Merge branch 'dev' of https://github.com/nodemcu/nodemcu-firmware
This commit is contained in:
HuangRui
commit
fc3ad90136
|
|
@ -225,8 +225,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 +237,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 reconnect.
|
||||
-- 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 20150331"
|
||||
|
||||
#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);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
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 ) },
|
||||
|
|
|
|||
|
|
@ -916,7 +916,7 @@ uint8_t u8g_com_esp8266_ssd_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, voi
|
|||
case U8G_COM_MSG_WRITE_BYTE:
|
||||
//u8g->pin_list[U8G_PI_SET_A0] = 1;
|
||||
if ( u8g_com_esp8266_ssd_start_sequence(u8g) == 0 )
|
||||
return platform_i2c_stop( ESP_I2C_ID ), 0;
|
||||
return platform_i2c_send_stop( ESP_I2C_ID ), 0;
|
||||
// ignore return value -> tolerate missing ACK
|
||||
if ( platform_i2c_send_byte( ESP_I2C_ID, arg_val) == 0 )
|
||||
; //return platform_i2c_send_stop( ESP_I2C_ID ), 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,60 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
#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);
|
||||
|
||||
#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))))
|
||||
|
|
|
|||
|
|
@ -127,11 +127,19 @@ int smart_check(uint8_t *nibble, uint16_t len, uint8_t *dst, uint8_t *got){
|
|||
return res;
|
||||
}
|
||||
|
||||
void detect(uint8 *buf, uint16 len){
|
||||
void detect(uint8 *arg, uint16 len){
|
||||
uint16_t seq;
|
||||
int16_t seq_delta = 0;
|
||||
uint16_t byte_num = 0, bit_num = 0;
|
||||
int16_t c = 0;
|
||||
uint8 *buf = NULL;
|
||||
if( len == 12 ){
|
||||
return;
|
||||
} else if (len >= 64){
|
||||
buf = arg + sizeof(struct RxControl);
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
if( ( (buf[0]) & TYPE_SUBTYPE_MASK) != TYPE_SUBTYPE_QOS_DATA){
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -59,6 +59,40 @@ extern "C" {
|
|||
|
||||
#define STATION_CHECK_TIME (2*1000)
|
||||
|
||||
struct RxControl{
|
||||
signed rssi:8;//表示该包的信号强度
|
||||
unsigned rate:4;
|
||||
unsigned is_group:1;
|
||||
unsigned:1;
|
||||
unsigned sig_mode:2;//表示该包是否是11n 的包，0 表示非11n，非0 表示11n
|
||||
unsigned legacy_length:12;//如果不是11n 的包，它表示包的长度
|
||||
unsigned damatch0:1;
|
||||
unsigned damatch1:1;
|
||||
unsigned bssidmatch0:1;
|
||||
unsigned bssidmatch1:1;
|
||||
unsigned MCS:7;//如果是11n 的包，它表示包的调制编码序列，有效值：0-76
|
||||
unsigned CWB:1;//如果是11n 的包，它表示是否为HT40 的包
|
||||
unsigned HT_length:16;//如果是11n 的包，它表示包的长度
|
||||
unsigned Smoothing:1;
|
||||
unsigned Not_Sounding:1;
|
||||
unsigned:1;
|
||||
unsigned Aggregation:1;
|
||||
unsigned STBC:2;
|
||||
unsigned FEC_CODING:1;//如果是11n 的包，它表示是否为LDPC 的包
|
||||
unsigned SGI:1;
|
||||
unsigned rxend_state:8;
|
||||
unsigned ampdu_cnt:8;
|
||||
unsigned channel:4;//表示该包所在的信道
|
||||
unsigned:12;
|
||||
};
|
||||
|
||||
struct sniffer_buf{
|
||||
struct RxControl rx_ctrl; // 12-bytes
|
||||
u8 buf[48];//包含ieee80211 包头
|
||||
u16 cnt;//包的个数
|
||||
u16 len[1];//包的长度
|
||||
};
|
||||
|
||||
struct _my_addr_map {
|
||||
uint8 addr[ADDR_LENGTH*3];
|
||||
uint8_t addr_len;
|
||||
|
|
|
|||
|
|
@ -395,13 +395,11 @@ typedef struct __attribute(( packed )) {
|
|||
// common page header
|
||||
spiffs_page_header p_hdr;
|
||||
// alignment
|
||||
u8_t _align[4 - (sizeof(spiffs_page_header)&3)==0 ? 4 : (sizeof(spiffs_page_header)&3)];
|
||||
u8_t _align[4 - ((sizeof(spiffs_page_header)+sizeof(spiffs_obj_type)+SPIFFS_OBJ_NAME_LEN)&3)==0 ? 4 : ((sizeof(spiffs_page_header)+sizeof(spiffs_obj_type)+SPIFFS_OBJ_NAME_LEN)&3)];
|
||||
// size of object
|
||||
u32_t size;
|
||||
// type of object
|
||||
spiffs_obj_type type;
|
||||
// alignment2
|
||||
u8_t _align2[4 - (sizeof(spiffs_obj_type)&3)==0 ? 4 : (sizeof(spiffs_obj_type)&3)];
|
||||
// name of object
|
||||
u8_t name[SPIFFS_OBJ_NAME_LEN];
|
||||
} spiffs_page_object_ix_header;
|
||||
|
|
|
|||
|
|
@ -381,3 +381,72 @@ 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",2,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()
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
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