RyujiAndy

No, quando guardi la board tenendo lo spinotto per il monitor verso di sulla destra ci sono quattro fori cove c'era saldato lo spinotto per l'alimentatore, tra 2 fori c'è una saldatora quadrata quelli i sono i due poli (positivo e negativo), per devinire quali sinao il positivo e il negativo dovresti innanzittutto vedere dove vanno i contatti dello spinotto con und tester e poi basta quadare sull'alimentatore come sono fatti, di norma c'è sempre disegnato dove trovi le cratteristiche.

Ci sono motori da 3v (servono 2 batterie aa collegate in serie), 4.5v (servono 3 stilo aa collegate in serie), ecc.

lo trovi tutto sul primo post.

Se guardi la board sui fianchi dello spinotto ci 2 linguette punti dove saldare l'alimentatore esterno.

Vi ho aggiunto tutti. Ho anche aggiornato il primo post.

Cerca di non fare doppi post, non siamo su di una chat, ma su un forum quindi basta usare il tasto modifica

Come ho detto lateralmente, ma dalla foto non sicapisce qual'è il più e quale il meno. Ti serve un alimentatore da 19v 2.1A e non uno da 8.4v altrimenti non funziona per alumentazione non sufficente

gli ups vengono di norma utilizzati per apparecchi elettronici tipo server o pc, non credo che siano in grado di sopportare l'assorbimento di corrente di un grosso elettrodomestico, questo è un problema che di norma va risolto aumentando la sicura massima dell'abitazione, bisogna rivolsersi al fornitore di energia elettrica. P.S.: lavoro nella domotica e di questi problemi li vedo spesso.

Dipende dal motorino, di norma c'è sempre la tensione massima di alimentazione, e poi che batterie aveva la macchinina in questione?

Dalla foto non si capisce un gran che ma sono riuscito a trovare in internet lo spinotto in questione e si vede che ci sono 2 piedini laterali tipo smd e quindi puoi salarci sopra un alimentatore ma devi stare attento al più e al meno dell'alimentatore esterno.

La possibilitá puó essere presa in considerazione. Magari piú info e perché no qualche immagine?

appena a casa ti aggiungo

Che ne dite di scambiarci le news e le info sulla wiiu? vedró di fare una lista aggiornandola il piú possibile. Nintendo network ID: RyujiAndy => RyujiAndy00 bikers88 => bikers d4ark_alex => dark_alex canabio => canaja wiimanuel => Manu98 shoot3r => shoot3r1 daredevil.84 => Scout_Lucky toti84wii => Toti84WiiU alexlusi => theRinco03 sennar2006 => LittleMario mr.stiff => mr.stiff

un sintetizzatore è in grado di riprodurre più di una frequenza contemporaneamente cosa che qui non avviene, o si utilizza più di un pin e poi si mixano i segnali o dobbiamo passare ad arduino due, infatti possiede due uscite analogiche.

Creare toni con Arduino Come mi avevate chiesto in uno dei tutorial precedenti, questa volta vediamo come collegare un Buzzer o un piccolo altoparlante da 8ohm ad Arduino e fargli riprodurre un suono. Per evitare che Arduino suoni non appena viene programmato ho aggiunto un pulsante allo schema: in questo modo possiamo decidere se riprodurre il suono o no. http://www.nonsologaming.com/vd/arduino_buzz_push_sch.png Materiale necessario: Arduino UNO R1 = resistenza da 100ohm R2 = resistenza da 10kohm S1 = pulsante J1 = buzzer o box da 8ohm Schema elettrico: http://www.nonsologaming.com/vd/arduino_buzz_push_sch2.png Arduino prevede già di suo una funzione che possiamo sfruttare per fargli riprodurre un suono, ovvero "tone": tone(pin, frequenza, durata); Esiste anche un'altro comando che a sua volta permette di fermare la riproduzione del suono: noTone(pin); Nel circuito che realizzeremo in questo tutorial vogliamo che arduino emetta un suono quando il pulsante viene premuto, quindi i nostro programma sarà: int freq = 1047; int pinbuzz = 8; int pintasto = 2; void setup() { pinMode(pintasto, INPUT); } void loop() { if(digitalRead(pintasto)) { tone(pinbuzz, freq); } else { noTone(pinbuzz); } } Per comodità ho creato una variabile con la frequenza del tono: in questo modo basta cambiare il valore per cambiare il suono. Come potete notare, nella funzione tone non ho specificato la durata, questo perchè il suono deve venire riprodotto solo quando il pulsante viene premuto, e non appena viene rilasciato la funzione noTone fa smettere la riproduzione. Ora invece creiamo una vera e propria melodia: ricercando in internet ho trovato una lista dove definisce le note con le relative frequenze. Integrando questo file nel nostro programma diventerà più semplice indicare ad Arduino che suono deve riprodurre ed in che sequenza. Chiamiamo la "libreria delle note" pitches.h, questo file deve essere messo nella stessa cartella dove andremo a salvare il programma che abbiamo realizzato per Arduino. All'interno del file pitches.h scriviamo: #define NOTE_B0 31 #define NOTE_C1 33 #define NOTE_CS1 35 #define NOTE_D1 37 #define NOTE_DS1 39 #define NOTE_E1 41 #define NOTE_F1 44 #define NOTE_FS1 46 #define NOTE_G1 49 #define NOTE_GS1 52 #define NOTE_A1 55 #define NOTE_AS1 58 #define NOTE_B1 62 #define NOTE_C2 65 #define NOTE_CS2 69 #define NOTE_D2 73 #define NOTE_DS2 78 #define NOTE_E2 82 #define NOTE_F2 87 #define NOTE_FS2 93 #define NOTE_G2 98 #define NOTE_GS2 104 #define NOTE_A2 110 #define NOTE_AS2 117 #define NOTE_B2 123 #define NOTE_C3 131 #define NOTE_CS3 139 #define NOTE_D3 147 #define NOTE_DS3 156 #define NOTE_E3 165 #define NOTE_F3 175 #define NOTE_FS3 185 #define NOTE_G3 196 #define NOTE_GS3 208 #define NOTE_A3 220 #define NOTE_AS3 233 #define NOTE_B3 247 #define NOTE_C4 262 #define NOTE_CS4 277 #define NOTE_D4 294 #define NOTE_DS4 311 #define NOTE_E4 330 #define NOTE_F4 349 #define NOTE_FS4 370 #define NOTE_G4 392 #define NOTE_GS4 415 #define NOTE_A4 440 #define NOTE_AS4 466 #define NOTE_B4 494 #define NOTE_C5 523 #define NOTE_CS5 554 #define NOTE_D5 587 #define NOTE_DS5 622 #define NOTE_E5 659 #define NOTE_F5 698 #define NOTE_FS5 740 #define NOTE_G5 784 #define NOTE_GS5 831 #define NOTE_A5 880 #define NOTE_AS5 932 #define NOTE_B5 988 #define NOTE_C6 1047 #define NOTE_CS6 1109 #define NOTE_D6 1175 #define NOTE_DS6 1245 #define NOTE_E6 1319 #define NOTE_F6 1397 #define NOTE_FS6 1480 #define NOTE_G6 1568 #define NOTE_GS6 1661 #define NOTE_A6 1760 #define NOTE_AS6 1865 #define NOTE_B6 1976 #define NOTE_C7 2093 #define NOTE_CS7 2217 #define NOTE_D7 2349 #define NOTE_DS7 2489 #define NOTE_E7 2637 #define NOTE_F7 2794 #define NOTE_FS7 2960 #define NOTE_G7 3136 #define NOTE_GS7 3322 #define NOTE_A7 3520 #define NOTE_AS7 3729 #define NOTE_B7 3951 #define NOTE_C8 4186 #define NOTE_CS8 4435 #define NOTE_D8 4699 #define NOTE_DS8 4978 Ora sarà sufficiente scrivere il nostro programma: #include "pitches.h" int pinbuzz = 8; int pintasto = 2; int melodia[] = {NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3, NOTE_G3, NOTE_B3, NOTE_C4}; int tempo[] = {4, 8, 8, 4, 4, 4, 4, 4 } int nr = 8; void setup() { pinMode(pintasto, INPUT); } void loop() { if(digitalRead(pintasto)) { for (int numero = 0; numero < nr; numero++) { int duratanota = 1000 / tempo[numero]; tone(pinbuzz, melodia[numero], duratanota); delay(duratanota * 1.30) noTone(pinbuzz); } delay(50); } } Come potete vedere ho creato due array, uno dove vado a scrivere la melodia mentre l'altro con la durata delle note... e poi ho aggiunto il numero corrispondente alle note da eseguire. Ora il nostro programma non fa altro che aspettare la pressione del pulsante per eseguire la melodia. Nell'array ho fatto in modo da dover iserire il valore reali 1 = 4/4, 2 = 1/2, 4 = 1/4, ecc, in seguito ho reato un'altra variabile dove viene calcolato il tempo in millisecondi. Buon divertimento nel modificare questo semplice programma!

Ragazzi non so da voi ma qui nevica quasi ininterrottamente... http://img3.fotos-hochladen.net/uploads/6ekfro97gjb.jpg http://img3.fotos-hochladen.net/uploads/9znr5fk8m0j.jpg http://img5.fotos-hochladen.net/uploads/179k2n3o8m6l.jpg http://img5.fotos-hochladen.net/uploads/18nti3ueq27a.jpg

Chissa dove ho la testa.....mmmh

Ottima osservazione e ottima soluzione del problema, comunque il programma originale era: int tastroprecedente = LOW; int tasto = LOW; int statoled = LOW; void setup() { pinMode(13, OUTPUT); pinMode(7, INPUT); } void loop() { int stato = digitalRead(7); if (stato != tastoprecedente && stato == HIGH) { statoled = 1 - statoled; } digitalWrite(13, statoled); tastoprecedente = stato; } Nello scrivere mi sono dimenticato di aggiungere l'int davanti alla lettura dello stato del pulsante. Mi complimento per l'acuta osservazione, questo dimostra che anche io sono umano.

milli() è la funzione che conta i millisecondi, è nativa dell'IDE infatti non necessita ri richiamo libreria

Python ed Arduino Tramite la porta USB arduino può inviare una serie di dati che il computer può leggere e visualizzare. Questo è particolarmente utile perchè un programma sviluppato ad hoc sarebbe in grado di elaborare i dati forniti da Arduino. Una delle possibili applicazioni di questa funzione è quella di automatizzare la creazione di grafici sulla base dei dati raccolti: immaginatevi ad esempio un sensore di temperatura (come un resistore che varia il suo valore al variare della temperatura) collegato ad Arduino, e il PC che continua a leggere il valore del resistore trasformando il dato in °C e mettendo il tutto su di un grafico. Dopo aver letto questo tutorial sarete in grado di fare anche una cosa del genere. Innanzitutto riprendiamo lo schema dell'ultima volta: http://www.nonsologaming.com/vd/arduino_led_potv1.png ...e il programma scritto per Arduino: int pinpot = 0; int pinled = 9; int valpot = 0; int valled = 0; void setup() { pinMode(pinled, OUTPUT); } void loop() { valpot = analogRead(pinpot); valled = map(valpot, 0, 1023, 0, 255); analogWrite(pinled, valled); delay(10); } Per aprire un flusso di dati dobbiamo inizializzare la periferica seriale su Arduino aggiungendola alla funzione setup: void setup() { pinMode(pinled, OUTPUT); Serial.begin(9600); } Ora dobbiamo dire quale valore Arduino deve inviare sulla porta seriale: io ho preso in considerazione il valore del potenziometro quindi la funzione loop diventa: void loop() { valpot = analogRead(pinpot); valled = map(valpot, 0, 1023, 0, 255); analogWrite(pinled, valled); Serial.println(valpot); delay(10); } Sull'IDE di Arduino c'è un pulsante denominato "serial monitor": se noi carichiamo l'attuale programma e poi clicchiamo su "serial monitor" ci verrà mostrata una serie di numeri che variano se spostiamo il potenziometro... ecco, questi sono i valori della variabile valpot, che come tutti gli ingressi analogici di Arduino può assumere tutti gli stati che vanno da 0 a 1023 (come abbiamo già visto). Per vedere il flusso di dati non è necessario avere necessariamente sempre aperto l'IDE di arduino, infatti grazie al linguaggio Python è possibile leggere questo flusso, e sviluppare di conseguenza dei programmi che possono elaborare i dati inviati al PC dalla board. C'è da ricordare comunque che per fare questo è necessario prima installare python-serial, atrimenti python non è in grado di aprire la porta seriale. Creiamo il file "Arduino_Monitor.py" e all'interno andiamo a scrivere: from threading import Thread import time import serial last_received = '' def receiving(ser): global last_received buffer = '' while True: buffer = buffer + ser.read(ser.inWaiting()) if '\n' in buffer: lines = buffer.split('\n') last_received = lines[-2] buffer = lines[-1] class SerialData(object): def __init__(self, init=50): try: self.ser = ser = serial.Serial( port='/dev/ttyACM0', baudrate=9600, bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, timeout=0.1, xonxoff=0, rtscts=0, interCharTimeout=None ) except serial.serialutil.SerialException: self.ser = None else: Thread(target=receiving, args=(self.ser,)).start() def next(self): if not self.ser: return 100 for i in range(40): raw_line = last_received try: return float(raw_line.strip()) except ValueError: print 'bogus data',raw_line time.sleep(.005) return 0. def __del__(self): if self.ser: self.ser.close() if __name__=='__main__': s = SerialData() for i in range(500): time.sleep(.015) print s.next() Andando ad eseguire questo nostro programma, vedremo sul terminale che non fa altro che scrivere a schermo i valori del potenziometro, esattamente come succede con l'IDE di arduino. Avendo a disposizione anche il modulo wx e matplotlib di python possiamo creare un vero e proprio grafico, basta creare un altro file python, ad esempio "wx_arduino_dynamic_graph.py" e all'interno aggiungiamo: import os import pprint import random import sys import wx REFRESH_INTERVAL_MS = 90 import matplotlib matplotlib.use('WXAgg') from matplotlib.figure import Figure from matplotlib.backends.backend_wxagg import \ FigureCanvasWxAgg as FigCanvas, \ NavigationToolbar2WxAgg as NavigationToolbar import numpy as np import pylab from Arduino_Monitor import SerialData as DataGen class BoundControlBox(wx.Panel): def __init__(self, parent, ID, label, initval): wx.Panel.__init__(self, parent, ID) self.value = initval box = wx.StaticBox(self, -1, label) sizer = wx.StaticBoxSizer(box, wx.VERTICAL) self.radio_auto = wx.RadioButton(self, -1, label="Auto", style=wx.RB_GROUP) self.radio_manual = wx.RadioButton(self, -1, label="Manual") self.manual_text = wx.TextCtrl(self, -1, size=(35,-1), value=str(initval), style=wx.TE_PROCESS_ENTER) self.Bind(wx.EVT_UPDATE_UI, self.on_update_manual_text, self.manual_text) self.Bind(wx.EVT_TEXT_ENTER, self.on_text_enter, self.manual_text) manual_box = wx.BoxSizer(wx.HORIZONTAL) manual_box.Add(self.radio_manual, flag=wx.ALIGN_CENTER_VERTICAL) manual_box.Add(self.manual_text, flag=wx.ALIGN_CENTER_VERTICAL) sizer.Add(self.radio_auto, 0, wx.ALL, 10) sizer.Add(manual_box, 0, wx.ALL, 10) self.SetSizer(sizer) sizer.Fit(self) def on_update_manual_text(self, event): self.manual_text.Enable(self.radio_manual.GetValue()) def on_text_enter(self, event): self.value = self.manual_text.GetValue() def is_auto(self): return self.radio_auto.GetValue() def manual_value(self): return self.value class GraphFrame(wx.Frame): title = 'Demo: dynamic matplotlib graph' def __init__(self): wx.Frame.__init__(self, None, -1, self.title) self.datagen = DataGen() self.data = [self.datagen.next()] self.paused = False self.create_menu() self.create_status_bar() self.create_main_panel() self.redraw_timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.on_redraw_timer, self.redraw_timer) self.redraw_timer.Start(REFRESH_INTERVAL_MS) def create_menu(self): self.menubar = wx.MenuBar() menu_file = wx.Menu() m_expt = menu_file.Append(-1, "&Save plot\tCtrl-S", "Save plot to file") self.Bind(wx.EVT_MENU, self.on_save_plot, m_expt) menu_file.AppendSeparator() m_exit = menu_file.Append(-1, "E&xit\tCtrl-X", "Exit") self.Bind(wx.EVT_MENU, self.on_exit, m_exit) self.menubar.Append(menu_file, "&File") self.SetMenuBar(self.menubar) def create_main_panel(self): self.panel = wx.Panel(self) self.init_plot() self.canvas = FigCanvas(self.panel, -1, self.fig) self.xmin_control = BoundControlBox(self.panel, -1, "X min", 0) self.xmax_control = BoundControlBox(self.panel, -1, "X max", 50) self.ymin_control = BoundControlBox(self.panel, -1, "Y min", 0) self.ymax_control = BoundControlBox(self.panel, -1, "Y max", 100) self.pause_button = wx.Button(self.panel, -1, "Pause") self.Bind(wx.EVT_BUTTON, self.on_pause_button, self.pause_button) self.Bind(wx.EVT_UPDATE_UI, self.on_update_pause_button, self.pause_button) self.cb_grid = wx.CheckBox(self.panel, -1, "Show Grid", style=wx.ALIGN_RIGHT) self.Bind(wx.EVT_CHECKBOX, self.on_cb_grid, self.cb_grid) self.cb_grid.SetValue(True) self.cb_xlab = wx.CheckBox(self.panel, -1, "Show X labels", style=wx.ALIGN_RIGHT) self.Bind(wx.EVT_CHECKBOX, self.on_cb_xlab, self.cb_xlab) self.cb_xlab.SetValue(True) self.hbox1 = wx.BoxSizer(wx.HORIZONTAL) self.hbox1.Add(self.pause_button, border=5, flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL) self.hbox1.AddSpacer(20) self.hbox1.Add(self.cb_grid, border=5, flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL) self.hbox1.AddSpacer(10) self.hbox1.Add(self.cb_xlab, border=5, flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL) self.hbox2 = wx.BoxSizer(wx.HORIZONTAL) self.hbox2.Add(self.xmin_control, border=5, flag=wx.ALL) self.hbox2.Add(self.xmax_control, border=5, flag=wx.ALL) self.hbox2.AddSpacer(24) self.hbox2.Add(self.ymin_control, border=5, flag=wx.ALL) self.hbox2.Add(self.ymax_control, border=5, flag=wx.ALL) self.vbox = wx.BoxSizer(wx.VERTICAL) self.vbox.Add(self.canvas, 1, flag=wx.LEFT | wx.TOP | wx.GROW) self.vbox.Add(self.hbox1, 0, flag=wx.ALIGN_LEFT | wx.TOP) self.vbox.Add(self.hbox2, 0, flag=wx.ALIGN_LEFT | wx.TOP) self.panel.SetSizer(self.vbox) self.vbox.Fit(self) def create_status_bar(self): self.statusbar = self.CreateStatusBar() def init_plot(self): self.dpi = 100 self.fig = Figure((3.0, 3.0), dpi=self.dpi) self.axes = self.fig.add_subplot(111) self.axes.set_axis_bgcolor('black') self.axes.set_title('Arduino Serial Data', size=12) pylab.setp(self.axes.get_xticklabels(), fontsize=8) pylab.setp(self.axes.get_yticklabels(), fontsize=8) self.plot_data = self.axes.plot( self.data, linewidth=1, color=(1, 1, 0), )[0] def draw_plot(self): if self.xmax_control.is_auto(): xmax = len(self.data) if len(self.data) > 50 else 50 else: xmax = int(self.xmax_control.manual_value()) if self.xmin_control.is_auto(): xmin = xmax - 50 else: xmin = int(self.xmin_control.manual_value()) if self.ymin_control.is_auto(): ymin = round(min(self.data), 0) - 1 else: ymin = int(self.ymin_control.manual_value()) if self.ymax_control.is_auto(): ymax = round(max(self.data), 0) + 1 else: ymax = int(self.ymax_control.manual_value()) self.axes.set_xbound(lower=xmin, upper=xmax) self.axes.set_ybound(lower=ymin, upper=ymax) if self.cb_grid.IsChecked(): self.axes.grid(True, color='gray') else: self.axes.grid(False) pylab.setp(self.axes.get_xticklabels(), visible=self.cb_xlab.IsChecked()) self.plot_data.set_xdata(np.arange(len(self.data))) self.plot_data.set_ydata(np.array(self.data)) self.canvas.draw() def on_pause_button(self, event): self.paused = not self.paused def on_update_pause_button(self, event): label = "Resume" if self.paused else "Pause" self.pause_button.SetLabel(label) def on_cb_grid(self, event): self.draw_plot() def on_cb_xlab(self, event): self.draw_plot() def on_save_plot(self, event): file_choices = "PNG (*.png)|*.png" dlg = wx.FileDialog( self, message="Save plot as...", defaultDir=os.getcwd(), defaultFile="plot.png", wildcard=file_choices, style=wx.SAVE) if dlg.ShowModal() == wx.ID_OK: path = dlg.GetPath() self.canvas.print_figure(path, dpi=self.dpi) self.flash_status_message("Saved to %s" % path) def on_redraw_timer(self, event): if not self.paused: self.data.append(self.datagen.next()) self.draw_plot() def on_exit(self, event): self.Destroy() def flash_status_message(self, msg, flash_len_ms=1500): self.statusbar.SetStatusText(msg) self.timeroff = wx.Timer(self) self.Bind( wx.EVT_TIMER, self.on_flash_status_off, self.timeroff) self.timeroff.Start(flash_len_ms, oneShot=True) def on_flash_status_off(self, event): self.statusbar.SetStatusText('') if __name__ == '__main__': app = wx.PySimpleApp() app.frame = GraphFrame() app.frame.Show() app.MainLoop() Vi ricordo che questo programma è dipendente da quello precedente infatti il primo legge il flusso di dati ed il secondo li visualizza graficamente. Il tutto è stato programmato su Ubuntu 12.04 con python3.

Regolare l'intensità di un LED tramite un potenziometro Abbiamo già visto in precedenza come gestire un segnale PWM per regolare l'intensità di un LED, ora vorrei introdurre i pin analogici per regolare manualmente questo segnale. Costruendo il seguente circuito: http://www.nonsologaming.com/vd/arduino_led_potv1.png notiamo che ho collegato un potenziometro al pin A0, questo perchè arduino è in grado di misurare la differenza di potenziale tra 0V e 5V e restituisce come verdremo in seguito un valore compreso tra 0 e 1023. Ora per comodità definiamo le variabili che tengono conto dei pin dove abbiamo collegato il LED ed il nostro potenziometro: int pinpot = 0; int pinled = 9; Ora ci servono altre due variabili dove andremo a memorizzare lo stato del potenziometro ed il relativo valore del segnale PWM per regolare l'intensità del led: int valpot = 0; int valled = 0; Come sempre dobbiamo inizializzare i pin tramite la funzione "void setup": void setup() { pinMode(pinled, OUTPUT); } Il pin A0 non è necessario definire perchè è già un input analogico. tramite a funzione "analogRead" possiamo leggere la differenza di potenziale presente tra il cursore e la massa. Se guardiamo il simbolo elettrico del potenziometro è come se avessimo due resistenze che variano a seconda della posizione del cursore e quindi la differenza di potenziale di R2 cambia. Dobbiamo tenere in considerazione una proporzione tra il valore del segnale PWM che è compreso tra 0 e 255 e il valore restituito dal pin analogico, compreso tra 0 e 1024, quest'ultimo è 4 volte superiore al primo e quindi possiamo scrivere il nostro loop: void loop() { valpot = analogRead(pinpot); valled = valpot / 4; analogWrite(pinled, valled); delay(10); } Ora vorrei introdurre una nuova funzione: il rimappamento. Questa serve per scalare un valore tenendo conto di 2 margini differenti: restituzione = map(valore, da minimo, da massimo, a minimo, a massimo); ora applichiamolo al nostro programma: int pinpot = 0; int pinled = 9; int valpot = 0; int valled = 0; void setup() { pinMode(pinled, OUTPUT); } void loop() { valpot = analogRead(pinpot); valled = map(valpot, 0, 1023, 0, 255); analogWrite(pinled, valled); delay(10); } Schema elettrico: http://www.nonsologaming.com/vd/arduino_led_potv2.png

Continuo a non capire la tua richiesta.....mmmh Di norma si va alla ricerca dello schema elettronico e non del pcb, perchè il pcb lo si costruisce a seconda delle necessità, ma ci si basa sempre sullo schema elettronico ed anche questo va sistemato a seconda delle necessità. Per NAND intendi la porta logica NOT-AND http://upload.wikimedia.org/wikipedia/commons/e/e6/NAND_ANSI_Labelled.svg oppure la memoria flash, che in fondo si basa sulla tecnologia della porta

l'arduino due lo sto aspettando anche io, altrimenti avrei già scritto qualcosa. Lo stellaris lo conosco infatti viene molto utilizzato nella telefonia ip, é un arm cortex m-3. L'mps430 l'ho appena ordinato per curiosità.

Il Programmatore non lo conosco, ma quanto riguarda l'IDE io uso MPLABX