openbricks 2.6.2__tar.gz → 2.7.1__tar.gz

{openbricks-2.6.2 → openbricks-2.7.1}/CHANGELOG.md

@@ -3,6 +3,46 @@
 Versions the unified `openbricks` PyPI package (CLI + MuJoCo sim).
 Firmware versions are tracked separately on the `v*` tag namespace.
 
+## 2.7.1 — the integral cancels the FF deficit during the move
+
+The end-of-run stutter, root-caused with 2.6.2's per-axis stats:
+the forward axis expired 100 wheel-deg (~77 mm) behind with the
+integral supplying 51 dps of a ~250 dps feed-forward deficit — all
+three landings spent walking the robot in, pulse by pulse. pbio's
+integral only grows NEAR the target (remaining-distance band); a
+plant trailing 100 deg entered that band 0.16 s before expiry.
+Their design assumes a factory-calibrated feed-forward; ours isn't.
+
+* Integral growth now gates on TRACKING error (deadzone up to the
+  P-linear region): it engages from move start and cancels the
+  deficit during the motion. Harness: expiry residual 32.8 -> 11.5
+  wheel-deg, integral carrying 420 dps at expiry.
+* Standstill now reads MEASURED axis speed (EMA of the position
+  derivative, glitch-clamped) — pbio's actual signal; command- and
+  ff-based checks each failed a real case.
+* The integral retires by a ~35 ms bleed after done instead of an
+  instant zero (which was itself a command step).
+
+Both sides move: flash 2.7.1 AND `pipx upgrade openbricks`.
+
+## 2.7.0 — run is upload-then-run; flash --with-qtr-init
+
+Two CLI changes, both user-requested:
+
+* **`run` stages to the button slot** (reversing the 1.97.0 run-slot
+  split, deliberately different from Pybricks): the script lands at
+  `/program.mpy` before executing, so a run that fails midway stays
+  rerunnable with the start button — no BLE round trip. The accepted
+  price: one-shot tools (calibrations, diagnostics) replace the
+  button program; re-upload your mission afterwards.
+* **`flash --with-qtr-init`** stores a starter QTR calibration at
+  `/qtr.cal` (reference-bench sweep, default pins 1-10, the exact
+  `save_calibration` format) so line-follow examples work on a
+  fresh hub. Re-run `examples/qtr_calibrate.py` for your own mat
+  and lighting.
+
+CLI-side: `pipx upgrade openbricks` (no reflash needed).
+
 ## 2.6.2 — done requires standstill; per-axis settle diagnostics
 
 Bench (the twitch that survived 2.6.0, now measured): the final

{openbricks-2.6.2/openbricks.egg-info → openbricks-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbricks
-Version: 2.6.2
+Version: 2.7.1
 Summary: openbricks — host-side CLI + MuJoCo-backed simulator for the openbricks MicroPython firmware. Flash, list, run, upload, log; ``openbricks sim`` for the physics simulator.
 Author: openbricks contributors
 License: MIT

{openbricks-2.6.2 → openbricks-2.7.1}/native/_shared/drivebase_core.c

@@ -57,6 +57,11 @@ void ob_drivebase_init(ob_drivebase_t *db,
     db->integ_diff      = 0.0;
     db->ki              = (ob_float_t)OB_DRIVEBASE_DEFAULT_KI;
     db->last_tick_ms    = 0;
+    db->meas_vel_sum    = 0.0;
+    db->meas_vel_diff   = 0.0;
+    db->prev_sum_pos    = 0.0;
+    db->prev_diff_pos   = 0.0;
+    db->have_prev_pos   = false;
     db->landings        = 0;
     db->landing_active  = false;
     db->landing_best_err = 0.0;
@@ -383,17 +388,25 @@ void ob_drivebase_stop(ob_drivebase_t *db) {
 // ---------------------------------------------------------------------
 // Per-tick control law
 
-// Position-integral update, pbio integrator.c rules (2.6.0):
-// decreasing the magnitude is always allowed; growth only happens
-// in the band DEADZONE <= |remaining to endpoint| <= 2*(actuation
-// saturation error), is rate-capped per tick, and the total clamps
-// at the value whose ki-term alone commands ACTUATION_MAX. The
-// deadzone stops stiction hunting at rest; the upper bound stops a
-// far-from-target cruise from winding the integral up; the clamp
-// bounds the authority a wound integral can ever have.
+// Position-integral update (2.7.x): decreasing the magnitude is
+// always allowed; growth happens whenever the TRACKING error is in
+// the band DEADZONE <= |err| <= (P-linear region), is rate-capped
+// per tick, and the total clamps at the value whose ki-term alone
+// commands ACTUATION_MAX. Deliberate deviation from pbio's
+// remaining-distance band (2026-08-17, bench-measured): their
+// near-target-only integral assumes a factory-calibrated
+// feed-forward; ours under-delivered ~250 dps on the reference
+// curve, the plant ran ~100 wheel-deg behind the reference the
+// whole move, and it entered pbio's band only 0.16 s before expiry
+// — integral at 51 dps of a 250 dps deficit, three landings, the
+// end-of-run stutter. Gating on tracking error engages the
+// integral from move start, so it cancels the FF deficit DURING
+// the motion and the reference arrives with the plant on it. The
+// deadzone still stops stiction hunting at rest; the band's upper
+// edge (P saturation) still refuses to wind against a hard stall —
+// the fault latch and watchdog own that case.
 static ob_float_t db_integ_update(ob_float_t *integ,
                                   ob_float_t err,
-                                  ob_float_t target_err,
                                   ob_float_t dt_s,
                                   ob_float_t kp,
                                   ob_float_t ki) {
@@ -413,13 +426,12 @@ static ob_float_t db_integ_update(ob_float_t *integ,
         mag_next = (next < 0) ? -next : next;
         decrease = mag_next < mag_cur;
     }
-    ob_float_t ta = (target_err < 0) ? -target_err : target_err;
+    ob_float_t ea = (err < 0) ? -err : err;
     ob_float_t upper = (kp > 0)
         ? ((ob_float_t)OB_DRIVEBASE_ACTUATION_MAX_DPS / kp)
-          * (ob_float_t)2.0
         : (ob_float_t)0.0;
-    if ((ta >= (ob_float_t)OB_DRIVEBASE_INTEG_DEADZONE_WHEEL_DEG
-         && ta <= upper) || decrease) {
+    if ((ea >= (ob_float_t)OB_DRIVEBASE_INTEG_DEADZONE_WHEEL_DEG
+         && ea <= upper) || decrease) {
         *integ = next;
     }
     if (ki > 0) {
@@ -512,6 +524,32 @@ void ob_drivebase_tick(ob_drivebase_t *db, long now_ms) {
                           ? db->heading_override_wheel_deg
                           : db_diff_pos_encoder(db);
 
+    // 3b. Measured axis speeds: EMA of the position derivative
+    //     (~20 ms window at the 1 kHz tick — smooths the 1-count
+    //     quantization step, fast enough for a 60 dps threshold).
+    if (dt_s > (ob_float_t)0.0) {
+        if (db->have_prev_pos) {
+            // Clamp each raw sample to a physically plausible bound:
+            // a heading-frame jump (gyro re-base, injected test
+            // heading) is a position STEP whose derivative would
+            // poison the EMA for ~100 ms.
+            ob_float_t vmax = (ob_float_t)OB_DRIVEBASE_ACTUATION_MAX_DPS
+                              * (ob_float_t)4.0;
+            ob_float_t rs = (sum_pos - db->prev_sum_pos) / dt_s;
+            ob_float_t rd = (diff_pos - db->prev_diff_pos) / dt_s;
+            if (rs >  vmax) { rs =  vmax; }
+            if (rs < -vmax) { rs = -vmax; }
+            if (rd >  vmax) { rd =  vmax; }
+            if (rd < -vmax) { rd = -vmax; }
+            ob_float_t a = (ob_float_t)0.1;
+            db->meas_vel_sum  += a * (rs - db->meas_vel_sum);
+            db->meas_vel_diff += a * (rd - db->meas_vel_diff);
+        }
+        db->prev_sum_pos  = sum_pos;
+        db->prev_diff_pos = diff_pos;
+        db->have_prev_pos = true;
+    }
+
     // 4. Coupled P + feedforward.
     ob_float_t sum_err  = fwd_target  - sum_pos;
     ob_float_t diff_err = turn_target - diff_pos;
@@ -531,26 +569,24 @@ void ob_drivebase_tick(ob_drivebase_t *db, long now_ms) {
         ob_float_t de_now = db->turn_hold - diff_pos;
         se_now = (se_now < 0) ? -se_now : se_now;
         de_now = (de_now < 0) ? -de_now : de_now;
-        // ...and pbio's STANDSTILL condition: the landing's own
-        // feed-forward must be slow before done may latch, or a
-        // plant crossing the window at speed gets its wheels
-        // released mid-motion by the then= dispatch.
-        ob_float_t vf = (fwd_ff_vel  < 0) ? -fwd_ff_vel  : fwd_ff_vel;
-        ob_float_t vt = (turn_ff_vel < 0) ? -turn_ff_vel : turn_ff_vel;
+        // ...and pbio's STANDSTILL condition on MEASURED speed —
+        // theirs tests the plant, not the command. A command-based
+        // check deadlocks: a wound integral commands hundreds of
+        // dps into an arrived robot, and with error ~0 it never
+        // unwinds; an ff-based check let the same integral latch
+        // done with the wheels genuinely turning.
+        ob_float_t mv_sum  = (db->meas_vel_sum  < 0)
+                             ? -db->meas_vel_sum  : db->meas_vel_sum;
+        ob_float_t mv_diff = (db->meas_vel_diff < 0)
+                             ? -db->meas_vel_diff : db->meas_vel_diff;
         if (se_now < (ob_float_t)OB_DRIVEBASE_DONE_TOL_WHEEL_DEG
             && de_now < (ob_float_t)OB_DRIVEBASE_DONE_TOL_WHEEL_DEG
-            && vf < (ob_float_t)OB_DRIVEBASE_ARRIVAL_SPEED_TOL_DPS
-            && vt < (ob_float_t)OB_DRIVEBASE_ARRIVAL_SPEED_TOL_DPS) {
+            && mv_sum  < (ob_float_t)OB_DRIVEBASE_ARRIVAL_SPEED_TOL_DPS
+            && mv_diff < (ob_float_t)OB_DRIVEBASE_ARRIVAL_SPEED_TOL_DPS) {
             db->fwd_active     = false;
             db->turn_active    = false;
             db->landing_active = false;
             db->done           = true;
-            // Arrived: the integral's job is over. Left wound, it
-            // keeps commanding ki*integ against ZERO error through
-            // the inter-move hold — the probe measured an arrived
-            // robot still pushed at 204 dps.
-            db->integ_sum  = 0.0;
-            db->integ_diff = 0.0;
         }
     }
 
@@ -692,38 +728,38 @@ void ob_drivebase_tick(ob_drivebase_t *db, long now_ms) {
             // beyond the forgive limit is a move that DIDN'T HAPPEN
             // — done stays false and the caller's watchdog raises
             // loudly.
+            ob_float_t amv_sum  = (db->meas_vel_sum  < 0)
+                                  ? -db->meas_vel_sum  : db->meas_vel_sum;
+            ob_float_t amv_diff = (db->meas_vel_diff < 0)
+                                  ? -db->meas_vel_diff : db->meas_vel_diff;
             bool arrived =
                 se < (ob_float_t)OB_DRIVEBASE_DONE_TOL_WHEEL_DEG
-                && de < (ob_float_t)OB_DRIVEBASE_DONE_TOL_WHEEL_DEG;
+                && de < (ob_float_t)OB_DRIVEBASE_DONE_TOL_WHEEL_DEG
+                && amv_sum  < (ob_float_t)OB_DRIVEBASE_ARRIVAL_SPEED_TOL_DPS
+                && amv_diff < (ob_float_t)OB_DRIVEBASE_ARRIVAL_SPEED_TOL_DPS;
             bool capped  = (now_ms - db->settle_start_ms)
                                >= (long)OB_DRIVEBASE_SETTLE_MS
                            && worst < (ob_float_t)
                                   OB_DRIVEBASE_SETTLE_FORGIVE_WHEEL_DEG;
             if (arrived || capped) {
                 db->done = true;
-                db->integ_sum  = 0.0;   // see the arrival-cut latch
-                db->integ_diff = 0.0;
             }
         }
     }
-    // Remaining-to-endpoint errors gate WHERE the integral may grow
-    // (pbio's target_error): during cruise the endpoint is far and
-    // the integral stays parked; through the decel ramp and settle
-    // it engages and squeezes out the tracking lag P alone cannot.
-    ob_float_t fwd_end = db->fwd_active
-        ? db->fwd.start + db->fwd.direction
-          * ((db->fwd.distance < 0) ? -db->fwd.distance : db->fwd.distance)
-        : db->fwd_hold;
-    ob_float_t turn_end = db->turn_active
-        ? db->turn.start + db->turn.direction
-          * ((db->turn.distance < 0) ? -db->turn.distance : db->turn.distance)
-        : db->turn_hold;
+    if (db->done) {
+        // Post-move hold: retire the integral SMOOTHLY (~35 ms
+        // half-life). An instant zero at the done latch was itself
+        // a command step; left wound instead, it pushed an arrived
+        // robot at 204 dps through the inter-move hold. The bleed
+        // is both: shaped on the way out, gone within a tenth of a
+        // second.
+        db->integ_sum  *= (ob_float_t)0.98;
+        db->integ_diff *= (ob_float_t)0.98;
+    }
     ob_float_t integ_sum  = db_integ_update(&db->integ_sum, sum_err,
-                                            fwd_end - sum_pos, dt_s,
-                                            db->kp_sum, db->ki);
+                                            dt_s, db->kp_sum, db->ki);
     ob_float_t integ_diff = db_integ_update(&db->integ_diff, diff_err,
-                                            turn_end - diff_pos, dt_s,
-                                            db->kp_diff, db->ki);
+                                            dt_s, db->kp_diff, db->ki);
 
     ob_float_t fwd_cmd  = fwd_ff_vel  + db->kp_sum  * sum_err
                           + db->ki * integ_sum;

{openbricks-2.6.2 → openbricks-2.7.1}/native/_shared/drivebase_core.h

@@ -164,6 +164,18 @@ typedef struct {
     ob_float_t ki;
     long       last_tick_ms;      // for the integral dt (0 = none yet)
 
+    // Measured axis speeds (2.7.x) — EMA of the position derivative,
+    // wheel-deg/s. pbio's standstill condition tests the PLANT's
+    // speed, not the command: a wound integral can command hundreds
+    // of dps into a robot that is demonstrably at rest, and a
+    // command-based check then deadlocks done (the integral only
+    // unwinds on opposing error, and error is ~0 at arrival).
+    ob_float_t meas_vel_sum;
+    ob_float_t meas_vel_diff;
+    ob_float_t prev_sum_pos;
+    ob_float_t prev_diff_pos;
+    bool       have_prev_pos;
+
     // Landing settle bookkeeping (2.6.0). ``expiry_residual`` is the
     // worst-axis error captured at the move's FIRST profile expiry —
     // the bench-measurable answer to "how big is the gap the settle

{openbricks-2.6.2 → openbricks-2.7.1/openbricks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbricks
-Version: 2.6.2
+Version: 2.7.1
 Summary: openbricks — host-side CLI + MuJoCo-backed simulator for the openbricks MicroPython firmware. Flash, list, run, upload, log; ``openbricks sim`` for the physics simulator.
 Author: openbricks contributors
 License: MIT

{openbricks-2.6.2 → openbricks-2.7.1}/openbricks_dev/__init__.py

@@ -1,4 +1,4 @@
 # SPDX-License-Identifier: MIT
 """openbricks — host-side CLI for flashing and running code on hubs."""
 
-__version__ = "2.6.2"
+__version__ = "2.7.1"

{openbricks-2.6.2 → openbricks-2.7.1}/openbricks_dev/cli.py

@@ -77,6 +77,14 @@ def _build_parser():
         "--baud", default="460800",
         help="esptool flash baud rate. Default: 460800.",
     )
+    p_flash.add_argument(
+        "--with-qtr-init", action="store_true",
+        help="After flashing, store a starter QTR line-sensor "
+             "calibration at /qtr.cal (recorded on the reference "
+             "bench, default pins 1-10) so line-follow examples work "
+             "out of the box. Re-run examples/qtr_calibrate.py for a "
+             "calibration measured on your own mat and lighting.",
+    )
     p_flash.add_argument(
         "--skip-erase", action="store_true",
         help="Skip erase_flash (faster dev loop; leaves stale NVS keys).",

{openbricks-2.6.2 → openbricks-2.7.1}/openbricks_dev/flash.py

@@ -364,6 +364,41 @@ def _wait_for_repl(mpremote, port, timeout_s=20):
     )
 
 
+# Starter QTR calibration shipped by ``--with-qtr-init`` — a real
+# bench sweep (2026-08-17, QTRX-HD-15A on the WRO mat, default pins
+# 1-10; the per-element spans from that run's log). Format matches
+# ``QTRArray.save_calibration``: {"pins", "min", "max"}. A starter
+# file gets a fresh flash line-following immediately; heights, mats
+# and lighting differ, so examples/qtr_calibrate.py remains the way
+# to a calibration measured on YOUR rig.
+_QTR_CAL_PATH = "/qtr.cal"
+_QTR_STARTER_CAL = {
+    "pins": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+    "min": [9346, 4048, 3888, 3728, 3984, 3888, 3824, 3968, 4593, 8658],
+    "max": [44922, 37849, 36024, 35816, 36056, 36536, 32888, 36552,
+            40057, 43834],
+}
+
+
+def _write_qtr_starter_cal(mpremote, port):
+    """Store the starter QTR calibration on the hub filesystem and
+    verify it parses back — a corrupt or truncated write must fail
+    HERE, not as a RuntimeError in the user's first line-follow."""
+    import json
+    payload = json.dumps(_QTR_STARTER_CAL)
+    snippet = (
+        "f = open(%r, 'w'); f.write(%r); f.close(); "
+        "import json; d = json.load(open(%r)); "
+        "print('qtr-cal-ok', len(d['min']), len(d['max']))"
+    ) % (_QTR_CAL_PATH, payload, _QTR_CAL_PATH)
+    rc, out, err = _mpremote_exec(mpremote, port, snippet)
+    if rc != 0 or "qtr-cal-ok 10 10" not in out:
+        _die("failed to write starter QTR calibration:\n" + (err or out))
+    print("starter QTR calibration written to %s (re-run "
+          "examples/qtr_calibrate.py for your own mat/lighting)"
+          % _QTR_CAL_PATH)
+
+
 def _write_hub_name(mpremote, port, name):
     # The name already passed validation in ``_validate_name``; plain
     # bytes literal is safe.
@@ -645,6 +680,9 @@ def run(args):
         _die("verification failed: wrote %r, read back %r" % (args.name, readback))
     print("hub name %r written and verified" % readback)
 
+    if getattr(args, "with_qtr_init", False):
+        _write_qtr_starter_cal(mpremote, args.port)
+
     flashed_version = _write_fw_marker(mpremote, args.port,
                                        firmware_verdict)
 

{openbricks-2.6.2 → openbricks-2.7.1}/openbricks_dev/run.py

@@ -59,16 +59,15 @@ _TARGET_PATH = "/program.py"
 # removes the other — see _compose_runner(remove_stale=...).
 _MPY_TARGET_PATH = "/program.mpy"
 
-# One-shot runs stage to their OWN slot (CLI >= 1.97.0): ``run`` used
-# to share /program.mpy with ``upload``, so every run — including
-# calibrations and diagnostics — silently replaced the program the
-# BUTTON launches. Bench 2026-08-14: upload aa.py, run
+# ``run`` stages to the BUTTON slot (/program.*) — an upload-then-run
+# (user decision 2026-08-17, reversing the 1.97.0 run-slot split and
+# deliberately different from Pybricks): a run that fails mid-way
+# leaves the program on the hub, so the start button reruns it
+# without another BLE round trip. The accepted price is the 1.97.0
+# hazard returning: running a calibration or diagnostic script
+# replaces the button program (bench 2026-08-14: upload aa.py, run
 # qtr_calibrate, press start -> the robot invisibly re-ran the
-# calibration and the report was "button does nothing". The button
-# never reads /run.*, so the two intents can no longer clobber
-# each other.
-_RUN_TARGET_PATH = "/run.py"
-_RUN_MPY_TARGET_PATH = "/run.mpy"
+# calibration) — re-upload your mission after one-shot tools.
 
 # First firmware whose launcher runs /program.mpy (native exec_mpy).
 _MIN_MPY_FIRMWARE = (1, 92, 0)
@@ -744,7 +743,7 @@ async def _run_session(link, name, user_bytes, mpy_bytes):
         await _enter_raw_repl(blink, link)
         try:
             target, use_mpy, remove_stale = await _pick_staging(
-                blink, link, _RUN_MPY_TARGET_PATH, _RUN_TARGET_PATH)
+                blink, link)
             payload = mpy_bytes if use_mpy else user_bytes
             runner = _compose_runner(target, remove_stale)
             await _stage_file(blink, link, target, payload, name)

{openbricks-2.6.2 → openbricks-2.7.1}/tests/test_cli.py

@@ -232,6 +232,8 @@ class DispatchTests(unittest.TestCase):
             ("stop", ["stop", "-n", "X"]),
             ("log", ["log", "-n", "X"]),
             ("servo_id", ["servo-id", "-p", "/p", "3"]),
+            ("pasteprobe", ["paste-probe", "-n", "X"]),
+            ("docs", ["docs"]),
         ]
         for mod_name, argv in cases:
             seen.clear()

{openbricks-2.6.2 → openbricks-2.7.1}/tests/test_flash.py

@@ -524,6 +524,37 @@ class RunHappyPathTests(unittest.TestCase):
                       stderr=""),
         ])
 
+    def test_full_flow_with_qtr_init_writes_the_cal(self):
+        # --with-qtr-init inserts one mpremote exec between the name
+        # readback and the fw marker: the /qtr.cal write+verify.
+        snippets = []
+
+        def _fake_call(cmd):
+            return 0
+
+        run_responses = iter([
+            MagicMock(returncode=1, stdout="", stderr="no repl"),
+            MagicMock(returncode=0, stdout="ok\n", stderr=""),
+            MagicMock(returncode=0, stdout="wrote: 'RobotA'\n", stderr=""),
+            MagicMock(returncode=0, stdout="RobotA\n", stderr=""),
+            MagicMock(returncode=0, stdout="qtr-cal-ok 10 10\n", stderr=""),
+            MagicMock(returncode=0, stdout="9.9.9\n", stderr=""),
+            MagicMock(returncode=0, stdout="marker: 9.9.9:customized\n",
+                      stderr=""),
+        ])
+
+        def _fake_run(cmd, capture_output=True, text=True, timeout=None):
+            snippets.append(cmd[-1])
+            return next(run_responses)
+
+        with patch("subprocess.call", side_effect=_fake_call), \
+             patch("subprocess.run", side_effect=_fake_run):
+            rc = flash.run(self._run_args(with_qtr_init=True))
+
+        self.assertEqual(rc, 0)
+        self.assertTrue(any("'/qtr.cal'" in sn for sn in snippets),
+                        "qtr cal write never composed")
+
     def test_full_flow_success(self):
         # subprocess.call for erase_flash / write_flash / final reset.
         call_history = []
@@ -703,6 +734,53 @@ class ToolMissingTests(unittest.TestCase):
         self.assertIn("esptool not found", str(ctx.exception))
 
 
+class QtrStarterCalTests(unittest.TestCase):
+    """``flash --with-qtr-init`` stores the reference-bench starter
+    calibration at /qtr.cal in exactly the format
+    ``QTRArray.save_calibration`` writes — pins list included, since
+    ``load_calibration`` refuses a file recorded for other wiring."""
+
+    def test_snippet_writes_valid_cal_json(self):
+        import json as _json
+        captured = {}
+
+        def _fake_run(cmd, capture_output=True, text=True, timeout=None):
+            captured["snippet"] = cmd[-1]
+            return MagicMock(returncode=0,
+                             stdout="qtr-cal-ok 10 10\n", stderr="")
+
+        with patch("subprocess.run", side_effect=_fake_run):
+            flash._write_qtr_starter_cal("mpremote", "/dev/ttyUSB0")
+
+        snippet = captured["snippet"]
+        self.assertIn("'/qtr.cal'", snippet)
+        # The staged payload is the repr of a JSON document with the
+        # save_calibration schema: 10 pins, 10 mins, 10 maxes, and
+        # every span positive (min < max) — a starter file that fails
+        # load_calibration would be worse than no file.
+        start = snippet.index("f.write(") + len("f.write(")
+        payload_repr = snippet[start:snippet.index("); f.close()")]
+        payload = eval(payload_repr)   # repr of a str literal
+        data = _json.loads(payload)
+        self.assertEqual(data["pins"], list(range(1, 11)))
+        self.assertEqual(len(data["min"]), 10)
+        self.assertEqual(len(data["max"]), 10)
+        for lo, hi in zip(data["min"], data["max"]):
+            self.assertTrue(0 < lo < hi <= 65535, (lo, hi))
+
+    def test_verification_failure_dies(self):
+        def _fake_run(cmd, capture_output=True, text=True, timeout=None):
+            return MagicMock(returncode=0, stdout="garbage\n", stderr="")
+
+        with patch("subprocess.run", side_effect=_fake_run):
+            try:
+                flash._write_qtr_starter_cal("mpremote", "/p")
+            except flash.FlashError as e:
+                self.assertIn("starter QTR calibration", str(e))
+            else:
+                self.fail("must die on unverified write")
+
+
 class NameWriteSnippetTests(unittest.TestCase):
     """The mpremote ``exec`` snippet must embed the name in a form that
     ``openbricks._read_hub_name`` will accept back (bytes via set_blob)."""

{openbricks-2.6.2 → openbricks-2.7.1}/tests/test_run.py

@@ -339,13 +339,13 @@ class RunFlowTests(unittest.TestCase):
 
         self.assertEqual(rc, 0)
         joined = b"".join(fake.writes)
-        # The SOURCE crossed the link, targeting the run slot's
-        # source path, and no sibling delete was composed. The
-        # button's /program.* is never touched.
+        # The SOURCE crossed the link, targeting the BUTTON slot's
+        # source path (run = upload-then-run since 2.7.0, so a failed
+        # run stays button-rerunnable), and no sibling delete was
+        # composed on the source path.
         self.assertIn(b"hello from hub", joined)
-        self.assertIn(b"'/run.py'", joined)
-        self.assertNotIn(b"'/program.py'", joined)
-        self.assertNotIn(b"'/program.mpy'", joined)
+        self.assertIn(b"'/program.py'", joined)
+        self.assertNotIn(b"'/run.py'", joined)
         self.assertNotIn(b"os.remove", joined)
         self.assertIn("predates precompiled", err.getvalue())
         self.assertIn("1.91.1", err.getvalue())
@@ -367,10 +367,10 @@ class RunFlowTests(unittest.TestCase):
         self.assertNotIn("===", out.getvalue())
 
         joined = b"".join(fake.writes)
-        # Confirm the staging writes the RUN slot and calls
-        # run_program on it — never the button's /program.*.
-        self.assertIn(b"'/run.mpy'", joined)
-        self.assertNotIn(b"'/program.py'", joined)
+        # Confirm the staging writes the BUTTON slot (run =
+        # upload-then-run since 2.7.0) and calls run_program on it.
+        self.assertIn(b"'/program.mpy'", joined)
+        self.assertNotIn(b"'/run.mpy'", joined)
         self.assertIn(b"launcher.run_program", joined)
         # Confirm the control-byte sequence of raw-paste mode.
         self.assertIn(b"\x03\x03", joined)      # Ctrl-C interrupt
@@ -522,11 +522,13 @@ class InlineCommandTests(unittest.TestCase):
         self.assertIn(b"M\\x06", joined)   # .mpy header inside the
         self.assertNotIn(b"print('hello')", joined)  # staged repr
         self.assertIn(b"launcher.run_program", joined)
-        # One-shot runs stage to their OWN slot (1.97.0) — the
-        # BUTTON's /program.mpy must never appear in a run session.
-        self.assertIn(b"'/run.mpy'", joined)
-        self.assertNotIn(b"'/program.mpy'", joined)
-        self.assertNotIn(b"os.remove('/program.py')", joined)
+        # run stages to the BUTTON slot (2.7.0: upload-then-run, so
+        # a failed run stays rerunnable by start press) — the .mpy
+        # staging removes a stale source sibling so the launcher's
+        # source-wins resolution can't run old code.
+        self.assertIn(b"'/program.mpy'", joined)
+        self.assertNotIn(b"'/run.mpy'", joined)
+        self.assertIn(b"os.remove('/program.py')", joined)
 
 
     def test_connect_failure_propagates_as_run_error(self):
@@ -857,7 +859,7 @@ class HostInterruptForwardingTests(unittest.TestCase):
             return None
 
         async def _stub_pick(blink, l, *slot_pair):
-            return run_mod._RUN_TARGET_PATH, False, None
+            return run_mod._TARGET_PATH, False, None
 
         patches = [
             ("_enter_raw_repl", _raw_repl),