XY microstep modes: the baseline, the catalog test and the bench tools

The baseline derives x/y_mode, step_freq, ramp_rate and the configured
markers from the xy_microsteps setting; ramp_rate joins the GRBL
controller's set (the driver writes it; the cloud client runs at the
module's). motion.microstep-modes cycles 8, 16 and 32: the save restarts
the idle controller, the kernel reads the mode with its tick and ramp,
$100/$101 are the mode's and a typed $100 is overwritten, a 40 mm jog at
top speed returns to Idle with the kernel counters over the mode agreeing
with the commanded travel and the accelerometer seeing the head move; the
setting is put back as found.

Bench tools: xy_mode_test.py (the null-sink harness the grblHAL CI runs),
raster_dry.py (a top-speed raster per mode), xy_pattern_accel.py (the
operator's pattern from home with the machine silent and the head
accelerometer listening), arc_tolerance_sweep.py (a $12 ladder on the 9
in circle: the chord rate the protocol loop feeds, about 300 a second, is
the ceiling, not the core), and the xymode and xycircle live drills.
BRINGUP carries the present state and the facts; CAMPAIGN-LOG the dated
record, including the planner-blocks spin (a $398 of 255 or more loops
forever at start, a core bug) and its recovery.

forgetest/tests/test_baseline.py

@@ -271,6 +271,65 @@ class BaselineTests(unittest.TestCase):
             {"sysfs": {"cnc/motor_lock": "8", "cnc/step_freq": "10000", "cnc/y_mode": "8"}}))
         self.assertFalse(baseline.reference_preconfig({"sysfs": {}}))
 
+    # -- the XY microstep mode drives the fixed values ------------------------
+
+    def test_the_fixed_values_follow_the_microstep_mode(self):
+        x8 = dict(baseline.fixed_sysfs(8))
+        self.assertEqual(x8, dict(baseline.FIXED_SYSFS))
+        x16 = dict(baseline.fixed_sysfs(16))
+        self.assertEqual((x16["cnc/x_mode"], x16["cnc/y_mode"], x16["cnc/step_freq"], x16["cnc/ramp_rate"]),
+                         ("16", "16", "56320", "250000"))
+        x32 = dict(baseline.fixed_sysfs(32))
+        self.assertEqual((x32["cnc/x_mode"], x32["cnc/step_freq"], x32["cnc/ramp_rate"]),
+                         ("32", "112640", "500000"))
+        # everything else is the same list, in the same order
+        self.assertEqual([a for a, _ in baseline.fixed_sysfs(32)], [a for a, _ in baseline.FIXED_SYSFS])
+        self.assertEqual(x32["cnc/x_decay"], x8["cnc/x_decay"])
+
+    def test_the_mode_is_read_from_the_settings_with_a_default(self):
+        self.assertEqual(baseline.xy_mode_of({"xy_microsteps": "16"}), 16)
+        self.assertEqual(baseline.xy_mode_of({"xy_microsteps": "32"}), 32)
+        self.assertEqual(baseline.xy_mode_of({"xy_microsteps": ""}), 8)
+        self.assertEqual(baseline.xy_mode_of({}), 8)
+        self.assertEqual(baseline.xy_mode_of(None), 8)
+        self.assertEqual(baseline.xy_mode_of({"xy_microsteps": "24"}), 8)
+        self.assertEqual(baseline.xy_mode_of({"xy_microsteps": "abc"}), 8)
+        self.assertEqual(baseline.ref_xy_mode({"forgectrl": {"/settings": {"xy_microsteps": "16"}}}), 16)
+        self.assertEqual(baseline.ref_xy_mode({"forgectrl": {"/settings": None}}), 8)
+        self.assertEqual(baseline.ref_xy_mode({}), 8)
+
+    def test_fixed_constants_are_checked_at_the_reference_mode(self):
+        ref = {"sysfs": {"cnc/x_mode": "16", "cnc/step_freq": "56320", "cnc/ramp_rate": "250000"},
+               "forgectrl": {"/settings": {"xy_microsteps": "16"}}}
+        self.assertEqual(baseline.check_fixed_against(ref, self.lines.append), [])
+        ref["forgectrl"]["/settings"]["xy_microsteps"] = "8"
+        diffs = baseline.check_fixed_against(ref, self.lines.append)
+        self.assertEqual(diffs, ["cnc/x_mode: boot=16 constant=8",
+                                 "cnc/step_freq: boot=56320 constant=28160",
+                                 "cnc/ramp_rate: boot=250000 constant=125000"])
+
+    def test_wait_configured_watches_the_mode_in_force(self):
+        self._probe_state()
+        calls = {"n": 0}
+
+        def sleep(_s):
+            calls["n"] += 1
+            if calls["n"] == 2:             # an x16 controller's init writes land
+                self._attr("cnc/step_freq", "56320")
+                self._attr("cnc/y_mode", "16")
+        ok = baseline.wait_controller_configured(
+            self.lines.append, {"controller": "running", "mode": "grbl", "motion": "verified"},
+            timeout=5, sleep=sleep, xy_mode=16)
+        self.assertTrue(ok)
+        self.assertTrue(any("controller configured" in l for l in self.lines))
+        # a reference taken under x16 is not pre-config
+        self.assertFalse(baseline.reference_preconfig(
+            {"sysfs": {"cnc/step_freq": "56320", "cnc/y_mode": "16"},
+             "forgectrl": {"/settings": {"xy_microsteps": "16"}}}))
+        self.assertTrue(baseline.reference_preconfig(
+            {"sysfs": {"cnc/step_freq": "10000", "cnc/y_mode": "1"},
+             "forgectrl": {"/settings": {"xy_microsteps": "16"}}}))
+
     def test_stale_preconfig_reference_is_retaken_on_a_fresh_boot(self):
         os.environ["FORGETEST_BOOT_ID"] = "test-boot-2"
         try: