Develop

.gitignore

@@ -2,6 +2,8 @@
 /.vscode
 /venv
 
+__pycache__
+
 /MicroPythonDumbDisplay.iml
 /MicroPythonDumbDisplay.code-workspace
 
@@ -17,3 +19,4 @@
 
 uDumbDisplay.code-workspace
 /OLD.md
+/setup_OLD.py

README.md

@@ -1,5 +1,5 @@
 
-# DumbDisplay MicroPython Library (v0.5.0)
+# DumbDisplay MicroPython Library (v0.6.0)
 
 DumbDisplay MicroPython Library -- workable with Python 3 -- is a port of the [DumbDisplay Arduino Library](https://github.com/trevorwslee/Arduino-DumbDisplay)
 to MicroPython / Python 3 for the [DumbDisplay Android app](https://play.google.com/store/apps/details?id=nobody.trevorlee.dumbdisplay)
@@ -135,7 +135,7 @@ Other then the `DumbDisplay` object, you will need to create one or more layer o
   |:--:|
   |<img style="width: 300px; height: 300px;" src="screenshots/layer_lcd.png"></img>|
 
-- `LayerGraphical` -- a graphical LCD that you can draw to with common drawing directives
+- `LayerGraphical` -- a graphical LCD that you can draw to with common TFT LCD drawing directives
   ```
   from dumbdisplay.core import *
   from dumbdisplay.layer_graphical import *
@@ -148,31 +148,46 @@ Other then the `DumbDisplay` object, you will need to create one or more layer o
   |:--:|
   |<img style="width: 300px; height: 300px;" src="screenshots/layer_graphical.png"></img>|
 
-- `LayerSelection` -- a row / column / grid of TEXT based LCDs mostly for showing selection choices
+- `Layer7SegmentRow` -- a single 7-segment digit, or a row of **n** 7-segments digits
   ```
   from dumbdisplay.core import *
-  from dumbdisplay.layer_selection import *
+  from dumbdisplay.layer_7segrow import *
   dd = DumbDisplay()
-  l = LayerSelection(dd)
+  l = Layer7SegmentRow(dd)
+  ```
+
+  example:
+  |[`demo_Layer7SegmentRow()` in `dd_demo.py`](dd_demo.py)|
+  |:--:|
+  |<img style="width: 300px; height: 300px;" src="screenshots/layer_7segment_3d.png"></img>|
+- 
+- `LayerTurtle` -- a Python Turtle like canvas that you can draw to using Python Turtle like commands
+  ```
+  from dumbdisplay.core import *
+  from dumbdisplay.layer_turtle import *
+  dd = DumbDisplay()
+  l = LayerTurtle(dd)
   ```
 
   example:
-  |[`demo_LayerSelection()` in `dd_demo.py`](dd_demo.py)|
+  |[`demo_LayerTurtle()` in `dd_demo.py`](dd_demo.py)|
   |:--:|
-  |<img style="width: 300px; height: 300px;" src="screenshots/layer_selection_1x3.png"></img>|
+  |<img style="width: 300px; height: 300px;" src="screenshots/layer_turtle.png"></img>|
 
-- `Layer7SegmentRow` -- a single 7-segment digit, or a row of **n** 7-segments digits
+
+- `LayerSelection` -- a row / column / grid of TEXT based LCDs mostly for showing selection choices
   ```
   from dumbdisplay.core import *
-  from dumbdisplay.layer_7segrow import *
+  from dumbdisplay.layer_selection import *
   dd = DumbDisplay()
-  l = Layer7SegmentRow(dd)
+  l = LayerSelection(dd)
   ```
-  
+
   example:
-  |[`demo_Layer7SegmentRow()` in `dd_demo.py`](dd_demo.py)|
+  |[`demo_LayerSelection()` in `dd_demo.py`](dd_demo.py)|
   |:--:|
-  |<img style="width: 300px; height: 300px;" src="screenshots/layer_7segment_3d.png"></img>|
+  |<img style="width: 300px; height: 300px;" src="screenshots/layer_selection_1x3.png"></img>|
+
 
 - `LayerPlotter` -- a "plotter" for plotting real-time data
   ```
@@ -213,7 +228,7 @@ Other then the `DumbDisplay` object, you will need to create one or more layer o
 
   as shown in the example
   * you can configure the joystick to be a horizontal or vertical slider by changing the `directions` parameter to `LayerJoystick`
-    - param `maxStickValue`: the max value of the stick; e.g. 255 or 1023 (the default); min is 15
+    - param `max_stick_value`: 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"
   * feedback -- to be talked about later -- is enabled by default, and you can poll for feedback like
@@ -334,6 +349,12 @@ MIT
 
 # Change History
 
+v0.6.0
+- added DDRootLayer
+- added LayerTurtle
+- added more examples
+- bug fixes
+
 v0.5.0
 - ported "level options" for LayerGraphical 
 - ported LayerSelection

_dev_test.py

@@ -1,8 +1,5 @@
 import random
-import time
-import math
-
-
+from dumbdisplay.full import *
 from dumbdisplay_examples.utils import create_example_wifi_dd
 
 
@@ -25,6 +22,179 @@ def run_melody():
     import samples.melody.main
 
 
+def test_turtleTracked():
+    from dumbdisplay.layer_turtle import LayerTurtleTracked
+    dd = create_example_wifi_dd()
+    l = LayerTurtleTracked(dd, 2000, 2000)
+    l.backgroundColor("ivory")
+    l.border(3, "blue")
+    if True:
+        sync = True
+        distance = 1
+        angle = 10
+        for i in range(0, 180):
+            l.penColor("red")
+            l.penSize(20)
+            l.forward(distance)
+            l.rightTurn(angle)
+            distance += 1
+            coor = l.pos(sync=sync)
+            if True:
+                l.goTo(0, 0, with_pen=False)
+                l.penColor("blue")
+                l.penSize(10)
+                l.circle(15 * i, centered=True)
+            l.goTo(coor[0], coor[1], with_pen=False)
+            print(f"* LOOP[{i}] turtle pos: {coor}")
+            if not sync:
+                dd.sleep(0.1)
+    else:
+        l.forward(100)
+        coor = l.pos()
+        print(f"* INIT turtle pos: {coor}")
+        l.forward(100)
+        coor = l.pos()
+        print(f"* INIT 2 turtle pos: {coor}")
+    while True:
+        coor = l.pos()
+        print(f"* turtle pos: {coor}")
+        dd.sleep(2)
+
+def test_passive_turtleTracked(sync: bool = True):
+    from dumbdisplay.layer_turtle import LayerTurtleTracked
+    def _setup(dd: DumbDisplay) -> LayerTurtleTracked:
+        l = LayerTurtleTracked(dd, 2000, 2000)
+        l.backgroundColor("ivory")
+        l.border(3, "blue")
+        return l
+    def _loop(l: LayerTurtleTracked, i: int, distance: int):
+        l.penColor("red")
+        l.penSize(20)
+        l.forward(distance)
+        l.rightTurn(10)
+        if True:
+            r = 50 + int(random.random() * 30)
+            r2 = r + 10 + int(random.random() * 20)
+            a = int(random.random() * 45)
+            a2 = a + 10 + int(random.random() * 45)
+            centered = random.random() < 0.5
+            l.penColor("green")
+            l.penSize(10)
+            shape = i % 7
+            if shape == 0:
+                l.rectangle(r, r2, centered=centered)
+            elif shape == 1:
+                l.centeredPolygon(r, 5, inside=centered)
+            elif shape == 2:
+                l.polygon(r, 5)
+            elif shape == 3:
+                l.arc(r, r2, a, a2, centered=centered)
+            elif shape == 4:
+                l.circle(r, centered=centered)
+            elif shape == 5:
+                l.isoscelesTriangle(r, a)
+            else:
+                l.dot(r, color="darkblue")
+        coor = l.pos(sync=sync)
+        if i % 2 == 0:
+            l.goTo(0, 0, with_pen=False)
+            l.penColor("blue")
+            l.penSize(5)
+            r = 5 * i
+            l.circle(r, centered=True)
+            l.goTo(coor[0], coor[1], with_pen=False)
+        print(f"* LOOP[{i}] turtle pos: {coor}")
+        # if not sync:
+        #     l.dd.sleep(0.2)
+    dd = create_example_wifi_dd()
+    distance = 1
+    i = 0
+    l: LayerTurtleTracked = None
+    freeze_for_steps = 10
+    while True:
+        (connected, reconnecting) = dd.connectPassive()
+        if connected:
+            if l is None:
+                l = _setup(dd)
+                # if freeze_for_steps > 0:
+                #     dd.freezeDrawing()
+                distance = 1
+                i = 0
+            else:
+              if reconnecting:
+                dd.masterReset()
+                l = None
+              else:
+                if i <= 300:
+                    if i < 300:
+                        # if freeze_for_steps > 0 and i == 0:
+                        #     dd.freezeDrawing()
+                        _loop(l, i=i, distance=distance)
+                        if freeze_for_steps > 0:
+                            if (i + 1) % freeze_for_steps == 0:
+                                dd.unfreezeDrawing(refreeze_after_draw=True)
+                                print(f"  --- unfreeze")
+                    else:
+                        if freeze_for_steps > 0:
+                            dd.unfreezeDrawing()
+                            print(f"  --- FINAL[{i}] unfreeze")
+                else:
+                    coor = l.pos(sync=sync)
+                    print(f"* ENDED[{i}] turtle pos: {coor}")
+                    l.dd.sleep(1)
+                    if i > 305:
+                        l.clear()
+                        l.home(with_pen=False)
+                        distance = 0
+                        i = -1
+                distance = distance + 1
+                i = i + 1
+
+
+
+def test_auto_pin_remaining():
+    rooted = True
+
+    dd = create_example_wifi_dd()
+
+    if rooted:
+        root_layer = DDRootLayer(dd, 200, 300)
+        root_layer.border(5, "darkgreen")
+        root_layer.backgroundColor("lightgreen")
+    status_layer = LayerGraphical(dd, 300, 80)
+    dd.configPinFrame(100, 100)
+    dd.pinLayer(status_layer, 0, 0, 100, 35)
+
+    test_remaining = True
+
+    ll = []
+    if test_remaining:
+        dd.pinAutoPinLayers(AutoPin("H").build(), 0, 35, 100, 65)
+        for i in range(3):
+            l = LayerLedGrid(dd, i + 1, i + 1)
+            l.offColor("yellow")
+            ll.append(l)
+        dd.addRemainingAutoPinConfig(AutoPin("V", ll[0], ll[1]).build())
+    else:
+        l1 = LayerLedGrid(dd)
+        l1.offColor("yellow")
+        l2 = LayerLedGrid(dd, 2, 2)
+        l2.offColor("pink")
+        dd.pinAutoPinLayers(AutoPin("H", l1, l2).build(), 0, 35, 100, 65)
+        ll.append(l1)
+        ll.append(l2)
+
+    while True:
+        for l in ll:
+            l.toggle()
+        print("... ", end="")
+        dd.sleep(1)
+        print("...")
+        if dd.isReconnecting():
+            break # since haven't setup for reconnection (like with recordLayerSetupCommands) ... may as well break out of the loop
+    print("... ASSUME disconnected")
+
+
 def test_margin():
     from dumbdisplay.layer_ledgrid import LayerLedGrid
     dd = create_example_wifi_dd()
@@ -51,22 +221,6 @@ def run_passive_blink_app():
     app.run()
 
 
-def run_sliding_puzzle_app():
-    from dumbdisplay_examples.sliding_puzzle.sliding_puzzle_app import SlidingPuzzleApp
-    print(f"*** SlidingPuzzleApp ***")
-    suggest_move_from_dir_func = lambda board_manager: random.randint(0, 3)
-    app = SlidingPuzzleApp(dd=create_example_wifi_dd(), suggest_move_from_dir_func=suggest_move_from_dir_func)
-    app.run()
-
-def run_mnist_app():
-    from dumbdisplay_examples.mnist.mnist_app import MnistApp
-    print(f"*** MnistApp ***")
-    inference_func = lambda board_manager: random.randint(0, 9)
-    app = MnistApp(dd=create_example_wifi_dd(), inference_func=inference_func)
-    app.run()
-
-
-
 def test_read_readme():
     from pathlib import Path
     this_directory = Path(__file__).parent
@@ -81,27 +235,20 @@ def test_find_packages():
 
 
 if __name__ == "__main__":
-    #test_LayerLedGrid(2, 2)
-    #test_LayerLcd()
-    #test_LayerGraphical()
-    #test_Layer7SegmentRow()
-    #test_LayerSelection()
-    #test_LayerPlotter()
-
-    test_AutoPin()
-
-    #run_passive_blink_app()
-    #run_sliding_puzzle_app()
-    #run_mnist_app()
 
-    #run_debug()
-    #run_doodle()
-    #run_graphical()
-    #run_melody()
+    test_passive_turtleTracked(sync=True)
 
-    #test_margin()
 
-    #run_debugBlepriority("MyBLEDevice")
+    #test_auto_pin_remaining()
 
-    #test_read_readme()
-    #test_find_packages()
+    # run_debug()
+    # run_doodle()
+    # run_graphical()
+    # run_melody()
+    #
+    # test_margin()
+    #
+    # run_debugBlepriority("MyBLEDevice")
+    #
+    # test_read_readme()
+    # test_find_packages()