Basi · 11 min di lettura

Capire il codice Arduino: leggere uno sketch riga per riga

Capire il codice Arduino: librerie, pin, setup e loop, funzioni e condizioni if, un esempio spiegato riga per riga e il passaggio a ESP32 e Pico.

Capire il codice Arduino è ciò che distingue chi copia un progetto sperando che funzioni da chi lo rende davvero suo. Quasi tutti gli sketch che trovi in rete, sui libri o che ti passa un amico seguono lo stesso scheletro: in alto le librerie e le definizioni dei pin, in mezzo un setup() che gira una volta sola, sotto un loop() che si ripete all'infinito e, se serve, qualche funzione propria. Una volta riconosciuto questo scheletro, puoi guardare un codice mai visto e dire: "questa riga legge quel pin e, in quel caso, accende quel motore".

In questa guida impari un metodo passo passo per leggere il codice Arduino. Prima conoscerai le parti di uno sketch e il loro compito, poi smonteremo riga per riga il codice di un piccolo cestino il cui coperchio si apre quando avvicini la mano. Vedremo poi come leggere variabili, condizioni e funzioni, come adattare il codice di qualcun altro al tuo circuito e come portare lo stesso codice su un ESP32 e su un Raspberry Pi Pico. Alla fine scoprirai come esercitarti con la scheda "Capire il codice" di BlueGrays.

Scheda Arduino Uno e i suoi pin
Ogni numero di pin nel codice corrisponde a una scritta sulla scheda: la riga const int TRIG_PIN = 9 ti dice che il cavo va nel foro marcato D9.

L'anatomia di uno sketch Arduino

Gli sketch Arduino seguono sempre lo stesso ordine dall'alto in basso. Il compilatore legge il file dall'inizio alla fine, ma la scheda lo esegue in un ordine diverso: prima vengono preparate le dichiarazioni globali, poi setup() gira una volta e infine loop() si ripete finché la scheda è alimentata. La tabella riassume le parti che vedrai aprendo uno sketch e come riconoscerle:

Parte del codiceA cosa serveRiga tipicaCome riconoscerla
CommentiSpiegano il codice, il compilatore li ignora// nota oppure /* ... */Iniziano con //, grigi nell'IDE
LibrerieAggiungono codice già pronto (servo, display, sensore)#include <Servo.h>Iniziano con #, in cima
Definizioni dei pin e costantiDanno un nome ai numeri dei pin e alle soglieconst int LED_PIN = 13;Di solito nomi in MAIUSCOLO
Variabili globali e oggettiDati raggiungibili da qualunque punto del codiceint count = 0; Servo lidServo;Fuori da ogni funzione
setup()Gira una volta all'accensionepinMode(LED_PIN, OUTPUT);void setup() { ... }
loop()Si ripete all'infinito, qui avviene il lavoro veroif (distance < 20) { ... }void loop() { ... }
Funzioni tueRaccolgono un compito che si ripetelong readDistanceCm() { ... }Blocchi separati sopra o sotto loop

Da dove cominciare? Un metodo in cinque passi

  1. Leggi commenti e librerie. Le righe #include svelano l'hardware: Servo.h vuol dire un servo, LiquidCrystal_I2C.h un LCD I2C, DHT.h un sensore di temperatura.
  2. Scrivi i pin su un foglio. Trasforma ogni riga const int o #define in un elenco di collegamenti come "TRIG = D9, ECHO = D10" e confrontalo con il tuo circuito.
  3. Leggi setup(). Qui vedi quali pin sono ingressi e quali uscite, la velocità della seriale e lo stato iniziale della scheda (servo chiuso, LED spento e così via).
  4. Esegui loop() una volta a mano. Scegli un valore del sensore (per esempio 45 cm) e segui il codice riga per riga con quel valore; annota in quale blocco if entri e quale variabile cambia.
  5. Entra nelle funzioni quando serve. Se in loop() vedi una chiamata come readDistanceCm(), prima intuisci dal nome cosa fa, poi apri la funzione per verificarlo.

Sketch di esempio: analisi riga per riga

Per esercitarci abbiamo scelto il codice di un progetto reale: un sensore a ultrasuoni HC-SR04 vede una mano che si avvicina, un servo apre il coperchio e lo richiude tre secondi dopo, nel frattempo si accende un LED e il numero di aperture compare nel monitor seriale. Nello sketch c'è tutto: libreria, costanti, variabile globale, oggetto, setup, loop, condizione e una funzione propria. Dai prima un'occhiata all'insieme, poi lo ripercorriamo riga per riga con la tabella.

C++ (Arduino IDE)
1// Akıllı çöp kutusu: el yaklaşınca kapak açılır / Smart bin: the lid opens when a hand comes close
2#include <Servo.h>                  // servo kütüphanesi / servo library
3
4const int TRIG_PIN = 9;             // HC-SR04 TRIG
5const int ECHO_PIN = 10;            // HC-SR04 ECHO
6const int SERVO_PIN = 6;            // servo sinyal kablosu / servo signal wire
7const int LED_PIN = 13;             // durum LED'i / status LED
8const int OPEN_DISTANCE = 20;       // bundan yakınsa aç (cm) / open if closer than this (cm)
9const int OPEN_ANGLE = 90;          // açık kapak açısı / open lid angle
10const int CLOSED_ANGLE = 0;         // kapalı kapak açısı / closed lid angle
11
12Servo lidServo;                     // servo nesnesi / servo object
13int openCount = 0;                  // kaç kez açıldı / how many times it opened
14
15void setup() {
16  Serial.begin(9600);
17  pinMode(TRIG_PIN, OUTPUT);
18  pinMode(ECHO_PIN, INPUT);
19  pinMode(LED_PIN, OUTPUT);
20  lidServo.attach(SERVO_PIN);
21  lidServo.write(CLOSED_ANGLE);     // açılışta kapalı / closed at power-up
22}
23
24void loop() {
25  long distance = readDistanceCm(); // mesafeyi ölç / measure the distance
26  Serial.print("Mesafe / Distance: ");
27  Serial.println(distance);
28
29  if (distance > 0 && distance < OPEN_DISTANCE) {
30    openCount++;                    // sayacı bir artır / add one to the counter
31    digitalWrite(LED_PIN, HIGH);
32    lidServo.write(OPEN_ANGLE);     // kapağı aç / open the lid
33    delay(3000);                    // 3 sn açık kal / stay open for 3 s
34    lidServo.write(CLOSED_ANGLE);   // kapağı kapat / close the lid
35    digitalWrite(LED_PIN, LOW);
36    Serial.print("Acilma sayisi / Times opened: ");
37    Serial.println(openCount);
38  }
39  delay(100);                       // saniyede yaklaşık 10 ölçüm / about 10 readings per second
40}
41
42// Mesafeyi santimetre olarak döndürür / returns the distance in centimetres
43long readDistanceCm() {
44  digitalWrite(TRIG_PIN, LOW);
45  delayMicroseconds(2);
46  digitalWrite(TRIG_PIN, HIGH);     // 10 µs tetik darbesi / 10 µs trigger pulse
47  delayMicroseconds(10);
48  digitalWrite(TRIG_PIN, LOW);
49  long duration = pulseIn(ECHO_PIN, HIGH, 30000);  // en fazla 30 ms bekle / wait at most 30 ms
50  return duration / 58;             // µs'yi cm'ye çevir / convert µs to cm
51}
RigaCosa faCosa succede se la cambi?
#include <Servo.h>Aggiunge la libreria Servo allo sketchSe la togli, il compilatore segnala "'Servo' does not name a type"
const int TRIG_PIN = 9;Dà il nome TRIG_PIN al pin 9Se sposti il cavo, cambi solo questo numero
const int OPEN_DISTANCE = 20;Distanza di soglia per aprire il coperchioCon 30 il coperchio si apre da più lontano
Servo lidServo;Crea un oggetto servo chiamato lidServoTutte le righe successive devono usare lo stesso nome
int openCount = 0;Contatore globale, a zero all'accensioneSe lo sposti dentro loop(), si azzera a ogni giro e mostra sempre 1
lidServo.attach(SERVO_PIN);Collega il servo al pin 6Se la dimentichi, il servo non si muove mai
long distance = readDistanceCm();Chiama la funzione e salva il risultatodistance esiste solo dentro loop()
if (distance > 0 && distance < OPEN_DISTANCE)Entra nel blocco se entrambe le condizioni sono veredistance > 0 scarta lo 0 restituito quando l'eco non torna
delay(3000);Fa aspettare la scheda 3 secondiIn quel tempo Arduino non controlla nient'altro
return duration / 58;Converte il tempo dell'eco in centimetriIl suono va e torna: circa 58 µs per centimetro

Ora eseguiamo loop() a mano in due situazioni. Senza nessuno davanti, il sensore misura 45 cm: distance vale 45, il monitor seriale mostra "Mesafe / Distance: 45", la condizione 45 < 20 è falsa e il blocco viene saltato, la scheda aspetta 100 ms e loop() ricomincia. Succede circa dieci volte al secondo. Se avvicini la mano a 12 cm, entrambe le condizioni sono vere: openCount passa da 0 a 1, il LED si accende, il servo ruota a 90 gradi, la scheda aspetta tre secondi, il coperchio si chiude, il LED si spegne e il monitor scrive "Acilma sayisi / Times opened: 1". Seguire un codice con numeri veri è il modo più affidabile per capirlo.

Nota un altro dettaglio: se pulseIn() non riceve l'eco entro 30 ms, restituisce 0. Senza il controllo distance > 0, quello 0 misurato verso il vuoto conterebbe come "minore di 20" e il coperchio si aprirebbe senza motivo. Il codice ben scritto è pieno di piccoli controlli come questo; se non capisci perché una riga è lì, cancellala per un momento e guarda cosa succede. Come funziona il sensore lo spieghiamo nella guida al sensore a ultrasuoni HC-SR04, la versione completa del progetto con due sensori in quella sul cestino intelligente.

Variabili e tipi di dati: le etichette delle scatole

Una variabile è una scatola con un'etichetta in cui metti un numero o un testo. La parola all'inizio della riga indica il tipo di scatola, cioè cosa ci sta dentro. Su Arduino Uno il tipo sbagliato causa errori silenziosi: se salvi millis() in un int, per esempio, dopo circa 32 secondi il numero diventa negativo.

TipoIntervallo (Arduino Uno)Uso tipico
intda -32.768 a 32.767Numeri dei pin, valori di analogRead, contatori
longcirca ±2,1 miliardiDurata di pulseIn, numeri grandi
unsigned longda 0 a circa 4,29 miliardiTempi di millis() e micros()
floatNumeri con la virgola, 6–7 cifre di precisioneCalcoli di temperatura, tensione e distanza
booltrue oppure falseQualcosa è acceso o spento?
byteda 0 a 255Valori PWM, numeri piccoli
char / StringUn carattere / del testoComandi dalla seriale, testi per i display

Conta anche dove viene dichiarata una variabile: si parla di visibilità (scope). Nell'esempio openCount è dichiarata fuori da ogni funzione, quindi è globale: il suo valore resta a ogni giro di loop(). distance, invece, è dichiarata dentro loop(): è locale, nasce a ogni giro e sparisce alla fine del giro. Una variabile con const davanti è una costante e il programma non può modificarla mentre gira. Per approfondire, leggi la nostra guida alle basi della programmazione Arduino e, per tenere più valori in una sola variabile, quella sugli array in Arduino.

Come leggere condizioni, cicli e funzioni

  • if / else if / else: leggilo come "se ... allora fai questo, altrimenti fai quello". Le parentesi graffe { } mostrano quali righe dipendono dalla condizione.
  • Confronti: == significa "uguale a", != "diverso da", < "minore di", >= "maggiore o uguale a". && vuol dire "e", || "oppure", ! "non".
  • Ciclo for: leggi for (int i = 0; i < 5; i++) come "i parte da 0, ripeti finché i è minore di 5 e aggiungi uno a ogni giro"; il blocco gira 5 volte.
  • Ciclo while: while (digitalRead(BUTTON_PIN) == HIGH) si legge "aspetta finché il pulsante non è premuto"; se la condizione non cambia mai, il codice resta bloccato lì.
  • switch / case: il programma prende una strada diversa in base al valore di una variabile; se dimentichi il break alla fine di un case, viene eseguito anche il successivo.
  • Definizione di funzione: in long readDistanceCm(), long è il tipo del valore restituito, readDistanceCm il nome e le parentesi vuote indicano che non ci sono parametri. Le funzioni che iniziano con void non restituiscono nulla, svolgono solo un compito.
Ci sono due trappole che sfuggono facilmente durante la lettura. if (x = 5) non è un confronto ma un'assegnazione di 5 a x, e la condizione è sempre vera; la forma corretta è if (x == 5). La seconda: il punto e virgola alla fine di if (distance < 20); annulla la condizione e il blocco sotto viene eseguito a ogni giro. Il compilatore non segnala errori in nessuno dei due casi, quindi leggi queste righe con particolare attenzione.

Riconoscere le funzioni delle librerie

In una riga come lidServo.write(90), il punto indica che la funzione write appartiene all'oggetto lidServo: "lidServo, vai a 90 gradi". Ci sono tre modi semplici per scoprire cosa fa una funzione di libreria: nell'Arduino IDE 2 passare il mouse sopra per leggerne la descrizione oppure fare clic destro e scegliere Go to Definition; aprire gli esempi della libreria da File > Esempi; scorrere l'elenco delle funzioni nel file .h della libreria. Spieghiamo come installare le librerie nella guida come aggiungere una libreria Arduino. Queste sono le funzioni di base che incontrerai in quasi ogni sketch:

FunzioneCosa faEsempio
pinMode(pin, modo)Imposta un pin come ingresso o uscitapinMode(13, OUTPUT);
digitalWrite(pin, valore)Porta un'uscita a 5 V (HIGH) o 0 V (LOW)digitalWrite(13, HIGH);
digitalRead(pin)Legge se un ingresso è HIGH o LOWdigitalRead(2)
analogRead(pin)Converte 0–5 V in un numero da 0 a 1023analogRead(A0)
analogWrite(pin, 0–255)Regola in PWM la luminosità di un LED o la velocità di un motoreanalogWrite(9, 128);
delay(ms)Ferma la scheda per il tempo indicatodelay(1000);
millis()Millisecondi dall'accensioneif (millis() - last > 500)
Serial.begin / print / printlnInvia testo al monitor serialeSerial.println(distance);
map(x, a, b, c, d)Trasforma un intervallo di valori in un altromap(value, 0, 1023, 0, 180)
pulseIn(pin, HIGH)Misura la durata di un impulso in µspulseIn(10, HIGH, 30000)

Per l'elenco completo con esempi dettagliati, guarda la nostra guida ai comandi Arduino. Capire la differenza tra delay() e millis() è una delle cose più utili per leggere gli sketch; la guida millis e delay la spiega con esempi.

Adattare il codice di qualcun altro al tuo circuito

  1. Ricava dal codice una tabella dei collegamenti. Scrivi tutte le costanti dei pin una sotto l'altra: è il circuito di chi ha scritto il codice.
  2. Confrontala con il tuo circuito. Se hai usato altri pin, non spostare i cavi: cambia solo i numeri nelle righe const e lascia stare il resto del codice.
  3. Controlla le differenze tra librerie. Due librerie con lo stesso nome possono usare funzioni diverse; con gli LCD I2C anche l'indirizzo 0x27 o 0x3F è la causa di incompatibilità più comune.
  4. Attenzione ad attivo LOW e attivo HIGH. Quasi tutti i moduli relè scattano con LOW; se il codice accende con HIGH, il tuo relè farà esattamente il contrario.
  5. Allinea la velocità della seriale. Se nel codice c'è Serial.begin(115200), scegli 115200 anche nel monitor seriale, altrimenti vedrai caratteri senza senso.
  6. Prova un pezzo alla volta. Fai girare prima solo la parte che legge il sensore e, quando i valori tornano, aggiungi motore e display.
Il monitor seriale è una torcia che punti dentro il codice. Se non capisci perché una condizione non scatta, aggiungi subito prima dell'if una riga come Serial.println(distance) e guarda con quale valore avviene davvero il confronto. Trovi i dettagli nella guida al monitor seriale di Arduino.

Portare lo stesso codice sull'ESP32

Anche l'ESP32 si programma con l'Arduino IDE, quindi gran parte del codice funziona così com'è; cambiano i numeri dei pin, il livello di tensione e alcune librerie. La tabella elenca cosa controllare quando porti il codice di un Arduino Uno sull'ESP32:

ArgomentoArduino UnoESP32Cosa fare
Nomi dei pinD2–D13, A0–A5Numeri GPIOSostituisci le costanti con i numeri GPIO, attenzione a 6–11 e 34–39
Tensione di lavoro5 V3,3 VMetti un partitore di tensione sui sensori con uscita a 5 V (ECHO dell'HC-SR04)
analogRead10 bit, 0–102312 bit, 0–4095Ricalcola soglie e intervalli di map() per un intervallo quattro volte più ampio
Libreria servoServo.hESP32Servo.hCambia libreria e indica in attach l'intervallo dell'impulso
Velocità serialeDi solito 9600Di solito 115200Allinea Serial.begin e il monitor seriale
Memoria2 KB di RAMCirca 320 KB di RAMArray grandi e String non sono più un problema
C++ (Arduino IDE)
1// ESP32 sürümü: değişen satırlar işaretli / ESP32 version: changed lines are marked
2#include <ESP32Servo.h>             // DEĞİŞTİ: Servo.h yerine / CHANGED: instead of Servo.h
3
4const int TRIG_PIN = 26;            // DEĞİŞTİ / CHANGED
5const int ECHO_PIN = 27;            // DEĞİŞTİ: 1k/2k bölücüyle / CHANGED: through a 1k/2k divider
6const int SERVO_PIN = 18;           // DEĞİŞTİ / CHANGED
7const int LED_PIN = 2;              // DEĞİŞTİ: çoğu DevKit'te dahili LED / CHANGED: onboard LED on most DevKits
8const int OPEN_DISTANCE = 20;
9const int OPEN_ANGLE = 90;
10const int CLOSED_ANGLE = 0;
11
12Servo lidServo;
13int openCount = 0;
14
15void setup() {
16  Serial.begin(115200);             // DEĞİŞTİ: ESP32'de yaygın hız / CHANGED: common ESP32 speed
17  pinMode(TRIG_PIN, OUTPUT);
18  pinMode(ECHO_PIN, INPUT);
19  pinMode(LED_PIN, OUTPUT);
20  lidServo.setPeriodHertz(50);      // EKLENDİ: standart servo 50 Hz / ADDED: standard servo 50 Hz
21  lidServo.attach(SERVO_PIN, 500, 2400);  // DEĞİŞTİ: darbe aralığı µs / CHANGED: pulse range in µs
22  lidServo.write(CLOSED_ANGLE);
23}
24
25void loop() {
26  long distance = readDistanceCm();
27  Serial.print("Mesafe / Distance: ");
28  Serial.println(distance);
29
30  if (distance > 0 && distance < OPEN_DISTANCE) {
31    openCount++;
32    digitalWrite(LED_PIN, HIGH);
33    lidServo.write(OPEN_ANGLE);
34    delay(3000);
35    lidServo.write(CLOSED_ANGLE);
36    digitalWrite(LED_PIN, LOW);
37    Serial.print("Acilma sayisi / Times opened: ");
38    Serial.println(openCount);
39  }
40  delay(100);
41}
42
43long readDistanceCm() {
44  digitalWrite(TRIG_PIN, LOW);
45  delayMicroseconds(2);
46  digitalWrite(TRIG_PIN, HIGH);
47  delayMicroseconds(10);
48  digitalWrite(TRIG_PIN, LOW);
49  long duration = pulseIn(ECHO_PIN, HIGH, 30000);
50  return duration / 58;
51}

Come vedi, loop() e la funzione readDistanceCm() sono passati senza cambiare una lettera; tutto ciò che è cambiato sta in cima al file e dentro setup(). È il segno di un codice ben scritto: i dettagli legati all'hardware stanno raccolti in alto e la logica sotto resta pulita. Dato che il pin ECHO dell'HC-SR04 esce a 5 V, deve arrivare all'ESP32 attraverso un partitore di tensione da 1 kΩ e 2 kΩ; il servo invece va alimentato dai 5 V del pin VIN, non dai 3,3 V. Confrontiamo le altre differenze tra le schede nella guida Arduino o ESP32.

La stessa logica sul Raspberry Pi Pico: MicroPython

Quando programmi il Pico in MicroPython, il codice ha un aspetto diverso ma la logica è la stessa. Si scrive import al posto di #include e l'indentazione sostituisce le parentesi graffe. Le parole setup() e loop() non esistono: le righe in cima al file girano una volta (l'equivalente di setup) e il blocco while True: gira all'infinito (l'equivalente di loop). Le funzioni iniziano con def invece che con void o long. Metti questo codice accanto allo sketch Arduino qui sopra e troverai l'equivalente di ogni riga:

MicroPython
1from machine import Pin, PWM, time_pulse_us   # #include karşılığı / the #include part
2import time
3
4TRIG = Pin(14, Pin.OUT)              # HC-SR04 TRIG
5ECHO = Pin(15, Pin.IN)               # HC-SR04 ECHO, bölücüyle / through a divider
6LED = Pin(25, Pin.OUT)               # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
7servo = PWM(Pin(16))
8servo.freq(50)                       # servo 50 Hz ister / servos need 50 Hz
9
10OPEN_DISTANCE = 20                   # cm
11
12
13def set_angle(angle):
14    pulse_us = 500 + angle * 2000 // 180            # 0 derece 0,5 ms, 180 derece 2,5 ms / 0 deg 0.5 ms, 180 deg 2.5 ms
15    servo.duty_u16(pulse_us * 65535 // 20000)       # 20 ms periyodun oranı / share of the 20 ms period
16
17
18def read_distance_cm():
19    TRIG.low()
20    time.sleep_us(2)
21    TRIG.high()                      # 10 µs tetik darbesi / 10 µs trigger pulse
22    time.sleep_us(10)
23    TRIG.low()
24    duration = time_pulse_us(ECHO, 1, 30000)        # zaman aşımında negatif / negative on timeout
25    if duration < 0:
26        return 0
27    return duration // 58
28
29
30set_angle(0)                         # setup() karşılığı / the setup() part
31open_count = 0
32
33while True:                          # loop() karşılığı / the loop() part
34    distance = read_distance_cm()
35    print("Mesafe / Distance:", distance)
36    if 0 < distance < OPEN_DISTANCE:
37        open_count += 1
38        LED.on()
39        set_angle(90)
40        time.sleep(3)
41        set_angle(0)
42        LED.off()
43        print("Acilma sayisi / Times opened:", open_count)
44    time.sleep_ms(100)

Poiché qui in Python non c'è una libreria Servo, la funzione set_angle() converte da sola l'angolo in durata dell'impulso: il servo si posiziona in base a un impulso da 0,5 a 2,5 ms che arriva ogni 20 ms. La scrittura 0 < distance < OPEN_DISTANCE è la forma breve, in Python, della condizione C++ distance > 0 && distance < OPEN_DISTANCE. Se sei alle prime armi con MicroPython, la guida alle basi di MicroPython spiega le regole di indentazione, variabili e funzioni.

Esercitarsi con "Capire il codice" in BlueGrays

Nell'app BlueGrays la schermata del codice di ogni progetto ha anche la scheda "Capire il codice". La sezione "Cosa fa questo codice?" riassume prima in poche frasi il compito del programma. "Passo dopo passo" divide poi il codice in piccoli pezzi e spiega sotto ognuno a cosa servono quelle righe e cosa succede se le cambi. "Se ti blocchi" raccoglie i problemi più comuni come sintomo e soluzione, e "Prova tu" ti propone un piccolo compito con suggerimento e soluzione, per esempio cambiare la soglia di una luce notturna perché il LED si accenda prima. Lì puoi applicare il metodo in cinque passi di questa guida: leggi il riassunto, abbina ogni pezzo al tuo circuito e alla fine risolvi il compito modificando tu stesso il codice.

Esercizi per imparare a leggere il codice

  • Prevedi, poi verifica: prima di cambiare una costante, scrivi cosa succederà, poi carica il codice e controlla la tua previsione.
  • Commenta una riga: metti // davanti a una riga e ricarica; quello che smette di funzionare ti mostra a cosa serviva.
  • Raccontalo con parole tue: traduci ogni riga di loop() in una frase in italiano; una riga che non riesci a tradurre è una riga che non hai ancora capito.
  • Disegna un diagramma di flusso: rappresenta setup, loop, gli if e le chiamate di funzione con riquadri e frecce; è utilissimo con il codice che usa una macchina a stati.
  • Sbaglia apposta: cancella un punto e virgola e leggi il messaggio del compilatore; la guida agli errori di compilazione Arduino spiega i messaggi più frequenti.

Errori comuni nella lettura del codice

ErrorePerché è un problemaCome fare
Pensare che il codice sia un elenco eseguito una volta solaloop() si ripete all'infinito e le variabili cambiano tra un giro e l'altroSegui loop() per più giri con valori diversi
Confondere = con ==if (x = 5) è sempre veroPer confrontare usa sempre ==
Non accorgersi della divisione intera5 / 2 dà 2, la parte decimale si perdeSe ti servono i decimali, scrivi 5.0 / 2 o usa un float
Dimenticare che delay() blocca tuttoDurante l'attesa pulsanti e sensori non vengono lettiPer più compiti insieme, gestisci il tempo con millis()
Ignorare le differenze di versione delle librerieLa stessa funzione può avere un altro nome in una versione nuovaCerca nei commenti con quale libreria è stato scritto il codice
Cambiare la costante di un pin e dimenticare il cavoIl codice legge il pin giusto, ma il cavo è altroveAggiorna la tabella dei collegamenti dopo ogni modifica
Davanti a uno sketch difficile, riscrivilo prima con parole semplici: "Misura la distanza. Se è maggiore di 0 e minore di 20, aumenta il contatore, accendi il LED, apri il coperchio, aspetta 3 secondi, chiudi il coperchio, spegni il LED. Aspetta 100 ms e ricomincia." Si chiama pseudocodice ed è il modo più rapido per cogliere il ragionamento di chi ha scritto il programma.

Leggere il codice, proprio come leggere uno schema elettrico, diventa più veloce a ogni esempio che vedi. Per cominciare, apri nell'app BlueGrays progetti brevi come accendere un LED, il semaforo, il LED con pulsante o la luce notturna con LDR e segui la scheda "Capire il codice" riga per riga; ogni progetto ti aspetta con lo schema, la spiegazione del codice pezzo per pezzo e un piccolo compito.

Domande frequenti

In che linguaggio si programma Arduino?

Il codice Arduino si basa su C e C++. Arduino aggiunge funzioni già pronte come pinMode o digitalWrite per semplificare il lavoro, ma le regole di if, cicli for, variabili e funzioni sono C++ puro. Per questo conoscere un po' di C++ rende molto più facile leggere il codice Arduino.

Qual è la differenza tra setup e loop?

setup() gira una sola volta, quando la scheda si accende o viene resettata, e serve per le preparazioni come impostare i pin e la comunicazione seriale. loop() si ripete poi senza sosta finché c'è alimentazione; lì si svolge il lavoro vero, come leggere i sensori, prendere decisioni e muovere i motori.

Cosa significa void in Arduino?

void indica che una funzione non restituisce alcun valore. void setup() e void loop() svolgono azioni ma non danno un risultato. Una funzione come long readDistanceCm(), invece, restituisce con return un valore del tipo scritto prima del suo nome.

Perché il codice compila ma il circuito non funziona?

Il compilatore controlla solo la sintassi; un numero di pin sbagliato, un modulo collegato al contrario o una soglia scelta male non producono errori di compilazione. Confronta le costanti dei pin nel codice con il tuo circuito e osserva i valori con Serial.println nel monitor seriale; di solito il problema è nei collegamenti o in una soglia.

Posso usare il codice Arduino su un ESP32?

Quasi sempre sì, perché anche l'ESP32 si programma con l'Arduino IDE e le funzioni di base sono le stesse. Dovrai sostituire i numeri dei pin con i numeri GPIO, abbassare i segnali a 5 V a 3,3 V e cambiare alcune librerie, come Servo, con le versioni per ESP32. Ricorda anche che analogRead restituisce valori da 0 a 4095.

Dove trovo esempi di codice Arduino?

Il menu File > Esempi dell'Arduino IDE è un ottimo punto di partenza, insieme agli esempi di ogni libreria che installi. Anche i progetti dell'app BlueGrays arrivano con lo schema e il codice spiegato riga per riga. Da qualunque fonte arrivi il codice, leggerlo una volta con il metodo di questa guida prima di caricarlo ti aiuta a scoprire subito gli errori.

Vedi tutti i progetti
LED lampeggiante
AR-1Principiante

LED lampeggiante

Il primissimo ciao dell'elettronica: accendere e spegnere un solo LED. L'Arduino accende e spegne il LED a intervalli brevissimi, così la luce lampeggia veloce.

4.6(200)
1246
Semaforo
AR-3Principiante

Semaforo

Una copia in miniatura del semaforo che vedi ogni giorno per strada. Il rosso resta acceso due secondi, il giallo brilla per un attimo, il verde resta due secondi, poi si torna al rosso passando di…

4.8(137)
440
Accendere un LED con un pulsante (Push)
AR-9Principiante

Accendere un LED con un pulsante (Push)

Come un campanello: la luce resta accesa finché premi e si spegne quando lasci. L'Arduino ascolta il pulsante di continuo; mentre è premuto accende il LED, e appena togli il dito lo spegne.

4.8(114)
253
Luce notturna con LDR
AR-12Principiante

Luce notturna con LDR

Una piccola luce notturna che si accende da sola quando fa buio e si spegne quando arriva il mattino.

4.7(105)
224
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

HC-SR04 Misura della distanza (display seriale)

Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

4.6(50)
82
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
Sensore di parcheggio con HC-SR04
AR-28Intermedio
Premium

Sensore di parcheggio con HC-SR04

Una versione in miniatura del sensore di parcheggio delle auto: più qualcosa si avvicina, più i bip accelerano.

4.8(64)
86
Funzionamento del servomotore con potenziometro
AR-36Principiante
Premium

Funzionamento del servomotore con potenziometro

Mentre giri la manopola del potenziometro, il braccio del servomotore ruota insieme a lei: un'estremità della manopola corrisponde a zero gradi, l'altra a mezzo giro.

4.6(37)
53