Ripasso di inizio anno – appunti per la classe.
Di seguito un mini vocabolario, come sempre stampatelo e mettetelo nel tuo quadernone (alcune cose le abbiamo viste anche nella lezione precedente):
Useremo un dialetto semplice.
- Una istruzione per riga.
- Parole chiave in MAIUSCOLO e con i due punti
:quando aprono un blocco:SE … ALLORA: … ALTRIMENTI:MENTRE (condizione):PER i da A a B:FUNZIONE nome(parametri): RITORNA valore
- Indentazione (rientro) di 2–4 spazi per il contenuto dei blocchi.
- Commenti: usa
//all’inizio della riga. - Nomi chiari per variabili e costanti:
sogliaLuce,tempoGiallo,pinLed.
Mini-vocabolario
IMPOSTA x a 10: assegna un valoreLEGGI x: prendi un input (da Serial o da sensore)SCRIVI …: stampa (su Serial o su un display)ATTENDI 500 ms: pausaESCI DAL CICLO: interrompiMENTREoPER- OperatorI:
==,!=,<,>,>=,<=,AND,OR,NOT
Mappa mentale
| Pseudocodice | Arduino (C/C++) |
|---|---|
IMPOSTA x a 10 |
int x = 10; oppure x = 10; |
LEGGI da Serial |
parseInt()/readStringUntil('\n') |
LEGGI digitale pin |
digitalRead(pin) |
LEGGI analogico pin |
analogRead(pin) |
SCRIVI su Serial |
Serial.print()/println() |
ACCENDI LED |
digitalWrite(pin, HIGH) |
SPEGNI LED |
digitalWrite(pin, LOW) |
ATTENDI t ms |
delay(t) |
PER i da 1 a N: |
for (int i=1; i<=N; i++) { ... } |
MENTRE (condizione): |
while (condizione) { ... } |
SE / ALTRIMENTI |
if (...) { ... } else { ... } |
FUNZIONE |
tipo nome(params){...} |
RITORNA |
return |
Funzioni di aiuto per leggere dal Monitor Seriale
Blocchi riutilizzabili
// ---------------------------
// Aiuti per I/O seriale
// ---------------------------
// Legge un intero dalla Serial (es.: 42, -17).
// Attende che ci siano dati disponibili, usa parseInt()
// e poi "pulisce" il buffer fino al newline '\n' per preparare
// la prossima lettura.
int leggiInt() {
// Attende finché il buffer seriale è vuoto.
// Serial.available() restituisce quanti byte sono pronti da leggere.
while (!Serial.available()) {
// ciclo di attesa attivo: resta qui finché non arriva almeno 1 byte
}
// parseInt():
// - salta automaticamente spazi e caratteri non numerici iniziali;
// - legge opzionalmente il segno (-);
// - si ferma quando incontra un separatore (es. spazio, '\n', ecc.)
// - rispetta Serial.setTimeout(): se i numeri arrivano "a pezzi", attende fino al timeout.
int v = Serial.parseInt();
// Dopo parseInt possono essere rimasti caratteri nel buffer
// (ad es. l'utente ha premuto Invio, quindi c'è '\n' o anche "\r\n").
// Questo while consuma tutto ciò che c'è fino a trovare '\n' e poi esce,
// in modo da "allineare" la prossima lettura all'inizio della riga seguente.
while (Serial.available()) {
// Legge un carattere dal buffer
if (Serial.read() == '\n') break; // esce quando trova il newline
// Nota: se volessi trattare anche '\r' come fine riga su sistemi Windows,
// potresti controllare anche '\r' (carriage return).
}
// Restituisce il valore intero letto.
return v;
}
// Legge una riga di testo fino al newline '\n' e la restituisce come String.
// Esempio di input: "ciao mondo\n" -> "ciao mondo" (senza newline né spazi finali).
String leggiLinea() {
// Attende che arrivi almeno un byte.
while (!Serial.available()) {
// attesa attiva
}
// Legge i caratteri fino al delimitatore '\n' (newline).
// Il newline non viene incluso nella String risultante.
String s = Serial.readStringUntil('\n');
// trim():
// - rimuove spazi iniziali/finali, tab e ritorni a capo residui.
// - Utile se su alcune piattaforme l'invio produce "\r\n" (Windows):
// readStringUntil('\n') rimuove '\n', ma può restare '\r' in coda; trim() lo elimina.
s.trim();
// Restituisce la riga "pulita".
return s;
}
Codice senza commenti da copiare ed incollare:
// ——— Aiuti per I/O seriale ———
int leggiInt() {
while (!Serial.available()) {}
int v = Serial.parseInt();
while (Serial.available()) {
if (Serial.read() == '\n') break;
}
return v;
}
String leggiLinea() {
while (!Serial.available()) {}
String s = Serial.readStringUntil('\n');
s.trim();
return s;
}
Esempi guidati pseudocodice > sketch Arduino
Esempio 01 – Saluto con nome (solo Serial)
Scopo: input/output base, variabili stringa.
Pseudocodice – esempio 01
SCRIVI "Come ti chiami?" LEGGI nome SCRIVI "Ciao, " + nome + "!"
Arduino – esempio 01 – con commenti
void setup() {
Serial.begin(9600); // Inizializza la seriale a 9600 baud (Monitor Seriale deve avere lo stesso valore).
while (!Serial) { ; } // Attende che la porta seriale sia pronta (utile su schede con USB "native", es. UNO R4).
// Su UNO R3 spesso non serve, ma non fa danni.
Serial.println("Come ti chiami?"); // Messaggio iniziale: l’utente vede la richiesta nel Monitor Seriale.
Serial.setTimeout(60000); // Imposta il "tempo massimo di attesa" a 60 s per funzioni come readStringUntil/parseInt.
// Se l’utente impiega tempo a digitare, la lettura aspetta fino a 60 s prima di rinunciare.
}
void loop() {
String nome = leggiLinea(); // Legge una riga di testo inserita dall’utente fino al tasto Invio (newline '\n').
// Esempio: se scrivo "Michele" e premo Invio, nome = "Michele".
Serial.print("Ciao, "); // Stampa senza andare a capo...
Serial.print(nome); // ...stampa il nome letto...
Serial.println("!"); // ...e chiude la riga con il punto esclamativo + newline.
while (true) {} // Ferma il programma qui (loop infinito).
// Serve per NON chiedere nuovamente il nome in un ciclo senza fine.
// Se vuoi che ripeta la domanda, rimuovi questa riga.
}
Arduino – esempio 01 – senza commenti
void setup() {
Serial.begin(9600);
while (!Serial) {;}
Serial.println("Come ti chiami?");
Serial.setTimeout(60000);
}
void loop() {
String nome = leggiLinea();
Serial.print("Ciao, ");
Serial.print(nome);
Serial.println("!");
while (true) {} // fine
}
Esercizio aggiuntivo: chiedi anche l’età e rispondi “Sei maggiorenne/minorenne”.
Esempio 02 – Blink (LED lampeggiante)
Collegamenti: LED con resistenza su pin 13 (o usa quello onboard).
Pseudocodice – esempio 02
IMPOSTA pinLed a 13
IMPOSTA periodo a 500 ms
MENTRE (vero):
ACCENDI LED
ATTENDI periodo
SPEGNI LED
ATTENDI periodo
Arduino – esempio 02
const int pinLed = 13;
const int periodo = 500;
void setup() {
pinMode(pinLed, OUTPUT);
}
void loop() {
digitalWrite(pinLed, HIGH);
delay(periodo);
digitalWrite(pinLed, LOW);
delay(periodo);
}
Esercizio aggiuntivo: leggi periodo da Serial.
Esempio 03 – Pulsante accende/spegne LED
Collegamenti: pulsante su pin 2, modalità INPUT_PULLUP; LED su pin 8.
Nota: il pulsante chiude a GND (premuto = LOW).
Pseudocodice – esempio 03
IMPOSTA statoLed a SPENTO
MENTRE (vero):
LEGGI pulsante
SE (pulsante premuto) ALLORA:
ATTENDI 20 ms // anti-rimbalzo semplice
SE (ancora premuto) ALLORA:
inverti statoLed
applica stato al LED
ATTENDI rilascio
Arduino – esempio 03
const int pinBtn = 2;
const int pinLed = 8;
bool statoLed = false;
void setup() {
Serial.begin(9600);
pinMode(pinBtn, INPUT_PULLUP);
pinMode(pinLed, OUTPUT);
}
void loop() {
if (digitalRead(pinBtn) == LOW) { // premuto
delay(20); // debounce base
if (digitalRead(pinBtn) == LOW) {
statoLed = !statoLed; // toggle
digitalWrite(pinLed, statoLed ? HIGH : LOW);
// Attendi rilascio
while (digitalRead(pinBtn) == LOW) {}
delay(20);
}
}
}
Esercizio aggiuntivo: Estensione: stampa su Serial “ON/OFF” ad ogni pressione.
Esercizi
Esercizio 01 – Potenziometro > luminosità (PWM)
Obiettivo: Regolare mediante potenziometro l’intensità luminosa del LED.
Collegamenti: potenziometro su A0; LED su pin PWM 9.
Esercizio 02 – LED ON per 3 secondi quando premo il pulsante
Obiettivo: premo il pulsante > il LED rimane acceso per 3 secondi > poi si spegne.
Evitare ripetizioni mentre si tiene premuto (debounce base).
Componenti & Collegamenti
- 1 × LED + 1 × resistenza (220–330 Ω) su pin 8 → GND
- 1 × pulsante su pin 2 con INPUT_PULLUP (l’altro capo del pulsante a GND)
Esercizio 03 — LDR: accendi il LED quando è buio
Obiettivo: leggo la luce con una LDR. Se il valore è sotto una soglia (buio), accendo il LED; altrimenti lo spengo. Stampo i valori su Serial.
Componenti & Collegamenti
- LDR in partitore su A0 (esempio: 5V — LDR — A0 — resistenza 10 kΩ — GND)
- LED + resistenza su pin 9 → GND
Esercizio 04 – Potenziometro > luminosità LED (PWM)
Obiettivo: con il potenziometro regolo la luminosità del LED usando analogWrite (PWM).
Componenti & Collegamenti
- Potenziometro 10 kΩ su A0 (estremi a 5V e GND, cursore ad A0)
- LED + resistenza su pin ~9 (pin PWM) > GND
Buon Coding a tutti 🙂
