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

package/src/toolchain/index.ts

@@ -206,12 +206,17 @@ export const Toolchain = {
     // for either driver. Thread a non-default profile here only if a future
     // board carries a display node under a different nodelabel.
     const displayProfile = usesDisplay ? DEFAULT_ZEPHYR_DISPLAY_PROFILE : undefined;
+    // Touch controller kind comes from which DT nodelabel the emitted adapter
+    // references (FT6336U on I2C, XPT2046 on the display's SPI bus).
+    const usesTouch = uses('ft6336u') || uses('touch_');
+    const usesXpt = uses('xpt2046');
     const overlay = generateOverlay(chip, {
       usesI2c: uses('i2c_'),
       usesSpi: uses('spi_'),
       usesUart: uses('uart_'),
       usesDisplay,
-      usesTouch: uses('ft6336u') || uses('touch_'),
+      usesTouch: usesTouch || usesXpt,
+      touchController: usesXpt ? 'xpt2046' : 'ft6336u',
     }, displayProfile);
     const overlayDir = join(projectRoot, 'boards');
     mkdirSync(overlayDir, { recursive: true });
@@ -303,23 +308,49 @@ export const Toolchain = {
             backlightPin: typeof dispCfg.backlightPin === 'number' ? dispCfg.backlightPin : undefined,
           }
         : undefined;
-      // Extract touch pin wiring (irq/resetPin/sda/scl) from the config
-      // display.touch section so the DT overlay wires the I2C bus + touch node.
+      // Extract touch pin wiring from the config display.touch section so the
+      // DT overlay wires the bus + touch node. I2C (FT6336U) carries
+      // irq/resetPin/sda/scl; SPI (XPT2046) carries irq/cs + the calibration
+      // range the xptek,xpt2046 binding requires.
       const touchCfg = dispCfg?.touch as Record<string, unknown> | undefined;
-      const touchWiring: TouchWiring | undefined = touchCfg
+      const isXpt = touchCfg?.library === 'XPT2046_Touchscreen';
+      const touchCal = touchCfg?.calibration as
+        { xMin?: unknown; xMax?: unknown; yMin?: unknown; yMax?: unknown } | undefined;
+      const num = (v: unknown): number | undefined => (typeof v === 'number' ? v : undefined);
+      let touchWiring: TouchWiring | undefined = touchCfg
         ? {
-            irq: typeof touchCfg.irq === 'number' ? touchCfg.irq : undefined,
-            resetPin: typeof touchCfg.resetPin === 'number' ? touchCfg.resetPin : undefined,
-            sda: typeof touchCfg.sda === 'number' ? touchCfg.sda : undefined,
-            scl: typeof touchCfg.scl === 'number' ? touchCfg.scl : undefined,
+            controller: isXpt ? 'xpt2046' : 'ft6336u',
+            irq: num(touchCfg.irq),
+            resetPin: num(touchCfg.resetPin),
+            sda: num(touchCfg.sda),
+            scl: num(touchCfg.scl),
+            cs: num(touchCfg.cs),
+            calibration: touchCal
+              ? {
+                  xMin: num(touchCal.xMin) ?? 0,
+                  xMax: num(touchCal.xMax) ?? 4095,
+                  yMin: num(touchCal.yMin) ?? 0,
+                  yMax: num(touchCal.yMax) ?? 4095,
+                }
+              : undefined,
+            minPressure: num(touchCfg.minPressure),
           }
         : undefined;
+      // Touch controller kind for Kconfig (bus driver selection) and the DT
+      // node shape: from the config when available, else from the DT nodelabel
+      // the emitted adapter references. Forced onto touchWiring so a source
+      // scan match without a config section still emits the right node.
+      const usesXpt = isXpt || uses('xpt2046');
+      if (usesXpt) {
+        touchWiring = { controller: 'xpt2046', ...(touchWiring ?? {}) };
+      }
       const overlay = generateOverlay(chip, {
         usesI2c: uses('i2c_'),
         usesSpi: uses('spi_'),
         usesUart: uses('uart_'),
         usesDisplay,
-        usesTouch: uses('ft6336u') || uses('touch_'),
+        usesTouch: uses('ft6336u') || uses('touch_') || usesXpt,
+        touchController: usesXpt ? 'xpt2046' : 'ft6336u',
         psram: o.psram,
       }, displayProfile, wiring, touchWiring);
       const overlayDir = join(projectRoot, 'boards');

package/src/toolchain/scaffold.ts

@@ -85,6 +85,9 @@ export function scaffoldZephyrProject(projectRoot: string, debug = false, userKc
   const usage: KconfigUsage = {
     usesAdc: uses('adc_'),
     usesPwm: uses('pwm_'),
+    usesDac: uses('dac_') || uses('__tc_dac'),
+    usesFS: uses('__tc_fs'),
+    usesHwtimer: uses('counter_') || uses('__tc_hw'),
     usesI2c: uses('i2c_'),
     usesSpi: uses('spi_'),
     usesUart: uses('uart_'),
@@ -127,8 +130,10 @@ export function scaffoldZephyrProject(projectRoot: string, debug = false, userKc
     '',
     'project(zephyr_app)',
     '',
-    '# Collect cuttlefish-emitted sources.',
-    'file(GLOB app_sources src/*.cpp src/*.c)',
+    '# Collect cuttlefish-emitted sources. CONFIGURE_DEPENDS makes CMake re-',
+    '# check the glob when the source set changes (e.g. the transpiler removes',
+    '# a stale entry), instead of linking a file list from the last configure.',
+    'file(GLOB app_sources CONFIGURE_DEPENDS src/*.cpp src/*.c)',
     '',
     'target_sources(app PRIVATE ${app_sources})',
     // When PSRAM is configured, define BOARD_HAS_PSRAM so the UI runtime's

package/src/toolchain/west-discover.ts

@@ -10,15 +10,17 @@
 // Discovery cascade (first usable wins):
 //   1. `west` already on PATH (env already activated / global install).
 //   2. $ZEPHYR_BASE venv: ${ZEPHYR_BASE}/../.venv/<python> -m west.
-//   3. Well-known workspace layouts: ~/zephyrproject/.venv, /opt/zephyrproject/.
+//   3. micromamba env from @typecad/zephyr-installer (invoked via `micromamba run`,
+//      so cuttlefish builds work with NO manual activation).
+//   4. Well-known workspace layouts: ~/zephyrproject/.venv, /opt/zephyrproject/.
 //      venv, etc.
-//   4. System pythons (`python`, `python3`, `py`) via `-m west`.
+//   5. System pythons (`python`, `python3`, `py`) via `-m west`.
 //
 // Leaner than the ESP-IDF equivalent: west needs no env sourcing (no 15s
 // export.sh) — only the right interpreter + ZEPHYR_BASE.
 // ---------------------------------------------------------------------------
 
-import { existsSync, realpathSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { spawnSync } from 'node:child_process';
@@ -65,15 +67,21 @@ function westOnPath(cmd: string): boolean {
  * `pythonExecutable -m west`.
  */
 export interface WestInstall {
-  mode: 'launcher' | 'module';
+  mode: 'launcher' | 'module' | 'micromamba';
   /** Absolute path to a `west` launcher (mode 'launcher') or undefined. */
   westExecutable?: string;
   /** Absolute path to a Python interpreter with west installed (mode 'module'). */
   pythonExecutable?: string;
   /** Absolute path to the Zephyr SDK root (for $ZEPHYR_BASE), if found. */
   zephyrBase?: string;
+  /** mode 'micromamba': path to the micromamba binary (for `micromamba run -n …`). */
+  micromambaExe?: string;
+  /** mode 'micromamba': the conda env name (default 'zephyr'). */
+  envName?: string;
+  /** mode 'micromamba': MAMBA_ROOT_PREFIX, injected so micromamba finds its envs. */
+  mambaRootPrefix?: string;
   /** Which discovery strategy found this install. */
-  source: 'path' | 'zephyr-base-venv' | 'well-known' | 'system-python';
+  source: 'path' | 'zephyr-base-venv' | 'well-known' | 'system-python' | 'micromamba';
 }
 
 /** True if `dir` looks like a Zephyr SDK root: has CMakeLists.txt and the
@@ -89,9 +97,12 @@ export function isZephyrBase(dir: string): boolean {
 // ── Strategy 1: `west` on PATH ──────────────────────────────────────────────
 
 export function discoverFromPath(): WestInstall | null {
+  // shell only on Windows (where.exe resolution through cmd) — an args array
+  // with shell: true triggers Node's DEP0190 deprecation warning on Linux/
+  // macOS, where `which` is a plain executable that needs no shell.
   const which = spawnSync(IS_WIN ? 'where' : 'which', ['west'], {
     encoding: 'utf8',
-    shell: true,
+    shell: IS_WIN,
     windowsHide: true,
   });
   if (which.status !== 0) return null;
@@ -128,7 +139,77 @@ export function discoverFromZephyrBase(): WestInstall | null {
   };
 }
 
-// ── Strategy 3: well-known workspace layouts ───────────────────────────────
+// ── Strategy 3: micromamba env (the @typecad/zephyr-installer install) ─────
+
+// Locate the micromamba binary + root prefix. The installer downloads
+// micromamba to $MAMBA_ROOT_PREFIX/bin (POSIX) or Library/bin (Windows); the
+// root defaults to ~/micromamba. Returns null if the binary isn't present
+// (the installer hasn't run on this machine).
+function findMicromamba(): { exe: string; rootPrefix: string } | null {
+  const root = process.env.MAMBA_ROOT_PREFIX || join(homedir(), 'micromamba');
+  const exe = IS_WIN
+    ? join(root, 'Library', 'bin', 'micromamba.exe')
+    : join(root, 'bin', 'micromamba');
+  return existsSync(exe) ? { exe, rootPrefix: root } : null;
+}
+
+/**
+ * The micromamba env created by `@typecad/zephyr-installer`. The env's west
+ * lives at envs/<name>/bin/west (POSIX) or Scripts/west.exe (Windows). Found
+ * installs are invoked via `micromamba run -n <name> west …` (see
+ * west-spawn.ts), which sets up the env's full PATH (cmake/ninja/dtc) AND runs
+ * the activation hook (ZEPHYR_BASE / ZEPHYR_SDK_INSTALL_DIR) — so cuttlefish
+ * builds work with NO manual `micromamba activate`. This is what makes a fresh
+ * `cuttlefish build` succeed in any project without the user activating.
+ *
+ * Env name defaults to "zephyr"; override via TYPECAD_ZEPHYR_ENV. File-check
+ * based (no spawn) so it's cheap to run on every cuttlefish invocation.
+ */
+/** Read a TYPECAD_ZEPHYR_* value from the installer-written env-vars file in
+ *  a micromamba env. Handles .sh (export VAR="val"), .bat (set "VAR=val"),
+ *  and .ps1 ($env:VAR = "val"). Returns undefined if absent/unreadable. */
+function readMicromambaEnvVar(envDir: string, varName: string): string | undefined {
+  const candidates = IS_WIN
+    ? [join(envDir, 'etc', 'conda', 'env-vars.ps1'), join(envDir, 'etc', 'conda', 'env-vars.bat')]
+    : [join(envDir, 'etc', 'conda', 'env-vars.sh')];
+  for (const f of candidates) {
+    if (!existsSync(f)) continue;
+    try {
+      const text = readFileSync(f, 'utf8');
+      // .sh/.ps1: VAR = "value" (quoted value after =).
+      let m = text.match(new RegExp(`${varName}\\s*=\\s*"([^"]+)"`));
+      if (m) return m[1];
+      // .bat: set "VAR=value" (value after VAR= inside quotes).
+      m = text.match(new RegExp(`${varName}=([^"\\r\\n]+)"`));
+      if (m) return m[1].trim();
+    } catch { /* ignore unreadable */ }
+  }
+  return undefined;
+}
+
+export function discoverFromMicromamba(
+  envName: string = process.env.TYPECAD_ZEPHYR_ENV || 'zephyr',
+): WestInstall | null {
+  const mm = findMicromamba();
+  if (!mm) return null;
+  const envDir = join(mm.rootPrefix, 'envs', envName);
+  const westExe = join(envDir, IS_WIN ? 'Scripts' : 'bin', IS_WIN ? 'west.exe' : 'west');
+  if (!existsSync(envDir) || !existsSync(westExe)) return null;
+  // Read ZEPHYR_BASE from the installer's env-vars so the compat check (and
+  // anything else in the cuttlefish process) can detect the Zephyr version
+  // WITHOUT activation — micromamba run sets it only inside the west subprocess.
+  const zb = readMicromambaEnvVar(envDir, 'TYPECAD_ZEPHYR_BASE');
+  return {
+    mode: 'micromamba',
+    micromambaExe: mm.exe,
+    envName,
+    mambaRootPrefix: mm.rootPrefix,
+    zephyrBase: zb && isZephyrBase(zb) ? zb : undefined,
+    source: 'micromamba',
+  };
+}
+
+// ── Strategy 4: well-known workspace layouts ───────────────────────────────
 
 /** Candidate Zephyr workspace directories. Each may contain both `.venv/`
  *  and `zephyr/` (the SDK). Exported for test injection. */
@@ -169,7 +250,7 @@ export function discoverFromWellKnown(
   return null;
 }
 
-// ── Strategy 4: system pythons via `-m west` ────────────────────────────────
+// ── Strategy 5: system pythons via `-m west` ────────────────────────────────
 
 /** Candidate system Python interpreters to probe with `-m west`. */
 export function systemPythons(): string[] {
@@ -205,7 +286,8 @@ export function resetWestDiscoveryCache(): void {
  * Try each discovery strategy in order. The first usable install wins.
  * Result is memoized for the process lifetime (west installs don't move).
  *
- * Order: PATH → $ZEPHYR_BASE venv → well-known workspaces → system pythons.
+ * Order: PATH → $ZEPHYR_BASE venv → micromamba env → well-known workspaces →
+ * system pythons.
  * Returns null when no usable west install is found.
  */
 export function discoverWest(): WestInstall | null {
@@ -213,6 +295,7 @@ export function discoverWest(): WestInstall | null {
   const strategies: Array<() => WestInstall | null> = [
     discoverFromPath,
     discoverFromZephyrBase,
+    discoverFromMicromamba,
     discoverFromWellKnown,
     discoverFromSystemPython,
   ];

package/src/toolchain/west-spawn.ts

@@ -121,6 +121,21 @@ export function westSpawn(
   // an explicit shell changes arg-quoting semantics on Windows.
   const { shell: _drop, ...optsWithoutShell } = baseOptions as any;
 
+  if (install.mode === 'micromamba' && install.micromambaExe) {
+    // `micromamba run -n <env> west …` sets up the env's full PATH
+    // (cmake/ninja/dtc) and runs the activation hook (ZEPHYR_BASE /
+    // ZEPHYR_SDK_INSTALL_DIR), so cuttlefish builds work WITHOUT the user
+    // activating the env. Inject MAMBA_ROOT_PREFIX so micromamba finds envs.
+    const mmEnv = { ...env };
+    if (install.mambaRootPrefix) mmEnv.MAMBA_ROOT_PREFIX = install.mambaRootPrefix;
+    return {
+      command: install.micromambaExe,
+      args: ['run', '-n', install.envName ?? 'zephyr', 'west', ...westArgs],
+      options: { ...optsWithoutShell, env: mmEnv },
+      install,
+    };
+  }
+
   if (install.mode === 'launcher' && install.westExecutable) {
     return {
       command: install.westExecutable,