Arduino: controllo sequenziale uscite digitali

Lascia una risposta

Durante la progettazione di un sistema di automazione accade frequentemente di avere la necessità di ripetere, sequenzialmente e in modo continuo, l’attivazione di apparati (ad es. motori) oppure la lettura continua dei dati provenienti da più sensori. Come attività di ripasso per i miei studenti ho deciso di riprendere alcuni argomenti affrontati nelle scorse settimane con specifiche esperienze di laboratorio:

  • automi a stati finiti;
  • utilizzo degli array;
  • input valori interi da serial monitor;
  • marcia, arresto, pausa di sequenze;
  • controllo uscite digitali mediante ingressi analogici;
  • realizzazione di commutatori con pulsanti con uno o più pulsanti;
  • utilizzo corretto dei tipi di dati per risparmiare memoria;
  • e molto altro

Di seguito 9 sketch in cui vengono ripresi gli argomenti sopra elencati e che potranno essere utilizzati nei prossimi mesi per sviluppare ulteriori sperimentazioni.
Come sempre all’interno degli sketch proposti trovate le spiegazioni di ogni parte del codice ed in alcuni casi trovate link di approfondimento che rimandano a questo sito.

Per ripercorrere gli argomenti svolti partirò dal classico sketch che permette di realizza l’accensione sequenziale di LED, come quello che potete trovare nelle mie slice: Alfabeto Arduino – Lezione 2 a pagina 66.
I LED nel circuito identificano gli apparati da attivare sequenzialmente, realizzando così il classico effetto “super car” (i diversamente giovani 🙂 sanno perché si chiama così).
Circuito e sketch verranno poi modificati per rispondere alle specifiche indicate ad inizio di ogni esempio.

Sketch 01

Sequenza di accensione e spegnimento da destra e sinistra e viceversa di 8 LED con tempo di accensione di 100 millisecondi.

Video Player

 

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2   30.12.2020
3   Lezione di riferimento: https://wp.me/p4kwmk-4D3
4 
5   Versione 01
6   Sequenza di accensione e spegnimento alternato
7   da destra e sinistra e viceversa di 8 LED con
8   tempo di accensione di 100 millisecondi.
9    
10   Questo codice è di dominio pubblico
11 */
12 
13// creazione di un array di 8 pin a cui vanno collegati i LED
14// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
15// http://wp.me/p4kwmk-26e
16 
17byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};
18 
19// per approfondimenti sull'uso dei tipi di dati
20// si consultino i link:
21// https://wp.me/p4kwmk-4As
22// https://wp.me/p4kwmk-1zF
23 
24// intervallo di accensione/spegnimento
25byte ritardoLed = 100;
26 
27// indicatore di direzione di accensione
28byte direzione = 1;
29 
30// indice dell'array per l'accensione del LED
31byte ledCorrente = 0;
32 
33// variabile in cui memorizzare il tempo di accensione di Arduino
34// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
35// http://wp.me/p4kwmk-1zF
36 
37unsigned long tempoTrascorso;
38 
39void setup() {               
40  // impostiamo tutti i pin ad output
41  for (byte x=0; x<8; x++) {
42    pinMode(ledPin[x], OUTPUT);
43  }
44     
45  // Memorizzazione del tempo trascorso
46  // dal momento in cui avviamo Arduino
47  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
48  // http://wp.me/p4kwmk-1QG
49   
50  tempoTrascorso = millis();
51}
52 
53void loop() {
54  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
55  if ((millis() - tempoTrascorso) > ritardoLed) {
56    cambiaStatoLed();
57    tempoTrascorso = millis();
58  }
59}
60 
61// la funzione cambiaStatoLed() permette di controllare
62// la sequenza di accensione dei LED
63 
64void cambiaStatoLed() {
65  // spegne tutti i LED
66  for (byte x=0; x<8; x++) {
67    digitalWrite(ledPin[x], LOW);
68  }
69  // accende il LED corrente
70  digitalWrite(ledPin[ledCorrente], HIGH);
71  // incrementa la variabile direzione
72  ledCorrente += direzione;
73  // cambia la direzione se si arriva alla fine
74  if (ledCorrente == 7) {
75    direzione = -1;
76  }
77  if (ledCorrente == 0) {
78    direzione = 1;
79  }
80}

Sketch 02

Sequenza di accensione e spegnimento da destra e sinistra e viceversa di 8 LED. Con un trimmer è possibile variare il tempo di accensione nell’intervallo da 50 millisecondi a 1000 millisecondi (1 secondo).

Video Player

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2   30.12.2020
3   Lezione di riferimento: https://wp.me/p4kwmk-4D3
4 
5   Versione 02
6   Sequenza di accensione e spegnimento alternato
7   da destra e sinistra e viceversa di 8 LED controllato
8   da un trimmer che permetterà di variare il tempo di accensione
9   da 50 millisecondi a 1000 millisecondi (1 secondo).
10    
11   Questo codice è di dominio pubblico
12 */
13 
14// creazione di un array di 8 pin a cui vanno collegati i LED
15// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
16// http://wp.me/p4kwmk-26e
17 
18byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};
19 
20// per approfondimenti sull'uso dei tipi di dati
21// si consultino i link:
22// https://wp.me/p4kwmk-4As
23// https://wp.me/p4kwmk-1zF
24 
25// intervallo di accensione/spegnimento
26int ritardoLed;
27 
28// variabile in cui memorizzare il valore restituito dall'analogRead
29int val = 0;
30 
31// indicatore di direzione di accensione
32byte direzione = 1;
33 
34// indice dell'array per l'accensione del LED
35byte ledCorrente = 0;
36 
37// variabile in cui memorizzare il tempo di accensione di Arduino
38// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
39// http://wp.me/p4kwmk-1zF
40 
41unsigned long tempoTrascorso;
42 
43void setup() {
44  Serial.begin(9600);           
45  // impostiamo tutti i pin ad output
46  for (byte x=0; x<8; x++) {
47    pinMode(ledPin[x], OUTPUT);
48  }
49     
50  // Memorizzazione del tempo trascorso
51  // dal momento in cui avviamo Arduino
52  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
53  // http://wp.me/p4kwmk-1QG
54   
55  tempoTrascorso = millis();
56}
57 
58void loop() {
59 
60  // valore analogico letto su A0 inserito con il trimmer
61  val = analogRead(A0);
62 
63// Togliere il commento per valutare
64// valore massimo/minimo del valore restituito
65// dall'analogRead in questo modo si potranno
66// inserire nella map i valori massimi e minimi
67// dell'intervallo di partenza
68 
69// Serial.println(val);
70// delay(1000);
71 
72  // ValMax = 285, ValMin = 719
73  // riconvertiti nell'intervallo 50, 1000
74   
75  ritardoLed = map(val, 285, 719, 50, 1000);
76   
77  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
78  if ((millis() - tempoTrascorso) > ritardoLed) {
79    cambiaStatoLed();
80    tempoTrascorso = millis();
81  }
82}
83 
84// la funzione cambiaStatoLed() permette di controllare
85// la sequenza di accensione dei LED
86 
87void cambiaStatoLed() {
88  // spegne tutti i LED
89  for (byte x=0; x<8; x++) {
90    digitalWrite(ledPin[x], LOW);
91  }
92  // accende il LED corrente
93  digitalWrite(ledPin[ledCorrente], HIGH);
94  // incrementa la variabile direzione
95  ledCorrente += direzione;
96  // cambia la direzione se si arriva alla fine
97  if (ledCorrente == 7) {
98    direzione = -1;
99  }
100  if (ledCorrente == 0) {
101    direzione = 1;
102  }
103}

Sketch 03

Sequenza di accensione e spegnimento alternato da destra e sinistra e viceversa di 8 LED. L’accensione di ogni LED è fissato in partenza a 100 millisecondi. Con un messaggio sulle Serial Monitor viene richiesto di inserire un nuovo tempo di accensione e spegnimento di ogni LED (delay), tempo che può essere scelto a piacimento.

Video Player

Lo schema di collegamento è analogo a quello utilizzato per lo sketch 01.

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2   30.12.2020
3   Lezione di riferimento: https://wp.me/p4kwmk-4D3
4 
5   Versione 03
6   Sequenza di accensione e spegnimento alternato
7   da destra e sinistra e viceversa di 8 LED.
8 
9   Partenza sequenza con 100 millisecondi e messaggio sulla
10   Serial Monitor per modificare il tempo di
11   accensione e spegnimento del singolo LED (delay)
12    
13   Questo codice è di dominio pubblico
14 */
15 
16// creazione di un array di 8 pin a cui vanno collegati i LED
17// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
18// http://wp.me/p4kwmk-26e
19 
20byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};
21 
22// per approfondimenti sull'uso dei tipi di dati
23// si consultino i link:
24// https://wp.me/p4kwmk-4As
25// https://wp.me/p4kwmk-1zF
26 
27// intervallo di accensione/spegnimento
28int ritardoLed = 100;
29 
30// indicatore di direzione di accensione
31byte direzione = 1;
32 
33// indice dell'array per l'accensione del LED
34byte ledCorrente = 0;
35 
36// variabile in cui memorizzare il tempo di accensione di Arduino
37// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
38// http://wp.me/p4kwmk-1zF
39 
40unsigned long tempoTrascorso;
41 
42// per stampare una sola volta il messaggio sulla Serial Monitor 
43bool abilitaMessaggio = 0;
44 
45void setup() {
46  // inizializzazione della serial monitor
47  Serial.begin(9600);
48                
49  // impostiamo tutti i pin ad output
50  for (byte x=0; x<8; x++) {
51    pinMode(ledPin[x], OUTPUT);
52  }
53 
54  // Memorizzazione del tempo trascorso
55  // dal momento in cui avviamo Arduino
56  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
57  // http://wp.me/p4kwmk-1QG
58  tempoTrascorso = millis();
59}
60 
61void loop() {
62  // consente di visualizzare sulla Serial Monitor
63  // una sola stampa delle stringa
64  if (abilitaMessaggio == 0) {
65    // ritardo che evita la doppia stampa del messaggio
66    delay(200);
67    Serial.print("Inserisci il ritardo in millisecondi: ");
68    abilitaMessaggio = 1;
69  }
70 
71  // Controlla se è disponibile almeno un carattere sulla seriale
72  // La Serial.available() restituisce
73  // 1 se presente un cattere,
74  // 0 se non è presente un carattere
75 
76  // per maggior informazioni sull'uso di parseInt() consultare il link:
77  // https://wp.me/p4kwmk-4Ah
78 
79  if (Serial.available())
80  {
81    // in r viene memorizzato il valore inserito
82    // attraverso la Serial Monitor
83    int r = Serial.parseInt();
84    if (r != 0) {
85      ritardoLed = r;
86      Serial.println(ritardoLed);
87 
88      // abilita alla stampa di una nuova stringa:
89      // "Inserisci il ritardo in millisecondi: "
90      abilitaMessaggio = 0;
91    }
92  }
93   
94  // funzione che fa lampeggiare il LED su Arduino
95  lampeggio();
96}
97 
98void lampeggio() {
99  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
100  if ((millis() - tempoTrascorso) > ritardoLed) {
101    cambiaStatoLed();
102    tempoTrascorso = millis();
103  }
104}
105 
106// la funzione cambiaStatoLed() permette di controllare
107// la sequenza di accensione dei LED
108 
109void cambiaStatoLed() {
110  // spegne tutti i LED
111  for (byte x = 0; x < 8; x++) {
112    digitalWrite(ledPin[x], LOW);
113  }
114  // accende il LED corrente
115  digitalWrite(ledPin[ledCorrente], HIGH);
116  // incrementa la variabile direzione
117  ledCorrente += direzione;
118  // cambia la direzione se si arriva alla fine
119  if (ledCorrente == 7) {
120    direzione = -1;
121  }
122  if (ledCorrente == 0) {
123    direzione = 1;
124  }
125}

Sketch 04

Sequenza di accensione e spegnimento alternato da destra e sinistra e viceversa di 8 LED.
All’avvio tutti i LED sono spenti. Inserimento da Serial Monitor del tempo di accensione e spegnimento del singolo LED (delay) all’avvio. E’ possibile modificare il delay inserendo sulla Serial Monitor un nuovo valore.

Video Player

Lo schema di collegamento è analogo a quello utilizzato per lo sketch 01.

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2   30.12.2020
3   Lezione di riferimento: https://wp.me/p4kwmk-4D3
4 
5   Versione 04
6   Sequenza di accensione e spegnimento alternato
7   da destra e sinistra e viceversa di 8 LED.
8 
9   All'avvio tutti i LED sono spenti.
10    
11   Inserimento da Serial Monitor del tempo di
12   accensione del singolo LED (delay) all'avvio e
13   nei momenti successivi
14    
15   Questo codice è di dominio pubblico
16 */
17 
18// creazione di un array di 8 pin a cui vanno collegati i LED
19// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
20// http://wp.me/p4kwmk-26e
21 
22byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};
23 
24// per approfondimenti sull'uso dei tipi di dati
25// si consultino i link:
26// https://wp.me/p4kwmk-4As
27// https://wp.me/p4kwmk-1zF
28 
29// intervallo di accensione/spegnimento
30int ritardoLed;
31 
32// indicatore di direzione di accensione
33byte direzione = 1;
34 
35// indice dell'array per l'accensione del LED
36byte ledCorrente = 0;
37 
38// variabile in cui memorizzare il tempo di accensione di Arduino
39// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
40// http://wp.me/p4kwmk-1zF
41unsigned long tempoTrascorso;
42 
43// per stampare una sola volta il messaggio sulla Serial Monitor
44bool abilitaMessaggio = 0;
45 
46// per abilitare l'avvio della sequenza di accensione dopo
47// l'inserimento del delay da Serial Monitor
48bool abilitaBlink = 0;
49 
50void setup() {
51  // inizializzazione della serial monitor
52  Serial.begin(9600);
53 
54  // impostiamo tutti i pin ad output
55  for (byte x = 0; x < 8; x++) {
56    pinMode(ledPin[x], OUTPUT);
57  }
58 
59  // Memorizzazione del tempo trascorso
60  // dal momento in cui avviamo Arduino
61  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
62  // http://wp.me/p4kwmk-1QG
63  tempoTrascorso = millis();
64}
65 
66// Stampa del messaggio su Serial Monitor:
67// "Inserisci il ritardo in millisecondi: "
68void inserisciRitardo() {
69   
70  // consente di visualizzare sulla Serial Monitor
71  // una sola stampa delle stringa
72  if (abilitaMessaggio == 0) {
73    // ritardo che evita la doppia stampa del messaggio
74    delay(200);
75    Serial.print("Inserisci il ritardo in millisecondi: ");
76    abilitaMessaggio = 1;
77  }
78 
79  // Controlla se è disponibile almeno un carattere sulla seriale
80  // La Serial.available() restituisce
81  // 1 se presente un cattere,
82  // 0 se non è presente un carattere
83 
84  // per maggior informazioni sull'uso di parseInt() consultare il link:
85  // https://wp.me/p4kwmk-4Ah
86 
87  if (Serial.available()) {
88    // in r viene memorizzato il valore inserito
89    // attraverso la Serial Monitor   
90    int r = Serial.parseInt();
91    if (r != 0) {
92      ritardoLed = r;
93      Serial.println(ritardoLed);
94 
95      // abilita alla stampa di una nuova stringa:
96      // "Inserisci il ritardo in millisecondi: "
97      abilitaMessaggio = 0;
98 
99      // abilita l'avvio del Blink sequenziale dei LED
100      abilitaBlink = 1;
101    }
102  }
103}
104 
105void loop() {
106  inserisciRitardo();
107    // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento e abilitaBlink == 1
108    // allora si cambia stato (si accende il LED successivo).
109     
110    // L'AND con "abilitaBlink == 1" permette di avviare la sequenza di accensione
111    // solo dopo l'inserimento del valore di ritardoLed, se non si facesse questo controllo
112    // al primo avvio tutti i LED sarebbero accessi perché la funzione cambiaStatoLed() verrebbe
113    // richiamata continuamente in quanto la differenza è sempre > di "ritardoLed" che è 0 e non
114    // si percepirebbe il cambiamento di stato.
115 
116     
117  if (((millis() - tempoTrascorso) > ritardoLed) && (abilitaBlink == 1)) {
118    cambiaStatoLed();
119    tempoTrascorso = millis();
120  }
121}
122 
123// la funzione cambiaStatoLed() permette di controllare
124// la sequenza di accensione dei LED
125 
126void cambiaStatoLed() {
127  // spegne tutti i LED
128  for (byte x = 0; x < 8; x++) {
129    digitalWrite(ledPin[x], LOW);
130  }
131  // accende il LED corrente
132  digitalWrite(ledPin[ledCorrente], HIGH);
133  // incrementa la variabile direzione
134  ledCorrente += direzione;
135  // cambia la direzione se si arriva alla fine
136  if (ledCorrente == 7) {
137    direzione = -1;
138  }
139  if (ledCorrente == 0) {
140    direzione = 1;
141  }
142}

Sketch 05

Sequenza di accensione e spegnimento alternato da destra e sinistra e viceversa di 8 LED.
All’avvio tutti i LED sono spenti. Inserimento da Serial Monitor del tempo di accensione e spegnimento del singolo LED (delay) all’avvio. Mediante la pressione continua di un pulsante viene messa in pausa la sequenza, rilasciando il pulsante si riavvia la sequenza.

Video Player

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2   30.12.2020
3   Lezione di riferimento: https://wp.me/p4kwmk-4D3
4 
5   Versione 05
6   Sequenza di accensione e spegnimento alternato
7   da destra e sinistra e viceversa di 8 LED.
8 
9   All'avvio tutti i LED sono spenti.
10 
11   Inserimento da Serial Monitor del tempo di
12   accensione e spegnimento del singolo LED (delay)
13   all'avvio e in momenti successivi.
14 
15   Mediante la pressione continua di un pulsante viene messa in pausa
16   la sequenza, rilasciando il pulsante si riavvia la sequenza.
17 
18   Questo codice è di dominio pubblico
19*/
20 
21// creazione di un array di 8 pin a cui vanno collegati i LED
22// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
23// http://wp.me/p4kwmk-26e
24 
25byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};
26 
27// per approfondimenti sull'uso dei tipi di dati
28// si consultino i link:
29// https://wp.me/p4kwmk-4As
30// https://wp.me/p4kwmk-1zF
31 
32// intervallo di accensione/spegnimento
33int ritardoLed;
34 
35// indicatore di direzione di accensione
36byte direzione = 1;
37 
38// indice dell'array per l'accensione del LED
39byte ledCorrente = 0;
40 
41// variabile in cui memorizzare il tempo di accensione di Arduino
42// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
43// http://wp.me/p4kwmk-1zF
44unsigned long tempoTrascorso;
45 
46// per stampare una sola volta il messaggio sulla Serial Monitor
47bool abilitaMessaggio = 0;
48 
49// per abilitare l'avvio della sequenza di accensione dopo
50// l'inserimento del delay da Serial Monitor
51bool abilitaBlink = 0;
52 
53// abilitazione/disabilitazione pausa sequenza
54byte pulsante = 11;
55 
56void setup() {
57  // inizializzazione della serial monitor
58  Serial.begin(9600);
59 
60  // impostiamo tutti i pin ad output
61  for (byte x = 0; x < 8; x++) {
62    pinMode(ledPin[x], OUTPUT);
63    // per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
64    // http://wp.me/p4kwmk-1QG
65  }
66 
67  // inizializzazione pin pulsante
68  pinMode(pulsante, INPUT);
69 
70  // Memorizzazione del tempo trascorso
71  // dal momento in cui avviamo Arduino
72  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
73  // http://wp.me/p4kwmk-1QG
74  tempoTrascorso = millis();
75}
76 
77// Stampa del messaggio su Serial Monitor:
78// "Inserisci il ritardo in millisecondi: "
79void inserisciRitardo() {
80 
81  // consente di visualizzare sulla Serial Monitor
82  // una sola stampa delle stringa
83  if (abilitaMessaggio == 0) {
84    // ritardo che evita la doppia stampa del messaggio
85    delay(200);
86    Serial.print("Inserisci il ritardo in millisecondi: ");
87    abilitaMessaggio = 1;
88  }
89 
90  // Controlla se è disponibile almeno un carattere sulla seriale
91  // La Serial.available() restituisce
92  // 1 se presente un cattere,
93  // 0 se non è presente un carattere
94 
95  // per maggior informazioni sull'uso di parseInt() consultare il link:
96  // https://wp.me/p4kwmk-4Ah
97 
98  if (Serial.available()) {
99    // in r viene memorizzato il valore inserito
100    // attraverso la Serial Monitor
101    int r = Serial.parseInt();
102    if (r != 0) {
103      ritardoLed = r;
104      Serial.println(ritardoLed);
105 
106      // abilita alla stampa di una nuova stringa:
107      // "Inserisci il ritardo in millisecondi: "
108      abilitaMessaggio = 0;
109 
110      // abilita l'avvio del Blink sequenziale dei LED
111      abilitaBlink = 1;
112    }
113  }
114}
115 
116void loop() {
117  inserisciRitardo();
118  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento e abilitaBlink == 1
119  // allora si cambia stato (si accende il LED successivo).
120 
121  // L'AND con "abilitaBlink == 1" permette di avviare la sequenza di accensione
122  // solo dopo l'inserimento del valore di ritardoLed, se non si facesse questo controllo
123  // al primo avvio tutti i LED sarebbero accessi perché la funzione cambiaStatoLed() verrebbe
124  // richiamata continuamente in quanto la differenza è sempre > di "ritardoLed" che è 0 e non
125  // si percepirebbe il cambiamento di stato.
126 
127 
128  if (((millis() - tempoTrascorso) > ritardoLed) && (abilitaBlink == 1)) {
129    controlloBlink();
130    tempoTrascorso = millis();
131  }
132}
133 
134// la funzione controlloBlink() verifica se il pulsante
135// di pausa è premuto. Fino a quando viene premuto viene mantenuta
136// la pausa, quando rilascio la sequenza continua.
137 
138void controlloBlink() {
139  while (true) {
140    if (digitalRead(pulsante) == LOW) {
141      break;
142    }
143  }
144  cambiaStatoLed();
145}
146 
147// la funzione cambiaStatoLed() permette di controllare
148// la sequenza di accensione dei LED
149 
150void cambiaStatoLed() {
151  // spegne tutti i LED
152  for (byte x = 0; x < 8; x++) {
153    digitalWrite(ledPin[x], LOW);
154  }
155  // accende il LED corrente
156  digitalWrite(ledPin[ledCorrente], HIGH);
157  // incrementa la variabile direzione
158  ledCorrente += direzione;
159  // cambia la direzione se si arriva alla fine
160  if (ledCorrente == 7) {
161    direzione = -1;
162  }
163  if (ledCorrente == 0) {
164    direzione = 1;
165  }
166}

Sketch 06

Sequenza di accensione e spegnimento alternato da destra e sinistra e viceversa di 8 LED.
All’avvio tutti i LED sono spenti. Inserimento da Serial Monitor del tempo di accensione e spegnimento del singolo LED (delay) all’avvio.

Utilizzo del pulsante come interruttore:

  • prima pressione si avvia la sequenza.
  • seconda pressione stop sequenza.

Se durante lo stop si inserisce un nuovo valore del delay, alla successiva pressione del pulsante (avvio) la sequenza si riavvia con il nuovo delay inserito.

Video Player

Lo schema di collegamento è analogo a quello utilizzato per lo sketch 05.

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2   30.12.2020
3   Lezione di riferimento: https://wp.me/p4kwmk-4D3
4 
5   Versione 06
6   Sequenza di accensione e spegnimento alternato
7   da destra e sinistra e viceversa di 8 LED.
8 
9   All'avvio tutti i LED sono spenti.
10 
11   Inserimento da Serial Monitor del tempo di
12   accensione e spegnimento del singolo LED (delay)
13   all'avvio e in momenti successivi.
14 
15   Utilizzo del pulsante come interruttore:
16   - prima pressione si avvia la sequenza.
17   - seconda pressione stop sequenza.
18 
19     Se durante lo stop si inserisce un nuovo valore del delay,
20     alla successiva pressione del pulsante la sequenza si riavvia
21     con il nuovo delay inserito.
22 
23   Questo codice è di dominio pubblico
24*/
25 
26// creazione di un array di 8 pin a cui vanno collegati i LED
27// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
28// http://wp.me/p4kwmk-26e
29 
30byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};
31 
32// per approfondimenti sull'uso dei tipi di dati
33// si consultino i link:
34// https://wp.me/p4kwmk-4As
35// https://wp.me/p4kwmk-1zF
36 
37// intervallo di accensione/spegnimento
38int ritardoLed;
39 
40// indicatore di direzione di accensione
41byte direzione = 1;
42 
43// indice dell'array per l'accensione del LED
44byte ledCorrente = 0;
45 
46// variabile in cui memorizzare il tempo di accensione di Arduino
47// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
48// http://wp.me/p4kwmk-1zF
49unsigned long tempoTrascorso;
50 
51// per stampare una sola volta il messaggio sulla Serial Monitor
52bool abilitaMessaggio = 0;
53 
54// per abilitare l'avvio della sequenza di accensione dopo
55// l'inserimento del delay da Serial Monitor
56bool abilitaBlink = 0;
57 
58// abilitazione/disabilitazione pausa sequenza
59byte pulsante = 11;
60 
61// stato del pulsante attuale
62bool stato = 0;
63 
64// stato del pulsante al passo precedente
65bool stato_precedente = 0;
66 
67// controllo attivazione sequenza mediante pulsante
68bool attivaSequenza = 0;
69 
70void setup() {
71  // inizializzazione della serial monitor
72  Serial.begin(9600);
73 
74  // impostiamo tutti i pin ad output
75  for (byte x = 0; x < 8; x++) {
76    pinMode(ledPin[x], OUTPUT);
77  }
78  pinMode(pulsante, INPUT);
79 
80  // Memorizzazione del tempo trascorso
81  // dal momento in cui avviamo Arduino
82  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
83  // http://wp.me/p4kwmk-1QG
84  tempoTrascorso = millis();
85}
86 
87void spegniLed() {
88  for (byte x = 0; x < 8; x++) {
89    digitalWrite(ledPin[x], LOW);
90  }
91}
92 
93// Stampa del messaggio su Serial Monitor:
94// "Inserisci il ritardo in millisecondi: "
95void inserisciRitardo() {
96 
97  // consente di visualizzare sulla Serial Monitor
98  // una sola stampa delle stringa
99  if (abilitaMessaggio == 0) {
100    // ritardo che evita la doppia stampa del messaggio
101    delay(200);
102    Serial.print("Inserisci il ritardo in millisecondi: ");
103    abilitaMessaggio = 1;
104  }
105 
106  // Controlla se è disponibile almeno un carattere sulla seriale
107  // La Serial.available() restituisce
108  // 1 se presente un cattere,
109  // 0 se non è presente un carattere
110 
111  // per maggior informazioni sull'uso di parseInt() consultare il link:
112  // https://wp.me/p4kwmk-4Ah
113 
114  if (Serial.available()) {
115    int r = Serial.parseInt(); // in r viene memorizzato il valore inserito in numero
116    if (r != 0) {
117      ritardoLed = r;
118      Serial.println(ritardoLed);
119 
120      // abilita alla stampa di una nuova stringa:
121      // "Inserisci il ritardo in millisecondi: "
122      abilitaMessaggio = 0;
123 
124      // abilita l'avvio del Blink sequenziale dei LED
125      abilitaBlink = 1;
126    }
127  }
128}
129 
130void loop() {
131  inserisciRitardo();
132  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento e abilitaBlink == 1
133  // allora si cambia stato (si accende il LED successivo).
134 
135  // L'AND con "abilitaBlink == 1" permette di avviare la sequenza di accensione
136  // solo dopo l'inserimento del valore di ritardoLed, se non si facesse questo controllo
137  // al primo avvio tutti i LED sarebbero accessi perché la funzione cambiaStatoLed() verrebbe
138  // richiamata continuamente in quanto la differenza è sempre > di "ritardoLed" che è 0 e non
139  // si percepirebbe il cambiamento di stato.
140 
141 
142  if (((millis() - tempoTrascorso) > ritardoLed) && (abilitaBlink == 1)) {
143    controlloPulsante();
144    tempoTrascorso = millis();
145  }
146}
147 
148// la funzione controlloPulsante() verifica lo stato
149// attuale e precedente del pulsante in modo in modo che
150// ad ogni pressioni venga avviata o fermata la sequenza,
151// in modo che il funzionamento sia come quello di un interruttore
152// Una pressione avvia la sequenza, seconda pressione ferma la sequenza.
153 
154void controlloPulsante() {
155  stato = digitalRead(pulsante);
156 
157  // controllo se il pulsante è stato premuto
158  if ((stato == HIGH) && (stato_precedente == LOW)) {
159    attivaSequenza = 1 - attivaSequenza;
160    delay(15);
161  }
162 
163  stato_precedente = stato;
164 
165  if (attivaSequenza == 1) {
166    cambiaStatoLed();
167  } else {
168    spegniLed();
169  }
170}
171 
172// la funzione cambiaStatoLed() permette di controllare
173// la sequenza di accensione dei LED
174 
175void cambiaStatoLed() {
176  // spegne tutti i LED
177  for (byte x = 0; x < 8; x++) {
178    digitalWrite(ledPin[x], LOW);
179  }
180  // accende il LED corrente
181  digitalWrite(ledPin[ledCorrente], HIGH);
182  // incrementa la variabile direzione
183  ledCorrente += direzione;
184  // cambia la direzione se si arriva alla fine
185  if (ledCorrente == 7) {
186    direzione = -1;
187  }
188  if (ledCorrente == 0) {
189    direzione = 1;
190  }
191}

Sketch 07

Attivazione ciclica. Comando accensione sequenziale di 8 LED con un pulsante. Ad ogni pressione si accende il LED successivo. All’avvio si accende il primo LED. Accesso l’ultimo LED, la pressione successiva del pulsante accende il primo LED della serie.

Video Player

Lo schema di collegamento è analogo a quello utilizzato per lo sketch 05.

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2   30.12.2020
3   Lezione di riferimento: https://wp.me/p4kwmk-4D3
4 
5   Versione 07
6   Attivazione ciclica.
7   Comando accensione sequenziale di 8 LED con un pulsante.
8   Ad ogni pressione si accende il LED successivo.
9 
10   All'avvio si accende il primo LED.
11   Accesso l'ultimo LED, la pressione successiva
12   del pulsante accende il primo LED.
13 
14   Questo codice è di dominio pubblico
15*/
16 
17// abilitazione/disabilitazione pausa sequenza
18byte pulsante = 11;
19 
20// creazione di un array di 8 pin a cui vanno collegati i LED
21// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
22// http://wp.me/p4kwmk-26e
23 
24byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};
25 
26// per approfondimenti sull'uso dei tipi di dati
27// si consultino i link:
28// https://wp.me/p4kwmk-4As
29// https://wp.me/p4kwmk-1zF
30 
31void setup() {
32  // impostiamo tutti i pin ad output
33  for (byte x = 0; x < 8; x++) {
34    pinMode(ledPin[x], OUTPUT);
35  }
36  pinMode(pulsante, INPUT);
37}
38 
39// inizializzazione della variabile utilizzata per memorizzare
40// il pin del LED attivo in un determinato istante
41byte pinAttivo = 3;
42 
43void loop() {
44 
45  // se il pulsante è stato premuto si incrementa la variabile pinAttivo
46  // al raggiungimento del valore limite alla successiva pressione viene
47  // attivato il primo LED, quello collegato al pin 3
48 
49  if (digitalRead(pulsante)) {
50    pinAttivo++;
51    if (pinAttivo >= 11) {
52      pinAttivo = 3;
53    }
54    delay(250);
55  }
56 
57  // ogni volta che viene incrementata la variabile pinAttivo
58  // vengono spenti tutti i LED accendendo solo quello collegato
59  // al pin corrispondente alla variabile pinAttivo
60 
61  for (byte i = 0; i < 8; i++) {
62    digitalWrite(ledPin[i], LOW);
63  }
64 
65  // Viene acceso il LED collegato al pinAttivo
66 
67  digitalWrite(pinAttivo, HIGH);
68}

Sketch 08

Attivazione avanti/indietro. Comando accensione sequenziale di 8 LED con un pulsante. Ad ogni pressione si accende il LED successivo, raggiunto l’ultimo LED si controllerà l’attivazione dei LED in senso inverso.

Video Player

Lo schema di collegamento è analogo a quello utilizzato per lo sketch 05.

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2   30.12.2020
3   Lezione di riferimento: https://wp.me/p4kwmk-4D3
4 
5   Versione 08
6   Attivazione avanti/indietro.
7   Comando accensione sequenziale di 8 LED con un pulsante.
8   Ad ogni pressione si accende il LED successivo,
9   raggiunto l'ultimo LED si controllerà l'attivazione dei
10   LED in senso inverso.
11 
12   Questo codice è di dominio pubblico
13*/
14 
15// controllo accensione LED
16byte pulsante = 11;
17 
18// creazione di un array di 8 pin a cui vanno collegati i LED
19// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
20// http://wp.me/p4kwmk-26e
21 
22byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};
23 
24// per approfondimenti sull'uso dei tipi di dati
25// si consultino i link:
26// https://wp.me/p4kwmk-4As
27// https://wp.me/p4kwmk-1zF
28 
29void setup() {
30 
31  // impostiamo tutti i pin ad output
32  for (byte x = 0; x < 8; x++) {
33    pinMode(ledPin[x], OUTPUT);
34  }
35  pinMode(pulsante, INPUT);
36}
37 
38// inizializzazione della variabile utilizzata per memorizzare
39// il pin del LED attivo in un determinato istante
40byte pinAttivo = 3;
41 
42// indicatore di direzione di accensione
43byte direzione = 1;
44 
45// indice dell'array per l'accensione del LED
46byte ledCorrente = 0;
47 
48void loop() {
49 
50  // se il pulsante viene premuto si incrementa la variabile ledCorrente
51  // usata come indice dell'array di LED, che sarà incrementata di una
52  // unità ad ogni pressione, al raggiungimento del valore massimo (7) viene
53  // modificata la direzione di accensione e decrementando la variabile
54  // ledCorrente, al raggiungimento del valore minimo (0) viene
55  // modificata la direzione di accensione.
56 
57  if (digitalRead(pulsante)) {
58 
59    // spegne tutti i LED
60    for (byte x = 0; x < 8; x++) {
61      digitalWrite(ledPin[x], LOW);
62    }
63 
64    // accende il LED corrente
65    digitalWrite(ledPin[ledCorrente], HIGH);
66    // incrementa la variabile direzione
67    ledCorrente += direzione;
68    // cambia la direzione se si arriva alla fine
69    if (ledCorrente == 7) {
70      direzione = -1;
71    }
72    if (ledCorrente == 0) {
73      direzione = 1;
74    }
75  }
76  delay(250);
77}

Sketch 09

Sequenza di accensione e spegnimento di 8 LED mediante due pulsanti. All’avvio tutti i LED sono spenti. Alla pressione del pulsante di sinistra si comanda l’accensione e lo spegnimento da destra verso sinistra dei LED. Alla pressione del pulsante di destra si comanda l’accensione e lo spegnimento da sinistra verso destra dei LED.

Video Player

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2   30.12.2020
3   Lezione di riferimento: https://wp.me/p4kwmk-4D3
4 
5   Versione 09
6   Sequenza di accensione e spegnimento di 8 LED
7   mediante due pulsanti
8 
9   All'avvio tutti i LED sono spenti.
10 
11   Alla pressione del pulsante di sinistra si comanda
12   l'accensione e lo spegnimento da destra verso sinistra dei LED.
13   Alla pressione del pulsante di destra si comanda
14   l'accensione e lo spegnimento da sinistra verso destra dei LED.
15 
16   Questo codice è di dominio pubblico
17*/
18 
19// controllo accensione LED da DX a SX
20byte pulsanteSx = 11;
21 
22// controllo accensione LED da SX a DX
23byte pulsanteDx = 12;
24 
25// creazione di un array di 8 pin a cui vanno collegati i LED
26// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
27// http://wp.me/p4kwmk-26e
28 
29byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};
30 
31// per approfondimenti sull'uso dei tipi di dati
32// si consultino i link:
33// https://wp.me/p4kwmk-4As
34// https://wp.me/p4kwmk-1zF
35 
36void setup() {
37 
38  // impostiamo tutti i pin ad output
39  for (byte x = 0; x < 8; x++) {
40    pinMode(ledPin[x], OUTPUT);
41  }
42  pinMode(pulsanteSx, INPUT);
43  pinMode(pulsanteDx, INPUT);
44}
45 
46// inizializzazione della variabile utilizzata per memorizzare
47// il pin del LED attivo in un determinato istante
48byte pinAttivo = 3;
49 
50// indicatore di direzione di accensione
51byte direzione = 1;
52 
53// indice dell'array per l'accensione del LED
54byte ledCorrente = 0;
55 
56void loop() {
57 
58  // se il pulsante SX viene premuto si incrementa la variabile pinAttivo
59  // al raggiungimento del valore limite alla successiva pressione
60  // viene spento l'ultimo LED e pressioni successive del pulsante di SX
61  // non causerà nulla
62 
63  if (digitalRead(pulsanteSx)) {
64    pinAttivo++;
65    if (pinAttivo > 10) {
66      pinAttivo = 10;
67    }
68    delay(250);
69  }
70 
71  // se il pulsante DX viene premuto si decrementa la variabile pinAttivo
72  // al raggiungimento del valore limite alla successiva pressione
73  // viene spento l'ultimo LED e pressioni successive del pulsante di DX
74  // non causerà nulla
75 
76  if (digitalRead(pulsanteDx)) {
77    pinAttivo--;
78    if (pinAttivo < 3) {
79      pinAttivo = 3;
80    }
81    delay(250);
82  }
83 
84  // ogni volta che viene incrementata la variabile pinAttivo
85  // vengono spenti tutti i LED accendendo solo quello collegato
86  // al pin corrispondente alla variabile pinAttivo
87 
88  for (byte i = 0; i < 8; i++) {
89    digitalWrite(ledPin[i], LOW);
90  }
91 
92  // Viene acceso il LED collegato al pinAttivo
93 
94  digitalWrite(pinAttivo, HIGH);
95}

Buon making a tutti 🙂

Articoli correlati:

  1. Evitare il loop di messaggi inviati sulla Serial Monitor
  2. Arduino: utilizzo del metodo parseInt() per la conversione di un stringa di testo che rappresenta un numero in un numero
  3. Arduino: tipi di dati – ripasso
  4. Arduino: Il mio stack su delicious
  5. Appunti su Arduino: pilotare un display LCD

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito utilizza Akismet per ridurre lo spam. Scopri come vengono elaborati i dati derivati dai commenti.