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

package/src/lowering/adc.ts

@@ -1,102 +1,222 @@
-// ---------------------------------------------------------------------------
-// ADC lowering — nRF SAADC via raw adc_read
-//
-// The XIAO nRF52840 has no pre-declared ADC channel nodes in devicetree, so we
-// cannot use the `adc_dt_spec` convenience. Instead the lowering configures the
-// channel up-front against DEVICE_DT_GET(DT_NODELABEL(adc)) and reads it with
-// `adc_read`. The channel index comes from the chip descriptor's pin→channel
-// map (XIAO D0–D3 = AIN0–AIN3).
-//
-// Channel setup is emitted in adcInitLines() (one per channel used); the ops
-// then just read. A static `adc_channel_cfg` + a per-channel "configured" flag
-// guards the setup, so repeated reads don't reconfigure.
-// ---------------------------------------------------------------------------
-
-import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-import type { ZephyrChipDescriptor } from '../chips/types.js';
-
-/** Resolve the SAADC channel index for a HAL pin number; -1 if unmapped. */
-export function adcChannelForPin(chip: ZephyrChipDescriptor, pin: number): number {
-  const ch = chip.adc?.channels.find((c) => c.pin === pin);
-  return ch ? ch.channel : -1;
-}
-
-/**
- * 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.
- */
-export function adcInitLines(chip: ZephyrChipDescriptor): string[] {
-  const dev = `DEVICE_DT_GET(DT_NODELABEL(${chip.adc?.nodeLabel ?? 'adc'}))`;
-  const res = chip.adc?.resolution ?? 12;
-  const vref = chip.adc?.vrefMv ?? 3000;
-  const lines: string[] = ['// CUTTLEFISH_ADC_BEGIN'];
-  lines.push(`static const struct device* __tc_adc_dev = ${dev};`);
-  for (const c of chip.adc?.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,`,
-      `        .acquisition_time = ADC_ACQ_TIME_DEFAULT,`,
-      `        .channel_id = ${n},`,
-      `        .differential = 0,`,
-      `    };`,
-      `    adc_channel_setup(__tc_adc_dev, &cfg);`,
-      `    __tc_adc${n}_ready = true;`,
-      `}`,
-    );
-  }
-  lines.push(`#define __TC_ADC_VREF_MV ${vref}`);
-  lines.push(`#define __TC_ADC_RESOLUTION ${res}`);
-  lines.push('// CUTTLEFISH_ADC_END');
-  return lines;
-}
-
-/**
- * Resolve a HAL adc.* op to Zephyr C++.
- * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
- */
-export function lowerAdc(
-  op: HALOpIR,
-  chip: ZephyrChipDescriptor,
-): { code?: string; expression?: string } {
-  const o = op as any;
-  const res = chip.adc?.resolution ?? 12;
-  const vref = chip.adc?.vrefMv ?? 3000;
-
-  switch (op.operation) {
-    case 'adc.read': {
-      const ch = adcChannelForPin(chip, o.pin);
-      // GCC statement-expression: configures-on-first-call, reads, returns raw.
-      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); __b; })`,
-      };
-    }
-    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.
-      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; })`,
-      };
-    }
-    case 'adc.get_resolution':
-      return { expression: String(res) };
-    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) */` };
-    case 'adc.get_reference':
-      return { expression: `0 /* DEFAULT (ADC_REF_INTERNAL) */` };
-    default:
-      throw new Error(
-        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
-          `Open an issue or use rawCpp() to emit it manually.`,
-      );
-  }
-}
+// ---------------------------------------------------------------------------
+// ADC lowering — nRF SAADC via raw adc_read
+//
+// The XIAO nRF52840 has no pre-declared ADC channel nodes in devicetree, so we
+// cannot use the `adc_dt_spec` convenience. Instead the lowering configures the
+// channel up-front against DEVICE_DT_GET(DT_NODELABEL(adc)) and reads it with
+// `adc_read`. The channel index comes from the chip descriptor's pin→channel
+// map (XIAO D0–D3 = AIN0–AIN3).
+//
+// Channel setup is emitted in adcInitLines() (one per channel used); the ops
+// then just read. A static `adc_channel_cfg` + a per-channel "configured" flag
+// guards the setup, so repeated reads don't reconfigure.
+// ---------------------------------------------------------------------------
+
+import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
+import type { ZephyrChipDescriptor } from '../chips/types.js';
+import { ZEPHYR_ADC_GAINS, ZEPHYR_ADC_REFERENCES } from '@typecad/hal';
+
+/**
+ * Resolve the SAADC channel index for an adc.read argument; -1 if unmapped.
+ *
+ * The numeric argument serves two HAL forms: `InputPin.readAnalog()` passes
+ * a GPIO number, while the Arduino-compat `ADC.read(channel)` passes an ADC
+ * channel number. Pin-first resolution keeps readAnalog behavior unchanged;
+ * the channel fallback makes `ADC.read(n)` resolve on targets where channel
+ * n does not alias GPIO n (e.g. the XIAO's AIN2 = P0.28). Where a number
+ * matches both a mapped pin and another channel's index, the pin wins.
+ */
+export function adcChannelForPin(chip: ZephyrChipDescriptor, pin: number): number {
+  const channels = chip.adc?.channels ?? [];
+  const byPin = channels.find((c) => c.pin === pin);
+  if (byPin) return byPin.channel;
+  const byChannel = channels.find((c) => c.channel === pin);
+  return byChannel ? byChannel.channel : -1;
+}
+
+/**
+ * Resolve the owning ADC controller's node label for an adc.read argument.
+ * Defaults to the descriptor's primary (`chip.adc.nodeLabel`) — channels on
+ * additional controllers (STM32 adc3-only routes, ESP32 adc2 pads) carry
+ * their controller explicitly, and their device handle is
+ * `__tc_adc_<label>_dev` (the primary keeps the unsuffixed `__tc_adc_dev`
+ * so single-controller output is unchanged).
+ */
+export function adcControllerForPin(chip: ZephyrChipDescriptor, pin: number): string {
+  const channels = chip.adc?.channels ?? [];
+  const byPin = channels.find((c) => c.pin === pin);
+  if (byPin) return byPin.controller ?? chip.adc?.nodeLabel ?? 'adc';
+  const byChannel = channels.find((c) => c.channel === pin);
+  return byChannel?.controller ?? chip.adc?.nodeLabel ?? 'adc';
+}
+
+/** The C++ device-handle symbol for an ADC controller nodelabel. The primary
+ *  controller maps to the historical unsuffixed `__tc_adc_dev`. */
+function adcDevSymbol(controller: string, primary: string): string {
+  return controller === primary ? '__tc_adc_dev' : `__tc_adc_${controller}_dev`;
+}
+
+// ── Thin ADC (hal/adc-pin.ts) — gain/reference tokens ──────────────────────
+//
+// "ADC.GAIN_1_4" / "ADC.REF_INTERNAL" token text maps name-for-
+// name onto the enum adc_gain / adc_reference macros. The name sets come from
+// the GENERATED Zephyr token tables (scripts/gen-zephyr-hal-tokens.mjs —
+// parsed from the pinned tree's headers, so the set cannot drift from
+// upstream); empty/absent tokens mean "use the chip descriptor's pair".
+
+const ADC_GAIN_TOKENS: Record<string, string> = Object.fromEntries(
+  ZEPHYR_ADC_GAINS.map((g) => [`ADC.GAIN_${g}`, `ADC_GAIN_${g}`]),
+);
+const ADC_REF_TOKENS: Record<string, string> = Object.fromEntries(
+  ZEPHYR_ADC_REFERENCES.map((r) => [`ADC.REF_${r}`, `ADC_REF_${r}`]),
+);
+
+/** Resolve one thin-ADC token to its macro; undefined when absent/empty.
+ *  Unknown tokens are build errors naming the valid spellings. */
+function adcThinToken(token: string | undefined, map: Record<string, string>, kind: string): string | undefined {
+  const t = String(token ?? '').trim();
+  if (!t || t === '0' || t === "''") return undefined;
+  const m = map[t];
+  if (!m) {
+    throw new Error(
+      `ADC ${kind} token '${t}' is not a known ADC.* token — valid ${kind}s: ${Object.keys(map).join(', ')}.`,
+    );
+  }
+  return m;
+}
+
+/**
+ * Emit the per-channel ADC setup state. One block per channel in the chip
+ * 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,
+  usedPins?: ReadonlySet<number>,
+  overrideDevices?: ReadonlySet<string>,
+): string[] {
+  const primary = 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 owns = (c: { controller?: string }, label: string) => (c.controller ?? primary) === label;
+  const channels = (chip.adc?.channels ?? []).filter(
+    (c) =>
+      !usedPins ||
+      // Pin-form usage (the ADC/readAnalog path): the exact channel.
+      [...usedPins].some((n) => n === c.pin) ||
+      // Channel-number fallback (the Arduino-compat ADC.read(n) form) — must
+      // match the CONTROLLER too, or colliding indices across controllers
+      // (both ESP32 SARADC units expose channel 0) over-include.
+      [...usedPins].some((n) => adcChannelForPin(chip, n) === c.channel && owns(c, adcControllerForPin(chip, n))),
+  );
+  const lines: string[] = ['// CUTTLEFISH_ADC_BEGIN'];
+  lines.push(`static const struct device* __tc_adc_dev = DEVICE_DT_GET(DT_NODELABEL(${primary}));`);
+  // Additional controllers referenced by used channels get their own device
+  // handle (sorted for deterministic output). Channel indices collide across
+  // controllers, so non-primary setup symbols carry the controller label.
+  const extraControllers = [...new Set(channels.map((c) => c.controller).filter((x): x is string => !!x && x !== primary))].sort();
+  // Inline-override devices (escape hatch): handles for the DT labels the
+  // construction opts name — they may not appear in the manifest at all.
+  for (const label of (overrideDevices ?? [])) {
+    if (label !== primary && !extraControllers.includes(label)) extraControllers.push(label);
+  }
+  for (const label of extraControllers) {
+    lines.push(`static const struct device* __tc_adc_${label}_dev = DEVICE_DT_GET(DT_NODELABEL(${label}));`);
+  }
+  for (const c of channels) {
+    const n = c.channel;
+    const dev = adcDevSymbol(c.controller ?? primary, primary);
+    const sym = c.controller && c.controller !== primary ? `__tc_adc_${c.controller}_${n}` : `__tc_adc${n}`;
+    lines.push(
+      `static bool ${sym}_ready = false;`,
+      `static void ${sym}_setup(void) {`,
+      `    if (${sym}_ready) return;`,
+      `    const struct adc_channel_cfg cfg = {`,
+      `        .gain = ${gain},`,
+      `        .reference = ${reference},`,
+      `        .acquisition_time = ADC_ACQ_TIME_DEFAULT,`,
+      `        .channel_id = ${n},`,
+      `        .differential = 0,`,
+      `    };`,
+      `    adc_channel_setup(${dev}, &cfg);`,
+      `    ${sym}_ready = true;`,
+      `}`,
+    );
+  }
+  lines.push(`#define __TC_ADC_VREF_MV ${vref}`);
+  lines.push(`#define __TC_ADC_RESOLUTION ${res}`);
+  lines.push('// CUTTLEFISH_ADC_END');
+  return lines;
+}
+
+/**
+ * Resolve a HAL adc.* op to Zephyr C++.
+ * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
+ */
+export function lowerAdc(
+  op: HALOpIR,
+  chip: ZephyrChipDescriptor,
+): { code?: string; expression?: string } {
+  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_raw':
+    case 'adc.read_mv': {
+      // Construction-time overrides (hal/adc-pin.ts opts: channel/device/
+      // pinctrl): the user vouches for the routing on a pin the facts layer
+      // does not cover. The channel and device symbol come from the op; the
+      // marker comment carries device/pinctrl to the overlay regen (the
+      // transpiler cannot synthesize DT nodes) and suppresses the
+      // unavailable-pin diagnostic.
+      const hasOverride = (typeof o.channelOverride === 'number' && o.channelOverride >= 0)
+        || (typeof o.deviceOverride === 'string' && o.deviceOverride !== '')
+        || (typeof o.pinctrlOverride === 'string' && o.pinctrlOverride !== '');
+      const ch = hasOverride && typeof o.channelOverride === 'number' && o.channelOverride >= 0
+        ? (o.channelOverride as number)
+        : adcChannelForPin(chip, o.pin);
+      const primary = chip.adc?.nodeLabel ?? 'adc';
+      const devCtrl = (typeof o.deviceOverride === 'string' && o.deviceOverride !== '')
+        ? (o.deviceOverride as string)
+        : adcControllerForPin(chip, o.pin);
+      const dev = adcDevSymbol(devCtrl, primary);
+      const gainMacro = adcThinToken(o.gain, ADC_GAIN_TOKENS, 'gain');
+      const refMacro = adcThinToken(o.reference, ADC_REF_TOKENS, 'reference');
+      const g = gainMacro ?? gain;
+      const r = refMacro ?? reference;
+      const marker = hasOverride
+        ? `/* cuttlefish-user-facts: adc pin=${o.pin}`
+          + `${typeof o.deviceOverride === 'string' && o.deviceOverride !== '' ? ` device=${o.deviceOverride}` : ''}`
+          + `${typeof o.pinctrlOverride === 'string' && o.pinctrlOverride !== '' ? ` pinctrl=${o.pinctrlOverride}` : ''}`
+          + ` channel=${ch} */ `
+        : '';
+      const setup = `static bool __tc_adct${o.pin}_done = false; if (!__tc_adct${o.pin}_done) { const struct adc_channel_cfg __tc_adct${o.pin}_cfg = { .gain = ${g}, .reference = ${r}, .acquisition_time = ADC_ACQ_TIME_DEFAULT, .channel_id = ${ch}, .differential = 0 }; adc_channel_setup(${dev}, &__tc_adct${o.pin}_cfg); __tc_adct${o.pin}_done = true; }`;
+      const read = `int16_t __b = 0; struct adc_sequence __s = { .channels = BIT(${ch}), .buffer = &__b, .buffer_size = sizeof(__b), .resolution = ${res} }; adc_read(${dev}, &__s);`;
+      if (op.operation === 'adc.read_raw') {
+        return { expression: `({ ${marker}${setup} ${read} __b; })` };
+      }
+      return {
+        expression: `({ ${marker}${setup} ${read} int32_t __v = __b; adc_raw_to_millivolts(${vref}, ${g}, ${res}, &__v); __v; })`,
+      };
+    }
+    default:
+      throw new Error(
+        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
+          `Open an issue or use rawCpp() to emit it manually.`,
+      );
+  }
+}

package/src/lowering/ble.ts

@@ -91,6 +91,9 @@ export function bleInitLines(): string[] {
     `// bt_gatt_chrc metadata for each characteristic declaration attr.`,
     `static struct bt_gatt_chrc __tc_ble_chrc_meta[__TC_BLE_MAX_CHARS];`,
     `// The flat attribute array + its wrapping service. Plus per-char CCC cfg.`,
+    `static struct bt_gatt_ccc_managed_user_data __tc_ble_ccc[__TC_BLE_MAX_CHARS];`,
+    `// write_ccc dereferences cfg_changed — every slot needs the no-op.`,
+    `static void __tc_ble_ccc_changed(const struct bt_gatt_attr* a, uint16_t v) { (void)a; (void)v; }`,
     `static struct bt_gatt_attr __tc_ble_attrs[__TC_BLE_MAX_ATTRS];`,
     `static size_t __tc_ble_attr_count = 0;`,
     `static struct bt_gatt_service __tc_ble_svc;`,
@@ -145,8 +148,10 @@ export function bleInitLines(): string[] {
     `    if (idx < 0 || idx >= __TC_BLE_MAX_CHARS || !__tc_ble.on_read[idx]) return 0;`,
     `    const char* t = __tc_ble_char_defs[idx].type;`,
     `    if (t && strcmp(t, "utf8") == 0) {`,
-    `        const char* s_c = reinterpret_cast<const char*(*)(void)>(__tc_ble.on_read[idx])();`,
-    `        return bt_gatt_attr_read(conn, attr, buf, len, offset, s_c, strlen(s_c));`,
+    `        // Hoisted string callbacks return std::string BY VALUE — call through`,
+    `        // the true signature and borrow c_str() for the copy below.`,
+    `        std::string s_v = reinterpret_cast<std::string(*)(void)>(__tc_ble.on_read[idx])();`,
+    `        return bt_gatt_attr_read(conn, attr, buf, len, offset, s_v.c_str(), s_v.size());`,
     `    } else if (t && strcmp(t, "float32") == 0) {`,
     `        double d = reinterpret_cast<double(*)(void)>(__tc_ble.on_read[idx])();`,
     `        float f = static_cast<float>(d);`,
@@ -266,6 +271,7 @@ export function bleInitLines(): string[] {
     `// (declaration + value); the value attr carries the char index in user_data.`,
     `static void __tc_ble_build_svc_table(void) {`,
     `    size_t a = 0;`,
+    `    for (int c = 0; c < __TC_BLE_MAX_CHARS; c++) { __tc_ble_ccc[c].cfg_changed = __tc_ble_ccc_changed; }`,
     `    for (int s = 0; s < static_cast<int>(__tc_ble.svc_count); s++) {`,
     `        // Primary service declaration.`,
     `        __tc_ble_attrs[a].uuid = BT_UUID_GATT_PRIMARY;`,
@@ -301,6 +307,17 @@ export function bleInitLines(): string[] {
     `            __tc_ble_attrs[a].perm = BT_GATT_PERM_READ | BT_GATT_PERM_WRITE;`,
     `            __tc_ble.val_attr_idx[c] = static_cast<int>(a);`,
     `            a++;`,
+    `            if (__tc_ble_char_defs[c].perms & 4) {`,
+    `                // CCC descriptor — without it a central cannot subscribe`,
+    `                // and notifications never reach anyone.`,
+    `                __tc_ble_attrs[a].uuid = BT_UUID_GATT_CCC;`,
+    `                __tc_ble_attrs[a].read = bt_gatt_attr_read_ccc;`,
+    `                __tc_ble_attrs[a].write = bt_gatt_attr_write_ccc;`,
+    `                __tc_ble_attrs[a].user_data = &__tc_ble_ccc[c];`,
+    `                __tc_ble_attrs[a].handle = 0;`,
+    `                __tc_ble_attrs[a].perm = BT_GATT_PERM_READ | BT_GATT_PERM_WRITE;`,
+    `                a++;`,
+    `            }`,
     `        }`,
     `    }`,
     `    __tc_ble_attr_count = a;`,
@@ -323,24 +340,28 @@ export function bleInitLines(): string[] {
     `    bt_gatt_service_register(&__tc_ble_svc);`,
     `    __tc_ble.status = 1; // Initializing`,
     `    bt_enable(NULL);  // synchronous`,
+    `    bt_enable(NULL);  // synchronous`,
     `    __tc_ble.inited = true;`,
     `    __tc_ble_advertise_start();`,
     `}`,
     ``,
     `// ── Notify ──`,
+    `// Explicit-conn: the NULL (broadcast) form hit an ESP32 controller assert`,
+    `// (lld_con.c) on the first push after subscription on the S3.`,
     `static void __tc_ble_notify(int idx, int16_t value) {`,
     `    if (idx < 0 || idx >= __TC_BLE_MAX_CHARS) return;`,
+    `    if (__tc_ble.conn == NULL) return;   // no link: a NULL-conn notify asserted the controller`,
     `    int ai = __tc_ble.val_attr_idx[idx];`,
     `    if (ai == 0) return;`,
     `    const char* t = __tc_ble_char_defs[idx].type;`,
     `    if (t && strcmp(t, "uint32") == 0) {`,
-    `        uint32_t u = static_cast<uint32_t>(value); bt_gatt_notify(NULL, &__tc_ble_attrs[ai], &u, sizeof(u));`,
+    `        uint32_t u = static_cast<uint32_t>(value); bt_gatt_notify(__tc_ble.conn, &__tc_ble_attrs[ai], &u, sizeof(u));`,
     `    } else if (t && strcmp(t, "float32") == 0) {`,
-    `        float f = static_cast<float>(value); bt_gatt_notify(NULL, &__tc_ble_attrs[ai], &f, sizeof(f));`,
+    `        float f = static_cast<float>(value); bt_gatt_notify(__tc_ble.conn, &__tc_ble_attrs[ai], &f, sizeof(f));`,
     `    } else if (t && strcmp(t, "boolean") == 0) {`,
-    `        uint8_t b = value ? 1 : 0; bt_gatt_notify(NULL, &__tc_ble_attrs[ai], &b, sizeof(b));`,
+    `        uint8_t b = value ? 1 : 0; bt_gatt_notify(__tc_ble.conn, &__tc_ble_attrs[ai], &b, sizeof(b));`,
     `    } else {`,
-    `        int16_t s16 = value; bt_gatt_notify(NULL, &__tc_ble_attrs[ai], &s16, sizeof(s16));`,
+    `        int16_t s16 = value; bt_gatt_notify(__tc_ble.conn, &__tc_ble_attrs[ai], &s16, sizeof(s16));`,
     `    }`,
     `}`,
     ``,
@@ -348,18 +369,7 @@ export function bleInitLines(): string[] {
     `    return __tc_ble.status == 3 && __tc_ble.connected_clients > 0;`,
     `}`,
     `static inline int __tc_ble_client_count(void) { return __tc_ble.connected_clients; }`,
-    `static inline void __tc_ble_set_name(const char* name) { strncpy(__tc_ble.name, name, sizeof(__tc_ble.name) - 1); __tc_ble.name[sizeof(__tc_ble.name) - 1] = 0; }`,
-    `static inline void __tc_ble_set_tx_power(int dbm) { (void)dbm; /* nRF TX power via bt_le_set_tx_power — deferred */ }`,
     ``,
-    `static inline bool __tc_ble_until_connected(uint32_t timeout_ms) {`,
-    `    int64_t deadline = static_cast<int64_t>(k_uptime_get()) + static_cast<int64_t>(timeout_ms);`,
-    `    while (!__tc_ble_is_connected()) {`,
-    `        if (timeout_ms > 0 && k_uptime_get() >= deadline) return false;`,
-    `        k_msleep(50);`,
-    `    }`,
-    `    return true;`,
-    `}`,
-    `static inline void __tc_ble_until_connected_start(void) { /* __tc_ble_server_begin already started advertising */ }`,
     `// CUTTLEFISH_BLE_END`,
     ``,
   ];
@@ -404,21 +414,14 @@ export function lowerBle(op: HALOpIR): { code?: string; expression?: string } {
     case 'ble.on_disconnect':
       return { code: `__tc_ble.on_disconnect = (${s(o.handler)});` };
     case 'ble.notify':
-      return { expression: `__tc_ble_notify(__tc_ble.current_char, ${s(o.value)})` };
+      // Index-based: val_attr_idx[idx] resolves the registered attr (the
+      // declaration-order slot). current_char would be whatever add_char ran
+      // last — wrong for a standalone notify after later declarations.
+      return { expression: `__tc_ble_notify(${s(o.index ?? 0)}, ${s(o.value)})` };
     case 'ble.is_connected':
       return { expression: `__tc_ble_is_connected()` };
     case 'ble.client_count':
       return { expression: `__tc_ble_client_count()` };
-    case 'ble.status':
-      return { expression: `__tc_ble.status` };
-    case 'ble.set_name':
-      return { code: `__tc_ble_set_name(${s(o.name)});` };
-    case 'ble.set_tx_power':
-      return { code: `__tc_ble_set_tx_power(${s(o.dbm)});` };
-    case 'ble.until_connected':
-      return { expression: `__tc_ble_until_connected(${s(o.timeoutMs)})` };
-    case 'ble.until_connected_start':
-      return { code: `__tc_ble_until_connected_start();` };
     default:
       throw new Error(
         `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
@@ -426,3 +429,4 @@ export function lowerBle(op: HALOpIR): { code?: string; expression?: string } {
       );
   }
 }
+

package/src/lowering/dac.ts

@@ -1,82 +1,82 @@
-// ---------------------------------------------------------------------------
-// DAC lowering — Zephyr DAC driver via dac_channel_setup / dac_write_value
-//
-// Targets with a DAC (ESP32: 2× 8-bit channels on GPIO25/26) declare a `dac`
-// entry in the chip descriptor: the DT device node label + the pin→channel map.
-// The lowering emits a `dac_channel_setup` (lazy, on first write) + a
-// `dac_write_value` against DEVICE_DT_GET(DT_NODELABEL(<device>)).
-//
-// Targets without a DAC (nRF52840, ESP32-S3) omit `dac`; usage there lowers to a
-// comment and profileDiagnostics flags it (mirror of the ADC pin-validity gate).
-// ---------------------------------------------------------------------------
-
-import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-import type { ZephyrChipDescriptor, ZephyrDacChannel } from '../chips/types.js';
-
-/** Look up a DAC channel by HAL pin number. */
-function findDacChannel(chip: ZephyrChipDescriptor, pin: number): ZephyrDacChannel | undefined {
-  return chip.dac?.channels.find((c) => c.pin === pin);
-}
-
-/**
- * Emit the DAC device handle. Called from shimLines when the program uses the
- * DAC (the chip must declare a `dac` entry, or nothing is emitted).
- */
-export function dacInitLines(chip: ZephyrChipDescriptor): string[] {
-  if (!chip.dac) return [];
-  return [
-    '// CUTTLEFISH_DAC_BEGIN',
-    `static const struct device* __tc_dac_dev = DEVICE_DT_GET(DT_NODELABEL(${chip.dac.device}));`,
-    '// CUTTLEFISH_DAC_END',
-  ];
-}
-
-/**
- * Resolve a HAL dac.* op to Zephyr C++.
- * Returns `{ code }` for statement ops.
- */
-export function lowerDac(
-  op: HALOpIR,
-  chip: ZephyrChipDescriptor,
-): { code?: string; expression?: string } {
-  const o = op as any;
-
-  // No DAC on this target (e.g. nRF52840). Return a comment so the resolver
-  // reports non-undefined (the manifest validator's probe sends pin:25 on the
-  // default chip, which has no DAC). profileDiagnostics flags real misuse.
-  if (!chip.dac) {
-    return { code: `/* dac on pin ${o.pin}: no DAC on ${chip.id} */` };
-  }
-
-  const ch = findDacChannel(chip, o.pin);
-  if (!ch) {
-    const valid = [...chip.dac.channels].map((c) => c.pin).sort((a, b) => a - b).join(', ');
-    return {
-      code: `/* dac on pin ${o.pin}: not a DAC pin on ${chip.id} (valid: ${valid}) */`,
-    };
-  }
-
-  switch (op.operation) {
-    case 'dac.write': {
-      // Lazy one-time channel setup on first write (the HAL DAC surface has no
-      // begin()), then output the value. Arduino analogWrite is 0–255 against
-      // the channel's resolution; dac_write_value takes the raw code.
-      return {
-        code: [
-          `{ static bool __tc_dac_done = false;`,
-          `  if (!__tc_dac_done) {`,
-          `    static const struct dac_channel_cfg __tc_dac_cfg = { .channel_id = ${ch.channel}, .resolution = ${ch.resolution} };`,
-          `    (void)dac_channel_setup(__tc_dac_dev, &__tc_dac_cfg);`,
-          `    __tc_dac_done = true;`,
-          `  }`,
-          `  (void)dac_write_value(__tc_dac_dev, ${ch.channel}, ${o.value}); }`,
-        ].join(' '),
-      };
-    }
-    default:
-      throw new Error(
-        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
-          `Open an issue or use rawCpp() to emit it manually.`,
-      );
-  }
-}
+// ---------------------------------------------------------------------------
+// DAC lowering — Zephyr DAC driver via dac_channel_setup / dac_write_value
+//
+// Targets with a DAC (ESP32: 2× 8-bit channels on GPIO25/26) declare a `dac`
+// entry in the chip descriptor: the DT device node label + the pin→channel map.
+// The lowering emits a `dac_channel_setup` (lazy, on first write) + a
+// `dac_write_value` against DEVICE_DT_GET(DT_NODELABEL(<device>)).
+//
+// Targets without a DAC (nRF52840, ESP32-S3) omit `dac`; usage there lowers to a
+// comment and profileDiagnostics flags it (mirror of the ADC pin-validity gate).
+// ---------------------------------------------------------------------------
+
+import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
+import type { ZephyrChipDescriptor, ZephyrDacChannel } from '../chips/types.js';
+
+/** Look up a DAC channel by HAL pin number. */
+function findDacChannel(chip: ZephyrChipDescriptor, pin: number): ZephyrDacChannel | undefined {
+  return chip.dac?.channels.find((c) => c.pin === pin);
+}
+
+/**
+ * Emit the DAC device handle. Called from shimLines when the program uses the
+ * DAC (the chip must declare a `dac` entry, or nothing is emitted).
+ */
+export function dacInitLines(chip: ZephyrChipDescriptor): string[] {
+  if (!chip.dac) return [];
+  return [
+    '// CUTTLEFISH_DAC_BEGIN',
+    `static const struct device* __tc_dac_dev = DEVICE_DT_GET(DT_NODELABEL(${chip.dac.device}));`,
+    '// CUTTLEFISH_DAC_END',
+  ];
+}
+
+/**
+ * Resolve a HAL dac.* op to Zephyr C++.
+ * Returns `{ code }` for statement ops.
+ */
+export function lowerDac(
+  op: HALOpIR,
+  chip: ZephyrChipDescriptor,
+): { code?: string; expression?: string } {
+  const o = op as any;
+
+  // No DAC on this target (e.g. nRF52840). Return a comment so the resolver
+  // reports non-undefined (the manifest validator's probe sends pin:25 on the
+  // default chip, which has no DAC). profileDiagnostics flags real misuse.
+  if (!chip.dac) {
+    return { code: `/* dac on pin ${o.pin}: no DAC on ${chip.id} */` };
+  }
+
+  const ch = findDacChannel(chip, o.pin);
+  if (!ch) {
+    const valid = [...chip.dac.channels].map((c) => c.pin).sort((a, b) => a - b).join(', ');
+    return {
+      code: `/* dac on pin ${o.pin}: not a DAC pin on ${chip.id} (valid: ${valid}) */`,
+    };
+  }
+
+  switch (op.operation) {
+    case 'dac.write_value': {
+      // Thin DAC: raw code with the construction resolution (0 = the
+      // descriptor channel's), lazy setup per pin.
+      const res = Number(o.resolution) > 0 ? Number(o.resolution) : ch.resolution;
+      return {
+        code: [
+          `{ static bool __tc_dact${o.pin}_done = false;`,
+          `  if (!__tc_dact${o.pin}_done) {`,
+          `    static const struct dac_channel_cfg __tc_dact${o.pin}_cfg = { .channel_id = ${ch.channel}, .resolution = ${res} };`,
+          `    (void)dac_channel_setup(__tc_dac_dev, &__tc_dact${o.pin}_cfg);`,
+          `    __tc_dact${o.pin}_done = true;`,
+          `  }`,
+          `  (void)dac_write_value(__tc_dac_dev, ${ch.channel}, ${o.value}); }`,
+        ].join(' '),
+      };
+    }
+    default:
+      throw new Error(
+        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
+          `Open an issue or use rawCpp() to emit it manually.`,
+      );
+  }
+}