czwartek, 20 listopada 2025

Dwukierunkowa komunikacja WebSocket między dwoma ESP32-C3 — prostsze niż myślisz!

W zasadzie powinienem przeprosić za ten mój dzisiejszy wpis. Dlaczego? Bo to nie mój wpis tylko wygenerowany przez AI. Nie ma w nim nic odkrywczego i nie zawiera żadnych osobistych doświadczeń i wniosków choć trzeba przyznać wszystko jest prawdziwe i zgrabnie podane. 

Ale to tylko taka próba co potrafi AI AD 2025. Za rok powtórzę dokładnie ten sam test by zobaczyć czy i jak rozwija się ta "inteligencja". Dla porównania dwa teksty wygenerowane przez chatgpt i GROKa.


[zadanie dla chatgpt:

napisz mi ładnego bloga o połączeniu dwóch ESP32 C3 websocket w stylu

 https://100-x-arduino.blogspot.com/ ]

W dzisiejszym wpisie pokażę, jak w bardzo prosty sposób połączyć dwa moduły ESP32-C3 tak, aby mogły rozmawiać ze sobą w obie strony za pomocą WebSocketów.
Ten typ połączenia daje ogromne możliwości — błyskawiczną wymianę danych, stabilność, możliwość przesyłania tekstów, liczb, komend, a nawet struktur JSON.

A co najlepsze: działa to po zwykłym Wi-Fi, bez żadnych dodatkowych modułów.

Co będzie potrzebne

  • dwa moduły ESP32-C3

  • Arduino IDE z dodaną płytką ESP32

  • Wi-Fi w zasięgu

  • dwie otwarte karty Serial Monitora, aby obserwować oba ESP jednocześnie

Dlaczego WebSocket, a nie zwykły HTTP?

HTTP jest jak rozmowa listowna — wysyłasz, czekasz, odbierasz.
WebSocket to już rozmowa telefoniczna — połączenie trwa non stop i obie strony mogą mówić, kiedy chcą.

Dzięki temu:

  • ESP32-C3 A może wysłać wiadomość w dowolnym momencie

  • ESP32-C3 B może odpowiedzieć natychmiast

  • czas reakcji to zwykle ułamek milisekundy

  • połączenie jest stałe i bardzo stabilne

Doskonałe do robotów, sterowania, sensorów, telemetrycznych projektów, paneli dotykowych, a nawet prostych gier.

Schemat działania projektu

Połączenie zorganizujemy w najprostszej możliwej formie:

  1. ESP32-C3 nr 1 → pełni rolę WebSocket Servera

  2. ESP32-C3 nr 2 → łączy się jako WebSocket Client

Oba moduły wysyłają sobie naprzemiennie wiadomości typu String.



Kod dla ESP32-C3 — WebSocket Server

[zadanie dla AI

podaj kod pokolorowany ]

#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>

const char* ssid = "TwojeSSID";
const char* password = "TwojeHASLO";

AsyncWebServer server(80);
AsyncWebSocket ws("/ws");

void onWsEvent(
    AsyncWebSocket * server,
    AsyncWebSocketClient * client,
    AwsEventType type,
    void * arg,
    uint8_t *data,
    size_t len) {

  if (type == WS_EVT_CONNECT) {
    Serial.println("Klient połączony");
    client->text("Witaj kliencie!");
  }
  else if (type == WS_EVT_DATA) {
    String msg = "";
    for (size_t i = 0; i < len; i++)
      msg += (char)data[i];

    Serial.print("Odebrano od klienta: ");
    Serial.println(msg);

    client->text("Serwer odebrał: " + msg);
  }
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED)
    delay(500);

  Serial.println(WiFi.localIP());

  ws.onEvent(onWsEvent);
  server.addHandler(&ws);
  server.begin();
}

void loop() {
  static unsigned long last = 0;
  if (millis() - last > 5000) {
    last = millis();
    ws.textAll("Ping z serwera");
  }
}

Kod dla ESP32-C3 — WebSocket Client

[to zostawiłem w pierwotnym oryginale ]

Tutaj moduł łączy się do serwera po jego adresie IP.

#include <WiFi.h>
#include <WebSocketsClient.h>

const char* ssid = "TwojeSSID";
const char* password = "TwojeHASLO";

#define SERVER_IP "192.168.1.50"   // wpisz IP serwera
#define SERVER_PORT 80

WebSocketsClient webSocket;

void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
  switch(type) {
    case WStype_CONNECTED:
      Serial.println("Połączono z serwerem!");
      webSocket.sendTXT("Pozdrowienia od klienta!");
      break;

    case WStype_TEXT:
      Serial.printf("Odebrano z serwera: %s\n", payload);
      break;
  }
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) delay(500);

  Serial.println(WiFi.localIP());

  webSocket.begin(SERVER_IP, SERVER_PORT, "/ws");
  webSocket.onEvent(webSocketEvent);
  webSocket.setReconnectInterval(2000);
}

void loop() {
  webSocket.loop();

  static unsigned long last = 0;
  if (millis() - last > 3000) {
    last = millis();
    webSocket.sendTXT("Ping od klienta");
  }
}

Pierwsze uruchomienie

  1. Wgraj serwer na pierwszy ESP32-C3.

  2. Otwórz Serial Monitor i sprawdź wyświetlone IP.

  3. Wpisz to IP w kodzie klienta (SERVER_IP).

  4. Wgraj klienta na drugi ESP32-C3.

  5. Otwórz dwa okna Serial Monitora – zobaczysz „rozmowę” urządzeń.

Efekt działania

Po uruchomieniu urządzenia wymieniają komunikaty automatycznie:

  • serwer wysyła „Ping z serwera”

  • klient wysyła „Ping od klienta”

  • oba zwracają komunikaty i odpowiadają

To wygląda jak mały czat pomiędzy dwoma mikrokontrolerami.

---------------------------------------------------------------------------

----------------------------------------------------------------------------

----------------------------------------------------------------------------

[zadanie dla grok'a:

napisz mi ładnego bloga o połączeniu dwóch ESP32 C3 websocket w stylu

 https://100-x-arduino.blogspot.com/ ]

Oto gotowy, ładny i przyjemny wpis blogowy w stylu klasycznego polskiego bloga Arduino (z nutką nostalgii, dużą dawką praktyki i szczyptą humoru), dokładnie taki, jaki mógłby się pojawić na https://100-x-arduino.blogspot.com/

Tytuł: Dwa ESP32-C3 rozmawiają przez WebSocket – czyli jak zrobić bezprzewodowy „czat” w 20 minut

Cześć! ☕ Dzisiaj znowu siedzimy w piwnicy z lutownicą i kawą. Tym razem bierzemy dwa małe, ale wściekle fajne moduły ESP32-C3 (te z RISC-V i wbudowanym Wi-Fi/Bluetooth) i łączymy je ze sobą przez WebSocket. Po co? Bo możemy! A przy okazji wychodzi nam superszybka, dwukierunkowa komunikacja bez żadnego serwera pośredniczącego (no, prawie).

Po co to komu?

  • Sterowanie jednym ESP drugim (np. robot + pilot)
  • Synchronizacja danych między dwoma urządzeniami w sieci lokalnej
  • Prosty „czat” do debugowania (wysyłasz z jednego – widzisz na drugim)
  • Baza do bardziej zaawansowanych projektów typu mesh czy multiplayer w grach na ESP

Co będzie potrzebne?

  • 2 × ESP32-C3 (ja używałem popularnych „mini” i „super mini”)
  • Arduino IDE 2.x + płytka ESP32 by Espressif Systems
  • Trochę cierpliwości i działające Wi-Fi

Krok 1 – Biblioteka Używamy genialnej biblioteki WebSockets autorstwa Gil Maimon (Links2004). W Arduino IDE: Szkic → Dołącz bibliotekę → Zarządzaj bibliotekami… → szukamy „WebSockets by Links2004” → instalujemy wersję 2.3.7 lub nowszą.

Krok 2 – Kod serwera (pierwszy ESP32-C3)

C++
#include <WiFi.h>
#include <WebSocketsServer.h>

const char* ssid = "TwojaSiec";
const char* password = "TwojeHaslo";

WebSocketsServer webSocket = WebSocketsServer(81);  // port 81, bo 80 czasem zajęty

void onWebSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
  switch(type) {
    case WStype_DISCONNECTED:
      Serial.printf("Klient %u rozłączony\n", num);
      break;
    case WStype_CONNECTED:
      Serial.printf("Klient %u połączony!\n", num);
      webSocket.sendTXT(num, "Witaj po drugiej stronie! 🌊");
      break;
    case WStype_TEXT:
      String tekst = String((char*)payload);
      Serial.printf("Odebrano od %u: %s\n", num, tekst.c_str());
      
      // odbijamy wiadomość do wszystkich klientów
      webSocket.broadcastTXT(tekst);
      break;
  }
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("IP serwera: ");
  Serial.println(WiFi.localIP());

  webSocket.begin();
  webSocket.onEvent(onWebSocketEvent);
}

void loop() {
  webSocket.loop();
  
  // co 5 sekund wysyłamy coś dla zabawy
  static unsigned long last = 0;
  if (millis() - last > 5000) {
    last = millis();
    String msg = "Serwer żyje! Czas: " + String(millis()/1000) + "s";
    webSocket.broadcastTXT(msg);
  }
}

Krok 3 – Kod klienta (drugi ESP32-C3)

C++
#include <WiFi.h>
#include <WebSocketsClient.h>

const char* ssid = "TwojaSiec";
const char* password = "TwojeHaslo";
const char* serverIP = "192.168.1.100";  // <-- TU WPISZ IP SERWERA!
const uint16_t serverPort = 81;

WebSocketsClient webSocket;

void onWebSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
  switch(type) {
    case WStype_DISCONNECTED:
      Serial.println("Rozłączony z serwerem :(");
      break;
    case WStype_CONNECTED:
      Serial.println("Połączony z serwerem!");
      break;
    case WStype_TEXT:
      Serial.printf("Odebrano: %s\n", payload);
      // Migamy diodą dla frajdy
      digitalWrite(8, !digitalRead(8));
      break;
  }
}

void setup() {
  pinMode(8, OUTPUT); // dioda na większości płytek C3
  Serial.begin(115200);
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nPołączony z Wi-Fi");

  webSocket.begin(serverIP, serverPort, "/");
  webSocket.onEvent(onWebSocketEvent);
  webSocket.setReconnectInterval(5000); // próbuj ponownie co 5s
}

void loop() {
  webSocket.loop();

  // wysyłamy coś co 3 sekundy
  static unsigned long last = 0;
  if (millis() - last > 3000) {
    last = millis();
    String msg = "Cześć serwer! Tu klient nr " + String(random(1,100));
    webSocket.sendTXT(msg);
  }
}

Krok 4 – Działanie!

  1. Wgrywasz kod serwera na pierwszą płytkę
  2. Odczytujesz jej IP z monitora szeregowego
  3. W kodzie klienta wpisujesz to IP
  4. Wgrywasz kod klienta na drugą płytkę
  5. Otwierasz dwa monitory szeregowe i… magia!

Na serwerze widzisz: Klient 0 połączony! Odebrano od 0: Cześć serwer! Tu klient nr 47

A na kliencie: Odebrano: Serwer żyje! Czas: 42s Odebrano: Cześć serwer! Tu klient nr 47 (odbita wiadomość!)

Bonusik – jak zrobić to jeszcze ładniej

  • Zamiast broadcast możesz wysyłać konkretnemu num (webSocket.sendTXT(num, tekst))
  • Dodaj JSON – super łatwo parsować dane (biblioteka ArduinoJson)
  • Zrób prosty panel webowy i podłącz przeglądarkę jako trzeciego klienta – działa identycznie!

Podsumowanie WebSockety na ESP32-C3 to jak espresso – małe, mocne i działa natychmiast. Zero MQTT, zero brokerów, zero problemów. Idealne kiedy chcesz szybkiej, lokalnej komunikacji między dwoma (lub więcej) urządzeniami.

A teraz idź, wgrywaj i baw się dobrze! Jak coś nie działa – pisz w komentarzu, razem ogarniemy.

73 i do następnego!

Ale o tym zadecyduje nasz ulubiony ciąg dalszy.


[nie sądzę by tak to chciał  kontynuować nasz ulubiony ciąg dalszy  ale bez wątpienia GROK zrobił to ciekawiej i bardziej w "moim stylu" i to bez pytania

chatgpt coś namieszał z kodem serwera u groka wygląda to jasno i oczywiście]


Autor:
Etykiety: , ,

Brak komentarzy:

Prześlij komentarz

Subskrybuj: Komentarze do posta (Atom)