Archivi tag: parseInt()

Arduino: controllare il movimento di un motore a spazzola con un transistor

Abbiamo visto a lezione in cosa consiste la Modulazione di Larghezza di Impulso, in altro modo conosciuta come PWM (Pulse Width Modulation). Questo tipo di modulazione permette ad un sistema digitale di controllare dispositivi di tipo analogico in corrente continua facendo variare in modo continuo la potenza erogata, quindi moduliamo la larghezza di un impulso, ovvero la durata temporale di una serie di impulsi che regolerà l’attivazione e disattivazione del motore. Con il PWM agiamo non sulla tensione di alimentazione per controllare la velocità del motore, ma bensì sul tempo, per maggiori informazioni vi rimando alle slide: Alfabeto Arduino – Lezione 2 in cui come esempio viene controllata l’intensità luminosa di LED. (Per i miei studenti fate riferimento al libro di testo e agli appunti di teoria).

Il transistor nell’immagine che segue viene fatto funzionare in modalità ON-OFF e quindi possiamo assimilarlo ad un interruttore che si apre e si chiude in corrispondenza del segnale presente sulla base del transistor. Se il segnale sulla base è alto il transistor sarà in conduzione e il motore potrà essere alimentato (si chiude verso massa il collegamento del motore). Se il segnale sulla base del transistor è a livello basso il transistor è assimilabile ad un interruttore aperto per cui il motore risulta non alimentato (non si ha collegamento a massa). Quindi al motore verrà applicata una tensione continua proporzionale al duty cycle e quindi variando il duty cycle varieremo la velocità di rotazione del motore.

La generazione dell’onda quadra, che controlla la velocità del motore, viene eseguita da Arduino. Il diodo presente nel circuito è chiamato diodo di ricircolo ed è inserito in parallelo al motore (carico induttivo) per sopprimere i transienti elettrici ed è collegato in modo tale che non conduce quando il carico (il motore) viene alimentato.
Quando il motore viene disattivato rapidamente si avrà un picco di tensione in senso inverso perché l’induttore tenderà a mantenere costante la corrente che circola al suo interno, in questa situazione però il diodo sarà polarizzato direttamente e tutta la corrente scorrerà dall’induttore al diodo e l’energia che era stata immagazzinata dall’induttore viene dissipata in calore dalla componente resistiva dell’induttore. Inserendo il diodo si eviterà di applicare una sovratensione sul collettore del transistor evitando quindi che si danneggi.

Controlliamo con Arduino il movimento del motore

Lista Componenti

Arduino UNO R3
Resistore da 1 K Ohm
Dido: 1N4001
Transistor: 2N2222
Condensatore: 0,1 microF

Pinout transistor 2N2222

Circuito 1 di montaggio: alimentazione del motore prelevata da Arduino

Circuito 2 di montaggio: alimentazione del motore esterna ad Arduino

Esempio 1
Si faccia riferimento al circuito 1. Realizziamo uno sketch che permette la regolazione della velocità del motore inserendo un numero compreso tra 0 e 9. Il valore 0 ferma il motore, il valore 9 permette di muovere il motore alla velocità massima, valori intermedi movimenteranno il motore ad una velocità proporzionale al numero inserito.

Valori fuori dall’intervallo impostato restituiscono un messaggio di errore.

Per la realizzazione di questo sketch si utilizza la funzione isDigit() che restituisce TRUE verifica se il carattere inviato sulla Serial Monitor è un numero, altrimenti restituisce FALSE.

1/*
2   Prof. Maffucci Michele
3   Controllo motore a spazzola:
4   accensione, spegnimento, controllo velocità.
5   All'avvio del programma il motore è spento.
6 
7   La velocità del motore è impostata
8   con un valore compreso tra 0 e 9
9 
10   Valori non numerici restituiscono
11   un messaggio di errore
12    
13   Data: 19.01.2021
14*/
15 
16// driver del motore collegato al pin 6
17const byte pinMotore = 6; // motor driver is connected to pin 3
18 
19// per stampare una sola volta il messaggio sulla Serial Monitor  
20bool abilitaMessaggio = 0;
21 
22void setup()
23{
24  // inizializzazione della serial monitor
25  Serial.begin(9600);
26 
27  // inizializzazione OUTPUT del pin 6
28  pinMode(pinMotore, OUTPUT);
29}
30 
31void loop()
32{
33  // consente di visualizzare sulla Serial Monitor
34  // una sola stampa delle stringa
35  if (abilitaMessaggio == 0) {
36    // ritardo che evita la doppia stampa del messaggio 
37    delay(200);
38    Serial.println("Controllo velocità motore");
39    Serial.println("Inserire la velocità (0 - 9)");
40    Serial.println();
41    abilitaMessaggio = 1;
42  }
43 
44  // Controlla se è disponibile almeno un carattere sulla seriale
45  // La Serial.available() restituisce
46  // 1 se presente un cattere,
47  // 0 se non è presente un carattere
48 
49  // per maggior informazioni sull'uso di parseInt() consultare il link:
50  // https://wp.me/p4kwmk-4Ah
51   
52  if (Serial.available()) {        // Viene controllato se è disponibile un carattere
53 
54    // definizione di una variabile di tipo char in cui memorizzare
55    // il carattere inviato ad Arduino mediante la Serial Monitor
56 
57    char carattere = Serial.read();
58 
59    // La funzione isDigit restituisce TRUE se se il carattere
60    // inviato sulla Serial Monitor è un numero altrimenti restituisce FALSE
61 
62    if (isDigit(carattere)) // verifica se è un numero
63    {
64      // mappiamo l'intervallo dei caratteri da '0' a '9'
65      // in un valore compreso tra 0 e 255, intervallo di valori
66      // del Duty Cycle
67 
68      int vel = map(carattere, '0', '9', 0, 255);
69      analogWrite(pinMotore, vel);
70       
71      Serial.print("Valore del Duty Cycle: ");
72      Serial.println(vel);
73      Serial.println("--------------------------");
74      Serial.print("Velocità impostata: ");
75      Serial.println(carattere);
76      Serial.println("==========================");
77             
78    }
79    else
80    {
81      // nel caso in cui il carattere inserito non è un numero
82      // viene restituito un messaggio e stampa il carattere
83      Serial.println();
84      Serial.println("******************************");
85      Serial.print("Carattere non riconosciuto: ");
86      Serial.println(carattere);
87      Serial.println("******************************");
88      Serial.println();
89    }
90  }
91}

Esempio 2
Si faccia riferimento al circuito 1. Realizziamo uno sketch che permette la regolazione della velocità del motore inserendo un numero compreso tra 0 e 9. Il valore 0 ferma il motore, il valore 9 permette di muovere il motore alla velocità massima, valori intermedi movimenteranno il motore ad una velocità proporzionale al numero inserito.

Valori fuori dall’intervallo impostato fermano il motore.

Per la realizzazione di questo sketch si utilizza la funzione Serial.parseInt() che legge i caratteri sulla seriali e restituisce la loro rappresentazione numerica (tipo long). I caratteri che non sono numeri interi (o con segno meno) vengono ignorati.

Nel dettaglio

I caratteri iniziali che non sono cifre o sono numeri negativi vengono ignorati;
L’analisi si interrompe quando non sono stati letti caratteri per un valore di tempo di timeout che può essere configurato oppure viene letta una non cifra;
Se non sono state lette cifre valide quando si verifica il timeout (vedere Serial.setTimeout ()), viene restituito 0; Serial.parseInt () eredita dalla classe Stream.

1/*
2   Prof. Maffucci Michele
3   Controllo motore a spazzola:
4   accensione, spegnimento, controllo velocità.
5   All'avvio del programma il motore è spento.
6 
7   La velocità del motore è impostata
8   con un valore compreso tra 0 e 9
9 
10   Valori non numerici fermano il motore.
11 
12   Viene utilizzata la funzione Serial.parseInt() per leggere
13 
14   Data: 19.01.2021
15 
16*/
17 
18// driver del motore collegato al pin 6
19const byte pinMotore = 6; // motor driver is connected to pin 3
20 
21// per stampare una sola volta il messaggio sulla Serial Monitor
22bool abilitaMessaggio = 0;
23 
24void setup()
25{
26  // inizializzazione della serial monitor
27  Serial.begin(9600);
28 
29  // inizializzazione OUTPUT del pin 6
30  pinMode(pinMotore, OUTPUT);
31}
32 
33void loop()
34{
35  // consente di visualizzare sulla Serial Monitor
36  // una sola stampa delle stringa
37  if (abilitaMessaggio == 0) {
38    // ritardo che evita la doppia stampa del messaggio
39    delay(200);
40    Serial.println("Controllo velocità motore");
41    Serial.println("Inserire la velocità (0 - 9)");
42    Serial.println();
43    abilitaMessaggio = 1;
44  }
45 
46  // Controlla se è disponibile almeno un carattere sulla seriale
47  // La Serial.available() restituisce
48  // 1 se presente un cattere,
49  // 0 se non è presente un carattere
50 
51  // per maggior informazioni sull'uso di parseInt() consultare il link:
52  // https://wp.me/p4kwmk-4Ah
53 
54  if (Serial.available()) {        // Viene controllato se è disponibile un carattere
55 
56    // definizione di una variabile di tipo char in cui memorizzare
57    // il carattere inviato ad Arduino mediante la Serial Monitor
58 
59    // per maggior informazioni sull'uso di parseInt() consultare il link:
60    // https://wp.me/p4kwmk-4Ah
61 
62    int valore = Serial.parseInt();
63 
64    // La funzione isDigit verifica se il carattere inviato è un numero
65    // e restituisce TRUE se il carattere è un numero altrimenti restituisce FALSE
66 
67    // mappiamo l'intervallo dei caratteri da '0' a '9'
68    // in un valore compreso tra 0 e 255, intervallo di valori
69    // del Duty Cycle
70 
71    if (valore >= 0 && valore <= 9) {
72 
73      if (valore == 0) {
74        Serial.println();
75        Serial.println("************************************");
76        Serial.println("MOTORE FERMO");
77        Serial.println("Valore inserito 0 o fuori intervallo");
78        Serial.println("************************************");
79        Serial.println();
80      }
81 
82      int vel = map(valore, 0, 9, 0, 255);
83      analogWrite(pinMotore, vel);
84 
85      Serial.print("Valore del Duty Cycle: ");
86      Serial.println(vel);
87      Serial.println("--------------------------");
88      Serial.print("Velocità impostata: ");
89      Serial.println(valore);
90      Serial.println("==========================");
91    }
92  }
93}

Esercizio 1
Aggiungere al circuito 1 due pulsanti che permettono di aumentare o diminuire la velocità del motore. Fare in modo che la velocità impostata del motore sia proporzionale ai valori numerici interi nell’intervallo tra 0 e 9, così come fatto negli esempi precedenti. Ad ogni pressione del pulsante P1 si incrementa di una unità il valore della velocità. Ad ogni pressione del pulsante P2 si decrementa la velocità del motore i una unità. All’avvio di Arduino il motore è spento. Mostrare la velocità impostata sulla serial monitor.

Esercizio 2
Aggiungere all’esercizio precedente un pulsante P3 di emergenza che alla pressione ferma il motore. Se è stata azionata l’emergenza i pulsanti P1 e P2 di incremento e decremento non funzionano. Per poter riattivare il sistema bisogna premere nuovamente P3.

Arduino – Uso di LED RGB – approfondimento

Lascia una risposta

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.

Arduino: utilizzo del metodo parseInt() per la conversione di un stringa di testo che rappresenta un numero in un numero

Lascia una risposta

Nel primo esercizio della lezione: Arduino: Stepper 28BYJ-48 – AccelStepper library veniva chiesto di impostare i parametri di azionamento del motore passo paso da Serial Monitor, questa operazione può essere svolta usando la classe toInt(), ma in modo più efficace e semplice possiamo usare la classe parseInt(). In questa breve lezione un esempio di controllo del lampeggio di un LED da Serial Monitor mediante l’uso di parseInt().

È possibile ricevere numeri con più di una cifra utilizzando i metodi parseInt e parseFloat che semplificano l’estrazione di valori numerici da seriale. (Funziona anche con Ethernet e altri oggetti derivati dalla classe Stream)

Serial.parseInt() e Serial.parseFloat() leggono i caratteri seriali e restituiscono la loro rappresentazione numerica.

I caratteri non numerici prima del numero vengono ignorati e il numero termina con il primo carattere che non è una cifra numerica (o “.” Se si utilizza parseFloat). Se non ci sono caratteri numerici nell’input, le funzioni restituiscono 0, quindi bisogna controllare i valori zero e gestirli in modo appropriato.

Nel dettaglio

I caratteri iniziali che non sono cifre o sono numeri negativi vengono ignorati;
L’analisi si interrompe quando non sono stati letti caratteri per un valore di tempo di timeout che può essere configurato oppure viene letta una non cifra;
Se non sono state lette cifre valide quando si verifica il timeout (vedere Serial.setTimeout ()), viene restituito 0; Serial.parseInt () eredita dalla classe Stream.

Se avete la Serial Monitor configurata per inviare una nuova riga o un ritorno a capo (o entrambi) quando fate clic su invia, parseInt o parseFloat proveranno ad interpretare il return come numero, ma poiché il ritorno a capo non è un numero il valore restituito da parseInt o parseFloat sarà zero.

Nell’esempio che segue un invio imposta blinkRitardo a zero il che implica che il LED non lampeggia.

1// Prof. Maffucci Michele
2// 10.11.2020
3// Impostazione del delay del Blink da tastiera
4 
5int lampeggioRitardo = 0;
6int chiave = 0;
7void setup()
8{
9  Serial.begin(9600); // inizializzazione della serial monitor
10  pinMode(LED_BUILTIN, OUTPUT); // imposta il pin come output
11}
12void loop()
13{
14  // ritardo per evitare una doppia scrittura
15  // della prima stampa a monitor
16  delay(1000);
17 
18  // consente di visualizzare sulla Serial Monitor
19  // una sola stampa delle stringa
20  if (chiave == 0) {
21    Serial.print("Inserisci il ritardo in millisecondi: ");
22    chiave = 1;
23  }
24 
25  // Controlla se è disponibile almeno un carattere sulla seriale
26  // La Serial.available() restituisce
27  // 1 se presente un cattere,
28  // 0 se non è presente un carattere
29   
30  if (Serial.available())
31  {
32    int r = Serial.parseInt(); // in r viene memorizzato il valore inserito in numero
33    if (r != 0) {
34      lampeggioRitardo = r;
35      Serial.println(lampeggioRitardo);
36 
37      // abilita alla stampa di una nuova stringa:
38      // "Inserisci il ritardo in millisecondi: "
39      chiave = 0;
40    }
41  }
42  lampeggio(); // funzione che fa lampeggiare il LED su Arduino
43}
44 
45// il LED lampeggia con i tempi di
46// accensione e spegnimento determinati da lampeggioRitardo
47void lampeggio()
48{
49  digitalWrite(LED_BUILTIN, HIGH);
50  delay(lampeggioRitardo); // il delay dipende dal valore in lampeggioRitardo
51  digitalWrite(LED_BUILTIN, LOW);
52  delay(lampeggioRitardo);
53}

Esercizio 1
Dato un LED RGB connesso ad Arduino, realizzare un selettore che da Serial Monitor consente di controllare l’accensione e lo spegnimento del rosso, del verde e del blu

Esercizio 2
Svolgere l’esercizio 1 della lezione Stepper 28BYJ-48 – AccelStepper library usando la parseInt()

Michele Maffucci

… my stories, life and work

Archivi tag: parseInt()

Arduino: controllare il movimento di un motore a spazzola con un transistor

Arduino – Uso di LED RGB – approfondimento

Arduino: utilizzo del metodo parseInt() per la conversione di un stringa di testo che rappresenta un numero in un numero

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati: