Archivi tag: i2c

Lezione 9 – Corso di Elettronica Creativa con Arduino Sensor Kit

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 🙂

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:

/*
   Prof. Maffucci Michele
   https://www.maffucci.it
   Ver.1 - 27.12.21
   Controllo di luminosità LED con
   visualizzazione intensità mediante una
   barra di avanzamento su display 16x2
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

byte pinPot = A0;           // pin analogico 0 a cui connettere il potenziometro per controllare la luminosità
byte pinLed = 3;            // pin PWM a cui connettere il LED
int  analogVal = 0;         // variabile in cui memorizzare il valore impostato dal potenziometro
int  luminosita = 0;        // variabile in cui memorizzare la luminosità
byte barraAvanzamento = 0;  // indice barra avanzamento

// Per maggiori informazioni sulla realizzazione di caratteri speciali:
// https://www.maffucci.it/2020/01/18/disegnare-caratteri-personalizzati-con-arduino-per-un-lcd-16x2/

// Carattere personalizzato per disegnare la barraAvanzamento di avanzamento
byte iconaBarra[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
// impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
LiquidCrystal_I2C lcd(0x27, 16, 2);
//-----------------------------

void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione

  // Inpostazione ad OUTPUT del pin a cui connettiamo il LED
  pinMode(pinLed, OUTPUT);

  // Cancella il display
  lcd.clear();

  // Stampa il messaggio sulla prima riga del display
  lcd.print("Luminosita' LED");

  //Creazione del carattere per la barra di avanzamento
  lcd.createChar(0, iconaBarra);
}

// Per maggiori informazioni sull'uso del display 16x2 I2C:
// https://www.maffucci.it/2019/01/25/utilizzo-delllcd-16x2-hitachi-hd44780-1602-con-modulo-i2c-pcf8574t/
//-----------------------------

void loop() {
  // Cancella il display
  lcd.clear();

  // Stampa il messsaggio sulla prima riga
  lcd.print("Luminosita' LED");

  //Posiziona il cursore nella seconda riga, prima colonna
  lcd.setCursor(0,1);

  // Lettura del valore impostato dal potenziometro
  analogVal = analogRead(pinPot);

  // Conversione del valore analogico impostato con il potenziometro
  // in Duty Cicle per impostare la luminosità del LED
  luminosita=map(analogVal, 0, 1024, 0, 255);

  // Impostazione della luminosità del LED
  analogWrite(pinLed, luminosita);

  // Conversione della luminosità in quantità di caratteri della barra da stampare
  barraAvanzamento=map(luminosita, 0, 255, 0, 15);

  // Stampa la barra di avanzamento
  for (byte i = 0; i < barraAvanzamento; i++)
  {
    lcd.setCursor(i, 1);
    lcd.write(byte(0));
  }
  // leggero ritardo di 500 ms per visualizzare la barra
  delay(500);
}

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 🙂

Gestire con micro:bit un display 1602 I2C

2 Repliche

Ho realizzato questo tutorial come risposta ad un quesito che mi è stato posto da un’amica collega sull’utilizzo del display 1602 I2C comandato da micro:bit.
Per quanto riguarda la descrizione tecnica del display vi rimando al post su questo sito:

Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T

Per un utilizzo con micro:bit è sufficiente conoscere il tipo esatto di integrato I2C che gestisce la comunicazione tra display e micro:bit nella modalità indicata da questo tutorial.

Aprite un nuovo progetto dall’ambiente grafico di programmazione di micro:bit.
Aggiungiamo l’estensione che consente la gestione di un display 16×2 I2C, per far ciò selezionate “+Extensions”:

nel campo di ricerca inserite: I2C

dovreste ottenere il seguente risultato:

Selezionate l’estensione indicata nell’immagine:

All’interno dei blocchi disponibili ritroverete quelli che fanno riferimento al display:

Ogni dispositivo I2C dispone di un indirizzo, un codice a cui bisogna far riferimento in fase di programmazione e per quanto riguarda la scheda di comunicazione I2C disposta sul retro del display troverete due tipi di dispositivi con indirizzo differenti l’uno dall’altro. La differenza consiste nel tipo di circuito integrato che gestisce la comunicazione I2C:

PCF8574 > indirizzo 39
PCF8574A > indirizzo 63

L’indirizzo dovrà essere inserito all’interno di un apposito blocco come indicato di seguito.

Per sapere quale indirizzo usare potete leggere la sigla dell’integrato, come indicato nell’immagine che segue:

nel mio caso l’indirizzo da inserire sarà il 39.

L’altro metodo consiste nel sostituire, nel codice che segue, gli indirizzi sopra indicati in modo da individuare il numero corretto che permette la visualizzazione del testo sul display.

Per il collegamento del circuito avete necessità di alimentare il display a 5V, in commercio esistono degli edge connector (connettore per collegare micro:bit alla breadboard) che prelevano dalla USB i 5 volt, nel mio caso questa funzionalità non è fornita, l’unica tensione disponibile è di 3,3V non sufficienti per alimentare il display.

Se anche voi siete nelle medesime condizioni allora alimenterete via USB il micro:bit mentre il display dovrà essere alimentato esternamente mediante una tensione di 5V. Se agite in questo modo ricordate che la terra (GND) dovrà essere la medesima (collegate insieme) per entrambi i dispositivi. Fate riferimento allo schema di seguito indicato:

Sul micro:bit il pin 20 corrisponde all’SDA e il pin 19 all’SCL, pin che avranno una corrispondenza con il display. Per le mie sperimentazioni dispongo di un cavo USB modificato per poter inserire su breadboard la tensione di 5V proveniente dalla USB del computer.

Realizzeremo un semplice programma che consente di visualizzare su due righe il testo:

BBC micro:bit
Italy timer

dove timer è il numero di secondi trascorsi dall’avvio del programma.

L’inserimento della prima istruzione provocherà la visualizzazione del display I2C:

L’istruzione “LCD initialize with Address 39” assegna al display l’indirizzo 39

L’istruzione “show string” mostrerà sul display il testo incluso nel primo campo: “BBC micro:bit” che verrà scritto a partire dalla colonna 0 e riga 0 (in prima riga).

La seconda “show string” mostrerà sul display il testo “Italy” alla colonna 0 e riga 1 (in seconda riga):

Definiamo una nuova variabile che andremo successivamente ad incrementare:

assegnamo alla variabile il nome: contatore

All’interno della funzione “forever” inserire l’istruzione “change” per incrementare di una unità la variabile “contatore”.

Con l’istruzione “show number” visualizziamo sul display un numero, inserendo nel primo campo la variabile “contatore” il numero visualizzato sarà quello memorizzato nella variabile contatore:

La visualizzazione del numero contenuto in “contatore” avverrà in colonna 6 riga 1:

Aggiungendo una pausa di 1 secondo l’incremento del numero che appare sul display sarà di 1 secondo:

Questo il risultato:

Buon Coding a tutti 🙂

Disegnare caratteri personalizzati con Arduino per un LCD 16×2

Lascia una risposta

Durante le attività di sperimentazione capita spesso la necessità di utilizzare caratteri speciali o icone che non fanno parte del set di caratteri ASCII standard (https://www.asciitable.com) visualizzatili su un display 16×2. Ovviamente un display LCD 16×2 non permette risoluzioni elevate, ma la qualità che si riesce ad ottenere è più che accettabile.

Tutti i display LCD basati sul controller Hitachi HD44780 hanno due tipi di memorie in cui vengono memorizzati i caratteri: CGROM e CGRAM (Character Generator ROM & RAM). La memoria CGROM non è volatile e non può essere modificata mentre la memoria CGRAM è volatile e può essere modificata in qualsiasi momento.

CGROM è usato per memorizzare tutti i caratteri permanenti che possono essere visualizzati usando il loro codice ASCII. Ad esempio, se scriviamo 0x4D, sul display viene visualizzato il carattere “M”. CGRAM è un’altra memoria che può essere utilizzata per la memorizzazione di caratteri definiti dall’utente.

Questa RAM è limitata a 64 byte, cioè implica che per LCD a 5 × 8 pixel come LCD 16×2 Hitachi HD44780, nel CGRAM possono essere memorizzati fino a 8 caratteri definiti dall’utente.

Un carattere sul display viene realizzato utilizzando una matrice di pixel 5 × 8, quindi per definire un nostro carattere dovremo lavorare in quest’area.

La definizione del carattere personale avviene utilizzando la funzione createChar() della libreria LiquidCrystal.

Prima di utilizzare la libreria createChar() è necessario impostare un array di 8 byte ed ognuno di essi definisce una riga della matrice costituita dalla lettera b che definisce il tipo del dato (byte) e la serie di 1 e 0 definiscono i pixel attivi o disattivi: nell’array i bit a 1 indicano i pixel attivi, mentre gli 0 indicano i pixel disattivi.

Nell’esempio che segue viene utilizzato un display 16×2 i2c

Per quanto riguarda la libreria LiquidCrystal_I2C vi rimando alla lezione:
Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T

Nel caso abbiate necessità di sviluppare in modo più semplice ed agevole i vostri caratteri personalizzati potete utilizzare una soluzione grafica che immediatamente vi permettessi impostare l’array di byte, fate riferimento a questi due link:

da cui ho realizzato velocemente le icone, il codice corrispondenti è poi stato inserito all’interno dello sketch come si può evincere dallo sketch che segue:

/*
 *  Prof. Michele Maffucci
 *  Crezione di caratteri personali
 *  Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 *  con modulo i2C PCF8574T
 *  Data: 17.01.2020 - v01
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

// caratteri personalizzati

byte lucchettoChiuso[8] = {
  0b01110,
  0b10001,
  0b10001,
  0b10001,
  0b11111,
  0b11011,
  0b11011,
  0b11111
};

byte lucchettoAperto[8] = {
  0b01110,
  0b10000,
  0b10000,
  0b10000,
  0b11111,
  0b11011,
  0b11011,
  0b11111
};

byte Altoparlante[8] = {
  0b00001,
  0b00011,
  0b01111,
  0b01111,
  0b01111,
  0b00011,
  0b00001,
  0b00000
};

byte batteriaMezza[8] = {
  0b01110,
  0b11011,
  0b10001,
  0b10001,
  0b10001,
  0b11111,
  0b11111,
  0b11111
};

byte alieno[8] = {
  0b10001,
  0b01010,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b01010,
  0b11011
};


byte pacmanBoccaChiusa[8] = {
  0b01110,
  0b11101,
  0b11111,
  0b11111,
  0b11000,
  0b11111,
  0b11111,
  0b01110
};

byte pacmanBoccaAperta[8] = {
  0b01110,
  0b11101,
  0b11111,
  0b11100,
  0b11000,
  0b11000,
  0b11111,
  0b01110
};

byte fantasmino[8] = {
  0b01110,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b10101
};

void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione

  // creazione nuovi caratteri
  lcd.createChar(0, lucchettoChiuso);
  lcd.createChar(1, lucchettoAperto);
  lcd.createChar(2, Altoparlante);
  lcd.createChar(3, batteriaMezza);
  lcd.createChar(4, alieno);
  lcd.createChar(5, pacmanBoccaChiusa);
  lcd.createChar(6, pacmanBoccaAperta);
  lcd.createChar(7, fantasmino);

  // Cancella il display
  lcd.clear();

  // Stampa la stringa
  lcd.print("maffucci.it");

}

void loop()
{
  lcd.setCursor(0, 1);
  lcd.write(byte(0));

  lcd.setCursor(2, 1);
  lcd.write(byte(1));

  lcd.setCursor(4, 1);
  lcd.write(byte(2));

  lcd.setCursor(6, 1);
  lcd.write(byte(3));

  lcd.setCursor(8, 1);
  lcd.write(byte(4));

  lcd.setCursor(10, 1);
  lcd.write(byte(5));

  lcd.setCursor(12, 1);
  lcd.write(byte(6));

  lcd.setCursor(14, 1);
  lcd.write(byte(7));

}

Dopo aver incluso la libreria, è necessario inizializzare l’array che definisce il carattere personalizzato definito da 8 byte.

...
byte alieno[8] = {
  0b10001,
  0b01010,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b01010,
  0b11011
};
...

Nel setup() bisogna inizializzare il carattere personalizzato mediante la funzione createChar(), che accetta due parametri, il primo, compreso tra 0 e 7 è utilizzato come indirizzo ad uno degli 8 caratteri creati personalizzati, il secondo parametro definisce il nome dell’array di byte che definisce il carattere personalizzato.

  // creazione nuovi caratteri
  lcd.createChar(0, lucchettoChiuso);
  lcd.createChar(1, lucchettoAperto);
  lcd.createChar(2, Altoparlante);
  lcd.createChar(3, batteriaMezza);
  lcd.createChar(4, alieno);
  lcd.createChar(5, pacmanBoccaChiusa);
  lcd.createChar(6, pacmanBoccaAperta);
  lcd.createChar(7, fantasmino);

Successivamente nel loop, per la visualizzazione del carattere personalizzato viene utilizzata la funzione write() che ha come parametro il numero (l’indirizzo) assegnato al carattere.

...
void loop()
{
  lcd.setCursor(0, 1);
  lcd.write(byte(0));

  lcd.setCursor(2, 1);
  lcd.write(byte(1));

  lcd.setCursor(4, 1);
  lcd.write(byte(2));

  lcd.setCursor(6, 1);
  lcd.write(byte(3));

  lcd.setCursor(8, 1);
  lcd.write(byte(4));

  lcd.setCursor(10, 1);
  lcd.write(byte(5));

  lcd.setCursor(12, 1);
  lcd.write(byte(6));

  lcd.setCursor(14, 1);
  lcd.write(byte(7));
}
...

Esercizi per i miei studenti

Esercizio 1

Realizzare uno sketch che mostra un omino che cammina da sinistra verso destra e ritorno, in modo continuo. Il movimento deve essere accompagnato dall’emissione di due note che mettono in evidenza il passo.

Esercizio 2

Realizzare un Pac Man che partendo dalla riga 0 colonna 0 mangi una serie di puntini , scende alla riga 1 colonna 0 e prosegue fino alla riga 1 colonna 15 dove si trova un fantasma che deve essere mangiato. Predisporre un buzzer che emette due tipi di suoni, uno che identifica quando Pac Man mangia un puntino ed uno quando Pac Man mangia il fantasma. Quando il fantasma viene mangiato il display fa un 3 blink e l’azione comincia nuovamente con il Pac Man che si posizione in riga 0 colonna 0.

Esercizio 3

Realizzare un sistema che rilevi il livello di carica di batterie da 1,5V.
Utilizzare 7 icone che definiscono livelli diversi di carica della batteria e a fianco di ogni icona deve anche apparire in modo numerico il valore di tensione misurato.

Esercizio 4

Realizzare uno sketch che valuta in percentuale la quantità di luce in una stanza e la mostra su display mediante numero in percentuale e una barra di livello realizzata con caratteri personalizzati che può aumentare o diminuire in funzione della quantità di luce che colpisce l’LDR.
Mediante la pressione di un pulsante viene attivata la calibrazione del sistema, questa fase dura 5 secondi in cui viene misurate il valore minimo di luce (comprendo con mano il sensore) e valore massimo della luce (togliendo la mano dal sensore). La fase di calibrazione deve essere evidenziato dalla scrittura su display del messaggio: “calibrazione” e icone animate che dovete inventare.

Utilizzare un orologio RTC con Arduino – Modulo Tiny RTC I2C

Lascia una risposta

Scrivo questo post come base di partenza per le sperimentazioni che farò svolgere ai miei studenti nei prossimi giorni sull’uso degli RTC. L’acronimo RTC si riferisce a Real Time Clock, un orologio in tempo reale. Un RTC ed è alla base di moltissime automazioni in cui è indispensabile gestire una serie di processi in funzione di una specifica data e ora, si pensi ad esempio alla semplice gestione dell’illuminazione di un locale oppure alla realizzazione di un data logging o ancora la gestione del condizionamento automatico di un locale in funzione della data e dell’ora.
Ricordo ai miei studenti che nella sessione ordinaria del 2018 dell’esame di maturità per l’indirizzo elettronica ed elettrotecnica, articolazione di automazione, si faceva riferimento ad un sito archeologico in cui erano presenti due locali affrescati in cui era necessario controllare il numero massimo di persone presenti, gestire la temperatura in maniera diversa nel periodo invernale ed estivo ed inoltre doveva essere controllata anche l’umidità relativa.
Erano presenti inoltre domande in riferimento all’illuminazione massima all’interno dei locali ed altri quesiti a cui darete risposta durante le esercitazioni di laboratorio nelle prossime settimane.

Cito parte del testo dell’esame di maturità:

…
a) la temperatura deve essere mantenuta tra i 6°C e i 12°C nel periodo invernale e tra i 20°C e i 24°C nel periodo estivo; quando la temperatura scende al di sotto dei valori minimi si attivano delle piccole piastre riscaldanti, poste a 1 metro dal pavimento, fino al raggiungimento della temperatura media, mentre se la temperatura è troppo elevata si attiva il sistema di aerazione che al raggiungimento della temperatura media si disattiva;

b) l’umidità relativa deve essere mantenuta nel range 45% ±5% per evitare la proliferazione di muffe; tale livello viene garantito azionando per 10 minuti, se si è fuori dal range, gli aeratori o il sistema di nebulizzazione a pompa posto a muro.
…

L’obiettivo di questo post è quello di mostrare come gestire un RTC.

Il modulo utilizzato è un Tiny RTC I2C dotato di un integrato DS1307 I2C RTC di cui allego datasheet. Sulla scheda è presente una batteria tampone ricaricabile al litio LIR2032 che permette il funzionamento dell’RTC in assenza di alimentazione esterna, ovvero il mantenimento dell’ora e della data anche quando viene disconnesso dal microcontrollore che lo utilizza.

Il pilotaggio dell’RTC avviene mediante il protocollo I2C, che come già spiegato in precedenti lezioni, permette la comunicazione tra due o più dispositivi I2C utilizzando un bus a due fili più un terzo filo per il riferimento di massa comune a tutti i dispositivi.
Poiché il protocollo I2C utilizza 7 bit per indirizzare il dispositivo sul bus, il numero massimo di dispositivi collegabili sul bus è di 128 dispositivi, però il numero scende a 112 in quanto 16 indirizzi sono riservati.
Il bus è costituito da una linea dati SDA (Serial Data line), una line di clock SCL (Serial Clock line) e come detto sopra al filo di massa comune a tutti i dispositivi.

Per collegare il Tiny RTC I2C si faccia riferimento allo schema che segue:

Per poter pilotare il DS1307 è necessario installare una libreria specifica, ne esistono diverse quella che utilizzeremo sarà quella di Adafruit la RTClib. Installate la libreria: Sketch > Include Library > Manage Libraries

Si aprirà il gestore librerie, nel campo di ricerca inserite il testo RTClib come indicato nell’immagine che segue e procedere con l’installazione dell’ultima versione disponibile:

Al termine dell’installazione apparirà la voce INSTALLED a fianco della libreria installata

Con la libreria vengono resi disponibili una serie di sketch di esempio che potete aprire direttamente da: File > Examples > RTClib.

Aprite lo schetch: DS1307 di seguito indicato:

// Date and time functions using a DS1307 RTC connected via I2C and Wire lib
#include "RTClib.h"

RTC_DS1307 rtc;

char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup () {
  while (!Serial); // for Leonardo/Micro/Zero

  Serial.begin(57600);
  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! rtc.isrunning()) {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // This line sets the RTC with an explicit date & time, for example to set
    // January 21, 2014 at 3am you would call:
    // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }
}

void loop () {
    DateTime now = rtc.now();

    Serial.print(now.year(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.day(), DEC);
    Serial.print(" (");
    Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
    Serial.print(") ");
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();

    Serial.print(" since midnight 1/1/1970 = ");
    Serial.print(now.unixtime());
    Serial.print("s = ");
    Serial.print(now.unixtime() / 86400L);
    Serial.println("d");

    // calculate a date which is 7 days, 12 hours, 30 minutes, and 6 seconds into the future
    DateTime future (now + TimeSpan(7,12,30,6));

    Serial.print(" now + 7d + 12h + 30m + 6s: ");
    Serial.print(future.year(), DEC);
    Serial.print('/');
    Serial.print(future.month(), DEC);
    Serial.print('/');
    Serial.print(future.day(), DEC);
    Serial.print(' ');
    Serial.print(future.hour(), DEC);
    Serial.print(':');
    Serial.print(future.minute(), DEC);
    Serial.print(':');
    Serial.print(future.second(), DEC);
    Serial.println();

    Serial.println();
    delay(3000);
}

Nello sketch sono presenti due righe fondamentali, che risultano commentate e che secondo necessità possiamo decommentare ed utilizzare.

Se desideriamo che l’ora e la data venga impostata non appena viene caricato sulla scheda lo sketch bisogna decommentare la riga:

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

che permette di leggere la data e l’ora corrente in cui sono presenti le costanti predefinite all’interno dell’IDE Arduino: DATE e TIME, che si riferiscono alla data e all’ora di compilazione dello sketch, quindi non appena compilate vengono impostate e passate all’orologio che assume queste come data e ora corrente.

Nel caso si desidera impostare manualmente l’ora e la data bisognerà decommentare la riga:

rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));

inserendo data e ora corrente, ad esempio facendo riferimento alla data 08/01/2020 ore 01:37 dovrete scrivere:

rtc.adjust(DateTime(2020, 1, 8, 1, 37, 0));

La parte restante del codice si occupa di stampare sulla Serial Monitor data e ora corrente. Nel codice è presente una parte in cui viene stampato una data futura ed il numero di secondi trascorsi da una specifica data.

Ricordate che, come specificato nella setup() la seriale è impostata con una velocità di 57600 caratteri al secondo e quindi nella finestra della Serial Monitor dovrete impostare questa velocità per visualizzare il testo:

Questo il risultato:

Per i miei studenti:

Esercizio 1

Convertire nel formato italiano data e ora ottenendo un output come quello indicato nell’immagine che segue:

Esercizio 2

Realizzare uno sketch che permette l’accensione di un led connesso al pin 3 ogni minuto nell’intervallo da 0 a 15 secondi, spento nei restanti secondi all’interno del minuto. Visualizzare sulla Serial Monitor l’ora corrente.

Esercizio 3

Fare in modo che il led dal 50° al 59° secondo incominci a lampeggiare velocemente e nell’intervallo da 0 a 15 secondi sia acceso.

Esercizio 4

Stesse specifiche dell’esercizio 4 però facendo aumentare progressivamente la frequenza di lampeggio del LED all’approssimarsi del 59° secondo.

Buon lavoro 🙂

Sensore di temperatura ed umidità (DHT22)

Caratteristiche tecniche del DHT22

Cos’è l’umidità relativa

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

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

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

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

Related posts:

Lista componenti

Schema di collegamento

Scketch

Proposta esercizi

Related posts:

Related posts:

Related posts:

Related posts: