chumicro-knobs 0.1.0__tar.gz → 0.1.2__tar.gz

{chumicro_knobs-0.1.0 → chumicro_knobs-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: chumicro-knobs
-Version: 0.1.0
+Version: 0.1.2
 Summary: Rotary encoders and analog knobs, read as a position that holds still
 Project-URL: Homepage, https://github.com/ChuMicro/ChuMicro
 Project-URL: Documentation, https://chumicro.com/ChuMicro/knobs/stable/
@@ -74,6 +74,23 @@ while True:
 
 The loop never pauses, so the rest of your program keeps running between turns.  `just_moved` is true for exactly one pass, which means you can read it as many times as you like without it firing twice.
 
+In a program with more going on, hand the loop to [`chumicro-runner`](https://github.com/ChuMicro/ChuMicro/tree/main/libraries/runner) and let the callback do the reading:
+
+```python
+from chumicro_runner import Runner
+
+volume.on_change = lambda detents: print("volume", volume.position)
+
+runner = Runner()
+runner.add(volume)
+
+while True:
+    now = runner.tick()
+    runner.wait(now)
+```
+
+Every service in your program shares those same two lines.
+
 ## A fast spin arrives whole
 
 An encoder reports movement as pulses on two signal pins, and one brisk flick of the wrist sends dozens of them.  If your loop stalls on a socket read or a flash write, a plain pin read looks at the wrong moments and most of the turn is gone.  The counting here happens outside your loop, so a tick that arrives late still reads the whole spin.

{chumicro_knobs-0.1.0 → chumicro_knobs-0.1.2}/README.md

@@ -47,6 +47,23 @@ while True:
 
 The loop never pauses, so the rest of your program keeps running between turns.  `just_moved` is true for exactly one pass, which means you can read it as many times as you like without it firing twice.
 
+In a program with more going on, hand the loop to [`chumicro-runner`](https://github.com/ChuMicro/ChuMicro/tree/main/libraries/runner) and let the callback do the reading:
+
+```python
+from chumicro_runner import Runner
+
+volume.on_change = lambda detents: print("volume", volume.position)
+
+runner = Runner()
+runner.add(volume)
+
+while True:
+    now = runner.tick()
+    runner.wait(now)
+```
+
+Every service in your program shares those same two lines.
+
 ## A fast spin arrives whole
 
 An encoder reports movement as pulses on two signal pins, and one brisk flick of the wrist sends dozens of them.  If your loop stalls on a socket read or a flash write, a plain pin read looks at the wrong moments and most of the turn is gone.  The counting here happens outside your loop, so a tick that arrives late still reads the whole spin.

chumicro_knobs-0.1.2/VERSION

@@ -0,0 +1 @@
+0.1.2

{chumicro_knobs-0.1.0 → chumicro_knobs-0.1.2}/docs/guide.md

@@ -37,6 +37,23 @@ from machine import Pin
 volume = Encoder(Pin(16), Pin(17))
 ```
 
+In a program with more going on, hand the loop to `chumicro-runner` and let the callback do the reading:
+
+```python
+from chumicro_runner import Runner
+
+volume.on_change = lambda detents: print("volume", volume.position)
+
+runner = Runner()
+runner.add(volume)
+
+while True:
+    now = runner.tick()
+    runner.wait(now)
+```
+
+The [runner section](#runner-pattern) below covers pacing an analog knob's conversions with `period_ms`.
+
 ## Reading the encoder
 
 Every reading is a plain attribute, refreshed by `check()`:
@@ -154,6 +171,21 @@ while True:
         print("brightness", brightness.value)     # 0 through 9
 ```
 
+Or on the runner, paced to fifty conversions a second:
+
+```python
+from chumicro_runner import Runner
+
+brightness.on_change = lambda step: print("brightness", step)
+
+runner = Runner()
+runner.add(brightness, period_ms=20)
+
+while True:
+    now = runner.tick()
+    runner.wait(now)
+```
+
 `steps` defaults to 100, held in `DEFAULT_STEPS`, which puts the middle of the sweep at 50 and the top at 99.  `delta` is the change for this tick, negative when the knob comes back down, and `raw` is the settled reading on the 0 to 65535 scale that `value` was worked out from:
 
 ```python

{chumicro_knobs-0.1.0 → chumicro_knobs-0.1.2}/docs/index.md

@@ -23,6 +23,23 @@ while True:
 
 `just_moved` is true for exactly one pass of the loop, so you can read it as often as you like without it firing twice.  `bounds` walks the number between 0 and 20 and stops it at both ends.
 
+In a program with more going on, hand the loop to `chumicro-runner` and let the callback do the reading:
+
+```python
+from chumicro_runner import Runner
+
+volume.on_change = lambda detents: print("volume", volume.position)
+
+runner = Runner()
+runner.add(volume)
+
+while True:
+    now = runner.tick()
+    runner.wait(now)
+```
+
+Every service in your program shares those same two lines.
+
 ## Documentation
 
 - [User Guide](guide.md): wiring an encoder, bounds and wrap, reading a potentiometer, the deadband that holds it still, callbacks, and wiring into a runner

chumicro_knobs-0.1.0/VERSION

@@ -1 +0,0 @@
-0.1.0