Arduino: accensione fluida di un LED RGB da un pulsante. Controllo della luminosità del LED tramite potenziometro. Descrizione del programma per Arduino

In questo esperimento aggiungiamo una porzione di luminosità al LED con un pulsante e la diminuiamo con l'altro.

ELENCO DELLE PARTI PER L'ESPERIMENTO

- 1 scheda Arduino Uno;

- 1 breadboard senza saldature;

- 2 pulsanti orologio;

- 1 resistenza del valore nominale di 220 Ohm;

- 1 LED;

- 7 fili maschio-maschio.

SCHEMA ELETTRICO

SCHEMA SUL BREADBOARD

NOTA

• Se stai rielaborando il circuito dell'esperimento precedente, tieni presente che questa volta dobbiamo collegare il LED a una porta che supporti PWM.

SCHIZZO

scarica lo schizzo per l'IDE Arduino

#define PLUS_BUTTON_PIN 2 #define MINUS_BUTTON_PIN 3 #define LED_PIN 9 int luminosità = 100; booleano plusUp = vero; booleano minusUp = vero; void setup() ( pinMode(LED_PIN, OUTPUT); pinMode(PLUS_BUTTON_PIN, INPUT_PULLUP); pinMode(MINUS_BUTTON_PIN, INPUT_PULLUP); ) void loop() ( analogWrite(LED_PIN, luminosità); // rispondi ai clic utilizzando la funzione che abbiamo scritto plusUp = handleClick(PLUS_BUTTON_PIN, plusUp, +35); minusUp = handleClick(MINUS_BUTTON_PIN, minusUp, -35); ) // Funzione propria con 3 parametri: il numero pin con il pulsante // (buttonPin), lo stato prima della verifica (wasUp ) e la gradazione // della luminosità quando si fa clic sul pulsante (delta). La funzione restituisce // (ritorno in inglese) il nuovo stato corrente del pulsante boolean handleClick(int buttonPin, boolean wasUp, int delta) ( boolean isUp = digitalRead(buttonPin); if (wasUp && !isUp) ( delay(10 ); isUp = digitalRead(buttonPin); // se c'è stato un clic, cambia la luminosità da 0 a 255 if (!isUp) luminosità = vincola(luminosità + delta, 0, 255); ) return isUp; // restituisce il valore al codice chiamante)

SPIEGAZIONI PER IL CODICE

• Possiamo utilizzare non solo le funzioni integrate, ma anche crearne di nostre. Ciò è giustificato quando dobbiamo ripetere le stesse azioni in punti diversi del codice o, ad esempio, dobbiamo eseguire le stesse azioni su dati diversi, come in questo caso: elaborare il segnale dalle porte digitali 2 e 3.
• È possibile definire le proprie funzioni in qualsiasi punto del codice al di fuori del codice di altre funzioni. Nel nostro esempio, abbiamo definito una funzione dopo ciclo continuo .
• Per definire la nostra funzione abbiamo bisogno di:
  • Dichiara quale tipo di dati restituirà. Nel nostro caso lo è booleano. Se la funzione esegue solo alcune azioni e non restituisce alcun valore, utilizzare la parola chiave vuoto
  • Assegnare alla funzione un nome - identificatore. Qui valgono le stesse regole della denominazione di variabili e costanti. Le funzioni sono denominate nello stesso stile comeVariabili .
  • Tra parentesi, elenca i parametri passati alla funzione, indicando il tipo di ciascuno. Questa è una dichiarazione di variabili visibili all'interno della funzione appena creata e solo al suo interno. Ad esempio, se in questo esperimento proviamo ad accedere era su O è su da ciclo continuo() Riceveremo un messaggio di errore dal compilatore. Allo stesso modo, le variabili dichiarate in ciclo continuo, non sono visibili ad altre funzioni, ma i loro valori possono essere passati come parametri.
  • Tra una coppia di parentesi graffe, scrivi il codice eseguito dalla funzione
  • Se la funzione deve restituire un valore, utilizzare la parola chiave ritorno specificare quale valore restituire. Questo valore deve essere del tipo che abbiamo dichiarato
• Le cosiddette variabili globali, ad es. Le variabili a cui è possibile accedere da qualsiasi funzione vengono solitamente dichiarate all'inizio del programma. Nel nostro caso, questo è luminosità .
• All'interno della funzione che abbiamo creato handleClick Succede la stessa cosa dell'esperimento.
• Poiché con un incremento di luminosità pari a 35, dopo non più di otto clic consecutivi su uno dei pulsanti, il valore dell'espressione luminosità + delta uscirà dall'intervallo . Utilizzando la funzione vincolare limitiamo i valori consentiti per la variabile luminosità limiti dell'intervallo specificato.
• Nell'espressione piùSu = handleClick(PLUS_BUTTON_ SPILLO , piùSu, +35) accediamo alla variabile piùSu due volte. Perché il = inserisce il valore dell'operando di destra in quello di sinistra, calcolando prima cosa restituirà handleClick. Quindi quando le diamo piùSu come parametro ha ancora il vecchio valore calcolato durante l'ultima chiamata handleClick .
• Dentro handleClick calcoliamo il nuovo valore di luminosità del LED e lo scriviamo in una variabile globale luminosità, che ad ogni iterazione ciclo continuo appena passato a analogWrite .

DOMANDE PER PROVARE SE STESSI

1. Cosa significa la parola chiave? vuoto ?
2. Come si comporta un programma quando una variabile viene menzionata da lati diversi dell'operatore di assegnazione = ?

COMPITI PER UNA SOLUZIONE INDIPENDENTE

1. Modificare il codice in modo che il passaggio di modifica della luminosità venga regolato in un unico punto.
2. Crea un'altra funzione e rielabora il codice in modo che una funzione sia responsabile del tracciamento delle sequenze di tasti e un'altra sia responsabile del calcolo della luminosità del LED e del suo ripristino. analogWrite .

​

Consideriamo ora il LED multicolore, che spesso viene chiamato in sigla: LED RGB. RGB è un'abbreviazione che sta per: Red - rosso, Green - verde, Blue - blu. Cioè, all'interno di questo dispositivo sono posizionati tre LED separati. A seconda del tipo, un LED RGB può avere un catodo comune o un anodo comune.

1. Miscelazione dei colori

Perché un LED RGB è migliore di tre convenzionali? Riguarda la capacità della nostra visione di mescolare la luce proveniente da diverse fonti poste una vicina all'altra. Ad esempio, se posizioniamo i LED blu e rossi uno accanto all'altro, a una distanza di diversi metri il loro bagliore si fonderà e l'occhio vedrà un punto viola. E se aggiungiamo anche il verde, il punto ci apparirà bianco. Questo è esattamente il modo in cui funzionano i monitor dei computer, i televisori e gli schermi esterni. La matrice TV è composta da singoli punti di diversi colori. Se prendi una lente d'ingrandimento e guardi il monitor acceso, puoi vedere facilmente questi punti. Ma su uno schermo esterno i punti non sono posizionati molto fitti, così da poter essere distinti ad occhio nudo. Ma da una distanza di diverse decine di metri questi punti sono indistinguibili. Si scopre che più i punti multicolori sono vicini tra loro, minore è la distanza necessaria all'occhio per mescolare questi colori. Da qui la conclusione: a differenza di tre LED separati, la miscelazione dei colori di un LED RGB è percepibile già ad una distanza di 30-70 cm, mentre un LED RGB con lente opaca ha prestazioni ancora migliori.

2. Collegare un LED RGB ad Arduino

Poiché il LED multicolore è composto da tre LED normali, li collegheremo separatamente. Ogni LED è collegato al proprio pin e ha il proprio resistore separato. In questo tutorial utilizziamo un LED RGB con un catodo comune, quindi ci sarà solo un filo a terra. Diagramma schematico
Aspetto del layout

3. Programma per il controllo di un LED RGB

Componiamo un programma semplice, che illuminerà a turno ciascuno dei tre colori. const byte rPin = 3; const byte gPin = 5; const byte bPin = 6; void setup() ( pinMode(rPin, OUTPUT); pinMode(gPin, OUTPUT); pinMode(bPin, OUTPUT); ) void loop() ( // spegne il blu, accende il rosso digitalWrite(bPin, LOW); digitalWrite( rPin, HIGH); delay(500); // spegni il rosso, accendi il verde digitalWrite(rPin, LOW); digitalWrite(gPin, HIGH); delay(500); // spegni il verde, accendi il blu digitalWrite(gPin , LOW); digitalWrite( bPin, HIGH); delay(500); ) Carica il programma su Arduino e osserva il risultato. Il tuo browser non supportare il tag video. Ottimizziamo un po' il programma: al posto delle variabili rPin, gPin e bPin utilizzeremo un array. Questo ci aiuterà nei prossimi compiti. const byte rgbPins = (3,5,6); void setup() ( for(byte i=0; i<3; i++) pinMode(rgbPins[i], OUTPUT); } void loop() { digitalWrite(rgbPins, LOW); digitalWrite(rgbPins, HIGH); delay(500); digitalWrite(rgbPins, LOW); digitalWrite(rgbPins, HIGH); delay(500); digitalWrite(rgbPins, LOW); digitalWrite(rgbPins, HIGH); delay(500); }

4. Sette colori dell'arcobaleno

Ora proviamo ad illuminare due colori contemporaneamente. Programmiamo la seguente sequenza di colori:

• rosso
• rosso + verde = giallo
• verde
• verde + blu = azzurro
• blu
• blu + rosso = viola

Abbiamo omesso il colore arancione per semplicità. Quindi si sono rivelati sei colori dell'arcobaleno 🙂 const byte rgbPins = (3,5,6); const byte arcobaleno = ( (1,0,0), // rosso (1,1,0), // giallo (0,1,0), // verde (0,1,1), // blu ( 0,0,1), // blu (1,0,1), // viola ); void setup() ( for(byte i=0; i<3; i++) pinMode(rgbPins[i], OUTPUT); } void loop() { // перебираем все шесть цветов for(int i=0; i<6; i++){ // перебираем три компоненты каждого из шести цветов for(int k=0; k<3; k++){ digitalWrite(rgbPins[k], rainbow[i][k]); } delay(1000); } } В результате работы программы получается: Your browser does not support the video tag.

5. Cambiamento di colore uniforme

Non per niente abbiamo collegato il LED RGB ai pin 3, 5 e 6. Come sapete, questi pin consentono di generare un segnale PWM con diversi cicli di lavoro. In altre parole, non possiamo semplicemente accendere o spegnere il LED, ma controllarne il livello di tensione. Questo viene fatto utilizzando la funzione analogWrite. Facciamo in modo che il nostro LED passi da un colore all'altro dell'arcobaleno non in modo brusco, ma fluido. const byte rgbPins = (3,5,6); int dim = 1; void setup() ( for(byte i=0; i<3; i++){ pinMode(rgbPins[i], OUTPUT); } // начальное состояние - горит красный цвет analogWrite(rgbPins, 255); analogWrite(rgbPins, 0); analogWrite(rgbPins, 0); } void loop() { // гасим красный, параллельно разжигаем зеленый for(int i=255; i>=0; i--)( analogWrite(rgbPins, i/dim); analogWrite(rgbPins, (255-i)/dim); delay(10); ) // disattiva il verde, attiva il blu in parallelo for(int i=255 ; i> =0; i--)( analogWrite(rgbPins, i/dim); analogWrite(rgbPins, (255-i)/dim); delay(10); ) // spegne il blu, accende il rosso in parallelo for(int i=255 ; i>=0; i--)( analogWrite(rgbPins, i/dim); analogWrite(rgbPins, (255-i)/dim); delay(10); ) ) La variabile dim determina la luminosità del bagliore. A dim = 1 abbiamo la massima luminosità. Carica il programma su Arduino. Il tuo browser non supporta il tag video.

Compiti

1. Indicatore di temperatura. Aggiungiamo un termistore al circuito e colleghiamolo all'ingresso analogico. Il LED dovrebbe cambiare colore a seconda della temperatura del termistore. Più bassa è la temperatura, più blu è il colore, mentre più alta è la temperatura, più rosso è.
2. Lampada RGB con regolatore. Aggiungiamo tre resistori variabili al circuito e colleghiamoli agli ingressi analogici. Il programma dovrebbe leggere continuamente i valori del resistore e cambiare il colore del componente LED RGB corrispondente.

In questo esempio imparerai come modificare la luminosità di un LED utilizzando resistori con resistenze diverse.

Per questo esempio avrai bisogno

1 LED diametro 5 mm

1 resistenza da 270 ohm (rosso, viola, marrone)

1 resistenza da 470 ohm (giallo, viola, marrone)

1 resistenza da 2,2 kOhm (rosso, rosso, rosso)

1 resistenza da 10 kOhm (marrone, nero, arancione)

LED - informazioni generali

I LED servono bene nei dispositivi per vari tipi di indicazione. Consumano poca elettricità e sono durevoli.

In questo esempio utilizziamo i LED più comuni con un diametro di 5 mm. Sono comuni anche i LED con un diametro di 3 millimetri e i LED di grandi dimensioni con un diametro di 10 mm.

Non è consigliabile collegare il LED direttamente a una batteria o a una fonte di tensione. Innanzitutto, devi prima capire dove esattamente il LED ha i suoi piedini negativi e positivi. Bene, in secondo luogo, è necessario utilizzare resistori limitatori di corrente, altrimenti il ​​LED si brucerà molto rapidamente.

Se non si utilizza un resistore con il LED, il LED si guasterà molto rapidamente perché lo attraversa troppa corrente. Di conseguenza, il LED si surriscalda e la luce che genera il contatto verrà distrutta.

Esistono due modi per distinguere tra i rami positivo e negativo di un LED.

Il primo è che la gamba positiva è più lunga.

Il secondo è che quando si entra nell'alloggiamento del diodo stesso, sul connettore della gamba negativa è presente un bordo piatto.

Se trovi un LED che ha un bordo piatto sulla gamba più lunga, la gamba più lunga è ancora positiva.

Resistori - informazioni generali

Resist - resistenza (inglese)

Come suggerisce il nome, i resistori resistono al flusso di elettricità. Maggiore è il valore (ohm) del resistore, maggiore sarà la resistenza e minore sarà il flusso di corrente nel circuito in cui è installato. Utilizzeremo questa proprietà dei resistori per regolare la corrente che passa attraverso il LED e quindi la sua luminosità.

Ma prima parliamo un po’ delle resistenze.

Le unità in cui viene misurata la resistenza sono Ohm, che in molte fonti sono indicati con la lettera greca Ω - Omega Poiché Ohm è un piccolo valore di resistenza (quasi impercettibile in un circuito), spesso opereremo con unità come kOhm - kiloohm (1000 Ohm) e MOhm megaohm (1.000.000 ohm).

In questo esempio utilizzeremo resistori con quattro valori diversi: 270 Ω, 470 Ω, 2,2 kΩ e 10 kΩ. Le dimensioni di questi resistori sono le stesse. Anche il colore. L'unica cosa che li distingue sono le strisce colorate. È da queste strisce che viene determinato visivamente il valore dei resistori.

Per i resistori che hanno tre strisce colorate e l'ultima striscia dorata, funzionano le seguenti corrispondenze:

Marrone 1

Rosso 2

Arancione 3

Verde 5

Viola 7

Le prime due strisce indicano i primi 2 valori numerici, quindi rosso, viola significa 2, 7. La striscia successiva è il numero di zeri che devono essere posizionati dopo le prime due cifre. Cioè, se la terza striscia è marrone, come nella foto sopra, ci sarà uno zero e il valore della resistenza sarà 270 Ω.

Resistore con strisce marroni, nere, arancioni: 10 e tre zeri, quindi 10000 Ω. Cioè, 10 kΩ.

A differenza dei LED, i resistori non hanno gambe positive e negative. Non importa quale gamba usi per collegarli all'alimentazione/terra.

Schema di collegamento

Collegare secondo lo schema seguente:

L'Arduino ha un pin da 5 V per alimentare le periferiche. Lo useremo per alimentare un LED e un resistore. Non avrai bisogno di nient'altro dalla scheda, basta collegarla via USB al tuo computer.

Con una resistenza da 270 Ω, il LED dovrebbe illuminarsi in modo abbastanza intenso. Se sostituisci il resistore da 270 Ω con un resistore da 470 Ω, il LED non si illuminerà così intensamente. Con una resistenza da 2,2 kΩ il LED dovrebbe attenuarsi leggermente. Dopotutto, con una resistenza da 10 kΩ, il LED sarà appena visibile. È probabile che per vedere la differenza nell'ultimo passaggio dovrai estrarre l'adattatore rosso, utilizzandolo come interruttore. Quindi puoi vedere la differenza di luminosità.

A proposito, puoi condurre questo esperimento a luci spente.

Varie opzioni di installazione del resistore

Nel momento in cui 5 V sono collegati a un ramo del resistore, il secondo ramo del resistore è collegato al ramo positivo del LED e il secondo ramo del LED è collegato a terra. Se spostiamo il resistore in modo che sia dietro il LED come mostrato di seguito, il LED si accenderà comunque.

LED lampeggiante

Possiamo collegare il LED all'uscita Arduino. Spostare il filo rosso dal pin di alimentazione da 5 V a D13 come mostrato di seguito.

Ora scarica l'esempio "Blink" che abbiamo visto. Tieni presente che entrambi i LED, quello integrato e quello esterno installato, hanno iniziato a lampeggiare.

Proviamo a utilizzare un pin diverso su Arduino. Diciamo D7. Sposta il connettore dal pin D13 al pin D7 e modifica la seguente riga del tuo codice:

Carica lo schizzo modificato su Arduino. Il LED continuerà a lampeggiare, ma questa volta utilizzando l'alimentazione dal pin D7.

Nelle lezioni precedenti abbiamo conosciuto i circuiti più semplici: assemblaggio e. Oggi assembliamo un modello con un potenziometro (resistore variabile) e un LED. Un tale modello può essere utilizzato per controllare un robot.

Potenziometroè una variabile resistore con resistenza regolabile.I potenziometri sono utilizzati nella robotica come regolatori di vari parametri: volume del suono, potenza, tensione, ecc. Nel nostro modelloruotando la manopola del potenziometroLa luminosità del LED dipenderà. Questo è anche uno degli schemi di base.

Istruzioni video per l'assemblaggio del modello:

Per assemblare il modello abbiamo bisogno di:

• Scheda Arduino (o analoghi);
• Tagliere;
• 6 fili e/o ponticelli maschio-maschio;
• Diodo ad emissione luminosa;
• potenziometro (resistore variabile);
• Resistenza da 220 Ohm;
• Arduino IDE, che può essere scaricato dal sito web di Arduino.

Di cosa hai bisogno per collegare un potenziometro e un LED ad Arduino?

Schema di collegamento per modello Arduino con potenziometro e LED:

Schema di collegamento per modello Arduino con potenziometro e LED

Il seguente programma è adatto al funzionamento di questo modello (puoi semplicemente copiare il programma nell'IDE di Arduino):

// dà i nomi dei pin con LED
// e potenziometro
#definisci led 9
#definisci il piatto A0
configurazione nulla()
{
// pin con LED - uscita
pinMode(led, USCITA);
// pin con potenziometro - ingresso
pinMode(vaso, INPUT);
}
ciclo vuoto()
{
// dichiara la variabile x
intero x;
// legge la tensione dal potenziometro:
// si otterrà un numero da 0 a 1023
// dividilo per 4, ottieni un numero nell'intervallo
// 0-255 (la parte frazionaria verrà scartata)
x = analogRead(pot) / 4;
// invia il risultato al LED
analogWrite(led, x);
}

Ecco come appare il modello Arduino assemblato di un potenziometro con un LED:

Modello Arduino con potenziometro e LED assemblati

Questo completa la terza lezione “Arduino per principianti”. Continua!

Post delle lezioni:

1. Prima lezione: .
2. Seconda lezione: .
3. Terza lezione: .
4. Quarta lezione: .
5. Quinta lezione: .
6. Lezione sei: .
7. Settima lezione: .
8. Ottava lezione: .
9. Nona lezione:

E proviamo a completare una nuova attività. Penso che tutti abbiano visto le ghirlande espositive di Capodanno in cui i LED lampeggiano senza intoppi. Diciamo che vogliamo fare qualcosa del genere.
Abbiamo già esaminato la funzione digitalWrite() e sappiamo che il valore che scrive può essere di due opzioni: alto o basso. In questo caso, la funzione analogWrite() ci aiuterà. Le "formulazioni" delle funzioni differiscono solo nei prefissi iniziali, quindi sono facili da ricordare.

La funzione analogWrite(), come digitalWrite(), contiene due argomenti tra parentesi e funziona secondo lo stesso principio verbale: "dove, cosa". La differenza principale è la possibilità di registrare un'ampia gamma di valori invece dei soliti BASSO o ALTO. Questo ci permetterà di regolare la luminosità del LED. La nota principale da tenere presente è che questa funzionalità funziona solo su determinati contatti. Questi pin sono contrassegnati dal simbolo "~". Questo simbolo indica che si tratta di un contatto PWM. PWM (modulazione di larghezza di impulso) suona come PWM (modulazione di larghezza di impulso) in russo. Il principio di funzionamento si basa sulla modifica della durata dell'impulso. Graficamente questo può essere rappresentato in questo modo:

Proviamo a capire come funziona guardando un semplice esempio. Per fare ciò, è necessario collegare il LED al contatto PWM tramite una resistenza da 150 Ohm e “cablare” un semplice programma nell'Arduino. Lo schema di collegamento e il codice dello schizzo sono presentati di seguito:

configurazione nulla()
{
pinMode(led,USCITA);
}

ciclo vuoto()
{
for(int i=0; i<=255; i++)
{
analogWrite(led,i);
ritardo(10);
}
for(int i=255; i>=0; i--)
{
analogWrite(led,i);
ritardo(10);
}
}

Penso che il codice sia generalmente chiaro, ma dobbiamo prestare un po' di attenzione al ciclo for(). Esiste una cosa come il permesso. Poiché stiamo lavorando con una risoluzione a 8 bit (di cui parleremo più avanti), il valore minimo sarà 0 e il massimo sarà 255. Alla fine di ogni iterazione, impostiamo il ritardo temporale su 10 ms.

Torniamo al diagramma della lezione precedente e proviamo a creare una ghirlanda simile utilizzando la funzione analogWrite().

int buttonPin = 2;
int pin = (3,5,6,9,10,11);

booleano lastButton = BASSO;
booleano currentButton = BASSO;
abilitazione booleana = falso;

configurazione nulla()
{
pinMode(pulsantePin, INPUT);
for(int modalità = 0; modalità<= 5; mode++) pinMode(pins, OUTPUT);
}

antirimbalzo booleano (ultimo booleano)
{
corrente booleana = digitalRead(buttonPin);
se(ultimo!= corrente)
{
ritardo(5);
corrente = digitalRead(pulsantePin);
}
corrente di ritorno;
}

ciclo vuoto()
{
currentButton = antirimbalzo(lastButton);
if(ultimoPulsante == BASSO && pulsanteattuale == ALTO)
{
abilita =!abilita;
}

Se(abilita == vero)
{
for (int i=0; i<=5; i++)
{
for (int luminosità = 0; luminosità<= 255; brightness++)
{
ritardo(1);
}
ritardo(40);
}
for (int i=0; i<=5; i++)
{
for (int luminosità = 255; luminosità >= 0; luminosità--)
{
analogWrite(pin[i], luminosità);
ritardo(1);
}
ritardo(40);
}
}

Se (abilita == falso)
{
for(int i = 0; i<= 5; i++) digitalWrite(pins[i], LOW);
}

UltimoPulsante = pulsantecorrente;
}

Visivamente lo schizzo è diventato un po' più complesso. In effetti, qui tutto è semplice e scopriamolo. Dobbiamo identificare tutti i LED collegati, ma invece del solito int led utilizziamo un array, ciascun elemento del quale è un pin PWM su Arduino. Anche nel corpo della funzione void setup() abbiamo agito in modo astuto. Abbiamo affidato la “listing” di tutti i contatti al ciclo for(), ad ogni iterazione del quale viene configurato su OUTPUT il contatto corrispondente. Passiamo alla funzione void loop(). La funzione debounce() e la condizione if() iniziale rimangono invariate. Stiamo ancora controllando i livelli di due variabili: il valore precedente (inizialmente LOW) e lo stato attuale del pulsante. Quando queste condizioni sono soddisfatte, il valore della variabile di abilitazione viene invertito. Tenendo presente questo, abbiamo aggiunto altre due semplici condizioni if(). Se abilita = true, la ghirlanda è accesa, la cui fluidità del "flusso" è controllata dal ciclo for(). Se abilita = falso, tutti i LED sono spenti. Al termine delle condizioni, la variabile lastButton assume lo stato corrente del pulsante.
Durante il test del nostro programma, abbiamo notato che tutto non funzionava come previsto. Ricordate, nell'ultima lezione abbiamo apportato una modifica secondo cui se il ritardo è ampio, il pulsante si attiverà allo scadere del tempo? Nell'esempio precedente, quando la ghirlanda era accesa, il ritardo totale nel corpo della funzione void loop() era di 85 ms. Questo ci ha dato l’opportunità di “arrivarci” entro un certo periodo di tempo. In questo schizzo, nelle stesse condizioni, il ritardo differisce più volte. Forse, se vuoi spegnere la ghirlanda, suggerisce la parola "interrompere". Questa sarà la soluzione a questo problema!

Spero che questo articolo ti sia stato utile. Nel prossimo tutorial esamineremo gli interrupt in Arduino e otterremo il risultato desiderato.