Merge pull request #5 from trevorwslee/develop

Develop

Author: trevorwslee

.gitignore

@@ -11,3 +11,4 @@ dumbdisplay_experimental
 /_dd.py
 /_test.ipynb
 /.micropico
+/experiments/pyclock

README.md

@@ -1,4 +1,4 @@
-# DumbDisplay MicroPython Library (v0.3.0)
+# DumbDisplay MicroPython Library (v0.3.1)
 
 DumbDisplay MicroPython Library is a port of the [DumbDisplay Arduino Library](https://github.com/trevorwslee/Arduino-DumbDisplay)
 for the [DumbDisplay Android app](https://play.google.com/store/apps/details?id=nobody.trevorlee.dumbdisplay)
@@ -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)
 ```
@@ -126,6 +126,9 @@ Notes:
 
 # Change History
 
+v0.3.1
+- added LayerJoystick
+
 v0.3.0
 - checked Raspberry Pi Pico W WIFI support
 - ported more options from Arduino DumbDisplay library

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,10 +276,11 @@ 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:
+        self._onFeedbackSignal()
         if feedback[0:1] == '<':
-          self._onFeedbackKeepAlive()
+          #self._onFeedbackKeepAlive()
           if len(feedback) == 1:
             pass
             #self._onFeedbackKeepAlive()
@@ -309,7 +310,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 +327,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
@@ -339,7 +340,7 @@ def _readFeedback(self) -> str:
     feedback = self._connected_iop.read()
     #self._connected_iop.clear()
     return feedback
-  def _onFeedbackKeepAlive(self):
+  def _onFeedbackSignal(self):
     if self._connected_iop:
       self._connected_iop.keepAlive()
   def _validateConnection(self):

dumbdisplay/_ddio.py

@@ -1,6 +1,10 @@
 from ._ddiobase import DD_DEF_PORT, DDInputOutput
 from ._ddio_inet import DDIOInet
 
+# e.g.
+# from dumbdisplay.io_wifi import *
+# dd = DumbDisplay(io4Wifi(WIFI_SSID, WIFI_PWD))
+
 try:
   from ._ddio_wifi import DDIOWifi
 except:
@@ -9,7 +13,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:

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)))
 

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

dumbdisplay/_ddio_uart.py

@@ -5,16 +5,17 @@
 from machine import UART, Pin
 
 
+# e.g.
+# from dumbdisplay.io_uart import *
+# dd = DumbDisplay(io4Uart(id=1, baudrate=115200, rx=9, tx=8))
+
 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):
+  def __init__(self, uart, desc):
     super().__init__()
     self.uart = uart
+    self.desc = desc
+  def preconnect(self):
+    print(f"connect with UART ({self.desc})")
   def available(self):
     return self.uart.any() > 0
   def read(self):
@@ -30,18 +31,10 @@ def io4Uart(id, baudrate, rx, tx):
     uart = UART(id, baudrate)
     uart.init(baudrate, rx=rx, tx=tx)
   except:
-    uart = UART(id=id, baudrate=baudrate, rx=Pin(rx), tx=Pin(tx))
-  return DDIOUart(uart)
-def io4DefUart(id, baudrate, rx):
+    uart = UART(id, baudrate=baudrate, rx=Pin(rx), tx=Pin(tx))
+  return DDIOUart(uart, {"id": id, "baudrate": baudrate, "rx": rx, "tx": tx})
+def io4DefUart(id, baudrate):
   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)
+  return DDIOUart(uart, "default")
+
 

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():

dumbdisplay/_ddlayer.py

@@ -5,6 +5,9 @@ def DD_RGB_COLOR(r, g, b):
 def _DD_INT_ARG(val):
   return str(int(val))
 
+def _DD_FLOAT_ARG(val):
+  return str(float(val))
+
 def _DD_BOOL_ARG(b):
   if b:
     return "1"
@@ -64,34 +67,41 @@ 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):
     self.dd._sendCommand(self.layer_id, "margin")
-  def backgroundColor(self, color):
-    self.dd._sendCommand(self.layer_id, "bgcolor", _DD_COLOR_ARG(color))
+  def backgroundColor(self, color, opacity = 100):
+    '''
+    :param opacity: background opacity (0 - 100)
+    :return:
+    '''
+    if opacity < 100:
+      self.dd._sendCommand(self.layer_id, "bgcolor", _DD_COLOR_ARG(color), str(opacity))
+    else:
+      self.dd._sendCommand(self.layer_id, "bgcolor", _DD_COLOR_ARG(color))
   def noBackgroundColor(self):
     self.dd._sendCommand(self.layer_id, "nobgcolor")
   def clear(self):
@@ -103,7 +113,7 @@ def flashArea(self, x, y):
     self.dd._sendCommand(self.layer_id, "flasharea", str(x), str(y))
   # def writeComment(self, comment):
   #   self.dd.writeComment(comment)
-  def enableFeedback(self, auto_feedback_method = "fa", feedback_handler = None):
+  def enableFeedback(self, auto_feedback_method, feedback_handler = None):
     '''
     rely on getFeedback() being called */
     :param auto_feedback_method:
@@ -125,7 +135,7 @@ def disableFeedback(self):
     '''disable feedback'''
     self.dd._sendCommand(self.layer_id, "feedback", _DD_BOOL_ARG(False))
     self._feedback_handler = None
-  def getFeedback(self):
+  def getFeedback(self) -> DDFeedback:
     '''
     get any feedback as the structure {type, x, y}
     :return: None if none (or when "handler" set)
@@ -158,20 +168,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))
 
 
 

dumbdisplay/_ddlayer_7segrow.py

@@ -8,7 +8,7 @@ def __init__(self, dd, digit_count = 1):
     :param dd: DumbDisplay object
     :param digit_count: number of digits / # rows
     '''
-    layer_id = dd._createLayer(str("7segrow"), str(digit_count))
+    layer_id = dd._createLayer("7segrow", str(digit_count))
     super().__init__(dd, layer_id)
   def segmentColor(self, color):
     '''set segment color'''