AVRSH: una shell per l'interprete dei comandi per Arduino/AVR.: 6 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:06

Hai mai desiderato essere "loggato" al tuo microcontrollore AVR? Hai mai pensato che sarebbe bello "cat" un registro per vederne il contenuto? Hai sempre desiderato un modo per accendere e spegnere i singoli sottosistemi periferici del tuo AVR o Arduino in *tempo reale*? Anch'io, così ho scritto l'AVR Shell, una shell simile a UNIX. È simile a UNIX perché ricorda l'account di shell che hai acquistato e acquistato per eseguire i tuoi bot di collisione irc nick, oltre ad avere un comando o due in comune. Ha anche un filesystem che assomiglia a UNIX extfs, usando una EEPROM esterna, ma questo è diventato un progetto a sé stante, quindi rilascerò quel modulo separatamente sotto un'istruzione diversa quando sarà pronto per la produzione. Ecco un elenco delle cose che puoi fare attualmente con AVR Shell:

• Leggi tutti i tuoi registri di direzione dei dati (DDRn), porte e pin in tempo reale
• Scrivi su tutti i tuoi DDRn, porte e pin per accendere motori, LED o leggere sensori in tempo reale
• Elenca tutti i registri conosciuti sul sistema
• Creare e memorizzare valori in variabili definite dall'utente supportate da EEPROM.
• Crea una password di root e autenticati su di essa (utilizzata per l'accesso telnet)
• Leggi la velocità di clock della CPU configurata
• Modifica la velocità di clock della CPU impostando un prescaler
• Avvia e ferma timer a 16 bit per il cronometraggio di varie cose
• Accensione e/o spegnimento di sottosistemi periferici: Convertitori da analogico a digitale (ADC), Interfaccia periferica seriale (SPI), Interfaccia a due fili (TWI/I2C), UART/USART. Utile quando si vuole ridurre il consumo energetico del microcontrollore o abilitare determinate funzioni.
• Scritto in C++ con oggetti riutilizzabili.

Questa istruzione guiderà attraverso l'installazione, l'uso e la personalizzazione di avrsh.

Passaggio 1: cosa ti servirà

Questo istruibile non richiede molto tranne che tu:

• Avere un Arduino o un ATmega328P. Altri AVR potrebbero funzionare, ma potrebbe essere necessario modificare il codice per elencare tutti i registri che sono univoci per il tuo MCU. I nomi devono solo corrispondere a ciò che è elencato nel file di intestazione univoco per il tuo MCU. Molti dei nomi dei registri sono gli stessi tra gli AVR, quindi il tuo chilometraggio può variare durante il porting.
• Trova un modo per collegarti alla seriale USART del tuo Arduino/AVR. Il sistema è stato ampiamente testato con il Terminale AVR, un'app Windows che effettua una connessione seriale tramite la porta USB o COM. Funziona con Arduino utilizzando la connessione USB e qualsiasi AVR utilizzando USB-BUB da Moderndevice.com. Altre opzioni del terminale includono: Putty, minicom (Linux e FreeBSD), schermo (Linux/FreeBSD), Hyperterminal, Teraterm. Ho scoperto che stucco e teraterm inviano della spazzatura durante la connessione, quindi il tuo primo comando potrebbe essere confuso.
• Avere il firmware AVR Shell installato e funzionante, che puoi scaricare da queste pagine, o ottenere sempre l'ultima versione su BattleDroids.net.

Per installare il terminale AVR, decomprimilo ed eseguilo. Per installare il firmware AVR Shell, scaricalo e carica direttamente il file esadecimale e collega il tuo terminale seriale a 9600 baud, oppure compilalo tu stesso con "make" e poi "make programma" per caricare l'esadecimale. Nota, potrebbe essere necessario modificare le impostazioni di AVRDUDE per riflettere la tua porta COM. Nota: l'attributo PROGMEM è danneggiato nell'attuale implementazione di AVR GCC per C++ e questo è un bug noto. Se lo compili, aspettati di ricevere molti messaggi di avviso che dicono "avviso: solo le variabili inizializzate possono essere collocate nell'area di memoria del programma". Oltre ad essere fastidioso da vedere, questo avvertimento è innocuo. Poiché il C++ sulla piattaforma incorporata non è in cima all'elenco delle priorità di AVR GCC, non è noto quando verrà risolto. Se controlli il codice, vedrai dove ho risolto il problema per ridurre questo avviso implementando le mie dichiarazioni di attributo. Abbastanza semplice. Scarica e installa tutto ciò di cui potresti aver bisogno, quindi gira la pagina e iniziamo a craccare.

Passaggio 2: lettura e scrittura dei registri

L'AVR Shell è stato scritto principalmente per accedere ad alcuni sensori che avevo collegato al mio AVR. È iniziato con un semplice LED, poi è passato ai sensori di luce, ai sensori di temperatura e infine a due trasduttori a ultrasuoni. avrsh può impostare i componenti digitali di questi sensori scrivendo sui registri che li controllano. Manipolazione dei registri AVR durante l'esecuzione Per ottenere un elenco di tutti i registri conosciuti sul tuo Arduino, digita:

registri di stampa e otterrai una stampa simile a questa

Conosco i seguenti registri:

TIFR0 PORTC TIFR1 PORTD TIFR2 DDRR PCIFR DDRB EIFR DDRC EIMSK PINB EECR PINC EEDR PIND SREG EEARL GPIOR0 EEARH GPIOR1 GTCCR GPIOR2 TCCR0A TCCR0B TCNT0 OCR0A OCR0B SPCR SPDR ACSR SMCR MCUSR MCUCR SPMCSR WDTCSR CLKPR PRR OSCCAL PCICR Eicra PCMSK0 PCMSK1 TIMSK0 TIMSK1 TIMSK2 ADCL ADCH ADCSRA ADCSRB ADMUX DIDR0 DIDR1 TCCR1A TCCR1B TCCR1C TCNT1L TCNT1H ICR1L ICR1H OCR1AL OCR1AH OCR1BL OCR1BH TCCR2A TCCR2B TCNT2 OCR2A OCR2B ASSR TWBR TWSR UHSRUB0BSRUBSR0BSRUB0BSR0BSRWAR TWUCDR328 Per vedere come sono impostati i singoli bit in qualsiasi registro, usa il comando cat o echo

gatto %GPIOR0 Qui sto chiedendo all'interprete dei comandi di visualizzare, o fare eco, il contenuto del registro I/O per uso generale #0. Notare il segno di percentuale (%) davanti al nome del registro. Serve per indicare alla shell che si tratta di una parola chiave riservata che identifica un registro. L'output tipico di un comando echo è simile a questo

GPIOR0(0x0) impostato su [00000000] L'output mostra il nome del registro, il valore esadecimale trovato nel registro e la rappresentazione binaria del registro (mostrando ogni bit come 1 o 0). Per impostare un particolare bit in qualsiasi registro, utilizzare l'operatore "indice di" . Ad esempio, diciamo che voglio il 3° bit su 1

%GPIOR0[3] = 1 e la shell ti darà una risposta indicando la sua azione e il risultato

GPIOR0(0x0) impostato su [00000000] (0x8) impostato su [00001000] Non dimenticare il segno di percentuale per dire alla shell che stai lavorando con un registro. Si noti inoltre che impostando il 3° bit, si ottengono 4 bit perché i nostri AVR utilizzano un indice a base zero. In altre parole, contando fino al 3° bit si contano 0, 1, 2, 3, che è il 4° posto, ma il 3° bit. Puoi cancellare un po' allo stesso modo impostando un po' a zero. Impostando bit come questo puoi cambiare il funzionamento del tuo AVR al volo. Ad esempio, modificando il valore di corrispondenza del timer CTC trovato in OCR1A. Ti consente anche di sbirciare in particolari impostazioni che dovresti controllare a livello di codice nel tuo codice, come il valore UBBR per la tua velocità di trasmissione. Lavorare con DDRn, PORTn e PINn Anche i pin I/O sono assegnati ai registri e possono essere impostati esattamente allo stesso modo, ma è stata creata una sintassi speciale per lavorare con questi tipi di registri. Nel codice, esiste un normale processo, ad esempio, per accendere un LED o un altro dispositivo che richiede un valore digitale alto o basso. Richiede l'impostazione del registro di direzione dei dati per indicare che il pin è per l'uscita e quindi scrivere un 1 o uno 0 sul bit particolare nella porta corretta. Supponendo di avere un LED collegato al pin digitale 13 (PB5) e di volerlo accendere, ecco come farlo mentre l'AVR è in funzione

imposta pin pb5 outputwrite pin pb5 alto L'output, oltre a poter vedere il tuo LED accendersi, sarebbe simile a questo

root@ATmega328p> imposta pin pb5 outputSet pb5 per outputroot@ATmega328p> scrivi pin pb5 highScrivi la logica alta sul pin pb5 Il "root@ATmega328p>" è il prompt della shell che indica che è pronta ad accettare comandi da te. Per spegnere il LED, scriveresti semplicemente un valore basso sul pin. Se vuoi leggere l'ingresso digitale da un pin, usa il comando read. Usando il nostro esempio sopra

root@ATmega328p> leggi il pin pb5Pin: pb5 è ALTO In alternativa, è sufficiente eseguire l'eco del registro pin che controlla quella porta pin. Ad esempio, se abbiamo dei dip switch collegati ai pin digitali 7 e 8 (PD7 e PD8), potresti inviare il comando

echo %PIND e la shell mostrerebbe quindi il contenuto di quel registro, mostrando tutti gli stati di input/output dei dispositivi collegati e se lo stato dell'interruttore era acceso o spento.

Passaggio 3: lettura e scrittura dei fusibili

I fusibili sono tipi speciali di registri. Controllano tutto, dalla velocità di clock del microcontrollore ai metodi di programmazione disponibili per la protezione da scrittura EEPROM. A volte dovrai modificare queste impostazioni, soprattutto se stai creando un sistema AVR autonomo. Non sono sicuro che dovresti cambiare le impostazioni dei fusibili su Arduino. Stai attento con i tuoi fusibili; puoi bloccarti se li imposti in modo errato. In una precedente istruzione, ho dimostrato come puoi leggere e impostare i tuoi fusibili usando il tuo programmatore e avrdude. Qui, ti mostrerò come rileggere i tuoi fusibili in fase di esecuzione per vedere come li ha effettivamente impostati il tuo MCU. Si noti che questa non è l'impostazione in fase di compilazione che si ottiene dalle definizioni, ma i fusibili effettivi quando l'MCU li legge in fase di esecuzione. Dalla Tabella 27-9 nel datasheet dell'ATmega328P (databook, più simile) i bit del Fuse Low Byte sono i seguenti:

CKDIV8 CKOUT SUT1 SUT0 CKSEL3 CKSEL2 CKSEL1 CKSEL0Una cosa interessante da notare è che con i fusibili, 0 significa programmato e 1 significa che quel particolare bit non è programmato. Un po' controintuitivo, ma una volta che lo conosci lo sai.

• CKDIV8 imposta il clock della CPU in modo che sia diviso per 8. L'ATmega328P viene programmato in fabbrica per utilizzare il suo oscillatore interno a 8 MHz con CKDIV8 programmato (ovvero impostato su 0) che fornisce una frequenza F_CPU o CPU finale di 1 MHz. Su Arduino, questo è cambiato poiché sono configurati per utilizzare un oscillatore esterno a 16MHz.
• CKOUT quando programmato emetterà l'orologio della CPU su PB0, che è il pin digitale 8 su Arduino.
• SUT[1..0] specifica il tempo di avvio dell'AVR.
• CKSEL[3..0] imposta la sorgente di clock, come l'oscillatore RC interno, l'oscillatore esterno, ecc.

Quando leggerai i tuoi fusibili, ti verranno restituiti in esadecimale. Questo è il formato di cui hai bisogno se vuoi scrivere i fusibili tramite avrdude. Sul mio arduino, ecco cosa ottengo quando leggo il byte del fusibile inferiore:

root@ATmega328p> leggi lfuseLower Fuse: 0xffQuindi, tutti i bit sono impostati su 1. Ho eseguito la stessa procedura su un clone di Arduino e ho ottenuto lo stesso valore. Controllando uno dei miei sistemi AVR stand-alone, ho ottenuto 0xDA che è il valore che avevo impostato qualche tempo fa durante la configurazione del chip. La stessa procedura viene utilizzata per controllare i fusibili High Fuse Byte, Extended Fuse Byte e Lock. La calibrazione e i byte del fusibile della firma sono stati disabilitati nel codice con una direttiva del preprocessore #if 0, che puoi modificare se ti senti scadente.

Passaggio 4: altri comandi

Ci sono molti altri comandi che l'interprete dei comandi predefinito comprende e che potresti trovare utili. Puoi vedere tutti i comandi implementati e futuri rilasciando aiuto o menu al prompt. Li tratterò rapidamente qui in quanto sono per lo più autoesplicativi. Impostazioni della frequenza dell'orologio della CPU Puoi scoprire cosa è stato configurato il tuo firmware per utilizzare le impostazioni dell'orologio della CPU con il comando fcpu:

root@ATmega328p> fcpuCPU Freq: 16000000Sono 16 milioni, o 16 milioni di herz, più comunemente noti come 16 MHz. Puoi cambiarlo al volo, per qualsiasi motivo, con il comando orologio. Questo comando accetta un argomento: il prescaler da usare quando si divide la velocità di clock. Il comando clock comprende questi valori di prescaler:

• ckdiv2
• ckdiv4
• ckdiv8
• ckdiv16
• ckdiv32
• ckdiv64
• ckdiv128
• ckdiv256

Usando il comando:

orologio ckdiv2 quando la velocità della tua CPU è di 16 MHz, la velocità di clock viene modificata in 8 MHz. L'utilizzo di un prescaler di ckdiv64 con una velocità di clock iniziale di 16 MHz risulterà in una velocità di clock finale di 250 KHz. Perché mai vorresti rendere il tuo MCU più lento? Bene, per uno, una velocità di clock inferiore consuma meno energia e se hai la tua MCU che si scarica da una batteria in un contenitore di progetto potresti non averne bisogno per funzionare alla massima velocità e quindi potresti abbassare la velocità e ridurre il suo consumo energetico, aumentando la durata della batteria. Inoltre, se stai utilizzando l'orologio per qualsiasi tipo di problema di temporizzazione con un altro MCU, ad esempio, implementando un software UART o qualcosa del genere, potresti volerlo impostare su un valore particolare con cui è facile ottenere una velocità di trasmissione uniforme. tassi di errore inferiori. Accensione e spegnimento dei sottosistemi periferici Allo stesso modo della riduzione del consumo energetico menzionata in precedenza, è possibile ridurre ulteriormente la potenza spegnendo alcune delle periferiche integrate che non si utilizzano. L'interprete dei comandi e la shell possono attualmente accendere e spegnere le seguenti periferiche:

• Convertitore analogico-digitale (ADC). Questa periferica viene utilizzata quando si dispone di un sensore analogico che fornisce dati (come temperatura, luce, accelerazione, ecc.) e si deve convertirli in un valore digitale.
• Interfaccia periferica seriale (SPI). Il bus SPI viene utilizzato per comunicare con altri dispositivi abilitati SPI, come memorie esterne, driver LED, ADC esterni, ecc. Parti dell'SPI vengono utilizzate per la programmazione ISP, o almeno lo sono i pin, quindi fai attenzione quando lo spegni se stai programmando tramite ISP.
• Interfaccia a due fili. Alcuni dispositivi esterni utilizzano il bus I2C per comunicare, sebbene questi vengano rapidamente sostituiti da dispositivi abilitati SPI poiché SPI ha un throughput maggiore.
• USART. Questa è la tua interfaccia seriale. Probabilmente non vorrai disattivarlo se sei connesso all'AVR tramite la connessione seriale! Tuttavia, l'ho aggiunto qui come scheletro per il porting su dispositivi che hanno più USART come ATmega162 o ATmega644P.
• Tutti. Questo argomento del comando di accensione o spegnimento accende tutte le periferiche menzionate o le spegne tutte con un comando. Ancora una volta, usa questo comando con saggezza.

root@ATmega328p> powerdown twiPowerdown di twi complete.root@ATmega328p> powerup twiPowerup di twi completato.

Avvio e arresto dei timer La shell dispone di un timer incorporato a 16 bit disponibile per l'uso. Si avvia il timer con il comando timer:

avvio del timere ferma il timer con l'argomento stop

arresto del timerQuesto timer non entrerà in conflitto con il timer USART interno. Vedi il codice per i dettagli di implementazione del timer USART, se quel tipo di dettaglio cruento ti interessa

root@ATmega328p> timer startStarted timer.root@ATmega328p> timer stopTempo trascorso: ~ 157 secondi Autenticazione La shell può memorizzare una password di 8 caratteri nella EEPROM. Questo meccanismo di password è stato creato per supportare le funzionalità di accesso telnet, ma potrebbe essere ampliato per proteggere altre cose. Ad esempio, potresti richiedere alcuni comandi, come la modifica dei valori del registro, attraverso il meccanismo di autenticazione. Imposta la password con il comando password

root@ATmega328p> passwd blah Ha scritto la password di root su EEPROMAutorizzare contro la password (o richiedere l'autorizzazione in modo programmatico tramite il codice) con il comando auth. Nota che se tenti di cambiare la password di root e c'è già una password di root impostata, devi autorizzarti contro la vecchia password prima di poterla cambiare con una nuova password

root@ATmega328p> passwd blinkyDevi autorizzarti first.root@ATmega328p> auth blahAuthorized.root@ATmega328p> passwd blinkyWrote NEW root password to EEPROMNaturalmente, sarà necessario caricare il file avrsh.eep se si cancella il firmware per ripristinare i vecchi valori e variabili. Il Makefile creerà il file EEPROM per te. Variabili La shell comprende la nozione di variabili definite dall'utente. Il codice lo limita a 20, ma puoi cambiarlo se lo desideri modificando la definizione MAX_VARIABLES in script.h. È possibile salvare qualsiasi valore a 16 bit (ovvero, qualsiasi numero fino a 65, 536) in una variabile da richiamare in seguito. La sintassi è simile a quella dei registri, tranne per il fatto che viene utilizzato il simbolo del dollaro ($) per indicare le variabili della shell. Elenca tutte le tue variabili con il comando di stampa variabili

variabili di stampaVariabili definite dall'utente:Nome indice -> Valore(01): $GRATUITO$ -> 0(02): $GRATUITO$ -> 0(03): $GRATUITO$ -> 0(04): $GRATUITO$ -> 0(05): $GRATUITO$ -> 0(06): $GRATUITO$ -> 0(07): $GRATUITO$ -> 0(08): $GRATUITO$ -> 0(09): $GRATUITO$ -> 0(10): $GRATUITO$ -> 0(11): $GRATUITO$ -> 0(12): $GRATUITO$ -> 0(13): $GRATUITO$ -> 0(14): $GRATUITO$ -> 0(15): $GRATUITO$ -> 0(16): $GRATUITO$ -> 0(17): $GRATUITO$ -> 0(18): $GRATUITO$ -> 0(19): $GRATUITO$ -> 0(20): $FREE$ -> 0Completo. Imposta una variabile

$newvar = 25$timeout = 23245Ottieni il valore di una determinata variabile

root@ATmega328p> echo $newvar$ newvar 25Puoi vedere quali sono tutte le variabili che hai attualmente istanziato con il comando print che già conosci

Variabili definite dall'utente:Nome indice -> Valore(01): newvar -> 25(02): timeout -> 23245(03): $FREE$ -> 0(04): $FREE$ -> 0(05): $GRATUITO$ -> 0(06): $GRATUITO$ -> 0(07): $GRATUITO$ -> 0(08): $GRATUITO$ -> 0(09): $GRATUITO$ -> 0(10): $GRATUITO$ -> 0(11): $GRATUITO$ -> 0(12): $GRATUITO$ -> 0(13): $GRATUITO$ -> 0(14): $GRATUITO$ -> 0(15): $GRATUITO$ -> 0(16): $GRATUITO$ -> 0(17): $GRATUITO$ -> 0(18): $GRATUITO$ -> 0(19): $GRATUITO$ -> 0(20): $GRATUITO$ -> 0Completo. Il nome $FREE$ indica semplicemente che la posizione della variabile è libera e non è stata ancora assegnata a un nome di variabile.

Passaggio 5: personalizzazione della shell

Sei libero di hackerare il codice e personalizzarlo in base alle tue esigenze, se lo desideri. Se avessi saputo che avrei rilasciato questo codice, avrei creato una classe dell'interprete dei comandi e una struttura dei comandi separate e avrei semplicemente iterato attraverso questa chiamata a un puntatore a funzione. Ridurrebbe la quantità di codice, ma così com'è la shell analizza la riga di comando e chiama il metodo di shell appropriato. Per aggiungere i tuoi comandi personalizzati, procedi come segue: 1. Aggiungi il tuo comando all'elenco di analisi Il parser dei comandi analizza la riga di comando e ti fornisce il comando e tutti gli argomenti separatamente. Gli argomenti vengono passati come puntatori a puntatori o un array di puntatori, come preferisci lavorarci. Questo si trova in shell.cpp. Apri shell.cpp e trova il metodo ExecCmd della classe AVRShell. Potresti voler aggiungere il comando alla memoria del programma. Se lo fai, aggiungi il comando in progmem.he progmem.cpp. Puoi aggiungere il comando alla memoria del programma direttamente utilizzando la macro PSTR(), ma genererai un altro avviso del tipo menzionato in precedenza. Di nuovo, questo è un bug noto che funziona con C++, ma puoi aggirarlo aggiungendo il comando direttamente nei file progmem.*, come ho fatto io. Se non ti dispiace aggiungere al tuo utilizzo della SRAM, puoi aggiungere il comando come ho illustrato con il comando "clock". Supponi di voler aggiungere un nuovo comando chiamato "newcmd". Vai su AVRShell::ExecCmd e trova un posto conveniente per inserire il seguente codice:

else if (!strcmp(c, "newcmd")) cmdNewCmd(args);Questo aggiungerà il tuo comando e chiamerà il metodo cmdNewCmd che scriverai nel passaggio successivo. 2. Scrivi il tuo codice di comando personalizzato Nello stesso file, aggiungi il tuo codice di comando personalizzato. Questa è la definizione del metodo. Dovrai comunque aggiungere la dichiarazione a shell.h. Basta aggiungerlo agli altri comandi. Nell'esempio precedente, il codice potrebbe essere simile a questo

voidAVRShell::cmdNewCmd(char ** args){ sprintf_P(buff, PSTR("Il tuo comando è %s\r\n", args[0]); WriteRAM(buff);}Ci sono diverse cose qui. Innanzitutto, "buff" è un buffer di array di 40 caratteri fornito nel codice per l'uso. Usiamo la versione della memoria del programma di sprintf poiché gli stiamo passando un PSTR. Se lo desideri, puoi utilizzare la versione normale, ma assicurati di non passare il formato in un PSTR. Inoltre, gli argomenti sono nell'array args. Se hai digitato "newcmd arg1 arg2" puoi ottenere questi argomenti con i pedici args[0] e args[1]. Puoi passare un massimo di MAX_ARGS argomenti, come definito nel codice. Sentiti libero di cambiare quel valore quando ricompili se hai bisogno di molti più argomenti da passare contemporaneamente. WriteLine e WriteRAM sono funzioni globali che restituiscono i metodi UART con lo stesso nome. Il secondo argomento di questa funzione è implicito. Se non si passa nulla, verrà scritto un prompt dei comandi in seguito. Se passi uno 0 come secondo argomento, non verrà scritto un prompt. Ciò è utile quando si desidera scrivere diverse stringhe separate nell'output prima che il prompt dei comandi venga restituito all'utente. 3. Chiedi alla shell di eseguire il codice del comando Hai già detto all'esecutore della shell di eseguire il metodo cmdNewCmd quando imposti il nuovo comando, ma aggiungilo al file shell.h per farlo capire dall'oggetto shell. Basta aggiungerlo sotto l'ultimo comando o davanti al primo comando, o ovunque lì dentro. E questo è tutto. Ricompila e carica il firmware sul tuo Arduino e il tuo nuovo comando è disponibile dalla shell al prompt.

Passaggio 6: riepilogo

Dovresti sapere come installare e connetterti al tuo AVR/Arduino e ricevere un prompt live sul tuo microcontrollore in esecuzione. Conosci diversi comandi che estrarranno i dati di runtime dall'MCU o imposteranno i valori nell'MCU al volo. Ti è stato anche mostrato come aggiungere il tuo codice personalizzato per creare i tuoi comandi unici alla shell per personalizzarlo ulteriormente per le tue esigenze. Puoi anche sventrare l'interprete dei comandi in modo che contenga solo i tuoi comandi personalizzati, se questo soddisfa le tue esigenze. Spero che ti sia piaciuto questo istruttivo e che AVR Shell possa esserti utile, sia come interprete di comandi in tempo reale o come processo di apprendimento nell'implementazione del tuo. Come sempre, non vedo l'ora di ricevere commenti o suggerimenti su come migliorare questo istruttivo! Divertiti con il tuo AVR!