Arduino exit status 1: come risolvere gli errori di compilazione

L'errore exit status 1 di Arduino è un messaggio generico che ti dice che il tuo codice non è stato compilato, cioè che il compilatore non è riuscito a trasformare il programma nel codice macchina comprensibile dal processore; la vera causa non è mai scritta su questa riga. Si trova nella prima riga che contiene la parola error:, qualche riga più in alto nel pannello di output: hai scritto male un nome, hai dimenticato un punto e virgola, manca una libreria oppure il codice è stato scritto per un'altra scheda. La notifica Compilation error: exit status 1 in basso a destra nell'Arduino IDE 2 (in italiano Errore di compilazione: exit status 1) e la riga Errore durante la compilazione per la scheda Arduino Uno. della vecchia versione 1.8 significano esattamente la stessa cosa.

In questa guida vedrai prima cosa succede dietro le quinte durante la compilazione e come leggere un messaggio di errore scomponendolo in file, riga e colonna. Poi passeremo in rassegna uno per uno gli errori di compilazione più frequenti: was not declared in this scope, expected ';' before, No such file or directory, does not name a type, redefinition of e Sketch too big. Per ognuno troverai la situazione che lo provoca, il messaggio reale del compilatore e un esempio corretto che compila senza errori. Abbiamo aggiunto anche gli errori dovuti alla scelta della scheda sbagliata, i casi specifici dell'ESP32 e del Raspberry Pi Pico e, alla fine, una tabella errori e soluzioni che riassume tutto. Se il tuo codice compila senza problemi ma non arriva sulla scheda, il problema è in un'altra fase; per quello c'è la guida Arduino non carica lo sketch.

Cos'è exit status 1 su Arduino? Differenza tra compilazione e caricamento

Quando premi Verifica (il segno di spunta) o Carica, l'Arduino IDE esegue diversi programmi in background. Prima unisce i file .ino della cartella dello sketch e li trasforma in un normale file C++, aggiungendo in cima il file di intestazione Arduino.h e i prototipi delle tue funzioni. Poi un compilatore come avr-g++ per la Uno o xtensa-esp32-elf-g++ per l'ESP32 compila quel file e le librerie che usi, il linker unisce tutti i pezzi in un unico programma e infine si controlla se il programma entra nella scheda. Ogni programma, quando termina, restituisce un codice di uscita: 0 significa successo, 1 errore. "exit status 1" dice esattamente questo: uno dei programmi della catena ha fallito. Ecco perché la stessa espressione compare anche quando avrdude fallisce durante il caricamento; il messaggio che la precede ti dice di quale caso si tratta.

Come si legge un messaggio di errore di Arduino?

Ogni riga di errore del compilatore segue lo stesso schema: prima il nome del file, poi i numeri di riga e colonna separati da due punti, quindi il tipo di errore e la sua descrizione. Subito sopra c'è spesso una riga come In function 'void loop()': che indica in quale funzione si trova l'errore; sotto compaiono una copia della riga sbagliata e un piccolo ^ che indica il punto esatto. error è un vero errore che blocca la compilazione, warning è solo un avviso e il codice viene compilato comunque, mentre note aggiunge informazioni al messaggio precedente. Spesso il compilatore aggiunge anche un suggerimento: nell'esempio qui sotto mostra da solo la grafia corretta con suggested alternative: 'digitalWrite'.

1. In File > Preferenze spunta compilazione alla voce Mostra un output dettagliato durante. Così vedrai anche quali file e quali cartelle di librerie ha usato il compilatore.
2. Non serve collegare la scheda: premi il pulsante Verifica (il segno di spunta). Verifica compila soltanto; se l'errore è nella fase di compilazione, premere Carica ti fa solo perdere tempo.
3. Scorri il pannello di output fino in cima e trova la prima riga che contiene error:. La maggior parte degli errori successivi sono conseguenze a catena di questo primo.
4. Vai al numero di riga indicato. L'IDE 2 sottolinea in rosso il carattere con l'errore, la versione 1.8 colora di rosso tutta la riga. Se in quella riga non vedi problemi, guarda quella sopra.
5. Correggi solo quel primo errore e premi di nuovo Verifica. Se il numero di errori cala di colpo, sei sulla strada giusta.
6. Se cerchi su internet, togli dal messaggio i nomi delle tue variabili e i percorsi dei file: cercare was not declared in this scope invece di 'contatore' was not declared in this scope dà molti più risultati. Quando invece chiedi aiuto su un forum, copia tutto l'output.

L'errore 'was not declared in this scope' e come risolverlo

Questo messaggio indica che il compilatore, in quel punto, non riconosce un nome che hai usato; in italiano, "non dichiarato in questo ambito". La causa più frequente è un errore di battitura: Arduino distingue maiuscole e minuscole, quindi digitalwrite, Digitalwrite e digitalWrite sono tre nomi diversi. La seconda grande causa è l'ambito di visibilità (scope): se dichiari una variabile dentro setup(), esiste solo mentre setup() è in esecuzione e loop() non può vederla. Se userai una variabile in più funzioni, dichiarala fuori da tutte, in cima al file. Dichiarare una variabile dopo la riga in cui la usi provoca lo stesso errore, perché il compilatore legge il file dall'alto verso il basso. Infine, questo errore compare anche quando usi un oggetto di cui non hai incluso la libreria (Wire, Servo) o una funzione che la scheda selezionata non ha (Serial1 sulla Uno).

1// Kapsam (scope) örneği / Scope example
2const int LED_PIN = 13;   // global: her fonksiyon görür / global: every function can see it
3int yanmaSayisi = 0;      // setup() içine taşırsan loop() göremez / move it into setup() and loop() can't see it
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8}
9
10void loop() {
11  int sure = 500;                // yerel: yalnız loop() içinde / local: only inside loop()
12  digitalWrite(LED_PIN, HIGH);   // digitalwrite yazarsan: was not declared / typing digitalwrite: was not declared
13  delay(sure);
14  digitalWrite(LED_PIN, LOW);
15  delay(sure);
16  yanmaSayisi++;
17  Serial.println(yanmaSayisi);   // kaç kez yandı / how many times it blinked
18}

'expected ';' before' e altri errori di sintassi

In C++ ogni istruzione termina con un punto e virgola. Quando lo dimentichi alla fine di una riga, il compilatore se ne accorge solo leggendo la parola successiva. Per questo, con il compilatore della Uno, il numero di riga di expected ';' before 'delay' indica la riga sotto lo sbaglio: il punto e virgola mancante è alla fine della riga prima di delay. I compilatori più recenti dei pacchetti ESP32 e Pico, invece, indicano direttamente la fine della riga in cui manca il punto e virgola. Se lo dimentichi nell'ultima riga di una funzione, il messaggio diventa expected ';' before '}' token. Gli errori di parentesi si comportano in modo simile. Se dimentichi di chiudere la graffa di un blocco if o di una funzione, il compilatore legge fino alla fine del file e solo lì dice expected '}' at end of input. Se la graffa non chiusa è dentro setup(), arriva anche a function-definition is not allowed here before '{' token, perché per il compilatore loop() è ora una funzione che stai cercando di definire dentro setup(). Usare virgole al posto dei punti e virgola nelle parentesi di un ciclo for è un altro classico di questa famiglia.

'No such file or directory': libreria non trovata

Le righe fatal error: DHT.h: No such file or directory e il compilation terminated. che segue dicono che il file richiesto da una riga #include del tuo codice non è stato trovato sul computer. La parola "fatal" significa che la compilazione si ferma del tutto in quel punto, quindi non vedrai gli errori nel resto del codice finché non risolvi questo. La causa è quasi sempre una libreria non installata. Quando apri un progetto preso da internet, leggi una per una le righe #include all'inizio e installa la libreria di ciascuna da Strumenti > Gestisci librerie. Se nella finestra che chiede delle dipendenze non scegli Installa tutto, la libreria principale viene installata ma la seconda di cui ha bisogno resta mancante; in quel caso il file del messaggio non è uno scritto da te, ma uno richiamato dalla libreria stessa (per esempio Adafruit_Sensor.h). Contano anche maiuscole e minuscole del nome: su Linux dht.h e DHT.h sono file diversi. Per i tre modi di installare una libreria e i problemi con i file ZIP, consulta la guida Come installare una libreria Arduino.

L'errore 'does not name a type'

does not name a type significa che il compilatore si aspettava un tipo di dato (come int, float, Servo o LiquidCrystal_I2C) all'inizio della riga, ma non riconosce la parola che hai scritto. Le cause comuni sono tre. La prima è dimenticare la riga #include della libreria: se compili Servo sportello; senza Servo.h, ottieni 'Servo' does not name a type. La seconda è scrivere male il tipo: si scrive String e non string, int e non Int, e spesso il compilatore aiuta con did you mean 'String'?. La terza, la più sorprendente, è scrivere un comando fuori da una funzione. Fuori dalle funzioni puoi solo dichiarare: int angolo = 0; è valido, ma se in una riga successiva scrivi soltanto angolo = 90;, il compilatore scambia angolo per il nome di un tipo e segnala 'angolo' does not name a type. C'è poi una trappola tipica di Arduino: l'IDE aggiunge automaticamente i prototipi delle tue funzioni subito prima della prima funzione. Se hai scritto una funzione che restituisce un tuo tipo struct e hai definito lo struct sotto setup(), il prototipo finisce prima dello struct e compare lo stesso errore. La soluzione è spostare le definizioni degli struct in cima al file, prima della prima funzione.

1#include <Servo.h>   // bu satır yoksa: 'Servo' does not name a type / without it: 'Servo' does not name a type
2
3struct Olcum {       // struct'ı ilk fonksiyondan önce tanımla / define structs before the first function
4  int ham;
5  float volt;
6};
7
8Servo kapak;         // tür adı büyük harfle başlar / the type name starts with a capital letter
9int aci = 0;         // dışarıda tanım ve ilk değer serbest / declaring with a value outside is fine
10// aci = 90;         // dışarıda tek başına atama: 'aci' does not name a type / bare assignment outside: error
11
12Olcum potOku() {
13  Olcum o;
14  o.ham = analogRead(A0);           // potansiyometre A0'da / potentiometer on A0
15  o.volt = o.ham * 5.0 / 1023.0;    // 0-1023 değerini volta çevir / convert 0-1023 to volts
16  return o;
17}
18
19void setup() {
20  Serial.begin(9600);
21  kapak.attach(9);   // servo sinyali D9 / servo signal on D9
22}
23
24void loop() {
25  Olcum o = potOku();
26  aci = map(o.ham, 0, 1023, 0, 180);   // atama fonksiyonun içinde / assignment inside a function
27  kapak.write(aci);
28  Serial.println(o.volt);
29  delay(20);
30}

L'errore 'redefinition of': definire due volte la stessa cosa

L'errore redefinition of 'void setup()' dice che ci sono due definizioni con lo stesso nome; la riga note: 'void setup()' previously defined here subito sotto mostra dov'è la prima. Per chi inizia, la causa più comune è incollare due sketch di esempio uno dopo l'altro nello stesso file: ci si ritrova con due setup() e due loop(). La seconda causa sono le schede dell'editor. Prima di compilare, l'Arduino IDE unisce in un unico file tutti i file .ino della cartella dello sketch. Una vecchia copia di backup messa nella cartella (per esempio progetto_vecchio.ino) o una seconda scheda con i propri setup() e loop() provoca questo errore anche se non apri mai quella scheda; la soluzione è togliere quel file dalla cartella. Dichiarare due volte la stessa variabile produce un messaggio simile: redefinition of 'int led'. Il gemello di questo errore nel linker è multiple definition of; compare quando una variabile con un valore assegnato in un file di intestazione (.h) viene inclusa in due file .cpp diversi. Il suo opposto, undefined reference to, indica una funzione di cui hai scritto il prototipo ma mai il corpo, oppure il cui nome hai scritto in modo diverso.

1// İki örneği birleştirmek: tek setup(), tek loop() / Merging two sketches: one setup(), one loop()
2const int LED_PIN = 13;          // 1. örnek: Blink / sketch 1: Blink
3const int POT_PIN = A0;          // 2. örnek: potansiyometre / sketch 2: potentiometer
4unsigned long oncekiZaman = 0;   // millis() zamanlayıcısı / millis() timer
5bool ledDurum = false;
6
7void setup() {
8  pinMode(LED_PIN, OUTPUT);      // 1. örneğin setup içeriği / setup body of sketch 1
9  Serial.begin(9600);            // 2. örneğin setup içeriği / setup body of sketch 2
10}
11
12void loop() {
13  // 1. örnek: delay yerine millis ile yanıp sönme / sketch 1: blink with millis instead of delay
14  if (millis() - oncekiZaman >= 500) {
15    oncekiZaman = millis();
16    ledDurum = !ledDurum;
17    digitalWrite(LED_PIN, ledDurum);
18  }
19  // 2. örnek: potansiyometreyi oku ve yaz / sketch 2: read and print the potentiometer
20  int deger = analogRead(POT_PIN);   // 0-1023 arası / between 0 and 1023
21  Serial.println(deger);
22  delay(50);
23}

Per unire due sketch segui quest'ordine: prima raccogli in cima le righe #include di entrambi senza doppioni, poi aggiungi le variabili globali e le costanti; se un nome esiste in tutti e due, rinominane uno. Quindi metti il contenuto delle due funzioni setup() in un unico setup() e quello dei due loop() in un unico loop(). Se uno degli sketch usa un delay() lungo, rallenterà l'altro; puoi risolvere con la tecnica millis() invece di delay(). Infine controlla se i due sketch usano lo stesso pin: il compilatore non se ne accorge, ma il tuo circuito non funzionerà come previsto.

'Sketch too big' ed errori di memoria insufficiente

Alla fine di ogni compilazione riuscita vedi due righe. Se compili per la Uno l'esempio sull'ambito qui sopra, la riga Sketch uses 2212 bytes (6%) of program storage space. Maximum is 32256 bytes. ti dice quanta memoria flash occupa il programma, e Global variables use 190 bytes (9%) of dynamic memory quanta RAM usano le variabili globali. Se il programma non entra nella flash, supera il 100 per cento e seguono l'avviso Sketch too big e l'errore text section exceeds available space in board. Se invece sono le variabili globali a non entrare nella RAM, vedrai Not enough memory e data section exceeds available space in board. Quando l'uso della RAM supera il 75 per cento, l'IDE può mostrare l'avviso Low memory available, stability problems may occur.: il codice compila, ma siccome durante l'esecuzione non resta spazio per le variabili locali, la scheda può bloccarsi a caso o riavviarsi da sola. Sulla Uno il bootloader occupa 0,5 KB dei 32 KB di flash, per questo il limite è 32256 byte.

1// RAM tasarrufu: F() ve PROGMEM / Saving RAM: F() and PROGMEM
2const char mesaj[] PROGMEM = "Bu uzun metin RAM yerine flasta durur";   // flaşta saklanır / stored in flash
3const byte notalar[] PROGMEM = {60, 62, 64, 65, 67, 69, 71, 72};      // byte: int'in yarısı / byte: half of an int
4
5void setup() {
6  Serial.begin(9600);
7  Serial.println(F("Merhaba! Bu metin de flastan okunur"));   // F(): RAM harcamaz / F(): uses no RAM
8  char tampon[48];                                            // geçici RAM tamponu / temporary RAM buffer
9  strcpy_P(tampon, mesaj);                                    // flaştan RAM'e kopyala / copy from flash to RAM
10  Serial.println(tampon);
11  for (byte i = 0; i < sizeof(notalar); i++) {
12    Serial.print(pgm_read_byte(&notalar[i]));                 // flaştan bir bayt oku / read one byte from flash
13    Serial.print(' ');
14  }
15  Serial.println();
16}
17
18void loop() {
19}

• Metti i testi fissi dentro F(): Serial.println(F("Sistema pronto")); legge il testo direttamente dalla flash senza copiarlo in RAM. Lo stesso vale per i testi fissi mostrati su display LCD e OLED.
• Sposta gli array grandi in PROGMEM: Se tabelle di note, bitmap per display e testi lunghi non cambiano mai, non serve tenerli in RAM. Per tecniche più dettagliate, leggi l'articolo Arduino: memoria insufficiente.
• Scegli il tipo di dato giusto: Per un valore tra 0 e 255 basta byte (1 byte); sulla Uno un int occupa 2 byte, long e float 4.
• Riduci l'uso della classe String: Gli oggetti String concatenati di continuo frammentano la RAM; gli array di char a lunghezza fissa sono più prevedibili.
• Conosci i bisogni nascosti delle librerie per display: Adafruit SSD1306 riserva in fase di esecuzione un buffer da 1 KB per un display OLED 128×64. Questa memoria non compare nel resoconto di compilazione, quindi il display può non avviarsi anche se il resoconto dice 70 per cento.
• Passa a una scheda più grande: Un progetto che non riesci a far stare nella Uno gira tranquillamente sulla Mega o sull'ESP32. Sull'ESP32 puoi portare l'area programma da 1,25 MB a 3 MB scegliendo Huge APP (3MB No OTA/1MB SPIFFS) in Strumenti > Partition Scheme; con questa opzione non sono disponibili gli aggiornamenti via wireless (OTA).

Errori dovuti alla scelta della scheda sbagliata

Il compilatore compila sempre il tuo codice per il processore della scheda scelta in Strumenti > Scheda (nell'IDE 2, nel selettore della scheda in alto). Lo stesso codice può compilare senza errori per la Mega e fallire con la Uno selezionata, perché ogni scheda ha hardware, nomi dei pin e librerie del proprio pacchetto diversi. Quando apri un progetto trovato online, controlla prima per quale scheda è stato scritto: un codice per l'ESP32 non compila con la Uno selezionata, e un codice per la Uno che accede direttamente ai registri del processore non compila con l'ESP32 selezionato. Se la tua scheda non compare proprio nell'elenco, il suo pacchetto non è installato; i pacchetti per ESP32 e Raspberry Pi Pico si installano dal Gestore schede. Trovi i passaggi nella guida Come installare l'Arduino IDE.

Errori di compilazione sull'ESP32

Anche l'ESP32 si programma nel linguaggio di Arduino, ma poiché compilatore e pacchetto scheda sono diversi, un codice che compila senza errori sulla Uno può bloccarsi sull'ESP32. La causa più frequente è la versione del pacchetto: nella versione 3.x del pacchetto Arduino per ESP32 le funzioni PWM sono cambiate; ledcSetup() e ledcAttachPin() sono state rimosse e sostituite da ledcAttach() e ledcWrite(), che lavorano con il numero del pin invece che con un numero di canale. Ecco perché i vecchi esempi trovati online danno 'ledcSetup' was not declared in this scope; o converti il codice alle nuove funzioni o installi la versione 2.0.17 dal Gestore schede. La seconda differenza sono le impostazioni del compilatore. Il pacchetto della Uno compila con l'opzione -fpermissive, che trasforma alcuni errori in semplici avvisi; l'ESP32 non la usa. Per esempio, dichiarare una variabile dentro uno switch senza graffe compila sulla Uno, ma sull'ESP32 dà l'errore jump to case label. I pacchetti ESP32 attuali compilano inoltre con -Werror=return-type: se dimentichi il return in una funzione che deve restituire un valore, ottieni no return statement in function returning non-void ogni volta che i Warning del compilatore non sono impostati su Nessuno. Nella versione 2.x, con i Warning del compilatore su Altro o Tutti, la maggior parte degli avvisi diventa un errore. Per la configurazione di base della scheda, dai un'occhiata all'articolo Cos'è l'ESP32.

1// ESP32 Arduino paketi 3.x / ESP32 Arduino core 3.x
2const int LED_PIN = 2;        // birçok DevKit kartında dahili LED / onboard LED on many DevKit boards
3const int FREKANS = 5000;     // PWM frekansı 5 kHz / PWM frequency 5 kHz
4const int COZUNURLUK = 8;     // 8 bit: 0-255 arası / 8 bits: range 0-255
5
6int parlaklik(int adim) {
7  return (adim % 32) * 8;     // return unutulursa 3.x'te derleme hatası olabilir / a missing return can fail to compile on 3.x
8}
9
10void setup() {
11  Serial.begin(115200);
12  // eski 2.x kodu / old 2.x code: ledcSetup(0, FREKANS, COZUNURLUK); ledcAttachPin(LED_PIN, 0);
13  ledcAttach(LED_PIN, FREKANS, COZUNURLUK);   // 3.x: kanal otomatik seçilir / channel is picked automatically
14}
15
16void loop() {
17  for (int adim = 0; adim < 32; adim++) {
18    ledcWrite(LED_PIN, parlaklik(adim));      // 3.x: pin numarasıyla yaz / write using the pin number
19    delay(30);
20  }
21  if (Serial.available()) {
22    switch (Serial.read()) {
23      case 'h': {                             // case içinde değişken varsa süslü parantez şart / braces needed if a case declares a variable
24        int deger = ledcRead(LED_PIN);
25        Serial.println(deger);
26        break;
27      }
28      default:
29        break;
30    }
31  }
32}

Raspberry Pi Pico: errori con Arduino IDE e MicroPython

Se programmi il Pico con l'Arduino IDE, cioè con il pacchetto arduino-pico di Earle Philhower, il compilatore resta GCC e tutti i messaggi di questo articolo valgono così come sono. Con MicroPython è diverso: non c'è una fase di compilazione preliminare; il Pico trasforma il file in bytecode all'avvio e lo esegue riga per riga. Per questo gli errori compaiono nel pannello Shell in basso in Thonny, in un messaggio che inizia con Traceback (most recent call last):. Leggilo dal basso verso l'alto: l'ultima riga indica il tipo di errore e la descrizione, mentre il line 7 sopra indica la riga in cui si trova. Gli errori di sintassi (SyntaxError, IndentationError) vengono segnalati prima ancora che il programma parta; gli altri compaiono solo quando il programma arriva a quella riga, quindi il tuo codice può funzionare per un po' e poi fermarsi. Per installare MicroPython e muovere i primi passi, leggi l'articolo Cos'è il Raspberry Pi Pico.

1from machine import Pin
2import time
3
4led = Pin("LED", Pin.OUT)     # Pico ve Pico W dahili LED / onboard LED on Pico and Pico W
5sayac = 0
6
7while True:                   # iki nokta unutulursa SyntaxError / a missing colon gives SyntaxError
8    led.toggle()              # blok içinde 4 boşluk girinti / 4-space indent inside the block
9    sayac += 1
10    print("Sayac:", sayac)    # "Sayac: " + sayac yazmak TypeError verir / "Sayac: " + sayac raises TypeError
11    time.sleep(0.5)

Tabella degli errori di compilazione di Arduino e delle soluzioni

Prossimi passi per scrivere codice senza errori

• Consolida le basi: L'articolo Basi di programmazione Arduino spiega variabili, ambito, funzioni e cicli; la maggior parte degli errori di questo articolo nasce da questi argomenti.
• Impara la scrittura esatta dei comandi: L'elenco dei comandi Arduino mostra con esempi la sintassi e i parametri di ogni comando.
• Installa bene le librerie: La guida Come installare una libreria Arduino tratta nel dettaglio i messaggi No such file or directory e Multiple libraries were found.
• Guarda cosa fa il codice mentre gira: Con un codice che compila ma non si comporta come ti aspetti, stampare le variabili nel Monitor seriale è il modo più rapido per fare la diagnosi.
• Provalo senza scheda: Nei simulatori Wokwi o Tinkercad puoi compilare il codice ed eseguirlo insieme al circuito.
• Controlla il codice scritto dall'IA: Il codice generato dai chatbot è spesso pensato per vecchie versioni delle librerie o per un'altra scheda; l'articolo Codice Arduino con l'IA spiega come scovare questi problemi.

Gli errori di compilazione all'inizio fanno paura, ma in realtà il compilatore ti dice dov'è il problema e spesso anche come risolverlo: file, riga, colonna e una breve descrizione. Leggi il primo errore, correggi solo quello, ricompila e ripeti il ciclo; dopo qualche progetto li risolverai in pochi secondi. Quando il tuo codice compila ed è sulla scheda, puoi continuare con i progetti di LED, pulsanti, sensori e display dell'app BlueGrays: per Arduino, ESP32 e Raspberry Pi Pico ogni progetto ha lo schema del circuito e un codice che compila senza errori, passo dopo passo.