[esp8266] Added mechanism for handling out-of-band AT commands

Out-of-band AT commands from device are handled and buffered via
callback. Adopted in ESP8266.

Fixes #348

Author: geky

ESP8266/ATParser/ATParser.cpp

@@ -237,6 +237,19 @@ bool ATParser::vrecv(const char *response, va_list args)
             _buffer[offset + j++] = c;
             _buffer[offset + j] = 0;
 
+            // Check for oob data
+            for (int k = 0; k < _oobs.size(); k++) {
+                if (j == _oobs[k].len && memcmp(
+                        _oobs[k].prefix, _buffer+offset, _oobs[k].len) == 0) {
+                    debug_if(dbg_on, "AT! %s\r\n", _oobs[k].prefix);
+                    _oobs[k].cb();
+
+                    // oob may have corrupted non-reentrant buffer,
+                    // so we need to set it up again
+                    return vrecv(response, args);
+                }
+            }
+
             // Check for match
             int count = -1;
             sscanf(_buffer+offset, _buffer, &count);
@@ -307,3 +320,10 @@ bool ATParser::recv(const char *response, ...)
     va_end(args);
     return res;
 }
+
+
+// oob registration
+void ATParser::oob(const char *prefix, Callback<void()> cb)
+{
+    _oobs.push_back((struct oob){strlen(prefix), prefix, cb});
+}

ESP8266/ATParser/ATParser.h

@@ -20,7 +20,9 @@
 
 #include "mbed.h"
 #include <cstdarg>
+#include <vector>
 #include "BufferedSerial.h"
+#include "Callback.h"
 
 
 /**
@@ -54,6 +56,13 @@ class ATParser
     int _delim_size;
     bool dbg_on;
 
+    struct oob {
+        unsigned len;
+        const char *prefix;
+        mbed::Callback<void()> cb;
+    };
+    std::vector<oob> _oobs;
+
 public:
     /**
     * Constructor
@@ -193,6 +202,28 @@ class ATParser
     int scanf(const char *format, ...);
     int vscanf(const char *format, va_list args);
 
+    /**
+    * Attach a callback for out-of-band data
+    * 
+    * @param prefix string on when to initiate callback
+    * @param func callback to call when string is read
+    * @note out-of-band data is only processed during a scanf call
+    */
+    void oob(const char *prefix, mbed::Callback<void()> func);
+
+    /**
+    * Attach a callback for out-of-band data
+    *
+    * @param prefix string on when to initiate callback
+    * @param obj pointer to object to call member function on
+    * @param method callback to call when string is read
+    * @note out-of-band data is only processed during a scanf call
+    */
+    template <typename T, typename M>
+    void oob(const char *prefix, T *obj, M method) {
+        return oob(prefix, mbed::Callback<void()>(obj, method));
+    }
+
     /**
     * Flushes the underlying stream
     */

ESP8266/ESP8266.cpp

@@ -18,6 +18,7 @@
 
 ESP8266::ESP8266(PinName tx, PinName rx, bool debug)
     : _serial(tx, rx, 1024), _parser(_serial)
+    , _packets(0), _packets_end(&_packets)
 {
     _serial.baud(115200);
     _parser.debugOn(debug);
@@ -30,11 +31,15 @@ bool ESP8266::startup(int mode)
         return false;
     }
 
-    return reset()
+    bool success = reset()
         && _parser.send("AT+CWMODE=%d", mode) 
         && _parser.recv("OK")
         && _parser.send("AT+CIPMUX=1") 
         && _parser.recv("OK");
+
+    _parser.oob("+IPD", this, &ESP8266::_packet_handler);
+
+    return success;
 }
 
 bool ESP8266::reset(void)
@@ -123,20 +128,72 @@ bool ESP8266::send(int id, const void *data, uint32_t amount)
     return false;
 }
 
-int32_t ESP8266::recv(int id, void *data, uint32_t amount)
+void ESP8266::_packet_handler()
 {
-    uint32_t recv_amount;
-    int recv_id;
+    int id;
+    uint32_t amount;
 
-    if (!(_parser.recv("+IPD,%d,%d:", &recv_id, &recv_amount)
-        && recv_id == id
-        && recv_amount <= amount
-        && _parser.read((char*)data, recv_amount)
+    // parse out the packet
+    if (!_parser.recv(",%d,%d:", &id, &amount)) {
+        return;
+    }
+
+    struct packet *packet = (struct packet*)malloc(
+            sizeof(struct packet) + amount);
+    if (!packet) {
+        return;
+    }
+
+    packet->id = id;
+    packet->len = amount;
+    packet->next = 0;
+
+    if (!(_parser.read((char*)(packet + 1), amount)
         && _parser.recv("OK"))) {
-        return -1;
+        free(packet);
+        return;
     }
 
-    return recv_amount;
+    // append to packet list
+    *_packets_end = packet;
+    _packets_end = &packet->next;
+}
+
+int32_t ESP8266::recv(int id, void *data, uint32_t amount)
+{
+    while (true) {
+        // check if any packets are ready for us
+        for (struct packet **p = &_packets; *p; p = &(*p)->next) {
+            if ((*p)->id == id) {
+                struct packet *q = *p;
+
+                if (q->len <= amount) { // Return and remove full packet
+                    memcpy(data, q+1, q->len);
+
+                    if (_packets_end == &(*p)->next) {
+                        _packets_end = p;
+                    }
+                    *p = (*p)->next;
+
+                    uint32_t len = q->len;
+                    free(q);
+                    return len;
+                } else { // return only partial packet
+                    memcpy(data, q+1, amount);
+
+                    q->len -= amount;
+                    memmove(q+1, (uint8_t*)(q+1) + amount, q->len);
+
+                    return amount;
+                }
+            }
+        }
+
+        // Wait for inbound packet
+        if (!_parser.recv("OK")) {
+            return -1;
+        }
+    }
 }
 
 bool ESP8266::close(int id)

ESP8266/ESP8266.h

@@ -166,6 +166,14 @@ class ESP8266
     BufferedSerial _serial;
     ATParser _parser;
 
+    struct packet {
+        struct packet *next;
+        int id;
+        uint32_t len;
+        // data follows
+    } *_packets, **_packets_end;
+    void _packet_handler();
+
     char _ip_buffer[16];
     char _mac_buffer[18];
 };