Archivi tag: elettronica

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:

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→

Arduino UNO R4 WiFi – DAC – generazione di onde sinusoidali, quadre e a dente di sega

Lascia una risposta

Una delle nuove caratteristiche presenti in entrambe le schede Arduino Uno R4, Minima e WiFi, è l’inclusione di un singolo DAC a 12 bit. Questo può generare tensioni di uscita discrete da 0 a 5 volt. Poiché questa funzionalità può essere di estremo interesse nelle attività di laboratorio di Elettronica ne indico di seguito il principio di funzionamento per sviluppare future esercitazioni.

Principio di funzionamento

Un DAC, o Convertitore Digitale-Analogico (in inglese: Digital-to-Analog Converter), è un dispositivo che converte un valore digitale (in binario) in un valore analogico (segnali continui che possono assumere un’infinità di valori all’interno di un intervallo).
Si tratta dell’operazione inversa di quella eseguita da un ADC, o Convertitore Analogico-Digitale, che converte un segnale analogico in una rappresentazione digitale.

Il processo di conversione avviene in tre fasi:

lettura in input dei dati digitali,
conversione in analogico
output del segnale analogico

Il DAC riceve in input un segnale digitale, che è rappresentato da una serie di valori binari (0 e 1), l’elettronica del DAC consente successivamente di convertire i valori binari in un segnale di output analogico che può essere utilizzato per pilotare dispositivi analogici come altoparlanti, motori, o altre apparecchiature che necessitano di un ingresso analogico.

Dal punto di vista pratico un DAC può essere utilizzato per creare un’uscita analogica a partire da un valore digitale utile per molte applicazioni, ad esempio per generare forme d’onda audio, per pilotare dispositivi che richiedono un input analogico, o per creare segnali di tensione variabile. Ad esempio nei sistemi audio un DAC converte i segnali audio digitali (come quelli presenti nei file MP3 o nei CD) in segnali analogici che possono essere riprodotti attraverso altoparlanti o cuffie.

Per semplificare ulteriormente nell’utilizzo con Arduino UNO R4, immaginate di avere un valore digitale che varia da 0 a 4095 (rappresentando un range di 12 bit). Un DAC potrebbe convertire questo valore in una tensione che varia, ad esempio, da 0V a 5V. Quindi, se il valore digitale fosse 512 (circa metà del range), l’uscita del DAC potrebbe essere di circa 0,6V.

Vediamo un esempio pratico.

Lo sketch che segue genera una forma d’onda sinusoidale o, meglio, una forma d’onda sinusoidale “simulata”. La frequenza della forma d’onda sinusoidale viene controllata da potenziometro.

Utilizzeremo un oscilloscopio per visualizzare l’onda sinusoidale, il collegamento è piuttosto semplice, abbiamo bisogno di un potenziometro lineare con una resistenza di 5 KOhm o superiore, io ho utilizzato un potenziometro da 10 KOhm.

La sonda dell’oscilloscopio deve essere connessa al pin A0 che viene usata come uscita del DAC. Il potenziometro ha il pin centrale connesso ad A5 (ingresso del DAC), un pin laterale connesso a 5V sulla scheda e l’altro pin laterale connesso a GND sulla scheda.

Se non possedete un oscilloscopio potete inviare l’output ad un amplificatore audio in modo che possiate ascoltare la tonalità generata, ricordate però che se procedete in questo modo bisogna assicurarsi che il controllo del volume sull’amplificatore sia al minimo, dopo di che lentamente aumentate il volume.

Il codice indicato di seguito è tratto dall’esempio di riferimento sul sito Arduino e all’interno degli esempi dell’IDE su cui ho inserito i commenti tradotti in italiano e fatto una piccola correzione.

La spiegazione del funzionamento la trovate nei commenti.

// Prof. Maffucci Michele
// Arduino UNO R4 Digital-to-Analog Converter (DAC)
// Sketch di esempio tratto da: https://docs.arduino.cc/tutorials/uno-r4-wifi/dac/

// libreria per la generazione di forme d'onda analogiche
#include "analogWave.h"

// Crea un'istanza della classe analogWave, usando il pin DAC
analogWave wave(DAC);

int frequenza = 10; // variabile intera che conterrà la frequenza rilevata

void setup() {
Serial.begin(115200);
// pinMode(A5, INPUT); // non necessaria perchè ingresso analogico
wave.sine(frequenza);
}

void loop() {
// legge un valore analogico dal pin A5 e lo mappa nell'intervallo 0 - 10000 Hz
frequenza = map(analogRead(A5), 0, 1024, 0, 10000);

// Stampa l'aggiornmento dell frequenza impostata sulla serial monitor
Serial.println("La frequenza e' " + String(frequenza) + " hz");

// Imposta la frequenza del generatore di forma d'onda sul valore aggiornato
wave.freq(frequenza);

// aspetta un secondo prima di ripetere la successiv rilevazione
delay(1000);
}

Volutamente ho lasciato commentata nel setup() la riga di codice in cui viene impostato il pinMode del pin A5 perché non è necessario inizializzare un pin Analogico, nell’esempio originale invece viene inizializzata.
A tal proposito per chi inizia con Arduino consiglio la lettura della guida: “Errori comuni nell’uso di Arduino – confondere pin analogici con pin digitali“.

Il risultato sarà il seguente:

E’ possibile quindi generare forme d’onda non solo sinusoidali, la funzione wave permette di impostare:

sine – onda sinusoidale
square – onda quadra
saw – onda a dente di sega

sarà sufficiente sostituire wave.sine(frequenza) presente nella sezione setup() rispettivamente con:

wave.square(frequenza);
wave.saw(frequenza);

Onda quadra:

Onda a dente di sega:

Buon Making a tutti 🙂

Electronic Prototyping Base Plate – ordine sulla banco di lavoro

Lascia una risposta

L’attività di formazione nel settore delle tecnologie didattiche mi coinvolge parecchio ed ogni volta la parte più complessa del lavoro risiede nell’organizzare la regia degli oggetti che gestisco e mostro online. Realizzare robot, serre, stazioni meteorologiche o comunque automazioni elettroniche richiede ordine, e mantenere una disposizione corretta degli apparati durante una lezione in diretta online richiede, almeno da parte mia, uno sforzo notevole.
Durante la lezione vi sono diverse fasi in cui operando con microcontrollori, micro:bit o Arduino, è necessario sviluppare dei semielaborati che devono mostrare ad esempio l’evoluzione di una stazione meteorologica, con l’aggiunta via via di sensori.
Per ottimizzare il processo di costruzione ho deciso di sperimentare qualcosa che in realtà è stato realizzato da altri, la Prototyping Base Plate di Boris Humberg, io ne ho fatto una versione più grande cambiando alcune misure in modo da adattarla alle mie necessità, con molta fantasia ho voluto chiamarla Electronic Prototyping Base Plate, per poter scaricare i sorgenti per la stampa 3D e il taglio laser seguire il link su Thingiverse.

Si tratta di una basetta di compensato da 4mm di spessore con le dimensioni di un foglio A4 forata. I fori della basetta sono da 3mm distanziati 10 mm l’uno dall’altro. Gli elementi di supporto dei circuiti a forma di L hanno dimensioni tali da poter alloggiare viti M3 e potete utilizzarli in tutti e due i sensi.

Aggiungo tra gli elementi supporti per connettori Wago, contenitore porta oggetti, supporto per mini breadboard e servomotore. Ho aggiunto dei piedini in modo da distanziare le viti dalla base di appoggio.

La basetta è stata realizzata con una macchina a taglio laser, però potreste utilizzare qualsiasi pezzo di compensato e con un piccolo trapano effettuate i fori là dove vi servono, quindi è sufficiente stampare in 3D tutti gli elementi ed utilizzare la base di appoggio.

Spero che questo progetto possa servire anche ad altri.

Buon Making a tutti 🙂

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:

Principio di funzionamento

Related posts:

Related posts:

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