Unverified Commit eaac369d authored by Johny Mattsson's avatar Johny Mattsson Committed by GitHub
Browse files

LFS support for ESP32 NodeMCU (#2801)

* Port LFS from ESP8266 to ESP32
parent 7cb61a27
......@@ -536,46 +536,38 @@ static int lbthci_rawhci (lua_State *L)
}
static const LUA_REG_TYPE bthci_adv_map[] =
{
{ LSTRKEY( "enable" ), LFUNCVAL( lbthci_adv_enable ) },
{ LSTRKEY( "setdata" ), LFUNCVAL( lbthci_adv_setdata ) },
{ LSTRKEY( "setparams" ), LFUNCVAL( lbthci_adv_setparams ) },
LROT_BEGIN(bthci_adv)
LROT_FUNCENTRY( enable, lbthci_adv_enable )
LROT_FUNCENTRY( setdata, lbthci_adv_setdata )
LROT_FUNCENTRY( setparams, lbthci_adv_setparams )
// Advertising types
{ LSTRKEY( "CONN_UNDIR"), LNUMVAL( ADV_IND ) },
{ LSTRKEY( "CONN_DIR_HI"), LNUMVAL( ADV_DIRECT_IND_HI_DUTY ) },
{ LSTRKEY( "SCAN_UNDIR"), LNUMVAL( ADV_SCAN_IND ) },
{ LSTRKEY( "NONCONN_UNDIR"), LNUMVAL( ADV_NONCONN_IND ) },
{ LSTRKEY( "CONN_DIR_LO"), LNUMVAL( ADV_DIRECT_IND_LO_DUTY ) },
{ LSTRKEY( "CHAN_37" ), LNUMVAL( ADV_CHAN_37 ) },
{ LSTRKEY( "CHAN_38" ), LNUMVAL( ADV_CHAN_38 ) },
{ LSTRKEY( "CHAN_39" ), LNUMVAL( ADV_CHAN_39 ) },
{ LSTRKEY( "CHAN_ALL" ), LNUMVAL( ADV_CHAN_ALL ) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE bthci_scan_map[] =
{
{ LSTRKEY( "enable" ), LFUNCVAL( lbthci_scan ) },
{ LSTRKEY( "setparams" ), LFUNCVAL( lbthci_scan_setparams ) },
{ LSTRKEY( "on" ), LFUNCVAL( lbthci_scan_on ) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE bthci_map[] =
{
{ LSTRKEY( "rawhci" ), LFUNCVAL( lbthci_rawhci ) },
{ LSTRKEY( "reset" ), LFUNCVAL( lbthci_reset ) },
{ LSTRKEY( "adv" ), LROVAL( bthci_adv_map ) },
{ LSTRKEY( "scan" ), LROVAL( bthci_scan_map ) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(BTHCI, "bthci", bthci_map, lbthci_init);
LROT_NUMENTRY ( CONN_UNDIR, ADV_IND )
LROT_NUMENTRY ( CONN_DIR_HI, ADV_DIRECT_IND_HI_DUTY )
LROT_NUMENTRY ( SCAN_UNDIR, ADV_SCAN_IND )
LROT_NUMENTRY ( NONCONN_UNDIR, ADV_NONCONN_IND )
LROT_NUMENTRY ( CONN_DIR_LO, ADV_DIRECT_IND_LO_DUTY )
LROT_NUMENTRY ( CHAN_37, ADV_CHAN_37 )
LROT_NUMENTRY ( CHAN_38, ADV_CHAN_38 )
LROT_NUMENTRY ( CHAN_39, ADV_CHAN_39 )
LROT_NUMENTRY ( CHAN_ALL, ADV_CHAN_ALL )
LROT_END(bthci_adv, NULL, 0)
LROT_BEGIN(bthci_scan)
LROT_FUNCENTRY( enable, lbthci_scan )
LROT_FUNCENTRY( setparams, lbthci_scan_setparams )
LROT_FUNCENTRY( on, lbthci_scan_on )
LROT_END(bthci_scan, NULL, 0)
LROT_BEGIN(bthci)
LROT_FUNCENTRY( rawhci, lbthci_rawhci )
LROT_FUNCENTRY( reset, lbthci_reset )
LROT_TABENTRY ( adv, bthci_adv )
LROT_TABENTRY ( scan, bthci_scan )
LROT_END(bthci, NULL, 0)
NODEMCU_MODULE(BTHCI, "bthci", bthci, lbthci_init);
#endif
......@@ -148,16 +148,14 @@ static int can_send( lua_State *L )
}
// Module function map
static const LUA_REG_TYPE can_map[] =
{
{ LSTRKEY( "setup" ), LFUNCVAL( can_setup ) },
{ LSTRKEY( "start" ), LFUNCVAL( can_start ) },
{ LSTRKEY( "stop" ), LFUNCVAL( can_stop ) },
{ LSTRKEY( "send" ), LFUNCVAL( can_send ) },
{ LSTRKEY( "STANDARD_FRAME" ), LNUMVAL( 0 ) },
{ LSTRKEY( "EXTENDED_FRAME" ), LNUMVAL( 1 ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(can)
LROT_FUNCENTRY( setup, can_setup )
LROT_FUNCENTRY( start, can_start )
LROT_FUNCENTRY( stop, can_stop )
LROT_FUNCENTRY( send, can_send )
LROT_NUMENTRY ( STANDARD_FRAME, 0 )
LROT_NUMENTRY ( EXTENDED_FRAME, 1 )
LROT_END(can, NULL, 0)
int luaopen_can( lua_State *L ) {
can_data_task_id = task_get_id( can_data_task ); // reset CAN after sw reset
......@@ -165,4 +163,4 @@ int luaopen_can( lua_State *L ) {
return 0;
}
NODEMCU_MODULE(CAN, "can", can_map, luaopen_can);
NODEMCU_MODULE(CAN, "can", can, luaopen_can);
......@@ -153,18 +153,18 @@ static int crypto_hash_gc(lua_State* L) {
}
// The following table defines methods of the hasher object
static const LUA_REG_TYPE crypto_hasher_map[] = {
{LSTRKEY("update"), LFUNCVAL(crypto_hash_update)},
{LSTRKEY("finalize"), LFUNCVAL(crypto_hash_finalize)},
{LSTRKEY("__gc"), LFUNCVAL(crypto_hash_gc)},
{LSTRKEY("__index"), LROVAL(crypto_hasher_map)},
{LNILKEY, LNILVAL}};
LROT_BEGIN(crypto_hasher)
LROT_FUNCENTRY(update, crypto_hash_update)
LROT_FUNCENTRY(finalize, crypto_hash_finalize)
LROT_FUNCENTRY(__gc, crypto_hash_gc)
LROT_TABENTRY(__index, crypto_hasher)
LROT_END(crypto_hasher, NULL, 0)
// This table defines the functions of the crypto module:
static const LUA_REG_TYPE crypto_map[] = {
{LSTRKEY("new_hash"), LFUNCVAL(crypto_new_hash)},
{LSTRKEY("new_hmac"), LFUNCVAL(crypto_new_hmac)},
{LNILKEY, LNILVAL}};
LROT_BEGIN(crypto)
LROT_FUNCENTRY(new_hash, crypto_new_hash)
LROT_FUNCENTRY(new_hmac, crypto_new_hmac)
LROT_END(crypto, NULL, 0)
// luaopen_crypto is the crypto module initialization function
int luaopen_crypto(lua_State* L) {
......@@ -174,4 +174,4 @@ int luaopen_crypto(lua_State* L) {
}
// define the crypto NodeMCU module
NODEMCU_MODULE(CRYPTO, "crypto", crypto_map, luaopen_crypto);
NODEMCU_MODULE(CRYPTO, "crypto", crypto, luaopen_crypto);
......@@ -52,16 +52,12 @@ static int ldac_write( lua_State *L )
// Module function map
static const LUA_REG_TYPE dac_map[] =
{
{ LSTRKEY( "enable" ), LFUNCVAL( ldac_enable ) },
{ LSTRKEY( "disable" ), LFUNCVAL( ldac_disable ) },
{ LSTRKEY( "write" ), LFUNCVAL( ldac_write ) },
{ LSTRKEY( "CHANNEL_1" ), LNUMVAL( DAC_CHANNEL_1 ) },
{ LSTRKEY( "CHANNEL_2" ), LNUMVAL( DAC_CHANNEL_2 ) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(DAC, "dac", dac_map, NULL);
LROT_BEGIN(dac)
LROT_FUNCENTRY( enable, ldac_enable )
LROT_FUNCENTRY( disable, ldac_disable )
LROT_FUNCENTRY( write, ldac_write )
LROT_NUMENTRY ( CHANNEL_1, DAC_CHANNEL_1 )
LROT_NUMENTRY ( CHANNEL_2, DAC_CHANNEL_2 )
LROT_END(dac, NULL, 0)
NODEMCU_MODULE(DAC, "dac", dac, NULL);
......@@ -91,13 +91,12 @@ static int ldht_read2x( lua_State *L )
}
static const LUA_REG_TYPE dht_map[] = {
{ LSTRKEY( "read11" ), LFUNCVAL( ldht_read11 ) },
{ LSTRKEY( "read2x" ), LFUNCVAL( ldht_read2x ) },
{ LSTRKEY( "OK" ), LNUMVAL( LDHT_OK ) },
{ LSTRKEY( "ERROR_CHECKSUM" ), LNUMVAL( LDHT_ERROR_CHECKSUM ) },
{ LSTRKEY( "ERROR_TIMEOUT" ), LNUMVAL( LDHT_ERROR_TIMEOUT ) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(DHT, "dht", dht_map, NULL);
LROT_BEGIN(dht)
LROT_FUNCENTRY( read11, ldht_read11 )
LROT_FUNCENTRY( read2x, ldht_read2x )
LROT_NUMENTRY ( OK, LDHT_OK )
LROT_NUMENTRY ( ERROR_CHECKSUM, LDHT_ERROR_CHECKSUM )
LROT_NUMENTRY ( ERROR_TIMEOUT, LDHT_ERROR_TIMEOUT )
LROT_END(dht, NULL, 0)
NODEMCU_MODULE(DHT, "dht", dht, NULL);
......@@ -156,12 +156,11 @@ static int do_func (lua_State *L, uint8_t * (*conv_func)(lua_State *, const uint
DECLARE_FUNCTION(toHex);
// Module function map
static const LUA_REG_TYPE encoder_map[] = {
{ LSTRKEY("fromBase64"), LFUNCVAL(encoder_fromBase64) },
{ LSTRKEY("toBase64"), LFUNCVAL(encoder_toBase64) },
{ LSTRKEY("fromHex"), LFUNCVAL(encoder_fromHex) },
{ LSTRKEY("toHex"), LFUNCVAL(encoder_toHex) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(ENCODER, "encoder", encoder_map, NULL);
LROT_BEGIN(encoder)
LROT_FUNCENTRY(fromBase64, encoder_fromBase64)
LROT_FUNCENTRY(toBase64, encoder_toBase64)
LROT_FUNCENTRY(fromHex, encoder_fromHex)
LROT_FUNCENTRY(toHex, encoder_toHex)
LROT_END(encoder, NULL, 0)
NODEMCU_MODULE(ENCODER, "encoder", encoder, NULL);
......@@ -264,7 +264,6 @@ static int leth_init( lua_State *L )
default:
// prevented by opt_checkint_range
break;
};
config.phy_addr = phy_addr;
......@@ -287,30 +286,21 @@ static int leth_init( lua_State *L )
return 0;
}
LROT_BEGIN(eth)
LROT_FUNCENTRY( init, leth_init )
LROT_FUNCENTRY( on, leth_on )
LROT_FUNCENTRY( get_speed, leth_get_speed )
LROT_FUNCENTRY( get_mac, leth_get_mac )
LROT_FUNCENTRY( set_mac, leth_set_mac )
static const LUA_REG_TYPE eth_map[] =
{
{ LSTRKEY( "init" ), LFUNCVAL( leth_init ) },
{ LSTRKEY( "on" ), LFUNCVAL( leth_on ) },
{ LSTRKEY( "get_speed" ), LFUNCVAL( leth_get_speed ) },
{ LSTRKEY( "get_mac" ), LFUNCVAL( leth_get_mac ) },
{ LSTRKEY( "set_mac" ), LFUNCVAL( leth_set_mac ) },
{ LSTRKEY( "PHY_LAN8720" ), LNUMVAL( ETH_PHY_LAN8720 ) },
{ LSTRKEY( "PHY_TLK110" ), LNUMVAL( ETH_PHY_TLK110 ) },
{ LSTRKEY( "PHY_IP101" ), LNUMVAL( ETH_PHY_IP101 ) },
{ LSTRKEY( "CLOCK_GPIO0_IN" ), LNUMVAL( ETH_CLOCK_GPIO0_IN ) },
{ LSTRKEY( "CLOCK_GPIO0_OUT" ), LNUMVAL( ETH_CLOCK_GPIO0_OUT ) },
{ LSTRKEY( "CLOCK_GPIO16_OUT" ), LNUMVAL( ETH_CLOCK_GPIO16_OUT ) },
{ LSTRKEY( "CLOCK_GPIO17_OUT" ), LNUMVAL( ETH_CLOCK_GPIO17_OUT ) },
{ LNILKEY, LNILVAL }
};
LROT_NUMENTRY( PHY_LAN8720, ETH_PHY_LAN8720 )
LROT_NUMENTRY( PHY_TLK110, ETH_PHY_TLK110 )
LROT_NUMENTRY( PHY_IP101, ETH_PHY_IP101 )
static int eth_init( lua_State *L )
{
return 1;
}
LROT_NUMENTRY( CLOCK_GPIO0_IN, ETH_CLOCK_GPIO0_IN )
LROT_NUMENTRY( CLOCK_GPIO0_OUT, ETH_CLOCK_GPIO0_OUT )
LROT_NUMENTRY( CLOCK_GPIO16_OUT, ETH_CLOCK_GPIO16_OUT )
LROT_NUMENTRY( CLOCK_GPIO17_OUT, ETH_CLOCK_GPIO17_OUT )
LROT_END(eth, NULL, 0)
NODEMCU_MODULE(ETH, "eth", eth_map, eth_init);
NODEMCU_MODULE(ETH, "eth", eth, NULL);
......@@ -550,50 +550,47 @@ static int file_chdir( lua_State *L )
}
#endif
static const LUA_REG_TYPE file_obj_map[] =
{
{ LSTRKEY( "close" ), LFUNCVAL( file_close ) },
{ LSTRKEY( "read" ), LFUNCVAL( file_read ) },
{ LSTRKEY( "readline" ), LFUNCVAL( file_readline ) },
{ LSTRKEY( "write" ), LFUNCVAL( file_write ) },
{ LSTRKEY( "writeline" ), LFUNCVAL( file_writeline ) },
{ LSTRKEY( "seek" ), LFUNCVAL( file_seek ) },
{ LSTRKEY( "flush" ), LFUNCVAL( file_flush ) },
{ LSTRKEY( "__gc" ), LFUNCVAL( file_obj_free ) },
{ LSTRKEY( "__index" ), LROVAL( file_obj_map ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(file_obj)
LROT_FUNCENTRY( close, file_close )
LROT_FUNCENTRY( read, file_read )
LROT_FUNCENTRY( readline, file_readline )
LROT_FUNCENTRY( write, file_write )
LROT_FUNCENTRY( writeline, file_writeline )
LROT_FUNCENTRY( seek, file_seek )
LROT_FUNCENTRY( flush, file_flush )
LROT_FUNCENTRY( __gc, file_obj_free )
LROT_TABENTRY ( __index, file_obj )
LROT_END(file_obj, NULL, 0)
// Module function map
static const LUA_REG_TYPE file_map[] = {
{ LSTRKEY( "list" ), LFUNCVAL( file_list ) },
{ LSTRKEY( "open" ), LFUNCVAL( file_open ) },
{ LSTRKEY( "close" ), LFUNCVAL( file_close ) },
{ LSTRKEY( "write" ), LFUNCVAL( file_write ) },
{ LSTRKEY( "writeline" ), LFUNCVAL( file_writeline ) },
{ LSTRKEY( "read" ), LFUNCVAL( file_read ) },
{ LSTRKEY( "readline" ), LFUNCVAL( file_readline ) },
LROT_BEGIN(file)
LROT_FUNCENTRY( list, file_list )
LROT_FUNCENTRY( open, file_open )
LROT_FUNCENTRY( close, file_close )
LROT_FUNCENTRY( write, file_write )
LROT_FUNCENTRY( writeline, file_writeline )
LROT_FUNCENTRY( read, file_read )
LROT_FUNCENTRY( readline, file_readline )
#ifdef CONFIG_BUILD_SPIFFS
{ LSTRKEY( "format" ), LFUNCVAL( file_format ) },
{ LSTRKEY( "fscfg" ), LFUNCVAL( file_fscfg ) },
LROT_FUNCENTRY( format, file_format )
LROT_FUNCENTRY( fscfg, file_fscfg )
#endif
{ LSTRKEY( "remove" ), LFUNCVAL( file_remove ) },
{ LSTRKEY( "seek" ), LFUNCVAL( file_seek ) },
{ LSTRKEY( "flush" ), LFUNCVAL( file_flush ) },
{ LSTRKEY( "rename" ), LFUNCVAL( file_rename ) },
{ LSTRKEY( "exists" ), LFUNCVAL( file_exists ) },
{ LSTRKEY( "fsinfo" ), LFUNCVAL( file_fsinfo ) },
{ LSTRKEY( "on" ), LFUNCVAL( file_on ) },
{ LSTRKEY( "stat" ), LFUNCVAL( file_stat ) },
LROT_FUNCENTRY( remove, file_remove )
LROT_FUNCENTRY( seek, file_seek )
LROT_FUNCENTRY( flush, file_flush )
LROT_FUNCENTRY( rename, file_rename )
LROT_FUNCENTRY( exists, file_exists )
LROT_FUNCENTRY( fsinfo, file_fsinfo )
LROT_FUNCENTRY( on, file_on )
LROT_FUNCENTRY( stat, file_stat )
#ifdef CONFIG_BUILD_FATFS
{ LSTRKEY( "chdir" ), LFUNCVAL( file_chdir ) },
LROT_FUNCENTRY( chdir, file_chdir )
#endif
{ LNILKEY, LNILVAL }
};
LROT_END(file, NULL, 0)
int luaopen_file( lua_State *L ) {
luaL_rometatable( L, "file.obj", (void *)file_obj_map );
return 0;
}
NODEMCU_MODULE(FILE, "file", file_map, luaopen_file);
NODEMCU_MODULE(FILE, "file", file, luaopen_file);
......@@ -231,32 +231,29 @@ static int nodemcu_gpio_init (lua_State *L)
}
static const LUA_REG_TYPE lgpio_map[] =
{
{ LSTRKEY( "config" ), LFUNCVAL( lgpio_config ) },
{ LSTRKEY( "read" ), LFUNCVAL( lgpio_read ) },
{ LSTRKEY( "trig" ), LFUNCVAL( lgpio_trig ) },
{ LSTRKEY( "wakeup" ), LFUNCVAL( lgpio_wakeup ) },
{ LSTRKEY( "write" ), LFUNCVAL( lgpio_write ) },
{ LSTRKEY( "OUT" ), LNUMVAL( GPIO_MODE_OUTPUT ) },
{ LSTRKEY( "IN" ), LNUMVAL( GPIO_MODE_INPUT ) },
{ LSTRKEY( "IN_OUT" ), LNUMVAL( GPIO_MODE_INPUT_OUTPUT ) },
{ LSTRKEY( "FLOATING"), LNUMVAL( 0 ) },
{ LSTRKEY( "PULL_UP" ), LNUMVAL( PULL_UP ) },
{ LSTRKEY( "PULL_DOWN" ), LNUMVAL( PULL_DOWN ) },
{ LSTRKEY( "PULL_UP_DOWN"), LNUMVAL( PULL_UP | PULL_DOWN ) },
{ LSTRKEY( "INTR_NONE" ), LNUMVAL( GPIO_INTR_DISABLE ) },
{ LSTRKEY( "INTR_UP" ), LNUMVAL( GPIO_INTR_POSEDGE ) },
{ LSTRKEY( "INTR_DOWN" ), LNUMVAL( GPIO_INTR_NEGEDGE ) },
{ LSTRKEY( "INTR_UP_DOWN" ), LNUMVAL( GPIO_INTR_ANYEDGE ) },
{ LSTRKEY( "INTR_LOW" ), LNUMVAL( GPIO_INTR_LOW_LEVEL ) },
{ LSTRKEY( "INTR_HIGH" ), LNUMVAL( GPIO_INTR_HIGH_LEVEL ) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(GPIO, "gpio", lgpio_map, nodemcu_gpio_init);
LROT_BEGIN(lgpio)
LROT_FUNCENTRY( config, lgpio_config )
LROT_FUNCENTRY( read, lgpio_read )
LROT_FUNCENTRY( trig, lgpio_trig )
LROT_FUNCENTRY( wakeup, lgpio_wakeup )
LROT_FUNCENTRY( write, lgpio_write )
LROT_NUMENTRY ( OUT, GPIO_MODE_OUTPUT )
LROT_NUMENTRY ( IN, GPIO_MODE_INPUT )
LROT_NUMENTRY ( IN_OUT, GPIO_MODE_INPUT_OUTPUT )
LROT_NUMENTRY ( FLOATING, 0 )
LROT_NUMENTRY ( PULL_UP, PULL_UP )
LROT_NUMENTRY ( PULL_DOWN, PULL_DOWN )
LROT_NUMENTRY ( PULL_UP_DOWN, PULL_UP | PULL_DOWN )
LROT_NUMENTRY ( INTR_NONE, GPIO_INTR_DISABLE )
LROT_NUMENTRY ( INTR_UP, GPIO_INTR_POSEDGE )
LROT_NUMENTRY ( INTR_DOWN, GPIO_INTR_NEGEDGE )
LROT_NUMENTRY ( INTR_UP_DOWN, GPIO_INTR_ANYEDGE )
LROT_NUMENTRY ( INTR_LOW, GPIO_INTR_LOW_LEVEL )
LROT_NUMENTRY ( INTR_HIGH, GPIO_INTR_HIGH_LEVEL )
LROT_END(lgpio, NULL, 0)
NODEMCU_MODULE(GPIO, "gpio", lgpio, nodemcu_gpio_init);
......@@ -778,32 +778,30 @@ static int http_lapi_post(lua_State *L)
return make_oneshot_request(L, 4); // 4 = callback idx
}
static const LUA_REG_TYPE http_map[] = {
{ LSTRKEY("createConnection"), LFUNCVAL(http_lapi_createConnection) },
{ LSTRKEY("GET"), LNUMVAL(HTTP_METHOD_GET) },
{ LSTRKEY("POST"), LNUMVAL(HTTP_METHOD_POST) },
{ LSTRKEY("DELETE"), LNUMVAL(HTTP_METHOD_DELETE) },
{ LSTRKEY("HEAD"), LNUMVAL(HTTP_METHOD_HEAD) },
{ LSTRKEY("DELAYACK"), LNUMVAL(DELAY_ACK) },
{ LSTRKEY("ACKNOW"), LNUMVAL(0) }, // Doesn't really matter what this is
{ LSTRKEY("get"), LFUNCVAL(http_lapi_get) },
{ LSTRKEY("post"), LFUNCVAL(http_lapi_post) },
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE http_context_map[] = {
{ LSTRKEY("on"), LFUNCVAL(http_lapi_on) },
{ LSTRKEY("request"), LFUNCVAL(http_lapi_request) },
{ LSTRKEY("setmethod"), LFUNCVAL(http_lapi_setmethod) },
{ LSTRKEY("setheader"), LFUNCVAL(http_lapi_setheader) },
{ LSTRKEY("seturl"), LFUNCVAL(http_lapi_seturl) },
{ LSTRKEY("setpostdata"), LFUNCVAL(http_lapi_setpostdata) },
{ LSTRKEY("close"), LFUNCVAL(context_close) },
{ LSTRKEY("ack"), LFUNCVAL(http_lapi_ack) },
{ LSTRKEY("__gc"), LFUNCVAL(context_gc) },
{ LSTRKEY("__index"), LROVAL(http_context_map) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(http)
LROT_FUNCENTRY(createConnection, http_lapi_createConnection)
LROT_NUMENTRY (GET, HTTP_METHOD_GET)
LROT_NUMENTRY (POST, HTTP_METHOD_POST)
LROT_NUMENTRY (DELETE, HTTP_METHOD_DELETE)
LROT_NUMENTRY (HEAD, HTTP_METHOD_HEAD)
LROT_NUMENTRY (DELAYACK, DELAY_ACK)
LROT_NUMENTRY (ACKNOW, 0) // Doesn't really matter what this is
LROT_FUNCENTRY(get, http_lapi_get)
LROT_FUNCENTRY(post, http_lapi_post)
LROT_END(http, NULL, 0)
LROT_BEGIN(http_context)
LROT_FUNCENTRY(on, http_lapi_on)
LROT_FUNCENTRY(request, http_lapi_request)
LROT_FUNCENTRY(setmethod, http_lapi_setmethod)
LROT_FUNCENTRY(setheader, http_lapi_setheader)
LROT_FUNCENTRY(seturl, http_lapi_seturl)
LROT_FUNCENTRY(setpostdata, http_lapi_setpostdata)
LROT_FUNCENTRY(close, context_close)
LROT_FUNCENTRY(ack, http_lapi_ack)
LROT_FUNCENTRY(__gc, context_gc)
LROT_TABENTRY (__index, http_context)
LROT_END(http_context, NULL, 0)
static int luaopen_http(lua_State *L)
{
......@@ -813,4 +811,4 @@ static int luaopen_http(lua_State *L)
return 0;
}
NODEMCU_MODULE(HTTP, "http", http_map, luaopen_http);
NODEMCU_MODULE(HTTP, "http", http, luaopen_http);
......@@ -202,25 +202,24 @@ static int i2c_read( lua_State *L )
}
}
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( "transfer" ), LFUNCVAL( li2c_hw_master_transfer ) },
{ LSTRKEY( "slave"), LROVAL( li2c_slave_map ) },
{ 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 ) },
{ LSTRKEY( "SW" ), LNUMVAL( I2C_ID_SW ) },
{ LSTRKEY( "HW0" ), LNUMVAL( I2C_ID_HW0 ) },
{ LSTRKEY( "HW1" ), LNUMVAL( I2C_ID_HW1 ) },
{LNILKEY, LNILVAL}
};
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_FUNCENTRY( transfer, li2c_hw_master_transfer )
LROT_TABENTRY ( slave, li2c_slave )
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_NUMENTRY ( SW, I2C_ID_SW )
LROT_NUMENTRY ( HW0, I2C_ID_HW0 )
LROT_NUMENTRY ( HW1, I2C_ID_HW1 )
LROT_END(i2c, NULL, 0)
int luaopen_i2c( lua_State *L ) {
......@@ -230,4 +229,4 @@ int luaopen_i2c( lua_State *L ) {
}
NODEMCU_MODULE(I2C, "i2c", i2c_map, luaopen_i2c);
NODEMCU_MODULE(I2C, "i2c", i2c, luaopen_i2c);
......@@ -29,7 +29,7 @@ int li2c_hw_master_transfer( lua_State *L );
// ***************************************************************************
// Hardware slave prototypes
//
extern const LUA_REG_TYPE li2c_slave_map[];
LROT_EXTERN(li2c_slave);
void li2c_hw_slave_init( lua_State *L );
......
......@@ -318,12 +318,11 @@ static int li2c_slave_on( lua_State *L )
}
const LUA_REG_TYPE li2c_slave_map[] = {
{ LSTRKEY( "on" ), LFUNCVAL( li2c_slave_on ) },
{ LSTRKEY( "setup" ), LFUNCVAL( li2c_slave_setup ) },
{ LSTRKEY( "send" ), LFUNCVAL( li2c_slave_send ) },
{ LNILKEY, LNILVAL }
};
LROT_PUBLIC_BEGIN(li2c_slave)
LROT_FUNCENTRY( on, li2c_slave_on )
LROT_FUNCENTRY( setup, li2c_slave_setup )
LROT_FUNCENTRY( send, li2c_slave_send )
LROT_END(li2c_slave, NULL, 0)
void li2c_hw_slave_init( lua_State *L )
......
......@@ -309,42 +309,39 @@ static int node_i2s_mute( lua_State *L )
// Module function map
static const LUA_REG_TYPE i2s_map[] =
{
{ LSTRKEY( "start" ), LFUNCVAL( node_i2s_start ) },
{ LSTRKEY( "stop" ), LFUNCVAL( node_i2s_stop ) },
{ LSTRKEY( "read" ), LFUNCVAL( node_i2s_read ) },
{ LSTRKEY( "write" ), LFUNCVAL( node_i2s_write ) },
{ LSTRKEY( "mute" ), LFUNCVAL( node_i2s_mute ) },
{ LSTRKEY( "FORMAT_I2S" ), LNUMVAL( I2S_COMM_FORMAT_I2S ) },
{ LSTRKEY( "FORMAT_I2S_MSB" ), LNUMVAL( I2S_COMM_FORMAT_I2S_MSB ) },
{ LSTRKEY( "FORMAT_I2S_LSB" ), LNUMVAL( I2S_COMM_FORMAT_I2S_LSB ) },
{ LSTRKEY( "FORMAT_PCM" ), LNUMVAL( I2S_COMM_FORMAT_PCM ) },
{ LSTRKEY( "FORMAT_PCM_SHORT" ), LNUMVAL( I2S_COMM_FORMAT_PCM_SHORT ) },
{ LSTRKEY( "FORMAT_PCM_LONG" ), LNUMVAL( I2S_COMM_FORMAT_PCM_LONG ) },
{ LSTRKEY( "CHANNEL_RIGHT_LEFT" ), LNUMVAL( I2S_CHANNEL_FMT_RIGHT_LEFT ) },
{ LSTRKEY( "CHANNEL_ALL_LEFT" ), LNUMVAL( I2S_CHANNEL_FMT_ALL_LEFT ) },
{ LSTRKEY( "CHANNEL_ONLY_LEFT" ), LNUMVAL( I2S_CHANNEL_FMT_ONLY_LEFT ) },
{ LSTRKEY( "CHANNEL_ALL_RIGHT" ), LNUMVAL( I2S_CHANNEL_FMT_ALL_RIGHT ) },
{ LSTRKEY( "CHANNEL_ONLY_RIGHT" ), LNUMVAL( I2S_CHANNEL_FMT_ONLY_RIGHT ) },
{ LSTRKEY( "MODE_MASTER" ), LNUMVAL( I2S_MODE_MASTER ) },
{ LSTRKEY( "MODE_SLAVE" ), LNUMVAL( I2S_MODE_SLAVE ) },
{ LSTRKEY( "MODE_TX" ), LNUMVAL( I2S_MODE_TX ) },
{ LSTRKEY( "MODE_RX" ), LNUMVAL( I2S_MODE_RX ) },
{ LSTRKEY( "MODE_DAC_BUILT_IN" ), LNUMVAL( I2S_MODE_DAC_BUILT_IN ) },
{ LSTRKEY( "MODE_ADC_BUILT_IN" ), LNUMVAL( I2S_MODE_ADC_BUILT_IN ) },
{ LSTRKEY( "MODE_PDM" ), LNUMVAL( I2S_MODE_PDM ) },
{ LSTRKEY( "DAC_CHANNEL_DISABLE" ), LNUMVAL( I2S_DAC_CHANNEL_DISABLE ) },
{ LSTRKEY( "DAC_CHANNEL_RIGHT" ), LNUMVAL( I2S_DAC_CHANNEL_RIGHT_EN ) },
{ LSTRKEY( "DAC_CHANNEL_LEFT" ), LNUMVAL( I2S_DAC_CHANNEL_LEFT_EN ) },
{ LSTRKEY( "DAC_CHANNEL_BOTH" ), LNUMVAL( I2S_DAC_CHANNEL_BOTH_EN ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(i2s)
LROT_FUNCENTRY( start, node_i2s_start )
LROT_FUNCENTRY( stop, node_i2s_stop )
LROT_FUNCENTRY( read, node_i2s_read )
LROT_FUNCENTRY( write, node_i2s_write )
LROT_FUNCENTRY( mute, node_i2s_mute )
LROT_NUMENTRY( FORMAT_I2S, I2S_COMM_FORMAT_I2S )
LROT_NUMENTRY( FORMAT_I2S_MSB, I2S_COMM_FORMAT_I2S_MSB )
LROT_NUMENTRY( FORMAT_I2S_LSB, I2S_COMM_FORMAT_I2S_LSB )
LROT_NUMENTRY( FORMAT_PCM, I2S_COMM_FORMAT_PCM )
LROT_NUMENTRY( FORMAT_PCM_SHORT, I2S_COMM_FORMAT_PCM_SHORT )
LROT_NUMENTRY( FORMAT_PCM_LONG, I2S_COMM_FORMAT_PCM_LONG )
LROT_NUMENTRY( CHANNEL_RIGHT_LEFT, I2S_CHANNEL_FMT_RIGHT_LEFT )
LROT_NUMENTRY( CHANNEL_ALL_LEFT, I2S_CHANNEL_FMT_ALL_LEFT )
LROT_NUMENTRY( CHANNEL_ONLY_LEFT, I2S_CHANNEL_FMT_ONLY_LEFT )
LROT_NUMENTRY( CHANNEL_ALL_RIGHT, I2S_CHANNEL_FMT_ALL_RIGHT )
LROT_NUMENTRY( CHANNEL_ONLY_RIGHT, I2S_CHANNEL_FMT_ONLY_RIGHT )
LROT_NUMENTRY( MODE_MASTER, I2S_MODE_MASTER )
LROT_NUMENTRY( MODE_SLAVE, I2S_MODE_SLAVE )
LROT_NUMENTRY( MODE_TX, I2S_MODE_TX )
LROT_NUMENTRY( MODE_RX, I2S_MODE_RX )
LROT_NUMENTRY( MODE_DAC_BUILT_IN, I2S_MODE_DAC_BUILT_IN )
LROT_NUMENTRY( MODE_ADC_BUILT_IN, I2S_MODE_ADC_BUILT_IN )
LROT_NUMENTRY( MODE_PDM, I2S_MODE_PDM )
LROT_NUMENTRY( DAC_CHANNEL_DISABLE, I2S_DAC_CHANNEL_DISABLE )
LROT_NUMENTRY( DAC_CHANNEL_RIGHT, I2S_DAC_CHANNEL_RIGHT_EN )
LROT_NUMENTRY( DAC_CHANNEL_LEFT, I2S_DAC_CHANNEL_LEFT_EN )
LROT_NUMENTRY( DAC_CHANNEL_BOTH, I2S_DAC_CHANNEL_BOTH_EN )
LROT_END(i2s, NULL, 0)
int luaopen_i2s( lua_State *L ) {
for(int i2s_id = 0; i2s_id < MAX_I2C_NUM; i2s_id++) {
......@@ -361,4 +358,4 @@ int luaopen_i2s( lua_State *L ) {
return 0;
}
NODEMCU_MODULE(I2S, "i2s", i2s_map, luaopen_i2s);
NODEMCU_MODULE(I2S, "i2s", i2s, luaopen_i2s);
......@@ -231,66 +231,61 @@ static int lledc_set_fade( lua_State *L ) {
}
// Module function map
static const LUA_REG_TYPE ledc_channel_map[] =
{
{ LSTRKEY( "getduty" ), LFUNCVAL( lledc_get_duty ) },
{ LSTRKEY( "setduty" ), LFUNCVAL( lledc_set_duty ) },
{ LSTRKEY( "getfreq" ), LFUNCVAL( lledc_get_freq ) },
{ LSTRKEY( "setfreq" ), LFUNCVAL( lledc_set_freq ) },
{ LSTRKEY( "stop" ), LFUNCVAL( lledc_stop ) },
{ LSTRKEY( "reset" ), LFUNCVAL( lledc_timer_rst ) },
{ LSTRKEY( "pause" ), LFUNCVAL( lledc_timer_pause ) },
{ LSTRKEY( "resume" ), LFUNCVAL( lledc_timer_resume ) },
{ LSTRKEY( "fadewithtime" ), LFUNCVAL( lledc_set_fade_with_time ) },
{ LSTRKEY( "fadewithstep" ), LFUNCVAL( lledc_set_fade_with_step ) },
{ LSTRKEY( "fade" ), LFUNCVAL( lledc_set_fade ) },
{ LSTRKEY( "__index" ), LROVAL( ledc_channel_map )},
{ LNILKEY, LNILVAL }
};
static const LUA_REG_TYPE ledc_map[] =
{
{ LSTRKEY( "newChannel" ), LFUNCVAL( lledc_new_channel ) },
{ LSTRKEY( "HIGH_SPEED"), LNUMVAL( LEDC_HIGH_SPEED_MODE ) },
{ LSTRKEY( "LOW_SPEED"), LNUMVAL( LEDC_LOW_SPEED_MODE ) },
{ LSTRKEY( "TIMER_0"), LNUMVAL( LEDC_TIMER_0 ) },
{ LSTRKEY( "TIMER_1"), LNUMVAL( LEDC_TIMER_1 ) },
{ LSTRKEY( "TIMER_2"), LNUMVAL( LEDC_TIMER_2 ) },
{ LSTRKEY( "TIMER_10_BIT"), LNUMVAL( LEDC_TIMER_10_BIT ) },
{ LSTRKEY( "TIMER_11_BIT"), LNUMVAL( LEDC_TIMER_11_BIT ) },
{ LSTRKEY( "TIMER_12_BIT"), LNUMVAL( LEDC_TIMER_12_BIT ) },
{ LSTRKEY( "TIMER_13_BIT"), LNUMVAL( LEDC_TIMER_13_BIT ) },
{ LSTRKEY( "TIMER_14_BIT"), LNUMVAL( LEDC_TIMER_14_BIT ) },
{ LSTRKEY( "TIMER_15_BIT"), LNUMVAL( LEDC_TIMER_15_BIT ) },
{ LSTRKEY( "CHANNEL_0"), LNUMVAL( LEDC_CHANNEL_0 ) },
{ LSTRKEY( "CHANNEL_1"), LNUMVAL( LEDC_CHANNEL_1 ) },
{ LSTRKEY( "CHANNEL_2"), LNUMVAL( LEDC_CHANNEL_2 ) },
{ LSTRKEY( "CHANNEL_3"), LNUMVAL( LEDC_CHANNEL_3 ) },
{ LSTRKEY( "CHANNEL_4"), LNUMVAL( LEDC_CHANNEL_4 ) },
{ LSTRKEY( "CHANNEL_5"), LNUMVAL( LEDC_CHANNEL_5 ) },
{ LSTRKEY( "CHANNEL_6"), LNUMVAL( LEDC_CHANNEL_6 ) },
{ LSTRKEY( "CHANNEL_7"), LNUMVAL( LEDC_CHANNEL_7 ) },
{ LSTRKEY( "IDLE_LOW"), LNUMVAL( 0 ) },
{ LSTRKEY( "IDLE_HIGH"), LNUMVAL( 1 ) },
{ LSTRKEY( "FADE_NO_WAIT"), LNUMVAL( LEDC_FADE_NO_WAIT ) },
{ LSTRKEY( "FADE_WAIT_DONE"), LNUMVAL( LEDC_FADE_WAIT_DONE ) },
{ LSTRKEY( "FADE_DECREASE"), LNUMVAL( LEDC_DUTY_DIR_DECREASE ) },
{ LSTRKEY( "FADE_INCREASE"), LNUMVAL( LEDC_DUTY_DIR_INCREASE ) },
{ LNILKEY, LNILVAL }
};
LROT_BEGIN(ledc_channel)
LROT_FUNCENTRY( getduty, lledc_get_duty )
LROT_FUNCENTRY( setduty, lledc_set_duty )
LROT_FUNCENTRY( getfreq, lledc_get_freq )
LROT_FUNCENTRY( setfreq, lledc_set_freq )
LROT_FUNCENTRY( stop, lledc_stop )
LROT_FUNCENTRY( reset, lledc_timer_rst )
LROT_FUNCENTRY( pause, lledc_timer_pause )
LROT_FUNCENTRY( resume, lledc_timer_resume )
LROT_FUNCENTRY( fadewithtime, lledc_set_fade_with_time )
LROT_FUNCENTRY( fadewithstep, lledc_set_fade_with_step )
LROT_FUNCENTRY( fade, lledc_set_fade )
LROT_TABENTRY ( __index, ledc_channel )
LROT_END(ledc_channel, NULL, 0)
LROT_BEGIN(ledc)
LROT_FUNCENTRY( newChannel, lledc_new_channel )
LROT_NUMENTRY ( HIGH_SPEED, LEDC_HIGH_SPEED_MODE )
LROT_NUMENTRY ( LOW_SPEED, LEDC_LOW_SPEED_MODE )
LROT_NUMENTRY ( TIMER_0, LEDC_TIMER_0 )
LROT_NUMENTRY ( TIMER_1, LEDC_TIMER_1 )
LROT_NUMENTRY ( TIMER_2, LEDC_TIMER_2 )
LROT_NUMENTRY ( TIMER_10_BIT, LEDC_TIMER_10_BIT )
LROT_NUMENTRY ( TIMER_11_BIT, LEDC_TIMER_11_BIT )
LROT_NUMENTRY ( TIMER_12_BIT, LEDC_TIMER_12_BIT )
LROT_NUMENTRY ( TIMER_13_BIT, LEDC_TIMER_13_BIT )
LROT_NUMENTRY ( TIMER_14_BIT, LEDC_TIMER_14_BIT )
LROT_NUMENTRY ( TIMER_15_BIT, LEDC_TIMER_15_BIT )
LROT_NUMENTRY ( CHANNEL_0, LEDC_CHANNEL_0 )
LROT_NUMENTRY ( CHANNEL_1, LEDC_CHANNEL_1 )
LROT_NUMENTRY ( CHANNEL_2, LEDC_CHANNEL_2 )
LROT_NUMENTRY ( CHANNEL_3, LEDC_CHANNEL_3 )
LROT_NUMENTRY ( CHANNEL_4, LEDC_CHANNEL_4 )
LROT_NUMENTRY ( CHANNEL_5, LEDC_CHANNEL_5 )
LROT_NUMENTRY ( CHANNEL_6, LEDC_CHANNEL_6 )
LROT_NUMENTRY ( CHANNEL_7, LEDC_CHANNEL_7 )
LROT_NUMENTRY ( IDLE_LOW, 0 )
LROT_NUMENTRY ( IDLE_HIGH, 1 )
LROT_NUMENTRY ( FADE_NO_WAIT, LEDC_FADE_NO_WAIT )
LROT_NUMENTRY ( FADE_WAIT_DONE, LEDC_FADE_WAIT_DONE )
LROT_NUMENTRY ( FADE_DECREASE, LEDC_DUTY_DIR_DECREASE )
LROT_NUMENTRY ( FADE_INCREASE, LEDC_DUTY_DIR_INCREASE )
LROT_END(ledc, NULL, 0)
int luaopen_ledc(lua_State *L) {
luaL_rometatable(L, "ledc.channel", (void *)ledc_channel_map); // create metatable for ledc.channel
return 0;
}
NODEMCU_MODULE(LEDC, "ledc", ledc_map, luaopen_ledc);
NODEMCU_MODULE(LEDC, "ledc", ledc, luaopen_ledc);
......@@ -635,27 +635,26 @@ static int mqtt_new(lua_State* L) {
}
// map client methods to functions:
static const LUA_REG_TYPE mqtt_metatable_map[] =
{
{LSTRKEY("connect"), LFUNCVAL(mqtt_connect)},
{LSTRKEY("close"), LFUNCVAL(mqtt_close)},
{LSTRKEY("lwt"), LFUNCVAL(mqtt_lwt)},
{LSTRKEY("publish"), LFUNCVAL(mqtt_publish)},
{LSTRKEY("subscribe"), LFUNCVAL(mqtt_subscribe)},
{LSTRKEY("unsubscribe"), LFUNCVAL(mqtt_unsubscribe)},
{LSTRKEY("on"), LFUNCVAL(mqtt_on)},
{LSTRKEY("__gc"), LFUNCVAL(mqtt_delete)},
{LSTRKEY("__index"), LROVAL(mqtt_metatable_map)},
{LNILKEY, LNILVAL}};
LROT_BEGIN(mqtt_metatable)
LROT_FUNCENTRY(connect, mqtt_connect)
LROT_FUNCENTRY(close, mqtt_close)
LROT_FUNCENTRY(lwt, mqtt_lwt)
LROT_FUNCENTRY(publish, mqtt_publish)
LROT_FUNCENTRY(subscribe, mqtt_subscribe)
LROT_FUNCENTRY(unsubscribe, mqtt_unsubscribe)
LROT_FUNCENTRY(on, mqtt_on)
LROT_FUNCENTRY(__gc, mqtt_delete)
LROT_TABENTRY(__index, mqtt_metatable)
LROT_END(mqtt_metatable, NULL, 0)
// Module function map
static const LUA_REG_TYPE mqtt_map[] = {
{LSTRKEY("Client"), LFUNCVAL(mqtt_new)},
{LNILKEY, LNILVAL}};
LROT_BEGIN(mqtt)
LROT_FUNCENTRY(Client, mqtt_new)
LROT_END(mqtt, NULL, 0)
int luaopen_mqtt(lua_State* L) {
luaL_rometatable(L, MQTT_METATABLE, (void*)mqtt_metatable_map); // create metatable for mqtt
return 0;
}
NODEMCU_MODULE(MQTT, "mqtt", mqtt_map, luaopen_mqtt);
NODEMCU_MODULE(MQTT, "mqtt", mqtt, luaopen_mqtt);
......@@ -1155,62 +1155,56 @@ static void lerr_cb (lua_State *L, lnet_userdata *ud, err_t err)
// --- Tables
// 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( "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( "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 ) },
{ LSTRKEY( "TCP" ), LNUMVAL( TYPE_TCP ) },
{ LSTRKEY( "UDP" ), LNUMVAL( TYPE_UDP ) },
{ LSTRKEY( "__metatable" ), LROVAL( net_map ) },
{ LNILKEY, LNILVAL }
};
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, NULL, 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( getpeer, net_getpeer )
LROT_FUNCENTRY( getaddr, net_getaddr )
LROT_FUNCENTRY( __gc, net_delete )
LROT_TABENTRY ( __index, net_tcpsocket )
LROT_END(net_tcpsocket, NULL, 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( getaddr, net_getaddr )
LROT_FUNCENTRY( __gc, net_delete )
LROT_TABENTRY ( __index, net_udpsocket )
LROT_END(net_udpsocket, NULL, 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, NULL, 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 )
LROT_NUMENTRY ( TCP, TYPE_TCP )
LROT_NUMENTRY ( UDP, TYPE_UDP )
LROT_TABENTRY ( __metatable, net )
LROT_END(net, NULL, 0)
int luaopen_net( lua_State *L ) {
igmp_init();
......@@ -1225,4 +1219,4 @@ int luaopen_net( lua_State *L ) {
return 0;
}
NODEMCU_MODULE(NET, "net", net_map, luaopen_net);
NODEMCU_MODULE(NET, "net", net, luaopen_net);
......@@ -11,6 +11,7 @@
#include "ldebug.h"
#include "esp_vfs.h"
#include "lnodeaux.h"
#include "lflash.h"
// Lua: node.chipid()
static int node_chipid( lua_State *L )
......@@ -371,40 +372,39 @@ static int node_uptime(lua_State *L)
}
static const LUA_REG_TYPE node_egc_map[] = {
{ 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( "chipid" ), LFUNCVAL( node_chipid ) },
{ LSTRKEY( "compile" ), LFUNCVAL( node_compile ) },
{ LSTRKEY( "dsleep" ), LFUNCVAL( node_dsleep ) },
{ LSTRKEY( "egc" ), LROVAL( node_egc_map ) },
{ LSTRKEY( "heap" ), LFUNCVAL( node_heap ) },
{ LSTRKEY( "input" ), LFUNCVAL( node_input ) },
{ LSTRKEY( "output" ), LFUNCVAL( node_output ) },
{ LSTRKEY( "osprint" ), LFUNCVAL( node_osprint ) },
{ LSTRKEY( "restart" ), LFUNCVAL( node_restart ) },
{ LSTRKEY( "stripdebug"), LFUNCVAL( node_stripdebug ) },
{ LSTRKEY( "task" ), LROVAL( node_task_map ) },
{ LSTRKEY( "uptime" ), LFUNCVAL( node_uptime ) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(NODE, "node", node_map, NULL);
LROT_BEGIN(node_egc)
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( chipid, node_chipid )
LROT_FUNCENTRY( compile, node_compile )
LROT_FUNCENTRY( dsleep, node_dsleep )
LROT_TABENTRY ( egc, node_egc )
LROT_FUNCENTRY( flashreload,luaN_reload_reboot )
LROT_FUNCENTRY( flashindex, luaN_index )
LROT_FUNCENTRY( heap, node_heap )
LROT_FUNCENTRY( input, node_input )
LROT_FUNCENTRY( output, node_output )
LROT_FUNCENTRY( osprint, node_osprint )
LROT_FUNCENTRY( restart, node_restart )
LROT_FUNCENTRY( stripdebug, node_stripdebug )
LROT_TABENTRY ( task, node_task )
LROT_FUNCENTRY( uptime, node_uptime )
LROT_END(node, NULL, 0)
NODEMCU_MODULE(NODE, "node", node, NULL);
......@@ -239,15 +239,13 @@ next:
}
static const LUA_REG_TYPE otaupgrade_map[] =
{
{ LSTRKEY( "commence" ), LFUNCVAL( lotaupgrade_commence ) },
{ LSTRKEY( "write" ), LFUNCVAL( lotaupgrade_write) },
{ LSTRKEY( "complete" ), LFUNCVAL( lotaupgrade_complete) },
{ LSTRKEY( "accept" ), LFUNCVAL( lotaupgrade_accept) },
{ LSTRKEY( "rollback" ), LFUNCVAL( lotaupgrade_rollback) },
{ LSTRKEY( "info" ), LFUNCVAL( lotaupgrade_info) },
{ LNILKEY, LNILVAL }
};
NODEMCU_MODULE(OTAUPGRADE, "otaupgrade", otaupgrade_map, NULL);
LROT_BEGIN(otaupgrade)
LROT_FUNCENTRY( commence, lotaupgrade_commence )
LROT_FUNCENTRY( write, lotaupgrade_write )
LROT_FUNCENTRY( complete, lotaupgrade_complete )
LROT_FUNCENTRY( accept, lotaupgrade_accept )
LROT_FUNCENTRY( rollback, lotaupgrade_rollback )
LROT_FUNCENTRY( info, lotaupgrade_info )
LROT_END(otaupgrade, 0, NULL)
NODEMCU_MODULE(OTAUPGRADE, "otaupgrade", otaupgrade, NULL);
......@@ -326,24 +326,23 @@ static int ow_crc16( lua_State *L )
return 1;
}
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 ) },
{ LSTRKEY( "reset_search" ), LFUNCVAL( ow_reset_search ) },
{ LSTRKEY( "target_search" ), LFUNCVAL( ow_target_search ) },
{ LSTRKEY( "search" ), LFUNCVAL( ow_search ) },
{ LSTRKEY( "crc8" ), LFUNCVAL( ow_crc8 ) },
{ LSTRKEY( "check_crc16" ), LFUNCVAL( ow_check_crc16 ) },
{ LSTRKEY( "crc16" ), LFUNCVAL( ow_crc16 ) },
{ LNILKEY, LNILVAL }
};
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 )
LROT_FUNCENTRY( reset_search, ow_reset_search )
LROT_FUNCENTRY( target_search, ow_target_search )
LROT_FUNCENTRY( search, ow_search )
LROT_FUNCENTRY( crc8, ow_crc8 )
LROT_FUNCENTRY( check_crc16, ow_check_crc16 )
LROT_FUNCENTRY( crc16, ow_crc16 )
LROT_END(ow, NULL, 0)
int luaopen_ow( lua_State *L )
{
......@@ -354,4 +353,4 @@ int luaopen_ow( lua_State *L )
return 0;
}
NODEMCU_MODULE(OW, "ow", ow_map, luaopen_ow);
NODEMCU_MODULE(OW, "ow", ow, luaopen_ow);
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