ESP-WROOM-32 vs ESP32-DEVKITC (ESP32-WROOM-32E) – comparație tehnică pentru proiecte IoT, embedded și automatizări

Familia ESP32 rămâne una dintre cele mai versatile platforme pentru dezvoltarea de echipamente IoT,
aplicații embedded conectate și prototipuri rapide cu Wi-Fi și Bluetooth. În acest articol comparăm
două plăci populare bazate pe ESP32, disponibile în magazinul Automatic House Systems:

1. ESP-WROOM-32 ESP-32S WIFI Bluetooth Development Board 4MB (CP2102 + 38PIN + Micro)
2. Black ESP32-DEVKITC Development Baseboard Carries ESP32-WROOM-32E 4MB Flash Development Board

Deși la prima vedere cele două plăci par foarte asemănătoare, există diferențe relevante la nivel de modul,
implementare hardware, poziționare în ecosistemul ESP32 și recomandare pentru proiecte noi.
Vom analiza arhitectura comună, diferențele practice, avantajele fiecărei plăci și tipurile de proiecte
pentru care sunt potrivite.

Arhitectura comună – ce au în comun cele două plăci

Ambele plăci fac parte din ecosistemul ESP32 clasic și oferă capabilități foarte puternice pentru zona
embedded conectată:

• microcontroler dual-core Xtensa LX6 cu frecvență de până la 240 MHz;
• conectivitate Wi-Fi 2.4 GHz 802.11b/g/n;
• Bluetooth Classic + Bluetooth Low Energy (BLE);
• memorie Flash externă de 4 MB pe modul;
• periferice bogate: GPIO, UART, SPI, I2C, I2S, PWM, ADC, DAC, touch, pulse counter, RMT și TWAI;
• ecosistem software matur: Arduino IDE, PlatformIO și ESP-IDF.

Din punct de vedere funcțional, ambele plăci pot susține o gamă foarte largă de aplicații:
noduri smart home, senzori Wi-Fi, controlere de relee, loggere de date, web servere locale,
gateway-uri BLE/Wi-Fi, interfețe HMI simple și prototipuri de automatizare.

Placa 1 – ESP-WROOM-32 ESP-32S Development Board 4MB, CP2102, 38 pini

Prima placă este o implementare foarte răspândită în zona maker și prototyping, construită în jurul
modulului ESP-WROOM-32 (comercializat frecvent și ca ESP-32S).

Un avantaj clar al acestei variante este faptul că produsul specifică explicit interfața USB-UART CP2102, ceea ce este util atunci când vrei predictibilitate la nivel de drivere USB, compatibilitate bună pe Windows/Linux și un flux de programare simplu prin micro-USB.

De asemenea, placa folosește un format cu 38 pini, ceea ce este atractiv pentru proiectele în care ai nevoie de acces la cât mai multe GPIO-uri disponibile pe board. În practică, aceasta este o alegere
foarte bună pentru:

• prototipare rapidă pe breadboard sau cu fire Dupont;
• experimente cu senzori și module multiple conectate simultan;
• proiecte didactice și laborator;
• proiecte hobby sau PoC (proof of concept) cu cost redus;
• migrare rapidă între Arduino IDE și PlatformIO.

Puncte forte

• chip USB-serial explicit declarat: CP2102;
• layout foarte popular, cu mult suport în tutoriale;
• 38 pini expuși – util pentru prototipuri bogate în periferice;
• ușor de folosit pentru web server, MQTT, senzori, relee și telemetrie;
• foarte bună pentru învățare și dezvoltare rapidă.

Limitări și observații

• se bazează pe modulul ESP-WROOM-32, o variantă mai veche din familie;
• pentru produse noi, există variante mai recente recomandate de Espressif;
• ca la majoritatea plăcilor ESP32, logica este pe 3.3 V și GPIO-urile nu sunt 5 V tolerant;
• anumite GPIO-uri trebuie alese cu grijă pentru a evita problemele de boot.

 Placa 2 – Black ESP32-DEVKITC cu ESP32-WROOM-32E, 4MB Flash

A doua placă este poziționată ca un ESP32-DEVKITC bazat pe ESP32-WROOM-32E. Din punct de vedere tehnic, acesta este un argument important, pentru că WROOM-32E reprezintă o iterație mai nouă în aceeași familie ESP32. Placa include alimentare prin USB, regulator 3.3 V onboard, butoane BOOT și EN, plus GPIO-uri expuse pe headere, ceea ce o face potrivită atât pentru dezvoltare generală, cât și pentru prototipuri mai apropiate de stilul de referință DevKitC.

Acest tip de placă este foarte atractiv atunci când urmărești:

• o bază mai actuală pentru proiecte noi;
• compatibilitate conceptuală bună cu documentația și exemplele din ecosistemul ESP32 DevKitC;
• dezvoltare embedded mai riguroasă, inclusiv migrare ulterioară către ESP-IDF;
• prototipuri IoT mai robuste și mai apropiate de o arhitectură de produs.

Puncte forte

• modul ESP32-WROOM-32E – variantă mai nouă decât WROOM-32;
• format de tip DevKitC, foarte familiar în ecosistemul Espressif;
• butoane BOOT și EN utile la debug și recovery;
• alimentare și logică 3.3 V potrivite pentru integrare rapidă cu senzori și actuatori;
• alegere mai bună pentru proiecte noi și dezvoltare mai „curată” tehnic.

Limitări și observații

• tipul convertorului USB-serial poate varia în funcție de lot;
• disponibilitatea exactă a unor pini poate depinde de layout-ul boardului și de ce este rutat efectiv;
• la fel ca orice ESP32 clasic, necesită atenție la pinii de boot/strapping și la restricțiile ADC/Wi-Fi.

Diferențe tehnice relevante în practică

Ce capabilități oferă în mod real aceste plăci

În proiectare embedded, valoarea unei plăci ESP32 nu se reduce la „are Wi-Fi și Bluetooth”.
Cele două plăci pot funcționa ca:

• nucleu de comunicație IoT pentru MQTT, HTTP, HTTPS, REST, WebSocket;
• controler local pentru relee, PWM, LED-uri, ventilatoare, buzzere, touch sensors;
• unitate de achiziție date pentru senzori analogici și digitali;
• mini web server embedded pentru dashboard local și configurare din browser;
• gateway BLE/Wi-Fi pentru senzori BLE și publicare către rețea IP;
• logger de date cu timestamp, buffering și trimitere în cloud/local broker;
• interfață pentru protocoale industriale ușoare, cu hardware extern adecvat;
• platformă pentru low-power edge devices, cu moduri sleep și trezire periodică.

Ce proiecte se pot face cu aceste plăci

a) Smart home node cu senzori și MQTT

Una dintre cele mai naturale utilizări este realizarea unui nod smart home care citește senzori
de temperatură, umiditate, lumină, vibrații sau consum și publică datele către Home Assistant,
Node-RED sau un broker MQTT local.

b) Controller pentru relee și automatizări

Cu ajutorul unor tranzistoare/driver-e și al unei alimentări corecte, plăcile pot comanda relee,
electrovalve, benzi LED, ventilatoare sau alte sarcini de joasă tensiune. Pentru sarcini inductive
sau puteri mari, este necesar hardware de interfațare adecvat.

c) Web server local pentru configurare și monitorizare

ESP32 este foarte potrivit pentru dashboard-uri locale accesibile din browser:
pagini HTML simple, endpoint-uri JSON, configurare rețea, vizualizare de senzori și comenzi digitale.

d) Data logger Wi-Fi/BLE

Pentru monitorizare de mediu, automatizare de clădiri sau testare, aceste plăci pot colecta
periodic măsurători și le pot trimite prin Wi-Fi sau Bluetooth către o aplicație, un broker sau un server.

e) Gateway de laborator pentru senzori și actuatori

În prototipuri rapide, pot funcționa ca punte între senzori digitali/analogici și un backend software,
fără a fi nevoie de hardware complex sau de un SBC separat.

f) Aplicații educaționale și embedded training

Datorită ecosistemului foarte bogat, ambele plăci sunt excelente pentru învățarea programării embedded în C/C++, lucrul cu task-uri FreeRTOS, periferice, networking și arhitecturi IoT.

7. Recomandare tehnică – pe care să o alegi?

Alege placa ESP-WROOM-32 / ESP-32S cu CP2102 dacă:

• vrei o placă foarte accesibilă și ușor de folosit;
• te interesează prototipare rapidă, laborator, tutoriale și testare de idei;
• vrei explicit CP2102 pentru partea de USB-serial;
• lucrezi în special în Arduino IDE sau PlatformIO, fără pretenții de produs nou pe termen lung.

Alege placa Black ESP32-DEVKITC cu ESP32-WROOM-32E dacă:

• pornești un proiect nou și vrei o variantă mai actuală a modulului;
• vrei o bază mai apropiată de conceptul de DevKitC;
• intenționezi să duci proiectul spre o arhitectură mai matură;
• vrei o alegere mai solidă pentru dezvoltare embedded profesională.

Concluzie scurtă: ambele plăci sunt capabile și foarte utile, dar pentruun proiect nou aș favoriza în mod normal varianta cu ESP32-WROOM-32E. Varianta cu ESP-WROOM-32 / ESP-32S rămâne însă excelentă pentru învățare, prototipuri și aplicații rapide cu cost minim.

Observații practice de proiectare

• GPIO-urile ESP32 funcționează la 3.3 V; nu presupune compatibilitate directă cu 5 V.
• Pentru măsurări analogice în proiecte cu Wi-Fi activ, este preferabil să folosești canale din ADC1.
• GPIO34–GPIO39 sunt intrări-only și nu pot fi utilizate ca ieșiri digitale.
• Unele GPIO-uri sunt implicate în boot/strapping și trebuie alese atent în hardware final.
• Pentru relee, motoare sau sarcini inductive este necesar etaj de comandă separat.
• O sursă USB stabilă este importantă, mai ales când Wi-Fi transmite și există periferice externe alimentate de pe placă.

Exemplu practic 1 – Arduino IDE

Primul exemplu este gândit pentru ambele plăci și ilustrează un caz foarte util în practică:
conectarea la o rețea Wi-Fi, pornirea unui server web local, citirea unei valori analogice de pe GPIO34 și comanda unei ieșiri digitale pe GPIO23. Acest tip de firmware poate fi folosit ca bază pentru un sistem de monitorizare, un nod IoT sau un controller simplu pentru automatizări.

Pentru conectarea și programarea plăcilor ESP32 în Arduino IDE, este necesar ca mai întâi să fie instalat pachetul de suport pentru platforma ESP32 din Boards Manager, folosind URL-ul oficial Espressif în secțiunea Additional Boards Manager URLs. După conectarea plăcii prin cablu USB la calculator, se selectează din meniul Tools placa de tip ESP32 Dev Module, portul serial corespunzător și parametrii de bază, cum ar fi Flash Size = 4MB, schema de partiționare implicită și viteza de upload potrivită. În cazul în care placa nu intră automat în modul de programare, poate fi necesară apăsarea butonului BOOT în timpul încărcării programului. După configurare, sketch-ul poate fi compilat și încărcat direct din Arduino IDE, iar funcționarea aplicației poate fi verificată prin Serial Monitor, web server local sau interacțiune directă cu perifericele conectate la pinii GPIO ai plăcii.

Conexiuni hardware recomandate:

• un senzor analogic sau potențiometru conectat la GPIO34;
• un LED cu rezistor sau intrarea unui etaj driver conectată la GPIO23;
• alimentare prin USB.

/*
  Arduino IDE example for both boards:
  - Wi-Fi connection
  - local web server
  - ADC read on GPIO34 (ADC1, safe with Wi-Fi)
  - digital output on GPIO23

  Hardware:
  - connect a potentiometer or analog sensor output to GPIO34
  - connect an LED (through resistor) or a transistor-driven relay input to GPIO23
*/

#include <WiFi.h>
#include <WebServer.h>

const char* WIFI_SSID = "YOUR_WIFI_SSID";
const char* WIFI_PASS = "YOUR_WIFI_PASSWORD";

static const int ADC_PIN = 34;      // ADC1 channel, input only
static const int OUTPUT_PIN = 23;   // safe general-purpose output

WebServer server(80);

int outputState = LOW;

String buildHtmlPage()
{
  int adcRaw = analogRead(ADC_PIN);

  String html;
  html += "<!DOCTYPE html><html><head><meta charset='utf-8'>";
  html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
  html += "<title>ESP32 Diagnostic Node</title>";
  html += "<style>";
  html += "body{font-family:Arial,sans-serif;margin:24px;background:#f5f7fa;color:#222;}";
  html += ".card{max-width:720px;background:#fff;padding:20px;border-radius:12px;box-shadow:0 2px 10px rgba(0,0,0,0.08);}";
  html += "a.button{display:inline-block;margin:6px 8px 6px 0;padding:10px 14px;background:#0d6efd;color:#fff;text-decoration:none;border-radius:8px;}";
  html += "code{background:#eef2f7;padding:2px 6px;border-radius:4px;}";
  html += "</style></head><body><div class='card'>";
  html += "<h1>ESP32 Diagnostic Node</h1>";
  html += "<p><strong>IP:</strong> " + WiFi.localIP().toString() + "</p>";
  html += "<p><strong>ADC raw (GPIO34):</strong> " + String(adcRaw) + "</p>";
  html += "<p><strong>Output GPIO23:</strong> " + String(outputState ? "ON" : "OFF") + "</p>";
  html += "<p>";
  html += "<a class='button' href='/output/on'>Turn ON</a>";
  html += "<a class='button' href='/output/off'>Turn OFF</a>";
  html += "</p>";
  html += "<p>JSON endpoint: <code>/api/status</code></p>";
  html += "</div></body></html>";

  return html;
}

void handleRoot()
{
  server.send(200, "text/html; charset=utf-8", buildHtmlPage());
}

void handleOutputOn()
{
  outputState = HIGH;
  digitalWrite(OUTPUT_PIN, outputState);
  server.sendHeader("Location", "/");
  server.send(302, "text/plain", "ON");
}

void handleOutputOff()
{
  outputState = LOW;
  digitalWrite(OUTPUT_PIN, outputState);
  server.sendHeader("Location", "/");
  server.send(302, "text/plain", "OFF");
}

void handleApiStatus()
{
  int adcRaw = analogRead(ADC_PIN);

  String json = "{";
  json += "\"ip\":\"" + WiFi.localIP().toString() + "\",";
  json += "\"adc_raw\":" + String(adcRaw) + ",";
  json += "\"output\":" + String(outputState ? 1 : 0) + ",";
  json += "\"uptime_ms\":" + String(millis());
  json += "}";

  server.send(200, "application/json", json);
}

void connectWiFi()
{
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);

  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.print("Connected. IP address: ");
  Serial.println(WiFi.localIP());
}

void setup()
{
  Serial.begin(115200);
  delay(300);

  pinMode(OUTPUT_PIN, OUTPUT);
  digitalWrite(OUTPUT_PIN, LOW);

  pinMode(ADC_PIN, INPUT);

  connectWiFi();

  server.on("/", handleRoot);
  server.on("/output/on", handleOutputOn);
  server.on("/output/off", handleOutputOff);
  server.on("/api/status", handleApiStatus);

  server.begin();
  Serial.println("HTTP server started.");
}

void loop()
{
  server.handleClient();

  static unsigned long lastPrint = 0;
  if (millis() - lastPrint >= 2000)
  {
    lastPrint = millis();
    Serial.print("ADC(GPIO34) = ");
    Serial.println(analogRead(ADC_PIN));
  }
}
  

Acest exemplu este util mai ales în faza de validare hardware, pentru că permite verificarea rapidă a conectivității Wi-Fi, a funcționării ADC-ului și a unei ieșiri digitale, fără a introduce complexitate inutilă.

Exemplu practic 2 – PlatformIO

Al doilea exemplu este orientat către un stil de dezvoltare mai apropiat de embedded profesional.
Folosește PlatformIO, framework Arduino și două task-uri FreeRTOS: unul pentru achiziția periodică a semnalului analogic și unul pentru heartbeat. În plus, serverul HTTP oferă un API JSON și posibilitatea
de comandă a unei ieșiri din browser sau dintr-o aplicație externă.

Fișierul platformio.ini:

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
upload_speed = 921600
  

Fișierul src/main.cpp:

/*
  PlatformIO example (Arduino framework) for both boards:
  - Wi-Fi STA
  - HTTP JSON API
  - FreeRTOS task for analog acquisition
  - heartbeat LED / output
  - controllable output on GPIO23

  Hardware:
  - analog source to GPIO34
  - output LED or transistor input on GPIO23
  - optional heartbeat LED on GPIO18
*/

#include <Arduino.h>
#include <WiFi.h>
#include <WebServer.h>

static const char* WIFI_SSID = "YOUR_WIFI_SSID";
static const char* WIFI_PASS = "YOUR_WIFI_PASSWORD";

static const int ADC_PIN = 34;         // ADC1, input only
static const int OUTPUT_PIN = 23;      // controlled output
static const int HEARTBEAT_PIN = 18;   // periodic status pin

WebServer server(80);

volatile int g_adcRaw = 0;
volatile int g_outputState = 0;
portMUX_TYPE g_mux = portMUX_INITIALIZER_UNLOCKED;

void connectWiFi()
{
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);

  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.print("Connected. IP: ");
  Serial.println(WiFi.localIP());
}

void taskAnalog(void* parameter)
{
  (void)parameter;

  const int samples = 16;

  while (true)
  {
    uint32_t sum = 0;
    for (int i = 0; i < samples; ++i)
    {
      sum += analogRead(ADC_PIN);
      vTaskDelay(pdMS_TO_TICKS(10));
    }

    int avg = static_cast<int>(sum / samples);

    portENTER_CRITICAL(&g_mux);
    g_adcRaw = avg;
    portEXIT_CRITICAL(&g_mux);

    vTaskDelay(pdMS_TO_TICKS(200));
  }
}

void taskHeartbeat(void* parameter)
{
  (void)parameter;

  bool state = false;
  while (true)
  {
    state = !state;
    digitalWrite(HEARTBEAT_PIN, state ? HIGH : LOW);
    vTaskDelay(pdMS_TO_TICKS(500));
  }
}

void handleRoot()
{
  String html;
  int adcRawLocal;
  int outputStateLocal;

  portENTER_CRITICAL(&g_mux);
  adcRawLocal = g_adcRaw;
  outputStateLocal = g_outputState;
  portEXIT_CRITICAL(&g_mux);

  html += "<!DOCTYPE html><html><head><meta charset='utf-8'>";
  html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
  html += "<title>ESP32 PlatformIO Node</title>";
  html += "<style>";
  html += "body{font-family:Arial;margin:24px;background:#f4f6f8;color:#1f2937;}";
  html += ".box{max-width:760px;background:#fff;padding:22px;border-radius:12px;box-shadow:0 2px 10px rgba(0,0,0,0.08);}";
  html += "a.btn{display:inline-block;padding:10px 14px;margin-right:8px;text-decoration:none;border-radius:8px;background:#2563eb;color:#fff;}";
  html += "</style></head><body><div class='box'>";
  html += "<h1>ESP32 PlatformIO Node</h1>";
  html += "<p><strong>IP:</strong> " + WiFi.localIP().toString() + "</p>";
  html += "<p><strong>ADC average (GPIO34):</strong> " + String(adcRawLocal) + "</p>";
  html += "<p><strong>Output GPIO23:</strong> " + String(outputStateLocal ? "ON" : "OFF") + "</p>";
  html += "<p><a class='btn' href='/api/output?state=1'>Output ON</a>";
  html += "<a class='btn' href='/api/output?state=0'>Output OFF</a></p>";
  html += "<p>API endpoint: <code>/api/status</code></p>";
  html += "</div></body></html>";

  server.send(200, "text/html; charset=utf-8", html);
}

void handleApiStatus()
{
  int adcRawLocal;
  int outputStateLocal;

  portENTER_CRITICAL(&g_mux);
  adcRawLocal = g_adcRaw;
  outputStateLocal = g_outputState;
  portEXIT_CRITICAL(&g_mux);

  String json = "{";
  json += "\"device\":\"esp32-platformio-node\",";
  json += "\"ip\":\"" + WiFi.localIP().toString() + "\",";
  json += "\"adc_avg\":" + String(adcRawLocal) + ",";
  json += "\"output\":" + String(outputStateLocal) + ",";
  json += "\"wifi_rssi\":" + String(WiFi.RSSI()) + ",";
  json += "\"uptime_ms\":" + String(millis());
  json += "}";

  server.send(200, "application/json", json);
}

void handleApiOutput()
{
  if (!server.hasArg("state"))
  {
    server.send(400, "application/json", "{\"error\":\"missing state arg\"}");
    return;
  }

  int newState = (server.arg("state") == "1") ? 1 : 0;
  digitalWrite(OUTPUT_PIN, newState ? HIGH : LOW);

  portENTER_CRITICAL(&g_mux);
  g_outputState = newState;
  portEXIT_CRITICAL(&g_mux);

  server.send(200, "application/json", "{\"ok\":true}");
}

void setupServer()
{
  server.on("/", handleRoot);
  server.on("/api/status", handleApiStatus);
  server.on("/api/output", handleApiOutput);
  server.begin();
  Serial.println("HTTP server started.");
}

void setup()
{
  Serial.begin(115200);
  delay(300);

  pinMode(ADC_PIN, INPUT);
  pinMode(OUTPUT_PIN, OUTPUT);
  pinMode(HEARTBEAT_PIN, OUTPUT);

  digitalWrite(OUTPUT_PIN, LOW);
  digitalWrite(HEARTBEAT_PIN, LOW);

  connectWiFi();
  setupServer();

  xTaskCreatePinnedToCore(taskAnalog, "taskAnalog", 4096, nullptr, 1, nullptr, 1);
  xTaskCreatePinnedToCore(taskHeartbeat, "taskHeartbeat", 2048, nullptr, 1, nullptr, 0);
}

void loop()
{
  server.handleClient();

  static unsigned long lastLog = 0;
  if (millis() - lastLog >= 3000)
  {
    lastLog = millis();

    int adcRawLocal;
    int outputStateLocal;

    portENTER_CRITICAL(&g_mux);
    adcRawLocal = g_adcRaw;
    outputStateLocal = g_outputState;
    portEXIT_CRITICAL(&g_mux);

    Serial.printf("ADC=%d, OUT=%d, RSSI=%d dBm\n",
                  adcRawLocal,
                  outputStateLocal,
                  WiFi.RSSI());
  }
}
  

Avantajul acestui exemplu este că introduce o structură software mai apropiată de proiectele reale:
separarea responsabilităților în task-uri, expunerea unui API și o bază solidă pentru extindere către MQTT,
logging, control de relee, dashboard local sau integrare cu Home Assistant.

Cum pot fi extinse aceste exemple

Atât proiectul din Arduino IDE, cât și cel din PlatformIO pot fi dezvoltate mai departe în multe direcții:

• înlocuirea potențiometrului cu un senzor real: temperatură, lumină, presiune, vibrații sau curent;
• adăugarea unui releu comandat prin tranzistor pentru controlul unei sarcini externe;
• publicarea valorilor către un broker MQTT;
• integrarea cu Home Assistant prin MQTT Discovery sau HTTP API;
• stocarea parametrilor de configurare în NVS/Preferences;
• adăugarea unui portal web pentru configurarea SSID-ului și parolei Wi-Fi;
• implementarea unui watchdog software și a unei strategii de reconnect pentru robustețe.

Concluzie

Atât placa ESP-WROOM-32 ESP-32S, cât și placa
ESP32-DEVKITC cu ESP32-WROOM-32E reprezintă opțiuni excelente pentru dezvoltare IoT, aplicații embedded și prototipare rapidă. Diferența principală este legată de generația modulului și de contextul proiectului: prima placă este foarte bună pentru laborator, learning și proiecte hobby, iar a doua este mai potrivită pentru proiecte noi și pentru o bază tehnică mai actuală.

Exemplele integrate în acest articol arată că ambele plăci pot fi folosite imediat pentru dezvoltarea
unor aplicații reale: web server local, achiziție de date analogice, control de ieșiri și structură software
extensibilă. Din acest motiv, ele rămân unele dintre cele mai bune opțiuni pentru oricine lucrează în zona
de smart home, senzori, automatizări și embedded systems.

KY-026 Flame Sensor – articol tehnic despre funcționare, conectare și utilizare cu ESP32

Modulul KY-026 Flame Sensor este un senzor simplu și foarte popular în proiectele de electronică,
robotică și automatizare, folosit pentru detecția radiației infraroșii emise de o flacără. Deși este frecvent
întâlnit în kiturile educaționale pentru Arduino, acest senzor poate fi utilizat foarte bine și împreună cu
plăci ESP32, atât în aplicații de laborator, cât și în prototipuri embedded pentru monitorizare
sau reacție la evenimente de tip flacără/foc.

În cadrul unor teste practice, senzorul KY-026 poate fi folosit pentru a observa comportamentul unui detector optic de flacără în condiții reale: cum reacționează la o brichetă, la o lumânare, la o sursă de lumină ambientală puternică și cât de mult influențează distanța, unghiul și reglajul sensibilității rezultatul final. Tocmai de aceea, acest modul este foarte bun pentru înțelegerea conceptului de detecție IR și pentru prototipuri rapide cu ESP32.

Ce este senzorul KY-026

KY-026 este un modul de detecție a flăcării bazat pe un element optic sensibil la radiația infraroșie emisă de foc.Modulul este realizat de obicei în jurul unui receptor IR și al unui comparator LM393, având două tipuri de ieșiri:

• AO (Analog Output) – oferă un semnal analogic proporțional cu intensitatea luminii IR detectate;
• DO (Digital Output) – oferă un nivel logic comutat de comparator atunci când semnalul depășește un prag setat din potențiometrul onboard.

Acest tip de modul este atractiv pentru începători deoarece oferă atât o metodă simplă de detecție binară
(flacără detectată / flacără nedetectată), cât și o metodă mai flexibilă de analiză analogică a semnalului.

Principiul de funcționare

Flacăra generează radiație electromagnetică într-o gamă largă de frecvențe, inclusiv în domeniul infraroșu. Senzorul KY-026 este optimizat pentru a reacționa la radiație IR în intervalul specific tipic pentru acest modul, ceea ce îi permite să răspundă la prezența unei surse de foc aflate în câmpul său vizual.

Semnalul optic captat de elementul sensibil este convertit într-un semnal electric. Acest semnal este apoi disponibil direct pe ieșirea analogică și, în paralel, este comparat cu un prag reglabil intern. Dacă intensitatea semnalului depășește acel prag, comparatorul comută ieșirea digitală. În acest mod, utilizatorul poate lucra fie cu o citire brută, fie cu un semnal digital simplificat, mai ușor de folosit în aplicații de alarmare.

Specificații tehnice uzuale

• Tensiune de alimentare: 3.3 V – 5 V / 5.5 V, în funcție de variantă;
• Domeniu spectral IR detectat: aproximativ 760 nm – 1100 nm;
• Unghi tipic de detecție: aproximativ 60°;
• Ieșiri disponibile: 1 x analogică (AO), 1 x digitală (DO);
• Comparator onboard: LM393, în multe variante comerciale ale modulului;
• Sensibilitate: reglabilă prin potențiometrul multiturn montat pe placă;
• Indicatori LED: de obicei LED de alimentare și LED de stare/comutare.

Pinii modulului KY-026

Modulul are de regulă patru pini principali:

• VCC – alimentarea modulului;
• GND – masă;
• AO – ieșirea analogică;
• DO – ieșirea digitală.

În majoritatea aplicațiilor, dacă vrei doar o alarmă simplă, poți folosi ieșirea digitală. Dacă însă vrei să analizezi semnalul, să faci filtrare software, să construiești praguri proprii sau să observi răspunsul senzorului în timp, este mai interesantă ieșirea analogică.

Conectarea senzorului KY-026 la ESP32

Deoarece plăcile ESP32 lucrează la nivel logic de 3.3 V, este recomandat ca și modulul KY-026 să fie alimentat la 3.3 V atunci când este folosit împreună cu ESP32. În acest fel, nivelurile de tensiune pe ieșirea digitală rămân compatibile cu intrările microcontrolerului și se evită riscul de a aplica un nivel prea mare pe un GPIO.

O conexiune tipică poate fi realizată astfel:

• VCC de la KY-026 la 3V3 pe ESP32;
• GND de la KY-026 la GND pe ESP32;
• DO de la KY-026 la un pin digital, de exemplu GPIO23;
• AO de la KY-026 la un pin analogic din ADC1, de exemplu GPIO34.

Pentru ESP32 este de preferat ca ieșirea analogică să fie citită pe un pin din familia ADC1 (GPIO32–GPIO39), mai ales dacă proiectul folosește și Wi-Fi. Acest lucru este important deoarece pinii din
ADC2 au limitări atunci când driverul Wi-Fi este activ.

De ce este utilă folosirea ambelor ieșiri: AO și DO

Mulți utilizatori folosesc doar ieșirea digitală și atât. Totuși, în practică, folosirea ambelor ieșiri este foarte utilă:

• DO este ideală pentru reacții rapide: aprinderea unui LED, activarea unui buzzer, declanșarea unei alarme;
• AO este utilă pentru analiză, logare, calibrare, testare și detectarea variațiilor de intensitate IR.

Dacă lucrezi cu ESP32, poți citi simultan AO și DO, apoi poți construi în software o logică mai robustă:
de exemplu, să confirmi detecția doar dacă ieșirea digitală este activă și valoarea analogică depășește un anumit prag
pentru mai multe eșantioane consecutive.

Calibrarea sensibilității

KY-026 are de regulă un potențiometru onboard cu care se reglează pragul comparatorului. Acest prag influențează direct comportamentul ieșirii digitale. Dacă pragul este prea sensibil, modulul poate reacționa la surse de lumină ambientală sau reflexii puternice. Dacă pragul este prea ridicat, o flacără mică sau aflată la distanță poate să nu fie detectată.

O metodă practică de calibrare este următoarea:

1. alimentezi modulul și citești simultan AO și DO;
2. expui senzorul la o sursă de flacără controlată, de exemplu o brichetă sau o lumânare;
3. rotești lent potențiometrul până când DO comută stabil în prezența flăcării și rămâne inactiv în lipsa ei;
4. verifici comportamentul din mai multe unghiuri și la distanțe diferite;
5. repeti testul și în lumină ambientală puternică pentru a observa eventuale comutări false.

Ce se observă frecvent în teste practice

În testele de laborator, KY-026 reacționează în general rapid atunci când flacăra este orientată direct spre senzor și se află la distanță mică sau medie. Totuși, răspunsul nu este perfect stabil în orice condiții, deoarece acest tip de modul:

• depinde mult de unghiul sub care „vede” flacăra;
• este influențat de distanță;
• poate fi afectat de surse intense de lumină sau reflexii;
• nu oferă măsurare absolută a temperaturii sau a dimensiunii focului;
• este destinat mai degrabă pentru detecție de proximitate și experimente decât pentru protecție certificată.

În practică, modulul este excelent pentru demonstrații și prototipuri, dar trebuie tratat ca un senzor optic simplu, nu ca un detector profesional de incendiu.

Avantaje ale senzorului KY-026

• cost redus și disponibilitate foarte bună;
• conectare simplă la ESP32, Arduino și alte plăci de dezvoltare;
• ieșire analogică și digitală pe același modul;
• reglaj ușor al sensibilității prin potențiometru;
• bun pentru laborator, educație, robotică și automatizări experimentale.

Limitări și atenționări

Chiar dacă senzorul este util și interesant, are și limitări importante:

• nu este un sistem certificat pentru detecția incendiilor;
• poate genera alarme false în condiții nefavorabile de iluminare;
• poate rata o flacără aflată în afara unghiului său de sensibilitate;
• valoarea analogică trebuie interpretată cu grijă, mai ales în medii cu zgomot optic;
• la utilizarea cu ESP32 trebuie respectat nivelul de 3.3 V pe GPIO-uri.

Din acest motiv, KY-026 nu ar trebui folosit singur într-o aplicație critică de siguranță, ci cel mult într-un prototip, într-un sistem experimental sau într-o soluție unde mai există și alte mecanisme de confirmare.

Aplicații practice posibile

• detecția simplă a flăcării într-un proiect educațional;
• robot care urmărește sau evită o sursă de foc controlată;
• sistem de avertizare locală cu buzzer și LED;
• nod IoT cu ESP32 care raportează detecția prin Wi-Fi sau MQTT;
• experimente de laborator pentru înțelegerea detecției în infraroșu;
• prototipuri pentru automatizări și scenarii demonstrative.

Recomandări de integrare cu ESP32

Dacă senzorul este integrat într-un proiect mai mare bazat pe ESP32, este recomandat:

• să alimentezi modulul la 3.3 V pentru compatibilitate logică;
• să folosești AO pe un pin ADC1, de exemplu GPIO34;
• să aplici filtrare software sau mediere pentru semnalul analogic;
• să validezi semnalul digital pe mai multe eșantioane consecutive;
• să eviți amplasarea senzorului în fața surselor puternice de lumină sau reflexie.

Concluzie

KY-026 Flame Sensor este un modul simplu, ieftin și foarte util pentru proiecte de învățare,
testare și prototipare rapidă. Funcționează bine împreună cu ESP32 și oferă atât o ieșire digitală convenabilă, cât și o ieșire analogică ce poate fi exploatată pentru analize mai avansate. În testele practice, senzorul permite înțelegerea clară a modului în care o flacără poate fi detectată optic, precum și a limitărilor reale ale unui senzor IR.

Pentru aplicații educaționale, pentru experimente de laborator sau pentru sisteme embedded demonstrative, KY-026 este o alegere foarte bună. Pentru aplicații critice de securitate sau incendiu, este însă necesar un sistem mult mai robust, validat și proiectat special pentru astfel de cerințe.

Produsele analizate

• ESP-WROOM-32 ESP-32S WIFI Bluetooth Development Board 4MB (CP2102 + 38PIN + Micro)
  
• Black ESP32-DEVKITC Development Baseboard Carries ESP32-WROOM-32E 4MB Flash Development Board
  
• KY-026 – Modul senzor de flacără