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.

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 codice | A cosa serve | Riga tipica | Come riconoscerla |
|---|---|---|---|
| Commenti | Spiegano il codice, il compilatore li ignora | // nota oppure /* ... */ | Iniziano con //, grigi nell'IDE |
| Librerie | Aggiungono codice già pronto (servo, display, sensore) | #include <Servo.h> | Iniziano con #, in cima |
| Definizioni dei pin e costanti | Danno un nome ai numeri dei pin e alle soglie | const int LED_PIN = 13; | Di solito nomi in MAIUSCOLO |
| Variabili globali e oggetti | Dati raggiungibili da qualunque punto del codice | int count = 0; Servo lidServo; | Fuori da ogni funzione |
| setup() | Gira una volta all'accensione | pinMode(LED_PIN, OUTPUT); | void setup() { ... } |
| loop() | Si ripete all'infinito, qui avviene il lavoro vero | if (distance < 20) { ... } | void loop() { ... } |
| Funzioni tue | Raccolgono un compito che si ripete | long readDistanceCm() { ... } | Blocchi separati sopra o sotto loop |
Da dove cominciare? Un metodo in cinque passi
- 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.
- 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.
- 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).
- 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.
- 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.
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}| Riga | Cosa fa | Cosa succede se la cambi? |
|---|---|---|
| #include <Servo.h> | Aggiunge la libreria Servo allo sketch | Se la togli, il compilatore segnala "'Servo' does not name a type" |
| const int TRIG_PIN = 9; | Dà il nome TRIG_PIN al pin 9 | Se sposti il cavo, cambi solo questo numero |
| const int OPEN_DISTANCE = 20; | Distanza di soglia per aprire il coperchio | Con 30 il coperchio si apre da più lontano |
| Servo lidServo; | Crea un oggetto servo chiamato lidServo | Tutte le righe successive devono usare lo stesso nome |
| int openCount = 0; | Contatore globale, a zero all'accensione | Se lo sposti dentro loop(), si azzera a ogni giro e mostra sempre 1 |
| lidServo.attach(SERVO_PIN); | Collega il servo al pin 6 | Se la dimentichi, il servo non si muove mai |
| long distance = readDistanceCm(); | Chiama la funzione e salva il risultato | distance esiste solo dentro loop() |
| if (distance > 0 && distance < OPEN_DISTANCE) | Entra nel blocco se entrambe le condizioni sono vere | distance > 0 scarta lo 0 restituito quando l'eco non torna |
| delay(3000); | Fa aspettare la scheda 3 secondi | In quel tempo Arduino non controlla nient'altro |
| return duration / 58; | Converte il tempo dell'eco in centimetri | Il 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.
| Tipo | Intervallo (Arduino Uno) | Uso tipico |
|---|---|---|
| int | da -32.768 a 32.767 | Numeri dei pin, valori di analogRead, contatori |
| long | circa ±2,1 miliardi | Durata di pulseIn, numeri grandi |
| unsigned long | da 0 a circa 4,29 miliardi | Tempi di millis() e micros() |
| float | Numeri con la virgola, 6–7 cifre di precisione | Calcoli di temperatura, tensione e distanza |
| bool | true oppure false | Qualcosa è acceso o spento? |
| byte | da 0 a 255 | Valori PWM, numeri piccoli |
| char / String | Un carattere / del testo | Comandi 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.
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:
| Funzione | Cosa fa | Esempio |
|---|---|---|
| pinMode(pin, modo) | Imposta un pin come ingresso o uscita | pinMode(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 LOW | digitalRead(2) |
| analogRead(pin) | Converte 0–5 V in un numero da 0 a 1023 | analogRead(A0) |
| analogWrite(pin, 0–255) | Regola in PWM la luminosità di un LED o la velocità di un motore | analogWrite(9, 128); |
| delay(ms) | Ferma la scheda per il tempo indicato | delay(1000); |
| millis() | Millisecondi dall'accensione | if (millis() - last > 500) |
| Serial.begin / print / println | Invia testo al monitor seriale | Serial.println(distance); |
| map(x, a, b, c, d) | Trasforma un intervallo di valori in un altro | map(value, 0, 1023, 0, 180) |
| pulseIn(pin, HIGH) | Misura la durata di un impulso in µs | pulseIn(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
- 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.
- 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.
- 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.
- 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.
- Allinea la velocità della seriale. Se nel codice c'è Serial.begin(115200), scegli 115200 anche nel monitor seriale, altrimenti vedrai caratteri senza senso.
- Prova un pezzo alla volta. Fai girare prima solo la parte che legge il sensore e, quando i valori tornano, aggiungi motore e display.
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:
| Argomento | Arduino Uno | ESP32 | Cosa fare |
|---|---|---|---|
| Nomi dei pin | D2–D13, A0–A5 | Numeri GPIO | Sostituisci le costanti con i numeri GPIO, attenzione a 6–11 e 34–39 |
| Tensione di lavoro | 5 V | 3,3 V | Metti un partitore di tensione sui sensori con uscita a 5 V (ECHO dell'HC-SR04) |
| analogRead | 10 bit, 0–1023 | 12 bit, 0–4095 | Ricalcola soglie e intervalli di map() per un intervallo quattro volte più ampio |
| Libreria servo | Servo.h | ESP32Servo.h | Cambia libreria e indica in attach l'intervallo dell'impulso |
| Velocità seriale | Di solito 9600 | Di solito 115200 | Allinea Serial.begin e il monitor seriale |
| Memoria | 2 KB di RAM | Circa 320 KB di RAM | Array grandi e String non sono più un problema |
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:
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
| Errore | Perché è un problema | Come fare |
|---|---|---|
| Pensare che il codice sia un elenco eseguito una volta sola | loop() si ripete all'infinito e le variabili cambiano tra un giro e l'altro | Segui loop() per più giri con valori diversi |
| Confondere = con == | if (x = 5) è sempre vero | Per confrontare usa sempre == |
| Non accorgersi della divisione intera | 5 / 2 dà 2, la parte decimale si perde | Se ti servono i decimali, scrivi 5.0 / 2 o usa un float |
| Dimenticare che delay() blocca tutto | Durante l'attesa pulsanti e sensori non vengono letti | Per più compiti insieme, gestisci il tempo con millis() |
| Ignorare le differenze di versione delle librerie | La stessa funzione può avere un altro nome in una versione nuova | Cerca nei commenti con quale libreria è stato scritto il codice |
| Cambiare la costante di un pin e dimenticare il cavo | Il codice legge il pin giusto, ma il cavo è altrove | Aggiorna la tabella dei collegamenti dopo ogni modifica |
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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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.

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…

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.

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

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é.

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…

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

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.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

