Archivi tag: laboratori innovativi

Lezione 10 – Corso di Elettronica Creativa con Arduino Sensor Kit

Cenni teorici

Cos’è la pressione atmosferica?

La pressione atmosferica è la forza esercitata dall’aria su ogni unità di superficie. Viene misurata in pascal (Pa) o, più comunemente, in hectopascal (hPa) dove 1 hPa = 100 Pa.

Il sensore BMP280

Il BMP280 è un sensore barometrico assoluto prodotto da Bosch Sensortec. Le sue caratteristiche principali:

Campo di misura: 300 – 1100 hPa (≈ -500 m / +9000 m s.l.m.)
Accuratezza assoluta tip. ±1 hPa; accuratezza relativa ±0.12 hPa (≈ ±1 m)
Interfacce: I²C (fino a 3.4 MHz) e SPI
Consumo: 2.7 µA @ 1 Hz in modalità normale
Range termico: –40 … +85 °C

Collegamenti

Collegate il cavo Grove tra il connettore del sensore e la porta I²C (qualsiasi) sullo shield.

Installazione libreria

Sicuramente è un’operazione che avete già eseguito, in ogni caso lo ricordo:

Arduino IDE > Gestione librerie > cerca “Arduino_SensorKit”.
Installate la libreria (include automaticamente LPS22HB, HTS221, OLED, ecc.)

Esempio 01: Sketch base – Lettura e stampa dati su Serial Monitor

/*
  Prof. Maffucci Michele
  02.10.2025
  LPS22HB del Sensor Kit
  Stampa valori su Serial Monitor
*/
 
#include &lt;Arduino_SensorKit.h&gt;   // include unico per tutti i sensori
 
void setup() {
  Serial.begin(9600);
  Pressure.begin();              // inizializza il barometro
}
 
void loop() {
  // La libreria restituisce:
  // - pressione in pascal
  // - temperatura in gradi Celsius
  // - altitudine in metri rispetto a 1013,25 hPa
 
float pressionePa  = Pressure.readPressure();
  float temperaturaC = Pressure.readTemperature();
  float altitudineM  = Pressure.readAltitude();
 
// conversione pa → hPa per leggibilità
  float pressioneHpa = pressionePa / 100.0;
 
Serial.print(F("Pressione: "));
  Serial.print(pressioneHpa, 2);
  Serial.print(F(" hPa\tTemperatura: "));
  Serial.print(temperaturaC, 2);
  Serial.print(F(" °C\tAltitudine: "));
  Serial.print(altitudineM, 1);
  Serial.println(F(" m"));
 
delay(1000);
}

Ricordo che, come già indicato nelle precedenti lezioni, la F(…) (maiuscola), inserita all’interno delle Serial.print(), è una macro di Arduino che serve a mettere una stringa letterale in memoria flash (PROGMEM) invece che copiarla nella SRAM al momento della stampa.

Perché è utile utilizzare F

Le board come Arduino UNO (AVR) hanno poca SRAM (2 KB).
Senza (), ogni stringa tra virgolette ("Pressione: ") viene copiata in SRAM prima di stamparla > spreco di RAM.
Con F("Pressione: "), la stringa resta in flash e Serial.print() la legge direttamente da lì > RAM risparmiata.

Come si usa

Funziona con tutte le funzioni che derivano da Print (es. Serial.print, Serial.println, spesso anche display che usano print in stile Arduino):

Serial.print(F("Pressione: "));
Serial.println(F(" hPa"));

Quando usarla

Frasi/titoli/menu costanti e ripetute (log su Serial, messaggi di errore, etichette).
Con progetti in cui si ha scarsa disponibilità di RAM (UNO/Nano classici) può fare la differenza.

Limiti

Non puoi concatenare direttamente elementi come F(“A”) + F(“B”).
Evitare di mescolarla con String in modo implicito (meglio stampare pezzi separati).
Funzioni come sprintf non leggono da flash; su AVR esistono versioni “_P” (es. sprintf_P) per farlo.

La struttura delle funzioni (Pressure.begin(), Pressure.readPressure(), ecc.) è la stessa mostrata negli esempi ufficiali di Arduino.

Esempio 02: Lettura e stampa dati su Serial Monitor e display OLED

Abbiamo già visto l’uso del display OLED nella lezione: Lezione 9 – Corso di Elettronica Creativa con Arduino Sensor Kit vediamo ora come mostrare i valori di: pressione, temperatura e altitudine anche sul display OLED.

/*
  Prof. Maffucci Michele
  02.10.2025
  BMP280 - Arduino Sensor Kit
  Stampa valori su Serial Monitor e OLED
*/
 
#include <Arduino_SensorKit.h>  // include unico per tutti i sensori
 
void setup() {
  Serial.begin(9600);
  Pressure.begin();  // inizializza il barometro
 
Oled.begin();
  // Inizializza il display OLED.
  // Fa partire la comunicazione I2C e manda al display la sequenza di avvio.
  // Senza questa riga lo schermo non mostra nulla.
 
Oled.setFlipMode(true);
  // Ruota il contenuto di 180° (utile se lo vedi capovolto).
  // Se nel tuo caso appare già dritto, puoi mettere false: Oled.setFlipMode(false);
 
Oled.setFont(u8x8_font_chroma48medium8_r);
  // Sceglie il font (carattere) 8x8.
  // Con un font 8x8 il display 128x64 si comporta come una griglia 16 colonne × 8 righe.
  // Significa che setCursor(colonna, riga) userà numeri tra 0..15 (colonne) e 0..7 (righe).
 
Oled.clear();
  // Pulisce lo schermo (cancella tutto quello che c’era prima).
}
 
void loop() {
  // La libreria restituisce:
  // - pressione in pascal
  // - temperatura in gradi Celsius
  // - altitudine in metri rispetto a 1013,25 hPa
 
float pressionePa = Pressure.readPressure();
  float temperaturaC = Pressure.readTemperature();
  float altitudineM = Pressure.readAltitude();
 
// conversione pa → hPa per leggibilità
  float pressioneHpa = pressionePa / 100.0;
 
// --- Intestazione ---
 
Oled.setCursor(0, 0);             // colonna 0, riga 0
  Oled.println("STAZIONE METEO");   // stampa la stringa e va a capo
  Oled.println("P - Pressione");    // stampa la stringa e va a capo
  Oled.println("T - Temperatura");  // stampa la stringa e va a capo
  Oled.println("A - Altitudine");   // stampa la stringa e va a capo
 
Oled.setCursor(0, 5);         // colonna 0, riga 2
  Oled.print("P: ");            // stampa la stringa P:
  Oled.print(pressioneHpa, 2);  // stampa valore della pressione con 2 numeri decimali
 
Oled.setCursor(0, 6);         // colonna 0, riga 3
  Oled.print("T: ");            // stampa la stringa T:
  Oled.print(temperaturaC, 2);  // stampa valore della temperatura con 2 numeri decimali
  Oled.refreshDisplay();
 
Oled.setCursor(0, 7);        // colonna 0, riga 4
  Oled.print("A: ");           // stampa la stringa A:
  Oled.print(altitudineM, 2);  // stampa valore dell'altitudine con 2 numeri decimali
  Oled.refreshDisplay();
 
// Aggiorna fisicamente il display (altrimenti potresti non vedere le modifiche).
  delay(60);
 
Serial.print(F("Pressione: "));
  Serial.print(pressioneHpa, 2);
  Serial.print(F(" hPa\tTemperatura: "));
  Serial.print(temperaturaC, 2);
  Serial.print(F(" °C\tAltitudine: "));
  Serial.print(altitudineM, 1);
  Serial.println(F(" m"));
 
delay(1000);
}

Buon Coding a tutti 🙂

Lezione 8 – Corso di Elettronica Creativa con Arduino Sensor Kit

Lascia una risposta

Lo schermo OLED

Questo modulo è un display OLED monocromatico 128×64 con interfaccia Grove a 4 pin I²C, adatto a mostrare testi e semplici indicatori grafici direttamente dall’Arduino Sensor Kit. Rispetto agli LCD, gli OLED offrono autoluminescenza, alto contrasto, ampio angolo di visione e basso consumo, perché non richiedono retroilluminazione.

L’OLED (Organic Light-Emitting Diode) usa materiali organici che emettono luce quando attraversati da corrente; non avendo una retroilluminazione, ogni pixel deve essere acceso/aggiornato dal controller. Nel Sensor Kit l’OLED 0,96″ (famiglia SSD1306/SSD1315) si controlla in modo semplificato tramite la libreria Arduino_SensorKit, che fornisce la classe Oled con metodi pronti per inizializzazione, posizionamento del cursore e stampa del testo.

Collegamento

Inserire il modulo/display sul connettore I2C del Grove Base Shield, monta lo shield su Arduino UNO e collega via USB.
Impostare l’interruttore del Base Shield su 5V (necessario per alimentare correttamente il display).
Su Arduino UNO i pin I²C sono SDA=A4 e SCL=A5; l’indirizzo I²C tipico dei moduli SSD1306 è 0x3C (alcuni esemplari possono usare 0x3D). Se non risponde, esegui uno scanner I²C per verificarlo.
Sull’Arduino Sensor Kit collegare il display al connettore I2C come mostrato nell’immagine che segue.

Librerie da utilizzare

Oled.begin() inizializza il controller con l’indirizzo corretto e imposta modalità/parametri base di comunicazione I²C.
Oled.setCursor(x,y) posiziona il cursore: con l’API U8x8 esposta dal kit lavori in celle di carattere 8×8 (circa 16 colonne × 8 righe su 128×64).
Oled.print(...) scrive testo/valori;
Oled.refreshDisplay() aggiorna lo schermo.

L’API U8x8 è “testo-only” e non richiede buffer RAM; per disegni pixel-level bisogna usare l’API grafica U8g2 (con font e funzioni grafiche più ricche).

Le differenze tra le due API:

U8x8 = velocità e semplicità e solo per testo;
U8g2 = grafica avanzata con e richiede più memoria.

Per i più curiosi

Il controller SSD1306 gestisce la RAM del display per pagine e supporta vari modi di indirizzamento (orizzontale/verticale/pagina). Le librerie si occupano dei dettagli, ma sapere che l’aggiornamento avviene “a blocchi” aiuta a capire perché alcune operazioni grafiche richiedono più tempo/buffer.

Specifiche del display

Alimentazione: 3,3–5 V (compatibile con UNO).
Interfaccia: I²C (Grove 4 pin).
Indirizzo: 0x3C (varianti 0x3D).
Caratteristiche d’uso: alto contrasto, basso consumo, ampia temperatura operativa (fino a –40…+85 °C su molte versioni).

Qualche consiglio da tenere a mente durante le sperimentazioni

Non lasciare per ore la stessa immagine ad alto contrasto; meglio aggiornare periodicamente o usare una schermata di riposo.
Stabilità del contenuto: se il testo “sfarfalla”, stampare prima su Serial Monitor per verificare i valori e ridurre la frequenza di refresh (es. ogni 100–200 ms).
Differenza tra griglia di caratteri (U8x8) e coordinate in pixel (U8g2): una “barra” fatta di caratteri ha 16 step, mentre a pixel può averne 128.

Esempi pratici

Versione con commenti per gli studenti in cui viene dettagliato il funzionamento di ogni parte del codice.

Esempio 1 (semplice)

/*
Prof. Maffucci Michele
25/09/2025
OLED – Scrivere nome e cognome - versione 1
Inizializzare il display OLED del Sensor Kit e mostrare
"Allievo:" su una riga, poi Nome e Cognome sulla riga sotto.
*/
 
#include <Arduino_SensorKit.h>  // Include la libreria del Sensor Kit.
// Questa libreria mette a disposizione l’oggetto 'Oled' (già pronto)
// per usare facilmente il display senza dover scrivere codice di basso livello (I2C).
 
void setup() {
Oled.begin();
// Inizializza il display OLED.
// Fa partire la comunicazione I2C e manda al display la sequenza di avvio.
// Senza questa riga lo schermo non mostra nulla.
 
Oled.setFlipMode(true);
// Ruota il contenuto di 180° (utile se lo vedi capovolto).
// Se nel tuo caso appare già dritto, puoi mettere false: Oled.setFlipMode(false);
 
Oled.setFont(u8x8_font_chroma48medium8_r);
// Sceglie il font (carattere) 8x8.
// Con un font 8x8 il display 128x64 si comporta come una griglia 16 colonne × 8 righe.
// Significa che setCursor(colonna, riga) userà numeri tra 0..15 (colonne) e 0..7 (righe).
 
Oled.clear();
// Pulisce lo schermo (cancella tutto quello che c’era prima).
 
Oled.setCursor(0, 2);
// Posiziona il cursore alla colonna 0, riga 2 (terza riga dall’alto).
// Le coordinate sono "a caratteri" (non in pixel).
 
Oled.print("Allievo:");
// Stampa il testo "Allievo:" nella posizione corrente.
 
Oled.setCursor(0, 4);
// Sposta il cursore alla riga 4 (quinta riga), colonna 0.
// Qui stamperemo nome e cognome.
 
Oled.print("Michele");
// Stampa il nome.
 
Oled.print(" ");
// Stampa uno spazio tra nome e cognome.
 
Oled.print("Maffucci");
// Stampa il cognome.
 
Oled.refreshDisplay();
// Aggiorna fisicamente lo schermo.
// Finché non richiami refreshDisplay(), il display potrebbe non mostrare i nuovi testi.
}
 
void loop() {
// Vuoto: non dobbiamo aggiornare nulla in continuazione.
// Il display mantiene il testo finché non lo cambiamo nel codice.
}

Esempio 1 – senza commenti

Nel caso servisse copiare ed incollare solamente il codice per poi inserire i propri commenti vi lascio anche la versione senza commenti:

#include <Arduino_SensorKit.h> 
 
void setup() {
Oled.begin();
Oled.setFlipMode(true);
Oled.setFont(u8x8_font_chroma48medium8_r);
Oled.clear();
Oled.setCursor(0, 2);
Oled.print("Allievo:");
Oled.setCursor(0, 4);
Oled.print("Michele");
Oled.print(" ");
Oled.print("Maffucci");
Oled.refreshDisplay();
}
 
void loop() {
}

Esempio 1 – avanzato

Versione con commenti per gli studenti in cui viene dettagliato il funzionamento di ogni parte del codice.

/*
Prof. Maffucci Michele
25/09/2025
Scrive nome e cognome dell’allievo sul display OLED del Sensor Kit.
- Usa la libreria Arduino_SensorKit (oggetto Oled).
- Dimostrazione uso di: const char*, Oled.begin(), setFlipMode, setFont, setCursor, print, clear, refreshDisplay.
*/
#include <Arduino_SensorKit.h>  // Include la libreria che espone l’oggetto 'Oled'.
 
// -----------------------------------------------------------------------------
// DICHIARAZIONE DELLE STRINGHE
// 'const char*' = puntatore a caratteri costanti (stringa C in sola lettura).
// Puntano a letterali con terminatore '\0' (durata statica, non vanno modificati).
// -----------------------------------------------------------------------------
const char* nomeAllievo = "Michele"; // sostituisci con il nome reale (es. "Luca")
const char* cognomeAllievo = "Maffucci"; // sostituisci con il cognome (es. "Rossi")
 
void setup() {
// ---------------------------------------------------------------------------
// INIZIALIZZAZIONE DEL DISPLAY
// Oled.begin() avvia l'I2C e programma il controller del display (SSD1306/1315).
// Senza questa chiamata, il display non mostrerà nulla.
// ---------------------------------------------------------------------------
Oled.begin();
 
// setFlipMode(true) ruota il contenuto di 180°.
// Usarlo se il testo appare "capovolto" a causa dell’orientamento fisico.
// Mettere false se già si vede diritto.
Oled.setFlipMode(true);
 
// Seleziona il font 8x8 "chroma48medium8_r".
// Con font 8x8, lo schermo 128x64 si comporta come una griglia 16 colonne × 8 righe.
Oled.setFont(u8x8_font_chroma48medium8_r);
 
// ---------------------------------------------------------------------------
// PULIZIA E STAMPA DEL CONTENUTO
// ---------------------------------------------------------------------------
 
// Cancella tutto il contenuto precedente del display.
Oled.clear();
 
// Posiziona il cursore (colonna=0, riga=2) in coordinate "a caratteri" (non pixel).
// (0,2) significa: prima colonna, terza riga della griglia 16x8.
Oled.setCursor(0, 2);
 
// Stampa un’etichetta. Con la macro F("...") il testo resta in flash (serve per risparmiare RAM).
Oled.print(F("Allievo:"));
 
// Vai a riga 4, colonna 0, e stampa nome + cognome separati da spazio.
Oled.setCursor(0, 4);
Oled.print(nomeAllievo); // stampa la stringa puntata da 'nomeAllievo'
Oled.print(" "); // spazio tra nome e cognome
Oled.print(cognomeAllievo);
 
// Aggiorna fisicamente lo schermo: senza refresh, la nuova scritta potrebbe non apparire.
Oled.refreshDisplay();
}
 
void loop() {
// Nessuna azione periodica: il display mantiene il contenuto finché non lo cambiate.
// (Se volete far lampeggiare o scorrere il testo, lo fareste nel loop)
}

Esempio 1 – avanzato – senza commenti

#include <Arduino_SensorKit.h> 
 
const char* nomeAllievo = "Michele";
const char* cognomeAllievo = "Maffucci";
 
void setup() {
Oled.begin();
Oled.setFlipMode(true);
Oled.setFont(u8x8_font_chroma48medium8_r);
Oled.clear();
Oled.setCursor(0, 2);
Oled.print(F("Allievo:"));
Oled.setCursor(0, 4);
Oled.print(nomeAllievo);
Oled.print(" ");
Oled.print(cognomeAllievo);
Oled.refreshDisplay();
}
 
void loop() {
}

Che cosa significa `char`? Perché `const char` qui?

char è il tipo carattere in C/C++ (1 byte).
char* è un puntatore a char: invece di contenere direttamente un carattere, contiene l’indirizzo di memoria dove si trova una sequenza di caratteri (una stringa in stile C).
Le stringhe letterali scritte tra virgolette, es. "Nome", sono array di char terminati da \0 (null terminator). Hanno durata statica: esistono per tutta l’esecuzione del programma e sono solitamente in sola lettura.

Per questo si usa:

1	`const` `char*` `nomeAllievo` `=` `"Nome";`

const indica che non vogliamo (e non dobbiamo) modificare quei caratteri (sono un letterale costante).
Il tipo completo si legge: “puntatore a char costanti“. Potete cambiare il puntatore (farlo puntare ad un’altra stringa), ma non i caratteri a cui punta.

Alternative possibili

const char nomeAllievo[] = "Nome";
(array di char costanti: il compilatore conosce la lunghezza e non potete riassegnare il nome dell’array).
String nomeAllievo = "Nome";
(classe Arduino String: comoda ma usa più RAM dinamica; in progetti grandi può frammentare l’heap).

Nota su Arduino/AVR: i letterali come "testo" possono occupare SRAM a runtime se non si usa la macro F("testo") o PROGMEM. Nel nostro sketch la dimensione è minuscola, ma per testi lunghi conviene Oled.print(F("Allievo:")) per risparmiare RAM.

A cosa serve Oled.begin()

Oled.begin() inizializza il display OLED del Sensor Kit. In pratica:

Avvia la comunicazione I²C verso il controller del display (SSD1306/SSD1315) all’indirizzo corretto.
Manda la sequenza di setup al controller (accensione, modalità, contrasto di base, orientamento di default, ecc.).
Prepara l’oggetto Oled a ricevere comandi come setCursor, print, clear, refreshDisplay.

Senza Oled.begin() il display non risponde ai comandi, quindi va chiamato una volta nel setup().

Esempio 2

Lettura del valore analogico del potenziometro, visualizza il valore numerico grezzo dell’ADC e del valore percentuale sul display con barra (a carattere) di avanzamento.

Collegare il potenziometro all’ingresso A0.

/*
Prof. Maffucci Michele
25/09/2025
OLED
- Leggere il valore analogico dal potenziometro (0..1023 su Arduino UNO).
- Converte il valore in percentuale (0..100%).
- Visualizza il valore grezzo (ADC), la percentuale e una barra orizzontale su OLED.
 
Note:
- Usiamo la libreria Arduino_SensorKit che fornisce l'oggetto 'Oled' (display SSD1306/1315 via I2C).
- La barra è disegnata come sequenza di caratteri ASCII ('#').
*/
 
#include <Arduino_SensorKit.h>  // Include l'API semplificata per i sensori e l'OLED del Sensor Kit
 
// --------------------- CONFIGURAZIONE INGRESSO ANALOGICO ---------------------
// PIN del potenziometro: collega il cursore del pot al pin A0 (e gli altri due capi a +5V e GND).
const int PIN_POT = A0;
 
// Variabili per memorizzare il valore letto (grezzo) e la percentuale calcolata.
int valoreADC = 0; // Gamma tipica su UNO: 0..1023 (10 bit)
int percento = 0; // 0..100 (%)
 
// L'OLED in modalità font 8x8 ha circa 16 colonne: la barra avrà da 0 a 16 "blocchi" pieni.
const uint8_t LARGHEZZA_BAR = 16;
 
// -----------------------------------------------------------------------------
// Funzione di utilità: disegna una barra percentuale su una riga 'y' del display.
// Parametri:
// - y: indice riga (0..7 se font 8x8; 0 è la prima riga in alto).
// - percent: valore 0..100 che determina la lunghezza della barra.
// -----------------------------------------------------------------------------
void disegnaBarraPercento(uint8_t y, uint8_t percent) {
// Converte la percentuale 0..100 nel numero di "blocchi" (0..16)
// (uint32_t) evita overflow nella moltiplicazione su microcontrollori a 16 bit.
uint8_t pieni = (uint32_t)percent * LARGHEZZA_BAR / 100;
 
// 1) Pulisce la riga della barra: stampa 16 spazi per "cancellare" ciò che c'era prima.
Oled.setCursor(0, y); // posiziona il cursore all'inizio riga
for (uint8_t i = 0; i < LARGHEZZA_BAR; i++) {
Oled.print(' '); // spazio = cella vuota
}
 
// 2) Ridisegna i "blocchi" pieni (da sinistra verso destra) usando un carattere visibile e portabile ('#').
Oled.setCursor(0, y); // torna all'inizio riga
for (uint8_t i = 0; i < pieni; i++) {
Oled.print('#'); // carattere della barra
}
}
 
void setup() {
// ------------------------ INIZIALIZZAZIONE OLED ----------------------------
Oled.begin(); // inizializza I2C e il controller del display
Oled.setFlipMode(true); // ruota 180° se il testo appare capovolto (mettere false se OK)
Oled.setFont(u8x8_font_chroma48medium8_r); // font 8x8: griglia circa 16 colonne × 8 righe
 
// Pulizia e titolo
Oled.clear(); // cancella lo schermo
Oled.setCursor(0, 0); // colonna 0, riga 0 (prima riga)
Oled.print("Potenziometro"); // titolo
Oled.refreshDisplay(); // aggiorna la visualizzazione
}
 
void loop() {
// ----------------------------- LETTURA ADC --------------------------------
// Per stabilizzare il valore (ridurre rumore), facciamo una media di 4 campioni.
long somma = 0;
for (int i = 0; i < 4; i++) { somma += analogRead(PIN_POT); // legge l'ingresso analogico A0: 0..1023 delay(2); // piccola pausa per lasciare stabilizzare } valoreADC = somma / 4; // media semplice dei 4 campioni // ----------------------- SCALATURA IN PERCENTUALE ------------------------- // 'map' converte da una scala a un'altra: qui 0..1023 > 0..100.
// Nota: 'map' restituisce un intero; per scale diverse potresti usare una formula float.
percento = map(valoreADC, 0, 1023, 0, 100);
 
// ----------------------------- STAMPA TESTO -------------------------------
// Riga 2: mostriamo il valore ADC grezzo.
Oled.setCursor(0, 2); // colonna 0, riga 2
Oled.print("ADC: "); // spazi finali per "coprire" cifre residue
Oled.setCursor(5, 2); // posiziona circa a metà riga
Oled.print(valoreADC); // valore numerico 0..1023
 
// Riga 3: mostriamo la percentuale.
Oled.setCursor(0, 3);
Oled.print("Perc: ");
Oled.setCursor(6, 3);
Oled.print(percento); // 0..100
Oled.print("%");
 
// ------------------------------ BARRA GRAFICA -----------------------------
// Disegna la barra percentuale alla riga 5 (sesta riga).
disegnaBarraPercento(5, percento);
 
// Aggiorna fisicamente il display (altrimenti potresti non vedere le modifiche).
Oled.refreshDisplay();
 
// Piccolo delay per fluidità; valori troppo bassi aumentano il "flicker",
// valori troppo alti rendono meno reattivo l'aggiornamento.
delay(60);
}

Buon Coding a tutti 🙂

Lezione 7 – Corso di Elettronica Creativa con Arduino Sensor Kit

Lascia una risposta

Utilizzo del microfono analogico

In questa lezione vedremo come utilizzare il sensore di suono integrato nell’Arduino Sensor Kit, leggeremo il segnale analogico prodotto con l’istruzione analogRead() e ne interpreteremo i valori.
Verrà introdotto, in modo estremamente semplice il concetto di decibel e vedremo come procedere alla calibrazione del microfono in funzione delle attività di sperimentazione che verranno proposte.

Il microfono del Sensor Kit è pre‑cablato sulla linea analogica A0 tramite il connettore Grove, quindi non sono necessari ulteriori collegamenti.

Principio di funzionamento

Il modulo Grove Sound Sensor è un ottimo strumento per misurare i rumori intorno a voi. Quando l’aria vibra a causa di un suono, una sottile membrana nel microfono si piega avanti e indietro. Questi movimenti generano una variazione di tensione: più forte è il suono, più grande è la variazione e quindi più alto sarà il numero che andremo a leggere con Arduino mediante l’istruzione analogRead().

Approfondimento tecnico

Per chi ha qualche competenza in più in elettronica aggiungo che all’interno del modulo è presente un microfono a elettrete o microfono electret collegato a un piccolo amplificatore (LM358). L’amplificatore rende il segnale abbastanza grande da poter essere rilevabile da Arduino. Un circuito chiamato rivelatore di inviluppo converte le onde sonore in un valore di tensione continua che rappresenta l’intensità del suono istantaneo.

Il segnale in uscita varia da 0 V (silenzio) a 5 V (suono molto forte).
Arduino lo misura con il convertitore A/D a 10 bit, producendo numeri da 0 a 1023.
Il modulo è sensibile a frequenze fino a ~20 kHz (oltre il limite dell’udito umano).
L’amplificatore amplifica il segnale di circa 26 dB, così anche suoni deboli diventano misurabili.
Il consumo di corrente è basso, circa 4‑5 mA.

Nelle specifiche del dispositivo parlo di convertitore A/D a 10 bit e decibel (dB) e indico che l’amplificatore amplifica, in modo più semplice, ingrandisce di 26 dB, vediamo cosa vuol dire.

Qualche concetto tecnico spiegato in modo semplice

Cos’è un convertitore A/D a 10 bit

Un convertitore A/D (Analogico → Digitale) è come un traduttore: trasforma la tensione continua che esce dal sensore in numeri che il microcontrollore può elaborare.

10 bit significa che abbiamo 2¹⁰ = 1024 possibili valori, da 0 (0 V) a 1023 (5 V circa). Ogni “scalino” vale quindi circa 5 V / 1023 ≈ 0,005 V (5 millivolt). Più bit, più la scala è fine e la misura precisa.

Che cosa sono i decibel (dB) e perché l’amplificatore “ingrandisce” di 26 dB?

Il decibel (dB) è una grandezza adimensionale ed è un modo logaritmico di confrontare due grandezze: dice “quante volte più grande” è un segnale rispetto a un altro, ma usa il logaritmo per compattare numeri dimensionalmente diversi in una scala più gestibile. Inoltre il nostro orecchio non percepisce l’intensità del suono in modo lineare: se la potenza acustica raddoppia non ci sembra “due volte più forte”, ma solo un po’ più intensa. Questa risposta psicoacustica si descrive bene con una scala logaritmica, perciò usiamo i decibel.

Per le tensioni si usa la formula:

dB = 20 × log10(V2 / V1)

0 dB ⇒ stessa tensione
+6 dB ⇒ tensione circa doppia
−6 dB ⇒ tensione circa metà

Dire che l’amplificatore aumenta il segnale di 26 dB significa che la tensione in uscita è circa 20× (volte) più grande di quella che entra (perché 20× ≈ 26 dB). Così anche un suono debole crea un segnale abbastanza grande da essere misurato da Arduino.

ATTENZIONE

Questo sensore è pensato per percepire la presenza di suoni e valutarne l’intensità, non per registrare l’audio né per misurazioni professionali in decibel. Per avere dati certificati servono microfoni calibrati e convertitori più veloci.

Esempio di base

/*
  Prof. Maffucci Michele
  24.06.25
  LED reagisce al suono
  Accende il LED sul pin 6 se il valore supera la soglia impostata.
*/
 
const int pinSuono   = A2;    // pin a cui è connesso il sensore
const int pinLED     = 6;     // LED del Sensor Kik
const int sogliaRumore = 200; // valore da calibrare in base all'ambiente
 
void setup() {
  pinMode(pinLED, OUTPUT);
  Serial.begin(9600);
}
 
void loop() {
  int livello = analogRead(pinSuono);
  bool rumoreForte;
  // per approfondimenti sui tipi di dati:
  // https://www.maffucci.it/2020/11/15/arduino-tipi-di-dati-ripasso/
 
if (livello > sogliaRumore) {
    rumoreForte = true;
  } else {
    rumoreForte = false;
  }
 
if (rumoreForte) {
    digitalWrite(pinLED, HIGH);  // se supera la soglia il LED viene acceso
  } else {
    digitalWrite(pinLED, LOW);   // se non supera la soglia il led viene mantenuto apento
  }
 
Serial.print("Livello: ");
  Serial.print(livello);
  Serial.print("  Rumore forte? ");
  Serial.println(rumoreForte ? "SI" : "NO");
 
delay(500);
}

Continua a leggere→

Lezione 6 – Corso di Elettronica Creativa con Arduino Sensor Kit

Lascia una risposta

Sensore di luminosità

Inizio questa lezione con un’informazione che va a correggere quanto scritto sul sito Arduino in riferimento al Grove Light Sensor in cui erroneamente viene indicato il dispositivo come fotoresistenza, in realtà si tratta di un fototransistor e ciò, soprattutto per i neofiti può creare qualche problema di comprensione, soprattutto perché lo sketch presentato non fornisce esattamente quanto indicato.

Fotoresistenza o fototransistor?

Versione 1.0 del Grove-Light Sensor – usava una classica CdS LDR GL5528, cioè una vera fotoresistenza.
Versione 1.1 / 1.2 (quella montata sullo Shield dell’Arduino Sensor Kit) – per ragioni RoHS (il cadmio delle CdS è vietato) Seeed ha sostituito l’LDR con un LS06-S: si tratta di un sensore a fototransistor lineare (tecnicamente una fotodiodo-transistor) che “mima” la vecchia fotoresistenza ma è più rapido e lineare.

Il sito di Arduino non ha aggiornato la terminologia e continua a chiamarlo “photo-resistor”.

Ora come possiamo fare per non creare problemi a chi inizia?

Innanzi tutto se volete utilizzare una fotoresistenza vi rimando alle mie slide: Alfabeto di Arduino – Lezione 3, ma attenzione in questo caso dovrete usare una breadboard e realizzare un circuito con un resistore da 10Kohm e una fotoresistenza, in questo modo usando lo sketch presente sul sito Arduino o quelli indicati nelle mie slide tutto funzionerà ed avrete valori che variano tra 0 e circa 900, coll’esempio sul sito Arduino avrete un valore massimo più basso.

Dal punto di vista teorico cosa succede (usando una fotoresistenza):

La fotoresistenza (o LDR, Light Dependent Resistor) per rilevare l’intensità della luce:

la resistenza della fotoresistenza diminuisce quando l’intensità luminosa aumenta;
la resistenza della fotoresistenza aumenta quando l’intensità luminosa diminuisce.

L’ADC dell’Arduino la converte in un numero intero da 0 (buio) a 1023 (molta luce) quindi la lettura avviene tramite l’istruzione analogRead() per questo kit collegheremo direttamente il modulo al pin A3 e quindi nel codice scriveremo: analogRead(A3).

// Prof. Maffucci Michele
// Uso del sensore di luminosità
// 27.05.2025
 
int sensore_luce = A3;   // pin del sensore di luminosità
 
void setup() {
  analogReference(INTERNAL);   // 1,1 V; attivare PRIMA di qualsiasi analogRead
  delay(3);                    // attesa minima per la stabilizzazione della reference
  Serial.begin(9600);          // avvia la comunicazione seriale
}
 
void loop() {
  int luce_grezza = analogRead(sensore_luce);      // legge il valore grezzo dal pin A3
  int luce = map(luce_grezza, 0, 1023, 0, 100);    // converte 0–1023 in 0–100 (percentuale)
 
Serial.print("Livello di luce: ");
  Serial.println(luce);  // stampa il valore di luce sul Monitor Seriale
 
delay(1000);           // attende 1 secondo prima della prossima lettura
}

Le cose sono simili con il Grove-Light Sensor sull’Arduino Sensor Kit, ma avrete, come dicevo, valori massimi più bassi, che raggiungo circa i 750 con la torcia dello smartphone direttamente puntata sul fototransistor. Dal punto di vista funzionale nulla cambia ma è importante aver ben presente che siamo lavorando con componenti elettronici diversi che hanno comportamenti simili.

Con lo sketch precedente otterremo sulla serial monitor questi valori:

Il fatto che il valore massimo si fermi attorno a 750 è in realtà perfettamente coerente con l’elettronica del modulo.

Quindi per ora, per chi inizia potete far finta che il componente sull’Arduino Sensor Kit è una fotoresistenza e se desiderate potete fermarvi a questo punto.

Continua a leggere→

Lezione 5 – Corso di Elettronica Creativa con Arduino Sensor Kit

Lascia una risposta

Il Buzzer

Quando progettiamo un impianto di automazione abbiamo quasi sempre bisogno di avvisare l’utente di uno stato o di un’anomalia. Oltre alle classiche spie luminose, un modo immediato per “farsi sentire” è impiegare un buzzer, noto colloquialmente come cicalino. Questo piccolo attuatore trasforma un segnale elettrico in un impulso sonoro che può variare da un semplice beep continuo a brevi toni di diversa frequenza.

Tipologie principali di buzzer

Attivo
Contiene un oscillatore interno che genera automaticamente la frequenza fissa non appena viene alimentato.
Con Arduino basta portare il pin di alimentazione a livello HIGH/LOW per abilitare o silenziare il suono.

Passivo
Non possiede oscillatore: necessita di un’onda quadra esterna per farlo vibrare.
Arduino può pilotarlo con PWM (analogWrite) o con la funzione tone() per scegliere la frequenza desiderata.

Tecnologie costruttive

I buzzer – siano essi attivi o passivi – possono realizzarsi con due differenti principi fisici:

Magnetici
una bobina varia il campo magnetico e fa oscillare una sottile membrana metallica.
Piezoelettrici
un disco di materiale piezo si deforma quando riceve tensione, generando la vibrazione acustica.

La scelta fra le due tecnologie dipende principalmente da:

Segnale di pilotaggio disponibile (continua, PWM, ampiezza)
Pressione sonora richiesta (volume)
Spazio e forma concessi dal progetto

Come funziona un buzzer attivo

All’interno è presente un piccolo circuito oscillatore che, alimentato in continua, fa variare il campo magnetico di una bobina. La bobina è rigidamente accoppiata a una membrana, la quale vibra alla frequenza impostata dal circuito e produce un suono costante. In pratica: lo accendiamo – suona; lo spegniamo – tace.

Dati tecnici

Tensione nominale: 6V DC
Tensione di esercizio: 4-8V DC
Corrente nominale: < 30mA
Tipo di suono: segnale acustico continuo
Frequenza di risonanza: ~2300 Hz

Come funziona un buzzer passivo

Il buzzer passivo è sprovvisto di oscillatore e si comporta come un piccolo altoparlante: emette il tono dell’esatta frequenza del segnale che riceve. Con Arduino possiamo quindi:

generare una frequenza fissa con tone(pin, freq);
modulare il duty-cycle tramite analogWrite() per variare il volume;
creare melodie cambiando velocemente frequenza e durata.

Dati tecnici

Tensione nominale: 5V DC
Tensione di esercizio: 4-8V DC
Corrente nominale massima: ≤ 32 mA
Min. Uscita audio a 10 cm: 85 dB
Temperatura di esercizio: da 20°C a 45°C

Poiché vogliamo utilizzare il buzzer dell’Arduino Sensor Kit a questo punto possiamo chiederci:

“ma di che tipo è il buzzer di questo kit?”

E’ un buzzer di tipo passivo.

Nelle spiegazioni abbiamo parlato di PWM, di seguito alcuni dettagli, ma se volete approfondire consultate le mie slide: Alfabeto Arduino – Lezione 2 e l’approfondimento su questo sito: Arduino – Approfondimenti sulla modulazione di larghezza di impulso (PWM).

Per uno studio ancora più approfondito: Secrets of Arduino PWM.

Che cos’è il PWM

La modulazione di larghezza d’impulso, o PWM (Pulse Width Modulation), è una tecnica che permette di ottenere effetti analogici usando mezzi digitali. Il controllo digitale genera un’onda quadra, un segnale che passa continuamente da acceso (ON) a spento (OFF). Variando la frazione di tempo in cui il segnale rimane acceso (alto) rispetto a quella in cui rimane spento (basso), è possibile simulare tensioni intermedie tra lo 0 V (spento) e i 5 V (acceso al 100 %). Il periodo in cui il segnale resta acceso si chiama larghezza dell’impulso. Modificando (ovvero modulando) questa larghezza si ottengono valori analogici diversi. Se la commutazione ON/OFF avviene abbastanza velocemente, il segnale risulta percepito come una tensione “media” continua compresa tra 0 V e 5 V.
Questo segnale PWM può dunque essere usato per controllare con facilità un buzzer passivo.
Per generare segnali PWM con Arduino si utilizza la funzione analogWrite(), mentre digitalWrite() produce solo segnali in corrente continua (DC).
Sulla tua scheda ci sono sei pin digitali contrassegnati dal simbolo “~” (tilde), che indica la capacità di gestire un segnale PWM: 3, 5, 6, 9, 10, 11. Questi sono chiamati pin PWM.

Collegamenti

Come abbiamo detto precedentemente Il buzzer del kit è passivo: non produce autonomamente il tono, ma vibra quando riceve un’onda quadra. Con analogWrite() inviate un’onda PWM; variando il duty-cycle (0-255) variate il volume.

Esempio 1: emissione di un beep

/* Prof. Maffucci Michele
   beep con il buzzer
   14.05.25
*/
 
const int BuzzerPin = 5;       // D5 ha anche il simbolo ~ = PWM
 
void setup() {
  pinMode(BuzzerPin, OUTPUT);  // imposta il pin come uscita
}
 
void loop() {
  analogWrite(BuzzerPin, 128); // 50 % di duty-cycle ≈ volume medio
  delay(1000);                 // suona per 1 s
  analogWrite(BuzzerPin, 0);   // silenzio
  delay(1000);                 // pausa di 1 s
}

Funzionamento del codice

pinMode()
imposta il pin in uscita, così può fornire tensione
analogWrite(pin, val)
genera un’onda quadra a ~490 Hz sul pin; val è il duty-cycle (0 = 0 %, 255 = 100 %)
delay(ms)
pausa del programma – qui determina per quanto tempo il buzzer resta attivo/inattivo

Continua a leggere→

Cenni teorici

Cos’è la pressione atmosferica?

Il sensore BMP280

Collegamenti

Installazione libreria

Esempio 01: Sketch base – Lettura e stampa dati su Serial Monitor

Perché è utile utilizzare F

Come si usa

Quando usarla

Limiti

Esempio 02: Lettura e stampa dati su Serial Monitor e display OLED

Related posts:

Lo schermo OLED

Collegamento

Librerie da utilizzare

Per i più curiosi

Specifiche del display

Esempi pratici

Esempio 1 (semplice)

Esempio 1 – senza commenti

Esempio 1 – avanzato

Esempio 1 – avanzato – senza commenti

Che cosa significa char*? Perché const char* qui?

Alternative possibili

A cosa serve Oled.begin()

Esempio 2

Related posts:

Utilizzo del microfono analogico

Principio di funzionamento

Approfondimento tecnico

Qualche concetto tecnico spiegato in modo semplice

Cos’è un convertitore A/D a 10 bit

Che cosa sono i decibel (dB) e perché l’amplificatore “ingrandisce” di 26 dB?

ATTENZIONE

Esempio di base

Related posts:

Sensore di luminosità

Fotoresistenza o fototransistor?

Related posts:

Il Buzzer

Tipologie principali di buzzer

Tecnologie costruttive

Come funziona un buzzer attivo

Dati tecnici

Come funziona un buzzer passivo

Dati tecnici

Che cos’è il PWM

Collegamenti

Funzionamento del codice

Related posts:

Che cosa significa `char`? Perché `const char` qui?