ESP8266 – uruchamianie skryptów i firmware z karty SD, MicroPython, SD-OTA, konfiguracja

Pytanie

ESP8266 , uruchomienie programu, funkcji z karty SD

Odpowiedź Sztucznej Inteligencji

Bezpośrednia odpowiedź na pytanie

• ESP8266 nie potrafi natywnie wykonywać skompilowanego kodu binarnego bezpośrednio z karty SD.
• Można jednak:
  • interpretować skrypty lub pliki konfiguracyjne zapisane na SD,
  • zaktualizować cały firmware z pliku .bin znajdującego się na SD (tzw. SD-OTA),
  • sterować logiką programu przez odczyt parametrów z SD.

Kluczowe punkty

1. Kod maszynowy musi znajdować się w wewnętrznej pamięci Flash.
2. Karta SD może służyć wyłącznie jako źródło danych, skryptów lub obrazu nowego firmware.
3. Najczęściej stosuje się trzy scenariusze: pliki konfiguracyjne, interpretery (MicroPython/Lua) albo SD-OTA.

Szczegółowa analiza problemu

Architektura i ograniczenia

• ESP8266 (rdzeń Tensilica L106) wykonuje instrukcje tylko z obszarów pamięci Flash SPI mapowanych w przestrzeni adresowej.
• Interfejs SD jest obsługiwany jako SPI-slave; brak MMU uniemożliwia mapowanie sektorów SD jako kodu wykonywalnego.
• RAM (≈ 50 kB dostępnego) służy danym – po wczytaniu większych fragmentów binarnych nie ma miejsca na ich bezpieczne uruchomienie.

Trzy praktyczne podejścia

1. Interpretacja skryptów z SD
   • Firmware zawiera wbudowany interpreter (MicroPython, NodeMCU-Lua lub własny mini-parser C++).
   • Skrypty .py / .lua / *.txt leżą na SD i są liniowo interpretowane:

     # MicroPython – main.py na SD
     import machine, time, sdcard, os
     led = machine.Pin(2, machine.Pin.OUT)
     for _ in range(5):
         led.on();  time.sleep(0.5)
         led.off(); time.sleep(0.5)

   • Zalety: szybka modyfikacja logiki bez kompilacji; Wady: mniejsza wydajność.

2. Pliki konfiguracyjne / polecenia
   • Główne firmware (C++/Arduino) wczytuje dane JSON/INI/CSV z SD i na tej podstawie ustawia parametry lub wykonuje z góry zdefiniowane funkcje.
   • Przykład odczytu JSON (ArduinoJson v6):

     File f = SD.open("/cfg.json");
     DynamicJsonDocument doc(512);
     deserializeJson(doc, f);
     int pwm = doc["pwm"];
     analogWriteFreq(pwm);
     f.close();

   • Bardzo mały narzut pamięci, brak ryzyka „uceglenia”.

3. Aktualizacja firmware z SD (SD-OTA)
   • W pamięci Flash znajduje się niewielki boot-loader (np. 128 kB), który przy starcie:
   – sprawdza CRC/wersję pliku /firmware.bin na SD,
   – jeśli nowszy – kopiuje go do wyznaczonej partycji OTA0/OTA1 przez klasę Update,
   – weryfikuje sumę SHA-256, ustawia znacznik „boot OK” i restartuje MCU.
   • Kod przykładowy (Arduino-ESP8266 >=3.1):

     if (SD.exists("/fw.bin")) {
       File fw = SD.open("/fw.bin");
       if (Update.begin(fw.size(), U_FLASH)) {
         Update.writeStream(fw);
         if (Update.end() && Update.isFinished()) {
           ESP.restart();
         }
       }
       fw.close();
     }

   • Wady: wymaga zabezpieczeń zasilania i sprawnego boot-loadera; Zalety: pełna funkcjonalność jak OTA bez Wi-Fi.

Teoretyczne podstawy

• Vectored-interrupt + XIP (eXecute-In-Place) w Tensilica działa tylko z pamięci SPI Flash o czasie dostępu < 50 ns; SD karta (FAT + sektor 512 B) wprowadza latencję rzędu ms – niezgodne z pipeline CPU.
• Jedyną drogą „dynamicznego” kodu jest załadowanie binariów do RAM i wykonanie ich jako funkcji wskaźnikowych, jednak ESP8266 ma zbyt mało RAM, a region IRAM (≈ 32 kB) i tak jest zajęty przez biblioteki i stos.

Praktyczne zastosowania

• Stacje pomiarowe: parametry czujników i harmonogram logowań w pliku JSON.
• Automat gier retro: plik playlisty i grafiki na SD, główny silnik w Flash.
• Urządzenia instalowane w terenie: SD-OTA umożliwia serwisantowi wymianę firmware bez komputera.

Aktualne informacje i trendy

• Biblioteka LittleFS zastępuje SPIFFS w nowszych core ESP8266; na duże pliki nadal lepszy moduł SD.
• Coraz częściej stosuje się ESP32 (posiada MMU i więcej RAM), co ułatwia micropythonowe „moduły z SD” i większe interpretery.
• W wersji core 3.1.2 dodano obsługę SHA-256 dla Update, co umożliwia weryfikację obrazu FW z SD.

Wspierające wyjaśnienia i detale

• Zasilanie SD: 3 V ±5 % (nie 5 V!). Należy użyć konwertera poziomów lub czytnika z buforami 74LVC.
• Typowe piny NodeMCU v3:
  • CS – D8 (GPIO15)
  • MOSI – D7 (GPIO13)
  • MISO – D6 (GPIO12)
  • SCK – D5 (GPIO14)
• Format FAT16/32; klastry 4 kB minimalizują opóźnienie losowego odczytu.

Aspekty etyczne i prawne

• Aktualizacja z SD musi być podpisana lub sprawdzana sumą kontrolną, aby zapobiec złośliwym modyfikacjom (reguły EU RED & Cyber-Security Act).
• W produktach komercyjnych należy udokumentować procedurę aktualizacji i odzyskiwania (wymóg CE: EN 62368-1 – ochrona przed błędną aktualizacją).
• Dostęp do karty SD z poziomu użytkownika końcowego wymaga zabezpieczenia danych wrażliwych (np. hasła Wi-Fi w pliku config).

Praktyczne wskazówki

1. Najpierw potwierdź stabilną pracę SPI – skorzystaj z przykładowego „SD > CardInfo”.
2. Parser poleceń pisz w sposób odporny na błędy (sprawdzenie buforów, String.reserve()).
3. Przy SD-OTA stosuj podwójny układ partycji (app0/app1) – w razie niepowodzenia wrócisz do poprzedniej wersji.
4. W MicroPythonie zamontuj SD jako /sd, a następnie dołącz do sys.path, aby import działał:

   import sys, os, sdcard, machine
   sd = sdcard.SDCard(machine.SPI(1), machine.Pin(15))
   os.mount(sd, "/sd")
   sys.path.append("/sd")

Ewentualne zastrzeżenia lub uwagi dodatkowe

• „Dynamiczne biblioteki” ładowane do RAM w C++ są teoretycznie możliwe, ale praktycznie nieopłacalne (mało RAM, brak relocacji).
• System plików FAT jest podatny na uszkodzenie przy nagłym braku zasilania – rozważ kopię zapasową lub journaling (FFatFS).
• Podczas SD-OTA krytyczny jest stały poziom zasilania ≥ 180 mA – w razie spadku zostanie przerwany zapis Flash.

Sugestie dalszych badań

• Migracja projektu do ESP32-S3 lub RP2040 z zewnętrzną PSRAM – większy margines dla interpretera Python/BASIC.
• Wdrożenie podpisu cyfrowego ECDSA dla pliku fw.bin (Biblioteka BearSSL).
• Analiza systemu Zephyr RTOS na ESP32, który wspiera FOTA z SD i kontenery aplikacyjne.

Krótkie podsumowanie

Uruchomienie kodu z karty SD na ESP8266 w sensie „execute-in-place” jest niemożliwe. Funkcjonalność tę można jednak uzyskać pośrednio poprzez:

1. Interpreter skryptów na SD (MicroPython/Lua/własny parser).
2. Pliki konfiguracyjne sterujące zachowaniem firmware.
3. Aktualizację firmware z SD (SD-OTA) z weryfikacją integralności.

Dobór metody zależy od wymagań projektu: szybkość zmian (skrypty), prostota (konfiguracja) czy pełna modernizacja (SD-OTA). Staranne zarządzanie zasilaniem, pamięcią i bezpieczeństwem zagwarantuje bezawaryjne działanie rozwiązania.