fix tcp bulk transfer bug, socket timeout setter, streaming data from socket, and a max transfer size

Author: ladyada

adafruit_esp32spi/adafruit_esp32spi.py

@@ -128,7 +128,7 @@ def __init__(self, spi, cs_pin, ready_pin, reset_pin, gpio0_pin, *, debug=False)
         self._buffer = bytearray(10)
         self._pbuf = bytearray(1)  # buffer for param read
 
-        self._spi_device = SPIDevice(spi, cs_pin, baudrate=4000000)
+        self._spi_device = SPIDevice(spi, cs_pin, baudrate=8000000)
         self._cs = cs_pin
         self._ready = ready_pin
         self._reset = reset_pin
@@ -163,7 +163,6 @@ def _wait_for_ready(self):
                 break
             if self._debug:
                 print('.', end='')
-            time.sleep(0.01)
         else:
             raise RuntimeError("ESP32 not responding")
         if self._debug:
@@ -261,7 +260,7 @@ def _wait_response_cmd(self, cmd, num_responses=None, *, param_len_16=False):
             self._check_data(spi, _END_CMD)
 
         if self._debug:
-            print("Read: ", responses)
+            print("Read %d: " % len(responses[0]), responses)
         return responses
 
     def _send_command_get_response(self, cmd, params=None, *,
@@ -508,11 +507,17 @@ def socket_write(self, socket_num, buffer):
     def socket_available(self, socket_num):
         """Determine how many bytes are waiting to be read on the socket"""
         resp = self._send_command_get_response(_AVAIL_DATA_TCP_CMD, [[socket_num]])
-        return struct.unpack('<H', resp[0])[0]
+        reply = struct.unpack('<H', resp[0])[0]
+        if self._debug:
+            print("%d bytes available" % reply)
+        return reply
 
     def socket_read(self, socket_num, size):
         """Read up to 'size' bytes from the socket number. Returns a bytearray"""
-        resp = self._send_command_get_response(_GET_DATABUF_TCP_CMD, [[socket_num], [size]],
+        if self._debug:
+            print("Reading %d bytes from socket with status %d" % (size, self.socket_status(socket_num)))
+        resp = self._send_command_get_response(_GET_DATABUF_TCP_CMD,
+                                               [[socket_num], [size & 0xFF, (size >> 8) & 0xFF]],
                                                sent_param_len_16=True, recv_param_len_16=True)
         return resp[0]
 

adafruit_esp32spi/adafruit_esp32spi_requests.py

@@ -67,6 +67,7 @@ def __init__(self, sock):
         self._cached = None
         self.status_code = None
         self.reason = None
+        self._read_so_far = 0
 
     def close(self):
         """Close, delete and collect the response data"""
@@ -105,13 +106,25 @@ def json(self):
         import ujson
         return ujson.loads(self.content)
 
+    def iter_content(self, chunk_size=1, decode_unicode=False):
+        if decode_unicode:
+            raise NotImplementedError("Unicode not supported")
+
+        while True:
+            chunk = self.socket.read(chunk_size)
+            if chunk and len(chunk) > 0:
+                yield chunk
+            else:
+                return
 
 # pylint: disable=too-many-branches, too-many-statements, unused-argument, too-many-arguments, too-many-locals
-def request(method, url, data=None, json=None, headers=None, stream=None):
+def request(method, url, data=None, json=None, headers=None, stream=False):
     """Perform an HTTP request to the given url which we will parse to determine
     whether to use SSL ('https://') or not. We can also send some provided 'data'
     or a json dictionary which we will stringify. 'headers' is optional HTTP headers
-    sent along. 'stream' is unused in this implementation"""
+    sent along. 'stream' will determine if we buffer everything, or whether to only
+    read only when requested
+    """
     global _the_interface   # pylint: disable=global-statement, invalid-name
 
     if not headers:
@@ -139,6 +152,8 @@ def request(method, url, data=None, json=None, headers=None, stream=None):
     sock = socket.socket(addr_info[0], addr_info[1], addr_info[2])
     resp = Response(sock)  # our response
 
+    sock.settimeout(1)     # 1 second timeout
+
     try:
         if proto == "https:":
             conntype = _the_interface.TLS_MODE

adafruit_esp32spi/adafruit_esp32spi_socket.py

@@ -30,7 +30,7 @@
 """
 
 
-
+import time
 from micropython import const
 
 _the_interface = None   # pylint: disable=invalid-name
@@ -63,6 +63,7 @@ def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None):
             raise RuntimeError("Only SOCK_STREAM type supported")
         self._buffer = b''
         self._socknum = _the_interface.get_socket()
+        self.settimeout(0)
 
     def connect(self, address, conntype=None):
         """Connect the socket to the 'address' (which can be 32bit packed IP or
@@ -81,7 +82,7 @@ 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)
+            avail = min(_the_interface.socket_available(self._socknum), 4000)
             if avail:
                 self._buffer += _the_interface.socket_read(self._socknum, avail)
         firstline, self._buffer = self._buffer.split(b'\r\n', 1)
@@ -90,21 +91,28 @@ def readline(self):
     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 at the moment
+            avail = min(_the_interface.socket_available(self._socknum), 4000)
+            if avail:
+                self._buffer += _the_interface.socket_read(self._socknum, avail)
             ret = self._buffer
             self._buffer = b''
             return ret
+        stamp = time.monotonic()
         while len(self._buffer) < size:
-            avail = _the_interface.socket_available(self._socknum)
+            avail = min(_the_interface.socket_available(self._socknum), 4000)
             if avail:
-                self._buffer += _the_interface.socket_read(self._socknum, avail)
+                stamp = time.monotonic()
+                self._buffer += _the_interface.socket_read(self._socknum, min(size, avail))
+            if time.monotonic() - stamp > self._timeout:
+                break
         ret = self._buffer[:size]
         self._buffer = self._buffer[size:]
         return ret
 
+    def settimeout(self, value):
+        self._timeout = value
+
     def close(self):
         """Close the socket, after reading whatever remains"""
         _the_interface.socket_close(self._socknum)