Apprendimento della programmazione di base di Arduino - Tutorial per i nuovi arrivati

In questo tutorial impariamo come eseguire la programmazione di base di Arduino attraverso codici di esempio e programmi di esempio. Questo tutorial può essere un corso estremamente prezioso per tutti i nuovi arrivati ​​che desiderano cogliere le basi attraverso un linguaggio semplice e comprensibile.

introduzione

Secondo wikipedia un microcontrollore è equivalente a un mini computer costruito all'interno di un singolo chip IC, dotato di un proprio core processor, ingressi programmabili, memoria e periferiche di output.

Un microcontrollore diventa così utile per un utente poiché offre un processore integrato, memoria e porte di input / output (chiamate anche GPIO o pin di input / output per scopi generali) che possono essere controllate dall'utente secondo le specifiche desiderate.

In questo tutorial lavoreremo con una scheda Arduino Uno per l'apprendimento e il test dei programmi. Per testare e integrare l'assemblaggio hardware useremo una breadboard.

Ora muoviamoci velocemente e impariamo come iniziare con una programmazione Arduino.

1.2 Installazione del software (Windows)

Per questo avrai bisogno dell'accesso a Internet, che ovviamente avresti sul tuo computer. Vai al seguente link e scarica il software IDE:

File ZIP di Windows per installazione non amministratore

Dopo il download troverai l'icona di configurazione di Arduino nella cartella di download, che sarà simile a questa:

Una volta ottenuto questo, puoi semplicemente fare doppio clic su di esso e installare Arduino the Integrated Development Environment (IDE) nel tuo computer. Il processo completo può essere visualizzato nel seguente video:

1.4 A partire dal nostro primo circuito

Prima di iniziare ad apprendere le tecniche di programmazione effettive, per qualsiasi principiante sarebbe utile iniziare con un componente di base come un LED e capire come collegarlo ad un Arduino.

Come sappiamo un LED è un diodo luminoso che ha una polarità e non si illumina se non è collegato ai giusti poli di alimentazione.

Un altro aspetto dei LED è che questi dispositivi funzionano a bassa corrente e possono danneggiarsi istantaneamente se un resistore calcolato in modo appropriato non viene incluso in serie con uno dei suoi pin.

Come regola generale, un 330 ohm 1/4 watt è l'ideale per ogni aumento di 5V nell'ingresso di alimentazione per limitare la corrente a un livello di sicurezza richiesto. Pertanto per 5 V potrebbe essere 330 ohm, per 10 V potrebbe essere 680 ohm e così via.

Utilizzo di breadboard per l'assemblaggio

Assicurati di sapere come usare un file breadboard prima di provare il tutorial spiegato in questo capitolo, poiché utilizzeremmo una breadboard per tutti gli esperimenti qui.

Di seguito è possibile vedere la configurazione della connessione LED di base:

Puoi vedere 3 componenti di base sopra:

1. Un LED da 5 mm, 20 mA
2. una resistenza da 330 ohm 1/4 watt
3. Un Scheda Arduino

Basta montare il sistema come da schema.

Quindi, collega il 5V dall'USB del computer ad Arduino. Non appena lo fai vedrai il LED accendersi.

So che è abbastanza semplice, ma è sempre bene iniziare da zero. Stai certo che le cose inizieranno a diventare sempre più interessanti man mano che andiamo avanti.

1.5 Controllo LED con Arduino

Ora impareremo come controllare un LED con un programma Arduino.

Per scrivere un programma dobbiamo avere almeno 2 funzioni in ogni programma.

Una funzione può essere intesa come una serie di istruzioni di programmazione a cui può essere assegnato un nome, come indicato di seguito:

1. impostare() questo viene richiamato o eseguito durante l'avvio del programma.
2. ciclo continuo() questo viene chiamato o eseguito ripetutamente durante l'intero periodo operativo di Arduino.

Pertanto, sebbene possa non avere funzionalità pratiche, tecnicamente un programma Arduino legittimo più breve può essere scritto come:

Programma più semplice

void setup()
{
}
void loop()
{
}

Potresti aver notato che in molti linguaggi di programmazione, il sistema inizia mostrando una semplice stampa, 'Hello, World' sullo schermo del display

L'equivalente elettronico di questa frase nell'interpretazione del microcontrollore è lampeggiare un LED ON e OFF.

Questo è il programma più basilare che si può scrivere e implementare per indicare un corretto funzionamento del sistema.

Cercheremo di implementare e comprendere la procedura attraverso la seguente parte di codice:

Listato 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

OK, ora capiamo cosa significa ogni riga del codice e come funziona per eseguire la funzione:

const int kPinLed = 13

Funziona come una costante che ci permette di utilizzarlo durante l'intero corso di programmazione, senza la necessità di utilizzare il valore effettivo che gli viene posto contro.

Secondo le regole standard tali costanti sono riconosciute con la lettera iniziale per . Sebbene questo non sia obbligatorio, rende le cose più chiare e facilmente comprensibili ogni volta che hai voglia di esaminare i dettagli del codice.

void setup()
{
pinMode(kPinLed, OUTPUT)
}

Questo codice configura il pin specifico a cui è collegato il nostro LED. In altre parole, il codice dice ad Arduino di controllare l'aspetto di 'scrittura' su questo pin, invece di 'leggerlo'.

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

Le righe sopra indicano l'effettiva esecuzione dell'applicazione. Il codice inizia scrivendo e restituendo un HIGH sulla relativa connessione LED, accendendo il LED.

Qui, il termine ALTO significa semplicemente ottenere + 5V sul pin interessato di Arduino. Il termine complementare LOW indica semplicemente uno zero o 0 V sul pin designato.

Successivamente, chiamiamo delay() la cui funzione è creare un ritardo di millisecondi (1/1000 di secondo). Poiché viene immessa la cifra 500, il ritardo implementato sarà di 1/2 secondo.

Non appena questo 1/2 secondo è trascorso, viene eseguita la riga successiva che spegne il LED con il termine LOW sullo stesso pin.

La riga successiva genera ancora una volta il ritardo di 1/2 secondo, in modo da consentire al LED di rimanere spento per 1/2 secondi.

E il processo continua all'infinito con l'esecuzione delle righe di codice, fintanto che Arduino viene mantenuto alimentato.

Prima di procedere al livello successivo, ti consiglio di programmare il codice sopra e di verificare se sei in grado di implementare correttamente o meno la sequenza LED ON / OF.

Poiché il LED predefinito in Arduino è collegato al pin # 13, dovrebbe rispondere immediatamente al programma sopra e iniziare a lampeggiare. Tuttavia, se trovi il tuo LED esterno non lampeggiante, potrebbe esserci un errore di connessione con il tuo LED, potresti provare a invertire la polarità del tuo LED e, si spera, vederlo lampeggiare anche lui.

È possibile giocare con il tempo di ritardo modificando la cifra '500' su un altro valore e trovare il LED che 'ascolta' i comandi e lo fa lampeggiare secondo i valori di ritardo specificati.

Ma ricorda, se vedi il LED non lampeggiare con una frequenza costante di 1 secondo, indipendentemente dalla modifica del tempo di ritardo, ciò potrebbe indicare che il codice non funziona a causa di un errore. Perché per impostazione predefinita Arduino sarà programmato con una frequenza di lampeggiamento di 1 secondo. Pertanto questa velocità deve essere variata dal codice per confermare il suo corretto funzionamento.

1.7 Commenti

Le righe di codici che abbiamo capito sopra sono state scritte specificamente per il software del computer.

Tuttavia, al fine di garantire che l'utente sia in grado di riferire il significato delle righe e di comprenderle, spesso può essere utile e sensato scrivere la spiegazione accanto alle righe di codici desiderate.

Questi sono chiamati Commenti che sono scritti solo per riferimento umano o dell'utente e sono codificati per consentire ai computer di ignorarli in modo sicuro.

La lingua di questi commenti è scritta con un paio di formati:

1. Lo stile di blocco del commento, in cui la descrizione del commento è racchiusa sotto il simbolo di inizio / * e il simbolo di fine * /
2. Questo non deve essere limitato a una riga, ma potrebbe essere esteso alle righe successive successive a seconda della lunghezza del commento o della descrizione, come mostrato nell'esempio seguente:

/ * Questo è un commento * /

/ * Quindi è questo * /

/* E
* Questo
* come
* bene */

Per scrivere una descrizione rapida di una riga per un commento, sono sufficienti due simboli di barra // all'inizio. Questo dice al computer che questa riga non ha nulla a che fare con il codice effettivo e deve essere ignorata. Per esempio:

// Questo è un commento che i computer ignoreranno.

Ecco un esempio di riferimento:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 Risoluzione dei problemi

Se trovi che il tuo programma mostra un 'errore' durante la compilazione, o qualche altro problema, i seguenti suggerimenti probabilmente ti aiuteranno a ricontrollare il tuo codice per eliminare l'ostacolo.

1. La lingua del programma farà distinzione tra maiuscole e minuscole. Ad esempio l'espressione myVar non può essere scritto come MyVar.
2. Tutti i tipi di spazi bianchi che possono essere eseguiti dalla digitazione della tastiera, alla fine vengono visualizzati come un unico spazio, ed è visibile o compreso solo da te, il computer non ne terrà conto. In parole povere, gli spazi liberi di qualsiasi tipo non avranno alcun effetto sui risultati del codice.
3. Ogni blocco di codice deve essere racchiuso tra parentesi graffe sinistra e destra, '{' e '}'
4. Le cifre dei numeri non devono essere separate da virgole. Ad esempio, 1000 non può essere scritto come 1.000.
5. Ogni riga di codice racchiusa tra le parentesi graffe deve terminare con un punto e virgola

Creazione di un'interessante sequenza di luci LED con Arduino

Nel nostro capitolo precedente abbiamo imparato come far lampeggiare un LED ON / OFF continuamente con un tasso di ritardo costante.

Ora impareremo come è possibile eseguire diversi modelli di ritardo sullo stesso LED aggiornando il codice del programma.

Non useremo un LED esterno, piuttosto useremo il LED predefinito integrato nella scheda Arduino al pin # 13. Puoi trovare questo piccolo LED SMD appena dietro il connettore USB.

2.2 Comprensione delle dichiarazioni IF

In questa sezione impareremo come le strutture di controllo ci consentono di eseguire codici individuali e, a volte, anche ripetutamente, come richiesto.

La dichiarazione Se diventa la prima struttura di controllo. La seguente implementazione mostra come viene utilizzato:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Cercheremo di comprendere passo passo il codice precedente e impareremo come può essere utilizzato per altre esecuzioni simili.

I codici tra la 1a e la 7a riga sono esattamente simili al nostro programma iniziale.

La prima modifica avviene effettivamente sull'ottava riga.

int delayTime = 1000

Puoi trovare che questo sia simile al codice sulla prima riga, a meno che non manchi il termine const.

Questo è semplicemente perché questo codice non è una costante. Invece questo è definito come un file variabile , che ha la proprietà di un valore variabile nel corso della programmazione.

Nell'esempio sopra puoi vedere che questa variabile è attribuita con un valore di 1000. Ricorda, tali variabili che sono racchiuse tra parentesi graffe devono essere scritte rigorosamente solo all'interno di coppie di parentesi graffe e sono indicate come variabili 'locali'.

In alternativa, le variabili che dovrebbero essere al di fuori delle parentesi graffe, come quella di cui stiamo discutendo ora, sono riconosciute come 'globali' e potrebbero essere eseguite praticamente ovunque all'interno del codice di un programma.

Andando avanti, puoi vedere che anche i codici tra le righe 9 e 11 sono simili al primo programma, tuttavia le cose iniziano a farsi interessanti dopo la riga 11. Vediamo come!

delayTime = delayTime - 100

In questo codice vediamo che il valore predefinito di ritardo viene modificato sottraendo 100 da esso.

Significa che 100 viene sottratto dal suo valore iniziale di 1000, fornendo un nuovo valore di 900.

Attraverso l'immagine seguente cercheremo di comprendere alcuni degli operatori matematici utilizzati nel linguaggio Arduino.

Ora valutiamo i codici tra le righe 13 e 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

L'obiettivo principale del codice di cui sopra è garantire che il LED continui a lampeggiare senza interruzioni.

A causa del fatto che 100 viene detratto dall'originale ritardo , impedisce che il lampeggio del led raggiunga lo zero e permette al lampeggio di continuare a lampeggiare continuamente.

L'immagine seguente mostra alcuni operatori di confronto che useremmo nei nostri codici:

Nel nostro codice sopra, avremmo potuto testare il codice in modo che fosse if(delayTime == 0).

Tuttavia, poiché essere una figura negativa può essere ugualmente negativo, non ci siamo impegnati e questa è una pratica consigliata.

Pensa quale sarebbe stato il risultato se avessimo tentato di detrarre 300 invece di 100 da delayTime?

Quindi ora potresti aver capito che se il delayTime viene scritto come minore o uguale a zero, quindi il tempo di ritardo verrebbe riportato alla cifra originale 1000.

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

Le ultime 4 righe del codice come mostrato sopra diventano responsabili dell'accensione / spegnimento del LED, ON / OFF continuamente.

Qui puoi chiaramente notare che invece di utilizzare un numero di cifre, abbiamo utilizzato una variabile per l'assegnazione del tempo di ritardo in modo da poterlo regolare come vogliamo durante il periodo operativo del codice. Va bene, vero?

2.3 Dichiarazioni ELSE

Qui impareremo perché e come un file Se termine può avere una clausola altro in modo che decida la situazione nel caso Se l'affermazione è falsa.

Mi dispiace se suona troppo confuso, non preoccuparti, proveremo a capirlo con il seguente esempio:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

In quanto sopra puoi vedere bene che nella decima riga il codice viene eseguito solo quando delayTime è minore o uguale a 100, in caso contrario viene eseguito il codice nella tredicesima riga, ma entrambi non possono mai verificarsi insieme, verrà implementato il codice della decima riga o della tredicesima riga, mai entrambi.

Avrai notato che a differenza di quanto abbiamo fatto nella nostra precedente sezione 2.2, qui non abbiamo confrontato con 0, ma piuttosto con 100. Questo perché in questo esempio confrontato PRIMA di aver sottratto 100, al contrario nella sezione 2.2, abbiamo confrontato DOPO noi sottratto. Puoi dire cosa sarebbe potuto accadere se avessimo confrontato 0 invece di 100?

2.4 WHILE dichiarazioni

PER mentre dichiarazione è abbastanza simile a Se dichiarazione, tranne la verità che causa l'esecuzione ripetuta di un blocco di codice (che può essere tra parentesi graffe) per così tanto tempo le condizioni sono applicabili, e questo funziona senza un altro dichiarazione.

Il seguente esempio ti aiuterà a capirlo meglio

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}

Riuscite a indovinare cosa è programmato per fare il codice sopra? Bene, è progettato per far lampeggiare il LED più velocemente e poi più lentamente.

2.5 Cosa è vero e falso?

Nel linguaggio di programmazione, falso si riferisce a zero (0). In realtà non si usa 'vero', invece si presume che quando nulla è falso, allora tutto ciò che è incluso è vero.

Sembra un po 'strano, tuttavia fa il lavoro abbastanza bene.

Cercheremo di cogliere la situazione attraverso il seguente esempio.

A volte potresti imbatterti in un codice come indicato di seguito:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

Questo è codificato sembra che l'esecuzione del LED continuerà a funzionare per sempre, finché è disponibile l'alimentazione.

Tuttavia, uno svantaggio di questo tipo di codice potrebbe sorgere quando accidentalmente l'utente applica un = invece di ==.

Sono sicuro che sai già che = indica un'assegnazione, il che significa che viene utilizzato per designare un valore selezionato a una variabile, mentre a == viene utilizzato per imporre un test se il valore era lo stesso.

Ad esempio, supponi di aver richiesto che un LED lampeggi con uno schema di accelerazione sequenziale e ripetutamente, ma hai usato in modo errato un = invece di ==.

Il codice apparirà quindi come questo:

int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}

L'errore assegnerà 0 a delayTime e porterà a Se istruzione per verificare se 0 era vero o no. Poiché 0 si riferisce a falso, penserà che non sia vero e interromperà l'applicazione di delayTime = 1000, ma invece la funzione delayTime è tenuto a 0 durante il corso del ciclo ().

Questo sembra molto indesiderabile !!

Quindi, ricontrolla sempre il tuo programma per assicurarti di non aver commesso errori così stupidi.

2.6 Combinazioni

A volte potresti sentire il bisogno di testare più cose insieme. Ad esempio, potresti voler esaminare se una variabile era compresa tra due numeri. Sebbene ciò possa essere implementato utilizzando l'istruzione if più volte, può essere più conveniente utilizzare combinazioni logiche per una lettura migliore e più facile.

L'implementazione di combinazioni su termini logici può essere eseguita con 3 metodi, come mostrato nella tabella seguente:

Sarebbe interessante sapere che l'operatore NOT può funzionare come un commutatore per una variabile che può essere designata per essere l'una o l'altra vero o falso (o BASSO o ALTO).

L'esempio seguente illustra la condizione:

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

Qui il ledState sarà BASSO, e successivamente non appena ledState = !ledState, diventerà ALTO. Il ciclo seguente causerà ledState essere ALTO quando ledState = !ledState è basso.

2.7 Dichiarazioni FOR

Ora proveremo a capire un'altra struttura di controllo che è un file per ciclo continuo. Questo può essere molto utile quando desideri implementare qualcosa più volte.

Comprendiamolo con il seguente esempio:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

Puoi trovare qualcosa di unico nella linea con per.

È il codice i ++? . Ciò è utile per i programmatori che sono piuttosto pigri e desiderano implementare la codifica tramite comode scorciatoie

Il termine precedente è noto come operatori composti, poiché svolgono il compito di combinare un operatore di assegnazione con un altro operatore di assegnazione. I più popolari di questi possono essere visualizzati nella seguente tabella:

Scoprirai che ci sono 3 sotto-istruzioni in un'istruzione for. È strutturato come mostrato di seguito:

for (statement1conditionstatement2){
// statements
}

L'affermazione n. 1 compare all'inizio e solo una volta. La condizione viene verificata ogni volta nel corso del ciclo. Ogni volta che lo è vero all'interno delle parentesi graffe, viene applicata l'istruzione successiva n. 2. In caso di un file falso, il sistema passa al blocco di codice successivo.

Collegamento di più LED

OK, ora vedremo come possiamo collegare un numero maggiore di LEd per ottenere effetti più interessanti.

Si prega di collegare i LED e Arduino come mostrato di seguito. Il filo rosso in realtà non è necessario, ma poiché è sempre una buona idea avere entrambi i binari di alimentazione inclusi nella breadboard, la configurazione ha senso.

Ora sistemiamo un programma che ci permetterà di verificare se il nostro hardware è configurato correttamente o meno.

Si consiglia sempre di codificare ed eseguire piccoli bit di programmi passo passo per verificare se i rispettivi hardware sono cablati correttamente o meno.

Questo aiuta a risolvere rapidamente un possibile errore.

L'esempio di codice seguente fornisce ai LED da 2 a 5 uno schema specifico ruotandoli uno dopo l'altro in modo ciclico.

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

Come puoi notare, non c'è niente di sbagliato nel codice, tranne il fatto che sembra lungo e quindi soggetto a errori.

Ovviamente ci sono modi migliori per scrivere il codice sopra, la sezione seguente lo rivelerà.

2.9 Introduzione agli array

Gli array possono essere un gruppo di variabili che possono essere indicizzate con numeri di indice. Il seguente esempio ci aiuterà a capirlo meglio.

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

OK, ora esaminiamo ogni sezione e capiamo come funzionano effettivamente.

const int k_numLEDs = 4

Il codice precedente definisce quanti elementi massimi dovremmo avere nell'array. Questo codice ci aiuta nelle sezioni successive a garantire che tutto sia scritto all'interno di un array e nulla una volta terminato l'array.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

In questa riga successiva impostiamo la struttura dell'array. I numeri all'interno della parentesi indicano il numero di elementi nella matrice. Anche se la quantità effettiva avrebbe potuto essere scritta, scrivere come costanti funziona meglio. I valori possono essere normalmente visualizzati all'interno della parentesi con virgole e designare i valori all'array.

Quando trovi un array indicizzato con il numero 0, questo indica il primo elemento dell'array, come mostrato in code: k_LEDPins is k_LEDPins[0].

Allo stesso modo l'ultimo elemento verrà mostrato come k_LEDPins[3], poiché il conteggio da 0 a 3 è 4.

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

Il codice precedente mostra l'uso del ciclo per procedere attraverso ogni elemento dell'array e per impostarli come OUTPUT. Implementiamo parentesi quadre insieme all'indice per raggiungere ciascuno degli elementi nell'array.

se ti stai chiedendo se è possibile utilizzare il pin # 2 al pin # 5 senza array, la risposta è sì, è possibile. Ma in questo esempio non è stato fatto perché non l'abbiamo fatto in quel modo. Nelle sezioni seguenti è possibile eliminare l'approccio array se i pin di uscita selezionati non sono in linea.

Andando avanti, vediamo cosa fa il prossimo blocco di codice:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

Qui il codice procede attraverso ciascuno dei LED per accenderli in sequenza con un intervallo o un ritardo di 100 millisecondi.

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

L'utilizzo del codice precedente mostra come l'applicazione di per loop potrebbe essere utilizzato per spostarsi attraverso il ciclo anche nell'ordine inverso.

Inizia da k_numLEDs - 1 perché gli array sono indicizzati a zero. Non partiamo da k_LEDPins[4] perché ciò comporterebbe l'attraversamento della fine della matrice.

Il codice utilizza> = 0 per controllare in modo che il primo elemento all'indice 0 non venga perso o ignorato.

capitolo 3

Cos'è un input

Quindi abbiamo imparato a far funzionare le cose usando Arduino. In questo capitolo discuteremo come percepire il mondo reale interfacciando input da parametri esterni.

3.1 Utilizzo dei pulsanti

Sappiamo tutti cos'è un pulsante e come funziona. È una sorta di interruttore o pulsante che collega momentaneamente un segnale da uno stadio del circuito a un altro mentre è nella condizione depressa e interrompe il segnale quando viene rilasciato.

3.1.1 Un pulsante e un LED

Collegheremo Arduino con un pulsante con Arduino come da dettagli mostrati sopra e impareremo il funzionamento di base e l'implementazione della configurazione.

Il pulsante indicato, chiamato anche pulsante microinterruttore, ha 4 pin in totale (2 coppie su ciascun lato). Quando viene premuto, ogni coppia di pin viene collegata internamente e consente una connessione o una conduzione attraverso di essi.

In questo esempio stiamo usando solo una coppia di questi pin o contatti, l'altra coppia è irrilevante e quindi viene ignorata.

Procediamo applicando il seguente codice e verificiamo che funzioni!

const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Potresti trovare alcune cose che sembrano insolite qui. Scopriamoli passo passo.

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

La prima cosa che facciamo è aggiustare il file buttonPin come il INGRESSO. Beh, è ​​abbastanza semplice, lo so.

Successivamente, assegniamo ALTA al INGRESSO pin. Ti chiedi, come è possibile scrivere qualcosa all'ingresso? Certo, potrebbe essere interessante.

In realtà, l'assegnazione di un ALTO a un ingresso Arduino attiva o disattiva una resistenza di pull-up interna da 20k Ohm (un BASSO su questo pin lo disattiva).

Un'altra domanda che potresti fare è che cos'è un resistore di pull-up. Ho coperto un post completo sui resistori pull-up che tu imparalo qui .

OK, andando avanti, ora diamo un'occhiata al codice del ciclo principale:

void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Quando si preme il pulsante, il pin cablato viene collegato a terra, il che rende un file BASSO a quel perno. E mentre nella condizione non pressata viene tenuto lo stesso perno ALTA o + 5V tramite la resistenza di pull-up interna da 20K.

Qui vogliamo che Arduino accenda il LED quando viene premuto il pulsante (LOW), quindi scriviamo HIGH per l'uscita per ogni risposta di un LOW dal pulsante, mentre è premuto.

3.1.2 Due pulsanti e un LED

Bene, potresti chiederti che l'azione sopra mostrata avrebbe potuto essere eseguita anche senza un Arduino. Capisco, tuttavia, questa è una pietra miliare per imparare come usare il pulsante con Arduno.

Fino a questo punto, abbiamo studiato la scrittura dei codici per accendere (HIGH) o spegnere (LOW) un LED.

Ora vediamo come è possibile controllare la luminosità del LED con un Arduino.

Può essere fatto utilizzando due metodi:

1. Limitando la quantità di corrente al LED
2. Usando PWM o la modulazione di larghezza di impulso, in cui l'alimentazione al LED viene attivata / disattivata ad una velocità desiderata molto rapidamente, producendo un'illuminazione media la cui intensità dipenderebbe dal PWM.

In una scheda Arduino il supporto PWM è disponibile sui pin contrassegnati da una tilde (~), che sono i pin 3, 4,5,9,10 e 11) a 500Hz (500 volte al secondo). L'utente è in grado di fornire qualsiasi valore compreso tra 0 e 255, dove 0 si riferisce a nessun ALTO o nessun + 5V, e 255 dice ad Arduino di ottenere un ALTO o + 5V tutto il tempo. Per avviare questi comandi dovrai accedere ad analogWrite () con il valore desiderato.

Si può presumere che PWM sia x / 255 dove x è il valore desiderato che si desidera inviare tramite analogWrite().

Imposta Arduino e altri parametri come mostrato sopra.

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

Potresti trovare 3 righe qui che richiedono qualche spiegazione.

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

La linea: ledBrightness = constrain(ledBrightness, 0, 255) illustra una funzione unica all'interno di Arduino nota come constrain ().

Questa funzione interna comprende un codice simile al seguente:

vincolo int (valore int, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Tutti i codici discussi prima di questo sono iniziati con vuoto , il che significava non restituire nulla (void). Mentre il codice precedente inizia con int , che indica che restituisce un numero intero. Ne discuteremo di più nelle sezioni successive, al momento ricorda solo che un intero non ha parti frazionarie.

Giusto, quindi questo implica, il codice: ledBrightness = constrain(ledBrightness, 0, 255) assegna il ledBrightness to be within the range of 0 and 255.

La riga successiva utilizza analogWrite per comandare ad Arduino di applicare PWM sul pin selezionato con il valore desiderato.

La riga successiva crea un ritardo di 20 millisecondi, questo per garantire che non regoliamo il consumo più velocemente di 50 Hz o 50 volte al secondo. Questo perché gli esseri umani possono essere molto più lenti di un Arduino. Quindi se il ritardo non viene effettuato il programma potrebbe farci sentire che premendo il primo pulsante si spegne il led e premendo il secondo pulsante lo si accende (provate voi stessi per confermare).

3.2 Potenziometri

Andiamo avanti e impariamo come usare potenziometri con Arduino.

Per sapere come funzionano un potenziometro o una pentola, puoi leggere questo articolo .

Collega i parametri mostrati con il tuo Arduino come mostrato sopra.

Una pentola avrà 3 terminali. Il terminale centrale si collegherà con ANALOG IN 0 su Arduino. Gli altri due terminali esterni possono essere collegati alle linee di alimentazione + 5V e 0V.

Programmiamo e controlliamo i risultati:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

Troverai un paio di cose che potrebbero sembrare completamente nuove e non incluse in nessuno dei nostri codici precedenti.

1. La costante kPinPot è assegnato come A0, dove A è la scorciatoia per descrivere uno dei pin analogici. Tuttavia A0 si riferisce anche al pin # 14, A1 al pin # 15 e così via, e questi consentono di essere utilizzati come ingressi / uscite digitali nel caso in cui si esauriscano i pin per un esperimento. Ma ricorda che non puoi usare pin digitali come pin analogici.
2. La linea: ledBrightness = map(sensorValue, 0, 1023, 0, 255) presenta una nuova funzione interna in Arduino nota come carta geografica(). Questa funzione si ricalibra da un determinato intervallo a un altro, denominato map (valore, fromLow, fromHigh, toLow, toHigh). Questo può diventare cruciale poiché analogueRead restituisce un valore compreso nell'intervallo 0-1023, ma analogWrite è in grado di accettare un valore compreso tra 0 e 255.

Potreste pensare, che essendo possibile controllare la luminosità di un LED tramite una resistenza variabile, semplicemente un potenziometro poteva essere sufficiente allo scopo, motivo per cui è stato utilizzato Arduino. Ebbene, ancora una volta è solo il fondamento, per mostrare come un vaso potrebbe essere configurato con un Arduino.

Nessun problema, ora faremo qualcosa che non può essere fatto senza un Arduino.

In questo esperimento vedremo come la resistenza variabile di un vaso potrebbe essere utilizzata per controllare la velocità di lampeggiamento o la velocità di un LED.

Ecco il programma:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

3.2.3 Evitare ritardi ()

Il codice sopra sembra buono, ma il LED non è in grado di controllare il valore del piatto fino a quando non esegue ogni ciclo completo. Per ritardi più lunghi questo processo diventa più lungo l'utente deve attendere per vedere la risposta del piatto mentre lo sposta. Questo ritardo può essere evitato con una programmazione intelligente, in modo che consenta all'utente di controllare il valore senza ritardi minimi. Ecco il codice.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

Allora cosa c'è di diverso nel codice sopra? È la riga seguente che fa la differenza.

long lastTime = 0

Fino a questa sezione, abbiamo discusso della variabile int. Tuttavia, potrebbero esserci molti più tipi di variabili a cui puoi accedere. L'elenco può essere letto di seguito:

Al momento, potrebbe essere fondamentale sapere che per memorizzare numeri relativamente grandi per int variabile, potresti usare il termine lungo o a lungo int.

Qui puoi vedere un'altra interessante funzione chiamata millis ().

Questo produce l'intervallo di tempo in millisecondi in cui Arduino ha lavorato dall'inizio (questo verrà ripristinato a 0 dopo ogni 50 giorni). Qui ritorna un lungo perché se è tornato int , il conteggio per lunghi periodi potrebbe non essere possibile. Potresti rispondere esattamente per quanto tempo? La risposta è 32,767 secondi.

Quindi invece di usare delay (), controlliamo millis (), e non appena il numero particolare di millisecondi scade cambiamo il LED. Di conseguenza memorizziamo l'ora in cui l'abbiamo modificata l'ultima volta ultima volta variabile, in modo che ci consenta di ricontrollarlo quando lo si desidera.

3.3 LED RGB

Finora abbiamo giocato con un LED a un colore. Anche se il colore del LED potrebbe essere cambiato sostituendo il LED con un altro colore, ma che ne dici di usare i LED RGB per cambiare i colori dei LED senza cambiare i LED?

Un LED RGB è fondamentalmente un LED con un LED rosso, verde e blu incorporato e fuso in un unico LED. Ha un cavo comune che va a terra o alla linea di alimentazione 0V mentre gli altri 3 cavi sono alimentati con segnali positivi PWM diversificati per implementare il previsto miscelazione dei colori .

È possibile cablare la configurazione come mostrato di seguito:

Può sembrare un po 'complesso, ma in realtà è una replica del nostro precedente progetto di controllo LED che utilizza PWM.

Ecco un codice del programma di pratica:

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

Dopo aver caricato questo codice, guarda come le regolazioni del potenziometro creano un interessante effetto di luce sull'RGB, può essere un vero divertimento.

Scoprirai che quando tutti e 3 i vasi vengono spostati al massimo delle posizioni, invece di un colore bianco vedrai il rosso. Questo perché il colore rosso è il più prominente tra i 3 colori e quindi domina in questa situazione. Tuttavia puoi sperimentare con la funzione carta geografica() , prima di eseguirlo sulla porzione rossa del LED, in modo da creare un equilibrio più sensibile.

Audio con Arduino

In questa sezione impareremo come aggiungere suoni e musica di base a una configurazione Arduino.

Vedremo come passare un segnale a un altoparlante collegato con una frequenza desiderata.

Per essere più precisi, verrà provata una nota LA centrale, che è una nota con frequenza di 440 Hz.

Per fare ciò suoneremo semplicemente una nota LA centrale e ottimizzeremo il segnale dell'onda sinusoidale con l'onda quadra.

Inoltre, calcoleremo la quantità di tempo in cui un altoparlante può rimanere acceso citando la formula:

timeDelay = 1 secondo / 2 x toneFrequency.

timeDelay = 1 secondo / 2 x 440

timeDelay = 1136 microsecondi

4.1 Colleghiamo la scheda Arduino

4.2 Aggiunta di una nota semplice

Abbiamo già discusso della funzione ritardo() dove l'unità è in millisecondi (secondi / 1000), tuttavia troverai ancora un'altra funzione delayMicroseconds() dove l'unità è in microsecondi, (millisecondi / 1000).

Per la configurazione attuale programmiamo un codice per accendere / spegnere + 5V sul pin selezionato collegato all'altoparlante, alla velocità di 440 impulsi al secondo.

Ricordiamo, nell'ultima discussione abbiamo determinato il valore 1136 microsecondo per la nota audio prevista.

Quindi ecco il programma per questo, che ti permetterà di ascoltare una nota audio di 440 Hz non appena programmerai l'arduino con un altoparlante collegato.

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

Con l'applicazione di cui sopra è possibile creare una nota audio, il che significa anche che possiamo creare una musica secondo la nostra scelta.

Dal codice si capisce che Arduino include un paio di funzioni integrate che contribuiscono ulteriormente alla creazione di musica.

Il primo è tono() che funziona con 2 elementi insieme a un terzo elemento opzionale, designato come tono (pin, frequenza, durata). o tono (pin, frequenza)

Entrambi sono designati per eseguire il rispettivo periodo di tempo assegnato dall'utente.

In assenza di un periodo di tempo, la musica continuerà a suonare fino alla chiamata tono() viene eseguito di nuovo o fino a quando non viene eseguito non uno ().

Questo dovrà essere fatto utilizzando una funzione di ritardo nel caso in cui la riproduzione della musica sia l'unica cosa fondamentale che stai implementando.

La durata del tempo può essere cruciale poiché consente di fornire un tempo per quanto tempo viene riprodotta la musica, quindi puoi liberarti di fare altre cose. Non appena la durata scade, la musica si interrompe.

La prossima funzione non uno () gestisce un singolo parametro e arresta il tono selezionato su un particolare pin assegnato.

Un avvertimento particolare: in qualsiasi momento quando tono() è stata implementata, la funzione PWM sui pin 3 e 11 smetterà di funzionare.

Pertanto, ogni volta che nel programma viene utilizzato un attacco per altoparlante, assicurarsi di non utilizzare il perno menzionato per gli altoparlanti, ma provare altri piedini per l'attacco dell'altoparlante.

OK, ecco il programma per implementare la musica su un altoparlante, sebbene non sia una vera musica, piuttosto una nota di Do in scala di base.

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}

Nel codice sopra potresti aver notato qualcosa di nuovo e questo è #definire .

Questo termine funziona come un comando di ricerca e sostituzione per il computer durante la compilazione.

Ogni volta che trova la prima cosa prima di uno spazio, la sostituisce con la parte rimanente della riga (chiamata macro).

Quindi in questo esempio quando il computer vede NOTE_E4 lo sostituisce velocemente con la quantità 330.

Per ulteriori note e personalizzazioni puoi fare riferimento a un file nella tua chiavetta USB denominato piazzole.h , dove è possibile trovare la maggior parte delle frequenze in base alle proprie preferenze.

4.4 Musica con funzioni

Il codice sopra sembra buono, ma sembra avere molte ripetizioni, dovrebbe esserci un metodo per abbreviare queste ripetizioni, giusto?

Finora abbiamo lavorato con due funzioni essenziali incluse con Arduino. Ora potrebbe essere il momento di creare le nostre funzioni.

Ogni funzione deve iniziare con il tipo di variabile a cui può essere associata. Ad esempio la funzione vuoto si riferisce al tipo che non restituisce nulla, da cui il nome void. Nota, abbiamo già discusso un elenco di variabili nelle nostre sezioni precedenti, potresti fare riferimento a quelle.

Di conseguenza, il nome della funzione particolare ottiene una parentesi aperta '(' seguito da un elenco di parametri separati da virgole.

Ciascun parametro acquisisce il suo tipo insieme a un nome e infine una chiusura ')' parentesi.

Questi parametri possono essere applicati all'interno della funzione sotto forma di variabili.

Vediamo un esempio di seguito in cui sviluppiamo una funzione chiamata ourTone () progettato per unire il tono() con ritardo() linee, in modo che la funzione smetta di tornare finché la nota non ha finito di suonare il tono.

Implementiamo queste funzioni nel nostro codice precedente e otteniamo il programma seguente, vedi le ultime righe:

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Le funzioni possono essere estremamente utili per rendere un programma più facile da capire.

Quello che segue è un esempio in cui siamo in grado di specificare la scelta del tono che vogliamo suonare usando due array. Un array per conservare le note, l'altro per conservare i battiti.

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Puoi vedere chiaramente sulla prima riga l'introduzione di #includere dichiarazione. Il compito di questa istruzione è quello di prendere l'intero file tra le virgolette e metterlo nella posizione del file #includere dichiarazione. Secondo le regole standard, queste sono rigorosamente poste all'inizio del programma.

Capitolo 5

Misurazione della temperatura

Solo per ricordare, ricordare invece di scrivere programmi di grandi dimensioni del tutto, è sempre saggio scrivere e analizzare piccole parti di codici, il che aiuta a rintracciare rapidamente gli errori.

5.1 Monitor seriale

Fino ad ora, i codici di cui abbiamo discusso non sembrano così facili da consentire una rapida risoluzione dei problemi. Qui proveremo a rendere le cose più facili per il monitoraggio e la risoluzione più facile di un possibile problema.

Arduino ha una funzione che gli consente di 'rispondere' al computer. Si può notare che pin0 e pin1 sono contrassegnati come RX e TX uno accanto all'altro. Questi pin sono effettivamente tracciati da un IC separato all'interno di Arduino che li aggiorna per leggere attraverso il cavo USB mentre è collegato al PC.

La sezione seguente mostra un programma completo, per favore leggilo, impareremo in seguito le nuove voci nel codice. Questo codice è lo stesso della sezione 2.2, tranne per il fatto che include alcuni dati extra per permetterci di identificare per cosa è stato codificato.

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Puoi identificare due nuove cose qui, una nuova riga nel file impostare() funzione.

Serial.begin(9600)

Questa linea esprime semplicemente la necessità di utilizzare il Seriale 1 codice per applicarlo con 9600 baud. (qui seriale si riferisce a bit inviati uno dopo l'altro e baud indica la velocità con cui viene inviato). Questo valore di baud e quello all'interno del monitor seriale (lo impareremo più avanti) devono essere uguali, altrimenti i dati nel monitor seriale mostreranno spazzatura. 9600 essendo lo standard diventa più comodo da usare.

Le seconde new entry sono le seguenti

Serial.print('delayTime = ')
Serial.println(delayTime)

Qui la seconda riga suggerisce che la cosa successiva che esce dalla porta seriale inizierà sulla riga successiva. Ecco come la seconda riga è diversa dalla prima riga.

Un'altra cosa che puoi vedere sono le virgolette ('). Questa è nota come stringa, che qui verrà utilizzata solo come costanti, perché un'ulteriore discussione su questo argomento può essere troppo elaborata e oltre lo scopo.

OK, ora possiamo caricare il codice sopra in Arduino e vedere cosa succede.

Cosa, oops sembra che non sia successo nulla, il LED del pin 13 di Arduino ha lampeggiato e si è fermato, mentre il LED Tx è rimasto lampeggiante.

Bene, questo perché la finestra di Serial Monitor non è ancora stata risolta.

Devi fare clic sulla casella Serial Monitor nel tuo IDE come mostrato sopra. Non dimenticare di controllare la velocità di trasmissione che si trova in basso a destra, per impostazione predefinita dovrebbe essere 9600 e corrisponderà al codice. In caso contrario, assicurati di selezionare 9600.

Il seguente video clip spiega come è fatto.

Ora andiamo avanti e impariamo come la funzione di monitoraggio seriale sopra può aiutare per l'elaborazione del file misurazione della temperatura utilizzando Arduino

Useremo l'IC TMP36 come sensore di temperatura, con un intervallo da -40 a 150 gradi Celsius.

La configurazione può essere vista di seguito:

Il codice seguente avvierà la misurazione della temperatura leggendo l'uscita dal sensore TMP36 e inviandola al monitor seriale dell'ID.

const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Comprendiamo il codice dall'alto.

float temperatureC = getTemperatureC()

Qui puoi vedere che abbiamo incluso il tipo di variabile galleggiante.

Questo è l'unico tipo di variabile che consente di memorizzare tutto tranne i numeri interi (numeri senza parti decimali o frazionarie).

La precisione da una variabile float può essere fino a 6 a 7 cifre.

Il codice adiacente getTemperatureC() è la nostra funzione che calcola e converte matematicamente la differenza di tensione rilevata dal sensore TMP36 in gradi Celsius.

float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

Nella sezione successiva dei codici, poiché il termine analogIn() è assegnato a restituire una cifra compresa tra 1 e 1023, diventa possibile per noi valutare la tensione dal sensore moltiplicando la nostra lettura per 5 e poi dividendola per 1024.

Il sensore TMP36 è specificato per generare 0,5 V a 0 gradi Celsius e successivamente genera 10 mV per ogni singolo aumento di gradi Celsius.

Ecco l'approssimazione che siamo in grado di generare attraverso i calcoli:

Puoi considerare di essere la tua prima funzione che restituisce un valore (nota che tutte le funzioni rimanenti fino ad ora non hanno restituito alcun valore poiché erano del tipo vuoto ).

Puoi capire che per ottenere un valore da una funzione, devi semplicemente aggiungere ritorno seguito dal numero desiderato che si desidera restituire.

Quando diciamo ritorno significa che la funzione restituisce una risposta o una risposta ogni volta che viene chiamata, che potrebbe essere applicata a una variabile.

Quando viene inviato al monitor seriale, la lettura viene convertita in Fahrenheit convertToF ().

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Questa funzione rileva l'intervallo Celsius e lo converte in Fahrenheit.

Per convertire Fahrenheit in Celsius implementiamo la formula Fahrenheit = 9 / 5 (gradi Celsius) + 32.

5.3 Interfacciamento di un LCD

Ora studiamo come interfacciare o collegare un file display LCD con Arduino per ottenere la visualizzazione visiva degli output richiesti.

Nella nostra applicazione utilizzeremo un LCD grafico 84x48, con una risoluzione orizzontale di 84 pixel o punti e una risoluzione verticale di 48 pixel. Poiché un controller dedicato diventa imperativo per tutti gli LCD, il presente dispositivo ne incorpora anche uno sotto forma di controller PCD8544.

In questo tutorial collegheremo il modulo LCD sopra specificato con Arduino e applicheremo determinate routine per creare messaggi di testo sul display.

Nella figura seguente è possibile trovare i dettagli riguardanti l'interfacciamento del display LCD, insieme a un piccolo Regolatore di tensione 3,3 V. . Questo regolatore è necessario poiché il display LCD è specificato per funzionare con un'alimentazione a 3,3 V.

Puoi anche vedere 8 pinout dal modulo LCD, le specifiche di pinout possono essere studiate dalla seguente tabella:

Vediamo ora come possiamo collegare il display LCD ed i relativi parametri con il nostro Arduino. I dettagli possono essere visualizzati nell'illustrazione sotto riportata:

5.4 Comunicazione al display LCD

Sebbene sia possibile scrivere elaborati coeds per interagire con LCD da Arduino, impareremo piuttosto come fare lo stesso usando le librerie.

Le librerie comprendono un assortimento di codici che possono essere applicati rapidamente per un programma Arduino selezionato.

Ciò consente all'utente di chiamare una funzione senza sforzo senza dover eseguire complesse operazioni di codifica.

5.4.1 Come installare la libreria

Per questo dovrai creare una directory chiamata librerie nel tuo computer Arduino IDE, come spiegato Qui

5.4.2 Implementazione delle operazioni LCD

Proprio come il nostro approccio precedente, prima verificheremo l'intero codice e poi proveremo a comprendere i dettagli delle singole righe.

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

La riga include il codice #include

Il codice #include indica al PC di prelevare il file citato e sostituire l'elemento #include con il contenuto del file durante la compilazione del programma.

L'elemento #include può contenere parentesi angolari che indicano la ricerca nella directory della libreria, in alternativa può anche contenere virgolette che indicano la ricerca all'interno della stessa directory in cui si trova il programma.

Le successive righe di codice esprimono i pinout dell'LCD, quindi scriviamo una nuova forma di variabile:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Qui stiamo esprimendo una variabile con il nome lcd avente il tipo PCD8544 e istruendo il PC a riclassificare i suoi pinout associati ad Arduino.

In questo processo descriviamo la variabile al PC istruendo come i pin clk, din, dc e reset sono interfacciati con Arduino.

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

La linea lcd.init() inizializza l'operazione LCD. Una volta eseguito, la riga successiva impone un cursore nella parte superiore sinistra del display. E la riga successiva successiva si sforza di stampare il messaggio 'Hello, World'.

Questo sembra abbastanza identico alla tecnica in cui abbiamo inviato i messaggi sul monitor seriale. L'unica differenza è l'uso del codice lcd.print invece di serial.print.

Il blocco di codice successivo viene effettivamente chiamato ripetutamente.

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Utilizzando questa riga lcd.setCursor(0,1) fissiamo il cursore sulla 0a colonna all'estrema sinistra della 1a riga, sopra il display LCD.

La riga successiva utilizza una scorciatoia: lcd.print(millis())

Se ricordi, abbiamo lavorato con millis() nei nostri codici precedenti, avremmo potuto applicare lo stesso anche qui attraverso i codici:

long numMillis = millis()
lcd.print(numMillis)

Tuttavia a causa del fatto che qui non sono coinvolti periodi di tempo in millisecondi, quindi lo realizziamo semplicemente inviando millis() funzione direttamente in lcd.print() .

5.5 Combinare l'intera cosa

OK, ora combiniamo tutti i codici che abbiamo appreso sopra per realizzare il circuito della temperatura LCD e vediamo come appare:

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Tutto sembra standard nel programma di cui sopra, tranne l'uso della funzione setCursor () . Questo viene utilizzato per allineare il testo il più possibile attorno al centro del display.

Grande! E complimenti, hai appena programmato il tuo piccolo indicatore di temperatura LCD usando Arduino.

Applicazioni pratiche per Arduino

Poiché, a questo punto, abbiamo trattato in modo esauriente e dettagliato le varie tecniche di programmazione, è tempo di esaminarle applicandole per alcune utili implementazioni pratiche.

Inizieremo con i sensori e vedremo come i dispositivi dei sensori potrebbero essere utilizzati con Arduino eseguendo alcuni codici di esempio.

7.1 Introduzione ai sensori

In questo tutorial impareremo l'ampia varietà di sensori che potrebbero essere utilizzati con Arduino. Questi possono includere dispositivi come sensore di luce LDR, sensore di effetto hall magnetico, sensori di inclinazione, sensore di vibrazione, sensore di pressione ecc.

Inizieremo con l'interfacciamento di sensore di luce LDR con Arduino, come mostrato nel diagramma seguente:

Come tutti sappiamo, LDR è un dispositivo resistivo dipendente dalla luce la cui resistenza dipende dall'intensità dell'incidente ambientale sulla sua superficie.

L'intensità della luce è inversamente proporzionale alla lettura della resistenza dell'LDR.

Qui impareremo come questa proprietà può essere integrata con Arduino per eseguire un'applicazione utile:

Il codice completo del programma può essere visualizzato come di seguito:

const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}

Tutti i parametri utilizzati nel codice sono già stati discussi nel corso che abbiamo appreso finora. È possibile verificare le righe facendo riferimento alle relative sezioni.

I valori sono stati scelti in modo casuale, puoi facilmente modificare secondo le tue preferenze.

Sensore di inclinazione

Un sensore di inclinazione è un semplice dispositivo che può essere utilizzato per rilevare un'azione di inclinazione su qualsiasi oggetto in cui è installato. Il dispositivo ha fondamentalmente una sfera metallica all'interno, che inclinandosi rotola su una coppia di contatti provocando una conduzione attraverso tali contatti. Questi contatti essendo terminati come i conduttori dell'interruttore di inclinazione, vengono utilizzati con un circuito esterno per rilevare la conduzione dovuta ad un'azione di inclinazione e attivare l'applicazione di uscita desiderata.

Ora vediamo come a sensore di inclinazione il dispositivo potrebbe essere cablato. L'immagine sotto ci dà un'idea della configurazione completa:

const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}

In questo esempio, il LED pin # 13 predefinito viene utilizzato come indicatore di inclinazione.

Puoi vedere chiaramente l'inclusione del resistore di pull-up qui, abbastanza simile a quello che abbiamo fatto nella sezione 3.1. Pertanto il termine LOW indica che la funzione di inclinazione non è attivata.

7.4 Relè interruttore reed (relè attivato con magnete miniaturizzato)

Vediamo ora come collegare un interruttore a relè o un sensore di campo magnetico con Arduino. Un relè reed è una sorta di interruttore che si attiva o conduce quando un campo magnetico o un magnete viene avvicinato ad esso. Fondamentalmente ha una coppia di contatti ferromagnetici all'interno di un involucro di vetro miniaturizzato che si uniscono o fanno contatto a causa della trazione magnetica ogni volta che un magnetico è in prossimità di esso. Quando ciò accade i terminali dei contatti mostrano conduzione dovuta alla chiusura dei contatti.

Anche qui utilizziamo il LED del pin # 13 per indicare la risposta. È possibile collegare un LED esterno da questo pin se necessario secondo le nostre spiegazioni precedenti.

const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

I termini del codice dovrebbero essere familiari e autoesplicativi.

7.5 Sensore di vibrazioni con trasduttore piezoelettrico

Nel prossimo programma di esempio vedremo come un file trasduttore piezo può essere utilizzato come sensore di vibrazione per illuminare un LED tramite Arduino.

Un elemento piezo in realtà è un dispositivo che genera vibrazioni o oscillazioni quando una frequenza viene applicata ai suoi terminali. Tuttavia lo stesso piezo potrebbe essere utilizzato nel processo inverso per generazione di impulsi elettrici in risposta alle vibrazioni applicate sul suo corpo. Questa vibrazione potrebbe essere sotto forma di un colpo o di un colpo sulla superficie del piezo.

Imposta Arduino e un elemento piezo come mostrato nella figura seguente

const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}

La soglia 100 viene introdotta proprio per assicurarsi che l'Arduino risponda solo alle vibrazioni autentiche attraverso i colpi, e non altre vibrazioni più piccole come da suoni forti o corni.

La selezione del pin A5 non è obbligatoria, è possibile selezionare eventuali altri ingressi analogici secondo le proprie preferenze e abbinandoli nel codice del programma.

Utilizzo del servomotore con Arduino

Un servomotore è un tipo di motore DC che può essere ruotato ad angoli precisi secondo la richiesta di una particolare applicazione. Può essere fatto applicando un comando calcolato agli ingressi rilevanti del motore per produrre un angolo di rotazione o rotazione accurato entro un intervallo di 180 gradi sul motore.

Tipicamente un servomotore ha 3 fili o ingressi. I fili positivi sono normalmente di colore rosso, il filo negativo o di terra è nero, il cui filo di comando o di segnalazione è normalmente di colore bianco o giallo.

Arduino facilita il controllo del servomotore attraverso un linguaggio di supporto integrato che rende il controllo molto comodo e ideale per i servomotori.

Il seguente esempio ci mostrerà il programma di configurazione di base per implementare il controllo del servomotore tramite Arduino:

Il codice è dato di seguito:

#include
Servo servo1
const int kPinPot = A0
const int kPinServo1 = 9
void setup()
{
servo1.attach(kPinServo1)
}
void loop()
{
int val = analogRead(kPinPot)
val = map(val, 0, 1023, 0, 180)
servo1.write(val)
delay(15)
}

Possiamo vedere un paio di nuove voci qui. Uno che dice al filo collegato del servo a quale pin è assegnato. L'altro è il codice che fornisce al pin un valore compreso tra 0 e 180, per determinare l'angolo di rotazione del servo.

Conclusione

L'argomento di Arduino può essere infinitamente lungo, e quindi oltre lo scopo di questo articolo. Tuttavia, spero che il tutorial di cui sopra dovrebbe aver sicuramente aiutato ad apprendere le basi di Arduino e comprendere parametri importanti attraverso i vari codici applicativi di esempio.

Si spera che ulteriori informazioni possano essere aggiornate di volta in volta qui, ogni volta che sono disponibili.

Nel frattempo goditi il ​​tuo corso di programmazione, Buon Arduinoing a te !!