Archivi tag: arduino

Dirimere i conflitti con il pensiero computazionale – educazione civica – Definizione del problema – lezione 01

La violenza, dai conflitti globali alla violenza verbale quotidiana, nasce spesso dal non-ascolto e dalla prevaricazione. Nel laboratorio di sistemi elettronici trasformiamo i principi di convivenza civile in processi chiari: condizioni, regole, passi verificabili. Il lavoro in gruppo e la scrittura dell’algoritmo favoriscono la riflessione e il senso di giustizia che nasce dal confronto tra pari, non dall’imposizione. In un’epoca di bombardamento continuo di notizie che rischia di normalizzare la violenza e di farci sentire impotenti, progettare insieme percorsi di dialogo è un dovere civico oltre che un’attività didattica.

Contenuto dell’attività

Obiettivi

  • Distinguere fatti da interpretazioni in un conflitto.
  • Formulare il problema in una frase chiara.
  • Definire regole minime di dialogo e condizioni di sicurezza.

Durata: 60–75 minuti
Materiali: scheda cartacea o digitale (tabella), post-it, pennarelli.

Fasi

  1. Rompighiaccio (5 minuti)
    • Brainstorm: dove incontriamo conflitti (classe, chat, famiglia, social, ambiente)?
    • Raccogli su post-it parole chiave (ascolto, rispetto, tempi, diritti, minoranze).
  2. Fatti vs interpretazioni (15 minuti)
    • Consegna una scheda con due colonne:
      • Colonna A: FATTI (osservabili, verificabili).
      • Colonna B: INTERPRETAZIONI (opinioni, giudizi, attribuzioni di intenzioni).
    • Ogni gruppo (3–4 studenti) compila la tabella su un caso realistico proposto da te.
  3. Regole minime del confronto (10 minuti)
      • Stabilire 4 regole operative: niente insulti, parlo di me non accuso te, no interruzioni, tempi uguali.
        • Cosa si intende per: “parlo di me non accuso te”
          • Esempio 01: “Io mi sento confuso quando parliamo tutti insieme, perché non capisco. Ti chiedo di alzare la mano.”
          • Esempio 02: “Io mi innervosisco quando vengo interrotto, perché perdo l’idea. Ti chiedo di farmi finire.”
      • Decidere la condizione di sicurezza: se non è un buon momento, si prevede un time-out.
  4. Definizione del problema (15 minuti)
    • Ogni gruppo formula 1 “frase problema” chiara e neutra (max 20 parole).
    • Esempio: “Nel gruppo di laboratorio c’è disaccordo sulla divisione dei compiti e sui tempi di consegna”.
  5. Condivisione e feedback (10 minuti)
    • Ogni gruppo legge la frase. Feedback degli altri: è chiara? è neutra? evita accuse?

Lista elementi per la valutazione formativa

  • Chiarezza della frase problema.
  • Distinzione corretta fatti/interpretazioni.
  • Qualità delle regole proposte.
  • Partecipazione e rispetto dei turni.
  • Sintesi finale.

Buon lavoro 🙂

Qualcomm acquisisce Arduino e presenta UNO Q: AI e Linux nel formato UNO

Comunicato importante per la comunità Arduino

Qualcomm Technologies, Inc. ha reso noto di aver raggiunto un accordo per acquisire Arduino, riferimento mondiale nell’hardware e software open-source. L’operazione accelera la strategia di Qualcomm di mettere le proprie tecnologie edge a disposizione degli sviluppatori. L’iniziativa si aggiunge alle recenti integrazioni di Edge Impulse e Foundries.io, delineando una piattaforma edge full-stack che copre hardware, software e servizi cloud. La chiusura resta soggetta al via libera delle autorità e alle consuete condizioni di closing.

La combinazione tra elaborazione, grafica, computer vision e AI di Qualcomm e la semplicità, accessibilità e community di Arduino promette di moltiplicare la produttività degli sviluppatori nei diversi settori. Arduino manterrà impostazione open e spirito comunitario, aprendo al contempo a un piattaforma completa per lo sviluppo moderno, con UNO Q come primo tassello.

Arduino conserverà brand, strumenti e missione in modo indipendente e continuerà a supportare microcontrollori e microprocessori provenienti da più fornitori. Con l’ingresso nella famiglia Qualcomm, gli oltre 33 milioni di utenti attivi della community avranno accesso allo stack tecnologico dell’azienda e alla sua presenza globale. Start-up, aziende, professionisti, scuole e maker potranno prototipare e validare più in fretta, con un percorso verso il mercato supportato dalle tecnologie Qualcomm e da un ecosistema di partner esteso.

Arduino UNO Q

UNO Q è una single board di nuova generazione con architettura a “doppio cervello”: un microprocessore compatibile Debian Linux accanto a un microcontrollore per il controllo in tempo reale. Basata su Qualcomm Dragonwing™ QRB2210, la scheda è pensata per visione e audio con AI reattivi al contesto, dai sistemi smart home evoluti all’automazione industriale. L’ambizione è renderla lo strumento di riferimento per ogni sviluppatore: versatile, accessibile e adatta a un apprendimento continuo.

Oltre alla piena compatibilità con Arduino IDE e con il classico ecosistema UNO, UNO Q è la prima scheda Arduino supportata da Arduino App Lab, il nuovo IDE integrato che unifica i flussi RTOS, Linux, Python e AI per accelerare sviluppo e distribuzione. App Lab è open-source e progettato per ideare, prototipare e scalare rapidamente soluzioni AI fino alla produzione. L’integrazione nativa con Edge Impulse velocizza l’intero ciclo di vita dei modelli—dalla raccolta di dati reali al tuning e all’ottimizzazione—per casi d’uso come rilevamento di persone/oggetti, anomaly detection, classificazione immagini, riconoscimento suoni ambientali e keyword spotting.

Dichiarazioni

Nakul Duggal (Group GM, Automotive, Industrial & Embedded IoT, Qualcomm Technologies, Inc.):

“Con Foundries.io, Edge Impulse e ora Arduino, acceleriamo la nostra visione di rendere accessibili all’ecosistema globale degli sviluppatori le nostre tecnologie di calcolo e IA più avanzate. Unendo l’ethos open-source di Arduino al portafoglio di Qualcomm, milioni di sviluppatori potranno creare soluzioni intelligenti più rapidamente ed efficientemente, con un chiaro percorso alla commercializzazione.”

Fabio Violante (CEO, Arduino):

“La collaborazione con Qualcomm ci permette di potenziare il nostro impegno su accessibilità e innovazione. UNO Q è solo l’inizio: vogliamo offrire alla community strumenti potenti per un’IA intuitiva, scalabile e aperta a tutti.”

Massimo Banzi (Co-fondatore, Arduino):

“Da semplicità, economicità e community è nato un movimento che ha cambiato la tecnologia. Entrando in Qualcomm, porteremo strumenti di IA d’avanguardia alle persone, restando fedeli ai nostri valori.”

Evento

Per approfondire, segui la diretta “From Blink to Think” del 7 ottobre 2025 alle 7:00 a.m. PT / 16:00 CEST:
https://www.arduino.cc/from-blink-to-think

Fonte: Qualcomm

Lezione 10 – Corso di Elettronica Creativa con Arduino Sensor Kit

Cenni teorici

Cos’è la pressione atmosferica?

La pressione atmosferica è la forza esercitata dall’aria su ogni unità di superficie. Viene misurata in pascal (Pa) o, più comunemente, in hectopascal (hPa) dove 1 hPa = 100 Pa.

Il sensore BMP280

Il BMP280 è un sensore barometrico assoluto prodotto da Bosch Sensortec. Le sue caratteristiche principali:

  • Campo di misura: 300 – 1100 hPa (≈ -500 m / +9000 m s.l.m.)
  • Accuratezza assoluta tip. ±1 hPa; accuratezza relativa ±0.12 hPa (≈ ±1 m)
  • Interfacce: I²C (fino a 3.4 MHz) e SPI
  • Consumo: 2.7 µA @ 1 Hz in modalità normale
  • Range termico: –40 … +85 °C

Collegamenti

Collegate il cavo Grove tra il connettore del sensore e la porta I²C (qualsiasi) sullo shield.

Installazione libreria

Sicuramente è un’operazione che avete già eseguito, in ogni caso lo ricordo:

  • Arduino IDE > Gestione librerie > cerca “Arduino_SensorKit”.
  • Installate la libreria (include automaticamente LPS22HB, HTS221, OLED, ecc.)

 Esempio 01: Sketch base – Lettura e stampa dati su Serial Monitor

/*
  Prof. Maffucci Michele
  02.10.2025
  LPS22HB del Sensor Kit
  Stampa valori su Serial Monitor
*/

#include <Arduino_SensorKit.h>   // include unico per tutti i sensori

void setup() {
  Serial.begin(9600);
  Pressure.begin();              // inizializza il barometro
}

void loop() {
  // La libreria restituisce:
  // - pressione in pascal
  // - temperatura in gradi Celsius
  // - altitudine in metri rispetto a 1013,25 hPa

float pressionePa  = Pressure.readPressure();
  float temperaturaC = Pressure.readTemperature();
  float altitudineM  = Pressure.readAltitude();

// conversione pa → hPa per leggibilità
  float pressioneHpa = pressionePa / 100.0;

Serial.print(F("Pressione: "));
  Serial.print(pressioneHpa, 2);
  Serial.print(F(" hPa\tTemperatura: "));
  Serial.print(temperaturaC, 2);
  Serial.print(F(" °C\tAltitudine: "));
  Serial.print(altitudineM, 1);
  Serial.println(F(" m"));

delay(1000);
}

Ricordo che, come già indicato nelle precedenti lezioni, la F(…) (maiuscola), inserita all’interno delle Serial.print(), è una macro di Arduino che serve a mettere una stringa letterale in memoria flash (PROGMEM) invece che copiarla nella SRAM al momento della stampa.

Perché è utile utilizzare F

  • Le board come Arduino UNO (AVR) hanno poca SRAM (2 KB).
  • Senza (), ogni stringa tra virgolette ("Pressione: ") viene copiata in SRAM prima di stamparla > spreco di RAM.
  • Con F("Pressione: "), la stringa resta in flash e Serial.print() la legge direttamente da lì > RAM risparmiata.

Come si usa

Funziona con tutte le funzioni che derivano da Print (es. Serial.print, Serial.println, spesso anche display che usano print in stile Arduino):

Serial.print(F("Pressione: "));
Serial.println(F(" hPa"));

Quando usarla

  • Frasi/titoli/menu costanti e ripetute (log su Serial, messaggi di errore, etichette).
  • Con progetti in cui si ha scarsa disponibilità di RAM (UNO/Nano classici) può fare la differenza.

Limiti

  • Non puoi concatenare direttamente elementi come F(“A”) + F(“B”).
  • Evitare di mescolarla con String in modo implicito (meglio stampare pezzi separati).
  • Funzioni come sprintf non leggono da flash; su AVR esistono versioni “_P” (es. sprintf_P) per farlo.

La struttura delle funzioni (Pressure.begin(), Pressure.readPressure(), ecc.) è la stessa mostrata negli esempi ufficiali di Arduino.

 Esempio 02: Lettura e stampa dati su Serial Monitor e display OLED

Abbiamo già visto l’uso del display OLED nella lezione: Lezione 9 – Corso di Elettronica Creativa con Arduino Sensor Kit vediamo ora come mostrare i valori di: pressione, temperatura e altitudine anche sul display OLED.

/*
  Prof. Maffucci Michele
  02.10.2025
  BMP280 - Arduino Sensor Kit
  Stampa valori su Serial Monitor e OLED
*/

#include <Arduino_SensorKit.h>  // include unico per tutti i sensori

void setup() {
  Serial.begin(9600);
  Pressure.begin();  // inizializza il barometro

Oled.begin();
  // Inizializza il display OLED.
  // Fa partire la comunicazione I2C e manda al display la sequenza di avvio.
  // Senza questa riga lo schermo non mostra nulla.

Oled.setFlipMode(true);
  // Ruota il contenuto di 180° (utile se lo vedi capovolto).
  // Se nel tuo caso appare già dritto, puoi mettere false: Oled.setFlipMode(false);

Oled.setFont(u8x8_font_chroma48medium8_r);
  // Sceglie il font (carattere) 8x8.
  // Con un font 8x8 il display 128x64 si comporta come una griglia 16 colonne × 8 righe.
  // Significa che setCursor(colonna, riga) userà numeri tra 0..15 (colonne) e 0..7 (righe).

Oled.clear();
  // Pulisce lo schermo (cancella tutto quello che c’era prima).
}

void loop() {
  // La libreria restituisce:
  // - pressione in pascal
  // - temperatura in gradi Celsius
  // - altitudine in metri rispetto a 1013,25 hPa

float pressionePa = Pressure.readPressure();
  float temperaturaC = Pressure.readTemperature();
  float altitudineM = Pressure.readAltitude();

// conversione pa → hPa per leggibilità
  float pressioneHpa = pressionePa / 100.0;

// --- Intestazione ---

Oled.setCursor(0, 0);             // colonna 0, riga 0
  Oled.println("STAZIONE METEO");   // stampa la stringa e va a capo
  Oled.println("P - Pressione");    // stampa la stringa e va a capo
  Oled.println("T - Temperatura");  // stampa la stringa e va a capo
  Oled.println("A - Altitudine");   // stampa la stringa e va a capo

Oled.setCursor(0, 5);         // colonna 0, riga 2
  Oled.print("P: ");            // stampa la stringa P:
  Oled.print(pressioneHpa, 2);  // stampa valore della pressione con 2 numeri decimali

Oled.setCursor(0, 6);         // colonna 0, riga 3
  Oled.print("T: ");            // stampa la stringa T:
  Oled.print(temperaturaC, 2);  // stampa valore della temperatura con 2 numeri decimali
  Oled.refreshDisplay();

Oled.setCursor(0, 7);        // colonna 0, riga 4
  Oled.print("A: ");           // stampa la stringa A:
  Oled.print(altitudineM, 2);  // stampa valore dell'altitudine con 2 numeri decimali
  Oled.refreshDisplay();

// Aggiorna fisicamente il display (altrimenti potresti non vedere le modifiche).
  delay(60);

Serial.print(F("Pressione: "));
  Serial.print(pressioneHpa, 2);
  Serial.print(F(" hPa\tTemperatura: "));
  Serial.print(temperaturaC, 2);
  Serial.print(F(" °C\tAltitudine: "));
  Serial.print(altitudineM, 1);
  Serial.println(F(" m"));

delay(1000);
}

Buon Coding a tutti 🙂

Progettare bene, programmare meglio: pseudocodice e diagrammi per sistemi elettronici – lezione 4/5


Ripasso di inizio anno – appunti per la classe.

Nella lezione precedente abbiamo capito che cos’è lo pseudocodice e perché ci aiuta a trasformare problemi della vita quotidiana in passi ordinati, fatti di input, decisioni e azioni. Lo abbiamo usato per pianificare una routine del mattino, un “pomodoro” di studio, uno “zaino intelligente”: esempi senza hardware, ma già con la testa da progettisti.

Oggi facciamo un passo in più: useremo lo stesso modo di pensare per progettare sistemi elettronici con Arduino. Tradurre “ciò che deve accadere” in uno pseudocodice chiaro e verificabile ci farà risparmiare tempo quando passeremo alla codifica in C/C++.

Vedremo in questa lezione come:

  • descrivere il comportamento di un sistema (sensori, attuatori, tempi, soglie) prima di scrivere codice;
  • organizzare lo pseudocodice in sezioni: costanti e pin, variabili di stato, inizializzazione, loop principale, funzioni;
  • riconoscere e usare pattern ricorrenti da laboratorio: lettura sensori, debounce, timer con millis(), macchina a stati semplici;
  • migliorare la qualità del vostro pseudocodice: nomi significativi, commenti utili, blocchi brevi, casi limite previsti;

L’obiettivo pratico è quello di fornire uno schema eseguibile del vostro sistema, uno pseudocodice che, riga per riga, si traduce in istruzioni Arduino.

Vediamo come fare.

Vi ricordo che in laboratorio non “giochiamo con led e fili”: impariamo a progettare sistemi.
Ogni sistema ha ingressi (sensori), uscite (attuatori), stati, soglie, tempi e condizioni di errore, pertanto mettere tutto in ordine prima di codificare significa:

  • sapere cosa misurare e quando;
  • chiarire quando intervenire (condizioni);
  • evitare loop confusi e delay() ovunque (inizio a dirvi che il delay è il male assoluto 🙂 );
  • testare in modo mirato (so quali valori provo e che output mi aspetto);

Quindi il risultato quale sarà?

  • Meno frustrazione;
  • meno “perché non va?”;
  • più tempo per capire.

Le fasi di lavoro saranno le seguenti:

  • progettazione: partiremo dal comportamento desiderato e lo scriveremo in pseudocodice, a blocchi.
  • traduzione: mapperemo ogni blocco in istruzioni Arduino (Serial, pinMode, digitalRead/Write, analogRead, map, millis, ecc.);
  • verifica: controlleremo che i casi limite siano previsti (pulsante che rimbalza, soglia ballerina, time-out, errori di misura);
  • codifica: solo alla fine andremo sull’IDE Arduino.

Per semplificare la fase di progettazione di seguito trovate alcune regole di base molto semplici che consiglio di trasformare in un foglio di riferimento da aggiungere all’inizio del quadernone.

Regole di base

  • scrivi una istruzione per riga;
  • usa i due punti dopo le parole chiave (SE:, PER:, MENTRE:, FUNZIONE:);
  • indenta (vai a capo e rientra) quello che sta “dentro” ad un blocco;
  • metti commenti con // per spiegare.

Esempio di forma di scrittura codice:

SE (condizione) ALLORA:
    fai questa cosa
ALTRIMENTI:
    fai quest’altra

Negli anni passati avete già programmato, ma poiché ho notato qualche disordine e dimenticanza di seguito vi elenco le strutture di base in pseudocodice che useremo come base di partenza, le scrivo io, le analizzeremo e poi userete questi blocchi come mattoncini lego per scrivere lo pseudocodice di un sistema.

Input / Output

LEGGI nome
SCRIVI "Ciao, " + nome

Variabili

imposta eta a 13
imposta temperatura a 21.5

Scelte (IF)

SE (eta >= 18) ALLORA:
    SCRIVI "Maggiorenne"
ALTRIMENTI:
    SCRIVI "Minorenne"

Ripetizioni (LOOP)
Per numero di volte:

PER i da 1 a 5:
    SCRIVI i

Finché una condizione è vera

imposta numero a 1
MENTRE (numero <= 10):
    SCRIVI numero
    numero = numero + 1

Funzioni (blocchi riutilizzabili)

FUNZIONE somma(a, b):
    RITORNA a + b

SCRIVI somma(3, 4)  // stampa 7

Liste (array) piccole

imposta voti a [7, 8, 6, 9]
per ogni v in voti:
    SCRIVI v

Nota sullo stile dei commenti

E’ importante commentare e saper commentare, ne abbiamo già parlato, ma credo sia meglio ribadirlo:

usare nomi chiari: “contaStudenti” è meglio di “c”, ricorda di usare la forma camelcase;
commenta le parti importanti:

// aggiorno il punteggio
punteggio = punteggio + 10

Usa un’idea per riga: corto e leggibile.

Errori comuni

3 errori che ritrovo sempre nelle correzioni delle esercitazioni, sia nello scrivere lo pseudocodice che il codice:

  • dimenticare di aggiornare le variabili nei cicli > il ciclo non finisce mai.
  • usare = invece di == nelle condizioni (in pseudocodice teneteli distinti);
  • non indentare: diventa confuso capire cosa sta dentro un IF o un ciclo.

Qualche esempio pratico

Pari o dispari

LEGGI n
SE (n % 2 == 0) ALLORA:
    SCRIVI "Pari"
ALTRIMENTI:
    SCRIVI "Dispari"

Massimo tra 3 numeri

LEGGI a, b, c
imposta max a a
SE (b > max) ALLORA: max = b
SE (c > max) ALLORA: max = c
SCRIVI "Massimo = " + max

Conta quanti voti ≥ 6

LEGGI N
imposta cont a 0

PER i da 1 a N:
    LEGGI voto
    SE (voto >= 6) ALLORA:
        cont = cont + 1

SCRIVI "Promossi: " + cont

Nella prossima lezione vedremo come passare dallo pseudocodice allo sketch Arduino.

Buon pseudocodice a tutti 🙂

Arduino Plate v03 – Base di sperimentazione compatta, modulare e senza viti

La nuova platea per Arduino UNO R3 e breadboard: più piccola, stampabile su piatti 180×180 mm, con supporto a slitta e contenitore breadboard ad incastro. Sorgenti 3D e laser inclusi.

Questa platea nasce dal bisogno quotidiano di avere una base di sperimentazione ordinato, riutilizzabile e accessibile per le attività in laboratorio.
Dopo la v02 che è stata utilizzata da diversi colleghi in altri istituti, ho raccolto le osservazioni dei miei studenti e quelle degli insegnanti ed ho realizzato l’Arduino Plate v03: stessa filosofia e credo più pratica.

In alcune classi l’assemblaggio è a tutti gli effetti attività di laboratorio; per questo ho organizzato i passaggi in modo sequenziale e completo. I lettori “più maker” non si sorprendano della presenza di istruzioni di base: con i più giovani è fondamentale non dare nulla per scontato.

Attualmente sto utilizzando questa Plate come la mia classe 5 Elettronica su cui svolgo attività di  Laboratorio di Sistemi Elettronici, ma verrà utilizzata da altri colleghi dell’indirizzo.

Caratteristiche

  • Compatta: il layout è stato ripensato per stare su piatti piccoli 180×180 mm (anche stampanti entry-level).
  • Zero viti (se volete): la UNO R3 e la R4 scorrono e si bloccano in un supporto a slitta; nessun cacciavite per montare/smontare.
  • Breadboard non incollata: alloggia in un contenitore ad incastro, esce e rientra ed è assicurata mediante uno spessore.
  • Modulare: restano disponibili fori/slot per fissare piccole schede o sensori aggiuntivi.
  • Opzione viti: se preferite, potete comunque fissare Arduino con viti.

Cosa condivido

  • Sorgenti 3D (STL)
  • Sorgenti laser (PDF) + piccoli componenti stampati in 3D
  • Istruzioni di stampa/taglio e montaggio
  • Suggerimenti didattici per l’uso in classe

Download include:  

  • STL (stampa 3D, 4 pezzi)
  • PDF (taglio laser, 3 pezzi)

Per prelevare i file seguire il link su: Thingiverse

Se replicate oppure adattate il progetto, se puoi citami e condividi le tue varianti: è così che cresce la cultura Maker. 🙂

Componenti del progetto

Versione A – Solo stampa 3D (4 elementi)

  1. Base forata (layout compatto)
  2. Supporto a slitta per Arduino UNO R3
  3. Contenitore breadboard (per breadboard 830 punti)
  4. Clip/fermo

Versione B – Ibrida laser + 3D (3 elementi laser + 3 elementi 3D)

  • Laser: base + cornice + pannello superiore
  • 3D: supporto a slitta UNO, contenitore breadboard, piccoli distanziali/clip

Gli unici elementi da incollare (con nastro biadesivo) sono:  

  • Base Arduino (supporto a slitta) sulla platea
  • Contenitore breadboard sulla platea  
  • Tutto il resto resta smontabile.

Assemblaggio (passo-passo)

  1. Prepara la base (stampa o laser).
  2. Applica il biadesivo sotto al supporto a slitta e posizionalo sulla base.
  3. Inserisci Arduino UNO R3 nella slitta: infila la scheda e spingila fino a battuta; verifica che USB e jack restino comodi.
  4. Fissa il contenitore breadboard con biadesivo nella sede dedicata; inserisci la breadboard a incastro.
  5. (Opzionale) Usa viti nei fori passanti dedicati se preferisci un montaggio tradizionale o permanente.

Obiettivo (che consiglio): non vincolare in modo definitivo gli apparati alla base, per poterli riusare in mille attività.

Per quanto riguarda la versione da tagliare a laser, l’involucro della breadboard viene fissata a filo della base, una volta incollato procedete con l’involucro dell’Arduino ed utilizzate come distanziale lo spessore che verrà incollato sotto la breadboard, in questo modo sarete certi che non fisserete storta la base dell’Arduino.

Come ultima fase procedete con l’incollare gli spessori, il più stretto da fissare in prossimità del manico e l’altro al di sotto della breadboard, nell’immagine e nel video potete vedere come sono stati fissati.

Buon Making a tutti 🙂