massive rework of MQTT

Makefile

@@ -147,7 +147,7 @@ MODULES		= espfs httpd user serial cmd mqtt esp-link
 EXTRA_INCDIR	= include .
 
 # libraries used in this project, mainly provided by the SDK
-LIBS		= c gcc hal phy pp net80211 wpa main lwip
+LIBS		= c gcc hal phy pp net80211 wpa main lwip # crypto ssl
 
 # compiler flags using during compilation of source files
 CFLAGS		= -Os -ggdb -std=c99 -Werror -Wpointer-arith -Wundef -Wall -Wl,-EL -fno-inline-functions \

cmd/handlers.c

@@ -95,7 +95,7 @@ cmdCallback* ICACHE_FLASH_ATTR
 CMD_GetCbByName(char* name) {
   char checkname[16];
   os_strncpy(checkname, name, sizeof(checkname));
-  for (uint8_t i = 0; i < sizeof(commands); i++) {
+  for (uint8_t i = 0; i < MAX_CALLBACKS; i++) {
     //os_printf("CMD_GetCbByName: index %d name=%s cb=%p\n", i, callbacks[i].name,
     //  (void *)callbacks[i].callback);
     // if callback doesn't exist or it's null

cmd/mqtt_cmd.c

@@ -1,3 +1,5 @@
+#include <esp8266.h>
+#include "mqtt.h"
 #include "mqtt_cmd.h"
 
 uint32_t connectedCb = 0, disconnectCb = 0, tcpDisconnectedCb = 0, publishedCb = 0, dataCb = 0;
@@ -65,10 +67,12 @@ MQTTCMD_Setup(CmdPacket *cmd) {
   // create mqtt client
   uint8_t clientLen = sizeof(MQTT_Client);
   MQTT_Client* client = (MQTT_Client*)os_zalloc(clientLen);
-  if (client == NULL)
+  if (client == NULL) return 0;
-    return 0;
   os_memset(client, 0, clientLen);
 
+  return 0;
+#if 0
+
   uint16_t len;
   uint8_t *client_id, *user_data, *pass_data;
   uint32_t keepalive, clean_session, cb_data;
@@ -136,6 +140,7 @@ MQTTCMD_Setup(CmdPacket *cmd) {
   os_free(pass_data);
 
   return (uint32_t)client;
+#endif
 }
 
 uint32_t ICACHE_FLASH_ATTR
@@ -217,7 +222,7 @@ MQTTCMD_Connect(CmdPacket *cmd) {
   // get security
   CMD_PopArg(&req, (uint8_t*)&client->security, 4);
 
-  os_printf("MQTT: MQTTCMD_Connect host=%s, port=%ld, security=%d\n",
+  os_printf("MQTT: MQTTCMD_Connect host=%s, port=%d, security=%d\n",
     client->host,
     client->port,
     client->security);

cmd/mqtt_cmd.h

@@ -2,7 +2,6 @@
 #define MODULES_MQTT_CMD_H_
 
 #include "cmd.h"
-#include "mqtt.h"
 
 typedef struct {
   uint32_t connectedCb;

cmd/rest.c

@@ -154,12 +154,12 @@ rest_dns_found(const char *name, ip_addr_t *ipaddr, void *arg) {
 
   if(client->ip.addr == 0 && ipaddr->addr != 0) {
     os_memcpy(client->pCon->proto.tcp->remote_ip, &ipaddr->addr, 4);
-    //if(client->security){
+#ifdef CLIENT_SSL_ENABLE
-    //  espconn_secure_connect(client->pCon);
+    if(client->security) {
-    //}
+      espconn_secure_connect(client->pCon);
-    //else {
+    } else
+#endif
       espconn_connect(client->pCon);
-    //}
     os_printf("REST: connecting...\n");
   }
 }
@@ -368,6 +368,8 @@ REST_Request(CmdPacket *cmd) {
   }
   os_printf("\n");
 
+  //os_printf("REST request: %s", (char*)client->data);
+
   os_printf("REST: pCon state=%d\n", client->pCon->state);
   client->pCon->state = ESPCONN_NONE;
   espconn_regist_connectcb(client->pCon, tcpclient_connect_cb);

esp-link/main.c

@@ -29,7 +29,7 @@
 #include "log.h"
 #include <gpio.h>
 
-//#define SHOW_HEAP_USE
+#define SHOW_HEAP_USE
 
 //Function that tells the authentication system what users/passwords live on the system.
 //This is disabled in the default build; if you want to try it, enable the authBasic line in
@@ -120,13 +120,16 @@ static char *rst_codes[] = {
 # define VERS_STR(V) VERS_STR_STR(V)
 char* esp_link_version = VERS_STR(VERSION);
 
-//Main routine. Initialize stdout, the I/O, filesystem and the webserver and we're done.
+extern void app_init(void);
+
+// Main routine to initialize esp-link.
 void user_init(void) {
   // get the flash config so we know how to init things
   //configWipe(); // uncomment to reset the config for testing purposes
   bool restoreOk = configRestore();
   // init gpio pin registers
   gpio_init();
+  gpio_output_set(0, 0, 0, (1<<15)); // some people tie it GND, gotta ensure it's disabled
   // init UART
   uart_init(flashConfig.baud_rate, 115200);
   logInit(); // must come after init of uart
@@ -163,6 +166,5 @@ void user_init(void) {
 
   os_printf("** esp-link ready\n");
 
-  // call user_main init
+  app_init();
-  init();
 }

html/console.html

@@ -20,7 +20,7 @@
 <script type="text/javascript">console_url = "/console/text"</script>
 <script src="console.js"></script>
 <script type="text/javascript">
-  var rates = [57600, 115200, 230400, 460800];
+  var rates = [9600, 57600, 115200, 250000];
 
   onLoad(function() {
     fetchText(100, true);

httpd/httpd.c

@@ -521,7 +521,7 @@ static void ICACHE_FLASH_ATTR httpdDisconCb(void *arg) {
 }
 
 // Callback indicating a failure in the connection. "Recon" is probably intended in the sense
-// of "you need to reconnect". Sigh... Note that there is no DiconCb after ReconCb
+// of "you need to reconnect". Sigh... Note that there is no DisconCb after ReconCb
 static void ICACHE_FLASH_ATTR httpdReconCb(void *arg, sint8 err) {
 	debugConn(arg, "httpdReconCb");
 	HttpdConnData *conn = httpdFindConnData(arg);

include/user_config.h

@@ -1,20 +1,4 @@
 #ifndef _USER_CONFIG_H_
 #define _USER_CONFIG_H_
 
-#define MQTT_RECONNECT_TIMEOUT 	5	// seconds
-#define MQTT_BUF_SIZE		1024
-
-#define MQTT_HOST				"10.0.0.220" // "mqtt.yourdomain.com" or ip "10.0.0.1"
-#define MQTT_PORT				1883
-#define MQTT_SECURITY   0
-
-#define MQTT_CLIENT_ID	"esp-link" // ""
-#define MQTT_USER				""
-#define MQTT_PASS				""
-#define MQTT_KEEPALIVE	120	 // seconds
-#define MQTT_CLSESSION	true
-
-#define PROTOCOL_NAMEv31	// MQTT version 3.1 compatible with Mosquitto v0.15
-//PROTOCOL_NAMEv311			// MQTT version 3.11 compatible with https://eclipse.org/paho/clients/testing/
-
 #endif

mqtt/mqtt.h

@@ -27,72 +27,57 @@
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef USER_AT_MQTT_H_
+#ifndef MQTT_H_
-#define USER_AT_MQTT_H_
+#define MQTT_H_
 
-#include <esp8266.h>
 #include "mqtt_msg.h"
-#include "queue.h"
+#include "pktbuf.h"
-#include <rest.h>
 
-typedef struct mqtt_event_data_t {
+// in rest.c
-  uint8_t type;
+uint8_t UTILS_StrToIP(const char* str, void *ip);
-  const char* topic;
-  const char* data;
-  uint16_t topic_length;
-  uint16_t data_length;
-  uint16_t data_offset;
-} mqtt_event_data_t;
-
-typedef struct mqtt_state_t {
-  uint16_t port;
-  int auto_reconnect;
-  mqtt_connect_info_t* connect_info;
-  uint8_t* in_buffer;
-  uint8_t* out_buffer;
-  int in_buffer_length;
-  int out_buffer_length;
-  uint16_t message_length;
-  uint16_t message_length_read;
-  mqtt_message_t* outbound_message;
-  mqtt_connection_t mqtt_connection;
-  uint16_t pending_msg_id;
-  int pending_msg_type;
-  int pending_publish_qos;
-} mqtt_state_t;
 
+// State of MQTT connection
 typedef enum {
-  WIFI_INIT,
+  MQTT_DISCONNECTED,    // we're in disconnected state
-  WIFI_CONNECTING,
+  TCP_RECONNECT_REQ,    // connect failed, needs reconnecting
-  WIFI_CONNECTING_ERROR,
+  TCP_CONNECTING,       // in TCP connection process
-  WIFI_CONNECTED,
+  MQTT_CONNECTED,       // conneted (or connecting)
-  DNS_RESOLVE,
-  TCP_DISCONNECTED,
-  TCP_RECONNECT_REQ,
-  TCP_RECONNECT,
-  TCP_CONNECTING,
-  TCP_CONNECTING_ERROR,
-  TCP_CONNECTED,
-  MQTT_CONNECT_SEND,
-  MQTT_CONNECT_SENDING,
-  MQTT_SUBSCIBE_SEND,
-  MQTT_SUBSCIBE_SENDING,
-  MQTT_DATA,
-  MQTT_PUBLISH_RECV,
-  MQTT_PUBLISHING
 } tConnState;
 
+// Simple notification callback
 typedef void (*MqttCallback)(uint32_t* args);
-typedef void (*MqttDataCallback)(uint32_t* args, const char* topic, uint32_t topic_len, const char* data, uint32_t lengh);
+// Callback with data messge
+typedef void (*MqttDataCallback)(uint32_t* args, const char* topic, uint32_t topic_len,
+    const char* data, uint32_t data_len);
 
+// MQTTY client data structure
 typedef struct {
-  struct espconn* pCon;
+  struct espconn*     pCon;                   // socket
-  uint8_t security;
+  // connection information
-  char* host;
+  char*               host;                   // MQTT server
-  uint32_t port;
+  uint16_t            port;
-  ip_addr_t ip;
+  uint8_t             security;               // 0=tcp, 1=ssl
-  mqtt_state_t mqtt_state;
+  ip_addr_t           ip;                     // MQTT server IP address
-  mqtt_connect_info_t connect_info;
+  mqtt_connect_info_t connect_info;           // info to connect/reconnect
+  // protocol state and message assembly
+  tConnState          connState;              // connection state
+  bool                sending;                // espconn_send is pending
+  mqtt_connection_t   mqtt_connection;        // message assembly descriptor
+  PktBuf*             msgQueue;               // queued outbound messages
+  // TCP input buffer
+  uint8_t*            in_buffer;
+  int                 in_buffer_size;         // length allocated
+  int                 in_buffer_filled;       // number of bytes held
+  // outstanding message when we expect an ACK
+  PktBuf*             pending_buffer;         // buffer sent and awaiting ACK
+  PktBuf*             sending_buffer;         // buffer sent not awaiting ACK
+  // timer and associated timeout counters
+  ETSTimer            mqttTimer;              // timer for this connection
+  uint8_t             keepAliveTick;          // seconds 'til keep-alive is required (0=no k-a)
+  uint8_t             keepAliveAckTick;       // seconds 'til keep-alive ack is overdue (0=no k-a)
+  uint8_t             timeoutTick;            // seconds 'til other timeout
+  uint8_t             sendTimeout;            // value of send timeout setting
+  // callbacks
   MqttCallback        connectedCb;
   MqttCallback        cmdConnectedCb;
   MqttCallback        disconnectedCb;
@@ -103,42 +88,40 @@ typedef struct {
   MqttCallback        cmdPublishedCb;
   MqttDataCallback    dataCb;
   MqttDataCallback    cmdDataCb;
-  ETSTimer mqttTimer;
+  // misc
-  uint32_t keepAliveTick;
-  uint32_t reconnectTick;
-  uint32_t sendTimeout;
-  tConnState connState;
-  QUEUE msgQueue;
   void*               user_data;
 } MQTT_Client;
 
-#define SEC_NONSSL 0
+// Initialize client data structure
-#define SEC_SSL	1
+void MQTT_Init(MQTT_Client* mqttClient, char* host, uint32 port,
+    uint8_t security, uint8_t sendTimeout,
+    char* client_id, char* client_user, char* client_pass,
+    uint8_t keepAliveTime, uint8_t cleanSession);
+
+// Set Last Will Topic on client, must be called before MQTT_InitConnection
+void MQTT_InitLWT(MQTT_Client* mqttClient, char* will_topic, char* will_msg,
+    uint8_t will_qos, uint8_t will_retain);
+
+// Kick of a persistent connection to the broker, will reconnect anytime conn breaks
+void MQTT_Connect(MQTT_Client* mqttClient);
+
+// Kill persistent connection
+void MQTT_Disconnect(MQTT_Client* mqttClient);
 
-#define MQTT_FLAG_CONNECTED 	1
+// Subscribe to a topic
-#define MQTT_FLAG_READY 		2
+bool MQTT_Subscribe(MQTT_Client* client, char* topic, uint8_t qos);
-#define MQTT_FLAG_EXIT 			4
 
-#define MQTT_EVENT_TYPE_NONE 			0
+// Publish a message
-#define MQTT_EVENT_TYPE_CONNECTED 		1
+bool MQTT_Publish(MQTT_Client* client, const char* topic, const char* data,
-#define MQTT_EVENT_TYPE_DISCONNECTED 	2
+    uint8_t qos, uint8_t retain);
-#define MQTT_EVENT_TYPE_SUBSCRIBED 		3
-#define MQTT_EVENT_TYPE_UNSUBSCRIBED 	4
-#define MQTT_EVENT_TYPE_PUBLISH 		5
-#define MQTT_EVENT_TYPE_PUBLISHED 		6
-#define MQTT_EVENT_TYPE_EXITED 			7
-#define MQTT_EVENT_TYPE_PUBLISH_CONTINUATION 8
 
-void MQTT_InitConnection(MQTT_Client* mqttClient, char* host, uint32 port, uint8_t security);
+// Callback when connected
-void MQTT_InitClient(MQTT_Client* mqttClient, char* client_id, char* client_user, char* client_pass, uint8_t keepAliveTime, uint8_t cleanSession);
-void MQTT_InitLWT(MQTT_Client* mqttClient, char* will_topic, char* will_msg, uint8_t will_qos, uint8_t will_retain);
 void MQTT_OnConnected(MQTT_Client* mqttClient, MqttCallback connectedCb);
+// Callback when disconnected
 void MQTT_OnDisconnected(MQTT_Client* mqttClient, MqttCallback disconnectedCb);
+// Callback when publish succeeded
 void MQTT_OnPublished(MQTT_Client* mqttClient, MqttCallback publishedCb);
+// Callback when data arrives for subscription
 void MQTT_OnData(MQTT_Client* mqttClient, MqttDataCallback dataCb);
-bool MQTT_Subscribe(MQTT_Client* client, char* topic, uint8_t qos);
-void MQTT_Connect(MQTT_Client* mqttClient);
-void MQTT_Disconnect(MQTT_Client* mqttClient);
-bool MQTT_Publish(MQTT_Client* client, const char* topic, const char* data, uint8_t qos, uint8_t retain);
 
 #endif /* USER_AT_MQTT_H_ */

mqtt/mqtt_msg.c

@@ -29,6 +29,7 @@
 *
 */
 
+#include <esp8266.h>
 #include "mqtt_msg.h"
 #define MQTT_MAX_FIXED_HEADER_SIZE 3
 
@@ -129,7 +130,7 @@ mqtt_msg_init(mqtt_connection_t* connection, uint8_t* buffer, uint16_t buffer_le
 }
 
 int ICACHE_FLASH_ATTR
-mqtt_get_total_length(uint8_t* buffer, uint16_t length) {
+mqtt_get_total_length(const uint8_t* buffer, uint16_t length) {
   int i;
   int totlen = 0;
 
@@ -146,7 +147,7 @@ mqtt_get_total_length(uint8_t* buffer, uint16_t length) {
 }
 
 const char* ICACHE_FLASH_ATTR
-mqtt_get_publish_topic(uint8_t* buffer, uint16_t* length) {
+mqtt_get_publish_topic(const uint8_t* buffer, uint16_t* length) {
   int i;
   int totlen = 0;
   int topiclen;
@@ -173,7 +174,7 @@ mqtt_get_publish_topic(uint8_t* buffer, uint16_t* length) {
 }
 
 const char* ICACHE_FLASH_ATTR
-mqtt_get_publish_data(uint8_t* buffer, uint16_t* length) {
+mqtt_get_publish_data(const uint8_t* buffer, uint16_t* length) {
   int i;
   int totlen = 0;
   int topiclen;
@@ -215,7 +216,7 @@ mqtt_get_publish_data(uint8_t* buffer, uint16_t* length) {
 }
 
 uint16_t ICACHE_FLASH_ATTR
-mqtt_get_id(uint8_t* buffer, uint16_t length) {
+mqtt_get_id(const uint8_t* buffer, uint16_t length) {
   if (length < 1)
     return 0;
 

mqtt/mqtt_msg.h

@@ -31,7 +31,8 @@
 
 #ifndef MQTT_MSG_H
 #define MQTT_MSG_H
-#include <esp8266.h>
+
+#define PROTOCOL_NAMEv311
 
 enum mqtt_message_type {
   MQTT_MSG_TYPE_CONNECT = 1,
@@ -50,21 +51,22 @@ enum mqtt_message_type {
   MQTT_MSG_TYPE_DISCONNECT = 14
 };
 
+// Descriptor for a serialized MQTT message, this is returned by functions that compose a message
+// (It's really an MQTT packet in v3.1.1 terminology)
 typedef struct mqtt_message {
   uint8_t* data;
   uint16_t length;
-
 } mqtt_message_t;
 
+// Descriptor for a connection with message assembly storage
 typedef struct mqtt_connection {
-  mqtt_message_t message;
+  mqtt_message_t message; // resulting message
-
+  uint16_t message_id;	  // id of assembled message and memo to calculate next message id
-  uint16_t message_id;
+  uint8_t* buffer;	  // buffer for assembling messages
-  uint8_t* buffer;
+  uint16_t buffer_length; // buffer length
-  uint16_t buffer_length;
-
 } mqtt_connection_t;
 
+// Descriptor for a connect request
 typedef struct mqtt_connect_info {
   char* client_id;
   char* username;
@@ -75,32 +77,40 @@ typedef struct mqtt_connect_info {
   uint8_t will_qos;
   uint8_t will_retain;
   uint8_t clean_session;
-
 } mqtt_connect_info_t;
 
-
+static inline int ICACHE_FLASH_ATTR mqtt_get_type(const uint8_t* buffer) {
-static inline int ICACHE_FLASH_ATTR mqtt_get_type(uint8_t* buffer) {
   return (buffer[0] & 0xf0) >> 4;
 }
 
-static inline int ICACHE_FLASH_ATTR mqtt_get_dup(uint8_t* buffer) {
+static inline int ICACHE_FLASH_ATTR mqtt_get_dup(const uint8_t* buffer) {
   return (buffer[0] & 0x08) >> 3;
 }
 
-static inline int ICACHE_FLASH_ATTR mqtt_get_qos(uint8_t* buffer) {
+static inline int ICACHE_FLASH_ATTR mqtt_get_qos(const uint8_t* buffer) {
   return (buffer[0] & 0x06) >> 1;
 }
 
-static inline int ICACHE_FLASH_ATTR mqtt_get_retain(uint8_t* buffer) {
+static inline int ICACHE_FLASH_ATTR mqtt_get_retain(const uint8_t* buffer) {
   return (buffer[0] & 0x01);
 }
 
+// Init a connection descriptor
 void mqtt_msg_init(mqtt_connection_t* connection, uint8_t* buffer, uint16_t buffer_length);
-int mqtt_get_total_length(uint8_t* buffer, uint16_t length);
-const char* mqtt_get_publish_topic(uint8_t* buffer, uint16_t* length);
-const char* mqtt_get_publish_data(uint8_t* buffer, uint16_t* length);
-uint16_t mqtt_get_id(uint8_t* buffer, uint16_t length);
 
+// Returns the total length of a message including MQTT fixed header
+int mqtt_get_total_length(const uint8_t* buffer, uint16_t length);
+
+// Return pointer to topic, length in in/out param: in=length of buffer, out=length of topic
+const char* mqtt_get_publish_topic(const uint8_t* buffer, uint16_t* length);
+
+// Return pointer to data, length in in/out param: in=length of buffer, out=length of data
+const char* mqtt_get_publish_data(const uint8_t* buffer, uint16_t* length);
+
+// Return message id
+uint16_t mqtt_get_id(const uint8_t* buffer, uint16_t length);
+
+// The following functions construct an outgoing message
 mqtt_message_t* mqtt_msg_connect(mqtt_connection_t* connection, mqtt_connect_info_t* info);
 mqtt_message_t* mqtt_msg_publish(mqtt_connection_t* connection, const char* topic, const char* data, int data_length, int qos, int retain, uint16_t* message_id);
 mqtt_message_t* mqtt_msg_puback(mqtt_connection_t* connection, uint16_t message_id);

mqtt/pktbuf.c

@@ -0,0 +1,64 @@
+// Copyright 2015 by Thorsten von Eicken, see LICENSE.txt
+
+#include <esp8266.h>
+#include "pktbuf.h"
+
+void ICACHE_FLASH_ATTR
+PktBuf_Print(PktBuf *buf) {
+  os_printf("PktBuf:");
+  for (int i=-16; i<0; i++)
+    os_printf(" %02X", ((uint8_t*)buf)[i]);
+  os_printf(" %p", buf);
+  for (int i=0; i<16; i++)
+    os_printf(" %02X", ((uint8_t*)buf)[i]);
+  os_printf("\n");
+  os_printf("PktBuf: next=%p len=0x%04x\n",
+      ((void**)buf)[-4], ((uint16_t*)buf)[-6]);
+}
+
+
+PktBuf * ICACHE_FLASH_ATTR
+PktBuf_New(uint16_t length) {
+  PktBuf *buf = os_zalloc(length+sizeof(PktBuf));
+  buf->next = NULL;
+  buf->filled = 0;
+  //os_printf("PktBuf_New: %p l=%d->%d d=%p\n",
+  //    buf, length, length+sizeof(PktBuf), buf->data);
+  return buf;
+}
+
+PktBuf * ICACHE_FLASH_ATTR
+PktBuf_Push(PktBuf *headBuf, PktBuf *buf) {
+  if (headBuf == NULL) {
+    //os_printf("PktBuf_Push: %p\n", buf);
+    return buf;
+  }
+  PktBuf *h = headBuf;
+  while (h->next != NULL) h = h->next;
+  h->next = buf;
+  //os_printf("PktBuf_Push: %p->..->%p\n", headBuf, buf);
+  return headBuf;
+}
+
+PktBuf * ICACHE_FLASH_ATTR
+PktBuf_Unshift(PktBuf *headBuf, PktBuf *buf) {
+  buf->next = headBuf;
+  //os_printf("PktBuf_Unshift: %p->%p\n", buf, buf->next);
+  return buf;
+}
+
+PktBuf * ICACHE_FLASH_ATTR
+PktBuf_Shift(PktBuf *headBuf) {
+  PktBuf *buf = headBuf->next;
+  headBuf->next = NULL;
+  //os_printf("PktBuf_Shift: (%p)->%p\n", headBuf, buf);
+  return buf;
+}
+
+PktBuf * ICACHE_FLASH_ATTR
+PktBuf_ShiftFree(PktBuf *headBuf) {
+  PktBuf *buf = headBuf->next;
+  //os_printf("PktBuf_ShiftFree: (%p)->%p\n", headBuf, buf);
+  os_free(headBuf);
+  return buf;
+}

mqtt/pktbuf.h

@@ -0,0 +1,29 @@
+// Copyright 2015 by Thorsten von Eicken, see LICENSE.txt
+
+#ifndef PKTBUF_H
+#define PKTBUF_H
+
+typedef struct PktBuf {
+  struct PktBuf *next;   // next buffer in chain
+  uint16_t      filled;  // number of bytes filled in buffer
+  uint8_t       data[0]; // data in buffer
+} PktBuf;
+
+// Allocate a new packet buffer of given length
+PktBuf *PktBuf_New(uint16_t length);
+
+// Append a buffer to the end of a packet buffer queue, returns new head
+PktBuf *PktBuf_Push(PktBuf *headBuf, PktBuf *buf);
+
+// Prepend a buffer to the beginning of a packet buffer queue, return new head
+PktBuf * PktBuf_Unshift(PktBuf *headBuf, PktBuf *buf);
+
+// Shift first buffer off queue, returns new head (not shifted buffer!)
+PktBuf *PktBuf_Shift(PktBuf *headBuf);
+
+// Shift first buffer off queue, free it, return new head
+PktBuf *PktBuf_ShiftFree(PktBuf *headBuf);
+
+void PktBuf_Print(PktBuf *buf);
+
+#endif

mqtt/proto.c

@@ -1,86 +0,0 @@
-#include "proto.h"
-
-int8_t ICACHE_FLASH_ATTR 
-PROTO_Init(PROTO_PARSER* parser, PROTO_PARSE_CALLBACK* completeCallback, uint8_t* buf, uint16_t bufSize) {
-  parser->buf = buf;
-  parser->bufSize = bufSize;
-  parser->dataLen = 0;
-  parser->callback = completeCallback;
-  parser->isEsc = 0;
-  return 0;
-}
-
-int8_t ICACHE_FLASH_ATTR 
-PROTO_ParseByte(PROTO_PARSER* parser, uint8_t value) {
-  switch (value) {
-    case 0x7D:
-      parser->isEsc = 1;
-      break;
-
-    case 0x7E:
-      parser->dataLen = 0;
-      parser->isEsc = 0;
-      parser->isBegin = 1;
-      break;
-
-    case 0x7F:
-      if (parser->callback != NULL)
-        parser->callback();
-      parser->isBegin = 0;
-      return 0;
-      break;
-
-    default:
-      if (parser->isBegin == 0) break;
-
-      if (parser->isEsc) {
-        value ^= 0x20;
-        parser->isEsc = 0;
-      }
-
-      if (parser->dataLen < parser->bufSize)
-        parser->buf[parser->dataLen++] = value;
-
-      break;
-  }
-  return -1;
-}
-
-int16_t ICACHE_FLASH_ATTR 
-PROTO_ParseRb(RINGBUF* rb, uint8_t* bufOut, uint16_t* len, uint16_t maxBufLen) {
-  uint8_t c;
-
-  PROTO_PARSER proto;
-  PROTO_Init(&proto, NULL, bufOut, maxBufLen);
-  while (RINGBUF_Get(rb, &c) == 0) {
-    if (PROTO_ParseByte(&proto, c) == 0) {
-      *len = proto.dataLen;
-      return 0;
-    }
-  }
-  return -1;
-}
-
-int16_t ICACHE_FLASH_ATTR 
-PROTO_AddRb(RINGBUF* rb, const uint8_t* packet, int16_t len) {
-  uint16_t i = 2;
-  if (RINGBUF_Put(rb, 0x7E) == -1) return -1;
-  while (len--) {
-    switch (*packet) {
-      case 0x7D:
-      case 0x7E:
-      case 0x7F:
-        if (RINGBUF_Put(rb, 0x7D) == -1) return -1;
-        if (RINGBUF_Put(rb, *packet++ ^ 0x20) == -1) return -1;
-        i += 2;
-        break;
-      default:
-        if (RINGBUF_Put(rb, *packet++) == -1) return -1;
-        i++;
-        break;
-    }
-  }
-  if (RINGBUF_Put(rb, 0x7F) == -1) return -1;
-
-  return i;
-}

mqtt/proto.h

@@ -1,21 +0,0 @@
-#ifndef _PROTO_H_
-#define	_PROTO_H_
-#include <esp8266.h>
-#include "ringbuf.h"
-
-typedef void (PROTO_PARSE_CALLBACK)();
-
-typedef struct {
-  uint8_t* buf;
-  uint16_t bufSize;
-  uint16_t dataLen;
-  uint8_t isEsc;
-  uint8_t isBegin;
-  PROTO_PARSE_CALLBACK* callback;
-} PROTO_PARSER;
-
-int8_t PROTO_Init(PROTO_PARSER* parser, PROTO_PARSE_CALLBACK* completeCallback, uint8_t* buf, uint16_t bufSize);
-int16_t PROTO_AddRb(RINGBUF* rb, const uint8_t* packet, int16_t len);
-int8_t PROTO_ParseByte(PROTO_PARSER* parser, uint8_t value);
-int16_t PROTO_ParseRb(RINGBUF* rb, uint8_t* bufOut, uint16_t* len, uint16_t maxBufLen);
-#endif

mqtt/queue.c

@@ -1,53 +0,0 @@
-/* str_queue.c
-*
-* Copyright (c) 2014-2015, Tuan PM <tuanpm at live dot com>
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following conditions are met:
-*
-* * Redistributions of source code must retain the above copyright notice,
-* this list of conditions and the following disclaimer.
-* * Redistributions in binary form must reproduce the above copyright
-* notice, this list of conditions and the following disclaimer in the
-* documentation and/or other materials provided with the distribution.
-* * Neither the name of Redis nor the names of its contributors may be used
-* to endorse or promote products derived from this software without
-* specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-* POSSIBILITY OF SUCH DAMAGE.
-*/
-#include "queue.h"
-
-void ICACHE_FLASH_ATTR 
-QUEUE_Init(QUEUE* queue, int bufferSize) {
-  queue->buf = (uint8_t*)os_zalloc(bufferSize);
-  RINGBUF_Init(&queue->rb, queue->buf, bufferSize);
-}
-
-int32_t ICACHE_FLASH_ATTR 
-QUEUE_Puts(QUEUE* queue, uint8_t* buffer, uint16_t len) {
-  return PROTO_AddRb(&queue->rb, buffer, len);
-}
-
-int32_t ICACHE_FLASH_ATTR 
-QUEUE_Gets(QUEUE* queue, uint8_t* buffer, uint16_t* len, uint16_t maxLen) {
-  return PROTO_ParseRb(&queue->rb, buffer, len, maxLen);
-}
-
-bool ICACHE_FLASH_ATTR 
-QUEUE_IsEmpty(QUEUE* queue) {
-  if (queue->rb.fill_cnt <= 0)
-    return TRUE;
-  return FALSE;
-}

mqtt/queue.h

@@ -1,46 +0,0 @@
-/* str_queue.h --
-*
-* Copyright (c) 2014-2015, Tuan PM <tuanpm at live dot com>
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following conditions are met:
-*
-* * Redistributions of source code must retain the above copyright notice,
-* this list of conditions and the following disclaimer.
-* * Redistributions in binary form must reproduce the above copyright
-* notice, this list of conditions and the following disclaimer in the
-* documentation and/or other materials provided with the distribution.
-* * Neither the name of Redis nor the names of its contributors may be used
-* to endorse or promote products derived from this software without
-* specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-* POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef USER_QUEUE_H_
-#define USER_QUEUE_H_
-#include <esp8266.h>
-#include "proto.h"
-#include "ringbuf.h"
-
-typedef struct {
-  uint8_t* buf;
-  RINGBUF rb;
-} QUEUE;
-
-void QUEUE_Init(QUEUE* queue, int bufferSize);
-int32_t QUEUE_Puts(QUEUE* queue, uint8_t* buffer, uint16_t len);
-int32_t QUEUE_Gets(QUEUE* queue, uint8_t* buffer, uint16_t* len, uint16_t maxLen);
-bool QUEUE_IsEmpty(QUEUE* queue);
-#endif /* USER_QUEUE_H_ */

mqtt/ringbuf.c

@@ -1,63 +0,0 @@
-#include "ringbuf.h"
-
-/**
-* \brief init a RINGBUF object
-* \param r pointer to a RINGBUF object
-* \param buf pointer to a byte array
-* \param size size of buf
-* \return 0 if successfull, otherwise failed
-*/
-int16_t ICACHE_FLASH_ATTR 
-RINGBUF_Init(RINGBUF* r, uint8_t* buf, int32_t size) {
-  if (r == NULL || buf == NULL || size < 2) return -1;
-
-  r->p_o = r->p_r = r->p_w = buf;
-  r->fill_cnt = 0;
-  r->size = size;
-
-  return 0;
-}
-
-/**
-* \brief put a character into ring buffer
-* \param r pointer to a ringbuf object
-* \param c character to be put
-* \return 0 if successfull, otherwise failed
-*/
-int16_t ICACHE_FLASH_ATTR 
-RINGBUF_Put(RINGBUF* r, uint8_t c) {
-  if (r->fill_cnt >= r->size)return -1; // ring buffer is full, this should be atomic operation
-
-
-  r->fill_cnt++; // increase filled slots count, this should be atomic operation
-
-
-  *r->p_w++ = c; // put character into buffer
-
-  if (r->p_w >= r->p_o + r->size) // rollback if write pointer go pass
-    r->p_w = r->p_o; // the physical boundary
-
-  return 0;
-}
-
-/**
-* \brief get a character from ring buffer
-* \param r pointer to a ringbuf object
-* \param c read character
-* \return 0 if successfull, otherwise failed
-*/
-int16_t ICACHE_FLASH_ATTR 
-RINGBUF_Get(RINGBUF* r, uint8_t* c) {
-  if (r->fill_cnt <= 0)return -1; // ring buffer is empty, this should be atomic operation
-
-
-  r->fill_cnt--; // decrease filled slots count
-
-
-  *c = *r->p_r++; // get the character out
-
-  if (r->p_r >= r->p_o + r->size) // rollback if write pointer go pass
-    r->p_r = r->p_o; // the physical boundary
-
-  return 0;
-}

mqtt/ringbuf.h

@@ -1,17 +0,0 @@
-#ifndef _RING_BUF_H_
-#define _RING_BUF_H_
-
-#include <esp8266.h>
-
-typedef struct {
-  uint8_t* p_o; /**< Original pointer */
-  uint8_t* volatile p_r; /**< Read pointer */
-  uint8_t* volatile p_w; /**< Write pointer */
-  volatile int32_t fill_cnt; /**< Number of filled slots */
-  int32_t size; /**< Buffer size */
-} RINGBUF;
-
-int16_t RINGBUF_Init(RINGBUF* r, uint8_t* buf, int32_t size);
-int16_t RINGBUF_Put(RINGBUF* r, uint8_t c);
-int16_t RINGBUF_Get(RINGBUF* r, uint8_t* c);
-#endif

serial/serbridge.c

@@ -273,6 +273,7 @@ serbridgeSentCb(void *arg) {
 
 // Error callback (it's really poorly named, it's not a "connection reconnected" callback,
 // it's really a "connection broken, please reconnect" callback)
+// Note that there is no DisconCb after a ReconCb
 static void ICACHE_FLASH_ATTR serbridgeReconCb(void *arg, sint8 err) {
   serbridgeConnData *sbConn = serbridgeFindConnData(arg);
   if (sbConn == NULL) return;

serial/serled.h

@@ -6,4 +6,3 @@ void serledInit(void);
 void makeGpio(uint8_t pin);
 
 #endif
-

serial/uart.c

@@ -23,7 +23,7 @@
 #include "user_interface.h"
 #include "uart.h"
 
-#define recvTaskPrio        0
+#define recvTaskPrio        1
 #define recvTaskQueueLen    64
 
 // UartDev is defined and initialized in rom code.

user/user_main.c

@@ -1,9 +1,39 @@
 #include <esp8266.h>
-#include <mqtt.h>
+#include "cgiwifi.h"
-#include <cgiwifi.h>
+#include "mqtt.h"
 
 MQTT_Client mqttClient;
 
+static ETSTimer mqttTimer;
+
+static int once = 0;
+static void ICACHE_FLASH_ATTR mqttTimerCb(void *arg) {
+  if (once++ > 0) return;
+  MQTT_Init(&mqttClient, "h.voneicken.com", 1883, 0, 2, "test1", "", "", 10, 1);
+  MQTT_Connect(&mqttClient);
+  MQTT_Subscribe(&mqttClient, "system/time", 0);
+}
+
+void ICACHE_FLASH_ATTR
+wifiStateChangeCb(uint8_t status)
+{
+  if (status == wifiGotIP) {
+    os_timer_disarm(&mqttTimer);
+    os_timer_setfn(&mqttTimer, mqttTimerCb, NULL);
+    os_timer_arm(&mqttTimer, 15000, 0);
+  }
+}
+
+
+// initialize the custom stuff that goes beyond esp-link
+void app_init() {
+  wifiAddStateChangeCb(wifiStateChangeCb);
+}
+
+
+#if 0
+MQTT_Client mqttClient;
+
 void ICACHE_FLASH_ATTR
 mqttConnectedCb(uint32_t *args) {
   MQTT_Client* client = (MQTT_Client*)args;
@@ -46,19 +76,6 @@ mqttDataCb(uint32_t *args, const char* topic, uint32_t topic_len, const char *da
   os_free(dataBuf);
 }
 
-void ICACHE_FLASH_ATTR 
-wifiStateChangeCb(uint8_t status)
-{
-  if (status == wifiGotIP  && mqttClient.connState != TCP_CONNECTING){
-    MQTT_Connect(&mqttClient);
-  }
-  else if (status == wifiIsDisconnected && mqttClient.connState == TCP_CONNECTING){    
-    MQTT_Disconnect(&mqttClient);
-  }
-}
-
-void init() {
-  wifiAddStateChangeCb(wifiStateChangeCb);
   MQTT_InitConnection(&mqttClient, MQTT_HOST, MQTT_PORT, MQTT_SECURITY);
   MQTT_InitClient(&mqttClient, MQTT_CLIENT_ID, MQTT_USER, MQTT_PASS, MQTT_KEEPALIVE, MQTT_CLSESSION);
   MQTT_InitLWT(&mqttClient, "/lwt", "offline", 0, 0);
@@ -67,4 +84,4 @@ void init() {
   MQTT_OnDisconnected(&mqttClient, mqttTcpDisconnectedCb);
   MQTT_OnPublished(&mqttClient, mqttPublishedCb);
   MQTT_OnData(&mqttClient, mqttDataCb);
-}
+#endif