ESP32 od podstaw: pierwszy projekt czujnika Wi-Fi

Dlaczego ESP32 jest dobrym startem w świecie IoT

Internet Rzeczy na przykładzie prostego domowego czujnika

Internet Rzeczy (IoT) brzmi jak coś ogromnego i skomplikowanego, ale w praktyce często zaczyna się od bardzo prostego pomysłu: małe urządzenie, które mierzy coś w świecie fizycznym i wysyła wynik przez sieć. Przykład: czujnik temperatury w pokoju, który co minutę raportuje pomiar do serwera lub telefonu. W środku takiego urządzenia siedzi właśnie mikrokontroler z modułem Wi‑Fi – idealnym kandydatem jest ESP32.

ESP32 potrafi odczytać dane z czujnika (np. temperatury, wilgotności, światła), przetworzyć je w prostym programie i przesłać dalej przez Wi‑Fi do domowego routera, serwera MQTT, czy nawet bezpośrednio do aplikacji w chmurze. Dzięki temu można mieć w czasie rzeczywistym podgląd warunków w domu, w szklarni czy w garażu, bez ciągłego podłączania komputera lub ręcznego spisywania odczytów.

Kluczowe jest to, że taki projekt da się zrealizować w pełni w warunkach domowych: bez skomplikowanego sprzętu laboratoryjnego, bez lutowania (na początku wystarczy płytka stykowa i przewody) i bez konieczności pisania wielkich programów. Pierwszy czujnik Wi‑Fi można uruchomić w jeden wieczór, a później stopniowo go rozbudowywać.

ESP32 kontra Arduino UNO i ESP8266 – gdzie jest przewaga

Arduino UNO było (i nadal jest) świetnym wejściem w świat mikrokontrolerów, ale jego możliwości sieciowe są mocno ograniczone – bez dodatkowych modułów nie ma Wi‑Fi. Z kolei ESP8266 to poprzednik ESP32: tani i popularny układ Wi‑Fi, jednak już trochę przestarzały i mniej wygodny do bardziej rozbudowanych projektów.

ESP32 wyróżnia się w kilku kluczowych aspektach:

• Wbudowane Wi‑Fi – nie trzeba dokładać dodatkowego modułu; obsługa jest zintegrowana w bibliotece.
• Bluetooth i BLE – przydaje się w przyszłości do komunikacji z telefonem lub innymi urządzeniami.
• Dużo pamięci i mocniejszy procesor – wygodniej działa się z bibliotekami, serwerem WWW, MQTT i aktualizacjami OTA.
• Wiele GPIO i funkcji peryferyjnych – więcej pinów cyfrowych, ADC, PWM, I2C, SPI, a do tego sprzętowy licznik, interfejs dotykowy czy nawet DAC.

W praktyce oznacza to, że płytka ESP32 dla początkujących pozwala uruchomić prosty czujnik Wi‑Fi, a później bez zmiany platformy dołożyć kolejne funkcje: panel WWW, logowanie danych, sterowanie przekaźnikami czy integrację z Home Assistant. Nie trzeba przesiadać się na inne urządzenia, bo ESP32 ma spory zapas mocy.

Typowe zastosowania ESP32 w domowych projektach

W amatorskich i półprofesjonalnych zastosowaniach ESP32 jest dziś jednym z najpopularniejszych układów. Sprawdza się szczególnie w projektach, które wymagają jednocześnie pomiaru i komunikacji sieciowej:

• czujniki temperatury i wilgotności w mieszkaniu, piwnicy czy szklarni,
• liczniki energii, gazu lub wody z odczytem impulsów i wysyłką danych do MQTT,
• proste sterowniki domowe – załączanie oświetlenia czy wentylatorów na podstawie czujników,
• loggery danych zapisujące pomiary na serwer, do Google Sheets lub lokalnej bazy danych,
• mini stacje pogodowe z wyświetlaczem LCD/OLED i panelem WWW.

Wspólnym mianownikiem jest to, że ESP32 ma cały „mózg” i „modem” w jednym układzie. Nie trzeba osobnego komputera – program, który się na nim uruchamia, działa samodzielnie, a płytka może być zasilana np. z ładowarki USB albo z powerbanku.

Co konkretnie da się zrobić jako pierwszy projekt czujnika Wi‑Fi

Na start najprościej zbudować niewielki czujnik Wi‑Fi, który co zadany czas mierzy temperaturę i wilgotność, a następnie wysyła taki pakiet danych do wybranego miejsca: np. do serwera MQTT, prostego API HTTP lub lokalnej aplikacji. Typowy zestaw to:

• ESP32 DevKit jako główna płytka,
• czujnik DHT22 (prostszy) lub BME280 (dokładniejszy i bogatszy w dane),
• kilka przewodów i ewentualnie płytka stykowa,
• zasilanie z USB.

Z punktu widzenia użytkownika efekt końcowy wygląda tak: małe urządzenie, które po podłączeniu do zasilania łączy się z domową siecią Wi‑Fi, pobiera odczyt z czujnika i przesyła go w świat. Można te dane podejrzeć w logach MQTT, na prostej stronie WWW serwowanej przez ESP32, albo w aplikacji, którą odbierają dane z brokera MQTT. Taki prosty czujnik Wi‑Fi stanowi świetne ćwiczenie z podstaw elektroniki, programowania i sieci jednocześnie.

Wybór płytki i elementów – co rzeczywiście trzeba kupić

Różne wersje ESP32: DevKit, WROOM, WROVER

ESP32 to sama kość, ale w praktyce początkujący korzystają z gotowych płytek i modułów. Różnice nazw mogą na początku mylić, dlatego dobrze je uporządkować.

ESP32-WROOM to moduł produkowany przez Espressif: małą płytkę z samym układem ESP32, pamięcią flash i anteną. Ten moduł jest dalej montowany na większych płytkach, np. DevKit. Bez dodatkowej płytki nie da się go wygodnie podłączyć do USB czy płytki stykowej.

ESP32-WROVER to podobny moduł, ale rozszerzony o dodatkową pamięć PSRAM. Przydaje się w projektach z większym zapotrzebowaniem na RAM, np. gdy planujesz wyświetlacze graficzne, rozpoznawanie obrazu czy bardziej rozbudowane webserwery. Do prostego czujnika temperatury i wilgotności nie jest konieczny, ale jeśli cena jest podobna, nie zaszkodzi.

ESP32 DevKit (często oznaczany jako DevKitC lub z dopiskiem producenta) to pełna płytka rozwojowa z wlutowanym modułem ESP32-WROOM lub WROVER, z gniazdem USB, stabilizatorem napięcia i wyprowadzonymi pinami na goldpiny. To właśnie tę płytkę warto wybrać na pierwszy projekt, bo:

• można ją podłączyć zwykłym kablem USB do komputera,
• ma wbudowany konwerter USB-UART, więc nie trzeba dodatkowego sprzętu do programowania,
• rozmieszczenie pinów jest wygodne do wpięcia w płytkę stykową.

Minimalny zestaw startowy do czujnika Wi‑Fi

Aby zrealizować pierwszy projekt czujnika Wi‑Fi, potrzebny jest naprawdę skromny zestaw elementów. W praktyce wystarczy:

• Płytka ESP32 DevKit – najlepiej popularna wersja z modułem WROOM.
• Kabel USB – zazwyczaj micro USB lub USB‑C, zależnie od modelu płytki.
• Czujnik temperatury/wilgotności – np. DHT22 lub BME280 w wersji z gotową płytką.
• Przewody połączeniowe (tzw. jumpery) – męsko-żeńskie do łączenia ESP32 z czujnikiem.
• Płytka stykowa – niekonieczna, ale bardzo ułatwia prototypowanie bez lutowania.

Taki zestaw pozwala od razu przejść od programu „blink” do realnego czujnika. ESP32 może być w całości zasilany z USB komputera, więc nie trzeba od razu inwestować w osobne zasilacze. Na późniejszym etapie, gdy projekt zacznie pracować niezależnie od komputera, przyda się ładowarka 5 V lub mały zasilacz sieciowy.

Popularne czujniki na pierwszy projekt: DHT22, BME280 i kilka alternatyw

Do projektu „prosty czujnik temperatury Wi‑Fi” przydają się moduły, które da się wpiąć bezpośrednio w płytkę stykową i które mają gotowe biblioteki dla Arduino / ESP32. Najczęściej wybierane są:

• DHT22 – mierzy temperaturę i wilgotność, komunikuje się własnym prostym protokołem (1‑wire w rozumieniu biblioteki, nie należy mylić z klasycznym 1‑Wire od Dallas). Jest dość tani i łatwo dostępny, ale ma ograniczoną częstotliwość odczytu i bywa kapryśny przy długich przewodach.
• BME280 – bardziej zaawansowany czujnik, mierzy temperaturę, wilgotność i ciśnienie. Komunikuje się przez I2C lub SPI, jest dokładniejszy i zwykle stabilniejszy od DHT22. Dla pierwszego projektu jest nieco droższy, ale bardzo wygodny.
• BH1750 / czujniki światła – dobre jako drugi etap projektu, gdy chcesz rozbudować czujnik o natężenie oświetlenia np. do sterowania roletami.

Kryteria wyboru na początek są proste: dostępność biblioteki, łatwy interfejs (I2C lub popularny protokół), brak potrzeby kalibracji i napięcie pracy zgodne z 3,3 V logicznym ESP32. BME280 świetnie spełnia te warunki, dlatego często staje się pierwszym „poważnym” czujnikiem w świecie Internetu Rzeczy.

Dodatkowe akcesoria, które oszczędzają nerwy

Niewielka inwestycja w kilka drobiazgów potrafi znacząco poprawić komfort pracy z ESP32 i IoT.

• Dodatkowy konwerter USB‑UART – przydaje się, gdy płytka nie ma wbudowanego konwertera lub gdy chcesz debugować gołe moduły. Do gotowego DevKita nie jest konieczny, ale bywa użyteczny przy kolejnych projektach.
• Zasilacz 5 V (np. ładowarka USB) – gdy projekt ma działać bez udziału komputera, stabilne 5 V to podstawa. ESP32 ma na płytce własny stabilizator do 3,3 V.
• Diody LED i rezystory – do własnych sygnalizacji stanu, np. „połączono z Wi‑Fi”, „błąd czujnika”. Dają szybki podgląd bez konieczności włączania monitora portu szeregowego.
• Prosta obudowa – może to być gotowa puszka ABS, pudełko po elektronice lub własny wydruk 3D. Chroni układ przed kurzem i przypadkowym dotknięciem przewodów.

W miarę jak projekt się rozwija, przychodzi też moment na elementy mechaniczne: dystanse, śrubki, uchwyty do montażu na ścianie. Czujnik IoT to nie tylko elektronika, ale również praktyczny sposób wkomponowania go w otoczenie.

Przygotowanie środowiska – od instalacji do pierwszego „blink”

Arduino IDE czy PlatformIO – którą ścieżkę wybrać na początek

Do programowania ESP32 można użyć różnych środowisk. Najpopularniejsze dla początkujących pozostaje Arduino IDE, głównie ze względu na prostotę i ogromną liczbę przykładów. Bardziej zaawansowaną opcją jest PlatformIO, zwykle używane jako wtyczka do VS Code – daje lepsze zarządzanie bibliotekami i konfiguracją, ale wymaga więcej ustawień na start.

Dla pierwszego projektu czujnika Wi‑Fi najbardziej sensowne jest Arduino IDE, ponieważ:

• ma prosty interfejs i minimalną liczbę opcji na ekranie,
• dodanie obsługi ESP32 sprowadza się do jednego adresu URL w ustawieniach,
• większość poradników i bibliotek czujników ma gotowe przykłady w tym środowisku.

PlatformIO warto rozważyć później, gdy pojawią się większe projekty, wiele płytek i konieczność lepszej organizacji kodu. Z punktu widzenia funkcji ESP32 (Wi‑Fi, OTA, MQTT) oba rozwiązania pozwalają praktycznie na to samo, różnią się głównie wygodą i organizacją narzędzi.

Dodanie obsługi ESP32 do Arduino IDE

Świeżo zainstalowane Arduino IDE „zna” z pudełka głównie płytki Arduino (UNO, Nano, Mega itd.). Aby korzystać z ESP32, trzeba dodać do menedżera płytek odpowiedni adres repozytorium. Kroki są następujące:

1. Otwórz Arduino IDE i przejdź do Plik → Preferencje.
2. W polu Dodatkowe adresy URL menedżera płytek wklej adres repozytorium ESP32 od Espressif (np. z oficjalnej dokumentacji).
3. Zatwierdź przyciskiem OK.
4. Przejdź do Narzędzia → Płytka → Menedżer płytek i wyszukaj „ESP32”.
5. Zainstaluj pakiet ESP32 od Espressif.

Wybór właściwej płytki w Arduino IDE i pierwszy upload

Po zainstalowaniu obsługi ESP32 w Arduino IDE trzeba jeszcze wybrać konkretną płytkę i sprawdzić, czy środowisko „widzi” nasz układ. To zwykle pierwszy moment, w którym coś może pójść nie tak, więc dobrze przejść to spokojnie, krok po kroku.

1. Podłącz ESP32 DevKit do komputera kablem USB.
2. Wejdź w Narzędzia → Płytka i wybierz coś w rodzaju ESP32 Dev Module lub konkretny model DevKita, jeśli jest na liście.
3. W menu Narzędzia → Port wybierz nowy port, który pojawił się po podłączeniu płytki (w systemie Windows będzie to zwykle COMx, w macOS/Linux – /dev/ttyUSBx lub /dev/tty.SLAB_USBtoUART / tty.SLAB).
4. Jeśli port się nie pojawia, zainstaluj odpowiednie sterowniki do konwertera USB‑UART, najczęściej CP2102 albo CH340 – producent płytki zwykle podaje to w opisie.

Po prawidłowym wyborze płytki i portu można już wgrać pierwszy program. Najczęściej zaczyna się od „blink”, czyli mrugania diodą LED — nawet jeśli na ESP32 „wbudowana dioda” jest podłączona do innego pinu niż w klasycznym Arduino.

Pierwszy „blink” na ESP32 – przykład minimalny

Na większości płytek ESP32 wbudowana dioda LED jest podłączona do pinu 2. Jeśli nie masz pewności, można to szybko sprawdzić w dokumentacji DevKita lub po prostu przetestować. Oto prosty szkic:

#define LED_PIN 2

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);  // dioda ON
  delay(500);
  digitalWrite(LED_PIN, LOW);   // dioda OFF
  delay(500);
}

Po kliknięciu przycisku Wgraj (strzałka w prawo) Arduino IDE skompiluje kod i spróbuje przesłać go do ESP32. W części płytek konieczne jest ręczne wprowadzenie układu w tryb programowania – wtedy:

• przytrzymaj przycisk BOOT (lub IO0) na płytce zaraz po rozpoczęciu uploadu,
• puść go, gdy w konsoli IDE pojawi się komunikat o rozpoczęciu wgrywania (pasek postępu z procentami).

Jeśli po kilku próbach nic się nie udaje, zwykle pomaga zmiana kabla USB (niektóre „tylko zasilające” nie przesyłają danych) oraz sprawdzenie, czy wybrana jest odpowiednia płytka w menu Narzędzia.

Monitor portu szeregowego – podstawowe narzędzie diagnostyczne

Mrugająca dioda to poprawny start, ale przy czujniku Wi‑Fi ważniejsze będzie patrzenie „do środka” programu. Do tego służy monitor portu szeregowego – okno, w którym ESP32 wypisuje teksty za pomocą Serial.println().

Przykład prostego szkicu testowego:

void setup() {
  Serial.begin(115200);
  delay(1000);  // chwila na uruchomienie portu
  Serial.println("Start ESP32");
}

void loop() {
  Serial.println("Dzialam...");
  delay(1000);
}

Po wgraniu programu otwórz Narzędzia → Monitor portu szeregowego, ustaw prędkość na 115200 baud i sprawdź, czy pojawiają się komunikaty. Przy późniejszej pracy z Wi‑Fi, czujnikami i serwerami to okno staje się głównym „oknem diagnostycznym” całego projektu.

Podstawy ESP32 w praktyce – piny, zasilanie i ograniczenia

Mapa pinów ESP32 DevKit – które piny używać, a których unikać

ESP32 ma kilkadziesiąt wyprowadzeń, ale nie każde nadaje się do dowolnego zastosowania. Część jest zajęta przez pamięć flash, część ma specjalne role przy starcie. Brak tej świadomości często kończy się „zawiechą” układu, gdy podłączony czujnik blokuje start mikrokontrolera.

Przy prostym czujniku Wi‑Fi można przyjąć kilka praktycznych zasad:

• Do zwykłych wejść/wyjść (np. diody, przekaźniki, przyciski) bezpieczne są piny takie jak GPIO 2, 4, 5, 18, 19, 21, 22, 23, 25, 26, 27.
• Magistrala I2C domyślnie korzysta z pinów GPIO 21 (SDA) i GPIO 22 (SCL), choć w ESP32 można je zmienić programowo.
• Piny GPIO 34–39 są tylko wejściami (nie można ustawiać na nich stanu wysokiego/niskiego), więc nie nadają się np. do diod LED, ale świetnie sprawdzą się jako wejścia analogowe.
• Nie podłączaj na stałe do masy ani do zasilania pinów tzw. strapping pins (np. 0, 2, 12, 15) bez zrozumienia ich roli – od ich stanu przy starcie zależy tryb bootowania.

Przy pierwszym projekcie dobrą strategią jest użycie popularnego zestawu: 21/22 dla I2C (czujniki typu BME280) i jednego z pinów 25, 26 lub 27 jako dodatkowego wyjścia np. dla diody sygnalizującej błąd.

Poziomy napięć i zasilanie – dlaczego 5 V bywa problematyczne

ESP32 pracuje logicznie na 3,3 V. To oznacza, że na jego piny wejściowe nie powinno trafiać sygnałów 5‑woltowych z innych układów, bo można fizycznie uszkodzić mikrokontroler. Jednocześnie większość płytek DevKit ma na złączu pin 5V (czasem opisany jako VIN), który zasila wbudowany stabilizator. Różnicę warto mieć w głowie:

• 5 V / VIN – wejście zasilania płytki (np. z USB lub z zewnętrznego zasilacza),
• 3V3 – wyjście stabilizowanego 3,3 V dla modułu ESP32 i czujników.

Czujnik BME280 najczęściej występuje w wersji z małą płytką, na której już jest stabilizator i konwerter poziomów – taka wersja zwykle akceptuje 3,3–5 V na pinie VCC. Przy podłączeniu do ESP32 najwygodniej i najbezpieczniej jest użyć 3,3 V, bo wtedy sygnały logiczne i zasilanie są w tym samym standardzie.

Przykładowy schemat zasilania w pierwszym projekcie wygląda wtedy bardzo prosto:

• ESP32 DevKit zasilany z USB komputera,
• czujnik BME280 podłączony do pinu 3V3, masy GND oraz linii SDA i SCL ESP32.

Jeśli w przyszłości dołożysz elementy o większym poborze prądu (np. paski LED), one mogą być zasilane z 5 V lub wyższego napięcia, ale masę takiego zasilania trzeba połączyć z masą ESP32. W przeciwnym razie sygnały sterujące będą „wisiały w powietrzu”.

Analogowe wejścia ESP32 i ich specyfika

ESP32 posiada wbudowany przetwornik analogowo‑cyfrowy (ADC), dzięki czemu potrafi mierzyć napięcie na wybranych pinach. W czujniku temperatury i wilgotności zwykle korzysta się z gotowego interfejsu cyfrowego (I2C, 1‑wire), ale analogowe wejścia przydają się np. do prostego pomiaru napięcia baterii czy czujnika światła na fotorezystorze.

Najważniejsze praktyczne cechy ADC w ESP32:

• zakres napięcia na wejściu to zwykle 0–3,3 V (przekroczenie grozi uszkodzeniem),
• przetwornik jest dość „szumiący”, więc warto uśredniać kilka odczytów,
• nie wszystkie piny, które mają oznaczenie ADCx, dają takie same wyniki – dokumentacja opisuje tzw. characterization i nieliniowości.

Jeśli pojawi się pomysł np. pomiaru napięcia zasilania 12 V, trzeba zbudować dzielnik rezystorowy, który „ściągnie” zakres do 0–3,3 V. Na etapie pierwszego czujnika Wi‑Fi najwygodniej trzymać się jednostek z interfejsem cyfrowym – są mniej wrażliwe na zakłócenia i proste w obsłudze programistycznej.

Pierwsze kroki z czujnikiem – od schematu do odczytu danych

Fizyczne podłączenie BME280 do ESP32

BME280 to dobry kandydat na pierwszy czujnik: obsługuje magistralę I2C, ma prostą bibliotekę i pozwala jednocześnie mierzyć temperaturę, wilgotność oraz ciśnienie. Typowy moduł BME280 ma wyprowadzone piny:

• VCC – zasilanie (najlepiej 3,3 V),
• GND – masa,
• SCL – linia zegara I2C,
• SDA – linia danych I2C.

Na płytce stykowej połączenia wyglądają wtedy następująco:

• VCC → 3V3 na ESP32,
• GND → GND na ESP32,
• SCL → GPIO 22 (domyślny SCL),
• SDA → GPIO 21 (domyślne SDA).

Przy krótkich przewodach (kilka–kilkanaście centymetrów) nie trzeba żadnych dodatkowych elementów – moduły BME280 mają na płytce rezystory podciągające do linii I2C. Jeśli kiedyś przewody wydłużą się do metra czy dwóch, dobrze jest zadbać o ekranowany przewód i ewentualnie zmniejszyć prędkość magistrali w programie.

Instalacja biblioteki BME280 w Arduino IDE

Zanim pojawią się pierwsze liczby z czujnika, potrzebna jest biblioteka, która „odrobi za nas pracę domową” związaną z protokołem I2C i kalibracją sensora.

1. Wybierz Szkic → Dołącz bibliotekę → Zarządzaj bibliotekami….
2. W polu wyszukiwania wpisz BME280.
3. Znajdź bibliotekę np. Adafruit BME280 Library i kliknij Install.
4. Jeśli Arduino IDE zaproponuje zainstalowanie zależnej biblioteki Adafruit Unified Sensor, również potwierdź.

Po instalacji w menu Plik → Przykłady pojawi się nowa sekcja z gotowymi szkicami – to najszybsza droga, aby sprawdzić, czy sprzęt jest poprawnie podłączony.

Pierwszy odczyt z BME280 – przykładowy kod

Na początek wystarczy minimalny program, który inicjalizuje czujnik, a potem co kilka sekund wypisuje wartości do monitora portu szeregowego. Oto przykład bazujący na bibliotece Adafruit:

#include <Wire.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme; // obiekt czujnika

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("Start BME280 + ESP32");

  bool status = bme.begin(0x76); // popularny adres I2C czujnika
  if (!status) {
    Serial.println("Nie wykryto BME280. Sprawdz polaczenia!");
    while (1) {
      delay(1000);
    }
  }
}

void loop() {
  float temperature = bme.readTemperature();
  float humidity    = bme.readHumidity();
  float pressure    = bme.readPressure() / 100.0F; // hPa

  Serial.print("T = ");
  Serial.print(temperature);
  Serial.print(" *C, RH = ");
  Serial.print(humidity);
  Serial.print(" %, P = ");
  Serial.print(pressure);
  Serial.println(" hPa");

  delay(2000);
}

Jeśli po wgraniu programu i otwarciu monitora portu szeregowego na ekranie pojawiają się kolejne pomiary, oznacza to, że zarówno magistrala I2C, jak i sam BME280 działają prawidłowo. W typowej sytuacji różnice między BME280 a domowym termometrem mogą wynosić kilka dziesiątych stopnia – część wynika z nagrzewania się płytki ESP32, zwłaszcza gdy zamknie się wszystko w ciasnej obudowie.

Diagnozowanie problemów z komunikacją I2C

Jeżeli pojawia się komunikat „Nie wykryto BME280”, winne bywają najczęściej proste rzeczy: odwrócony czujnik na płytce stykowej, pomylone linie SDA/SCL albo złe napięcie zasilania. Pomaga wtedy podejście „krok po kroku”:

• Sprawdź, czy VCC czujnika jest faktycznie podłączone do 3V3, a GND do masy.
• Upewnij się, że SDA i SCL idą do odpowiednich pinów (21/22) i przewody są dobrze wciśnięte w płytkę stykową.
• Przetestuj inny adres I2C, np. bme.begin(0x77); – niektóre moduły BME280 używają drugiego adresu.

Istnieją też proste skanery I2C – krótkie programy, które przeszukują przestrzeń adresów magistrali i wypisują te, na które odpowiedział jakiś układ. Przy rozbudowie projektu o kolejne czujniki takie narzędzie bardzo ułatwia życie.

Wi‑Fi na ESP32 bez magii – łączenie z siecią domową

Minimalny szkic Wi‑Fi w trybie stacji

ESP32 potrafi pracować jako stacja (klient Wi‑Fi, tak jak telefon) oraz jako Access Point (tworzy własną sieć). Do domowego czujnika najwygodniejszy jest tryb stacji – moduł łączy się z Twoim routerem, dostaje adres IP i może wysyłać dane dalej.

Najprostszy szkic z użyciem biblioteki WiFi.h wygląda tak:

#include <WiFi.h>

const char* ssid     = "Twoja_Siec_WiFi";
const char* password = "Twoje_Haslo_WiFi";

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

  Serial.println("Laczenie z WiFi...");
  WiFi.begin(ssid, password);

  // Czekamy na polaczenie
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.println("Polaczono z WiFi!");
  Serial.print("Adres IP: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  // na razie nic tu nie ma
}

Po wgraniu programu ESP32 powinno po kilkunastu sekundach wypisać przypisany adres IP. Jeśli zamiast tego pojawi się niekończący ciąg kropek, moduł nie może połączyć się z siecią (błędne hasło, zbyt słaby sygnał, filtracja MAC w routerze).

Łączenie Wi‑Fi z obsługą czujnika

Sensowne jest połączenie inicjalizacji BME280 i Wi‑Fi w jednym szkicu. Najpierw uruchamia się port szeregowy, potem czujnik, a na końcu Wi‑Fi. Dzięki temu ewentualne problemy łatwiej rozdzielić: jeśli BME280 działa, a Wi‑Fi nie – szuka się błędu w sieci, a nie w kablach.

Przykładowy zarys programu:

#include <Wire.h>
#include <Adafruit_BME280.h>
#include <WiFi.h>

Adafruit_BME280 bme;

const char* ssid     = "Twoja_Siec_WiFi";
const char* password = "Twoje_Haslo_WiFi";

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

  Serial.println("Start BME280 + WiFi");

  if (!bme.begin(0x76)) {
    Serial.println("Blad BME280");
    while (1) delay(1000);
  }

  Serial.print("Laczenie z ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);

  uint8_t retries = 30; // ~15 s
  while (WiFi.status() != WL_CONNECTED && retries--) {
    delay(500);
    Serial.print(".");
  }

  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("nNie udalo sie polaczyc z WiFi");
  } else {
    Serial.println("nPolaczono z WiFi");
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());
  }
}

void loop() {
  float t = bme.readTemperature();
  float h = bme.readHumidity();
  float p = bme.readPressure() / 100.0F;

  Serial.print("T=");
  Serial.print(t);
  Serial.print("C  H=");
  Serial.print(h);
  Serial.print("%  P=");
  Serial.print(p);
  Serial.println("hPa");

  delay(5000);
}

Taki szkic wciąż tylko wypisuje pomiary do portu szeregowego, ale ESP32 ma już „otwarte drzwi” do sieci – można uruchomić prosty serwer HTTP lub wysyłać dane na zewnątrz.

Prosty serwer HTTP – podgląd danych w przeglądarce

Najbardziej intuicyjny pierwszy krok: ESP32 wystawia mini‑stronę WWW, na której widać aktualne pomiary. Nie trzeba stawiać żadnego dodatkowego serwera – wszystko działa w samym mikrokontrolerze.

Wykorzystany zostanie wbudowany WiFiServer nasłuchujący na porcie 80 (standardowy HTTP):

#include <WiFi.h>
#include <Wire.h>
#include <Adafruit_BME280.h>

const char* ssid     = "Twoja_Siec_WiFi";
const char* password = "Twoje_Haslo_WiFi";

Adafruit_BME280 bme;
WiFiServer server(80);

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

  if (!bme.begin(0x76)) {
    Serial.println("Blad BME280");
    while (1) delay(1000);
  }

  WiFi.begin(ssid, password);
  Serial.print("Laczenie z WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("nPolaczono!");
  Serial.print("Adres IP: ");
  Serial.println(WiFi.localIP());

  server.begin();
}

void loop() {
  WiFiClient client = server.available();
  if (!client) return;

  // czekamy, az klient wysle zapytanie
  while (client.connected() && !client.available()) {
    delay(1);
  }

  String request = client.readStringUntil('r');
  client.readStringUntil('n'); // pusta linia

  // pobieramy dane z czujnika
  float t = bme.readTemperature();
  float h = bme.readHumidity();
  float p = bme.readPressure() / 100.0F;

  // prosty naglowek HTTP
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html; charset=utf-8");
  client.println("Connection: close");
  client.println();
  // tresc strony
  client.println("<!DOCTYPE html>");
  client.println("<html><head><meta charset="utf-8">");
  client.println("<title>ESP32 BME280</title>");
  client.println("<meta name="viewport" content="width=device-width, initial-scale=1">");
  client.println("</head><body style="font-family: sans-serif;">");
  client.println("<h1>Czujnik ESP32</h1>");
  client.print("<p>Temperatura: <strong>");
  client.print(t);
  client.println(" &deg;C</strong></p>");
  client.print("<p>Wilgotnosc: <strong>");
  client.print(h);
  client.println(" %</strong></p>");
  client.print("<p>Cisnienie: <strong>");
  client.print(p);
  client.println(" hPa</strong></p>");
  client.println("</body></html>");

  delay(1);
  client.stop();
}

Po uruchomieniu i wyświetleniu w monitorze portu szeregowego adresu IP, wystarczy wpisać go w przeglądarce (np. http://192.168.0.50/) w tej samej sieci Wi‑Fi. Na ekranie pojawią się na żywo odczyty z BME280.

Najczęstsze problemy z Wi‑Fi

Przy pierwszych próbach z Wi‑Fi powtarzają się pewne drobiazgi. Zamiast szukać błędu w kodzie, lepiej zrobić szybki „check‑list”:

• Zły SSID lub hasło – kopiuj/wklej prosto z panelu routera, unikniesz literówek i pomyłek wielkości liter.
• Częstotliwość 5 GHz – większość płytek ESP32 obsługuje tylko 2,4 GHz; gdy router ma jedną nazwę sieci dla 2,4 i 5 GHz, bywa różnie z kompatybilnością. Dobrym testem jest chwilowe włączenie osobnej sieci 2,4 GHz.
• Zasięg – płytka na biurku często działa świetnie, ale gdy trafi za szafkę z metalową obudową, zasięg dramatycznie spada. Krótka próba bliżej routera szybko to weryfikuje.

Gdzie wysłać dane z czujnika?

Idea: push vs pull

Są dwa podstawowe sposoby „wyniesienia” pomiarów poza ESP32. Albo to ESP32 samo wysyła dane na zewnętrzny serwer (push), albo ktoś (np. przeglądarka, Home Assistant) odpyta ESP32 i odbierze pomiar (pull). W domowym projekcie oba wzorce się sprawdzają – można zacząć od prostego odpytywania, a potem przejść na wysyłanie do serwisu w chmurze czy lokalnej bazy.

Wysyłanie pomiarów HTTP GET/POST

Najprostsza forma „push” to zwykłe zapytanie HTTP z parametrami, np.:

http://moj-serwer.local/log?temp=23.4&hum=45.6

Po stronie serwera może pracować dowolny skrypt (PHP, Python, Node.js), który zapisze dane do pliku lub bazy. Po stronie ESP32 wystarczy WiFiClient lub gotowa biblioteka HTTPClient:

#include <WiFi.h>
#include <HTTPClient.h>
#include <Adafruit_BME280.h>

const char* ssid     = "Twoja_Siec_WiFi";
const char* password = "Twoje_Haslo_WiFi";

const char* serverUrl = "http://192.168.0.10/log.php";

Adafruit_BME280 bme;

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

  bme.begin(0x76);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("nWiFi OK");
}

void loop() {
  if (WiFi.status() == WL_CONNECTED) {
    float t = bme.readTemperature();
    float h = bme.readHumidity();

    HTTPClient http;
    String url = String(serverUrl) + "?t=" + String(t, 2) + "&h=" + String(h, 2);
    http.begin(url);
    int code = http.GET();
    if (code > 0) {
      Serial.print("Odpowiedz serwera: ");
      Serial.println(code);
    } else {
      Serial.print("Blad HTTP: ");
      Serial.println(code);
    }
    http.end();
  } else {
    Serial.println("Brak WiFi");
  }

  delay(10000); // co 10 s
}

To wystarcza, aby na prostym lokalnym serwerze (np. Raspberry Pi z Apache lub Nginx) budować własny logownik pogody. Jedna linijka w skrypcie PHP może dopisywać parametry do pliku CSV, który potem wczyta dowolny arkusz kalkulacyjny.

MQTT – lekkie „centrum komunikacji” dla IoT

Dla większej liczby czujników i urządzeń wygodny jest protokół MQTT. Działa na zasadzie publikowania wiadomości na tematach, które inne urządzenia mogą subskrybować. ESP32 może wtedy jednocześnie wysyłać dane i przyjmować komendy (np. włącz wentylator, gdy wilgotność przekroczy próg).

Do testów świetnie sprawdza się lokalny broker MQTT na Raspberry Pi (np. Mosquitto) lub kontenerze Docker. Po stronie ESP32 najłatwiej użyć biblioteki PubSubClient:

#include <WiFi.h>
#include <PubSubClient.h>
#include <Adafruit_BME280.h>

const char* ssid       = "Twoja_Siec_WiFi";
const char* password   = "Twoje_Haslo_WiFi";
const char* mqttServer = "192.168.0.20";
const uint16_t mqttPort = 1883;

WiFiClient espClient;
PubSubClient client(espClient);
Adafruit_BME280 bme;

void reconnectMQTT() {
  while (!client.connected()) {
    Serial.print("Laczenie z MQTT...");
    if (client.connect("esp32-czujnik")) {
      Serial.println("polaczono");
      // tu mozna zasubskrybowac tematy
      // client.subscribe("dom/czujnik/cmd");
    } else {
      Serial.print("blad, rc=");
      Serial.print(client.state());
      Serial.println(" ponowna proba za 5 s");
      delay(5000);
    }
  }
}

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

  bme.begin(0x76);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("nWiFi OK");

  client.setServer(mqttServer, mqttPort);
}

void loop() {
  if (!client.connected()) {
    reconnectMQTT();
  }
  client.loop(); // obsluga komunikacji w tle

  float t = bme.readTemperature();
  float h = bme.readHumidity();
  float p = bme.readPressure() / 100.0F;

  // publikacja na temat
  client.publish("dom/czujnik/temperatura", String(t, 2).c_str());
  client.publish("dom/czujnik/wilgotnosc", String(h, 2).c_str());
  client.publish("dom/czujnik/cisnienie",  String(p, 1).c_str());

  Serial.println("Wyslano dane MQTT");

  delay(10000);
}

Taki układ świetnie współpracuje z Home Assistantem czy Node‑RED. ESP32 jedynie wrzuca liczby na odpowiednie „kanały”, a logika, wykresy i automatyzacje dzieją się gdzie indziej.

Chmura i gotowe usługi

Jeśli nie ma miejsca na własny serwer, można wysyłać odczyty prosto do gotowych platform. Wspólny mianownik: wszystkie przyjmują dane przez HTTP lub MQTT, a do wizualizacji udostępniają gotowe dashboardy. Popularne kierunki to:

• ThingSpeak – bardzo prosty start, dane wysyła się zapytaniem HTTP z kluczem API, a serwis sam rysuje wykresy.
• InfluxDB + Grafana w chmurze – wygodne dla kilku czujników, gdy chce się mieć ładne, interaktywne panele.
• Blynk – aplikacja na telefon, w której tworzy się własny ekran do sterowania i podglądu danych, a ESP32 łączy się przez bibliotekę.

Przykład prostego wysyłania do ThingSpeak (kanał z jednym polem, klucz API wstawiony w kodzie) sprowadza się w praktyce do jednego zapytania HTTP co kilkadziesiąt sekund. Przy pierwszych ćwiczeniach bardziej przydaje się jednak lokalny serwer lub MQTT – łatwiej tam „zajrzeć pod maskę” i zrozumieć, co naprawdę dzieje się na łączu.

Jak często wysyłać dane i co z energią?

ESP32 nie musi raportować co sekundę, żeby system był użyteczny. W przypadku temperatury i wilgotności sens ma wysyłanie co 30–60 sekund, a nawet rzadziej. Mniej pakietów oznacza mniejsze obciążenie sieci, a przy zasilaniu bateryjnym – dużo dłuższy czas pracy.

Najczęściej zadawane pytania (FAQ)

Dlaczego na pierwszy projekt IoT lepiej wybrać ESP32 zamiast Arduino UNO?

Arduino UNO świetnie nadaje się do nauki podstaw elektroniki, ale sam z siebie nie ma Wi‑Fi. Do komunikacji z siecią trzeba dołożyć osobny moduł, co komplikuje start i zwiększa koszty. ESP32 ma Wi‑Fi wbudowane w układ, więc od razu można pisać program, który łączy się z domową siecią i wysyła dane z czujnika.

Dodatkowo ESP32 ma mocniejszy procesor, więcej pamięci i więcej wyprowadzeń. Dzięki temu bez problemu obsłuży np. serwer WWW, MQTT czy aktualizacje OTA, podczas gdy UNO szybko „dostaje zadyszki” przy bardziej rozbudowanych projektach sieciowych.

Czym różni się ESP32 od ESP8266 i kiedy który wybrać?

ESP8266 to starszy, bardzo popularny układ Wi‑Fi, który dobrze sprawdza się w prostych projektach, np. jednokanałowy przekaźnik z Wi‑Fi. Ma jednak mniej pamięci, słabszy procesor i mniej peryferiów niż ESP32. Przy kilku bibliotekach na raz (np. MQTT + serwer WWW) zaczyna robić się ciasno.

ESP32 ma dwa rdzenie, więcej RAM, a do tego obsługuje Bluetooth i BLE. Świetnie nadaje się na „bazę” do dalszej rozbudowy: od prostego czujnika temperatury, aż po sterownik domu z panelem WWW i integracją z Home Assistant. Jeśli zaczynasz od zera i nie masz ograniczeń budżetowych co do kilku złotych, praktyczniejszym wyborem jest ESP32.

Jaką wersję ESP32 kupić na pierwszy projekt czujnika Wi‑Fi?

Na start najwygodniejsza jest płytka ESP32 DevKit (często z dopiskiem DevKitC) z modułem ESP32‑WROOM. Ma gniazdo USB, wbudowany konwerter USB‑UART i wyprowadzone piny w rozstawie pasującym do płytki stykowej. Podłączasz kabel USB do komputera i od razu możesz programować układ.

Moduły ESP32‑WROOM czy ESP32‑WROVER w „gołej” wersji są przeznaczone raczej do własnych płytek drukowanych. WROVER ma dodatkową pamięć PSRAM, co przydaje się przy grafice, dźwięku czy bardziej rozbudowanych aplikacjach sieciowych, ale do prostego czujnika temperatury i wilgotności wystarczy zwykły WROOM.

Jaki czujnik temperatury i wilgotności wybrać do ESP32: DHT22 czy BME280?

DHT22 jest tańszy i bardzo popularny. Mierzy temperaturę oraz wilgotność, ma prosty interfejs i gotowe biblioteki dla Arduino/ESP32. Wystarczająco dobrze sprawdzi się np. w pokoju czy piwnicy, chociaż nie lubi zbyt częstych odczytów i długich przewodów.

BME280 jest dokładniejszy, stabilniejszy i dodatkowo mierzy ciśnienie atmosferyczne. Komunikuje się przez magistralę I2C lub SPI, co ułatwia podłączanie kilku czujników do tych samych linii. Jeśli chcesz mini stację pogodową albo myślisz o rozbudowie projektu, BME280 będzie bardziej przyszłościowym wyborem.

Jakie elementy są absolutnie potrzebne, żeby zbudować pierwszy czujnik Wi‑Fi na ESP32?

Do najprostszego działającego zestawu wystarczy kilka rzeczy, które zmieszczą się w jednej małej torebce:

• płytka ESP32 DevKit (np. z modułem WROOM),
• kabel USB (micro USB lub USB‑C, w zależności od wersji płytki),
• czujnik temperatury/wilgotności – DHT22 albo BME280 na gotowej małej płytce,
• kilka przewodów połączeniowych typu jumper (męsko‑żeńskie).

Płytka stykowa bardzo ułatwia życie, ale nie jest obowiązkowa przy pierwszym uruchomieniu – krótkie przewody można na początek wpiąć bezpośrednio w goldpiny ESP32 i w złącza czujnika. Zasilanie zapewnia samo USB z komputera.

Czy do pierwszego projektu na ESP32 potrzebne jest lutowanie?

Nie, większość podstawowych projektów – w tym prosty czujnik Wi‑Fi – można złożyć całkowicie bez lutowania. Wystarczy płytka stykowa i przewody jumper, którymi łączysz piny ESP32 z pinami czujnika (zasilanie, masa, linia danych).

Lutowanie przydaje się dopiero wtedy, gdy chcesz zbudować trwałe urządzenie w obudowie, np. docelowy czujnik do szklarni czy garażu. Na etapie nauki i prototypowania wygodniej jest mieć możliwość szybkiego przepinania przewodów i testowania różnych konfiguracji.

Gdzie wysyłać dane z czujnika ESP32: MQTT, HTTP, a może coś innego?

Najczęściej wybierane są trzy drogi. Najprostsza w zrozumieniu jest wysyłka danych przez HTTP na prosty serwer lub API – ESP32 robi wtedy zwykłe „zapytanie” z wynikiem pomiaru. Wiele osób stawia też lokalnego brokera MQTT (np. na Raspberry Pi lub w Home Assistant), do którego czujnik publikuje odczyty, a inne urządzenia je subskrybują.

Można też skorzystać z gotowych platform chmurowych do logowania i wizualizacji danych. Do pierwszych eksperymentów wygodny jest MQTT, bo łatwo podgląda się wysyłane wiadomości i integruje je z automatyką domową. Jeśli myślisz o współpracy z istniejącą aplikacją lub serwisem WWW, często naturalnym wyborem będzie proste API HTTP.