Arduino exit status 1: Fehler beim Kompilieren finden und lösen

Der Arduino-Fehler exit status 1 ist eine allgemeine Meldung, die dir sagt, dass dein Code nicht kompiliert werden konnte, der Compiler dein Programm also nicht in Maschinencode für den Prozessor übersetzen konnte; die eigentliche Ursache steht nie in dieser Zeile. Sie steht in der ersten Zeile mit dem Wort error:, ein paar Zeilen weiter oben im Ausgabefenster: Du hast einen Namen falsch geschrieben, ein Semikolon vergessen, eine Bibliothek fehlt oder der Code wurde für ein anderes Board geschrieben. Die Meldung Compilation error: exit status 1 unten rechts in der Arduino IDE 2 (auf Deutsch Fehler beim kompilieren: exit status 1) und die Zeile Fehler beim Kompilieren für das Board Arduino Uno. aus der alten Version 1.8 bedeuten genau dasselbe.

In dieser Anleitung siehst du zuerst, was beim Kompilieren im Hintergrund passiert und wie du eine Fehlermeldung in Datei, Zeile und Spalte zerlegst. Danach gehen wir die häufigsten Kompilierfehler einzeln durch: was not declared in this scope, expected ';' before, No such file or directory, does not name a type, redefinition of und Sketch too big. Zu jedem findest du die Situation, die ihn auslöst, die echte Meldung des Compilers und ein korrigiertes Beispiel, das fehlerfrei kompiliert. Außerdem behandeln wir Fehler durch die falsche Board-Auswahl, Besonderheiten beim ESP32 und Raspberry Pi Pico sowie am Ende eine Fehler-Lösungs-Tabelle, die alles zusammenfasst. Wenn dein Code fehlerfrei kompiliert, aber nicht auf das Board kommt, liegt das Problem in einer anderen Phase; dafür ist die Anleitung Arduino Sketch lässt sich nicht hochladen da.

Was ist Arduino exit status 1? Kompilieren und Hochladen im Vergleich

Wenn du auf Überprüfen (das Häkchen) oder Hochladen klickst, startet die Arduino IDE im Hintergrund mehrere Programme. Zuerst fügt sie die .ino-Dateien im Sketch-Ordner zusammen und macht daraus eine gewöhnliche C++-Datei, indem sie oben die Header-Datei Arduino.h und die Prototypen deiner Funktionen einfügt. Dann kompiliert ein Compiler wie avr-g++ für den Uno oder xtensa-esp32-elf-g++ für den ESP32 diese Datei und die verwendeten Bibliotheken, der Linker fügt alle Teile zu einem Programm zusammen, und zum Schluss wird geprüft, ob das Programm auf das Board passt. Jedes Programm gibt am Ende einen Exit-Code zurück: 0 bedeutet Erfolg, 1 einen Fehler. "exit status 1" sagt genau das: Eines der Programme in dieser Kette ist gescheitert. Deshalb taucht derselbe Ausdruck auch auf, wenn avrdude beim Hochladen scheitert; welcher Fall vorliegt, verrät dir die Meldung davor.

Wie liest man eine Arduino-Fehlermeldung?

Jede Fehlerzeile des Compilers folgt demselben Muster: zuerst der Dateiname, dann durch Doppelpunkte getrennt die Zeilen- und Spaltennummer, danach die Art des Fehlers und seine Beschreibung. Direkt darüber steht oft eine Zeile wie In function 'void loop()':, die dir sagt, in welcher Funktion der Fehler liegt; darunter folgen eine Kopie der fehlerhaften Zeile und ein kleines ^, das auf die Problemstelle zeigt. error ist ein echter Fehler, der das Kompilieren abbricht, warning ist nur eine Warnung und der Code wird trotzdem kompiliert, note liefert Zusatzinfos zur vorigen Meldung. Oft hängt der Compiler auch einen Vorschlag an: Im Beispiel unten zeigt er mit suggested alternative: 'digitalWrite' selbst die richtige Schreibweise.

1. Setze unter Datei > Einstellungen in der Zeile Compiler-Meldungen anzeigen beim den Haken bei Kompilieren. So siehst du auch, welche Dateien und Bibliotheksordner der Compiler verwendet hat.
2. Das Board muss nicht angeschlossen sein: Klicke auf Überprüfen (das Häkchen). Überprüfen kompiliert nur; liegt der Fehler beim Kompilieren, kostet dich ein Klick auf Hochladen nur Zeit.
3. Scrolle im Ausgabefenster ganz nach oben und suche die erste Zeile mit error:. Die meisten Fehler danach sind Folgefehler dieses ersten.
4. Springe zur Zeilennummer aus der Meldung. Die IDE 2 unterstreicht das fehlerhafte Zeichen rot, Version 1.8 färbt die ganze Zeile rot. Siehst du in dieser Zeile kein Problem, schau eine Zeile darüber.
5. Behebe nur diesen ersten Fehler und klicke erneut auf Überprüfen. Wenn die Zahl der Fehler plötzlich sinkt, bist du auf dem richtigen Weg.
6. Wenn du im Internet suchst, entferne deine eigenen Variablennamen und Dateipfade aus der Meldung: was not declared in this scope statt 'zaehler' was not declared in this scope liefert viel mehr Treffer. Wenn du in einem Forum um Hilfe bittest, kopiere dagegen die komplette Ausgabe.

Fehler 'was not declared in this scope' und seine Lösung

Diese Meldung bedeutet, dass der Compiler einen Namen an dieser Stelle nicht kennt, auf Deutsch etwa "in diesem Gültigkeitsbereich nicht deklariert". Die häufigste Ursache ist ein Tippfehler: Arduino unterscheidet Groß- und Kleinschreibung, digitalwrite, Digitalwrite und digitalWrite sind drei verschiedene Namen. Die zweite große Ursache ist der Gültigkeitsbereich (Scope): Deklarierst du eine Variable in setup(), lebt sie nur, solange setup() läuft, und loop() kann sie nicht sehen. Brauchst du eine Variable in mehreren Funktionen, deklariere sie außerhalb aller Funktionen ganz oben in der Datei. Auch eine Variable, die erst nach der Zeile deklariert wird, in der du sie benutzt, löst denselben Fehler aus, weil der Compiler die Datei von oben nach unten liest. Und schließlich erscheint der Fehler, wenn du ein Objekt nutzt, dessen Bibliothek du nicht eingebunden hast (Wire, Servo), oder eine Funktion, die das gewählte Board nicht hat (Serial1 auf dem 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' und andere Syntaxfehler

In C++ endet jede Anweisung mit einem Semikolon. Vergisst du es am Ende einer Zeile, merkt der Compiler das erst, wenn er das nächste Wort liest. Deshalb zeigt die Zeilennummer in expected ';' before 'delay' beim Compiler des Uno auf die Zeile unter dem Fehler: Das fehlende Semikolon gehört ans Ende der Zeile vor delay. Die neueren Compiler der ESP32- und Pico-Pakete zeigen dagegen direkt auf das Ende der Zeile, in der das Semikolon fehlt. Vergisst du es in der letzten Zeile einer Funktion, lautet die Meldung expected ';' before '}' token. Klammerfehler verhalten sich ähnlich. Schließt du die geschweifte Klammer eines if-Blocks oder einer Funktion nicht, liest der Compiler bis zum Dateiende weiter und meldet erst dort expected '}' at end of input. Liegt die offene Klammer in setup(), kommt zusätzlich a function-definition is not allowed here before '{' token, denn für den Compiler ist loop() jetzt eine Funktion, die du innerhalb von setup() definieren willst. Kommas statt Semikolons in der Klammer einer for-Schleife sind ein weiterer Klassiker dieser Familie.

'No such file or directory': Bibliothek nicht gefunden

Die Zeilen fatal error: DHT.h: No such file or directory und das folgende compilation terminated. sagen, dass die Datei, die eine #include-Zeile in deinem Code anfordert, auf deinem Rechner nicht gefunden wurde. Das Wort "fatal" heißt, dass das Kompilieren an dieser Stelle komplett abbricht; Fehler im restlichen Code siehst du erst, wenn dieser behoben ist. Die Ursache ist fast immer eine nicht installierte Bibliothek. Wenn du ein Projekt aus dem Internet öffnest, lies die #include-Zeilen am Anfang nacheinander und installiere die jeweilige Bibliothek über Werkzeuge > Bibliotheken verwalten. Wählst du im Fenster mit den Abhängigkeiten nicht Alle installieren, wird zwar die Hauptbibliothek installiert, aber die zweite, die sie braucht, fehlt; dann steht in der Meldung nicht eine Datei aus deinem Code, sondern eine, die die Bibliothek selbst aufruft (zum Beispiel Adafruit_Sensor.h). Auch die Groß- und Kleinschreibung des Dateinamens zählt: Unter Linux sind dht.h und DHT.h verschiedene Dateien. Die drei Wege, eine Bibliothek zu installieren, und ZIP-Probleme findest du in der Anleitung Arduino-Bibliothek installieren.

Der Fehler 'does not name a type'

does not name a type bedeutet, dass der Compiler am Zeilenanfang einen Datentyp (wie int, float, Servo oder LiquidCrystal_I2C) erwartet, das geschriebene Wort aber nicht kennt. Es gibt drei häufige Ursachen. Die erste ist eine vergessene #include-Zeile: Wird Servo klappe; ohne Servo.h kompiliert, kommt 'Servo' does not name a type. Die zweite ist ein falsch geschriebener Typ: Richtig ist String statt string und int statt Int, und oft hilft der Compiler mit did you mean 'String'?. Die dritte und überraschendste ist ein Befehl außerhalb einer Funktion. Außerhalb von Funktionen darfst du nur deklarieren: int winkel = 0; ist gültig, schreibst du aber in einer späteren Zeile nur winkel = 90;, hält der Compiler winkel für einen Typnamen und meldet 'winkel' does not name a type. Dazu kommt eine Arduino-typische Falle: Die IDE fügt die Prototypen deiner Funktionen automatisch direkt vor der ersten Funktion ein. Hast du eine Funktion geschrieben, die einen eigenen struct-Typ zurückgibt, und den struct unter setup() definiert, landet der Prototyp vor dem struct und es kommt derselbe Fehler. Die Lösung: struct-Definitionen ganz nach oben schreiben, vor die erste Funktion.

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}

Der Fehler 'redefinition of': dasselbe doppelt definiert

Der Fehler redefinition of 'void setup()' sagt, dass es zwei Definitionen mit demselben Namen gibt; die Zeile note: 'void setup()' previously defined here direkt darunter zeigt, wo die erste steht. Bei Einsteigern ist die häufigste Ursache, dass zwei Beispielsketches hintereinander in eine Datei kopiert wurden: Dann gibt es zwei setup() und zwei loop(). Die zweite Ursache sind Tabs. Vor dem Kompilieren fügt die Arduino IDE alle .ino-Dateien im Sketch-Ordner zu einer zusammen. Eine alte Sicherungskopie im Ordner (zum Beispiel projekt_alt.ino) oder ein zweiter Tab mit eigenem setup() und loop() löst diesen Fehler aus, selbst wenn du den Tab nie öffnest; die Lösung ist, die Datei aus dem Ordner zu entfernen. Wird dieselbe Variable zweimal deklariert, kommt eine ähnliche Meldung: redefinition of 'int led'. Das Gegenstück beim Linker heißt multiple definition of; es erscheint, wenn eine Variable mit Wertzuweisung in einer Header-Datei (.h) in zwei verschiedene .cpp-Dateien eingebunden wird. Das Gegenteil, undefined reference to, weist auf eine Funktion hin, deren Prototyp du geschrieben hast, deren Rumpf aber fehlt oder deren Name anders geschrieben ist.

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}

Halte dich beim Zusammenführen an diese Reihenfolge: Sammle zuerst die #include-Zeilen beider Sketches ohne Dopplungen oben, füge dann globale Variablen und Konstanten hinzu; gibt es einen Namen in beiden, benenne einen um. Danach kommt der Inhalt beider setup()-Funktionen in ein einziges setup() und der Inhalt beider loop()-Funktionen in ein einziges loop(). Nutzt einer der Sketches ein langes delay(), bremst er den anderen aus; das löst du mit der Methode millis() statt delay(). Prüfe zum Schluss, ob beide Sketches denselben Pin benutzen: Der Compiler bemerkt das nicht, aber deine Schaltung funktioniert dann nicht wie erwartet.

'Sketch too big' und Fehler bei zu wenig Speicher

Am Ende jedes erfolgreichen Kompilierens siehst du zwei Zeilen. Kompilierst du das Scope-Beispiel oben für den Uno, sagt dir die Zeile Sketch uses 2212 bytes (6%) of program storage space. Maximum is 32256 bytes., wie viel Flash-Speicher das Programm belegt, und Global variables use 190 bytes (9%) of dynamic memory, wie viel RAM die globalen Variablen brauchen. Passt das Programm nicht in den Flash, steigt der Wert über 100 Prozent, gefolgt von der Warnung Sketch too big und dem Fehler text section exceeds available space in board. Passen die globalen Variablen nicht in den RAM, siehst du stattdessen Not enough memory und data section exceeds available space in board. Liegt die RAM-Auslastung über 75 Prozent, kann die IDE die Warnung Low memory available, stability problems may occur. ausgeben: Der Code wird kompiliert, aber weil zur Laufzeit kein Platz für lokale Variablen bleibt, kann das Board zufällig hängen bleiben oder von selbst neu starten. Beim Uno belegt der Bootloader 0,5 KB der 32 KB Flash, deshalb liegt die Grenze bei 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}

• Feste Texte in F() packen: Serial.println(F("System bereit")); liest den Text direkt aus dem Flash, ohne ihn in den RAM zu kopieren. Das gilt auch für feste Texte auf LCD- und OLED-Displays.
• Große Arrays in PROGMEM verschieben: Notentabellen, Display-Bitmaps und lange Texte müssen nicht im RAM liegen, wenn sie sich nie ändern. Ausführlichere Techniken findest du im Artikel Arduino: zu wenig Speicher.
• Den passenden Datentyp wählen: Für einen Wert zwischen 0 und 255 reicht byte (1 Byte); ein int belegt auf dem Uno 2 Byte, long und float je 4 Byte.
• Die String-Klasse sparsam einsetzen: Ständig zusammengesetzte String-Objekte zerstückeln den RAM; char-Arrays fester Länge sind berechenbarer.
• Den versteckten Bedarf von Display-Bibliotheken kennen: Adafruit SSD1306 reserviert für ein 128×64-OLED-Display erst zur Laufzeit einen Puffer von 1 KB. Dieser Speicher taucht im Kompilierbericht nicht auf; das Display kann also ausfallen, obwohl der Bericht 70 Prozent anzeigt.
• Auf ein größeres Board umsteigen: Ein Projekt, das nicht auf den Uno passt, läuft auf dem Mega oder ESP32 problemlos. Beim ESP32 vergrößerst du den Programmbereich von 1,25 MB auf 3 MB, indem du unter Werkzeuge > Partition Scheme die Option Huge APP (3MB No OTA/1MB SPIFFS) wählst; Updates per Funk (OTA) sind damit nicht möglich.

Fehler durch die falsche Board-Auswahl

Der Compiler übersetzt deinen Code immer für den Prozessor des Boards, das unter Werkzeuge > Board (in der IDE 2 in der Board-Auswahl oben) eingestellt ist. Derselbe Code kann für den Mega fehlerfrei kompilieren und mit gewähltem Uno scheitern, denn jedes Board hat eigene Hardware, eigene Pin-Namen und eigene Bibliotheken aus seinem Board-Paket. Wenn du ein Projekt aus dem Internet öffnest, prüfe zuerst, für welches Board es geschrieben wurde: Code für den ESP32 kompiliert nicht mit gewähltem Uno, und Uno-Code, der direkt auf die Register des Prozessors zugreift, kompiliert nicht mit gewähltem ESP32. Taucht dein Board gar nicht in der Liste auf, ist sein Board-Paket nicht installiert; die Pakete für ESP32 und Raspberry Pi Pico installierst du über die Board-Verwaltung. Die Schritte findest du in der Anleitung Arduino IDE installieren.

Kompilierfehler beim ESP32

Auch der ESP32 wird in der Arduino-Sprache programmiert, aber weil Compiler und Board-Paket andere sind, kann Code, der auf dem Uno fehlerfrei kompiliert, auf dem ESP32 hängen bleiben. Der häufigste Grund ist die Paketversion: In Version 3.x des ESP32-Arduino-Pakets haben sich die PWM-Funktionen geändert; ledcSetup() und ledcAttachPin() wurden entfernt und durch ledcAttach() und ledcWrite() ersetzt, die mit der Pinnummer statt einer Kanalnummer arbeiten. Ältere Beispiele aus dem Internet liefern deshalb 'ledcSetup' was not declared in this scope; entweder stellst du den Code auf die neuen Funktionen um oder installierst über die Board-Verwaltung Version 2.0.17. Der zweite Unterschied sind die Compiler-Einstellungen. Das Uno-Paket kompiliert mit der Option -fpermissive, die manche Fehler zu Warnungen herabstuft; beim ESP32 fehlt sie. Eine Variable ohne geschweifte Klammern in einem switch-case zu deklarieren, kompiliert deshalb auf dem Uno, liefert auf dem ESP32 aber den Fehler jump to case label. Aktuelle ESP32-Pakete kompilieren außerdem mit -Werror=return-type: Vergisst du das return in einer Funktion, die einen Wert zurückgeben muss, bekommst du no return statement in function returning non-void, sobald Compiler-Meldungen auf etwas anderes als Keine steht. In Version 2.x werden mit Compiler-Meldungen auf Mehr oder Alle die meisten Warnungen zu Fehlern. Zur Grundeinrichtung des Boards wirf einen Blick in den Artikel Was ist der 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: Fehler in Arduino IDE und MicroPython

Programmierst du den Pico mit der Arduino IDE, also mit dem arduino-pico-Paket von Earle Philhower, ist der Compiler weiterhin GCC und alle Meldungen aus diesem Artikel gelten unverändert. Bei MicroPython ist es anders: Es gibt keinen vorgelagerten Kompilierschritt; der Pico übersetzt die Datei beim Start in Bytecode und führt sie Zeile für Zeile aus. Deshalb erscheinen Fehler im Shell-Bereich unten in Thonny, in einer Meldung, die mit Traceback (most recent call last): beginnt. Lies diese Meldung von unten nach oben: Die letzte Zeile nennt Fehlerart und Beschreibung, die Angabe line 7 darüber die Zeile. Syntaxfehler (SyntaxError, IndentationError) werden gemeldet, bevor das Programm überhaupt startet; andere Fehler tauchen erst auf, wenn das Programm die betreffende Zeile erreicht, dein Code kann also eine Weile laufen und dann stehen bleiben. Zur Installation von MicroPython und den ersten Schritten lies den Artikel Was ist der 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)

Tabelle: Arduino-Kompilierfehler und ihre Lösungen

Nächste Schritte zu fehlerfreiem Code

• Grundlagen festigen: Der Artikel Arduino-Programmierung: Grundlagen erklärt Variablen, Gültigkeitsbereiche, Funktionen und Schleifen; die meisten Fehler aus diesem Artikel haben dort ihren Ursprung.
• Befehle richtig schreiben: Die Liste der Arduino-Befehle zeigt Syntax und Parameter jedes Befehls mit Beispielen.
• Bibliotheken richtig installieren: Die Anleitung Arduino-Bibliothek installieren behandelt die Meldungen No such file or directory und Multiple libraries were found ausführlich.
• Sehen, was dein Code zur Laufzeit tut: Bei Code, der kompiliert, sich aber nicht wie erwartet verhält, ist die Ausgabe von Variablen im seriellen Monitor der schnellste Weg zur Diagnose.
• Ohne Board testen: In den Simulatoren Wokwi oder Tinkercad kannst du deinen Code kompilieren und zusammen mit der Schaltung ausführen.
• KI-Code prüfen: Code von Chatbots ist oft für alte Bibliotheksversionen oder ein anderes Board geschrieben; der Artikel Arduino-Code mit KI zeigt, wie du solche Probleme erkennst.

Kompilierfehler wirken anfangs abschreckend, aber eigentlich sagt dir der Compiler, wo das Problem liegt, und oft auch, wie du es löst: Datei, Zeile, Spalte und eine kurze Beschreibung. Lies den ersten Fehler, behebe nur diesen, kompiliere neu und wiederhole das; nach ein paar Projekten löst du solche Fehler in Sekunden. Sobald dein Code kompiliert und auf dem Board ist, kannst du mit den LED-, Taster-, Sensor- und Display-Projekten in der BlueGrays-App weitermachen: Für Arduino, ESP32 und Raspberry Pi Pico gibt es zu jedem Projekt einen Schaltplan und fehlerfrei kompilierenden Code, Schritt für Schritt.