Nowoczesne systemy automatyki domowej coraz częściej opierają się na prostych i niedrogich modułach IoT, które pozwalają sterować urządzeniami z dowolnego miejsca — przez sieć lokalną lub internet.

Jednym z najpopularniejszych rozwiązań w tej kategorii jest moduł ESP32, oferujący dużą moc obliczeniową, łączność Wi-Fi/Bluetooth oraz możliwość bezpośredniego sterowania przekaźnikami i innymi elementami wykonawczymi.

W tym wpisie przedstawiamy kompletny przewodnik, którego celem jest zbudowanie zdalnie sterowanego wyłącznika. Projekt oparty będzie na płytce IMZ ESP32 2-Relay dostępnej w naszej ofercie — wyposażonej w moduł ESP32 oraz dwa przekaźniki. Płytka nie posiada wbudowanego konwertera USB-UART, dlatego do programowania wykorzystamy zewnętrzny adapter, taki jak CH340, CP2102 czy FTDI.

W kolejnych krokach pokażemy:

jak przygotować moduł do pracy,
jak wgrać pierwszy program i uruchomić sterowanie przekaźnikami,
jak stworzyć prostą stronę WWW umożliwiającą włączanie i wyłączanie urządzeń,
oraz niektóre dostępne metody zdalnego dostępu

Celem artykułu jest nie tylko instrukcja, ale także pokazanie, jakie możliwości daje ESP32 oraz którą drogę warto wybrać w zależności od potrzeb projektu.

Co będzie potrzebne do startu

Do pracy z modułem IMZ ESP32 2-Relay potrzebujemy kilku podstawowych elementów. Część z nich omówiliśmy już w artykule Ekspresowe wprowadzenie do Arduino i ESP32 dotyczącym przygotowania środowiska Arduino IDE i pierwszego programowania ESP32 — tutaj natomiast skupimy się na kompletowaniu sprzętu niezbędnego do tego konkretnego projektu.

Moduł IMZ ESP32 2-Relay

Podstawą projektu jest płytka z naszej oferty wyposażona w:

dwa przekaźniki podłączone do GPIO 16 i 17,
diodę LED sygnalizacyjną na GPIO 23,
wejście zasilania 6–12 V,
wyprowadzone piny UART do programowania.

Takie zestawienie pozwala bezpośrednio sterować urządzeniami zasilanymi z sieci lub instalacji niskonapięciowych, a jednocześnie pozostawia pełną elastyczność po stronie oprogramowania.

Zewnętrzny konwerter USB–UART

Ponieważ płytka nie posiada wbudowanego interfejsu USB, do wgrywania oprogramowania konieczne jest użycie zewnętrznego konwertera, np.:

Kable połączeniowe

Do połączenia konwertera z modułem przydadzą się standardowe przewody połączeniowe (męsko–męskie). Są wygodne, elastyczne i pozwalają szybko zestawić połączenie testowe bez lutowania.

Zasilacz 6–12 V

Zasilacz nie jest konieczny do samego programowania modułu. Jednak przekaźniki wymagają stabilnego zasilania, dlatego warto skorzystać z zasilacza dostępnego w naszym sklepie. Zakres 6–12 V zapewnia prawidłową pracę zarówno części wykonawczej, jak i logiki sterującej.

Komputer z zainstalowanym środowiskiem Arduino IDE

Sposobów na zaprogramowanie modułów ESP32 jest wiele. Na początek proponuję Arduino IDE. W poprzednim artykule opisaliśmy jak:

zainstalować Arduino IDE,
dodać obsługę płytek ESP32,
skonfigurować port szeregowy i parametry kompilacji,
przetestować pierwsze szkice.

Kiedy już wszystko będzie przygotowane można przejść do pisania programu.

Programowanie moduł IMZ ESP32 2-Relay

Programowanie za pomocą konwertera USB-UART

Aby móc zaprogramować płytkę należy podłączyć zewnętrzny konwerter USB-UART. W tym przypadku połączenie krzyżowe TX↔RX jest konieczne, aby urządzenia mogły wymieniać dane — nadajnik jednego modułu musi być podłączony do odbiornika drugiego.

Płytka z ESP32	Konwerter USB-UART	OPIS
Tx	Rx	Wyjście danych ESP32 (Tx) łączymy z wejściem danych konwertera (Rx)
Rx	Tx	Wejście danych ESP32 (Rx) łączymy z wyjściem konwertera (Tx)
GND	GND	Łączymy masy
5V	5V	Podajemy zasilanie na płytkę

Napięcie logiki na 3.3V Konwertery USB–UART pozwalają wybrać poziom logiczny 5V lub 3.3V. W przypadku ESP32 zworkę należy przestawić na 3.3V, aby uniknąć uszkodzenia układu i zapewnić prawidłową komunikację.

W przypadku, kiedy moduł jest już podpięty do zasilania nie podpinamy zasilania 5V z konwertera. Wystarczą linie Rx, Tx, i GND.

Programowanie przez OTA (Over-The-Air)

Oprócz standardowego wgrywania oprogramowania przez konwerter USB–UART, moduł ESP32 umożliwia aktualizację firmware’u bezprzewodowo — w sieci Wi-Fi, dzięki mechanizmowi OTA. To bardzo wygodne rozwiązanie przy urządzeniach zamontowanych w trudno dostępnych miejscach lub pracujących w docelowej instalacji.

W osobnym artykule przygotujemy pełny przewodnik po konfiguracji OTA oraz praktyczne przykłady użycia.

Zadanie główne: zdalnie sterowany wyłącznik na ESP32

Mamy już kompletny hardware: moduł ESP32 oraz dwa przekaźniki . Teraz pora przejść do oprogramowania. ESP32 daje wiele możliwości od gotowych firmware’ów open-source, aż po własne programy pisane w Arduino IDE, PlatformIO, czy ESP-IDF.

Gotowe systemy i firmware dostępne dla ESP32

Poniżej przedstawiamy najważniejsze, praktyczne i rzeczywiście dostępne systemy, które działają na ESP32 i mogą obsługiwać przekaźniki, automatyzacje lub integracje sieciowe.

ESPHome

Jeden z najpopularniejszych systemów do automatyki domowej, przeznaczony przede wszystkim do integracji z Home Assistant. Konfiguracja odbywa się w formie YAML, a firmware generowany jest automatycznie — bez konieczności pisania kodu. Świetny wybór dla użytkowników automatyki inteligentnego domu. Wymaga Home Assitant!

ESPEasy

Rozbudowany firmware konfigurowany przez WWW, zawierający dziesiątki wtyczek, obsługę czujników, przekaźników, MQTT, HTTP i reguł automatyzacji. Bardzo wygodne rozwiązanie, jeśli chcemy obsłużyć przekaźniki „bez kodowania”, z dużą ilością gotowych opcji.

Tasmota

To otwarte oprogramowanie typu open-source służące do programowania urządzeń z kategorii Internetu Rzeczy (IoT), takich jak inteligentne gniazdka, żarówki czy przełączniki. Pozwala ono na lokalne sterowanie urządzeniami bez konieczności korzystania z chmury producenta, co zapewnia większą kontrolę, prywatność i szybkość działania. Po zainstalowaniu Tasmoty, urządzeniami można zarządzać za pomocą prostego interfejsu internetowego dostępnego przez przeglądarkę, bez potrzeby instalacji aplikacji mobilnych

ESPurna

Lekki firmware open-source, popularny w modułach z przekaźnikami. Oferuje obsługę MQTT, HTTP, scen, automatyzacji i trybów oszczędzania energii. Nieco mniej aktywnie rozwijany, ale nadal użyteczny.

OpenBeken

to oprogramowanie i platforma IoT open-source, która działa jak alternatywny firmware dla modułów Wi-Fi (jak ESP8266, ESP32), pozwalając na budowanie inteligentnych urządzeń domowych, symulowanie ich, konfigurowanie. Często bez potrzeby pisania skomplikowanego kodu, oferując symulator do testowania wirtualnych modułów, przycisków i przekaźników.

Systemy automatyki domowej współpracujące z ESP32

ESP32 może zostać włączone do większego ekosystemu automatyki domowej. Te systemy działają jako „centrala”, która udostępnia interfejs użytkownika (w tym aplikacje na telefon), zbiera dane z urządzeń, i steruje nimi. Za pomocą jednego z powyższych firmware’u, (lub własnego programu) możemy połączyć się z tymi systemami.

Home Assistant (HA)

Najpopularniejszy, najbardziej zaawansowany i stale rozwijany system automatyki domowej typu open-source. Oferuje ogromną liczbę integracji, obsługę MQTT, ESPHome, REST API, Webhooków, BLE oraz automatyzacji opartych o reguły i skrypty. HA umożliwia pełną kontrolę nad ESP32 – zarówno lokalnie, jak i zdalnie – oraz integrację z Google Assistant i Alexą (przez HA Cloud). To dziś standard w domowych instalacjach inteligentnych.

Domoticz

Lżejsza i prostsza alternatywa dla Home Assistanta. Domoticz obsługuje MQTT, HTTP oraz wiele typowych urządzeń IoT, czujników i przekaźników. W połączeniu z ESPEasy lub Tasmotą pozwala stworzyć stabilny system sterowania domem nawet na słabszym sprzęcie, takim jak Raspberry Pi Zero.

openHAB

Zaawansowana i bardzo modularna platforma open-source, dostosowana do dużych instalacji i zaawansowanych użytkowników. Obsługuje MQTT, HTTP, WebSockety i wiele protokołów. Jest ceniona za elastyczność i możliwość budowy skomplikowanych scen oraz reguł automatyki. Dobra alternatywa dla HA w środowiskach profesjonalnych.

SUPLA (polski projekt open-source)

Polski system automatyki domowej rozwijany jako open-source, z darmową chmurą i oficjalnymi aplikacjami mobilnymi. Umożliwia sterowanie przekaźnikami, oświetleniem, bramami, pomiarami energii i czujnikami. SUPLA obsługuje urządzenia ESP8266/ESP32 dzięki dedykowanemu firmware i może działać lokalnie lub w chmurze. Szczególnie popularna w Polsce, prosta w konfiguracji i bardzo stabilna.

Node-RED

To nie jest centrala, ale wielu używa go jako “mózgu” – graficznego narzędzia do tworzenia logiki przepływów (flows) między urządzeniami. Umożliwia obsługę MQTT, HTTP, WebSocketów i integrację właściwie z dowolnym API.

Homey (Homey Pro)

Komercyjna centrala z gotową aplikacją i integracjami. Łączy w jednym urządzeniu obsługę wielu protokołów: Zigbee, Z-Wave, BLE i WiFi. Po zakupie urządzenia większość integracji działa od razu, bez dodatkowej opłaty.

Hubitat Elevation

to lokalna centrala smart-home działająca bez chmur — automatyzacje, integracje i sterowanie wszystko działa w Twojej sieci. Można do niej podłączyć własne urządzenia DIY, np. z ESP32. Po zakupie masz pełną kontrolę i stabilność, bez konieczności subskrypcji czy dodatkowych opłat.

Systemy automatyki domowej pełnią rolę centrali, która komunikuje się z ESP32. Umożliwiają one sterowanie przekaźnikami, tworzenie scenariuszy automatyzacji, integrację z czujnikami oraz udostępnianie zdalnego dostępu.

Wersja podstawowa: prosta strona WWW do sterowania przekaźnikami

Własne oprogramowanie

Choć gotowe firmware oferują ogromne możliwości, w tym poradniku skupimy się na stworzeniu własnego, lekkiego oprogramowania działającego bezpośrednio na ESP32. Pozwoli to lepiej zrozumieć, jak pracują przekaźniki, jak działa komunikacja po Wi-Fi oraz jak przygotować prosty interfejs WWW do zdalnego sterowania.

To najprostsza, najbardziej elastyczna droga, jeśli chcemy mieć pełną kontrolę nad funkcjonalnością urządzenia lub przygotować rozwiązanie dopasowane do konkretnego zastosowania.

Warto jednak wiedzieć, że ESP32 można obsługiwać na różne sposoby. Sterowanie przekaźnikami może odbywać się:

Bluetooth Classic (SPP) – udostępnia wirtualny port COM do połączenia z aplikacją na telefon czy komputer
Bluetooth Low Energy (BLE) - umożliwia sterowanie modułem z poziomu aplikacji mobilnej przez specjalnie zdefiniowane profile GATT. Rozwiązanie jest energooszczędne i działa lokalnie, ale wymaga dedykowanej aplikacji lub systemu wspierającego BLE
Protokoły (MQTT, REST/ Webhook, Webcocket) – pozwalają na komunikację z innymi systemami/aplikacjami poprzez internet.
Własna strona www – ESP32 może samo udostępniać stronę, przez którą będziemy zarządzać przekaźnikami.

I właśnie ta ostatnia opcja będzie punktem wyjścia w tym poradniku. Zbudujemy lokalny panel sterowania — prostą stronę internetową hostowaną na ESP32, która pozwoli włączyć i wyłączyć przekaźniki z poziomu przeglądarki. To najprostszy i najbardziej zrozumiały sposób, aby zacząć pracę z modułem oraz zrozumieć, jak działa sterowanie wykonawcze.

Pierwszy szkic — tworzymy WebServer

Teraz, gdy wiemy już jakie możliwości komunikacji oferuje ESP32, przejdźmy do praktyki. W pierwszym kroku przygotujemy prosty WebServer uruchamiany bezpośrednio na module. Będzie on udostępniał lokalną stronę WWW, dzięki której włączymy i wyłączymy przekaźniki jednym kliknięciem w przeglądarce. To najprostszy sposób na zdalne sterowanie i świetny punkt wyjścia przed późniejszą integracją z siecią domową czy automatyką.

#include <WiFi.h>         // dołączamy bibliotekę odpowiedzialną za obsługę wifi
#include <WebServer.h>    // dołączamy bibliotekę tworzącą serwer http i obsługującą przychodzące połączenia

const char* ssid = "******";    // podaj nazwę sieci z którą chcesz się połączyć
const char* password = "*******************";   // podaj hasło tej sieci

WebServer server(80);   // tworzymy obiekt WebServer który zajmie się obsługą klientów www

const int relay1Pin = 16;   // piny, do których podłączone są przekaźniki
const int relay2Pin = 17;


// przetrzymuejmy stronę html w PROGMEM - string jest pobierany prosto z flash (nie wymaga kopoiowania do RAM)
const char MAIN_page[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head><meta charset="utf-8"><title>ESP32 Relay</title></head>
<body>
<h1>Sterowanie przekaźnikami</h1>
<p><a href="/relay1/on"><button>Relay 1 ON</button></a>
<a href="/relay1/off"><button>Relay 1 OFF</button></a></p>
<p><a href="/relay2/on"><button>Relay 2 ON</button></a>
<a href="/relay2/off"><button>Relay 2 OFF</button></a></p>
</body></html>
)rawliteral";



/*
* Pierwsza z wymaganych funkcji - tutaj dokonujemy konfiguracji
*/
void setup() {

  Serial.begin(115200);   // uruchamiamy połączenie UART z prędkością 115200 bit/s

  pinMode(relay1Pin, OUTPUT); // ustawiamy piny przypisane do przekaźników jako wyjścia
  pinMode(relay2Pin, OUTPUT);

  digitalWrite(relay1Pin, LOW); // ustaw początkowy stan jako wyłączony
  digitalWrite(relay2Pin, LOW);

  WiFi.begin(ssid, password);   // rozpocznamy łączenie się z siecią wifi

  Serial.print("Łączenie z WiFi…");   // wypisujemy pierwszy komunikat na UART

  while (WiFi.status() != WL_CONNECTED) { // pętla, która czeka aż połączymy się z wifi
    delay(500);
    Serial.print(".");
  }

  Serial.println();   // po połączeniu wypisujemy informacje o adresie
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());


  /**
  * konfigurujemy serwer WWW:
  *
  * przypisujemy funkcje, które będą wykonywane po wejściu na daną podstronę (server.on())
  **/
  server.on("/", HTTP_GET, [](){
    server.send_P(200, "text/html", MAIN_page);   // wysyłamy stronę główną - skoro string jest w PROGMEM musimy użyć funkcji send_P żeby go poprawnie odczytać
  });


  server.on("/relay1/on", HTTP_GET, [](){       // jeżeli ktoś wejdzie na podstronę /relay1/on włączamy 1 przekaźnik i przekierowywujemy go na naszą główną stronę
    digitalWrite(relay1Pin, HIGH);
    server.sendHeader("Location", "/");
    server.send(302, "text/plain", "");
  });
  
  
  server.on("/relay1/off", HTTP_GET, [](){
    digitalWrite(relay1Pin, LOW);
    server.sendHeader("Location", "/");
    server.send(302, "text/plain", "");
  });


  server.on("/relay2/on", HTTP_GET, [](){
    digitalWrite(relay2Pin, HIGH);
    server.sendHeader("Location", "/");
    server.send(302, "text/plain", "");
  });


  server.on("/relay2/off", HTTP_GET, [](){
    digitalWrite(relay2Pin, LOW);
    server.sendHeader("Location", "/");
    server.send(302, "text/plain", "");
  });



  server.begin();   // na koniec po poprawnej konfiguracji uruchamiamy serwer 
}




/*
* Po wykonaniu funkcji setup() funkcja loop() uruchamiana jest w nieskończonej pętli
*/
void loop() {

  server.handleClient();    // obsługujemy ewentualnych klientów naszej strony www.

}

Powyższy program tworzy prosty serwer WWW uruchomiony bezpośrednio na ESP32. Po połączeniu z siecią Wi-Fi moduł udostępnia stronę internetową, na której znajdują się cztery przyciski: włącz/wyłącz dla obu przekaźników. Cała logika sterowania opiera się na kilku elementach:

Połączenie z Wi-Fi

W funkcji setup() wywołujemy WiFi.begin() i czekamy, aż ESP32 uzyska połączenie. Po zestawieniu linku wypisujemy adres IP, pod którym dostępna będzie strona sterowania.

Konfiguracja pinów przekaźników

Piny GPIO16 oraz GPIO17 zostają ustawione jako wyjścia, a ich stan początkowy to LOW, czyli przekaźniki są wyłączone po starcie modułu.

Hostowanie strony WWW z poziomu ESP32

Zmienna MAIN_page przechowuje kompletny kod HTML strony — umieszczony został w pamięci flash (PROGMEM), dzięki czemu program działa szybciej i nie zajmuje RAM-u. Pod adresem / serwer wysyła tę stronę przeglądarce.

Obsługa podstron odpowiedzialnych za sterowanie przekaźnikami

Każda akcja (ON/OFF) to osobny adres URL

/relay1/on
/relay1/off
/relay2/on
/relay2/off

Po wejściu na taki adres serwer:

ustawia odpowiedni stan pinu (HIGH lub LOW),
zwraca nagłówek przekierowania 302, aby wrócić automatycznie do strony głównej.

Obsługa klientów w pętli głównej

Funkcja server.handleClient() jest wywoływana w każdej iteracji loop() — to ona odbiera przychodzące żądania i uruchamia odpowiednie handlery.

W ten sposób tworzymy najprostszy możliwy interfejs sieciowy do sterowania przekaźnikami. Moduł ESP32 jednocześnie pełni rolę urządzenia wykonawczego i mini-serwera WWW.

Możliwości rozbudowy programu

Przedstawiony przykład to najprostsza, minimalna forma panelu WWW – czysty HTML bez stylów i dodatkowych funkcji. ESP32 ma jednak ogromny potencjał, a ten projekt może być dobrym punktem wyjścia do rozbudowy o wiele ciekawych elementów. Poniżej kilka praktycznych kierunków, które możesz dodać w kolejnych wersjach programu.

Dodanie stylów CSS i bardziej rozbudowanego interfejsu

Strona może wyglądać znacznie lepiej. Wystarczy:

dodać proste style CSS,
nadać przyciskom kolory i ikony,
ustawić layout w bardziej czytelny sposób,
dodać odświeżanie stanu przekaźników.

Przechowywanie plików w LittleFS

LittleFS — nowocześniejszy i stabilniejszy system plików dla ESP32. Możesz tam umieścić:

pliki HTML,
style CSS,
grafiki,
skrypty JavaScript.

Dzięki temu kod programu staje się czystszy, a całe UI można przygotować jak normalną stronę www

Zapamiętywanie stanu po restarcie

ESP32 może przechowywać dane w:

EEPROM (emulowanym),
NVS (Non-Volatile Storage),
plikach LittleFS.

Program może zapisywać dane, dzięki czemu po zaniku zasilania urządzenie może np. pamiętać ostatni stan przekaźników lub wczytać konfigurację Wi-Fi.

WebSockety lub JavaScript – sterowanie bez przeładowania strony

W aktualnym przykładzie każda akcja przeładowuje stronę (HTTP + redirect). Dla płynnej obsługi można wykorzystać WebSockety lub JavaScript (AJAX lub fetch API).

AsyncWebServer – lepszy serwer dla bardziej rozbudowanych projektów

Klasyczny WebServer działa synchronicznie — gdy obsługuje klienta, nic innego nie może się dziać.

W bardziej złożonych projektach warto użyć ESPAsyncWebServer, który daje m.in. szybszą obsługę wielu klientów i brak blokowania loop(). Idealne, jeśli ESP32 ma wykonywać także inne zadania (czujniki, przekaźniki, logika).

Tryb Access Point (AP), gdy Wi-Fi nie jest dostępne

Jeśli ESP32 nie znajdzie wskazanej sieci Wi-Fi, można je przełączyć w tryb Access Point

Urządzenie tworzy własną sieć, np.:

SSID: ESP32-Relay
IP: 192.168.4.1

To świetne rozwiązanie:

na pierwszą konfigurację,
do pracy w terenie,
dla projektów mobilnych.

Funkcje automatyzacji i harmonogramy

Moduł może samodzielnie:

włączać przekaźnik o danej godzinie,
pracować w cyklach,
sterować na podstawie czujników (np. temperatury),
reagować na wejścia cyfrowe.

W połączeniu z RTC lub NTP można tworzyć zaawansowane automatyzacje bez udziału zewnętrznego systemu.

Wystawienie sterownika na świat

We wcześniejszym przykładzie sterujemy przekaźnikami korzystając z lokalnej sieci Wi-Fi. To działa w domu, ale wielu użytkowników chce mieć możliwość włączania urządzenia z dowolnego miejsca przez internet. Istnieje na to kilka sposobów: od bardzo prostych, poprzez rozwiązania Smart Home, aż po profesjonalne systemy oparte na chmurze lub VPN.

Niezależnie od systemu, którego użyjemy do sterowania ESP32 problem zawsze sprowadza się do jednego:

Jak „dostać się” do naszego urządzenia w sieci domowej, będąc poza nią?

Jest to bardzo złożone zagadnienie, które ma wiele różnych rozwiązań. Każde z nich ma swoje słabe i mocne strony, a wspólnym mianownikiem jest bezpieczeństwo sieciowe.

Jednakże jest to bardzo obszerny temat i nie będzie tutaj poruszany. Nie mniej wspominam o nim, ponieważ każda interakcja z internetem niesie ze sobą potencjalne ryzyko! Każdy, nawet najlepszy i najdroższy system jest tak silny jak jego najsłabsze ogniwo.

Poniżej przedstawiam wybrane rozwiązania sieciowe umożliwiające sterowanie ESP32 z poziomu internetu. Bardzo ciężko wskazać najlepsze rozwiązanie, ponieważ wybór zależy od wielu czynników i jest bezpośrednio związany z konkretnym projektem.

Należy pamiętać, że w cały system wchodzi nie tylko nasz sterownik na ESP32 i nasze łącze internetowe ale też aplikacja i sprzęt, z którego mamy zamiar sterować urządzeniem.

Stałe publiczne IP

Jeśli Twój operator udostępnia publiczny adres IP (nie CGNAT), możesz komunikować się z ESP32 bezpośrednio z internetu.

Przekierowanie portów (Port Forwarding) Router kieruje wybrany port z Internetu na adres ESP32 w sieci domowej. To najprostszy sposób na zdalny dostęp, ale oznacza wystawienie urządzenia na świat.
Dostęp do domu VPN np. WireGuard Tworzysz prywatną sieć, do której możesz dołączyć z dowolnego miejsca. Po połączeniu zachowujesz się tak, jakbyś był w domu, a ESP32 jest widoczne jak urządzenie w tej samej sieci lokalnej.
Gdy nie mamy publicznego IP To najczęstsza sytuacja. Operator stosuje CGNAT, więc nie da się wykonać połączenia do Twojej sieci. Rozwiązaniem jest zainicjowanie połączenia z domu na zewnątrz i wykorzystanie zewnętrznego serwera lub tunelu.

Gdy nie mamy publicznego IP

Dynamic DNS (DDNS)

DDNS nadaje Twojemu adresowi domenę, ale działa tylko wtedy, gdy masz publiczne IP. Idealne przy usłudze Neostrada Przy CGNAT ta metoda w praktyce niczego nie umożliwia.

Tunele internetowe (reverse tunnels)

Lokalna maszyna utrzymuje połączenie z usługą tunelową, a ta udostępnia Twój serwer w Internecie. Dzięki temu dostęp zdalny działa nawet wtedy, gdy operator blokuje połączenia przychodzące. Wymaga jednak uruchomienia własnego serwera lokalnego np. na Raspberry Pi. Popularne rozwiązania działające i stabilne: Cloudflare Tunnel, Tailscale Funnel

Serwer VPS

VPS to usługa, która udostępnia Ci Twój własny wirtualny komputer (serwer) w chmurze, do którego możesz się zdalnie logować i uruchamiać na nim różne programy lub usługi. To niezależny i elastyczny sposób, dający praktycznie nieograniczone możliwości. Wadą jest abonament oraz konieczność konfigurowania usług serwerowych a także dbanie o bezpieczeństwo.

Serwery pośredniczące dla WebSocket / REST

ESP32 łączy się aktywnie do zewnętrznego serwera (np. WebSocket), a aplikacja w telefonie łączy się do tego samego serwera. Dane są przekazywane przez backend. Darmowe platformy: render.com, glitch.com, railway.app, vercel.

Bazy danych / backendy w chmurze

ESP32 wysyła i pobiera dane z usług takich jak Firebase czy Supabase. Telefon lub aplikacja także komunikuje się z chmurą, dzięki czemu nie ma potrzeby utrzymywania połączenia z domem. Firebase, Firestore, Supabase, Appwrite, Google App Script

Brokery MQTT

Urządzenie nawiązuje połączenie z brokerem MQTT w Internecie i publikuję wiadomości, które później możesz odbierać z dowolnego miejsca. Sterowanie odbywa się poprzez przesyłanie krótkich komunikatów przez centralny serwer.

Platformy IoT

Gotowe platformy zapewniają komunikację, wizualizację danych i zdalne sterowanie bez konieczności budowania własnego backendu. ESP32 komunikuje się z ich serwerami, a użytkownik korzysta z aplikacji lub panelu online.

Ubidots / Ubidots STEM
Losant
TagoIO
Adafruit IO / io.adafruit.com
Blynk / Blynk IoT Cloud
ThingsBoard
Thinger.io
Datacake
Kaa IoT / Kaa
Kuzzle IoT
Arduino IoT Cloud / Arduino Cloud
Thingspeak / ThingSpeak
Cayenne IoT (myDevices)
Passenger Cloud
IOStash / Iostash
DevicePilot
THiNX Cloud
IoT MQTT Panel Cloud
IoT MQTT Panel (Android)
ESP RainMaker
Sinric Pro

Rozwiązania ekosystemów smartchome

Platformy smart-home umożliwiają dostęp do urządzeń z dowolnego miejsca dzięki własnej chmurze. ESP32 lub urządzenie pośrednie łączy się z ich serwerami, a użytkownik steruje wszystkim przez aplikację lub panel

Supla cloud
myopenHAB
Home Assistant Cloud (płatna)

Nietypowe rozwiązania:

Metody, które nie tworzą typowego kanału komunikacyjnego, ale pozwalają wysyłać lub odbierać dane od ESP32 w prosty sposób – przykładowo:

Mail ESP32 może wysyłać e-maile jako powiadomienia lub odbierać komendy na podstawie skrzynki pocztowej — sprawdza się jako bardzo prosty system alarmowy lub notyfikacyjny.
Telegram Bot Telegrama może służyć do wysyłania poleceń i odbierania danych z ESP32. Urządzenie komunikuje się z API Telegrama, a użytkownik steruje nim z aplikacji mobilnej.
Mastodon ESP32 może publikować statusy lub odbierać komendy za pomocą API Mastodona. To ciekawa alternatywa do budowania prostego kanału komunikacji opartego na publicznych lub prywatnych serwerach federacyjnych.

To tylko niektóre sposoby na rozwiązanie problemu sterowania ESP32 spoza domu przez internet. W dalszej części przedstawimy bodajże najszybszy sposób: sterowanie za pomocą usługi Telegram.

Przykład sterowania przez Telegram

Telegram to nowoczesny komunikator internetowy, podobny do Messengera, WhatsAppa czy Signal, który pozwala na rozmowy tekstowe, głosowe oraz tworzenie grup i kanałów. To, co wyróżnia Telegram spośród innych popularnych aplikacji, to wbudowana platforma dla tzw. botów – specjalnych kont sterowanych przez programy, a nie przez ludzi.

Telegram pełni rolę bezpiecznego i darmowego serwera pośredniczącego, który gwarantuje dostęp do ESP32 z dowolnego miejsca na świecie. Użytkownik wysyła polecenia w zwykłym czacie, a urządzenie z ESP32 odpowiada tak, jakby prowadziło z nami rozmowę. Aplikacja działa na telefonach z Androidem, iOS, komputerach PC, Linux oraz w przeglądarce, dzięki czemu sterowanie jest zawsze pod ręką. To sprawia, że Telegram jest jedną z najprostszych i najłatwiejszych do wdrożenia metod zdalnego sterowania modułami ESP32.

Uruchomienie zdalnego sterowania przez Telegram wymaga następujących kroków:

Instalacja aplikacji Telegram na telefonie
Utworzenie bota dla ESP32
Dodanie UniversalTelegramBot do naszego programu na ESP32

Instalacja i konfiguracja Telegrama

Telegram jest dostępny na praktycznie wszystkie platformy: Android, iOS, Windows, Linux oraz w wersji przeglądarkowej. Podstawową instalacją jest instalacja na telefonie gdzie rejestrujemy konto za pomocą numeru telefonu. Następnie możemy zainstalować klientów na komputerze.

Instalacja na telefonie (Android / iOS)

1. Otwórz Google Play lub App Store
2. Wyszukaj: Telegram
3. Zainstaluj aplikację
4. Uruchom i zaloguj/zarejestruj się numerem telefonu
5. Potwierdź kod SMS lub kod wysłany na innym urządzeniu

Tworzenie własnego bota w Telegramie

Bot to specjalne konto, które będzie sterowane przez ESP32. Dzięki niemu możesz wysyłać komendy i odbierać informacje. Użyjemy do tego konta BotFather. Należy używać tylko zweryfikowane konto.

W Telegramie w polu wyszukiwania wpisz: BotFather

Otwórz zweryfikowany profil (niebieska ikonka ✔)
Napisz komendę: /newbot

BotFather poprosi o dwie rzeczy:

Nazwa wyświetlana (np. „ESP32 Controller”)
Username, który musi kończyć się na bot np. esp32_relay_bot
Jeśli nazwa zajęta — spróbuj inną

Po poprawnym utworzeniu bot wyświetli ważny komunikat zaczynający się od:

Done! Congratulations on your new bot. You will find it at…

Kolejne czynności to:

Token w formacie. 1234567890:ABCDEFHIJKLMNOPRSTUWXYZ – zapisz go! Będzie potrzebny do komunikacji ESP32
Kliknij link w wiadomości: np. t.me/esp32_relay_bot
Naciśnij Start i wyślij wiadomość np.: /test – to aktywuje API i pozwoli komunikować się z poziomu ESP32.
Testowanie w przeglądarce wpisz: https://api.telegram.org/botTOKEN/getUpdates gdzie TOKEN zastąp otrzymanym tokenem. W naszym przykładzie link wyglądałby: https://api.telegram.org/bot1234567890:ABCDEFHIJKLMNOPRSTUWXYZ/getUpdates
Wynik będzie w formacie JSON. Można przesłać kilka wiadomości z telefonu aby sprawdzić jak działa komunikacja. Za każdym razem trzeba odświeżyć przeglądarkę.

Element	Znaczenie
update_id	unikalny numer zdarzenia, pozwala pominąć stare wiadomości
message.message_id	numer wiadomości w czacie
from.id	ID użytkownika, który wysłał wiadomość
chat.id	ID rozmowy — to właśnie CHAT_ID
text	treść wiadomości (komenda)
entities	informacja, że to komenda (opcjonalne)

Program na ESP32

Poniżej przedstawię przykładowy program, który komunikuje się przez Telegram za pomocą biblioteki UniversalTelegramBot.

#include <WiFi.h>                 // Biblioteka do obsługi WiFi w ESP32
#include <WiFiClientSecure.h>     // Umożliwia połączenia HTTPS (szyfrowane)
#include <UniversalTelegramBot.h> // Biblioteka do obsługi bota Telegram
#include <ArduinoJson.h>          // Używana wewnętrznie do przetwarzania danych JSON

// -------------------------------------------
//  USTAWIENIA SIECI WiFi ORAZ TELEGRAM BOTA
// -------------------------------------------
const char* ssid = "TwojeWiFi";         // Nazwa sieci WiFi
const char* password = "TwojeHaslo";    // Hasło do sieci WiFi

// Token bota — otrzymujesz go od BotFather po utworzeniu bota.
// To jest "klucz dostępu", dzięki któremu ESP32 może logować się do Telegrama.
String BOTtoken = "TU_WKLEJ_TOKEN";

// ID czatu — numer użytkownika lub grupy, do której bot ma wysyłać odpowiedzi.
// Znajdziesz go pod adresem: https://api.telegram.org/botTOKEN/getUpdates
String CHAT_ID  = "TU_WKLEJ_CHAT_ID";

// Obiekt klienta HTTPS (szyfrowane połączenie z Telegramem)
WiFiClientSecure client;

// Tworzymy obiekt bota — przekazujemy token i klienta HTTPS
UniversalTelegramBot bot(BOTtoken, client);

// -------------------------------------------
//  PINY, DO KTÓRYCH PODŁĄCZONE SĄ PRZEKAŹNIKI
// -------------------------------------------
const int RELAY1 = 16;   // Pin przekaźnika 1
const int RELAY2 = 17;   // Pin przekaźnika 2


void setup() {
  Serial.begin(115200); // Uruchomienie portu szeregowego do debugowania

  // Ustawienie pinów przekaźników jako wyjścia
  pinMode(RELAY1, OUTPUT);
  pinMode(RELAY2, OUTPUT);

  // Ustawiamy stan początkowy przekaźników (wyłączone)
  digitalWrite(RELAY1, LOW);
  digitalWrite(RELAY2, LOW);

  // -------------------------------------
  //  ŁĄCZENIE Z SIECIĄ WiFi
  // -------------------------------------
  Serial.print("Łączenie z WiFi...");
  WiFi.begin(ssid, password);  // Rozpoczęcie łączenia z WiFi

  // Czekamy aż ESP32 uzyska połączenie
  while (WiFi.status() != WL_CONNECTED) {
    delay(300);
    Serial.print(".");
  }

  Serial.println("\nPołączono z WiFi!");

  // Telegram używa HTTPS — tu wyłączamy sprawdzanie certyfikatów
  // (ułatwia działanie, nie trzeba wgrywać certyfikatów)
  client.setInsecure();
}

// -------------------------------------------
//  OBSŁUGA NOWYCH WIADOMOŚCI Z TELEGRAMA
// -------------------------------------------
//
// Funkcja handleNewMessages() uruchamia się wtedy,
// gdy pojawią się nowe wiadomości od użytkownika.
//
void handleNewMessages(int numNewMessages) {
  for (int i = 0; i < numNewMessages; i++) {

    // Pobranie ID użytkownika oraz tekstu wiadomości
    String chat_id = bot.messages[i].chat_id;
    String text    = bot.messages[i].text;

    Serial.println("Otrzymano komendę: " + text);

    // Sprawdzanie, czy ten użytkownik ma dostęp
    // (zabezpieczenie przed obcymi osobami)
    if (chat_id != CHAT_ID) {
      bot.sendMessage(chat_id, "Brak autoryzacji!", "");
      continue; // pomiń dalsze przetwarzanie
    }

    // -------------------------------------
    //  PRZEKAŹNIK 1 (komendy /on1 i /off1)
    // -------------------------------------
    if (text == "/on1") {
      digitalWrite(RELAY1, HIGH);                       // Włącz przekaznik
      bot.sendMessage(CHAT_ID, "Przekaźnik 1: WŁĄCZONY", "");
    }

    if (text == "/off1") {
      digitalWrite(RELAY1, LOW);                        // Wyłącz przekaźnik
      bot.sendMessage(CHAT_ID, "Przekaźnik 1: WYŁĄCZONY", "");
    }

    // -------------------------------------
    //  PRZEKAŹNIK 2 (komendy /on2 i /off2)
    // -------------------------------------
    if (text == "/on2") {
      digitalWrite(RELAY2, HIGH);
      bot.sendMessage(CHAT_ID, "Przekaźnik 2: WŁĄCZONY", "");
    }

    if (text == "/off2") {
      digitalWrite(RELAY2, LOW);
      bot.sendMessage(CHAT_ID, "Przekaźnik 2: WYŁĄCZONY", "");
    }

    // -------------------------------------
    //  KOMENDA /status — wysyła stany przekaźników
    // -------------------------------------
    if (text == "/status") {

      // Tworzymy tekst, który opiszemy użytkownikowi
      String msg = "";
      msg += "Przekaźnik 1: ";
      msg += (digitalRead(RELAY1) ? "ON" : "OFF");
      msg += "\n";

      msg += "Przekaźnik 2: ";
      msg += (digitalRead(RELAY2) ? "ON" : "OFF");

      bot.sendMessage(CHAT_ID, msg, ""); // wysłanie wiadomości
    }
  }
}

// -------------------------------------------
//  PĘTLA GŁÓWNA PROGRAMU
// -------------------------------------------
//
// Funkcja loop() działa w kółko — sprawdzamy tu,
// czy przyszły nowe wiadomości od użytkownika.
//
void loop() {

  // Pobranie nowych wiadomości (jeśli są)
  int numNewMessages = bot.getUpdates(bot.last_message_received + 1);

  // Jeśli są jakieś wiadomości → obsłuż je
  if (numNewMessages) {
    handleNewMessages(numNewMessages);
  }

  delay(500); // mała przerwa, aby nie przeciążać API Telegrama
}

Co robi program:

Łączy się z WiFi
Loguje się do Telegrama jako bot
Sprawdza co 0.5 sekundy, czy użytkownik napisał nową wiadomość
Rozpoznaje komendy:
1. /on1, /off1
2. /on2, /off2
3. /status
Steruje przekaźnikami na pinach 16 i 17
Odpowiada użytkownikowi w Telegramie

Zakończenie

Opisany projekt to szybki i praktyczny sposób na rozpoczęcie pracy z modułem ESP32 i zdalnym sterowaniem przekaźnikami. Wykorzystanie Telegrama pozwala stworzyć działający system dosłownie w kilka minut, bez konieczności konfiguracji routera, tuneli czy serwerów pośredniczących. Mimo swojej prostoty, rozwiązanie to jest bardzo elastyczne — bot może obsługiwać dodatkowe funkcje, przyciski, czujniki, harmonogramy czy integracje z systemami automatyki domowej.

Warto pamiętać, że przedstawione przykłady są jedynie wprowadzeniem do znacznie szerszych możliwości ESP32. Moduł ten może pracować jako lokalny serwer WWW, klient MQTT, urządzenie dla Home Assistant, element większej instalacji IoT albo zdalny sterownik pracujący w chmurze. Każdy z tych kierunków można rozwijać w zależności od potrzeb — zarówno domowych, jak i bardziej profesjonalnych.

Mamy nadzieję, że ten przewodnik pomoże Ci postawić pierwsze kroki i zainspiruje do budowania własnych projektów. Wszystkie wykorzystane w nim moduły i akcesoria znajdziesz oczywiście w naszej ofercie — chętnie pomożemy dobrać odpowiednie elementy lub doradzić przy kolejnych etapach pracy.

Powodzenia w dalszych eksperymentach!