Archivi tag: elettronica

Arduino nello zaino: 4 “laboratori” trasportabili stampabili in 3D per avere sempre una base di prototipazione pronta

Chi fa didattica laboratoriale (o semplicemente ama sperimentare) lo sa: il problema non è avere gli strumenti, ma riuscire a portare con sé una dotazione minima che permetta di accendere il cervello “maker” ovunque ci si trovi.

Io ho già i miei laboratori completi, a casa e a scuola, dove posso fare tutto ciò che mi serve, però nello zaino porto sempre una piccola base di sperimentazione: una scheda Arduino, una breadboard, qualche cavetto e pochi componenti selezionati. Non è un “mini laboratorio” nel senso classico del termine, ma è qualcosa di altrettanto prezioso: un sistema ordinato e trasportabile che riduce l’attrito e rende immediata qualsiasi micro-attività.

In questo post vi segnalo 4 tipologie di contenitori/workstation stampabili in 3D pensate proprio per questo: tenere insieme scheda, breadboard, jumper e componenti, proteggere il setup e arrivare in aula (o ovunque) già pronto a partire.

Perché ritengo che questi organizer siano utili anche se avete un laboratorio completo

setup più veloce: appoggi, apri, colleghi l’USB e inizi;
ordine e componenti “a prova di zaino”: meno dispersione, meno “dov’è finito quel cavetto?”;
micro-attività replicabili: perfetti per dimostrazioni, tutoraggi, ASL, attività itineranti, laboratori in aule non attrezzate;
continuità nelle sperimentazioni personali: potete riprendere un prototipo esattamente dov’era rimasto, senza ricostruire tutto da zero.

All’organizer associo anche un piccolo contenitore rigido in cui dispongo ulteriori componenti elettronici.

The Folding Arduino Lab (il “classico” da zaino)

È quello che uso da sempre: The Folding Arduino Lab di Jason Welsh già segnalato qualche tempo fa su questo sito.
L’idea è semplice: un contenitore compatto che integra Arduino + breadboard (400 punti) + cassetti per cavetti e componenti. In uno spazio ridotto (indicativamente 10×9×8 cm) vi portate dietro l’essenziale.

I motivi per cui uso questa soluzione sono:

struttura “a libro”: protegge il setup e lo rende trasportabile, ovviamente non bisogna pretendere molti componenti sulla breadboard;
due vani/cassetti: ottimi per jumper, LED, resistenze, pulsanti, piccoli sensori;
è un progetto con molte varianti e remix: facile trovare adattamenti e accessori;
nota personale: l’autore ha sviluppato diverse versioni; io attualmente utilizzo la versione 2, su cui ho montato un Arduino UNO R4 WiFi.

Vi segnalo che con questo kit potete evitare, per le cerniere, l’uso di elementi metallici che possono essere sostituiti con filamento per la stampa 3D che risultano relativamente robusti e rimovibili.

Supporto/Stazione di lavoro modulare per Arduino UNO e breadboard (modulare e “scalabile”)

Questa soluzione è pensata come una workstation regolabile e modulare, ideale se vuoi una base ordinata non solo per trasporto, ma anche per lavorare “pulito” su banco (e poi richiudere e portare via).
La Modular Arduino UNO Breadboard Holder/Workstation (V2) è dichiarata come progetto modulare, con inserti, tray e mount selezionabili, e con impostazioni/accortezze legate alla stampa “print-in-place” in alcune parti.

Caratteristiche interessanti

modularità reale: potete scegliere vassoi/inserti in base a cosa usate (jumper, sensori, viteria, ecc.);
approccio “workstation” più che “scatola”: molto comoda per lavorare in modo ordinato;
ottima se volete aggiungere nel tempo moduli e supporti (display, sensori, ecc.).

Portable Arduino Lab (PAL) – molto compatto

Il Portable Arduino Lab (PAL) è una versione più piccola della workstation, pensata esplicitamente per “piccoli progetti on the go”, è dichiarato compatibile con Arduino UNO R3 e UNO R4.

Cosa mi piace

È progettato come “compagno di laboratorio”: base + chiusura + possibilità di storage;
ha indicazioni di stampa molto chiare: per esempio layer height 0,2 mm e attenzione alle tolleranze della cerniera/parti in movimento;
pPrevede anche opzioni e aggiornamenti: ad esempio supporti per breakout (ESP32 / Arduino Nano) sono citati tra gli update del progetto.

Nota pratica

In alcune configurazioni richiede viteria (M3x25) e una piccola fase di assemblaggio; non è un difetto, ma una scelta per robustezza e funzionalità.

Arduino R4 Laboratorio Portatile – “print in place” dedicato a UNO R4

Questa soluzione è centrata su Arduino UNO R4 e punta alla massima portabilità con la logica “print-in-place”. È indicato l’uso con breadboard da 400 punti e il fissaggio della scheda con viti M2.5 (fino a una certa lunghezza). (Seguire il link per prelevare i file per la stampa)

Scegliere questa soluzione se:

lavorate principalmente con UNO R4 e volete un contenitore dedicato.
se vi interessa un progetto già impostato con un layout essenziale: scheda + breadboard + vano.

Cosa mettere nello zaino

Se volete rendere davvero efficace uno di questi organizer, la differenza la fa la scelta dei componenti. Io ragiono per “massima resa didattica con minimo volume”:

Arduino (nel mio caso UNO R4 WiFi) + cavo USB;
breadboard 400 punti + cavetti jumper (M-M, M-F, F-F in piccola quantità);
set micro: LED + resistenze, 1–2 pulsanti, 1 potenziometro;
1 sensore “jolly” (LDR o temperatura/umidità) + 1 attuatore (buzzer o micro-servo);
mini cacciavite / pinzetta, un paio di cavetti Dupont extra;
(opzionale) Power bank se volete lavorare senza PC per attività specifiche.

Sto realizzando in questi mesi una versione di un mini laboratorio trasportabile contenuto in una rugged bag, le classiche valigette a tenuta stagna molto robuste, le uso spesso per la realizzazione di giochi escape o per contenere apparati delicati, se riuscirò vi mostrerò più avanti il risultato.

Buon Making a tutti 🙂

Domande dagli utenti: “puoi chiarire il concetto di negativo in comune?”

Lascia una risposta

Continuo con la serie delle domande che mi sono giunte sul gruppo Facebook BBC micro:bit Italy, questa volta dall’amico: Davide

ciao Michele Maffucci, uno degli altri “problemi” che ho notato che non capiscono, quando alimenti separatamente, il “negativo in comune”
Magari un giorno affronta l’argomento 🙂

Quando si alimenta separatamente (micro:bit o Arduino da una fonte e motori/driver da un’altra), molti si bloccano sul concetto di “negativo in comune”. Un modo semplice per capirlo è l’esempio dell’ascensore che spesso faccio durante le mie lezioni.

Immagina due persone che vogliono incontrarsi in un edificio:

la prima usa come riferimento il piano terra e dice: “sono al 2° piano”;
la seconda, però, considera “piano terra” il 1° piano (ha spostato lo zero): anche lei dice “sono al 2° piano”, ma in realtà si trova su un livello diverso.

Risultato: usano numeri uguali, ma riferiti a zeri diversi, quindi non riescono a coordinarsi e incontrarsi.

In elettronica succede la stessa cosa: un segnale “alto” (ad esempio 3,3 V) significa 3,3 V rispetto a un riferimento, cioè rispetto alla massa (GND). Se micro:bit e driver/servo non condividono la stessa massa, quel “3,3 V” può non essere interpretato correttamente perché lo “zero” dell’uno non coincide con lo “zero” dell’altro.

Nota importante: massa e terra non sono la stessa cosa (anche se a volte coincidono)

Massa / GND (0 V di riferimento): è il potenziale comune di riferimento del circuito, spesso chiamato anche 0 V. È il “piano terra” della nostra analogia: lo zero rispetto a cui misuriamo e capiamo i segnali.
Terra / PE (Protective Earth – protezione): è il collegamento all’impianto di terra, usato soprattutto per sicurezza elettrica (scariche, guasti, schermature).

In molti dispositivi alimentati da rete, la massa del circuito può essere collegata alla terra, e in quel caso massa e terra finiscono per trovarsi allo stesso potenziale e spesso si parla di “0 V”.

In sistemi a batteria (micro:bit, driver, servo, pacchi AA/AAA) come ad esempio i nostri robot didattici, non esiste una “terra” fisica collegata all’impianto: esiste solo la massa come riferimento comune.

Quindi, quando diciamo “mettere il negativo in comune”, intendiamo:

“Rendere comune il riferimento (GND) tra i dispositivi che devono scambiarsi segnali.”

in altro modo:

GND micro:bit < - > GND driver/servo < - > GND batteria motori

In breve: potete tenere alimentazioni separate, ma dovete rendere comune il riferimento (GND), altrimenti i segnali non hanno un “piano zero” condiviso e il controllo diventa instabile.

Schema pratico

GND micro:bit ─────────┐ GND driver/motor board ├──> punto massa comune GND batteria motori ───┘

Il concetto è: micro:bit invia il segnale, il driver lo interpreta, ma entrambi devono riferirsi allo stesso “0 V”.

Schema di collegamento – casi tipici

A. micro:bit + driver motori DC (ponte H / Motor driver)

Batteria motori + (positivo) > Vmot / +VIN driver
Batteria motori − (negativo) > GND driver
micro:bit pin (PWM/direzione) > IN1/IN2/ENA… (driver)
micro:bit GND > GND driver (fondamentale)

IMPORTANTE: non serve collegare i “positivi” tra loro; serve collegare i GND.

B. micro:bit + servo (alimentazione servo separata)

Batteria servo + (positivo) > V+ servo
Batteria servo − (negativo) > GND servo
micro:bit pin segnale > SIG servo
micro:bit GND > GND servo

Senza GND in comune il servo può tremare, non rispondere o muoversi in modo erratico.

C. micro:bit alimentata e motori sullo stesso pacco batterie (solo se il pacco è adeguato)

Stesso pacco batterie > micro:bit (tramite regolazione corretta) + driver;
GND è già comune per costruzione;
è pratico, ma attenzione ai disturbi: spesso conviene comunque separare la potenza motori.

Accorgimenti costruttivi utili

collegare “a stella” le masse, ovvero un punto comune su cui colleghiamo tutte le masse vicino al driver/alimentazione motori, evitare se possibile collegamenti di masse in cascata;
mantenere i cavi motore e quelli di segnale separati quando possibile;
aggiungere condensatori di disaccoppiamento vicino al driver/servi (se il kit non li integra già).

Per approfondimenti consiglio la lettura del post: Sensori e attuatori lontani da Arduino: guida pratica al cablaggio corretto i consigli che vengono forniti possono essere adottati anche per la costruzione dei nostri robot didattici.

Questi concetti verranno approfonditi in modo pratico durante il mio prossimo corso di robotica.

Buon Making a tutti.

Domande dagli utenti: perché micro:bit non pilota i motori direttamente?

2 Repliche

Nella giornata di ieri mi è arrivata una domanda molto sensata, una di quelle che prima o poi ci si pone tutti quando si prova a far muovere un robot con micro:bit o con Arduino.

“Se micro:bit riuscisse a passare da 3V a 5V si risparmierebbero i costi della scheda di espansione, nonché l’ottimizzazione degli spazi. Lei è d’accordo? Chissà perché non lo fanno: ormai tutti abbiamo bisogno di motorini.”

La risposta breve è questa:

Capisco il ragionamento, ma il vero ostacolo non è 3 V vs 5 V. Il punto è che un pin di micro:bit non è uno stadio di potenza.
Anche se la scheda fosse “a 5 V”, non potresti comunque collegare un motore direttamente ai pin in modo sicuro e affidabile.

Vediamo perché, con esempi concreti e riferimenti ai due kit che uso spesso nei corsi: Ring:bit V2 board e Kitronik :MOVE mini.

La spiegazione che segue è volutamente semplificata in quanto non necessariamente i colleghi che seguono i miei corsi sono docenti di materie di indirizzo tecnico.

Perché “alzare la tensione” non risolve il problema

Corrente: il motore chiede molta più energia di quella che un pin può dare

Un motore (anche piccolo) non “vuole solo tensione”: vuole soprattutto corrente, e ne vuole parecchia quando parte (corrente di spunto) e quando è sotto sforzo (ruote che spingono, attrito, urti).

Un pin GPIO di una scheda a microcontrollore è progettato per segnali e piccoli carichi, non per alimentare carichi elettromeccanici. Se provate a farlo, i sintomi tipici sono:

reset improvvisi della scheda,
comportamenti instabili,
surriscaldamento,
nel peggiore dei casi danni ai pin o al microcontrollore.

Disturbi e picchi: il motore “sporca” l’alimentazione e genera back-EMF

Il motore è un carico induttivo: quando viene acceso/spento o se ne cambia la velocità, può generare picchi di tensione (back-EMF) e disturbi elettrici che:

mandano in crisi la logica,
creano interferenze (anche sulla radio/BT),
degradano l’affidabilità nel tempo.

Serve un driver: lo “stadio di potenza” che separa logica e motore.

Per pilotare un motore DC, ad esempio quelli gialli che tipicamente vengono usati nei progetti didattici di robotica, serve uno stadio di potenza, cioè un driver motore, per esempio:

ponte H (per andare avanti/indietro e fare PWM in modo robusto),
oppure MOSFET + protezioni (se serve solo on/off o un verso).

Il driver fa tre cose fondamentali:

regge la corrente (anche i picchi),
gestisce la direzione e la velocità (PWM),
protegge micro:bit dai disturbi e dai picchi del motore.

Citando la richiesta dell’utente: “Ma allora perché micro:bit non è a 5V?”

In realtà molte schede “vivono” già in ambienti dove esistono 5 V (ad esempio USB), ma l’elettronica interna e i pin di I/O lavorano a bassa tensione (tipicamente 3,3 V) perché:

si riducono consumi e riscaldamento,
si protegge meglio la scheda,
si mantiene compatibilità con sensori moderni a bassa tensione,
e soprattutto (punto chiave): anche a 5 V i pin non diventerebbero “pilotamotori”.

Quindi: passare a 5 V non eliminerebbe la necessità di un driver. Cambierebbe solo alcuni dettagli di alimentazione/compatibilità, ma non la sostanza.

Il caso reale nei kit: Ring:bit V2 board e Kitronik :MOVE mini

Ring:bit V2 board: non è “la scheda che pilota motori”

La Ring:bit V2 board è principalmente una scheda di espansione/breakout:

rende più comodi alcuni collegamenti (ad esempio porte tipo GVS su P0/P1/P2),
integra un portabatterie (3×AAA) per alimentare il sistema/il robot,
fornisce un’interfaccia pratica per prototipare.

Va interpretata come interfaccia e distribuzione di alimentazione/connessioni, non come “micro:bit che pilota motori direttamente”.

Ring:bit V2

Kitronik :MOVE mini: usa servomotori, non motori DC senza elettronica di controllo integrata

La scheda Kitronik :MOVE mini può controllare due servomotori a rotazione continua. Questa scelta è utile per la didattica, perché un servo:

contiene già la propria elettronica di pilotaggio,
si controlla con un semplice segnale PWM (impulsi “stile servo”),
prende l’energia dal pacco batterie/board del kit, non dai pin di micro:bit.

In pratica:

micro:bit invia il comando (PWM),
il servo esegue, usando la sua alimentazione dedicata.

Questo è il motivo per cui, con :MOVE mini, si riesce ad avere un robot “semplice” e robusto senza introdurre subito il tema dei ponti H per motori DC.

:MOVE mini

Cosa vedremo nel corso: motori DC “veri” e driver dedicati

Durante il corso mostrerò anche l’altro scenario, quello tipico quando si usano i classici motori gialli da 6 V (motori DC con riduttore), dove il driver è obbligatorio.

motore TT

Lavoreremo in particolare con:

L298N (ottimo per capire il concetto di ponte H e cablaggi, anche se non è la soluzione più efficiente in assoluto),
Motor:bit di ELECFREAKS (più compatta e didattica, comoda per micro:bit).

Obiettivo: far capire chiaramente la differenza tra:

“motore DC” (serve driver + alimentazione adeguata),
“servo” (driver interno, controllo PWM più diretto).

Regola utile sempre: alimentazione separata e masse in comune

Quando si entra nel mondo motori/attuatori, una buona pratica è:

alimentare i motori/servi con una linea robusta (batterie/pack dedicato),
e mantenere massa (GND) in comune tra microcontrollore e driver/attuatori (quando richiesto), così i segnali di controllo hanno un riferimento corretto.

Questa singola regola elimina moltissimi “misteri” (reset, comportamenti casuali, servo che impazziscono).

Qualche precisazione in più sui motori DC o motori senza elettronica di controllo integrata

Troverete spesso la dicitura motori bare DC motor in pratica sono motori che hanno solo due terminali (o due fili):

fornite tensione > girano
togliete tensione > si fermano
invertite la polarità > invertono il verso di rotazione (se lo permettete elettricamente)

In ambito tecnico anglofono è abbastanza comune parlare di “bare DC motor” per indicare un motore senza elettronica di controllo integrata (cioè “il solo motore”, tipicamente a due fili) e spesso anche senza riduttore/struttura accessoria.

Esempi tipici:

i classici motori gialli TT 3–6 V usati nei robot economici
motorini DC “a spazzole” da modellismo o recuperati da giocattoli

I bare DC motor non hanno al loro interno:

driver di potenza
protezioni contro i picchi (back-EMF)
logica per interpretare un segnale di controllo

Quindi, per farli funzionare con micro:bit, serve aggiungere elettronica esterna:

un ponte H (es. L298N, TB6612, DRV8833) se vuoi avanti/indietro + PWM
oppure un MOSFET + diodo se ti basta on/off (e magari un solo verso)

L298N

TB6612

DRV8833

Differenza con un servo (o un motoriduttore “intelligente”)

Un servomotore (anche a rotazione continua) invece non è senza elettronica di controllo perché contiene già:

elettronica di pilotaggio
circuito di potenza
logica che interpreta il comando (impulsi PWM stile servo)

Per questo il micro:bit può “comandare” un servo con un semplice segnale, mentre con un motore DC senza elettronica di controllo deve essere gestito da un driver.

Buon Making a tutti 🙂

Meditazione da Maker: un supporto DIN per prototipare in fretta (e con ordine)

Lascia una risposta

5 minuti da Maker del fine settimana.

In queste settimane devo prototipare velocemente e rispondere ai dubbi di studenti di classi diverse: c’è chi inizia a “giocare” con l’elettronica e chi, più grande, pensa già ai progetti per la maturità. Risultato? Un continuo montare e smontare circuiti… e l’ordine che vacilla.

Per la mia attività di making del weekend ho deciso di dare forma a un supporto di prototipazione basato su guide DIN (guide omega), utilissime in elettronica e automazione. Chi mi segue sa che in passato ho realizzato vari supporti, trovate esempi sul mio sito e su Thingiverse, soprattutto per esercitazioni con PLC e microcontrollori.

Oggi pomeriggio, stanco dei moduli sparsi sul banco, ho sfruttato solo materiale di recupero per costruire una base pratica che mi permetta di passare da un’esercitazione all’altra in pochi minuti. Ho trattato l’attività come una piccola “Meditazione da Maker”: due ore di musica in sottofondo, progettazione e realizzazione. Missione compiuta nei tempi.

Il progetto è ancora migliorabile, quindi per ora non condivido i sorgenti: li pubblicherò a breve. Dalle immagini si capisce comunque quanto sia semplice replicarlo. La base misura 22×22 cm, una scelta dettata dal pannello già a disposizione e la struttura che ospita le barre DIN riprende i miei progetti precedenti, con qualche variazione mirata.

Nei prossimi giorni arriveranno sorgenti e dettagli, tornate a trovarmi. 🙂

Arduino – istruzione “do…while” – soluzione esercizi proposti

Lascia una risposta

In riferimento alla lezione: Arduino – istruzione “do…while”: eseguire almeno una volta, poi verificare pubblico una possibile soluzione agli esercizi proposti.

Esercizio 01 – Attendi pulsante

Consegna: attendere che un pulsante su D2 venga premuto; durante l’attesa far lampeggiare il LED integrato.
Vincoli: usare while come attesa in ingresso (while(digitalRead(…)==HIGH)).
Extra: al termine, stampare “OK” e fermarsi.

Soluzione

/*
  Prof. Maffucci Michele
  data: 27.10.25

  Soluzione esercizio 01 - Attendi pulsante
  Hardware:
    - Pulsante su D2 con INPUT_PULLUP (un capo a D2, l'altro a GND)
    - LED integrato (pin 13)
  Obiettivo:
    - Lampeggiare il LED mentre si attende la pressione del pulsante
    - Usare while(digitalRead(PIN_BTN) == HIGH) come attesa
    - Quando il pulsante viene premuto -> stampare "OK" e fermarsi
*/

// PIN_BTN dichiarato come byte e non come int per occupare meno spazio di memoria
// collegare il pulsante a GND (INPUT_PULLUP)

const byte PIN_BTN = 2;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(PIN_BTN, INPUT_PULLUP);
  Serial.begin(9600);
  Serial.println("Premi il pulsante per continuare...");
}

void loop() {
  // Attesa attiva: finché il pulsante NON è premuto (HIGH con pull-up)
  // il LED_BUILTIN (13) lampeggia
  while (digitalRead(PIN_BTN) == HIGH) {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(150);
    digitalWrite(LED_BUILTIN, LOW);
    delay(150);
  }

  // Debounce semplice per elimina rimbalzi meccanici
  // realizzato con piccolo ritardo
  delay(30);
  
  while (digitalRead(PIN_BTN) == LOW) {  // resta qui finché è tenuto premuto
  }

  Serial.println("OK");
  digitalWrite(LED_BUILTIN, HIGH);      // lascia il LED acceso come conferma
  while (true) {}                       // ferma la demo
}

Esercizio 02 – Svuota buffer seriale

Consegna: quando l’utente invia testo, fare echo e svuotare tutti i caratteri residui.
Vincoli: usare while(Serial.available()>0).
Extra: contare quanti byte sono stati letti e mostrarli.

Soluzione

/*
  Prof. Maffucci Michele
  data: 27.10.25

  Soluzione esercizio 02 — Svuota buffer seriale
  Obiettivo:
    - Appena arriva del testo, fare echo di TUTTI i caratteri presenti nel buffer
    - Usare while(Serial.available() > 0) per svuotare il buffer
    - Contare i byte letti e mostrarli
  Ricordare:
    - Impostare il Serial Monitor a 9600 baud
*/

void setup() {
  Serial.begin(9600);
  Serial.println("Scrivi una riga di testo e premi invio...");
}

void loop() {
  if (Serial.available() > 0) {
    int conteggioByte = 0;

    Serial.print("Echo: ");
    // Legge TUTTO ciò che è attualmente in buffer
    while (Serial.available() > 0) {
      char c = Serial.read();     // leggi un byte
      Serial.write(c);            // echo (stampa il carattere così com'è)
      conteggioByte++;            // conta i byte letti
      // piccola attesa facoltativa per dare tempo al buffer di riempirsi
      delay(1);
    }
    Serial.println();
    Serial.print("Byte letti: ");
    Serial.println(conteggioByte);
    Serial.println("----");
  }
  // Se serve introdurre qui altro codice non bloccante
}

Attenzione!

Può capitare che vengano contati due byte in più, ciò accade perché la Serial Monitor (in basso a destra)
aggiunge automaticamente i caratteri di fine riga quando premete invio.

entrambi NL & CR (Both NL & CR) > aggiunge due byte: \r (CR, 13) e \n (LF, 10) → ecco il tuo +2 costante;
a capo NL (Newline) > aggiunge un byte: \n > +1;
ritorno carrello (CR) (Carriage return) > aggiunge un byte: \r > +1;
nessuna fine riga (No line ending) > +0 (il conteggio coincide con i caratteri digitati, salvo caratteri non ASCII).

Esercizio 03 – Timer regressivo

Consegna: da un valore t letto da Serial (es. 5..20), eseguire un countdown finché t>0.
Vincoli: usare while(t>0) con t– e stampa del tempo.
Extra: beep finale + messaggio “Decollo!”.

Soluzione

/*
  Prof. Maffucci Michele
  data: 27.10.25

  Soluzione esercizio 03 — Timer regressivo
  Obiettivo:
    - Leggere un intero t (5..20) dal Serial Monitor
    - Eseguire while(t > 0) con stampa del tempo e t--
    - Al termine: beep su D5 e messaggio "Decollo!"
  Note:
    - Usa Serial.parseInt() per semplicità (attende un numero)
    - Per maggior informazioni sull'uso di parseInt() consultare il link:
      https://wp.me/p4kwmk-4Ah
*/

const int PIN_BUZ = 5;  // collegare un buzzer piezo (se disponibile)

void setup() {
  Serial.begin(9600);
  pinMode(PIN_BUZ, OUTPUT);
  Serial.println("Inserisci un numero intero t tra 5 e 20 e premi invio:");
}

void loop() {
  int t = 0;

  // Attendi un numero valido nell'intervallo [5..20]
  while (t < 5 || t > 20) {
    if (Serial.available() > 0) {
      t = Serial.parseInt();  // legge il primo intero disponibile
      // Svuota residui (ad es. '\n')
      while (Serial.available() > 0) Serial.read();

      if (t < 5 || t > 20) {
        Serial.println("Valore non valido. Inserisci un numero tra 5 e 20:");
      }
    }
  }

  // Countdown con while(t > 0)
  while (t > 0) {
    Serial.print("T-");
    Serial.println(t);
    delay(1000);  // 1 secondo
    t--;
  }

  // Fine: beep + messaggio
  tone(PIN_BUZ, 880, 350);  // beep di 350 ms
  Serial.println("Decollo!");

  while (true) {}  // ferma la demo
}

Buon lavoro.

The Folding Arduino Lab (il “classico” da zaino)

Supporto/Stazione di lavoro modulare per Arduino UNO e breadboard (modulare e “scalabile”)

Portable Arduino Lab (PAL) – molto compatto

Arduino R4 Laboratorio Portatile – “print in place” dedicato a UNO R4

Cosa mettere nello zaino

Related posts:

Schema pratico

Schema di collegamento – casi tipici

Accorgimenti costruttivi utili

Related posts:

Perché “alzare la tensione” non risolve il problema

Disturbi e picchi: il motore “sporca” l’alimentazione e genera back-EMF

Il caso reale nei kit: Ring:bit V2 board e Kitronik :MOVE mini

Cosa vedremo nel corso: motori DC “veri” e driver dedicati

Regola utile sempre: alimentazione separata e masse in comune

Differenza con un servo (o un motoriduttore “intelligente”)

Related posts:

Related posts:

Esercizio 01 – Attendi pulsante

Soluzione

Esercizio 02 – Svuota buffer seriale

Soluzione

Esercizio 03 – Timer regressivo

Soluzione

Related posts: