Diff: ESP8266Interface.cpp

Revision:

55:c0808849cb89

Parent:

54:e78fad32cfff

--- a/ESP8266Interface.cpp	Fri Apr 01 17:28:04 2016 +0000
+++ b/ESP8266Interface.cpp	Wed Apr 06 13:49:41 2016 +0000
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+ 
 
 #include "ESP8266Interface.h"
 
@@ -30,62 +31,64 @@
     memset(_ids, 0, sizeof(_ids));
 }
 
-ESP8266Interface::~ESP8266Interface()
-{
-}
-
-int32_t ESP8266Interface::connect(
-    const char *ap, 
-    const char *pass_phrase, 
-    ns_security_t)
+int ESP8266Interface::connect(
+    const char *ssid,
+    const char *pass,
+    nsapi_security_t security)
 {
     _esp.setTimeout(ESP8266_CONNECT_TIMEOUT);
 
     if (!_esp.startup(3)) {
-        return NS_ERROR_DEVICE_ERROR;
+        return NSAPI_ERROR_DEVICE_ERROR;
     }
 
     if (!_esp.dhcp(true, 1)) {
-        return NS_ERROR_DHCP_FAILURE;
+        return NSAPI_ERROR_DHCP_FAILURE;
     }
 
-    if (!_esp.connect(ap, pass_phrase)) {
-        return NS_ERROR_NO_CONNECTION;
+    if (!_esp.connect(ssid, pass)) {
+        return NSAPI_ERROR_NO_CONNECTION;
     }
 
     if (!_esp.getIPAddress()) {
-        return NS_ERROR_DHCP_FAILURE;
+        return NSAPI_ERROR_DHCP_FAILURE;
     }
 
     return 0;
 }
 
-int32_t ESP8266Interface::disconnect()
+int ESP8266Interface::disconnect()
 {
     _esp.setTimeout(ESP8266_MISC_TIMEOUT);
 
     if (!_esp.disconnect()) {
-        return NS_ERROR_DEVICE_ERROR;
+        return NSAPI_ERROR_DEVICE_ERROR;
     }
 
     return 0;
 }
 
-const char *ESP8266Interface::getIPAddress()
+const char *ESP8266Interface::get_ip_address()
 {
     return _esp.getIPAddress();
 }
 
-const char *ESP8266Interface::getMACAddress()
+const char *ESP8266Interface::get_mac_address()
 {
     return _esp.getMACAddress();
 }
 
-SocketInterface *ESP8266Interface::createSocket(ns_protocol_t proto)
+struct esp8266_socket {
+    int id;
+    nsapi_protocol_t proto;
+    bool connected;
+};
+
+void *ESP8266Interface::socket_create(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;
@@ -93,68 +96,137 @@
             break;
         }
     }
-
+ 
     if (id == -1) {
         return 0;
     }
-
-    return new ESP8266Socket(&_esp, proto, id);
+    
+    struct esp8266_socket *socket = new struct esp8266_socket;
+    if (!socket) {
+        return 0;
+    }
+    
+    socket->id = id;
+    socket->proto = proto;
+    socket->connected = false;
+    return socket;
 }
 
-void ESP8266Interface::destroySocket(SocketInterface *iface)
+void ESP8266Interface::socket_destroy(void *handle)
 {
-    ESP8266Socket *socket = (ESP8266Socket *)iface;
-    _ids[socket->_id] = false;
+    struct esp8266_socket *socket = (struct esp8266_socket *)handle;
+    _ids[socket->id] = false;
     delete socket;
 }
 
+int ESP8266Interface::socket_set_option(void *handle, int optname, const void *optval, unsigned optlen)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
 
-// ESP8266Socket implementation
-int32_t ESP8266Interface::ESP8266Socket::open(const char *ip, uint16_t port)
+int ESP8266Interface::socket_get_option(void *handle, int optname, void *optval, unsigned *optlen)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+int ESP8266Interface::socket_bind(void *handle, int port)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+int ESP8266Interface::socket_listen(void *handle, int backlog)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+int ESP8266Interface::socket_connect(void *handle, const SocketAddress &addr)
 {
-    _esp->setTimeout(ESP8266_MISC_TIMEOUT);
+    struct esp8266_socket *socket = (struct esp8266_socket *)handle;
+    _esp.setTimeout(ESP8266_MISC_TIMEOUT);
+
+    const char *proto = (socket->proto == NSAPI_UDP) ? "UDP" : "TCP";
+    if (!_esp.open(proto, socket->id, addr.get_ip_address(), addr.get_port())) {
+        return NSAPI_ERROR_DEVICE_ERROR;
+    }
+    
+    socket->connected = true;
+    return 0;
+}
+    
+bool ESP8266Interface::socket_is_connected(void *handle)
+{
+    return true;
+}
+
+int ESP8266Interface::socket_accept(void *handle, void **connection)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
 
-    const char *proto = (_proto == NS_UDP) ? "UDP" : "TCP";
+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;
+}
 
-    if (!_esp->open(proto, _id, ip, port)) {
-        return NS_ERROR_TIMEOUT;
+int ESP8266Interface::socket_sendto(void *handle, const SocketAddress &addr, const void *data, unsigned size)
+{
+    struct esp8266_socket *socket = (struct esp8266_socket *)handle;
+    if (!socket->connected) {
+        int err = socket_connect(socket, addr);
+        if (err < 0) {
+            return err;
+        }
     }
+    
+    return socket_send(socket, data, size);
+}
 
+int ESP8266Interface::socket_recvfrom(void *handle, SocketAddress *addr, void *data, unsigned size)
+{
+    struct esp8266_socket *socket = (struct esp8266_socket *)handle;    
+    return socket_recv(socket, data, size);
+}
+
+int ESP8266Interface::socket_close(void *handle, bool shutdown)
+{
+    struct esp8266_socket *socket = (struct esp8266_socket *)handle;
+    _esp.setTimeout(ESP8266_MISC_TIMEOUT);
+ 
+    if (!_esp.close(socket->id)) {
+        return NSAPI_ERROR_DEVICE_ERROR;
+    }
+ 
     return 0;
 }
 
-int32_t ESP8266Interface::ESP8266Interface::ESP8266Socket::close()
+void ESP8266Interface::socket_attach_accept(void *handle, void (*callback)(void *), void *id)
 {
-    _esp->setTimeout(ESP8266_MISC_TIMEOUT);
-
-    if (!_esp->close(_id)) {
-        return NS_ERROR_TIMEOUT;
-    }
-
-    return 0;
 }
 
-int32_t ESP8266Interface::ESP8266Socket::send(const void *data, uint32_t size)
+void ESP8266Interface::socket_attach_send(void *handle, void (*callback)(void *), void *id)
 {
-    _esp->setTimeout(ESP8266_SEND_TIMEOUT);
-
-    if (!_esp->send(_id, data, size)) {
-        return NS_ERROR_TIMEOUT;
-    }
-
-    return size;
 }
 
-int32_t ESP8266Interface::ESP8266Socket::recv(void *data, uint32_t size)
+void ESP8266Interface::socket_attach_recv(void *handle, void (*callback)(void *), void *id)
 {
-    _esp->setTimeout(ESP8266_RECV_TIMEOUT);
-
-    int32_t recv = _esp->recv(_id, data, size);
-
-    if (recv < 0) {
-        return NS_ERROR_WOULD_BLOCK;
-    }
-
-    return recv;
 }
-