ESP8266 odbiór Server-Sent Events (SSE) jako klient – implementacja, kod, porady

Pytanie

Esp8266 client, odbiór danych od serwera przez SSE

Odpowiedź Sztucznej Inteligencji

Bezpośrednia odpowiedź na pytanie

• ESP8266 może pełnić rolę klienta Server-Sent Events, utrzymując długotrwałe połączenie HTTP i odbierając dane w formacie text/event-stream.
• Najprostsza implementacja wykorzystuje WiFiClient (lub WiFiClientSecure dla HTTPS) i własne parsowanie ramek SSE (data: …\n\n).
• Kluczowe punkty: poprawne nagłówki (Accept: text/event-stream, Connection: keep-alive), nieblokujące odczyty, automatyczne ponowne łączenie i opcjonalne wykorzystanie pól id:/retry: do wznawiania strumienia.

Szczegółowa analiza problemu

1. Protokół SSE w pigułce

• Transport: jednokierunkowy strumień HTTP/1.1 utrzymywany przez serwer.
• Format ramki (przykład):

  id: 157
  event: alarm
  data: {"level": "HIGH", "ts": 1680042000}

• Separatorem wiadomości są dwa znaki nowej linii (\n\n).
• id: umożliwia wznowienie strumienia (Last-Event-ID w nagłówku żądania).
• retry: podpowiada klientowi, po ilu ms ma próbować ponownie po zerwaniu.

2. Minimalny kod klienta (HTTP, nieszyfrowane)

#include <ESP8266WiFi.h>
const char* ssid     = "YOUR_SSID";
const char* password = "YOUR_PASS";
const char* host     = "192.168.1.100";
const uint16_t port  = 5000;
const char* path     = "/events";
WiFiClient client;
String     lastEventID = "";
uint32_t   lastReconnect   = 0;
const uint32_t reconnectMs = 5000;
void connectSSE() {
  if (!client.connect(host, port)) return;
  client.printf("GET %s HTTP/1.1\r\nHost: %s\r\n"
                "Accept: text/event-stream\r\n"
                "Connection: keep-alive\r\n"
                "%s\r\n",
                path, host,
                lastEventID.length() ? ("Last-Event-ID: " + lastEventID + "\r\n").c_str() : "\r\n");
}
void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(250);
  connectSSE();
}
void loop() {
  // automatyczne ponowne łączenie
  if (!client.connected() && millis() - lastReconnect > reconnectMs) {
    client.stop();
    connectSSE();
    lastReconnect = millis();
    return;
  }
  static String buffer;                 // gromadzi linie
  while (client.connected() && client.available()) {
    String line = client.readStringUntil('\n');      // wczytaj linię
    if (line.length() && line[0] == '\r') line = ""; // CRLF -> usuń CR
    if (line == "") {                                // koniec ramki
      if (buffer.length()) {
        Serial.println("[EVENT]\n" + buffer);
        buffer = "";
      }
      continue;
    }
    if (line.startsWith("id:"))       lastEventID = line.substring(3);
    else if (line.startsWith("data:")) buffer += line.substring(5) + "\n";
    // opcjonalnie: obsługa event:, retry:
  }
}

• Kod jest nieblokujący; łączy się ponownie po utracie linku.
• Przechowujemy lastEventID, by przy ponownym łączeniu dosłać brakujące zdarzenia.

3. Wersja HTTPS

#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
WiFiClientSecure client;
// client.setFingerprint("AB:CD:…");   // lub client.setInsecure() do testów

TLS zwiększa zużycie RAM (~15 kB) i wymaga wydłużonych timeoutów.

4. Obsługa wieloliniowych „data:”

Specyfikacja dopuszcza kilka linii data: wewnątrz jednej wiadomości. Należy je scalać separatorami \n, co w przykładzie realizuje zmienna buffer.

5. Zarządzanie pamięcią

• String jest wygodny, ale fragmentuje heap.
• W aplikacjach 24/7 zaleca się statyczny bufor:

  char buf[256];
  size_t idx = 0;
  int c;
  while ((c = client.read()) >= 0 && idx < sizeof(buf)-1) { … }

• Po zdekodowaniu JSON użyj StaticJsonDocument.

6. Zaawansowane tematy

• Exponential back-off + pole retry: serwera => adaptacyjne ponawianie.
• Watchdog (WDT): unikać długich, blokujących odczytów; stosować yield().
• Współpraca z FreeRTOS (na ESP32) – własne taski i kolejki.

Aktualne informacje i trendy

• Arduino-ESP8266 (core 3.1.x, 2023) wprowadza setTimeout() dla WiFiClient, co ułatwia kontrolę blokujących operacji.
• W repozytorium GitHub bblanchon/ArduinoSSEClient (2024-03) pojawiła się pierwsza, lekka biblioteka obsługująca SSE z automatycznym parsowaniem event/data. Wciąż eksperymentalna.
• Dla ESP32 popularna staje się biblioteka AsyncEventSource (część ESPAsyncWebServer) – na razie dostępna tylko dla serwera; prace nad klientem są w toku.
• Przejście na HTTP/2 (który natywnie obsługuje push) jest rozważane w nowych SoC (ESP32-S3), lecz wymaga pokaźnej pamięci.

Wspierające wyjaśnienia i detale

• Analogicznie do czytania pliku z dysku: traktuj strumień jako niekończący się tekst, gdzie „rekordem” jest pusty wiersz.
• Jeśli serwer wysyła JSON, możesz bezpośrednio przekazać go do deserializeJson():

  DynamicJsonDocument doc(256);
  deserializeJson(doc, buffer);
  float temp = doc["temp"];

• Mechanizm „heartbeat” (seryjne wysyłanie :\n) zapobiega time-outom w niektórych proxy.

Aspekty etyczne i prawne

• Transmisja danych osobowych powinna odbywać się wyłącznie po HTTPS z weryfikacją certyfikatu.
• Zgodność z RODO/GDPR: identyfikatory sensorów mogą stanowić dane osobowe, jeśli umożliwiają identyfikację osoby.
• Jeżeli projekt trafia do certyfikacji (CE, FCC), należy kontrolować emisję radiową i aktualizować firmware pod kątem CVE.

Praktyczne wskazówki

• Na etapie debugowania uruchom lokalny serwer (Python/Flask, Node.js/Express) i testuj strumień w przeglądarce (curl -N http://…/events).
• W aplikacjach low-power: podtrzymuj Wi-Fi w trybie MODEM_SLEEP, ale nie usypiaj całego radia – zerwie to połączenie SSE.
• W przypadku wielu strumieni (np. kilka czujników) rozważ multiplikację ścieżek /events/temperature, /events/humidity, by uprościć parsowanie.

Ewentualne zastrzeżenia lub uwagi dodatkowe

• ESP8266HTTPClient nie był projektowany do długotrwałych połączeń; przy strumieniach > 15 min potrafi błędnie zwalniać bufor. Lepiej użyć „gołego” WiFiClient.
• Jeśli Twój serwer korzysta z gzip/deflate – wyłącz kompresję (Cache-Control: no-transform), bo ESP8266 nie ma wbudowanego dekompresora.
• Alternatywa: WebSocket (dwukierunkowy) lub MQTT (broker). SSE jest lżejsze, ale jednostronne.

Sugestie dalszych badań

• Test biblioteki ArduinoSSEClient pod kątem stabilności i zużycia RAM.
• Eksperyment z HTTP/2 server push na ESP32-S3 z ESP-IDF v5.x.
• Porównanie poboru energii SSE vs. MQTT over TLS w trybie deep-sleep.
• Implementacja Last-Event-ID z trwałą pamięcią (RTC RAM lub SPIFFS) dla zachowania ciągłości po resecie.
• Analiza wpływu proxy/reverse-proxy (NGINX, Traefik) na transmisję SSE.

Krótkie podsumowanie

ESP8266 potrafi w pełni obsłużyć protokół Server-Sent Events w roli klienta – wystarczy utrzymać otwarte połączenie HTTP, poprawnie zbudować nagłówki i linia po linii parsować ramki zakończone \n\n. Najpewniejsze jest użycie WiFiClient, własnego bufora i logiki ponawiania połączeń z uwzględnieniem id:/retry:. Zapewnienie HTTPS, zarządzanie pamięcią i watchdogiem podnosi niezawodność w aplikacjach produkcyjnych.