do_sleep_opt (L, 2); rtctime_deep_sleep_us (us); // does not return return 0; } // rtctime.dsleep_aligned (aligned_usec, min_usec, option) static int rtctime_dsleep_aligned (lua_State *L) { if (!rtctime_have_time ()) return luaL_error (L, "time not available, unable to align"); uint32_t align_us = luaL_checknumber (L, 1); uint32_t min_us = luaL_checknumber (L, 2); do_sleep_opt (L, 3); rtctime_deep_sleep_until_aligned_us (align_us, min_us); // does not return return 0; } // Module function map static const LUA_REG_TYPE rtctime_map[] = { { LSTRKEY("set"), LFUNCVAL(rtctime_set) }, { LSTRKEY("get"), LFUNCVAL(rtctime_get) }, { LSTRKEY("dsleep"), LFUNCVAL(rtctime_dsleep) }, { LSTRKEY("dsleep_aligned"), LFUNCVAL(rtctime_dsleep_aligned) }, { LNILKEY, LNILVAL } }; NODEMCU_MODULE(RTCTIME, "rtctime", rtctime_map, NULL);
os_update_cpu_frequency(CPU160MHZ); } else { REG_CLR_BIT(0x3ff00014, BIT(0)); os_update_cpu_frequency(CPU80MHZ); } new_freq = ets_get_cpu_frequency(); lua_pushinteger(L, new_freq); return 1; } // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE node_map[] = { { LSTRKEY( "restart" ), LFUNCVAL( node_restart ) }, { LSTRKEY( "dsleep" ), LFUNCVAL( node_deepsleep ) }, { LSTRKEY( "info" ), LFUNCVAL( node_info ) }, { LSTRKEY( "chipid" ), LFUNCVAL( node_chipid ) }, { LSTRKEY( "flashid" ), LFUNCVAL( node_flashid ) }, { LSTRKEY( "flashsize" ), LFUNCVAL( node_flashsize) }, { LSTRKEY( "heap" ), LFUNCVAL( node_heap ) }, #ifdef DEVKIT_VERSION_0_9 { LSTRKEY( "key" ), LFUNCVAL( node_key ) }, { LSTRKEY( "led" ), LFUNCVAL( node_led ) }, #endif { LSTRKEY( "input" ), LFUNCVAL( node_input ) }, { LSTRKEY( "output" ), LFUNCVAL( node_output ) }, // Moved to adc module, use adc.readvdd33() // { LSTRKEY( "readvdd33" ), LFUNCVAL( node_readvdd33) }, { LSTRKEY( "compile" ), LFUNCVAL( node_compile) },
if (result == LUA_ERR_CC_INTOVERFLOW) { return luaL_error(L, "value too big or small for target integer type"); } if (result == LUA_ERR_CC_NOTINTEGER) { return luaL_error(L, "target lua_Number is integral but fractional value found"); } return 0; } #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE file_map[] = { { LSTRKEY( "list" ), LFUNCVAL( file_list ) }, { LSTRKEY( "slist" ), LFUNCVAL( file_slist ) }, { LSTRKEY( "format" ), LFUNCVAL( file_format ) }, { 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 ) }, { LSTRKEY( "remove" ), LFUNCVAL( file_remove ) }, { LSTRKEY( "seek" ), LFUNCVAL( file_seek ) }, { LSTRKEY( "flush" ), LFUNCVAL( file_flush ) }, { LSTRKEY( "rename" ), LFUNCVAL( file_rename ) }, { LSTRKEY( "info" ), LFUNCVAL( file_info ) }, { LSTRKEY( "state" ), LFUNCVAL( file_state ) }, { LSTRKEY( "compile" ), LFUNCVAL( file_compile ) },
int crc = 0; if(lua_isnumber(L, 2)) crc = lua_tointeger(L, 2); if(crc > 65535) return luaL_error( L, "wrong arg range" ); lua_pushinteger( L, onewire_crc16(pdata, (uint16_t)datalen, (uint16_t)crc) ); return 1; } #endif #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 ) }, #if ONEWIRE_SEARCH { LSTRKEY( "reset_search" ), LFUNCVAL( ow_reset_search ) }, { LSTRKEY( "target_search" ), LFUNCVAL( ow_target_search ) }, { LSTRKEY( "search" ), LFUNCVAL( ow_search ) }, #endif #if ONEWIRE_CRC { LSTRKEY( "crc8" ), LFUNCVAL( ow_crc8 ) },
default: { /* also treat cases `pnLlh' */ return luaL_error(L, "invalid option " LUA_QL("%%%c") " to " LUA_QL("format"), *(strfrmt - 1)); } } luaL_addlstring(&b, buff, c_strlen(buff)); } } luaL_pushresult(&b); return 1; } #define MIN_OPT_LEVEL 1 #include "lrodefs.h" const LUA_REG_TYPE strlib[] = { {LSTRKEY("byte"), LFUNCVAL(str_byte)}, {LSTRKEY("char"), LFUNCVAL(str_char)}, {LSTRKEY("dump"), LFUNCVAL(str_dump)}, {LSTRKEY("find"), LFUNCVAL(str_find)}, {LSTRKEY("format"), LFUNCVAL(str_format)}, #if LUA_OPTIMIZE_MEMORY > 0 && defined(LUA_COMPAT_GFIND) {LSTRKEY("gfind"), LFUNCVAL(gmatch)}, #else {LSTRKEY("gfind"), LFUNCVAL(gfind_nodef)}, #endif {LSTRKEY("gmatch"), LFUNCVAL(gmatch)}, {LSTRKEY("gsub"), LFUNCVAL(str_gsub)}, {LSTRKEY("len"), LFUNCVAL(str_len)}, {LSTRKEY("lower"), LFUNCVAL(str_lower)}, {LSTRKEY("match"), LFUNCVAL(str_match)}, {LSTRKEY("rep"), LFUNCVAL(str_rep)},
} // Lua: elua.version() static int version( lua_State *L ) { lua_pushstring( L, ELUA_STR_VERSION ); return 1; } // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE elua_map[] = { { LSTRKEY( "egc_setup" ), LFUNCVAL( egc_setup ) }, { LSTRKEY( "version" ), LFUNCVAL( version ) }, #if LUA_OPTIMIZE_MEMORY > 0 { LSTRKEY( "EGC_NOT_ACTIVE" ), LNUMVAL( EGC_NOT_ACTIVE ) }, { LSTRKEY( "EGC_ON_ALLOC_FAILURE" ), LNUMVAL( EGC_ON_ALLOC_FAILURE ) }, { LSTRKEY( "EGC_ON_MEM_LIMIT" ), LNUMVAL( EGC_ON_MEM_LIMIT ) }, { LSTRKEY( "EGC_ALWAYS" ), LNUMVAL( EGC_ALWAYS ) }, #endif { LNILKEY, LNILVAL } }; LUALIB_API int luaopen_elua( lua_State *L ) { #if LUA_OPTIMIZE_MEMORY > 0 return 0; #else
return 1; } // Lua: wifi.ap.dhcp.stop() static int wifi_ap_dhcp_stop( lua_State* L ) { lua_pushboolean(L, wifi_softap_dhcps_stop()); return 1; } // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" static const LUA_REG_TYPE wifi_station_map[] = { { LSTRKEY( "getconfig" ), LFUNCVAL ( wifi_station_getconfig ) }, { LSTRKEY( "config" ), LFUNCVAL ( wifi_station_config ) }, { LSTRKEY( "connect" ), LFUNCVAL ( wifi_station_connect4lua ) }, { LSTRKEY( "disconnect" ), LFUNCVAL ( wifi_station_disconnect4lua ) }, { LSTRKEY( "autoconnect" ), LFUNCVAL ( wifi_station_setauto ) }, { LSTRKEY( "getip" ), LFUNCVAL ( wifi_station_getip ) }, { LSTRKEY( "setip" ), LFUNCVAL ( wifi_station_setip ) }, { LSTRKEY( "getbroadcast" ), LFUNCVAL ( wifi_station_getbroadcast) }, { LSTRKEY( "getmac" ), LFUNCVAL ( wifi_station_getmac ) }, { LSTRKEY( "setmac" ), LFUNCVAL ( wifi_station_setmac ) }, { LSTRKEY( "getap" ), LFUNCVAL ( wifi_station_listap ) }, { LSTRKEY( "status" ), LFUNCVAL ( wifi_station_status ) }, { LSTRKEY( "eventMonReg" ), LFUNCVAL ( wifi_station_event_mon_reg ) }, { LSTRKEY( "eventMonStart" ), LFUNCVAL ( wifi_station_event_mon_start ) }, { LSTRKEY( "eventMonStop" ), LFUNCVAL ( wifi_station_event_mon_stop ) }, { LNILKEY, LNILVAL }
case BOOT_REASON_EXPIN_RST: strcpy(str,"EXPIN_RST");break; case BOOT_REASON_WDG_RST: strcpy(str,"WDG_RST");break; case BOOT_REASON_WWDG_RST: strcpy(str,"WWDG_RST");break; case BOOT_REASON_LOWPWR_RST: strcpy(str,"LOWPWR_RST");break; case BOOT_REASON_BOR_RST: strcpy(str,"BOR_RST");break; default:strcpy(str,"NONE");break; } lua_pushstring(L,str); return 1; } #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE mcu_map[] = { { LSTRKEY( "ver" ), LFUNCVAL( mcu_version )}, { LSTRKEY( "info" ), LFUNCVAL( mcu_wifiinfo )}, { LSTRKEY( "reboot" ), LFUNCVAL( mcu_reboot )}, { LSTRKEY( "mem" ), LFUNCVAL( mcu_memory )}, { LSTRKEY( "chipid" ), LFUNCVAL( mcu_chipid )}, { LSTRKEY( "bootreason" ), LFUNCVAL(mcu_bootreason)}, { LSTRKEY( "getparams" ), LFUNCVAL(get_params)}, { LSTRKEY( "sgetparams" ), LFUNCVAL(get_sparams)}, { LSTRKEY( "setparams" ), LFUNCVAL(set_sparams)}, { LSTRKEY( "queuepush" ), LFUNCVAL(queue_push)}, { LSTRKEY( "random" ), LFUNCVAL(mcu_random)}, #if LUA_OPTIMIZE_MEMORY > 0 #endif {LNILKEY, LNILVAL} };
// Lua: iptype = lookup( "name" ) static int net_lookup( lua_State *L ) { const char *name = luaL_checkstring( L, 1 ); elua_net_ip res; res = elua_net_lookup( name ); lua_pushinteger( L, res.ipaddr ); return 1; } // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE net_map[] = { { LSTRKEY( "accept" ), LFUNCVAL( net_accept ) }, { LSTRKEY( "packip" ), LFUNCVAL( net_packip ) }, { LSTRKEY( "unpackip" ), LFUNCVAL( net_unpackip ) }, { LSTRKEY( "connect" ), LFUNCVAL( net_connect ) }, { LSTRKEY( "socket" ), LFUNCVAL( net_socket ) }, { LSTRKEY( "close" ), LFUNCVAL( net_close ) }, { LSTRKEY( "send" ), LFUNCVAL( net_send ) }, { LSTRKEY( "recv" ), LFUNCVAL( net_recv ) }, { LSTRKEY( "lookup" ), LFUNCVAL( net_lookup ) }, #if LUA_OPTIMIZE_MEMORY > 0 { LSTRKEY( "SOCK_STREAM" ), LNUMVAL( ELUA_NET_SOCK_STREAM ) }, { LSTRKEY( "SOCK_DGRAM" ), LNUMVAL( ELUA_NET_SOCK_DGRAM ) }, { LSTRKEY( "ERR_OK" ), LNUMVAL( ELUA_NET_ERR_OK ) }, { LSTRKEY( "ERR_TIMEOUT" ), LNUMVAL( ELUA_NET_ERR_TIMEDOUT ) }, { LSTRKEY( "ERR_CLOSED" ), LNUMVAL( ELUA_NET_ERR_CLOSED ) }, { LSTRKEY( "ERR_ABORTED" ), LNUMVAL( ELUA_NET_ERR_ABORTED ) },
} #else extern int pio_mt_index( lua_State* L ); extern int pio_decode( lua_State *L ); #endif // ***************************************************************************** // Pin function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" static const LUA_REG_TYPE pio_pin_map[] = { { LSTRKEY( "setdir" ), LFUNCVAL ( pio_pin_setdir ) }, { LSTRKEY( "output" ), LFUNCVAL( pio_pin_output ) }, { LSTRKEY( "input" ), LFUNCVAL( pio_pin_input ) }, { LSTRKEY( "setpull" ), LFUNCVAL( pio_pin_setpull ) }, { LSTRKEY( "setval" ), LFUNCVAL( pio_pin_setval ) }, { LSTRKEY( "sethigh" ), LFUNCVAL( pio_pin_sethigh ) }, { LSTRKEY( "setlow" ), LFUNCVAL( pio_pin_setlow ) }, { LSTRKEY( "getval" ), LFUNCVAL( pio_pin_getval ) }, { LNILKEY, LNILVAL } }; static const LUA_REG_TYPE pio_port_map[] = { { LSTRKEY( "setdir" ), LFUNCVAL( pio_port_setdir ) }, { LSTRKEY( "output" ), LFUNCVAL( pio_port_output ) }, { LSTRKEY( "input" ), LFUNCVAL( pio_port_input ) },
return luaL_error( L, "invalid number" ); platform_uart_send( id, ( u8 )len ); } else { luaL_checktype( L, s, LUA_TSTRING ); buf = lua_tolstring( L, s, &len ); for( i = 0; i < len; i ++ ) platform_uart_send( id, buf[ i ] ); } } return 0; } // Module function map static const LUA_REG_TYPE uart_map[] = { { LSTRKEY( "setup" ), LFUNCVAL( uart_setup ) }, { LSTRKEY( "write" ), LFUNCVAL( uart_write ) }, { LSTRKEY( "on" ), LFUNCVAL( uart_on ) }, { LSTRKEY( "alt" ), LFUNCVAL( uart_alt ) }, { LSTRKEY( "STOPBITS_1" ), LNUMVAL( PLATFORM_UART_STOPBITS_1 ) }, { LSTRKEY( "STOPBITS_1_5" ), LNUMVAL( PLATFORM_UART_STOPBITS_1_5 ) }, { LSTRKEY( "STOPBITS_2" ), LNUMVAL( PLATFORM_UART_STOPBITS_2 ) }, { LSTRKEY( "PARITY_NONE" ), LNUMVAL( PLATFORM_UART_PARITY_NONE ) }, { LSTRKEY( "PARITY_EVEN" ), LNUMVAL( PLATFORM_UART_PARITY_EVEN ) }, { LSTRKEY( "PARITY_ODD" ), LNUMVAL( PLATFORM_UART_PARITY_ODD ) }, { LNILKEY, LNILVAL } }; NODEMCU_MODULE(UART, "uart", uart_map, NULL);
{ LSTRKEY( "DeviceInSilentState" ), LINTVAL( LORA_DEVICE_IN_SILENT_STATE ) }, { LSTRKEY( "DeviceIsNotIdle" ), LINTVAL( LORA_DEVICE_DEVICE_IS_NOT_IDLE ) }, { LSTRKEY( "Paused" ), LINTVAL( LORA_PAUSED ) }, { LSTRKEY( "Timeout" ), LINTVAL( LORA_TIMEOUT ) }, { LSTRKEY( "JoinDenied" ), LINTVAL( LORA_JOIN_DENIED ) }, { LSTRKEY( "UnexpectedResponse" ), LINTVAL( LORA_UNEXPECTED_RESPONSE ) }, { LSTRKEY( "NotJoined" ), LINTVAL( LORA_NOT_JOINED ) }, { LSTRKEY( "RejoinNeeded" ), LINTVAL( LORA_REJOIN_NEEDED ) }, { LSTRKEY( "InvalidDataLen" ), LINTVAL( LORA_INVALID_DATA_LEN ) }, { LSTRKEY( "TransmissionFail" ), LINTVAL( LORA_TRANSMISSION_FAIL_ACK_NOT_RECEIVED ) }, { LSTRKEY( "NotSetup" ), LINTVAL( LORA_NOT_SETUP ) }, { LSTRKEY( "InvalidArgument" ), LINTVAL( LORA_INVALID_PARAM ) }, }; static const LUA_REG_TYPE lora_map[] = { { LSTRKEY( "setup" ), LFUNCVAL( llora_setup ) }, { LSTRKEY( "setDevAddr" ), LFUNCVAL( llora_set_setDevAddr ) }, { LSTRKEY( "setDevEui" ), LFUNCVAL( llora_set_DevEui ) }, { LSTRKEY( "setAppEui" ), LFUNCVAL( llora_set_AppEui ) }, { LSTRKEY( "setAppKey" ), LFUNCVAL( llora_set_AppKey ) }, { LSTRKEY( "setNwksKey" ), LFUNCVAL( llora_set_NwkSKey ) }, { LSTRKEY( "setAppsKey" ), LFUNCVAL( llora_set_AppSKey ) }, { LSTRKEY( "setAppKey" ), LFUNCVAL( llora_set_AppKey ) }, { LSTRKEY( "setDr" ), LFUNCVAL( llora_set_Dr ) }, { LSTRKEY( "setAdr" ), LFUNCVAL( llora_set_Adr ) }, { LSTRKEY( "setRetX" ), LFUNCVAL( llora_set_RetX ) }, { LSTRKEY( "setLinkChk" ), LFUNCVAL( llora_set_LinkChk ) }, // MUST DO { LSTRKEY( "setRxDelay1" ), LFUNCVAL( llora_nothing ) }, { LSTRKEY( "setAr" ), LFUNCVAL( llora_set_Ar ) }, { LSTRKEY( "setRx2" ), LFUNCVAL( llora_nothing ) }, // MUST DO { LSTRKEY( "setChFreq" ), LFUNCVAL( llora_nothing ) }, // MUST DO
luaL_checkstack(L, 40, ""); /* assume array is smaller than 2^40 */ if (!lua_isnoneornil(L, 2)) /* is there a 2nd argument? */ luaL_checktype(L, 2, LUA_TFUNCTION); /* must be a function */ lua_settop(L, 2); /* make sure there are two arguments */ auxsort(L, 1, (unsigned int)n, 0u); } return 0; } /* }====================================================== */ #include "modules.h" static const LUA_REG_TYPE tab_funcs[] = { { LSTRKEY( "concat" ), LFUNCVAL( tconcat ) }, #if defined(LUA_COMPAT_MAXN) { LSTRKEY( "maxn" ), LFUNCVAL( maxn ) }, #endif { LSTRKEY( "insert" ), LFUNCVAL( tinsert ) }, { LSTRKEY( "pack" ), LFUNCVAL( pack ) }, { LSTRKEY( "unpack" ), LFUNCVAL( unpack ) }, { LSTRKEY( "remove" ), LFUNCVAL( tremove ) }, { LSTRKEY( "move" ), LFUNCVAL( tmove ) }, { LSTRKEY( "sort" ), LFUNCVAL( sort ) }, { LNILKEY, LNILVAL } }; LUAMOD_API int luaopen_table (lua_State *L) { #if !LUA_USE_ROTABLE
MicoUartSend( LUA_USR_UART,(char*)len,1); } else { luaL_checktype( L, s, LUA_TSTRING ); buf = lua_tolstring( L, s, &len ); MicoUartSend( LUA_USR_UART, buf,len); } } return 0; } #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE uart_map[] = { { LSTRKEY( "setup" ), LFUNCVAL( uart_setup )}, { LSTRKEY( "on" ), LFUNCVAL( uart_on )}, { LSTRKEY( "send" ), LFUNCVAL( uart_send )}, #if LUA_OPTIMIZE_MEMORY > 0 #endif {LNILKEY, LNILVAL} }; LUALIB_API int luaopen_uart(lua_State *L) { #if LUA_OPTIMIZE_MEMORY > 0 return 0; #else luaL_register( L, EXLIB_UART, uart_map ); return 1; #endif
y = luaL_checkinteger(L, 3); width = luaL_checkinteger(L, 4); height = luaL_checkinteger(L, 5); lm3s_disp_imageDraw(( const unsigned char* )img, x, y, width, height); return 0; } #define MIN_OPT_LEVEL 2 #include "lrodefs.h" // Module function map const LUA_REG_TYPE disp_map[] = { { LSTRKEY( "init" ), LFUNCVAL( disp_init ) }, { LSTRKEY( "enable" ), LFUNCVAL( disp_enable ) }, { LSTRKEY( "disable" ), LFUNCVAL( disp_disable ) }, { LSTRKEY( "on" ), LFUNCVAL( disp_on ) }, { LSTRKEY( "off" ), LFUNCVAL( disp_off ) }, { LSTRKEY( "clear" ), LFUNCVAL( disp_clear ) }, { LSTRKEY( "print" ), LFUNCVAL( disp_stringDraw ) }, { LSTRKEY( "draw" ), LFUNCVAL( disp_imageDraw ) }, { LNILKEY, LNILVAL } }; LUALIB_API int luaopen_disp( lua_State *L ) { LREGISTER( L, AUXLIB_DISP, disp_map ); }
return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL); } static int f_flush (lua_State *L) { return pushresult(L, fflush(tofile(L)) == 0, NULL); } #define MIN_OPT_LEVEL 2 #include "lrodefs.h" #if LUA_OPTIMIZE_MEMORY == 2 const LUA_REG_TYPE iolib_funcs[] = { #else const LUA_REG_TYPE iolib[] = { #endif {LSTRKEY("close"), LFUNCVAL(io_close)}, {LSTRKEY("flush"), LFUNCVAL(io_flush)}, {LSTRKEY("input"), LFUNCVAL(io_input)}, {LSTRKEY("lines"), LFUNCVAL(io_lines)}, {LSTRKEY("open"), LFUNCVAL(io_open)}, {LSTRKEY("output"), LFUNCVAL(io_output)}, {LSTRKEY("popen"), LFUNCVAL(io_popen)}, {LSTRKEY("read"), LFUNCVAL(io_read)}, {LSTRKEY("tmpfile"), LFUNCVAL(io_tmpfile)}, {LSTRKEY("type"), LFUNCVAL(io_type)}, {LSTRKEY("write"), LFUNCVAL(io_write)}, {LNILKEY, LNILVAL} }; #if LUA_OPTIMIZE_MEMORY == 2 static int luaL_index(lua_State *L) {
lua_pushinteger( L, idtype ); lua_pushlstring( L, ( const char * )data, ( size_t )len ); return 3; } else return 0; } // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE can_map[] = { { LSTRKEY( "setup" ), LFUNCVAL( can_setup ) }, { LSTRKEY( "send" ), LFUNCVAL( can_send ) }, { LSTRKEY( "recv" ), LFUNCVAL( can_recv ) }, #if LUA_OPTIMIZE_MEMORY > 0 { LSTRKEY( "ID_STD" ), LNUMVAL( ELUA_CAN_ID_STD ) }, { LSTRKEY( "ID_EXT" ), LNUMVAL( ELUA_CAN_ID_EXT ) }, #endif { LNILKEY, LNILVAL } }; LUALIB_API int luaopen_can( lua_State *L ) { #if LUA_OPTIMIZE_MEMORY > 0 return 0; #else // #if LUA_OPTIMIZE_MEMORY > 0 luaL_register( L, AUXLIB_CAN, can_map );
res = strtol( key + 4, &pend, 10 ); if( *pend != '\0' ) return 0; if( res >= VTMR_NUM_TIMERS ) return 0; lua_pushinteger( L, VTMR_FIRST_ID + res ); return 1; } #endif // #if VTMR_NUM_TIMERS > 0 // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE tmr_map[] = { { LSTRKEY( "delay" ), LFUNCVAL( tmr_delay ) }, { LSTRKEY( "read" ), LFUNCVAL( tmr_read ) }, { LSTRKEY( "start" ), LFUNCVAL( tmr_start ) }, { LSTRKEY( "gettimediff" ), LFUNCVAL( tmr_gettimediff ) }, { LSTRKEY( "getdiffnow" ), LFUNCVAL( tmr_getdiffnow ) }, { LSTRKEY( "getmindelay" ), LFUNCVAL( tmr_getmindelay ) }, { LSTRKEY( "getmaxdelay" ), LFUNCVAL( tmr_getmaxdelay ) }, { LSTRKEY( "setclock" ), LFUNCVAL( tmr_setclock ) }, { LSTRKEY( "getclock" ), LFUNCVAL( tmr_getclock ) }, #ifdef BUILD_LUA_INT_HANDLERS { LSTRKEY( "set_match_int" ), LFUNCVAL( tmr_set_match_int ) }, #endif #if LUA_OPTIMIZE_MEMORY > 0 && VTMR_NUM_TIMERS > 0 { LSTRKEY( "__metatable" ), LROVAL( tmr_map ) }, #endif #if VTMR_NUM_TIMERS > 0
return 1; } #endif static int math_randomseed (lua_State *L) { srand(luaL_checkint(L, 1)); return 0; } #define MIN_OPT_LEVEL 1 #include "lrodefs.h" const LUA_REG_TYPE math_map[] = { #ifdef LUA_NUMBER_INTEGRAL {LSTRKEY("abs"), LFUNCVAL(math_abs)}, {LSTRKEY("ceil"), LFUNCVAL(math_identity)}, {LSTRKEY("floor"), LFUNCVAL(math_identity)}, {LSTRKEY("max"), LFUNCVAL(math_max)}, {LSTRKEY("min"), LFUNCVAL(math_min)}, {LSTRKEY("pow"), LFUNCVAL(math_pow)}, {LSTRKEY("random"), LFUNCVAL(math_random)}, {LSTRKEY("randomseed"), LFUNCVAL(math_randomseed)}, {LSTRKEY("sqrt"), LFUNCVAL(math_sqrt)}, #if LUA_OPTIMIZE_MEMORY > 0 {LSTRKEY("huge"), LNUMVAL(LONG_MAX)}, #endif #else {LSTRKEY("abs"), LFUNCVAL(math_abs)}, // {LSTRKEY("acos"), LFUNCVAL(math_acos)}, // {LSTRKEY("asin"), LFUNCVAL(math_asin)},
return 1; } #endif static int math_randomseed (lua_State *L) { srand(luaL_checkint(L, 1)); return 0; } #define MIN_OPT_LEVEL 1 #include "lrodefs.h" const LUA_REG_TYPE math_map[] = { #ifdef LUA_NUMBER_INTEGRAL {LSTRKEY("abs"), LFUNCVAL(math_abs)}, {LSTRKEY("max"), LFUNCVAL(math_max)}, {LSTRKEY("min"), LFUNCVAL(math_min)}, {LSTRKEY("random"), LFUNCVAL(math_random)}, {LSTRKEY("randomseed"), LFUNCVAL(math_randomseed)}, {LSTRKEY("sqrt"), LFUNCVAL(math_sqrt)}, #if LUA_OPTIMIZE_MEMORY > 0 {LSTRKEY("huge"), LNUMVAL(LONG_MAX)}, #endif #else {LSTRKEY("abs"), LFUNCVAL(math_abs)}, {LSTRKEY("acos"), LFUNCVAL(math_acos)}, {LSTRKEY("asin"), LFUNCVAL(math_asin)}, {LSTRKEY("atan2"), LFUNCVAL(math_atan2)}, {LSTRKEY("atan"), LFUNCVAL(math_atan)}, {LSTRKEY("ceil"), LFUNCVAL(math_ceil)},
} int timer_tostring(lua_State *L) { timer_info_t *p = ((timer_info_t *)luaL_checkudata(L, -1, LUA_TIMER)); lua_pushfstring(L, "timer (%p)", p->timer_id); return 1; } #undef MIN_OPT_LEVEL #define MIN_OPT_LEVEL 0 #include "lrodefs.h" const LUA_REG_TYPE timer_map[] = { {LSTRKEY("create"), LFUNCVAL(timer_create)}, {LSTRKEY("delete"), LFUNCVAL(timer_delete)}, {LNILKEY, LNILVAL} }; const LUA_REG_TYPE timer_table[] = { {LSTRKEY("delete"), LFUNCVAL(timer_delete)}, {LSTRKEY("__gc"), LFUNCVAL(timer_gc)}, {LSTRKEY("__tostring"), LFUNCVAL(timer_tostring)}, {LNILKEY, LNILVAL} }; LUALIB_API int luaopen_timer(lua_State *L) { luaL_newmetatable(L, LUA_TIMER); /* create metatable for file handles */ lua_pushvalue(L, -1); /* push metatable */
int n = aux_getn(L, 1); luaL_checkstack(L, 40, ""); /* assume array is smaller than 2^40 */ if (!lua_isnoneornil(L, 2)) /* is there a 2nd argument? */ luaL_checktype(L, 2, LUA_TFUNCTION); lua_settop(L, 2); /* make sure there is two arguments */ auxsort(L, 1, n); return 0; } /* }====================================================== */ #define MIN_OPT_LEVEL 1 #include "lrodefs.h" const LUA_REG_TYPE tab_funcs[] = { {LSTRKEY("concat"), LFUNCVAL(tconcat)}, {LSTRKEY("foreach"), LFUNCVAL(foreach)}, {LSTRKEY("foreachi"), LFUNCVAL(foreachi)}, {LSTRKEY("getn"), LFUNCVAL(getn)}, {LSTRKEY("maxn"), LFUNCVAL(maxn)}, {LSTRKEY("insert"), LFUNCVAL(tinsert)}, {LSTRKEY("remove"), LFUNCVAL(tremove)}, {LSTRKEY("setn"), LFUNCVAL(setn)}, {LSTRKEY("sort"), LFUNCVAL(sort)}, {LNILKEY, LNILVAL} }; LUALIB_API int luaopen_table (lua_State *L) { LREGISTER(L, LUA_TABLIBNAME, tab_funcs); }
return 0; if( res >= SERMUX_NUM_VUART ) return 0; lua_pushinteger( L, SERMUX_SERVICE_ID_FIRST + res ); return 1; #endif return 0; } #endif // #ifdef BUILD_SERMUX // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE uart_map[] = { { LSTRKEY( "setup" ), LFUNCVAL( uart_setup ) }, { LSTRKEY( "write" ), LFUNCVAL( uart_write ) }, { LSTRKEY( "read" ), LFUNCVAL( uart_read ) }, { LSTRKEY( "getchar" ), LFUNCVAL( uart_getchar ) }, { LSTRKEY( "set_buffer" ), LFUNCVAL( uart_set_buffer ) }, { LSTRKEY( "set_flow_control" ), LFUNCVAL( uart_set_flow_control ) }, #if LUA_OPTIMIZE_MEMORY > 0 { LSTRKEY( "PAR_EVEN" ), LNUMVAL( PLATFORM_UART_PARITY_EVEN ) }, { LSTRKEY( "PAR_ODD" ), LNUMVAL( PLATFORM_UART_PARITY_ODD ) }, { LSTRKEY( "PAR_NONE" ), LNUMVAL( PLATFORM_UART_PARITY_NONE ) }, { LSTRKEY( "PAR_MARK" ), LNUMVAL( PLATFORM_UART_PARITY_MARK ) }, { LSTRKEY( "PAR_SPACE" ), LNUMVAL( PLATFORM_UART_PARITY_SPACE ) }, { LSTRKEY( "STOP_1" ), LNUMVAL( PLATFORM_UART_STOPBITS_1 ) }, { LSTRKEY( "STOP_1_5" ), LNUMVAL( PLATFORM_UART_STOPBITS_1_5 ) }, { LSTRKEY( "STOP_2" ), LNUMVAL( PLATFORM_UART_STOPBITS_2 ) }, { LSTRKEY( "NO_TIMEOUT" ), LNUMVAL( 0 ) },
case HOUR: t.hours = value; break; case DAY: t.days = value; break; case MONTH: t.month = value; break; case YEAR: t.year = value; break; }; break; default: return luaL_error( L, "Time values must be numbers" ); }; lua_pop( L, 1 ); } RTC_SetTime( &t ); return 0; } #define MIN_OPT_LEVEL 2 #include "lrodefs.h" // xmc4000.rtc.*() module function map const LUA_REG_TYPE rtc_map[] = { { LSTRKEY( "init" ), LFUNCVAL( rtc_init ) }, { LSTRKEY( "get" ), LFUNCVAL( rtc_get ) }, { LSTRKEY( "set" ), LFUNCVAL( rtc_set ) }, { LSTRKEY( "elapsed" ), LFUNCVAL( rtc_elapsed ) }, { LSTRKEY( "status" ), LFUNCVAL( rtc_status ) }, { LNILKEY, LNILVAL } };
static void tmr_printSuspended(lua_State* L){ swtmr_print_suspended(); } static void tmr_printTimerlist(lua_State* L){ swtmr_print_timer_list(); } #endif // Module function map static const LUA_REG_TYPE tmr_dyn_map[] = { { LSTRKEY( "register" ), LFUNCVAL( tmr_register ) }, { LSTRKEY( "alarm" ), LFUNCVAL( tmr_alarm ) }, { LSTRKEY( "start" ), LFUNCVAL( tmr_start ) }, { LSTRKEY( "stop" ), LFUNCVAL( tmr_stop ) }, { LSTRKEY( "unregister" ), LFUNCVAL( tmr_unregister ) }, { LSTRKEY( "state" ), LFUNCVAL( tmr_state ) }, { LSTRKEY( "interval" ), LFUNCVAL( tmr_interval) }, #ifdef TIMER_SUSPEND_ENABLE { LSTRKEY( "suspend" ), LFUNCVAL( tmr_suspend ) }, { LSTRKEY( "resume" ), LFUNCVAL( tmr_resume ) }, #endif { LSTRKEY( "__gc" ), LFUNCVAL( tmr_unregister ) }, { LSTRKEY( "__index" ), LROVAL( tmr_dyn_map ) }, { LNILKEY, LNILVAL } };
"numeric", "time", NULL}; const char *l = luaL_optstring(L, 1, NULL); int op = luaL_checkoption(L, 2, "all", catnames); lua_pushstring(L, setlocale(cat[op], l)); return 1; } static int os_exit (lua_State *L) { c_exit(luaL_optint(L, 1, EXIT_SUCCESS)); } #define MIN_OPT_LEVEL 1 #include "lrodefs.h" const LUA_REG_TYPE syslib[] = { {LSTRKEY("clock"), LFUNCVAL(os_clock)}, {LSTRKEY("date"), LFUNCVAL(os_date)}, #if !defined LUA_NUMBER_INTEGRAL {LSTRKEY("difftime"), LFUNCVAL(os_difftime)}, #endif {LSTRKEY("execute"), LFUNCVAL(os_execute)}, {LSTRKEY("exit"), LFUNCVAL(os_exit)}, {LSTRKEY("getenv"), LFUNCVAL(os_getenv)}, {LSTRKEY("remove"), LFUNCVAL(os_remove)}, {LSTRKEY("rename"), LFUNCVAL(os_rename)}, {LSTRKEY("setlocale"), LFUNCVAL(os_setlocale)}, {LSTRKEY("time"), LFUNCVAL(os_time)}, {LSTRKEY("tmpname"), LFUNCVAL(os_tmpname)}, {LNILKEY, LNILVAL} };
// "+2" below comes from the string terminator (+1) and the '\n' // that will be added by the shell code (+1) if( ( cmdcpy = ( char* )malloc( strlen( pcmd ) + 2 ) ) == NULL ) return luaL_error( L, "not enough memory for elua_shell" ); strcpy( cmdcpy, pcmd ); shellh_execute_command( cmdcpy, 0 ); free( cmdcpy ); return 0; } // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE elua_map[] = { { LSTRKEY( "egc_setup" ), LFUNCVAL( elua_egc_setup ) }, { LSTRKEY( "version" ), LFUNCVAL( elua_version ) }, { LSTRKEY( "save_history" ), LFUNCVAL( elua_save_history ) }, { LSTRKEY( "shell" ), LFUNCVAL( elua_shell ) }, #if LUA_OPTIMIZE_MEMORY > 0 { LSTRKEY( "EGC_NOT_ACTIVE" ), LNUMVAL( EGC_NOT_ACTIVE ) }, { LSTRKEY( "EGC_ON_ALLOC_FAILURE" ), LNUMVAL( EGC_ON_ALLOC_FAILURE ) }, { LSTRKEY( "EGC_ON_MEM_LIMIT" ), LNUMVAL( EGC_ON_MEM_LIMIT ) }, { LSTRKEY( "EGC_ALWAYS" ), LNUMVAL( EGC_ALWAYS ) }, #endif { LNILKEY, LNILVAL } }; LUALIB_API int luaopen_elua( lua_State *L ) { #if LUA_OPTIMIZE_MEMORY > 0
static int luaB_yield (lua_State *L) { return lua_yield(L, lua_gettop(L)); } static int luaB_corunning (lua_State *L) { if (lua_pushthread(L)) lua_pushnil(L); /* main thread is not a coroutine */ return 1; } #undef MIN_OPT_LEVEL #define MIN_OPT_LEVEL 1 #include "lrodefs.h" const LUA_REG_TYPE co_funcs[] = { {LSTRKEY("create"), LFUNCVAL(luaB_cocreate)}, {LSTRKEY("resume"), LFUNCVAL(luaB_coresume)}, {LSTRKEY("running"), LFUNCVAL(luaB_corunning)}, {LSTRKEY("status"), LFUNCVAL(luaB_costatus)}, {LSTRKEY("wrap"), LFUNCVAL(luaB_cowrap)}, {LSTRKEY("yield"), LFUNCVAL(luaB_yield)}, {LNILKEY, LNILVAL} }; /* }====================================================== */ static void auxopen (lua_State *L, const char *name, lua_CFunction f, lua_CFunction u) { lua_pushcfunction(L, u); lua_pushcclosure(L, f, 1);
help_init( HELP_FILE_NAME ); term_set_mode( TERM_MODE_COLS ); term_enable_paging( TERM_PAGING_ON ); help_help( topic ); term_set_mode( TERM_MODE_ASCII ); term_enable_paging( TERM_PAGING_OFF ); help_close(); return 0; } // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE elua_map[] = { { LSTRKEY( "egc_setup" ), LFUNCVAL( elua_egc_setup ) }, { LSTRKEY( "version" ), LFUNCVAL( elua_version ) }, { LSTRKEY( "save_history" ), LFUNCVAL( elua_save_history ) }, { LSTRKEY( "strftime" ), LFUNCVAL( elua_strftime ) }, { LSTRKEY( "fs_mounted" ), LFUNCVAL( elua_fs_mounted ) }, { LSTRKEY( "help" ), LFUNCVAL( elua_help ) }, #if LUA_OPTIMIZE_MEMORY > 0 { LSTRKEY( "EGC_NOT_ACTIVE" ), LNUMVAL( EGC_NOT_ACTIVE ) }, { LSTRKEY( "EGC_ON_ALLOC_FAILURE" ), LNUMVAL( EGC_ON_ALLOC_FAILURE ) }, { LSTRKEY( "EGC_ON_MEM_LIMIT" ), LNUMVAL( EGC_ON_MEM_LIMIT ) }, { LSTRKEY( "EGC_ALWAYS" ), LNUMVAL( EGC_ALWAYS ) }, #endif { LNILKEY, LNILVAL } }; LUALIB_API int luaopen_elua( lua_State *L )
} else idx = 0; base->AFR[ idx ] &= ~( 0x0F << ( pin * 4 ) ); base->AFR[ idx ] |= func << ( pin * 4 ); } } return 0; } // Module function map #define MIN_OPT_LEVEL 2 #include "lrodefs.h" const LUA_REG_TYPE stm32_pio_map[] = { { LSTRKEY( "set_function" ), LFUNCVAL( stm32_pio_set_function ) }, { LSTRKEY( "GPIO" ), LNUMVAL( PIN_FUNC_GPIO ) }, { LSTRKEY( "ADC" ), LNUMVAL( PIN_FUNC_ADC ) }, { LSTRKEY( "AF0" ), LNUMVAL( 0 ) }, { LSTRKEY( "AF1" ), LNUMVAL( 1 ) }, { LSTRKEY( "AF2" ), LNUMVAL( 2 ) }, { LSTRKEY( "AF3" ), LNUMVAL( 3 ) }, { LSTRKEY( "AF4" ), LNUMVAL( 4 ) }, { LSTRKEY( "AF5" ), LNUMVAL( 5 ) }, { LSTRKEY( "AF6" ), LNUMVAL( 6 ) }, { LSTRKEY( "AF7" ), LNUMVAL( 7 ) }, { LSTRKEY( "AF8" ), LNUMVAL( 8 ) }, { LSTRKEY( "AF9" ), LNUMVAL( 9 ) }, { LSTRKEY( "AF10" ), LNUMVAL( 10 ) }, { LSTRKEY( "AF11" ), LNUMVAL( 11 ) }, { LSTRKEY( "AF12" ), LNUMVAL( 12 ) },