Dopo aver familiarizzato con gli elementi di base di Arduino e aver scritto un programma “ Ciao mondo! È tempo di familiarizzare con un linguaggio di programmazione.
La struttura del linguaggio è basata principalmente su C/C++, quindi chi ha già programmato in questo linguaggio non avrà difficoltà ad apprendere Programmazione Arduino. Altri dovrebbero apprendere le informazioni di base sui comandi di controllo, sui tipi di dati e sulle funzioni.
Molte delle informazioni qui contenute saranno compatibili con qualsiasi corso C/C++, tenendo conto delle differenze nei tipi di dati, così come alcune istruzioni specifiche riguardanti la programmazione delle porte I/O.
Nozioni di base
Poche cose formali, cioè quelle che tutti conoscono, ma che a volte dimenticano...
IN IDE di Arduino, come in C/C++, devi essere consapevole dei caratteri maiuscoli. Parole chiave, come se, for sono sempre scritti minuscolo. Ogni istruzione termina con ";". Il punto e virgola indica al compilatore quale parte interpretare come istruzione.
Le parentesi (..) vengono utilizzate per denotare i blocchi di programma. Li usiamo per vincolare i corpi delle funzioni (vedi sotto), i cicli e le istruzioni condizionali.
È buona norma aggiungere commenti al contenuto del programma, questo rende il codice di facile comprensione. I commenti a riga singola iniziano con // (doppia barra). I commenti su più righe iniziano con /* e termina con */
Se vogliamo includere qualche libreria nel nostro programma, utilizziamo il comando include. Ecco alcuni esempi di collegamento di librerie:
#includere
Funzioni di Arduino
Una funzione (subroutine) è parte separata programmi che eseguono determinate operazioni. Le funzioni vengono utilizzate per semplificare il programma principale e migliorare la leggibilità del codice. È utile utilizzare le funzioni poiché possiamo usarle facilmente in molti dei nostri progetti.
Un corso di programmazione standard contiene informazioni sulle funzioni che verranno presentate nei seguenti articoli. Nel caso di Arduino le funzioni verranno discusse all'inizio perché even programma più semplice devono averne due funzioni speciali. Questo è già stato menzionato negli articoli precedenti, ma qui sistematizziamo queste informazioni.
Dichiarazione di funzione
Il diagramma di dichiarazione della funzione è simile al seguente:
Digitare nome_funzione(parametro) ( // istruzioni per l'esecuzione (corpo della funzione) return (/* valore restituito*/); )
tipoè il nome di chiunque tipologia disponibile dati su data lingua programmazione. Forniremo un elenco dei tipi disponibili durante la programmazione di Arduino in un articolo separato.
Dopo l'esecuzione, la funzione restituirà il valore del tipo dichiarato. Se la funzione non accetta alcun valore restituito, il tipo di dati sarà “void”.
nome_funzione permette di identificarlo in modo univoco. Per chiamare (eseguire) una funzione, le diamo un nome.
parametro— parametro di chiamata di funzione. I parametri non sono obbligatori, ma spesso sono utili. Se scriviamo una funzione che non ha argomenti, usciamo parentesi tonde vuoto.
All'interno delle parentesi “(…)” c'è il corpo effettivo della funzione o istruzione che vogliamo eseguire. Forniremo una descrizione delle istruzioni specifiche in un articolo separato.
Tutte le funzioni che restituiscono un valore terminano con un'istruzione return seguita dal valore restituito. Solo le funzioni dichiarate con un puntatore null ("void") non contengono un'istruzione return. È necessario sapere che l'istruzione return termina la funzione indipendentemente dalla posizione.
Di seguito sono riportati alcuni esempi di dichiarazioni di funzioni.
Void f1() ( //corpo della funzione) —————————————— int minus() ( //corpo della funzione return (0); ) ——————————— ——— int plus(int a, int b) ( return (a+b); )
Come puoi vedere dagli esempi, una dichiarazione di funzione può assumere molte forme a seconda delle tue esigenze.
Ti consigliamo vivamente di apprendere e utilizzare le funzioni durante la scrittura propri programmi. Nel tempo, ogni programmatore accumula la propria libreria di funzioni “per tutte le occasioni”, il che rende più facile e veloce scrivere nuovi programmi.
Ora che sappiamo come scrivere la nostra funzione, dobbiamo imparare come usarla.
Chiamare una funzione
Scriviamo tutte le funzioni in un file/programma. Esiste ovviamente una soluzione più elegante, ma proveremo a descriverla la prossima volta.
Una volta dichiarata una funzione, possiamo usarla in altre funzioni con il nome appropriato e gli eventuali parametri richiesti. Di seguito sono riportati esempi di chiamata delle funzioni fornite sopra:
F1(); più(2,2); y=più(1,5);
Come puoi vedere negli esempi, una chiamata di funzione viene effettuata specificandone il nome e il numero richiesto di parametri. È importante chiamare sempre una funzione come dichiarata.
Se la funzione f1() viene dichiarata senza parametri, non è possibile specificare alcun parametro quando la si chiama, ad es. la chiamata a f1(0) sarà errata.
La funzione plus(int a, int b) richiede esattamente due parametri, quindi non è possibile chiamare con uno o tre parametri.
Chiamando y=plus(1,5) verrà eseguita la funzione "più" con i parametri "1" e "5" e verrà memorizzato il valore restituito nella variabile "y".
funzioni setup() e loop().
Con la conoscenza della dichiarazione e della chiamata di funzioni, possiamo passare a system Funzioni dell'Arduino: impostare() E ciclo continuo(). L'IDE Arduino è tenuto a dichiarare queste due funzioni.
setup() è una funzione che viene chiamata automaticamente quando si accende l'alimentazione o si preme il pulsante RESET.
Come suggerisce il nome, viene utilizzato per impostare i valori iniziali delle variabili, dichiarazioni di input e output del sistema, che di solito sono specificati in parametri iniziali. A causa della sua specificità, questa funzione non restituisce un valore e non viene chiamata con parametri. La dichiarazione corretta della funzione setup() è la seguente:
Void setup () ( // corpo della funzione - inizializzazione del sistema)
loop() è una funzione che viene chiamata ciclo infinito. Questa funzione inoltre non restituisce un valore e non viene chiamato con parametri. La dichiarazione corretta della funzione loop() è mostrata di seguito:
Void loop () ( // corpo della funzione - codice del programma )
Come puoi vedere, la dichiarazione della funzione loop() è identica alla dichiarazione della funzione setup(). La differenza sta nell'esecuzione di queste funzioni da parte del microcontrollore.
Analizzeremo ora il seguente pseudocodice:
Void setup () ( on_led1 (); //accendi led1 off_led1 (); //spegni led1) void loop () ( on_led2 (); //accendi led2 off_led2 (); //spegni led2)
Ci sono due istruzioni nella funzione setup(): la prima accende il led1 collegato alla scheda (es. pin 13) e la seconda spegne il led1.
La funzione loop() ha istruzioni identiche per accendere e spegnere il LED2 collegato alla scheda (es. pin 12).
Come risultato dell'esecuzione del programma, il led1 lampeggerà una volta, mentre il led2 si accenderà e si spegnerà finché Arduino sarà acceso.
Premendo il pulsante RESET il led1 lampeggerà nuovamente e il led2 lampeggerà nuovamente in modo continuo.
Riassumere:
- Le funzioni setup() e loop() lo sono funzioni del sistema, che deve essere definito in ciascun progetto. Anche nel caso in cui non scriviamo alcun codice in una di esse, dobbiamo comunque dichiarare queste due funzioni;
- La funzione setup() viene eseguita una volta, loop() viene eseguita continuamente;
- Creiamo le nostre funzioni in un unico file;
- Possiamo chiamare le nostre funzioni sia da setup() e loop(), sia da altre funzioni;
- Le nostre funzioni possono essere chiamate con parametri e restituire un valore;
- Una chiamata di funzione deve essere effettuata in conformità con la sua dichiarazione.
Questa lezione fornisce le conoscenze minime necessarie per programmare i sistemi Arduino in C. Puoi solo visualizzarla e poi usarla come informazioni di base. Per chi ha programmato in C su altri sistemi potete saltare l'articolo.
Ribadisco che si tratta di informazioni minime. Descrizione di puntatori, classi, variabili stringa, ecc. verranno fornite nelle lezioni successive. Se qualcosa non è chiaro, non preoccuparti. Ci saranno molti esempi e spiegazioni nelle lezioni future.
Struttura del programma Arduino.
La struttura del programma Arduino è abbastanza semplice e, nella sua forma minimale, è composta da due parti setup() e loop().
configurazione nulla() (
ciclo vuoto() (
La funzione setup() viene eseguita una volta, quando il controller viene acceso o ripristinato. Di solito succede impostazioni iniziali variabili, registri. La funzione deve essere presente nel programma, anche se non contiene nulla.
Una volta completato setup(), il controllo passa alla funzione loop(). Esegue i comandi scritti nel suo corpo (tra le parentesi graffe) in un ciclo infinito. In realtà, questi comandi eseguono tutte le azioni algoritmiche del controller.
Le regole originali della sintassi del linguaggio C.
; punto e virgola Le espressioni possono contenere tutti gli spazi e le interruzioni di riga desiderati. La fine di un'espressione è indicata dal simbolo del punto e virgola.
z = x + y;
z=x
+y;
( ) parentesi graffe definire un blocco di funzioni o espressioni. Ad esempio, nelle funzioni setup() e loop().
/* … */ blocco commenti, assicurati di chiudere.
/* questo è un blocco commenti */
// commento di una riga, non è necessario chiudere, valido fino alla fine della riga.
// questa è una riga di commento
Variabili e tipi di dati.
La variabile è una cella memoria ad accesso casuale, in cui sono archiviate le informazioni. Il programma utilizza variabili per memorizzare i dati di calcolo intermedi. I dati possono essere utilizzati per i calcoli formati diversi, di diversa profondità di bit, quindi le variabili nel linguaggio C hanno i seguenti tipi.
| Tipo di dati | Profondità, bit | Intervallo di numeri |
| booleano | 8 | vero falso |
| car | 8 | -128 … 127 |
| carattere non firmato | 8 | 0 … 255 |
| byte | 8 | 0 … 255 |
| int | 16 | -32768 … 32767 |
| intero senza segno | 16 | 0 … 65535 |
| parola | 16 | 0 … 65535 |
| lungo | 32 | -2147483648 … 2147483647 |
| non firmato lungo | 32 | 0 … 4294967295 |
| corto | 16 | -32768 … 32767 |
| galleggiante | 32 | -3.4028235+38 … 3.4028235+38 |
| Doppio | 32 | -3.4028235+38 … 3.4028235+38 |
I tipi di dati vengono selezionati in base alla precisione di calcolo richiesta, ai formati dei dati, ecc. Ad esempio, per un contatore che conta fino a 100, non dovresti selezionare tipo lungo. Funzionerà, ma l'operazione richiederà più memoria dati e programmi richiederanno più tempo.
Dichiarazione di variabili.
Viene specificato il tipo di dati, seguito dal nome della variabile.
interox; // dichiarazione di una variabile denominata x di tipo int
larghezza floatBox; // dichiarazione di una variabile denominata widthBox di tipo float
Tutte le variabili devono essere dichiarate prima di essere utilizzate.
Una variabile può essere dichiarata ovunque in un programma, ma ciò determina quali blocchi di programma possono utilizzarla. Quelli. Le variabili hanno ambiti.
- Le variabili dichiarate all'inizio del programma, prima della funzione void setup(), sono considerate globali e sono disponibili ovunque nel programma.
- Le variabili locali sono dichiarate all'interno di funzioni o blocchi come un ciclo for e possono essere utilizzate solo all'interno di blocchi dichiarati. È possibile avere più variabili con lo stesso nome ma ambiti diversi.
modalità intera; // variabile disponibile per tutte le funzioni
configurazione nulla() (
// blocco vuoto, non sono richieste impostazioni iniziali
}
ciclo vuoto() (
conteggio lungo; // la variabile count è disponibile solo nella funzione loop()
for (int i=0; i< 10;) // переменная i доступна только внутри цикла
{
io++;
}
}
Quando dichiari una variabile, puoi impostarla valore iniziale(inizializzare).
intero x = 0; // la variabile x viene dichiarata con il valore iniziale 0
carattere d = 'a'; // la variabile d viene dichiarata con il valore iniziale uguale al codice carattere “a”
A operazioni aritmetiche Con tipi diversi si verificano i dati conversione automatica tipi di dati. Ma è sempre meglio usare una conversione esplicita.
interox; // variabile intera
caro; // variabile carattere
intero z; // variabile intera
z = x + (int)y; // la variabile y viene convertita esplicitamente in int
Operazioni aritmetiche.
Operazioni di relazione.
Operazioni logiche.
Operazioni sui puntatori.
Operazioni sui bit.
| & | E |
| | | O |
| ^ | ESCLUSIVO O |
| ~ | INVERSIONE |
| << | SPOSTA A SINISTRA |
| >> | SPOSTA A DESTRA |
Operazioni di assegnazione miste.
Selezione delle opzioni, gestione del programma.
Operatore SE controlla la condizione tra parentesi ed esegue l'espressione o il blocco successivo parentesi graffe, se la condizione è vera.
if (x == 5) // se x=5, allora viene eseguito z=0
z=0;
se (x > 5) // se x >
( z=0; y=8; )
SE ALTRO ti permette di scegliere tra due opzioni.
if (x > 5) // se x > 5, allora il blocco viene eseguito z=0, y=8;
{
z=0;
y=8;
}
{
z=0;
y=0;
}
ALTRIMENTI SE– consente di effettuare selezioni multiple
if (x > 5) // se x > 5, allora il blocco viene eseguito z=0, y=8;
{
z=0;
y=8;
}
else if (x > 20) // se x > 20, questo blocco viene eseguito
{
}
else // altrimenti questo blocco viene eseguito
{
z=0;
y=0;
}
SCATOLA DELL'INTERRUTTORE- scelta multipla. Permette di confrontare una variabile (nell'esempio è x) con diverse costanti (nell'esempio 5 e 10) ed eseguire un blocco in cui la variabile è uguale alla costante.
interruttore (x) (
caso 5:
// il codice viene eseguito se x = 5
rottura;
caso 10:
// il codice viene eseguito se x = 10
rottura;
predefinito:
// il codice viene eseguito se nessuno corrisponde valore precedente
rottura;
}
Ciclo FOR. Il design consente di organizzare cicli con un determinato numero di iterazioni. La sintassi è simile alla seguente:
for (azione prima dell'inizio del ciclo;
condizione di continuazione del ciclo;
azione alla fine di ogni iterazione) (
// codice del corpo del loop
Un esempio di un ciclo di 100 iterazioni.
per (i=0; i< 100; i++) // начальное значение 0, конечное 99, шаг 1
{
somma = somma + I;
}
MENTRE ciclo. L'operatore consente di organizzare i loop con la costruzione:
mentre (espressione)
{
// codice del corpo del loop
}
Il ciclo viene eseguito finché l'espressione tra parentesi è vera. Un esempio di un ciclo per 10 iterazioni.
x = 0;
mentre(x< 10)
{
// codice del corpo del loop
x++;
}
FARE DURANTE– un loop con una condizione all'uscita.
Fare
{
// codice del corpo del loop
) mentre (espressione);
Il ciclo viene eseguito finché l'espressione è vera.
ROTTURA– operatore di uscita dal ciclo. Utilizzato per interrompere l'esecuzione per i loop, mentre, fai mentre.
x = 0;
mentre(x< 10)
{
se (z > 20) rottura; // se z > 20, esce dal ciclo
// codice del corpo del loop
x++;
}
VAI A– operatore di transizione incondizionato.
gotometka1; // vai a metka1
………………
metka1:
CONTINUA- saltare le istruzioni fino alla fine del corpo del ciclo.
x = 0;
mentre(x< 10)
{
// codice del corpo del loop
se (z > 20) continuare; // se z > 20, ritorna all'inizio del corpo del loop
// codice del corpo del loop
x++;
}
Array.
Un array è un'area di memoria in cui vengono memorizzate diverse variabili in sequenza.
Un array è dichiarato in questo modo:
int età; // array di 10 variabili di tipo int
peso galleggiante // array di 100 variabili float
Una volta dichiarati, gli array possono essere inizializzati:
int età = ( 23, 54, 34, 24, 45, 56, 23, 23, 27, 28);
Si accede alle variabili dell'array in questo modo:
x = età; // A x viene assegnato il valore del quinto elemento dell'array.
età = 32; // Il 9° elemento dell'array è impostato su 32
La numerazione degli elementi dell'array parte sempre da zero.
Funzioni.
Le funzioni consentono di eseguire le stesse azioni con dati diversi. La funzione ha:
- il nome con cui viene chiamata;
- argomenti: dati utilizzati dalla funzione per il calcolo;
- il tipo di dati restituito dalla funzione.
Descrive una funzione definita dall'utente esterna alle funzioni setup() e loop().
configurazione nulla() (
// il codice viene eseguito una volta all'avvio del programma
}
ciclo vuoto() (
// codice principale, eseguito in un ciclo
}
// annuncio funzione personalizzata con il nome functionName
digitare nomefunzione(tipo argomento1, tipo argomento1, …, tipo argomento)
{
// corpo della funzione
ritorno();
}
Un esempio di funzione che calcola la somma dei quadrati di due argomenti.
int sumQwadr(int x, int y)
{
ritorno(x* x + y*y);
}
La chiamata alla funzione funziona così:
d=2; b=3;
z= sommaQwadr(d, b); // z sarà la somma dei quadrati delle variabili d e b
Le funzioni possono essere integrate, personalizzate o plug-in.
Molto breve, ma questi dati dovrebbero essere sufficienti per iniziare a scrivere programmi in C per i sistemi Arduino.
L'ultima cosa che voglio dirti in questa lezione è come è consuetudine formattare i programmi in C. Penso che se stai leggendo questa lezione per la prima volta, dovresti saltare questa sezione e tornarci più tardi, quando avrai finito qualcosa da formattare.
l'obiettivo principale progettazione esterna programmi è migliorare la leggibilità dei programmi e ridurre il numero di errori formali. Pertanto, per raggiungere questo obiettivo, puoi tranquillamente violare tutte le raccomandazioni.
Nomi in linguaggio C.
I nomi che rappresentano i tipi di dati devono essere scritti in maiuscole e minuscole. La prima lettera del nome deve essere maiuscola (maiuscola).
Segnale, conteggio del tempo
Le variabili devono essere scritte in nomi misti, con la prima lettera minuscola (minuscolo).
Arduino è una scheda di sviluppo pronta all'uso e un linguaggio di programmazione molto semplice che semplifica l'avvio con i microcontrollori a discapito delle dimensioni e della velocità del programma. Recentemente, Atmel ha aggiunto il supporto per il bootloader Arduino in Studio AVR, ovvero puoi scrivere e caricare programmi scritti in C, C++ o Assembler senza un programmatore. Inoltre, puoi scrivere codice nel linguaggio di elaborazione/cablaggio in AVR Studio.
Consiglio di iniziare a leggere l'articolo con l'aggiornamento alla fine!
In questo articolo proponiamo istruzioni passo passo sull'installazione del software di programmazione Arduino utilizzando AVR Studio. Abbiamo preso come base una recensione delle estensioni AVR Studio dal sito easyelectronics.ru. Eseguiremo tutti gli esempi sulla nostra scheda.
Installazione dell'IDE di Arduino
Stiamo utilizzando la versione 1.5.2 di Arduino. Puoi scaricarlo sul sito ufficiale. Ultima versione(1.6.2-r2 al momento in cui scrivo) per qualche motivo non funziona con il microcontrollore Atmega8.
Scaricherai un archivio zip con l'ambiente già distribuito. Non resta che decomprimerlo nella directory del programma.
Installazione di AtmelStudio
AGGIORNAMENTO
Vedo che l'argomento è popolare e voglio chiarire alcuni punti.
Ci sono tre modi in cui ho provato a programmare una scheda compatibile con Arduino in C:
- Scrivi direttamente nell'IDE di Arduino in C. Devi capire che Processing/Wiring non è un linguaggio, ma semplicemente un insieme di macro e librerie. Quando ci scrivi, guarda nelle sue intestazioni, converte il tuo codice leggibile dall'uomo in C e poi compila con il compilatore AVR GCC standard. Se scrivi codice in C, non accederà alle sue librerie e compilerà immediatamente tutto come dovrebbe, MA!... allo stesso tempo, il linker aggiungerà al tuo progetto quello che vuole. Il vantaggio è che non hai bisogno di altro che dell’IDE Arduino. Lo svantaggio è la magia, che è nascosta allo sviluppatore. Questo metodo viene spesso utilizzato nei casi in cui è necessario implementare una funzione che i nostri amici italiani non prevedevano nella loro lingua.
- Il metodo proposto in questo articolo (in effetti, il più strano, perché unisce tutte le carenze). Ideologicamente, questa estensione è necessaria per programmare in Processing/Wiring e utilizzare Atmel Studio come interfaccia. Esiste anche una funzionalità a pagamento che consente di eseguire il debug del codice, ma non l'ho provata. Quindi, in sostanza, durante la programmazione, tutto avviene come nella prima opzione, ma lavori in un IDE diverso. Allo stesso tempo, dal punto di vista del risultato, ottieni la stessa cosa. Se hai programmato Arduino e hai deciso di farlo in C, sentiti libero di scrivere direttamente all'IDE di Arduino. Se non ti piace l'interfaccia, puoi utilizzare un normale editor (ti consiglio Sublime Text). Se lavori in Atnel Studio e desideri eseguire il flashing della tua scheda direttamente dalla sua interfaccia o scriverci Elaborazione/Cablaggio (all'improvviso!), allora questo componente aggiuntivo fa per te. A proposito, lo studio funziona solo su Windows, cioè il metodo non è per tutti. Ho scritto questo articolo solo perché ho trovato un nuovo metodo per me stesso, ma non mi piace.
- Il terzo metodo, mi sembra, è il migliore per un utente avanzato. All'inizio tutto avviene come al solito: scrivi il codice, lo compili e ottieni un file esadecimale. Quindi, ricordando che hai una normale scheda di debug con un bootloader tra le mani, scarica un'utilità in grado di accedere a questo bootloader e trasferire il tuo codice in memoria. Abbiamo già pubblicato le istruzioni passo passo. In questo caso, lo sviluppatore riceve il massimo controllo su tutte le funzioni, ma potrebbero sorgere problemi dovuti all'utilizzo di un bootloader di terze parti.
Vorrei rivelare un'altra cosa che succede in Arduino. Qualunque cosa tu faccia, l'IDE di Arduino accenderà sicuramente le periferiche stesse. Ad esempio, avvierà i timer. E se vuoi lavorarci in C, potresti scoprire che non funzionano come ti aspettavi. E questo potrebbe diventarlo vero problema. E ci sono molti di questi esempi, cioè ci sono molti potenziali rastrelli, stampelle e insetti.
Se carichi semplicemente un file esadecimale, i problemi possono sorgere solo a causa del bootloader. Finora ne ho trovato solo uno: una volta completato il bootloader, l'UART rimane abilitato. Se scrivi tramite l'IDE di Arduino, verrà inserito nel tuo codice per disabilitarlo e chissà cos'altro. Se vuoi solo eseguire il tuo esagono, non avrai il controllo sulle gambe UART. Dovrai aggiungere manualmente una disabilitazione UART al tuo progetto. Questo artefatto e gli esempi di codice sono descritti in dettaglio in .
Bene, in conclusione. La maggior parte delle schede compatibili con Arduino dispongono di un connettore per un programmatore ISP. Se acquisti questo programmatore dai cinesi per 3-4 dollari, dimenticherai presto tutti questi problemi.
Saremo molto lieti se sosterrai la nostra risorsa e visiterai il nostro negozio di prodotti.
Nella vita di uno sviluppatore Arduino, prima o poi arriva il momento in cui l’ambiente di sviluppo standard diventa affollato. Se gli schizzi non hanno più memoria sufficiente, avete bisogno di tempo reale e lavorate con interruzioni, o volete semplicemente essere più vicini all'hardware, allora è il momento di passare a C. Gli ingegneri elettronici esperti aggrotteranno le sopracciglia con disprezzo alla menzione di Arduino e invieranno il principiante in un negozio di radio per un saldatore. Forse questo non è il massimo cattivo consiglio, ma non lo seguiremo ancora. Se scartiamo l'IDE di Arduino e il linguaggio di cablaggio/elaborazione, ci ritroviamo con un'ottima scheda di debug, già dotata di tutto il necessario per il funzionamento del microcontrollore. E, cosa più importante, un bootloader è già cablato nella memoria del controller, consentendoti di caricare il firmware senza utilizzare un programmatore.
Per programmare in C, abbiamo bisogno di AVR GCC Toolchain.
Avremo bisogno anche dell'IDE Arduino installato, perché... contiene l'utilità avrdude, necessaria per scaricare il firmware sul controller. CrossPack contiene anche avrdude, ma la versione fornita con esso non funziona con Arduino.
Dopo aver installato tutto, creiamo il nostro primo progetto. Per cominciare, scriviamo Makefile. Ci consentirà di evitare di inserire manualmente lunghi comandi ogni volta che compiliamo e carichiamo il firmware.
#Controller installato sulla scheda. Potrebbe essere diverso, ad esempio atmega328 DEVICE = atmega168 #Frequenza clock 16 MHz CLOCK = 16000000 #Avrdude comando di avvio. Deve essere copiato dall'IDE di Arduino. AVRDUDE = /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/avrdude -C/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/etc/avrdude.conf -carduino -P/dev/tty.usbserial-A600dAAQ -b19200 -D -p atmega168 OBJECTS = main.o COMPILE = avr-gcc -Wall -Os -DF_CPU=$(CLOCK) -mmcu=$(DISPOSITIVO) all: main .hex .c.o: $(COMPILE) -c $< -o $@ .S.o: $(COMPILE) -x assembler-with-cpp -c $< -o $@ .c.s: $(COMPILE) -S $< -o $@ flash: all $(AVRDUDE) -U flash:w:main.hex:i clean: rm -f main.hex main.elf $(OBJECTS) main.elf: $(OBJECTS) $(COMPILE) -o main.elf $(OBJECTS) main.hex: main.elf rm -f main.hex avr-objcopy -j .text -j .data -O ihex main.elf main.hex avr-size --format=avr --mcu=$(DEVICE) main.elf
In questo file dobbiamo inserire il nostro comando per avviare avrdude. SU sistemi diversi sembrerà diverso. Per scoprire la tua opzione, avvia l'IDE Arduino e seleziona la casella "Mostra output dettagliato durante il caricamento" nelle impostazioni.
Ora carichiamo Arduino qualunque disegna e guarda i messaggi visualizzati nella parte inferiore della finestra. Troviamo lì la chiamata avrdude, copiamo tutto tranne il parametro -Uflash e lo incolliamo nel Makefile dopo “AVRDUDE = “.
Una breve nota: tutti i rientri nel Makefile vengono eseguiti con caratteri di tabulazione (tasto Tab). Se tuo editor di testo sostituisce questi caratteri con spazi, il comando make rifiuterà di compilare il progetto.
Ora creiamo un file principale.c- il testo vero e proprio del nostro programma, in cui tradizionalmente facciamo lampeggiare il LED.
#includere
Il nostro progetto è pronto. Apriamo la console nella directory del nostro progetto e inseriamo il comando "make":
Come puoi vedere, la dimensione del firmware risultante è di soli 180 byte. Uno schizzo simile di Arduino occupa 1116 byte nella memoria del controller.
Ora torniamo alla console e inseriamo "make flash" per caricare il file compilato nel controller:
Se il download è stato completato senza errori, il LED collegato al pin 13 della scheda lampeggerà allegramente. A volte avrdude non riesce a trovare la scheda o cade a causa di un timeout: in questo caso, torcere il cavo USB può aiutare. Inoltre, per evitare conflitti di accesso alla scheda, non dimenticare di chiudere l'IDE di Arduino prima del comando “make flash”.
Forse molte delle cose descritte in questo articolo sembreranno ovvie agli sviluppatori esperti. Ho cercato di descrivere il processo in un linguaggio il più comprensibile possibile per un utente Arduino alle prime armi e di raccogliere in un unico posto le informazioni che sono riuscito a ottenere da varie fonti e verificare empiricamente. Forse questo articolo farà risparmiare a qualcuno un paio d'ore di tempo.
Buona fortuna nel padroneggiare i microcontrollori!
Questo simulatore funziona meglio sul browser Chrome
Diamo uno sguardo più da vicino ad Arduino.
Arduino non è un computer di grandi dimensioni che può essere collegato a circuiti esterni. Arduino Uno utilizza Atmega 328P
Questo è il chip più grande sul tabellone. Questo chip esegue i programmi memorizzati nella sua memoria. Puoi scaricare il programma tramite USB utilizzando l'IDE Arduino. La porta USB fornisce anche alimentazione all'arduino.
C'è un connettore di alimentazione separato. La scheda ha due pin etichettati 5v e 3,3v, necessari per alimentare vari dispositivi. Troverai anche i pin contrassegnati GND, questi sono i pin di terra (la terra è 0 V). La piattaforma Arduino dispone anche di 14 pin digitali, etichettati da 0 a 13, che si collegano a nodi esterni e hanno due stati, alto o basso (acceso o spento). Questi contatti possono funzionare come uscite o come ingressi, ad es. possono trasmettere alcuni dati e controllare dispositivi esterni oppure ricevere dati da dispositivi. I pin successivi sulla scheda sono etichettati A0-A5. Si tratta di ingressi analogici che possono ricevere dati da vari sensori. Ciò è particolarmente utile quando è necessario misurare un determinato intervallo, ad esempio la temperatura. Gli ingressi analogici dispongono di funzioni aggiuntive che possono essere abilitate separatamente.
Come utilizzare una scheda di sviluppo.
La breadboard è necessaria per collegare temporaneamente le parti, verificare come funziona il dispositivo, prima di saldare tutto insieme.
Tutti gli esempi seguenti sono assemblati su una breadboard in modo da poter apportare rapidamente modifiche al circuito e riutilizzare le parti senza preoccuparsi della saldatura.
La breadboard ha file di fori in cui è possibile inserire parti e fili. Alcuni di questi fori sono collegati elettricamente tra loro.
Le due file superiore e inferiore sono collegate in file lungo l'intero tabellone. Queste file vengono utilizzate per fornire alimentazione al circuito. Potrebbe essere 5 V o 3,3 V, ma in ogni caso la prima cosa che devi fare è collegare 5 V e GND alla breadboard come mostrato in figura. A volte questi collegamenti tra le righe possono essere interrotti al centro del tabellone, quindi se necessario puoi collegarli come mostrato nell'immagine.
Le rimanenti buche, situate al centro del tabellone, sono raggruppate in gruppi di cinque buche. Sono utilizzati per collegare le parti del circuito.
La prima cosa che collegheremo al nostro microcontrollore è un LED. Lo schema di collegamento elettrico è mostrato in figura.
Perché è necessaria una resistenza in un circuito? In questo caso limita la corrente che passa attraverso il LED. Ogni LED è progettato per una determinata corrente e, se questa corrente è superiore, il LED si guasterà. Puoi scoprire quale valore dovrebbe avere il resistore usando la legge di Ohm. Per chi non lo sapesse o lo avesse dimenticato, la legge di Ohm dice che esiste una relazione lineare tra corrente e tensione. Cioè, maggiore è la tensione applicata al resistore, maggiore sarà la corrente che lo attraverserà.
V=I*R
Dove V- tensione ai capi del resistore
IO- corrente attraverso il resistore
R- resistenza che deve essere trovata.
Per prima cosa dobbiamo scoprire la tensione ai capi del resistore. La maggior parte dei LED da 3 mm o 5 mm che utilizzerai hanno una tensione operativa di 3 V. Ciò significa che dobbiamo spegnere 5-3 = 2 V sul resistore.
Calcoleremo quindi la corrente che passa attraverso il resistore.
La maggior parte dei LED da 3 mm e 5 mm si illumina alla massima luminosità a 20 mA. Una corrente maggiore può disattivarli, mentre una corrente di minore intensità ne ridurrà la luminosità senza causare alcun danno.
Quindi, vogliamo collegare il LED al circuito da 5 V in modo che trasporti una corrente di 20 mA. Poiché tutte le parti sono incluse in un unico circuito, anche il resistore avrà una corrente di 20 mA.
Noi abbiamo
2 V = 20 mA * R
2 V = 0,02 A * R
R = 100 Ohm
100 Ohm è la resistenza minima, è meglio usarne un po' di più, perché i LED hanno qualche variazione nelle caratteristiche.
In questo esempio viene utilizzata una resistenza da 220 ohm. Solo perché l'autore ne ha molti: occhiolino: .
Inserisci il LED nei fori al centro della scheda in modo che il suo lungo cavo sia collegato a uno dei cavi del resistore. Collega la seconda estremità del resistore a 5 V e collega il secondo cavo del LED a GND. Il LED dovrebbe accendersi.
Tieni presente che esiste una differenza nel modo in cui colleghi il LED. La corrente scorre dal terminale più lungo a quello più corto. Nel diagramma puoi immaginare che la corrente scorra nella direzione in cui è diretto il triangolo. Prova a capovolgere il led e vedrai che non si accenderà.
Ma il modo in cui colleghi il resistore non fa alcuna differenza. Puoi capovolgerlo o provare a collegarlo a un pin diverso del LED, ciò non influirà sul funzionamento del circuito. Limiterà comunque la corrente attraverso il LED.
Anatomia dello schizzo di Arduino.
I programmi per Arduino si chiamano sketch. Sono costituiti da due funzioni principali. Funzione impostare e funzione ciclo continuo
All'interno di questa funzione imposterai tutte le impostazioni di base. Quali pin funzioneranno come input o output, quali librerie connettere, inizializzare le variabili. Funzione Impostare() viene eseguito solo una volta durante lo sketch, quando inizia l'esecuzione del programma.
questa è la funzione principale che viene eseguita dopo impostare(). In realtà, è il programma stesso. Questa funzione verrà eseguita indefinitamente finché non si spegne l'alimentazione.
LED lampeggiante di Arduino
In questo esempio collegheremo un circuito LED a uno dei pin digitali di Arduino e lo accenderemo e spegneremo utilizzando un programma, inoltre imparerai diverse funzioni utili.
Questa funzione viene utilizzata in impostare() parte del programma e serve per inizializzare i pin che utilizzerai come input (INGRESSO) o uscire (PRODUZIONE). Non sarai in grado di leggere o scrivere dati dal pin finché non lo imposti rispettivamente su pinMode. Questa funzione ha due argomenti: codice PINè il numero PIN che utilizzerai.
Modalità-imposta come funzionerà il pin. All'entrata (INGRESSO) o uscire (PRODUZIONE). Per accendere il LED dobbiamo dare un segnale DA Arduino. Per fare ciò, configuriamo il pin di output.
- questa funzione viene utilizzata per impostare lo stato (stato) Pina (codice PIN). Ci sono due stati principali (in realtà 3), uno lo è ALTO, ci saranno 5 V sul pin, questa è un'altra cosa Basso e il pin sarà 0v. Ciò significa che per accendere il LED dobbiamo impostare il pin collegato al LED ad un livello alto ALTO.
Ritardo. Serve a ritardare il funzionamento del programma per un periodo indicato in msec.
Di seguito è riportato il codice che fa lampeggiare il LED.
//LED Blink int ledPin = 7;//Pin Arduino a cui è collegato il LED void setup() ( pinMode(ledPin, OUTPUT);// impostando il pin come OUTPUT) void loop() ( digitalWrite(ledPin, HIGH) ;// attiva il ritardo del LED (1000);// ritarda 1000 ms (1 secondo) digitalWrite(ledPin, LOW);//disattiva il ritardo del LED (1000);//attendi 1 secondo)
Piccole spiegazioni sul codice.
Le righe che iniziano con "//" sono commenti e vengono ignorate da Arduino.
Tutti i comandi terminano con un punto e virgola; se li dimentichi riceverai un messaggio di errore.
ledPinè una variabile. Le variabili vengono utilizzate nei programmi per memorizzare valori. In questo esempio, la variabile ledPin il valore è assegnato a 7, questo è il numero del pin di Arduino. Quando il programma Arduino incontra una linea con una variabile ledPin, utilizzerà il valore specificato in precedenza.
Quindi registra pinMode(LEDPin, USCITA) simile alla registrazione pinModalità(7, USCITA).
Ma nel primo caso, devi solo cambiare la variabile e cambierà in ogni riga in cui viene utilizzata, e nel secondo caso, per cambiare la variabile, dovrai apportare modifiche manualmente in ogni comando.
La prima riga indica il tipo della variabile. Quando si programma Arduino è importante dichiarare sempre il tipo delle variabili. Per ora ti basta saperlo INT annuncia numeri negativi e positivi.
Di seguito è riportata una simulazione dello schizzo. Fare clic su Avvia per vedere il circuito in azione.
Come previsto, il LED si spegne e si riaccende dopo un secondo. Prova a modificare il ritardo per vedere come funziona.
Controllo di più LED.
In questo esempio imparerai come controllare più LED. Per fare ciò, installa altri 3 LED sulla scheda e collegali ai resistori e ai pin di Arduino come mostrato di seguito.
Per poter accendere e spegnere i LED uno per uno è necessario scrivere un programma simile a questo:
//Multi LED lampeggia int led1Pin = 4; int led2Pin = 5; int led3Pin = 6; int led4Pin = 7; void setup() ( //imposta i pin come OUTPUT pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH );//attiva il ritardo del LED(1000);//ritardo 1 secondo digitalWrite(led1Pin, LOW);//disattiva il ritardo del LED(1000);//ritardo 1 secondo //fai lo stesso per gli altri 3 LED digitalWrite(led2Pin, HIGH);//accende il LED con ritardo(1000);//ritardo 1 secondo digitalWrite(led2Pin, LOW);//spegne il LED con ritardo(1000);//ritardo 1 secondo digitalWrite(led3Pin, HIGH );//accendi il LED ritardo(1000);//ritarda 1 secondo digitalWrite(led3Pin, LOW);//spegni il LED ritardo(1000);//ritarda 1 secondo digitalWrite(led4Pin, HIGH);//accendi il ritardo del LED (1000);// ritardo 1 secondo digitalWrite (led4Pin, LOW);//spegnimento del ritardo LED (1000);// ritardo 1 secondo)
Questo programma funzionerà benissimo, ma non è la soluzione più razionale. Il codice deve essere cambiato. Affinché il programma funzioni più e più volte, utilizzeremo una costruzione chiamata .
I cicli sono utili quando è necessario ripetere la stessa azione più volte. Nel codice sopra ripetiamo le righe
Scrittura digitale (led4 pin, ALTA); ritardo(1000); scrittura digitale(led4Pin, BASSO); ritardo(1000);
codice schizzo completo in allegato (download: 1187)
Regolazione della luminosità dei LED
A volte sarà necessario modificare la luminosità dei LED nel programma. Questo può essere fatto usando il comando analogWrite()
. Questo comando accende e spegne il LED così velocemente che l'occhio non riesce a vederne lo sfarfallio. Se il LED viene acceso per metà del tempo e spento per la metà del tempo, sembrerà visivamente che brilli a metà della sua luminosità. Questa si chiama modulazione di larghezza di impulso (PWM o PWM in inglese). Lo spessore viene utilizzato abbastanza spesso, poiché può essere utilizzato per controllare un componente "analogico" utilizzando un codice digitale. Non tutti i pin Arduino sono adatti a questi scopi. Solo quelle conclusioni alle quali si giunge a tale designazione " ~
". Lo vedrai accanto ai pin 3,5,6,9,10,11.
Collega uno dei tuoi LED a uno dei pin PWM (per l'autore questo è il pin 9). Ora esegui lo schizzo lampeggiante del LED, ma prima modifica il comando scrittura digitale() SU analogWrite(). analogWrite() ha due argomenti: il primo è il numero del pin e il secondo è il valore PWM (0-255), per i LED questa sarà la loro luminosità e per i motori elettrici la velocità di rotazione. Di seguito è riportato un codice di esempio per diverse luminosità dei LED.
//Cambia la luminosità del LED int ledPin = 9;//un LED è collegato a questo pin void setup() ( pinMode(ledPin, OUTPUT);// inizializza il pin sull'uscita ) void loop() ( analogWrite( ledPin, 255);// piena luminosità (255/255 = 1) ritardo (1000);//pausa 1 secondo digitalWrite(ledPin, LOW);//spegnimento LED ritardo (1000);//pausa 1 secondo analogWrite( ledPin, 191);//luminosità di 3/4 (191/255 ~= 0,75) ritardo(1000);//pausa 1 secondo digitalWrite(ledPin, LOW);//disattiva il ritardo LED(1000);// pausa 1 secondo analogWrite(ledPin, 127); //metà luminosità (127/255 ~= 0,5) ritardo(1000);//pausa 1 secondo digitalWrite(ledPin, LOW);//spegnimento ritardo LED(1000);/ /pausa 1 secondo analogWrite(ledPin, 63); //un quarto di luminosità (63/255 ~= 0,25) ritardo(1000);//pausa 1 secondo digitalWrite(ledPin, LOW);//disattiva il ritardo del LED(1000) ;//pausa 1 secondo)
Prova a modificare il valore PWM nel comando analogWrite() per vedere come ciò influisce sulla luminosità.
Successivamente, imparerai come regolare la luminosità in modo uniforme da piena a zero. Ovviamente puoi copiare un pezzo di codice 255 volte
analogWrite(LEDPin, luminosità); ritardo(5);//luminosità ritardo breve = luminosità + 1;
Ma, capisci, questo non sarà pratico. Il modo migliore per farlo è usare il ciclo FOR che abbiamo usato in precedenza.
IN seguente esempio vengono utilizzati due cicli, uno per diminuire la luminosità da 255 a 0
for (int luminosità=0;luminosità=0;luminosità--)( analogWrite(ledPin,luminosità); ritardo(5); )
ritardo(5) utilizzato per rallentare la velocità di dissolvenza in apertura (5*256=1280ms=1,28s)
La prima riga utilizza " luminosità-" per far diminuire il valore della luminosità di 1 ogni volta che il ciclo viene ripetuto. Tieni presente che il ciclo verrà eseguito fino a luminosità >=0.Sostituzione del segno >
sul segno >=
abbiamo incluso 0 nell'intervallo di luminosità. Questo schizzo è modellato di seguito. //cambia gradualmente la luminosità int ledPin = 9;//un LED è collegato a questo pin void setup() ( pinMode(ledPin, OUTPUT);// inizializzazione del pin di uscita) void loop() ( //aumenta gradualmente la luminosità luminosità (da 0 a 255) for (int luminosità=0;luminosità=0;luminosità--)( analogWrite(ledPin,luminosità); ritardo(5); ) ritardo(1000);//attendi 1 secondo //riduci gradualmente la luminosità (da 255 a 0) for (int luminosità=255;luminosità>=0;luminosità--)( analogWrite(ledPin,luminosità); ritardo(5); ) ritardo(1000);//attendi 1 secondo ) )
Non è molto visibile, ma l'idea è chiara.
LED RGB e Arduino
Un LED RGB è in realtà composto da tre LED di colore diverso in un unico pacchetto.
Includendo diversi LED con luminosità diversa, è possibile combinarli e ottenerli colori differenti. Per Arduino, dove il numero di livelli di luminosità è 256, otterrai 256 ^ 3 = 16581375 colori possibili. In realtà, ovviamente, ce ne saranno meno.
Il LED che utilizzeremo è il catodo comune. Quelli. tutti e tre i LED sono strutturalmente collegati tramite catodi a un terminale. Collegheremo questo pin al pin GND. I restanti pin, tramite resistori di limitazione, devono essere collegati ai pin PWM. L'autore ha utilizzato i pin 9-11, in questo modo sarà possibile controllare ciascun LED separatamente. Il primo schizzo mostra come accendere ciascun LED individualmente.
//LED RGB - test //connessioni pin int rosso = 9; intero verde = 10; intero blu = 11; void setup())( pinMode(red, OUTPUT); pinMode(blue, OUTPUT); pinMode(green, OUTPUT); ) void loop())( //accende/spegne il LED rosso digitalWrite(red, HIGH); ritardo(500) ; digitalWrite(rosso, LOW); ritardo(500); //accende/spegne il LED verde digitalWrite(verde, ALTO); ritardo(500); digitalWrite(verde, LOW); ritardo(500); // accende/spegne il LED blu digitalWrite(blu, HIGH); ritardo(500); digitalWrite(blu, LOW); ritardo(500); )
L'esempio seguente utilizza i comandi analogWrite() e per ottenere diversi valori di luminosità casuale per i LED. Vedrai cambiare diversi colori a caso.
//LED RGB - colori casuali //connessioni pin int rosso = 9; intero verde = 10; intero blu = 11; void setup())( pinMode(red, OUTPUT); pinMode(blue, OUTPUT); pinMode(green, OUTPUT); ) void loop())( //scegli un colore casuale analogWrite(red, random(256)); analogWrite(blu, casuale(256)); analogWrite(verde, casuale(256)); ritardo(1000);//attendi un secondo)
Casuale(256)-ritorna numero casuale nell'intervallo da 0 a 255.
In allegato c'è uno schizzo che dimostrerà transizioni fluide colori dal rosso al verde, poi al blu, rosso, verde, ecc. (download: 326)
Lo schizzo di esempio funziona, ma è presente molto codice duplicato. Puoi semplificare il codice scrivendone uno tuo funzione ausiliaria, che cambierà gradualmente da un colore all'altro.
Ecco come apparirà: (download: 365)
Diamo un'occhiata alla definizione della funzione pezzo per pezzo. La funzione viene chiamata fader e ha due argomenti. Ogni argomento è separato da una virgola e ha un tipo dichiarato nella prima riga della definizione della funzione: fader vuoto(int color1, int color2). Vedi che entrambi gli argomenti sono dichiarati come int e vengono dati dei nomi colore1 E colore2 come variabili condizionali per definire una funzione. Vuoto significa che la funzione non restituisce alcun valore, esegue semplicemente i comandi. Se dovessi scrivere una funzione che restituisse il risultato della moltiplicazione, sarebbe simile a questa:
int moltiplicatore(int numero1, int numero2)( int prodotto = numero1*numero2; prodotto restituito; )
Nota come abbiamo dichiarato Type int come tipo restituito invece
vuoto.
All'interno della funzione ci sono i comandi che hai già utilizzato nello sketch precedente, sono stati sostituiti solo i numeri dei pin colore1 E colore2. La funzione viene chiamata fader, i suoi argomenti vengono calcolati come colore1 = rosso E colore2 = verde. L'archivio contiene uno schizzo completo utilizzando le funzioni (download: 272)
Pulsante
Lo schizzo successivo utilizzerà un pulsante con contatti normalmente aperti, senza blocco.
Ciò significa che mentre il pulsante non viene premuto, non scorre corrente attraverso di esso e, dopo essere stato rilasciato, il pulsante ritorna alla posizione posizione iniziale.
Oltre al pulsante, il circuito utilizza un resistore. IN in questo caso non limita la corrente, ma “tira” il pulsante a 0V (GND). Quelli. finché non verrà premuto il pulsante sul pin Arduino a cui è collegato, lo farà basso livello. La resistenza utilizzata nel circuito è di 10 kOhm.
//determina quando il pulsante viene premuto int buttonPin = 7; void setup())( pinMode(buttonPin, INPUT);//inizializza il pin sull'input Serial.begin(9600);//inizializza porta seriale) void loop())( if (digitalRead(buttonPin)==HIGH)(//se il pulsante è premuto Serial.println("premuto"); // print "premuto" ) else ( Serial.println("non premuto" ); // altrimenti "non premuto" ) )
Ci sono diversi nuovi comandi in questo schizzo.
-questo comando assume il valore Alto ( alto livello) e basso (livello basso), l'output che stiamo controllando. Questo output deve prima essere configurato come input in setup().
; //dove buttonPin è il numero pin a cui è collegato il pulsante.
La porta seriale consente all'Arduino di inviare messaggi al computer mentre il controller stesso esegue il programma. Ciò è utile per eseguire il debug di un programma, inviare messaggi ad altri dispositivi o applicazioni. Per abilitare il trasferimento dei dati tramite una porta seriale (chiamata anche UART o USART), è necessario inizializzarla in setup()
Serial.begin() ha un solo argomento: la velocità di trasferimento dei dati tra Arduino e il computer.
Lo schizzo utilizza un comando per visualizzare un messaggio sullo schermo nell'IDE di Arduino (Strumenti >> Monitor seriale).
- il design consente di controllare l'avanzamento dell'esecuzione del programma combinando diversi controlli in un unico posto.
Se digitalRead restituisce ALTO, sul monitor viene visualizzata la parola "premuto". Altrimenti (altrimenti) sul monitor viene visualizzata la parola “rilasciato”. Ora puoi provare ad accendere e spegnere il LED premendo un pulsante.
//rilevamento pressione pulsante con uscita LED int buttonPin = 7; int ledPin = 8; void setup())( pinMode(buttonPin, INPUT);//questa volta imposteremo il pin del pulsante come INPUT pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin )= =HIGH)( digitalWrite(ledPin,HIGH); Serial.println("premuto"); ) else ( digitalWrite(ledPin,LOW); Serial.println("non premuto"); ) )
Ingresso analogico.
analogicoLeggi consente di leggere i dati da uno dei pin analogici di Arduino e visualizza un valore nell'intervallo da 0 (0 V) a 1023 (5 V). Se la tensione sull'ingresso analogico è 2,5 V, verrà stampato 2,5 / 5 * 1023 = 512
analogicoLeggi ha un solo argomento: questo è il numero Ingresso analogico(A0-A5). Lo schizzo seguente mostra il codice per leggere la tensione dal potenziometro. Per fare ciò, connettiti resistore variabile, i pin più esterni vanno ai pin 5V e GND e il pin centrale va all'ingresso A0.
Esegui il seguente codice e guarda nel monitor seriale come cambiano i valori a seconda della rotazione della manopola del resistore.
//ingresso analogico int potPin = A0;//il pin centrale del potenziometro è collegato a questo pin void setup())( //il pin analogico è incluso come ingresso per impostazione predefinita, quindi non è necessaria l'inizializzazione Serial.begin(9600 ); ) void loop())( int potVal = analogRead(potPin);//potVal è un numero compreso tra 0 e 1023 Serial.println(potVal); )
Lo schizzo seguente combina lo schizzo del clic del pulsante e lo schizzo del controllo della luminosità del LED. Il LED si accenderà dal pulsante e la luminosità sarà controllata da un potenziometro.
//rilevamento pressione pulsante con uscita LED e intensità variabile int buttonPin = 7; int ledPin = 9; int potPin = A0; void setup())( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin)==HIGH)(//se il pulsante è premuto int analogVal = analogRead(potPin); int scaledVal = map(analogVal, 0, 1023, 0, 255); analogWrite(ledPin, scaledVal);//accendi led con intensità impostata dal pot Serial.println("pressed"); ) else ( digitalWrite(ledPin, LOW);//spegni se il pulsante non viene premuto Serial.println("non premuto"); ) )
