PCTO A.S. 2020 – 2021 – SumoBot – lezione 2

Lascia una risposta

In questa lezione vedremo come collegare e controllare i servomotori a rotazione continua di SumoBot.
Fate riferimento allo schema di collegamento che segue, in cui i servomotori vengono connessi ai pin 4 e 5 della Sensor Shield per Arduino Uno Nano V3, come si nota a fianco di ogni pin è disponibile l’alimentazione, infatti troviamo sempre il positivo, indicato con la lettera V e il GND indicato con la lettera G. Come ribadito nella lezione 1 utilizziamo una Sensor Shield perchè permette rapidamente di realizzare tutti i collegamenti senza la necessità i dover ricorrere ad una breadboard oppure alla saldatura dei cavi.

Per questa lezione vengono indicati solo i collegamenti ai motori, non verranno collegati ne il sensore ad ultrasuoni e ne i sensori ad infrarossi.

Per quanto riguarda l’utilizzo dei servomotori a rotazione continua fare riferimento alla slide: Alfabeto di Arduino – Lezione 6, ma per completezza riporto di seguito la spiegazione adattandola all’utilizzo con SumoBot.

Il servomotore è costituito in genere da tre cavi connessi ad un connettore femmina con passo standard tra i fori di 2,54 mm quindi facilmente utilizzabile con qualsiasi strip che ne permette il collegamento ad esempio su una breadboard oppure ai pin maschio della Sensor Shield che utilizziamo per SumoBot.

I fili di connessione possono assumere colori diversi in funzione della marca del servo.

Pinout del servomotore

Filo ROSSO: +V
Filo NERO o MARRONE: GND
Filo BIANCO o ARANCIO o BIANCO o BLU: Segnale

Nel servomotori adottati per questa esperienza i fili di connessione sono:

Filo ROSSO: +V
Filo MARRONE: GND
Filo ARANCIO: Segnale

Collegamenti

Guardando SumoBot frontalmente, collegheremo il motore di destra al pin 4 e il motore di sinistra al pin 5.

Principio di funzionamento del servomotore a rotazione continua

Notoriamente i servomotori possono effettuare una rotazione che oscilla tipicamente da 0 a 180, esistono inoltre modelli che consentono una rotazione inferiore tra 0 e 120 gradi, questi tipi di servomotori possono essere modificati facendo in modo che possano effettuare una rotazione continua, ovvero tra 0 e 360 gradi, ma in commercio sono disponibili servomotori di diverse dimensioni che funzionano in questa modalità. Nel kit utilizzato per la realizzazione di SumoBot utilizziamo due servomotori FS90R.

Sul servomotore a rotazione continua possiamo controllare da programma il senso di rotazione e in modo non molto preciso anche la velocità.

Il funzionamento di un servomotore a rotazione continua è simile a quella di un motore in corrente continua con la differenza che non necessitano di appositi shield per poter funzionare.
Rispetto ad altri tipi di motori in CC offrono scelte limitate per il controllo della velocità e limitazioni di alimentazione.

L’alimentazione potrà avvenire direttamente Attraverso Arduino o mediante alimentazione esterna. L’alimentazione dei motori di SumoBot avverrà direttamente dalla scheda Arduino.

Caratteristiche tecniche

Velocità di funzionamento a 4,8V: 110RPM
Velocità di funzionamento a 6V: 130RPM
Coppia di stallo a 4,8V: 1.3kg.cm/18.09oz.in
Coppia di stallo a 6V: 1.5kg.cm/20.86oz.in
Tensione operativa: 4.8-6V
Sistema di controllo: Analogico
Angolo di rotazione: 360 gradi
Impulso richiesto: 900-2100us
Materiale ingranaggi: Plastica
Dimensioni: 2,32×1,25×2,2 cm
Peso: 9g

Programmazione

/*
 * Prof. Maffucci Michele
 * SumoRobot
 * Data: 26.01.2021
 * 
 * Sketch 01: rotazione oraria e antioraria continua
 * 
 * Note:
 *          Per l'orientamento del robot 
 *          guardare SumoBot anteriormente
 *       
 *          180: max velocità in senso antiorario
 *          90 : servomotori fermi
 *          0  : max velocità in senso orario
 *            
 */

// inclusione della libreria servo.h per il controllo dei servomotori
#include <Servo.h>

// Creazione oggetti servo
Servo motoreDX;  // Inizializzazione del servomotore destro
Servo motoreSX;  // Inizializzazione del servomotore sinistro

byte pinDx = 4;     // Inizializza del pin 4 a cui è connesso il pin segnale del servo destro
byte pinSx = 5;     // Inizializza del pin 5 a cui è connesso il pin segnale del servo sinistro
int  durata = 250;  // Durata movimento (orario/antiorario)
int  ferma = 3000;  // Durata dello stop

void setup() {

  // attach() consente di definire a quale pin viene connesso il servomotore
  // e lo collega all'oggetto che gestisce il servomotore
  
  motoreDX.attach(pinDx); // pinDx collegato al motore destro
  motoreSX.attach(pinSx); // pinSxcollega to al motore sinistro
}

void loop() {
  orarioRobot();     // Rotazione in senso orario del robot
  stopRobot();       // Stop rotazione per un tempo fissato (vedere variabile ferma)
  antiorarioRobot(); // Rotazione in senso antiorario del robot
  stopRobot();       // Stop rotazione per un tempo fissato (vedere variabile ferma)
}

// rotazione del robot in senso antiorario
void antiorarioRobot(void) {
  motoreDX.write(150);  // Rotazione oraria del motore DX
  motoreSX.write(150);  // Rotazione antioraria del motore SX
  delay(durata);        // durata: durata della rotazione
}

// rotazione del robot in senso orario
void orarioRobot(void) {
  motoreDX.write(30);    // Rotazione antioraria del motore DX
  motoreSX.write(30);    // Rotazione oraria del motore SX
  delay(durata);         // durata: durata della rotazione
}

// stop del robot
void stopRobot(void) {
  motoreDX.write(90);   // Ferma il motore DX
  motoreSX.write(90);   // Ferma il motore SX
  delay(ferma);         // Durata dello stop
}

Per quanto riguarda il controllo dei servomotori seguire la spiegazione inserita come commento all’interno del codice, ricordo comunque che per controllare i servomotori sono necessarie 4 operazioni:

includere la libreria Servo.h
creazione dell’oggetto Servo. motoreDx e motoreSx saranno i due oggetti su cui opererete
assegnare un nome al pin di controllo del servomotore (filo arancione nello schema)
indicare nel setup il metodo attach() che permette di legare gli oggetti motoreDx e motoreSx ai pin su Arduino nell’esempio 4 e 5 a cui abbiamo assegnato i nomi pinDx e pinSx.

All’interno del codice utilizziamo il metodo write() che per i servomotori a rotazione continua permette il passaggio, all’oggetto motoreDx e motoreSx, la direzione e la velocità di rotazione del motore:

passando il valore 0 gradi al metodo write() il servo ruota alla massima velocità in una direzione.
passando il valore 90 gradi al metodo write() poniamo il servo in stop (posizione “neutra”)
passando il valore 180 gradi al metodo write() il servo di ruotare in senso opposto alla massima velocità.

Nel codice che segue SumoBot ripeterà continuamente una rotazione oraria di 250 millisecondi, si fermerà per 3 secondi e riprenderà la rotazione in senso antiorario per 250 millisecondi.

Per effettuare questa operazione vengono definite 3 funzioni:

orarioRobot()
stopRobot()
antiorarioRobot()

Nel codice si può notare che nella funzione antiorarioRobot() viene passato al metodo write() non il valore 180 che farebbe ruotare il robot alla massima velocità, ma un valore inferiore, nel nostro caso 150, ciò ridurrà la velocità di rotazione.

In modo analogo accade per la funzione orarioRobot() in cui invece di passare il valore 0 alla metodo write(), che lo farebbe ruotare alla massima velocità in senso orario, passiamo un valore maggiore, 30, che lo farà ruotare ad una velocità inferiore.

La fermata del robot avviene utilizzando la funzione stopRobot() in cui viene passato il valore 90 al metodo write(), ciò fermerà i motori.

Si noti che i motori potranno ruoteranno in un senso o in un altro, oppure potranno essere fermati non solo invocando il metodo write, ma bisognerà sempre inserire un delay() in cui viene specificato per quanto tempo il metodo deve agire.

Esercizio 01

Far compiere a SumoBot rotazioni continue di 90 gradi in senso orario inserendo un intervallo di 3 secondi ad ogni quarto di giro

Esercizio 02

Far compiere a SumoBot una rotazione continua di 360° con intervalli di 3 secondi ad ogni quarto di giro, raggiunti i 360° far cambiare il senso di rotazione ripetendo le fermate di 3 secondi ad ogni quarto di giro.

Esercizio 03

Individuare quanto tempo necessita per far effettuare una rotazione di 45° in senso orario a SumoBot e realizzare un programma che permetta di fare le seguenti operazioni:

rotazione di 45° in senso orario
fermate di 3 secondi
rotazione in senso antiorario di 90°
fermata

Buon Making a tutti 🙂

Arduino – realizzare un sensore di seduta a pressione con un tubo di gomma

Lascia una risposta

Questa mattina, durante la realizzazione e l’analisi dei problemi per il progetto di PCTO: “misura di sedentarietà delle persone sedute alla scrivania” che stanno realizzando i miei studenti di 3′ Elettronica, è nata l’esigenza di associare un doppio controllo per la valutazione della presenza della persona seduta alla scrivania, un controllo effettuato con PIR HC-SR501 ed un sensore di forza resistivo (FSR) inserito all’interno del cuscino della seduta.

Per evitare l’acquisto di un sensore di forza resistivo e non pesare sulle finanze dei ragazzi le modalità sono tre:

richiesta alla scuola
compra il Prof.
farlo costruire ai ragazzi

l’acquisto da parte della scuola o mia non è un problema, ma la terza soluzione è quella che in questo momento prediligo, perché può essere realizzata in 5 minuti, credo che possa gratificare di più lo studente Maker in erba 🙂 , inoltre ritengo importante che gli allievi assumano la capacità di costruire il sensore perché ne dovranno ottimizzare l’uso, scontrandosi inevitabilmente con una serie di variabili fisiche che dovranno gestire.

Ma come si costruisce il sensore?

E’ indispensabile piccolo tubo cilindrico non trasparente, preferibilmente nero che possa essere compresso e al termine della compressioni ritorni abbastanza velocemente nella sua posizione di riposo. Possiamo ricavare il tubo sguainando un cavo elettrico o cavo di rete, oppure come ho fatto in questo tutorial, prendendo una guaina termorestingente.

Inserire un diodo LED ad un’estremità del cilindro e dalla parte opposta inserire un LDR.
Collegare il sistema nella solita modalità, inserendo in serie al LED un resistore da 220 Ohm e creando un partitore di tensione tra l’LDR e un resistore da 10KOhm, così come indicato nel circuito indicato di seguito.

Come test di funzionamento utilizzare il semplice sketch che trovate di seguito, nei commenti la spiegazione di tutte le parti del codice.

Aprite la Serial Monitor e premete e rilasciate il tubo

/*
 * Prof. Michele Maffucci
 * Data 01.03.2021
 * 
 * Oggetto: sensore di seduta a pressione
 * 
*/

// variabile in cui verrà memorizzato il valore presente sul pin A0
const int misura = A0;

// valore restituito dall'analogRead
int val = 0;

// pin a cui è connesso il LED del sensore di seduta
int pinLed = 2;

// LED che segnala la seduta della persona
int pinLedAlert = 13;

void setup() {
  // Inizializzazione della Serial Monitor
  Serial.begin(9600);

  // ledPin è il pin a cui è connesso il LED del sensore di seduta
  pinMode(pinLed, OUTPUT);

  // pinLedAlert è il pin a cui è connesso il LED che segnala la seduta della persona
  pinMode(pinLedAlert, OUTPUT);

  // Attivazione del LED del sensore di seduta
  digitalWrite(pinLed, HIGH);

  // Messaggio di avvio
  Serial.println("Sistema di rilevazione seduta");
  Serial.println("-----------------------------");
  Serial.println(""); 
  delay(1000);
}

void loop() {
  // analogRead leggerà il valore su A0 restituendo un valore tra 0 e 1023
  val = analogRead(misura);

  // il valore di controllo nell'if deve essere sperimentato in funzione
  // delle necessità costruttive (ad es. la lunghezza del tubo)

  // se vero la persona è seduta
  if (val >= 100) {
    digitalWrite(pinLedAlert, HIGH);                      // accensione del LED di avviso
    Serial.println("Persona NON seduta alla scrivania");  // segnalazione di assenza persona
    Serial.print("Valore letto dal sensore = ");          // Stringa di stampa 
    Serial.println(val);                                  // Valore restituito dall'AnalogRead
    Serial.println("");                                   // Stampa linea vuota di separazione
    delay(1000);                                          // Intervallo di 1 secondo tra ogni stampa
  }
  else
  {
    digitalWrite(pinLedAlert, LOW);                       // spegnimento del LED di avviso
    Serial.println("Persona seduta alla scrivania");      // segnalazione di presenza persona
    Serial.print("Valore letto dal sensore = ");          // Stringa di stampa 
    Serial.println(val);                                  // Valore restituito dall'AnalogRead
    Serial.println("");                                   // Stampa linea vuota di separazione
    delay(1000);                                          // Intervallo di 1 secondo tra ogni stampa
  }
}

Il risultato sulla Serial Monitor è il seguente

Il valore di soglia scelto deve essere ricavato sperimentalmente in funzione della lunghezza e della trasparenza del tubo.

Buon Making a tutti 🙂

Arduino – usare un PIR HC-SR501

Lascia una risposta

Noto spesso nei progetti dei miei studenti il divertimento che nasce nell’utilizzo di un sensore ad infrarossi passivo che viene utilizzato per realizzare dei semplici dispositivi antintrusione, attualmente alcuni allievi li stanno utilizzando in due diversi progetti:

all’interno del kit EduRobot Home in cui il PIR HC-SR501 viene utilizzato come sensore di rilevamento per realizzare un antifurto
attività di PCTO in cui i ragazzi devono implementare un misuratore di sedentarietà, la rilevazione dell’essere umano davanti la computer avviene mediante un PIR.

Questa tipologia di sensore è molto diffuso, li utilizziamo ogni giorno: antifurto di casa, interruttori automatici di luci e molto altro in generale in tutti quei sistemi in cui è indispensabile attivare un’azione nel caso in cui venga rilevata la presenza di un essere umano o di un animale.

Come funziona il sensore di movimento PIR?

Come sicuramente saprete tutti gli oggetti con una temperatura superiore allo zero assoluto (0 Kelvin / -273,15 ° C) emettono energia termica sotto forma di radiazione infrarossa, inclusi i corpi umani. Più un oggetto è caldo, più radiazioni emette.

Il sensore PIR è appositamente progettato per rilevare tali livelli di radiazione infrarossa, è in grado di percepire oggetti caldi in movimento con uno lunghezza d’onda compreso tra i 700 nm e 1 mm . Nel caso della rilevazione di esseri umani la lunghezza d’onda da rilevare è compresa tra 8-14 micrometri.

Il mercato offre diverse tipologie di PIR in funzione del campo di impiego, i più comuni, quelli a lente di Fresnel hanno un range tra i 10 m e i 12 m con un campo di visivo di 300°. E’ possibile trovare sul mercato PIR con un campo visivo che raggiunge i 360° e distanze dell’oggetto rilevato fino a 30 m.

Il PIR fondamentalmente si compone di due parti principali: un sensore piroelettrico e una lente speciale chiamata lente di Fresnel che focalizza i segnali a infrarossi sul sensore piroelettrico.

Un sensore piroelettrico è dotato di due fessure rettangolari al suo interno fatte di un materiale che permette il passaggio della radiazione infrarossa, ciò che verrà rilevato dal sensore sarà la variazione della quantità di raggi infrarossi causata ad esempio dal passaggio di un essere umano e non la quantità di infrarossi totale dell’ambiente.
Le due fessure sono da considerare come due finestre che verranno colpite dai raggi infrarossi e se attraverso le due fessure viene rilevata la stessa quantità di infrarosso allora il segnale risultante di uscita sarà pari a zero, ovvero corpo non rilevato.
Quando però davanti al sensore passa un corpo caldo, come un essere umano, attraverso una finestra verrà rilevata una certa quantità di infrarosso che causerà una differenza di potenziale positiva tra le due finestra, quando il corpo caldo lascia l’area di rilevamento, avviene il contrario, per cui il sensore genera una variazione differenziale negativa. L’impulso di segnali corrispondente fa sì che il sensore imposti il pin di uscita alto, indicandoci quindi la presenza di una persona.

Il sensore HC-SR501, trattandosi di un sensore molto economico, possiede caratteristiche limitate rispetto a quelli che potremo utilizzare per scopi civili o industriali, ma il loro principio di funzionamento è il medesimo.

Analizziamo la scheda

Pinout

Caratteristiche tecniche

Tensione continua di lavoro compresa tra i 4,5V e i 20V
Livelli di tensione di uscita: 3,3V HIGH – 0V LOW
Massimo angolo di visione 110°
Distanza rilevata compresa tra i 3 m e i 7 m

Sulla scheda sono presenti i due trimmer

PIR Range Adjustment (Sensibilità)
Ruotando in senso orario si avrà una diminuzione della sensibilità con decremento della distanza di rilevamento, a fine corsa si avranno approssimativamente una sensibilità di 3 metri.
Ruotando in senso antiorario aumentiamo la sensibilità per raggiungere approssimativamente 7 m.
Time Delay Adjustment (Tempo di delay)
determina la quantità di tempo in cui l’output del sensore PIR rimarrà alto dopo il rilevamento del movimento. L’intervallo è compreso tra circa 3 secondi e 5 minuti. Girando in senso orario, a fine corsa si avrà un delay di 5 minuti, ruotando in senso antiorario, a fine corsa si otterrà un delay di circa 3 secondi.

Si ricordi che impostato il tempo di delay, ad esempio a 5 secondi, ciò comporterà che se viene rilevato il passaggio di un essere umano l’uscita del sensore sarà alta per 5 secondi e in questi 5 secondi il sensore è bloccato, cioè non sarà in grado di rilevare altri movimenti causati da altri corpi.

IMPORTANTE
Dopo il completamento del Time Delay l’uscita sarà a LOW (off) per circa 3 secondi , ciò vuol dire che in questi 3 secondi non verrà rilevato nulla dal sensore.

Sulla scheda è presente un jumper che ha la seguente funzionalità:

Con questo Jumper è possibile impostare le seguenti modalità:

Single Trigger Mode
Il Time Delay viene avviato immediatamente al rilevamento del movimento e il rilevamento continuo viene bloccato.
Questo vuol dire che se ad esempio viene impostato un Time Delay di 5 secondi, al rilevamento di una persona l’uscita passa ad HIGH, se nei 5 secondi passano davanti al sensore un’altra persone questa non viene rilevata e non viene aggiunto un’ulteriore Time Delay.

Immaginate di essere in modalità Single Trigger Mode con un Time Delay di 5 secondi.

Il PIR rileverà il movimento e lo imposterà ad HIGH per 5 secondi.
Dopo cinque secondi il PIR imposta la sua uscita bassa per circa 3 secondi.
Durante i tre secondi, il PIR non rileverà il movimento.
Dopo tre secondi di di LOW, il PIR è abilitato nuovamente al rilevamento di movimenti, al passaggio di una persona verrà impostata nuovamente l’uscita alta per il Time Delay impostato.

Repetable Trigger
Ogni movimento rilevato ripristina il Time Delay, pertanto il Time Delay inizia con l’ultimo movimento rilevato.
Questo vuol dire che se ad esempio viene impostato un Time Delay di 5 secondi, al rilevamento di una persona l’uscita passa ad HIGH se nei 5 secondi viene rilevato il passaggio di un’altra persona il Time Delay riparte nuovamente. Quindi supponendo che:

Persona 1 passa davanti al PIR, parte il Time Delay
Persona 2 passa davanti al PIR al secondo 3, se non passa nessuna persona il Time Delay cesserà ad 8 secondi ed il sensore potrà leggere nuovamente il passaggio di una persona al secondo 11.

IMPORTANTE

Prima di progettare un sistema in cui sono presenti dei PIR ricordare che questi sensori richiedono un po’ di tempo prima di adattarsi alla quantità di energia infrarossa presente nella stanza in cui vengono inseriti, per l’HC-SR501 sono necessari dai 30 ai 60 secondi da quando il sensore viene alimentato.
Ricordare inoltre che il sensore ha un periodo di reset che può oscillare dai 3 ai 6 secondi dopo aver effettuato la lettura, durante tale periodo non verrà rilevato nessun movimento.

Esempio 01
Lettura dello stato del PIR e relativa accensione del LED 13

Schema di collegamento

Il codice per l’utilizzo del sensore è estremamente semplice, è necessario solamente rilevare se il pin OUT si trova a valore alto o basso. Il funzionamento è dettagliato nei commenti.

/*
 * Prof. Michele Maffucci
 * data: 28.02.2021
 * 
 * Esempio 01
 * Utilizzo del sensore PIR: PIR HC-SR501
 * Lettura dello stato del PIR e relativa accensione 
 * del LED 13
 * 
 */
 
byte pinLed = 13;   // pin a cui è collegato il LED
byte pinInput = 8;  // pin di input a cui è collegato l'OUT del PIR
bool valPIR = 0;    // variabile utilizzata per memorizzre lo stato del PIR
 
void setup() {
  pinMode(pinLed, OUTPUT);    // pin a cui è collegato il LED è un output
  pinMode(pinInput, INPUT);   // pin a cui è collegato il PIR è un input
 
  Serial.begin(9600);
}

void loop() {
  valPIR = digitalRead(pinInput);  // viene letto il valore restituito dal PIR
  digitalWrite(pinLed, valPIR);    // il LED sulla scheda verrà acceso se viene
                                   // rilevata una persona altrimenti il LED
                                   // resterà spento. valPIR assume i valori 0 o 1
 }

Esempio 02
Lettura dello stato del PIR e relativa accensione del LED 13 e stampa dello stato sulla Serial Monitor

/*
 * Prof. Michele Maffucci
 * data: 28.02.2021
 * 
 * Esempio 02
 * Utilizzo del sensore PIR: PIR HC-SR501
 * Lettura dello stato del PIR e relativa accensione 
 * del LED 13 e stampa dello stato sulla Serial Monitor
 */
 
byte pinLed = 13;   // pin a cui è collegato il LED
byte pinInput = 8;  // pin di input a cui è collegato l'OUT del PIR
bool valPIR = 0;    // variabile utilizzata per memorizzre lo stato del PIR
 
void setup() {
  pinMode(pinLed, OUTPUT);    // pin a cui è collegato il LED è un output
  pinMode(pinInput, INPUT);   // pin a cui è collegato il PIR è un input
 
  Serial.begin(9600);
}

void loop() {
  valPIR = digitalRead(pinInput);  // viene letto il valore restituito dal PIR
  Serial.println(valPIR);          // stampa sulla Serial Monitor il valore letto
  delay(150);                      // ritardo per rallentare la frequenza di stampa
                                   // sulla Serial Monitor

  // Viene controllato se il PIR rileva una persona
  // Nota: scrivere "if (valPIR)" è analogo che scrivere
  // "if (valPIR == HIGH)" in quanto valPIR assume i valori 0 o 1
  
  if (valPIR) {
    digitalWrite(pinLed, HIGH);
    Serial.println("Rilevata una persona");
  }
  else
  {
    digitalWrite(pinLed, LOW);
    Serial.println("Non è presente nessuno");
  }
 }

Esercizio 01

Realizzare un semplice sistema di allarme costituito dal sensore PIR, un buzzer e due LED uno rosso ed uno verde.

Se il PIR non rileva nessuna persona il LED verde risulta acceso, il LED rosso spento ed il buzzer non emette nessun suono.
Se il PIR rileva una persona il LED verde risulta spento, il LED rosso acceso ed il buzzer emette un suono.

Esercizio 02

Realizzare le medesime funzionalità dell’esercizio 01 ed aggiungere un display I2C su cui inviare l’output:

Allarme
No presenza

Buon Making a tutti 🙂

Arduino – Sensore di temperatura digitale DS18B20 utilizzo in modalità singola

2 Repliche

Nelle attività di laboratorio di Sistemi e TPSEE usiamo molto spesso il sensore di temperatura TMP36, ma un’alternativa interessante al TPM36 è il sensore temperatura digitale DS18B20 utilizzato in modalità diversa dal TPM36.
Questo tipo di sensore è adatto per misure di temperatura ambiente, ma anche del terreno o per rilevare temperature nei liquidi.
Il sensore di solito è disponibile in due form factor, uno che viene fornito nel package TO-92, forma ampiamente utilizzato per i transistor, mentre un’altro, quello utilizzato da me è inserito all’interno di una sonda impermeabile a forma di siluro, utilissimo quando si ha la necessità di misurare temperature sottoterra, sott’acqua, o lontane dal microcontrollore.

Particolarmente utile inoltre in queste settimane in cui i miei studenti di 4′ automazione stanno realizzando come progetto di PCTO una serra idroponica in cui è essenziale misurare la temperatura dell’acqua del sistema.

Il DS18B20 è abbastanza preciso può misurare temperature da -55 ° C a + 125 ° C con una precisione di ± 0,5 ° C.

Il sensore si basa sul protocollo OneWire introdotto da Dallas Semiconductor ora Maxim e richiede due librerie. La prima è la libreria e la DallasTemperature di Miles Burton, la seconda è la libreria OneWire.
La prima libreria da installare è la DallasTemperature di Miles Burton. Sono disponibili diverse librerie con il nome OneWire, quella che vi consiglio di utilizzare è la Wire Library di Jim Studt, Tom Pollard e altri.

Noterete comunque che durante l’installazione della libreria DallasTemperature vi verrà chiesto in automatico se volete installare anche la OneWire, procedete installando in automatico entrambe le librerie. Leggete attentamente le fasi descritte di seguito in cui riporto tutte le schermate delle fasi di installazione.

Il collegamento è estremamente semplice, come indicato nell’immagine che segue collegate il cavo rosso a 5V o a 3,3V su schede a 3,3V, il cavo nero va connesso al GND e il cavo del segnale “Out”, in genere di colore giallo, bianco o di altro colore, collegatelo ad un pin digitale, nell’esempio viene connesso al pin 2 con una resistenza da 4,7 K Ohm tra il segnale e il pin di alimentazione (5 V o 3,3 V).

Pinout

GND: collegamento al ground
Out: Bus Dati 1-Wire, deve essere collegato a un pin digitale sul microcontrollore.
Vdd: da collegare alla tensione di alimentazione (3,3 – 5 V)

Per tutti i dati tecnici del sensore vi rimando al datasheet.

Schema di collegamento

Circuito – sensore con package TO-92

Circuito – sonda impermeabile

Installazione delle librerie

Il protocollo Dallas OneWire è piuttosto complesso e per nascondere questa complessità installeremo la libreria DallasTemperature.h in modo da poter impartire semplici comandi per ottenere letture di temperatura dal sensore.

Per installare la libreria, Sketch > Include Library > Manage Libraries

Inserite nel campo di ricerca: ds18b20. Dovrebbero esserci un paio di voci. Tra le varie possibilità selezionate, quella indicata nell’immagine

Il sensore per poter comunicare ha necessità anche della libreria OneWire, libreria che non è specifica per questo sensore, ma viene utilizzata con tutti i dispositivi che utilizzano il protocollo One Wire.

Nel momento in cui installate la prima libreria della Dallas Semiconductor viene chiesto con una finestra aggiuntiva se volete installare anche la libreria OneWire fate click su Install all.

Nel caso in cui avete dimenticato di installare la libreria OneWire potrete cercare sempre attraverso il Manage Libraries inserendo nel campo di ricerca

Esempio 01

Stampa della temperatura rilevata in gradi Celsius.
Il funzionamento del codice è dettagliato nei commenti.

/* 
 *  Prof. Maffucci Michele
 *  data: 24.02.2021
 *  Utilizzo del sensore di temperatura
 *  resistente all'acqua DS18B20
 *  
 *  Sketch 01: stampa delle temperature rilevate
 *  in gradi Celsius 
*/

// librerie per il funzionamento del sensore
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin Arduino a cui colleghiamo il pin DQ del sensore
const int pinLed = LED_BUILTIN; // Utilizzo del LED su scheda 

const int soglia = 25; // Accende il LED su scheda se si superano i 25°C

OneWire oneWire(ONE_WIRE_BUS); // Imposta la connessione OneWire

DallasTemperature sensore(&oneWire); // Dichiarazione dell'oggetto sensore

void setup(void)
{
  Serial.begin(9600);       // Inizializzazione della serial monitor
  sensore.begin();          // Inizializzazione del sensore
  pinMode(pinLed, OUTPUT);  // pinLed definito come OUTPUT

  // Stampa del messaggio di avvio
  Serial.println("Temperatura rilevata dal sensore DS18B20");
  Serial.println("----------------------------------------");
  delay(1000);
}

void loop()
{
  sensore.requestTemperatures(); // richiesta lettura temperatura
  
  // Restituzione della temperatura letta
  // in gradi Celsius

  // temperatura in Celsius
  float celsius = sensore.getTempCByIndex(0);
  
  // Visualizzazione delle letture 
  // della temperatura sulla Serial monitor
  
  Serial.print("C:");
  Serial.println(celsius);

  // se la temperatura è oltre la soglia
  // viene accesso il LED su scheda
  // altrimenti rimane spento
  
  if (celsius > soglia) {
    digitalWrite(pinLed, HIGH);
  } else {
    digitalWrite(pinLed, LOW);
  }
  // stampe delle temperature ogni secondo
  delay(1000);
}

All’interno del loop, lo sketch richiede una lettura della temperatura, quindi legge la temperatura in Celsius. Notare che non è necessario eseguire alcuna conversione aritmetica su
i risultati ottenuti dal sensore, tutto viene gestito dalla libreria. Tenete in conto che non è necessario apportare modifiche al codice, ma assicurati di cablare correttamente l’alimentazione del sensore, 3,3 V su schede che funzionano a questa tensione di riferimento o a 5V per schede che funzionano a 5V.

Esempio 02

Stampa della temperatura rilevata in gradi Celsius e Fahrenheit
Il funzionamento del codice è dettagliato nei commenti.

/* 
 *  Prof. Maffucci Michele
 *  data: 24.02.2021
 *  Utilizzo del sensore di temperatura
 *  resistente all'acqua DS18B20
 *  
 *  Sketch 02: stampa delle temperature rilevate
 *  in gradi Celsius e gradi Fahrenheit 
*/

// librerie per il funzionamento del sensore
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin Arduino a cui colleghiamo il pin DQ del sensore
const int pinLed = LED_BUILTIN; // Utilizzo del LED su scheda 

const int soglia = 25; // Accende il LED su scheda se si superano i 25°C
// La soglia di 25°C corrisponde a 77 °F
// Formula di conversione (Tc°C × 9/5) + 32 = Tf°F
// dove:
// Tc: temperatura in gradi Celsius
// Tf: temperatura in gradi Fahrenheit

OneWire oneWire(ONE_WIRE_BUS); // Imposta la connessione OneWire

DallasTemperature sensore(&oneWire); // Dichiarazione dell'oggetto sensore

void setup(void)
{
  Serial.begin(9600);       // Inizializzazione della serial monitor
  sensore.begin();          // Inizializzazione del sensore
  pinMode(pinLed, OUTPUT);  // pinLed definito come OUTPUT

  // Stampa del messaggio di avvio
  Serial.println("Temperatura rilevata dal sensore DS18B20");
  Serial.println("----------------------------------------");
  delay(1000);
}

void loop()
{
  sensore.requestTemperatures(); // richiesta lettura temperatura
  
  // Restituzione della temperatura letta
  // in gradi Celsius e gradi Fahrenheit

  // temperatura in Celsius
  float celsius = sensore.getTempCByIndex(0);

  // temperatura in Fahrenheit
  float fahrenheit = sensore.getTempFByIndex(0);
  
  // Visualizzazione delle letture 
  // della temperatura sulla Serial monitor
  
  Serial.print("C:");
  Serial.print(celsius);
  Serial.print(",");
  Serial.print(" F:");
  Serial.println(fahrenheit);

  // se la temperatura è oltre la soglia
  // viene accesso il LED su scheda
  // altrimenti rimane spento
  
  if (celsius > soglia) {
    digitalWrite(pinLed, HIGH);
  } else {
    digitalWrite(pinLed, LOW);
  }
  // stampe delle temperature ogni secondo
  delay(1000);
}

Il codice è molto simile al precedente, all’interno del loop, lo sketch richiede una lettura della temperatura, quindi legge la temperatura in Celsius, poi Fahrenheit.

Sono disponibili alcune utili funzioni che possono essere usate con l’oggetto DallasTemperature di seguito il dettaglio di alcune di esse:

La funzione setResolution() function imposta la risoluzione del convertitore Analogico-Digitale del DS18B20 a 9, 10, 11, or 12-bit, che corrispondono ad incrementi di 0.5°C, 0.25°C, 0.125°C e 0.0625°C.

La funzione setHighAlarmTemp() e setLowAlarmTemp () imposta gli allarmi interni di alta e bassa temperatura in gradi Celsius. L’intervallo valido è compreso tra -55 e 125 ° C

La funzione bool hasAlarm () restituisce true se il sensore rileva una condizione di superamento dei limiti minimo o massimo di temperatura.

Esercizio 1

Rilevare ogni 2 secondi 10 misurazioni, memorizzare questi valori in un Array
Visualizzare la temperatura minima, media e massima ogni 10 secondi su un display 16×2 I2C
Se la temperatura scende sotto il valore minimo o supera il valore massimo impostati viene emesso un allarme (messaggio su display, emissione di un suono, accensione di un LED rosso per il superamento del valore massimo, azzurro se la temperatura scende al di sotto del valore minimo impostato)

Esercizio 2

Realizzare le medesime funzionalità dell’esercizio precedente aggiungendo:

Ridurre la luminosità del display dopo 15 secondi di funzionamento
Alla pressione di un pulsante viene attivata la retroilluminazione del display
Se viene attivato un allarme si attiva la retroilluminazione

Nella prossima lezione vedremo come collegare sullo stesso bus più sensori DS18B20.

Buon Coding a tutti 🙂

FutureLabs – Corso: Attività laboratoriale per fornire competenze per la comunicazione digitale e produzione di mediatori didattici multidisciplinari

Lascia una risposta

Presso il FutureLabs dell’ITIS Pininfarina, istituto presso cui insegno, svolgerò il corso di formazione gratuito:

Attività laboratoriale per fornire competenze per la comunicazione digitale e produzione di mediatori didattici multidisciplinari.

Il corso intende fornire, mediante una metodologia laboratoriale, competenze digitali finalizzate alla comunicazione digitale e produzione di mediatori didattici multidisciplinari realizzabili da docenti e studenti. Il corso è indirizzato a tutti i docenti di ogni ordine e grado.

Tutti gli incontri si svolgeranno on-line e verranno proposte attività di laboratorio a distanza da svolgere in modalità sincrona ed asincrona.

Destinatari: docenti di scuola dell’infanzia, primaria e secondaria di 1° e 2° grado Periodo di svolgimento: n.6 incontri di 3 ore ciascuno nel periodo compreso tra il 23/03.2021 e il 15/04/2021. Per ogni incontro sarà riconosciuta una ulteriore ora in autoformazione.
Iscrizioni: dal 23/2/2021 al 1/3/2021 compilando il form al seguente link. Nel form selezionare come prima scelta: Attività laboratoriale per fornire competenze per la comunicazione digitale e produzione di mediatori didattici multidisciplinari.

Si precisa che al corso saranno ammessi 40 partecipanti. Al corso saranno accettate le domande in ordine cronologico di arrivo e i docenti ammessi riceveranno mail di conferma entro il 4/3/2021.

Argomento del corso sarà la didattica laboratoriale, con particolare attenzione all’uso di specifiche tecnologie: micro:bit, micro:bit Arcade, Arduino, Raspberry Pi, Raspberry Micro. Verranno offerte percorsi didattici completi su Coding e Robotica, proponendo soluzioni opensource e bassissimo costo per ogni ordine di scuola.

Contenuti del corso

Contenuti generali del corso che potranno essere declinati in funzione delle necessità dei corsisti

Progetto dell’attività di laboratorio: dalla ricerca delle fonti alla produzione dell’attività di laboratorio (organizzazione)
Processi di apprendimento: il ruolo dei nuovi media nella didattica
Progettazione di ambienti per la didattica con il digitale: gestire la classe e il laboratorio online
Tecniche di costruzione di contenuti digitali per la didattica – metodologie
L’utilizzo di video e della fotografia nella didattica – tecnologie e strumenti
Costruire strumenti didattici per il Mobile Learning: tecnologie e strategie
L’uso di piattaforme per la didattica – dalla creazione alla gestione
La didattica inclusiva e le opportunità dei nuovi media – strumenti
Coding e Robotica educativa.
- Realizzazione di sistemi di interazione con il mondo reale: tecnologie e loro utilizzo
- Creazione di robot: dal disegno al montaggio del robot alla programmazione
- STEAM con la stampa 3D: disegnare modelli 3D utilizzando il Coding conoscere la tecnologia della stampa 3D
- Simulatori online per la realizzazione di attività laboratoriali di Coding e Robotica.

Competenze in uscita

Sviluppo attività di insegnamento/apprendimento, con capacità nell’indicare la funzione svolta dai media e il modello didattico su cui si basano.
Scegliere e fornire indicazioni consapevoli per la progettazione di ambienti scolastici inclusivi coerenti con le attività didattiche programmate.
Utilizzare software per la realizzazione di contenuti digitali per la didattica, per la creazione di contenuti e abilità nel costruire strumenti didattici in modalità collaborativa con altri docenti e/o con i propri studenti.
Utilizzare software ed hardware specifico per la realizzazione di contenuti attività laboratoriali online ed in presenza, per la creazione di contenuti e abilità nel costruire strumenti didattici in modalità collaborativa con altri docenti e/o con i propri studenti.
Conoscere le fasi di utilizzo dei filmati in un contesto didattico: dall’individuazione o realizzazione del video, alla condivisione e successivo confronto in classe. Utilizzo del funzionamento di software open source per editare i video, per effettuare lo “screencast” e realizzare video-lezioni utilizzando varie tipologie di contenuti.
Utilizzo dei principali Social Network e modalità di integrazione nelle classi per una didattica più vicina agli studenti e un uso del Mobile Learning (m-learning).
Creazione e gestione di una classe virtuale mediante l’uso dei principali applicativi on-line, tecniche di coinvolgimento degli studenti, condivisione di risorse, utilizzo di strumenti integrati, collaborazione con altri docenti.
Saper progettare attività didattiche che valorizzano il ruolo inclusivo delle tecnologie per l’intera classe e nello specifico per alunni con BES e nello specifico saper analizzare e valutare le caratteristiche di uno strumento didattico digitale in ottica inclusiva.
Progettare e gestire attività didattiche basate sulla programmazione di robot (soluzione di labirinti, storytelling, realizzazione di giochi didattici, controllo comportamento e interazione del robot con oggetti esterni). Analisi delle tecnologie e soluzioni didattiche.
Utilizzo di tecnologie specifiche per la realizzazione di attività di laboratorio per il potenziamento delle STEAM mediante specifiche tecnologie: micro:bit, micro:bit Arcade, Arduino, Raspberry Pi, Raspberry Micro. Realizzazione di attività di laboratorio.
Coding on line: piattaforme online gratuiti e ambienti di sviluppo fortemente interattivi.

Vi aspetto 🙂

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati: