make work with original demos

Author: ladyada

adafruit_esp32spi/adafruit_esp32spi.py

@@ -83,6 +83,8 @@ def __init__(self, spi, cs_pin, ready_pin, reset_pin, gpio0_pin, *, debug=False)
         self._reset.direction = Direction.OUTPUT
         self._gpio0.direction = Direction.OUTPUT
 
+        if self._debug:
+            print("Reset ESP32")
         self._gpio0.value = True  # not bootload mode
         self._cs.value = True
         self._reset.value = False
@@ -134,16 +136,14 @@ def send_command(self, cmd, params=None, *, param_len_16=False):
 
         # handle parameters here
         for i, param in enumerate(params):
-            if self._debug:
-                print("sending param #%d is %d bytes long" % (i, len(param)))
+            if self._debug >= 2:
+                print("\tSending param #%d is %d bytes long" % (i, len(param)))
             if param_len_16:
                 packet.append((len(param) >> 8) & 0xFF)
             packet.append(len(param) & 0xFF)
             packet += (param)
 
         packet.append(END_CMD)
-        if self._debug:
-            print("packet len:", len(packet))
         while len(packet) % 4 != 0:
             packet.append(0xFF)
 
@@ -153,16 +153,16 @@ def send_command(self, cmd, params=None, *, param_len_16=False):
             print("Wrote: ", [hex(b) for b in packet])
         self.slave_deselect()
 
-    def get_param(self):
+    def read_byte(self):
         self._spi.readinto(self._pbuf)
-        if self._debug:
-            print("Read param", hex(self._pbuf[0]))
+        if self._debug >= 2:
+            print("\t\tRead:", hex(self._pbuf[0]))
         return self._pbuf[0]
 
     def wait_spi_char(self, desired):
         times = time.monotonic()
         while (time.monotonic() - times) < 0.1:
-            r = self.get_param()
+            r = self.read_byte()
             if r == ERR_CMD:
                 raise RuntimeError("Error response to command")
             if r == desired:
@@ -171,7 +171,7 @@ def wait_spi_char(self, desired):
             raise RuntimeError("Timed out waiting for SPI char")
 
     def check_data(self, desired):
-        r = self.get_param()
+        r = self.read_byte()
         if r != desired:
             raise RuntimeError("Expected %02X but got %02X" % (desired, r))
 
@@ -184,22 +184,24 @@ def wait_response_cmd(self, cmd, num_responses=None, *, param_len_16=False):
         if num_responses is not None:
             self.check_data(num_responses)
         else:
-            num_responses = self.get_param()
+            num_responses = self.read_byte()
         responses = []
         for num in range(num_responses):
             response = []
-            param_len = self.get_param()
+            param_len = self.read_byte()
             if param_len_16:
                 param_len <<= 8
-                param_len |= self.get_param()
-            if self._debug:
-                print("parameter #%d length is %d" % (num, param_len))
+                param_len |= self.read_byte()
+            if self._debug >= 2:
+                print("\tParameter #%d length is %d" % (num, param_len))
             for j in range(param_len):
-                response.append(self.get_param())
+                response.append(self.read_byte())
             responses.append(bytes(response))
         self.check_data(END_CMD)
 
         self.slave_deselect()
+        if self._debug:
+            print("Read: ", responses)
         return responses
 
     def send_command_get_response(self, cmd, params=None, *,
@@ -291,10 +293,22 @@ def network_data(self):
     def ip_address(self):
         return self.network_data['ip_addr']
 
+
+    @property
+    def is_connected(self):
+        return self.status == WL_CONNECTED
+
+    def connect(self, settings):
+        self.connect_AP(settings['ssid'], settings['password'])
+
     def connect_AP(self, ssid, password):
         if self._debug:
-            print("Connect to AP")
+            print("Connect to AP", ssid, password)
+        if isinstance(ssid, str):
+            ssid = bytes(ssid, 'utf-8')
         if password:
+            if isinstance(password, str):
+                password = bytes(password, 'utf-8')
             self.wifi_set_passphrase(ssid, password)
         else:
             self.wifi_set_network(ssid)
@@ -379,9 +393,8 @@ def socket_write(self, socket_num, buffer):
             raise RuntimeError("Failed to send %d bytes (sent %d)" % (len(buffer), sent))
 
         resp = self.send_command_get_response(DATA_SENT_TCP_CMD, [[socket_num]])
-        if self._debug:
-            print("** DATA SENT: ",resp)
-        return sent
+        if resp[0][0] != 1:
+            raise RuntimeError("Failed to verify data sent")
 
     def socket_available(self, socket_num):
         resp = self.send_command_get_response(AVAIL_DATA_TCP_CMD, [[socket_num]])

adafruit_esp32spi/adafruit_esp32spi_requests.py

@@ -28,30 +28,33 @@ class Response:
     headers = {}
     encoding = None
 
-    def __init__(self, f):
-        self.raw = f
+    def __init__(self, socket):
+        self.socket = socket
         self.encoding = "utf-8"
         self._cached = None
         self.status_code = None
         self.reason = None
 
     def close(self):
         """Close, delete and collect the response data"""
-        if self.raw:
-            self.raw.close()
-            del self.raw
+        if self.socket:
+            self.socket.close()
+            del self.socket
         del self._cached
         gc.collect()
 
     @property
     def content(self):
         """The HTTP content direct from the socket, as bytes"""
+        content_length = int(self.headers['content-length'])
+        #print("Content length:", content_length)
         if self._cached is None:
             try:
-                self._cached = self.raw.read()
+                self._cached = self.socket.read(content_length)
             finally:
-                self.raw.close()
-                self.raw = None
+                self.socket.close()
+                self.socket = None
+        #print("Buffer length:", len(self._cached))
         return self._cached
 
     @property
@@ -138,7 +141,7 @@ def request(method, url, data=None, json=None, headers=None, stream=None):
             if not line or line == b"\r\n":
                 break
 
-            #print(line)
+            #print("**line: ", line)
             title, content = line.split(b': ', 1)
             if title and content:
                 title = str(title.lower(), 'utf-8')

adafruit_esp32spi/adafruit_esp32spi_socket.py

@@ -61,7 +61,7 @@ def read(self, size=0):
         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
+        if size == 0:   # read as much as we can at the moment
             ret = self._buffer
             self._buffer = b''
             return ret