Archivi tag: arduino

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

Capire prima di costruire: una nuova serie di elettrotecnica ed elettronica

Un percorso per chiarire i concetti fondamentali e lavorare in laboratorio con maggiore consapevolezza.

Chi frequenta da tempo questo sito sa che qui trovano spazio soprattutto articoli approfonditi: lezioni estese, tutorial dettagliati, schemi, immagini, codice, proposte operative per il laboratorio e percorsi pensati per la didattica.

L’obiettivo, in queste pagine, è sempre stato quello di affrontare gli argomenti con attenzione, provando a costruire materiali chiari, solidi e riutilizzabili per studenti, docenti, appassionati e maker.

Proprio per questo, può forse sorprendere la nascita di una nuova serie di post più brevi. Eppure questa scelta non nasce da un cambio di rotta, né da una riduzione delle ambizioni didattiche. Nasce, al contrario, da un’esigenza molto concreta che negli ultimi anni è diventata sempre più evidente: per affrontare bene i temi più complessi, bisogna avere chiari i concetti fondamentali.

Da anni lavoro soprattutto con studenti del triennio dell’ITIS, in particolare delle classi quarte e quinte. Più recentemente, però, mi è capitato sempre più spesso di accompagnare anche studenti del biennio, molti dei quali mostrano un entusiasmo autentico verso l’uso di Arduino e desiderano progettare dispositivi, automazioni e piccoli sistemi anche piuttosto articolati.

Questo entusiasmo è prezioso. Curiosità, desiderio di costruire, voglia di sperimentare: sono spesso il miglior punto di partenza possibile per avvicinarsi all’elettronica e all’automazione.

Accanto a questo slancio iniziale, però, nel lavoro quotidiano in laboratorio emerge con chiarezza anche un altro aspetto: le nozioni di base dell’elettrotecnica e dell’elettronica non sempre sono sufficientemente stabili e consapevoli.

Capita così che termini come tensione, corrente, resistenza, massa, polarità, collegamento in serie e in parallelo, uso corretto del multimetro o funzione di una resistenza di pull-up vengano utilizzati in modo intuitivo, ma non pienamente compresi.

Molti dei temi che compariranno in questa serie nascono proprio dalle domande ricorrenti che gli studenti più giovani mi pongono durante le lezioni e le attività di laboratorio. Ho voluto raccogliere quei dubbi, quelle richieste di chiarimento e quelle incertezze che emergono con maggiore frequenza per trasformarle in un percorso ordinato, accessibile e utile anche al di fuori della classe.

Ed è precisamente da questa osservazione che nasce l’idea della nuova rubrica.

Molto spesso, infatti, la difficoltà non sta soltanto negli argomenti avanzati, ma nel fatto che i fondamenti vengono incontrati presto, usati presto, ma non sempre assimilati con la necessaria profondità. Così può accadere che uno studente riesca a montare un circuito, caricare uno sketch e vedere un sistema funzionare, ma fatichi poi a spiegare che cosa stia realmente accadendo dal punto di vista elettrico. E senza questa comprensione, anche le attività più motivanti rischiano di restare fragili.

Per questo ho deciso di affiancare ai tutorial più articolati una serie di lezioni brevi, chiare e mirate, pensate per tornare sui concetti essenziali con un linguaggio accessibile, ma senza rinunciare al rigore.

Saranno testi più snelli nella forma, ma costruiti con la stessa attenzione che riservo ai contenuti più estesi: attenzione ai dubbi reali degli studenti, agli errori ricorrenti, alle semplificazioni fuorvianti e ai passaggi che, se trascurati, rendono più difficile tutto ciò che viene dopo.

A questa scelta si lega anche una riflessione sul formato.

So bene che oggi il video è uno strumento potente, immediato e molto efficace sotto molti aspetti. Non ho nulla contro questa forma di comunicazione, che anzi può essere molto utile in diversi contesti. Tuttavia, realizzare video con continuità richiede tempi di progettazione, registrazione, montaggio e revisione che, almeno in questa fase, non riesco a sostenere in modo regolare. Ma il punto, per me, non è soltanto organizzativo.

Da sempre prediligo la lezione scritta.

La scrittura mi obbliga a rallentare, a ordinare meglio le idee, a scegliere con maggiore precisione le parole e a riflettere più a fondo sul modo in cui un concetto può essere spiegato. Ogni testo diventa così non solo un contenuto da pubblicare, ma anche una traccia di lavoro, una struttura didattica, un riferimento che posso riprendere, sviluppare e collegare ad altri argomenti nel tempo. In questo senso, le lezioni scritte funzionano per me anche come uno storyboard permanente: aiutano chi legge, ma aiutano anche me a costruire percorsi più coerenti.

C’è poi un secondo aspetto che considero importante.

Nel caso di argomenti tecnici di base, credo che leggere un testo mentre si osserva uno schema, si prende un appunto, si prova un collegamento, si misura un valore o si monta un piccolo circuito possa essere estremamente formativo. Il testo scritto ha un ritmo diverso: permette di fermarsi, tornare indietro, rileggere, verificare, annotare, confrontare subito teoria e pratica. Non impone velocità, lascia spazio al tempo dell’apprendimento.

Non penso affatto che il testo debba sostituire il video in assoluto. Penso però che, almeno per alcuni apprendimenti fondamentali, la combinazione tra lettura, riflessione e azione pratica sia particolarmente efficace. In un contesto in cui siamo sempre più abituati a fruire contenuti rapidamente, riprendere un passo più lento può sembrare controcorrente, eppure, proprio questa lentezza consente spesso di fissare meglio i concetti e di trasformarli in competenza reale.

Questa nuova serie, dunque, non nasce per sostituire gli articoli lunghi, né per semplificare artificialmente i contenuti. Nasce per affiancarli e per offrire un percorso di accesso più graduale a studenti, principianti e lettori curiosi che desiderano chiarire bene i fondamenti prima di affrontare temi più complessi.

Ogni post sarà costruito attorno a una domanda semplice o a un nodo concettuale essenziale. L’obiettivo sarà spiegare in modo comprensibile, ma corretto, un singolo aspetto dell’elettrotecnica o dell’elettronica, cercando di collegarlo, quando possibile, a situazioni reali di laboratorio, a esempi concreti o a errori frequenti da evitare.

Questa serie è pensata soprattutto per:

  • studenti che stanno iniziando;
  • docenti che cercano spiegazioni sintetiche ma affidabili da riprendere in classe;
  • appassionati e maker che desiderano chiarire alcuni concetti di base;
  • lettori che preferiscono contenuti brevi, ma non superficiali.

Continuo a credere che, soprattutto nelle discipline tecniche, spiegare bene le basi sia un lavoro importante quanto affrontare gli argomenti più avanzati. Anzi, spesso è proprio dalla qualità delle fondamenta che dipende la possibilità di comprendere davvero tutto il resto.

Per questo motivo, accanto ai tutorial più ampi e strutturati, da oggi troveranno spazio anche queste brevi lezioni essenziali, pensate per rendere più accessibili i concetti fondamentali dell’elettrotecnica e dell’elettronica e per accompagnare, un passo alla volta, chi sta iniziando questo percorso.

Da dove partirà la serie

Questa collezione di lezioni è attualmente in costruzione e si svilupperà progressivamente a partire da alcuni concetti fondamentali che, nell’attività di laboratorio, si rivelano spesso decisivi per comprendere davvero ciò che si sta facendo.

Tra i primi temi che intendo affrontare ci sono:

  • differenza tra tensione, corrente e resistenza;
  • perché un LED ha bisogno di una resistenza in serie;
  • che cosa significa GND in un circuito;
  • collegamento in serie e in parallelo;
  • che cos’è un cortocircuito e perché è pericoloso;
  • a cosa serve il multimetro e come iniziare a usarlo;
  • pull-up e pull-down;
  • differenza tra segnale analogico e digitale.

Il percorso crescerà nel tempo, anche a partire dalle difficoltà più frequenti che emergono durante le attività pratiche e dalle domande ricorrenti degli studenti.

Spero che questa nuova formula possa essere utile.

Come sempre, osservazioni, suggerimenti e proposte di temi da affrontare saranno molto ben accetti.

Buona lettura e buon lavoro 🙂

Esercitazione 1 – Pulsante singolo con antirimbalzo, doppio clic, pressione lunga e timeout

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

Obiettivo didattico

Realizzare una piccola interfaccia utente con un solo pulsante. Il sistema deve riconoscere una pressione breve, un doppio clic, una pressione lunga e un timeout di inattività. L’attività allena la gestione degli eventi, l’antirimbalzo software e l’uso di millis() senza bloccare il programma.

Nota importante

La comprensione del funzionamento di questo esercizio permetterà lo svolgimento in autonomia dell’esercizio aggiuntivo che trovate al fondo di questa scheda di lavoro.

Materiali suggeriti

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

Schema di collegamento

Richiamo teorico

Per leggere correttamente un pulsante reale bisogna evitare il rimbalzo dei contatti. Si usa quindi una variabile con l’ultima lettura, una temporizzazione di stabilizzazione e una logica a eventi. Con millis() si misura il tempo senza usare delay(), così il programma può continuare a controllare altri compiti.

Schema logico dell’attività

Il programma legge continuamente il pulsante. Se la lettura cambia, attende il tempo di debounce. Quando il livello è stabile, riconosce pressione e rilascio. Dal tempo trascorso ricava l’evento: clic breve, doppio clic oppure pressione lunga. Se non accade nulla per molti secondi, attiva un LED di timeout.

Diagramma di flusso

Diagramma di flusso Mermaid

Ricordo che per realizzare il diagramma di flusso, copiate il codice Mermaid seguendo le indicazioni della lezione: Progettare bene, programmare meglio: diagrammi di flusso – cos’è il formato Mermaid? – Lezione 2/5

flowchart TD
    A[Inizio] --> B[Configura pin e variabili]
    B --> C[Leggi pulsante]
    C --> D{Lettura cambiata?}
    D -- Sì --> E[Salva istante variazione]
    D -- No --> F{Tempo debounce trascorso?}
    E --> F
    F -- No --> C
    F -- Sì --> G{Stato stabile cambiato?}
    G -- No --> H{Timeout inattività?}
    G -- Sì --> I{Pulsante premuto?}
    I -- Sì --> J[Memorizza istante pressione]
    I -- No --> K[Calcola durata pressione]
    K --> L{Pressione lunga?}
    L -- Sì --> M[Genera evento LONG]
    L -- No --> N{Secondo clic entro finestra?}
    N -- Sì --> O[Genera evento DOUBLE]
    N -- No --> P[Attendi possibile secondo clic]
    H -- Sì --> Q[Attiva LED timeout]
    H -- No --> C
    J --> C
    M --> C
    O --> C
    P --> C
    Q --> C

Programma

/*
  Prof. Maffucci Michele
  Esercizio 1: Pulsante singolo con antirimbalzo, doppio clic, pressione lunga e timeout
*/


// ---------------------------
// Definizione dei pin usati
// ---------------------------
const int PIN_PULSANTE = 2;
const int PIN_LED_BREVE = 8;
const int PIN_LED_DOPPIO = 9;
const int PIN_LED_TIMEOUT = 10;

// ---------------------------
// Costanti temporali
// ---------------------------
const unsigned long TEMPO_DEBOUNCE = 30;
const unsigned long SOGLIA_PRESSIONE_LUNGA = 800;
const unsigned long FINESTRA_DOPPIO_CLICK = 350;
const unsigned long TEMPO_TIMEOUT = 5000;

// ---------------------------
// Variabili per antirimbalzo
// ---------------------------
int ultimaLetturaGrezza = HIGH;
int statoStabile = HIGH;
unsigned long istanteUltimaVariazione = 0;

// ---------------------------
// Variabili per eventi utente
// ---------------------------
bool attesaSecondoClick = false;
unsigned long istantePrimoClick = 0;
unsigned long istantePressione = 0;
unsigned long ultimoEventoUtente = 0;

void setup() {
  // Il pulsante usa la resistenza interna di pull-up.
  pinMode(PIN_PULSANTE, INPUT_PULLUP);

  // I tre LED rappresentano tre eventi diversi.
  pinMode(PIN_LED_BREVE, OUTPUT);
  pinMode(PIN_LED_DOPPIO, OUTPUT);
  pinMode(PIN_LED_TIMEOUT, OUTPUT);

  // All'avvio tutti i LED sono spenti.
  digitalWrite(PIN_LED_BREVE, LOW);
  digitalWrite(PIN_LED_DOPPIO, LOW);
  digitalWrite(PIN_LED_TIMEOUT, LOW);

  // La seriale aiuta a vedere quale evento viene riconosciuto.
  Serial.begin(9600);

  // Salvo il tempo iniziale come ultimo evento.
  ultimoEventoUtente = millis();
}

void loop() {
  // Leggo il pulsante in forma grezza.
  int letturaCorrente = digitalRead(PIN_PULSANTE);

  // Se la lettura è cambiata rispetto alla precedente,
  // aggiorno il tempo della variazione.
  if (letturaCorrente != ultimaLetturaGrezza) {
    istanteUltimaVariazione = millis();
    ultimaLetturaGrezza = letturaCorrente;
  }

  // Se il segnale è stabile da abbastanza tempo,
  // posso considerarlo affidabile.
  if ((millis() - istanteUltimaVariazione) >= TEMPO_DEBOUNCE) {

    // Se anche lo stato stabile è cambiato, ho un nuovo evento.
    if (letturaCorrente != statoStabile) {
      statoStabile = letturaCorrente;
      ultimoEventoUtente = millis();
      digitalWrite(PIN_LED_TIMEOUT, LOW);

      // Transizione verso livello basso = pulsante premuto.
      if (statoStabile == LOW) {
        istantePressione = millis();
      }
      // Transizione verso livello alto = pulsante rilasciato.
      else {
        unsigned long durataPressione = millis() - istantePressione;

        // Se la durata supera la soglia, classifico come pressione lunga.
        if (durataPressione >= SOGLIA_PRESSIONE_LUNGA) {
          Serial.println("Evento: PRESSIONE LUNGA");
          lampeggiaLed(PIN_LED_DOPPIO, 2, 120);
          attesaSecondoClick = false;
        }
        else {
          // Se sto già aspettando un secondo clic,
          // verifico la finestra temporale.
          if (attesaSecondoClick == true &&
              (millis() - istantePrimoClick) <= FINESTRA_DOPPIO_CLICK) {
            Serial.println("Evento: DOPPIO CLICK");
            lampeggiaLed(PIN_LED_DOPPIO, 1, 250);
            attesaSecondoClick = false;
          }
          else {
            // Primo clic breve: non lo confermo subito,
            // perché potrei ricevere un secondo clic.
            attesaSecondoClick = true;
            istantePrimoClick = millis();
          }
        }
      }
    }
  }

  // Se è in attesa un secondo clic e la finestra è scaduta,
  // confermo il clic breve.
  if (attesaSecondoClick == true && (millis() - istantePrimoClick) > FINESTRA_DOPPIO_CLICK) {
    Serial.println("Evento: CLICK BREVE");
    lampeggiaLed(PIN_LED_BREVE, 1, 250);
    attesaSecondoClick = false;
  }

  // Se passa troppo tempo senza eventi, attivo il LED di timeout.
  if ((millis() - ultimoEventoUtente) >= TEMPO_TIMEOUT) {
    digitalWrite(PIN_LED_TIMEOUT, HIGH);
  }
}

// ----------------------------------------------------------
// Funzione di servizio: fa lampeggiare un LED alcune volte.
// In questa attività è accettabile usare delay() perché
// la funzione serve solo come feedback visivo di conferma.
// ----------------------------------------------------------
void lampeggiaLed(int pinLed, int numeroLampi, int durata) {
  for (int i = 0; i < numeroLampi; i = i + 1) {
    digitalWrite(pinLed, HIGH);
    delay(durata);
    digitalWrite(pinLed, LOW);
    delay(durata);
  }
}

Continua a leggere

Arduino VENTUNO Q: la nuova piattaforma per AI, robotica e attuazione

Arduino ha annunciato VENTUNO Q, una nuova piattaforma descritta come una single-board computer progettata per applicazioni di intelligenza artificiale, robotica e attuazione. Il lancio è avvenuto oggi 9 marzo 2026 sul blog ufficiale Arduino, che la presenta come una soluzione pensata per unire su una sola board capacità di percezione, decisione e controllo del mondo fisico.

Per chi segue l’evoluzione dell’ecosistema Arduino, si tratta di un passaggio interessante: non più solo microcontrollori per prototipazione rapida, ma una piattaforma che punta a coprire anche scenari più avanzati, vicini alla robotica intelligente, alla computer vision on-device e ai sistemi che richiedono AI locale e controllo real-time. Questa lettura è inferenziale, ma coerente con il posizionamento ufficiale dichiarato da Arduino.

Una piattaforma pensata per “percepire, decidere e agire”

Uno dei concetti chiave con cui Arduino presenta VENTUNO Q è l’idea di una piattaforma capace di gestire, nello stesso sistema, l’acquisizione dei dati, l’elaborazione AI e il pilotaggio di attuatori. Il messaggio è chiaro: non soltanto “eseguire modelli”, ma costruire dispositivi in grado di interagire fisicamente con l’ambiente.

Nelle specifiche tecniche Arduino parla infatti di un’architettura “dual-brain“: da una parte un processore Qualcomm Dragonwing IQ8, dall’altra un microcontrollore STM32H5, collegati tramite un bridge RPC. L’obiettivo è separare i compiti di elaborazione complessa da quelli che richiedono tempi di risposta deterministici.

Architettura dual-brain: AI da una parte, controllo real-time dall’altra

Secondo Arduino, il processore principale Dragonwing IQ8 è dedicato ai carichi di lavoro più pesanti, inclusa l’inferenza di reti neurali, mentre lo STM32H5 si occupa delle operazioni a bassa latenza e del controllo in tempo reale. Sul blog ufficiale viene inoltre indicata una capacità fino a 40 dense TOPS (Tera Operations Per Second) per l’accelerazione AI, insieme a 16 GB di RAM e 64 GB di memoria espandibile.

Linux embedded e Arduino Core su Zephyr

VENTUNO Q può eseguire Ubuntu o Debian sul lato applicativo, mentre il microcontrollore real-time usa Arduino Core su Zephyr OS. Questa combinazione è rilevante perché mette insieme un ambiente Linux, più adatto a strumenti evoluti, librerie e workflow AI, con una componente embedded deterministica più vicina alla filosofia del controllo industriale e della robotica.

In termini pratici, ciò potrebbe consentire di sviluppare applicazioni in cui una parte del sistema gestisce visione, audio, interfacce o modelli AI, mentre l’altra mantiene il controllo puntuale di attuatori, encoder, segnali PWM o logiche di sicurezza. La possibilità concreta dipenderà naturalmente da tool, documentazione e maturità dell’ecosistema, ma la direzione indicata da Arduino è questa.

App Lab, Python e integrazione con Edge Impulse

Ovviamente VENTUNO Q si collega ad Arduino App Lab, l’ambiente in grado di unificare sketch Arduino, script Python e flussi di lavoro AI. Sarà possibile anche l’integrazione con Edge Impulse Studio e il supporto a modelli provenienti da Qualcomm AI Hub ed Edge Impulse.

Esempi applicativi: LLM locali, VLM, riconoscimento vocale automatico (ASR), sintesi vocale (TTS), stima di pose e gesture, oltre a funzioni di object tracking offline. Per chi lavora nella didattica o nella prototipazione, questa è forse una delle promesse più interessanti: portare l’AI “vicino” al dispositivo, senza dipendere sempre dal cloud.

Compatibilità hardware: Arduino, Qwiic e Raspberry Pi HAT

Arduino indica una compatibilità piuttosto ampia con diversi ecosistemi hardware. Nello specifico, VENTUNO Q viene presentata come compatibile con shield e carrier Arduino UNO, con i moduli Modulino, con i sensori Qwiic e addirittura con Raspberry Pi HATs.

Questo aspetto è importante perché amplia subito le possibilità di utilizzo: non una board isolata, ma una piattaforma che cerca di inserirsi in ambienti già familiari a maker, scuole, laboratori e sviluppatori. In ambito formativo questo può fare molta differenza, perché riduce la soglia di ingresso per sperimentare.

Connettività e interfacce per robotica ed Edge AI

Fra le caratteristiche che vengono evidenziate compaiono Wi-Fi 6, Bluetooth 5.3, CAN-FD nativo, PWM, GPIO ad alta velocità, connettori per più telecamere MIPI-CSI, audio avanzato, supporto display ed Ethernet 2.5 Gb. Interessantissimo, almeno per me la notizia che VENTUNO Q è ROS 2-ready, elemento che la colloca chiaramente anche nel perimetro della robotica moderna.

Nel complesso, la dotazione sembra andare oltre il classico uso educational di base e si spinge verso applicazioni più articolate: robot di servizio, sistemi di visione, automazione intelligente, interfacce vocali embedded, ispezione visiva e prototipazione preindustriale.

Alcuni scenari d’uso suggeriti da Arduino

Casi d’uso: interfacce vocali offline, sistemi interattivi basati su gesture, robot pick-and-place guidati dalla visione, robot di servizio che seguono le persone, applicazioni con Visual SLAM, monitoraggio intelligente e controllo qualità tramite modelli di visione locale.

Sono esempi significativi perché chiariscono il posizionamento del prodotto: VENTUNO Q non nasce come semplice variante di una board tradizionale, ma come piattaforma per progetti in cui servono insieme sensori, modelli AI, connettività e azione fisica sul mondo reale.

Perché potrebbe essere interessante anche per la scuola

Dal punto di vista didattico, VENTUNO Q potrebbe risultare particolarmente utile nei percorsi che incrociano elettronica, informatica, automazione, robotica e intelligenza artificiale. La presenza di un ambiente Linux, l’apertura verso Python e i workflow AI, unita al controllo real-time, la rende potenzialmente adatta a laboratori interdisciplinari più evoluti rispetto a quelli costruiti con microcontrollori tradizionali.

Naturalmente, molto dipenderà dalla disponibilità effettiva della scheda, dalla documentazione, dai costi, dagli esempi pronti e dalla facilità con cui queste caratteristiche potranno essere tradotte in attività scolastiche. Ma il segnale lanciato da Arduino è netto: l’AI embedded e la robotica intelligente stanno entrando sempre più chiaramente anche nel loro ecosistema.

Disponibilità

Arduino indica che VENTUNO Q sarà disponibile prossimamente tramite Arduino Store e presso rivenditori ufficiali come DigiKey, Farnell, Macfos, Mouser e RS. Al momento del lancio il prodotto è quindi annunciato come in arrivo, non ancora come board immediatamente acquistabile dal catalogo standard con una pagina e-commerce completa.

… cosa dire di più
sono curiosissimo ed impaziente di poterlo utilizzare 🙂

Con VENTUNO Q, Arduino sembra voler spingere il proprio ecosistema verso una nuova fascia progettuale: quella in cui non basta più leggere sensori e accendere attuatori, ma serve una piattaforma capace di analizzare, decidere e agire in locale. È un passaggio che guarda con decisione alla convergenza tra AI on-device, robotica e controllo embedded.

Resta ora da vedere come questa piattaforma si comporterà nella pratica, quali strumenti saranno davvero disponibili fin da subito e quanto sarà accessibile a scuole, maker e laboratori. Ma come annuncio, VENTUNO Q è sicuramente uno dei segnali più interessanti arrivati da Arduino negli ultimi tempi.

Fonte ufficiale Arduino: annuncio del 9 marzo 2026 sul blog Arduino e pagina prodotto ufficiale.

Mini progetto “dado elettronico” – due soluzioni

Ricordate la lezione: “randomSeed() su Arduino come usarla“. Vi avevo proposto un semplice esercizio sulla realizzazione di un dado digitale che genera un numero casuale da 1 a 6.

Vi propongo le due soluzioni:

  1. Con pulsante su pin digitale (lancio “fisico”)
  2. Con input da Serial Monitor (lancio “software”, immediato)

Entrambe sono adatte sia a Arduino UNO R3 sia a Arduino UNO R4.

Riprendiamo i concetti chiave visti nella lezione su randomSeed():

random(1,7) genera un numero pseudo-casuale tra 1 e 6.
Per evitare che la sequenza sia sempre uguale dopo un reset, conviene inizializzare il generatore con randomSeed(…). Nel dado, la cosa migliore è legare il seed a qualcosa di “imprevedibile”, ad esempio il momento in cui premete un pulsante (tempo umano) oppure un input seriale.

Versione A: dado con pulsante (pin digitale)

Materiale

  • 1 × Arduino UNO R3 o UNO R4
  • 1 × pulsante
  • cavetti e breadboard

Collegamenti

Usiamo la resistenza di pull-up interna, quindi niente resistenze esterne.

  • un piedino del pulsante -> GND
  • l’altro piedino del pulsante -> D2

Nel codice imposteremo pinMode(2, INPUT_PULLUP): a riposo il pin legge HIGH, quando premete legge LOW, ciò permette un cablaggio più semplice e rapido.

Nello sketch che segue imposteremo

  • debounce software (anti-rimbalzo)
  • seed inizializzato alla prima pressione usando micros() (molto efficace perché dipende dal tempo umano)
/*
  Prof. Maffucci Michele
  15.02.26
  Dado elettronico 1..6 con pulsante su D2 (INPUT_PULLUP).
  Include debounce e inizializzazione randomSeed al primo lancio.
*/

const byte PIN_PULSANTE = 2;

const unsigned long DEBOUNCE_MS = 30;

bool seedInizializzato = false;

int ultimoStatoLetto = HIGH; // con pull-up: HIGH a riposo
int statoStabile = HIGH;
unsigned long ultimoCambio = 0;

void setup() {
  Serial.begin(9600);
  delay(1000);
  pinMode(PIN_PULSANTE, INPUT_PULLUP);

  Serial.println("Dado elettronico (pulsante su D2).");
  Serial.println("Premi il pulsante per lanciare.\n");
}

void loop() {
  int lettura = digitalRead(PIN_PULSANTE);

  // Rilevo cambiamenti (possibili rimbalzi)
  if (lettura != ultimoStatoLetto) {
    ultimoCambio = millis();
    ultimoStatoLetto = lettura;
  }

  // Se è passato il tempo di debounce, considero stabile
  if (millis() - ultimoCambio > DEBOUNCE_MS) {
    if (lettura != statoStabile) {
      statoStabile = lettura;

      // Evento: pressione (con pull-up la pressione è LOW)
      if (statoStabile == LOW) {
        lanciaDado();
      }
    }
  }
}

void lanciaDado() {
  // Seed al primo lancio: il tempo umano rende la sequenza non ripetibile
  if (!seedInizializzato) {
    unsigned long seme = micros() ^ (unsigned long)analogRead(A0); // A0 può anche essere scollegato
    randomSeed(seme);
    seedInizializzato = true;
  }

  int risultato = random(1, 7); // 1..6

  Serial.print("Lancio! Risultato: ");
  Serial.println(risultato);
}

Versione B: dado con Serial Monitor (input testuale)

Una volta caricato lo sketch procedete in questo modo:

  • aprite il Serial Monitor a 9600 baud
  • impostate “Invio” (newline) o “CR+LF”
  • digitate un qualsiasi tasto e premete invio -> il dado lancia
/*
  Prof. Maffucci Michele
  15.02.26
  Dado elettronico 1..6 con input da Serial Monitor.
  Scrivete un carattere e premete invio per lanciare.
*/

bool seedInizializzato = false;

void setup() {
  Serial.begin(9600);
  delay(1000);
  Serial.println("Dado elettronico (Serial Monitor).");
  Serial.println("Scrivi un carattere e premi INVIO per lanciare.");
  Serial.println("Esempio: scrivi 'l' e invia.\n");
}

void loop() {
  if (Serial.available() > 0) {
    char c = Serial.read();

    // (Opzionale) scarto newline e carriage return
    if (c == '\n' || c == '\r') return;

    if (!seedInizializzato) {
      // Seed legato al momento in cui arriva il comando (tempo umano)
      unsigned long seme = micros() ^ (unsigned long)analogRead(A0);
      randomSeed(seme);
      seedInizializzato = true;
    }

    int risultato = random(1, 7);

    Serial.print("Comando ricevuto: '");
    Serial.print(c);
    Serial.print("' -> Risultato dado: ");
    Serial.println(risultato);

    Serial.println();
  }
}

In questo sketch l’istante in cui l’utente invia un carattere non è prevedibile: questo rende il seed variabile e quindi la sequenza di random() non riparte “uguale” ad ogni reset.

Esercizi per gli studenti

Attività 01: verifica del seed

  • lanciate 10 volte, annota i risultati;
  • premete reset e riprovate:
    • con seed legato alla pressione/comando dovreste vedere sequenze diverse.

Attività 02: statistica veloce

  • lanciate 60 volte;
  • contate quante volte esce ogni faccia (1..6);
  • discussione: la distribuzione è “circa uniforme?” Perché non è perfetta su pochi lanci?

Attività 03: debug consapevole

modificate il codice per usare un seed fisso, ad esempio randomSeed(1234) e confrontate:

  • questo è utile nei test perché rende i risultati ripetibili.

Buon Coding a tutti 🙂