Diff: ESP8266Interface.cpp

Revision:

56:34829ec3a3da

Parent:

54:e78fad32cfff

Child:

57:2ad35ade7a83

diff -r d6244089a657 -r 34829ec3a3da ESP8266Interface.cpp
--- a/ESP8266Interface.cpp	Fri Apr 15 23:58:10 2016 +0000
+++ b/ESP8266Interface.cpp	Thu Apr 21 06:11:08 2016 -0500
@@ -30,58 +30,60 @@
     memset(_ids, 0, sizeof(_ids));
 }
 
-ESP8266Interface::~ESP8266Interface()
-{
-}
-
-int32_t ESP8266Interface::connect(
+int ESP8266Interface::connect(
     const char *ap, 
     const char *pass_phrase, 
-    ns_security_t)
+    nsapi_security_t)
 {
     _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;
+        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;
+};
+
+int ESP8266Interface::socket_open(void **handle, nsapi_protocol_t proto)
 {
     // Look for an unused socket
     int id = -1;
@@ -95,66 +97,110 @@
     }
 
     if (id == -1) {
-        return 0;
+        return NSAPI_ERROR_NO_SOCKET;
     }
 
-    return new ESP8266Socket(&_esp, proto, id);
-}
-
-void ESP8266Interface::destroySocket(SocketInterface *iface)
-{
-    ESP8266Socket *socket = (ESP8266Socket *)iface;
-    _ids[socket->_id] = false;
-    delete socket;
-}
-
-
-// ESP8266Socket implementation
-int32_t ESP8266Interface::ESP8266Socket::open(const char *ip, uint16_t port)
-{
-    _esp->setTimeout(ESP8266_MISC_TIMEOUT);
-
-    const char *proto = (_proto == NS_UDP) ? "UDP" : "TCP";
-
-    if (!_esp->open(proto, _id, ip, port)) {
-        return NS_ERROR_TIMEOUT;
+    struct esp8266_socket *socket = new struct esp8266_socket;
+    if (!socket) {
+        return NSAPI_ERROR_NO_SOCKET;
     }
 
+    socket->id = id;
+    socket->proto = proto;
+    socket->connected = false;
+    *handle = socket;
     return 0;
 }
 
-int32_t ESP8266Interface::ESP8266Interface::ESP8266Socket::close()
+int ESP8266Interface::socket_close(void *handle)
 {
-    _esp->setTimeout(ESP8266_MISC_TIMEOUT);
-
-    if (!_esp->close(_id)) {
-        return NS_ERROR_TIMEOUT;
+    struct esp8266_socket *socket = (struct esp8266_socket *)handle;
+    int err = 0;
+    _esp.setTimeout(ESP8266_MISC_TIMEOUT);
+ 
+    if (!_esp.close(socket->id)) {
+        err = NSAPI_ERROR_DEVICE_ERROR;
     }
 
+    _ids[socket->id] = false;
+    delete socket;
+    return err;
+}
+
+int ESP8266Interface::socket_bind(void *handle, const SocketAddress &address)
+{
+    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)
+{
+    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;
 }
-
-int32_t ESP8266Interface::ESP8266Socket::send(const void *data, uint32_t size)
+    
+int ESP8266Interface::socket_accept(void **handle, void *server)
 {
-    _esp->setTimeout(ESP8266_SEND_TIMEOUT);
+    return NSAPI_ERROR_UNSUPPORTED;
+}
 
-    if (!_esp->send(_id, data, size)) {
-        return NS_ERROR_TIMEOUT;
+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;
 }
 
-int32_t ESP8266Interface::ESP8266Socket::recv(void *data, uint32_t size)
+int ESP8266Interface::socket_recv(void *handle, void *data, unsigned size)
 {
-    _esp->setTimeout(ESP8266_RECV_TIMEOUT);
-
-    int32_t recv = _esp->recv(_id, data, 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 NS_ERROR_WOULD_BLOCK;
+        return NSAPI_ERROR_WOULD_BLOCK;
     }
-
+ 
     return recv;
 }
 
+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);
+}
+
+void ESP8266Interface::socket_attach(void *handle, void (*callback)(void *), void *data)
+{
+}
+