Merge branch 'dev' of https://github.com/nodemcu/nodemcu-firmware

README.md

@@ -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( host, port, secure, auto_reconnect, function(client) )
-m:connect("192.168.11.118", 1880, 0, function(conn) print("connected") end)
+-- 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
 
 ```

app/cjson/strbuf.c

@@ -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;

app/include/user_version.h

@@ -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__ */

app/libc/c_stdio.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_malloc os_malloc
-#define c_zalloc os_zalloc
+// #define c_zalloc os_zalloc
-#define c_free os_free
+// #define c_free os_free
 
 extern void output_redirect(const char *str);
 #define c_puts output_redirect

app/libc/c_stdlib.h

@@ -29,9 +29,9 @@
 #define os_realloc(p, s) mem_realloc((p), (s))
 #endif
 
-// #define c_free os_free
+#define c_free os_free
-// #define c_malloc os_malloc
+#define c_malloc os_malloc
-// #define c_zalloc os_zalloc
+#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_malloc(size_t __size);
-void *c_zalloc(size_t __size);
+// void *c_zalloc(size_t __size);
-void c_free(void *);
+// void c_free(void *);
 
 // int	c_rand(void);
 // void c_srand(unsigned int __seed);

app/modules/adc.c

@@ -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

app/modules/node.c

@@ -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 )
+// static int node_readvdd33( lua_State* L )
-{
+// {
-  uint32_t vdd33 = readvdd33();
+//   uint32_t vdd33 = readvdd33();
-  lua_pushinteger(L, vdd33);
+//   lua_pushinteger(L, vdd33);
-  return 1;
+//   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 ) },

app/modules/u8g.c

@@ -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;

app/mqtt/mqtt_msg.c

@@ -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);

app/mqtt/msg_queue.c

@@ -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;
+}

app/mqtt/msg_queue.h

@@ -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

app/platform/flash_api.c

@@ -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))) &&
+    if ((SPI_FLASH_RESULT_OK == flash_safe_erase_sector((flash_safe_get_sec_num() - 2))) &&
-            (SPI_FLASH_RESULT_OK == flash_safe_erase_sector((flash_rom_get_sec_num() - 1))))
+            (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))))

app/smart/smart.c

@@ -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;
   }

app/smart/smart.h

@@ -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;

app/spiffs/spiffs_nucleus.h

@@ -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;

examples/fragment.lua

@@ -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()

examples/init.lua

@@ -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)

examples/user.lua

@@ -0,0 +1 @@
+print("hello NodeMCU")

ld/eagle.app.v6.ld

@@ -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

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'
+        buf = '\xc0'+(packet.replace('\xdb','\xdb\xdd').replace('\xc0','\xdb\xdc'))+'\xc0'
-        for b in packet:
-            if b == '\xc0':
-                buf += '\xdb\xdc'
-            elif b == '\xdb':
-                buf += '\xdb\xdd'
-            else:
-                buf += b
-        buf += '\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)
+        mac = esp.read_mac()
-        mac1 = esp.read_reg(esp.ESP_OTP_MAC1)
+        print 'MAC: %s' % ':'.join(map(lambda x: '%02x'%x, mac))
-        print 'MAC: 18:fe:34:%02x:%02x:%02x' % ((mac1 >> 8) & 0xff, mac1 & 0xff, (mac0 >> 24) & 0xff)
+
+    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()