PlatformIO installeren: gids voor Arduino, ESP32 en Pico in VS Code
PlatformIO in VS Code instellen: configureer Uno, ESP32 en Pico met platformio.ini, voeg bibliotheken toe via lib_deps, upload code en stap over van de Arduino IDE.
PlatformIO installeren voegt één extensie toe aan VS Code, zodat je boards zoals de Arduino Uno, ESP32 en Raspberry Pi Pico vanuit één professionele omgeving kunt programmeren. Kort gezegd: installeer VS Code, zoek op PlatformIO IDE in het tabblad Extensies en installeer het, wacht tot de benodigde tools bij de eerste start zijn gedownload en maak daarna op het PIO Home-scherm een nieuw project aan door je board te kiezen. De rest gebeurt in een klein instellingenbestand met de naam platformio.ini: welk board, welk framework, welke bibliotheken en welke seriële poortsnelheid je gebruikt, staat allemaal daar.
De Arduino IDE is een prima tool om mee te leren, maar naarmate projecten groeien merk je de beperkingen: de codeaanvulling is basaal, bibliotheken worden gedeeld door alle projecten, een bibliotheekupdate kan een oud project laten breken en de boardinstellingen worden niet met het project opgeslagen. PlatformIO lost deze problemen op. In deze gids installeer je het stap voor stap, maak je je eerste project, definieer je drie verschillende boards in één project met platformio.ini, voeg je een bibliotheek toe, upload je code, open je de Serial Monitor en leer je hoe je bestaande Arduino IDE-projecten overzet. In het laatste deel vergelijken we de twee tools eerlijk, zodat je kunt kiezen wat bij je past.

Wat is PlatformIO en hoe werkt het?
PlatformIO is een opensource-ontwikkelomgeving voor embedded systemen. De kern is een opdrachtregeltool in Python met de naam PlatformIO Core; de VS Code-extensie maakt die gemakkelijk bruikbaar met knoppen, menu's en het PIO Home-scherm. Als je een project bouwt, leest PlatformIO eerst platformio.ini, downloadt dan de benodigde compiler (avr-gcc voor de Uno, de Xtensa-toolchain voor de ESP32, arm-none-eabi-gcc voor de Pico), het framework en de bibliotheken uit het eigen register en compileert je code. Deze pakketten worden maar één keer gedownload en opgeslagen in de map .platformio in je gebruikersmap; latere projecten hergebruiken dezelfde pakketten. Als je de onderstaande begrippen kent, lees je het bestand veel makkelijker:
| Begrip | Betekenis | Voorbeeld |
|---|---|---|
| Platform | Het pakket met compiler en uploadtool voor een microcontrollerfamilie | atmelavr, espressif32, raspberrypi |
| Board | Een specifiek board binnen een platform; pinindeling, kloksnelheid en geheugeninfo | uno, nanoatmega328, esp32dev, pico |
| Framework | De softwarebasis waarop je code is geschreven | arduino, espidf |
| Omgeving (env) | Het gedeelte dat platform, board, framework en extra instellingen samen definieert | [env:uno] |
| Bibliotheek | Een kant-en-klaar codepakket dat je met lib_deps aan het project toevoegt | adafruit/DHT sensor library |
| PIO Home | Het scherm om projecten te openen en boards en bibliotheken te zoeken | Het huisjespictogram in de statusbalk |
PlatformIO instellen stap voor stap
- Download Visual Studio Code van de officiële website en installeer het. Op Windows maakt het aanvinken van Add to PATH tijdens de installatie het gebruik van de terminal makkelijker.
- Open VS Code en klik links op het tabblad Extensies, of gebruik de sneltoets Ctrl+Shift+X (Cmd+Shift+X op macOS).
- Typ PlatformIO IDE in het zoekvak en installeer de extensie van PlatformIO met de knop Install. De benodigde C/C++-extensie wordt automatisch meegeïnstalleerd.
- Rechtsonder verschijnt een melding "Installing PlatformIO Core". Afhankelijk van je internetsnelheid duurt dit een paar minuten; sluit VS Code in de tussentijd niet af.
- Als de installatie klaar is, vraagt VS Code je om opnieuw te starten. Na het herstarten verschijnt links een PlatformIO-pictogram en onderaan in de statusbalk een huisjespictogram.
- Klik op het huisjespictogram om het PIO Home-scherm te openen. Als dit scherm er goed uitziet, is de installatie voltooid.
Je eerste project maken en de mapstructuur
Klik in PIO Home op de knop New Project. Geef in het venster dat opent het project een naam (bijvoorbeeld blink-uno), typ Arduino Uno in het veld Board en kies het uit de lijst, laat het framework op Arduino staan en kies de locatie. Als je op Finish klikt, downloadt PlatformIO voor het eerst het platformpakket dat je gekozen board nodig heeft; daarom kan het eerste project een paar minuten duren, terwijl latere projecten in seconden openen. Zodra het project is gemaakt, opent VS Code de map en zie je deze structuur:
| Map / bestand | Waar het voor dient |
|---|---|
| platformio.ini | Het hart van het project: instellingen voor board, framework, bibliotheken en poort |
| src/ | Je broncode; het programma start vanuit main.cpp |
| include/ | Je eigen headerbestanden (.h) |
| lib/ | Projectspecifieke lokale bibliotheken die je met de hand toevoegt (elk in een eigen submap) |
| test/ | Een map gereserveerd voor unittests |
| .pio/ | Buildresultaat en gedownloade bibliotheken; wordt opnieuw gemaakt als je het verwijdert |
| .vscode/ | Instellingen voor VS Code en IntelliSense; automatisch gegenereerd |
Wat is het bestand platformio.ini?
platformio.ini is een gewoon tekstbestand in INI-formaat. Elke sectie [env:naam] die met vierkante haken begint, definieert een buildomgeving. Het board en de poortsnelheid die je in de Arduino IDE in het menu Tools kiest, staan hier als tekst; als je het project naar een andere computer verplaatst of aan een vriend geeft, gaan de instellingen dus mee met de code. Regels die met een puntkomma beginnen, zijn commentaar. Als we de snelheid van de Serial Monitor toevoegen aan het bestand dat voor de Uno is gemaakt, ziet het er zo uit:
1; PlatformIO proje ayarları / PlatformIO project settings
2[env:uno]
3platform = atmelavr
4board = uno
5framework = arduino
6; Seri monitör hızı, Serial.begin ile aynı olmalı / Monitor speed, must match Serial.begin
7monitor_speed = 115200| Instelling | Wat het doet | Voorbeeldwaarde |
|---|---|---|
| platform | Het te gebruiken platformpakket; de versie kan ook worden vastgezet | atmelavr, [email protected] |
| board | Board-ID | uno, megaatmega2560, esp32dev, pico |
| framework | Softwareframework | arduino |
| monitor_speed | Snelheid van de Serial Monitor (standaard 9600) | 115200 |
| upload_port | Uploadpoort (wordt automatisch gevonden als je hem leeg laat) | COM5, /dev/ttyUSB0 |
| upload_speed | Uploadbaudrate (vooral bij ESP-boards) | 921600 |
| lib_deps | Bibliotheken die automatisch worden gedownload | adafruit/DHT sensor library@^1.4.4 |
| build_flags | Extra vlaggen en macro's voor de compiler | -D LED_PIN=2 |
| monitor_filters | Filters die op de uitvoer van de Serial Monitor worden toegepast | time, esp32_exception_decoder |
Eerste code: main.cpp en het verschil met Arduino.h
Het bestand main.cpp in de map src is het equivalent van het .ino-bestand in de Arduino IDE, maar er zijn twee belangrijke verschillen. Ten eerste moet het bestand beginnen met een #include-regel die de header Arduino.h toevoegt; de Arduino IDE doet dat op de achtergrond, PlatformIO niet. Ten tweede volgt een .cpp-bestand de echte C++-regels: de compiler moet een functie kennen voordat je hem aanroept. De Arduino IDE genereert functieprototypes voor je; in PlatformIO definieer je de functie vóór gebruik of schrijf je bovenaan het bestand een prototype van één regel. Het onderstaande voorbeeld is een blinkprogramma dat op de Uno, ESP32 en Pico werkt:
1#include <Arduino.h>
2
3// LED_PIN platformio.ini'den gelebilir / LED_PIN may come from platformio.ini
4#ifndef LED_PIN
5#define LED_PIN LED_BUILTIN // Uno: 13, Pico: GP25
6#endif
7
8void blinkLed(int count); // prototip / prototype
9
10void setup() {
11 Serial.begin(115200);
12 pinMode(LED_PIN, OUTPUT);
13 Serial.println("PlatformIO hazir / ready");
14}
15
16void loop() {
17 blinkLed(3);
18 delay(1000);
19}
20
21void blinkLed(int count) {
22 for (int i = 0; i < count; i++) {
23 digitalWrite(LED_PIN, HIGH);
24 delay(150);
25 digitalWrite(LED_PIN, LOW);
26 delay(150);
27 }
28 Serial.print("Yanip sondu / Blinked: ");
29 Serial.println(count);
30}Bouwen, uploaden en Serial Monitor
| Actie | Statusbalk / menu | Terminalopdracht |
|---|---|---|
| Bouwen | Vinkje | pio run |
| Uploaden | Pijl naar rechts | pio run -t upload |
| Uploaden en monitor openen | PlatformIO-menu > Upload and Monitor | pio run -t upload -t monitor |
| Serial Monitor | Stekkerpictogram | pio device monitor |
| Opschonen | Prullenbak | pio run -t clean |
| Poorten tonen | PIO Home > Devices | pio device list |
| Een specifieke omgeving bouwen | Omgevingskiezer (env:...) | pio run -e esp32dev |
| Een bibliotheek installeren | PIO Home > Libraries | pio pkg install -l "adafruit/DHT sensor library" |
Om de Serial Monitor goed te laten werken, moet de waarde monitor_speed in platformio.ini overeenkomen met de snelheid van Serial.begin() in je code; anders zie je onzintekens op het scherm. PlatformIO vindt het aangesloten board meestal zelf, maar als de computer meer dan één seriële poort heeft, kan het proberen naar de verkeerde poort te uploaden. Toon in dat geval de poorten met pio device list en schrijf de juiste in de regels upload_port en monitor_port. Als de Serial Monitor van de Arduino IDE of een ander terminalprogramma de poort open houdt, stopt de upload met de fout "Access is denied" of "Resource busy"; het sluiten van dat programma is genoeg. Wil je de Serial Monitor zelf beter leren kennen, lees dan ook het bericht Arduino Serial Monitor. De opdracht pio werkt altijd in de PlatformIO Core CLI-terminal die je via het PlatformIO-menu opent.
Uno, ESP32 en Pico in één project definiëren
Een van de sterkste eigenschappen van PlatformIO is dat het dezelfde code voor meerdere boards kan bouwen. Je schrijft voor elk board een aparte sectie [env:...]; als je gedeelde instellingen in de naamloze sectie [env] zet, erven alle omgevingen die. De onderstaande tabel vat de basiswaarden van drie populaire boards samen:
| Waarde | Arduino Uno | ESP32 DevKit | Raspberry Pi Pico |
|---|---|---|---|
| platform | atmelavr | espressif32 | raspberrypi |
| board | uno | esp32dev | pico |
| framework | arduino | arduino | arduino (Arduino Mbed-core) |
| Ingebouwde led | D13 | GPIO 2 (op de meeste DevKit-boards) | GP25 |
| Uploadmethode | USB-serieel en bootloader | USB-serieel en esptool | USB en BOOTSEL-modus |
| Typische monitor_speed | 9600 of 115200 | 115200 | 115200 |
1[platformio]
2; Varsayılan ortam / Default environment
3default_envs = uno
4
5; Tüm ortamlarda ortak ayarlar / Settings shared by all environments
6[env]
7framework = arduino
8monitor_speed = 115200
9
10[env:uno]
11platform = atmelavr
12board = uno
13
14[env:esp32dev]
15platform = espressif32
16board = esp32dev
17upload_speed = 921600
18monitor_filters = esp32_exception_decoder
19; Dahili LED GPIO 2 / Onboard LED on GPIO 2
20build_flags = -D LED_PIN=2
21
22[env:pico]
23platform = raspberrypi
24board = picoDe regel default_envs bepaalt welke omgeving de knoppen voor bouwen en uploaden in de statusbalk gebruiken; als je hem niet schrijft, bouwt PlatformIO alle omgevingen in het bestand achter elkaar. Je kunt via de omgevingskiezer in de statusbalk direct naar een ander board wisselen, of rechtstreeks naar de ESP32 uploaden door pio run -e esp32dev -t upload in de terminal te typen. De vlag -D LED_PIN=2 in de ESP32-omgeving definieert de macro LED_PIN in de code; omdat de Uno en Pico deze vlag niet hebben, valt de code terug op de waarde van LED_BUILTIN (13 en 25). Zo draait één main.cpp zonder aanpassingen op alle drie de boards. Om snel de pinindeling van de boards te zien, kun je de pinout-tool gebruiken.
PlatformIO-instellingen voor de ESP32
ESP32-boards worden in PlatformIO met esptool geüpload, net als in de Arduino IDE. upload_speed = 921600 verkort de uploadtijd merkbaar; als je kabel lang of van slechte kwaliteit is en je fouten krijgt, ga dan terug naar 460800 of 115200. Het filter esp32_exception_decoder zet de betekenisloze adresdump die de Serial Monitor toont als het board crasht om in functienamen en regelnummers; het is erg waardevol om Guru Meditation-fouten op te sporen. Als de upload blijft hangen bij "Connecting...", houd dan de knop BOOT op het board ingedrukt en laat hem los zodra de upload begint; uitgebreide oplossingen staan in het bericht ESP32 Failed to Connect. Nog een detail is de coreversie: het officiële platform espressif32 van PlatformIO gebruikte lang versie 2.x van de Arduino-ESP32-core; als je API's nodig hebt die specifiek zijn voor 3.x, kun je overstappen op het door de community onderhouden platform pioarduino. Welke core wordt gebruikt, zie je aan de versie van framework-arduinoespressif32 op de regel PACKAGES bovenaan de buildoutput. Wil je dat je code op beide versies compileert, dan kun je ze onderscheiden met de macro ESP_ARDUINO_VERSION_MAJOR.
Raspberry Pi Pico en PlatformIO
Met board = pico gebruikt het officiële platform raspberrypi de officiële RP2040-core van Arduino op basis van Mbed OS. Veel gebruikers geven de voorkeur aan de arduino-pico-core van Earle Philhower, die meer functies en betere bibliotheekcompatibiliteit biedt; in PlatformIO gebruik je die via een apart, door de community onderhouden platformpakket en de instelling board_build.core = earlephilhower. Welke core je ook kiest, voor de eerste upload moet je de Pico misschien op USB aansluiten terwijl je de knop BOOTSEL ingedrukt houdt; het board verschijnt op je computer als een schijf met de naam RPI-RP2 en nadat PlatformIO het programma heeft geüpload, herstart het uit zichzelf. Voor latere uploads heb je de knop meestal niet nodig. Een belangrijke opmerking: PlatformIO ondersteunt MicroPython niet. Wil je de Pico met MicroPython programmeren, gebruik dan een editor als Thonny; zie voor details de berichten MicroPython-basis en Wat is de Raspberry Pi Pico?.
Bibliotheken toevoegen: lib_deps
In PlatformIO worden bibliotheken per project geïnstalleerd, niet voor de hele computer. De schoonste methode is een regel lib_deps toevoegen aan platformio.ini: bij de eerste build downloadt PlatformIO de bibliotheek uit het register en zet die in de map .pio/libdeps/. Je kunt ook op het tabblad Libraries in PIO Home zoeken naar de exacte naam van de bibliotheek en die toevoegen met de knop Add to Project; deze knop schrijft de regel lib_deps voor je. Hieronder staat een voorbeeld dat een DHT11-sensor aansluit op pin D2 van de Uno; voor de bedrading van de sensor, zie het bericht DHT11-temperatuur- en vochtigheidssensor.
1[env:uno]
2platform = atmelavr
3board = uno
4framework = arduino
5monitor_speed = 115200
6; Kütüphaneler ilk derlemede otomatik iner / Libraries download on first build
7lib_deps =
8 adafruit/DHT sensor library@^1.4.4
9 adafruit/Adafruit Unified Sensor@^1.1.91#include <Arduino.h>
2#include <DHT.h>
3
4#define DHT_PIN 2 // Uno D2 pini / Uno pin D2
5#define DHT_TYPE DHT11
6
7DHT dht(DHT_PIN, DHT_TYPE);
8
9void setup() {
10 Serial.begin(115200);
11 dht.begin();
12}
13
14void loop() {
15 delay(2000); // DHT11 en fazla 1 Hz / DHT11 max 1 Hz
16 float h = dht.readHumidity();
17 float t = dht.readTemperature();
18 if (isnan(h) || isnan(t)) {
19 Serial.println("Sensor okunamadi / Read failed");
20 return;
21 }
22 Serial.print("Sicaklik / Temp: ");
23 Serial.print(t, 1);
24 Serial.print(" C Nem / Hum: ");
25 Serial.print(h, 0);
26 Serial.println(" %");
27}In de versienotatie staat ^1.4.4 versies 1.4.4 en hoger toe, maar lager dan 2.0.0; ~1.4.4 accepteert alleen 1.4.x-patches; als je alleen 1.4.4 schrijft, ligt de versie volledig vast. Het vastzetten van versies garandeert dat dezelfde code over een jaar nog steeds op dezelfde manier compileert. Als je een bibliotheek die niet in het register staat, of een die je zelf hebt geschreven, in de map lib van het project plaatst als submap met haar eigen naam, vindt PlatformIO die automatisch. Wil je het vergelijken met hoe bibliotheken in de Arduino IDE werken, lees dan het bericht Arduino-bibliotheken toevoegen.
Een project van de Arduino IDE naar PlatformIO verplaatsen
- Maak in PIO Home een nieuw project en kies hetzelfde board dat je in de Arduino IDE gebruikte.
- Plak de inhoud van het .ino-bestand in src/main.cpp; voeg andere .ino-tabbladen in dezelfde map toe aan het eind van main.cpp en kopieer .h- en .cpp-bestanden naar de map src.
- Voeg helemaal bovenaan het bestand de regel #include voor Arduino.h toe.
- Schrijf bovenaan het bestand een prototype voor elke functie die je naast setup() en loop() hebt geschreven.
- Zoek de bibliotheken die je gebruikt via PIO Home > Libraries en voeg ze toe aan lib_deps; als je het versienummer uit de Arduino IDE opschrijft, krijg je hetzelfde gedrag.
- Schrijf de snelheid van Serial.begin() in de regel monitor_speed en bouw het project. Los de resterende waarschuwingen in de foutenlijst een voor een op.
Je kunt ook een bestaande map rechtstreeks importeren met de knop Import Arduino Project in PIO Home. PlatformIO zet de .ino-bestanden in de map src tijdens de build om naar .cpp en probeert de prototypes te genereren. Omdat deze conversie bij complexe code dingen verkeerd kan doen en IntelliSense op .ino-bestanden niet op volle kracht werkt, is verhuizen naar main.cpp op de lange termijn gezonder. Als je moeite hebt met het interpreteren van buildmeldingen, gelden de uitleg in het bericht Arduino-compileerfouten ook voor PlatformIO.
Arduino IDE of PlatformIO?
| Eigenschap | Arduino IDE 2.x | PlatformIO (VS Code) |
|---|---|---|
| Installatie | Eén pakket, een paar minuten | VS Code plus de extensie; tools worden bij de eerste installatie gedownload |
| Codeaanvulling | Basaal | Geavanceerde IntelliSense, naar definitie gaan, bulkhernoemen |
| Boardinstellingen | In het menu Tools, niet opgeslagen met het project | In platformio.ini, reist mee met het project |
| Bibliotheken | Gedeeld over de hele computer | Apart per project, versies kunnen worden vastgezet |
| Meerdere boards | Telkens via het menu gewijzigd | Meerdere omgevingen in één project |
| Bestandsstructuur | .ino; mapnaam moet overeenkomen met de bestandsnaam | src, include, lib; standaard .cpp en .h |
| Functieprototypes | Automatisch gegenereerd | Met de hand geschreven (automatisch bij het importeren van .ino) |
| Versiebeheer met Git | Mogelijk, maar boardinstellingen blijven buiten beeld | Eenvoudig; alles behalve de map .pio wordt bijgehouden |
| Debuggen en testen | Een debugger op sommige boards | Ondersteuning voor debugger (debugprobe) en unittests |
| Geschikt voor beginners | Zeer hoog | Gemiddeld; vraagt een korte gewenningsperiode |
Kortom: als je je eerste led laat branden of een schoolproject met een paar bestanden doet, is de Arduino IDE genoeg en minder verwarrend. Heb je te maken met meerdere boards, code in meerdere bestanden, versiebeheer met Git of samenwerking, dan bespaart PlatformIO je veel tijd. De twee tools sluiten elkaar niet uit; je kunt beide op dezelfde computer gebruiken. Heb je de Arduino IDE nog niet geïnstalleerd, begin dan met het bericht Arduino IDE installeren.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| 'xyz' was not declared in this scope | Ontbrekend functieprototype | Schrijf het prototype vóór setup() of verplaats de functie naar boven |
| fatal error: DHT.h: No such file or directory | De bibliotheek staat niet in lib_deps of is aan een andere omgeving toegevoegd | Voeg de bibliotheek toe aan de juiste sectie [env] en bouw opnieuw |
| Onzintekens in de Serial Monitor | monitor_speed wijkt af van de snelheid van Serial.begin() | Maak de twee waarden gelijk (bijv. 115200) |
| Board verschijnt niet, geen poort | Kabel alleen voor opladen, of het CH340/CP2102-stuurprogramma ontbreekt | Gebruik een datakabel, installeer het stuurprogramma, controleer met pio device list |
| Access is denied / Resource busy | De poort is geopend in een ander programma | Sluit de Serial Monitor van de Arduino IDE en andere terminals |
| ESP32: Failed to connect, Wrong boot mode | Het board ging niet in downloadmodus | Start de upload terwijl je de knop BOOT ingedrukt houdt |
| Upload naar de Pico start niet | Het board staat niet in BOOTSEL-modus | Sluit hem aan terwijl je BOOTSEL ingedrukt houdt en controleer of de schijf RPI-RP2 verschijnt |
| Permission denied: /dev/ttyUSB0 op Linux | Ontbrekende udev-regel of gebruikersrechten | Installeer het bestand 99-platformio-udev.rules en voeg je gebruiker toe aan de groep dialout |
| Op Windows stopt het bouwen met onbegrijpelijke padfouten | Niet-Engelse tekens of spaties in de gebruikersnaam | Verplaats de coremap naar C:\platformio met PLATFORMIO_CORE_DIR |
| Blijft hangen bij de fase Installing PlatformIO Core | Probleem met internet, antivirus of Python | Herstart VS Code, controleer het log Output > PlatformIO |
Eerste projecten om met PlatformIO uit te proberen
- Blink voor meerdere boards: Upload het bovenstaande project met drie omgevingen om de beurt naar de Uno, ESP32 en Pico om te begrijpen hoe de omgevingskiezer werkt.
- Sensorlog met tijdstempel: Toon DHT11-gegevens met tijdstempels in de Serial Monitor met de instelling monitor_filters = time.
- Wi-Fi-webserver: Splits in het ESP32-webserverproject de code op in meerdere .cpp- en .h-bestanden om een nette structuur te maken.
- Draadloze updates: Upload met ESP32 OTA code via Wi-Fi door upload_protocol = espota in te stellen en het IP-adres van het board in de regel upload_port te schrijven.
- Toestandsmachine: Schrijf de logica van de Arduino-toestandsmachine in een apart klassebestand en profiteer van de mapstructuur van PlatformIO.
- Timing zonder delay: Schrijf een programma dat met millis() meerdere taken tegelijk uitvoert.
Hoewel het installeren van PlatformIO in het begin wat langer duurt dan de Arduino IDE, houdt het bestand platformio.ini alle instellingen van een project op één plek, waardoor het na verloop van tijd de tool wordt die je het meeste tijd bespaart. Als de installatie klaar is, is het eerste wat je doet een eenvoudig ledproject bouwen en uploaden, en daarna doorgaan naar projecten met bibliotheken en meerdere boards. In de BlueGrays-app vind je stap voor stap, met schakelschema's en code, led-knipperprojecten, startprojecten voor ESP32 en Pico en sensorprojecten zoals de DHT11 en HC-SR04, en je kunt ze uitproberen door de code rechtstreeks over te zetten naar je eigen PlatformIO-project.
Veelgestelde vragen
Is PlatformIO gratis?
Ja. PlatformIO Core en de PlatformIO IDE-extensie voor VS Code zijn opensource en gratis te gebruiken. Voor hobby-, school- of commerciële projecten hoef je geen licentiekosten te betalen voor de boarddefinities, de bibliotheekbeheerder en de functies voor bouwen en uploaden.
Werkt Arduino IDE-code in PlatformIO?
Ja, want als je framework = arduino kiest, worden dezelfde Arduino-core en dezelfde functies gebruikt. Je hoeft alleen de code naar src/main.cpp te verplaatsen, bovenaan de include van Arduino.h toe te voegen, de functieprototypes te schrijven en de bibliotheken die je gebruikt toe te voegen aan lib_deps.
Waarom duurt de installatie van PlatformIO zo lang?
Bij de eerste installatie worden PlatformIO Core, de Python-omgeving en de basistools gedownload; in je eerste project worden ook de compiler en het framework voor het gekozen board gedownload. Omdat ESP32-pakketten honderden megabytes kunnen zijn, kan dit 5–15 minuten duren, afhankelijk van je verbinding. Zodra de pakketten zijn gedownload, openen latere projecten snel.
Ondersteunt PlatformIO MicroPython?
Nee, PlatformIO is ontworpen voor op C/C++ gebaseerde frameworks zoals Arduino en ESP-IDF. Wil je een Raspberry Pi Pico of ESP32 met MicroPython programmeren, gebruik dan een editor als Thonny. Als je wilt, kun je hetzelfde board in PlatformIO ook programmeren met het Arduino-framework.
Hoe voeg je een bibliotheek toe in PlatformIO?
De makkelijkste manier is het tabblad Libraries in PIO Home te openen, de bibliotheek te zoeken en je project te kiezen met Add to Project. Dit voegt een regel lib_deps toe aan platformio.ini en de bibliotheek wordt bij de eerste build automatisch gedownload. Je eigen bibliotheken kun je als submappen in de map lib van het project zetten.
Hoe kies je de COM-poort in PlatformIO?
PlatformIO vindt het aangesloten board meestal automatisch. Als er meerdere seriële apparaten zijn, kun je de poort vastzetten met de poortkiezer in de statusbalk of door de regels upload_port = COM5 en monitor_port = COM5 in platformio.ini te schrijven. Welke poorten zijn aangesloten, zie je met de opdracht pio device list.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

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.

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…

Afstand meten met HC-SR04 (Serial-weergave)
De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

Ingebouwde led van de ESP32 laten knipperen
De ingebouwde blauwe led op de ESP32 DevKit V1 laten knipperen. Geen externe componenten nodig! Het eerste project dat je moet proberen als je een ESP32 koopt. GPIO 2 is verbonden met de ingebouwde led.

Raspberry Pi Pico: een externe led aansturen (breadboard)
De volgende stap na de ingebouwde led van de Pico: sluit een externe led aan op een breadboard en bestuur hem via pin GP14. Je leert hoe je elke GPIO-pin van de Pico als uitgang gebruikt, de polariteit van de led (lang pootje = anode/+, kort pootje = kathode/–) en waarom een stroombeperkende weerstand (220Ω) een must is. Zonder weerstand loopt er te veel stroom door de led en kan hij doorbranden.

ESP32-ledbesturing met drukknop (Push)
De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Laat zien hoe je de digitale ingangspin en de interne pull-upweerstand van de ESP32 gebruikt. Met de modus INPUT_PULLUP heb je geen externe weerstand nodig.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

