Gidsen · 15 min leestijd

Arduino-code schrijven met AI: betere prompts, testen en fouten herstellen

Arduino-code schrijven met AI-tools zoals ChatGPT: een promptsjabloon, controles vóór het uploaden, verzonnen functies, verkeerde pins, delay()-blokkades en veiligheid bij netspanning.

Arduino-code schrijven met AI betekent dat je je project beschrijft aan een chatassistent zoals ChatGPT, Gemini, Claude of Copilot en om werkende code vraagt voor een Arduino, ESP32 of Raspberry Pi Pico. Goed gebruikt maak je van uren werk een kwestie van minuten: in plaats van een leeg scherm krijg je een concept dat klaar is om te compileren. Maar de AI kan je schakeling niet zien, weet niet welk board op jouw bureau ligt en kan met volle overtuiging iets onjuists beweren. Hij kan een bibliotheekfunctie verzinnen die niet bestaat, de verkeerde pin kiezen of delay()-lussen schrijven die alles laten vastlopen. Daarom is de echte vaardigheid niet om code te vragen, maar goed te vragen en te controleren wat je terugkrijgt.

In deze gids zie je hoe een AI-assistent Arduino-code maakt en waarom hij fouten maakt, hoe je een goede prompt schrijft met board, pins, bibliotheken en verwacht gedrag, en welke stappen je volgt om de code te controleren voordat je hem uploadt. We bespreken de drie meest voorkomende fouten met echte compilermeldingen en verbeterde code. Daarna lees je hoe je een compileerfout goed plakt en laat oplossen, waarom je AI niet blind moet vertrouwen bij netspanning en hoe je deze tools gebruikt zonder op te houden met leren.

Arduino Uno R3-board
AI kan code schrijven, maar kan je board, je bedrading en de modules die je gebruikt niet zien; die informatie moet je zelf in je prompt zetten.

Hoe schrijft AI Arduino-code en waarom gaat het soms mis?

Grote taalmodellen (LLM's) zoals ChatGPT schrijven code niet door die uit te voeren zoals een compiler; ze schrijven hem door de meest waarschijnlijke voortzetting te voorspellen op basis van de miljoenen voorbeelden die ze tijdens de training zagen. Voor onderwerpen met veel voorbeelden online (een led laten knipperen, een DHT11 uitlezen, een servo draaien) werkt dit heel goed. Maar de kennis van het model is bevroren op een bepaalde datum, dus het kent functies die in nieuwere bibliotheekversies zijn veranderd mogelijk niet. Het kan de functies van twee verschillende bibliotheken met dezelfde naam door elkaar halen. Het belangrijkste: in plaats van "dat weet ik niet" te zeggen, kan het een antwoord verzinnen dat aannemelijk klinkt; dit heet hallucinatie. Omdat het model je schakeling niet kan zien, leidt het pinnummers, spanningsniveaus en modulversies af uit wat jij schreef of uit eigen gissingen.

TaakHoe goed is AI hierin?Waarom?
Eenvoudige voorbeeldcode (led, knop, sensor uitlezen)Zeer goedEr zijn duizenden vergelijkbare voorbeelden online
Bestaande code regel voor regel uitleggenZeer goedCode lezen en uitleggen vereist geen gokwerk
De oorzaak van een compileerfout vindenGoedFoutmeldingen volgen patronen die modellen herkennen
Code voor de nieuwste bibliotheekversieZwakDe kennis is bevroren op een bepaalde datum; nieuwe functies kent het misschien niet
Pins kiezen die bij jouw schakeling passenZwakHet kan je board of bedrading niet zien en gaat dus uit van aannames
Timing en meerdere dingen tegelijk doenMatigDe meeste voorbeelden gebruiken delay(), dus het levert blokkerende code op
Netspanning, batterijen en schakelingen met hoge stroomOnbetrouwbaarFouten kosten brandwonden, brand of een elektrische schok; het model kan geen verantwoordelijkheid nemen

Hoe schrijf je een goede prompt?

De code die een AI je geeft kan niet beter zijn dan de informatie die je geeft. Bij een verzoek van één regel zoals "schrijf Arduino-code om temperatuur te meten" kiest het model zelf het board, de sensor, de pin en de bibliotheek. Passen die keuzes niet bij wat jij hebt, dan compileert de code niet, of hij compileert en werkt niet. Schrijf een goede prompt zoals je het project telefonisch zou uitleggen aan een vriend die er voor het eerst van hoort: noem het board, de componenten, de aansluitingen, de bibliotheken, het verwachte gedrag en de beperkingen stuk voor stuk. De tabel hieronder vat samen wat een Arduino-prompt moet bevatten:

Wat hoort in de prompt?Waarom het belangrijk isVoorbeeld
Exacte boardnaamPins, spanning en commando's verschillen tussen Uno, ESP32 en PicoArduino Uno R3 (ATmega328P)
IDE en core-versieOp de ESP32 zijn functies veranderd tussen core 2.x en 3.xArduino IDE 2.3, esp32 core 3.x
Typenummers van componentenDHT11 en DHT22, of SG90 en MG996R, zijn niet hetzelfdeDHT22, 16x2 I2C LCD (PCF8574, adres 0x27)
PinaansluitingenHet model volgt jouw bedrading in plaats van pins te verzinnenDHT22 DATA → D2, knop tussen D3 en GND
Naam en auteur van de bibliotheekVerschillende bibliotheken met dezelfde naam gebruiken andere functiesAdafruit DHT sensor library, Frank de Brabander LiquidCrystal I2C
Verwacht gedrag in cijfers"Piep als het warm wordt" is vaag, "boven 30 °C" is meetbaarMeet elke 2 seconden, laat de buzzer 3 keer piepen boven 30 °C
BeperkingenHoudt de slechte gewoonten van het model vanaf het begin tegenGebruik geen delay(), gebruik millis()
UitvoerformaatJe krijgt de code en de installatie-informatie samenEén .ino-bestand, commentaar in het Engels, een lijst met benodigde bibliotheken

Deze prompt geeft bijvoorbeeld veel betere resultaten dan een verzoek van één regel: "Ik gebruik een Arduino Uno R3 en Arduino IDE 2.3. De DATA-pin van de DHT22 zit op D2, een actieve buzzer op D8 en een 16x2 I2C LCD (PCF8574, adres 0x27) heeft SDA op A4 en SCL op A5. De Adafruit DHT sensor library en de LiquidCrystal I2C-bibliotheek van Frank de Brabander zijn geïnstalleerd. Toon elke 2 seconden temperatuur en luchtvochtigheid op de LCD en laat de buzzer in korte stootjes piepen als de temperatuur boven 30 °C komt. Gebruik millis() in plaats van delay() en voorzie de regels van commentaar. Zet bovenaan een lijst met bibliotheken die ik moet installeren en onderaan een lijst met de aannames die je hebt gemaakt." Met deze prompt valt er voor het model bijna niets meer te raden.

Voeg voordat je om code vraagt toe: "Ontbreekt er informatie om dit project te schrijven? Stel me eerst vragen." Een goed model vraagt dan naar de voedingsspanning, of de sensor los is of op een module zit, of naar het LCD-adres. Zet nooit je wifiwachtwoord, API-sleutel of bottoken in een prompt; gebruik plaatshouders zoals "YOUR_PASSWORD" en typ de echte waarden helemaal aan het eind zelf in de code.

Stappen om door AI geschreven code te controleren

Hoe netjes de code er ook uitziet, loop een checklist af voordat je hem naar je board uploadt. De meeste stappen kosten maar een paar minuten en zijn veel goedkoper dan een module die doorbrandt door een verkeerd aangesloten pin:

  1. Compileer eerst: Druk op Verify (het vinkje) zonder dat het board is aangesloten. Krijg je een fout, laat die dan oplossen met de methode hieronder; wat de meldingen betekenen lees je in Arduino-compileerfouten.
  2. Controleer de bibliotheken één voor één: Zoek elke #include-regel op in de Library Manager en installeer de bibliotheek waarvan naam, auteur en voorbeelden bij de code passen. Weet je niet hoe, dan loopt de gids een Arduino-bibliotheek toevoegen je erdoorheen.
  3. Vergelijk de pins: Vergelijk elk pinnummer in de code met je eigen bedrading en de pinindeling van het board. Gebruik de tool Pinout voor PWM-pins en pins die je moet vermijden.
  4. Reken de elektrische waarden na: Controleer de voorgestelde weerstandswaarde met de rekenmachine ledweerstand. Gaat een sensor met een uitgang van 5 V naar een ESP32 of Pico van 3,3 V, plaats er dan een spanningsdeler tussen.
  5. Probeer het in een simulator: Draai de code in Wokwi of Tinkercad voordat je echte hardware aansluit; zo vang je logicafouten op zonder onderdelen te riskeren.
  6. Test stuk voor stuk: Upload niet het hele project in één keer. Probeer eerst een kleine sketch die alleen de sensor uitleest en naar de Serial Monitor print, voeg dan het display toe en als laatste de buzzer of het relais.
  7. Houd de Serial Monitor in de gaten: Voeg Serial.println() toe op belangrijke punten om te zien of variabelen de verwachte waarden krijgen, en zorg dat de baudrate overeenkomt met Serial.begin() in de code. Meer in Arduino Serial Monitor.
  8. Laat de code uitleggen: Vraag bij elke regel die je niet begrijpt: "wat doet deze regel en wat gebeurt er als ik hem verwijder?" Upload nooit code die je niet kunt uitleggen.

Veelgemaakte fout 1: bibliotheekfuncties die niet bestaan

De sluwste fout van AI is het schrijven van functies die niet echt bestaan maar heel aannemelijke namen hebben. De standaard Servo-bibliotheek heeft bijvoorbeeld attach(), write(), writeMicroseconds(), read() en detach(), maar geen functie setSpeed(); het model kan die verzinnen als je om een langzaam bewegende servo vraagt. Soms bestaat de functie wel, maar op een ander board: Serial.printf() werkt op de ESP32 maar compileert niet op een Arduino Uno. En soms hoort de functie bij een oude versie: ledcSetup() en ledcAttachPin() zijn verwijderd in versie 3.x van de ESP32 Arduino-core, uitgebracht in 2024, en toch schrijven de meeste modellen er nog code mee. Dan zijn er verschillende bibliotheken die hetzelfde headerbestand gebruiken: in de ene bibliotheek met de naam LiquidCrystal_I2C.h start je het display met lcd.init(), in een andere met dezelfde naam is het lcd.begin(). Zie je in de compileruitvoer de waarschuwing "Multiple libraries were found", vermoed dan deze verwarring.

Wat de AI schreefCompilermelding of symptoomEchte oplossing
Serial.printf("%d", x) op een Uno'class HardwareSerial' has no member named 'printf'; did you mean 'print'?Print stuk voor stuk met Serial.print() of bouw eerst de tekst op met snprintf()
sprintf(buf, "%.1f", t) op een UnoCompileert, maar print ? in plaats van het getalOp AVR ondersteunt de printf-familie geen floats; gebruik dtostrf(t, 4, 1, buf)
servo.setSpeed(10)'class Servo' has no member named 'setSpeed'Verander de hoek in kleine stappen in een lus
ledcSetup(0, 5000, 8) op ESP32 core 3.x'ledcSetup' was not declared in this scopeGebruik ledcAttach(pin, frequency, resolution) en ledcWrite(pin, value)
Alleen de DHT-bibliotheek geïnstalleerdfatal error: Adafruit_Sensor.h: No such file or directoryInstalleer ook de Adafruit Unified Sensor-bibliotheek
lcd.begin() dat niet past bij de geïnstalleerde bibliotheekno matching function for call to 'LiquidCrystal_I2C::begin()'Open het eigen voorbeeld van de geïnstalleerde bibliotheek en gebruik de startopdracht daaruit (zoals lcd.init())
analogReadResolution(12) op een Uno'analogReadResolution' was not declared in this scopeDe ADC van de Uno is 10-bits; verwijder de regel, de waarden lopen van 0 tot 1023

De valkuil van oude functies op de ESP32: ledcAttach in plaats van ledcSetup

Als je om ESP32-code vraagt die de helderheid van een led of de snelheid van een motor instelt, schrijft de AI hoogstwaarschijnlijk het trio ledcSetup(channel, frequency, resolution), ledcAttachPin(pin, channel) en ledcWrite(channel, value). Die code werkt op versie 2.x van de core. In versie 3.x worden kanalen echter automatisch toegewezen: ledcAttach(pin, frequency, resolution) stelt de pin in één keer in en ledcWrite(pin, value) neemt nu een pinnummer in plaats van een kanaal. In de Boards Manager zie je naast het esp32-pakket welke versie is geïnstalleerd. De onderstaande code controleert de versie tijdens het compileren, zodat hij op beide cores werkt:

C++ (Arduino IDE)
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}

De les hier geldt niet alleen voor de ESP32: als je de core- en bibliotheekversies in je prompt zet, heeft het model kans de juiste functies te kiezen. Gebruikt het na het geven van de versie nog steeds oude functies, open dan een van de officiële voorbeelden van de bibliotheek via het menu File › Examples en plak het in de prompt met "schrijf het om met de functies uit dit voorbeeld". Officiële voorbeelden komen altijd overeen met de geïnstalleerde versie. Benieuwd hoe PWM werkt? Lees dan Wat is PWM?

Veelgemaakte fout 2: de verkeerde pin kiezen

Ook als de code compileert en geüpload wordt, betekent een verkeerde pin een schakeling die stilletjes niets doet of een module die doorbrandt. De compiler kan dat niet opvangen, want voor de compiler is een pinnummer gewoon een getal. Dit zijn de pinfouten die AI het vaakst maakt, board per board:

BoardVeelgemaakte AI-foutWat gebeurt er?De juiste aanpak
Arduino UnoEen niet-PWM-pin voor analogWrite() (bijv. D7)De led dimt niet: onder 128 is hij uit, vanaf 128 volledig aanPWM-pins: 3, 5, 6, 9, 10, 11
Arduino UnoEen module aansluiten op D0 of D1Uploaden kan mislukken en de Serial Monitor kan rommel tonenD0 en D1 zijn de seriële USB-lijn; begin bij D2
Arduino NanoA6 en A7 als digitale pins gebruikendigitalRead() en digitalWrite() werken nietA6 en A7 zijn alleen analoge ingangen
ESP32GPIO 6–11 gebruikenHet board crasht of blijft herstartenDeze pins zijn verbonden met het flashgeheugen; kies veilige pins zoals GPIO 4, 5, 16–19, 21–23
ESP32GPIO 34–39 als uitgangen gebruikenDe led blijft uit; een knop wordt onregelmatig gelezen zonder pull-upDeze pins zijn alleen ingang en hebben geen interne pull-upweerstanden
ESP32Analoge waarden lezen van ADC2-pins terwijl wifi aan staatanalogRead() mislukt of geeft betekenisloze waardenSluit analoge sensoren aan op ADC1-pins (GPIO 32–39)
Raspberry Pi Pico WPin(25) voor de ingebouwde ledDe led blijft uitOp de Pico W zit de led aan de draadloze chip; gebruik Pin("LED")
AI negeert vaak spanningsniveaus. De pins van de ESP32 en Raspberry Pi Pico werken op 3,3 V en zijn niet 5V-tolerant; een sensor met een uitgang van 5 V direct aansluiten kan de pin blijvend beschadigen. Op een Arduino Uno mag je continu niet meer dan 20 mA uit een pin halen (40 mA absoluut maximum). Motoren, relaisspoelen en lange ledstrips gaan nooit direct op een pin; er komt een transistor of driver tussen. Voor de pinindeling van je board, zie Arduino Uno pinout.

Veelgemaakte fout 3: delay()-blokkades

Omdat de meeste Arduino-voorbeelden online met delay() zijn geschreven, gebruikt AI standaard ook delay(). Terwijl delay(1000) loopt, doet de processor een hele seconde niets anders: hij leest geen knoppen, controleert geen sensoren en ververst het display niet. In code die één ding doet is dat prima. Maar vraag je twee dingen tegelijk, zoals "laat een led knipperen en laat de buzzer piepen als de knop wordt ingedrukt", dan krijg je vaak code als deze:

C++ (Arduino IDE)
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}

Deze code compileert zonder fouten, maar meestal gebeurt er niets als je op de knop drukt. Ongeveer 2 seconden van elke doorloop van loop() gaan op aan de twee delay()-aanroepen en de knop wordt er maar een paar microseconden tussen gelezen. Een korte druk mist dat moment bijna altijd; om zeker te zijn dat de buzzer klinkt, moet je de knop langer dan 2 seconden ingedrukt houden. De oplossing is niet wachten, maar de klok controleren: millis() geeft de milliseconden sinds het board startte, elke taak controleert of zijn tijd gekomen is en loop() draait duizenden keren per seconde:

C++ (Arduino IDE)
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 deze versie werken de led, de knop en de buzzer zonder op elkaar te wachten. Een aftrekking in de vorm simdi - ledZaman >= LED_ARALIK geeft het juiste resultaat, ook als millis() ongeveer elke 49,7 dagen terugspringt naar nul, terwijl de vergelijking millis() > targetTime die AI soms schrijft bij die terugloop breekt. Het moment opvangen waarop de knop van HIGH naar LOW gaat voorkomt dat de buzzer steeds opnieuw piept zolang de knop ingedrukt blijft, en de wachttijd van 30 ms filtert contactdender (debounce) weg. Het volledige onderwerp vind je in de gids Arduino millis() vs delay(), en voor het aansluiten van de knop zie een knop aansluiten op Arduino.

Als je vanaf het begin in je prompt schrijft "gebruik geen delay(), timing elke taak met millis()", loop je nooit tegen dit probleem aan. Er zijn nog twee blokkadepatronen om te controleren: op boards met native USB zoals de Leonardo en Micro laat de regel while (!Serial); het programma eeuwig wachten als het board niet op een computer is aangesloten. En een delay() in een interruptroutine (ISR) kan het programma laten vastlopen, omdat millis() tijdens de interrupt niet verder telt.

Een compileerfout plakken en laten oplossen

AI is echt goed in het uitleggen van compileerfouten, zolang je de hele fout en de context geeft. Alleen schrijven "de code werkt niet" dwingt het model te gokken. Volg deze volgorde:

  1. Verschijnt er in Arduino IDE 2 een compileerfout, klik dan in de melding rechtsonder op Copy error messages, of selecteer en kopieer de hele tekst in het uitvoerpaneel. De exit status 1 op de laatste regel is op zichzelf nutteloos; de echte oorzaak staat in de error:-regel hoger.
  2. Je prompt moet in deze volgorde bevatten: het board en de core-versie, de volledige code, de volledige foutmelding en de namen en versies van de geïnstalleerde bibliotheken.
  3. Schrijf voordat je om een oplossing vraagt "Leg eerst de oorzaak van de fout uit en toon dan alleen de regels die moeten veranderen". Zo herschrijft het model niet de hele sketch en voegt het geen nieuwe fouten toe, en leer jij wat er veranderd is en waarom.
  4. Pas de voorgestelde wijziging toe en compileer opnieuw. Verschijnt er een nieuwe fout, plak dan opnieuw de bovenste error:-regel; los één fout tegelijk op.
  5. Is dezelfde fout na twee of drie rondes nog steeds aanwezig, doorbreek dan de lus en compileer het officiële voorbeeld van de bibliotheek. Compileert dat voorbeeld ook niet, dan ligt het probleem niet aan je code maar aan je setup: het verkeerde board gekozen, een ontbrekende bibliotheek, of twee bibliotheken met dezelfde naam die botsen.

Gebeurt de fout bij het uploaden in plaats van bij het compileren (zoals "avrdude: stk500_recv(): programmer is not responding" of "Failed to connect to ESP32" op een ESP32), dan helpt het aanpassen van de code niet; je moet de poort, de kabel, het stuurprogramma en de boardkeuze controleren. De gids Arduino-code wordt niet geüpload loopt die gevallen met je door. Vraag je AI om hulp bij een uploadfout, geef dan de hele melding en je besturingssysteem mee.

AI Raspberry Pi Pico- en MicroPython-code laten schrijven

Dezelfde regels gelden als je om MicroPython-code vraagt, maar hier kan de AI ook platforms door elkaar halen. Code die is geschreven voor Raspberry Pi-computers met RPi.GPIO of gpiozero draait niet op de Pico; op de Pico gebruik je de machine-module van MicroPython. De modules board en digitalio van CircuitPython bestaan ook niet in MicroPython. Zet in je prompt dus duidelijke informatie zoals "Raspberry Pi Pico W, MicroPython, Thonny". De onderstaande code draait op zowel de Pico als de Pico W en gebruikt ticks_ms() voor de timing in plaats van te wachten:

MicroPython
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)

Draai je de code in Thonny, dan knippert de ingebouwde led elke halve seconde en print elke druk op de knop een oplopend getal in het Shell-venster. time.ticks_diff() geeft het juiste verschil, ook als de tickteller rondgaat, terwijl de gewone aftrekking time.ticks_ms() - son die AI vaak schrijft in lang draaiende code een fout resultaat kan geven. Ben je nieuw met de Pico, begin dan met Wat is de Raspberry Pi Pico?

Netspanning: vertrouw de AI niet

AI schrijft in enkele seconden code voor een relais dat een lamp, stopcontact of verwarming op netspanning schakelt en beschrijft de bedrading met volle overtuiging. Maar netspanning kan doden; een verkeerde aansluiting of een losse draad kan een elektrische schok en brand veroorzaken. Het model kan de bedrading die het beschrijft niet meten, kan je schakeling niet zien en kan geen verantwoordelijkheid nemen voor het resultaat. Maak nooit een netaansluiting uitsluitend op basis van aanwijzingen van een AI; ben je jonger dan 18, doe dit werk dan altijd samen met een volwassene of iemand die verstand heeft van elektra.

Gaat je project op netspanning draaien, test het dan eerst op lage spanning: gebruik een led in plaats van de lamp en een 12V-ledstrip in plaats van het stopcontact. Moet het systeem echt netspanning schakelen, dan zijn sommige regels niet onderhandelbaar. Haal de stekker uit het stopcontact voordat je aan de schakeling werkt. Het relais moet de fasedraad (L) schakelen, niet de nul. Overschrijd de stroom- en spanningswaarde die op de relaismodule staat niet (10 A 250 VAC bij de meeste modules) en plaats de hoogspanningskant in een gesloten, geïsoleerde behuizing. Goedkope relaismodules laten vaak te weinig afstand tussen de laag- en hoogspanningskant; kies waar mogelijk een kant-en-klare, gecertificeerde slimme stekker of relaisbox. De bedrading van relaismodules vind je uitgebreid in Wat is een relaismodule?

AI gebruiken zonder op te houden met leren

Als AI elke sketch voor je schrijft, weet je de eerste dag dat de code niet werkt niet wat je moet doen. Is je doel elektronica en programmeren te leren, gebruik AI dan niet als codemachine maar als geduldige leraar:

  • Schrijf het eerst zelf: Probeer de code zelf en vraag de AI hem dan te beoordelen met "toon me de fouten maar geef me de verbeterde code niet".
  • Vraag om hints, niet om antwoorden: Zeg als je vastzit "geef me alleen een hint voor de volgende stap".
  • Laat het regel voor regel uitleggen: Probeer na de uitleg dezelfde logica in je eigen woorden uit te leggen; wat je niet kunt uitleggen, heb je nog niet geleerd.
  • Typ in plaats van te kopiëren: Code met de hand typen in plaats van plakken leert je syntaxis en functienamen veel sneller.
  • Voorspel en test dan: Voorspel voordat je een waarde verandert wat er gaat gebeuren (bijv. als LED_ARALIK 200 wordt), upload het dan en controleer.
  • Overhoor jezelf: Vraag de AI je vijf vragen te stellen over het onderwerp dat je net hebt geleerd; om de basis op te frissen gebruik je Arduino-programmeerbasis.
  • Volg de regels: Volg bij schoolopdrachten en wetenschapsbeurzen de regels over het gebruik van AI en zeg duidelijk dat je het hebt gebruikt.

Eerste projecten om met AI te proberen

  • Temperatuurdisplay: Toon waarden gemeten door een DHT11 op een I2C LCD; geef het LCD-adres en de auteur van de bibliotheek op in je prompt.
  • Parkeersensor: Meet afstand met een HC-SR04 en laat sneller piepen naarmate een obstakel dichterbij komt; vraag om timing op basis van millis().
  • Nachtlampje: Zet een led aan als het donker wordt met een LDR; lees eerst de drempel af in de Serial Monitor en geef hem als getal in je prompt.
  • Wifi-ledbediening: Schakel een led aan en uit vanaf een pagina die je op je telefoon opent met een ESP32; vermeld de core-versie in je prompt.
  • Je eigen idee: Kies een project uit de lijst Arduino-projectideeën en beschrijf het aan de AI met het promptsjabloon uit deze gids.

AI kan de snelste helper binnen handbereik zijn terwijl je Arduino leert, zolang je de juiste informatie geeft, compileert wat je terugkrijgt, de pins controleert, stuk voor stuk test en nooit een regel uploadt die je niet begrijpt. Zoek je betrouwbare voorbeelden om door AI geschreven code mee te vergelijken, dan heeft de BlueGrays-app projecten met led, knop, DHT11, ESP32-PWM en Pico met schakelschema's stap voor stap en geteste code.

Veelgestelde vragen

Kan AI Arduino-code schrijven?

Ja. Assistenten zoals ChatGPT, Gemini, Claude en Copilot kunnen werkende code maken voor de meeste eenvoudige Arduino-, ESP32- en Raspberry Pi Pico-projecten. Voordat je uploadt moet je de code echter compileren en de pins, bibliotheken en spanningsniveaus zelf controleren; de AI kan je schakeling niet zien en kan het mis hebben.

Welke AI is het beste voor het schrijven van Arduino-code?

Er is geen enkel goed antwoord; actuele grote modellen geven vergelijkbare resultaten voor eenvoudige Arduino-code. Het verschil komt meestal van de prompt, niet van het model: een prompt die het board, de pinaansluitingen, de bibliotheken en het verwachte gedrag duidelijk noemt, levert betere code op bij welke assistent je ook gebruikt.

Waarom werkt de Arduino-code van ChatGPT niet?

De meest voorkomende oorzaken zijn functies die niet bestaan of bij een ander board horen, code die voor een andere bibliotheekversie is geschreven, verkeerde pins en delay()-aanroepen die alles blokkeren. Compileer de code eerst; als er een fout is, plak dan de hele melding samen met de gegevens over board en versies. Compileert de code wel maar werkt hij niet, print dan tussenwaarden naar de Serial Monitor om te zien waar het probleem zit.

Hoe vraag ik AI een Arduino-compileerfout op te lossen?

Geef de boardnaam, de core- en bibliotheekversies, de volledige code en de volledige foutmelding uit het uitvoerpaneel in één bericht. Voeg je toe "leg eerst de oorzaak uit en toon dan alleen de regels die veranderen", dan krijg je de juiste oplossing en leer je waarom de fout ontstond.

Kan ik AI-bedrading voor een relais op netspanning vertrouwen?

Nee, niet zonder meer. De code is meestal in orde, maar het gevaar zit in de bedrading; de AI kan je schakeling niet zien en kan niet garanderen dat zijn aanwijzingen kloppen. Bedraad de netkant alleen samen met iemand die er verstand van heeft, met de stekker eruit, met een relaisopstelling die de fasedraad schakelt en in een gesloten behuizing zit; gebruik waar mogelijk een kant-en-klare gecertificeerde slimme stekker.

Is het gebruik van AI slecht voor het leren van Arduino?

Als je code kopieert zonder hem te begrijpen wel; bij de eerste fout weet je dan niet wat je moet doen. Schrijf je de code eerst zelf en laat je de AI hem beoordelen, regel voor regel uitleggen en hints geven in plaats van antwoorden, dan versnelt het het leren. De regel is simpel: upload nooit een regel die je niet kunt uitleggen.

Alle projecten bekijken
LED laten knipperen
AR-1Beginner

LED laten knipperen

De allereerste hallo van de elektronica: één LED aan- en uitzetten. De Arduino zet de LED met korte tussenpozen aan en uit, zodat het licht snel knippert.

4.6(200)
1246
LED aansturen met een drukknop (Push)
AR-9Beginner

LED aansturen met een drukknop (Push)

Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

4.8(114)
253
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

Temperatuur en luchtvochtigheid met DHT11

Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

4.7(47)
83
Led laten knipperen met ESP32
ES-1Beginner

Led laten knipperen met ESP32

Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

4.7(37)
108
Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)
PI-1Beginner

Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)

Het openingsproject van de Raspberry Pi Pico-serie! We laten de groene ingebouwde led van de Pico knipperen om te controleren of het board werkt: het klassieke "Hello World" als eerste experiment. Je hebt geen externe onderdelen nodig, alleen de Pico en een USB-kabel. De code is geschreven in MicroPython, de taal die officieel door de Raspberry Pi Foundation wordt ondersteund.

5.0(1)
10
ESP32-led dimmen met PWM
ES-8Beginner

ESP32-led dimmen met PWM

De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

4.8(36)
55
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

Raspberry Pi Pico PWM-led-fade (ademeffect)

De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

4
Een lcd-scherm gebruiken met I2C
AR-32Beginner
Premium

Een lcd-scherm gebruiken met I2C

Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…

4.8(53)
70