Archivi tag: led

Lezioni operative Premium per docenti, studenti e maker

Dal concetto alla pratica: materiali strutturati per imparare, insegnare e costruire

Da molti anni pubblico su questo sito articoli, tutorial, esperienze di laboratorio, attività STEAM, percorsi con microcontrollori, robotica, stampa 3D, coding, elettronica e strumenti digitali per la didattica.

Chi segue queste pagine lo sa bene: il filo conduttore è sempre stato lo stesso. Cercare di rendere più chiari i concetti, più accessibili le tecnologie e più concreta l’esperienza di apprendimento.

In queste ultime settimane, però, molti avranno notato un cambiamento nel ritmo di pubblicazione. Sono passato da una pubblicazione quasi giornaliera a una presenza meno regolare, più discontinua. Questa alternanza non nasce da una perdita di interesse, ma da due motivi principali.

Il primo è molto concreto: l’impegno didattico a scuola, che richiede tempo, attenzione ed energie.

Il secondo riguarda invece una riflessione più ampia che porto avanti da tempo: il desiderio di ristrutturare il lavoro sul sito, andando oltre il singolo tutorial e costruendo contenuti con una maggiore valenza didattica, pratica e formativa.

In questi anni ho pubblicato molte guide operative. Alcune sono nate per rispondere a esigenze dei miei studenti, altre per documentare attività svolte in laboratorio, altre ancora per aiutare docenti, maker e appassionati a orientarsi tra strumenti, componenti, schede elettroniche e tecnologie digitali.

Con il tempo, però, è diventata sempre più evidente una necessità: non bastano sempre idee, spunti o tutorial isolati. Spesso servono materiali più strutturati: lezioni organizzate, attività già pensate per il lavoro reale in classe o in laboratorio, percorsi progressivi, schede operative, strumenti di verifica, indicazioni per evitare gli errori più frequenti.

A questo si aggiunge un altro aspetto. Molte persone mi chiedono un supporto più continuativo per i loro progetti, per attività scolastiche, corsi, prototipi, percorsi didattici o soluzioni tecniche. Mi fa piacere, perché significa che il lavoro svolto in questi anni è stato utile. Allo stesso tempo, però, le richieste sono tante e non sempre riesco a seguirle come vorrei.

Capita anche di ritrovare materiali, idee, spiegazioni o strutture nate da questi articoli all’interno di siti, dispense, corsi o libri di testo. Da un lato è una soddisfazione: vuol dire che quei contenuti circolano e vengono considerati utili, dall’altro lato, però, dietro ogni articolo c’è un lavoro importante: studio, progettazione, scrittura, revisione, immagini, schemi, prove pratiche e adattamento didattico.

Spesso ricevo messaggi molto gentili, del tipo: “Grazie Michele, la tua guida mi è stata utilissima, mi ha permesso di completare un progetto per un cliente” oppure “I tuoi tutorial mi hanno aiutato molte volte a risolvere problemi pratici”. Sono parole che fanno piacere, naturalmente, ma, nella pratica, tutto questo resta spesso una bella pacca sulla spalla e poco più.

Per diverso tempo ho provato a immaginare soluzioni alternative: lezioni singole, incontri in presenza, attività su richiesta, materiali ad accesso libero con eventuale offerta volontaria. Sono strade interessanti, ma difficili da organizzare in modo stabile, soprattutto quando si vuole mantenere una qualità alta e una continuità reale.

Per questo sono arrivato a una svolta.

Dopo molto tempo passato a pensare, progettare e riorganizzare le idee, ho deciso di impostare il lavoro in modo diverso, mantenendo il sito gratuito come spazio aperto di divulgazione, riflessione e condivisione, e affiancandogli un’area Premium dedicata ai materiali più strutturati.

L’area Premium non sarà semplicemente un archivio di articoli più lunghi. Sarà uno spazio in cui raccogliere lezioni operative, corsi, laboratori guidati, schede, materiali per studenti, strumenti per docenti e percorsi già pensati per essere utilizzati, adattati e portati in classe o in laboratorio.

L’idea è far confluire progressivamente in questo spazio anche i materiali che sviluppo per la scuola, per i corsi in presenza, per i webinar e per le attività formative rivolte ai docenti. Non saranno materiali caricati così come sono, ma contenuti ristrutturati, ordinati e resi immediatamente utilizzabili.

Il sito gratuito continuerà quindi a essere il punto di partenza. L’area Premium diventerà lo spazio di approfondimento operativo.

Il principio rimarrà lo stesso che ha guidato il lavoro di questi anni:

capire, sperimentare, misurare, costruire, documentare.

Continua a leggere→

Capire prima di costruire – 02: perché un LED ha bisogno di una resistenza in serie?

Lascia una risposta

Una delle prime regole che si imparano in laboratorio, ma che vale la pena capire davvero.

Quando si comincia a lavorare con i circuiti elettronici, prima o poi arriva sempre questa raccomandazione:

“Non collegare mai un LED direttamente all’alimentazione senza una resistenza.”

È una regola giusta, e in laboratorio va presa sul serio. Però, se vogliamo imparare davvero l’elettronica, non basta ripeterla a memoria: dobbiamo capire che cosa succede nel circuito e perché quella resistenza è così importante.

Prima di tutto: che cos’è un LED

Un LED, cioè Light Emitting Diode, è un diodo che emette luce quando viene attraversato da corrente nel verso corretto.

La cosa importante da ricordare è questa:

un LED non si comporta come una normale resistenza. Non è lui a “scegliere” quanta corrente far passare in modo sicuro. Se lo colleghiamo male, può danneggiarsi molto in fretta, anche se per un istante sembra funzionare.

Il punto chiave: il LED non limita da solo la corrente

Questo è il concetto centrale.

Molti studenti all’inizio dei loro studi di elettronica pensano: “Se gli do la tensione giusta, il LED si accende e basta”. In parte è vero: il LED si accende quando è polarizzato correttamente. Il problema, però, è la corrente.

Senza un componente che la tenga sotto controllo, il LED può lasciar passare più corrente di quella che riesce a sopportare. Ed è proprio qui che entra in gioco la resistenza.

La resistenza serve a limitare la corrente che attraversa il LED e a mantenerla entro un valore sicuro.

Perché la sola tensione non basta

Ogni LED ha una propria caduta di tensione diretta: è la tensione che troviamo ai suoi capi quando il LED è acceso e lavora nel verso corretto.

Indicativamente possiamo avere questi valori:

LED rosso: circa 1,8 – 2,2 V
LED verde: circa 2 – 3 V
LED blu o bianco: circa 3 – 3,3 V

Facciamo un esempio semplice. Immaginiamo un LED rosso con una caduta di circa 2 V e un’alimentazione da 5 V.

Se lo colleghiamo direttamente ai 5 V, quei volt in più devono comunque “finire” da qualche parte. Senza una resistenza, il rischio è che la corrente salga troppo rapidamente.

Il risultato può essere questo:

il LED diventa molto luminoso per un attimo;
si scalda;
si danneggia in modo permanente.

Il ruolo della resistenza

La resistenza prende su di sé una parte della tensione disponibile e, soprattutto, stabilisce quanta corrente può passare nel circuito.

Per stimare il valore della resistenza possiamo usare la legge di Ohm:

R = (V alimentazione – V LED) / I

Per esempio:

alimentazione = 5 V;
caduta sul LED = 2 V;
corrente desiderata = 10 mA = 0,01 A.

Quindi:

R = (5 – 2) / 0,01 = 300 Ω

Nella pratica si sceglie spesso il valore standard più vicino. In questo caso, ad esempio, si può usare tranquillamente una resistenza da 330 Ω. Continua a leggere→

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

2 Repliche

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→

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

2 Repliche

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→

BBC microbit – Pixel per Pixel – uso dell’Istruzione plot

Lascia una risposta

Nel corso delle nostre avventure creative durante il corso “Carta, Cartone e Coding”, abbiamo esplorato attività in cui la creatività e l’arte incontra la tecnologia, trasformando idee astratte in realtà tangibili. Uno degli strumenti che abbiamo utilizzato per dare vita alle nostre creazioni è il BBC micro:bit.

Tra le numerose domande che mi avete inviato via mail alcune fanno riferimento all’uso dell’istruzione “plot”. Capisco che, per chi si avvicina per la prima volta a questi concetti, ci possano essere alcuni dubbi su come funzioni esattamente e su come possa essere applicata in modo efficace nelle nostre attività didattiche e in questo breve post voglio fornirvi una possibile soluzione che sfrutto molto spesso per mostrare il comportamento di istruzioni for nidificate.

L’istruzione “plot” è estremamente utile quando lavoriamo con il display LED del micro:bit, che come sapete è costituito da una matrice composto da 25 LED disposti in una griglia 5×5. L’istruzione plot ci permette di accendere un singolo LED sulla griglia, specificando le sue coordinate (x, y).

Come funziona?

x rappresenta la posizione orizzontale del LED, partendo da 0 (il lato più a sinistra) fino a 4 (il lato più a destra).
y indica la posizione verticale, anch’essa partendo da 0 (in alto) fino a 4 (in basso).

Utilizzando “plot(x, y)”, possiamo quindi selezionare esattamente quale LED accendere, permettendoci di creare disegni, lettere, numeri o qualsiasi altro tipo di segnale visivo che possiamo immaginare.

Vediamo alcuni semplici esempi.

Esempio 01

Accensione sequenziale di tutti i LED sul display del micro:bit dall’alto verso il basso, un colonna alla volta partendo dall’angolo in alto a sinistra del display.

Link al programma.

Esempio 02

Movimento di una pallina sul display. Accensione sequenziale dei LED sul display del micro:bit dall’alto verso il basso, un colonna alla volta partendo dall’angolo in alto a sinistra del display. Il ciclo si ripete all’infinito.

Link al programma.

Esempio 03

Accensione sequenziale di tutti i LED sul display del micro:bit dall’alto verso il basso, un colonna alla volta partendo dall’angolo in alto a sinistra del display, con cancellazione finale del display e ripartenza sequenza.

Link al programma.

Per tutti gli esercizi invertendo nei cicli for le variabili “x” e “y” si avrà un movimento da destra verso sinistra.

Buon Coding a tutti 🙂

Michele Maffucci

… my stories, life and work

Archivi tag: led

Lezioni operative Premium per docenti, studenti e maker

Dal concetto alla pratica: materiali strutturati per imparare, insegnare e costruire

Capire prima di costruire – 02: perché un LED ha bisogno di una resistenza in serie?