add socket

Author: ladyada

adafruit_esp32spi.py

@@ -340,9 +340,11 @@ def get_socket(self):
         resp = resp[0][0]
         if resp == 255:
             raise RuntimeError("No sockets available")
+        if self._debug:
+            print("Allocated socket #%d" % resp)
         return resp
 
-    def socket_open(self, dest, ip, port, socket_num, conn_mode=TCP_MODE):
+    def socket_open(self, socket_num, ip, port, conn_mode=TCP_MODE):
         if self._debug:
             print("*** Open socket")
         port_param = struct.pack('>H', port)
@@ -378,20 +380,17 @@ def socket_read(self, socket_num, size):
                                               sent_param_len_16=True, recv_param_len_16=True)
         return resp[0]
 
-    def socket_connect(self, dest, port):
+    def socket_connect(self, socket_num, dest, port):
         if self._debug:
             print("*** Socket connect")
         if isinstance(dest, str):          # convert to IP address
             dest = self.get_host_by_name(dest)
-        self.sock_num = self.get_socket()
-        if self._debug:
-            print("Allocated socket #%d" % self.sock_num)
 
-        self.socket_open(dest, dest, port, self.sock_num)
+        self.socket_open(socket_num, dest, port)
         times = time.monotonic()
         while (time.monotonic() - times) < 3:  # wait 3 seconds
-            if self.socket_connected(self.sock_num):
-                return
+            if self.socket_connected(socket_num):
+                return True
             time.sleep(0.01)
         raise RuntimeError("Failed to establish connection")
 

adafruit_esp32spi_socket.py

@@ -0,0 +1,79 @@
+"""A 'socket' compatible interface thru the ESP SPI command set"""
+from micropython import const
+
+_the_interface = None   # pylint: disable=invalid-name
+def set_interface(iface):
+    """Helper to set the global internet interface"""
+    global _the_interface   # pylint: disable=global-statement, invalid-name
+    _the_interface = iface
+
+SOCK_STREAM = const(1)
+AF_INET = const(2)
+
+# pylint: disable=too-many-arguments, unused-argument
+def getaddrinfo(host, port, family=0, socktype=0, proto=0, flags=0):
+    """Given a hostname and a port name, return a 'socket.getaddrinfo'
+    compatible list of tuples. Honestly, we ignore anything but host & port"""
+    if not isinstance(port, int):
+        raise RuntimeError("Port must be an integer")
+    ipaddr = _the_interface.get_host_by_name(host)
+    return [(AF_INET, socktype, proto, '', (ipaddr, port))]
+# pylint: enable=too-many-arguments, unused-argument
+
+# pylint: disable=unused-argument, redefined-builtin, invalid-name
+class socket:
+    """A simplified implementation of the Python 'socket' class, for connecting
+    through an interface to a remote device"""
+    def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None):
+        if family != AF_INET:
+            raise RuntimeError("Only AF_INET family supported")
+        if type != SOCK_STREAM:
+            raise RuntimeError("Only SOCK_STREAM type supported")
+        self._buffer = b''
+        self._socknum = _the_interface.get_socket()
+
+    def connect(self, address, conntype=None):
+        """Connect the socket to the 'address' (which can be 32bit packed IP or
+        a hostname string). 'conntype' is an extra that may indicate SSL or not,
+        depending on the underlying interface"""
+        host, port = address
+        if not _the_interface.socket_connect(self._socknum, host, port):
+            raise RuntimeError("Failed to connect to host", host)
+        self._buffer = b''
+
+    def write(self, data):         # pylint: disable=no-self-use
+        """Send some data to the socket"""
+        _the_interface.socket_write(self._socknum, data)
+
+    def readline(self):
+        """Attempt to return as many bytes as we can up to but not including '\r\n'"""
+        while b'\r\n' not in self._buffer:
+            # there's no line already in there, read some more
+            avail = _the_interface.socket_available(self._socknum)
+            if avail:
+                self._buffer += _the_interface.socket_read(self._socknum, avail)
+        firstline, self._buffer = self._buffer.split(b'\r\n', 1)
+        return firstline
+
+    def read(self, size=0):
+        """Read up to 'size' bytes from the socket, this may be buffered internally!
+        If 'size' isnt specified, return everything in the buffer."""
+        avail = _the_interface.socket_available(self._socknum)
+        if avail:
+            self._buffer += _the_interface.socket_read(self._socknum, avail)
+        if size == 0:   # read as much as we can
+            ret = self._buffer
+            self._buffer = b''
+            return ret
+        while len(self._buffer) < size:
+            avail = _the_interface.socket_available(self._socknum)
+            if avail:
+                self._buffer += _the_interface.socket_read(self._socknum, avail)
+        ret = self._buffer[:size]
+        self._buffer = self._buffer[size:]
+        return ret
+
+    def close(self):
+        """Close the socket, after reading whatever remains"""
+        _the_interface.socket_close(self._socknum)
+# pylint: enable=unused-argument, redefined-builtin, invalid-name