Codice Arduino con l'intelligenza artificiale: prompt ed errori

Scrivere codice Arduino con l'intelligenza artificiale significa descrivere il tuo progetto a un assistente come ChatGPT, Gemini, Claude o Copilot e chiedergli un codice funzionante per Arduino, ESP32 o Raspberry Pi Pico. Usata bene, l'IA trasforma ore di lavoro in minuti: invece di una pagina bianca hai una bozza pronta da compilare. Ma l'IA non vede il tuo circuito, non sa quale scheda hai sul tavolo e può affermare una cosa sbagliata con assoluta sicurezza. Può inventare una funzione di libreria che non esiste, scegliere il pin sbagliato o scrivere cicli con delay() che bloccano tutto. Per questo la vera abilità non è chiedere il codice, ma chiederlo bene e verificare ciò che ricevi.

In questa guida vedrai come un assistente IA produce codice Arduino e perché sbaglia, come scrivere un buon prompt che indichi scheda, pin, librerie e comportamento atteso, e quali passaggi seguire per verificare il codice prima di caricarlo. Analizzeremo i tre errori più frequenti con veri messaggi del compilatore e codice corretto. Poi vedremo il modo giusto per incollare un errore di compilazione e farlo correggere, perché non devi fidarti dell'IA quando lavori con la rete a 230 V e come usare questi strumenti senza smettere di imparare.

Come scrive codice Arduino l'IA e perché sbaglia?

I grandi modelli linguistici (LLM) come ChatGPT non scrivono codice eseguendolo come un compilatore, ma prevedendo la continuazione più probabile a partire dai milioni di esempi visti durante l'addestramento. Per gli argomenti con tanti esempi online (far lampeggiare un LED, leggere un DHT11, muovere un servo) il metodo funziona molto bene. Però le conoscenze del modello sono ferme a una certa data, quindi può non conoscere funzioni cambiate nelle versioni più recenti di una libreria. Può confondere le funzioni di due librerie diverse con lo stesso nome. Soprattutto, invece di dire «non lo so», può inventare una risposta che sembra plausibile: si chiama allucinazione. Dato che il modello non vede il tuo circuito, ricava numeri di pin, livelli di tensione e versioni dei moduli da ciò che hai scritto o dalle proprie ipotesi.

Come si scrive un buon prompt?

Il codice che ti dà l'IA non può essere migliore delle informazioni che le fornisci. Con una richiesta di una riga come «scrivi un codice Arduino che misuri la temperatura», il modello sceglie da solo scheda, sensore, pin e libreria. Se le sue scelte non corrispondono ai tuoi componenti, il codice non compila oppure compila e non funziona. Scrivi un buon prompt come se spiegassi il progetto al telefono a un amico che ne sente parlare per la prima volta: indica uno per uno scheda, componenti, collegamenti, librerie, comportamento atteso e vincoli. La tabella riassume cosa deve contenere un prompt per Arduino:

Per esempio, questo prompt dà risultati molto migliori di una richiesta di una riga: «Uso un Arduino Uno R3 e l'Arduino IDE 2.3. Il pin DATA del DHT22 è su D2, un buzzer attivo su D8 e un LCD 16x2 I2C (PCF8574, indirizzo 0x27) ha SDA su A4 e SCL su A5. Ho installato la Adafruit DHT sensor library e la libreria LiquidCrystal I2C di Frank de Brabander. Ogni 2 secondi mostra temperatura e umidità sull'LCD e, se la temperatura supera i 30 °C, fai suonare il buzzer a brevi intervalli. Usa millis() al posto di delay() e commenta le righe in italiano. All'inizio elenca le librerie che devo installare e alla fine le ipotesi che hai fatto.» Con questo prompt al modello non resta quasi nulla da indovinare.

I passaggi per verificare il codice generato dall'IA

Per quanto ordinato sembri il codice, passalo al vaglio di una lista di controllo prima di caricarlo sulla scheda. Quasi tutti questi passaggi richiedono pochi minuti e costano molto meno di un modulo bruciato per un pin collegato male:

1. Prima compila e basta: Premi Verifica (il pulsante con il segno di spunta) senza collegare la scheda. Se compare un errore, fallo correggere con il metodo qui sotto; per capire i messaggi, leggi errori di compilazione Arduino.
2. Controlla le librerie una per una: Cerca ogni riga #include nel Gestore librerie e installa quella il cui nome, autore ed esempi corrispondono al codice. Se non sai come fare, la guida come aggiungere una libreria Arduino te lo spiega passo dopo passo.
3. Confronta i pin: Confronta ogni numero di pin del codice con i tuoi collegamenti e con la piedinatura della scheda. Per i pin PWM e quelli da evitare usa lo strumento Pinout.
4. Calcola i valori elettrici: Controlla il valore di resistenza proposto con il calcolatore della resistenza per LED. Se un sensore con uscita a 5 V va collegato a un ESP32 o a un Pico a 3,3 V, metti in mezzo un partitore di tensione.
5. Provalo in un simulatore: Esegui il codice su Wokwi o Tinkercad prima di collegare l'hardware vero; scopri gli errori di logica senza rischiare nessun componente.
6. Prova un pezzo alla volta: Non caricare tutto il progetto in un colpo. Prova prima un piccolo sketch che legge solo il sensore e lo stampa sul monitor seriale, poi aggiungi il display e per ultimi il buzzer o il relè.
7. Osserva il monitor seriale: Aggiungi Serial.println() nei punti chiave per vedere se le variabili assumono i valori che ti aspetti, e verifica che la velocità in baud coincida con Serial.begin() nel codice. Trovi i dettagli in monitor seriale di Arduino.
8. Fatti spiegare il codice: Per ogni riga che non capisci, chiedi «cosa fa questa riga e cosa succede se la cancello?». Non caricare mai un codice che non sai spiegare.

Errore frequente 1: funzioni di libreria che non esistono

L'errore più subdolo dell'IA è scrivere funzioni che in realtà non esistono ma hanno nomi molto credibili. Per esempio, la libreria Servo standard ha attach(), write(), writeMicroseconds(), read() e detach(), ma nessuna funzione setSpeed() per la velocità; il modello può inventarla se chiedi un servo che giri lentamente. A volte la funzione esiste davvero, ma su un'altra scheda: Serial.printf() funziona sull'ESP32, ma su Arduino Uno non compila. E a volte la funzione appartiene a una versione vecchia: nella versione 3.x del core Arduino per ESP32, uscita nel 2024, ledcSetup() e ledcAttachPin() sono state rimosse, eppure la maggior parte dei modelli scrive ancora codice che le usa. Ci sono poi librerie diverse che usano lo stesso file di intestazione: in una libreria chiamata LiquidCrystal_I2C.h il display si avvia con lcd.init(), in un'altra con lo stesso nome con lcd.begin(). Se nell'output del compilatore vedi l'avviso «Multiple libraries were found», sospetta questa confusione.

La trappola delle vecchie funzioni sull'ESP32: ledcAttach al posto di ledcSetup

Quando chiedi un codice ESP32 che regola la luminosità di un LED o la velocità di un motore, molto probabilmente l'IA scriverà il trio ledcSetup(canale, frequenza, risoluzione), ledcAttachPin(pin, canale) e ledcWrite(canale, valore). Quel codice funziona con la versione 2.x del core. Nella versione 3.x, invece, i canali vengono assegnati automaticamente: ledcAttach(pin, frequenza, risoluzione) prepara il pin in un solo passaggio e ledcWrite(pin, valore) ora riceve un numero di pin invece di un canale. Puoi vedere quale versione è installata accanto al pacchetto esp32 nel Gestore schede. Il codice qui sotto controlla la versione durante la compilazione e quindi funziona con entrambi i core:

1// ESP32 PWM: çekirdek 2.x ve 3.x ile uyumlu LED soldurma / LED fade for both core 2.x and 3.x
2#include <esp_arduino_version.h>   // ESP_ARDUINO_VERSION_MAJOR için / for ESP_ARDUINO_VERSION_MAJOR
3
4const int LED_PIN = 2;             // çoğu DevKit'te dahili LED / onboard LED on most DevKits
5const uint32_t FREKANS = 5000;     // PWM frekansı, Hz / PWM frequency, Hz
6const uint8_t COZUNURLUK = 8;      // 8 bit: 0-255 / 8-bit: 0-255
7
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9// Çekirdek 3.x: kanal otomatik seçilir, fonksiyonlar pin alır / Core 3.x: channel is automatic, functions take the pin
10void pwmBaslat() { ledcAttach(LED_PIN, FREKANS, COZUNURLUK); }
11void pwmYaz(uint32_t deger) { ledcWrite(LED_PIN, deger); }
12#else
13// Çekirdek 2.x: önce kanal kurulur, sonra pine bağlanır / Core 2.x: set up a channel, then attach the pin
14const uint8_t KANAL = 0;
15void pwmBaslat() { ledcSetup(KANAL, FREKANS, COZUNURLUK); ledcAttachPin(LED_PIN, KANAL); }
16void pwmYaz(uint32_t deger) { ledcWrite(KANAL, deger); }
17#endif
18
19void setup() {
20  Serial.begin(115200);
21  Serial.print("ESP32 Arduino cekirdegi / core: ");
22  Serial.println(ESP_ARDUINO_VERSION_MAJOR);
23  pwmBaslat();
24}
25
26void loop() {
27  // Tek iş yaptığı için burada delay() sorun değil / delay() is fine here: only one task
28  for (int d = 0; d <= 255; d++) { pwmYaz(d); delay(4); }   // yavaşça yan / fade in
29  for (int d = 255; d >= 0; d--) { pwmYaz(d); delay(4); }   // yavaşça sön / fade out
30}

La lezione non riguarda solo l'ESP32: se nel prompt indichi la versione del core e delle librerie, il modello ha la possibilità di scegliere le funzioni giuste. Se usa ancora funzioni vecchie nonostante la versione indicata, apri uno degli esempi ufficiali della libreria da File > Esempi e incollalo nel prompt con «riscrivilo con le funzioni di questo esempio». Gli esempi ufficiali corrispondono sempre alla versione installata. Se vuoi capire come funziona il PWM, dai un'occhiata a Cos'è il PWM?

Errore frequente 2: il pin sbagliato

Anche se il codice compila e si carica, un pin sbagliato significa un circuito che non fa nulla senza avvisare oppure un modulo bruciato. Il compilatore non può accorgersene, perché per lui il numero di un pin è solo un numero. Ecco gli errori sui pin che l'IA commette più spesso, scheda per scheda:

Errore frequente 3: il blocco di delay()

Poiché la maggior parte degli esempi Arduino online è scritta con delay(), anche l'IA usa delay() per impostazione predefinita. Mentre delay(1000) è in esecuzione, il processore non fa nient'altro per un intero secondo: non legge i pulsanti, non controlla i sensori e non aggiorna il display. In un codice che fa una sola cosa non è un problema. Ma se chiedi due cose insieme, come «fai lampeggiare un LED e suonare il buzzer quando premo il pulsante», spesso ottieni un codice come questo:

1// Yapay zekanın sık ürettiği, kilitlenen kod / Blocking code that AI often produces
2const int BUTON_PIN = 2;    // buton: D2 ile GND arası / button between D2 and GND
3const int LED_PIN = 13;     // dahili LED / onboard LED
4const int BUZZER_PIN = 8;   // aktif buzzer / active buzzer
5
6void setup() {
7  pinMode(BUTON_PIN, INPUT_PULLUP);
8  pinMode(LED_PIN, OUTPUT);
9  pinMode(BUZZER_PIN, OUTPUT);
10}
11
12void loop() {
13  digitalWrite(LED_PIN, HIGH);
14  delay(1000);                          // 1 sn boyunca buton okunmaz / button is not read for 1 s
15  digitalWrite(LED_PIN, LOW);
16  delay(1000);                          // 1 sn daha kör bekleme / another blind second
17
18  if (digitalRead(BUTON_PIN) == LOW) {  // yalnızca tam bu anda basılıysa / only if pressed right now
19    digitalWrite(BUZZER_PIN, HIGH);
20    delay(200);
21    digitalWrite(BUZZER_PIN, LOW);
22  }
23}

Questo codice compila senza errori, ma la maggior parte delle volte, quando premi il pulsante, non succede nulla. Circa 2 secondi di ogni giro di loop() passano dentro le due chiamate a delay(), e il pulsante viene letto solo per pochi microsecondi tra l'una e l'altra. Una pressione breve manca quasi sempre quel momento; per essere sicuro che il buzzer suoni, devi tenere premuto il pulsante per più di 2 secondi. La soluzione non è aspettare, ma guardare l'orologio: millis() restituisce i millisecondi trascorsi dall'accensione, ogni compito controlla se è arrivato il suo momento e loop() gira migliaia di volte al secondo:

1// millis() ile kilitlenmeyen sürüm / Non-blocking version with millis()
2const int BUTON_PIN = 2;    // buton: D2 ile GND arası / button between D2 and GND
3const int LED_PIN = 13;     // dahili LED / onboard LED
4const int BUZZER_PIN = 8;   // aktif buzzer / active buzzer
5
6const unsigned long LED_ARALIK = 1000;  // LED değişim aralığı, ms / LED toggle interval, ms
7const unsigned long BIP_SURE = 200;     // bip süresi, ms / beep length, ms
8const unsigned long SICRAMA = 30;       // debounce süresi, ms / debounce time, ms
9
10unsigned long ledZaman = 0;     // LED'in son değiştiği an / last LED toggle
11unsigned long bipZaman = 0;     // bipin başladığı an / beep start
12unsigned long butonZaman = 0;   // butonun son değiştiği an / last button change
13bool ledDurum = false;
14bool bipCaliyor = false;
15int oncekiButon = HIGH;         // önceki buton seviyesi / previous button level
16
17void setup() {
18  pinMode(BUTON_PIN, INPUT_PULLUP);
19  pinMode(LED_PIN, OUTPUT);
20  pinMode(BUZZER_PIN, OUTPUT);
21}
22
23void loop() {
24  unsigned long simdi = millis();
25
26  // 1) LED: zamanı geldiyse durum değiştir / toggle the LED when its time has come
27  if (simdi - ledZaman >= LED_ARALIK) {
28    ledZaman = simdi;
29    ledDurum = !ledDurum;
30    digitalWrite(LED_PIN, ledDurum ? HIGH : LOW);
31  }
32
33  // 2) Buton: yalnızca basıldığı anı yakala / catch only the moment of the press
34  int buton = digitalRead(BUTON_PIN);
35  if (buton != oncekiButon && simdi - butonZaman >= SICRAMA) {
36    butonZaman = simdi;
37    oncekiButon = buton;
38    if (buton == LOW && !bipCaliyor) {  // HIGH -> LOW: yeni basış / new press
39      bipCaliyor = true;
40      bipZaman = simdi;
41      digitalWrite(BUZZER_PIN, HIGH);
42    }
43  }
44
45  // 3) Buzzer: süre dolunca sustur / silence it when the time is up
46  if (bipCaliyor && simdi - bipZaman >= BIP_SURE) {
47    bipCaliyor = false;
48    digitalWrite(BUZZER_PIN, LOW);
49  }
50}

In questa versione LED, pulsante e buzzer funzionano senza aspettarsi a vicenda. Una sottrazione nella forma simdi - ledZaman >= LED_ARALIK dà il risultato giusto anche quando millis() torna a zero, circa ogni 49,7 giorni, mentre il confronto millis() > tempoObiettivo che l'IA a volte scrive va in crisi proprio in quel momento. Rilevare l'istante in cui il pulsante passa da HIGH a LOW evita che il buzzer suoni di continuo mentre tieni premuto, e l'attesa di 30 ms filtra i rimbalzi del contatto (debounce). Trovi l'argomento completo nella guida millis() invece di delay() su Arduino e il collegamento del pulsante in come collegare un pulsante ad Arduino.

Incollare un errore di compilazione e farlo correggere

L'IA è davvero brava a spiegare gli errori di compilazione, a patto che tu le dia l'errore completo e il contesto. Scrivere solo «il codice non funziona» costringe il modello a tirare a indovinare. Segui quest'ordine:

1. Quando nell'Arduino IDE 2 compare un errore di compilazione, premi Copia messaggi di errore nella notifica in basso a destra, oppure seleziona e copia tutto il testo del pannello di output. La scritta exit status 1 nell'ultima riga da sola non serve; la vera causa è più in alto, nella riga con error:.
2. Il tuo prompt deve contenere, in quest'ordine: la scheda e la versione del core, il codice completo, il messaggio di errore completo, il nome e la versione delle librerie installate.
3. Prima di chiedere la correzione, scrivi «Prima spiega la causa dell'errore, poi mostra solo le righe da cambiare». Così il modello non riscrive tutto lo sketch aggiungendo nuovi errori, e tu impari cosa cambia e perché.
4. Applica la modifica proposta e ricompila. Se compare un nuovo errore, incolla di nuovo la prima riga con error:; correggi un solo errore alla volta.
5. Se lo stesso errore resta dopo due o tre giri, interrompi il ciclo e compila l'esempio ufficiale della libreria. Se nemmeno l'esempio compila, il problema non è nel codice ma nell'installazione: scheda sbagliata, libreria mancante o due librerie con lo stesso nome in conflitto.

Se l'errore compare durante il caricamento e non durante la compilazione (per esempio «avrdude: stk500_recv(): programmer is not responding» oppure, sull'ESP32, «Failed to connect to ESP32»), cambiare il codice non serve; devi controllare porta, cavo, driver e scheda selezionata. La guida Arduino non carica lo sketch ti accompagna passo dopo passo in questi casi. Quando chiedi all'IA di un errore di caricamento, indica anche il messaggio completo e il sistema operativo che usi.

Far scrivere all'IA codice per Raspberry Pi Pico e MicroPython

Le stesse regole valgono per il codice MicroPython, ma qui l'IA può anche confondere le piattaforme. Il codice scritto per i computer Raspberry Pi con RPi.GPIO o gpiozero non funziona sul Pico; sul Pico si usa il modulo machine di MicroPython. Anche i moduli board e digitalio di CircuitPython non esistono in MicroPython. Per questo scrivi nel prompt informazioni chiare come «Raspberry Pi Pico W, MicroPython, Thonny». Il codice qui sotto funziona sia sul Pico sia sul Pico W e temporizza con ticks_ms() invece di aspettare:

1# Pico ve Pico W: bekletmeden LED + buton / Pico and Pico W: LED + button without blocking
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)             # Pico W'da Pin(25) çalışmaz / Pin(25) does not work on Pico W
6buton = Pin(14, Pin.IN, Pin.PULL_UP)  # buton: GP14 ile GND arası / button between GP14 and GND
7
8ARALIK = 500                          # LED değişim aralığı, ms / LED toggle interval, ms
9SICRAMA = 30                          # debounce süresi, ms / debounce time, ms
10son = time.ticks_ms()                 # LED'in son değiştiği an / last LED toggle
11degisim = time.ticks_ms()             # butonun son değiştiği an / last button change
12onceki = 1                            # önceki buton seviyesi / previous button level
13sayac = 0
14
15while True:
16    simdi = time.ticks_ms()
17    if time.ticks_diff(simdi, son) >= ARALIK:      # taşmada da doğru / correct even on overflow
18        son = simdi
19        led.toggle()
20    deger = buton.value()
21    if deger != onceki and time.ticks_diff(simdi, degisim) >= SICRAMA:
22        degisim = simdi
23        onceki = deger
24        if deger == 0:                # basıldığı an / moment of the press
25            sayac += 1
26            print("Basma / press:", sayac)

Quando esegui il codice in Thonny, il LED integrato lampeggia ogni mezzo secondo e a ogni pressione del pulsante compare un numero crescente nella finestra Shell. time.ticks_diff() restituisce la differenza corretta anche quando il contatore del tempo riparte da capo, mentre la semplice sottrazione time.ticks_ms() - son che l'IA scrive spesso può dare un risultato sbagliato in un codice che gira a lungo. Se sei alle prime armi con il Pico, parti da Cos'è il Raspberry Pi Pico?

Con la rete a 230 V non fidarti dell'IA

Se il tuo progetto dovrà funzionare con la rete elettrica, provalo prima a bassa tensione: un LED al posto della lampada e una striscia LED a 12 V al posto della presa. Se il sistema deve davvero commutare i 230 V, alcune regole non si discutono. Stacca la spina prima di lavorare sul circuito. Il relè deve interrompere la fase (L), non il neutro. Non superare la corrente e la tensione stampate sul modulo relè (10 A 250 VAC nella maggior parte dei moduli) e chiudi la parte ad alta tensione in una scatola chiusa e isolante. I moduli relè economici spesso lasciano troppo poco spazio tra la parte a bassa e quella ad alta tensione; quando puoi, scegli una presa smart o una scatola relè già pronte e certificate. Trovi il collegamento del modulo relè nei dettagli in Cos'è un modulo relè?

Usare l'IA senza smettere di imparare

Se l'IA scrive ogni sketch al posto tuo, il primo giorno in cui il codice non funziona non saprai cosa fare. Se il tuo obiettivo è imparare l'elettronica e la programmazione, usala non come una macchina per codice, ma come un insegnante paziente:

• Prima scrivi tu: Prova il codice da solo, poi chiedi all'IA di rivederlo con «mostrami gli errori ma non darmi il codice corretto».
• Chiedi indizi, non risposte: Quando ti blocchi, di' «dammi solo un indizio per il passo successivo».
• Fatti spiegare riga per riga: Dopo la spiegazione, prova a raccontare la stessa logica con parole tue; quello che non riesci a spiegare è ciò che non hai ancora imparato.
• Scrivi invece di copiare: Digitare il codice a mano invece di incollarlo ti insegna sintassi e nomi delle funzioni molto più in fretta.
• Prevedi, poi prova: Prima di cambiare un valore, prevedi cosa succederà (per esempio se LED_ARALIK diventa 200), poi carica lo sketch e controlla.
• Mettiti alla prova: Chiedi all'IA di farti cinque domande sull'argomento appena imparato; per ripassare le basi usa le basi della programmazione Arduino.
• Rispetta le regole: Per compiti, progetti scolastici e concorsi scientifici, segui le regole sull'uso dell'IA e dichiara apertamente se l'hai usata.

I primi progetti da provare con l'IA

• Termometro con display: Mostra i valori di un DHT11 su un LCD I2C; indica nel prompt l'indirizzo dell'LCD e l'autore della libreria.
• Sensore di parcheggio: Misura la distanza con un HC-SR04 e fai suonare il buzzer più velocemente man mano che l'ostacolo si avvicina; chiedi una temporizzazione con millis().
• Luce notturna: Accendi un LED quando fa buio con una fotoresistenza (LDR); leggi prima la soglia sul monitor seriale e scrivila come numero nel prompt.
• LED via Wi-Fi: Accendi e spegni un LED da una pagina aperta sullo smartphone con un ESP32; indica nel prompt la versione del core.
• La tua idea: Scegli un progetto dalle idee di progetti Arduino e descrivilo all'IA con il modello di prompt di questa guida.

L'IA può essere l'aiuto più rapido che hai mentre impari Arduino, a patto che tu le dia le informazioni giuste, compili ciò che ti restituisce, controlli i pin, provi un pezzo alla volta e non carichi mai una riga che non capisci. Se cerchi esempi affidabili con cui confrontare il codice scritto dall'IA, nell'app BlueGrays trovi progetti con LED, pulsante, DHT11, PWM su ESP32 e Pico, con schemi elettrici passo passo e codice testato.