Arduino Code mit KI erstellen: Prompts, Prüfung und Fehler

Arduino Code mit KI erstellen heißt, einem Chat-Assistenten wie ChatGPT, Gemini, Claude oder Copilot dein Projekt zu beschreiben und ihn um funktionierenden Code für einen Arduino, ESP32 oder Raspberry Pi Pico zu bitten. Richtig eingesetzt macht das aus Stunden Minuten: Statt vor einer leeren Seite zu sitzen, hast du einen Entwurf, der bereit zum Kompilieren ist. Aber die KI sieht deine Schaltung nicht, kennt das Board auf deinem Tisch nicht und kann etwas Falsches mit voller Überzeugung behaupten. Sie erfindet vielleicht eine Bibliotheksfunktion, die es nicht gibt, wählt den falschen Pin oder schreibt delay()-Schleifen, die alles blockieren. Die eigentliche Fähigkeit ist deshalb nicht, nach Code zu fragen, sondern gut zu fragen und das Ergebnis zu prüfen.

In dieser Anleitung erfährst du, wie ein KI-Assistent Arduino-Code erzeugt und warum er sich irrt, wie du einen guten Prompt mit Board, Pins, Bibliotheken und erwartetem Verhalten schreibst und mit welchen Schritten du den Code prüfst, bevor du ihn hochlädst. Die drei häufigsten Fehler sehen wir uns mit echten Compiler-Meldungen und korrigiertem Code an. Danach geht es darum, wie du einen Kompilierfehler richtig einfügst und beheben lässt, warum du der KI bei 230 V Netzspannung nicht vertrauen solltest und wie du diese Werkzeuge nutzt, ohne mit dem Lernen aufzuhören.

Wie schreibt eine KI Arduino-Code und warum irrt sie sich?

Große Sprachmodelle (LLMs) wie ChatGPT schreiben Code nicht, indem sie ihn wie ein Compiler ausführen, sondern indem sie aus Millionen von Beispielen aus dem Training die wahrscheinlichste Fortsetzung vorhersagen. Bei Themen mit vielen Beispielen im Netz (LED blinken lassen, DHT11 auslesen, Servo drehen) klappt das sehr gut. Das Wissen des Modells ist aber auf einem bestimmten Stand eingefroren, sodass es Funktionen, die sich in neueren Bibliotheksversionen geändert haben, womöglich nicht kennt. Es kann die Funktionen zweier verschiedener Bibliotheken mit gleichem Namen verwechseln. Vor allem erfindet es manchmal eine plausibel klingende Antwort, statt „weiß ich nicht“ zu sagen; das nennt man Halluzination. Weil das Modell deine Schaltung nicht sieht, leitet es Pinnummern, Spannungspegel und Modulversionen entweder aus deinen Angaben oder aus eigenen Vermutungen ab.

Wie schreibt man einen guten Prompt?

Der Code der KI kann nicht besser sein als die Informationen, die du ihr gibst. Bei einer Ein-Satz-Anfrage wie „Schreib Arduino-Code zum Temperaturmessen“ wählt das Modell Board, Sensor, Pin und Bibliothek selbst aus. Passt diese Auswahl nicht zu deinen Bauteilen, lässt sich der Code nicht kompilieren, oder er kompiliert und funktioniert trotzdem nicht. Schreib einen guten Prompt so, als würdest du das Projekt einem Freund am Telefon erklären, der zum ersten Mal davon hört: Board, Bauteile, Verbindungen, Bibliotheken, erwartetes Verhalten und Einschränkungen nennst du einzeln. Die Tabelle fasst zusammen, was in einen Arduino-Prompt gehört:

Dieser Prompt liefert zum Beispiel deutlich bessere Ergebnisse als eine Ein-Satz-Anfrage: „Ich nutze einen Arduino Uno R3 und die Arduino IDE 2.3. Der DATA-Pin des DHT22 hängt an D2, ein aktiver Summer an D8, und ein 16x2-I2C-LCD (PCF8574, Adresse 0x27) hat SDA an A4 und SCL an A5. Installiert sind die Adafruit DHT sensor library und die LiquidCrystal-I2C-Bibliothek von Frank de Brabander. Zeig alle 2 Sekunden Temperatur und Luftfeuchtigkeit auf dem LCD an und lass den Summer kurz piepen, wenn die Temperatur über 30 °C steigt. Verwende millis() statt delay() und kommentiere die Zeilen auf Deutsch. Liste am Anfang die Bibliotheken auf, die ich installieren muss, und am Ende deine Annahmen.“ Bei diesem Prompt bleibt dem Modell kaum noch etwas zu raten.

So prüfst du KI-generierten Code

Egal wie ordentlich der Code aussieht: Geh vor dem Hochladen eine Checkliste durch. Die meisten Schritte dauern nur ein paar Minuten und sind viel billiger als ein Modul, das wegen eines falsch angeschlossenen Pins durchbrennt:

1. Zuerst nur kompilieren: Klick ohne angeschlossenes Board auf Überprüfen (das Häkchen). Kommt ein Fehler, lass ihn mit der Methode weiter unten beheben; was die Meldungen bedeuten, steht unter Arduino-Kompilierfehler.
2. Bibliotheken einzeln prüfen: Such jede #include-Zeile im Bibliotheksverwalter und installiere die Bibliothek, deren Name, Autor und Beispiele zum Code passen. Wie das geht, zeigt die Anleitung Arduino-Bibliothek hinzufügen Schritt für Schritt.
3. Pins vergleichen: Vergleich jede Pinnummer im Code mit deiner Verkabelung und der Pinbelegung des Boards. Für PWM-Pins und Pins, die du meiden solltest, hilft das Werkzeug Pinout.
4. Elektrische Werte nachrechnen: Prüf den vorgeschlagenen Widerstandswert mit dem Rechner LED-Vorwiderstand. Soll ein Sensor mit 5-V-Ausgang an einen ESP32 oder Pico mit 3,3 V, gehört ein Spannungsteiler dazwischen.
5. Im Simulator testen: Lass den Code in Wokwi oder Tinkercad laufen, bevor du echte Hardware anschließt; so findest du Logikfehler, ohne Bauteile zu riskieren.
6. Schritt für Schritt testen: Lade nicht das ganze Projekt auf einmal hoch. Probier zuerst einen kleinen Sketch, der nur den Sensor ausliest und im Seriellen Monitor ausgibt, dann füg das Display hinzu und zuletzt den Summer oder das Relais.
7. Mit dem Seriellen Monitor beobachten: Setz an wichtigen Stellen Serial.println() ein, um zu sehen, ob Variablen die erwarteten Werte annehmen, und achte darauf, dass die Baudrate zu Serial.begin() im Code passt. Mehr dazu unter Arduino Serieller Monitor.
8. Code erklären lassen: Frag bei jeder Zeile, die du nicht verstehst: „Was macht diese Zeile, und was passiert, wenn ich sie lösche?“ Lade keinen Code hoch, den du nicht erklären kannst.

Häufiger Fehler 1: Bibliotheksfunktionen, die es nicht gibt

Der heimtückischste Fehler der KI sind Funktionen, die es gar nicht gibt, deren Namen aber sehr plausibel klingen. Die Standard-Servo-Bibliothek hat zum Beispiel attach(), write(), writeMicroseconds(), read() und detach(), aber keine setSpeed()-Funktion für die Geschwindigkeit; das Modell erfindet sie womöglich, wenn du einen langsam drehenden Servo willst. Manchmal gibt es die Funktion wirklich, aber auf einem anderen Board: Serial.printf() funktioniert auf dem ESP32, lässt sich auf dem Arduino Uno aber nicht kompilieren. Und manchmal stammt die Funktion aus einer alten Version: In der 2024 erschienenen Version 3.x des ESP32-Arduino-Cores wurden ledcSetup() und ledcAttachPin() entfernt, trotzdem schreiben die meisten Modelle noch Code damit. Dazu kommen verschiedene Bibliotheken mit derselben Header-Datei: Bei einer Bibliothek namens LiquidCrystal_I2C.h startet man das Display mit lcd.init(), bei einer gleichnamigen anderen mit lcd.begin(). Siehst du in der Compiler-Ausgabe die Warnung „Multiple libraries were found“, steckt wahrscheinlich diese Verwechslung dahinter.

Die Altlast beim ESP32: ledcAttach statt ledcSetup

Fragst du nach ESP32-Code, der LED-Helligkeit oder Motordrehzahl regelt, schreibt die KI höchstwahrscheinlich das Trio ledcSetup(Kanal, Frequenz, Auflösung), ledcAttachPin(Pin, Kanal) und ledcWrite(Kanal, Wert). Dieser Code läuft mit Version 2.x des Cores. In Version 3.x werden die Kanäle dagegen automatisch vergeben: ledcAttach(Pin, Frequenz, Auflösung) richtet den Pin in einem Schritt ein, und ledcWrite(Pin, Wert) erwartet jetzt eine Pinnummer statt eines Kanals. Welche Version installiert ist, siehst du im Boardverwalter neben dem esp32-Paket. Der folgende Code prüft die Version beim Kompilieren und läuft deshalb mit beiden Cores:

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}

Die Lehre gilt nicht nur für den ESP32: Nennst du im Prompt Core- und Bibliotheksversion, hat das Modell eine Chance, die richtigen Funktionen zu wählen. Nutzt es trotz Versionsangabe alte Funktionen, öffne eines der offiziellen Beispiele der Bibliothek unter Datei > Beispiele und füg es mit „Schreib es mit den Funktionen aus diesem Beispiel neu“ in den Prompt ein. Offizielle Beispiele passen immer zur installierten Version. Wie PWM funktioniert, erklärt der Beitrag Was ist PWM?

Häufiger Fehler 2: der falsche Pin

Selbst wenn der Code kompiliert und hochgeladen wird, bedeutet ein falscher Pin eine Schaltung, die stillschweigend nichts tut, oder ein durchgebranntes Modul. Der Compiler kann das nicht erkennen, denn für ihn ist eine Pinnummer nur eine Zahl. Das sind die häufigsten Pin-Fehler der KI, nach Board sortiert:

Häufiger Fehler 3: blockierendes delay()

Weil die meisten Arduino-Beispiele im Netz mit delay() geschrieben sind, verwendet auch die KI standardmäßig delay(). Während delay(1000) läuft, tut der Prozessor eine ganze Sekunde lang nichts anderes: Er liest keine Taster, prüft keine Sensoren und aktualisiert kein Display. In Code mit nur einer Aufgabe ist das kein Problem. Verlangst du aber zwei Dinge gleichzeitig, etwa „LED blinken lassen und bei Tastendruck den Summer piepen lassen“, kommt oft Code wie dieser heraus:

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}

Dieser Code kompiliert fehlerfrei, aber meistens passiert beim Drücken des Tasters nichts. Etwa 2 Sekunden jedes loop()-Durchlaufs vergehen in den beiden delay()-Aufrufen, und der Taster wird nur in den wenigen Mikrosekunden dazwischen gelesen. Ein kurzer Druck verpasst diesen Moment fast immer; damit der Summer sicher piept, musst du den Taster länger als 2 Sekunden halten. Die Lösung heißt nicht warten, sondern auf die Uhr schauen: millis() liefert die Millisekunden seit dem Start, jede Aufgabe prüft, ob ihre Zeit gekommen ist, und loop() läuft tausende Male pro Sekunde:

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 dieser Version arbeiten LED, Taster und Summer, ohne aufeinander zu warten. Eine Subtraktion der Form simdi - ledZaman >= LED_ARALIK liefert auch dann das richtige Ergebnis, wenn millis() etwa alle 49,7 Tage auf null überläuft; der Vergleich millis() > zielZeit, den die KI manchmal schreibt, versagt bei diesem Überlauf. Weil nur der Wechsel des Tasters von HIGH auf LOW zählt, piept der Summer nicht immer wieder, solange der Taster gedrückt bleibt, und die 30 ms Wartezeit filtern das Prellen der Kontakte (Entprellen). Das ganze Thema findest du in der Anleitung Arduino millis() statt delay(), den Anschluss des Tasters unter Taster am Arduino anschließen.

Kompilierfehler einfügen und beheben lassen

Im Erklären von Kompilierfehlern ist die KI wirklich gut, solange du ihr den kompletten Fehler und den Zusammenhang gibst. Nur „der Code geht nicht“ zu schreiben, zwingt das Modell zum Raten. Geh in dieser Reihenfolge vor:

1. Erscheint in der Arduino IDE 2 ein Kompilierfehler, klick in der Benachrichtigung unten rechts auf Fehlermeldungen kopieren oder markiere und kopiere den gesamten Text im Ausgabefenster. Das exit status 1 in der letzten Zeile allein nützt nichts; die eigentliche Ursache steht weiter oben in der Zeile mit error:.
2. Dein Prompt sollte in dieser Reihenfolge enthalten: Board und Core-Version, den vollständigen Code, die vollständige Fehlermeldung sowie Namen und Versionen der installierten Bibliotheken.
3. Bevor du um eine Korrektur bittest, schreib „Erklär zuerst die Ursache des Fehlers und zeig dann nur die Zeilen, die sich ändern müssen“. So schreibt das Modell nicht den ganzen Sketch neu und baut keine neuen Fehler ein, und du lernst, was sich warum ändert.
4. Übernimm die vorgeschlagene Änderung und kompiliere erneut. Taucht ein neuer Fehler auf, füg wieder die oberste error:-Zeile ein; behebe immer nur einen Fehler auf einmal.
5. Bleibt derselbe Fehler nach zwei, drei Runden bestehen, brich die Schleife ab und kompiliere das offizielle Beispiel der Bibliothek. Lässt sich auch das Beispiel nicht kompilieren, liegt das Problem nicht im Code, sondern in der Einrichtung: falsches Board gewählt, fehlende Bibliothek oder zwei gleichnamige Bibliotheken im Konflikt.

Tritt der Fehler nicht beim Kompilieren, sondern beim Hochladen auf (etwa „avrdude: stk500_recv(): programmer is not responding“ oder beim ESP32 „Failed to connect to ESP32“), hilft es nichts, den Code zu ändern; dann musst du Port, Kabel, Treiber und Board-Auswahl prüfen. Die Anleitung Arduino Sketch lässt sich nicht hochladen führt dich Schritt für Schritt durch diese Fälle. Wenn du die KI nach einem Upload-Fehler fragst, gib die komplette Meldung und dein Betriebssystem an.

Code für Raspberry Pi Pico und MicroPython mit KI

Für MicroPython-Code gelten dieselben Regeln, aber hier verwechselt die KI zusätzlich gern Plattformen. Code für Raspberry-Pi-Computer mit RPi.GPIO oder gpiozero läuft nicht auf dem Pico; dort nutzt du das machine-Modul von MicroPython. Die CircuitPython-Module board und digitalio gibt es in MicroPython ebenfalls nicht. Schreib deshalb klare Angaben wie „Raspberry Pi Pico W, MicroPython, Thonny“ in den Prompt. Der folgende Code läuft auf Pico und Pico W und steuert das Timing mit ticks_ms(), statt zu warten:

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)

Startest du den Code in Thonny, blinkt die Onboard-LED im Halbsekundentakt, und bei jedem Tastendruck erscheint im Shell-Fenster eine steigende Zahl. time.ticks_diff() liefert auch dann den richtigen Abstand, wenn der Zeitzähler überläuft; die einfache Subtraktion time.ticks_ms() - son, die die KI oft schreibt, kann in lange laufendem Code ein falsches Ergebnis liefern. Bist du neu beim Pico, fang mit Was ist der Raspberry Pi Pico? an.

Bei 230 V Netzspannung: Trau der KI nicht

Soll dein Projekt mit Netzspannung laufen, teste es zuerst mit Kleinspannung: eine LED statt der Lampe, ein 12-V-LED-Streifen statt der Steckdose. Muss das System wirklich 230 V schalten, sind manche Regeln nicht verhandelbar. Zieh vor jeder Arbeit an der Schaltung den Stecker. Das Relais muss den Außenleiter (L) schalten, nicht den Neutralleiter. Überschreite nie den auf dem Relaismodul aufgedruckten Strom- und Spannungswert (bei den meisten Modulen 10 A 250 VAC) und bring die Hochvoltseite in einem geschlossenen, isolierenden Gehäuse unter. Billige Relaismodule haben oft zu wenig Abstand zwischen Nieder- und Hochvoltseite; nimm nach Möglichkeit eine fertige, zertifizierte smarte Steckdose oder Relaisbox. Den Anschluss eines Relaismoduls findest du ausführlich unter Was ist ein Relaismodul?

KI nutzen, ohne das Lernen aufzugeben

Schreibt die KI jeden Sketch für dich, weißt du am ersten Tag, an dem der Code nicht läuft, nicht weiter. Wenn du Elektronik und Programmieren lernen willst, nutze sie nicht als Codeautomaten, sondern als geduldige Lehrerin:

• Schreib zuerst selbst: Probier den Code selbst und bitte die KI dann um eine Prüfung mit „Zeig mir die Fehler, aber gib mir nicht den korrigierten Code“.
• Frag nach Hinweisen, nicht nach Lösungen: Wenn du festhängst, sag „Gib mir nur einen Hinweis für den nächsten Schritt“.
• Lass dir Zeile für Zeile erklären: Versuch nach der Erklärung, dieselbe Logik mit eigenen Worten zu beschreiben; was du nicht erklären kannst, hast du noch nicht gelernt.
• Abtippen statt kopieren: Code von Hand zu tippen, statt ihn einzufügen, bringt dir Syntax und Funktionsnamen viel schneller bei.
• Erst vorhersagen, dann testen: Überleg vor dem Ändern eines Werts, was passieren wird (z. B. wenn LED_ARALIK 200 wird), und lade dann hoch und prüfe es.
• Frag dich selbst ab: Bitte die KI, dir fünf Fragen zum gerade gelernten Thema zu stellen; zum Auffrischen der Grundlagen hilft Arduino-Programmierung: Grundlagen.
• Halte dich an die Regeln: Bei Hausaufgaben, Schulprojekten und Wettbewerben wie Jugend forscht gelten Regeln zur KI-Nutzung; halte dich daran und gib offen an, wenn du KI verwendet hast.

Erste Projekte, die du mit KI ausprobieren kannst

• Temperaturanzeige: Zeig die Messwerte eines DHT11 auf einem I2C-LCD an; nenn im Prompt die LCD-Adresse und den Autor der Bibliothek.
• Einparkhilfe: Miss mit einem HC-SR04 den Abstand und lass den Summer schneller piepen, je näher ein Hindernis kommt; verlang ein Timing mit millis().
• Nachtlicht: Schalte mit einem LDR eine LED ein, wenn es dunkel wird; lies den Schwellwert vorher im Seriellen Monitor ab und gib ihn als Zahl im Prompt an.
• LED per WLAN steuern: Schalte mit einem ESP32 eine LED über eine Seite auf deinem Handy ein und aus; nenn im Prompt die Core-Version.
• Deine eigene Idee: Such dir ein Projekt aus den Arduino-Projektideen aus und beschreib es der KI mit der Prompt-Vorlage aus dieser Anleitung.

Die KI kann beim Arduino-Lernen der schnellste Helfer sein, den du hast, solange du ihr die richtigen Informationen gibst, das Ergebnis kompilierst, die Pins prüfst, Schritt für Schritt testest und keine Zeile hochlädst, die du nicht verstehst. Suchst du verlässliche Beispiele, mit denen du KI-Code vergleichen kannst, findest du in der BlueGrays-App Projekte mit LED, Taster, DHT11, ESP32-PWM und Pico samt Schritt-für-Schritt-Schaltplänen und getestetem Code.