Archivi categoria: arduino

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 11 – Corso di Elettronica Creativa con Arduino Sensor Kit

Lascia una risposta

Accelerometro

L’accelerometro del Sensor Kit è un “sensore di movimento” a tre assi (X, Y, Z) capace di misurare come cambia la velocità di un oggetto nello spazio. Anche quando è fermo, l’accelerometro non rileva “zero accelerazione” in quanto misura la gravità terrestre, circa 1 g (≈ 9,81 m/s²). Questa caratteristica è utilissima perché ci permette sia di capire se e quanto ci stiamo muovendo, sia di stimare l’inclinazione del modulo rispetto alla verticale. In pratica: se appoggio la scheda piatta sul banco, il valore lungo Z sarà vicino a 1 g; se lo incliniamo, la gravità si “ridistribuisce” tra X e Y e possiamo ricavare l’angolo di inclinazione.

Con i dati che fornisce l’accelerometro possiamo fare molte cose: visualizzare scosse e vibrazioni (come un mini sismografo), creare un avviso di caduta, progettare giochi di equilibrio o semplicemente tracciare i movimenti sulla Serial Plotter. In questa lezione impareremo a leggere le tre componenti, a filtrare il rumore e a trasformare quei numeri in azioni concrete (LED, buzzer, messaggi su OLED).

Un briciolo di teoria

L’accelerometro misura accelerazioni lungo X, Y, Z e come dicevo sopra, da fermo “vede” la gravità (~1 g ≈ 9,81 m/s²).

Il modulo del vettore accelerazione è:

Con il dispositivo quasi fermo, possiamo stimare l’inclinazione rispetto alla verticale usando solo la gravità:

che rappresenta l’angolo rispetto all’asse Z (in gradi).

Caratteristiche tecniche (per i più esperti)

Tipo sensore: MEMS accelerometro triassiale digitale.
Interfacce: I²C e SPI digitali (il modulo Grove è normalmente usato in I²C sul Sensor Kit).
Indirizzo I²C: di default 0x19, commutabile a 0x18 (pin SA0/SDO a GND).
Campo di misura (full-scale): ±2 g, ±4 g, ±8 g, ±16 g (selezionabile via registro).
Risoluzione dati: uscita fino a 16-bit; modalità operative low-power/normal/high-resolution (fino a 12-bit effettivi).
Frequenza di campionamento (ODR): da 1 Hz fino a 5.3 kHz (a seconda della modalità).
Funzioni integrate:
- 2 generatori di interrupt programmabili (motion, free-fall, wake-up).
- Rilevamento orientamento 6D/4D, self-test, FIFO 32 campioni.
Alimentazione (chip): 1.71–3.6 V; consumo molto basso (fino a ~2 µA in ultra-low-power). Il modulo Grove è compatibile 3 V / 5 V.
Intervallo di temperatura operativa: −40 °C … +85 °C.

Informazioni utili per l’uso nell’Arduino Sensor Kit

Con la libreria Arduino_SensorKit.h leggete le tre componenti con Accelerometer.readX() / readY() / readZ(); i valori restituiti sono interpretati in g (gravità ≈ 1 g a riposo).
Il modulo Grove usato nel Sensor Kit documenta esplicitamente indirizzi I²C, range e compatibilità 3V/5V, utile se sorgono conflitti su bus I²C o serve cambiare indirizzo.

Collegamenti

Per quanto riguarda i collegamenti è sufficiente connettere il sensore ad uno degli ingressi I²C della Base Shield.

Esempio 01 – Lettura accelerometro 3 assi

/*
  Prof. Maffucci Michele
  02.10.2025
  Lettura accelerometro 3 assi – Arduino Sensor Kit
*/

#include <Arduino_SensorKit.h>   // Libreria unica per i moduli del Sensor Kit

const unsigned long intervalloMs = 500;  // intervallo tra una stampa e la successiva

void setup() {
  // Inizializzazione porta seriale per inviare i dati al PC
  Serial.begin(9600);

  // ATTENZIONE:
  // while(!Serial); serve ad ASPETTARE che il monitor seriale sia stato aperto
  // (utile sulle schede con USB nativa, esempio: Arduino UNO R4 WiFi, Leonardo, MKR).
  // Così non "perdi" le prime stampe.
  // Su schede senza USB nativa non è necessario e puoi rimuoverlo.
  while (!Serial) { ; }

  // Avvio dell'accelerometro a 3 assi
  Accelerometer.begin();
}

void loop() {
  // Lettura delle tre componenti di accelerazione (in g)
  float accelX = Accelerometer.readX();  // Asse X
  float accelY = Accelerometer.readY();  // Asse Y
  float accelZ = Accelerometer.readZ();  // Asse Z

  // Stampa in formato semplice: x:..  y:..  z:..
  Serial.print("x: "); 
  Serial.print(accelX, 3);   // 3 decimali per leggibilità
  Serial.print("  ");

  Serial.print("y: "); 
  Serial.print(accelY, 3);
  Serial.print("  ");

  Serial.print("z: "); 
  Serial.println(accelZ, 3);

  delay(intervalloMs);
}

Esempio 02: Accelerometro – Stampa su Serial Monitor e display OLED

Visualizzazione delle componenti x, y e z dell’accelerazione su Serial Monitor e display OLED

/*
  Prof. Maffucci Michele
  02.10.2025
  Lettura accelerometro 3 assi – Arduino Sensor Kit
  Stampa su Serial Monitor e display Oled
*/

#include <Arduino_SensorKit.h>  // Libreria unica per i moduli del Sensor Kit

const unsigned long intervalloMs = 500;  // intervallo tra una stampa e la successiva

void setup() {
  // Inizializzazione porta seriale per inviare i dati al PC
  Serial.begin(9600);

  // ATTENZIONE:
  // while(!Serial); serve ad ASPETTARE che il monitor seriale sia stato aperto
  // (utile sulle schede con USB nativa, esempio: Arduino UNO R4 WiFi, Leonardo, MKR).
  // Così non "perdi" le prime stampe.
  // Su schede senza USB nativa non è necessario e puoi rimuoverlo.
  while (!Serial) { ; }

  // Avvio dell'accelerometro a 3 assi
  Accelerometer.begin();
  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() {
  // Lettura delle tre componenti di accelerazione (in g)
  float accelX = Accelerometer.readX();  // Asse X
  float accelY = Accelerometer.readY();  // Asse Y
  float accelZ = Accelerometer.readZ();  // Asse Z

  // Stampa in formato semplice: x:..  y:..  z:..
  Serial.print("x: ");      // stampa la stringa x: su Serial Monitor
  Serial.print(accelX, 3);  // 3 decimali per leggibilità
  Serial.print("  ");

  Serial.print("y: ");      // stampa la stringa y: su Serial Monitor
  Serial.print(accelY, 3);  // 3 decimali per leggibilità
  Serial.print("  ");

  Serial.print("z: ");        // stampa la stringa z: su Serial Monitor
  Serial.println(accelZ, 3);  // 3 decimali per leggibilità

  Oled.setCursor(0, 0);           // colonna 0, riga 0
  Oled.println("ACCELERAZIONE");  // stampa la stringa e va a capo

  Oled.setCursor(0, 2);   // colonna 0, riga 2
  Oled.print("x: ");      // stampa la stringa x:
  Oled.print(accelX, 3);  // stampa la componente x dell'accelerazione con 3 cifre decimali

  Oled.setCursor(0, 3);   // colonna 0, riga 3
  Oled.print("y: ");      // stampa la stringa y:
  Oled.print(accelY, 3);  // stampa la componente y dell'accelerazione con 3 cifre decimali
  Oled.refreshDisplay();

  Oled.setCursor(0, 4);   // colonna 0, riga 4
  Oled.print("z: ");      // stampa la stringa z:
  Oled.print(accelZ, 3);  // stampa la componente z dell'accelerazione con 3 cifre decimali
  Oled.refreshDisplay();

  delay(intervalloMs);
}

Esempio 03: Accelerometro – Uscita per Serial Plotter (3 curve: X, Y, Z)

Stampa i tre assi con etichette e tab in un’unica riga per campione, in questo modo l’IDE mostra tre curve (X, Y, Z).

/*
  Prof. Maffucci Michele
  02.10.2025
  Accelerometro – Uscita per Serial Plotter (3 curve: X, Y, Z)

  Nota: una riga = un campione; valori etichettati e separati da TAB -> 3 curve nel Plotter.
*/

#include <Arduino_SensorKit.h&gt

const unsigned long periodoCampionamentoMs = 10;  // circa 100 Hz (riduci/aumenta a piacere)

void setup() {
  Serial.begin(115200);
  // Attende l'apertura del Monitor/Plotter Seriali sulle schede con USB nativa
  while (!Serial) { ; }

  Accelerometer.begin();

  // Messaggio di avvio (facoltativo)
  Serial.println("Traccio X,Y,Z (g) - dati GREZZI (nessun filtro)");
}

void loop() {
  // Letture grezze in g
  float x = Accelerometer.readX();
  float y = Accelerometer.readY();
  float z = Accelerometer.readZ();

  // Stampa “label:valore” separati da TAB → il Plotter disegna tre curve
  Serial.print("X:");
  Serial.print(x, 3);
  Serial.print('\t');
  Serial.print("Y:");
  Serial.print(y, 3);
  Serial.print('\t');
  Serial.print("Z:");
  Serial.println(z, 3);

  delay(periodoCampionamentoMs);
}

Versione per esperti

Esempio 04: Accelerometro – Uscita per Serial Plotter (3 curve: X, Y, Z) con filtro passa-basso

Come avete potuto notare nella versione precedente le curve delle tre componenti dell’accelerazione erano seghettate e venivano rappresentate anche piccoli tremolii.

Per evitare questo problema useremo nello sketch che segue un filtro IIR (passa-basso) che smusserà il rumore.

Quali sono i vantaggi nell’utilizzo di un filtro passa basso:

Rumore: piccole variazioni veloci e indesiderate nei dati (tremolio della mano, vibrazioni del banco, disturbi elettrici).
Passa-basso: un filtro che lascia passare i cambiamenti lenti (il “trend” reale del movimento) e attenua i cambiamenti veloci (dovuti al rumore).
IIR (Infinite Impulse Response): significa che l’uscita del filtro dipende sia dal valore attuale sia dall’uscita precedente. In pratica: il filtro “ricorda” un po’ del passato -> è una media mobile esponenziale.

Formule per ogni asse:

uscita_filtrata(t) = α * ingresso(t) + (1−α) * uscita_filtrata(t−1)

α è un numero tra 0 e 1:

α piccolo (es. 0.1) > molto liscio (tanto filtraggio) ma più lento a seguire i cambiamenti.
α grande (es. 0.6) > meno liscio (meno filtraggio) ma più reattivo.

In sintesi:
scegliere α in base al compromesso “più liscio vs più rapido”.

/*
  Prof. Maffucci Michele
  02.10.2025
  Accelerometro - Uscita per Serial Plotter (3 curve: X, Y, Z) con filtro IIS (passa-basso)

  Note:
  - Il Serial Plotter IDE riconosce coppie "etichetta:valore" sulla stessa riga,
    separate da TAB. Ogni riga = un campione nel tempo.
*/

#include <Arduino_SensorKit.h&gt

const unsigned long periodoCampionamentoMs = 10;  // circa 100 Hz
const bool usaFiltro = true;                      // metti false se vuoi i dati grezzi
const float alfa = 0.2;                           // 0..1 (più piccolo = più filtrato)

float xF = 0, yF = 0, zF = 0;  // stati del filtro

void setup() {
  Serial.begin(115200);

  // Serve ad attendere l'apertura del Monitor/Plotter Seriali sulle schede con USB nativa,
  // così non perdete le prime stampe (su UNO "classico" puoi toglierlo senza problemi).
  while (!Serial) { ; }

  Accelerometer.begin();

  // (Facoltativo) riga di "header" informale: non necessaria, ma utile a chi guarda il log
  Serial.println("Pronto: traccio X,Y,Z (g) su Serial Plotter");
}

void loop() {
  // Letture in g
  float x = Accelerometer.readX();
  float y = Accelerometer.readY();
  float z = Accelerometer.readZ();

  if (usaFiltro) {
    // Filtro IIR (passa-basso) molto semplice per smussare il rumore
    xF = alfa * x + (1.0f - alfa) * xF;
    yF = alfa * y + (1.0f - alfa) * yF;
    zF = alfa * z + (1.0f - alfa) * zF;

    // Stampa "label:valore" separati da TAB > tre curve nel Plotter
    Serial.print("X:");
    Serial.print(xF, 3);
    Serial.print('\t');
    Serial.print("Y:");
    Serial.print(yF, 3);
    Serial.print('\t');
    Serial.print("Z:");
    Serial.println(zF, 3);
  } else {
    Serial.print("X:");
    Serial.print(x, 3);
    Serial.print('\t');
    Serial.print("Y:");
    Serial.print(y, 3);
    Serial.print('\t');
    Serial.print("Z:");
    Serial.println(z, 3);
  }

  delay(periodoCampionamentoMs);
}

Analizziamo nel dettaglio la parte del filtro.

xF = alfa * x + (1.0f - alfa) * xF;
yF = alfa * y + (1.0f - alfa) * yF;
zF = alfa * z + (1.0f - alfa) * zF;

xF = alfa * x + (1.0f - alfa) * xF;

x è il dato grezzo appena letto dall’accelerometro sull’asse X.
xF è il dato filtrato (uscita del filtro) per l’asse X.
alfa * x prende una frazione del dato nuovo (quanto “peso” dai alla misura attuale).
(1.0f - alfa) * xF prende una frazione del valore filtrato precedente (la “memoria”).
La somma dei due termini fornisce un valore ammorbidito: meno sensibile ai picchi improvvisi.

Nota sul suffisso f: indica un float letterale (utile per evitare promozioni a double in alcune piattaforme).

yF = alfa * y + (1.0f - alfa) * yF;

Identico ragionamento, ma applicato all’asse Y: nuova misura y + memoria del filtrato yF.
Mantieni alfa uguale sugli assi per coerenza visiva nel Plotter.

zF = alfa * z + (1.0f - alfa) * zF;

Stessa cosa per l’asse Z: la componente verticale (spesso contiene circa 1 g).
Filtrare Z aiuta a vedere meglio oscillazioni lente e a ridurre tremolii.

Qualche nota pratica

Inizializzazione: se impostate xF = yF = zF = 0 all’inizio, i primi campioni possono “salire” gradualmente verso il valore reale (breve transitorio). Se volete partire subito “allineati”, potete inizializzare xF=yF=zF al primo dato letto.
Scelta di alfa:
0.1-0.3 > grafico molto liscio (meno rumore), risposta più lenta.
0.4-0.7 > più reattivo, ma un po’ più “seghettato”.

Buon Coding a tutti 🙂

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

Lascia una risposta

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

2 Repliche

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)

Base forata (layout compatto)
Supporto a slitta per Arduino UNO R3
Contenitore breadboard (per breadboard 830 punti)
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)

Prepara la base (stampa o laser).
Applica il biadesivo sotto al supporto a slitta e posizionalo sulla base.
Inserisci Arduino UNO R3 nella slitta: infila la scheda e spingila fino a battuta; verifica che USB e jack restino comodi.
Fissa il contenitore breadboard con biadesivo nella sede dedicata; inserisci la breadboard a incastro.
(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 🙂

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

Lascia una risposta

Ripasso di inizio anno – appunti per la classe.

Lo pseudocodice è un modo semplice e strutturato di descrivere un algoritmo in lingua naturale (italiano+parole chiave) senza la rigidità della sintassi di un linguaggio di programmazione.
È come scrivere una ricetta: elenchi ingredienti (dati), spieghi i passaggi (istruzioni) e le condizioni (“se… allora…”). Non lo “esegue” il computer, ma lo capiscono persone (docenti, compagni, te stesso domani) e ti guida a tradurre poi tutto in codice (es. Arduino/C++).

Cosa rende utile lo pseudocodice

Chiedere agli studenti di scrivere pseudocodice non è un esercizio di progettazione, ma neanche un modo per semplificare la progettazione del nostro sistema, è un modo che permette di decidere prima che cosa deve accadere, poi si penserà a come scriverlo in un linguaggio di programmazione, nel nostro caso in C/C++ per Arduino.

Possiamo definire lo pseudocodice come ad una lingua ponte: viene compreso sia da chi programma ma anche da chi ancora non programma; detto in altro modo possiamo dire che “mette in fila le idee”, riduce gli errori di distrazione, rende veloce il debug e lascia una traccia chiara e leggibile del progetto.

E’ sicuramente uno strumento inclusivo: abbassa la soglia d’ingresso per chi fatica con la sintassi ed è più abile nel ragionamento.

Nella pratica se so raccontare bene l’algoritmo con verbi chiari (LEGGI, SE, MENTRE, RITORNA), tradurlo in codice diventa un’operazione quasi meccanica.

Avrete intuito che saper scrivere pseudocodice non è solo un’attività di progettazione del software, ma anche un modo per comprendere sistemi complessi che interessano non solo la programmazione ma la nostra vita quotidiana: organizzare lo studio, pianificare un viaggio, andare a scuola, ecc… tutto può essere reso pseudocodice, se vi allenerete a scrivere pseudocodice vi accorgerete di avere maggior percezione di un problema e lo comprenderete meglio.

Sintetizziamo quanto sopra detto con una lista puntata che vi servirà nello studio.

Vantaggi dello pseudocodice

Chiarezza di idee: separate il cosa fare dal come scriverlo in C/C++.
Comunicazione: è una lingua comune tra chi sa e chi non sa ancora programmare, oppure una lingua comune tra persone che serve per comprendere un sistema.
Progettazione top-down: partite dal problema, lo scomponete in sotto-problemi, definite funzioni e responsabilità.
Riduzione errori: se l’algoritmo è corretto in pseudocodice, gli errori in codice molto probabilmente si ridurranno a dettagli sintattici.
Debug più rapido: quando il programma non funziona, si verifica prima la logica (lo pseudocodice), poi la sintassi.
Documentazione: lasciate tracce intelligibili del progetto, quindi ottimo per la relazione di laboratorio.
Valutazione: mostra il processo e non solo il risultato. Un buon pseudocodice rivela le vostre competenze di analisi, decomposizione, gestione dei casi limite (pensate a quanto diventa utile anche durante la prova scritta dell’esame di maturità… ne parlo più avanti)
Inclusione: aiuta chi ha poca dimestichezza con la sintassi a concentrarsi sui concetti fondamentali (input, output, decisioni, cicli, dati).

Perché è importante usarlo nel laboratorio di sistemi elettronici

In laboratorio non scriviamo solo righe di codice: progettiamo sistemi con sensori, attuatori, tempi, soglie e stati.
Lo pseudocodice costringe a dichiarare pin, costanti e variabili di stato, a prevedere debounce, time-out, condizioni di errore, cioè chiarisce il flusso:

inizializzazione > letture > decisioni > azioni

e rivolgendomi agli studenti, vedrete che renderà i test al banco di lavoro più rapidi, nel senso che saprete già quali valori provare e che risposta aspettarmi su ad esempio un LED, buzzer o seriale.

Ritengo che tra i vantaggi più importanti nella realizzazione dello pseudocodice ci sia quella di facilitare il lavoro di gruppo:

ognuno implementa una funzione sapendo dove si inserisce nel flusso generale. Risultato: meno tentativi a vuoto, più tempo speso a capire cosa fa davvero il nostro sistema.

Nelle esercitazioni che svilupperete con Arduino ma in generale con qualsiasi scheda a microcontrollore, c’è sempre un “sistema” da far funzionare: sensori, attuatori, logica, tempi, soglie, stati.

Se scriverete prima lo pseudocodice:

sarete obbligati a dichiarare ingressi (sensori), uscite (attuatori), costanti (soglie, pin), variabili di stato;
sarà più chiaro il flusso: inizializzazione > ciclo principale > gestione eventi > funzioni di servizio;
vi aiuterà a ragionare su casi limite (esempio: debounce, errori di misura, time-out);
diventerete più rapidi nel passaggio alla codifica e nella verifica sperimentale al banco.

In pratica: pseudocodice = “schema funzionale” del vostro impianto in forma testuale.

Pensiamo ora ad un evento che vi coinvolgerà: l’esame di maturità

Sarebbe bello ottimizzare il tempo della prova scritta di sistemi (se questa sarà la materia della seconda prova) ma l’uso dello pseudocodice va bene anche per la progettazione di qualsiasi tipo di prova, anche per strutturare un tema di italiano.
All’orale la commissione potrebbe valutare anche come progettate, quindi non solo se il codice funziona. Saper scrivere su un foglio:

Requisiti > Pseudocodice > Schema I/O > Stralcio di codice > Piano di test

sicuramente comunica metodo, ordine e padronanza… e quindi fate una bella figura 😉

Lo pseudocodice vi aiuta a spiegare le scelte: perché una soglia? perché una macchina a stati? come gestisci i casi limite?
E vi mette al sicuro quando vi chiedono una variazione durante l’orale: se la logica è chiara, sapete subito dove intervenire. È un modo semplice per far vedere che sapete passare dall’idea all’implementazione in modo professionale.

Immaginate poi ad un insegnante che dovrà correggere il vostro compito, avere un buon pseudocodice vi assicuro che lo aiuta 😉

Quindi sintetizzando è molto importante ricordare:

esporre prima lo pseudocodice mette in luce le vostre capacità progettuali;
mostra che sapete astrarre dal codice e motivare le scelte;
facilita domande e risposte: il docente può chiedervi di modificare una parte, ad esempio aggiungere un sensore e voi sapete intervenire nel flusso.

e non ultimo farà pensare: “questa persona è professionale”.

Ora andiamo al nocciolo della questione, vediamo come si fa lo pseudocodice, in realtà vi darò una linea guida, qualche esempio ed esercizi semplici che coinvolgono la vostra vita quotidiana, imparerete in brevissimo tempo.

Quello che scrivo da questo momento in poi dovrebbe essere inserito nelle prime pagine del vostro quaderno, dove andrete ad inserire i riferimenti delle schede che utilizziamo, della sintassi di programmazione ecc…

Nota i miei studenti (da recuperare)

Ricordo che ogni attività di progettazione che farete e consegnerete dovrà includere:

- diagramma di flusso
- pseudocodice
- sketch Arduino commentato in ogni parte
- breve relazione di funzionamento
- eventuale:
  - schema elettrico
  - schema topografico di collegamenti
  - tabella misure
  - grafici
- Sitografia
- Bibliografia

A tal proposito vi mostrerò un format di foglio di lavoro che potrete poi modificare secondo necessità.

Ogni progetto deve essere esposto anche oralmente.

In alcune occasioni vi sarà azione di debate, ovvero un confronto tra gruppi su specifici problemi tecnici da risolvere.

Regole di base

Una istruzione per riga; rientra (indenta) i blocchi.
Parole chiave in MAIUSCOLO: SE, ALTRIMENTI, MENTRE, PER, FUNZIONE, RITORNA, ATTENDI.
Date nomi chiari a variabili e costanti: sogliaLuce, tempoGiallo, pinLedRosso, cioè usiamo la convenzione camelcase che combina più parole in un’unica stringa, scrivendo la prima parola in minuscolo e le parole successive con la loro iniziale maiuscola ad esempio: nomeUtente.
In testa: Pin, Costanti, Variabili. Poi: Inizializzazione, Loop, Funzioni.
Commentate perché fate qualcosa, non scrivete l’ovvio: “sommo 1 al contatore perché ogni impulso accende il led…”

Di seguito un template da copiare ed incollare:

/* Requisito sintetico: cosa deve fare il sistema */

COSTANTI:
    pinLed = ...
    pinBtn = ...
    soglia = ...

VARIABILI:
    stato = ...
    conteggio = ...

INIZIALIZZA:
    configura pin
    azzera conteggi

LOOP PRINCIPALE:
    leggi sensori
    SE (condizione) ALLORA:
        azione
    ALTRIMENTI SE (...) ALLORA:
        altra azione
    ALTRIMENTI:
        default
    aggiorna attuatori
    ATTENDI t ms

FUNZIONI:
    FUNZIONE nome(parametri):
        passi...
        RITORNA valore

La checklist da seguire ASSOLUTAMENTE è questa:

Input/Output identificati? (pin, range, unità)
Costanti definite? (soglie, tempi, limiti)
Stati chiari? (idle, misura, allarme, reset…)
Casi limite previsti? (debounce, isteresi, time-out, valori anomali)
Test plan minimo? (quali valori proverai e cosa ti aspetti di vedere)

Ora facciamo qualche esempio che coinvolge la nostra vita

01 – Sveglia e alzarsi

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Suona sveglia]
    B --> C{Ancora sonno?}
    C -- Si --> D[Attendi 5 minuti]
    D --> B
    C -- No --> E[Alzati dal letto]
    E --> Z[Fine]

Diagramma di flusso

Pseudocodice

RIPETI
  SUONA_SVEGLIA()
  LEGGI risposta // "si" se hai ancora sonno, "no" altrimenti
  SE risposta == "si" ALLORA
     ATTENDI 5 minuti
  ALTRIMENTI
     ESCI DAL CICLO
  FINE SE
FINCHÉ VERO
ALZATI_DAL_LETTO()
SCRIVI "Pronto per iniziare la giornata"

02 – Colazione semplice

Si pone che la scelta sia tra due tipologie di colazione, latte o te, in alternativa bisogna bere acqua.

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Apri cucina]
    B --> C{Hai fame?}
    C -- Si --> D[Scegli bevanda]
    D --> E{Bevanda scelta latte?}
    E -- Si --> F[Prepara latte]
    E -- No --> G[Prepara te]
    F --> H[Mangia colazione]
    G --> H
    C -- No --> I[Bevi acqua]
    H --> Z[Fine]
    I --> Z

Diagramma di flusso

Pseudocodice

APRI_CUCINA()
LEGGI fame // "si" oppure "no"

SE fame == "si" ALLORA
   SCRIVI "Scegli una bevanda"
   LEGGI bevanda // "latte" oppure "te"
   SE bevanda == "latte" ALLORA
      PREPARA_LATTE()
   ALTRIMENTI
      PREPARA_TE()
   FINE SE
   MANGIA_COLAZIONE()
ALTRIMENTI
   BEVI_ACQUA()
FINE SE

SCRIVI "Colazione terminata"

03 – Prepara lo zaino

Diagramma di flusso Mermaid

APRI_DIARIO()
LEGGI listaLibriRichiesti
IMPOSTA zaino = lista_vuota
PER ciascun libro IN listaLibriRichiesti:
   AGGIUNGI libro A zaino
FINE PER

CONTROLLA_ASTUCCIO()

LEGGI mancaQualcosa // "si" oppure "no"
MENTRE mancaQualcosa == "si" FAI
   LEGGI cosaManca
   AGGIUNGI cosaManca A zaino
   LEGGI mancaQualcosa // ricontrolla
FINE MENTRE

SCRIVI "Zaino pronto"

Diagramma di flusso

Pseudocodice

APRI_DIARIO()
LEGGI listaLibriRichiesti
IMPOSTA zaino = lista_vuota
PER ciascun libro IN listaLibriRichiesti:
   AGGIUNGI libro A zaino
FINE PER

CONTROLLA_ASTUCCIO()

LEGGI mancaQualcosa // "si" oppure "no"
MENTRE mancaQualcosa == "si" FAI
   LEGGI cosaManca
   AGGIUNGI cosaManca A zaino
   LEGGI mancaQualcosa // ricontrolla
FINE MENTRE

SCRIVI "Zaino pronto"

04 – Uscire di casa in base al meteo

Si pone che, in funzione del tempo, la scelta sia tra due oggetti alternativi: ombrello o cappellino.

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Leggi meteo]
    B --> C{Pioggia?}
    C -- Si --> D[Prendi ombrello]
    C -- No --> E[Prendi cappellino]
    D --> F[Esci di casa]
    E --> F
    F --> Z[Fine]

Diagramma di flusso

Pseudocodice

LEGGI meteo // "pioggia" oppure "sereno"

SE meteo == "pioggia" ALLORA
   PRENDI_OMBRELLO()
ALTRIMENTI
   PRENDI_CAPPELLINO()
FINE SE

ESCI_DI_CASA()
SCRIVI "Buona giornata"

05 – Zaino intelligente (liste + loop)

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Leggi orarioDelGiorno come elenco di materie]
    B --> C[Inizializza libriNecessari come lista vuota]
    C --> D[Imposta i = 0]
    D --> E[Calcola n uguale a numero di materie]
    E --> F{i minore di n?}

    F -- Si --> G[Prendi materia in posizione i]
    G --> H[Aggiungi materia a libriNecessari]
    H --> I[Incrementa i di 1]
    I --> F

    F -- No --> L[Stampa Metti nello zaino elenco libriNecessari]
    L --> Z[Fine]

Diagramma di flusso

Pseudocodice

LEGGI orarioDelGiorno   // lista, es: ["Mate","Storia","Inglese","Sistemi"]
IMPOSTA libriNecessari a lista vuota

PER ogni materia in orarioDelGiorno:
    AGGIUNGI materia a libriNecessari

SCRIVI "Metti nello zaino: " + libriNecessari

… e magari fate anche la versione per il quaderno e i materiali da portare con voi.

06 – Pomodoro di studio (ciclo + timer)

Visto che adotto questo metodo nella mia vita lavorativa, non potevo non propinare lo pseudocodice della tecnica del pomodoro.

Studiare a blocchi da 25’ con pause da 5’, per 4 cicli.

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Imposta pomodoro = 1]
    B --> C{pomodoro <= 4} C -->|Si| D[Stampa Studia 25 minuti Pomodoro pomodoro]
    D --> E[Attendi 25 minuti]
    E --> F{pomodoro < 4} F -->|Si| G[Stampa Pausa 5 minuti]
    G --> H[Attendi 5 minuti]
    H --> J[Incrementa pomodoro di 1]
    F -->|No| I[Salta pausa]
    I --> J
    J --> C
    C -->|No| K[Stampa Sessione completata]
    K --> Z[Fine]

Diagramma di flusso

Pseudocodice

PER pomodoro da 1 a 4:
    SCRIVI "Studia 25 minuti (Pomodoro " + pomodoro + ")"
    ATTENDI 25 minuti
    SE (pomodoro < 4) ALLORA:
        SCRIVI "Pausa 5 minuti"
        ATTENDI 5 minuti
SCRIVI "Sessione completata!"

Per i miei studenti

Lista degli esercizi che dovrete fare come compito (vi dirò quando):

1. Lavarsi i denti (tempo minimo per lavaggio 2 min).
2. Merenda e soldi (se soldi maggiore di 2€ compro panino, altrimenti porto merenda da casa).
3. Smartphone e batteria (se livello della batteria è inferiore al 20% ricaricare).
4. Spegnere la luce uscendo di casa (tenere conto anche della chiusura con chiavi della porta di casa).
5. Priorità compiti (ordinamento concettuale, ordinare le attività per scadenza e importanza).
6. Vestiti in base al meteo (vestirsi in base al meteo (IF multiplo)).
7. Abitudine acqua (promemoria ciclico, bere 1 bicchiere ogni ora tra le 9 e le 13).
8. Media dei voti e situazione (input + aritmetica. Calcolare media e capire se sei sopra la soglia 6).

Seguiranno altri esercizi.

Nella prossima lezione vedremo come passare dallo pseudocodice ad uno sketch Arduino.

Buon pseudocodice a tutti 😉

Comunicato importante per la comunità Arduino

Arduino UNO Q

Evento

Related posts:

Accelerometro

Un briciolo di teoria

Caratteristiche tecniche (per i più esperti)

Informazioni utili per l’uso nell’Arduino Sensor Kit

Collegamenti

Esempio 01 – Lettura accelerometro 3 assi

Esempio 02: Accelerometro – Stampa su Serial Monitor e display OLED

Esempio 03: Accelerometro – Uscita per Serial Plotter (3 curve: X, Y, Z)

Versione per esperti

Esempio 04: Accelerometro – Uscita per Serial Plotter (3 curve: X, Y, Z) con filtro passa-basso

Related posts:

Regole di base

Nota sullo stile dei commenti

Errori comuni

Qualche esempio pratico

Related posts:

Caratteristiche

Cosa condivido

Componenti del progetto

Assemblaggio (passo-passo)

Related posts:

Cosa rende utile lo pseudocodice

Vantaggi dello pseudocodice

Perché è importante usarlo nel laboratorio di sistemi elettronici

Pensiamo ora ad un evento che vi coinvolgerà: l’esame di maturità

Ora facciamo qualche esempio che coinvolge la nostra vita

01 – Sveglia e alzarsi

02 – Colazione semplice

03 – Prepara lo zaino

04 – Uscire di casa in base al meteo

05 – Zaino intelligente (liste + loop)

06 – Pomodoro di studio (ciclo + timer)

Per i miei studenti

Related posts: