Archivi tag: const

Arduino – Uso di LED RGB – approfondimento

Scrivo questa lezione come approfondimento della guida realizzata tempo fa: Arduino – lezione 09: uso di LED RGB in cui mostravo come funzionano e come si gestiscono i LED RGB con Arduino. Negli esercizi proposti utilizzavo un LED ad ANODO comune. In questa nuova lezione utilizzerò un diodo a CATODO comune e mostrerò tre esempi, nel primo ripropongo in una modalità diversa l’esercizio della prima lezione in cui faccio alcuni approfondimenti sull’uso della direttiva #define, mentre nel secondo e terzo esercizio viene mostrato come impostare il colore emesso dal LED RGB mediante input da tastiera su Serial Monitor richiamando con questi esempi l’uso del qualificatore const per una variabile e l’utilizzo della funzione parseInt(). Come sempre nei commenti, all’interno del codice, trovate la spiegazione del funzionamento di ogni parte dello sketch.

Esempio 01

Variazione colore continuo di un LED RGB secondo lo schema:

ROSSO > VERDE, VERDE > BLU, BLU > ROSSO

Scema di collegamento

1/*  Prof. Maffucci Michele
2    06.01.2021
3 
4    Esempio 01
5    Variazione colore continuo
6    di un LED RGB secondo lo schema:
7 
8    ROSSO > VERDE, VERDE > BLU, BLU > ROSSO
9 
10*/
11 
12/* Utilizzo della direttiva #define per definire una costante
13   La direttiva viene utilizzata per definire una MACRO ovvero
14   un simbolo.
15 
16   La sintassi per la definizione di una macro è:
17   #define nome-MACRO  valore_MACRO
18 
19   Per convenzione il nome della macro viene scritta in maiuscolo.
20 
21   Il preprocessore legge la definizione di ogni MACRO e ogni volta che
22   ne incontra il nome all'interno del programma (file sorgente) sostituisce
23   al simbolo il valore corrispondente, senza che venga effettuata la verifica
24   della correttezza sintattica dell'espressione risultante.
25*/
26 
27#define VERDE 9
28#define BLU 10
29#define ROSSO 11
30 
31// tempo di dissolvenza tra i colori
32#define tempoRitardo 10
33 
34void setup()
35{
36  // impostazione ad OUTPUT dei pin
37  pinMode(ROSSO, OUTPUT);
38  pinMode(VERDE, OUTPUT);
39  pinMode(BLU, OUTPUT);
40 
41  // all'avvio viene emesso il colorore ROSSO
42  digitalWrite(BLU, LOW);
43  digitalWrite(VERDE, LOW);
44  digitalWrite(ROSSO, HIGH);
45}
46 
47// definizione di variabili
48int valoreRosso;
49int valoreVerde;
50int valoreBlu;
51 
52void loop()
53{
54  // Impostazioni variabili per avere partire con LED:
55  // ROSSO accesso, VERDE spento, BLU spento.
56  valoreRosso = 255;
57  valoreVerde = 0;
58  valoreBlu = 0;
59 
60  // partendo dal ROSSO si sfuma al VERDE pieno quando i = 255
61  for (int i = 0; i < 255; i += 1)
62  {
63    valoreRosso -= 1;
64    valoreVerde += 1;
65 
66    // L'intensità del ROSSO viene diminuita ad ogni ciclo, mentre
67    // l'intensità del VERDE viene aumentata ad ogni ciclo
68    analogWrite(ROSSO, valoreRosso);
69    analogWrite(VERDE, valoreVerde);
70    delay(tempoRitardo);
71  }
72 
73  // Impostazioni variabili per avere partire con LED:
74  // ROSSO spento, VERDE acceso, BLU spento.
75  valoreRosso = 0;
76  valoreVerde = 255;
77  valoreBlu = 0;
78 
79  // partendo dal VERDE si sfuma al BLU pieno quando i = 255
80  for (int i = 0; i < 255; i += 1)
81  {
82    valoreVerde -= 1;
83    valoreBlu += 1;
84 
85    // L'intensità del VERDE viene diminuita ad ogni ciclo, mentre
86    // l'intensità del BLU viene aumentata ad ogni ciclo
87    analogWrite(VERDE, valoreVerde);
88    analogWrite(BLU, valoreBlu);
89    delay(tempoRitardo);
90  }
91 
92  // Impostazioni variabili per avere partire con LED:
93  // ROSSO spento, VERDE spento, BLU acceso.
94  valoreRosso = 0;
95  valoreVerde = 0;
96  valoreBlu = 255;
97 
98  // partendo dal BLU si sfuma al ROSSO pieno quando i = 255
99  for (int i = 0; i < 255; i += 1)
100  {
101    valoreBlu -= 1;
102    valoreRosso += 1;
103 
104    // L'intensità del BLU viene diminuita ad ogni ciclo, mentre
105    // l'intensità del ROSSO viene aumentata ad ogni ciclo
106    analogWrite(BLU, valoreBlu);
107    analogWrite(ROSSO, valoreRosso);
108    delay(tempoRitardo);
109  }
110}

Esempio 02

Inserimento da Serial Monitor dei valori di intensità del colore. La stringa di richiesta inserimento dei valori RGB viene ripetuta una sola volta e ad ogni nuovo inserimento non viene stampato sulla serial monitor il valore inserito.

Lo schema di collegamento è il medesimo dell’esempio 01.

1/*  Prof. Maffucci Michele
2    06.01.2021
3 
4    Esempio 02
5    Inserimento da Serial Monitor dei valori
6    di intensità del colore.
7    La stringa di richiesta inserimento viene ripetuta una sola volta.
8    Ad ogni nuovo inserimento non viene stampato sulla serial monitor
9    il valore inserito.
10 
11    L'inserimento dei tre valori potrà essere effettuato
12    in una delle due modalità:
13    1. separando i tre numeri con spazio
14    2. separando i tre numeri con la virgola
15*/
16 
17/*
18   Una variabile const indica al compilatore che il valore della
19   variabile non può essere modificato durante l'esecuzione del programma.
20   Una variabile const viene inizializzata nel momento della dichiarazione,
21   se ciò viene fatto in un momento successivo il compilatore rileverà un
22   errore che segnalerà anche errore in ogni operazione che comportano la
23   modifica del valore dell avariabile definita come const
24*/
25 
26const byte pinRosso = 11;
27const byte pinBlu = 10;
28const byte pinVerde = 9;
29 
30void setup() {
31  // Inizializzazione della comunicazione seriale
32  Serial.begin(9600);
33 
34  // Impostazione dei pin come OUTPUT
35  pinMode(pinRosso, OUTPUT);
36  pinMode(pinBlu, OUTPUT);
37  pinMode(pinVerde, OUTPUT);
38 
39  // Messaggio sulla serial monitor
40  Serial.println("Inserisci i valori R G B (es. 125, 50, 255)");
41  Serial.println("-------------------------------------------");
42  delay(1000);
43}
44 
45void loop() {
46 
47  // Controlla se è disponibile almeno un carattere sulla seriale
48  // La Serial.available() restituisce
49  // 1 se presente un cattere,
50  // 0 se non è presente un carattere
51 
52  // per maggior informazioni sull'uso di parseInt() consultare il link:
53  // https://wp.me/p4kwmk-4Ah
54 
55  if (Serial.available()) {
56    // memorizzazione dei colori nelle variabili
57    int rosso = Serial.parseInt();
58    int verde = Serial.parseInt();
59    int blu = Serial.parseInt();
60 
61    // impostazione del PWM
62    analogWrite(pinRosso, rosso);
63    analogWrite(pinVerde, verde);
64    analogWrite(pinBlu, blu);
65  }
66}

Esempio 3

Inserimento da Serial Monitor dei valori di intensità del colore.
Il valore inserito verrà stampato sulla Serial Monitor e ad ogni invio verrà richiesto di inserire un nuovo valore.

Lo schema di collegamento è il medesimo dell’esempio 01.

1/*  Prof. Maffucci Michele
2    06.01.2021
3 
4    Esempio 03
5    Inserimento da Serial Monitor dei valori
6    di intensità del colore.
7    Il valore inserito verrà stampato sulla Serial Monitor e ad ogni
8    invio verrà richiesto di inserire un nuovo valore.
9 
10    L'inserimento dei tre valori potrà essere effettuato
11    in una delle due modalità:
12    1. separando i tre numeri con spazio
13    2. separando i tre numeri con la virgola
14*/
15 
16/*
17   Una variabile const indica al compilatore che il valore della
18   variabile non può essere modificato durante l'esecuzione del programma.
19   Una variabile const viene inizializzata nel momento della dichiarazione,
20   se ciò viene fatto in un momento successivo il compilatore rileverà un
21   errore che segnalerà anche errore in ogni operazione che comportano la
22   modifica del valore dell avariabile definita come const
23*/
24 
25const byte pinRosso = 11;
26const byte pinBlu = 10;
27const byte pinVerde = 9;
28 
29// per stampare una sola volta il messaggio sulla Serial Monitor
30bool abilitaMessaggio = 0;
31 
32void setup() {
33  // Inizializzazione della comunicazione seriale
34  Serial.begin(9600);
35 
36  // Impostazione dei pin come OUTPUT
37  pinMode(pinRosso, OUTPUT);
38  pinMode(pinBlu, OUTPUT);
39  pinMode(pinVerde, OUTPUT);
40}
41 
42void loop() {
43  // consente di visualizzare sulla Serial Monitor
44  // una sola stampa delle stringa
45  if (abilitaMessaggio == 0) {
46    // ritardo che evita la doppia stampa del messaggio
47    delay(200);
48    Serial.print("Inserisci i valori R G B (es. 125, 50, 255): ");
49    abilitaMessaggio = 1;
50  }
51 
52  // Controlla se è disponibile almeno un carattere sulla seriale
53  // La Serial.available() restituisce
54  // 1 se presente un cattere,
55  // 0 se non è presente un carattere
56 
57  // per maggior informazioni sull'uso di parseInt() consultare il link:
58  // https://wp.me/p4kwmk-4Ah
59 
60 
61  if (Serial.available()) {
62    // memorizzazione dei colori nelle variabili
63    int rosso = Serial.parseInt();
64    int verde = Serial.parseInt();
65    int blu = Serial.parseInt();
66    Serial.print(rosso);
67    Serial.print(", ");
68    Serial.print(verde);
69    Serial.print(", ");
70    Serial.println(blu);
71    Serial.println("-------------------------------------------");
72 
73    // impostazione del PWM
74    analogWrite(pinRosso, rosso);
75    analogWrite(pinVerde, verde);
76    analogWrite(pinBlu, blu);
77 
78    // abilita alla stampa di una nuova stringa:
79    // "Inserisci il ritardo in millisecondi: "
80    abilitaMessaggio = 0;
81  }
82}

Esercizi per i miei studenti

Esercizio 1

Utilizzare tre pulsanti che funzionino come interruttori che permettono di accendere e spegnere un solo LED alla volta:

pulsante 1: LED ROSSO
pulsante 2: LED VERDE
pulsante 3: LED BLU

Ogni cambiamento di stato deve essere segnalato sulla Serial Monitor.

Esercizio 2

Utilizzare due pulsanti in gredo di realizzare la seguente automazione:

pulsante 1: attivare/disattivare la modalità di variazione continua del colore, così come esposta nell’esempio 01
pulsante 2: attivare/disattivare la generazione casuale di un colore

Ogni cambiamento di stato deve essere segnalato sulla Serial Monitor.

Esercizio 3

Utilizzando la Serial Monitor come unico strumento per inviare comandi ad Arduino, realizzare un menù di selezione che permette di impostare le funzionalità dell’esercizio 01 e dell’esercizio 03.

Errori comuni nell’uso di Arduino – inserimento del punto e virgola alla fine di ogni istruzione

Lascia una risposta

Il punto e virgola è usato come segno di terminazione istruzione, ma non è da usare nelle istruzioni composte: if, for, while, do while e la direttiva per il preprocessore #define.

Di seguito alcuni esempi che mettono in evidenza questo tipico errore.

Versione non corretta

1if (temperatura > 25);          // questo punto e virgola non è corretto
2{
3  digitalWrite (normaleTemp, LOW);
4  digitalWrite (allarmeTemp, HIGH);
5}
6 
7for (int i = 0; i < 15; i++);   // questo punto e virgola non è corretto
8  digitalWrite (i, HIGH);

I punti e virgola indicati nell’esempio sopra terminano le istruzioni “if” e “for” e ciò non permetterà l’esecuzione delle istruzioni che sono presenti nel corpo delle rispettive istruzioni.

Versione corretta

1if (temperatura > 25)
2{
3  digitalWrite (normaleTemp, LOW);
4  digitalWrite (allarmeTemp, HIGH);
5}
6 
7for (int i = 0; i < 15; i++)
8digitalWrite (i, HIGH);

In questo caso le istruzioni presenti nel corpo della if vengono eseguite se la condizione temperatura>25 è vera, nel secondo caso, nel for, sarà eseguita l’istruzione che segue fino a quando la condizioni<15 risulta vera.

Come si può notare nel for, nel caso in cui sia presente una sola istruzione nel corpo, non è indispensabile inserire le parentesi graffe, non è comunque un errore inserirle e scrivere:

1...
2for (int i = 0; i < 15; i++)
3{
4  digitalWrite (i, HIGH);
5}

Errore simile viene spesso commesso quando si usa il #define

Versione non corretta

`1`	`#define PIN_LED 8; // non bisogna inserire il punto e virgola`

`2`	`#define PIN_LED = 8; // non bisogna inserire ne = e ne ;`

Versione corretta

`1`	`#define PIN_LED 8`

il #define non richiede il punto e virgola.

Possiamo ottenere lo stesso risultato dell’istruzione precedente utilizzando const:

`1`	`const` `byte PIN_LED = 8;`

Questa scrittura rimane coerente rispetto alla scrittura delle variabili che fa uso dei simboli = e ; ma non efficiente dal punto dello spazio di memoria utilizzata rispetto alla #define.

Buon Coding a tutti

Michele Maffucci

… my stories, life and work

Archivi tag: const

Arduino – Uso di LED RGB – approfondimento

Errori comuni nell’uso di Arduino – inserimento del punto e virgola alla fine di ogni istruzione

Condividi:

Articoli correlati:

Condividi:

Articoli correlati: