Unverified Commit 1990f957 authored by Terry Ellison's avatar Terry Ellison Committed by GitHub
Browse files

Updated ROTables 1st tranch (#2742)

Updated ROTables
parent e0f3dbed
......@@ -467,31 +467,30 @@ static void gpio_pulse_task(os_param_t param, uint8_t prio)
}
}
static const LUA_REG_TYPE pulse_map[] = {
{ LSTRKEY( "getstate" ), LFUNCVAL( gpio_pulse_getstate ) },
{ LSTRKEY( "stop" ), LFUNCVAL( gpio_pulse_stop ) },
{ LSTRKEY( "cancel" ), LFUNCVAL( gpio_pulse_cancel ) },
{ LSTRKEY( "start" ), LFUNCVAL( gpio_pulse_start ) },
{ LSTRKEY( "adjust" ), LFUNCVAL( gpio_pulse_adjust ) },
{ LSTRKEY( "update" ), LFUNCVAL( gpio_pulse_update ) },
{ LSTRKEY( "__gc" ), LFUNCVAL( gpio_pulse_delete ) },
{ LSTRKEY( "__index" ), LROVAL( pulse_map ) },
{ LNILKEY, LNILVAL }
};
const LUA_REG_TYPE gpio_pulse_map[] =
{
{ LSTRKEY( "build" ), LFUNCVAL( gpio_pulse_build ) },
{ LSTRKEY( "__index" ), LROVAL( gpio_pulse_map ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(pulse)
LROT_FUNCENTRY( getstate, gpio_pulse_getstate )
LROT_FUNCENTRY( stop, gpio_pulse_stop )
LROT_FUNCENTRY( cancel, gpio_pulse_cancel )
LROT_FUNCENTRY( start, gpio_pulse_start )
LROT_FUNCENTRY( adjust, gpio_pulse_adjust )
LROT_FUNCENTRY( update, gpio_pulse_update )
LROT_FUNCENTRY( __gc, gpio_pulse_delete )
LROT_TABENTRY( __index, pulse )
LROT_END( pulse, pulse, LROT_MASK_GC_INDEX )
LROT_PUBLIC_BEGIN(gpio_pulse)
LROT_FUNCENTRY( build, gpio_pulse_build )
LROT_TABENTRY( __index, gpio_pulse )
LROT_END( gpio_pulse, gpio_pulse, LROT_MASK_INDEX )
int gpio_pulse_init(lua_State *L)
{
luaL_rometatable(L, "gpio.pulse", (void *)pulse_map);
luaL_rometatable(L, "gpio.pulse", LROT_TABLEREF(pulse));
tasknumber = task_get_id(gpio_pulse_task);
return 0;
}
//NODEMCU_MODULE(GPIOPULSE, "gpiopulse", gpio_pulse_map, gpio_pulse_init);
NODEMCU_MODULE(GPIOPULSE, "gpiopulse", gpio_pulse, gpio_pulse_init);
......@@ -99,10 +99,10 @@ static int hdc1080_read(lua_State* L) {
return 2;
}
static const LUA_REG_TYPE hdc1080_map[] = {
{ LSTRKEY( "read" ), LFUNCVAL( hdc1080_read )},
{ LSTRKEY( "setup" ), LFUNCVAL( hdc1080_setup )},
{ LNILKEY, LNILVAL}
};
LROT_BEGIN(hdc1080)
LROT_FUNCENTRY( read, hdc1080_read )
LROT_FUNCENTRY( setup, hdc1080_setup )
LROT_END( hdc1080, NULL, 0 )
NODEMCU_MODULE(HDC1080, "hdc1080", hdc1080_map, NULL);
NODEMCU_MODULE(HDC1080, "hdc1080", hdc1080, NULL);
......@@ -89,10 +89,10 @@ static int hmc5883_read(lua_State* L) {
return 3;
}
static const LUA_REG_TYPE hmc5883_map[] = {
{ LSTRKEY( "read" ), LFUNCVAL( hmc5883_read )},
{ LSTRKEY( "setup" ), LFUNCVAL( hmc5883_setup )},
{ LNILKEY, LNILVAL}
};
LROT_BEGIN(hmc5883)
LROT_FUNCENTRY( read, hmc5883_read )
LROT_FUNCENTRY( setup, hmc5883_setup )
LROT_END( hmc5883, NULL, 0 )
NODEMCU_MODULE(HMC5883L, "hmc5883l", hmc5883_map, NULL);
NODEMCU_MODULE(HMC5883L, "hmc5883l", hmc5883, NULL);
......@@ -269,17 +269,17 @@ static int http_lapi_get( lua_State *L )
}
// Module function map
static const LUA_REG_TYPE http_map[] = {
{ LSTRKEY( "request" ), LFUNCVAL( http_lapi_request ) },
{ LSTRKEY( "post" ), LFUNCVAL( http_lapi_post ) },
{ LSTRKEY( "put" ), LFUNCVAL( http_lapi_put ) },
{ LSTRKEY( "delete" ), LFUNCVAL( http_lapi_delete ) },
{ LSTRKEY( "get" ), LFUNCVAL( http_lapi_get ) },
LROT_BEGIN(http)
LROT_FUNCENTRY( request, http_lapi_request )
LROT_FUNCENTRY( post, http_lapi_post )
LROT_FUNCENTRY( put, http_lapi_put )
LROT_FUNCENTRY( delete, http_lapi_delete )
LROT_FUNCENTRY( get, http_lapi_get )
{ LSTRKEY( "OK" ), LNUMVAL( 0 ) },
{ LSTRKEY( "ERROR" ), LNUMVAL( HTTP_STATUS_GENERIC_ERROR ) },
LROT_NUMENTRY( OK, 0 )
LROT_NUMENTRY( ERROR, HTTP_STATUS_GENERIC_ERROR )
{ LNILKEY, LNILVAL }
};
LROT_END( http, NULL, 0 )
NODEMCU_MODULE(HTTP, "http", http_map, NULL);
NODEMCU_MODULE(HTTP, "http", http, NULL);
......@@ -66,15 +66,15 @@ static int ICACHE_FLASH_ATTR hx711_read(lua_State* L) {
}
// Module function map
static const LUA_REG_TYPE hx711_map[] = {
{ LSTRKEY( "init" ), LFUNCVAL( hx711_init )},
{ LSTRKEY( "read" ), LFUNCVAL( hx711_read )},
{ LNILKEY, LNILVAL}
};
LROT_BEGIN(hx711)
LROT_FUNCENTRY( init, hx711_init )
LROT_FUNCENTRY( read, hx711_read )
LROT_END( hx711, NULL, 0 )
int luaopen_hx711(lua_State *L) {
// TODO: Make sure that the GPIO system is initialized
return 0;
}
NODEMCU_MODULE(HX711, "hx711", hx711_map, luaopen_hx711);
NODEMCU_MODULE(HX711, "hx711", hx711, luaopen_hx711);
......@@ -146,19 +146,19 @@ static int i2c_read( lua_State *L )
}
// Module function map
static const LUA_REG_TYPE i2c_map[] = {
{ LSTRKEY( "setup" ), LFUNCVAL( i2c_setup ) },
{ LSTRKEY( "start" ), LFUNCVAL( i2c_start ) },
{ LSTRKEY( "stop" ), LFUNCVAL( i2c_stop ) },
{ LSTRKEY( "address" ), LFUNCVAL( i2c_address ) },
{ LSTRKEY( "write" ), LFUNCVAL( i2c_write ) },
{ LSTRKEY( "read" ), LFUNCVAL( i2c_read ) },
{ LSTRKEY( "FASTPLUS" ), LNUMVAL( PLATFORM_I2C_SPEED_FASTPLUS ) },
{ LSTRKEY( "FAST" ), LNUMVAL( PLATFORM_I2C_SPEED_FAST ) },
{ LSTRKEY( "SLOW" ), LNUMVAL( PLATFORM_I2C_SPEED_SLOW ) },
{ LSTRKEY( "TRANSMITTER" ), LNUMVAL( PLATFORM_I2C_DIRECTION_TRANSMITTER ) },
{ LSTRKEY( "RECEIVER" ), LNUMVAL( PLATFORM_I2C_DIRECTION_RECEIVER ) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(I2C, "i2c", i2c_map, NULL);
LROT_BEGIN(i2c)
LROT_FUNCENTRY( setup, i2c_setup )
LROT_FUNCENTRY( start, i2c_start )
LROT_FUNCENTRY( stop, i2c_stop )
LROT_FUNCENTRY( address, i2c_address )
LROT_FUNCENTRY( write, i2c_write )
LROT_FUNCENTRY( read, i2c_read )
LROT_NUMENTRY( FASTPLUS, PLATFORM_I2C_SPEED_FASTPLUS )
LROT_NUMENTRY( FAST, PLATFORM_I2C_SPEED_FAST )
LROT_NUMENTRY( SLOW, PLATFORM_I2C_SPEED_SLOW )
LROT_NUMENTRY( TRANSMITTER, PLATFORM_I2C_DIRECTION_TRANSMITTER )
LROT_NUMENTRY( RECEIVER, PLATFORM_I2C_DIRECTION_RECEIVER )
LROT_END( i2c, NULL, 0 )
NODEMCU_MODULE(I2C, "i2c", i2c, NULL);
......@@ -79,10 +79,10 @@ static int l3g4200d_read(lua_State* L) {
return 3;
}
static const LUA_REG_TYPE l3g4200d_map[] = {
{ LSTRKEY( "read" ), LFUNCVAL( l3g4200d_read )},
{ LSTRKEY( "setup" ), LFUNCVAL( l3g4200d_setup )},
{ LNILKEY, LNILVAL}
};
LROT_BEGIN(l3g4200d)
LROT_FUNCENTRY( read, l3g4200d_read )
LROT_FUNCENTRY( setup, l3g4200d_setup )
LROT_END( l3g4200d, NULL, 0 )
NODEMCU_MODULE(L3G4200D, "l3g4200d", l3g4200d_map, NULL);
NODEMCU_MODULE(L3G4200D, "l3g4200d", l3g4200d, NULL);
......@@ -204,14 +204,14 @@ static int mcp4725_read(lua_State* L){
}
static const LUA_REG_TYPE mcp4725_map[] = {
{ LSTRKEY( "write" ), LFUNCVAL( mcp4725_write ) },
{ LSTRKEY( "read" ), LFUNCVAL( mcp4725_read ) },
{ LSTRKEY( "PWRDN_NONE" ), LNUMVAL(MCP4725_POWER_DOWN_NORMAL) },
{ LSTRKEY( "PWRDN_1K" ), LNUMVAL((MCP4725_POWER_DOWN_RES_1K)>>1) },
{ LSTRKEY( "PWRDN_100K" ), LNUMVAL((MCP4725_POWER_DOWN_RES_100K)>>1) },
{ LSTRKEY( "PWRDN_500K" ), LNUMVAL((MCP4725_POWER_DOWN_RES_500K)>>1) },
{ LNILKEY, LNILVAL}
};
NODEMCU_MODULE(MCP4725, "mcp4725", mcp4725_map, NULL);
LROT_BEGIN(mcp4725)
LROT_FUNCENTRY( write, mcp4725_write )
LROT_FUNCENTRY( read, mcp4725_read )
LROT_NUMENTRY( PWRDN_NONE, MCP4725_POWER_DOWN_NORMAL )
LROT_NUMENTRY( PWRDN_1K, MCP4725_POWER_DOWN_RES_1K>>1 )
LROT_NUMENTRY( PWRDN_100K, MCP4725_POWER_DOWN_RES_100K>>1 )
LROT_NUMENTRY( PWRDN_500K, MCP4725_POWER_DOWN_RES_500K>>1 )
LROT_END( mcp4725, NULL, 0 )
NODEMCU_MODULE(MCP4725, "mcp4725", mcp4725, NULL);
......@@ -88,10 +88,10 @@ static int mdns_register(lua_State *L)
}
// Module function map
static const LUA_REG_TYPE mdns_map[] = {
{ LSTRKEY("register"), LFUNCVAL(mdns_register) },
{ LSTRKEY("close"), LFUNCVAL(mdns_close) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(mdns)
LROT_FUNCENTRY( register, mdns_register )
LROT_FUNCENTRY( close, mdns_close )
LROT_END( mdns, NULL, 0 )
NODEMCU_MODULE(MDNS, "mdns", mdns_map, NULL);
NODEMCU_MODULE(MDNS, "mdns", mdns, NULL);
......@@ -1873,43 +1873,43 @@ static int mqtt_socket_lwt( lua_State* L )
}
// Module function map
static const LUA_REG_TYPE mqtt_socket_map[] = {
{ LSTRKEY( "connect" ), LFUNCVAL( mqtt_socket_connect ) },
{ LSTRKEY( "close" ), LFUNCVAL( mqtt_socket_close ) },
{ LSTRKEY( "publish" ), LFUNCVAL( mqtt_socket_publish ) },
{ LSTRKEY( "subscribe" ), LFUNCVAL( mqtt_socket_subscribe ) },
{ LSTRKEY( "unsubscribe" ), LFUNCVAL( mqtt_socket_unsubscribe ) },
{ LSTRKEY( "lwt" ), LFUNCVAL( mqtt_socket_lwt ) },
{ LSTRKEY( "on" ), LFUNCVAL( mqtt_socket_on ) },
{ LSTRKEY( "__gc" ), LFUNCVAL( mqtt_delete ) },
{ LSTRKEY( "__index" ), LROVAL( mqtt_socket_map ) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE mqtt_map[] = {
{ LSTRKEY( "Client" ), LFUNCVAL( mqtt_socket_client ) },
{ LSTRKEY( "CONN_FAIL_SERVER_NOT_FOUND" ), LNUMVAL( MQTT_CONN_FAIL_SERVER_NOT_FOUND ) },
{ LSTRKEY( "CONN_FAIL_NOT_A_CONNACK_MSG" ), LNUMVAL( MQTT_CONN_FAIL_NOT_A_CONNACK_MSG ) },
{ LSTRKEY( "CONN_FAIL_DNS" ), LNUMVAL( MQTT_CONN_FAIL_DNS ) },
{ LSTRKEY( "CONN_FAIL_TIMEOUT_RECEIVING" ), LNUMVAL( MQTT_CONN_FAIL_TIMEOUT_RECEIVING ) },
{ LSTRKEY( "CONN_FAIL_TIMEOUT_SENDING" ), LNUMVAL( MQTT_CONN_FAIL_TIMEOUT_SENDING ) },
{ LSTRKEY( "CONNACK_ACCEPTED" ), LNUMVAL( MQTT_CONNACK_ACCEPTED ) },
{ LSTRKEY( "CONNACK_REFUSED_PROTOCOL_VER" ), LNUMVAL( MQTT_CONNACK_REFUSED_PROTOCOL_VER ) },
{ LSTRKEY( "CONNACK_REFUSED_ID_REJECTED" ), LNUMVAL( MQTT_CONNACK_REFUSED_ID_REJECTED ) },
{ LSTRKEY( "CONNACK_REFUSED_SERVER_UNAVAILABLE" ), LNUMVAL( MQTT_CONNACK_REFUSED_SERVER_UNAVAILABLE ) },
{ LSTRKEY( "CONNACK_REFUSED_BAD_USER_OR_PASS" ), LNUMVAL( MQTT_CONNACK_REFUSED_BAD_USER_OR_PASS ) },
{ LSTRKEY( "CONNACK_REFUSED_NOT_AUTHORIZED" ), LNUMVAL( MQTT_CONNACK_REFUSED_NOT_AUTHORIZED ) },
{ LSTRKEY( "__metatable" ), LROVAL( mqtt_map ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(mqtt_socket)
LROT_FUNCENTRY( connect, mqtt_socket_connect )
LROT_FUNCENTRY( close, mqtt_socket_close )
LROT_FUNCENTRY( publish, mqtt_socket_publish )
LROT_FUNCENTRY( subscribe, mqtt_socket_subscribe )
LROT_FUNCENTRY( unsubscribe, mqtt_socket_unsubscribe )
LROT_FUNCENTRY( lwt, mqtt_socket_lwt )
LROT_FUNCENTRY( on, mqtt_socket_on )
LROT_FUNCENTRY( __gc, mqtt_delete )
LROT_TABENTRY( __index, mqtt_socket )
LROT_END( mqtt_socket, mqtt_socket, 0 )
LROT_BEGIN(mqtt)
LROT_FUNCENTRY( Client, mqtt_socket_client )
LROT_NUMENTRY( CONN_FAIL_SERVER_NOT_FOUND, MQTT_CONN_FAIL_SERVER_NOT_FOUND )
LROT_NUMENTRY( CONN_FAIL_NOT_A_CONNACK_MSG, MQTT_CONN_FAIL_NOT_A_CONNACK_MSG )
LROT_NUMENTRY( CONN_FAIL_DNS, MQTT_CONN_FAIL_DNS )
LROT_NUMENTRY( CONN_FAIL_TIMEOUT_RECEIVING, MQTT_CONN_FAIL_TIMEOUT_RECEIVING )
LROT_NUMENTRY( CONN_FAIL_TIMEOUT_SENDING, MQTT_CONN_FAIL_TIMEOUT_SENDING )
LROT_NUMENTRY( CONNACK_ACCEPTED, MQTT_CONNACK_ACCEPTED )
LROT_NUMENTRY( CONNACK_REFUSED_PROTOCOL_VER, MQTT_CONNACK_REFUSED_PROTOCOL_VER )
LROT_NUMENTRY( CONNACK_REFUSED_ID_REJECTED, MQTT_CONNACK_REFUSED_ID_REJECTED )
LROT_NUMENTRY( CONNACK_REFUSED_SERVER_UNAVAILABLE, MQTT_CONNACK_REFUSED_SERVER_UNAVAILABLE )
LROT_NUMENTRY( CONNACK_REFUSED_BAD_USER_OR_PASS, MQTT_CONNACK_REFUSED_BAD_USER_OR_PASS )
LROT_NUMENTRY( CONNACK_REFUSED_NOT_AUTHORIZED, MQTT_CONNACK_REFUSED_NOT_AUTHORIZED )
LROT_TABENTRY( __metatable, mqtt )
LROT_END( mqtt, mqtt, 0 )
int luaopen_mqtt( lua_State *L )
{
luaL_rometatable(L, "mqtt.socket", (void *)mqtt_socket_map); // create metatable for mqtt.socket
luaL_rometatable(L, "mqtt.socket", LROT_TABLEREF(mqtt_socket));
return 0;
}
NODEMCU_MODULE(MQTT, "mqtt", mqtt_map, luaopen_mqtt);
NODEMCU_MODULE(MQTT, "mqtt", mqtt, luaopen_mqtt);
......@@ -968,79 +968,79 @@ static int net_getdnsserver( lua_State* L ) {
#pragma mark - Tables
#ifdef TLS_MODULE_PRESENT
extern const LUA_REG_TYPE tls_cert_map[];
LROT_EXTERN(tls_cert);
#endif
// Module function map
static const LUA_REG_TYPE net_tcpserver_map[] = {
{ LSTRKEY( "listen" ), LFUNCVAL( net_listen ) },
{ LSTRKEY( "getaddr" ), LFUNCVAL( net_getaddr ) },
{ LSTRKEY( "close" ), LFUNCVAL( net_close ) },
{ LSTRKEY( "__gc" ), LFUNCVAL( net_delete ) },
{ LSTRKEY( "__index" ), LROVAL( net_tcpserver_map ) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE net_tcpsocket_map[] = {
{ LSTRKEY( "connect" ), LFUNCVAL( net_connect ) },
{ LSTRKEY( "close" ), LFUNCVAL( net_close ) },
{ LSTRKEY( "on" ), LFUNCVAL( net_on ) },
{ LSTRKEY( "send" ), LFUNCVAL( net_send ) },
{ LSTRKEY( "hold" ), LFUNCVAL( net_hold ) },
{ LSTRKEY( "unhold" ), LFUNCVAL( net_unhold ) },
{ LSTRKEY( "dns" ), LFUNCVAL( net_dns ) },
{ LSTRKEY( "ttl" ), LFUNCVAL( net_ttl ) },
{ LSTRKEY( "getpeer" ), LFUNCVAL( net_getpeer ) },
{ LSTRKEY( "getaddr" ), LFUNCVAL( net_getaddr ) },
{ LSTRKEY( "__gc" ), LFUNCVAL( net_delete ) },
{ LSTRKEY( "__index" ), LROVAL( net_tcpsocket_map ) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE net_udpsocket_map[] = {
{ LSTRKEY( "listen" ), LFUNCVAL( net_listen ) },
{ LSTRKEY( "close" ), LFUNCVAL( net_close ) },
{ LSTRKEY( "on" ), LFUNCVAL( net_on ) },
{ LSTRKEY( "send" ), LFUNCVAL( net_send ) },
{ LSTRKEY( "dns" ), LFUNCVAL( net_dns ) },
{ LSTRKEY( "ttl" ), LFUNCVAL( net_ttl ) },
{ LSTRKEY( "getaddr" ), LFUNCVAL( net_getaddr ) },
{ LSTRKEY( "__gc" ), LFUNCVAL( net_delete ) },
{ LSTRKEY( "__index" ), LROVAL( net_udpsocket_map ) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE net_dns_map[] = {
{ LSTRKEY( "setdnsserver" ), LFUNCVAL( net_setdnsserver ) },
{ LSTRKEY( "getdnsserver" ), LFUNCVAL( net_getdnsserver ) },
{ LSTRKEY( "resolve" ), LFUNCVAL( net_dns_static ) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE net_map[] = {
{ LSTRKEY( "createServer" ), LFUNCVAL( net_createServer ) },
{ LSTRKEY( "createConnection" ), LFUNCVAL( net_createConnection ) },
{ LSTRKEY( "createUDPSocket" ), LFUNCVAL( net_createUDPSocket ) },
{ LSTRKEY( "multicastJoin"), LFUNCVAL( net_multicastJoin ) },
{ LSTRKEY( "multicastLeave"), LFUNCVAL( net_multicastLeave ) },
{ LSTRKEY( "dns" ), LROVAL( net_dns_map ) },
LROT_BEGIN(net_tcpserver)
LROT_FUNCENTRY( listen, net_listen )
LROT_FUNCENTRY( getaddr, net_getaddr )
LROT_FUNCENTRY( close, net_close )
LROT_FUNCENTRY( __gc, net_delete )
LROT_TABENTRY( __index, net_tcpserver )
LROT_END( net_tcpserver, net_tcpserver, 0 )
LROT_BEGIN(net_tcpsocket)
LROT_FUNCENTRY( connect, net_connect )
LROT_FUNCENTRY( close, net_close )
LROT_FUNCENTRY( on, net_on )
LROT_FUNCENTRY( send, net_send )
LROT_FUNCENTRY( hold, net_hold )
LROT_FUNCENTRY( unhold, net_unhold )
LROT_FUNCENTRY( dns, net_dns )
LROT_FUNCENTRY( ttl, net_ttl )
LROT_FUNCENTRY( getpeer, net_getpeer )
LROT_FUNCENTRY( getaddr, net_getaddr )
LROT_FUNCENTRY( __gc, net_delete )
LROT_TABENTRY( __index, net_tcpsocket )
LROT_END( net_tcpsocket, net_tcpsocket, 0 )
LROT_BEGIN(net_udpsocket)
LROT_FUNCENTRY( listen, net_listen )
LROT_FUNCENTRY( close, net_close )
LROT_FUNCENTRY( on, net_on )
LROT_FUNCENTRY( send, net_send )
LROT_FUNCENTRY( dns, net_dns )
LROT_FUNCENTRY( ttl, net_ttl )
LROT_FUNCENTRY( getaddr, net_getaddr )
LROT_FUNCENTRY( __gc, net_delete )
LROT_TABENTRY( __index, net_udpsocket )
LROT_END( net_udpsocket, net_udpsocket, 0 )
LROT_BEGIN(net_dns)
LROT_FUNCENTRY( setdnsserver, net_setdnsserver )
LROT_FUNCENTRY( getdnsserver, net_getdnsserver )
LROT_FUNCENTRY( resolve, net_dns_static )
LROT_END( net_dns, net_dns, 0 )
LROT_BEGIN(net)
LROT_FUNCENTRY( createServer, net_createServer )
LROT_FUNCENTRY( createConnection, net_createConnection )
LROT_FUNCENTRY( createUDPSocket, net_createUDPSocket )
LROT_FUNCENTRY( multicastJoin, net_multicastJoin )
LROT_FUNCENTRY( multicastLeave, net_multicastLeave )
LROT_TABENTRY( dns, net_dns )
#ifdef TLS_MODULE_PRESENT
{ LSTRKEY( "cert" ), LROVAL( tls_cert_map ) },
LROT_TABENTRY( cert, tls_cert )
#endif
{ LSTRKEY( "TCP" ), LNUMVAL( TYPE_TCP ) },
{ LSTRKEY( "UDP" ), LNUMVAL( TYPE_UDP ) },
{ LSTRKEY( "__metatable" ), LROVAL( net_map ) },
{ LNILKEY, LNILVAL }
};
LROT_NUMENTRY( TCP, TYPE_TCP )
LROT_NUMENTRY( UDP, TYPE_UDP )
LROT_TABENTRY( __metatable, net )
LROT_END( net, net, 0 )
int luaopen_net( lua_State *L ) {
igmp_init();
luaL_rometatable(L, NET_TABLE_TCP_SERVER, (void *)net_tcpserver_map);
luaL_rometatable(L, NET_TABLE_TCP_CLIENT, (void *)net_tcpsocket_map);
luaL_rometatable(L, NET_TABLE_UDP_SOCKET, (void *)net_udpsocket_map);
luaL_rometatable(L, NET_TABLE_TCP_SERVER, LROT_TABLEREF(net_tcpserver));
luaL_rometatable(L, NET_TABLE_TCP_CLIENT, LROT_TABLEREF(net_tcpsocket));
luaL_rometatable(L, NET_TABLE_UDP_SOCKET, LROT_TABLEREF(net_udpsocket));
return 0;
}
NODEMCU_MODULE(NET, "net", net_map, luaopen_net);
NODEMCU_MODULE(NET, "net", net, luaopen_net);
......@@ -15,7 +15,6 @@
#include "lundump.h"
#include "platform.h"
#include "lrodefs.h"
#include "lflash.h"
#include "c_types.h"
#include "c_string.h"
......@@ -593,13 +592,13 @@ static int node_writercr (lua_State *L) {
typedef enum pt_t { lfs_addr=0, lfs_size, spiffs_addr, spiffs_size, max_pt} pt_t;
static const LUA_REG_TYPE pt_map[] = {
{ LSTRKEY( "lfs_addr" ), LNUMVAL( lfs_addr ) },
{ LSTRKEY( "lfs_size" ), LNUMVAL( lfs_size ) },
{ LSTRKEY( "spiffs_addr" ), LNUMVAL( spiffs_addr ) },
{ LSTRKEY( "spiffs_size" ), LNUMVAL( spiffs_size ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(pt)
LROT_NUMENTRY( lfs_addr, lfs_addr )
LROT_NUMENTRY( lfs_size, lfs_size )
LROT_NUMENTRY( spiffs_addr, spiffs_addr )
LROT_NUMENTRY( spiffs_size, spiffs_size )
LROT_END( pt, NULL, 0 )
// Lua: ptinfo = node.getpartitiontable()
static int node_getpartitiontable (lua_State *L) {
......@@ -745,69 +744,67 @@ static int node_setpartitiontable (lua_State *L) {
// Module function map
static const LUA_REG_TYPE node_egc_map[] = {
{ LSTRKEY( "meminfo" ), LFUNCVAL( node_egc_meminfo ) },
{ LSTRKEY( "setmode" ), LFUNCVAL( node_egc_setmode ) },
{ LSTRKEY( "NOT_ACTIVE" ), LNUMVAL( EGC_NOT_ACTIVE ) },
{ LSTRKEY( "ON_ALLOC_FAILURE" ), LNUMVAL( EGC_ON_ALLOC_FAILURE ) },
{ LSTRKEY( "ON_MEM_LIMIT" ), LNUMVAL( EGC_ON_MEM_LIMIT ) },
{ LSTRKEY( "ALWAYS" ), LNUMVAL( EGC_ALWAYS ) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE node_task_map[] = {
{ LSTRKEY( "post" ), LFUNCVAL( node_task_post ) },
{ LSTRKEY( "LOW_PRIORITY" ), LNUMVAL( TASK_PRIORITY_LOW ) },
{ LSTRKEY( "MEDIUM_PRIORITY" ), LNUMVAL( TASK_PRIORITY_MEDIUM ) },
{ LSTRKEY( "HIGH_PRIORITY" ), LNUMVAL( TASK_PRIORITY_HIGH ) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE node_map[] =
{
{ LSTRKEY( "heap" ), LFUNCVAL( node_heap ) },
{ LSTRKEY( "info" ), LFUNCVAL( node_info ) },
{ LSTRKEY( "task" ), LROVAL( node_task_map ) },
{ LSTRKEY( "flashreload" ), LFUNCVAL( luaN_reload_reboot ) },
{ LSTRKEY( "flashindex" ), LFUNCVAL( luaN_index ) },
{ LSTRKEY( "restart" ), LFUNCVAL( node_restart ) },
{ LSTRKEY( "dsleep" ), LFUNCVAL( node_deepsleep ) },
{ LSTRKEY( "dsleepMax" ), LFUNCVAL( dsleepMax ) },
{ LSTRKEY( "sleep" ), LFUNCVAL( node_sleep ) },
LROT_BEGIN(node_egc)
LROT_FUNCENTRY( meminfo, node_egc_meminfo )
LROT_FUNCENTRY( setmode, node_egc_setmode )
LROT_NUMENTRY( NOT_ACTIVE, EGC_NOT_ACTIVE )
LROT_NUMENTRY( ON_ALLOC_FAILURE, EGC_ON_ALLOC_FAILURE )
LROT_NUMENTRY( ON_MEM_LIMIT, EGC_ON_MEM_LIMIT )
LROT_NUMENTRY( ALWAYS, EGC_ALWAYS )
LROT_END( node_egc, NULL, 0 )
LROT_BEGIN(node_task)
LROT_FUNCENTRY( post, node_task_post )
LROT_NUMENTRY( LOW_PRIORITY, TASK_PRIORITY_LOW )
LROT_NUMENTRY( MEDIUM_PRIORITY, TASK_PRIORITY_MEDIUM )
LROT_NUMENTRY( HIGH_PRIORITY, TASK_PRIORITY_HIGH )
LROT_END( node_task, NULL, 0 )
LROT_BEGIN(node)
LROT_FUNCENTRY( heap, node_heap )
LROT_FUNCENTRY( info, node_info )
LROT_TABENTRY( task, node_task )
LROT_FUNCENTRY( flashreload, luaN_reload_reboot )
LROT_FUNCENTRY( flashindex, luaN_index )
LROT_FUNCENTRY( restart, node_restart )
LROT_FUNCENTRY( dsleep, node_deepsleep )
LROT_FUNCENTRY( dsleepMax, dsleepMax )
LROT_FUNCENTRY( sleep, node_sleep )
#ifdef PMSLEEP_ENABLE
PMSLEEP_INT_MAP,
#endif
#ifdef DEVELOPMENT_TOOLS
{ LSTRKEY( "readrcr" ), LFUNCVAL( node_readrcr ) },
{ LSTRKEY( "writercr" ), LFUNCVAL( node_writercr ) },
LROT_FUNCENTRY( readrcr, node_readrcr )
LROT_FUNCENTRY( writercr, node_writercr )
#endif
{ LSTRKEY( "chipid" ), LFUNCVAL( node_chipid ) },
{ LSTRKEY( "flashid" ), LFUNCVAL( node_flashid ) },
{ LSTRKEY( "flashsize" ), LFUNCVAL( node_flashsize) },
{ LSTRKEY( "input" ), LFUNCVAL( node_input ) },
{ LSTRKEY( "output" ), LFUNCVAL( node_output ) },
LROT_FUNCENTRY( chipid, node_chipid )
LROT_FUNCENTRY( flashid, node_flashid )
LROT_FUNCENTRY( flashsize, node_flashsize )
LROT_FUNCENTRY( input, node_input )
LROT_FUNCENTRY( output, node_output )
// Moved to adc module, use adc.readvdd33()
// { LSTRKEY( "readvdd33" ), LFUNCVAL( node_readvdd33) },
{ LSTRKEY( "compile" ), LFUNCVAL( node_compile) },
{ LSTRKEY( "CPU80MHZ" ), LNUMVAL( CPU80MHZ ) },
{ LSTRKEY( "CPU160MHZ" ), LNUMVAL( CPU160MHZ ) },
{ LSTRKEY( "setcpufreq" ), LFUNCVAL( node_setcpufreq) },
{ LSTRKEY( "getcpufreq" ), LFUNCVAL( node_getcpufreq) },
{ LSTRKEY( "bootreason" ), LFUNCVAL( node_bootreason) },
{ LSTRKEY( "restore" ), LFUNCVAL( node_restore) },
{ LSTRKEY( "random" ), LFUNCVAL( node_random) },
// LROT_FUNCENTRY( readvdd33, node_readvdd33 )
LROT_FUNCENTRY( compile, node_compile )
LROT_NUMENTRY( CPU80MHZ, CPU80MHZ )
LROT_NUMENTRY( CPU160MHZ, CPU160MHZ )
LROT_FUNCENTRY( setcpufreq, node_setcpufreq )
LROT_FUNCENTRY( getcpufreq, node_getcpufreq )
LROT_FUNCENTRY( bootreason, node_bootreason )
LROT_FUNCENTRY( restore, node_restore )
LROT_FUNCENTRY( random, node_random )
#ifdef LUA_OPTIMIZE_DEBUG
{ LSTRKEY( "stripdebug" ), LFUNCVAL( node_stripdebug ) },
LROT_FUNCENTRY( stripdebug, node_stripdebug )
#endif
{ LSTRKEY( "egc" ), LROVAL( node_egc_map ) },
LROT_TABENTRY( egc, node_egc )
#ifdef DEVELOPMENT_TOOLS
{ LSTRKEY( "osprint" ), LFUNCVAL( node_osprint ) },
LROT_FUNCENTRY( osprint, node_osprint )
#endif
{ LSTRKEY( "getpartitiontable" ), LFUNCVAL( node_getpartitiontable ) },
{ LSTRKEY( "setpartitiontable" ), LFUNCVAL( node_setpartitiontable ) },
LROT_FUNCENTRY( getpartitiontable, node_getpartitiontable )
LROT_FUNCENTRY( setpartitiontable, node_setpartitiontable )
// Combined to dsleep(us, option)
// { LSTRKEY( "dsleepsetoption" ), LFUNCVAL( node_deepsleep_setoption) },
{ LNILKEY, LNILVAL }
};
// LROT_FUNCENTRY( dsleepsetoption, node_deepsleep_setoption )
LROT_END( node, NULL, 0 )
NODEMCU_MODULE(NODE, "node", node_map, NULL);
NODEMCU_MODULE(NODE, "node", node, NULL);
......@@ -282,29 +282,29 @@ static int ow_crc16( lua_State *L )
#endif
// Module function map
static const LUA_REG_TYPE ow_map[] = {
{ LSTRKEY( "setup" ), LFUNCVAL( ow_setup ) },
{ LSTRKEY( "reset" ), LFUNCVAL( ow_reset ) },
{ LSTRKEY( "skip" ), LFUNCVAL( ow_skip ) },
{ LSTRKEY( "select" ), LFUNCVAL( ow_select ) },
{ LSTRKEY( "write" ), LFUNCVAL( ow_write ) },
{ LSTRKEY( "write_bytes" ), LFUNCVAL( ow_write_bytes ) },
{ LSTRKEY( "read" ), LFUNCVAL( ow_read ) },
{ LSTRKEY( "read_bytes" ), LFUNCVAL( ow_read_bytes ) },
{ LSTRKEY( "depower" ), LFUNCVAL( ow_depower ) },
LROT_BEGIN(ow)
LROT_FUNCENTRY( setup, ow_setup )
LROT_FUNCENTRY( reset, ow_reset )
LROT_FUNCENTRY( skip, ow_skip )
LROT_FUNCENTRY( select, ow_select )
LROT_FUNCENTRY( write, ow_write )
LROT_FUNCENTRY( write_bytes, ow_write_bytes )
LROT_FUNCENTRY( read, ow_read )
LROT_FUNCENTRY( read_bytes, ow_read_bytes )
LROT_FUNCENTRY( depower, ow_depower )
#if ONEWIRE_SEARCH
{ LSTRKEY( "reset_search" ), LFUNCVAL( ow_reset_search ) },
{ LSTRKEY( "target_search" ), LFUNCVAL( ow_target_search ) },
{ LSTRKEY( "search" ), LFUNCVAL( ow_search ) },
LROT_FUNCENTRY( reset_search, ow_reset_search )
LROT_FUNCENTRY( target_search, ow_target_search )
LROT_FUNCENTRY( search, ow_search )
#endif
#if ONEWIRE_CRC
{ LSTRKEY( "crc8" ), LFUNCVAL( ow_crc8 ) },
LROT_FUNCENTRY( crc8, ow_crc8 )
#if ONEWIRE_CRC16
{ LSTRKEY( "check_crc16" ), LFUNCVAL( ow_check_crc16 ) },
{ LSTRKEY( "crc16" ), LFUNCVAL( ow_crc16 ) },
LROT_FUNCENTRY( check_crc16, ow_check_crc16 )
LROT_FUNCENTRY( crc16, ow_crc16 )
#endif
#endif
{ LNILKEY, LNILVAL }
};
LROT_END( ow, NULL, 0 )
NODEMCU_MODULE(OW, "ow", ow_map, NULL);
NODEMCU_MODULE(OW, "ow", ow, NULL);
......@@ -229,34 +229,34 @@ static int pcm_new( lua_State *L )
}
static const LUA_REG_TYPE pcm_driver_map[] = {
{ LSTRKEY( "play" ), LFUNCVAL( pcm_drv_play ) },
{ LSTRKEY( "pause" ), LFUNCVAL( pcm_drv_pause ) },
{ LSTRKEY( "stop" ), LFUNCVAL( pcm_drv_stop ) },
{ LSTRKEY( "close" ), LFUNCVAL( pcm_drv_close ) },
{ LSTRKEY( "on" ), LFUNCVAL( pcm_drv_on ) },
{ LSTRKEY( "__gc" ), LFUNCVAL( pcm_drv_free ) },
{ LSTRKEY( "__index" ), LROVAL( pcm_driver_map ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(pcm_driver)
LROT_FUNCENTRY( play, pcm_drv_play )
LROT_FUNCENTRY( pause, pcm_drv_pause )
LROT_FUNCENTRY( stop, pcm_drv_stop )
LROT_FUNCENTRY( close, pcm_drv_close )
LROT_FUNCENTRY( on, pcm_drv_on )
LROT_FUNCENTRY( __gc, pcm_drv_free )
LROT_TABENTRY( __index, pcm_driver )
LROT_END( pcm_driver, pcm_driver, LROT_MASK_GC_INDEX )
// Module function map
static const LUA_REG_TYPE pcm_map[] = {
{ LSTRKEY( "new" ), LFUNCVAL( pcm_new ) },
{ LSTRKEY( "SD" ), LNUMVAL( PCM_DRIVER_SD ) },
{ LSTRKEY( "RATE_1K" ), LNUMVAL( PCM_RATE_1K ) },
{ LSTRKEY( "RATE_2K" ), LNUMVAL( PCM_RATE_2K ) },
{ LSTRKEY( "RATE_4K" ), LNUMVAL( PCM_RATE_4K ) },
{ LSTRKEY( "RATE_5K" ), LNUMVAL( PCM_RATE_5K ) },
{ LSTRKEY( "RATE_8K" ), LNUMVAL( PCM_RATE_8K ) },
{ LSTRKEY( "RATE_10K" ), LNUMVAL( PCM_RATE_10K ) },
{ LSTRKEY( "RATE_12K" ), LNUMVAL( PCM_RATE_12K ) },
{ LSTRKEY( "RATE_16K" ), LNUMVAL( PCM_RATE_16K ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(pcm)
LROT_FUNCENTRY( new, pcm_new )
LROT_NUMENTRY( SD, PCM_DRIVER_SD )
LROT_NUMENTRY( RATE_1K, PCM_RATE_1K )
LROT_NUMENTRY( RATE_2K, PCM_RATE_2K )
LROT_NUMENTRY( RATE_4K, PCM_RATE_4K )
LROT_NUMENTRY( RATE_5K, PCM_RATE_5K )
LROT_NUMENTRY( RATE_8K, PCM_RATE_8K )
LROT_NUMENTRY( RATE_10K, PCM_RATE_10K )
LROT_NUMENTRY( RATE_12K, PCM_RATE_12K )
LROT_NUMENTRY( RATE_16K, PCM_RATE_16K )
LROT_END( pcm, NULL, 0 )
int luaopen_pcm( lua_State *L ) {
luaL_rometatable( L, "pcm.driver", (void *)pcm_driver_map ); // create metatable
luaL_rometatable( L, "pcm.driver", LROT_TABLEREF(pcm_driver));
pcm_data_vu_task = task_get_id( pcm_data_vu );
pcm_data_play_task = task_get_id( pcm_data_play );
......@@ -264,4 +264,4 @@ int luaopen_pcm( lua_State *L ) {
return 0;
}
NODEMCU_MODULE(PCM, "pcm", pcm_map, luaopen_pcm);
NODEMCU_MODULE(PCM, "pcm", pcm, luaopen_pcm);
......@@ -135,10 +135,10 @@ static int perf_stop(lua_State *L)
return 4;
}
static const LUA_REG_TYPE perf_map[] = {
{ LSTRKEY( "start" ), LFUNCVAL( perf_start ) },
{ LSTRKEY( "stop" ), LFUNCVAL( perf_stop ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(perf)
LROT_FUNCENTRY( start, perf_start )
LROT_FUNCENTRY( stop, perf_stop )
LROT_END( perf, NULL, 0 )
NODEMCU_MODULE(PERF, "perf", perf_map, NULL);
NODEMCU_MODULE(PERF, "perf", perf, NULL);
......@@ -128,16 +128,16 @@ int lpwm_open( lua_State *L ) {
}
// Module function map
static const LUA_REG_TYPE pwm_map[] = {
{ LSTRKEY( "setup" ), LFUNCVAL( lpwm_setup ) },
{ LSTRKEY( "close" ), LFUNCVAL( lpwm_close ) },
{ LSTRKEY( "start" ), LFUNCVAL( lpwm_start ) },
{ LSTRKEY( "stop" ), LFUNCVAL( lpwm_stop ) },
{ LSTRKEY( "setclock" ), LFUNCVAL( lpwm_setclock ) },
{ LSTRKEY( "getclock" ), LFUNCVAL( lpwm_getclock ) },
{ LSTRKEY( "setduty" ), LFUNCVAL( lpwm_setduty ) },
{ LSTRKEY( "getduty" ), LFUNCVAL( lpwm_getduty ) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(PWM, "pwm", pwm_map, lpwm_open);
LROT_BEGIN(pwm)
LROT_FUNCENTRY( setup, lpwm_setup )
LROT_FUNCENTRY( close, lpwm_close )
LROT_FUNCENTRY( start, lpwm_start )
LROT_FUNCENTRY( stop, lpwm_stop )
LROT_FUNCENTRY( setclock, lpwm_setclock )
LROT_FUNCENTRY( getclock, lpwm_getclock )
LROT_FUNCENTRY( setduty, lpwm_setduty )
LROT_FUNCENTRY( getduty, lpwm_getduty )
LROT_END( pwm, NULL, 0 )
NODEMCU_MODULE(PWM, "pwm", pwm, lpwm_open);
......@@ -81,14 +81,14 @@ static int ICACHE_FLASH_ATTR rc_send(lua_State* L) {
}
// Module function map
static const LUA_REG_TYPE rc_map[] = {
{ LSTRKEY( "send" ), LFUNCVAL( rc_send )},
{ LNILKEY, LNILVAL}
};
LROT_BEGIN(rc)
LROT_FUNCENTRY( send, rc_send )
LROT_END( rc, NULL, 0 )
int luaopen_rc(lua_State *L) {
// TODO: Make sure that the GPIO system is initialized
return 0;
}
NODEMCU_MODULE(RC, "rc", rc_map, luaopen_rc);
NODEMCU_MODULE(RC, "rc", rc, luaopen_rc);
......@@ -102,10 +102,9 @@ static int rfswitch_send( lua_State *L )
}
// Module function map
static const LUA_REG_TYPE rfswitch_map[] =
{
{ LSTRKEY( "send" ), LFUNCVAL( rfswitch_send ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(rfswitch)
LROT_FUNCENTRY( send, rfswitch_send )
LROT_END( rfswitch, NULL, 0 )
NODEMCU_MODULE(RFSWITCH, "rfswitch", rfswitch_map, NULL);
NODEMCU_MODULE(RFSWITCH, "rfswitch", rfswitch, NULL);
......@@ -395,20 +395,20 @@ static int rotary_open(lua_State *L)
}
// Module function map
static const LUA_REG_TYPE rotary_map[] = {
{ LSTRKEY( "setup" ), LFUNCVAL( lrotary_setup ) },
{ LSTRKEY( "close" ), LFUNCVAL( lrotary_close ) },
{ LSTRKEY( "on" ), LFUNCVAL( lrotary_on ) },
{ LSTRKEY( "getpos" ), LFUNCVAL( lrotary_getpos) },
{ LSTRKEY( "TURN" ), LNUMVAL( MASK(TURN) ) },
{ LSTRKEY( "PRESS" ), LNUMVAL( MASK(PRESS) ) },
{ LSTRKEY( "RELEASE" ), LNUMVAL( MASK(RELEASE) ) },
{ LSTRKEY( "LONGPRESS" ),LNUMVAL( MASK(LONGPRESS) ) },
{ LSTRKEY( "CLICK" ), LNUMVAL( MASK(CLICK) ) },
{ LSTRKEY( "DBLCLICK" ), LNUMVAL( MASK(DBLCLICK)) },
{ LSTRKEY( "ALL" ), LNUMVAL( ROTARY_ALL ) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(ROTARY, "rotary", rotary_map, rotary_open);
LROT_BEGIN(rotary)
LROT_FUNCENTRY( setup, lrotary_setup )
LROT_FUNCENTRY( close, lrotary_close )
LROT_FUNCENTRY( on, lrotary_on )
LROT_FUNCENTRY( getpos, lrotary_getpos )
LROT_NUMENTRY( TURN, MASK(TURN) )
LROT_NUMENTRY( PRESS, MASK(PRESS) )
LROT_NUMENTRY( RELEASE, MASK(RELEASE) )
LROT_NUMENTRY( LONGPRESS, MASK(LONGPRESS) )
LROT_NUMENTRY( CLICK, MASK(CLICK) )
LROT_NUMENTRY( DBLCLICK, MASK(DBLCLICK) )
LROT_NUMENTRY( ALL, ROTARY_ALL )
LROT_END( rotary, NULL, 0 )
NODEMCU_MODULE(ROTARY, "rotary", rotary, rotary_open);
......@@ -165,18 +165,18 @@ static int rtcfifo_dsleep_until_sample (lua_State *L)
#endif
// Module function map
static const LUA_REG_TYPE rtcfifo_map[] = {
{ LSTRKEY("prepare"), LFUNCVAL(rtcfifo_prepare) },
{ LSTRKEY("ready"), LFUNCVAL(rtcfifo_ready) },
{ LSTRKEY("put"), LFUNCVAL(rtcfifo_put) },
{ LSTRKEY("pop"), LFUNCVAL(rtcfifo_pop) },
{ LSTRKEY("peek"), LFUNCVAL(rtcfifo_peek) },
{ LSTRKEY("drop"), LFUNCVAL(rtcfifo_drop) },
{ LSTRKEY("count"), LFUNCVAL(rtcfifo_count) },
LROT_BEGIN(rtcfifo)
LROT_FUNCENTRY( prepare, rtcfifo_prepare )
LROT_FUNCENTRY( ready, rtcfifo_ready )
LROT_FUNCENTRY( put, rtcfifo_put )
LROT_FUNCENTRY( pop, rtcfifo_pop )
LROT_FUNCENTRY( peek, rtcfifo_peek )
LROT_FUNCENTRY( drop, rtcfifo_drop )
LROT_FUNCENTRY( count, rtcfifo_count )
#ifdef LUA_USE_MODULES_RTCTIME
{ LSTRKEY("dsleep_until_sample"), LFUNCVAL(rtcfifo_dsleep_until_sample) },
LROT_FUNCENTRY( dsleep_until_sample, rtcfifo_dsleep_until_sample )
#endif
{ LNILKEY, LNILVAL }
};
LROT_END( rtcfifo, NULL, 0 )
NODEMCU_MODULE(RTCFIFO, "rtcfifo", rtcfifo_map, NULL);
NODEMCU_MODULE(RTCFIFO, "rtcfifo", rtcfifo, NULL);
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment