Implement socket_bind and socket_accept

Author: janjongboom

ESP8266/ESP8266.cpp

@@ -16,8 +16,8 @@
 
 #include "ESP8266.h"
 
-ESP8266::ESP8266(PinName tx, PinName rx, bool debug)
-    : _serial(tx, rx, 1024), _parser(_serial)
+ESP8266::ESP8266(PinName tx, PinName rx, Callback<void(SignalingAction, int)> signalingCallback, bool debug)
+    : _serial(tx, rx, 1024), _parser(_serial), _signalingCallback(signalingCallback)
     , _packets(0), _packets_end(&_packets)
 {
     _serial.baud(115200);
@@ -30,11 +30,11 @@ int ESP8266::get_firmware_version()
     int version;
     if(_parser.recv("SDK version:%d", &version) && _parser.recv("OK")) {
         return version;
-    } else { 
+    } else {
         // Older firmware versions do not prefix the version with "SDK version: "
         return -1;
     }
-    
+
 }
 
 bool ESP8266::startup(int mode)
@@ -51,6 +51,18 @@ bool ESP8266::startup(int mode)
 
     _parser.oob("+IPD", this, &ESP8266::_packet_handler);
 
+    _parser.oob("0,CONNECT", this, &ESP8266::_incoming_socket_opened0);
+    _parser.oob("1,CONNECT", this, &ESP8266::_incoming_socket_opened1);
+    _parser.oob("2,CONNECT", this, &ESP8266::_incoming_socket_opened2);
+    _parser.oob("3,CONNECT", this, &ESP8266::_incoming_socket_opened3);
+    _parser.oob("4,CONNECT", this, &ESP8266::_incoming_socket_opened4);
+
+    _parser.oob("0,CLOSED", this, &ESP8266::_incoming_socket_closed0);
+    _parser.oob("1,CLOSED", this, &ESP8266::_incoming_socket_closed1);
+    _parser.oob("2,CLOSED", this, &ESP8266::_incoming_socket_closed2);
+    _parser.oob("3,CLOSED", this, &ESP8266::_incoming_socket_closed3);
+    _parser.oob("4,CLOSED", this, &ESP8266::_incoming_socket_closed4);
+
     return success;
 }
 
@@ -320,3 +332,23 @@ bool ESP8266::recv_ap(nsapi_wifi_ap_t *ap)
 
     return ret;
 }
+
+bool ESP8266::bind(const SocketAddress& address)
+{
+    return _parser.send("AT+CIPSERVER=1,%d", address.get_port())
+        && _parser.recv("OK");
+}
+
+void ESP8266::_incoming_socket_opened(int8_t socket_id)
+{
+    printf("Incoming socket opened %d\n", socket_id);
+
+    _signalingCallback(ESP8266_SOCKET_CONNECT, socket_id);
+}
+
+void ESP8266::_incoming_socket_closed(int8_t socket_id)
+{
+    printf("Incoming socket closed %d\n", socket_id);
+
+    _signalingCallback(ESP8266_SOCKET_CLOSE, socket_id);
+}

ESP8266/ESP8266.h

@@ -19,21 +19,26 @@
 
 #include "ATParser.h"
 
+enum SignalingAction {
+    ESP8266_SOCKET_CONNECT,
+    ESP8266_SOCKET_CLOSE
+};
+
 /** ESP8266Interface class.
     This is an interface to a ESP8266 radio.
  */
 class ESP8266
 {
 public:
-    ESP8266(PinName tx, PinName rx, bool debug=false);
+    ESP8266(PinName tx, PinName rx, Callback<void(SignalingAction, int)> signalingCallback, bool debug=false);
 
     /**
     * Check firmware version of ESP8266
     *
     * @return integer firmware version or -1 if firmware query command gives outdated response
     */
     int get_firmware_version(void);
-    
+
     /**
     * Startup the ESP8266
     *
@@ -97,7 +102,7 @@ class ESP8266
 
     /** Get the local network mask
      *
-     *  @return         Null-terminated representation of the local network mask 
+     *  @return         Null-terminated representation of the local network mask
      *                  or null if no network mask has been recieved
      */
     const char *getNetmask();
@@ -123,7 +128,7 @@ class ESP8266
      *               see @a nsapi_error
      */
     int scan(WiFiAccessPoint *res, unsigned limit);
-    
+
     /**Perform a dns query
     *
     * @param name Hostname to resolve
@@ -206,9 +211,19 @@ class ESP8266
         attach(Callback<void()>(obj, method));
     }
 
+    /**
+    * Start binding to a port
+    *
+    * @param address SocketAddress instance (only port is being used)
+    */
+    bool bind(const SocketAddress& address);
+
+    void ping();
+
 private:
     BufferedSerial _serial;
     ATParser _parser;
+    Callback<void(SignalingAction, int)> _signalingCallback;
 
     struct packet {
         struct packet *next;
@@ -217,12 +232,28 @@ class ESP8266
         // data follows
     } *_packets, **_packets_end;
     void _packet_handler();
+    void _incoming_socket_opened(int8_t);
+    void _incoming_socket_closed(int8_t);
     bool recv_ap(nsapi_wifi_ap_t *ap);
 
     char _ip_buffer[16];
     char _gateway_buffer[16];
     char _netmask_buffer[16];
     char _mac_buffer[18];
+
+    // The CONNECTED OOB messages start with %d, and patching the ATParser is not worth it
+    // Max. connections is 5 according to ESP8266_SOCKET_COUNT, if that changes, this has to change too
+    void _incoming_socket_opened0() { _incoming_socket_opened(0); }
+    void _incoming_socket_opened1() { _incoming_socket_opened(1); }
+    void _incoming_socket_opened2() { _incoming_socket_opened(2); }
+    void _incoming_socket_opened3() { _incoming_socket_opened(3); }
+    void _incoming_socket_opened4() { _incoming_socket_opened(4); }
+
+    void _incoming_socket_closed0() { _incoming_socket_closed(0); }
+    void _incoming_socket_closed1() { _incoming_socket_closed(1); }
+    void _incoming_socket_closed2() { _incoming_socket_closed(2); }
+    void _incoming_socket_closed3() { _incoming_socket_closed(3); }
+    void _incoming_socket_closed4() { _incoming_socket_closed(4); }
 };
 
 #endif

ESP8266Interface.cpp

@@ -37,10 +37,11 @@
 
 // ESP8266Interface implementation
 ESP8266Interface::ESP8266Interface(PinName tx, PinName rx, bool debug)
-    : _esp(tx, rx, debug)
+    : _esp(tx, rx, callback(this, &ESP8266Interface::signal), false)
 {
     memset(_ids, 0, sizeof(_ids));
     memset(_cbs, 0, sizeof(_cbs));
+    memset(_incoming_sockets, 0, sizeof(_incoming_sockets));
 
     _esp.attach(this, &ESP8266Interface::event);
 }
@@ -59,19 +60,19 @@ int ESP8266Interface::connect(const char *ssid, const char *pass, nsapi_security
 int ESP8266Interface::connect()
 {
     _esp.setTimeout(ESP8266_CONNECT_TIMEOUT);
-    
+
     if (!_esp.reset()) {
         return NSAPI_ERROR_DEVICE_ERROR;
-    }   
- 
+    }
+
     _esp.setTimeout(ESP8266_MISC_TIMEOUT);
-    
+
     if (_esp.get_firmware_version() != ESP8266_VERSION) {
         debug("ESP8266: ERROR: Firmware incompatible with this driver.\
-               \r\nUpdate to v%d - https://developer.mbed.org/teams/ESP8266/wiki/Firmware-Update\r\n",ESP8266_VERSION); 
+               \r\nUpdate to v%d - https://developer.mbed.org/teams/ESP8266/wiki/Firmware-Update\r\n",ESP8266_VERSION);
         return NSAPI_ERROR_DEVICE_ERROR;
     }
-    
+
     _esp.setTimeout(ESP8266_CONNECT_TIMEOUT);
 
     if (!_esp.startup(3)) {
@@ -164,24 +165,24 @@ int ESP8266Interface::socket_open(void **handle, nsapi_protocol_t proto)
 {
     // Look for an unused socket
     int id = -1;
- 
+
     for (int i = 0; i < ESP8266_SOCKET_COUNT; i++) {
         if (!_ids[i]) {
             id = i;
             _ids[i] = true;
             break;
         }
     }
- 
+
     if (id == -1) {
         return NSAPI_ERROR_NO_SOCKET;
     }
-    
+
     struct esp8266_socket *socket = new struct esp8266_socket;
     if (!socket) {
         return NSAPI_ERROR_NO_SOCKET;
     }
-    
+
     socket->id = id;
     socket->proto = proto;
     socket->connected = false;
@@ -194,7 +195,7 @@ int ESP8266Interface::socket_close(void *handle)
     struct esp8266_socket *socket = (struct esp8266_socket *)handle;
     int err = 0;
     _esp.setTimeout(ESP8266_MISC_TIMEOUT);
- 
+
     if (socket->connected && !_esp.close(socket->id)) {
         err = NSAPI_ERROR_DEVICE_ERROR;
     }
@@ -207,7 +208,7 @@ int ESP8266Interface::socket_close(void *handle)
 
 int ESP8266Interface::socket_bind(void *handle, const SocketAddress &address)
 {
-    return NSAPI_ERROR_UNSUPPORTED;
+    return _esp.bind(address);
 }
 
 int ESP8266Interface::socket_listen(void *handle, int backlog)
@@ -224,38 +225,62 @@ int ESP8266Interface::socket_connect(void *handle, const SocketAddress &addr)
     if (!_esp.open(proto, socket->id, addr.get_ip_address(), addr.get_port())) {
         return NSAPI_ERROR_DEVICE_ERROR;
     }
-    
+
     socket->connected = true;
     return 0;
 }
-    
+
 int ESP8266Interface::socket_accept(void *server, void **socket, SocketAddress *addr)
 {
-    return NSAPI_ERROR_UNSUPPORTED;
+    printf("socket_accept\n");
+
+    while (1) {
+        // to get the OOB messages we need to send something to the ESP8266 so the ATParser has time to
+        // grab the packets. Send a bogus message to the module...
+        _esp.get_firmware_version();
+
+        // now go through the _incoming_sockets array and see if there are unattached sockets...
+        for (size_t ix = 0; ix < ESP8266_SOCKET_COUNT; ix++) {
+            // printf("_incoming_sockets[ix] socket=%p connected=%d accepted=%d\n",
+            //     _incoming_sockets[ix].socket, _incoming_sockets[ix].socket && _incoming_sockets[ix].socket->connected,
+            //     _incoming_sockets[ix].accepted);
+            if (_incoming_sockets[ix].socket && _incoming_sockets[ix].socket->connected && !_incoming_sockets[ix].accepted) {
+                printf("accepting socket %d\n", ix);
+
+                *socket = _incoming_sockets[ix].socket;
+                // addr is not used here I think...
+                _incoming_sockets[ix].accepted = true;
+                return 0;
+            }
+        }
+
+        wait_ms(20); // socket_accept is blocking
+    }
+    return 0;
 }
 
 int ESP8266Interface::socket_send(void *handle, const void *data, unsigned size)
 {
     struct esp8266_socket *socket = (struct esp8266_socket *)handle;
     _esp.setTimeout(ESP8266_SEND_TIMEOUT);
- 
+
     if (!_esp.send(socket->id, data, size)) {
         return NSAPI_ERROR_DEVICE_ERROR;
     }
- 
+
     return size;
 }
 
 int ESP8266Interface::socket_recv(void *handle, void *data, unsigned size)
 {
     struct esp8266_socket *socket = (struct esp8266_socket *)handle;
     _esp.setTimeout(ESP8266_RECV_TIMEOUT);
- 
+
     int32_t recv = _esp.recv(socket->id, data, size);
     if (recv < 0) {
         return NSAPI_ERROR_WOULD_BLOCK;
     }
- 
+
     return recv;
 }
 
@@ -278,7 +303,7 @@ int ESP8266Interface::socket_sendto(void *handle, const SocketAddress &addr, con
         }
         socket->addr = addr;
     }
-    
+
     return socket_send(socket, data, size);
 }
 
@@ -295,7 +320,7 @@ int ESP8266Interface::socket_recvfrom(void *handle, SocketAddress *addr, void *d
 
 void ESP8266Interface::socket_attach(void *handle, void (*callback)(void *), void *data)
 {
-    struct esp8266_socket *socket = (struct esp8266_socket *)handle;    
+    struct esp8266_socket *socket = (struct esp8266_socket *)handle;
     _cbs[socket->id].callback = callback;
     _cbs[socket->id].data = data;
 }
@@ -307,3 +332,45 @@ void ESP8266Interface::event() {
         }
     }
 }
+
+void ESP8266Interface::signal(SignalingAction action, int socket_id) {
+    printf("ESP8266Interface::signal %d %d\n", action, socket_id);
+
+    if (action == ESP8266_SOCKET_CONNECT) {
+        if (_ids[socket_id]) {
+            // this should not be possible...
+            printf("ESP8266_SOCKET_CONNECT for socket that already exists...\n");
+            // return;
+        }
+
+        struct esp8266_socket *socket = new struct esp8266_socket;
+        if (!socket) {
+            printf("ESP8266_SOCKET_CONNECT could not create socket\n");
+            return;
+        }
+
+        _ids[socket_id] = true;
+
+        socket->id = socket_id;
+        socket->proto = NSAPI_TCP;
+        socket->connected = true;
+
+        _incoming_sockets[socket_id].socket = socket;
+        _incoming_sockets[socket_id].accepted = false;
+    }
+    else if (action == ESP8266_SOCKET_CLOSE) {
+        // Q: should we be able to delete the socket here? probably segfaults if held in user code
+        struct esp8266_socket *socket = _incoming_sockets[socket_id].socket;
+        if (!socket || !socket->connected) {
+            printf("ESP8266_SOCKET_CLOSE for socket that does not exist or is already closed\n");
+            return;
+        }
+
+        socket->connected = false;
+        _incoming_sockets[socket_id].accepted = false;
+        _incoming_sockets[socket_id].socket = NULL;
+        _ids[socket_id] = false;
+
+        // delete socket?
+    }
+}