366 lines
12 KiB
C++
366 lines
12 KiB
C++
#include <atomic>
|
|
#include <chrono>
|
|
#include <csignal>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <optional>
|
|
#include <thread>
|
|
#include <unordered_map>
|
|
|
|
#include "interpreter_config.h"
|
|
#include "json.hpp"
|
|
#include "log.h"
|
|
#include "lua.hpp"
|
|
#include "ws2811.h"
|
|
|
|
#include "httplib.h"
|
|
|
|
using json = nlohmann::json;
|
|
using std::chrono::duration_cast;
|
|
using std::chrono::milliseconds;
|
|
using std::chrono::system_clock;
|
|
|
|
#define TARGET_FREQ WS2811_TARGET_FREQ
|
|
#define GPIO_PIN 18
|
|
#define DMA 10
|
|
#define STRIP_TYPE WS2812_STRIP // WS2812/SK6812RGB integrated chip+leds
|
|
#define LED_COUNT 30 * 5
|
|
|
|
#define FPS 15
|
|
|
|
int frametime = 1000 / FPS;
|
|
|
|
struct LedSegment {
|
|
std::optional<std::thread> lua_thread;
|
|
InterpreterConfig *interpreter_config;
|
|
std::string owner;
|
|
std::string lua_code;
|
|
};
|
|
|
|
std::vector<LedSegment *> ledsegments;
|
|
|
|
// this map is used to be able to see allowed leds from lua
|
|
std::unordered_map<lua_State *, InterpreterConfig *> statemap;
|
|
std::atomic<std::uint64_t> framecounter = {0};
|
|
ws2811_t ledstring = {
|
|
.freq = TARGET_FREQ,
|
|
.dmanum = DMA,
|
|
.channel =
|
|
{
|
|
[0] =
|
|
{
|
|
.gpionum = GPIO_PIN,
|
|
.invert = 0,
|
|
.count = LED_COUNT,
|
|
.strip_type = STRIP_TYPE,
|
|
.brightness = 10,
|
|
},
|
|
[1] =
|
|
{
|
|
.gpionum = 0,
|
|
.invert = 0,
|
|
.count = 0,
|
|
.brightness = 0,
|
|
},
|
|
},
|
|
};
|
|
void hook(lua_State *L, lua_Debug *ar);
|
|
|
|
inline bool kill_thread_if_desired(lua_State *L) {
|
|
if (!statemap[L]->enabled) {
|
|
cout << "putting errors on the stack" << endl;
|
|
lua_sethook(L, hook, LUA_MASKLINE, 0);
|
|
luaL_error(L, "killed by manager");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// TODO also call this hook about once every second
|
|
void hook(lua_State *L, lua_Debug *ar) { kill_thread_if_desired(L); }
|
|
|
|
extern "C" {
|
|
static int c_override_print(lua_State *L) {
|
|
kill_thread_if_desired(L);
|
|
int n = lua_gettop(L); /* number of arguments */
|
|
int i;
|
|
for (i = 1; i <= n; i++) { /* for each argument */
|
|
size_t l;
|
|
const char *s = luaL_tolstring(L, i, &l); /* convert it to string */
|
|
if (i > 1) /* not the first element? */
|
|
statemap[L]->logger << '\t'; /* add a tab before it */
|
|
statemap[L]->logger << s; /* print it */
|
|
lua_pop(L, 1); /* pop result */
|
|
}
|
|
statemap[L]->logger << '\n';
|
|
return 0;
|
|
}
|
|
|
|
static int c_led(lua_State *L) {
|
|
kill_thread_if_desired(L);
|
|
int virtual_location = luaL_checkinteger(L, 1);
|
|
int red = luaL_checkinteger(L, 2);
|
|
int green = luaL_checkinteger(L, 3);
|
|
int blue = luaL_checkinteger(L, 4);
|
|
InterpreterConfig *config = statemap[L];
|
|
|
|
// Lua is one-based, let's keep it consistent and also make our API one-based
|
|
if (virtual_location <= 0 || virtual_location > (int)config->length) {
|
|
std::ostringstream errstream;
|
|
errstream << "setting led " << virtual_location << " of strip with lenght "
|
|
<< config->length << "";
|
|
luaL_argerror(L, 1, errstream.str().c_str());
|
|
return 0;
|
|
} else if (red < 0 || red > 0xff) {
|
|
std::ostringstream errstream;
|
|
errstream << "setting red channel to " << red
|
|
<< " but should be between 0 and 255";
|
|
luaL_argerror(L, 2, errstream.str().c_str());
|
|
return 0;
|
|
} else if (green < 0 || green > 0xff) {
|
|
std::ostringstream errstream;
|
|
errstream << "setting green channel to " << green
|
|
<< " but should be between 0 and 255";
|
|
luaL_argerror(L, 3, errstream.str().c_str());
|
|
return 0;
|
|
} else if (blue < 0 || blue > 0xff) {
|
|
std::ostringstream errstream;
|
|
errstream << "setting blue channel to " << blue
|
|
<< " but should be between 0 and 255";
|
|
luaL_argerror(L, 4, errstream.str().c_str());
|
|
return 0;
|
|
}
|
|
unsigned int real_location = config->begin + virtual_location - 1;
|
|
// TODO remove this debugging line
|
|
ledstring.channel[0].leds[real_location] = (red << 16) | (green << 8) | blue;
|
|
return 0;
|
|
}
|
|
|
|
static int c_ledamount(lua_State *L) {
|
|
kill_thread_if_desired(L);
|
|
lua_pushinteger(L, statemap[L]->length);
|
|
return 1;
|
|
}
|
|
|
|
static int c_delay(lua_State *L) {
|
|
if (kill_thread_if_desired(L)) {
|
|
return 0;
|
|
}
|
|
uint64_t millis = luaL_checkinteger(L, 1);
|
|
uint64_t begin =
|
|
duration_cast<milliseconds>(system_clock::now().time_since_epoch())
|
|
.count();
|
|
|
|
while (duration_cast<milliseconds>(system_clock::now().time_since_epoch())
|
|
.count() -
|
|
begin <
|
|
millis - 100) {
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100 - 5));
|
|
if (kill_thread_if_desired(L)) {
|
|
return 0;
|
|
}
|
|
}
|
|
uint64_t passed =
|
|
(duration_cast<milliseconds>(system_clock::now().time_since_epoch())
|
|
.count() -
|
|
begin);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(millis - passed));
|
|
return 0;
|
|
}
|
|
|
|
static int c_waitframes(lua_State *L) {
|
|
kill_thread_if_desired(L);
|
|
// TODO this is incorrect, fix this
|
|
int amount = luaL_checkinteger(L, 1);
|
|
uint64_t destination = amount + framecounter;
|
|
if (amount >= 2 * FPS) {
|
|
std::this_thread::sleep_for(
|
|
std::chrono::milliseconds(1000 * ((amount / FPS) - 1)));
|
|
}
|
|
while (framecounter <= destination) {
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(frametime / 2));
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Thanks to https://www.stefanmisik.com/post/sandboxing-lua-from-c.html
|
|
static void LuaLoadAndUndefine(lua_State *L, lua_CFunction openFunction,
|
|
const char *moduleName,
|
|
const char *functions[]) {
|
|
/* Load the module, the module table gets placed on the top of the stack */
|
|
luaL_requiref(L, moduleName, openFunction, 1);
|
|
|
|
/* Undefine the unwanted functions */
|
|
for (int i = 0; functions[i] != NULL; i++) {
|
|
lua_pushnil(L);
|
|
lua_setfield(L, -2, functions[i]);
|
|
}
|
|
|
|
/* Pop the module table */
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
lua_State *setup_lua_sandbox(const char *luacode) {
|
|
lua_State *L = luaL_newstate();
|
|
L = luaL_newstate();
|
|
if (!L) {
|
|
return nullptr;
|
|
}
|
|
|
|
static const char *remove_base[] = {"assert", "collectgarbage",
|
|
"dofile", "getmetatable",
|
|
"loadfile", "load",
|
|
"loadstring", "rawequal",
|
|
"rawlen", "rawget",
|
|
"rawset", "setmetatable",
|
|
"print", NULL};
|
|
LuaLoadAndUndefine(L, luaopen_base, "_G", remove_base);
|
|
static const char *remove_str[] = {"dump", NULL};
|
|
LuaLoadAndUndefine(L, luaopen_string, LUA_STRLIBNAME, remove_str);
|
|
|
|
static const char *all_allowed[] = {NULL};
|
|
LuaLoadAndUndefine(L, luaopen_table, LUA_TABLIBNAME, all_allowed);
|
|
LuaLoadAndUndefine(L, luaopen_math, LUA_MATHLIBNAME, all_allowed);
|
|
|
|
lua_pushcfunction(L, c_led);
|
|
lua_setglobal(L, "led");
|
|
lua_pushcfunction(L, c_ledamount);
|
|
lua_setglobal(L, "ledamount");
|
|
lua_pushcfunction(L, c_delay);
|
|
lua_setglobal(L, "delay");
|
|
lua_pushcfunction(L, c_waitframes);
|
|
lua_setglobal(L, "waitframes");
|
|
lua_pushcfunction(L, c_override_print);
|
|
lua_setglobal(L, "print");
|
|
|
|
luaL_loadbuffer(L, luacode, strlen(luacode), "script");
|
|
lua_sethook(L, hook, LUA_MASKCOUNT, 1000);
|
|
|
|
return L;
|
|
}
|
|
|
|
int execute_lua_sandbox(lua_State *L) {
|
|
int ret = lua_pcall(L, 0, 0, 0);
|
|
if (ret != 0) {
|
|
// TODO get full stacktrace
|
|
luaL_traceback(L, L, lua_tostring(L, -1), 1);
|
|
statemap[L]->logger << "CRASH: " << lua_tostring(L, -1) << '\n';
|
|
lua_close(L);
|
|
return 1;
|
|
}
|
|
lua_close(L);
|
|
return 0;
|
|
}
|
|
|
|
std::thread spawn_lua_tread(const char *luacode, InterpreterConfig *config) {
|
|
lua_State *L = setup_lua_sandbox(luacode);
|
|
statemap[L] = config;
|
|
std::thread t(execute_lua_sandbox, L);
|
|
return t;
|
|
}
|
|
|
|
void signal_callback_handler(int signum) {
|
|
(void)signum;
|
|
ws2811_fini(&ledstring);
|
|
exit(1);
|
|
}
|
|
|
|
httplib::Server svr;
|
|
|
|
void starthttpserver() { svr.listen("0.0.0.0", 8080); }
|
|
|
|
int main(int argc, char **argv) {
|
|
unsigned int amount = 10;
|
|
unsigned int leds_per_segment = LED_COUNT / amount;
|
|
for (unsigned int i = 0; i < amount; i++) {
|
|
InterpreterConfig *config =
|
|
new InterpreterConfig{.begin = leds_per_segment * i,
|
|
.length = leds_per_segment,
|
|
.enabled = true};
|
|
cout << config->begin << endl;
|
|
LedSegment *segment = new LedSegment{.lua_thread = std::nullopt,
|
|
.interpreter_config = config,
|
|
.owner = "",
|
|
.lua_code = ""};
|
|
ledsegments.push_back(segment);
|
|
}
|
|
|
|
svr.Get("/api/segments.json",
|
|
[](const httplib::Request &, httplib::Response &res) {
|
|
res.set_header("Access-Control-Allow-Origin", "*");
|
|
res.set_header("Access-Control-Allow-Methods", "GET");
|
|
json j;
|
|
int i = 0;
|
|
for (LedSegment *ledsegment : ledsegments) {
|
|
json o;
|
|
o["begin"] = ledsegment->interpreter_config->begin;
|
|
o["length"] = ledsegment->interpreter_config->length;
|
|
o["owner"] = ledsegment->owner;
|
|
o["code"] = ledsegment->lua_code;
|
|
o["id"] = i;
|
|
i++;
|
|
j.push_back(o);
|
|
}
|
|
res.set_content(j.dump(), "text/json");
|
|
});
|
|
|
|
svr.Put("/api/code.json", [](const httplib::Request &req,
|
|
httplib::Response &res,
|
|
const httplib::ContentReader &content_reader) {
|
|
res.set_header("Access-Control-Allow-Origin", "*");
|
|
res.set_header("Access-Control-Allow-Methods", "PUT");
|
|
if (req.is_multipart_form_data()) {
|
|
res.set_content("No multipart forms allowed", "text/plain");
|
|
return true;
|
|
} else {
|
|
content_reader([&](const char *raw_data, size_t data_length) {
|
|
std::string data(raw_data, data_length);
|
|
auto j = json::parse(data);
|
|
LedSegment *selected = ledsegments.at(j["id"].get<unsigned int>());
|
|
if (selected->lua_thread.has_value()) {
|
|
selected->interpreter_config->enabled = false;
|
|
selected->lua_thread.value().join();
|
|
}
|
|
selected->owner = j["owner"].get<std::string>();
|
|
selected->lua_code = j["code"].get<std::string>();
|
|
selected->interpreter_config->enabled = true;
|
|
selected->lua_thread = spawn_lua_tread(selected->lua_code.c_str(),
|
|
selected->interpreter_config);
|
|
cout << "Uploaded new code from " << selected->owner << " to segment "
|
|
<< j["id"].get<unsigned int>() << endl;
|
|
return true;
|
|
});
|
|
}
|
|
return true;
|
|
});
|
|
|
|
svr.Options("/api/code.json",
|
|
[](const httplib::Request &req, httplib::Response &res) {
|
|
res.set_header("Access-Control-Allow-Origin", "*");
|
|
res.set_header("Access-Control-Allow-Methods", "PUT");
|
|
return true;
|
|
});
|
|
|
|
std::thread httpserverthread(starthttpserver);
|
|
|
|
ws2811_return_t ret;
|
|
if ((ret = ws2811_init(&ledstring)) != WS2811_SUCCESS) {
|
|
fprintf(stderr, "ws2811_init failed: %s\n", ws2811_get_return_t_str(ret));
|
|
return ret;
|
|
}
|
|
signal(SIGINT, signal_callback_handler);
|
|
signal(SIGHUP, signal_callback_handler);
|
|
signal(SIGTERM, signal_callback_handler);
|
|
|
|
ledstring.channel[0].leds[10] = 0x00200000;
|
|
ledstring.channel[0].leds[11] = 0x00002000;
|
|
ledstring.channel[0].leds[12] = 0x00000020;
|
|
|
|
while (true) {
|
|
ws2811_render(&ledstring);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(frametime));
|
|
}
|
|
}
|