mirror of
https://git.mirrors.martin98.com/https://github.com/luc-github/ESP3D.git
synced 2025-10-13 10:41:30 +08:00
ae2dec2186
* Split esp32 code from esp8266 for Serial * split receive serial message and processing serial message in esp32 in different task * Make the esp32 code backward compatible with Arduino esp32 2.0.17 / IDF 4.4.7
344 lines
10 KiB
C++
344 lines
10 KiB
C++
/*
|
|
EspLuaEngine project
|
|
|
|
Copyright (c) 2024 Luc Lebosse. All rights reserved.
|
|
|
|
This code is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
This code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "EspLuaEngine.h"
|
|
#define ESP_LUA_NB_LINES_BEFORE_HOOK 1000
|
|
|
|
#if defined(ARDUINO_ARCH_ESP32)
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#endif // defined(ARDUINO_ARCH_ESP32)
|
|
|
|
#if defined(ARDUINO_ARCH_ESP8266)
|
|
// #define DEBUG_ESP_LUA_ENGINE Serial
|
|
#if defined(DEBUG_ESP_LUA_ENGINE)
|
|
#define log_e(format, ...) \
|
|
DEBUG_ESP_LUA_ENGINE.printf("E: " format "\n", ##__VA_ARGS__)
|
|
#define log_v(format, ...) \
|
|
DEBUG_ESP_LUA_ENGINE.printf("V: " format "\n", ##__VA_ARGS__)
|
|
#else
|
|
#define log_e(format, ...)
|
|
#define log_v(format, ...)
|
|
#endif // defined(DEBUG_ESP_LUA_ENGINE)
|
|
#endif // defined(ARDUINO_ARCH_ESP8266)
|
|
|
|
EspLuaEngine::PauseFunction EspLuaEngine::_pauseFunction = nullptr;
|
|
String EspLuaEngine::_lastError;
|
|
|
|
/*Public methods*/
|
|
std::atomic<bool> EspLuaEngine::_isPaused{false};
|
|
std::atomic<bool> EspLuaEngine::_isRunning{false};
|
|
|
|
EspLuaEngine::EspLuaEngine() : _lua_state(nullptr) {
|
|
_lua_state = luaL_newstate();
|
|
if (_lua_state) {
|
|
_loadLibraries();
|
|
} else {
|
|
log_e("Error : Impossible to create a new Lua state");
|
|
}
|
|
}
|
|
|
|
EspLuaEngine::~EspLuaEngine() {
|
|
if (_lua_state) {
|
|
lua_close(_lua_state);
|
|
}
|
|
}
|
|
|
|
void EspLuaEngine::setPauseFunction(PauseFunction func) {
|
|
_pauseFunction = func;
|
|
}
|
|
|
|
void EspLuaEngine::_defaultPauseFunction() {
|
|
#if defined(ARDUINO_ARCH_ESP32)
|
|
vTaskDelay(ESP_LUA_CHECK_INTERVAL);
|
|
#endif // defined(ARDUINO_ARCH_ESP32)
|
|
#if defined(ARDUINO_ARCH_ESP8266)
|
|
delay(ESP_LUA_CHECK_INTERVAL);
|
|
#endif // defined(ARDUINO_ARCH_ESP8266)
|
|
}
|
|
|
|
void EspLuaEngine::hookFunction(lua_State* L, lua_Debug* ar) {
|
|
if (_isPaused.load()) {
|
|
while (_isPaused.load() && _isRunning.load()) {
|
|
if (_pauseFunction) {
|
|
_pauseFunction();
|
|
} else {
|
|
_defaultPauseFunction();
|
|
}
|
|
}
|
|
}
|
|
if (!_isRunning.load()) {
|
|
if (_lastError.length() == 0) _lastError = "Execution stopped";
|
|
luaL_error(L, "Execution stopped");
|
|
}
|
|
}
|
|
|
|
void EspLuaEngine::resetState() {
|
|
if (_lua_state) {
|
|
lua_close(_lua_state);
|
|
_lua_state = luaL_newstate();
|
|
if (_lua_state) {
|
|
_loadLibraries();
|
|
} else {
|
|
log_e("Error: Impossible to create a new Lua state");
|
|
}
|
|
}
|
|
}
|
|
|
|
bool EspLuaEngine::executeScript(const char* script) {
|
|
_lastError=""; // Clear the error message
|
|
_isPaused.store(false);
|
|
_isRunning.store(true);
|
|
|
|
// Configure the hook function
|
|
lua_sethook(_lua_state, hookFunction, LUA_MASKCOUNT,
|
|
ESP_LUA_NB_LINES_BEFORE_HOOK);
|
|
|
|
bool success = true;
|
|
|
|
// Compile the script
|
|
if (luaL_loadstring(_lua_state, script) != LUA_OK) {
|
|
if (_lastError.length() == 0) _lastError = lua_tostring(_lua_state, -1);
|
|
log_e("Error loading script: %s", _lastError.c_str());
|
|
lua_pop(_lua_state, 1);
|
|
success = false;
|
|
} else {
|
|
// Execute the script
|
|
if (lua_pcall(_lua_state, 0, 0, 0) != LUA_OK) {
|
|
if (_lastError.length() == 0) _lastError = lua_tostring(_lua_state, -1);
|
|
log_e("Error executing script: %s", _lastError.c_str());
|
|
lua_pop(_lua_state, 1);
|
|
success = false;
|
|
}
|
|
}
|
|
|
|
// Disable the hook function
|
|
lua_sethook(_lua_state, nullptr, 0, 0);
|
|
_isRunning.store(false);
|
|
_isPaused.store(false);
|
|
|
|
return success;
|
|
}
|
|
|
|
void EspLuaEngine::pauseExecution() {
|
|
if (_isRunning.load()) {
|
|
_isPaused.store(true);
|
|
}
|
|
}
|
|
|
|
void EspLuaEngine::resumeExecution() { _isPaused.store(false); }
|
|
|
|
void EspLuaEngine::stopExecution() {
|
|
_isRunning.store(false);
|
|
_isPaused.store(false);
|
|
if (_lastError.length() == 0) _lastError = "Execution stopped by user";
|
|
}
|
|
|
|
bool EspLuaEngine::isRunning() { return _isRunning.load(); }
|
|
|
|
bool EspLuaEngine::isPaused() { return _isPaused.load(); }
|
|
|
|
EspLuaEngine::Status EspLuaEngine::getStatus() {
|
|
if (_isPaused.load()) {
|
|
return Status::Paused;
|
|
} else if (_isRunning.load()) {
|
|
return Status::Running;
|
|
} else {
|
|
return Status::Idle;
|
|
}
|
|
}
|
|
|
|
bool EspLuaEngine::hasError() { return _lastError.length() > 0; }
|
|
|
|
bool EspLuaEngine::registerFunction(const char* name, lua_CFunction function,
|
|
void* userData) {
|
|
if (!_checkPreconditions(name) || !function) {
|
|
log_e("Error: Invalid function pointer or name");
|
|
return false;
|
|
}
|
|
int top = lua_gettop(_lua_state);
|
|
|
|
if (userData) {
|
|
lua_pushlightuserdata(_lua_state, userData);
|
|
lua_pushcclosure(_lua_state, function, 1);
|
|
} else {
|
|
lua_pushcfunction(_lua_state, function);
|
|
}
|
|
lua_setglobal(_lua_state, name);
|
|
|
|
if (!_verifyGlobal(name, LUA_TFUNCTION)) {
|
|
_cleanupOnFailure(name, top);
|
|
return false;
|
|
}
|
|
lua_settop(_lua_state, top);
|
|
log_v("Function '%s' registered successfully", name);
|
|
return true;
|
|
}
|
|
|
|
// Implement the template method
|
|
template <typename T>
|
|
bool EspLuaEngine::registerConstant(const char* name, T value) {
|
|
return _registerConstantImpl(name, value);
|
|
}
|
|
|
|
// Specializations template explicit, before the explicit specializations
|
|
template <>
|
|
bool EspLuaEngine::registerConstant<unsigned char>(const char* name,
|
|
unsigned char value) {
|
|
return _registerConstantImpl(name, static_cast<int>(value));
|
|
}
|
|
|
|
// Specializations explicit
|
|
template bool EspLuaEngine::registerConstant<lua_Number>(const char*,
|
|
lua_Number);
|
|
template bool EspLuaEngine::registerConstant<const char*>(const char*,
|
|
const char*);
|
|
template bool EspLuaEngine::registerConstant<bool>(const char*, bool);
|
|
template bool EspLuaEngine::registerConstant<int>(const char*, int);
|
|
template bool EspLuaEngine::registerConstant<unsigned char>(const char*,
|
|
unsigned char);
|
|
|
|
// Implementations of the specialized methods
|
|
bool EspLuaEngine::_registerConstantImpl(const char* name, lua_Number value) {
|
|
if (!_checkPreconditions(name)) return false;
|
|
int top = lua_gettop(_lua_state);
|
|
lua_pushnumber(_lua_state, value);
|
|
lua_setglobal(_lua_state, name);
|
|
if (!_verifyGlobal(name, LUA_TNUMBER) || !_makeReadOnly(name)) {
|
|
_cleanupOnFailure(name, top);
|
|
return false;
|
|
}
|
|
lua_settop(_lua_state, top);
|
|
log_v("Constant '%s' (number) registered successfully", name);
|
|
return true;
|
|
}
|
|
|
|
bool EspLuaEngine::_registerConstantImpl(const char* name, const char* value) {
|
|
if (!_checkPreconditions(name) || !value) {
|
|
log_e("Error: Invalid value");
|
|
return false;
|
|
}
|
|
int top = lua_gettop(_lua_state);
|
|
lua_pushstring(_lua_state, value);
|
|
lua_setglobal(_lua_state, name);
|
|
if (!_verifyGlobal(name, LUA_TSTRING) || !_makeReadOnly(name)) {
|
|
_cleanupOnFailure(name, top);
|
|
return false;
|
|
}
|
|
lua_settop(_lua_state, top);
|
|
log_v("Constant '%s' (string) registered successfully", name);
|
|
return true;
|
|
}
|
|
|
|
bool EspLuaEngine::_registerConstantImpl(const char* name, bool value) {
|
|
if (!_checkPreconditions(name)) return false;
|
|
int top = lua_gettop(_lua_state);
|
|
lua_pushboolean(_lua_state, value);
|
|
lua_setglobal(_lua_state, name);
|
|
if (!_verifyGlobal(name, LUA_TBOOLEAN) || !_makeReadOnly(name)) {
|
|
_cleanupOnFailure(name, top);
|
|
return false;
|
|
}
|
|
lua_settop(_lua_state, top);
|
|
log_v("Constant '%s' (boolean) registered successfully", name);
|
|
return true;
|
|
}
|
|
|
|
bool EspLuaEngine::_registerConstantImpl(const char* name, int value) {
|
|
if (!_checkPreconditions(name)) return false;
|
|
int top = lua_gettop(_lua_state);
|
|
lua_pushinteger(_lua_state, value);
|
|
lua_setglobal(_lua_state, name);
|
|
if (!_verifyGlobal(name, LUA_TNUMBER) || !_makeReadOnly(name)) {
|
|
_cleanupOnFailure(name, top);
|
|
return false;
|
|
}
|
|
lua_settop(_lua_state, top);
|
|
log_v("Constant '%s' (integer) registered successfully", name);
|
|
return true;
|
|
}
|
|
|
|
/*Private methods*/
|
|
void EspLuaEngine::_loadLibraries() {
|
|
static const luaL_Reg loadedlibs[] = {{"_G", luaopen_base},
|
|
{LUA_TABLIBNAME, luaopen_table},
|
|
{LUA_STRLIBNAME, luaopen_string},
|
|
{LUA_MATHLIBNAME, luaopen_math},
|
|
{LUA_UTF8LIBNAME, luaopen_utf8},
|
|
{NULL, NULL}};
|
|
|
|
for (const luaL_Reg* lib = loadedlibs; lib->func; lib++) {
|
|
luaL_requiref(_lua_state, lib->name, lib->func, 1);
|
|
lua_pop(_lua_state, 1);
|
|
log_v("Successfully loaded library: %s", lib->name);
|
|
}
|
|
}
|
|
|
|
bool EspLuaEngine::_checkPreconditions(const char* name) {
|
|
if (!_lua_state) {
|
|
log_e("Error: Lua state is not initialized");
|
|
return false;
|
|
}
|
|
if (!name || strlen(name) == 0) {
|
|
log_e("Error: Invalid name");
|
|
return false;
|
|
}
|
|
if (!lua_checkstack(_lua_state, 3)) {
|
|
log_e("Error: Unable to allocate stack space");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool EspLuaEngine::_verifyGlobal(const char* name, int type) {
|
|
lua_getglobal(_lua_state, name);
|
|
bool result = (lua_type(_lua_state, -1) == type);
|
|
lua_pop(_lua_state, 1);
|
|
if (!result) {
|
|
log_e("Error: Failed to register %s '%s'",
|
|
(type == LUA_TFUNCTION) ? "function" : "constant", name);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void EspLuaEngine::_cleanupOnFailure(const char* name, int top) {
|
|
lua_pushnil(_lua_state);
|
|
lua_setglobal(_lua_state, name);
|
|
lua_settop(_lua_state, top);
|
|
}
|
|
|
|
bool EspLuaEngine::_makeReadOnly(const char* name) {
|
|
luaL_getmetatable(_lua_state, "Constants");
|
|
if (lua_isnil(_lua_state, -1)) {
|
|
lua_pop(_lua_state, 1);
|
|
luaL_newmetatable(_lua_state, "Constants");
|
|
lua_pushstring(_lua_state, "__newindex");
|
|
lua_pushcfunction(_lua_state, [](lua_State* L) -> int {
|
|
return luaL_error(L, "Attempt to modify read-only constant");
|
|
});
|
|
lua_settable(_lua_state, -3);
|
|
}
|
|
lua_getglobal(_lua_state, name);
|
|
lua_pushvalue(_lua_state, -2);
|
|
lua_setmetatable(_lua_state, -2);
|
|
lua_pop(_lua_state, 2);
|
|
return true;
|
|
}
|