Merge pull request #1 from trevorwslee/develop

Develop

Author: trevorwslee

.gitignore

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

README.md

@@ -1,4 +1,4 @@
-# DumbDisplay MicroPython Library (v0.2.2) #
+# DumbDisplay MicroPython Library (v0.3.0)
 
 DumbDisplay MicroPython Library is a port of the Arduino DumbDisplay Library (https://github.com/trevorwslee/Arduino-DumbDisplay)
 for the DumbDisplay Android app -- https://play.google.com/store/apps/details?id=nobody.trevorlee.dumbdisplay
@@ -105,7 +105,7 @@ l_b.enableFeedback("f", feedback_handler)
 l.enableFeedback("fs:rpt50", feedback_handler)
 AutoPin('V', AutoPin('H', l_r, l_g, l_b), l).pin(dd)
 while True:
-    dd.delay(1)
+    dd.sleep(1)
 ```
 
 
@@ -120,15 +120,15 @@ Notes:
 
 
 
-## Enjoy! May God bless you! Peace be with you! Jesus loves you! ##
+## Enjoy! Peace be with you! May God bless you! Jesus loves you!
 
 
 
 # Change History
 
 v0.3.0
 - checked Raspberry Pi Pico W WIFI support
-- port more options from Arduino DumbDisplay library
+- ported more options from Arduino DumbDisplay library
 - bug fixes
 
 v0.2.1

dumbdisplay/_ddimpl.py

@@ -15,11 +15,20 @@
 
 _HS_GAP: int = 1000
 
+_RECONNECT_NO_KEEP_ALIVE_MS: int = 5000
+_VALIDATE_GAP: int = 1000
+_RECONNECTING_VALIDATE_GAP: int = 500
+
 
 class IOProxy:
   def __init__(self, io):
     self._io = io
     self.data: str = ''
+    self.last_keep_alive_ms = 0
+    self.reconnect_keep_alive_ms = 0
+    self.reconnecting = False
+    self.reconnect_enabled = False
+    self.reconnect_RC_id = None
   def available(self):
     done = '\n' in self.data
     while (not done) and self._io.available():
@@ -40,6 +49,48 @@ def read(self) -> str:
   #  self.data = ''
   def print(self, s):
     self._io.print(s)
+  def keepAlive(self):
+    self.last_keep_alive_ms = time.ticks_ms()
+  def setReconnectRCId(self, rc_id: str):
+    ### reconnect not working yet
+    self.reconnect_RC_id = rc_id
+    self.reconnect_enabled = True
+    self.reconnect_keep_alive_ms = 0
+  def validateConnection(self) -> bool:
+    #print("validateConnection")
+    diff_ms = -1
+    need_reconnect = False
+    if self.last_keep_alive_ms > 0:
+      now = time.ticks_ms()
+      diff_ms = now - self.last_keep_alive_ms
+      if diff_ms > _RECONNECT_NO_KEEP_ALIVE_MS:
+        need_reconnect = True
+    if True:
+      if need_reconnect:
+        if self.reconnect_enabled:
+          print("disconnected ... reconnecting ... ", self.reconnect_RC_id, diff_ms)
+        else:
+          print("disconnected")
+    if need_reconnect:
+      self.reconnecting = True
+    if need_reconnect and self.reconnect_enabled:
+      try:
+        self._io.print("%%>RECON>")
+        self._io.print(_DD_SID)
+        self._io.print(":")
+        self._io.print(self.reconnect_RC_id)
+        self._io.print("\n")
+      except:
+        pass
+      self.reconnect_keep_alive_ms = self.last_keep_alive_ms
+    elif self.reconnect_keep_alive_ms > 0:
+      self.reconnecting = False
+      #_ConnectVersion = _ConnectVersion + 1;
+      self.reconnect_keep_alive_ms = 0
+      self.last_keep_alive_ms = time.ticks_ms()
+    return not need_reconnect
+  def isReconnecting(self) -> bool:
+    return self.reconnecting;
 
 _NextLayerNid: int = 0
 def _AllocLayerNid():
@@ -57,14 +108,21 @@ def __init__(self, io: DDInputOutput):
     self._connected_iop: IOProxy = None
     self._layers: dict[DDLayer] = {}
     self._tunnels: dict = {}
-    
+    self.last_validate_ms = 0
+
   def timeslice(self):
     self._checkForFeedback()
 
   def delay(self, seconds: float = 0):
-    self.delay_ms(seconds * 1000)
+    '''
+    use sleep() instead
+    '''
+    self.sleep_ms(seconds * 1000)
+
+  def sleep(self, seconds: float = 0):
+    self.sleep_ms(seconds * 1000)
 
-  def delay_ms(self, ms: int = 0):
+  def sleep_ms(self, ms: int = 0):
     self._checkForFeedback()
     until_ms = int(time.ticks_ms() + ms)
     while True:
@@ -90,11 +148,13 @@ def release(self):
     self._connected = False
     self._connected_iop = None
 
-  def toggleDebugLed(self):
+  # def toggleDebugLed(self):
+  #   pass
+  # def switchDebugLed(self, on):
+  #   pass
+  def onDetectedDisconnect(self):
     pass
-  def switchDebugLed(self, on):
-    pass
-  def onSendCommandException(self, os_error):
+  def onSendCommandException(self, error):
     pass
 
   def _allocLayerNid(self):
@@ -109,9 +169,8 @@ def _createLayer(self, layer_type: str, *params) -> str:
     layer_id = str(self._allocLayerNid())
     self._sendCommand(layer_id, "SU", layer_type, *params)
     return layer_id
-  def _reorderLayer(self, layer_id: str, how: str): {
+  def _reorderLayer(self, layer_id: str, how: str):
     self._sendCommand(layer_id, "REORD", how)
-  }   
   def _deleteLayer(self, layer_id: str):
     self._sendCommand(layer_id, "DEL")
   def _onCreatedLayer(self, layer: DDLayer):
@@ -129,7 +188,7 @@ def _connect(self):
     if self._connected:
       return
 
-    self.switchDebugLed(True)
+    #self.switchDebugLed(True)
     self._io.preconnect()
 
     # > ddhello and < ddhello
@@ -139,7 +198,7 @@ def _connect(self):
       now = time.ticks_ms()
       if now > next_time:
         iop.print('ddhello\n')
-        self.toggleDebugLed()
+        #self.toggleDebugLed()
         next_time = now + _HS_GAP
       if iop.available():
         data = iop.read()
@@ -156,7 +215,7 @@ def _connect(self):
       now = time.ticks_ms()
       if now > next_time:
           iop.print('>init>:' + _DD_SID + '\n')
-          self.toggleDebugLed()
+          #self.toggleDebugLed()
           next_time = now + _HS_GAP
       if iop.available():
         data = iop.read()
@@ -170,12 +229,12 @@ def _connect(self):
 
     self._connected = True  
     self._compatibility = compatibility
-    self.switchDebugLed(False)
+    #self.switchDebugLed(False)
     #print('connected:' + str(compatibility))
 
   def _sendSpecial(self, special_type: str, special_id: str, special_command: str, special_data: str):
     ##print("lt:" + str(special_command) + ":" + str(special_data))#####
-    self.switchDebugLed(True)
+    #self.switchDebugLed(True)
     self._io.print('%%>')
     self._io.print(special_type)
     self._io.print('.')
@@ -187,10 +246,10 @@ def _sendSpecial(self, special_type: str, special_id: str, special_command: str,
     if special_data != None:
       self._io.print(special_data)
     self._io.print('\n')
-    self.switchDebugLed(False)
+    #self.switchDebugLed(False)
   def _sendCommand(self, layer_id: str, command: str, *params):
     self._checkForFeedback()
-    self.switchDebugLed(True)
+    #self.switchDebugLed(True)
     try:
       if layer_id != None:
         self._io.print(layer_id)
@@ -202,11 +261,12 @@ def _sendCommand(self, layer_id: str, command: str, *params):
         else:
           self._io.print(',')
         self._io.print(params[i])
-    except OSError as e:
-      self.switchDebugLed(False)
+      self._io.print('\n')
+    except Exception as e:
+      #self.switchDebugLed(False)
       self.onSendCommandException(e)
-    self._io.print('\n')
-    self.switchDebugLed(False)
+    #self._io.print('\n')
+    #self.switchDebugLed(False)
 
 
 
@@ -215,8 +275,10 @@ def _checkForFeedback(self):
     if feedback != None:
       if len(feedback) > 0:
         if feedback[0:1] == '<':
+          self._onFeedbackKeepAlive()
           if len(feedback) == 1:
-            self._onFeedbackKeepAlive()
+            pass
+            #self._onFeedbackKeepAlive()
           else:
             #print(feedback)####
             if feedback.startswith('<lt.'):
@@ -265,19 +327,30 @@ def _checkForFeedback(self):
             except:
               pass
   def _readFeedback(self) -> str:
+    if not self._validateConnection():
+      self.onDetectedDisconnect()
     if not self._connected_iop.available():
       return None
     feedback = self._connected_iop.read()
     #self._connected_iop.clear()
     return feedback
   def _onFeedbackKeepAlive(self):
-    pass
-  # def _onFeedback(self, lid, type, x, y):
-  #   layer = self.layers.get(lid)
-  #   if layer != None:
-  #     layer._handleFeedback(type, x, y)
-  #     #print("FB: " + layer.layer_id + '.' + type + ':' + str(x) + ',' + str(y))
-
+    if self._connected_iop:
+      self._connected_iop.keepAlive()
+  def _validateConnection(self):
+    if self._connected_iop:
+      validate_gap = _RECONNECTING_VALIDATE_GAP if self._connected_iop.isReconnecting() else _VALIDATE_GAP
+      now = time.ticks_ms()
+      diff_ms = now - self.last_validate_ms
+      if diff_ms >= validate_gap:
+        res = self._connected_iop.validateConnection()
+        self.last_validate_ms = now
+      else:
+        res = True
+      return res
+  def _setReconnectRCId(self, rc_id: str):
+    if self._connected_iop:
+        self._connected_iop.setReconnectRCId(rc_id)
   def _createTunnel(self, end_point):
     tunnel_id = str(self._allocTunnelNid())
     self._sendSpecial("lt", tunnel_id, "connect", end_point)

dumbdisplay/_ddio_socket.py

@@ -44,11 +44,13 @@ def print(self, s):
     while all > count:
       try:
         count = self.conn.send(data[count:])
-      except OSError as e:
-        if e.args[0] == 11:
-          pass
-        else:
-          raise e
+      except Exception as e:
+        raise e
+      # except OSError as e:
+      #   if e.args[0] == 11:
+      #     pass
+      #   else:
+      #     raise e
     #self.conn.sendall(data)
   def close(self):
     if self.conn != None:

dumbdisplay/_ddlayer.py

@@ -36,6 +36,9 @@ def __init__(self, dd, layer_id):
   def visibility(self, visible):
     '''set layer visibility'''
     self.dd._sendCommand(self.layer_id, "visible", _DD_BOOL_ARG(visible))
+  def disabled(self, disabled: bool = True):
+    '''set layer disabled'''
+    self.dd._sendCommand(self.layer_id, "disabled", _DD_BOOL_ARG(disabled))
   def transparent(self, transparent: bool):
     self.dd._sendCommand(self.layer_id, "transparent", _DD_BOOL_ARG(transparent))
   def opacity(self, opacity: int):
@@ -73,9 +76,18 @@ def padding(self, left, top = None, right = None, bottom = None):
       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, right, bottom):
+  def margin(self, left, top = None, right = None, bottom = None):
     '''see border() for size unit'''
-    self.dd._sendCommand(self.layer_id, "margin", str(left), str(top), str(right), str(bottom))
+    if top == None and right == None and bottom == None:
+      self.dd._sendCommand(self.layer_id, "margin", str(left))
+    else:
+      if top == None:
+        top = left
+      if right == None:
+        right = left
+      if bottom == 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):

dumbdisplay/_ddlayer_graphical.py

@@ -46,7 +46,7 @@ def drawChar(self, x, y, char, color, bg_color = "", size = 0):
   def drawStr(self, x, y, string, color, bg_color = "", size = 0):
     '''
     :param bg_color: "" means default
-    :param size: 0 means defajult
+    :param size: 0 means default
     '''
     self.dd._sendCommand(self.layer_id, "drawstr", str(x), str(y), _DD_COLOR_ARG(color), _DD_COLOR_ARG(bg_color), str(size), string)
   def drawPixel(self, x, y, color):