Archivi tag: temperatura

Lezione 9 – Corso di Elettronica Creativa con Arduino Sensor Kit

2 Repliche

Sensore di temperatura ed umidità (DHT22)

Ho parlato in precedenti post dei sensori di temperatura ed umidità, nello specifico l’uso del diffusissimo DHT11. L’Arduino Sensor Kit li può usare entrambi, ma nel kit è presente il DHT22.

Caratteristiche tecniche del DHT22

Il DHT22 è un sensore digitale che integra:

  • un elemento capacitivo per l’umidità relativa (RH),
  • un sensore termico per la temperatura,
  • un microcontrollore che invia i dati su un’unica linea (single-wire digitale, non analogica).
  • Range tipici e specifiche:
    • Temperatura: –40…+80 °C (risoluzione 0,1 °C, tip. ±0,5 °C),
    • Umidità relativa: 0…100 % RH (risoluzione 0,1 % RH, tip. ±2 % RH, max ±5 %),
  • Alimentazione: 3,3–5 V,
  • Frequenza di campionamento: max 0,5 Hz (una misura ogni ~2 s).

Cos’è l’umidità relativa

L’umidità relativa (RH) indica quanta vapor d’acqua è presente nell’aria rispetto alla quantità massima che quell’aria potrebbe contenere alla stessa temperatura.

  • 50 % RH = l’aria contiene metà del vapore “possibile” a quella temperatura.
  • 100 % RH = saturazione (rischio di condensa).
    Poiché la capacità dell’aria di trattenere vapore cresce con la temperatura, la RH dipende dalla temperatura: per questo i sensori come il DHT22 misurano entrambe le grandezze.

Mi è capitato spesso rispondere alla domanda: “ma Prof. cosa è meglio usare il DHT11 o il DHT22”

Se si dispone di entrambi certamente scegliere il DHT22 è da preferire, ma perché?

  • Precisione e range migliori: DHT22 copre –40…+80 °C (vs 0…+50 °C del DHT11) con ±0,5 °C tipici; RH 0…100 % con ±2–5 % (DHT11 è meno preciso e più limitato).
  • Risoluzione più fine: 0,1 °C / 0,1 % RH (utile per realizzare grafici e verificare trend).

Un vantaggio derivante dall’uso dell’Arduino Sensor Kit è che il DHT22 viene connesso all’Arduino mediante connessione I²C pertanto per il suo utilizzo è possibile collegarlo ad una delle uscite I²C presenti sulla Base Shield.

Veniamo ora agli esempi pratici, ne indico 6 di base, come sempre nei commenti la spiegazione. In classe ne realizzerò altri in cui mostreremo ad esempio la rilevazione della temperatura a media mobile a 10 campioni, attivazione di allarmi e ventole e molto altro.

Connessioni usate in questa lezione:

  • Sensore di Temperatura ed Umidità: connesso ad una qualsiasi dei pin I²C della Base Shield.
  • Display OLED: connesso ad una qualsiasi dei pin I²C della Base Shield.
  • Diodo LED: connesso al D6.

Esempio 01: sensore ambiente – lettura base (temperatura – umidità)

/*
  Prof. Maffucci Michele
  01.10.2025
  Sensore Ambiente – Lettura base (Temperatura + Umidità)

  NOTE:
    - DHT20 (I2C): decommenta la define Environment_I2C e abilita Wire.begin()
    - DHT11 (pin D3 via Base Shield): commenta la define, la libreria gestisce il pin di default
*/

#include <Arduino_SensorKit.h>

// >>> Decommenta se il sensore è DHT20 (I2C) <<<
#define Environment Environment_I2C

void setup() {
  Serial.begin(9600);
  // Necessario per DHT20 (I2C); non influisce negativamente su DHT11
  Wire.begin();

  Environment.begin();  // inizializza il sensore ambiente (DHT11 o DHT20)
}

void loop() {
  float temperaturaC = Environment.readTemperature(); // °C
  float umiditaRH    = Environment.readHumidity();    // %RH

  // Stampa della temperatura e dell'umidità sulla Serial Monitor ogni secondo
  Serial.print("Temperatura: ");
  Serial.print(temperaturaC, 1);
  Serial.print(" °C   Umidità: ");
  Serial.print(umiditaRH, 1);
  Serial.println(" %");

  delay(1000);
}

Esempio 02: Lettura Temperatura e Umidità con allarme su D6 (LED)

In questo esempio utilizziamo il diodo LED connesso al D6 come allarme, pertanto verrà acceso se la temperatura supera un valore di soglia impostato.

/*
  Prof. Maffucci Michele
  01.10.2025
  Lettura Temperatura e Umidità con allarme su D6 (LED)

  - Allarme: LED su D6 si accende se T > soglia.
  - Messaggi su Serial Monitor: ALERT all'attivazione, DISATTIVATO allo spegnimento.
  - DHT20 (I2C): lascia attiva la define Environment_I2C.
  - DHT11: commenta la define sotto; la libreria gestisce il pin del Base Shield.
*/

#include "Arduino_SensorKit.h"

#define Environment Environment_I2C

// Configurazione allarme
const int pinLedAllarme = 6;            // LED collegato al pin D6
const float sogliaTemperaturaC = 25.0;  // soglia in °C

bool allarmeAttivo = false;  // stato attuale dell'allarme

void setup() {
  Serial.begin(9600);

  // Necessario per DHT20 e per eventuali altre periferiche I2C (OLED, ecc.)
  Wire.begin();

  // Inizializza il sensore ambiente (DHT11 o DHT20 a seconda della define)
  Environment.begin();

  // LED di allarme
  pinMode(pinLedAllarme, OUTPUT);
  digitalWrite(pinLedAllarme, LOW);

  Serial.println("== Avvio lettura Temperatura & Umidita' con allarme su D6 ==");
  Serial.print("Soglia T = ");
  Serial.print(sogliaTemperaturaC, 1);
  Serial.println(" C");
}

void loop() {
  // Letture dal sensore
  float temperaturaC = Environment.readTemperature();  // °C
  float umiditaRH = Environment.readHumidity();        // %RH

// --- Gestione allarme con isteresi ---
// Usiamo DUE soglie diverse per evitare ON/OFF continui vicino al limite.
//  - Soglia di ACCENSIONE  (T_on):  temperaturaC > sogliaTemperaturaC
//  - Soglia di SPEGNIMENTO (T_off): temperaturaC < sogliaTemperaturaC // Finché T resta tra T_off e T_on, manteniamo lo stato attuale (nessun cambiamento). if (!allarmeAttivo && temperaturaC > sogliaTemperaturaC) {
  // Caso 1: l'allarme è attualmente OFF e la temperatura SUPERA la soglia di ACCENSIONE.
  // Accendiamo l'allarme (LED ON) e stampiamo un messaggio di ALERT.
  allarmeAttivo = true;
  digitalWrite(pinLedAllarme, HIGH);

  Serial.print("!!! ALERT: Temperatura sopra soglia: ");
  Serial.print(temperaturaC, 1);
  Serial.println(" C");

} else if (allarmeAttivo && temperaturaC < sogliaTemperaturaC) { // Caso 2: l'allarme è attualmente ON e la temperatura SCENDE sotto la soglia di SPEGNIMENTO // Spegniamo l'allarme (LED OFF) e informiamo che è rientrato. allarmeAttivo = false; digitalWrite(pinLedAllarme, LOW); Serial.print("Allarme DISATTIVATO: Temperatura rientrata: "); Serial.print(temperaturaC, 1); Serial.println(" C"); } // Nota sui casi limite: // - Se temperaturaC == sogliaTemperaturaC, NON si accende (serve ">" strettamente).
// - Se temperaturaC == (sogliaTemperaturaC, NON si spegne (serve "<" strettamente).

  // Stampa della temperatura e dell'umidità sulla Serial Monitor
  Serial.print("T=");
  Serial.print(temperaturaC, 1);
  Serial.print(" C   RH=");
  Serial.print(umiditaRH, 1);
  Serial.print(" %   ALLARME=");
  if (allarmeAttivo) {
    Serial.println("ON");
  } else {
    Serial.println("OFF");
  }

  delay(1000);
}

Esempio 03: Lettura Temperatura e Umidità con allarme su D6 (LED) con isteresi

Premessa

In elettronica, isteresi è la presenza di due soglie diverse per il passaggio tra due stati, così l’uscita dipende non solo dal valore istantaneo dell’ingresso, ma anche dalla sua storia. Serve a evitare commutazioni rapide e instabili quando il segnale oscilla vicino a una soglia.

Come nell’esempio precedente utilizziamo il diodo LED connesso al D6 come allarme, inoltre useremo l’isteresi per evitare che il LED “sfarfalli” (ON/OFF ripetuti) quando la temperatura oscilla vicino alla soglia a causa di rumore o piccole variazioni.

Nello sketch che segue l’isteresi funziona in questo modo:

  • Soglia di attivazione: sogliaTemperaturaC = 26.0 °C
    L’allarme si accende appena T > 26.0 °C.
  • Isteresi: isteresiC = 0.5 °C
    L’allarme si spegne solo quando T < 26.0 − 0.5 = 25.5 °C.

Quindi usi due soglie:

  • T_on = 26.0 °C (accendo quando la supero)
  • T_off = 25.5 °C (spengo solo quando scendo sotto)

Senza isteresi, se la temperatura è nell’intorno di intorno a 26 °C (es. 25.9 ↔ 26.1 per il rumore), l’allarme continuerebbe ad accendersi e spegnersi rapidamente. Con l’isteresi, una volta acceso, resta acceso finché non rientra ben al di sotto della soglia, evitando lampeggi/ronzii fastidiosi e messaggi “ALERT” ripetuti.

Quindi come regola generale per i sensori DHT che utilizziamo in laboratorio valori tra 0,3 e 1°C sono di solito sufficienti. Se è presente ancora sfarfallio, aumentare leggermente; se la risposta è troppo lenta a spegnersi, ridurre.

Come schema logico si tenga in conto:

  • Se allarme OFF e T > T_on → accendere
  • Se allarme ON e T < T_off → spegnere
  • Altrimenti mantenere lo stato corrente

È la stessa logica usata nei termostati: due soglie (accensione/spegnimento) invece di una sola, per ottenere un comportamento stabile.

/*
  Prof. Maffucci Michele
  01.10.2025
  Lettura Temperatura e Umidità con allarme su D6 (LED) con isteresi

  - Allarme: LED su D6 si accende se T > soglia.
  - Messaggi su Serial Monitor: ALERT all'attivazione, DISATTIVATO allo spegnimento.
  - DHT20 (I2C): lascia attiva la define Environment_I2C.
  - DHT11: commenta la define sotto; la libreria gestisce il pin del Base Shield.
*/

#include <Arduino_SensorKit.h>

#define Environment Environment_I2C

// Configurazione allarme
const int pinLedAllarme = 6;            // LED collegato al pin D6
const float sogliaTemperaturaC = 25.0;  // soglia in °C
const float isteresiC = 0.5;            // isteresi per evitare lampeggi (spegnimento sotto soglia - isteresi)

bool allarmeAttivo = false;  // stato attuale dell'allarme

void setup() {
  Serial.begin(9600);

  // Necessario per DHT20 e per eventuali altre periferiche I2C (OLED, ecc.)
  Wire.begin();

  // Inizializza il sensore ambiente (DHT11 o DHT20 a seconda della define)
  Environment.begin();

  // LED di allarme
  pinMode(pinLedAllarme, OUTPUT);
  digitalWrite(pinLedAllarme, LOW);

  Serial.println("== Avvio lettura Temperatura & Umidita' con allarme su D6 ==");
  Serial.print("Soglia T = ");
  Serial.print(sogliaTemperaturaC, 1);
  Serial.println(" C");
}

void loop() {
  // Letture dal sensore
  float temperaturaC = Environment.readTemperature();  // °C
  float umiditaRH = Environment.readHumidity();        // %RH

// --- Gestione allarme con isteresi ---
// Usiamo DUE soglie diverse per evitare ON/OFF continui vicino al limite.
//  - Soglia di ACCENSIONE  (T_on):  temperaturaC > sogliaTemperaturaC
//  - Soglia di SPEGNIMENTO (T_off): temperaturaC < (sogliaTemperaturaC - isteresiC) // Finché T resta tra T_off e T_on, manteniamo lo stato attuale (nessun cambiamento). if (!allarmeAttivo && temperaturaC > sogliaTemperaturaC) {
  // Caso 1: l'allarme è attualmente OFF e la temperatura SUPERA la soglia di ACCENSIONE.
  // Accendiamo l'allarme (LED ON) e stampiamo un messaggio di ALERT.
  allarmeAttivo = true;
  digitalWrite(pinLedAllarme, HIGH);

  Serial.print("!!! ALERT: Temperatura sopra soglia: ");
  Serial.print(temperaturaC, 1);
  Serial.println(" C");

} else if (allarmeAttivo && temperaturaC < (sogliaTemperaturaC - isteresiC)) { // Caso 2: l'allarme è attualmente ON e la temperatura SCENDE sotto la soglia di SPEGNIMENTO // (cioè sotto la soglia di accensione meno l'isteresi). // Spegniamo l'allarme (LED OFF) e informiamo che è rientrato. allarmeAttivo = false; digitalWrite(pinLedAllarme, LOW); Serial.print("Allarme DISATTIVATO: Temperatura rientrata: "); Serial.print(temperaturaC, 1); Serial.println(" C"); } // Nota sui casi limite: // - Se temperaturaC == sogliaTemperaturaC, NON si accende (serve ">" strettamente).
// - Se temperaturaC == (sogliaTemperaturaC - isteresiC), NON si spegne (serve "<" strettamente).
// Questo evita cambi di stato ripetuti quando il valore oscilla esattamente sulla soglia.

  // Stampa della temperatura e dell'umidità sulla Serial Monitor
  Serial.print("T=");
  Serial.print(temperaturaC, 1);
  Serial.print(" C   RH=");
  Serial.print(umiditaRH, 1);
  Serial.print(" %   ALLARME=");
  if (allarmeAttivo) {
    Serial.println("ON");
  } else {
    Serial.println("OFF");
  }

  delay(1000);
}

Esempio 04: Lettura Temperatura e Umidità con stampa su OLED e Serial Monitor

Abbiamo visto nella precedente lezione l’uso del display OLED dell’Arduino Sensor Kit, utilizziamolo ora per mostrare temperatura ed umidità che stamperemo anche sulla Serial Monitor.

/*
  Prof. Maffucci Michele
  01.10.2025
  Lettura Temperatura e Umidità con stampa su OLED e Serial Monitor

  - DHT20 (I2C): lascia attiva la define Environment_I2C.
  - DHT11: commenta la define sotto; la libreria gestisce il pin del Base Shield.
*/

#include <Arduino_SensorKit.h>

#define Environment Environment_I2C

void setup() {
  Serial.begin(9600);
  Wire.begin();         // necessario con DHT20/OLED su I2C
  Environment.begin();  // DHT11 o DHT20 (in base alla define)
  Oled.begin();         // inizializza OLED

  // Orientamento e font leggibile
  Oled.setFlipMode(true);
  Oled.setFont(u8x8_font_chroma48medium8_r);

  // Pulisci UNA volta all’avvio
  Oled.clearDisplay();

  // Etichette fisse (non cambiano > non serve riscriverle)
  Oled.setCursor(0, 2);
  Oled.print("T=");
  Oled.setCursor(0, 4);
  Oled.print("RH=");
}

void loop() {

  float tC = Environment.readTemperature();  // °C
  float rH = Environment.readHumidity();     // %RH

  // --Stampa su OLED

  // Sovrascrivo soltanto il campo variabile, SENZA clearDisplay
  Oled.setCursor(2, 2);  // subito dopo "T="
  Oled.print(tC);

  Oled.setCursor(3, 4);  // subito dopo "RH="
  Oled.print(rH);

  // --Stampa su seriale
  Serial.print("T=");
  Serial.print(tC);
  Serial.print(" C   RH=");
  Serial.print(rH);
  Serial.println(" %");

  delay(500);  // aggiorna 2 volte al secondo (meno sfarfallio)
}

Esempio 05: Lettura Temperatura e Umidità con stampa su OLED e Serial Monitor ed accensione LED con isteresi

Aggiungiamo alla versione precedente l’allarme dato con il LED.

/*
  Prof. Maffucci Michele
  01.10.2025
  Lettura Temperatura e Umidità con stampa su OLED e Serial Monitor
  ed accensione LED con isteresi

  - DHT20 (I2C): lascia attiva la define Environment_I2C.
  - DHT11: commenta la define sotto; la libreria gestisce il pin del Base Shield.
*/

#include <Arduino_SensorKit.h>

#define Environment Environment_I2C

// Configurazione allarme
const int pinLedAllarme = 6;            // LED collegato al pin D6
const float sogliaTemperaturaC = 25.0;  // soglia in °C
const float isteresiC = 0.5;            // isteresi per evitare lampeggi (spegnimento sotto soglia - isteresi)

bool allarmeAttivo = false;  // stato attuale dell'allarme

void setup() {
  Serial.begin(9600);
  Wire.begin();         // necessario con DHT20/OLED su I2C
  Environment.begin();  // DHT11 o DHT20 (in base alla define)
  Oled.begin();         // inizializza OLED

  // Orientamento e font leggibile
  Oled.setFlipMode(true);
  Oled.setFont(u8x8_font_chroma48medium8_r);

  // Pulisci UNA volta all’avvio
  Oled.clearDisplay();

  // Etichette fisse (non cambiano → non serve riscriverle)
  Oled.setCursor(0, 2);
  Oled.print("T=");
  Oled.setCursor(0, 4);
  Oled.print("RH=");

  pinMode(pinLedAllarme, OUTPUT);
  digitalWrite(pinLedAllarme, LOW);

  Serial.println("== Avvio lettura Temperatura & Umidita' con allarme su D6 ==");
  Serial.print("Soglia T = ");
  Serial.print(sogliaTemperaturaC, 1);
  Serial.println(" C");
}

void loop() {

  float tC = Environment.readTemperature();  // °C
  float rH = Environment.readHumidity();     // %RH

// --- Gestione allarme con isteresi ---
// Usiamo DUE soglie diverse per evitare ON/OFF continui vicino al limite.
//  - Soglia di ACCENSIONE  (T_on):  temperaturaC > sogliaTemperaturaC
//  - Soglia di SPEGNIMENTO (T_off): temperaturaC < (sogliaTemperaturaC - isteresiC) // Finché T resta tra T_off e T_on, manteniamo lo stato attuale (nessun cambiamento). if (!allarmeAttivo && tC > sogliaTemperaturaC) {
  // Caso 1: l'allarme è attualmente OFF e la temperatura SUPERA la soglia di ACCENSIONE.
  // Accendiamo l'allarme (LED ON) e stampiamo un messaggio di ALERT.
  allarmeAttivo = true;
  digitalWrite(pinLedAllarme, HIGH);

  Serial.print("!!! ALERT: Temperatura sopra soglia: ");
  Serial.print(tC, 1);
  Serial.println(" C");

} else if (allarmeAttivo && tC < (sogliaTemperaturaC - isteresiC)) {
  // Caso 2: l'allarme è attualmente ON e la temperatura SCENDE sotto la soglia di SPEGNIMENTO
  // (cioè sotto la soglia di accensione meno l'isteresi).
  // Spegniamo l'allarme (LED OFF) e informiamo che è rientrato.
  allarmeAttivo = false;
  digitalWrite(pinLedAllarme, LOW);

  Serial.print("Allarme DISATTIVATO: Temperatura rientrata: ");
  Serial.print(tC, 1);
  Serial.println(" C");
}

  // -- Stampa su OLED --

  // Sovrascrivo soltanto il campo variabile, SENZA clearDisplay
  Oled.setCursor(2, 2);  // subito dopo "T="
  Oled.print(tC);

  Oled.setCursor(3, 4);  // subito dopo "RH="
  Oled.print(rH);

  // -- Stampa su seriale --
  Serial.print("T=");
  Serial.print(tC);
  Serial.print(" C   RH=");
  Serial.print(rH);
  Serial.println(" %");

  delay(500);  // aggiorna 2 volte al secondo (meno sfarfallio)
}

Esempio 06: lettura Temperatura & Umidità con stampa su OLED e Serial Monitor ed accensione LED – su OLED viene mostrato allarme

Aggiungiamo allo sketch precedente la visualizzazione del messaggio di alert sul display. Per semplicità di lettura ho tolto i commenti nella sezione: “Gestione allarme con isteresi”, lasciando solo quelli che si riferiscono alla stampa dell’alert sul display.

/*
  Prof. Maffucci Michele
  01.10.2025
  Lettura Temperatura & Umidità con stampa su OLED e Serial Monitor
  ed accensione LED - su OLED viene mostrato allarme

  - DHT20 (I2C): lascia attiva la define Environment_I2C.
  - DHT11: commenta la define sotto; la libreria gestisce il pin del Base Shield.
*/

#include <Arduino_SensorKit.h>

#define Environment Environment_I2C

// Configurazione allarme
const int pinLedAllarme = 6;            // LED collegato al pin D6
const float sogliaTemperaturaC = 25.0;  // soglia in °C
const float isteresiC = 0.5;            // isteresi per evitare lampeggi (spegnimento sotto soglia - isteresi)

bool allarmeAttivo = false;  // stato attuale dell'allarme

void setup() {
  Serial.begin(9600);
  Wire.begin();         // necessario con DHT20/OLED su I2C
  Environment.begin();  // DHT11 o DHT20 (in base alla define)
  Oled.begin();         // inizializza OLED

  // Orientamento e font leggibile
  Oled.setFlipMode(true);
  Oled.setFont(u8x8_font_chroma48medium8_r);

  // Pulisci UNA volta all’avvio
  Oled.clearDisplay();

  // Etichette fisse (non cambiano → non serve riscriverle)
  Oled.setCursor(0, 2);
  Oled.print("T=");
  Oled.setCursor(0, 4);
  Oled.print("RH=");

  pinMode(pinLedAllarme, OUTPUT);
  digitalWrite(pinLedAllarme, LOW);

  Serial.println("== Avvio lettura Temperatura & Umidita' con allarme su D6 ==");
  Serial.print("Soglia T = ");
  Serial.print(sogliaTemperaturaC, 1);
  Serial.println(" C");
}

void loop() {

  float tC = Environment.readTemperature();  // °C
  float rH = Environment.readHumidity();     // %RH

  // --- Gestione allarme con isteresi ---
  if (!allarmeAttivo && tC > sogliaTemperaturaC) {
    allarmeAttivo = true;
    digitalWrite(pinLedAllarme, HIGH);

    // cursore nell'angolo in alto a destra
    Oled.setCursor(0, 0);
    // stampa del messaggio di alert
    Oled.print("ALERT: t>tMax");
    Serial.print("!!! ALERT: Temperatura sopra soglia: ");
    Serial.print(tC, 1);
    Serial.println(" C");
  } else if (allarmeAttivo && tC < (sogliaTemperaturaC - isteresiC)) {
    allarmeAttivo = false;
    digitalWrite(pinLedAllarme, LOW);

    // cursore nell'angolo in alto a destra
    Oled.setCursor(0, 0);
    // cancellazione con spazi del messaggio di alert
    Oled.print("             ");
    Serial.print("Allarme DISATTIVATO: Temperatura rientrata: ");
    Serial.print(tC, 1);
    Serial.println(" C");
  }

  // -- Stampa su OLED --

  // Sovrascrivo soltanto il campo variabile, SENZA clearDisplay
  Oled.setCursor(2, 2);  // subito dopo "T="
  Oled.print(tC);

  Oled.setCursor(3, 4);  // subito dopo "RH="
  Oled.print(rH);

  // -- Stampa su seriale --
  Serial.print("T=");
  Serial.print(tC);
  Serial.print(" C   RH=");
  Serial.print(rH);
  Serial.println(" %");

  delay(500);  // aggiorna 2 volte al secondo (meno sfarfallio)
}

Buon Coding a tutti 🙂

Related posts:

  1. Quick References per lo studio – Checklist pre-verifica
  2. La micro matita
  3. L’alfabeto di Scratch
  4. Cosa sono le awesome list?

BBC micro:bit – usare un sensore DHT 22

Lascia una risposta

Durante il mio ultimo corso sulla realizzazione di mini serre indoor, ho fornito ai corsisti le competenze di base per usare una serie di sensori controllati dal micro:bit. Alcuni colleghi possedevano kit generici di componentistica elettronica tra cui sensori non disposti PCB board, pertanto per alcuni non erano presenti quei componenti che permettevano l’interfacciamento al microcontrollore. È il caso ad esempio del DHT22 sensore di temperatura è umidità relativa che ha una modalità di utilizzo molto simile al più noto ed economico DHT11.

Le caratteristiche tecniche dei due sensori sono indicate di seguito:

DHT11 DHT22
Intervallo di temperatura 0 to 50 ºC +/-2 ºC -40 to 80 ºC +/-0.5ºC
Intervallo di umidità 20 to 90% +/-5% 0 to 100% +/-2%
Risoluzione Umidità: 1%
Temperatura: 1ºC		 Umidità: 0.1%
Temperatura: 0.1ºC
Tensione di funzionamento 3 – 5.5 V DC 3 – 6 V DC
Corrente di funzionamento 0.5 – 2.5 mA 1 – 1.5 mA
Periodo di campionamento 1 secondo 2 secondo

Il sensore DHT22 può essere acquistato nelle due modalità: su PCB board oppure in modalità solo componente come indicato nell’immagine che segue:

Il DHT22 per poter funzionare necessità di un resistore di pull-up che nella versione PCB è già presente. Nel caso si dispone del solo sensore è necessario aggiungere un resistore tra i 5k ohm e i 10k ohm connesso come nell’immagine che segue:

La modalità di utilizzo del sensore con il micro:bit è estremamente semplice e richiede solamente l’installazione di un’estensione che potrete cercare facendo clic su “Extensions” ed inserendo nel campo di ricerca dht22. L’estensione sarà DHT11_DHT22 in grado di gestire sia il DHT11 che il DHT22.

Seguire il link per consultare la pagina di riferimento dell’estensione utilizzata.

Come potrete leggere l’istruzione di configurazione riportata nell’immagine che segue è costituita da una serie di campi:

  • Query: permette la selezione del tipo di sensore, DHT11 o DHT22
  • Data pin: è il pin del micro:bit a cui dovremo connettere il pin data del DHT22
  • Pin pull-up: indica se presente il resistore di pull-up nel nostro caso dovrà essere impostato a true. Nel caso fosse impostato a false verrà utilizzato il resistore di pull-up interno del micro:bit che è di circa 13 K ohm.
  • Serial output: stabilisce se si vuole un output sulla serial monitor, false non mostra i dati, true li mostra
  • Wait 2 sec after query: se impostato su true consente di fissare l’intervallo tra due interrogazioni al sensore a 2 secondi, lasciare questa impostazione. È importante non ridurre questo intervallo altrimenti il sensore non riuscirà a fornirci la misura.

Durante la comunicazione tra sensore e micro:bit viene effettuato un controllo di eventuali errori di comunicazione, se ciò accade leggerete in output il codice di errore -999 se l’errore persiste per più secondo molto probabilmente il problema è di carattere elettivo, nella maggior parte dei casi una connessione mancante o errata connessione elettrica tra i dispositivi.

Aggiungo alcuni programmi che mostrano il funzionamento del DHT22.

Stampa su display della temperatura rilevata:

Link al programma.

Stampa su display della temperatura e dell’umidità rilevata:

Link al programma.

Stampa su Serial Monitor della temperatura rilevata:

Link al programma.

Stampa sulla serial monitor temperatura ed umidità rilevata:

Link al programma.

Buon Making a tutti 🙂

Related posts:

  1. L’alfabeto di Scratch
  2. Arduino: realizzare un menù di selezione utilizzando un Diaplay LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T
  3. Video di presentazione del corso: Realizzare laboratori green con il Making e il Coding
  4. Arduino: Sensore resistivo di umidità del terreno

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 🙂

Related posts:

  1. Corsi di formazioni CTS: LIM e Apprendere Progettando e Pasticciando
  2. L’alfabeto di Scratch
  3. MaKey MaKey nella Robot Pet Therapy e non solo
  4. La micro matita

Arduino: utilizzo del sensore di umidità e temperatura DHT11

Lascia una risposta

Proseguo con le sperimentazioni di laboratorio di Sistemi dedicate alla progettazione di una semplice stazione meteorologica. In questa lezione i miei allievi di 5 Automazione dovranno gestire un sensore di umidità e temperatura DHT 11 e svolgere successivamente i tre esercizi proposti al termine di questa guida.

Il DHT11 è un sensore digitale di umidità e temperatura dell’aria costituito da una parte resistiva che si occupa della rilevazione dell’umidità e da un NTC che rileva la temperatura, queste due parti sono gestite da un microcontrollore che è parte integrante del sensore. Il DHT 11 viene pre-calibrato in fabbrica e i dati di calibrazione vengono memorizzati all’interno di una memoria di sola lettura (OPT Memory).

Caratteristiche del sensore

  • Intervallo di temperatura: da 0 a 50 ºC +/-2 ºC
  • Intervallo di umidità: da 20 a 90% +/-5%
  • Risoluzione:
    • Umidità: 1%
    • Temperatura: 1ºC
  • Tensione di alimentazione: 3 – 5.5 V DC
  • Corrente assorbita: 0.5 – 2.5 mA
  • Periodo di campionamento: 1 sec

Le dimensioni ridotte, il basso consumo energetico e la possibilità di trasmettere il segnale su cavo fino a 20 metri lo rendono interessante per diverse applicazioni sia in campo hobbistico che semiprofessionale.

Quando la lunghezza del cavo di collegamento è inferiore a 20 metri è consigliabile inserire una resistenza di pull-up da 4,7 Kohm sulla linea dati (pin 2).

Il sensore può essere acquistato in due configurazioni:

Componente singolo a 4 pin su stessa linea

Componente montato su breakout board a 3 pin (in questo caso la resistenza di pull-up interna sul pin 2 è già presente)

Pinout

Nel caso in cui si utilizzi il componente a 4 pin la corrispondenza è la seguente

  • pin 1: Vcc
  • pin 2: Out
  • pin 3: non connesso
  • pin 4: GND

Per filtrare i segnali di disturbo provenienti dall’alimentazione è consigliabile inserire un condensatore da 100nF tra Vcc e GND.

Modalità di comunicazione

La lettura dei dati rilevati dal sensore può avvenire solo dopo un tempo di 1 secondo dall’atto dell’accensione del sensore.

La comunicazione con il sensore avviene utilizzando una connessione seriale che utilizza un solo filo (Single-Wire Two-Way). Il pacchetto informativo che include i dati di temperatura ed umidità inviati dal sensore ha una lunghezza di 40 bit ed una durata di 4 ms.

Il DHT11 quando alimentato si pone in una modalità a basso consumo. Quando il microcontrollore invia un segnale di start, il DHT11 passa dalla modalità a basso consumo alla modalità di funzionamento nell’attesa che il Microcontrollore completi la fase di avvio. Completata la fase di avvio il sensore invia un pacchetto informativo di risposta al microcontrollore costituito da 40 bit al cui interno si trovano le informazioni relative a umidità e temperatura rilevate. Senza il segnale di start proveniente dal microcontrollore il DHT11 non fornirà mai i dati. Conclusa la fase di invio dati il DHT11 ritorna in una modalità a basso consumo fino a quando non rileva un nuovo segnale di start proveniente dal microcontrollore.

Schema di collegamento

Per poter utilizzare il sensore è indispensabile utilizzare una libreria specifica, utilizzeremo  la libreria DHT di Adafruit

Per poter installare la libreria andare in Sketch > Library > Include Library > Manage Libraries

Inserite nel campo di ricerca “DHT” e selezionate la libreria di Adafruit:

Procedere successivamente all’installazione della libreria “Adafruit Unified Sensor”, procedendo seguendo la medesima procedura adottata per la libreria precedente:

Per verificare il funzionamento del sensore aprite lo sketch: File > Examples > DHT Sensor library > DHTtester

Lo sketch DHTtester permetterà di stampare temperatura e umidità sulla Serial Monitor

// Example testing sketch for various DHT humidity/temperature sensors
// Written by ladyada, public domain

// REQUIRES the following Arduino libraries:
// - DHT Sensor Library: https://github.com/adafruit/DHT-sensor-library
// - Adafruit Unified Sensor Lib: https://github.com/adafruit/Adafruit_Sensor

#include "DHT.h"

#define DHTPIN 2     // Digital pin connected to the DHT sensor
// Feather HUZZAH ESP8266 note: use pins 3, 4, 5, 12, 13 or 14 --
// Pin 15 can work but DHT must be disconnected during program upload.

// Uncomment whatever type you're using!
#define DHTTYPE DHT11   // DHT 11
//#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors.  This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  Serial.println(F("DHTxx test!"));

  dht.begin();
}

void loop() {
  // Wait a few seconds between measurements.
  delay(2000);

  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit (isFahrenheit = true)
  float f = dht.readTemperature(true);

  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  // Compute heat index in Fahrenheit (the default)
  float hif = dht.computeHeatIndex(f, h);
  // Compute heat index in Celsius (isFahreheit = false)
  float hic = dht.computeHeatIndex(t, h, false);

  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  Temperature: "));
  Serial.print(t);
  Serial.print(F("°C "));
  Serial.print(f);
  Serial.print(F("°F  Heat index: "));
  Serial.print(hic);
  Serial.print(F("°C "));
  Serial.print(hif);
  Serial.println(F("°F"));
}

Analisi del codice

Inclusione della libreria DHT

#include "DHT.h"

Definizione del pin digitale di Arduino a cui collegheremo il pin dati del DHT 11

#define DHTPIN 2     // Digital pin connected to the DHT sensor

Definizione di quale tipo di sensore DHT deve essere utilizzato, nel nostro caso il DHT 11.

#define DHTTYPE DHT11   // DHT 11

Se state utilizzando un altro sensore DHT, dovrete commentare la riga precedente e rimuovere il commento da una delle seguenti linee di codice:

//#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

Inizializza un oggetto DHT chiamato dht con il pin e digitale che avete definito in precedenza

DHT dht(DHTPIN, DHTTYPE);

Nel setup() inizializziamo la Serial Monitor con un baud rate di 9600 caratteri e scriviamo un testo per avere percezione che il sistema è avviato

  Serial.begin(9600);
  Serial.println(F("DHTxx test!"));

Inizializziamo il sensore DHT con il metodo .begin()

dht.begin();

Nel loop() viene aggiunto un ritardo di 2 secondi affinché il sensore si stabilizzi ed abbia il tempo di effettuare la lettura dei dati. La frequenza di campionamento massima è di due secondi per il DHT22 e un secondo per il DHT11.

delay(2000);

Per ottenere l’umidità, è sufficiente utilizzare il metodo readHumidity() sull’oggetto dht. Nello scketck viene salvato il valore nella variabile. Si noti che il metodo readHumidity() restituisce un valore di tipo float.

float h = dht.readHumidity();

Per ottenere leggere la temperatura bisogna utilizzare il metodo readTemperature()

float t = dht.readTemperature();

Nel caso in cui si voglia leggere la temperatura in gradi Fahrenheit è sufficiente passare il valore true al metodo readTemperature()

  float f = dht.readTemperature(true);

La libreria include anche metodi per calcolare l’indice di calore in Fahrenheit e Celsius

  // Compute heat index in Fahrenheit (the default)
  float hif = dht.computeHeatIndex(f, h);
  // Compute heat index in Celsius (isFahreheit = false)
  float hic = dht.computeHeatIndex(t, h, false);

Il codice che segue stampa sulla Serial Monitor i dati letti

  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  Temperature: "));
  Serial.print(t);
  Serial.print(F("°C "));
  Serial.print(f);
  Serial.print(F("°F  Heat index: "));
  Serial.print(hic);
  Serial.print(F("°C "));
  Serial.print(hif);
  Serial.println(F("°F"));

Effettuato l’upload dello sketch sulla scheda aprendo la Serial Monitor vedere i dati letti dal sensore

Noterete che il sensore risulta molto lento nel fornire la temperatura e l’umidità reale, ha necessità di qualche minuto affinché la misura si stabilizzi su quella realmente presente nell’ambiente.

Di seguito lo sketch semplificato in più parti che fornisce solo la lettura di umidità e temperatura:

// Libreria DHT
#include "DHT.h"

// Pin digitale di arduino connesso al DHT
#define DHTPIN 2

// tipo del sensore: DHT 11
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  Serial.println(F("DHTxx test!"));

  dht.begin();
}

void loop() {
  // Attesa di 2 secondi prima di fornire la misura.
  delay(2000);

  // Lettura dell'umidità
  float h = dht.readHumidity();
  // Lettura della temperatura in gradi Celsius
  float t = dht.readTemperature();

  // Verifica se le si presenta un errore di lettura (e riprova nuovamente)
  if (isnan(h) || isnan(t)) {
    Serial.println(F("Impossibile leggere dal sensore DHT!"));
    return;
  }

  Serial.print(F("Umidità: "));
  Serial.print(h);
  Serial.print(F("%  Temperatura: "));
  Serial.print(t);
  Serial.println(F("°C "));
}

Nota

Avrete sicuramente notato che l’istruzione Serial.print contiene al suo interno come parametro F(“testo”). La “F” indica che la stringa non utilizza la RAM della scheda.

Quando compilate uno sketch Arduino alla fine della compilazione viene indicata la quantità di memoria occupata dal programma (memorizzata nella memoria flash) che state utilizzando e la quantità di RAM dinamica che state utilizzando.

Nel caso si utilizzi un gran quantità di testo costante potreste incorrere in un messaggio di errore di “memoria insufficiente”, ciò vuol dire che si è esaurita la RAM a disposizione.

Ciò dipende dal fatto che le stringhe di testo costanti presenti nello sketch vengono sempre allocate in RAM.

Per risolvere il problema è sufficiente indicare al compilatore che tutte le stringhe di testo costanti contenute nelle Serial.print non dovranno essere allocate nella RAM.

Attenzione che ciò non potrete essere fatto per le Serial.print che contengono variabili.

Quindi

  Serial.print("Umidità: ");

può essere sostituita con

  Serial.print(F("Umidità: "));

e così anche per le altre Serial.print che contengono un testo costante.

Esercizi

Esercizio 1: inviare temperatura e umidità su un display 16×2 I2C

Esercizio 2: utilizzare due pulsanti che permetteranno rispettivamente di mostrare temperatura e pressione sul display

Esercizio 3: All’avvio dello sketch con retroilluminazione attiva, appare un messaggio di benvenuto che dura 2 secondi, successivamente un messaggio che mostra l’help di utilizzo, ad esempio:

  • P1 temperatura
  • P2 umidità

questo messaggio persiste per 5 secondi, dopo di che la retroilluminazione viene disattivata (il testo help rimane presente sul display).

Non appena si preme uno dei due pulsanti si attiva la retroilluminazione del display e compare il dato richiesto per 5 secondi, allo scadere del tempo ricompare l’help e la retroilluminazione si disattiva.

Buon making a tutti 🙂

Related posts:

  1. L’alfabeto di Scratch
  2. La micro matita
  3. I miei corsi: Apprendimento attivo con Raspberry Pi e Arduino
  4. Video di presentazione del corso: Realizzare laboratori green con il Making e il Coding

Coding a scuola con BBC micro:bit – lezione 8

1 Replica

Incominciamo questa lezione fornendo la soluzione all’esercizio della lezione precedente.

Specifiche dell’esercizio

Dovreste notare che al termine del conteggio, quando sul display compare “0” la pressione successiva del pulsante “B” visualizzerà sul display il valore “-1”, ciò capita perché l’ultimo valore assunto da “contatore” è proprio “-1”.

Come possiamo risolvere il problema?

E’ sufficiente reimpostare la variabile “contatore” a “0” non appena è concluso il controllo della fine del conteggio, così come indicato nell’immagine che segue:

Proseguiamo con la lezione 8

Introduzione

In questa lezione utilizzeremo il sensore di temperatura presente sulla nostra scheda per mostrarla sulla matrice di LED quando scuotiamo il micro:bit

Di cosa avete bisogno

  • n.1 BBC micro:bit
  • n.1 Micro USB
  • n.1 Computer o tablet
  • n.2 x Batterie AAA ed un contenitore per le batterie (opzionale perché la scheda potrà essere alimentata direttamente anche via USB)

Programmiamo

  1. Selezionate dal menù delle istruzioni “on shake” e trascinatela all’interno dell’area di programmazione

  1. Poiché l’obiettivo è quello di rilevare la temperatura ambiente una volta che scuotiamo il micro:bit, abbiamo bisogno di una variabile in cui memorizzare il valore della temperatura. Dalla sezione “Variables” fate click su “Make a Variable” per creare la variabile “temperatura”

Il blocco “temperatura” all’interno del menù “Variables”

Continua a leggere→

Related posts:

  1. Corsi di formazioni CTS: LIM e Apprendere Progettando e Pasticciando
  2. I miei corsi Arduino presso l’Università di Padova – Ultimi sforzi ed ultime sperimentazioni di fine anno
  3. Arduino UNO R4 WiFi – usare la matrice LED per esercitarsi con i cicli for
  4. LightBlue Bean – programmare un microcontrollore Arduino da dispositivo mobile… e non solo