going for v0.3.0

trevorwslee · trevorwslee · commit dc49d9a99e99 · 2023-09-20T23:25:11.000+08:00
diff --git a/dumbdisplay/_ddlayer.py b/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"
@@ -125,7 +128,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)
diff --git a/dumbdisplay/_ddlayer_7segrow.py b/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'''
diff --git a/dumbdisplay/_ddlayer_graphical.py b/dumbdisplay/_ddlayer_graphical.py
@@ -9,7 +9,7 @@ def __init__(self, dd, width, height):
     :param width: width
     :param height: height
     '''
-    layer_id = dd._createLayer(str("graphical"), _DD_INT_ARG(width), _DD_INT_ARG(height))
+    layer_id = dd._createLayer("graphical", _DD_INT_ARG(width), _DD_INT_ARG(height))
     super().__init__(dd, layer_id)
   def setCursor(self, x, y):
     self.dd._sendCommand(self.layer_id, "setcursor", str(x), str(y))
diff --git a/dumbdisplay/_ddlayer_joystick.py b/dumbdisplay/_ddlayer_joystick.py
@@ -0,0 +1,36 @@
+from ._ddlayer import DDLayer
+from ._ddlayer import _DD_COLOR_ARG, _DD_BOOL_ARG, _DD_INT_ARG, _DD_FLOAT_ARG
+
+class DDLayerJoystick(DDLayer):
+  '''Virtual joystick'''
+  def __init__(self, dd, maxStickValue: int = 1023, directions: str = "", stickLookScaleFactor: float = 1.0):
+    '''
+    :param dd: DumbDisplay object
+    :param maxStickValue: the max value of the stick; e.g. 255 or 1023 (the default); min is 15
+    :param directions: "lr" or "hori": left-to-right; "tb" or "vert": top-to-bottom; "rl": right-to-left; "bt": bottom-to-top;
+                        use "+" combines the above like "lr+tb" to mean both directions; "" the same as "lr+tb"
+    :param stickLookScaleFactor: the scaling factor of the stick (UI); 1 by default                    
+    '''
+    layer_id = dd._createLayer("joystick", _DD_INT_ARG(maxStickValue), directions, _DD_FLOAT_ARG(stickLookScaleFactor))
+    super().__init__(dd, layer_id)
+  def autoRecenter(self, auto_recenter: bool = True):
+    self.dd._sendCommand(self.layer_id, "autorecenter", _DD_BOOL_ARG(auto_recenter))
+  def colors(self, stick_color: str, stick_outline_color: str, socket_color: str, socket_outline_color):
+    self.dd._sendCommand(self.layer_id, "colors", _DD_COLOR_ARG(stick_color), _DD_COLOR_ARG(stick_outline_color), _DD_COLOR_ARG(socket_color), _DD_COLOR_ARG(socket_outline_color))
+  def moveToPos(self, x: int, y: int, send_feedback: bool = False):
+    '''
+    move joystick position (if joystick is single directional, will only move in the movable direction)
+    :param bg_color: "" means default
+    :param x: x to move to
+    :param y: y to move to
+    :param send_feedback: if true, will send "feedback" for the move (regardless of the current position)
+    '''
+    self.dd._sendCommand(self.layer_id, "movetopos", str(x), str(y), _DD_BOOL_ARG(send_feedback))
+  def moveToCenter(self, send_feedback: bool = False):
+    '''
+    move joystick to the center
+    :param send_feedback: if true, will send "feedback" for the move (regardless of the current position)
+    '''
+    self.dd._sendCommand(self.layer_id, "movetocenter", _DD_BOOL_ARG(send_feedback))
+
+
diff --git a/dumbdisplay/_ddlayer_lcd.py b/dumbdisplay/_ddlayer_lcd.py
@@ -12,7 +12,7 @@ def __init__(self, dd, col_count = 16, row_count = 2, char_height = 0, font_name
     :param char_height: char height
     :param font_name: font name
     '''
-    layer_id = dd._createLayer(str("lcd"), str(col_count), str(row_count), str(char_height), font_name)
+    layer_id = dd._createLayer("lcd", str(col_count), str(row_count), str(char_height), font_name)
     super().__init__(dd, layer_id)
   def print(self, text):
     self.dd._sendCommand(self.layer_id, "print", str(text))
diff --git a/dumbdisplay/_ddlayer_ledgrid.py b/dumbdisplay/_ddlayer_ledgrid.py
@@ -12,7 +12,7 @@ def __init__(self, dd, col_count = 1, row_count = 1, sub_col_count = 1, sub_row_
     :param sub_col_count: # sub columns of each cell
     :param sub_row_count: # sub rows of each cell
     '''
-    layer_id = dd._createLayer(str("ledgrid"), str(col_count), str(row_count), str(sub_col_count), str(sub_row_count))
+    layer_id = dd._createLayer("ledgrid", str(col_count), str(row_count), str(sub_col_count), str(sub_row_count))
     super().__init__(dd, layer_id)
   def turnOn(self, x = 0, y = 0):
     '''turn on LED @ (x, y)'''
diff --git a/dumbdisplay/_ddlayer_plotter.py b/dumbdisplay/_ddlayer_plotter.py
@@ -11,7 +11,7 @@ def __init__(self, dd, width, height, pixels_per_second = 10):
     :param height: height
     :param pixels_per_second: # pixel to scroll per second
     '''
-    layer_id = dd._createLayer(str("plotterview"), str(width), str(height), str(pixels_per_second))
+    layer_id = dd._createLayer("plotterview", str(width), str(height), str(pixels_per_second))
     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'''
diff --git a/dumbdisplay/_dumbdisplay.py b/dumbdisplay/_dumbdisplay.py
@@ -38,7 +38,9 @@ def _build_layout(self):
       else:
         layout_spec += layer.layer_id
     if layout_spec is not None:
-      layout_spec = str(self.orientation) + '(' + layout_spec + ")"
+      layout_spec = str(self.orientation) + '(' + layout_spec + ')'
+    else:
+      layout_spec = str(self.orientation) + '(*)'
     return layout_spec
 
 
diff --git a/dumbdisplay/core.py b/dumbdisplay/core.py
@@ -1,5 +1,6 @@
 from ._dumbdisplay import DumbDisplay
 from ._dumbdisplay import DDAutoPin as AutoPin
+from ._ddlayer import DDFeedback as Feedback
 
 from ._ddiobase import DD_DEF_PORT
 from ._ddlayer import DD_RGB_COLOR as RGB_COLOR
diff --git a/dumbdisplay/layer_joystick.py b/dumbdisplay/layer_joystick.py
@@ -0,0 +1 @@
+from ._ddlayer_joystick import DDLayerJoystick as LayerJoystick
diff --git a/dumbdisplay/layers.py b/dumbdisplay/layers.py
diff --git a/experiments/picopio/pio_neo_blink.py b/experiments/picopio/pio_neo_blink.py
@@ -6,19 +6,21 @@
 
 
 # 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
+# =============
+# - for the pixels: 1st pixel then 2nd pixel ...
+# - for a pixel (24 bits): G then R then B
+# - for R/G/B (8 bits): most significant bit first
+# timing for a bit:
+# - 0: .4us high + .85us low
+# - 1: .8us high + .45us low
+# if frequency is 20MHz ... i.e. each cycle takes 0.05us
+# - 0: 8 cycles high + 17 cycles low
+# - 1: 16 cycles high + 9 cycles low
 # afterward, delay for 300us
 
+NEO_PIXELS_IN_PIN = 22
 
-@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT)
+@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT)  # SHIFT_LEFT: i.e. most significant bit first
 def neo_prog():
     pull()                       # osr <= number of pixels - 1
     mov(y, osr)                  # y <= number of pixels - 1
@@ -45,12 +47,12 @@ def neo_prog():
     # mov(isr, y)
     # push()
 
-sm = rp2.StateMachine(0, neo_prog, freq=20_000_000, set_base=Pin(22))
+sm = rp2.StateMachine(0, neo_prog, freq=20_000_000, set_base=Pin(NEO_PIXELS_IN_PIN))
 sm.active(1)
 
 def ShowNeoPixels(*pixels):
     '''
-    each pixel RGB is the tuple (r, g, b)
+    each pixel is the tuple (r, g, b)
     '''
     pixel_count = len(pixels)
     sm.put(pixel_count - 1)
@@ -60,10 +62,10 @@ def ShowNeoPixels(*pixels):
             (r, g, b) = pixel
         else:
             (r, g, b) = (0, 0, 0)
-        grb = (g << 16) + (r << 8) + b  # the order is G R B
+        grb = (g << 16) + (r << 8) + b    # the order is G R B
         #print(f". [{i}] = {pixel} ({grb})")
-        sm.put(grb, 8)
-    time.sleep_us(300)
+        sm.put(grb, 8)                    # a word is 32 bits, so, pre-shift out (discard) 8 bits, leaving 24 bits of the GRB
+    time.sleep_us(300)                    # make sure the NeoPixels is reset for the next round
     # res = sm.get()
     # print(f"got result {res}")
 
@@ -92,7 +94,7 @@ def ShowNeoPixels(*pixels):
     Pixels[i] = c
     ShowNeoPixels(*Pixels)
     time.sleep(0.1)
-    Pixels[i] = (0, 0, 0)
+    Pixels[i] = None
     ShowNeoPixels(*Pixels)
     rgb = (rgb + 1) % 3
     i = (i + 1) % NUM_PIXELS    
diff --git a/samples/neopixels/_my_secret.py b/samples/neopixels/_my_secret.py
@@ -0,0 +1,3 @@
+
+WIFI_SSID="your wifi router ssid"
+WIFI_PWD="your wifi router password"
diff --git a/samples/neopixels/main.py b/samples/neopixels/main.py
@@ -0,0 +1,57 @@
+from dumbdisplay.core import *
+from dumbdisplay.layer_graphical import *
+from dumbdisplay.layer_joystick import *
+
+# create DumbDisplay
+if DumbDisplay.runningWithMicropython():
+    # connect using WIFI:
+    # assume a _my_secret.py Python script containing
+    #   WIFI_SSID="SSID"
+    #   WIFI_PWD="PASSWORD"
+    from _my_secret import *
+    from dumbdisplay.io_wifi import *
+    dd = DumbDisplay(io4Wifi(WIFI_SSID, WIFI_PWD))
+else:
+    # connect using Inet (Python Internet connection)
+    from dumbdisplay.io_inet import *
+    dd = DumbDisplay(io4Inet())
+
+import time
+
+
+color_layer = LayerGraphical(dd, 150, 101)
+color_layer.border(5, "black", "round", 2)
+
+r_slider_layer = LayerJoystick(dd, 255, "hori", 0.5)
+r_slider_layer.border(3, "darkred", "round", 1)
+r_slider_layer.colors("red", RGB_COLOR(0xff, 0x44, 0x44), "black", "darkgray")
+
+g_slider_layer = LayerJoystick(dd, 255, "hori", 0.5)
+g_slider_layer.border(3, "darkgreen", "round", 1)
+g_slider_layer.colors("green", RGB_COLOR(0x44, 0xff, 0x44), "black", "darkgray")
+
+b_slider_layer = LayerJoystick(dd, 255, "hori", 0.5)
+b_slider_layer.border(3, "darkblue", "round", 1)
+b_slider_layer.colors("blue", RGB_COLOR(0x44, 0x44, 0xff), "black", "darkgray")
+
+AutoPin('V').pin(dd)
+
+r = 0
+g = 0
+b = 0
+color_layer.backgroundColor(RGB_COLOR(r, g, b))
+while True:
+    old_r = r
+    old_g = g
+    old_b = b
+    fb: Feedback = r_slider_layer.getFeedback()
+    if fb:
+        r = fb.x
+    fb: Feedback = g_slider_layer.getFeedback()
+    if fb:
+        g = fb.x
+    fb: Feedback = b_slider_layer.getFeedback()
+    if fb:
+        b = fb.x
+    if r != old_r or g != old_g or b != old_b:
+        color_layer.backgroundColor(RGB_COLOR(r, g, b))
diff --git a/samples/run_test.py b/samples/run_test.py
@@ -1,6 +1,8 @@
 
 
 if __name__ == "__main__":
-    import melody.main
+    #import neopixels.main
+    #import doodle.main
+    #import melody.main
     #import graphical.main
-    #import doodle.main
+    import ledgrid_onoff.main

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+from ._ddlayer_joystick import DDLayerJoystick as LayerJoystick`