Archivi tag: laboratorio di elettronica

Capire prima di costruire – 01: che differenza c’è tra tensione, corrente e resistenza?

Tre parole che compaiono ovunque in elettronica, ma che spesso vengono confuse tra loro.


Chi inizia a studiare elettrotecnica o elettronica incontra quasi subito tre grandezze fondamentali: tensione, corrente e resistenza.
Sono termini molto usati, ma proprio perché si sentono spesso si rischia di credere di averli capiti, quando in realtà restano un po’ sfocati.

Dagli appunti per i miei studenti.
Capire bene la differenza tra queste tre grandezze è importante perché costituisce una delle basi di tutto ciò che verrà dopo: circuiti, sensori, LED, alimentatori, Arduino, motori, misure elettriche.

La tensione elettrica

La tensione elettrica, spesso indicata come differenza di potenziale (d.d.p.), rappresenta la causa prima di ogni fenomeno elettrico dinamico. Scientificamente, si definisce tensione tra due punti A e B il rapporto tra il lavoro L compiuto dalle forze del campo elettrico per spostare una carica positiva q dal punto A al punto B e la carica stessa. In termini matematici, utilizzando la notazione standard, si esprime come:

V_{AB} = \frac{L_{AB}}{q}

L’unità di misura, il Volt (V), rende omaggio ad Alessandro Volta, la cui ricerca presso l’Università di Pavia ha segnato la nascita dell’elettrotecnica moderna. Per chi inizia lo studio dell’elettrotecnica, è fondamentale comprendere che la tensione non è un “flusso” ma una “condizione” di squilibrio energetico. Una batteria carica possiede una tensione ai suoi capi anche se non è collegata a alcun circuito, esattamente come un corpo sollevato da terra possiede energia potenziale gravitazionale anche se non è in caduta libera.

Sorgente di Tensione Valore Nominale (V) Ambito di Utilizzo
Pila Zinco-Carbone / Alcalina 1,5 V Telecomandi, piccoli apparati
Batteria al Litio (Singola Cella) 3,7 V Smartphone, droni, wearable
Porta USB Standard 5,0 V Alimentazione logica digitale, Arduino
Batteria Piombo-Acido (Auto) 12,0 V Avviamento motori, servizi automotive
Rete Domestica (Monofase) 230 V Elettrodomestici, illuminazione civile

Nelle applicazioni pratiche di laboratorio, la tensione viene fornita da generatori che possono essere pile chimiche o alimentatori da banco, questi ultimi permettono di regolare la “spinta” impressa alle cariche, permettendo di osservare come variano le altre grandezze in gioco. Un errore frequente nella fase di apprendimento è confondere la tensione disponibile con quella effettivamente “utilizzata” dai componenti; la comprensione che la tensione è una proprietà relativa a due punti e non un valore assoluto è il primo passo per una corretta analisi dei nodi e delle maglie di un circuito.

L’intensità di corrente

Se la tensione è la causa, la corrente elettrica è l’effetto. Essa consiste nel movimento ordinato di particelle dotate di carica elettrica. Nei conduttori metallici, tipicamente utilizzati nei laboratori, i portatori di carica sono gli elettroni di conduzione, che si muovono all’interno del reticolo cristallino del metallo. L’intensità di corrente I è definita come la quantità di carica dQ che attraversa una sezione del conduttore nell’intervallo di tempo dt:

I = \frac{dQ}{dt}

L’unità di misura è l’Ampere (A), una delle sette unità fondamentali del Sistema Internazionale. È cruciale distinguere tra la velocità con cui l’energia si propaga nel circuito (vicina a quella della luce) e la velocità di deriva degli elettroni, che è sorprendentemente lenta, spesso dell’ordine di pochi millimetri al secondo. Questo fenomeno viene spiegato agli studenti attraverso il modello del “domino” o della “colonna di palline”: quando si applica tensione, l’effetto si ripercuote istantaneamente su tutta la linea, ma ogni singola carica percorre solo un breve tratto nell’unità di tempo.

Nell’elettronica moderna, specialmente quando si opera con sensori e microcontrollori, si utilizzano quasi esclusivamente i sottomultipli dell’Ampere.

Livello di Corrente Valore Tipico Significato Tecnico
Corrente di dispersione <1 µA Valori minimi in isolanti o standby
Corrente Sensori Analogici 1–10 mA Segnale tipico per trasduttori
Corrente LED Standard 10–20 mA Valore di sicurezza per segnalazione
Limite Pin Arduino 40 mA Massima corrente prelevabile senza danni
Carico di Potenza (Motori) >500 mA Richiede stadi di amplificazione o driver

Un aspetto che richiede un’attenzione particolare è il verso della corrente. Storicamente, prima della scoperta dell’elettrone, si ipotizzò che a muoversi fossero cariche positive dal polo + al polo . Questa convenzione è rimasta universale in tutta l’elettrotecnica e l’elettronica. Per chi inizia lo studio è necessario chiarire che, sebbene fisicamente gli elettroni risalgano il potenziale (dal al +), i calcoli e gli schemi seguono il verso convenzionale discendente. Questa distinzione è essenziale quando si affrontano componenti polarizzati come i diodi o i condensatori elettrolitici.

La resistenza elettrica e le proprietà tecnologiche dei materiali

La resistenza elettrica è la grandezza che quantifica l’opposizione di un corpo al passaggio della corrente. Tale opposizione non deve essere vista come un fattore puramente negativo, ma come lo strumento principale per il controllo delle correnti e per la trasformazione dell’energia elettrica in altre forme, come il calore (effetto Joule) o la luce. La resistenza R si misura in Ohm (\Omega) e dipende strettamente dalla natura del materiale e dalle sue dimensioni geometriche, secondo la seconda legge di Ohm:

R = \rho \cdot \frac{L}{S}

Dove \rho (rho) rappresenta la resistività, una proprietà intrinseca del materiale che varia anche in funzione della temperatura. La formula offre una comprensione intuitiva della “fatica” che le cariche compiono: un conduttore più lungo (L) oppone più resistenza perché aumenta il numero di urti tra cariche e atomi; un conduttore con sezione (S) maggiore offre invece più “spazio” per il passaggio, riducendo la resistenza.

Materiale Resistività ρ (Ω·m) a 20 °C Utilizzo Tecnologico
Argento 1,59·10−8 Contatti di alta precisione
Rame 1,68·10−8 Cablaggi elettrici universali
Alluminio 2,82·10−8 Linee aeree di alta tensione
Costantana 4,9·10−7 Resistenze di precisione (stabile con T)
Silicio Variabile Semiconduttore per microchip

Un approfondimento necessario riguarda la dipendenza dalla temperatura. Nella maggior parte dei metalli, la resistenza aumenta con il calore poiché l’agitazione termica degli atomi del reticolo aumenta la probabilità di collisione con gli elettroni di conduzione. Questo fenomeno è alla base del funzionamento di dispositivi come i termistori (NTC/PTC) utilizzati in elettronica per la misura della temperatura. Al contrario, nei semiconduttori, l’aumento di temperatura può liberare più portatori di carica, riducendo la resistenza, un comportamento che sottolinea la complessità e la varietà dei materiali elettronici che gli studenti impareranno a classificare.

L’analogia idraulica tra tradizione didattica e limiti scientifici

L’uso di analogie nel campo della fisica è una pratica consolidata. Nel contesto didattico, l’analogia idraulica è lo strumento più efficace per visualizzare grandezze altrimenti invisibili.

In questo modello, il circuito elettrico viene paragonato a un sistema di tubazioni in cui scorre un liquido incomprimibile (l’acqua).

Elemento Elettrico Analogia Idraulica Significato Fisico dell’Analogia
Tensione (V) Pressione o dislivello La forza che spinge il fluido attraverso il condotto.
Corrente (I) Portata Il volume d’acqua che passa in una sezione per unità di tempo.
Resistenza (R) Strozzatura o attrito L’opposizione fisica causata dal diametro o dalla rugosità del tubo.
Generatore Pompa Il dispositivo che ristabilisce il potenziale fornendo energia.
Conduttore Tubo di grosso diametro Il percorso che permette il movimento con perdite minime.
Interruttore Rubinetto (con inversione logica) Il comando che permette o impedisce il flusso.

Tuttavia bisogna avere estrema cautela nell’uso di questo modello. Uno dei rischi maggiori è indurre lo studente a pensare che l’elettricità possa “uscire” dal filo come l’acqua da un tubo rotto. È necessario spiegare che, mentre l’acqua può fluire in un tubo aperto verso l’atmosfera, la corrente elettrica richiede necessariamente un percorso chiuso e un ritorno al generatore, a causa dell’altissima rigidità dielettrica dell’aria. Inoltre, l’analogia fallisce nel descrivere i campi elettromagnetici che circondano il filo, fondamentali per comprendere il funzionamento di trasformatori e motori che gli allievi incontreranno nel proseguimento del corso di studi.

Errori tipici e difficoltà

Una delle idee più radicate è il cosiddetto “modello della consumazione”. Molti allievi ritengono che la corrente diminuisca man mano che attraversa i componenti di un circuito (ad esempio, che ce ne sia di più prima di una lampadina e meno dopo). Questo errore deriva da una confusione tra corrente (materia/carica) ed energia. Credo che la strategia didattica corretta possa essere quella che utilizza l’analogia della catena di bicicletta o del circuito idraulico chiuso: la catena si muove alla stessa velocità in ogni punto, ma è il lavoro compiuto dal ciclista a trasferire energia alla ruota.

Un’altra difficoltà riguarda il “ragionamento sequenziale”. Gli studenti tendono ad analizzare i circuiti come se la corrente decidesse cosa fare man mano che incontra i componenti, ignorando che un cambiamento in qualsiasi punto del circuito modifica istantaneamente l’equilibrio di tutto il sistema. L’uso di simulatori come PhET, che permettono di vedere le cariche muoversi in tempo reale e reagire a ogni variazione di resistenza, è fondamentale per superare questo limite cognitivo.

Infine, persiste spesso la confusione tra tensione e corrente, usate nel linguaggio comune come sinonimi (si dice spesso “è passata la 220” intendendo la tensione). E’ importante insistere sul fatto che la tensione è una causa potenziale e la corrente è un effetto attuale: si può avere tensione senza corrente (circuito aperto), ma non corrente senza tensione (salvo nei superconduttori, argomento avanzato).

Questa breve lezione è un primo passo, nei prossimi post vedremo come queste grandezze entrano in gioco in situazioni pratiche, ad esempio quando si collega un LED o si usa un multimetro.

Buono Studio 🙂

Esercitazione 4 – Macchina a stati per un ciclo automatico con start, pausa, allarme e reset

Allenamento per l’esame di maturità
Percorso di laboratorio con Arduino per studenti di quinta ITIS

Obiettivo didattico

Modellare un ciclo automatico come macchina a stati: attesa, marcia, pausa, allarme e reset. L’attività avvicina gli studenti al modo in cui si progetta un processo tecnico da esame.

Materiali suggeriti

  • Arduino UNO R3 o UNO R4,
  • 3 pulsanti (START, PAUSA, RESET);
  • 2 LED;
  • 2 Resistori da 220 Ohm (per i LED);
  • jumper.

Schema di collegamento

Richiamo teorico

Una macchina a stati finiti rappresenta un processo come un insieme di stati mutuamente esclusivi. In ogni stato il sistema esegue azioni ben definite e attende eventi che causano il passaggio allo stato successivo. Questo metodo riduce gli errori logici nei programmi complessi.

Schema logico dell’attività

  • All’avvio il sistema è in ATTESA;
  • se arriva START passa a MARCIA;
  • in MARCIA può ricevere PAUSA oppure entrare in ALLARME se scade il tempo massimo;
  • in PAUSA attende una nuova pressione di START;
  • da ALLARME si esce solo con RESET, che riporta il sistema in ATTESA.

Diagramma a stati

Per rappresentare in modo corretto il comportamento di questo esercizio è molto utile affiancare al codice un diagramma a stati. In questo caso, infatti, il sistema non si limita a eseguire istruzioni una dopo l’altra, ma cambia comportamento in funzione della condizione operativa in cui si trova.

Il programma può trovarsi in un solo stato per volta, e ogni stato descrive una precisa fase di funzionamento del sistema. Nel nostro sketch gli stati sono quattro:

  • STATO_ATTESA
  • STATO_MARCIA
  • STATO_PAUSA
  • STATO_ALLARME

Il diagramma a stati è particolarmente adatto a questa situazione perché mostra in modo immediato tre aspetti fondamentali:

  • quali sono gli stati possibili del sistema;
  • quali eventi provocano il passaggio da uno stato all’altro;
  • quale logica di funzionamento è stata implementata nel codice.

In altre parole, mentre il diagramma di flusso descrive bene la sequenza dei controlli svolti nel loop(), il diagramma a stati descrive meglio la struttura logica del processo.

Stato iniziale del sistema

Nel diagramma compare il simbolo iniziale che punta verso STATO_ATTESA. Questo significa che, all’accensione di Arduino o dopo un reset, il sistema parte nello stato di attesa.

In questa fase il ciclo automatico non è attivo. Il LED di marcia è spento, il LED di allarme è spento e il programma controlla continuamente i pulsanti in attesa di un comando di avvio.

Dal punto di vista didattico, questo è il comportamento tipico di molti sistemi automatici: il processo non parte in modo autonomo, ma richiede un comando esplicito dell’operatore.

Transizione da ATTESA a MARCIA

Dal nodo STATO_ATTESA parte una freccia verso STATO_MARCIA con l’etichetta:

START premuto / istanteInizioMarcia = millis()

Questa notazione va letta così: se il sistema si trova in attesa e viene rilevata la pressione del pulsante START, allora il programma passa allo stato di marcia. Durante questa transizione viene anche eseguita un’azione importante, cioè il salvataggio dell’istante iniziale della marcia tramite millis().

Questo passaggio è fondamentale perché permette al sistema di iniziare a contare il tempo trascorso in marcia senza bloccare il programma. In pratica, nel momento in cui parte la marcia, viene memorizzato il riferimento temporale da cui inizierà il controllo del timeout.

Significato dello stato MARCIA

Lo stato STATO_MARCIA rappresenta la fase in cui il sistema è attivo.

In questa condizione il LED di marcia viene acceso, il LED di allarme resta spento e il programma continua a controllare due possibili situazioni:

    • la richiesta di pausa;
    • il superamento del tempo massimo consentito.

Importante: nello stato di marcia il sistema non esegue una sola azione, ma resta in una condizione operativa in cui il programma continua a verificare gli eventi che possono modificare il comportamento complessivo del processo.

Transizione da MARCIA a PAUSA

Se durante la marcia viene premuto il pulsante PAUSA, il sistema passa a STATO_PAUSA.

Questa transizione rappresenta una sospensione del ciclo. Dal punto di vista logico, il processo non è terminato, ma è momentaneamente fermo in attesa di un nuovo comando.

Nel diagramma questa freccia mostra che la pausa può essere richiesta solo quando il sistema si trova effettivamente in marcia. Questo rende molto chiaro un concetto fondamentale: non tutti i comandi hanno senso in tutti gli stati. Il significato di un ingresso dipende dallo stato corrente del sistema.

Transizione da MARCIA a ALLARME

La seconda uscita possibile da STATO_MARCIA conduce a STATO_ALLARME ed è attivata dal superamento del tempo massimo di marcia.

Nel codice questa condizione è realizzata confrontando il tempo attuale, ottenuto con millis(), con l’istante iniziale salvato all’ingresso nello stato di marcia. Quando la differenza raggiunge o supera il valore impostato in TEMPO_MASSIMO_MARCIA, il sistema genera l’allarme.

Questo passaggio è interessante perché mostra come una macchina a stati possa cambiare stato non solo in risposta a un pulsante, ma anche in risposta a una condizione temporale. In molti sistemi automatici reali, infatti, il tempo costituisce un vincolo di sicurezza o di controllo del processo.

Significato dello stato PAUSA

Lo stato STATO_PAUSA rappresenta una sospensione controllata del ciclo.

In questa fase il LED di marcia è spento e il LED di allarme è spento. Il programma non torna allo stato iniziale, ma resta in una condizione intermedia da cui il processo può riprendere.

Dal diagramma si vede che da questo stato esiste una sola transizione utile: la pressione di START, che riporta il sistema in STATO_MARCIA.

È importante però osservare un dettaglio del codice: quando si torna in marcia dalla pausa, il programma esegue di nuovo l’istruzione che salva istanteInizioMarcia = millis(). Questo significa che il conteggio del tempo massimo non viene congelato e poi ripreso, ma riparte da zero.

Questo aspetto è importante, perché aiuta a capire che il diagramma descrive la struttura generale del comportamento, mentre le variabili e le azioni associate alle transizioni determinano il comportamento concreto del sistema.

Significato dello stato ALLARME

Lo stato STATO_ALLARME rappresenta una condizione anomala o di sicurezza.

Quando il sistema entra in allarme, il LED di marcia viene spento e il LED di allarme viene acceso. In questo modo l’operatore può riconoscere immediatamente che il ciclo si è interrotto per il superamento del limite previsto.

Dal diagramma si vede che da STATO_ALLARME non si può tornare direttamente in marcia. L’unica uscita prevista è verso STATO_ATTESA, e questa transizione è attivata dal pulsante RESET.

Anche questa è una scelta molto importante dal punto di vista progettuale: in presenza di un allarme il sistema non riparte automaticamente, ma richiede un intervento esplicito da parte dell’operatore. È una logica tipica dei sistemi in cui la sicurezza o il controllo delle anomalie hanno priorità sulla continuità del funzionamento.

IMPORTANTE

Quando si studiano le macchine a stati è utile distinguere tra:

      • azioni di stato, cioè ciò che il sistema fa mentre si trova in un determinato stato;
      • azioni di transizione, cioè ciò che il sistema esegue nel momento in cui passa da uno stato a un altro.

Nell’esercizio proposto, l’accensione o lo spegnimento dei LED, è un’azione associata allo stato, perché avviene nel blocco di codice relativo a ciascun case.

Il salvataggio di istanteInizioMarcia, invece, è un’azione di transizione, perché viene eseguito nel momento in cui il sistema entra nello stato di marcia.
Questa distinzione è molto utile per comprendere meglio sia il diagramma sia il codice.

Continua a leggere

Domande dagli utenti – Perché Arduino legge valori strani se il pin non è collegato?

Ho deciso di mettere maggiormente in evidenza le richieste di chiarimento su diversi argomenti tecnici che mi giungono via mail o le domande lasciate nei commenti ai miei post. Spesso questi interventi nascono da dubbi autentici e molto concreti, ma rischiano di perdersi tra i tanti contenuti pubblicati. Per questo motivo ho pensato che alcune di queste domande meritino di essere riprese e trasformate in risposte più ampie, dettagliate e utili anche per altri lettori.

Molto spesso a scrivermi sono studenti giovanissimi, che stanno iniziando il loro percorso nell’elettronica, nella programmazione o nell’uso di Arduino. Ed è proprio a loro che sento di dover dedicare un’attenzione particolare, perché dietro una domanda apparentemente semplice si nasconde quasi sempre un passaggio importante da chiarire. Sono convinto, infatti, che proprio dalle domande più essenziali si costruiscano le basi migliori per capire davvero.

Molti, quando mi scrivono, aggiungono frasi come:

“Mi scusi per la domanda forse banale…”

oppure

“Preferisco scriverle in privato perché non vorrei fare una figura da inesperto nei commenti”

Su questo vorrei essere molto chiaro, perché per me è un aspetto importante, sia come docente sia come autore di contenuti didattici: non esiste la domanda sciocca, esiste solo la domanda non fatta.

Anzi, molto spesso le domande più utili sono proprio quelle che sembrano più elementari, perché costringono a chiarire i concetti fondamentali. E senza fondamenta solide, anche gli argomenti più avanzati restano fragili.

Una delle domande che mi è arrivata di recente è questa:

“Prof, perché Arduino mi legge valori strani anche se non ho collegato niente al pin?”

È una domanda ottima ed è anche una domanda che può aiutare molte persone che iniziano a usare Arduino, l’elettronica o i sensori.

Risposta

Perché un pin lasciato scollegato non è in uno stato definito.

Se un ingresso non è collegato né al positivo né alla massa, il microcontrollore non possiede un riferimento elettrico chiaro. In questa situazione il pin può captare piccoli disturbi presenti nell’ambiente circostante e restituire valori instabili, apparentemente casuali.

Quindi, nella maggior parte dei casi, non c’è nessun guasto nella scheda.
Il pin sta semplicemente lavorando in una condizione detta flottante.

Che cosa significa “pin flottante”

Quando si comincia a usare Arduino, è facile immaginare che un pin non collegato equivalga a “zero” oppure a “nessun segnale”.

In realtà non funziona così.

Un ingresso lasciato libero può comportarsi un po’ come una piccola antenna: intercetta disturbi elettrici, rumori, influenze del circuito circostante e può quindi produrre letture variabili anche se noi non stiamo toccando nulla.

Questo significa che:

  • un ingresso digitale può passare casualmente tra HIGH e LOW;
  • un ingresso analogico può mostrare valori che cambiano continuamente nel monitor seriale.

È un comportamento molto istruttivo, perché mostra subito una differenza importante tra lo schema ideale disegnato sulla carta e il comportamento reale dei circuiti.

L’idea fondamentale da ricordare

Il concetto chiave è questo:

in elettronica, “non collegato” non significa “zero”.

Questo è uno di quei principi che ritornano continuamente quando si lavora con pulsanti, sensori, interruttori, linee di ingresso e acquisizioni analogiche.

Capirlo bene fin dall’inizio evita molti errori e, soprattutto, aiuta a ragionare in modo più corretto sul funzionamento dei circuiti.

Come si risolve

Per evitare che un ingresso fluttui, bisogna assegnargli uno stato elettrico preciso.

Di solito si usa una di queste soluzioni:

  • una resistenza di pull-down, che mantiene il pin a livello basso quando non arriva alcun segnale;
  • una resistenza di pull-up, che mantiene il pin a livello alto;
  • la modalità INPUT_PULLUP di Arduino, molto comoda per gli ingressi digitali, perché sfrutta una resistenza interna del microcontrollore.

È una delle prime configurazioni corrette da imparare, soprattutto quando si cominciano a collegare pulsanti.

Un piccolo esperimento

Per osservare direttamente il fenomeno si può fare una prova semplicissima.

Si collega Arduino al computer, si carica uno sketch che legge un ingresso analogico lasciato libero, e si osservano i valori nel monitor seriale.

Esempio di sketch: lettura di un pin analogico flottante

/*
  Lettura di un ingresso analogico lasciato scollegato
  per mostrare il comportamento di un pin flottante.

  Collegamenti:
  - Non collegare nulla al pin A0
  - Aprire il Monitor Seriale a 9600 baud

  Osservazione attesa:
  I valori letti non saranno stabili, ma varieranno nel tempo.
*/

const int pinAnalogico = A0;   // Pin analogico lasciato volutamente scollegato

void setup() {
  Serial.begin(9600);
  delay(1000); // Piccola attesa per dare tempo al monitor seriale di aprirsi

  Serial.println("Lettura di un pin analogico flottante");
  Serial.println("Il pin A0 non e' collegato a nulla.");
  Serial.println("Osserva i valori letti:");
}

void loop() {
  int valoreLetto = analogRead(pinAnalogico);  // Legge il valore presente su A0

  Serial.print("Valore letto: ");
  Serial.println(valoreLetto);

  delay(200); // Solo per rallentare la visualizzazione
}

Che cosa si osserva

Aprendo il monitor seriale, i valori non resteranno fermi.
Potranno cambiare anche senza alcun intervento esterno.

A seconda della scheda, dell’ambiente, dei cavi vicini, della posizione delle mani e del rumore elettrico circostante, potresti vedere numeri che oscillano in modo più o meno evidente.

Ed è proprio questo il punto interessante: il pin non è “a zero”, ma è in una condizione indefinita.

Una seconda prova ancora più istruttiva

Dopo aver osservato il comportamento flottante, potete ripetere l’esperimento collegando:

  • una resistenza di pull-down verso GND;
  • oppure un partitore o un riferimento fisso;
  • oppure, nel caso di un ingresso digitale, attivando INPUT_PULLUP.

Il confronto tra “prima” e “dopo” è didatticamente molto efficace, perché fa vedere in modo concreto cosa significa stabilizzare un ingresso.

Variante digitale

Lo stesso fenomeno si può osservare anche con un ingresso digitale lasciato libero.

/*
  Lettura di un ingresso digitale flottante.

  Collegamenti:
  - Non collegare nulla al pin 2
  - Aprire il Monitor Seriale a 9600 baud

  Osservazione attesa:
  Il pin potra' cambiare in modo imprevedibile tra HIGH e LOW.
*/

const int pinDigitale = 2;   // Pin digitale lasciato scollegato

void setup() {
  Serial.begin(9600);
  pinMode(pinDigitale, INPUT);  // INPUT semplice: nessuna pull-up interna attiva

  delay(1000);

  Serial.println("Lettura di un pin digitale flottante");
  Serial.println("Il pin 2 non e' collegato a nulla.");
}

void loop() {
  int statoPin = digitalRead(pinDigitale);

  Serial.print("Stato letto: ");
  if (statoPin == HIGH) {
    Serial.println("HIGH");
  } else {
    Serial.println("LOW");
  }

  delay(200);
}

In questo caso il risultato potrà essere meno “spettacolare” oppure più irregolare, ma il principio resta identico: senza riferimento, l’ingresso non è affidabile.

Una domanda come questa può sembrare piccola, ma in realtà apre la porta a uno dei concetti più importanti dell’elettronica di base:

ogni ingresso deve avere un riferimento chiaro.

Capire bene questo passaggio significa costruire basi più solide per affrontare tutto il resto: pulsanti, sensori, automazione, misure, controllo e programmazione embedded.

E quindi, come dico sempre a chi mi scrive in privato:
fate domande, SEMPRE.

Perché una domanda sincera, anche molto semplice, vale molto più di un silenzio pieno di dubbi.

Piccola proposta pratica per il laboratorio

Chi vuole può provare questa sequenza:

  1. caricare lo sketch con A0 scollegato;
  2. osservare i valori nel monitor seriale;
  3. toccare con un dito il filo collegato ad A0 o avvicinare la mano;
  4. osservare come cambiano i valori;
  5. collegare poi il pin a GND oppure a 5 V tramite una configurazione corretta;
  6. confrontare il comportamento.

È una prova molto semplice, ma estremamente utile per capire, come dicevo ad inizio post, che in elettronica anche ciò che sembra “non collegato” può avere effetti reali.

Buona esplorazione 🙂

Esercitazione 3 – Scheduler cooperativo con tre task e supervisione dei tempi

Allenamento per l’esame di maturità
Percorso di laboratorio con Arduino per studenti di quinta ITIS

Obiettivo didattico

Organizzare il programma come scheduler cooperativo con tre task indipendenti: acquisizione analogica, lampeggio di stato e trasmissione seriale periodica. L’attività mostra come il loop() possa diventare un piccolo supervisore software.

Materiali suggeriti

  • Arduino UNO R3 o UNO R4;
  • 1 potenziometro;
  • 2 LED;
  • 2 resitori (per i LED);
  • breadboard;
  • cavetti jumper.

Schema di collegamento

Richiamo teorico

In un sistema embedded semplice non si usa un vero sistema operativo, ma si può costruire uno scheduler cooperativo con millis(). Ogni task possiede il proprio intervallo e il proprio istante dell’ultima esecuzione. Il loop() controlla se ciascun task è pronto e lo richiama.

Schema logico dell’attività

Il programma inizializza i timer dei tre task. Nel loop legge il tempo corrente e verifica uno dopo l’altro se è il momento di eseguire il task di acquisizione, quello di segnalazione e quello di stampa seriale. Se il tempo non è scaduto, passa al controllo successivo.

Diagramma di flusso

Diagramma di flusso Mermaid

flowchart TD
    A[Inizio] --> B[Configura pin, seriale e timer]
    B --> C[Leggi tempo attuale]
    C --> D{Task acquisizione pronto?}
    D -- Sì --> E[Esegui acquisizione]
    D -- No --> F{Task LED pronto?}
    E --> F
    F -- Sì --> G[Commuta LED di stato]
    F -- No --> H{Task seriale pronto?}
    G --> H
    H -- Sì --> I[Invia dati in seriale]
    H -- No --> J[Ritorna al loop]
    I --> J
    J --> C

Programma

/*
  Prof. Maffucci Michele
  Esercizio 3: scheduler cooperativo con tre task indipendenti
*/

const int PIN_SENSORE = A0;
const int PIN_LED_STATO = 8;
const int PIN_LED_SOGLIA = 9;

// ---------------------------
// Intervalli dei tre task
// ---------------------------
const unsigned long PERIODO_ACQUISIZIONE = 50;
const unsigned long PERIODO_LED = 300;
const unsigned long PERIODO_SERIALE = 500;

// ---------------------------
// Istanti ultima esecuzione
// ---------------------------
unsigned long ultimoTaskAcquisizione = 0;
unsigned long ultimoTaskLed = 0;
unsigned long ultimoTaskSeriale = 0;

// ---------------------------
// Variabili condivise
// ---------------------------
int valoreGrezzo = 0;
float tensione = 0.0;
bool statoLed = false;

void setup() {
  pinMode(PIN_LED_STATO, OUTPUT);
  pinMode(PIN_LED_SOGLIA, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // Il loop assume il ruolo di piccolo scheduler.
  unsigned long adesso = millis();

  // ---------------------------
  // Task 1: acquisizione
  // ---------------------------
  if ((adesso - ultimoTaskAcquisizione) >= PERIODO_ACQUISIZIONE) {
    ultimoTaskAcquisizione = adesso;
    taskAcquisizione();
  }

  // ---------------------------
  // Task 2: LED di stato
  // ---------------------------
  if ((adesso - ultimoTaskLed) >= PERIODO_LED) {
    ultimoTaskLed = adesso;
    taskLed();
  }

  // ---------------------------
  // Task 3: seriale
  // ---------------------------
  if ((adesso - ultimoTaskSeriale) >= PERIODO_SERIALE) {
    ultimoTaskSeriale = adesso;
    taskSeriale();
  }
}

// ----------------------------------------------------------
// Legge il sensore e calcola una tensione equivalente.
// ----------------------------------------------------------
void taskAcquisizione() {
  valoreGrezzo = analogRead(PIN_SENSORE);

  // Conversione esplicita ADC -> tensione.
  tensione = (valoreGrezzo * 5.0) / 1023.0;

  // Uso della misura per attivare un LED di soglia.
  if (tensione >= 2.50) {
    digitalWrite(PIN_LED_SOGLIA, HIGH);
  } else {
    digitalWrite(PIN_LED_SOGLIA, LOW);
  }
}

// ----------------------------------------------------------
// Task di segnalazione periodica.
// ----------------------------------------------------------
void taskLed() {
  if (statoLed == false) {
    statoLed = true;
    digitalWrite(PIN_LED_STATO, HIGH);
  } else {
    statoLed = false;
    digitalWrite(PIN_LED_STATO, LOW);
  }
}

// ----------------------------------------------------------
// Task di comunicazione seriale.
// ----------------------------------------------------------
void taskSeriale() {
  Serial.print("ADC = ");
  Serial.print(valoreGrezzo);
  Serial.print("  Tensione = ");
  Serial.print(tensione, 2);
  Serial.println(" V");
}

Continua a leggere

Esercitazione 2 – Tastiera 4×4 non bloccante con codice di accesso e feedback di errore

Allenamento per l’esame di maturità
Percorso di laboratorio con Arduino per studenti di quinta ITIS

Obiettivo didattico

Scansionare una tastiera 4×4 senza usare una libreria esterna, acquisire una sequenza di tasti, confrontarla con un codice corretto e fornire un feedback di esito positivo o errore. L’attività allena gestione di matrici di pin, scansione righe/colonne, buffer di input e logica non bloccante.

Materiali suggeriti

  • Arduino UNO R3 o UNO R4;
  • tastiera 4×4;
  • LED verde;
  • LED rosso,
  • buzzer opzionale;
  • 2 resitori da 220 Ohm (per i LED);
  • breadboard;
  • cavetti jumper.

Schema di collegamento

Richiamo teorico

Una tastiera a matrice riduce il numero di fili usando righe e colonne. Il microcontrollore attiva una riga alla volta e legge le colonne. Se una colonna va a livello attivo, il tasto corrispondente a quella riga e colonna è premuto. Anche qui bisogna evitare il rimbalzo e gestire l’ingresso come sequenza di eventi.

Schema logico dell’attività

Il programma scansiona una riga alla volta. Quando rileva un tasto stabile, lo aggiunge al buffer. Se viene premuto # confronta il buffer con il codice atteso. Se il codice è corretto accende il LED verde. Se è errato accende il LED rosso, svuota il buffer e ricomincia.

Diagramma di flusso

Diagramma di flusso Mermaid

flowchart TD
    A[Inizio] --> B[Configura righe, colonne e LED]
    B --> C[Scansione tastiera]
    C --> D{Tasto valido trovato?}
    D -- No --> C
    D -- Sì --> E{Tasto uguale a # ?}
    E -- No --> F[Aggiungi carattere al buffer]
    F --> C
    E -- Sì --> G[Confronta buffer con codice]
    G --> H{Codice corretto?}
    H -- Sì --> I[Feedback verde e reset buffer]
    H -- No --> J[Feedback rosso e reset buffer]
    I --> C
    J --> C

Programma

/*
  Prof. Maffucci Michele
  Esercizio 2: Tastiera 4x4 non bloccante con codice di accesso e feedback di errore
*/

// ---------------------------
// Pin delle 4 righe
// ---------------------------
const int righe[4] = { 2, 3, 4, 5 };

// ---------------------------
// Pin delle 4 colonne
// ---------------------------
const int colonne[4] = { 6, 7, 8, 9 };

// ---------------------------
// Mappa dei tasti
// ---------------------------
char mappaTasti[4][4] = {
  { '1', '2', '3', 'A' },
  { '4', '5', '6', 'B' },
  { '7', '8', '9', 'C' },
  { '*', '0', '#', 'D' }
};

// ---------------------------
// LED di feedback
// ---------------------------
const int PIN_LED_VERDE = 10;
const int PIN_LED_ROSSO = 11;

// ---------------------------
// Codice corretto da inserire
// ---------------------------
char codiceCorretto[] = "2580";

// ---------------------------
// Buffer di ingresso utente
// ---------------------------
char bufferInput[8];
int indiceInput = 0;

// ---------------------------
// Variabili per antirimbalzo
// ---------------------------
char ultimoTastoLetto = '\0';
char ultimoTastoConfermato = '\0';
unsigned long istanteCambio = 0;
const unsigned long TEMPO_DEBOUNCE = 40;

void setup() {
  // Le righe vengono pilotate in uscita.
  for (int i = 0; i < 4; i = i + 1) {
    pinMode(righe[i], OUTPUT);
    digitalWrite(righe[i], HIGH);
  }

  // Le colonne sono ingressi con pull-up.
  for (int i = 0; i < 4; i = i + 1) {
    pinMode(colonne[i], INPUT_PULLUP);
  }

  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROSSO, OUTPUT);

  Serial.begin(9600);
  svuotaBuffer();
}

void loop() {
  // Leggo il tasto corrente tramite scansione.
  char tastoCorrente = leggiTastiera();

  // Se è cambiato il valore grezzo, aggiorno il tempo.
  if (tastoCorrente != ultimoTastoLetto) {
    ultimoTastoLetto = tastoCorrente;
    istanteCambio = millis();
  }

  // Se il valore è stabile da abbastanza tempo, lo confermo.
  if ((millis() - istanteCambio) >= TEMPO_DEBOUNCE) {
    if (tastoCorrente != ultimoTastoConfermato) {
      ultimoTastoConfermato = tastoCorrente;

      // Elaboro il tasto solo quando è reale e non nullo.
      if (ultimoTastoConfermato != '\0') {
        gestisciTasto(ultimoTastoConfermato);
      }
    }
  }
}

// ----------------------------------------------------------
// Scansione manuale della tastiera.
// Attivo una riga alla volta e leggo tutte le colonne.
// ----------------------------------------------------------
char leggiTastiera() {
  for (int r = 0; r < 4; r = r + 1) {

    // Prima porto tutte le righe alte.
    for (int i = 0; i < 4; i = i + 1) {
      digitalWrite(righe[i], HIGH);
    }

    // Poi attivo solo la riga corrente.
    digitalWrite(righe[r], LOW);

    // Leggo tutte le colonne.
    for (int c = 0; c < 4; c = c + 1) {
      if (digitalRead(colonne[c]) == LOW) {
        return mappaTasti[r][c];
      }
    }
  }

  // Se non trovo alcun tasto, restituisco nullo.
  return '\0';
}

// ----------------------------------------------------------
// Gestione del carattere ricevuto.
// * cancella, # conferma, altri tasti vengono memorizzati.
// ----------------------------------------------------------
void gestisciTasto(char tasto) {
  Serial.print("Tasto ricevuto: ");
  Serial.println(tasto);

  if (tasto == '*') {
    svuotaBuffer();
    Serial.println("Buffer cancellato");
  } else if (tasto == '#') {
    verificaCodice();
  } else {
    if (indiceInput < 7) {
      bufferInput[indiceInput] = tasto;
      indiceInput = indiceInput + 1;
      bufferInput[indiceInput] = '\0';
    }
  }
}

// ----------------------------------------------------------
// Confronto del buffer con il codice corretto.
// ----------------------------------------------------------
void verificaCodice() {
  bool corretto = true;

  for (int i = 0; codiceCorretto[i] != '\0'; i = i + 1) {
    if (bufferInput[i] != codiceCorretto[i]) {
      corretto = false;
    }
  }

  // Verifico anche la lunghezza.
  if (indiceInput != 4) {
    corretto = false;
  }

  if (corretto == true) {
    Serial.println("CODICE CORRETTO");
    digitalWrite(PIN_LED_VERDE, HIGH);
    delay(500);
    digitalWrite(PIN_LED_VERDE, LOW);
  } else {
    Serial.println("CODICE ERRATO");
    digitalWrite(PIN_LED_ROSSO, HIGH);
    delay(500);
    digitalWrite(PIN_LED_ROSSO, LOW);
  }

  svuotaBuffer();
}

// ----------------------------------------------------------
// Ripulisce il buffer e rimette l'indice a zero.
// ----------------------------------------------------------
void svuotaBuffer() {
  for (int i = 0; i < 8; i = i + 1) {
    bufferInput[i] = '\0';
  }
  indiceInput = 0;
}

Continua a leggere