Archivi categoria: arduino

CoolTerm – Alternative alla Serial Monitor di Arduino

La comunicazione seriale viene usata in moltissimi dispositivi elettronici che utilizziamo ogni giorno. Rispetto alla comunicazione parallela (4, 8 o 64-bit), la comunicazione seriale è utilizzata spesso nei sistemi embedded a causa del basso costo e della trasmissione efficace nelle lunghe distanze.
Per chi opera con Arduino, sa che l’uso della Serial Monitor è necessario per la lettura di dati inviati serialemente tra Arduino ed il computer con altri dispositivi elettronici, ad esempio l’invio sulla Serial Monitor dei valori di temperatura rilevata da un sensore di temperatura connesso ad Arduino.

La comunicazione seriale è inoltre uno strumento utilissimo per effettuare il debug, ovvero inviare dei messaggi sulla seriale per l’utente al fine di rilevare errori o mettere in evidenza i passi di esecuzione di un programma o lo stato di un sistema.

I dati inviati da Arduino al Computer o viceversa possono essere visualizzati sul monitor del computer (attraverso la finestra della Serial Monitor) o su altri dispositivi come ad esempio un display LCD connesso ad Arduino.

Ho mostrato più volte in precedenti lezioni l’uso dei comandi seriali: Serial.begin(), Serial.print(), Serial.read() e l’utilizzo della Serial Plotter che permette di visualizzare il grafico su piano cartesiano dei dati seriali trasmessi da Arduino.

Sicuramente anche voi, nell’uso costante della Serial Monitor, avrete notato i limiti dello strumento, come esempio l’impossibilità del salvataggio dei dati inviati ad un file di log.
E’ utile quindi considerare l’uso di un terminale alternativo che offra maggiori funzionalità rispetto alla Serial Monitor, come ad esempio visualizzare:

i caratteri di controllo;
i dati in formato testo o binario o entrambi;
salvare i dati rilevati in un file di log.

Tra i molti software disponibili il mio consiglio va a CoolTerM, un terminale user-friendly estremamente utile.
CoolTerM viene distribuito con licenza freeware / donationware sviluppato da Roger Meier ed è disponibile per dispositivi Windows, Mac, Linux.

Come si usa CoolTerM per rilevare dati che provengono da Arduino.

A titolo di esempio sfruttiamo quanto già svolto in passato, visualizzimo su CoolTerM la distanza di un ostacolo rilevato da un sensore ad ultrasuoni.
Prendiamo come riferimento lo sketch che segue, tratto da una mia lezione sull’uso del sensore ad ultrasuoni per un kit robotico, nello stesso post trovate la teoria di funzionamento del sensore HC-SR04.

1/* Prof. Maffucci Michele
2    
3   Utilizzo del sensore ultrasuoni HC-SR04
4   Misura della distanza di un ostacolo
5 
6*/
7 
8long durata;          // durata dell'impulso
9long distanza;        // distanza dell'oggetto
10int pin_echo = 7;     // pin Arduino a cui è collegato il sensore SR04
11int pin_trig = 9;     // pin Arduino a cui è collegato il sensore SR04
12 
13void setup()
14{
15    Serial.begin(9600);
16    pinMode(pin_trig, OUTPUT);
17    pinMode(pin_echo, INPUT);
18    Serial.println("Sensore ad ultrasuini");
19}
20 
21void loop()
22{
23  Serial.print("Distanza ostacolo: ");
24  Serial.println(distanzaOstacolo());
25  delay(100);
26}
27 
28// rilevazione distanza ostacolo
29 
30// misura la distanza dell'ostacolo
31long distanzaOstacolo()
32{
33  digitalWrite(pin_trig, LOW);
34  delayMicroseconds(2);
35  digitalWrite(pin_trig, HIGH);
36  delayMicroseconds(10);
37  digitalWrite(pin_trig, LOW);
38  durata = pulseIn(pin_echo, HIGH);
39  distanza = (durata / 2.0) / 29.1;
40  delay(100);
41  return distanza;
42}

Con Arduino connesso al computer aprire CoolTerM e selezionare “Options”, da quì impostare la porta a cui è connessa la scheda e la velocità di connessione a 9600, una velocità diversa non permetterà una lettura corretta dei dati.

Torna alla schermata principale fate clic su “Connect”, ciò permetterà di avviare la trasmissione dei dati tra Arduino e il computer e i dati inizieranno ad apparire.
Quando desiderate interrompere la trasmissione ovviamente farete clic su “Disconnetti”.

E’ spesso utile analizzare i dati raccolti, in tal caso selezionate: Connection > Capture to Text/Binary File > Start ciò permetterà di salvare i vostri dati in un file TXT che potrà poi essere analizzato ad esempio con un foglio di calcolo.

CoolTerM offre ulteriori funzionalità molto utili:

se disponibile è possibile connettere più porte seriali concorrenti;
visualizzazione dei dati in formato semplice o esadecimale (HEX);
salvataggio e caricamento delle opzioni di connessione;
gestione dei caratteri speciali;
scripting;
eco locale di dati trasmessi / ricevuti;

Buon Making a tutti

Esercitazioni di base di Arduino – visualizzazione luminosità LED mediante una barra di avanzamento su display 16×2

Lascia una risposta

Continuo nell’aggiornamento delle esercitazioni di base per gli studenti di 3′ dell’ITIS (Elettronica ed Automazione) e per gli utenti che iniziano con Arduino.
Utilizzeremo un display LCD 16×2 di tipo I2C su cui visualizzeremo mediante una barra di avanzamento, la quantità di luminosità impostata per il LED, mediante un potenziometro.

Per la gestione di un display LCD di tipo I2C rimando alla mia lezione: Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T.

Per la creazione di caratteri personalizzati rimando alla mia lezione: Disegnare caratteri personalizzati con Arduino per un LCD 16×2.

Lista componenti

N.1 Arduino UNO
N.1 Breadboard
N.1 LCD 16×2 I2C
N.1 Potenziometri da 10 KOhm
N.1 LED da 5 mm
N.1 Resistore da 220 Ohm
jumper

Schema di collegamento

Scketch

Di seguito viene indicato il codice i base, all’interno i commenti che ne dettagliano il funzionamento di ogni parte:

1/*
2   Prof. Maffucci Michele
3   https://www.maffucci.it
4   Ver.1 - 27.12.21
5   Controllo di luminosità LED con
6   visualizzazione intensità mediante una
7   barra di avanzamento su display 16x2
8*/
9 
10#include <Wire.h>
11#include <LiquidCrystal_I2C.h>
12 
13byte pinPot = A0;           // pin analogico 0 a cui connettere il potenziometro per controllare la luminosità
14byte pinLed = 3;            // pin PWM a cui connettere il LED
15int  analogVal = 0;         // variabile in cui memorizzare il valore impostato dal potenziometro
16int  luminosita = 0;        // variabile in cui memorizzare la luminosità 
17byte barraAvanzamento = 0;  // indice barra avanzamento
18 
19// Per maggiori informazioni sulla realizzazione di caratteri speciali:
20// https://www.maffucci.it/2020/01/18/disegnare-caratteri-personalizzati-con-arduino-per-un-lcd-16x2/
21 
22// Carattere personalizzato per disegnare la barraAvanzamento di avanzamento
23byte iconaBarra[8] = {
24  B11111,
25  B11111,
26  B11111,
27  B11111,
28  B11111,
29  B11111,
30  B11111,
31};
32 
33// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
34// impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
35LiquidCrystal_I2C lcd(0x27, 16, 2);
36//-----------------------------
37 
38void setup()
39{
40  lcd.begin();      // inizializzazione dell'LCD
41  lcd.backlight();  // attivazione della retroilluminazione
42 
43  // Inpostazione ad OUTPUT del pin a cui connettiamo il LED
44  pinMode(pinLed, OUTPUT);
45 
46  // Cancella il display
47  lcd.clear();
48 
49  // Stampa il messaggio sulla prima riga del display
50  lcd.print("Luminosita' LED");
51 
52  //Creazione del carattere per la barra di avanzamento
53  lcd.createChar(0, iconaBarra);
54}
55 
56// Per maggiori informazioni sull'uso del display 16x2 I2C:
57// https://www.maffucci.it/2019/01/25/utilizzo-delllcd-16x2-hitachi-hd44780-1602-con-modulo-i2c-pcf8574t/
58//-----------------------------
59 
60void loop() {
61  // Cancella il display
62  lcd.clear();
63   
64  // Stampa il messsaggio sulla prima riga
65  lcd.print("Luminosita' LED");
66   
67  //Posiziona il cursore nella seconda riga, prima colonna
68  lcd.setCursor(0,1);
69   
70  // Lettura del valore impostato dal potenziometro
71  analogVal = analogRead(pinPot);
72           
73  // Conversione del valore analogico impostato con il potenziometro
74  // in Duty Cicle per impostare la luminosità del LED
75  luminosita=map(analogVal, 0, 1024, 0, 255); 
76   
77  // Impostazione della luminosità del LED
78  analogWrite(pinLed, luminosita); 
79   
80  // Conversione della luminosità in quantità di caratteri della barra da stampare 
81  barraAvanzamento=map(luminosita, 0, 255, 0, 15);
82   
83  // Stampa la barra di avanzamento
84  for (byte i = 0; i < barraAvanzamento; i++)
85  {
86    lcd.setCursor(i, 1);   
87    lcd.write(byte(0));  
88  }
89  // leggero ritardo di 500 ms per visualizzare la barra
90  delay(500);        
91}

Proposta esercizi

Esercizio 1
Nell’esempio proposto viene utilizzato un delay() finale per permettere la visualizzazione dei caratteri sul display. Sostituire il delay() ed utilizzare l’istruzione millis() per valutare il tempo trascorso e controllare la stampa dei caratteri sul display.

Esercizio 2
Modificare il programma precedente raddoppiando il numero di caratteri che rappresenta la barra di avanzamento.

Esercizio 3
Modificare l’esercizio proposto variando la barra di avanzamento in funzione dell’approssimarsi al valore massimo o minimo della luminosità.

Esercizio 4
Modificare l’esercizio proposte inserendo un buzzer che emette un suono la cui frequenza varia in funzione dell’intensità luminosa del LED.

Buon Making a tutti

Esercitazione di Sistemi Elettronici – Arduino – impianto semaforico ad 1 via

Lascia una risposta

Questa esercitazione è dedicata ai miei studenti di 3′ (Automazione ed Elettronica Biomedicale) che come compito per le vacanze natalizie dovranno, partendo dall’esempio svolto, realizzare le 4 varianti richieste al fondo di questa lezione.

Introduzione

In questo progetto bisognerà realizzare l’impianto semaforico per automobili e modificarlo secondo le specifiche indicate al fondo di questo post
vengono utilizzati 3 LED: verde, giallo e rosso per simulare un semaforo reale
vengono utilizzati 2 LED : verde e rosso per simulare il semaforo per i pedoni
è presente un pulsante di richiesta attraversamento per i pedoni

Lista componenti

1 Breadboard
1 Arduino UNO
3 LED da 5mm (rosso, giallo, verde)
2 LEd da 5mm LED (rosso, verde)
5 resistori da 220 Ohm
1 resistore da 10 kOhm
1 pulsante normalmente aperto
jumper

Collegamenti

Sketch

Per la realizzazione di questo progetto non avrete necessità di nessuna libreria da aggiungere all’IDE di Arduino.

L’automazione del semaforo sarà la seguente:

Il semaforo per le automobili è sempre verde e la luce pedonale risulta sempre rossa a meno che qualcuno preme il pulsante.
Quando viene premuto il pulsante dal pedone:
- il semaforo auto cambia da giallo e successivamente si spegne il giallo e si accende il rosso;
- sul semaforo pedonale si spegne il rosso e si accende il verde;
- le luci del semaforo pedonale rimangono in questo stato per un tempo pari a tempoAttraversamento
- successivamente il verde del semaforo pedonale lampeggia, terminata la sequenza di lampeggio si spegne e si accende il rosso;
il semaforo delle auto passa da rosso a verde

Tutte queste funzioni sono svolte dalla funzione cambiabentoLuci().

1/*
2   Prof. Maffucci Michele
3   Ver.1 - 22.12.21
4   Impianto semaforico con attraversamento
5   pedonale a richiesta
6*/
7 
8// pin a cui sono connessi i LED
9byte rossoAuto = 13;
10byte gialloAuto = 12;
11byte verdeAuto = 11;
12byte rossoPedone = 10;
13byte verdePedone = 9;
14 
15// pin a cui è connesso il pulsante di richiesta
16byte pulsante = 8;
17 
18// tempo massimo di attraversamento del pedone
19int tempoAttraversamento = 10000;
20 
21// definizione della variabile per l'impostazione
22// del cambio stato del semaforo auto
23unsigned long tempoCambio;
24 
25void setup() {
26  // inizializzazione timer
27  tempoCambio = millis();
28 
29  // inizializzazione dei pin come OUTPUT
30 
31  pinMode(rossoAuto, OUTPUT);
32  pinMode(gialloAuto, OUTPUT);
33  pinMode(verdeAuto, OUTPUT);
34  pinMode(rossoPedone, OUTPUT);
35  pinMode(verdePedone, OUTPUT);
36 
37  // inizializzazione pin come INPUT
38  pinMode(pulsante, INPUT);
39 
40  // accensione luci verdi
41  // all'avvio le auto hanno il verde e i pedoni il rosso
42  digitalWrite(verdeAuto, HIGH);
43  digitalWrite(rossoPedone, HIGH);
44  digitalWrite(rossoAuto, LOW);
45  digitalWrite(gialloAuto, LOW);
46  digitalWrite(verdePedone, LOW);
47 
48  // inizializzazione della Serial Monitor
49  Serial.begin(9600);
50}
51 
52void loop() {
53  // la variabile state viene utilizzata per sapere se il
54  // pulsante di attraversamento viene premuto
55  int stato = digitalRead(pulsante);
56 
57  // lo stato del pulsante viene visualizzato sulla Serial Monitor
58  Serial.println(stato);
59 
60  // Se viene premuto il pulsante e se sono
61  // passati 5 secondi dall'ultima pressione del pulsante
62 
63  if (stato == HIGH && (millis() - tempoCambio) > 5000) {
64    // chiama la funzione per il cambio luci
65    cambioLuci();
66  }
67}
68 
69void cambioLuci() {
70  digitalWrite(verdeAuto, LOW);      // il LED verde viene spento
71  digitalWrite(gialloAuto, HIGH);    // il LED giallo viene acceso per 2 secondi
72  delay(2000);
73 
74  digitalWrite(gialloAuto, LOW);    // il LED giallo viene spento
75  digitalWrite(rossoAuto, HIGH);    // il LED rosso viene acceso per 5 secondi
76 
77  digitalWrite(rossoPedone, LOW);   // il LED rosso del pedone viene spento
78  digitalWrite(verdePedone, HIGH);  // il LED verde del pedone viene acceso
79  delay(tempoAttraversamento);
80 
81  // lampeggio del LED verde dei pedoni
82  for (int x = 0; x < 10; x++) {
83    digitalWrite(verdePedone, LOW);
84    delay(100);
85    digitalWrite(verdePedone, HIGH);
86    delay(100);
87  }
88  digitalWrite(verdePedone, LOW);
89  digitalWrite(rossoAuto, LOW);
90  digitalWrite(rossoPedone, HIGH);
91  digitalWrite(verdeAuto, HIGH);
92 
93  tempoCambio = millis();
94}

Esercizio 1
Aggiungere un sensore ad ultrasuoni che rileva la presenza del pedone in fase di attraversamento, fino a quando viene rilevato il pedone viene mantenuto il verde per il pedone ed il rosso per le auto. E’ presente sempre il pulsante di richiesta attraversamento.

Esercizio 2
Ampliare l’esercizio 1 aggiungendo un display a 7 segmenti utilizzato come conto alla rovescia (da 9 a 0) per i pedoni quando attraversano.

Esercizio 3
Ampliare l’esercizio 1 aggiungendo un buzzer che con un segnale pulsante variabile, indica l’approssimarsi del rosso.

Esercizio 4
Ampliare l’esercizio proposto in questa lezione trasformando l’impianto semaforico da 1 via a 4 vie con rispettivi attraversamenti pedonali sulle 4 strade.

Per coloro che non sono miei studenti, sul mio Patreon nei prossimi giorni verrà proposta:

La soluzione a tutti gli esercizi proposti con schemi di collegamento e codice
Video di spiegazione
Sorgenti STL per la stampa 3D di un semaforo da poter essere inseriti all’interno di un plastico
Proposta progettuale per la realizzazione di un kit didattico per lo sviluppo di questa tipologia di esercizi.

Buon Making a tutti.

Arduino – misurare tensioni superiori a 5V dc utilizzando un partitore di tensione

Lascia una risposta

Nella precedente lezione abbiamo visto come misurare una tensione non superiore ai 5V dc, vedremo ora come realizzare un semplice circuito che permette mediante un partitore di tensione la misurazione di tensioni fino a 9 Volt. Dimensionando opportunamente le resistenze di partizione potremo effettuare misure per tensioni elettriche superiori.

Precisazione importante

Gli esempi riportati in questa e nella precedente lezione ed inoltre la gran parte degli esempio classici che trovate online, sono pensati per far comprendere il funzionamento del convertitore A/D, ma è opportuno fare alcune considerazioni sulla precisione di lettura, ovvero degli errori commessi dal convertitore A/D e sull’imprecisione delle tensioni di riferimento usate dal microcontrollore per fornirvi la misura. Questo sarà argomento di una prossima lezione e vedremo come ridurre l’errore di misura.

Per rendere semplice la realizzazione utilizzeremo la batteria da 9V, ma se intendete avere dei limiti di misura diversi e superiori a 9V dovrete apportare modifiche ai valori dei componenti, ma le formule esposte restano le medesime.

Prima di procedere con la realizzazione pratica è essenziale comprendere come dimensionare le resistenze del partitore, inoltre è essenziale che la tensione sul pin analogico A0 non superi il valore di 5V. Per effettuare il dimensionamento del circuito fissiamo la massima tensione misurabile V_{mis_max} a 9V e imponiamo il valore di uno dei due resistori, ad esempio R₁ in modo da poter ricavare il valore di R₂.

Vi ricordo inoltre che sarebbe opportuno, una volta fissate le resistenze, fare qualche considerazione sulla corrente massima entrante in A0 in modo che non venga superato il valore di 40 mA corrente massima di I/O sui pin analogici e digitali di Arduino Uno R3, ma come le resistenze che sono state scelte non correremo alcun rischio, però esporrò ugualmente il calcolo.

Nello schema che segue V_mis rappresenta la tensione da misurare, V_adc la tensione sul pin A0. I è la corrente totale che circola nel circuito.

Sappiamo che la tensione V_adc ai capi di R₂ non dovrà superare i 5V. Le tensioni su R₁ ed R₂ saranno:

(a) V_R1 = R₁*I
(b) V_R2 = R₂*I

Pertanto la tensione V_mis sarà

da cui ricaviamo:

(d) I = V_mis /(R₁+R₂)

Sostituendo I in (a) e (b) avremo:

(e) V_R1 = R₁*I = R₁ * V_mis /(R₁+R₂)
(f) V_R2 = R₂*I = R₂ * V_mis /(R₁+R₂)

Per il calcolo di R2 consideriamo la formula (f) sostituendo i valori fissati, V_{mis_max}e R₁, ricordando che V_R2 è la tensioni in A0, cioè V_adc:

⇒ V_R2 = R₂ * V_mis /(R₁+R₂)

⇒ R₂ /(R₁+R₂) = V_R2/V_{mis_max}

⇒ R₂ /(R₁+R₂) = 5/9

⇒ R₂ /(R₁+R₂) = 0,56

⇒ R₂ = 0,56*R₁ + 0,56*R₂

⇒ R₂*(1-0,56) = 0,56*R₁

⇒ R₂ = 0,56 *R1/0,44

⇒ R₂ = 0,56 * 27 * 10³/0,44 = 34,363 * 10³ = 34,363 Kohm

Scelgo come valore commerciale prossimo (e che dispongo nel mie scorte) il valore di 33 Kohm, quindi:

R₁ = 27 Kohm
R₂ = 33 Kohm

Per quanto riguarda la corrente entrante in A0, utilizziamo la formula (b):

V_R2 = R₂*I

I = V_R2/R₂

I = 5V/33000 Ω = 0,00015 A = 0,15 mA

ben al di sotto del valore massimo del valore accettabile su un pin I/O di Arduino che è di 40mA.

Schema di collegamento

Programmazione

Sviluppiamo il codice necessario per la lettura della tensione e partendo dal primo sketch della lezione precedente modifichiamone alcune parti, nei commenti la spiegazione delle varie parti.

Nel codice bisognerà tenere in conto che la tensione su A0 è data dal calcolo della partizione di tensione, pertanto sapendo che V_mis = V_adc, dalla forma (f) abbiamo:

⇒ V_R2 = R₂*I = R₂ * V_mis /(R₁+R₂)

⇒ V_R2 = V_adc= R₂ * V_mis /(R₁+R₂)

⇒ V_mis = V_adc* (R₁+R₂)/R₂

Che sarà la formula che ci consentirà di rilevare la misura.

1// Prof. Maffucci Michele
2// Esempio 01: Misura una tensione di 9V con Arduino
3// utilizzando variabili di tipo float
4// Data: 03.10.2021
5 
6// tensione di riferimento massima misurabile
7const float tensioneDiRiferimento = 5.0;
8 
9float R1 = 27000.0; // 27 Kohm
10float R2 = 33000.0; // 33 Kohm
11 
12float volt_adc = 0.0;
13float volt_mis = 0.0;
14 
15void setup() {
16  Serial.begin(9600);
17  //analogReference(DEFAULT);
18}
19void loop() {
20  // legge il valore su A0 (su R2), cioè la tensione Vadc e lo trasforma
21  // in un valore numerico tra 0 e 1023
22   
23  int valoreLetto = analogRead(A0);
24 
25  // Tensione in ingresso ad A0, cioè la tensione Vadc
26  // calcolo della proporzione
27  // volt:tensioneDiRiferimento = valoreLetto:1023.0
28  // da cui si ricava la formula che segue
29   
30  volt_adc = (valoreLetto/1023.0) * tensioneDiRiferimento;
31 
32  //Stampa del valore letto dall'ADC
33  Serial.print("Valore ADC = ");
34  Serial.println(valoreLetto);
35   
36  // calcolo della tensione di ingresso Vmis
37 
38  volt_mis = volt_adc*(R1+R2)/R2;
39 
40  // stampa sulla Serial Monitor la tensione misurata
41  Serial.print("Tensione di ingresso = ");
42  Serial.println(volt_mis);
43  Serial.println(" ");
44 
45  delay(1000);
46}

Esercizi per i miei studenti

Esercizio 1
Dimensionare il Circuito per misurare una tensione massima di 12V

Esercizio 2
Realizzare uno sketch Arduino che permette di dimensionare il circuito prendendo in input, attraverso la Serial Monitor il valore massimo misurabile ed il valore di R₁ e restituisce il valore di R₂ calcolato.

Esercizio 3
Realizzare le medesime funzionalità dell’esercizio 2, ma il valore restituito di R₂ deve essere sia quello calcolato che quello commerciale immediatamente superiore o inferiore al valore calcolato.

Buon Coding a tutti

Arduino – misurare tensioni continue fino a 5V

Lascia una risposta

La misurazione di una tensione con Arduino è un esercizio standard utilizzato per spiegare come funziona il convertitore Analogico Digitale sulla scheda. Nell’esempio che segue verrà mostrato come visualizzare sulla Serial Monitor la tensione di una batterie da 1,5V ma in generale di una tensione non superiore ai 5V, seguono poi una serie di esercizi per i miei studenti.
Nella prossima lezione mostreremo come misurare una tensione superiore ai 5V.

ATTENZIONE
E’ essenziale ricordare che non bisogna in alcun modo inserire tensioni superiori a 5V sui pin di Arduino, in quanto potreste distruggere irrimediabilmente la scheda.

Per la rilevazione di una tensione elettrica su un pin analogico viene utilizzata la funzione analogRead, che come più volte indicato su questo sito, è in grado di convertire una tensione tra 0V e 5V continui in un valore numerico intero con risoluzione di 10 bit tra 0 e 1023, operazione svolta dal convertitore A/D.

Ricordo che l’analogRead(pin) legge il valore di tensione (compreso tra 0 e 5V) applicato sul piedino analogico ‘pin’ con una risoluzione di 10 bit e la converte in un valore numerico compreso tra 0 e 1023, corrispondente quindi ad un intervallo di 1024 valori, pertanto il valore unitario corrisponde a:

Vu = 5V/1023 = 4,89 mV

Per conoscere il valore di tensione rilevato sarà sufficiente moltiplicare la tensione unitaria Vu per il valore restituito dalla funzione analogRead(pin), quello che chiamiamo valore quantizzato Vq compreso tra 0 e 1024, il valore misurato Vm sarà:

Vm = Vu x Vq

e sapendo che Vu corrisponde a 4,89 mV possiamo scrivere:

Vm = 4,89 x Vq

Nota per i miei allievi: riprenderemo questo semplice calcolo qundo utilizzeremo ad esempio i sensori di temperatura.

Il semplice schema di collegamento è riportato nell’immagine che segue:

Per stampare sulla Serial Monitor la tensione ai capi della batteria, useremo valori di tipo float (in virgola mobile), che come indicato nel mio post: “Arduino: tipi di dati – ripasso” possiamo esprime valori compresi tra –3.4028235E+38 e 3.4028235E+38.
La stampa di numeri in virgola mobile sula Serial Monitor verrà rappresentata con numeri che hanno al massimo con due cifre decimali, riprenderemo questo aspetto nel secondo esempio di questa lezione.

1// Prof. Maffucci Michele
2// Esempio 01: Misura di tensioni continue non superiori a 5V
3// utilizzando variabili di tipo float
4// Data: 01.10.2021
5 
6// tensione di riferimento predefinita sulla scheda
7const float tensioneDiRiferimento = 5.0;
8 
9// batteria connessa al pin analogico 0
10const byte pinBatteria = A0;
11 
12void setup() {
13  // inizializzazione della porta seriale
14  Serial.begin(9600);
15}
16 
17void loop() {
18  // legge il valore della batteria e lo trasforma
19  // in un valore numerico tra 0 e 1023
20  int valoreLetto = analogRead(pinBatteria);
21 
22  // calcolo della proporzione
23  // volt:tensioneDiRiferimento = valoreLetto:1023.0
24  // da cui si ricava la formula che segue
25  float volt = (valoreLetto/1023.0) * tensioneDiRiferimento;
26 
27  // stampa sulla Serial Monitor la tensione misurata
28  Serial.println(volt);
29}

Per evitare spreco di memoria dovuto ai calcoli che utilizzano i tipi di dati float che occupano maggiore memoria, è possibile utilizzare al posto del tipo float il tipo long, ovvero un int lungo rappresentato da 4 byte in grado di rappresentare numeri interi tra –2147483648 a 2147483647.

Vediamo come modificare lo sketch precedente per rilevare tensioni espresse in millivolt in cui però si utilizzano variabili intere di tipo long:

1// Prof. Maffucci Michele
2// Esempio 02: Misura di tensioni continue non superiori a 5V
3// utilizzando variabili di tipo float
4// Data: 01.10.2021
5 
6// batteria connessa al pin analogico 0
7const byte pinBatteria = A0;
8 
9void setup() {
10  // inizializzazione della porta seriale
11  Serial.begin(9600);
12}
13 
14void loop() {
15  // legge il valore della batteria e lo trasforma
16  // in un valore numerico tra 0 e 1023
17  // valoreLetto è di tipo long
18  long valoreLetto = analogRead(pinBatteria);
19 
20  // stampa sulla Serial Monitor la tensione misurata
21  // in millivolt
22   
23  Serial.println((valoreLetto*(500000/1023L))/100);
24}

Quindi per evitare di effettuare calcoli con numeri di tipo float (in virgola mobile) senza perdere precisione, il trucco consiste nell’operare sui valori in millivolt invece che sui valori in volt. Ricordo che 1 volt corrisponde a 1000 millivolt.

Come detto all’inizio di questa lezione sappiamo che un valore numerico di 1023 restituito dall’analogRead, corrisponde al valore massimo di 5000 millivolt, allora ogni unità rappresenta 5000/1023 millivolt, che corrisponde a 4,89 millivolt. Come detto nell’esempio precedente, la stampa su Serial Monitor di un numero in virgola mobile mostrerà al massimo due decimali, pertanto l’eliminazione dei decimali nel secondo esempio possiamo farlo moltiplicando per 100, nel codice: 5000×100=500000, questo valore verrà poi moltiplicato per il rapporto tra il valore letto e 1023 ed il tutto ancora diviso per 100, così facendo otterremo il valore in millivolt. Questo calcolo permette di far effettuare al compilatore solamente calcoli tra interi e non tra float, rendendo quindi la computazione più veloce e riducendo la quantità di memoria utilizzata.

Si noti che al fondo del numero 1023 è stata aggiuta una L, cioè 1023L, che indicare al compilatore che il numero rappresentato è di tipo long (4 byte).

Esercizi per i miei studenti

Esercizio 1
Utilizzare un Trimmer per regolare la tensione in ingresso ad A0 tra 0 e 5V, in questo caso si prenda la tensione di 5V dal pin di Arduino.

Esercizio 2
Nel primo sketch proposto utilizzare la funzione map per convertire il valore restituito dall’ analogRead in un valore di tensione. In questo caso nascono dei problemi sulla precisione della misura, sapresti indicarmi quali?

Esercizio 3
Visualizzare il valore di tensione regolato dal Trimmer sul Plotter Seriale.

Esercizio 4
Utilizzando uno qualsiasi dei due sketch indicati sopra e visualizzare la tensione misurate sul un display 16×2

Esercizio 5
Aggiungere all’esercizio precedente l’indicazione di carica data da un grafico costituito da 5 quadrati che ne indicano il livello di carica, non appena il livello di carica raggiunge 1 volt il quadrettino inizia a lampeggiare.

Buon Making a tutti

Michele Maffucci

… my stories, life and work

Archivi categoria: arduino

CoolTerm – Alternative alla Serial Monitor di Arduino

Come si usa CoolTerM per rilevare dati che provengono da Arduino.

Esercitazioni di base di Arduino – visualizzazione luminosità LED mediante una barra di avanzamento su display 16×2

Lista componenti

Schema di collegamento

Scketch

Proposta esercizi

Esercitazione di Sistemi Elettronici – Arduino – impianto semaforico ad 1 via

Arduino – misurare tensioni superiori a 5V dc utilizzando un partitore di tensione

Arduino – misurare tensioni continue fino a 5V

Come si usa CoolTerM per rilevare dati che provengono da Arduino.

Condividi:

Articoli correlati:

Lista componenti

Schema di collegamento

Scketch

Proposta esercizi

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati: