@typecad/hal 1.0.0-alpha.13 → 1.0.0-alpha.15

package/src/pwm-pin.ts

@@ -0,0 +1,54 @@
+// ---------------------------------------------------------------------------
+// PWM — the thin Zephyr-shaped PWM channel
+//
+// The period is a CONSTRUCTION fact (Zephyr's model — the period lives with
+// the channel, not with each write): `new PWM(PA5, { periodNs: 20_000_000 })`.
+// The first use applies the construction period (pwm_set_dt with an idle
+// pulse — Zephyr 4.4 has no period-only setter), then setPulse lowers to
+// pwm_set_pulse_dt verbatim. setDuty(0.0–1.0) is sugar that lowers to
+// exactly one pwm_set_pulse_dt against the known period — no 0–255 scaling
+// anywhere. Nanoseconds throughout.
+// ----------------------------------------------------------------------------
+
+import { pwmSetPulse, pwmSetDuty, pwmSetPeriod } from './emit.js';
+import type { Pin } from './gpio.js';
+
+export class PWM {
+  private readonly _pin: number;
+  private readonly _periodNs: number;
+  // Routing overrides (the inline escape hatch): the DT controller nodelabel
+  // and channel for pins the facts layer does not cover.
+  private readonly _controller: string;
+  private readonly _channel: number;
+
+  /** Construct a PWM channel. `periodNs` is required — the channel's period
+   *  in nanoseconds (50 Hz servo = 20_000_000; 1 kHz LED dimming = 1_000_000).
+   *  `controller`/`channel` override the routing when the board's facts do
+   *  not map this pin. */
+  constructor(
+    pin: number | Pin,
+    opts: { periodNs: number; controller?: string; channel?: number },
+  ) {
+    this._pin = typeof pin === 'number' ? pin : pin.number;
+    this._periodNs = opts.periodNs;
+    this._controller = opts?.controller ?? '';
+    this._channel = opts?.channel ?? -1;
+  }
+
+  /** Set the pulse width in nanoseconds (pwm_set_pulse_dt). */
+  setPulse(pulseNs: number): void {
+    pwmSetPulse(this._pin, this._periodNs, pulseNs, this._controller, this._channel);
+  }
+
+  /** Set the duty cycle as a fraction 0.0–1.0. Sugar: lowers to one
+   *  pwm_set_pulse_dt with pulse = duty × the constructed period. */
+  setDuty(duty: number): void {
+    pwmSetDuty(this._pin, this._periodNs, duty, this._controller, this._channel);
+  }
+
+  /** Change the period at runtime (pwm_set_dt). Zephyr 4.4 has no period-only
+   *  setter, so the pulse resets to idle — follow with setPulse/setDuty. */
+  setPeriod(periodNs: number): void {
+    pwmSetPeriod(this._pin, periodNs, this._controller, this._channel);
+  }
+}

package/src/random.ts

@@ -1,31 +1,24 @@
-import { rawCpp } from './emit.js';
-
-export function randomSeed(seed: number): void {}
-export function random(minOrMax: number, max?: number): number { return 0; }
+// ---------------------------------------------------------------------------
+// Random — the thin PRNG surface
+//
+// The Random namespace methods (seed/upTo/between/int) are intercepted by the
+// transpiler's namespace-method resolver and lowered to the random.* HAL op
+// family (random.seed / random.range / random.int), which each framework lowers
+// to its platform PRNG (Zephyr: a userspace xorshift32 seeded from
+// sys_rand_get). The bodies below are inert runtime stubs for host-side
+// type-checking only — never emitted.
+// ---------------------------------------------------------------------------
 
 export class Random {
   /** Seeds the PRNG with a starting value. */
-  static seed(val: number): void {
-    rawCpp(`randomSeed(${val});`);
-  }
+  static seed(val: number): void {}
 
   /** Returns a random number in range [0, max-1]. */
-  static upTo(max: number): number {
-    rawCpp(`return random(${max});`);
-    return 0;
-  }
+  static upTo(max: number): number { return 0; }
 
   /** Returns a random number in range [min, max-1]. */
-  static between(min: number, max: number): number {
-    rawCpp(`return random(${min}, ${max});`);
-    return 0;
-  }
+  static between(min: number, max: number): number { return 0; }
 
   /** Returns a random non-negative 31-bit integer [0, 2147483646]. */
-  static int(): number {
-    // Arduino random(max) returns [0, max-1]; 2147483647 = INT_MAX gives a
-    // non-negative 31-bit range (sign bit always 0).
-    rawCpp(`return random(2147483647);`);
-    return 0;
-  }
+  static int(): number { return 0; }
 }