ESP8266 Arduino: uruchamianie skryptów Lua przez bibliotekę ESP8266-Arduino-Lua

Pytanie

ESP8266, jak uruchomić skrypt Lua w kodzie arduino

Odpowiedź Sztucznej Inteligencji

Bezpośrednia odpowiedź na pytanie

• Tak, da się uruchomić skrypty Lua z poziomu szkicu Arduino na ESP8266, osadzając interpreter Lua jako bibliotekę (najprościej – ESP8266-Arduino-Lua).
• Alternatywą jest wgranie firmware NodeMCU (wtedy całe urządzenie pracuje natywnie w Lua), ale w tym scenariuszu nie ma już kodu Arduino-C++.
• W obu przypadkach trzeba liczyć się z ograniczoną pamięcią RAM (~50–80 kB) i narzutem czasowym interpretera.

Szczegółowa analiza problemu

1. Architektura „embedding”
   • Szkic C/C++ (host) inicjalizuje lua_State, otwiera standardowe biblioteki Lua i (opcjonalnie) udostępnia funkcje GPIO, Wi-Fi itd.
   • Skrypt Lua jest pobierany (LittleFS/SPIFFS, PROGMEM, UART, HTTP…) i wykonywany przez luaL_dostring() lub luaL_loadbuffer()+lua_pcall().
   • Łączność dwukierunkowa:
   – C++ → Lua: lua_getglobal(L,"nazwa"); lua_pcall(...).
   – Lua → C++: funkcje C rejestrowane przez lua_pushcfunction() / lua_setglobal().

2. Instalacja (przykład biblioteki ESP8266-Arduino-Lua)
   a) Arduino IDE > Szkic > Dołącz bibliotekę > Dodaj ZIP → wskaż ZIP z repozytorium github.com/fdu/ESP8266-Arduino-Lua.
   b) W menu Plik > Przykłady pojawi się zestaw demo, m.in. ExecuteScriptFromSerial.
   c) Wybierz płytkę „NodeMCU 1.0 (ESP-12E)” lub inną zgodną, ustaw 80 MHz i 4 MB (FS 1 MB).

3. Minimalny szkic hosta

   #include <Arduino.h>
   #include <LittleFS.h>
   extern "C"{
   #include "lua.h"
   #include "lualib.h"
   #include "lauxlib.h"
   }
   lua_State *L;
   void setup(){
   Serial.begin(115200);
   LittleFS.begin();
   L = luaL_newstate();
   luaL_openlibs(L);
   // Prosta funkcja GPIO dostępna w Lua: set_pin(pin,val)
   auto set_pin = [](lua_State *L)->int{
      int pin = luaL_checkinteger(L,1);
      int val = luaL_checkinteger(L,2);
      pinMode(pin,OUTPUT);
      digitalWrite(pin,val);
      return 0;
   };
   lua_pushcfunction(L,set_pin);
   lua_setglobal(L,"set_pin");
   // wczytaj skrypt z pliku /script.lua
   File f = LittleFS.open("/script.lua","r");
   if(f){
     String code=f.readString();
     if(luaL_dostring(L,code.c_str())!=LUA_OK){
         Serial.println(lua_tostring(L,-1));
         lua_pop(L,1);
     }
     f.close();
   }
   }
   void loop(){
   // przykład cyklicznego wywołania funkcji Lua tick()
   lua_getglobal(L,"tick");
   if(lua_isfunction(L,-1)){
      if(lua_pcall(L,0,0,0)!=LUA_OK){
          Serial.println(lua_tostring(L,-1));
          lua_pop(L,1);
      }
   }else lua_pop(L,1);
   delay(1000);
   }

   Przykładowy script.lua:

   print("Lua start")
   function tick()
   set_pin(2, 0)  -- LED ON
   tmr.delay(100000) -- 100 ms
   set_pin(2, 1)  -- LED OFF
   end

4. Firmware NodeMCU – kiedy warto
   Jeśli cała logika ma być w Lua, prościej raz wgrać firmware NodeMCU i pracować wyłącznie w Lua (pliki init.lua, tmr, wifi, mqtt). Tracimy jednak dostęp do ekosystemu bibliotek Arduino.

5. Zarządzanie pamięcią i wydajnością
   • Jeden lua_State.
   • Unikać dużych tablic tworzonych w pętli.
   • Manualny GC: lua_gc(L,LUA_GCCOLLECT,0); w dłuższych projektach.
   • Zadania twardoreal-czasowe (ISR, komunikacja wysokiej prędkości) pozostawić w C/C++.

Aktualne informacje i trendy

• Biblioteka ESP8266-Arduino-Lua utrzymywana jest w kilku for-kach; najaktualniejsze (2023/24) podnoszą rdzeń do Lua 5.3.6 i kompilują się także dla ESP32.
• MikroPython zyskuje większą społeczność, lecz Lua pozostaje lżejsza (mniejszy RAM, szybciej się uruchamia).
• Coraz popularniejsze są hybrydowe build-systemy (PlatformIO), które ułatwiają linkowanie natywnego kodu i interpretera.

Wspierające wyjaśnienia i detale

• Bindingi Arduino w Lua (biblioteka powyżej): pinMode, digitalWrite, analogRead, millis, delay, Serial.print.
• Własne moduły można rejestrować jako tabele:

  lua_newtable(L);
  lua_pushcfunction(L,myFunc);
  lua_setfield(L,-2,"myFunc");
  lua_setglobal(L,"myModule");

• LittleFS/SPIFFS upload: narzędzie „ESP8266 Sketch Data Upload” (IDE 2.x – wtyczka, PlatformIO – pio run -t uploadfs).

Aspekty etyczne i prawne

• Lua (PUC-Rio) i biblioteka ESP8266-Arduino-Lua są licencjonowane na zasadach MIT/BSD – można używać komercyjnie, zachowując nagłówki licencyjne.
• Przy dystrybucji urządzeń należy zapewnić dostęp do kodu źródłowego części na MIT, jeśli jest dołączony (GPL tu nie obowiązuje).
• Aktualizacje OTA: zadbaj o podpisywanie binarek oraz szyfrowany transport (HTTPS) – skrypt Lua może modyfikować logikę urządzenia w locie.

Praktyczne wskazówki

1. Na start skompiluj szkic z przykładem ExecuteScriptFromSerial, by zweryfikować, że interpreter działa.
2. System plików: minimum 256 kB na LittleFS, aby wygodnie aktualizować skrypty.
3. Debug: wyłapuj błędy interpretera (lua_tostring) i drukuj na Serial.
4. Profiluj zużycie RAM (ESP.getFreeHeap()) po wykonaniu większych fragmentów Lua.
5. Jeśli RAM < 20 kB wolne – rozważ wyłączenie nieużywanych bibliotek Lua (math, io) w pliku luaconf.h.

Ewentualne zastrzeżenia lub uwagi dodatkowe

• Interpreter + biblioteki ≈ 80–100 kB flash i 20–25 kB RAM. W bardzo małych modułach (ESP-01 512 kB) miejsce może być niewystarczające.
• Wydajność: typowe pętle Lua ~10-20× wolniejsze od C++; unikać w ISR.
• Społeczność ESP8266 koncentruje się dziś na MicroPython; biblioteki Lua mogą mieć mniejszą liczbę maintainerów.

Sugestie dalszych badań

• Analiza projektu eLua (odchudzony interpreter z opcjonalną kompilacją byte-code offline).
• Porównanie zużycia pamięci Lua 5.4 vs MicroPython 1.20 na ESP8266.
• Mechanizmy sandboxingu: ograniczenie skryptu Lua do wybranych funkcji dla bezpieczeństwa OTA.
• Integracja z MQTT – napisanie warstwy bindingu Lua dla PubSubClient.
• Próba kompilacji interpretera w wariancie „integer only” (bez double), co redukuje RAM o ~4 kB.

Krótkie podsumowanie

Możesz włączyć interpreter Lua w szkic Arduino dla ESP8266 – najprościej użyć biblioteki ESP8266-Arduino-Lua, która kompiluje standardowy Lua 5.3 i udostępnia podstawowe API Arduino w skryptach. Wgrywasz bibliotekę, inicjalizujesz lua_State, ładujesz skrypt z LittleFS i wykonujesz go przez luaL_dostring(). Pamiętaj o ograniczeniach RAM i wydajności; dla czystszej obsługi w Lua można zamiast tego wgrać firmware NodeMCU, lecz wtedy rezygnujesz z kodu C++. Wybór zależy od tego, czy Lua ma być tylko warstwą konfiguracyjną (embedding), czy głównym językiem aplikacji.