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

package/src/mdns.ts

@@ -1,50 +0,0 @@
-/**
- * MdnsClass — mDNS service discovery (ESP-IDF esp_mdns).
- *
- * Lowered to native mDNS HAL ops (mdns.*): ESP-IDF's esp_mdns component
- * advertises the device on the local network as `<hostname>.local` and
- * publishes services (e.g. `_http._tcp`) for discovery by Bonjour/Avahi.
- *
- * The semantic primitives (mdnsStart / mdnsAddService / ...) are resolved to
- * mdns.* HAL ops by the transpiler; this class is the ergonomic surface.
- *
- * Requires WiFi to be connected (mDNS rides on the station interface).
- */
-export class MdnsClass {
-  static readonly __instance_name = "MDNS";
-
-  /** Initialize mDNS and set the host name (advertised as <name>.local). */
-  start(hostname: string): boolean {
-    mdnsStart(hostname);
-    return true;
-  }
-
-  /** Set/override the host name after start(). */
-  setHostname(name: string): void {
-    mdnsSetHostname(name);
-  }
-
-  /** Publish a service instance. proto is "_tcp" or "_udp". */
-  addService(instance: string, proto: string, port: number): void {
-    mdnsAddService(instance, proto, port);
-  }
-
-  /** Advertise that the device is reachable (sends a probe/announce). */
-  announce(): void {
-    mdnsAnnounce();
-  }
-
-  /** Tear down the mDNS responder. */
-  stop(): void {
-    mdnsStop();
-  }
-}
-
-export const MDNS = new MdnsClass();
-
-// ── Semantic primitives (resolved to mdns.* HAL ops by the transpiler) ──
-export function mdnsStart(hostname: string): void {}
-export function mdnsSetHostname(name: string): void {}
-export function mdnsAddService(instance: string, proto: string, port: number): void {}
-export function mdnsAnnounce(): void {}
-export function mdnsStop(): void {}

package/src/ota.ts

@@ -1,44 +0,0 @@
-/**
- * OtaClass — over-the-air firmware update (ESP-IDF esp_https_ota / esp_app_format).
- *
- * Lowered to native OTA HAL ops (ota.*): ESP-IDF's esp_https_ota downloads a
- * firmware image over HTTPS and writes it to the OTA partition, then reboots
- * into it. The runtime shim owns the session/progress/verification dance.
- *
- * Requires a network connection (WiFi) and that the partition table defines
- * at least two OTA app slots (the framework's default partitions.csv does).
- */
-export class OtaClass {
-  static readonly __instance_name = "OTA";
-
-  /** Download and apply a firmware image from an HTTPS URL, then reboot.
-   *  Blocks until the update is written and verified. Returns true on success
-   *  (the reboot happens inside the shim on success, so a true return means
-   *  the new firmware is about to boot). */
-  fromUrl(url: string): boolean {
-    return otaFromUrl(url);
-  }
-
-  /** Begin a manual update session (caller writes chunks via write()). */
-  begin(): boolean {
-    return otaBegin();
-  }
-
-  /** Write a chunk of firmware data to the OTA partition. */
-  write(chunk: string): void {
-    otaWrite(chunk);
-  }
-
-  /** Finalize the update: verify, set the boot partition, and reboot. */
-  apply(): void {
-    otaApply();
-  }
-}
-
-export const OTA = new OtaClass();
-
-// ── Semantic primitives (resolved to ota.* HAL ops by the transpiler) ──
-export function otaFromUrl(url: string): boolean { return false; }
-export function otaBegin(): boolean { return false; }
-export function otaWrite(chunk: string): void {}
-export function otaApply(): void {}

package/src/power.ts

@@ -1,36 +0,0 @@
-import { powerDeepSleep, powerLightSleep, powerSetCpuFrequency, powerDeepSleepPin } from './emit.js';
-
-/**
- * PowerClass provides control over MCU power states and clock frequencies.
- *
- * The arch guard (ESP32 family vs AVR) lives in the strategy, not here — it
- * relies on the FQBN-derived architecture which is always available at
- * transpile time, unlike `board("architecture")` which needs a board package.
- */
-export class PowerClass {
-  static readonly __instance_name = "Power";
-
-  deepSleep(ms: number): void {
-    powerDeepSleep(ms);
-  }
-
-  /** Enter deep sleep until `pin` reaches `level` (0 = low, 1 = high).
-   *
-   *  Lowers to ext0 wakeup (Xtensa ESP32/S3, RTC pins only) or the gpio-wakeup
-   *  variant (RISC-V C3/C6) depending on the target. `pin` must be RTC-capable;
-   *  the framework flags non-RTC pins at compile time. Wakeup resets the chip,
-   *  so this call never returns. */
-  deepSleepPin(pin: number, level: 0 | 1): void {
-    powerDeepSleepPin(pin, level);
-  }
-
-  lightSleep(): void {
-    powerLightSleep();
-  }
-
-  setCpuFrequency(mhz: number): void {
-    powerSetCpuFrequency(mhz);
-  }
-}
-
-export const Power = new PowerClass();

package/src/pulse.ts

@@ -1,63 +0,0 @@
-import { rawCpp } from './emit.js';
-import { HIGH, LOW } from './constants.js';
-import type { Pin, InputPin } from './gpio.js';
-
-export function pulseIn(pin: number, value: number, timeout?: number): number {
-  if (timeout !== undefined) {
-    rawCpp(`return pulseIn(${pin}, ${value}, ${timeout});`);
-  } else {
-    rawCpp(`return pulseIn(${pin}, ${value});`);
-  }
-  return 0;
-}
-export function pulseInLong(pin: number, value: number, timeout?: number): number {
-  if (timeout !== undefined) {
-    rawCpp(`return pulseInLong(${pin}, ${value}, ${timeout});`);
-  } else {
-    rawCpp(`return pulseInLong(${pin}, ${value});`);
-  }
-  return 0;
-}
-
-export class Pulse {
-  /** 
-   * Functional entrypoint for measuring pulses.
-   * @example Pulse.on(D7).high()
-   */
-  static on(pin: Pin | InputPin): PulseMeasurement {
-    return new PulseMeasurement(pin);
-  }
-
-  /** Measure long pulses using high-precision 64-bit timers. */
-  static long(pin: Pin | InputPin, value: number): number {
-    rawCpp(`return pulseInLong(${pin.number}, ${value});`);
-    return 0;
-  }
-}
-
-class PulseMeasurement {
-  private _pin: number;
-  private _timeout: number | undefined;
-
-  constructor(pin: Pin | InputPin) {
-    this._pin = pin.number;
-  }
-
-  /** Set the maximum wait time for a pulse (in microseconds). */
-  timeout(us: number): this {
-    this._timeout = us;
-    return this;
-  }
-
-  /** Measures the next HIGH pulse duration in microseconds. */
-  high(): number {
-    rawCpp(`return pulseIn(${this._pin}, HIGH${this._timeout !== undefined ? `, ${this._timeout}` : ""});`);
-    return 0;
-  }
-
-  /** Measures the next LOW pulse duration in microseconds. */
-  low(): number {
-    rawCpp(`return pulseIn(${this._pin}, LOW${this._timeout !== undefined ? `, ${this._timeout}` : ""});`);
-    return 0;
-  }
-}

package/src/rmt.ts

@@ -1,125 +0,0 @@
-// ---------------------------------------------------------------------------
-// @typecad/hal — RMT (Remote Control Transceiver) ergonomic API
-// ---------------------------------------------------------------------------
-// Exposes RMT via a RmtChannel class, mirroring the I2CBus/I2CDevice pattern.
-// The transpiler only resolves semantic calls made inside class-method bodies
-// (free top-level calls emit verbatim), so every peripheral exposes its API
-// through a class whose methods call the positional semantic primitives in
-// emit.ts. The resolver collapses object literals, so HALOpIR fields must be
-// scalars; these methods destructure `opts` at the call site before forwarding.
-//
-// Channel identity is the GPIO pin (like pwm.ts's LEDC channel-per-pin model).
-
-import type { Pin } from './gpio.js';
-import {
-  rmtTxInit,
-  rmtRxInit,
-  rmtTxWriteBytes,
-  rmtTxWriteSymbols,
-  rmtTxWaitDone,
-  rmtTxDeinit,
-  rmtRxOnReceived,
-  rmtRxStart,
-  rmtRxStop,
-  rmtRxRead,
-  rmtRxDeinit,
-} from './emit.js';
-
-/** Pin identifier accepted by RmtChannel: a Pin object, raw GPIO number, or port name. */
-type RmtPin = Pin | number | string;
-
-/**
- * RMT transceiver channel bound to a GPIO pin. One channel per pin; TX and RX
- * are independent roles on the same channel object.
- *
- * ```ts
- * const led = new RmtChannel(LED);
- * led.txInit({ resolutionHz: 10_000_000, bit0: [4, 9], bit1: [9, 4] });
- * led.txWriteBytes([0, 16, 0]);
- * led.txWaitDone();
- * ```
- */
-export class RmtChannel {
-  private _pin: RmtPin;
-
-  constructor(pin: RmtPin) {
-    this._pin = pin;
-  }
-
-  // ── TX ─────────────────────────────────────────────────────────────────────
-  /** Initialize the channel for TX. Idempotent per pin. Bit timings are fixed
-   *  at init — ESP-IDF bakes them into the bytes-encoder and exposes no public
-   *  mutation API. Tick units are 1/resolutionHz seconds.
-   *
-   *  Args are positional scalars (not an opts object) because the transpiler's
-   *  method-body renderer folds scalar params but not property accesses on an
-   *  object param (opts.resolutionHz would render as a collapsed object + dead
-   *  property access). Mirrors how I2CBus.begin(address) takes a scalar. */
-  txInit(
-    resolutionHz: number,
-    bit0Hi: number, bit0Lo: number,
-    bit1Hi: number, bit1Lo: number,
-    msbFirst: boolean = false,
-    queueDepth: number = 4,
-  ): void {
-    rmtTxInit(
-      this._pin,
-      resolutionHz,
-      bit0Hi, bit0Lo,
-      bit1Hi, bit1Lo,
-      msbFirst,
-      queueDepth,
-    );
-  }
-
-  /** Write bytes via the channel's bytes-encoder (timings fixed at txInit). */
-  txWriteBytes(bytes: number[] | Uint8Array): void {
-    rmtTxWriteBytes(this._pin, bytes);
-  }
-
-  /** Write raw RMT symbols — arbitrary [hiTicks, loTicks] pairs. */
-  txWriteSymbols(symbols: [number, number][]): void {
-    rmtTxWriteSymbols(this._pin, symbols);
-  }
-
-  /** Block until the queued TX completes. */
-  txWaitDone(timeoutMs?: number): void {
-    rmtTxWaitDone(this._pin, timeoutMs);
-  }
-
-  /** Tear down the TX channel and release its slot. */
-  txDeinit(): void {
-    rmtTxDeinit(this._pin);
-  }
-
-  // ── RX ─────────────────────────────────────────────────────────────────────
-  /** Initialize the channel for RX. Idempotent per pin. */
-  rxInit(resolutionHz: number): void {
-    rmtRxInit(this._pin, resolutionHz);
-  }
-
-  /** Register a callback-by-name invoked when an RX burst completes. */
-  rxOnReceived(handler: string): void {
-    rmtRxOnReceived(this._pin, handler);
-  }
-
-  /** Start receiving. */
-  rxStart(): void {
-    rmtRxStart(this._pin);
-  }
-
-  /** Stop receiving. */
-  rxStop(): void {
-    rmtRxStop(this._pin);
-  }
-
-  /** Blocking read — returns flattened symbols [d0,l0,d1,l1,…] in ticks. */
-  rxRead(maxCount: number): number[] {
-    return rmtRxRead(this._pin, maxCount);
-  }
-
-  /** Tear down the RX channel and release its slot. */
-  rxDeinit(): void {
-    rmtRxDeinit(this._pin);
-  }
-}

package/src/shift.ts

@@ -1,88 +0,0 @@
-import { rawCpp } from './emit.js';
-import { LSBFIRST, MSBFIRST } from './constants.js';
-import type { Pin, OutputPin, InputPin } from './gpio.js';
-
-export function shiftIn(dataPin: number, clockPin: number, bitOrder: number): number {
-  rawCpp(`return shiftIn(${dataPin}, ${clockPin}, ${bitOrder});`);
-  return 0;
-}
-export function shiftOut(dataPin: number, clockPin: number, bitOrder: number, value: number): void {
-  rawCpp(`shiftOut(${dataPin}, ${clockPin}, ${bitOrder}, ${value});`);
-}
-
-export class Shift {
-  /** Directly shifts a byte out to a pin. */
-  static out(dataPin: Pin | OutputPin, clockPin: Pin | OutputPin, order: 'lsb' | 'msb', value: number): void {
-    const bitOrder = order === 'lsb' ? LSBFIRST : MSBFIRST;
-    rawCpp(`shiftOut(${dataPin.number}, ${clockPin.number}, ${bitOrder}, ${value});`);
-  }
-
-  /** Directly shifts a byte in from a pin. */
-  static in(dataPin: Pin | InputPin, clockPin: Pin | OutputPin, order: 'lsb' | 'msb'): number {
-    const bitOrder = order === 'lsb' ? LSBFIRST : MSBFIRST;
-    rawCpp(`return shiftIn(${dataPin.number}, ${clockPin.number}, ${bitOrder});`);
-    return 0;
-  }
-
-  /** Fluent builder for shifting out. */
-  static write(dataPin: Pin | OutputPin, value: number): ShiftOutBuilder {
-    return new ShiftOutBuilder(dataPin, value);
-  }
-
-  /** Fluent builder for shifting in. */
-  static read(dataPin: Pin | InputPin): ShiftInBuilder {
-    return new ShiftInBuilder(dataPin);
-  }
-}
-
-class ShiftOutBuilder {
-  private _dataPin: number;
-  private _value: number;
-  private _clockPin: number | undefined;
-
-  constructor(dataPin: Pin | OutputPin, value: number) {
-    this._dataPin = dataPin.number;
-    this._value = value;
-  }
-
-  clock(clk: Pin | OutputPin): this {
-    this._clockPin = clk.number;
-    return this;
-  }
-
-  msbFirst(): void {
-    if (this._clockPin === undefined) throw new Error("Clock pin must be specified");
-    rawCpp(`shiftOut(${this._dataPin}, ${this._clockPin}, MSBFIRST, ${this._value});`);
-  }
-
-  lsbFirst(): void {
-    if (this._clockPin === undefined) throw new Error("Clock pin must be specified");
-    rawCpp(`shiftOut(${this._dataPin}, ${this._clockPin}, LSBFIRST, ${this._value});`);
-  }
-}
-
-class ShiftInBuilder {
-  private _dataPin: number;
-  private _clockPin: number | undefined;
-
-  constructor(dataPin: Pin | InputPin) {
-    this._dataPin = dataPin.number;
-  }
-
-  clock(clk: Pin | OutputPin): this {
-    this._clockPin = clk.number;
-    return this;
-  }
-
-  msbFirst(): number {
-    if (this._clockPin === undefined) throw new Error("Clock pin must be specified");
-    rawCpp(`return shiftIn(${this._dataPin}, ${this._clockPin}, MSBFIRST);`);
-    return 0;
-  }
-
-  lsbFirst(): number {
-    if (this._clockPin === undefined) throw new Error("Clock pin must be specified");
-    rawCpp(`return shiftIn(${this._dataPin}, ${this._clockPin}, LSBFIRST);`);
-    return 0;
-  }
-}

package/src/temperature.ts

@@ -1,20 +0,0 @@
-/**
- * TemperatureClass — on-chip die temperature sensor.
- *
- * Lowered to the temp.* HAL op: ESP-IDF's temperature_sensor driver reads the
- * internal die temperature in °C. Useful for thermal monitoring and
- * compensation. No external components required.
- */
-export class TemperatureClass {
-  static readonly __instance_name = "Temperature";
-
-  /** Read the on-chip die temperature in degrees Celsius. */
-  read(): number {
-    return tempRead();
-  }
-}
-
-export const Temperature = new TemperatureClass();
-
-// ── Semantic primitive (resolved to temp.* HAL op by the transpiler) ──
-export function tempRead(): number { return 0; }

package/src/timer.ts

@@ -1,58 +0,0 @@
-import { boardResolve } from './emit.js';
-import { callback } from './callback.js';
-
-/**
- * HardwareTimer provides direct control over the board's hardware timers.
- *
- * Hardware timers are distinct from the software-based setInterval/setTimeout
- * and are typically used for high-precision timing, PWM generation, or
- * interrupt-driven tasks. Lowered to hwtimer.* HAL ops: ESP-IDF's GPTimer
- * driver (driver/gptimer.h); Arduino's HardwareTimer (Timer0/1/2 on STM32).
- *
- * The instance index maps to the platform's timer numbering (ESP-IDF GPTimer
- * unit 0..n, STM32 TIM0..n).
- */
-export class HardwareTimer {
-  private _instance: number;
-
-  constructor(instance: number) {
-    this._instance = instance;
-  }
-
-  /** Sets the timer frequency in Hertz. */
-  setFrequency(hz: number): void {
-    hwtimerSetFrequency(this._instance, hz);
-  }
-
-  /** Attaches an interrupt handler that executes when the timer overflows. */
-  onOverflow(handler: () => void): void {
-    hwtimerOnOverflow(this._instance, callback(handler));
-  }
-
-  /** Starts the timer. */
-  start(): void {
-    hwtimerStart(this._instance);
-  }
-
-  /** Stops the timer. */
-  stop(): void {
-    hwtimerStop(this._instance);
-  }
-
-  /** Returns the bit resolution of the timer (e.g., 8, 16, 32). */
-  getBits(): number {
-    // "peripherals.timer" (singular) matches the board-resolver's array-key
-    // derivation (TIMER_INSTANCES → peripherals.timer.<index>.*).
-    return boardResolve("peripherals.timer." + this._instance + ".bits");
-  }
-}
-
-export const Timer0 = new HardwareTimer(0);
-export const Timer1 = new HardwareTimer(1);
-export const Timer2 = new HardwareTimer(2);
-
-// ── Semantic primitives (resolved to hwtimer.* HAL ops by the transpiler) ──
-export function hwtimerSetFrequency(instance: number, hz: number): void {}
-export function hwtimerOnOverflow(instance: number, handler: string): void {}
-export function hwtimerStart(instance: number): void {}
-export function hwtimerStop(instance: number): void {}

package/src/timing.ts

@@ -1,67 +0,0 @@
-import { rawCpp, getMillis, getMicros, getFreeHeap, delayMs, delayMicro } from './emit.js';
-import { callback } from './callback.js';
-
-export class TimingClass {
-  static readonly __instance_name = "Timing";
-  millis(): number { return getMillis(); }
-  micros(): number { return getMicros(); }
-  delay(ms: number): void { delayMs(ms); }
-  delayMicroseconds(us: number): void { delayMicro(us); }
-  freeHeap(): number {
-    return getFreeHeap();
-  }
-
-
-  setInterval(handler: () => void, timeout: number): number {
-    rawCpp(`return __tc_setInterval(${callback(handler)}, ${timeout});`);
-    return 0;
-  }
-
-  setTimeout(handler: () => void, timeout: number): number {
-    rawCpp(`return __tc_setTimeout(${callback(handler)}, ${timeout});`);
-    return 0;
-  }
-
-  clearInterval(id: number): void {
-    rawCpp(`__tc_clearInterval(${id});`);
-  }
-
-  clearTimeout(id: number): void {
-    rawCpp(`__tc_clearTimeout(${id});`);
-  }
-}
-
-export const Timing = new TimingClass();
-
-export function delay(ms: number): void { delayMs(ms); }
-export function millis(): number { return getMillis(); }
-export function micros(): number { return getMicros(); }
-export function delayMicroseconds(us: number): void { delayMicro(us); }
-export function freeHeap(): number { return Timing.freeHeap(); }
-
-
-export function setInterval(handler: () => void, timeout: number): number {
-  rawCpp(`return __tc_setInterval(${callback(handler)}, ${timeout});`);
-  return 0;
-}
-
-export function setTimeout(handler: () => void, timeout: number): number {
-  rawCpp(`return __tc_setTimeout(${callback(handler)}, ${timeout});`);
-  return 0;
-}
-
-export function clearInterval(id: number): void {
-  rawCpp(`__tc_clearInterval(${id});`);
-}
-
-export function clearTimeout(id: number): void {
-  rawCpp(`__tc_clearTimeout(${id});`);
-}
-
-/** Re-map a number from one range to another. Passes through to the Arduino
- *  core `map()` macro — the transpiler lowers this to a bare `map(...)` call,
- *  so the target framework must provide the implementation (Arduino.h does). */
-export function map(value: number, fromLow: number, fromHigh: number, toLow: number, toHigh: number): number { return 0; }
-/** Constrain a number to a range. Passes through to the Arduino core
- *  `constrain()` macro — see note on `map()` above. */
-export function constrain(value: number, low: number, high: number): number { return 0; }

package/src/uart.ts

@@ -1,77 +0,0 @@
-import { uartBegin, uartEnd, uartPrint, uartPrintln, uartPrintf, uartWrite, uartRead, uartPeek, uartAvailable, uartFlush, rawCpp } from './emit.js';
-
-export class SerialPort {
-  static readonly __includes = ["<Arduino.h>"];
-  private _port: string;
-
-  constructor(port: string) {
-    this._port = port;
-  }
-
-  begin(baud: number = 9600): this {
-    uartBegin(this._port, baud);
-    return this;
-  }
-
-  end(): void {
-    uartEnd(this._port);
-  }
-
-  print(value: any): void {
-    uartPrint(this._port, value);
-  }
-
-  println(value: any): void {
-    uartPrintln(this._port, value);
-  }
-
-  printf(format: string, ...args: any[]): void {
-    uartPrintf(this._port, format, args);
-  }
-
-  write(data: any): void {
-    uartWrite(this._port, data);
-  }
-
-  read(): number {
-    return uartRead(this._port);
-  }
-
-  readLine(): string {
-    rawCpp(`return ${this._port}.readStringUntil('\\n');`);
-    return "";
-  }
-
-  peek(): number {
-    return uartPeek(this._port);
-  }
-
-  available(): number {
-    return uartAvailable(this._port);
-  }
-
-  flush(): void {
-    uartFlush(this._port);
-  }
-
-  waitForConnection(timeout?: number): Promise<void> {
-    rawCpp(`while (!${this._port}) { delay(10); }`);
-    return Promise.resolve();
-  }
-
-  take(): this | null {
-    // Basic implementation for single-threaded Arduino; 
-    // real locking would be framework-specific.
-    return this;
-  }
-
-  release(): void {
-    // No-op for standard Arduino.
-  }
-}
-
-
-/** Map TypeCAD UART instance number to Arduino C++ object name. UART0→Serial, UART1→Serial1 */
-export function serialName(instance: number): string {
-  return instance === 0 ? "Serial" : `Serial${instance}`;
-}

package/src/utils.ts

@@ -1,17 +0,0 @@
-/**
- * Helper to inflate peripheral instances from a definition list into a sparse array
- * for named destructuring.
- * 
- * @example
- * export const [UART0, UART1] = createHALInstances(UART_INSTANCES, i => new SerialPort(serialName(i)));
- */
-export function createHALInstances<T>(
-  instances: readonly { instance: number }[],
-  factory: (instance: number) => T
-): T[] {
-  const result: T[] = [];
-  for (const item of instances) {
-    result[item.instance] = factory(item.instance);
-  }
-  return result;
-}

package/src/wdt.ts

@@ -1,17 +0,0 @@
-import { wdtEnable, wdtReset, wdtDisable } from './emit.js';
-
-export class WDTClass {
-  static readonly __instance_name = "WDT";
-
-  enable(timeout: number | string): void {
-    wdtEnable(timeout);
-  }
-  reset(): void {
-    wdtReset();
-  }
-  disable(): void {
-    wdtDisable();
-  }
-}
-
-export const WDT = new WDTClass();