going for v0.3.0

trevorwslee · trevorwslee · commit cba254f9a892 · 2023-09-19T22:58:17.000+08:00
diff --git a/README.md b/README.md
@@ -58,7 +58,7 @@ l.enableFeedback("fa")
 l.offColor(RGB_COLOR(0xcc, 0xcc, 0xcc))
 while True:
     feedback = l.getFeedback()
-    if feedback != None:
+    if feedback is not None:
         print("l FB: {}: {},{}".format(feedback.type, feedback.x, feedback.y))
         l.toggle(feedback.x, feedback.y)
 ```
diff --git a/dumbdisplay/_ddimpl.py b/dumbdisplay/_ddimpl.py
@@ -146,7 +146,7 @@ def release(self):
     tunnels = set(self._tunnels)
     for tunnel in tunnels:
       tunnel.release()  
-    if self._io != None:
+    if self._io is not None:
       self._io.close()
     self._io = None
     self._connected = False
@@ -243,19 +243,19 @@ def _sendSpecial(self, special_type: str, special_id: str, special_command: str,
     self._io.print(special_type)
     self._io.print('.')
     self._io.print(special_id)
-    if special_command != None:
+    if special_command is not None:
       self._io.print(':')
       self._io.print(special_command)
     self._io.print('>')
-    if special_data != None:
+    if special_data is not None:
       self._io.print(special_data)
     self._io.print('\n')
     #self.switchDebugLed(False)
   def _sendCommand(self, layer_id: str, command: str, *params):
     self._checkForFeedback()
     #self.switchDebugLed(True)
     try:
-      if layer_id != None:
+      if layer_id is not None:
         self._io.print(layer_id)
         self._io.print('.')
       self._io.print(command)
@@ -276,7 +276,7 @@ def _sendCommand(self, layer_id: str, command: str, *params):
 
   def _checkForFeedback(self):
     feedback = self._readFeedback()
-    if feedback != None:
+    if feedback is not None:
       if len(feedback) > 0:
         if feedback[0:1] == '<':
           self._onFeedbackKeepAlive()
@@ -309,7 +309,7 @@ def _checkForFeedback(self):
                       data = "???" + command + "???"
                   #print("##" + str(final) + "/" + str(command) + "/" + str(data))####    
                   tunnel = self._tunnels.get(tid)
-                  if tunnel != None:
+                  if tunnel is not None:
                     tunnel._handleInput(data, final)
               except:
                 pass
@@ -326,7 +326,7 @@ def _checkForFeedback(self):
               x = int(feedback[0:idx])
               y = int(feedback[idx + 1:])
               layer = self._layers.get(lid)
-              if layer != None:
+              if layer is not None:
                 layer._handleFeedback(type, x, y)
             except:
               pass
diff --git a/dumbdisplay/_ddio.py b/dumbdisplay/_ddio.py
@@ -9,7 +9,7 @@
 def io4Inet(port: int = DD_DEF_PORT) -> DDInputOutput:
   return DDIOInet(port)
 
-def io4Wifi(ssid: str, password: str, port: int = DD_DEF_PORT) -> DDInputOutput:
+def io4Wifi(ssid: str = None, password: str = None, port: int = DD_DEF_PORT) -> DDInputOutput:
   return DDIOWifi(ssid, password, port)
 
 def io4WifiOrInet(ssid: str, password: str, port: int = DD_DEF_PORT) -> DDInputOutput:
diff --git a/dumbdisplay/_ddio_ble.py b/dumbdisplay/_ddio_ble.py
@@ -19,12 +19,12 @@ def preconnect(self):
     self._register()
     self._advertiser()
     while True:
-      if self._data != None:
+      if self._data is not None:
         break
       time.sleep_ms(500)
     print('... BLE connected')
   def available(self):
-    return self._data != None and len(self._data) > 0
+    return self._data is not None and len(self._data) > 0
   def read(self):
     return self._data.pop(0)
   def print(self, s):
@@ -37,7 +37,7 @@ def print(self, s):
       self.ble.gatts_notify(0, self._tx, b)
       #print(b)
   def close(self):
-    if self._conn_handle != None:
+    if self._conn_handle is not None:
       self.ble.gap_disconnect(self._conn_handle)
       self._conn_handle = None
       self._data = None
@@ -91,7 +91,7 @@ def _ble_irq(self, event, data):
       #message = buffer.decode('UTF-8')[:-1]
       message = buffer.decode('UTF-8').strip()
       #print(message)
-      if (self._data != None):
+      if (self._data is not None):
         self._data.append(message + '\n') 
       #print(str(len(self._data)))
 
diff --git a/dumbdisplay/_ddio_socket.py b/dumbdisplay/_ddio_socket.py
@@ -53,7 +53,7 @@ def print(self, s):
       #     raise e
     #self.conn.sendall(data)
   def close(self):
-    if self.conn != None:
+    if self.conn is not None:
       self.conn.close()
       self.sock.close()
     self.conn = None
diff --git a/dumbdisplay/_ddio_uart.py b/dumbdisplay/_ddio_uart.py
@@ -6,12 +6,6 @@
 
 
 class DDIOUart(DDInputOutput):
-  # def __init__(self, id, baudrate = 115200, tx = None, rx = None):
-  #   '''if specify tx, must also specify rx'''
-  #   super().__init__()
-  #   self.uart = UART(id, baudrate)
-  #   if tx != None:
-  #     self.uart.init(baudrate, tx = tx, rx = rx)
   def __init__(self, uart):
     super().__init__()
     self.uart = uart
@@ -36,12 +30,4 @@ def io4DefUart(id, baudrate, rx):
   uart = UART(id, baudrate)
   return DDIOUart(uart)
 
-# def io4Uart(id, baudrate = 115200, tx = None, rx = None):
-#   '''if specify tx, must also specify rx'''
-#   uart = UART(id, baudrate)
-#   if tx != None:
-#     uart.init(baudrate, tx = tx, rx = rx)
-#   return DDIOUart(id, baudrate, tx, rx)
-# def io4IpcoUart(uart):
-#   return DDIOUart(uart)
 
diff --git a/dumbdisplay/_ddio_wifi.py b/dumbdisplay/_ddio_wifi.py
@@ -6,9 +6,11 @@
 class DDIOWifi(DDIOSocket):
   def __init__(self, ssid, password, port = DD_DEF_PORT):
     super().__init__(port)
-    print('connecting WIFI ... {} ...'.format(ssid))
     station = network.WLAN(network.STA_IF)
     if not station.isconnected():
+      print('connecting WIFI ... {} ...'.format(ssid))
+      if ssid is None:
+        raise Exception('SSID not provided')
       station.active(True)
       station.connect(ssid, password)
       while not station.isconnected():
diff --git a/dumbdisplay/_ddlayer.py b/dumbdisplay/_ddlayer.py
@@ -64,28 +64,28 @@ def noBorder(self):
     self.dd._sendCommand(self.layer_id, "border")
   def padding(self, left, top = None, right = None, bottom = None):
     '''see border() for size unit'''
-    if top == None and right == None and bottom == None:
+    if top is None and right is None and bottom is None:
       self.dd._sendCommand(self.layer_id, "padding", str(left))
     else:
-      if top == None:
+      if top is None:
         top = left
-      if right == None:
+      if right is None:
         right = left
-      if bottom == None:
+      if bottom is None:
         bottom = top
       self.dd._sendCommand(self.layer_id, "padding", str(left), str(top), str(right), str(bottom))
   def noPadding(self):
     self.dd._sendCommand(self.layer_id, "padding")
   def margin(self, left, top = None, right = None, bottom = None):
     '''see border() for size unit'''
-    if top == None and right == None and bottom == None:
+    if top is None and right is None and bottom is None:
       self.dd._sendCommand(self.layer_id, "margin", str(left))
     else:
-      if top == None:
+      if top is None:
         top = left
-      if right == None:
+      if right is None:
         right = left
-      if bottom == None:
+      if bottom is None:
         bottom = top
       self.dd._sendCommand(self.layer_id, "margin", str(left), str(top), str(right), str(bottom))
   def noMargin(self):
@@ -158,20 +158,11 @@ def reorderLayer(self, how: str):
 
   def _handleFeedback(self, type, x, y):
     #print("RAW FB: " + self.layer_id + '.' + type + ':' + str(x) + ',' + str(y))
-    if self._feedback_handler != None:
+    if self._feedback_handler is not None:
       self._feedback_handler(self, type, x, y)
     else:
       self._feedbacks.append((type, x, y))
       # self._shipFeedbacks()
-  # def _shipFeedbacks(self):
-  #   if self._feedback_handler != None:
-  #     feedbacks = self._feedbacks.copy()
-  #     self._feedbacks.clear()
-  #     for (type, x, y) in feedbacks:
-  #       self._feedback_handler.handleFeedback(type, x, y)
-  #   # else:
-  #   #   for (type, x, y) in self.feedbacks:
-  #   #     print("unhandled FB: " + self.layer_id + '.' + type + ':' + str(x) + ',' + str(y))
 
 
 
diff --git a/dumbdisplay/_ddlayer_plotter.py b/dumbdisplay/_ddlayer_plotter.py
@@ -15,14 +15,14 @@ def __init__(self, dd, width, height, pixels_per_second = 10):
     super().__init__(dd, layer_id)
   def label(self, no_key_label = None, **key_label_pairs):
     '''set labels of keys; if key has no label, the key will be the label'''
-    if no_key_label != None:
+    if no_key_label is not None:
       self.dd._sendCommand(self.layer_id, "label", "", str(no_key_label))
     for (key, lab) in key_label_pairs.items():
       self.dd._sendCommand(self.layer_id, "label", key, str(lab))
   def set(self, no_key_value = None, **key_value_pairs):
     '''set values with multiple key value pairs; value should be numeric'''
     params = []
-    if no_key_value != None:
+    if no_key_value is not None:
       params.append("")
       params.append(str(no_key_value))
     for (k, v) in key_value_pairs.items():
diff --git a/dumbdisplay/_dumbdisplay.py b/dumbdisplay/_dumbdisplay.py
@@ -24,20 +24,20 @@ def build(self):
     return self._build_layout()
   def pin(self, dd):
     layout_spec = self._build_layout()
-    if layout_spec != None:
+    if layout_spec is not None:
       dd.configAutoPin(layout_spec)
   def _build_layout(self):
     layout_spec = None
     for layer in self.layers:
-      if layout_spec == None:
+      if layout_spec is None:
         layout_spec = ''
       else:
         layout_spec += '+'
       if type(layer) == DDAutoPin:
         layout_spec += layer._build_layout()
       else:
         layout_spec += layer.layer_id
-    if layout_spec != None:
+    if layout_spec is not None:
       layout_spec = str(self.orientation) + '(' + layout_spec + ")"
     return layout_spec
 
@@ -124,15 +124,6 @@ def notone(self):
 
 
 
-  # def toggleDebugLed(self):
-  #     if self.debug_led != None:
-  #       self.debug_led.value(not self.debug_led.value())
-  # def switchDebugLed(self, on):
-  #   if self.debug_led != None:
-  #     if on:
-  #       self.debug_led.on()
-  #     else:
-  #       self.debug_led.off()
   def onDetectedDisconnect(self, for_ms: int):
     if self.reset_machine_if_detected_disconnect_for_s and for_ms >= (1000 * self.reset_machine_if_detected_disconnect_for_s):
       print("xxxxxxxxx")
diff --git a/dumbdisplay/_exp__ddtunnel.py b/dumbdisplay/_exp__ddtunnel.py
@@ -16,14 +16,14 @@ def release(self):
     self.dd._onDeletedTunnel(self.tunnel_id)
     self.dd = None
   def reconnect(self):
-    if self.dd == None:
+    if self.dd is None:
       return False
     self.dd._reconnectTunnel(self.tunnel_id, self.end_point)
     self._done = False
     self._data = []
     return True
   def _count(self):
-    return len(self._data) if self._data != None else 0
+    return len(self._data) if self._data is not None else 0
   def _eof(self):
     return self._done and len(self._data) == 0
   def _readLine(self):
diff --git a/experiments/picopio/pio_do_re-mi.py b/experiments/picopio/pio_do_re-mi.py
diff --git a/experiments/picopio/pio_neo_blink.py b/experiments/picopio/pio_neo_blink.py
@@ -4,6 +4,20 @@
 import rp2
 from machine import Pin
 
+
+# bits shifting
+# . 1st pixel then 2nd pixel ...
+# . G then R then B
+# . most significant first
+# timing for bit:
+# . 0: .4us high + .85us low
+# . 1: .8us high + .45us low
+# if frequency is 20MHz ... i.e. each cycle 0.05us
+# . 0: 8 cycles high + 17 cycles low
+# . 1: 16 cycles high + 9 cycles low
+# afterward, delay for 300us
+
+
 @rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT)
 def neo_prog():
     pull()                       # osr <= number of pixels - 1
diff --git a/experiments/picopio/pio_tone.py b/experiments/picopio/pio_tone.py
@@ -5,12 +5,7 @@
 import rp2
 from machine import Pin
 
-# Create a PIO program to read a number, wait for 10 cycles, and then return it
-@rp2.asm_pio(
-    set_init=rp2.PIO.OUT_LOW,
-    in_shiftdir=rp2.PIO.SHIFT_LEFT,
-    out_shiftdir=rp2.PIO.SHIFT_LEFT,
-)
+@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW)
 
 def wave_prog():
     pull(block)
diff --git a/experiments/testing/_ddgraphical.py b/experiments/testing/_ddgraphical.py
@@ -4,7 +4,7 @@
 def run(io, debug_led_pin = None):
   # create DumbDisplay connected using WIFI or Inet (Python Internet connection)
   dd = DumbDisplay(io)
-  if debug_led_pin != None:
+  if debug_led_pin is not None:
     dd.debugSetup(debug_led_pin)  # 2
 
   # create 4 graphical [LCD] layers
diff --git a/experiments/testing/_debug.py b/experiments/testing/_debug.py
@@ -56,7 +56,7 @@ def once(dd, loop = True):
       led1.toggle()
       led2.toggle()
       feedback = led2.getFeedback()
-      if feedback != None:
+      if feedback is not None:
         print("led2 FB: {}: {},{}".format(feedback.type, feedback.x, feedback.y))
     lcd.writeCenteredLine('restarting')
     led1.clear()
diff --git a/experiments/testing/le.py b/experiments/testing/le.py
@@ -99,7 +99,7 @@ def _advertiser(self):
       self.ble.gap_advertise(100, bytearray('\x02\x01\x02') + bytearray((len(name) + 1, 0x09)) + name)
 
     def close(self):
-      if self._conn_handle != None:
+      if self._conn_handle is not None:
         self.ble.gap_disconnect(self._conn_handle)
         self._conn_handle = None
       self.ble.active(False)
diff --git a/experiments/testing/uart_test.py b/experiments/testing/uart_test.py
diff --git a/samples/ledgrid_onoff/main.py b/samples/ledgrid_onoff/main.py
diff --git a/samples/melody/main.py b/samples/melody/main.py
