Merge remote-tracking branch 'upstream/dev' into dev
This commit is contained in:
devsaurus
commit
4cd2b554ec
14
README.md
14
README.md
|
|
@ -36,6 +36,12 @@ Tencent QQ group: 309957875<br />
|
|||
- cross compiler (done)
|
||||
|
||||
# Change log
|
||||
2015-03-31<br />
|
||||
polish mqtt module, add queue for mqtt module.<br />
|
||||
add reconnect option to mqtt.connect api, :connect( host, port, secure, auto_reconnect, function(client) )<br />
|
||||
move node.readvdd33 to adc.readvdd33.<br />
|
||||
tools/esptool.py supported NodeMCU devkit automatic flash.
|
||||
|
||||
2015-03-18<br />
|
||||
update u8glib.<br />
|
||||
merge everything to master.
|
||||
|
|
@ -225,8 +231,10 @@ m:on("message", function(conn, topic, data)
|
|||
end
|
||||
end)
|
||||
|
||||
-- for secure: m:connect("192.168.11.118", 1880, 1)
|
||||
m:connect("192.168.11.118", 1880, 0, function(conn) print("connected") end)
|
||||
-- m:connect( host, port, secure, auto_reconnect, function(client) )
|
||||
-- for secure: m:connect("192.168.11.118", 1880, 1, 0)
|
||||
-- for auto-reconnect: m:connect("192.168.11.118", 1880, 0, 1)
|
||||
m:connect("192.168.11.118", 1880, 0, 0, function(conn) print("connected") end)
|
||||
|
||||
-- subscribe topic with qos = 0
|
||||
m:subscribe("/topic",0, function(conn) print("subscribe success") end)
|
||||
|
|
@ -235,7 +243,7 @@ m:subscribe("/topic",0, function(conn) print("subscribe success") end)
|
|||
-- publish a message with data = hello, QoS = 0, retain = 0
|
||||
m:publish("/topic","hello",0,0, function(conn) print("sent") end)
|
||||
|
||||
m:close();
|
||||
m:close(); -- if auto-reconnect == 1, will disable auto-reconnect and then disconnect from host.
|
||||
-- you can call m:connect again
|
||||
|
||||
```
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ int strbuf_init(strbuf_t *s, int len)
|
|||
s->reallocs = 0;
|
||||
s->debug = 0;
|
||||
|
||||
s->buf = c_malloc(size);
|
||||
s->buf = (char *)c_malloc(size);
|
||||
if (!s->buf){
|
||||
NODE_ERR("not enough memory\n");
|
||||
return -1;
|
||||
|
|
@ -60,7 +60,7 @@ strbuf_t *strbuf_new(int len)
|
|||
{
|
||||
strbuf_t *s;
|
||||
|
||||
s = c_malloc(sizeof(strbuf_t));
|
||||
s = (strbuf_t *)c_malloc(sizeof(strbuf_t));
|
||||
if (!s){
|
||||
NODE_ERR("not enough memory\n");
|
||||
return NULL;
|
||||
|
|
|
|||
|
|
@ -7,6 +7,6 @@
|
|||
#define NODE_VERSION_INTERNAL 0U
|
||||
|
||||
#define NODE_VERSION "NodeMCU 0.9.5"
|
||||
#define BUILD_DATE "build 20150318"
|
||||
#define BUILD_DATE "build 20150405"
|
||||
|
||||
#endif /* __USER_VERSION_H__ */
|
||||
|
|
|
|||
|
|
@ -47,9 +47,9 @@ extern int c_stderr;
|
|||
#define SEEK_END 2 /* set file offset to EOF plus offset */
|
||||
#endif
|
||||
|
||||
#define c_malloc os_malloc
|
||||
#define c_zalloc os_zalloc
|
||||
#define c_free os_free
|
||||
// #define c_malloc os_malloc
|
||||
// #define c_zalloc os_zalloc
|
||||
// #define c_free os_free
|
||||
|
||||
extern void output_redirect(const char *str);
|
||||
#define c_puts output_redirect
|
||||
|
|
|
|||
|
|
@ -29,9 +29,9 @@
|
|||
#define os_realloc(p, s) mem_realloc((p), (s))
|
||||
#endif
|
||||
|
||||
// #define c_free os_free
|
||||
// #define c_malloc os_malloc
|
||||
// #define c_zalloc os_zalloc
|
||||
#define c_free os_free
|
||||
#define c_malloc os_malloc
|
||||
#define c_zalloc os_zalloc
|
||||
#define c_realloc os_realloc
|
||||
|
||||
#define c_abs abs
|
||||
|
|
@ -47,9 +47,9 @@
|
|||
// c_getenv() get env "LUA_INIT" string for lua initialization.
|
||||
const char *c_getenv(const char *__string);
|
||||
|
||||
void *c_malloc(size_t __size);
|
||||
void *c_zalloc(size_t __size);
|
||||
void c_free(void *);
|
||||
// void *c_malloc(size_t __size);
|
||||
// void *c_zalloc(size_t __size);
|
||||
// void c_free(void *);
|
||||
|
||||
// int c_rand(void);
|
||||
// void c_srand(unsigned int __seed);
|
||||
|
|
|
|||
|
|
@ -541,8 +541,12 @@ extern int readline4lua(const char *prompt, char *buffer, int length);
|
|||
|
||||
/*
|
||||
@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
|
||||
** Attention: This value should probably not be set higher than 1K.
|
||||
** The size has direct impact on the C stack size needed be auxlib functions.
|
||||
** For example: If set to 4K a call to string.gsub will need more than
|
||||
** 5k C stack space.
|
||||
*/
|
||||
#define LUAL_BUFFERSIZE ((BUFSIZ)*4)
|
||||
#define LUAL_BUFFERSIZE BUFSIZ
|
||||
|
||||
/* }================================================================== */
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#include "lrotable.h"
|
||||
|
||||
#include "c_types.h"
|
||||
#include "user_interface.h"
|
||||
|
||||
// Lua: read(id) , return system adc
|
||||
static int adc_sample( lua_State* L )
|
||||
|
|
@ -19,12 +20,33 @@ static int adc_sample( lua_State* L )
|
|||
return 1;
|
||||
}
|
||||
|
||||
// Lua: readvdd33()
|
||||
static int adc_readvdd33( lua_State* L )
|
||||
{
|
||||
uint32_t vdd33 = 0;
|
||||
if(STATION_MODE == wifi_get_opmode())
|
||||
{
|
||||
// Bug fix
|
||||
wifi_set_opmode( STATIONAP_MODE );
|
||||
vdd33 = readvdd33();
|
||||
wifi_set_opmode( STATION_MODE );
|
||||
}
|
||||
else
|
||||
{
|
||||
vdd33 = readvdd33();
|
||||
}
|
||||
|
||||
lua_pushinteger(L, vdd33);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Module function map
|
||||
#define MIN_OPT_LEVEL 2
|
||||
#include "lrodefs.h"
|
||||
const LUA_REG_TYPE adc_map[] =
|
||||
{
|
||||
{ LSTRKEY( "read" ), LFUNCVAL( adc_sample ) },
|
||||
{ LSTRKEY( "readvdd33" ), LFUNCVAL( adc_readvdd33) },
|
||||
#if LUA_OPTIMIZE_MEMORY > 0
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -80,7 +80,7 @@ LUALIB_API int ( luaopen_file )( lua_State *L );
|
|||
LUALIB_API int ( luaopen_ow )( lua_State *L );
|
||||
|
||||
#define AUXLIB_CJSON "cjson"
|
||||
LUALIB_API int ( luaopen_ow )( lua_State *L );
|
||||
LUALIB_API int ( luaopen_cjson )( lua_State *L );
|
||||
|
||||
// Helper macros
|
||||
#define MOD_CHECK_ID( mod, id )\
|
||||
|
|
|
|||
|
|
@ -146,6 +146,82 @@ static int lgpio_write( lua_State* L )
|
|||
return 0;
|
||||
}
|
||||
|
||||
#define DELAY_TABLE_MAX_LEN 256
|
||||
#define noInterrupts os_intr_lock
|
||||
#define interrupts os_intr_unlock
|
||||
#define delayMicroseconds os_delay_us
|
||||
#define DIRECT_WRITE(pin, level) (GPIO_OUTPUT_SET(GPIO_ID_PIN(pin_num[pin]), level))
|
||||
// Lua: serout( pin, firstLevel, delay_table, [repeatNum] )
|
||||
// -- serout( pin, firstLevel, delay_table, [repeatNum] )
|
||||
// gpio.mode(1,gpio.OUTPUT,gpio.PULLUP)
|
||||
// gpio.serout(1,1,{30,30,60,60,30,30}) -- serial one byte, b10110010
|
||||
// gpio.serout(1,1,{30,70},8) -- serial 30% pwm 10k, lasts 8 cycles
|
||||
// gpio.serout(1,1,{3,7},8) -- serial 30% pwm 100k, lasts 8 cycles
|
||||
// gpio.serout(1,1,{0,0},8) -- serial 50% pwm as fast as possible, lasts 8 cycles
|
||||
// gpio.mode(1,gpio.OUTPUT,gpio.PULLUP)
|
||||
// gpio.serout(1,0,{20,10,10,20,10,10,10,100}) -- sim uart one byte 0x5A at about 100kbps
|
||||
// gpio.serout(1,1,{8,18},8) -- serial 30% pwm 38k, lasts 8 cycles
|
||||
static int lgpio_serout( lua_State* L )
|
||||
{
|
||||
unsigned level;
|
||||
unsigned pin;
|
||||
unsigned table_len = 0;
|
||||
unsigned repeat = 0;
|
||||
int delay_table[DELAY_TABLE_MAX_LEN];
|
||||
|
||||
pin = luaL_checkinteger( L, 1 );
|
||||
MOD_CHECK_ID( gpio, pin );
|
||||
level = luaL_checkinteger( L, 2 );
|
||||
if ( level!=HIGH && level!=LOW )
|
||||
return luaL_error( L, "wrong arg type" );
|
||||
if( lua_istable( L, 3 ) )
|
||||
{
|
||||
table_len = lua_objlen( L, 3 );
|
||||
if (table_len <= 0 || table_len>DELAY_TABLE_MAX_LEN)
|
||||
return luaL_error( L, "wrong arg range" );
|
||||
int i;
|
||||
for( i = 0; i < table_len; i ++ )
|
||||
{
|
||||
lua_rawgeti( L, 3, i + 1 );
|
||||
delay_table[i] = ( int )luaL_checkinteger( L, -1 );
|
||||
lua_pop( L, 1 );
|
||||
if( delay_table[i] < 0 || delay_table[i] > 1000000 ) // can not delay more than 1000000 us
|
||||
return luaL_error( L, "delay must < 1000000 us" );
|
||||
}
|
||||
} else {
|
||||
return luaL_error( L, "wrong arg range" );
|
||||
}
|
||||
|
||||
if(lua_isnumber(L, 4))
|
||||
repeat = lua_tointeger( L, 4 );
|
||||
if( repeat < 0 || repeat > DELAY_TABLE_MAX_LEN )
|
||||
return luaL_error( L, "delay must < 256" );
|
||||
|
||||
if(repeat==0)
|
||||
repeat = 1;
|
||||
int j;
|
||||
bool skip_loop = true;
|
||||
do
|
||||
{
|
||||
if(skip_loop){ // skip the first loop.
|
||||
skip_loop = false;
|
||||
continue;
|
||||
}
|
||||
for(j=0;j<table_len;j++){
|
||||
noInterrupts();
|
||||
// platform_gpio_write(pin, level);
|
||||
DIRECT_WRITE(pin, level);
|
||||
interrupts();
|
||||
delayMicroseconds(delay_table[j]);
|
||||
level=!level;
|
||||
}
|
||||
repeat--;
|
||||
} while (repeat>0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
#undef DELAY_TABLE_MAX_LEN
|
||||
|
||||
// Module function map
|
||||
#define MIN_OPT_LEVEL 2
|
||||
#include "lrodefs.h"
|
||||
|
|
@ -154,6 +230,7 @@ const LUA_REG_TYPE gpio_map[] =
|
|||
{ LSTRKEY( "mode" ), LFUNCVAL( lgpio_mode ) },
|
||||
{ LSTRKEY( "read" ), LFUNCVAL( lgpio_read ) },
|
||||
{ LSTRKEY( "write" ), LFUNCVAL( lgpio_write ) },
|
||||
{ LSTRKEY( "serout" ), LFUNCVAL( lgpio_serout ) },
|
||||
#ifdef GPIO_INTERRUPT_ENABLE
|
||||
{ LSTRKEY( "trig" ), LFUNCVAL( lgpio_trig ) },
|
||||
#endif
|
||||
|
|
|
|||
1041
app/modules/mqtt.c
1041
app/modules/mqtt.c
File diff suppressed because it is too large
Load Diff
|
|
@ -100,13 +100,15 @@ static int node_chipid( lua_State* L )
|
|||
lua_pushinteger(L, id);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// deprecated, moved to adc module
|
||||
// Lua: readvdd33()
|
||||
static int node_readvdd33( lua_State* L )
|
||||
{
|
||||
uint32_t vdd33 = readvdd33();
|
||||
lua_pushinteger(L, vdd33);
|
||||
return 1;
|
||||
}
|
||||
// static int node_readvdd33( lua_State* L )
|
||||
// {
|
||||
// uint32_t vdd33 = readvdd33();
|
||||
// lua_pushinteger(L, vdd33);
|
||||
// return 1;
|
||||
// }
|
||||
|
||||
// Lua: flashid()
|
||||
static int node_flashid( lua_State* L )
|
||||
|
|
@ -430,7 +432,8 @@ const LUA_REG_TYPE node_map[] =
|
|||
#endif
|
||||
{ LSTRKEY( "input" ), LFUNCVAL( node_input ) },
|
||||
{ LSTRKEY( "output" ), LFUNCVAL( node_output ) },
|
||||
{ LSTRKEY( "readvdd33" ), LFUNCVAL( node_readvdd33) },
|
||||
// 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 ) },
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#include "lrotable.h"
|
||||
|
||||
#include "c_string.h"
|
||||
#include "c_stdlib.h"
|
||||
|
||||
#include "c_types.h"
|
||||
#include "user_interface.h"
|
||||
|
|
@ -327,8 +328,8 @@ static int wifi_station_config( lua_State* L )
|
|||
if (sl>32 || ssid == NULL)
|
||||
return luaL_error( L, "ssid:<32" );
|
||||
const char *password = luaL_checklstring( L, 2, &pl );
|
||||
if (pl>64 || password == NULL)
|
||||
return luaL_error( L, "pwd:<64" );
|
||||
if (pl<8 || pl>64 || password == NULL)
|
||||
return luaL_error( L, "pwd:8~64" );
|
||||
|
||||
c_memset(sta_conf.ssid, 0, 32);
|
||||
c_memset(sta_conf.password, 0, 64);
|
||||
|
|
@ -380,6 +381,7 @@ static int wifi_station_setauto( lua_State* L )
|
|||
return 0;
|
||||
}
|
||||
|
||||
// Lua: table = wifi.sta.getap()
|
||||
static int wifi_station_listap( lua_State* L )
|
||||
{
|
||||
if(wifi_get_opmode() == SOFTAP_MODE)
|
||||
|
|
@ -437,44 +439,46 @@ static int wifi_ap_getbroadcast( lua_State* L ){
|
|||
// Lua: wifi.ap.config(table)
|
||||
static int wifi_ap_config( lua_State* L )
|
||||
{
|
||||
struct softap_config config;
|
||||
size_t len;
|
||||
wifi_softap_get_config(&config);
|
||||
if (!lua_istable(L, 1))
|
||||
return luaL_error( L, "wrong arg type" );
|
||||
|
||||
struct softap_config config;
|
||||
wifi_softap_get_config(&config);
|
||||
|
||||
size_t len;
|
||||
|
||||
lua_getfield(L, 1, "ssid");
|
||||
if (!lua_isnil(L, -1)){ /* found? */
|
||||
if( lua_isstring(L, -1) ) // deal with the ssid string
|
||||
{
|
||||
const char *ssid = luaL_checklstring( L, -1, &len );
|
||||
if(len>32)
|
||||
return luaL_error( L, "ssid:<32" );
|
||||
if(len<1 || len>32 || ssid == NULL)
|
||||
return luaL_error( L, "ssid:1~32" );
|
||||
c_memset(config.ssid, 0, 32);
|
||||
c_memcpy(config.ssid, ssid, len);
|
||||
config.ssid_len = len;
|
||||
config.ssid_hidden = 0;
|
||||
NODE_DBG(config.ssid);
|
||||
NODE_DBG("\n");
|
||||
config.ssid_len = len;
|
||||
config.ssid_hidden = 0;
|
||||
}
|
||||
else
|
||||
return luaL_error( L, "wrong arg type" );
|
||||
}
|
||||
else
|
||||
return luaL_error( L, "wrong arg type" );
|
||||
return luaL_error( L, "ssid required" );
|
||||
|
||||
lua_getfield(L, 1, "pwd");
|
||||
if (!lua_isnil(L, -1)){ /* found? */
|
||||
if( lua_isstring(L, -1) ) // deal with the password string
|
||||
{
|
||||
const char *pwd = luaL_checklstring( L, -1, &len );
|
||||
if(len>64)
|
||||
return luaL_error( L, "pwd:<64" );
|
||||
if(len<8 || len>64 || pwd == NULL)
|
||||
return luaL_error( L, "pwd:8~64" );
|
||||
c_memset(config.password, 0, 64);
|
||||
c_memcpy(config.password, pwd, len);
|
||||
config.authmode = AUTH_WPA_WPA2_PSK;
|
||||
NODE_DBG(config.password);
|
||||
NODE_DBG("\n");
|
||||
config.authmode = AUTH_WPA_WPA2_PSK;
|
||||
}
|
||||
else
|
||||
return luaL_error( L, "wrong arg type" );
|
||||
|
|
@ -483,13 +487,164 @@ static int wifi_ap_config( lua_State* L )
|
|||
config.authmode = AUTH_OPEN;
|
||||
}
|
||||
|
||||
lua_getfield(L, 1, "auth");
|
||||
if (!lua_isnil(L, -1))
|
||||
{
|
||||
config.authmode = (uint8_t)luaL_checkinteger(L, -1);
|
||||
NODE_DBG(config.authmode);
|
||||
NODE_DBG("\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
// keep whatever value resulted from "pwd" logic above
|
||||
}
|
||||
|
||||
lua_getfield(L, 1, "channel");
|
||||
if (!lua_isnil(L, -1))
|
||||
{
|
||||
unsigned channel = luaL_checkinteger(L, -1);
|
||||
if (channel < 1 || channel > 13)
|
||||
return luaL_error( L, "channel:1~13" );
|
||||
|
||||
config.channel = (uint8_t)channel;
|
||||
NODE_DBG(config.channel);
|
||||
NODE_DBG("\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
config.channel = 6;
|
||||
}
|
||||
|
||||
lua_getfield(L, 1, "hidden");
|
||||
if (!lua_isnil(L, -1))
|
||||
{
|
||||
config.ssid_hidden = (uint8_t)luaL_checkinteger(L, -1);
|
||||
NODE_DBG(config.ssid_hidden);
|
||||
NODE_DBG("\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
config.ssid_hidden = 0;
|
||||
}
|
||||
|
||||
lua_getfield(L, 1, "max");
|
||||
if (!lua_isnil(L, -1))
|
||||
{
|
||||
unsigned max = luaL_checkinteger(L, -1);
|
||||
if (max < 1 || max > 4)
|
||||
return luaL_error( L, "max:1~4" );
|
||||
|
||||
config.max_connection = (uint8_t)max;
|
||||
NODE_DBG(config.max_connection);
|
||||
NODE_DBG("\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
config.max_connection = 4;
|
||||
}
|
||||
|
||||
lua_getfield(L, 1, "beacon");
|
||||
if (!lua_isnil(L, -1))
|
||||
{
|
||||
unsigned beacon = luaL_checkinteger(L, -1);
|
||||
if (beacon < 100 || beacon > 60000)
|
||||
return luaL_error( L, "beacon:100~60000" );
|
||||
|
||||
config.beacon_interval = (uint16_t)beacon;
|
||||
NODE_DBG(config.beacon_interval);
|
||||
NODE_DBG("\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
config.beacon_interval = 100;
|
||||
}
|
||||
|
||||
wifi_softap_set_config(&config);
|
||||
// system_restart();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Lua: table = wifi.ap.getclient()
|
||||
static int wifi_ap_listclient( lua_State* L )
|
||||
{
|
||||
if (wifi_get_opmode() == STATION_MODE)
|
||||
{
|
||||
return luaL_error( L, "Can't list client in STATION_MODE mode" );
|
||||
}
|
||||
|
||||
char temp[64];
|
||||
|
||||
lua_newtable(L);
|
||||
|
||||
struct station_info * station = wifi_softap_get_station_info();
|
||||
struct station_info * next_station;
|
||||
while (station != NULL)
|
||||
{
|
||||
c_sprintf(temp, IPSTR, IP2STR(&station->ip));
|
||||
lua_pushstring(L, temp);
|
||||
|
||||
c_sprintf(temp, MACSTR, MAC2STR(station->bssid));
|
||||
lua_setfield(L, -2, temp);
|
||||
|
||||
next_station = STAILQ_NEXT(station, next);
|
||||
c_free(station);
|
||||
station = next_station;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Lua: ip = wifi.ap.dhcp.config()
|
||||
static int wifi_ap_dhcp_config( lua_State* L )
|
||||
{
|
||||
if (!lua_istable(L, 1))
|
||||
return luaL_error( L, "wrong arg type" );
|
||||
|
||||
struct dhcps_lease lease;
|
||||
uint32_t ip;
|
||||
|
||||
ip = parse_key(L, "start");
|
||||
if (ip == 0)
|
||||
return luaL_error( L, "wrong arg type" );
|
||||
|
||||
lease.start_ip = ip;
|
||||
NODE_DBG(IPSTR, IP2STR(&lease.start_ip));
|
||||
NODE_DBG("\n");
|
||||
|
||||
// use configured max_connection to determine end
|
||||
struct softap_config config;
|
||||
wifi_softap_get_config(&config);
|
||||
lease.end_ip = lease.start_ip;
|
||||
ip4_addr4(&lease.end_ip) += config.max_connection - 1;
|
||||
|
||||
char temp[64];
|
||||
c_sprintf(temp, IPSTR, IP2STR(&lease.start_ip));
|
||||
lua_pushstring(L, temp);
|
||||
c_sprintf(temp, IPSTR, IP2STR(&lease.end_ip));
|
||||
lua_pushstring(L, temp);
|
||||
|
||||
// note: DHCP max range = 101 from start_ip to end_ip
|
||||
wifi_softap_dhcps_stop();
|
||||
wifi_softap_set_dhcps_lease(&lease);
|
||||
wifi_softap_dhcps_start();
|
||||
|
||||
return 2;
|
||||
}
|
||||
|
||||
// Lua: wifi.ap.dhcp.start()
|
||||
static int wifi_ap_dhcp_start( lua_State* L )
|
||||
{
|
||||
lua_pushboolean(L, wifi_softap_dhcps_start());
|
||||
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"
|
||||
|
|
@ -509,6 +664,14 @@ static const LUA_REG_TYPE wifi_station_map[] =
|
|||
{ LNILKEY, LNILVAL }
|
||||
};
|
||||
|
||||
static const LUA_REG_TYPE wifi_ap_dhcp_map[] =
|
||||
{
|
||||
{ LSTRKEY( "config" ), LFUNCVAL( wifi_ap_dhcp_config ) },
|
||||
{ LSTRKEY( "start" ), LFUNCVAL( wifi_ap_dhcp_start ) },
|
||||
{ LSTRKEY( "stop" ), LFUNCVAL( wifi_ap_dhcp_stop ) },
|
||||
{ LNILKEY, LNILVAL }
|
||||
};
|
||||
|
||||
static const LUA_REG_TYPE wifi_ap_map[] =
|
||||
{
|
||||
{ LSTRKEY( "config" ), LFUNCVAL( wifi_ap_config ) },
|
||||
|
|
@ -517,6 +680,12 @@ static const LUA_REG_TYPE wifi_ap_map[] =
|
|||
{ LSTRKEY( "getbroadcast" ), LFUNCVAL ( wifi_ap_getbroadcast) },
|
||||
{ LSTRKEY( "getmac" ), LFUNCVAL ( wifi_ap_getmac ) },
|
||||
{ LSTRKEY( "setmac" ), LFUNCVAL ( wifi_ap_setmac ) },
|
||||
{ LSTRKEY( "getclient" ), LFUNCVAL ( wifi_ap_listclient ) },
|
||||
#if LUA_OPTIMIZE_MEMORY > 0
|
||||
{ LSTRKEY( "dhcp" ), LROVAL( wifi_ap_dhcp_map ) },
|
||||
|
||||
// { LSTRKEY( "__metatable" ), LROVAL( wifi_ap_map ) },
|
||||
#endif
|
||||
{ LNILKEY, LNILVAL }
|
||||
};
|
||||
|
||||
|
|
@ -540,6 +709,12 @@ const LUA_REG_TYPE wifi_map[] =
|
|||
{ LSTRKEY( "LIGHT_SLEEP" ), LNUMVAL( LIGHT_SLEEP_T ) },
|
||||
{ LSTRKEY( "MODEM_SLEEP" ), LNUMVAL( MODEM_SLEEP_T ) },
|
||||
|
||||
{ LSTRKEY( "OPEN" ), LNUMVAL( AUTH_OPEN ) },
|
||||
// { LSTRKEY( "WEP" ), LNUMVAL( AUTH_WEP ) },
|
||||
{ LSTRKEY( "WPA_PSK" ), LNUMVAL( AUTH_WPA_PSK ) },
|
||||
{ LSTRKEY( "WPA2_PSK" ), LNUMVAL( AUTH_WPA2_PSK ) },
|
||||
{ LSTRKEY( "WPA_WPA2_PSK" ), LNUMVAL( AUTH_WPA_WPA2_PSK ) },
|
||||
|
||||
// { LSTRKEY( "STA_IDLE" ), LNUMVAL( STATION_IDLE ) },
|
||||
// { LSTRKEY( "STA_CONNECTING" ), LNUMVAL( STATION_CONNECTING ) },
|
||||
// { LSTRKEY( "STA_WRONGPWD" ), LNUMVAL( STATION_WRONG_PASSWORD ) },
|
||||
|
|
@ -573,6 +748,12 @@ LUALIB_API int luaopen_wifi( lua_State *L )
|
|||
MOD_REG_NUMBER( L, "LIGHT_SLEEP", LIGHT_SLEEP_T );
|
||||
MOD_REG_NUMBER( L, "MODEM_SLEEP", MODEM_SLEEP_T );
|
||||
|
||||
MOD_REG_NUMBER( L, "OPEN", AUTH_OPEN );
|
||||
// MOD_REG_NUMBER( L, "WEP", AUTH_WEP );
|
||||
MOD_REG_NUMBER( L, "WPA_PSK", AUTH_WPA_PSK );
|
||||
MOD_REG_NUMBER( L, "WPA2_PSK", AUTH_WPA2_PSK );
|
||||
MOD_REG_NUMBER( L, "WPA_WPA2_PSK", AUTH_WPA_WPA2_PSK );
|
||||
|
||||
// MOD_REG_NUMBER( L, "STA_IDLE", STATION_IDLE );
|
||||
// MOD_REG_NUMBER( L, "STA_CONNECTING", STATION_CONNECTING );
|
||||
// MOD_REG_NUMBER( L, "STA_WRONGPWD", STATION_WRONG_PASSWORD );
|
||||
|
|
@ -589,6 +770,11 @@ LUALIB_API int luaopen_wifi( lua_State *L )
|
|||
luaL_register( L, NULL, wifi_ap_map );
|
||||
lua_setfield( L, -2, "ap" );
|
||||
|
||||
// Setup the new table (dhcp) inside ap
|
||||
lua_newtable( L );
|
||||
luaL_register( L, NULL, wifi_ap_dhcp_map );
|
||||
lua_setfield( L, -1, "dhcp" );
|
||||
|
||||
return 1;
|
||||
#endif // #if LUA_OPTIMIZE_MEMORY > 0
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,8 @@
|
|||
#include "platform.h"
|
||||
#include "auxmods.h"
|
||||
#include "lrotable.h"
|
||||
#include "c_stdlib.h"
|
||||
#include "c_string.h"
|
||||
/**
|
||||
* All this code is mostly from http://www.esp8266.com/viewtopic.php?f=21&t=1143&sid=a620a377672cfe9f666d672398415fcb
|
||||
* from user Markus Gritsch.
|
||||
|
|
@ -35,7 +37,10 @@ static int ICACHE_FLASH_ATTR ws2812_writergb(lua_State* L)
|
|||
{
|
||||
const uint8_t pin = luaL_checkinteger(L, 1);
|
||||
size_t length;
|
||||
char *buffer = (char *)luaL_checklstring(L, 2, &length); // Cast away the constness.
|
||||
const char *rgb = luaL_checklstring(L, 2, &length);
|
||||
// dont modify lua-internal lstring - make a copy instead
|
||||
char *buffer = (char *)c_malloc(length);
|
||||
c_memcpy(buffer, rgb, length);
|
||||
|
||||
// Initialize the output pin:
|
||||
platform_gpio_mode(pin, PLATFORM_GPIO_OUTPUT, PLATFORM_GPIO_FLOAT);
|
||||
|
|
@ -59,17 +64,17 @@ static int ICACHE_FLASH_ATTR ws2812_writergb(lua_State* L)
|
|||
|
||||
// Send the buffer:
|
||||
os_intr_lock();
|
||||
const char * const end = buffer + length;
|
||||
while (buffer != end) {
|
||||
for (i = 0; i < length; i++) {
|
||||
uint8_t mask = 0x80;
|
||||
while (mask) {
|
||||
(*buffer & mask) ? send_ws_1(pin_num[pin]) : send_ws_0(pin_num[pin]);
|
||||
(buffer[i] & mask) ? send_ws_1(pin_num[pin]) : send_ws_0(pin_num[pin]);
|
||||
mask >>= 1;
|
||||
}
|
||||
++buffer;
|
||||
}
|
||||
os_intr_unlock();
|
||||
|
||||
c_free(buffer);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
*
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include "c_string.h"
|
||||
#include "mqtt_msg.h"
|
||||
|
||||
#define MQTT_MAX_FIXED_HEADER_SIZE 3
|
||||
|
|
@ -61,7 +61,7 @@ static int append_string(mqtt_connection_t* connection, const char* string, int
|
|||
|
||||
connection->buffer[connection->message.length++] = len >> 8;
|
||||
connection->buffer[connection->message.length++] = len & 0xff;
|
||||
memcpy(connection->buffer + connection->message.length, string, len);
|
||||
c_memcpy(connection->buffer + connection->message.length, string, len);
|
||||
connection->message.length += len;
|
||||
|
||||
return len + 2;
|
||||
|
|
@ -121,7 +121,7 @@ static mqtt_message_t* fini_message(mqtt_connection_t* connection, int type, int
|
|||
|
||||
void mqtt_msg_init(mqtt_connection_t* connection, uint8_t* buffer, uint16_t buffer_length)
|
||||
{
|
||||
memset(connection, 0, sizeof(connection));
|
||||
c_memset(connection, 0, sizeof(connection));
|
||||
connection->buffer = buffer;
|
||||
connection->buffer_length = buffer_length;
|
||||
}
|
||||
|
|
@ -294,7 +294,7 @@ mqtt_message_t* mqtt_msg_connect(mqtt_connection_t* connection, mqtt_connect_inf
|
|||
|
||||
variable_header->lengthMsb = 0;
|
||||
variable_header->lengthLsb = 4;
|
||||
memcpy(variable_header->magic, "MQTT", 4);
|
||||
c_memcpy(variable_header->magic, "MQTT", 4);
|
||||
variable_header->version = 4;
|
||||
variable_header->flags = 0;
|
||||
variable_header->keepaliveMsb = info->keepalive >> 8;
|
||||
|
|
@ -305,7 +305,7 @@ mqtt_message_t* mqtt_msg_connect(mqtt_connection_t* connection, mqtt_connect_inf
|
|||
|
||||
if(info->client_id != NULL && info->client_id[0] != '\0')
|
||||
{
|
||||
if(append_string(connection, info->client_id, strlen(info->client_id)) < 0)
|
||||
if(append_string(connection, info->client_id, c_strlen(info->client_id)) < 0)
|
||||
return fail_message(connection);
|
||||
}
|
||||
else
|
||||
|
|
@ -313,10 +313,10 @@ mqtt_message_t* mqtt_msg_connect(mqtt_connection_t* connection, mqtt_connect_inf
|
|||
|
||||
if(info->will_topic != NULL && info->will_topic[0] != '\0')
|
||||
{
|
||||
if(append_string(connection, info->will_topic, strlen(info->will_topic)) < 0)
|
||||
if(append_string(connection, info->will_topic, c_strlen(info->will_topic)) < 0)
|
||||
return fail_message(connection);
|
||||
|
||||
if(append_string(connection, info->will_message, strlen(info->will_message)) < 0)
|
||||
if(append_string(connection, info->will_message, c_strlen(info->will_message)) < 0)
|
||||
return fail_message(connection);
|
||||
|
||||
variable_header->flags |= MQTT_CONNECT_FLAG_WILL;
|
||||
|
|
@ -327,7 +327,7 @@ mqtt_message_t* mqtt_msg_connect(mqtt_connection_t* connection, mqtt_connect_inf
|
|||
|
||||
if(info->username != NULL && info->username[0] != '\0')
|
||||
{
|
||||
if(append_string(connection, info->username, strlen(info->username)) < 0)
|
||||
if(append_string(connection, info->username, c_strlen(info->username)) < 0)
|
||||
return fail_message(connection);
|
||||
|
||||
variable_header->flags |= MQTT_CONNECT_FLAG_USERNAME;
|
||||
|
|
@ -335,7 +335,7 @@ mqtt_message_t* mqtt_msg_connect(mqtt_connection_t* connection, mqtt_connect_inf
|
|||
|
||||
if(info->password != NULL && info->password[0] != '\0')
|
||||
{
|
||||
if(append_string(connection, info->password, strlen(info->password)) < 0)
|
||||
if(append_string(connection, info->password, c_strlen(info->password)) < 0)
|
||||
return fail_message(connection);
|
||||
|
||||
variable_header->flags |= MQTT_CONNECT_FLAG_PASSWORD;
|
||||
|
|
@ -351,7 +351,7 @@ mqtt_message_t* mqtt_msg_publish(mqtt_connection_t* connection, const char* topi
|
|||
if(topic == NULL || topic[0] == '\0')
|
||||
return fail_message(connection);
|
||||
|
||||
if(append_string(connection, topic, strlen(topic)) < 0)
|
||||
if(append_string(connection, topic, c_strlen(topic)) < 0)
|
||||
return fail_message(connection);
|
||||
|
||||
if(qos > 0)
|
||||
|
|
@ -364,7 +364,7 @@ mqtt_message_t* mqtt_msg_publish(mqtt_connection_t* connection, const char* topi
|
|||
|
||||
if(connection->message.length + data_length > connection->buffer_length)
|
||||
return fail_message(connection);
|
||||
memcpy(connection->buffer + connection->message.length, data, data_length);
|
||||
c_memcpy(connection->buffer + connection->message.length, data, data_length);
|
||||
connection->message.length += data_length;
|
||||
|
||||
return fini_message(connection, MQTT_MSG_TYPE_PUBLISH, 0, qos, retain);
|
||||
|
|
@ -412,7 +412,7 @@ mqtt_message_t* mqtt_msg_subscribe(mqtt_connection_t* connection, const char* to
|
|||
if((*message_id = append_message_id(connection, 0)) == 0)
|
||||
return fail_message(connection);
|
||||
|
||||
if(append_string(connection, topic, strlen(topic)) < 0)
|
||||
if(append_string(connection, topic, c_strlen(topic)) < 0)
|
||||
return fail_message(connection);
|
||||
|
||||
if(connection->message.length + 1 > connection->buffer_length)
|
||||
|
|
@ -432,7 +432,7 @@ mqtt_message_t* mqtt_msg_unsubscribe(mqtt_connection_t* connection, const char*
|
|||
if((*message_id = append_message_id(connection, 0)) == 0)
|
||||
return fail_message(connection);
|
||||
|
||||
if(append_string(connection, topic, strlen(topic)) < 0)
|
||||
if(append_string(connection, topic, c_strlen(topic)) < 0)
|
||||
return fail_message(connection);
|
||||
|
||||
return fini_message(connection, MQTT_MSG_TYPE_SUBSCRIBE, 0, 1, 0);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,82 @@
|
|||
#include "c_string.h"
|
||||
#include "c_stdlib.h"
|
||||
#include "c_stdio.h"
|
||||
#include "msg_queue.h"
|
||||
|
||||
msg_queue_t *msg_enqueue(msg_queue_t **head, mqtt_message_t *msg, uint16_t msg_id, int msg_type, int publish_qos){
|
||||
if(!head){
|
||||
return NULL;
|
||||
}
|
||||
if (!msg || !msg->data || msg->length == 0){
|
||||
NODE_DBG("empty message\n");
|
||||
return NULL;
|
||||
}
|
||||
msg_queue_t *node = (msg_queue_t *)c_zalloc(sizeof(msg_queue_t));
|
||||
if(!node){
|
||||
NODE_DBG("not enough memory\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
node->msg.data = (uint8_t *)c_zalloc(msg->length);
|
||||
if(!node->msg.data){
|
||||
NODE_DBG("not enough memory\n");
|
||||
c_free(node);
|
||||
return NULL;
|
||||
}
|
||||
c_memcpy(node->msg.data, msg->data, msg->length);
|
||||
node->msg.length = msg->length;
|
||||
node->next = NULL;
|
||||
node->msg_id = msg_id;
|
||||
node->msg_type = msg_type;
|
||||
node->publish_qos = publish_qos;
|
||||
|
||||
msg_queue_t *tail = *head;
|
||||
if(tail){
|
||||
while(tail->next!=NULL) tail = tail->next;
|
||||
tail->next = node;
|
||||
} else {
|
||||
*head = node;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
void msg_destroy(msg_queue_t *node){
|
||||
if(!node) return;
|
||||
if(node->msg.data){
|
||||
c_free(node->msg.data);
|
||||
node->msg.data = NULL;
|
||||
}
|
||||
c_free(node);
|
||||
}
|
||||
|
||||
msg_queue_t * msg_dequeue(msg_queue_t **head){
|
||||
if(!head || !*head){
|
||||
return NULL;
|
||||
}
|
||||
msg_queue_t *node = *head; // fetch head.
|
||||
*head = node->next; // update head.
|
||||
node->next = NULL;
|
||||
return node;
|
||||
}
|
||||
|
||||
msg_queue_t * msg_peek(msg_queue_t **head){
|
||||
if(!head || !*head){
|
||||
return NULL;
|
||||
}
|
||||
return *head; // fetch head.
|
||||
}
|
||||
|
||||
int msg_size(msg_queue_t **head){
|
||||
if(!head || !*head){
|
||||
return 0;
|
||||
}
|
||||
int i = 1;
|
||||
msg_queue_t *tail = *head;
|
||||
if(tail){
|
||||
while(tail->next!=NULL){
|
||||
tail = tail->next;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#ifndef _MSG_QUEUE_H
|
||||
#define _MSG_QUEUE_H 1
|
||||
#include "mqtt_msg.h"
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct msg_queue_t;
|
||||
|
||||
typedef struct msg_queue_t {
|
||||
struct msg_queue_t *next;
|
||||
mqtt_message_t msg;
|
||||
uint16_t msg_id;
|
||||
int msg_type;
|
||||
int publish_qos;
|
||||
} msg_queue_t;
|
||||
|
||||
msg_queue_t * msg_enqueue(msg_queue_t **head, mqtt_message_t *msg, uint16_t msg_id, int msg_type, int publish_qos);
|
||||
void msg_destroy(msg_queue_t *node);
|
||||
msg_queue_t * msg_dequeue(msg_queue_t **head);
|
||||
msg_queue_t * msg_peek(msg_queue_t **head);
|
||||
int msg_size(msg_queue_t **head);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -321,7 +321,7 @@ bool flash_init_data_written(void)
|
|||
// FLASH SEC - 4
|
||||
uint32_t data[2] ICACHE_STORE_ATTR;
|
||||
#if defined(FLASH_SAFE_API)
|
||||
if (SPI_FLASH_RESULT_OK == flash_safe_read((flash_rom_get_sec_num() - 4) * SPI_FLASH_SEC_SIZE, (uint32 *)data, sizeof(data)))
|
||||
if (SPI_FLASH_RESULT_OK == flash_safe_read((flash_safe_get_sec_num() - 4) * SPI_FLASH_SEC_SIZE, (uint32 *)data, sizeof(data)))
|
||||
#else
|
||||
if (SPI_FLASH_RESULT_OK == spi_flash_read((flash_rom_get_sec_num() - 4) * SPI_FLASH_SEC_SIZE, (uint32 *)data, sizeof(data)))
|
||||
#endif // defined(FLASH_SAFE_API)
|
||||
|
|
@ -369,8 +369,8 @@ bool flash_init_data_blank(void)
|
|||
// It will init system config to blank!
|
||||
bool result = false;
|
||||
#if defined(FLASH_SAFE_API)
|
||||
if ((SPI_FLASH_RESULT_OK == flash_safe_erase_sector((flash_rom_get_sec_num() - 2))) &&
|
||||
(SPI_FLASH_RESULT_OK == flash_safe_erase_sector((flash_rom_get_sec_num() - 1))))
|
||||
if ((SPI_FLASH_RESULT_OK == flash_safe_erase_sector((flash_safe_get_sec_num() - 2))) &&
|
||||
(SPI_FLASH_RESULT_OK == flash_safe_erase_sector((flash_safe_get_sec_num() - 1))))
|
||||
#else
|
||||
if ((SPI_FLASH_RESULT_OK == spi_flash_erase_sector((flash_rom_get_sec_num() - 2))) &&
|
||||
(SPI_FLASH_RESULT_OK == spi_flash_erase_sector((flash_rom_get_sec_num() - 1))))
|
||||
|
|
|
|||
|
|
@ -71,6 +71,9 @@
|
|||
#define fs_rename myspiffs_rename
|
||||
#define fs_size myspiffs_size
|
||||
|
||||
#define fs_mount myspiffs_mount
|
||||
#define fs_unmount myspiffs_unmount
|
||||
|
||||
#define FS_NAME_MAX_LENGTH SPIFFS_OBJ_NAME_LEN
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ The small 4KB sectors allow for greater flexibility in applications th
|
|||
|
||||
********************/
|
||||
|
||||
void spiffs_mount() {
|
||||
void myspiffs_mount() {
|
||||
spiffs_config cfg;
|
||||
cfg.phys_addr = ( u32_t )platform_flash_get_first_free_block_address( NULL );
|
||||
cfg.phys_addr += 0x3000;
|
||||
|
|
@ -69,6 +69,10 @@ void spiffs_mount() {
|
|||
NODE_DBG("mount res: %i\n", res);
|
||||
}
|
||||
|
||||
void myspiffs_unmount() {
|
||||
SPIFFS_unmount(&fs);
|
||||
}
|
||||
|
||||
// FS formatting function
|
||||
// Returns 1 if OK, 0 for error
|
||||
int myspiffs_format( void )
|
||||
|
|
@ -85,7 +89,7 @@ int myspiffs_format( void )
|
|||
while( sect_first <= sect_last )
|
||||
if( platform_flash_erase_sector( sect_first ++ ) == PLATFORM_ERR )
|
||||
return 0;
|
||||
spiffs_mount();
|
||||
myspiffs_mount();
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -477,6 +477,8 @@ u32_t SPIFFS_buffer_bytes_for_cache(spiffs *fs, u32_t num_pages);
|
|||
#if SPIFFS_CACHE
|
||||
#endif
|
||||
|
||||
void myspiffs_mount();
|
||||
void myspiffs_unmount();
|
||||
int myspiffs_open(const char *name, int flags);
|
||||
int myspiffs_close( int fd );
|
||||
size_t myspiffs_write( int fd, const void* ptr, size_t len );
|
||||
|
|
|
|||
|
|
@ -44,6 +44,7 @@ INCLUDES += -I ../libc
|
|||
INCLUDES += -I ../platform
|
||||
INCLUDES += -I ../lua
|
||||
INCLUDES += -I ../wofs
|
||||
INCLUDES += -I ../spiffs
|
||||
PDIR := ../$(PDIR)
|
||||
sinclude $(PDIR)Makefile
|
||||
|
||||
|
|
|
|||
|
|
@ -14,8 +14,7 @@
|
|||
#include "c_stdlib.h"
|
||||
#include "c_stdio.h"
|
||||
|
||||
#include "romfs.h"
|
||||
|
||||
#include "flash_fs.h"
|
||||
#include "user_interface.h"
|
||||
|
||||
#include "ets_sys.h"
|
||||
|
|
@ -44,7 +43,6 @@ void task_init(void){
|
|||
system_os_task(task_lua, USER_TASK_PRIO_0, taskQueue, TASK_QUEUE_LEN);
|
||||
}
|
||||
|
||||
extern void spiffs_mount();
|
||||
// extern void test_spiffs();
|
||||
// extern int test_romfs();
|
||||
|
||||
|
|
@ -70,6 +68,15 @@ void nodemcu_init(void)
|
|||
flash_init_data_default();
|
||||
// Flash blank data at FLASHSIZE - 0x02000 Byte.
|
||||
flash_init_data_blank();
|
||||
if( !fs_format() )
|
||||
{
|
||||
NODE_ERR( "\ni*** ERROR ***: unable to format. FS might be compromised.\n" );
|
||||
NODE_ERR( "It is advised to re-flash the NodeMCU image.\n" );
|
||||
}
|
||||
else{
|
||||
NODE_ERR( "format done.\n" );
|
||||
}
|
||||
fs_unmount(); // mounted by format.
|
||||
}
|
||||
#endif // defined(FLASH_SAFE_API)
|
||||
|
||||
|
|
@ -94,7 +101,7 @@ void nodemcu_init(void)
|
|||
|
||||
// test_romfs();
|
||||
#elif defined ( BUILD_SPIFFS )
|
||||
spiffs_mount();
|
||||
fs_mount();
|
||||
// test_spiffs();
|
||||
#endif
|
||||
// endpoint_setup();
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ sk:connect(80,"115.239.210.27")
|
|||
sk:send("GET / HTTP/1.1\r\nHost: 115.239.210.27\r\nConnection: keep-alive\r\nAccept: */*\r\n\r\n")
|
||||
|
||||
sk:connect(80,"192.168.0.66")
|
||||
sk:send("GET / HTTP/1.1\r\nHost: 1192.168.0.66\r\nConnection: keep-alive\r\nAccept: */*\r\n\r\n")
|
||||
sk:send("GET / HTTP/1.1\r\nHost: 192.168.0.66\r\nConnection: keep-alive\r\nAccept: */*\r\n\r\n")
|
||||
|
||||
i2c.setup(0,1,0,i2c.SLOW)
|
||||
function read_bmp(addr) i2c.start(0) i2c.address(0,119,i2c.RECEIVER) c=i2c.read(0,1) i2c.stop(0) print(string.byte(c)) end
|
||||
|
|
@ -381,3 +381,141 @@ function TestDNSLeak()
|
|||
tmr.alarm(1, 3000, 0, function() print("hack socket close, MEM: "..node.heap()) c:close() end) -- socket timeout hack
|
||||
print("MEM: "..node.heap())
|
||||
end
|
||||
|
||||
v="abc%0D%0Adef"
|
||||
print(string.gsub(v, "%%(%x%x)", function(x) return string.char(tonumber(x, 16)) end))
|
||||
|
||||
function ex(x) string.find("abc%0Ddef","bc") return 's' end
|
||||
string.gsub("abc%0Ddef", "%%(%x%x)", ex)
|
||||
|
||||
function ex(x) string.char(35) return 's' end
|
||||
string.gsub("abc%0Ddef", "%%(%x%x)", ex) print("hello")
|
||||
|
||||
function ex(x) string.lower('Ab') return 's' end
|
||||
string.gsub("abc%0Ddef", "%%(%x%x)", ex) print("hello")
|
||||
|
||||
v="abc%0D%0Adef"
|
||||
pcall(function() print(string.gsub(v, "%%(%x%x)", function(x) return string.char(tonumber(x, 16)) end)) end)
|
||||
|
||||
mosca -v | bunyan
|
||||
|
||||
m=mqtt.Client()
|
||||
m:connect("192.168.18.88",1883)
|
||||
topic={}
|
||||
topic["/topic1"]=0
|
||||
topic["/topic2"]=0
|
||||
m:subscribe(topic,function(m) print("sub done") end)
|
||||
m:on("message",function(m,t,pl) print(t..":") if pl~=nil then print(pl) end end )
|
||||
m:publish("/topic1","hello",0,0)
|
||||
m:publish("/topic3","hello",0,0) m:publish("/topic4","hello",0,0)
|
||||
|
||||
m=mqtt.Client()
|
||||
m:connect("192.168.18.88",1883)
|
||||
m:subscribe("/topic1",0,function(m) print("sub done") end)
|
||||
m:subscribe("/topic2",0,function(m) print("sub done") end)
|
||||
m:on("message",function(m,t,pl) print(t..":") if pl~=nil then print(pl) end end )
|
||||
m:publish("/topic1","hello",0,0)
|
||||
m:publish("/topic3","hello",0,0) m:publish("/topic4","hello",0,0)
|
||||
m:publish("/topic1","hello1",0,0) m:publish("/topic2","hello2",0,0)
|
||||
m:publish("/topic1","hello",1,0)
|
||||
m:subscribe("/topic3",0,function(m) print("sub done") end)
|
||||
m:publish("/topic3","hello3",2,0)
|
||||
|
||||
m=mqtt.Client()
|
||||
m:connect("192.168.18.88",1883, function(con) print("connected hello") end)
|
||||
|
||||
m=mqtt.Client()
|
||||
m:on("connect",function(m) print("connection") end )
|
||||
m:connect("192.168.18.88",1883)
|
||||
m:on("offline",function(m) print("disconnection") end )
|
||||
|
||||
m=mqtt.Client()
|
||||
m:on("connect",function(m) print("connection "..node.heap()) end )
|
||||
m:on("offline", function(conn)
|
||||
if conn == nil then print("conn is nil") end
|
||||
print("Reconnect to broker...")
|
||||
print(node.heap())
|
||||
conn:connect("192.168.18.88",1883,0,1)
|
||||
end)
|
||||
m:connect("192.168.18.88",1883,0,1)
|
||||
|
||||
m=mqtt.Client()
|
||||
m:on("connect",function(m) print("connection "..node.heap()) end )
|
||||
m:on("offline", function(conn)
|
||||
if conn == nil then print("conn is nil") end
|
||||
print("Reconnect to broker...")
|
||||
print(node.heap())
|
||||
conn:connect("192.168.18.88",1883)
|
||||
end)
|
||||
m:connect("192.168.18.88",1883)
|
||||
|
||||
m:close()
|
||||
|
||||
m=mqtt.Client()
|
||||
m:connect("192.168.18.88",1883)
|
||||
m:on("message",function(m,t,pl) print(t..":") if pl~=nil then print(pl) end end )
|
||||
m:subscribe("/topic1",0,function(m) print("sub done") end)
|
||||
m:publish("/topic1","hello3",2,0) m:publish("/topic1","hello2",2,0)
|
||||
m:publish("/topic1","hello3",0,0) m:publish("/topic1","hello2",2,0)
|
||||
|
||||
m:subscribe("/topic2",2,function(m) print("sub done") end)
|
||||
m:publish("/topic2","hello3",0,0) m:publish("/topic2","hello2",2,0)
|
||||
|
||||
m=mqtt.Client()
|
||||
m:on("connect",function(m)
|
||||
print("connection "..node.heap())
|
||||
m:subscribe("/topic1",0,function(m) print("sub done") end)
|
||||
m:publish("/topic1","hello3",0,0) m:publish("/topic1","hello2",2,0)
|
||||
end )
|
||||
m:on("offline", function(conn)
|
||||
print("disconnect to broker...")
|
||||
print(node.heap())
|
||||
end)
|
||||
m:connect("192.168.18.88",1883,0,1)
|
||||
|
||||
-- serout( pin, firstLevel, delay_table, [repeatNum] )
|
||||
gpio.mode(1,gpio.OUTPUT,gpio.PULLUP)
|
||||
gpio.serout(1,1,{30,30,60,60,30,30}) -- serial one byte, b10110010
|
||||
gpio.serout(1,1,{30,70},8) -- serial 30% pwm 10k, lasts 8 cycles
|
||||
gpio.serout(1,1,{3,7},8) -- serial 30% pwm 100k, lasts 8 cycles
|
||||
gpio.serout(1,1,{0,0},8) -- serial 50% pwm as fast as possible, lasts 8 cycles
|
||||
|
||||
gpio.mode(1,gpio.OUTPUT,gpio.PULLUP)
|
||||
gpio.serout(1,0,{20,10,10,20,10,10,10,100}) -- sim uart one byte 0x5A at about 100kbps
|
||||
|
||||
gpio.serout(1,1,{8,18},8) -- serial 30% pwm 38k, lasts 8 cycles
|
||||
|
||||
-- Lua: mqtt.Client(clientid, keepalive, user, pass)
|
||||
-- test with cloudmqtt.com
|
||||
m_dis={}
|
||||
function dispatch(m,t,pl)
|
||||
if pl~=nil and m_dis[t] then
|
||||
m_dis[t](pl)
|
||||
end
|
||||
end
|
||||
function topic1func(pl)
|
||||
print("get1: "..pl)
|
||||
end
|
||||
function topic2func(pl)
|
||||
print("get2: "..pl)
|
||||
end
|
||||
m_dis["/topic1"]=topic1func
|
||||
m_dis["/topic2"]=topic2func
|
||||
m=mqtt.Client("nodemcu1",60,"test","test123")
|
||||
m:on("connect",function(m)
|
||||
print("connection "..node.heap())
|
||||
m:subscribe("/topic1",0,function(m) print("sub done") end)
|
||||
m:subscribe("/topic2",0,function(m) print("sub done") end)
|
||||
m:publish("/topic1","hello",0,0) m:publish("/topic2","world",0,0)
|
||||
end )
|
||||
m:on("offline", function(conn)
|
||||
print("disconnect to broker...")
|
||||
print(node.heap())
|
||||
end)
|
||||
m:on("message",dispatch )
|
||||
m:connect("m11.cloudmqtt.com",11214,0,1)
|
||||
-- Lua: mqtt:connect( host, port, secure, auto_reconnect, function(client) )
|
||||
|
||||
tmr.alarm(0,10000,1,function() local pl = "time: "..tmr.time()
|
||||
m:publish("/topic1",pl,0,0)
|
||||
end)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,18 @@
|
|||
--init.lua, something like this
|
||||
countdown = 3
|
||||
tmr.alarm(0,1000,1,function()
|
||||
print(countdown)
|
||||
countdown = countdown-1
|
||||
if countdown<1 then
|
||||
tmr.stop(0)
|
||||
countdown = nil
|
||||
local s,err
|
||||
if file.open("user.lc") then
|
||||
file.close()
|
||||
s,err = pcall(function() dofile("user.lc") end)
|
||||
else
|
||||
s,err = pcall(function() dofile("user.lua") end)
|
||||
end
|
||||
if not s then print(err) end
|
||||
end
|
||||
end)
|
||||
|
|
@ -0,0 +1 @@
|
|||
print("hello NodeMCU")
|
||||
|
|
@ -5,7 +5,7 @@ MEMORY
|
|||
dport0_0_seg : org = 0x3FF00000, len = 0x10
|
||||
dram0_0_seg : org = 0x3FFE8000, len = 0x14000
|
||||
iram1_0_seg : org = 0x40100000, len = 0x8000
|
||||
irom0_0_seg : org = 0x40210000, len = 0x5A000
|
||||
irom0_0_seg : org = 0x40210000, len = 0x60000
|
||||
}
|
||||
|
||||
PHDRS
|
||||
|
|
|
|||
|
|
@ -0,0 +1,98 @@
|
|||
--[[
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
|
||||
documentation files (the "Software"), to deal in the Software without restriction,
|
||||
including without limitation the rights to use, copy, modify, merge, publish, distribute,
|
||||
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
]]--
|
||||
|
||||
-- Your access point's SSID and password
|
||||
local SSID = "xxxxxx"
|
||||
local SSID_PASSWORD = "xxxxxx"
|
||||
|
||||
-- configure ESP as a station
|
||||
wifi.setmode(wifi.STATION)
|
||||
wifi.sta.config(SSID,SSID_PASSWORD)
|
||||
wifi.sta.autoconnect(1)
|
||||
|
||||
local TWILIO_ACCOUNT_SID = "xxxxxx"
|
||||
local TWILIO_TOKEN = "xxxxxx"
|
||||
|
||||
local HOST = "iot-https-relay.appspot.com" -- visit http://iot-https-relay.appspot.com/ to learn more about this service
|
||||
-- Please be sure to understand the security issues of using this relay app and use at your own risk.
|
||||
local URI = "/twilio/Calls.json"
|
||||
|
||||
function build_post_request(host, uri, data_table)
|
||||
|
||||
local data = ""
|
||||
|
||||
for param,value in pairs(data_table) do
|
||||
data = data .. param.."="..value.."&"
|
||||
end
|
||||
|
||||
request = "POST "..uri.." HTTP/1.1\r\n"..
|
||||
"Host: "..host.."\r\n"..
|
||||
"Connection: close\r\n"..
|
||||
"Content-Type: application/x-www-form-urlencoded\r\n"..
|
||||
"Content-Length: "..string.len(data).."\r\n"..
|
||||
"\r\n"..
|
||||
data
|
||||
|
||||
print(request)
|
||||
|
||||
return request
|
||||
end
|
||||
|
||||
local function display(sck,response)
|
||||
print(response)
|
||||
end
|
||||
|
||||
-- When using send_sms: the "from" number HAS to be your twilio number.
|
||||
-- If you have a free twilio account the "to" number HAS to be your twilio verified number.
|
||||
local function make_call(from,to,body)
|
||||
|
||||
local data = {
|
||||
sid = TWILIO_ACCOUNT_SID,
|
||||
token = TWILIO_TOKEN,
|
||||
Body = string.gsub(body," ","+"),
|
||||
From = from,
|
||||
To = to
|
||||
}
|
||||
|
||||
socket = net.createConnection(net.TCP,0)
|
||||
socket:on("receive",display)
|
||||
socket:connect(80,HOST)
|
||||
|
||||
socket:on("connection",function(sck)
|
||||
|
||||
local post_request = build_post_request(HOST,URI,data)
|
||||
sck:send(post_request)
|
||||
end)
|
||||
end
|
||||
|
||||
function check_wifi()
|
||||
local ip = wifi.sta.getip()
|
||||
|
||||
if(ip==nil) then
|
||||
print("Connecting...")
|
||||
else
|
||||
tmr.stop(0)
|
||||
print("Connected to AP!")
|
||||
print(ip)
|
||||
-- make a call with a voice message "your house is on fire"
|
||||
make_call("15558976687","1334856679","Your house is on fire!")
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
tmr.alarm(0,2000,1,check_wifi)
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
-- test with cloudmqtt.com
|
||||
m_dis={}
|
||||
function dispatch(m,t,pl)
|
||||
if pl~=nil and m_dis[t] then
|
||||
m_dis[t](m,pl)
|
||||
end
|
||||
end
|
||||
function topic1func(m,pl)
|
||||
print("get1: "..pl)
|
||||
end
|
||||
function topic2func(m,pl)
|
||||
print("get2: "..pl)
|
||||
end
|
||||
m_dis["/topic1"]=topic1func
|
||||
m_dis["/topic2"]=topic2func
|
||||
-- Lua: mqtt.Client(clientid, keepalive, user, pass)
|
||||
m=mqtt.Client("nodemcu1",60,"test","test123")
|
||||
m:on("connect",function(m)
|
||||
print("connection "..node.heap())
|
||||
m:subscribe("/topic1",0,function(m) print("sub done") end)
|
||||
m:subscribe("/topic2",0,function(m) print("sub done") end)
|
||||
m:publish("/topic1","hello",0,0) m:publish("/topic2","world",0,0)
|
||||
end )
|
||||
m:on("offline", function(conn)
|
||||
print("disconnect to broker...")
|
||||
print(node.heap())
|
||||
end)
|
||||
m:on("message",dispatch )
|
||||
-- Lua: mqtt:connect( host, port, secure, auto_reconnect, function(client) )
|
||||
m:connect("m11.cloudmqtt.com",11214,0,1)
|
||||
tmr.alarm(0,10000,1,function() local pl = "time: "..tmr.time()
|
||||
m:publish("/topic1",pl,0,0)
|
||||
end)
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
-- test transfer files over mqtt.
|
||||
m_dis={}
|
||||
function dispatch(m,t,pl)
|
||||
if pl~=nil and m_dis[t] then
|
||||
m_dis[t](m,pl)
|
||||
end
|
||||
end
|
||||
|
||||
function pubfile(m,filename)
|
||||
file.close()
|
||||
file.open(filename)
|
||||
repeat
|
||||
local pl=file.read(1024)
|
||||
if pl then m:publish("/topic2",pl,0,0) end
|
||||
until not pl
|
||||
file.close()
|
||||
end
|
||||
-- payload(json): {"cmd":xxx,"content":xxx}
|
||||
function topic1func(m,pl)
|
||||
print("get1: "..pl)
|
||||
local pack = cjson.decode(pl)
|
||||
if pack.content then
|
||||
if pack.cmd == "open" then file.open(pack.content,"w+")
|
||||
elseif pack.cmd == "write" then file.write(pack.content)
|
||||
elseif pack.cmd == "close" then file.close()
|
||||
elseif pack.cmd == "remove" then file.remove(pack.content)
|
||||
elseif pack.cmd == "run" then dofile(pack.content)
|
||||
elseif pack.cmd == "read" then pubfile(m, pack.content)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
m_dis["/topic1"]=topic1func
|
||||
-- Lua: mqtt.Client(clientid, keepalive, user, pass)
|
||||
m=mqtt.Client()
|
||||
m:on("connect",function(m)
|
||||
print("connection "..node.heap())
|
||||
m:subscribe("/topic1",0,function(m) print("sub done") end)
|
||||
end )
|
||||
m:on("offline", function(conn)
|
||||
print("disconnect to broker...")
|
||||
print(node.heap())
|
||||
end)
|
||||
m:on("message",dispatch )
|
||||
-- Lua: mqtt:connect( host, port, secure, auto_reconnect, function(client) )
|
||||
m:connect(192.168.18.88,1883,0,1)
|
||||
|
||||
-- usage:
|
||||
-- another client(pc) subscribe to /topic2, will receive the test.lua content.
|
||||
-- and publish below message to /topic1
|
||||
-- {"cmd":"open","content":"test.lua"}
|
||||
-- {"cmd":"write","content":"print([[hello world]])\n"}
|
||||
-- {"cmd":"write","content":"print(\"hello2 world2\")\n"}
|
||||
-- {"cmd":"write","content":"test.lua"}
|
||||
-- {"cmd":"run","content":"test.lua"}
|
||||
-- {"cmd":"read","content":"test.lua"}
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
--[[
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
|
||||
documentation files (the "Software"), to deal in the Software without restriction,
|
||||
including without limitation the rights to use, copy, modify, merge, publish, distribute,
|
||||
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
]]--
|
||||
|
||||
-- Your access point's SSID and password
|
||||
local SSID = "xxxxxx"
|
||||
local SSID_PASSWORD = "xxxxxx"
|
||||
|
||||
-- configure ESP as a station
|
||||
wifi.setmode(wifi.STATION)
|
||||
wifi.sta.config(SSID,SSID_PASSWORD)
|
||||
wifi.sta.autoconnect(1)
|
||||
|
||||
local TWILIO_ACCOUNT_SID = "xxxxxx"
|
||||
local TWILIO_TOKEN = "xxxxxx"
|
||||
|
||||
local HOST = "iot-https-relay.appspot.com" -- visit http://iot-https-relay.appspot.com/ to learn more about this service
|
||||
-- Please be sure to understand the security issues of using this relay app and use at your own risk.
|
||||
local URI = "/twilio/Messages.json"
|
||||
|
||||
function build_post_request(host, uri, data_table)
|
||||
|
||||
local data = ""
|
||||
|
||||
for param,value in pairs(data_table) do
|
||||
data = data .. param.."="..value.."&"
|
||||
end
|
||||
|
||||
request = "POST "..uri.." HTTP/1.1\r\n"..
|
||||
"Host: "..host.."\r\n"..
|
||||
"Connection: close\r\n"..
|
||||
"Content-Type: application/x-www-form-urlencoded\r\n"..
|
||||
"Content-Length: "..string.len(data).."\r\n"..
|
||||
"\r\n"..
|
||||
data
|
||||
|
||||
print(request)
|
||||
|
||||
return request
|
||||
end
|
||||
|
||||
local function display(sck,response)
|
||||
print(response)
|
||||
end
|
||||
|
||||
-- When using send_sms: the "from" number HAS to be your twilio number.
|
||||
-- If you have a free twilio account the "to" number HAS to be your twilio verified number.
|
||||
local function send_sms(from,to,body)
|
||||
|
||||
local data = {
|
||||
sid = TWILIO_ACCOUNT_SID,
|
||||
token = TWILIO_TOKEN,
|
||||
Body = string.gsub(body," ","+"),
|
||||
From = from,
|
||||
To = to
|
||||
}
|
||||
|
||||
socket = net.createConnection(net.TCP,0)
|
||||
socket:on("receive",display)
|
||||
socket:connect(80,HOST)
|
||||
|
||||
socket:on("connection",function(sck)
|
||||
|
||||
local post_request = build_post_request(HOST,URI,data)
|
||||
sck:send(post_request)
|
||||
end)
|
||||
end
|
||||
|
||||
function check_wifi()
|
||||
local ip = wifi.sta.getip()
|
||||
|
||||
if(ip==nil) then
|
||||
print("Connecting...")
|
||||
else
|
||||
tmr.stop(0)
|
||||
print("Connected to AP!")
|
||||
print(ip)
|
||||
-- send a text message with the text "Hello from your esp8266"
|
||||
send_sms("15558889944","15559998845","Hello from your ESP8266")
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
tmr.alarm(0,7000,1,check_wifi)
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
# DHT22 module
|
||||
|
||||
This module is compatible with DHT22 and DHT21.
|
||||
Supports nodemcu with or without floating point.
|
||||
No need to use a resistor to connect the pin data of DHT22 to ESP8266.
|
||||
|
||||
## Example
|
||||
```lua
|
||||
PIN = 4 -- data pin, GPIO2
|
||||
|
||||
dht22 = require("dht22")
|
||||
dht22.read(PIN)
|
||||
t = dht22.getTemperature()
|
||||
h = dht22.getHumidity()
|
||||
|
||||
if h == nil then
|
||||
print("Error reading from DHT22")
|
||||
else
|
||||
-- temperature in degrees Celsius and Farenheit
|
||||
-- floating point and integer version:
|
||||
print("Temperature: "..((t-(t % 10)) / 10).."."..(t % 10).." deg C")
|
||||
-- only integer version:
|
||||
print("Temperature: "..(9 * t / 50 + 32).."."..(9 * t / 5 % 10).." deg F")
|
||||
-- only float point version:
|
||||
print("Temperature: "..(9 * t / 50 + 32).." deg F")
|
||||
|
||||
-- humidity
|
||||
-- floating point and integer version
|
||||
print("Humidity: "..((h - (h % 10)) / 10).."."..(h % 10).."%")
|
||||
end
|
||||
|
||||
-- release module
|
||||
dht22 = nil
|
||||
package.loaded["dht22"]=nil
|
||||
```
|
||||
## Functions
|
||||
### read
|
||||
read(pin)
|
||||
Read humidity and temperature from DHT22.
|
||||
|
||||
**Parameters:**
|
||||
|
||||
* pin - ESP8266 pin connect to data pin in DHT22
|
||||
|
||||
### getHumidity
|
||||
getHumidity()
|
||||
Returns the humidity of the last reading.
|
||||
|
||||
**Returns:**
|
||||
* last humidity reading in per thousand
|
||||
|
||||
### getTemperature
|
||||
getTemperature()
|
||||
Returns the temperature of the last reading.
|
||||
|
||||
**Returns:**
|
||||
* last temperature reading in 0.1ºC
|
||||
|
||||
|
|
@ -1,102 +0,0 @@
|
|||
-- ***************************************************************************
|
||||
-- DHT22 module for ESP8266 with nodeMCU
|
||||
--
|
||||
-- Written by Javier Yanez
|
||||
-- but based on a script of Pigs Fly from ESP8266.com forum
|
||||
--
|
||||
-- MIT license, http://opensource.org/licenses/MIT
|
||||
-- ***************************************************************************
|
||||
|
||||
local moduleName = ...
|
||||
local M = {}
|
||||
_G[moduleName] = M
|
||||
|
||||
local humidity
|
||||
local temperature
|
||||
|
||||
function M.read(pin)
|
||||
local checksum
|
||||
local checksumTest
|
||||
humidity = 0
|
||||
temperature = 0
|
||||
checksum = 0
|
||||
|
||||
-- Use Markus Gritsch trick to speed up read/write on GPIO
|
||||
local gpio_read = gpio.read
|
||||
|
||||
local bitStream = {}
|
||||
for j = 1, 40, 1 do
|
||||
bitStream[j] = 0
|
||||
end
|
||||
local bitlength = 0
|
||||
|
||||
-- Step 1: send out start signal to DHT22
|
||||
gpio.mode(pin, gpio.OUTPUT)
|
||||
gpio.write(pin, gpio.HIGH)
|
||||
tmr.delay(100)
|
||||
gpio.write(pin, gpio.LOW)
|
||||
tmr.delay(20000)
|
||||
gpio.write(pin, gpio.HIGH)
|
||||
gpio.mode(pin, gpio.INPUT)
|
||||
|
||||
-- Step 2: DHT22 send response signal
|
||||
-- bus will always let up eventually, don't bother with timeout
|
||||
while (gpio_read(pin) == 0 ) do end
|
||||
local c=0
|
||||
while (gpio_read(pin) == 1 and c < 500) do c = c + 1 end
|
||||
-- bus will always let up eventually, don't bother with timeout
|
||||
while (gpio_read(pin) == 0 ) do end
|
||||
c=0
|
||||
while (gpio_read(pin) == 1 and c < 500) do c = c + 1 end
|
||||
|
||||
-- Step 3: DHT22 send data
|
||||
for j = 1, 40, 1 do
|
||||
while (gpio_read(pin) == 1 and bitlength < 10 ) do
|
||||
bitlength = bitlength + 1
|
||||
end
|
||||
bitStream[j] = bitlength
|
||||
bitlength = 0
|
||||
-- bus will always let up eventually, don't bother with timeout
|
||||
while (gpio_read(pin) == 0) do end
|
||||
end
|
||||
|
||||
--DHT data acquired, process.
|
||||
for i = 1, 16, 1 do
|
||||
if (bitStream[i] > 3) then
|
||||
humidity = humidity + 2 ^ (16 - i)
|
||||
end
|
||||
end
|
||||
for i = 1, 16, 1 do
|
||||
if (bitStream[i + 16] > 3) then
|
||||
temperature = temperature + 2 ^ (16 - i)
|
||||
end
|
||||
end
|
||||
for i = 1, 8, 1 do
|
||||
if (bitStream[i + 32] > 3) then
|
||||
checksum = checksum + 2 ^ (8 - i)
|
||||
end
|
||||
end
|
||||
|
||||
checksumTest = (bit.band(humidity, 0xFF) + bit.rshift(humidity, 8) + bit.band(temperature, 0xFF) + bit.rshift(temperature, 8))
|
||||
checksumTest = bit.band(checksumTest, 0xFF)
|
||||
|
||||
if temperature > 0x8000 then
|
||||
-- convert to negative format
|
||||
temperature = -(temperature - 0x8000)
|
||||
end
|
||||
|
||||
-- conditions compatible con float point and integer
|
||||
if (checksumTest - checksum >= 1) or (checksum - checksumTest >= 1) then
|
||||
humidity = nil
|
||||
end
|
||||
end
|
||||
|
||||
function M.getTemperature()
|
||||
return temperature
|
||||
end
|
||||
|
||||
function M.getHumidity()
|
||||
return humidity
|
||||
end
|
||||
|
||||
return M
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
# DHTxx module
|
||||
|
||||
This module is compatible with DHT11, DHT21 and DHT22.
|
||||
And is able to auto-select wheather you are using DHT11 or DHT2x
|
||||
|
||||
No need to use a resistor to connect the pin data of DHT22 to ESP8266.
|
||||
|
||||
##Integer Verison[When using DHT11, Float version is useless...]
|
||||
### Example
|
||||
```lua
|
||||
PIN = 4 -- data pin, GPIO2
|
||||
|
||||
DHT= require("dht_lib")
|
||||
|
||||
DHT.read(PIN)
|
||||
|
||||
t = DHT.getTemperature()
|
||||
h = DHT.getHumidity()
|
||||
|
||||
if h == nil then
|
||||
print("Error reading from DHTxx")
|
||||
else
|
||||
-- temperature in degrees Celsius and Farenheit
|
||||
|
||||
print("Temperature: "..((t-(t % 10)) / 10).."."..(t % 10).." deg C")
|
||||
|
||||
print("Temperature: "..(9 * t / 50 + 32).."."..(9 * t / 5 % 10).." deg F")
|
||||
|
||||
-- humidity
|
||||
|
||||
print("Humidity: "..((h - (h % 10)) / 10).."."..(h % 10).."%")
|
||||
end
|
||||
|
||||
-- release module
|
||||
DHT = nil
|
||||
package.loaded["dht_lib"]=nil
|
||||
```
|
||||
##Float Verison
|
||||
###Example
|
||||
```lua
|
||||
PIN = 4 -- data pin, GPIO2
|
||||
|
||||
DHT= require("dht_lib")
|
||||
|
||||
DHT.read(PIN)
|
||||
|
||||
t = DHT.getTemperature()
|
||||
h = DHT.getHumidity()
|
||||
|
||||
if h == nil then
|
||||
print("Error reading from DHT11/22")
|
||||
else
|
||||
-- temperature in degrees Celsius and Farenheit
|
||||
-- floating point and integer version:
|
||||
|
||||
print("Temperature: "..(t/10).." deg C")
|
||||
print("Temperature: "..(9 * t / 50 + 32).." deg F")
|
||||
|
||||
-- humidity
|
||||
print("Humidity: "..(h/10).."%")
|
||||
end
|
||||
|
||||
-- release module
|
||||
DHT = nil
|
||||
package.loaded["dht_lib"]=nil
|
||||
```
|
||||
## Functions
|
||||
|
||||
###read
|
||||
read(pin)
|
||||
Read humidity and temperature from DHTxx(11,21,22...).
|
||||
**Parameters:**
|
||||
|
||||
* pin - ESP8266 pin connect to data pin
|
||||
|
||||
### getHumidity
|
||||
getHumidity()
|
||||
Returns the humidity of the last reading.
|
||||
|
||||
**Returns:**
|
||||
* last humidity reading in per thousand
|
||||
|
||||
### getTemperature
|
||||
getTemperature()
|
||||
Returns the temperature of the last reading.
|
||||
|
||||
**Returns:**
|
||||
* last temperature reading in(dht22) 0.1ºC (dht11)1ºC
|
||||
*
|
||||
|
|
@ -0,0 +1,178 @@
|
|||
-- ***************************************************************************
|
||||
-- DHTxx(11,21,22) module for ESP8266 with nodeMCU
|
||||
--
|
||||
-- Written by Javier Yanez mod by Martin
|
||||
-- but based on a script of Pigs Fly from ESP8266.com forum
|
||||
--
|
||||
-- MIT license, http://opensource.org/licenses/MIT
|
||||
-- ***************************************************************************
|
||||
|
||||
--Support list：
|
||||
|
||||
--DHT11 Tested
|
||||
--DHT21 Not Test yet
|
||||
--DHT22(AM2302) Tested
|
||||
--AM2320 Not Test yet
|
||||
|
||||
--Output format-> Real temperature times 10(or DHT22 will miss it float part in Int Version)
|
||||
--==========================Module Part======================
|
||||
local moduleName = ...
|
||||
local M = {}
|
||||
_G[moduleName] = M
|
||||
--==========================Local the UMI and TEMP===========
|
||||
local humidity
|
||||
local temperature
|
||||
--==========================Local the bitStream==============
|
||||
local bitStream = {}
|
||||
|
||||
---------------------------Read bitStream from DHTXX--------------------------
|
||||
local function read(pin)
|
||||
|
||||
local bitlength = 0
|
||||
humidity = 0
|
||||
temperature = 0
|
||||
|
||||
-- Use Markus Gritsch trick to speed up read/write on GPIO
|
||||
local gpio_read = gpio.read
|
||||
|
||||
|
||||
for j = 1, 40, 1 do
|
||||
bitStream[j] = 0
|
||||
end
|
||||
|
||||
-- Step 1: send out start signal to DHT22
|
||||
gpio.mode(pin, gpio.OUTPUT)
|
||||
gpio.write(pin, gpio.HIGH)
|
||||
tmr.delay(100)
|
||||
gpio.write(pin, gpio.LOW)
|
||||
tmr.delay(20000)
|
||||
gpio.write(pin, gpio.HIGH)
|
||||
gpio.mode(pin, gpio.INPUT)
|
||||
|
||||
-- Step 2: Receive bitStream from DHT11/22
|
||||
-- bus will always let up eventually, don't bother with timeout
|
||||
while (gpio_read(pin) == 0 ) do end
|
||||
local c=0
|
||||
while (gpio_read(pin) == 1 and c < 500) do c = c + 1 end
|
||||
-- bus will always let up eventually, don't bother with timeout
|
||||
while (gpio_read(pin) == 0 ) do end
|
||||
c=0
|
||||
while (gpio_read(pin) == 1 and c < 500) do c = c + 1 end
|
||||
|
||||
-- Step 3: DHT22 send data
|
||||
for j = 1, 40, 1 do
|
||||
while (gpio_read(pin) == 1 and bitlength < 10 ) do
|
||||
bitlength = bitlength + 1
|
||||
end
|
||||
bitStream[j] = bitlength
|
||||
bitlength = 0
|
||||
-- bus will always let up eventually, don't bother with timeout
|
||||
while (gpio_read(pin) == 0) do end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------Check out the data--------------------------
|
||||
----Auto Select the DHT11/DHT22 By check the byte[1] && byte[3] -------
|
||||
---------------Which is empty when using DHT11-------------------------
|
||||
function M.read(pin)
|
||||
read(pin)
|
||||
|
||||
local byte_0 = 0
|
||||
local byte_1 = 0
|
||||
local byte_2 = 0
|
||||
local byte_3 = 0
|
||||
local byte_4 = 0
|
||||
|
||||
for i = 1, 8, 1 do -- Byte[0]
|
||||
if (bitStream[i] > 3) then
|
||||
byte_0 = byte_0 + 2 ^ (8 - i)
|
||||
end
|
||||
end
|
||||
|
||||
for i = 1, 8, 1 do -- Byte[1]
|
||||
if (bitStream[i+8] > 3) then
|
||||
byte_1 = byte_1 + 2 ^ (8 - i)
|
||||
end
|
||||
end
|
||||
|
||||
for i = 1, 8, 1 do -- Byte[2]
|
||||
if (bitStream[i+16] > 3) then
|
||||
byte_2 = byte_2 + 2 ^ (8 - i)
|
||||
end
|
||||
end
|
||||
|
||||
for i = 1, 8, 1 do -- Byte[3]
|
||||
if (bitStream[i+24] > 3) then
|
||||
byte_2 = byte_2 + 2 ^ (8 - i)
|
||||
end
|
||||
end
|
||||
|
||||
for i = 1, 8, 1 do -- Byte[4]
|
||||
if (bitStream[i+32] > 3) then
|
||||
byte_4 = byte_4 + 2 ^ (8 - i)
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
if byte_1==0 and byte_3 == 0 then
|
||||
---------------------------Convert the bitStream into Number through DHT11's Way--------------------------
|
||||
--As for DHT11 40Bit is consisit of 5Bytes
|
||||
--First byte->Humidity Data's Int part
|
||||
--Sencond byte->Humidity Data's Float Part(Which should be empty)
|
||||
--Third byte->Temp Data;s Intpart
|
||||
--Forth byte->Temp Data's Float Part(Which should be empty)
|
||||
--Fifth byte->SUM Byte, Humi+Temp
|
||||
|
||||
if(byte_4 ~= byte_0+byte_2) then
|
||||
humidity = nil
|
||||
temperature = nil
|
||||
else
|
||||
humidity = byte_0 *10 -- In order to universe with the DHT22
|
||||
temperature = byte_2 *10
|
||||
end
|
||||
|
||||
else ---------------------------Convert the bitStream into Number through DHT22's Way--------------------------
|
||||
--As for DHT22 40Bit is consisit of 5Bytes
|
||||
--First byte->Humidity Data's High Bit
|
||||
--Sencond byte->Humidity Data's Low Bit(And if over 0x8000, use complement)
|
||||
--Third byte->Temp Data's High Bit
|
||||
--Forth byte->Temp Data's Low Bit
|
||||
--Fifth byte->SUM Byte
|
||||
|
||||
humidity = byte_0 * 256 + byte_1
|
||||
temperature = byte_2 * 256 + byte_3
|
||||
checksum = byte_4
|
||||
|
||||
checksumTest = (bit.band(humidity, 0xFF) + bit.rshift(humidity, 8) + bit.band(temperature, 0xFF) + bit.rshift(temperature, 8))
|
||||
checksumTest = bit.band(checksumTest, 0xFF)
|
||||
|
||||
if temperature > 0x8000 then
|
||||
-- convert to negative format
|
||||
temperature = -(temperature - 0x8000)
|
||||
end
|
||||
|
||||
-- conditions compatible con float point and integer
|
||||
if (checksumTest - checksum >= 1) or (checksum - checksumTest >= 1) then
|
||||
humidity = nil
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
byte_0 = nil
|
||||
byte_1 = nil
|
||||
byte_2 = nil
|
||||
byte_3 = nil
|
||||
byte_4 = nil
|
||||
|
||||
end
|
||||
--------------API for geting the data out------------------
|
||||
|
||||
function M.getTemperature()
|
||||
return temperature
|
||||
end
|
||||
|
||||
function M.getHumidity()
|
||||
return humidity
|
||||
end
|
||||
-------------Return Index------------------------------------
|
||||
return M
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
|
||||
-- ***************************************************************************
|
||||
-- Yeelink Updata Libiary
|
||||
--
|
||||
-- Written by Martin
|
||||
-- but based on a script of zhouxu_o from bbs.nodemcu.com
|
||||
--
|
||||
-- MIT license, http://opensource.org/licenses/MIT
|
||||
-- ***************************************************************************
|
||||
|
||||
if wifi.sta.getip() == nil then
|
||||
print("Please Connect WIFI First")
|
||||
return nil
|
||||
end
|
||||
--==========================Module Part======================
|
||||
|
||||
local moduleName = ...
|
||||
local M = {}
|
||||
_G[moduleName] = M
|
||||
--=========================Local Args=======================
|
||||
local dns = "0.0.0.0"
|
||||
|
||||
local device = ""
|
||||
local sensor = ""
|
||||
local apikey = ""
|
||||
|
||||
--================================
|
||||
local debug = true --<<<<<<<<<<<<< Don't forget to "false" it before using
|
||||
--================================
|
||||
local sk=net.createConnection(net.TCP, 0)
|
||||
|
||||
local datapoint = 0
|
||||
--====DNS the yeelink ip advance(in order to save RAM)=====
|
||||
sk:dns("api.yeelink.net",function(conn,ip)
|
||||
|
||||
dns=ip
|
||||
|
||||
print("DNS YEELINK OK... IP: "..dns)
|
||||
|
||||
end)
|
||||
|
||||
--========Set the init function===========
|
||||
--device->number
|
||||
--sensor->number
|
||||
-- apikey must be -> string <-
|
||||
-- e.g. xxx.init(00000,00000,"123j12b3jkb12k4b23bv54i2b5b3o4")
|
||||
--========================================
|
||||
function M.init(_device, _sensor, _apikey)
|
||||
device = tostring(_device)
|
||||
sensor = tostring(_sensor)
|
||||
apikey = _apikey
|
||||
if dns == "0.0.0.0" then
|
||||
return false
|
||||
else
|
||||
return dns
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
|
||||
--=====Update to Yeelink Sever(At least 10s per sencods))=====
|
||||
-- datapoint->number
|
||||
--
|
||||
--e.g. xxx.update(233.333)
|
||||
--============================================================
|
||||
function M.update(_datapoint)
|
||||
|
||||
datapoint = tostring(_datapoint)
|
||||
|
||||
sk:on("connection", function(conn)
|
||||
|
||||
print("connect OK...")
|
||||
|
||||
|
||||
local a=[[{"value":]]
|
||||
local b=[[}]]
|
||||
|
||||
local st=a..datapoint..b
|
||||
|
||||
sk:send("POST /v1.0/device/"..device.."/sensor/"..sensor.."/datapoints HTTP/1.1\r\n"
|
||||
.."Host: www.yeelink.net\r\n"
|
||||
.."Content-Length: "..string.len(st).."\r\n"--the length of json is important
|
||||
.."Content-Type: application/x-www-form-urlencoded\r\n"
|
||||
.."U-ApiKey:"..apikey.."\r\n"
|
||||
.."Cache-Control: no-cache\r\n\r\n"
|
||||
..st.."\r\n" )
|
||||
|
||||
end)
|
||||
|
||||
sk:on("receive", function(sck, content)
|
||||
|
||||
if debug then
|
||||
print("\r\n"..content.."\r\n")
|
||||
else
|
||||
print("Date Receive")
|
||||
end
|
||||
|
||||
end)
|
||||
|
||||
sk:connect(80,dns)
|
||||
|
||||
|
||||
end
|
||||
--================end==========================
|
||||
return M
|
||||
162
tools/esptool.py
162
tools/esptool.py
|
|
@ -41,7 +41,7 @@ class ESPROM:
|
|||
|
||||
# Maximum block sized for RAM and Flash writes, respectively.
|
||||
ESP_RAM_BLOCK = 0x1800
|
||||
ESP_FLASH_BLOCK = 0x100
|
||||
ESP_FLASH_BLOCK = 0x400
|
||||
|
||||
# Default baudrate. The ROM auto-bauds, so we can use more or less whatever we want.
|
||||
ESP_ROM_BAUD = 115200
|
||||
|
|
@ -56,6 +56,12 @@ class ESPROM:
|
|||
ESP_OTP_MAC0 = 0x3ff00050
|
||||
ESP_OTP_MAC1 = 0x3ff00054
|
||||
|
||||
# Sflash stub: an assembly routine to read from spi flash and send to host
|
||||
SFLASH_STUB = "\x80\x3c\x00\x40\x1c\x4b\x00\x40\x21\x11\x00\x40\x00\x80" \
|
||||
"\xfe\x3f\xc1\xfb\xff\xd1\xf8\xff\x2d\x0d\x31\xfd\xff\x41\xf7\xff\x4a" \
|
||||
"\xdd\x51\xf9\xff\xc0\x05\x00\x21\xf9\xff\x31\xf3\xff\x41\xf5\xff\xc0" \
|
||||
"\x04\x00\x0b\xcc\x56\xec\xfd\x06\xff\xff\x00\x00"
|
||||
|
||||
def __init__(self, port = 0, baud = ESP_ROM_BAUD):
|
||||
self._port = serial.Serial(port, baud)
|
||||
|
||||
|
|
@ -78,15 +84,7 @@ class ESPROM:
|
|||
|
||||
""" Write bytes to the serial port while performing SLIP escaping """
|
||||
def write(self, packet):
|
||||
buf = '\xc0'
|
||||
for b in packet:
|
||||
if b == '\xc0':
|
||||
buf += '\xdb\xdc'
|
||||
elif b == '\xdb':
|
||||
buf += '\xdb\xdd'
|
||||
else:
|
||||
buf += b
|
||||
buf += '\xc0'
|
||||
buf = '\xc0'+(packet.replace('\xdb','\xdb\xdd').replace('\xc0','\xdb\xdc'))+'\xc0'
|
||||
self._port.write(buf)
|
||||
|
||||
""" Calculate checksum of a blob, as it is defined by the ROM """
|
||||
|
|
@ -132,11 +130,25 @@ class ESPROM:
|
|||
|
||||
# RTS = CH_PD (i.e reset)
|
||||
# DTR = GPIO0
|
||||
# self._port.setRTS(True)
|
||||
# self._port.setDTR(True)
|
||||
# self._port.setRTS(False)
|
||||
# time.sleep(0.1)
|
||||
# self._port.setDTR(False)
|
||||
|
||||
# NodeMCU devkit
|
||||
self._port.setRTS(True)
|
||||
self._port.setDTR(True)
|
||||
self._port.setRTS(False)
|
||||
time.sleep(0.1)
|
||||
self._port.setRTS(False)
|
||||
self._port.setDTR(False)
|
||||
time.sleep(0.1)
|
||||
self._port.setRTS(True)
|
||||
time.sleep(0.1)
|
||||
self._port.setDTR(True)
|
||||
self._port.setRTS(False)
|
||||
time.sleep(0.3)
|
||||
self._port.setDTR(True)
|
||||
|
||||
self._port.timeout = 0.5
|
||||
for i in xrange(10):
|
||||
|
|
@ -209,16 +221,78 @@ class ESPROM:
|
|||
self.flash_begin(0, 0)
|
||||
self.flash_finish(reboot)
|
||||
|
||||
""" Read MAC from OTP ROM """
|
||||
def read_mac(self):
|
||||
mac0 = esp.read_reg(esp.ESP_OTP_MAC0)
|
||||
mac1 = esp.read_reg(esp.ESP_OTP_MAC1)
|
||||
if ((mac1 >> 16) & 0xff) == 0:
|
||||
oui = (0x18, 0xfe, 0x34)
|
||||
elif ((mac1 >> 16) & 0xff) == 1:
|
||||
oui = (0xac, 0xd0, 0x74)
|
||||
else:
|
||||
raise Exception("Unknown OUI")
|
||||
return oui + ((mac1 >> 8) & 0xff, mac1 & 0xff, (mac0 >> 24) & 0xff)
|
||||
|
||||
""" Read SPI flash manufacturer and device id """
|
||||
def flash_id(self):
|
||||
self.flash_begin(0, 0)
|
||||
self.write_reg(0x60000240, 0x0, 0xffffffff)
|
||||
self.write_reg(0x60000200, 0x10000000, 0xffffffff)
|
||||
flash_id = esp.read_reg(0x60000240)
|
||||
self.flash_finish(False)
|
||||
return flash_id
|
||||
|
||||
""" Read SPI flash """
|
||||
def flash_read(self, offset, size, count = 1):
|
||||
# Create a custom stub
|
||||
stub = struct.pack('<III', offset, size, count) + self.SFLASH_STUB
|
||||
|
||||
# Trick ROM to initialize SFlash
|
||||
self.flash_begin(0, 0)
|
||||
|
||||
# Download stub
|
||||
self.mem_begin(len(stub), 1, len(stub), 0x40100000)
|
||||
self.mem_block(stub, 0)
|
||||
self.mem_finish(0x4010001c)
|
||||
|
||||
# Fetch the data
|
||||
data = ''
|
||||
for _ in xrange(count):
|
||||
if self._port.read(1) != '\xc0':
|
||||
raise Exception('Invalid head of packet (sflash read)')
|
||||
|
||||
data += self.read(size)
|
||||
|
||||
if self._port.read(1) != chr(0xc0):
|
||||
raise Exception('Invalid end of packet (sflash read)')
|
||||
|
||||
return data
|
||||
|
||||
""" Perform a chip erase of SPI flash """
|
||||
def flash_erase(self):
|
||||
# Trick ROM to initialize SFlash
|
||||
self.flash_begin(0, 0)
|
||||
|
||||
# This is hacky: we don't have a custom stub, instead we trick
|
||||
# the bootloader to jump to the SPIEraseChip() routine and then halt/crash
|
||||
# when it tries to boot an unconfigured system.
|
||||
self.mem_begin(0,0,0,0x40100000)
|
||||
self.mem_finish(0x40004984)
|
||||
|
||||
# Yup - there's no good way to detect if we succeeded.
|
||||
# It it on the other hand unlikely to fail.
|
||||
|
||||
class ESPFirmwareImage:
|
||||
|
||||
def __init__(self, filename = None):
|
||||
self.segments = []
|
||||
self.entrypoint = 0
|
||||
self.flash_mode = 0
|
||||
self.flash_size_freq = 0
|
||||
|
||||
if filename is not None:
|
||||
f = file(filename, 'rb')
|
||||
(magic, segments, _, _, self.entrypoint) = struct.unpack('<BBBBI', f.read(8))
|
||||
(magic, segments, self.flash_mode, self.flash_size_freq, self.entrypoint) = struct.unpack('<BBBBI', f.read(8))
|
||||
|
||||
# some sanity check
|
||||
if magic != ESPROM.ESP_IMAGE_MAGIC or segments > 16:
|
||||
|
|
@ -246,7 +320,8 @@ class ESPFirmwareImage:
|
|||
|
||||
def save(self, filename):
|
||||
f = file(filename, 'wb')
|
||||
f.write(struct.pack('<BBBBI', ESPROM.ESP_IMAGE_MAGIC, len(self.segments), 0, 0, self.entrypoint))
|
||||
f.write(struct.pack('<BBBBI', ESPROM.ESP_IMAGE_MAGIC, len(self.segments),
|
||||
self.flash_mode, self.flash_size_freq, self.entrypoint))
|
||||
|
||||
checksum = ESPROM.ESP_CHECKSUM_MAGIC
|
||||
for (offset, size, data) in self.segments:
|
||||
|
|
@ -346,6 +421,12 @@ if __name__ == '__main__':
|
|||
'write_flash',
|
||||
help = 'Write a binary blob to flash')
|
||||
parser_write_flash.add_argument('addr_filename', nargs = '+', help = 'Address and binary file to write there, separated by space')
|
||||
parser_write_flash.add_argument('--flash_freq', '-ff', help = 'SPI Flash frequency',
|
||||
choices = ['40m', '26m', '20m', '80m'], default = '40m')
|
||||
parser_write_flash.add_argument('--flash_mode', '-fm', help = 'SPI Flash mode',
|
||||
choices = ['qio', 'qout', 'dio', 'dout'], default = 'qio')
|
||||
parser_write_flash.add_argument('--flash_size', '-fs', help = 'SPI Flash size in Mbit',
|
||||
choices = ['4m', '2m', '8m', '16m', '32m'], default = '4m')
|
||||
|
||||
parser_run = subparsers.add_parser(
|
||||
'run',
|
||||
|
|
@ -369,11 +450,32 @@ if __name__ == '__main__':
|
|||
help = 'Create an application image from ELF file')
|
||||
parser_elf2image.add_argument('input', help = 'Input ELF file')
|
||||
parser_elf2image.add_argument('--output', '-o', help = 'Output filename prefix', type = str)
|
||||
parser_elf2image.add_argument('--flash_freq', '-ff', help = 'SPI Flash frequency',
|
||||
choices = ['40m', '26m', '20m', '80m'], default = '40m')
|
||||
parser_elf2image.add_argument('--flash_mode', '-fm', help = 'SPI Flash mode',
|
||||
choices = ['qio', 'qout', 'dio', 'dout'], default = 'qio')
|
||||
parser_elf2image.add_argument('--flash_size', '-fs', help = 'SPI Flash size in Mbit',
|
||||
choices = ['4m', '2m', '8m', '16m', '32m'], default = '4m')
|
||||
|
||||
parser_read_mac = subparsers.add_parser(
|
||||
'read_mac',
|
||||
help = 'Read MAC address from OTP ROM')
|
||||
|
||||
parser_flash_id = subparsers.add_parser(
|
||||
'flash_id',
|
||||
help = 'Read SPI flash manufacturer and device ID')
|
||||
|
||||
parser_read_flash = subparsers.add_parser(
|
||||
'read_flash',
|
||||
help = 'Read SPI flash content')
|
||||
parser_read_flash.add_argument('address', help = 'Start address', type = arg_auto_int)
|
||||
parser_read_flash.add_argument('size', help = 'Size of region to dump', type = arg_auto_int)
|
||||
parser_read_flash.add_argument('filename', help = 'Name of binary dump')
|
||||
|
||||
parser_erase_flash = subparsers.add_parser(
|
||||
'erase_flash',
|
||||
help = 'Perform Chip Erase on SPI flash')
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Create the ESPROM connection object, if needed
|
||||
|
|
@ -421,6 +523,12 @@ if __name__ == '__main__':
|
|||
|
||||
elif args.operation == 'write_flash':
|
||||
assert len(args.addr_filename) % 2 == 0
|
||||
|
||||
flash_mode = {'qio':0, 'qout':1, 'dio':2, 'dout': 3}[args.flash_mode]
|
||||
flash_size_freq = {'4m':0x00, '2m':0x10, '8m':0x20, '16m':0x30, '32m':0x40}[args.flash_size]
|
||||
flash_size_freq += {'40m':0, '26m':1, '20m':2, '80m': 0xf}[args.flash_freq]
|
||||
flash_info = struct.pack('BB', flash_mode, flash_size_freq)
|
||||
|
||||
while args.addr_filename:
|
||||
address = int(args.addr_filename[0], 0)
|
||||
filename = args.addr_filename[1]
|
||||
|
|
@ -434,7 +542,11 @@ if __name__ == '__main__':
|
|||
print '\rWriting at 0x%08x... (%d %%)' % (address + seq*esp.ESP_FLASH_BLOCK, 100*(seq+1)/blocks),
|
||||
sys.stdout.flush()
|
||||
block = image[0:esp.ESP_FLASH_BLOCK]
|
||||
block = block + '\xe0' * (esp.ESP_FLASH_BLOCK-len(block))
|
||||
# Fix sflash config data
|
||||
if address == 0 and seq == 0 and block[0] == '\xe9':
|
||||
block = block[0:2] + flash_info + block[4:]
|
||||
# Pad the last block
|
||||
block = block + '\xff' * (esp.ESP_FLASH_BLOCK-len(block))
|
||||
esp.flash_block(block, seq)
|
||||
image = image[esp.ESP_FLASH_BLOCK:]
|
||||
seq += 1
|
||||
|
|
@ -478,6 +590,11 @@ if __name__ == '__main__':
|
|||
for section, start in ((".text", "_text_start"), (".data", "_data_start"), (".rodata", "_rodata_start")):
|
||||
data = e.load_section(section)
|
||||
image.add_segment(e.get_symbol_addr(start), data)
|
||||
|
||||
image.flash_mode = {'qio':0, 'qout':1, 'dio':2, 'dout': 3}[args.flash_mode]
|
||||
image.flash_size_freq = {'4m':0x00, '2m':0x10, '8m':0x20, '16m':0x30, '32m':0x40}[args.flash_size]
|
||||
image.flash_size_freq += {'40m':0, '26m':1, '20m':2, '80m': 0xf}[args.flash_freq]
|
||||
|
||||
image.save(args.output + "0x00000.bin")
|
||||
data = e.load_section(".irom0.text")
|
||||
off = e.get_symbol_addr("_irom0_text_start") - 0x40200000
|
||||
|
|
@ -487,6 +604,17 @@ if __name__ == '__main__':
|
|||
f.close()
|
||||
|
||||
elif args.operation == 'read_mac':
|
||||
mac0 = esp.read_reg(esp.ESP_OTP_MAC0)
|
||||
mac1 = esp.read_reg(esp.ESP_OTP_MAC1)
|
||||
print 'MAC: 18:fe:34:%02x:%02x:%02x' % ((mac1 >> 8) & 0xff, mac1 & 0xff, (mac0 >> 24) & 0xff)
|
||||
mac = esp.read_mac()
|
||||
print 'MAC: %s' % ':'.join(map(lambda x: '%02x'%x, mac))
|
||||
|
||||
elif args.operation == 'flash_id':
|
||||
flash_id = esp.flash_id()
|
||||
print 'Manufacturer: %02x' % (flash_id & 0xff)
|
||||
print 'Device: %02x%02x' % ((flash_id >> 8) & 0xff, (flash_id >> 16) & 0xff)
|
||||
|
||||
elif args.operation == 'read_flash':
|
||||
print 'Please wait...'
|
||||
file(args.filename, 'wb').write(esp.flash_read(args.address, 1024, int(math.ceil(args.size / 1024.)))[:args.size])
|
||||
|
||||
elif args.operation == 'erase_flash':
|
||||
esp.flash_erase()
|
||||
|
|
|
|||
Loading…
Reference in New Issue