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

package/src/framework.manifest.ts

@@ -50,8 +50,16 @@ export default defineFrameworkManifest({
   profile: {
     // Informational list of supported board targets. The manifest validator
     // never iterates this; chipForTarget (src/chips/index.ts) is the real
-    // resolver. ESP32-S3 + plain ESP32 added alongside the nRF52840 MVP target.
-    targets: ['xiao_ble', 'esp32s3_devkitc', 'esp32_devkitc'],
+    // resolver. ESP32-S3 + plain ESP32 added alongside the nRF52840 MVP target;
+    // rpi_pico / rpi_pico2 / esp32c3 / esp32c6 / blackpill_f411ce resolve via
+    // the board packages' zephyr chip data (resolveChipFromBoard), not the
+    // hardcoded chip registry.
+    targets: [
+      'xiao_ble', 'esp32s3_devkitc', 'esp32_devkitc',
+      'rpi_pico', 'rpi_pico2/rp2350a/m33',
+      'esp32c3_devkitm/esp32c3', 'esp32c6_devkitc/esp32c6/hpcore',
+      'blackpill_f411ce/stm32f411xe',
+    ],
     forcedIncludes: ['<zephyr/kernel.h>', '<zephyr/drivers/gpio.h>', '<cstdint>'],
     symbolAliases: {},
   },
@@ -213,7 +221,8 @@ export default defineFrameworkManifest({
       },
     },
     // ── Partial: WiFi (STA connect + scan + config via conn_mgr/net_mgmt) ────
-    // ESP32-S3 only — profileDiagnostics flags wifi usage on radioless chips.
+    // ESP32 family only (esp32, esp32s3, esp32c3, esp32c6) — profileDiagnostics
+    // flags wifi usage on radioless chips (nRF52840, RP2040/RP2350).
     // AP mode, credential persistence, static IP, and event callbacks deferred.
     wifi: {
       supported: true,

package/src/lowering/adc.ts

@@ -23,25 +23,38 @@ export function adcChannelForPin(chip: ZephyrChipDescriptor, pin: number): numbe
 
 /**
  * Emit the per-channel ADC setup state. One block per channel in the chip
- * descriptor, each guarded by a `static bool __tc_adc<N>_ready` so the first
- * read configures it and subsequent reads skip. Called from shimLines when
- * the program uses ADC.
+ * descriptor that the PROGRAM ACTUALLY READS (`usedPins`) — an unread
+ * channel's `static` setup function would trip -Wunused-function in the
+ * single generated TU. When `usedPins` is omitted (probe paths with no
+ * program), every descriptor channel is emitted. Each block is guarded by a
+ * `static bool __tc_adc<N>_ready` so the first read configures it and
+ * subsequent reads skip. Called from shimLines when the program uses ADC.
  */
-export function adcInitLines(chip: ZephyrChipDescriptor): string[] {
+export function adcInitLines(chip: ZephyrChipDescriptor, usedPins?: ReadonlySet<number>): string[] {
   const dev = `DEVICE_DT_GET(DT_NODELABEL(${chip.adc?.nodeLabel ?? 'adc'}))`;
   const res = chip.adc?.resolution ?? 12;
   const vref = chip.adc?.vrefMv ?? 3000;
+  // Gain/reference are SoC-specific: the nRF SAADC scheme (gain 1/4 against
+  // the 0.6V internal ref, vref-mv 3000 = VDD) is the default; the STM32
+  // driver requires exactly ADC_GAIN_1 + ADC_REF_INTERNAL (Zephyr maps
+  // "internal" to the VREF+ pad) with vref-mv = VDDA. The descriptor carries
+  // the SoC's pair so the emitted channel setup validates in the driver.
+  const gain = chip.adc?.gain ?? 'ADC_GAIN_1_4';
+  const reference = chip.adc?.reference ?? 'ADC_REF_INTERNAL';
+  const channels = (chip.adc?.channels ?? []).filter(
+    (c) => !usedPins || usedPins.has(c.pin),
+  );
   const lines: string[] = ['// CUTTLEFISH_ADC_BEGIN'];
   lines.push(`static const struct device* __tc_adc_dev = ${dev};`);
-  for (const c of chip.adc?.channels ?? []) {
+  for (const c of channels) {
     const n = c.channel;
     lines.push(
       `static bool __tc_adc${n}_ready = false;`,
       `static void __tc_adc${n}_setup(void) {`,
       `    if (__tc_adc${n}_ready) return;`,
       `    const struct adc_channel_cfg cfg = {`,
-      `        .gain = ADC_GAIN_1_4,`,
-      `        .reference = ADC_REF_INTERNAL,`,
+      `        .gain = ${gain},`,
+      `        .reference = ${reference},`,
       `        .acquisition_time = ADC_ACQ_TIME_DEFAULT,`,
       `        .channel_id = ${n},`,
       `        .differential = 0,`,
@@ -68,6 +81,8 @@ export function lowerAdc(
   const o = op as any;
   const res = chip.adc?.resolution ?? 12;
   const vref = chip.adc?.vrefMv ?? 3000;
+  const gain = chip.adc?.gain ?? 'ADC_GAIN_1_4';
+  const reference = chip.adc?.reference ?? 'ADC_REF_INTERNAL';
 
   switch (op.operation) {
     case 'adc.read': {
@@ -79,10 +94,11 @@ export function lowerAdc(
     }
     case 'adc.read_voltage': {
       const ch = adcChannelForPin(chip, o.pin);
-      // Read raw, convert to millivolts via adc_raw_to_millivolts (gain 1/4,
-      // internal ref). Returns mV as int.
+      // Read raw, convert to millivolts via adc_raw_to_millivolts with the
+      // descriptor's gain (raw_to_millivolts divides out the gain the channel
+      // was set up with). Returns mV as int.
       return {
-        expression: `({ __tc_adc${ch}_setup(); int16_t __b = 0; struct adc_sequence __s = { .channels = BIT(${ch}), .buffer = &__b, .buffer_size = sizeof(__b), .resolution = ${res} }; adc_read(__tc_adc_dev, &__s); int32_t __v = __b; adc_raw_to_millivolts(${vref}, ADC_GAIN_1_4, ${res}, &__v); __v; })`,
+        expression: `({ __tc_adc${ch}_setup(); int16_t __b = 0; struct adc_sequence __s = { .channels = BIT(${ch}), .buffer = &__b, .buffer_size = sizeof(__b), .resolution = ${res} }; adc_read(__tc_adc_dev, &__s); int32_t __v = __b; adc_raw_to_millivolts(${vref}, ${gain}, ${res}, &__v); __v; })`,
       };
     }
     case 'adc.get_resolution':
@@ -90,9 +106,9 @@ export function lowerAdc(
     case 'adc.set_reference':
       // Zephyr configures the reference at channel-setup time; runtime switching
       // would require re-setup. Record the intent as a no-op statement.
-      return { code: `/* adc.set_reference(${o.reference}): configured at channel setup (ADC_REF_INTERNAL) */` };
+      return { code: `/* adc.set_reference(${o.reference}): configured at channel setup (${reference}) */` };
     case 'adc.get_reference':
-      return { expression: `0 /* DEFAULT (ADC_REF_INTERNAL) */` };
+      return { expression: `0 /* DEFAULT (${reference}) */` };
     default:
       throw new Error(
         `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +

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,20 +121,23 @@ 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':
       // Native atomic toggle — never read-modify-write. gpio_pin_get_raw on
       // a direction-only output reads the input latch, which is undefined on
@@ -142,7 +145,7 @@ function lowerGpioRaw(
       // 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}, ${pin});` };
+      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) ──────────────────────`,

package/src/strategy.ts

@@ -42,6 +42,54 @@ import { entryHasUI } from '@typecad/cuttlefish/ui-hook';
 import { chipForTarget, setActiveChip, getActiveChip } from './chips/index.js';
 import { resolveChipFromBoard } from './chips/resolve.js';
 import { emitGpioDevDispatcher } from './chips/controllers.js';
+import type { ZephyrChipDescriptor } from './chips/types.js';
+
+/**
+ * Deep-walk the program IR and collect the HAL pin numbers the program
+ * actually touches for a peripheral family ('adc' | 'pwm') — the same walk
+ * profileDiagnostics does. Emit paths gate per-channel state on these sets
+ * so nothing unused reaches the single generated TU (-Wunused-function
+ * hygiene: every emitted function/variable is referenced). `undefined`
+ * (no program — probe paths) means "no information": callers emit every
+ * descriptor channel, preserving probe behavior.
+ *
+ * `pwm` also covers tone.* — the tone lowering drives the descriptor's
+ * first PWM spec regardless of pin, so any tone op marks it used.
+ */
+function collectUsedPins(
+  program: ProgramIR | undefined,
+  kind: 'adc' | 'pwm',
+  chip?: ZephyrChipDescriptor,
+): Set<number> | undefined {
+  if (!program) return undefined;
+  const pins = new Set<number>();
+  let usesTone = false;
+  const visit = (node: unknown): void => {
+    if (!node || typeof node !== 'object') return;
+    const n = node as Record<string, unknown>;
+    const op = n.operation;
+    if (op && typeof op === 'object') {
+      const o = op as Record<string, unknown>;
+      const name = o.operation;
+      const pin = o.pin;
+      if (typeof name === 'string' && typeof pin === 'number') {
+        if (kind === 'adc' && (name === 'adc.read' || name === 'adc.read_voltage')) pins.add(pin);
+        if (kind === 'pwm' && name.startsWith('pwm.')) pins.add(pin);
+      }
+      if (kind === 'pwm' && typeof name === 'string' && name.startsWith('tone.')) usesTone = true;
+    }
+    for (const v of Object.values(n)) {
+      if (Array.isArray(v)) { for (const item of v) visit(item); }
+      else if (v && typeof v === 'object') visit(v);
+    }
+  };
+  visit(program);
+  if (kind === 'pwm' && usesTone) {
+    const first = chip?.pwm?.specs[0];
+    if (first) pins.add(first.pin);
+  }
+  return pins;
+}
 import { lowerHalOp } from './lowering/index.js';
 import { buildZephyrWorkerBacking } from './lowering/worker-backing.js';
 import { adcInitLines } from './lowering/adc.js';
@@ -425,8 +473,8 @@ export class ZephyrStrategy implements PlatformStrategy {
     if (uses('usesUart') && chip.uart) {
       for (let i = 0; i < chip.uart.controllers.length; i++) guardBody.push(...uartInitLines(chip, i));
     }
-    if (uses('usesADC') && chip.adc) guardBody.push(...adcInitLines(chip));
-    if (uses('usesPWM') && chip.pwm) guardBody.push(...pwmInitLines(chip));
+    if (uses('usesADC') && chip.adc) guardBody.push(...adcInitLines(chip, collectUsedPins(program, 'adc')));
+    if (uses('usesPWM') && chip.pwm) guardBody.push(...pwmInitLines(chip, collectUsedPins(program, 'pwm', chip)));
     if (uses('usesDAC') && chip.dac) guardBody.push(...dacInitLines(chip));
     if (uses('usesHwtimer') && chip.hwtimer) guardBody.push(...hwtimerInitLines(chip));
     if (uses('usesInterrupts')) guardBody.push(...interruptInitLines(chip));
@@ -577,14 +625,14 @@ export class ZephyrStrategy implements PlatformStrategy {
     if (this.needsGpioReadShim(program, ctx)) {
       lines.push(...emitGpioDevDispatcher(chip));
       lines.push(
-        'inline int __tc_gpio_read(int pin) { return gpio_pin_get_raw(__tc_gpio_dev(static_cast<uint32_t>(pin)), static_cast<gpio_pin_t>(pin)); }',
+        'inline int __tc_gpio_read(int pin) { return gpio_pin_get_raw(__tc_gpio_dev(static_cast<uint32_t>(pin)), __tc_gpio_pin(static_cast<uint32_t>(pin))); }',
       );
     }
     // __tc_gpio_write / __tc_delay_us are only referenced via @typecad/safety
     // lowering, so they stay gated on it.
     if (program && programUsesSafety(program)) {
       lines.push(
-        'inline void __tc_gpio_write(uint32_t pin, uint32_t value) { gpio_pin_set_raw(__tc_gpio_dev(pin), pin, value); }',
+        'inline void __tc_gpio_write(uint32_t pin, uint32_t value) { gpio_pin_set_raw(__tc_gpio_dev(pin), __tc_gpio_pin(pin), value); }',
         '#ifndef __TC_DELAY_US_DEFINED',
         '#define __TC_DELAY_US_DEFINED',
         'inline void __tc_delay_us(uint32_t us) { k_busy_wait(us); }',

package/src/toolchain/debug-config.ts

@@ -477,7 +477,7 @@ export function writeDebugConfig(o: DebugConfigOptions): void {
  * the CLI resolves output.outDir against the ENTRY's directory (cli.ts), so
  * the emitted app root — and therefore the ELF, build dir, and .cuttlefish/
  * debug artifacts — always lands at `src/out`. Keep in sync with
- * generateProjectConfig in @typecad/cuttlefish create/init-templates.ts.
+ * generateProjectConfig in @typecad/cuttlefish create/templates.ts.
  */
 const STARTER_SKETCH_REL = 'src/out';