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

package/src/lowering/index.ts

@@ -1,93 +1,91 @@
-// ---------------------------------------------------------------------------
-// HAL lowering dispatcher
-//
-// Routes a HALOpIR to the per-category lowering module by category prefix
-// (e.g. 'gpio.write' → lowerGpio). Returns undefined for categories the
-// framework does not lower (display/mdns/ota/rmt/
-// capacitive/temp/espnow/crypto/i2s/twai/usb/eth/pcnt/mcpwm — see
-// the manifest), so the transpiler falls back and the manifest validator
-// cross-checks the unsupported categories. (board.* is registered below but is
-// a dead-letter — its values are constant-folded at IR-build time.)
-//
-// Prefix dispatch (matching framework-esp32's lowerHalOp) keeps this resilient:
-// a new op added to a category's lowering fn is picked up here automatically,
-// without also editing a 40-case switch. The per-fn default arm still throws a
-// clear "unsupported op" error for ops that fall within a category prefix but
-// aren't handled, so coverage stays honest.
-// ---------------------------------------------------------------------------
-
-import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-import { getActiveChip } from '../chips/index.js';
-import { lowerGpio } from './gpio.js';
-import { lowerTiming } from './timing.js';
-import { lowerAdc } from './adc.js';
-import { lowerPwm } from './pwm.js';
-import { lowerI2c } from './i2c.js';
-import { lowerSpi } from './spi.js';
-import { lowerUart } from './uart.js';
-import { lowerInterrupt } from './interrupts.js';
-import { lowerWdt } from './wdt.js';
-import { lowerPower } from './power.js';
-import { lowerTone } from './tone.js';
-import { lowerPulseOrShift } from './pulse.js';
-import { lowerBle } from './ble.js';
-import { lowerWorker } from './worker.js';
-import { lowerWifi } from './wifi.js';
-import { lowerHttp } from './http.js';
-import { lowerMqtt } from './mqtt.js';
-import { lowerPreferences } from './preferences.js';
-import { lowerBoard } from './board.js';
-import { lowerRandom } from './random.js';
-import { lowerDac } from './dac.js';
-import { lowerFs } from './fs.js';
-import { lowerHwtimer } from './hwtimer.js';
-
-export {
-  lowerGpio, lowerTiming, lowerAdc, lowerPwm, lowerI2c, lowerSpi, lowerUart,
-  lowerInterrupt, lowerWdt, lowerPower, lowerTone, lowerPulseOrShift, lowerBle,
-  lowerWifi, lowerHttp, lowerMqtt, lowerPreferences, lowerBoard, lowerRandom,
-  lowerDac, lowerFs, lowerHwtimer,
-};
-
-/**
- * Lower a HAL op to Zephyr C++. Returns undefined for unsupported categories
- * (mirrors lowerHalOp in framework-esp32/src/lowering/index.ts).
- */
-export function lowerHalOp(
-  op: HALOpIR,
-): { code?: string; expression?: string } | undefined {
-  const chip = getActiveChip();
-
-  if (op.operation.startsWith('gpio.'))       return lowerGpio(op, chip);
-  if (op.operation.startsWith('timing.'))     return lowerTiming(op);
-  if (op.operation.startsWith('adc.'))        return lowerAdc(op, chip);
-  if (op.operation.startsWith('pwm.'))        return lowerPwm(op, chip);
-  if (op.operation.startsWith('dac.'))        return lowerDac(op, chip);
-  if (op.operation.startsWith('i2c.'))        return lowerI2c(op, chip);
-  if (op.operation.startsWith('spi.'))        return lowerSpi(op, chip);
-  if (op.operation.startsWith('uart.'))       return lowerUart(op);
-  if (op.operation.startsWith('interrupt.'))  return lowerInterrupt(op, chip);
-  if (op.operation.startsWith('wdt.'))        return lowerWdt(op);
-  if (op.operation.startsWith('hwtimer.'))    return lowerHwtimer(op, chip);
-  if (op.operation.startsWith('power.'))      return lowerPower(op);
-  if (op.operation.startsWith('tone.'))       return lowerTone(op, chip);
-  // pulse.* and shift.* share a bit-bang lowering module.
-  if (op.operation.startsWith('pulse.') || op.operation.startsWith('shift.'))
-    return lowerPulseOrShift(op, chip);
-  if (op.operation.startsWith('ble.'))        return lowerBle(op);
-  if (op.operation.startsWith('worker.'))     return lowerWorker(op);
-  if (op.operation.startsWith('wifi.'))       return lowerWifi(op);
-  if (op.operation.startsWith('http.'))       return lowerHttp(op);
-  if (op.operation.startsWith('mqtt.'))       return lowerMqtt(op);
-  if (op.operation.startsWith('preferences.')) return lowerPreferences(op);
-  if (op.operation.startsWith('fs.'))         return lowerFs(op);
-  // board.resolve is constant-folded at IR-build time; lowerBoard is the
-  // dead-letter reached only on an unresolvable path.
-  if (op.operation.startsWith('board.')) return lowerBoard(op);
-  if (op.operation.startsWith('random.')) return lowerRandom(op);
-
-  // raw / snprintf.emit / display.* / ... — not lowered by this
-  // framework. Return undefined so the transpiler falls back and the manifest
-  // validator confirms the unsupported declaration.
-  return undefined;
-}
+// ---------------------------------------------------------------------------
+// HAL lowering dispatcher
+//
+// Routes a HALOpIR to the per-category lowering module by category prefix
+// (e.g. 'gpio.write' → lowerGpio). Returns undefined for categories the
+// framework does not lower (display/mdns/ota/rmt/
+// capacitive/temp/espnow/crypto/i2s/twai/usb/eth/pcnt/mcpwm — see
+// the manifest), so the transpiler falls back and the manifest validator
+// cross-checks the unsupported categories. (board.* is registered below but is
+// a dead-letter — its values are constant-folded at IR-build time.)
+//
+// Prefix dispatch (matching framework-esp32's lowerHalOp) keeps this resilient:
+// a new op added to a category's lowering fn is picked up here automatically,
+// without also editing a 40-case switch. The per-fn default arm still throws a
+// clear "unsupported op" error for ops that fall within a category prefix but
+// aren't handled, so coverage stays honest.
+// ---------------------------------------------------------------------------
+
+import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
+import { getActiveChip } from '../chips/index.js';
+import { lowerGpio } from './gpio.js';
+import { lowerTiming } from './timing.js';
+import { lowerAdc } from './adc.js';
+import { lowerPwm } from './pwm.js';
+import { lowerI2c } from './i2c.js';
+import { lowerSpi } from './spi.js';
+import { lowerUart } from './uart.js';
+import { lowerUsb } from './usb.js';
+import { lowerInterrupt } from './interrupts.js';
+import { lowerWdt } from './wdt.js';
+import { lowerBle } from './ble.js';
+import { lowerWifi } from './wifi.js';
+import { lowerHttp } from './http.js';
+import { lowerMqtt } from './mqtt.js';
+import { lowerPreferences } from './preferences.js';
+import { lowerBoard } from './board.js';
+import { lowerRandom } from './random.js';
+import { lowerDac } from './dac.js';
+import { lowerFs } from './fs.js';
+import { lowerSensor } from './sensor.js';
+import { lowerHwtimer, lowerCounter } from './hwtimer.js';
+import { lowerThread } from './thread.js';
+
+export {
+  lowerGpio, lowerTiming, lowerAdc, lowerPwm, lowerI2c, lowerSpi, lowerUart,
+  lowerUsb, lowerInterrupt, lowerWdt, lowerBle,
+  lowerWifi, lowerHttp, lowerMqtt, lowerPreferences, lowerBoard, lowerRandom,
+  lowerDac, lowerFs, lowerHwtimer, lowerCounter, lowerSensor, lowerThread,
+};
+
+/**
+ * Lower a HAL op to Zephyr C++. Returns undefined for unsupported categories
+ * (mirrors lowerHalOp in framework-esp32/src/lowering/index.ts).
+ */
+export function lowerHalOp(
+  op: HALOpIR,
+): { code?: string; expression?: string } | undefined {
+  const chip = getActiveChip();
+
+  if (op.operation.startsWith('gpio.'))       return lowerGpio(op, chip);
+  if (op.operation.startsWith('timing.'))     return lowerTiming(op);
+  if (op.operation.startsWith('adc.'))        return lowerAdc(op, chip);
+  if (op.operation.startsWith('pwm.'))        return lowerPwm(op, chip);
+  if (op.operation.startsWith('dac.'))        return lowerDac(op, chip);
+  if (op.operation.startsWith('i2c.'))        return lowerI2c(op, chip);
+  if (op.operation.startsWith('spi.'))        return lowerSpi(op, chip);
+  if (op.operation.startsWith('uart.'))       return lowerUart(op);
+  if (op.operation.startsWith('usb.'))        return lowerUsb(op, chip);
+  if (op.operation.startsWith('interrupt.'))  return lowerInterrupt(op, chip);
+  if (op.operation.startsWith('wdt.'))        return lowerWdt(op, chip);
+  if (op.operation.startsWith('hwtimer.'))    return lowerHwtimer(op, chip);
+  if (op.operation.startsWith('counter.'))    return lowerCounter(op, chip);
+  // (legacy pulse/shift bit-bang module removed)
+  if (op.operation.startsWith('ble.'))        return lowerBle(op);
+  if (op.operation.startsWith('wifi.'))       return lowerWifi(op);
+  if (op.operation.startsWith('http.'))       return lowerHttp(op);
+  if (op.operation.startsWith('mqtt.'))       return lowerMqtt(op);
+  if (op.operation.startsWith('preferences.')) return lowerPreferences(op);
+  if (op.operation.startsWith('fs.'))         return lowerFs(op);
+  // board.resolve is constant-folded at IR-build time; lowerBoard is the
+  // dead-letter reached only on an unresolvable path.
+  if (op.operation.startsWith('board.')) return lowerBoard(op);
+  if (op.operation.startsWith('random.')) return lowerRandom(op);
+  if (op.operation.startsWith('sensor.')) return lowerSensor(op);
+  if (op.operation.startsWith('thread.'))   return lowerThread(op);
+
+  // raw / snprintf.emit / display.* / ... — not lowered by this
+  // framework. Return undefined so the transpiler falls back and the manifest
+  // validator confirms the unsupported declaration.
+  return undefined;
+}

package/src/lowering/interrupts.ts

@@ -5,7 +5,7 @@
 // `struct gpio_callback` per pin, registered with gpio_add_callback, with a
 // trampoline that calls the user's C handler. The descriptor's gpio.interruptPins
 // lists the pins with DT specs (buttons). The user's handler is a free C
-// function; the trampoline calls it with no args (Arduino attachInterrupt style).
+// function; the trampoline calls it with no args.
 //
 // Each interrupt pin gets a static callback struct + a trampoline in shimLines.
 // attach enables + adds the callback; detach disables + removes it.
@@ -13,6 +13,8 @@
 
 import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
 import type { ZephyrChipDescriptor, ZephyrInterruptPin } from '../chips/types.js';
+import { controllerNodelabelForPin, controllerRawPinForPin, controllerRangeForPin } from '../chips/controllers.js';
+import { ZEPHYR_GPIO_INTS } from '@typecad/hal';
 
 /** Look up an interrupt pin spec by HAL pin number. */
 function findIntPin(chip: ZephyrChipDescriptor, pin: number): ZephyrInterruptPin | undefined {
@@ -24,26 +26,42 @@ function dtSpecVar(dtSpec: string): string {
   return `__tc_int_${dtSpec.replace(/-/g, '_')}`;
 }
 
-/** Map a HAL interrupt mode string to Zephyr GPIO_INT_* flags. */
-function modeToFlags(mode: string): string {
-  switch (mode.toLowerCase()) {
-    case 'rising': return 'GPIO_INT_EDGE_RISING';
-    case 'falling': return 'GPIO_INT_EDGE_FALLING';
-    case 'change': return 'GPIO_INT_EDGE_BOTH';
-    case 'high': return 'GPIO_INT_LEVEL_HIGH';
-    case 'low': return 'GPIO_INT_LEVEL_LOW';
-    default: return 'GPIO_INT_EDGE_BOTH';
+// ── Thin GPIO interrupts (hal/gpio-pin.ts onInterrupt) — INT_* tokens ─────
+//
+// The name set comes from the GENERATED Zephyr token table (parsed from the
+// pinned tree's drivers/gpio.h).
+
+const GPIO_INT_TOKENS: Record<string, string> = Object.fromEntries(
+  ZEPHYR_GPIO_INTS.map((f) => [`GPIO.${f}`, `GPIO_${f}`]),
+);
+
+/** Map thin-GPIO INT token text to the GPIO_INT_* macro. */
+export function gpioIntTokenToMacro(intFlags: string): string {
+  const token = String(intFlags ?? '').trim();
+  const m = GPIO_INT_TOKENS[token];
+  if (!m) {
+    throw new Error(
+      `GPIO interrupt flag '${token}' is not a known GPIO.INT_* token — valid: ${Object.keys(GPIO_INT_TOKENS).join(', ')}.`,
+    );
   }
+  return m;
 }
 
 /**
  * Emit the per-pin interrupt callback state + trampolines. Called from shimLines
  * when the program uses interrupts. The trampoline calls a user function via a
  * function-pointer static, set at attach time.
+ *
+ * Two paths:
+ *  - descriptor `gpio.interruptPins` (buttons with DT specs): callback state
+ *    against the DT spec, polarity-correct via gpio_*_dt.
+ *  - `usedPins` (any other pin the program attaches to): raw-controller state —
+ *    GPIO.onInterrupt() works on EVERY GPIO, not just DT-aliased buttons. Each
+ *    such pin gets its own callback struct + trampoline addressed by the owning
+ *    controller (STM32 splits gpioa/gpiob/gpioc) and port-relative bit.
  */
-export function interruptInitLines(chip: ZephyrChipDescriptor): string[] {
+export function interruptInitLines(chip: ZephyrChipDescriptor, usedPins?: ReadonlySet<number>): string[] {
   const pins = chip.gpio.interruptPins ?? [];
-  if (pins.length === 0) return [];
   const lines: string[] = ['// CUTTLEFISH_INT_BEGIN'];
   for (const pin of pins) {
     const v = dtSpecVar(pin.dtSpec);
@@ -57,18 +75,60 @@ export function interruptInitLines(chip: ZephyrChipDescriptor): string[] {
       `}`,
     );
   }
+  if (usedPins) {
+    for (const pin of usedPins) {
+      if (pins.some((p) => p.pin === pin)) continue;
+      const v = `__tc_int_raw${pin}`;
+      lines.push(
+        `static const struct device* ${v}_dev = DEVICE_DT_GET(DT_NODELABEL(${controllerNodelabelForPin(chip, pin)}));`,
+        `static struct gpio_callback ${v}_cb;`,
+        `static void (*${v}_handler)(void) = NULL;`,
+        `static void ${v}_tramp(const struct device* port, struct gpio_callback* cb, gpio_port_pins_t pins_v) {`,
+        `    (void)port; (void)cb; (void)pins_v;`,
+        `    if (${v}_handler) { ${v}_handler(); }`,
+        `}`,
+      );
+    }
+  }
   lines.push('// CUTTLEFISH_INT_END');
   return lines;
 }
 
+/**
+ * Collect the pin numbers the program attaches interrupts to (any GPIO — not
+ * just descriptor-listed buttons). Feeds interruptInitLines' raw-path state.
+ */
+export function collectInterruptPins(program: unknown): Set<number> {
+  const pins = new Set<number>();
+  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>;
+      if (o.operation === 'interrupt.attach_flags' && typeof o.pin === 'number') {
+        pins.add(o.pin as number);
+      }
+    }
+    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);
+  return pins;
+}
+
 /**
  * Resolve a HAL interrupt.* op to Zephyr C++.
  * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
  *
- * Note: attach requires the pin to be in the descriptor's interruptPins. If a
- * program attaches to an unlisted pin, we fall back to a diagnostic comment
- * (the probe uses an unknown pin, so the manifest marks these 'supported' via
- * the comment lowering — the probe sees a non-undefined return).
+ * Two paths: pins listed in the descriptor's gpio.interruptPins (DT-aliased
+ * buttons) go through the polarity-correct gpio_*_dt chain; every other GPIO
+ * attaches through the raw-controller chain (any GPIO is interrupt-capable on
+ * the supported SoCs — the descriptor list exists for DT specs, not as a
+ * capability gate). The manifest probe's synthetic op keeps the comment
+ * fallback (no program ⇒ no shim state was emitted for the raw path).
  */
 export function lowerInterrupt(
   op: HALOpIR,
@@ -78,10 +138,42 @@ export function lowerInterrupt(
   const pin = findIntPin(chip, o.pin);
 
   if (!pin) {
+    // Raw-controller path — state comes from interruptInitLines' usedPins.
+    // Only for pins a declared controller range covers: an out-of-range number
+    // (e.g. pin 99 on a 34-pin SoC) keeps the diagnostic comment. Single-
+    // controller chips declare no ranges, so every number is taken as real and
+    // the driver rejects invalid bits at runtime (Arduino-like behavior).
+    const knownPin = typeof o.pin === 'number' && Number.isInteger(o.pin)
+      && (!chip.gpioControllers || chip.gpioControllers.length === 0
+        || controllerRangeForPin(chip, o.pin) !== undefined);
+    if (knownPin) {
+      const v = `__tc_int_raw${o.pin}`;
+      const raw = controllerRawPinForPin(chip, o.pin);
+      if (op.operation === 'interrupt.attach_flags') {
+        // Thin GPIO: INT_* tokens instead of mode strings. The pin's
+        // input/pull configuration already came from the construction flags
+        // (the class emits gpio.configure ahead of this op) — no INPUT
+        // override here, unlike the legacy raw path above.
+        const flags = gpioIntTokenToMacro(o.intFlags);
+        return {
+          code: [
+            `${v}_handler = (${o.handler});`,
+            `gpio_init_callback(&${v}_cb, ${v}_tramp, BIT(${raw}));`,
+            `gpio_pin_interrupt_configure(${v}_dev, ${raw}, ${flags});`,
+            `gpio_add_callback(${v}_dev, &${v}_cb);`,
+          ].join(' '),
+        };
+      }
+      if (op.operation === 'interrupt.detach') {
+        return {
+          code: `gpio_pin_interrupt_configure(${v}_dev, ${raw}, GPIO_INT_DISABLE); gpio_remove_callback(${v}_dev, &${v}_cb); ${v}_handler = NULL;`,
+        };
+      }
+    }
     // Fallback (also covers the manifest probe): a diagnostic comment so the
     // resolver returns non-undefined. Real attach needs a descriptor entry.
-    if (op.operation === 'interrupt.attach') {
-      return { code: `/* interrupt.attach(pin ${o.pin}): no DT spec — add to chip descriptor gpio.interruptPins */` };
+    if (op.operation === 'interrupt.attach_flags') {
+      return { code: `/* interrupt.attach_flags(pin ${o.pin}): no DT spec — add to chip descriptor gpio.interruptPins */` };
     }
     return { code: `/* interrupt.detach(pin ${o.pin}): no DT spec */` };
   }
@@ -89,12 +181,12 @@ export function lowerInterrupt(
   const v = dtSpecVar(pin.dtSpec);
 
   switch (op.operation) {
-    case 'interrupt.attach': {
-      const flags = modeToFlags(o.mode);
+    case 'interrupt.attach_flags': {
+      // Thin GPIO: INT_* tokens; construction flags already configured the pin.
+      const flags = gpioIntTokenToMacro(o.intFlags);
       return {
         code: [
           `${v}_handler = (${o.handler});`,
-          `gpio_pin_configure_dt(&${v}, GPIO_INPUT);`,
           `gpio_init_callback(&${v}_cb, ${v}_tramp, BIT(${v}.pin));`,
           `gpio_pin_interrupt_configure_dt(&${v}, ${flags});`,
           `gpio_add_callback(${v}.port, &${v}_cb);`,

package/src/lowering/mqtt.ts

@@ -3,11 +3,11 @@
 //
 // Zephyr's MQTT library is event-driven but has no internal task: the app
 // must call mqtt_input() when the socket is readable and mqtt_live()
-// periodically for keepalive. The generated firmware is setup()/loop(),
-// and the user's loop() is not ours to edit — so the connect shim spawns a
+// periodically for keepalive. The generated firmware is main()-based and
+// the user's main() is not ours to edit — so the connect shim spawns a
 // dedicated k_thread that runs the poll loop (poll() → mqtt_input/mqtt_live)
 // until disconnect. This mirrors a "managed client" model (like ESP-IDF's
-// esp_mqtt internal task) and keeps the user's loop() untouched.
+// esp_mqtt internal task) and keeps the user's main() untouched.
 //
 // mqtt_connect() does no DNS — the broker is a resolved sockaddr — so the
 // shim getaddrinfo-resolves the broker host itself (like the HTTP shim).
@@ -270,8 +270,6 @@ export function mqttInitLines(): string[] {
     `        (void)mqtt_abort(&__tc_mqtt.client);`,
     `        return;`,
     `    }`,
-    `    printk("tc-mqtt: connecting to %s:%u\\n", __tc_mqtt.host,`,
-    `           static_cast<unsigned int>(__tc_mqtt.port));`,
     `    // Drive input locally until CONNACK arrives (poll thread hasn't started).`,
     `    // mqtt_connect opened the socket; poll it for the connect-ack. Cap the wait`,
     `    // so a silent broker doesn't hang setup forever.`,
@@ -294,7 +292,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) {`,