Gidsen · 18 min leestijd

Blynk ESP32-tutorial: bedien leds, relais en sensoren met je telefoon

Blynk ESP32-tutorial: maak een template en datastreams (V0, V1), haal de auth token op, bedien een led en relais, zet sensordata in een grafiek, stuur meldingen en gebruik BlynkTimer.

Blynk en de ESP32 zijn de snelste manier om een board vanaf elke plek ter wereld te bedienen zonder zelf een telefoon-app te schrijven. Blynk IoT geeft je een cloudserver waarmee de ESP32 verbinding maakt (Blynk.Cloud), een mobiele app waarin je een dashboard bouwt met slepen en neerzetten, en een webdashboard. Als je op je telefoon een schakelaar aantikt, gaat het commando eerst naar de cloud en van daaruit naar de ESP32; de temperatuur die de ESP32 meet, reist op dezelfde manier terug en verschijnt op je telefoon als getal en als grafiek. Je telefoon en het board hoeven niet in hetzelfde huis te zijn: het werkt zelfs als je telefoon op mobiele data zit.

In deze gids bouw je helemaal vanaf nul een werkend project: je opent een Blynk.Cloud-account, definieert een template en datastreams (V0, V1, V2, V3), haalt de auth token van het apparaat op, installeert de bibliotheek, bedient een led en een relais vanaf je telefoon, zet DHT11-sensordata in een grafiek en krijgt een melding op je telefoon als de temperatuur stijgt. Je leert ook waarom je delay() beter niet gebruikt en wat BlynkTimer in plaats daarvan doet, hoe je de berichtenlimiet van het gratis abonnement uitrekent, waarom code uit de oude Blynk niet compileert en hoe je de meest voorkomende verbindingsfouten oplost.

ESP32-developmentboard dat met Blynk IoT vanaf een telefoon wordt bediend
Dankzij de ingebouwde Wi-Fi maakt de ESP32 rechtstreeks verbinding met Blynk.Cloud; je hebt geen extra draadloze module nodig.

Wat is Blynk IoT en hoe werkt het?

Bij Blynk maken de ESP32 en je telefoon nooit rechtstreeks verbinding met elkaar; beide verbinden met Blynk.Cloud en de server brengt de berichten over. Als de ESP32 start, maakt hij verbinding met Wi-Fi, daarna met de Blynk-server en meldt hij zich aan met zijn auth token. Data loopt via virtuele pins (V0–V255): een virtuele pin is geen echt pootje van de ESP32, maar een genummerd datakanaal tussen je code en de app. De schakelaar in de app schrijft een 1 naar V1, de functie BLYNK_WRITE(V1) in je code vangt dat op en bekrachtigt het relais; als je code Blynk.virtualWrite(V2, 24.5) uitvoert, wordt de meter op je telefoon bijgewerkt. Dit zijn de bouwstenen:

BegripWat het doetVoorbeeld in deze gids
TemplateHet gedeelde recept voor apparaten van hetzelfde soort: datastreams, dashboards en eventsESP32 Home
DatastreamEen datakanaal gekoppeld aan een virtuele pin, met vast type en bereikV2: Temperatuur, Double, 0–50 °C
ApparaatEen echt board dat uit de template is gemaakt; elk board heeft zijn eigen dataDe ESP32 in de woonkamer
Auth tokenDe geheime identiteitssleutel van het apparaat; je code gebruikt hem om met de cloud te verbindenDe regel BLYNK_AUTH_TOKEN
WidgetDashboard-elementen zoals schakelaars, meters en grafiekenButton, Gauge, SuperChart
EventEen waarschuwing die meldingen verstuurt en op de tijdlijn wordt vastgelegdyuksek_sicaklik

Verschillen tussen de oude Blynk en de nieuwe Blynk IoT

De meeste Blynk-video's en -sketches op internet zijn gemaakt voor de oude versie (Blynk Legacy), die niet meer werkt. Het nieuwe platform ging in mei 2021 live; de oude app is in juni 2022 uit de stores gehaald en de oude cloudservers zijn op 31 december 2022 definitief uitgezet. Een token uit een oud project, energiepunten die je ooit hebt gekocht of het adres blynk-cloud.com zijn dus nutteloos; je moet het project opnieuw opbouwen op het nieuwe platform. Het goede nieuws: het grootste deel van de ESP32-code (BLYNK_WRITE, virtualWrite, BlynkTimer) is hetzelfde gebleven.

KenmerkOude Blynk (Legacy)Blynk IoT (nieuw)
Waar stel je het project in?Alles in een project in de telefoon-appTemplates en datastreams in Blynk.Console (web), dashboards op telefoon en web
Auth tokenEén per project, per e-mail verstuurdEén per apparaat, te zien op de apparaatpagina
PrijsmodelWidgets kocht je met energiepuntenMaandabonnementen met limieten voor apparaten, berichten en functies
Bovenaan de sketchAlleen een regel char auth[]BLYNK_TEMPLATE_ID, BLYNK_TEMPLATE_NAME en BLYNK_AUTH_TOKEN zijn verplicht
MeldingenBlynk.notify() en Blynk.email()Een event wordt in de template gedefinieerd en met Blynk.logEvent() geactiveerd
Serverblynk-cloud.com, poort 80 of 8080 (uitgezet)blynk.cloud, poort 80 of 443 met SSL
WebdashboardGeenJa (Blynk.Console)
Lokale serverEen open-source Java-server kon zelf worden gehostGeen eigen lokale server; de oude server wordt niet meer bijgewerkt
Als je een oud voorbeeld met de nieuwe bibliotheek compileert, loop je tegen drie typische problemen aan: sketches die BLYNK_DEVICE_NAME gebruiken, falen met "Please specify your BLYNK_TEMPLATE_ID and BLYNK_TEMPLATE_NAME", sketches met Blynk.notify() stoppen met "'class BlynkWifi' has no member named 'notify'", en sketches die blynk-cloud.com (meestal met poort 8080) in Blynk.begin() noemen, compileren misschien wel, maar maken nooit verbinding.

Onderdelenlijst en bedrading

Voor dit project gebruik je een ESP32-developmentboard, een 5V-relaismodule, een DHT11-temperatuur- en vochtigheidssensor, optioneel een led met een weerstand van 220 Ω, een breadboard en jumperdraden. Voor de led is de ingebouwde blauwe led van het board op GPIO 2 genoeg; als je een externe led toevoegt, vind je de weerstandswaarde met de ledweerstandcalculator. Controleer de pinindeling van je board ook in de tool Pinout; op sommige boards heet de 5V-pin VIN, op andere 5V.

ESP32
ESP32
Relaismodule
Relaismodule
DHT11
DHT11
LED
LED
Breadboard
Breadboard
Jumperdraad
Jumperdraad
OnderdeelPin van het onderdeelESP32-pinOpmerking
Led (optioneel)Lang pootje (+)GPIO 2Via een weerstand van 220 Ω; kort pootje naar GND
RelaismoduleVCCVIN / 5VEr staat ongeveer 5 V op deze pin als het board via USB wordt gevoed
RelaismoduleGNDGNDGemeenschappelijke massa
RelaismoduleINGPIO 26Zet bij een active-LOW-module ROLE_AKTIF_LOW = true in de code
DHT11VCC3V3Werkt op 3,3–5,5 V
DHT11DATAGPIO 4Een kale sensor heeft een pull-upweerstand van 10 kΩ nodig; modules hebben die al aan boord
DHT11GNDGNDGemeenschappelijke massa
De pins van de ESP32 geven 3,3 V af. De meeste 5V-relaismodules schakelen met dit signaal, maar bij een active-LOW-module laat een HIGH van 3,3 V het relais niet altijd volledig los; als het relais nooit uitgaat, gebruik dan een module met 3,3V-trigger of zet er een NPN-transistor tussen. Als je met het relais een belasting op 230 V-net schakelt, bedraad je altijd met de stekker uit het stopcontact, laat je geen blote geleiders liggen en vraag je een volwassene om hulp; details in Wat is een relaismodule?

Stap 1: maak een Blynk.Cloud-account en een template

  1. Ga op je computer naar blynk.cloud, registreer een gratis account met je e-mailadres en stel je wachtwoord in via de link in de e-mail die je ontvangt.
  2. Ga in het linkermenu naar Developer Zone > My Templates en klik op + New Template.
  3. Geef de template een naam (bijvoorbeeld ESP32 Home), kies ESP32 als hardware en WiFi als verbindingstype en maak de template aan.
  4. De waarden BLYNK_TEMPLATE_ID en BLYNK_TEMPLATE_NAME op de templatepagina komen straks in je code; onthoud voorlopig alleen waar ze staan.
  5. Als er bij het registreren een Quickstart-wizard verschijnt, kun je die overslaan; in deze gids doen we elke stap met de hand, zodat je ziet waar elke instelling voor dient.

Stap 2: definieer de datastreams (V0, V1, V2, V3)

Een datastream is de identiteitskaart van een virtuele pin: hij bepaalt welke pin het is, het datatype (Integer voor hele getallen, Double voor decimalen, String voor tekst), de minimale en maximale waarde, de eenheid en hoeveel decimalen worden getoond. Open de template in bewerkmodus, ga naar het tabblad Datastreams, kies + New Datastream > Virtual Pin en maak deze vier kanalen aan:

Virtuele pinNaamDatatypeMin – MaxEenheid en decimalenWidget
V0LEDInteger0 – 1GeenButton / Switch
V1RelaisInteger0 – 1GeenButton / Switch
V2TemperatuurDouble0 – 50°C, #.#Gauge, SuperChart
V3VochtigheidDouble0 – 100%, #Gauge, SuperChart
De velden Min en Max zijn geen versiering: Blynk begrenst waarden buiten het bereik tot de limiet. Als je de Max van de temperatuur-datastream op 1 laat staan, zie je 1 op het dashboard, ook als de sensor 24,5 °C meet. Wil je dat schakelaars na een herstart van het board terugkeren naar hun laatste stand, gebruik dan Blynk.syncVirtual() in BLYNK_CONNECTED() in je code; je kunt ook Sync with latest server value inschakelen in de geavanceerde instellingen van de datastream en Blynk.syncAll() aanroepen. Vergeet na elke wijziging niet op Save te klikken in de template.

Stap 3: maak een apparaat aan en haal de auth token op

De template is een recept, het apparaat is het echte board dat ervan wordt gemaakt. Open in het linkermenu Devices, klik op + New Device, kies de template ESP32 Home met From template en geef het apparaat een naam. Zodra het apparaat is aangemaakt, verschijnt een configuratie van drie regels: BLYNK_TEMPLATE_ID, BLYNK_TEMPLATE_NAME en BLYNK_AUTH_TOKEN. Kopieer deze regels; je vindt ze later ook in het onderdeel Device Info van de apparaatpagina (in sommige versies van de interface heet dat Developer Tools).

De auth token is het wachtwoord van je apparaat. Plaats geen code met de token op forums of in een openbare GitHub-repository; iedereen die de token krijgt, kan je relais aan- en uitzetten. Als de token uitlekt, verwijder je het apparaat en maak je het opnieuw aan om een nieuwe token te krijgen. Elk board heeft een eigen apparaat en een eigen token nodig: als je dezelfde token op twee ESP32's flasht, gooien ze elkaar steeds offline.

Stap 4: installeer de Blynk-bibliotheek in de Arduino IDE

  1. Als het ESP32-boardpakket nog niet in de Arduino IDE is geïnstalleerd, installeer je dat eerst; de stappen staan in Wat is de ESP32?
  2. Open de Library Manager, typ Blynk in het zoekvak en installeer de officiële bibliotheek Blynk van Volodymyr Shymanskyy. Als er naar afhankelijkheden wordt gevraagd, kies je Install all.
  3. Installeer voor de sensor op dezelfde plek de DHT sensor library van Adafruit en de benodigde bibliotheek Adafruit Unified Sensor. Als je problemen krijgt, zie de gids Een Arduino-bibliotheek toevoegen.
  4. Selecteer ESP32 Dev Module onder Tools > Board, sluit het board aan met een USB-kabel die data doorgeeft en kies de juiste poort.
  5. De bibliotheek bevat kant-en-klare voorbeelden: File > Examples > Blynk > Boards_WiFi > ESP32_WiFi is de eenvoudigste vorm van de eerste sketch hieronder.

Eerste sketch: een led aan- en uitzetten vanaf je telefoon (V0)

Vervang in de code hieronder de bovenste drie regels door die je van de apparaatpagina hebt gekopieerd, en de wifinaam en het wachtwoord door je eigen gegevens. Deze drie #define-regels moeten vóór de #include-regels staan; de bibliotheek zoekt deze waarden tijdens het compileren en geeft een compileerfout als ze ontbreken.

C++ (Arduino IDE)
1// Bu üç satırı Blynk.Console'daki cihaz sayfasından kopyala / copy these three lines from the device page in Blynk.Console
2#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"
3#define BLYNK_TEMPLATE_NAME "ESP32 Ev"
4#define BLYNK_AUTH_TOKEN    "CihazTokeniniBurayaYapistir"
5
6#define BLYNK_PRINT Serial          // bağlantı günlüğünü Seri Monitör'e yaz / print the connection log to the Serial Monitor
7
8#include <WiFi.h>
9#include <WiFiClient.h>
10#include <BlynkSimpleEsp32.h>
11
12char ssid[] = "AgAdi";              // Wi-Fi adın (yalnız 2,4 GHz) / your Wi-Fi name (2.4 GHz only)
13char pass[] = "Sifre123";           // Wi-Fi şifren / your Wi-Fi password
14
15const int LED_PIN = 2;              // çoğu DevKit'te dahili LED / onboard LED on most DevKits
16
17// Uygulama V0'a her değer yazdığında çalışır / runs every time the app writes a value to V0
18BLYNK_WRITE(V0) {
19  int deger = param.asInt();        // anahtar: 0 ya da 1 / switch: 0 or 1
20  digitalWrite(LED_PIN, deger);
21  Serial.print("V0 = ");
22  Serial.println(deger);
23}
24
25// Buluta her bağlanışta son V0 değerini iste / ask for the last V0 value on every connection
26BLYNK_CONNECTED() {
27  Blynk.syncVirtual(V0);
28}
29
30void setup() {
31  Serial.begin(115200);
32  pinMode(LED_PIN, OUTPUT);
33  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);   // Wi-Fi'ye ve Blynk.Cloud'a bağlan / connect to Wi-Fi and Blynk.Cloud
34}
35
36void loop() {
37  Blynk.run();                      // gelen komutları işler, bağlantıyı canlı tutar / handles commands, keeps the link alive
38}
RegelWat het doet
BLYNK_PRINT SerialLaat de bibliotheek haar verbindingsstappen naar de Serial Monitor printen; erg handig bij het oplossen van problemen
BLYNK_WRITE(V0)Een functie die automatisch wordt uitgevoerd als de app of het webdashboard een waarde naar V0 stuurt
param.asInt()Zet de binnenkomende waarde om naar een geheel getal; gebruik asFloat() voor decimalen en asStr() voor tekst
BLYNK_CONNECTED()Wordt eenmaal uitgevoerd na elke geslaagde verbinding
Blynk.syncVirtual(V0)Vraagt de server om de laatste waarde van V0, zodat de led ook na een herstart terugkeert naar zijn vorige stand
Blynk.begin(...)Maakt verbinding met Wi-Fi en Blynk.Cloud; wacht tot de verbinding er is
Blynk.run()Verwerkt binnenkomende commando's en houdt de verbinding in leven; moet in loop zonder wachttijd worden aangeroepen

Nadat je de code hebt geüpload en de Serial Monitor op 115200 baud hebt geopend, zie je regels als "Connecting to AgAdi", "Connected to WiFi", het IP-adres, "Connecting to blynk.cloud:80" en ten slotte "Ready (ping: 45ms).", in die volgorde. Zodra de regel Ready verschijnt, staat het apparaat in Blynk.Console als Online. Bij de eerste verbinding zie je mogelijk ook een regel die begint met "Redirecting to"; de bibliotheek schakelt automatisch over naar de regionale server waar je account op staat, wat normaal is.

De telefoon- en webdashboards instellen

De code is klaar, dus tijd om de knoppen te plaatsen. In Blynk worden het mobiele dashboard en het webdashboard apart ontworpen; omdat beide dezelfde datastreams gebruiken, verschijnt een wijziging op het ene meteen op het andere.

  1. Installeer de app Blynk IoT op je telefoon (niet de oude Blynk of Blynk Legacy) en log in met hetzelfde account.
  2. Zet Developer Mode aan op je profielpagina en tik dan in de Developer Zone op de template ESP32 Home.
  3. Tik op het lege canvas om widgets toe te voegen: een Button of Switch voor V0 en V1, een Gauge of Labeled Value voor V2 en V3, en een SuperChart voor de geschiedenis.
  4. Tik op elke widget en selecteer in de instellingen de bijpassende datastream; je kunt V2 en V3 samen aan de SuperChart toevoegen. Wijzigingen worden automatisch opgeslagen.
  5. Voor het webdashboard bewerk je de template in Blynk.Console, sleep je widgets naar het tabblad Web Dashboard, kies je de datastream via het tandwielpictogram van elke widget en klik je op Save.
  6. Tik in de app op de naam van je apparaat en probeer de schakelaar: de led op GPIO 2 moet meteen oplichten en de Serial Monitor moet "V0 = 1" printen.
De Button-widget heeft twee standen: in de modus Switch wisselt hij bij elke tik tussen 1 en 0, in de modus Push stuurt hij 1 zolang je hem vasthoudt en 0 als je loslaat. Gebruik Switch voor lampen en stopcontacten en Push voor taken die een korte puls nodig hebben, zoals een deurbel of een garagedeur.

Relais en sensor: lezen zonder delay() met BlynkTimer

De gouden regel van Blynk is: loop() mag alleen Blynk.run() en timer.run() bevatten. Als je delay(2000) in loop zet, ziet de ESP32 in die tijd geen commando's van je telefoon en reageert de schakelaar te laat; heel lange wachttijden zorgen ervoor dat de server het apparaat als offline beschouwt. Erger nog: als je Blynk.virtualWrite() rechtstreeks in loop zet, probeert de ESP32 honderden berichten per seconde te sturen; de server remt het apparaat af en je maandelijkse berichtenquotum raakt snel op. De oplossing is BlynkTimer, die volgens het millis()-principe werkt: hij roept de functie die jij kiest aan op het interval dat jij kiest, en loop blijft er tussendoor vrij. We leggen dit idee uitgebreid uit in Arduino millis() versus delay().

De code hieronder bedient het relais met V1, stuurt elke 60 seconden de met de DHT11 gemeten temperatuur naar V2 en de luchtvochtigheid naar V3, en activeert een meldingsevent als de temperatuur boven 30 °C komt. Hoe de sensor werkt, lees je in DHT11-temperatuur- en vochtigheidssensor.

C++ (Arduino IDE)
1#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"
2#define BLYNK_TEMPLATE_NAME "ESP32 Ev"
3#define BLYNK_AUTH_TOKEN    "CihazTokeniniBurayaYapistir"
4#define BLYNK_PRINT Serial
5
6#include <WiFi.h>
7#include <WiFiClient.h>
8#include <BlynkSimpleEsp32.h>
9#include <DHT.h>
10
11char ssid[] = "AgAdi";
12char pass[] = "Sifre123";
13
14const int ROLE_PIN = 26;            // röle modülünün IN pini / relay module IN pin
15const int DHT_PIN  = 4;             // DHT11 veri pini / DHT11 data pin
16const bool ROLE_AKTIF_LOW = true;   // çoğu modül LOW'da çeker / most modules switch on with LOW
17
18DHT dht(DHT_PIN, DHT11);            // DHT22 kullanıyorsan DHT22 yaz / write DHT22 if you use a DHT22
19BlynkTimer timer;                   // delay() yerine zamanlayıcı / a timer instead of delay()
20bool alarmGitti = false;            // aynı bildirimin tekrarını önler / stops the same alert repeating
21
22void roleYaz(bool acik) {
23  if (ROLE_AKTIF_LOW) digitalWrite(ROLE_PIN, acik ? LOW : HIGH);
24  else                digitalWrite(ROLE_PIN, acik ? HIGH : LOW);
25}
26
27// V1: uygulamadaki röle anahtarı / relay switch in the app
28BLYNK_WRITE(V1) {
29  roleYaz(param.asInt() == 1);
30}
31
32// Elektrik gidip gelince rölenin son durumunu geri al / restore the relay state after a power cut
33BLYNK_CONNECTED() {
34  Blynk.syncVirtual(V1);
35}
36
37// Zamanlayıcının çağırdığı fonksiyon / the function called by the timer
38void sensorGonder() {
39  float sicaklik = dht.readTemperature();
40  float nem = dht.readHumidity();
41  if (isnan(sicaklik) || isnan(nem)) {
42    Serial.println("DHT okunamadi / DHT read failed");
43    return;
44  }
45  Blynk.virtualWrite(V2, sicaklik);   // V2: sıcaklık (°C) / temperature (°C)
46  Blynk.virtualWrite(V3, nem);        // V3: nem (%) / humidity (%)
47
48  // 30 °C'yi geçince tek bildirim, 28 °C'nin altında yeniden kur / one alert above 30 °C, re-arm below 28 °C
49  if (sicaklik > 30.0 && !alarmGitti) {
50    Blynk.logEvent("yuksek_sicaklik", String("Sicaklik / Temp: ") + sicaklik + " C");
51    alarmGitti = true;
52  } else if (sicaklik < 28.0) {
53    alarmGitti = false;
54  }
55}
56
57void setup() {
58  Serial.begin(115200);
59  pinMode(ROLE_PIN, OUTPUT);
60  roleYaz(false);                   // açılışta röle kapalı / relay off at boot
61  dht.begin();
62  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
63  timer.setInterval(60000L, sensorGonder);   // 60 saniyede bir ölç ve gönder / measure and send every 60 seconds
64}
65
66void loop() {
67  Blynk.run();
68  timer.run();                      // loop'ta delay() ya da virtualWrite olmasın / no delay() or virtualWrite in loop
69}

De regel timer.setInterval(60000L, sensorGonder) roept de functie elke 60.000 milliseconden aan; de L aan het eind markeert het getal als long. Voor eenmalige taken gebruik je timer.setTimeout(), bijvoorbeeld om het relais aan te zetten en 5 seconden later weer uit. Eén BlynkTimer-object bevat maximaal 16 timers, wat voor de meeste projecten ruim voldoende is. De controle met isnan() voorkomt dat een betekenisloze NaN-waarde in de cloud terechtkomt als de sensor niet gelezen kan worden. De vlag alarmGitti en het verschil tussen de drempels van 30 en 28 °C (hysterese) voorkomen een nieuwe melding bij elke meting als de temperatuur rond 30 °C schommelt.

Sensordata in een grafiek tonen

Om de grafiek te vullen zijn twee dingen nodig: de ESP32 moet data sturen met virtualWrite en de datastream moet geschiedenis bewaren. Als bij de datastream-instellingen voor de geschiedenis Last Value is gekozen, bewaart de server alleen de laatste waarde en wordt er geen grafiek getekend; de optie gemiddelde per minuut (1 Minute AVG) is genoeg voor grafieken. In het gratis abonnement wordt de geschiedenis 1 week bewaard en is opslag van ruwe (RAW) data voorbehouden aan betaalde abonnementen. In SuperChart kun je wisselen tussen tijdbereiken zoals uren, dagen en weken en temperatuur en luchtvochtigheid in twee kleuren in dezelfde grafiek zien. Omdat er elke 60 seconden data binnenkomt, duurt het een paar minuten voordat de eerste punten verschijnen; wees niet ongeduldig en zet het interval niet op 1 seconde, je ziet waarom in het gedeelte over het gratis abonnement.

Meldingen versturen: events en Blynk.logEvent()

In de nieuwe Blynk werken meldingen via events. Je definieert het event eerst in de template en activeert het dan in code met Blynk.logEvent(); Blynk schrijft het event naar de tijdlijn van het apparaat en stuurt, afhankelijk van de instellingen, een pushmelding of e-mail naar je telefoon. Een eventbeschrijving mag maximaal 300 tekens lang zijn, maar omdat de verzendbuffer van de bibliotheek klein is, hou je haar het best kort.

  1. Open de template in bewerkmodus en ga naar het tabblad Events & Notifications.
  2. Klik op + Create Event, geef het event een naam zoals "High temperature" en stel de eventcode in op yuksek_sicaklik. De code mag alleen letters, cijfers en underscores bevatten en moet exact overeenkomen met de tekst in je sketch.
  3. Kies Warning als eventtype; Info, Warning en Critical bepalen hoe ernstig de waarschuwing is. Zorg dat de tijdlijnoptie aan staat, zodat het event in de app verschijnt.
  4. Zet op het tabblad Notifications meldingen aan, kies je eigen account als ontvanger en push en e-mail als kanalen; beperk de meldingen desgewenst tot één per uur.
  5. Klik op Save in de template en bevestig het bijwerken van het apparaat. Vergeet niet meldingen toe te staan voor de app Blynk IoT op je telefoon.
LimietWaarde
Events per apparaat per dag (logEvent)100
Tussen twee events van hetzelfde typeMinstens 1 seconde
Tussen twee meldingen (push, e-mail)Minstens 5 seconden
EventbeschrijvingMaximaal 300 tekens
Aanvraagsnelheid per apparaatMaximaal 50 per seconde
Lengte van een stringwaardeMaximaal 1024 bytes
Zet Blynk.logEvent() nooit in loop() of in een voorwaarde zonder vlag die bij elke meting wordt uitgevoerd. Code die elke 60 seconden een event verstuurt zolang de temperatuur boven de drempel ligt, verbruikt de limiet van 100 events per dag in ongeveer 100 minuten, en dan krijg je die dag geen enkele andere melding meer. Gebruik een vlag zoals in de code hierboven, of zet de beperkingsopties op het tabblad Notifications aan.

Limieten van het gratis abonnement: zo reken je de berichten uit

Het gratis abonnement van Blynk is genoeg om te leren en voor kleine projecten, maar een project dat je bouwt zonder de limieten te kennen, kan halverwege de maand stil vallen. Per oktober 2026 vermeldt de prijspagina van Blynk deze waarden voor het gratis abonnement: 5 apparaten, 1 gebruiker, 100.000 apparaatberichten per maand, 1 week datageschiedenis, 10 templates, 5 events per template, 1 webhook en 5 automatiseringen. Deze limieten zijn de afgelopen jaren meerdere keren veranderd; controleer vóór je een langlopend project bouwt de actuele waarden op de prijspagina van Blynk of in de abonnementsinstellingen van je account. Het zwaarst voor het quotum tellen de commando's virtualWrite, syncVirtual en logEvent die je apparaat verstuurt, en elke virtualWrite is één bericht. Een maand heeft ongeveer 2.592.000 seconden, dus de berekening is eenvoudig:

Verzendinterval1 datastream (30 dagen)2 datastreams (30 dagen)Past binnen de 100.000?
2 seconden1.296.0002.592.000Nee
10 seconden259.200518.400Nee
30 seconden86.400172.800Eén waarde past, twee niet
60 seconden43.20086.400Past, maar met twee waarden is er weinig ruimte over
5 minuten8.64017.280Past ruim
Er zijn drie manieren om berichten te besparen: maak het meetinterval zo lang als je echt nodig hebt (de kamertemperatuur elke 5 minuten controleren is genoeg), stuur een waarde alleen als die met een bepaalde stap verandert (bijvoorbeeld als de temperatuur 0,5 °C verandert) en stuur geen data naar datastreams die je niet gebruikt. De eigen voorbeelden van de bibliotheek raden ook af om meer dan 10 waarden per seconde te sturen.

Een verbinding die niet vastloopt zonder Wi-Fi

Blynk.begin() is gemakkelijk, maar heeft een nadeel: als de Wi-Fi- of Blynk-verbinding niet tot stand komt, wacht het eindeloos in setup() en draait de rest van het board nooit. In projecten die moeten blijven werken als het internet wegvalt, zoals een thermostaat of een bewateringssysteem, moet je de verbinding zelf beheren. Het skelet hieronder start Wi-Fi zonder te wachten, past met Blynk.config() alleen de instellingen toe en controleert de verbinding elke 10 seconden; ondertussen blijven de lokale taken die je aan de timer toevoegt gewoon draaien, ongeacht het internet.

C++ (Arduino IDE)
1#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"
2#define BLYNK_TEMPLATE_NAME "ESP32 Ev"
3#define BLYNK_AUTH_TOKEN    "CihazTokeniniBurayaYapistir"
4#define BLYNK_PRINT Serial
5
6#include <WiFi.h>
7#include <WiFiClient.h>
8#include <BlynkSimpleEsp32.h>
9
10char ssid[] = "AgAdi";
11char pass[] = "Sifre123";
12
13BlynkTimer timer;
14
15// Wi-Fi varsa ama Blynk bağlı değilse yeniden dene / retry Blynk when Wi-Fi is up but Blynk is not
16void baglantiKontrol() {
17  if (WiFi.status() == WL_CONNECTED && !Blynk.connected()) {
18    Serial.println("Blynk'e yeniden baglaniliyor / reconnecting to Blynk");
19    Blynk.connect(3000);            // en fazla 3 saniye bekle / wait at most 3 seconds
20  }
21}
22
23void setup() {
24  Serial.begin(115200);
25  WiFi.mode(WIFI_STA);
26  WiFi.begin(ssid, pass);           // beklemeden başlat / start without waiting
27  Blynk.config(BLYNK_AUTH_TOKEN);   // yalnız ayarla, bağlanmayı bekleme / configure only, don't block
28  timer.setInterval(10000L, baglantiKontrol);   // 10 saniyede bir kontrol / check every 10 seconds
29}
30
31void loop() {
32  if (Blynk.connected()) {
33    Blynk.run();
34  }
35  timer.run();                      // yerel işler internet yokken de çalışır / local tasks keep running offline
36}

De ESP32 probeert zelf opnieuw met Wi-Fi te verbinden als de verbinding wegvalt; de code maakt pas weer verbinding met Blynk zodra Wi-Fi terug is. Wil je je data versleutelen, neem dan BlynkSimpleEsp32_SSL.h op in plaats van BlynkSimpleEsp32.h; de verbinding gebruikt dan TLS op poort 443 in plaats van 80 en komt ook langs poortblokkades op sommige school- of bedrijfsnetwerken. Wil je je wifigegevens niet in de code zetten, dan kun je met het voorbeeld Blynk.Edgent > Edgent_ESP32 van de bibliotheek de netwerknaam en het wachtwoord invoeren in de app Blynk IoT op je telefoon; bij deze methode wordt de auth token automatisch toegewezen wanneer het apparaat wordt toegevoegd en kan de code over de lucht (OTA) worden bijgewerkt. Dezelfde code draait ook op ESP8266-boards: voor een NodeMCU gebruik je gewoon ESP8266WiFi.h en BlynkSimpleEsp8266.h.

Blynk met de Raspberry Pi Pico W en MicroPython

Blynk is er niet alleen voor de ESP32. Als je MicroPython op een Raspberry Pi Pico W gebruikt, hoef je alleen het losse bestand BlynkLib.py uit de Python-bibliotheek van Blynk met Thonny naar de Pico te kopiëren. Houd er rekening mee dat deze bibliotheek niet meer actief wordt ontwikkeld en dat Blynk voor nieuwe projecten zijn MQTT-API aanraadt; toch doet ze haar werk voor leren en eenvoudige projecten. De code hieronder bedient de ingebouwde led van de Pico W met V0 en stuurt eenmaal per minuut de waarde van de temperatuursensor in de chip naar V2. Maak in Blynk.Console een apart apparaat voor de Pico W aan en gebruik de token daarvan. Ben je nieuw met MicroPython, dan is MicroPython-basis een goed beginpunt.

MicroPython
1import network, time
2from machine import Pin, ADC
3import BlynkLib                      # BlynkLib.py Pico'da olmalı / BlynkLib.py must be on the Pico
4
5WIFI_SSID = "AgAdi"
6WIFI_PASS = "Sifre123"
7BLYNK_AUTH = "PicoTokeniniBurayaYapistir"
8
9led = Pin("LED", Pin.OUT)            # Pico W dahili LED / Pico W onboard LED
10sensor = ADC(4)                      # yongadaki sıcaklık sensörü / on-chip temperature sensor
11
12wlan = network.WLAN(network.STA_IF)
13wlan.active(True)
14wlan.connect(WIFI_SSID, WIFI_PASS)
15while not wlan.isconnected():
16    time.sleep(0.5)
17print("IP:", wlan.ifconfig()[0])
18
19blynk = BlynkLib.Blynk(BLYNK_AUTH, insecure=True)   # 80 portu, TLS'siz / port 80, no TLS
20
21@blynk.on("V0")
22def v0_yazildi(value):               # uygulamadaki anahtar / switch in the app
23    led.value(int(value[0]))
24
25@blynk.on("connected")
26def baglandi(ping):
27    print("Blynk hazir / ready, ping:", ping, "ms")
28    blynk.sync_virtual(0)            # son V0 değerini iste / ask for the last V0 value
29
30son = time.ticks_ms()
31while True:
32    blynk.run()
33    if time.ticks_diff(time.ticks_ms(), son) >= 60000:   # 60 saniyede bir / every 60 seconds
34        son = time.ticks_ms()
35        volt = sensor.read_u16() * 3.3 / 65535
36        sicaklik = 27 - (volt - 0.706) / 0.001721
37        blynk.virtual_write(2, round(sicaklik, 1))      # V2: sıcaklık / temperature

In dit voorbeeld wordt de verbinding onversleuteld op poort 80 gemaakt met insecure=True; dit is de optie die het minste geheugen gebruikt en ze staat op hetzelfde niveau als BlynkSimpleEsp32.h op de ESP32. Als je deze parameter weghaalt, probeert de bibliotheek TLS op poort 443 te gebruiken. De reden dat we de tijd in de lus meten met ticks_ms in plaats van time.sleep() is dezelfde als bij Arduino: als blynk.run() niet vaak genoeg wordt aangeroepen, lopen commando's achter en valt de verbinding weg. De temperatuursensor in de chip kan een paar graden afwijken van de kamertemperatuur; sluit een DHT11 of DS18B20 aan voor echte metingen.

Projectideeën met Blynk

  • Slimme stekker: zet een bureaulamp of ventilator vanaf elke plek ter wereld aan en uit met een relais; voor de bedrading van het relais zie Wat is een relaismodule?
  • Planten op afstand water geven: laat de pomp draaien als de bodemvochtsensor droge grond meldt en volg het vochtniveau in een grafiek.
  • Slimme kas: zet een ventilator aan als temperatuur en luchtvochtigheid stijgen en krijg een melding als waarden een drempel overschrijden; details in Project slimme kas.
  • Inbraakalarm: stuur met logEvent een kritieke melding naar je telefoon als de PIR-bewegingssensor iemand detecteert.
  • Gaslekmelding: laat een buzzer klinken en je telefoon ook trillen als de MQ-2-gassensor zijn drempel overschrijdt.
  • Weerstation: vergelijk temperatuur, luchtvochtigheid en luchtdruk van een BME280 in een weekgrafiek.
  • Deur- en raambewaking: zie in de app of een deur open is blijven staan met een reedschakelaar.

Veelvoorkomende fouten en oplossingen

Symptoom of meldingOorzaakOplossing
"Please specify your BLYNK_TEMPLATE_ID and BLYNK_TEMPLATE_NAME" bij het compilerenRegels ontbreken, staan na de #include of de oude BLYNK_DEVICE_NAME wordt gebruiktZet de drie #define-regels helemaal bovenaan, vóór de includes; verander DEVICE_NAME in TEMPLATE_NAME
"'class BlynkWifi' has no member named 'notify'" bij het compilerenHet commando Blynk.notify() uit oude Blynk-codeMaak een event in de template en gebruik Blynk.logEvent()
"Invalid auth token" in de Serial MonitorToken ontbreekt of is verkeerd gekopieerd, apparaat is verwijderd of er wordt een token van de oude Blynk gebruiktKopieer de token opnieuw van de apparaatpagina, zonder spaties aan het begin of einde
Niets na de regel "Connecting to AgAdi"Het board kan geen verbinding maken met Wi-Fi: 5GHz-netwerk, fout wachtwoord of zwak signaalGebruik een 2,4GHz-netwerk; zie de ESP32-wifigids voor details
"Connecting to blynk.cloud:80" herhaalt zich of "Login timeout"Geen internet op het netwerk, of een school- of bedrijfsnetwerk blokkeert de verbindingProbeer een hotspot van je telefoon; gebruik poort 443 met BlynkSimpleEsp32_SSL.h
"Heartbeat timeout", apparaat vaak OfflineLange delay() of een blokkerende lus in loop, zwakke voedingVerplaats wachttijden naar BlynkTimer, gebruik een goede kabel en voedingsadapter
Er gebeurt niets als je op de schakelaar druktDe widget is gekoppeld aan een andere datastream of de pin in BLYNK_WRITE is andersDe pin in de widgetinstellingen moet overeenkomen met de Vx in je code
De meter toont altijd 1 of de grafiek is leegDe Max van de datastream staat nog op 1 of de geschiedenis staat op Last ValuePas Min en Max aan op het bereik van de sensor en wijzig de geschiedenisinstelling
Na een tijdje komt er helemaal geen data meer binnenHet maandelijkse berichtenquotum is opVerleng het verzendinterval en stuur alleen bij verandering
Het relais werkt andersom of laat nooit losActive-LOW-module of het 3,3V-signaal is niet genoegDraai ROLE_AKTIF_LOW om en gebruik een module die geschikt is voor 3,3 V
Houd bij het oplossen van problemen een vaste volgorde aan: controleer eerst de wifiverbinding in de Serial Monitor, zoek dan de regel "Ready" en controleer pas daarna of widgets bij datastreams passen. Kom je niet verder bij de Wi-Fi-stap, zie dan ESP32 maakt geen verbinding met Wi-Fi; herstart het board als Wi-Fi aangaat, lees dan ESP32 brownout en Guru Meditation.

Blynk, je eigen webserver of MQTT?

MethodeVoordelenNadelenWanneer kies je het
Blynk IoTKant-en-klaar dashboard zonder een app te schrijven, toegang van buiten je huis, meldingenLimieten van het gratis abonnement, afhankelijk van de cloudSnelle prototypes en monitoring op afstand
ESP32-webserverHelemaal gratis, werkt zonder internetMeestal alleen bereikbaar vanaf hetzelfde netwerk, je schrijft de interface zelfBedieningspaneel binnenshuis
MQTT en Home AssistantOnbeperkt aantal berichten, draait lokaal, krachtige automatiseringLangere installatie, vereist een server die altijd aan staatEen permanent slim-huissysteem
Telegram-botGratis, ideaal voor waarschuwingen en commando'sGeen grafieken of dashboardAlarmen en eenvoudige commando's

Kortom: Blynk is de makkelijkste manier om snel resultaat te krijgen met een kant-en-klaar, mooi dashboard en om je project van buiten je huis te bereiken. Wil je een onbeperkt, volledig lokaal systeem, lees dan ESP32-webserver en WebSocket of ESP32 MQTT en Home Assistant; wil je alleen waarschuwingen naar je telefoon sturen, bekijk dan de gids ESP32 Telegram-bot.

Een makkelijkere manier: BlueGrays IoT

Blynk is een flexibel en krachtig platform. Maar als je alleen een relais wilt schakelen of een sensor vanaf je telefoon wilt bekijken, wil je misschien niet met de hand de template, datastreams, widgets en auth token instellen. BlueGrays IoT doet dit met kant-en-klare sjablonen: je kiest er een onder Werkplaats › Mijn apparaten › Nieuw apparaat toevoegen, Ohmi maakt de code klaar met jouw apparaatsleutel en je uploadt die één keer vanuit de Arduino IDE met de bibliotheek BlueGraysIoT. Het werkt met de ESP32 en Raspberry Pi Pico W via 2,4GHz-Wi-Fi en je eerste apparaat is gratis. Voor de details zie de gids over een ESP32 bedienen vanaf je telefoon.

Als je het trio template, datastream en auth token eenmaal begrijpt, kost het met Blynk maar een paar minuten om een nieuw ESP32-project met je telefoon te verbinden. Combineer de voorbeelden voor led, relais en sensor uit deze gids en je hebt het begin van je eigen slimme-huissysteem. In de BlueGrays-app vind je ook ESP32-projecten zoals een led laten knipperen, verbinden met Wi-Fi, temperatuur meten met een DHT22, slimme verlichting, planten water geven en een bewegingsalarm met Telegram, elk met een schakelschema en code in stappen.

Veelgestelde vragen

Is Blynk gratis?

Ja, Blynk heeft een gratis abonnement voor persoonlijk gebruik. Per oktober 2026 biedt het 5 apparaten, 100.000 apparaatberichten per maand en 1 week datageschiedenis. Voor meer apparaten, onbeperkte berichten en langere dataopslag moet je overstappen naar een betaald maandabonnement.

Waar vind ik de Blynk auth token?

Open in Blynk.Console je apparaat via het onderdeel Devices; in Device Info zie je de regels BLYNK_TEMPLATE_ID, BLYNK_TEMPLATE_NAME en BLYNK_AUTH_TOKEN, klaar om in je code te plakken. In de nieuwe Blynk wordt de token niet meer per e-mail verstuurd en heeft elk apparaat zijn eigen token.

Werkt de oude Blynk-app nog?

Nee. De oude Blynk-app (Legacy) is in 2022 uit de stores gehaald en de cloudservers zijn op 31 december 2022 uitgezet. Je moet oude projecten opnieuw opbouwen op het nieuwe platform Blynk IoT met templates en datastreams; het grootste deel van de ESP32-code kun je met kleine aanpassingen hergebruiken.

Wat is een virtuele pin in Blynk?

Een virtuele pin is een genummerd datakanaal tussen de app en je code en komt niet overeen met een fysiek pootje van het board. Ze zijn genummerd van V0 tot V255; waarden uit de app lees je met BLYNK_WRITE(Vx) en waarden van het board stuur je met Blynk.virtualWrite(Vx, value) naar de app. Zo kun je binnenkomende waarden naar wens verwerken en sensordata naar het dashboard brengen.

Waarom staat mijn ESP32 offline in Blynk?

De meest voorkomende oorzaken zijn een verkeerde of ontbrekende auth token, een ESP32 die probeert met een 5GHz-netwerk te verbinden, lange delay()-aanroepen in loop() en een zwakke voeding. Als de regel "Ready" niet in de Serial Monitor verschijnt, ligt het probleem bij de verbinding; als hij wel verschijnt, controleer dan of je in de app naar het juiste apparaat kijkt.

Werkt Blynk zonder internet?

Nee. In Blynk IoT lopen commando's en data via Blynk.Cloud, dus zowel de ESP32 als je telefoon hebben internettoegang nodig. Voor bediening zonder internet kun je de eigen webserver van de ESP32, ESP-NOW of Bluetooth gebruiken.

Alle projecten bekijken
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
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
Lichtsterkte meten met de ESP32 en een LDR-module
ES-11Beginner

Lichtsterkte meten met de ESP32 en een LDR-module

Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

4.6(36)
55
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
ES-25Gevorderd

ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)

In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

4.4(21)
38
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)

Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

4.8(38)
57
ESP32 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

ESP32 slimme verlichting (PIR + LDR + relais + OLED)

Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

4.3(6)
11
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)

Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.

9