ESP8266 OTA – wgrywanie wsadu przez WiFi z serwera HTTP/HTTPS, przykład kodu i serwera

Pytanie

esp8266 wgrywanie wsadu przez wifi z serwera przykład

Odpowiedź Sztucznej Inteligencji

Bezpośrednia odpowiedź na pytanie

• Najprostszy i w pełni produkcyjny sposób aktualizacji ESP8266 „z powietrza” (OTA) polega na umieszczeniu pliku .bin na serwerze HTTP/HTTPS i wywołaniu w firmware funkcji ESPhttpUpdate.update(url); po pobraniu i zweryfikowaniu obrazu układ automatycznie przełączy się na nową partycję i zrestartuje.
• Kluczowe kroki:
  1. Pierwsze wgranie (USB) kodu z obsługą OTA.
  2. Udostępnienie na serwerze pliku version.txt/version.json i właściwego firmware.bin.
  3. Okresowe porównywanie wersji i, w razie potrzeby, pobranie oraz zapis nowego wsadu przez ESPhttpUpdate.

Szczegółowa analiza problemu

1. Architektura OTA dla ESP8266

1. Pamięć flash modułu jest dzielona na dwie główne partycje – aktywną i zapasową. Aktualizacja trafia do zapasowej, co chroni urządzenie przed utratą funkcjonalności przy przerwanym transferze.
2. Biblioteka ESPhttpUpdate (część core ESP8266) obsługuje:
   • pobieranie pliku (HTTP/HTTPS),
   • weryfikację sumy kontrolnej,
   • zapis do flash,
   • restart i przełączenie.

2. Kod po stronie ESP8266 (PlatformIO/Arduino IDE)

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <ESP8266httpUpdate.h>
#include <ArduinoJson.h>
const char* ssid = "MY_WIFI";
const char* pass = "MY_PASS";
const char* host        = "my-server.com";
const int   port        = 443;                 // 80 dla HTTP
const char* versionURL  = "/ota/version.json";
String      currentVer  = "1.0.0";
WiFiClientSecure client;                       // WiFiClient dla HTTP
void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, pass);
  while (WiFi.status()!=WL_CONNECTED) {delay(500);}
  client.setInsecure(); // lub client.setFingerprint() – produkcyjnie
  checkForUpdate();
}
void loop() {
  static uint32_t last = 0;
  if (millis()-last > 30*60*1000UL) {          // co 30 min
    last = millis();
    checkForUpdate();
  }
  // …tu logika aplikacji…
}
void checkForUpdate() {
  HTTPClient http;
  String url = String("https://") + host + versionURL;
  if(!http.begin(client, url)) return;
  int code = http.GET();
  if (code==HTTP_CODE_OK) {
      StaticJsonDocument<128> doc;
      deserializeJson(doc, http.getString());
      String newVer = doc["version"].as<String>();
      String binURL = doc["file"].as<String>();
      if (newVer != currentVer) performUpdate(binURL);
  }
  http.end();
}
void performUpdate(String binURL) {
  WiFiClientSecure binClient;
  binClient.setInsecure(); // produkcyjnie fingerprint / root CA
  ESPhttpUpdate.setLedPin(LED_BUILTIN, LOW);
  t_httpUpdate_return r = ESPhttpUpdate.update(binClient, binURL);
  if (r==HTTP_UPDATE_OK) Serial.println("Update OK, restart…");
  else Serial.printf("Update error: %d\n", ESPhttpUpdate.getLastError());
}

– Dla HTTP należy zamienić WiFiClientSecure na WiFiClient, a URL zaczynać od http://.

3. Minimalny serwer (Python Flask)

from flask import Flask, send_from_directory, jsonify
app = Flask(__name__, static_folder='.')
CURRENT = "1.1.0"                # wersja dostępna
@app.route('/ota/version.json')
def version():
    return jsonify(version=CURRENT,
                   file="https://my-server.com/ota/firmware_%s.bin" % CURRENT)
@app.route('/ota/<path:name>')
def ota(name):
    return send_from_directory('ota', name, mimetype='application/octet-stream')
if __name__ == '__main__':
    app.run('0.0.0.0', 443, ssl_context=('cert.pem','key.pem'))

Plik .bin umieszczamy w katalogu ota/. Aktualizacja sprowadza się do:

1. arduino-cli compile --export-binaries → firmware_1.1.0.bin
2. podmiana CURRENT w kodzie serwera.

4. Bezpieczeństwo i weryfikacja

• TLS: dla środowiska produkcyjnego obowiązkowo HTTPS oraz weryfikacja certyfikatu (setFingerprint, setTrustAnchors lub BearSSL CA Bundle).
• Podpis binarki: ESPhttpUpdate.update() obsługuje plik .bin + .bin.sig (RSA2048). Publiczny klucz dodajemy w kompilacji (opcja „Sign firmware”).
• Autoryzacja: token w nagłówku lub parametrze GET (/firmware.bin?device=MAC&token=JWT).

5. Praktyczne zastosowania

• Inteligentne czujniki w trudno dostępnych miejscach (np. stacje pogodowe).
• Linie produkcyjne – jednoczesny rollout na dziesiątki modułów.
• Produkty OEM – aktualizacje funkcji bez serwisu.

Aktualne informacje i trendy

• Eleganckie web-OTA: biblioteka AsyncElegantOTA – pełny interfejs webowy, drag&drop; coraz popularniejsza w nowych projektach.
• Chmura: AWS IoT Device Management OTA, Azure Device Update – pozwalają monitorować flotę i zbierać statystyki.
• Bezpieczna aktualizacja delta (Rdiff, bsdiff) – eksperymentalnie na ESP8266, finalne rozwiązania głównie dla ESP32.

Wspierające wyjaśnienia i detale

• Schemat wersjonowania: semver „major.minor.patch”; przy porównywaniu stringów 1.10 > 1.2 można skorzystać z semver.h lub własnej funkcji parsera.
• Podział flash (typowa płyta 4 MB):
  • 0x00000-0x100000 → APP0,
  • 0x100000-0x200000 → APP1,
  • 0x200000-0x3FB000 → SPIFFS/LittleFS.
• Limit wielkości binarki ≈ 1 MB dla układów 4 MB; większy kod wymaga modyfikacji layoutu (np. „64K SPIFFS 3M” vs „FS:none OTA:~1019KB”).

Aspekty etyczne i prawne

• Aktualizacja bez wiedzy użytkownika może naruszać prawo telekomunikacyjne (EU RED, FCC OTA compliance).
• W UE – RODO: zbieranie MAC-ów urządzeń = dane osobowe → konieczne podstawy prawne i anonimizacja.
• GPL/BSD: jeżeli wgrywany wsad zawiera open-source pod GPL, producent ma obowiązek udostępnić kod źródłowy nowej wersji.

Praktyczne wskazówki

• Zawsze loguj kody zwracane przez ESPhttpUpdate (−1…5).
• Test awaryjnego odcięcia zasilania – wyrywkowo odłączaj zasilanie w trakcie pobierania, upewniając się, że urządzenie wraca do starej wersji.
• W małych sieciach domowych zamiast domeny użyj mDNS: http://esp-ota.local/….

Ewentualne zastrzeżenia lub uwagi dodatkowe

• Pamięć RAM (≈ 50 kB wolnego) wystarcza na bufor 4 kB w ESPhttpUpdate, ale skomplikowane aplikacje wraz z TLS 1.2 mogą zbliżyć się do limitu.
• Certyfikaty Let’s Encrypt odnawiają się co 90 dni – utrzymanie ważnego fingerprintu wymaga automatycznej dystrybucji CA lub OTA zaktualizowanego fingerprintu.

Sugestie dalszych badań

• Aktualizacja różnicowa (delta) – ograniczenie transferu nawet x10.
• Mechanizmy roll-back (watchdog + zapamiętywanie stanu startu).
• OTA multicast (MWP, ESP-Now) – jednoczesna aktualizacja wielu węzłów w sieci mesh.
• Analiza bezpieczeństwa: fuzzing warstwy HTTP w ESPhttpUpdate.

Krótkie podsumowanie

ESP8266 obsługuje pewny, dwupartycyjny mechanizm OTA. W praktyce wystarczy:

1. dodać do projektu fragment kodu wywołujący ESPhttpUpdate.update(),
2. wystawić na serwerze binarkę i plik z numerem wersji,
3. zapewnić bezpieczny transport (HTTPS, podpis).
   Dzięki temu każdą kolejną rewizję można wgrać w pełni zdalnie, minimalizując koszt serwisowania i ryzyko unieruchomienia urządzenia.