@typecad/framework-zephyr 1.0.0-alpha.12 → 1.0.0-alpha.14

package/src/lowering/gpio.ts

@@ -17,7 +17,7 @@
 
 import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
 import type { ZephyrChipDescriptor } from '../chips/types.js';
-import { controllerNodelabelForPin } from '../chips/controllers.js';
+import { controllerNodelabelForPin, controllerRawPinForPin } from '../chips/controllers.js';
 
 /** The C identifier emitted for a pin's gpio_dt_spec variable. */
 export function dtSpecVarName(dtSpec: string): string {
@@ -121,24 +121,31 @@ function lowerGpioRaw(
   const o = op as any;
   const pin: number = o.pin;
   // Resolve the owning controller by pin range (ESP32-S3 splits GPIO across
-  // gpio0/gpio1). For single-controller SoCs this is just chip.gpioController.
+  // gpio0/gpio1; STM32 across gpioa/gpiob/gpioc). For single-controller SoCs
+  // this is just chip.gpioController. The raw API takes the PORT-RELATIVE
+  // index (STM32 gpiob is 0-15), not the global HAL pin number.
   const controller = `DEVICE_DT_GET(DT_NODELABEL(${controllerNodelabelForPin(chip, pin)}))`;
+  const rawPin = controllerRawPinForPin(chip, pin);
 
   switch (op.operation) {
     case 'gpio.set_mode': {
-      return { code: `gpio_pin_configure(${controller}, ${pin}, ${flagsForMode(o.mode)});` };
+      return { code: `gpio_pin_configure(${controller}, ${rawPin}, ${flagsForMode(o.mode)});` };
     }
     case 'gpio.write': {
       const v = o.value;
       const rhs = typeof v === 'string' ? `((${v}) ? 1 : 0)` : v ? 1 : 0;
-      return { code: `gpio_pin_set_raw(${controller}, ${pin}, ${rhs});` };
+      return { code: `gpio_pin_set_raw(${controller}, ${rawPin}, ${rhs});` };
     }
     case 'gpio.read':
-      return { expression: `gpio_pin_get_raw(${controller}, ${pin})` };
+      return { expression: `gpio_pin_get_raw(${controller}, ${rawPin})` };
     case 'gpio.toggle':
-      return {
-        code: `gpio_pin_set_raw(${controller}, ${pin}, !gpio_pin_get_raw(${controller}, ${pin}));`,
-      };
+      // Native atomic toggle — never read-modify-write. gpio_pin_get_raw on
+      // a direction-only output reads the input latch, which is undefined on
+      // SoCs that don't latch it. Zephyr's toggle API has no _raw variant —
+      // gpio_pin_toggle is the driver-level atomic toggle, and for pins
+      // configured without GPIO_ACTIVE_LOW the logical level equals the
+      // physical one, so it matches the get_raw/set_raw used elsewhere.
+      return { code: `gpio_pin_toggle(${controller}, ${rawPin});` };
     default:
       throw new Error(
         `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +

package/src/lowering/mqtt.ts

@@ -294,7 +294,15 @@ export function mqttInitLines(): string[] {
     `    (void)k_thread_create(&__tc_mqtt.poll_thread, __tc_mqtt_stack,`,
     `                          K_THREAD_STACK_SIZEOF(__tc_mqtt_stack),`,
     `                          __tc_mqtt_poll_thread, nullptr, nullptr, nullptr,`,
-    `                          5, 0, K_NO_WAIT);`,
+    `                          5, 0, K_FOREVER);`,
+    `#ifdef CONFIG_SMP`,
+    `    // On SMP targets park the poll thread on the app core so the network`,
+    `    // stack never competes with the main/UI thread for core 0. k_thread_cpu_pin`,
+    `    // is SMP-only; the pin happens before k_thread_start (which is why the`,
+    `    // thread is created K_FOREVER). Compiles away on !SMP builds.`,
+    `    (void)k_thread_cpu_pin(&__tc_mqtt.poll_thread, 1);`,
+    `#endif`,
+    `    k_thread_start(&__tc_mqtt.poll_thread);`,
     `}`,
     ``,
     `static inline void __tc_mqtt_set_on_message(__tc_mqtt_msg_cb_t fn) {`,

package/src/lowering/pulse.ts

@@ -10,7 +10,7 @@
 
 import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
 import type { ZephyrChipDescriptor } from '../chips/types.js';
-import { controllerNodelabelForPin } from '../chips/controllers.js';
+import { controllerNodelabelForPin, controllerRawPinForPin } from '../chips/controllers.js';
 
 /** `DEVICE_DT_GET(DT_NODELABEL(<owning-controller>))` for a HAL pin. */
 function devForPin(chip: ZephyrChipDescriptor, pin: number): string {
@@ -32,9 +32,9 @@ export function lowerPulseOrShift(
       // for the start edge is bounded by the timeout; the measurement of the
       // pulse itself is intentionally unbounded (that IS the pulse length).
       // Returns -1 (0) if the start edge never arrives within the timeout.
-      const pin = o.pin;
+      const pin = controllerRawPinForPin(chip, o.pin);
       const want = o.value;
-      const dev = devForPin(chip, pin);
+      const dev = devForPin(chip, o.pin);
       const timeout = o.timeout ?? 1_000_000; // default 1s in us
       return {
         expression: `({ int64_t __max = static_cast<int64_t>(${timeout} / 1000); int64_t __t0 = k_uptime_get(); bool __ok = true; while (gpio_pin_get_raw(${dev}, ${pin}) != ${want}) { if ((k_uptime_get() - __t0) > __max) { __ok = false; break; } } int32_t __ret = 0; if (__ok) { int64_t __start = k_uptime_get(); while (gpio_pin_get_raw(${dev}, ${pin}) == ${want}) { } __ret = static_cast<int32_t>((k_uptime_get() - __start) * 1000); } __ret; })`,
@@ -45,9 +45,9 @@ export function lowerPulseOrShift(
       // with NO timeout (the comment claimed "no overflow concern" but the
       // real risk was hanging the thread on a stuck pin). Apply the same
       // timeout-bounded start-edge wait as pulse.in (bug Q5).
-      const pin = o.pin;
+      const pin = controllerRawPinForPin(chip, o.pin);
       const want = o.value;
-      const dev = devForPin(chip, pin);
+      const dev = devForPin(chip, o.pin);
       const timeout = o.timeout ?? 3_000_000; // default 3s in us (long pulses)
       return {
         expression: `({ int64_t __max = static_cast<int64_t>(${timeout} / 1000); int64_t __t0 = k_uptime_get(); bool __ok = true; while (gpio_pin_get_raw(${dev}, ${pin}) != ${want}) { if ((k_uptime_get() - __t0) > __max) { __ok = false; break; } } int32_t __ret = 0; if (__ok) { int64_t __start = k_uptime_get(); while (gpio_pin_get_raw(${dev}, ${pin}) == ${want}) { } __ret = static_cast<int32_t>((k_uptime_get() - __start) * 1000); } __ret; })`,
@@ -66,7 +66,7 @@ export function lowerPulseOrShift(
       const test = msbFirst ? '(__i >= 0)' : '(__i < 8)';
       const step = msbFirst ? '__i--' : '__i++';
       return {
-        code: `for (int __i = ${init}; ${test}; ${step}) { gpio_pin_set_raw(${dataDev}, ${dataPin}, (${o.value} >> __i) & 1); gpio_pin_set_raw(${clockDev}, ${clockPin}, 1); k_busy_wait(1); gpio_pin_set_raw(${clockDev}, ${clockPin}, 0); }`,
+        code: `for (int __i = ${init}; ${test}; ${step}) { gpio_pin_set_raw(${dataDev}, ${controllerRawPinForPin(chip, dataPin)}, (${o.value} >> __i) & 1); gpio_pin_set_raw(${clockDev}, ${controllerRawPinForPin(chip, clockPin)}, 1); k_busy_wait(1); gpio_pin_set_raw(${clockDev}, ${controllerRawPinForPin(chip, clockPin)}, 0); }`,
       };
     }
     case 'shift.in': {
@@ -81,7 +81,7 @@ export function lowerPulseOrShift(
       const step = msbFirst ? '__i--' : '__i++';
       const accum = msbFirst ? '__v = (__v << 1)' : '__v |= (bit << __i)';
       return {
-        expression: `({ uint8_t __v = 0; for (int __i = ${init}; ${test}; ${step}) { gpio_pin_set_raw(${clockDev}, ${clockPin}, 1); k_busy_wait(1); int bit = gpio_pin_get_raw(${dataDev}, ${dataPin}); gpio_pin_set_raw(${clockDev}, ${clockPin}, 0); ${accum}; } __v; })`,
+        expression: `({ uint8_t __v = 0; for (int __i = ${init}; ${test}; ${step}) { gpio_pin_set_raw(${clockDev}, ${controllerRawPinForPin(chip, clockPin)}, 1); k_busy_wait(1); int bit = gpio_pin_get_raw(${dataDev}, ${controllerRawPinForPin(chip, dataPin)}); gpio_pin_set_raw(${clockDev}, ${controllerRawPinForPin(chip, clockPin)}, 0); ${accum}; } __v; })`,
       };
     }
     default:

package/src/lowering/pwm.ts

@@ -10,6 +10,26 @@
 import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
 import type { ZephyrChipDescriptor, ZephyrPwmSpec } from '../chips/types.js';
 
+/**
+ * The DT alias a PWM spec is addressed by. Board-shipped specs carry their
+ * alias in `dtSpec`; synthesized specs (controller + channel) get a
+ * `tc-pwm<pin>` alias that the overlay generator creates in
+ * <board>.overlay — both sides derive the name from the pin so they agree.
+ */
+export function pwmDtAlias(spec: ZephyrPwmSpec): string {
+  return spec.dtSpec ?? `tc-pwm${spec.pin}`;
+}
+
+/**
+ * The C macro token for a spec's alias. Zephyr's devicetree macros replace
+ * dashes in alias names with underscores (`pwm-led0` in DTS is
+ * DT_ALIAS(pwm_led0) in C) — the dashed spelling is a subtraction
+ * expression and fails to compile (caught by the blackpill E2E west build).
+ */
+export function pwmDtAliasToken(spec: ZephyrPwmSpec): string {
+  return pwmDtAlias(spec).replace(/-/g, '_');
+}
+
 /** Look up a PWM spec by HAL pin number. */
 function findPwmSpec(chip: ZephyrChipDescriptor, pin: number): ZephyrPwmSpec | undefined {
   return chip.pwm?.specs.find((s) => s.pin === pin);
@@ -17,18 +37,23 @@ function findPwmSpec(chip: ZephyrChipDescriptor, pin: number): ZephyrPwmSpec | u
 
 /** The C variable name emitted for a PWM channel's spec. */
 function pwmVarName(spec: ZephyrPwmSpec): string {
-  return `__tc_pwm_${spec.dtSpec.replace(/-/g, '_')}`;
+  return `__tc_pwm_${pwmDtAliasToken(spec)}`;
 }
 
 /**
  * Emit the per-channel PWM spec declarations. One per spec in the chip
- * descriptor. Called from shimLines when the program uses PWM.
+ * descriptor that the PROGRAM ACTUALLY DRIVES (`usedPins`) — a spec for an
+ * untouched pin is unused code in the emitted TU (and would need a dead DT
+ * alias in the overlay). When `usedPins` is omitted (probe paths with no
+ * program), every spec is emitted. Called from shimLines when the program
+ * uses PWM.
  */
-export function pwmInitLines(chip: ZephyrChipDescriptor): string[] {
+export function pwmInitLines(chip: ZephyrChipDescriptor, usedPins?: ReadonlySet<number>): string[] {
   const lines: string[] = ['// CUTTLEFISH_PWM_BEGIN'];
   for (const spec of chip.pwm?.specs ?? []) {
+    if (usedPins && !usedPins.has(spec.pin)) continue;
     lines.push(
-      `static const struct pwm_dt_spec ${pwmVarName(spec)} = PWM_DT_SPEC_GET(DT_ALIAS(${spec.dtSpec}));`,
+      `static const struct pwm_dt_spec ${pwmVarName(spec)} = PWM_DT_SPEC_GET(DT_ALIAS(${pwmDtAliasToken(spec)}));`,
     );
   }
   lines.push('// CUTTLEFISH_PWM_END');

package/src/lowering/spi.ts

@@ -15,7 +15,7 @@
 import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
 import type { ZephyrChipDescriptor } from '../chips/types.js';
 import { parseControllerIndex } from './util.js';
-import { controllerNodelabelForPin } from '../chips/controllers.js';
+import { controllerNodelabelForPin, controllerRawPinForPin } from '../chips/controllers.js';
 
 /** The C variable prefix for a controller's state. */
 function prefix(idx: number): string {
@@ -112,7 +112,7 @@ export function lowerSpi(
       const val = op.operation === 'spi.cs_low' ? 0 : 1;
       const gpioController = controllerNodelabelForPin(chip, o.pin);
       return {
-        code: `gpio_pin_set_raw(DEVICE_DT_GET(DT_NODELABEL(${gpioController})), ${o.pin}, ${val});`,
+        code: `gpio_pin_set_raw(DEVICE_DT_GET(DT_NODELABEL(${gpioController})), ${controllerRawPinForPin(chip, o.pin)}, ${val});`,
       };
     }
     default:

package/src/lowering/tone.ts

@@ -14,7 +14,7 @@
 
 import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
 import type { ZephyrChipDescriptor } from '../chips/types.js';
-import { lowerPwm } from './pwm.js';
+import { lowerPwm, pwmDtAliasToken } from './pwm.js';
 
 /**
  * Resolve a HAL tone.* op to Zephyr C++ via PWM.
@@ -35,7 +35,7 @@ export function lowerTone(
       if (!spec) {
         return { code: `/* tone.play(${o.frequency}): no PWM spec in chip descriptor */` };
       }
-      const v = `__tc_pwm_${spec.dtSpec.replace(/-/g, '_')}`;
+      const v = `__tc_pwm_${pwmDtAliasToken(spec)}`;
       const freq = o.frequency;
       const duration = o.duration;
       const setTone = `uint32_t __period = (${freq} > 0) ? (1000000000ULL / static_cast<uint64_t>(${freq})) : 0; pwm_set_dt(&${v}, __period, __period / 2);`;
@@ -48,7 +48,7 @@ export function lowerTone(
     case 'tone.stop': {
       const spec = chip.pwm?.specs[0];
       if (!spec) return { code: `/* tone.stop: no PWM spec */` };
-      const v = `__tc_pwm_${spec.dtSpec.replace(/-/g, '_')}`;
+      const v = `__tc_pwm_${pwmDtAliasToken(spec)}`;
       return { code: `pwm_set_pulse_dt(&${v}, 0);` };
     }
     default:

package/src/lowering/wifi.ts

@@ -126,6 +126,29 @@ export function wifiInitLines(): string[] {
     `    }`,
     `    __tc_wifi.inited = true;`,
     `}`,
+    ``,
+    `// ── blocking-wait pump ───────────────────────────────────────────────────`,
+    `// Blocking wifi waits hold the main thread, which suspends the loop()-driven`,
+    `// ui_tick — a 15s association would freeze the display for its whole`,
+    `// duration. Each wait slice sleeps 20ms and, in the entry TU of a UI build`,
+    `// (the only TU carrying the ui_tick definition), pumps one frame so`,
+    `// animations and touch stay live during the wait. Constraint: do NOT call`,
+    `// blocking wifi waits from inside UI event handlers — that re-enters`,
+    `// ui_tick mid-tick; use wifi.connect_start + wifi.is_connected there.`,
+    `#ifdef CUTTLEFISH_ENTRY_UI_TU`,
+    `static void ui_tick(uint16_t deltaMs);   // defined by the UI runtime header`,
+    `#endif`,
+    `static void __tc_wifi_wait_slice(uint32_t slice_ms) {`,
+    `    k_msleep(slice_ms);`,
+    `#ifdef CUTTLEFISH_ENTRY_UI_TU`,
+    `    static uint32_t last_ms = 0U;`,
+    `    uint32_t now_ms = k_uptime_get_32();`,
+    `    uint32_t delta = (last_ms != 0U) ? (now_ms - last_ms) : 0U;`,
+    `    if (delta > 250U) delta = 250U;   // same clamp as the loop() tick injection`,
+    `    last_ms = now_ms;`,
+    `    ui_tick(static_cast<uint16_t>(delta));`,
+    `#endif`,
+    `}`,
     `// CUTTLEFISH_WIFI_CORE_END`,
     ``,
     `// ── connect / disconnect (net_mgmt — conn_mgr monitor supplies L4 events) ─`,
@@ -180,8 +203,9 @@ export function wifiInitLines(): string[] {
     `static void __tc_wifi_connect(const char* ssid, const char* password, int32_t timeout_ms) {`,
     `    __tc_wifi_connect_start(ssid, password);`,
     `    // Block until the L4 handler signals connectivity or the deadline passes.`,
+    `    // 20ms slices let __tc_wifi_wait_slice pump the UI between polls.`,
     `    int32_t waited = 0;`,
-    `    while (!__tc_wifi.connected && waited < timeout_ms) { k_msleep(100); waited += 100; }`,
+    `    while (!__tc_wifi.connected && waited < timeout_ms) { __tc_wifi_wait_slice(20); waited += 20; }`,
     `    printk("tc-wifi: connect %s after %dms\\n", __tc_wifi.connected ? "ok" : "timeout", waited);`,
     `}`,
     `// CUTTLEFISH_WIFI_CONNECT_BLOCKING_END`,
@@ -245,7 +269,7 @@ export function wifiInitLines(): string[] {
     ``,
     `static void __tc_wifi_scan_blocking(void) {`,
     `    __tc_wifi_scan_start();`,
-    `    while (__tc_wifi.scanning) { k_msleep(100); }`,
+    `    while (__tc_wifi.scanning) { __tc_wifi_wait_slice(20); }`,
     `}`,
     ``,
     `static const char* __tc_wifi_scan_ssid(int32_t i) {`,
@@ -313,13 +337,13 @@ export function wifiInitLines(): string[] {
     `static void __tc_wifi_wait_connected(int32_t timeout_ms) {`,
     `    __tc_wifi_ensure_init();`,
     `    int32_t waited = 0;`,
-    `    while (!__tc_wifi.connected && waited < timeout_ms) { k_msleep(100); waited += 100; }`,
+    `    while (!__tc_wifi.connected && waited < timeout_ms) { __tc_wifi_wait_slice(20); waited += 20; }`,
     `}`,
-    ``,
+
     `static void __tc_wifi_wait_disconnected(void) {`,
     `    __tc_wifi_ensure_init();`,
     `    // No timeout in the HAL surface — block until the L4 handler clears the flag.`,
-    `    while (__tc_wifi.connected) { k_msleep(100); }`,
+    `    while (__tc_wifi.connected) { __tc_wifi_wait_slice(20); }`,
     `}`,
     ``,
     `// ── AP mode (NET_REQUEST_WIFI_AP_ENABLE / DISABLE) ──────────────────────`,