Gidsen · 12 min leestijd

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.

Arduino Uno-board geprogrammeerd met PlatformIO
Met PlatformIO programmeer je boards zoals de Arduino Uno, ESP32 en Raspberry Pi Pico vanuit dezelfde editor met één instellingenbestand.

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:

BegripBetekenisVoorbeeld
PlatformHet pakket met compiler en uploadtool voor een microcontrollerfamilieatmelavr, espressif32, raspberrypi
BoardEen specifiek board binnen een platform; pinindeling, kloksnelheid en geheugeninfouno, nanoatmega328, esp32dev, pico
FrameworkDe softwarebasis waarop je code is geschrevenarduino, espidf
Omgeving (env)Het gedeelte dat platform, board, framework en extra instellingen samen definieert[env:uno]
BibliotheekEen kant-en-klaar codepakket dat je met lib_deps aan het project toevoegtadafruit/DHT sensor library
PIO HomeHet scherm om projecten te openen en boards en bibliotheken te zoekenHet huisjespictogram in de statusbalk

PlatformIO instellen stap voor stap

  1. 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.
  2. Open VS Code en klik links op het tabblad Extensies, of gebruik de sneltoets Ctrl+Shift+X (Cmd+Shift+X op macOS).
  3. 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.
  4. Rechtsonder verschijnt een melding "Installing PlatformIO Core". Afhankelijk van je internetsnelheid duurt dit een paar minuten; sluit VS Code in de tussentijd niet af.
  5. 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.
  6. Klik op het huisjespictogram om het PIO Home-scherm te openen. Als dit scherm er goed uitziet, is de installatie voltooid.
Als je Windows-gebruikersnaam niet-Engelse tekens (zoals ş, ğ, ı, ü) of spaties bevat, kan de toolchain van PlatformIO problemen hebben met het pad C:\Users\<naam>\.platformio en kan het bouwen stoppen met onbegrijpelijke padfouten. De oplossing is om PLATFORMIO_CORE_DIR toe te voegen aan de systeemomgevingsvariabelen en als waarde een map met alleen Engelse letters te kiezen, zoals C:\platformio. Als de installatie op Linux mislukt, controleer dan eerst of het pakket python3-venv is geïnstalleerd.

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 / bestandWaar het voor dient
platformio.iniHet 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:

C++ (Arduino IDE)
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
InstellingWat het doetVoorbeeldwaarde
platformHet te gebruiken platformpakket; de versie kan ook worden vastgezetatmelavr, [email protected]
boardBoard-IDuno, megaatmega2560, esp32dev, pico
frameworkSoftwareframeworkarduino
monitor_speedSnelheid van de Serial Monitor (standaard 9600)115200
upload_portUploadpoort (wordt automatisch gevonden als je hem leeg laat)COM5, /dev/ttyUSB0
upload_speedUploadbaudrate (vooral bij ESP-boards)921600
lib_depsBibliotheken die automatisch worden gedownloadadafruit/DHT sensor library@^1.4.4
build_flagsExtra vlaggen en macro's voor de compiler-D LED_PIN=2
monitor_filtersFilters die op de uitvoer van de Serial Monitor worden toegepasttime, 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:

C++ (Arduino IDE)
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}
Als je tijdens het compileren de fout 'blinkLed' was not declared in this scope ziet, ontbreekt er bijna altijd een prototype. Kopieer gewoon de eerste regel van de functie boven setup(), zonder de body en met een puntkomma aan het eind. Als je veel functies hebt, is het netter om ze te verzamelen in een .h-bestand in de map include.

Bouwen, uploaden en Serial Monitor

ActieStatusbalk / menuTerminalopdracht
BouwenVinkjepio run
UploadenPijl naar rechtspio run -t upload
Uploaden en monitor openenPlatformIO-menu > Upload and Monitorpio run -t upload -t monitor
Serial MonitorStekkerpictogrampio device monitor
OpschonenPrullenbakpio run -t clean
Poorten tonenPIO Home > Devicespio device list
Een specifieke omgeving bouwenOmgevingskiezer (env:...)pio run -e esp32dev
Een bibliotheek installerenPIO Home > Librariespio 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:

WaardeArduino UnoESP32 DevKitRaspberry Pi Pico
platformatmelavrespressif32raspberrypi
boardunoesp32devpico
frameworkarduinoarduinoarduino (Arduino Mbed-core)
Ingebouwde ledD13GPIO 2 (op de meeste DevKit-boards)GP25
UploadmethodeUSB-serieel en bootloaderUSB-serieel en esptoolUSB en BOOTSEL-modus
Typische monitor_speed9600 of 115200115200115200
C++ (Arduino IDE)
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 = pico

De 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.

C++ (Arduino IDE)
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.9
C++ (Arduino IDE)
1#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

  1. Maak in PIO Home een nieuw project en kies hetzelfde board dat je in de Arduino IDE gebruikte.
  2. 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.
  3. Voeg helemaal bovenaan het bestand de regel #include voor Arduino.h toe.
  4. Schrijf bovenaan het bestand een prototype voor elke functie die je naast setup() en loop() hebt geschreven.
  5. 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.
  6. 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?

EigenschapArduino IDE 2.xPlatformIO (VS Code)
InstallatieEén pakket, een paar minutenVS Code plus de extensie; tools worden bij de eerste installatie gedownload
CodeaanvullingBasaalGeavanceerde IntelliSense, naar definitie gaan, bulkhernoemen
BoardinstellingenIn het menu Tools, niet opgeslagen met het projectIn platformio.ini, reist mee met het project
BibliothekenGedeeld over de hele computerApart per project, versies kunnen worden vastgezet
Meerdere boardsTelkens via het menu gewijzigdMeerdere omgevingen in één project
Bestandsstructuur.ino; mapnaam moet overeenkomen met de bestandsnaamsrc, include, lib; standaard .cpp en .h
FunctieprototypesAutomatisch gegenereerdMet de hand geschreven (automatisch bij het importeren van .ino)
Versiebeheer met GitMogelijk, maar boardinstellingen blijven buiten beeldEenvoudig; alles behalve de map .pio wordt bijgehouden
Debuggen en testenEen debugger op sommige boardsOndersteuning voor debugger (debugprobe) en unittests
Geschikt voor beginnersZeer hoogGemiddeld; 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

SymptoomWaarschijnlijke oorzaakOplossing
'xyz' was not declared in this scopeOntbrekend functieprototypeSchrijf het prototype vóór setup() of verplaats de functie naar boven
fatal error: DHT.h: No such file or directoryDe bibliotheek staat niet in lib_deps of is aan een andere omgeving toegevoegdVoeg de bibliotheek toe aan de juiste sectie [env] en bouw opnieuw
Onzintekens in de Serial Monitormonitor_speed wijkt af van de snelheid van Serial.begin()Maak de twee waarden gelijk (bijv. 115200)
Board verschijnt niet, geen poortKabel alleen voor opladen, of het CH340/CP2102-stuurprogramma ontbreektGebruik een datakabel, installeer het stuurprogramma, controleer met pio device list
Access is denied / Resource busyDe poort is geopend in een ander programmaSluit de Serial Monitor van de Arduino IDE en andere terminals
ESP32: Failed to connect, Wrong boot modeHet board ging niet in downloadmodusStart de upload terwijl je de knop BOOT ingedrukt houdt
Upload naar de Pico start nietHet board staat niet in BOOTSEL-modusSluit hem aan terwijl je BOOTSEL ingedrukt houdt en controleer of de schijf RPI-RP2 verschijnt
Permission denied: /dev/ttyUSB0 op LinuxOntbrekende udev-regel of gebruikersrechtenInstalleer het bestand 99-platformio-udev.rules en voeg je gebruiker toe aan de groep dialout
Op Windows stopt het bouwen met onbegrijpelijke padfoutenNiet-Engelse tekens of spaties in de gebruikersnaamVerplaats de coremap naar C:\platformio met PLATFORMIO_CORE_DIR
Blijft hangen bij de fase Installing PlatformIO CoreProbleem met internet, antivirus of PythonHerstart VS Code, controleer het log Output > PlatformIO
IntelliSense markeert code soms met rode kronkellijntjes, ook al slaagt de build. Dat betekent meestal dat je een submap van het project in VS Code hebt geopend of dat de index niet is bijgewerkt. Open altijd de map die platformio.ini bevat en voer in het opdrachtenpalet (Ctrl+Shift+P) de opdracht PlatformIO: Rebuild IntelliSense Index uit.

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.

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 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
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
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

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.

4.6(50)
82
Ingebouwde led van de ESP32 laten knipperen
ES-4Beginner

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.

4.8(29)
54
Raspberry Pi Pico: een externe led aansturen (breadboard)
PI-2Beginner

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.

4.5(2)
7
ESP32-ledbesturing met drukknop (Push)
ES-2Beginner

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.

4.6(36)
57