@typecad/hal 1.0.0-alpha.14 → 1.0.0-alpha.16

package/dist/gpio-pin.js

@@ -0,0 +1,77 @@
+// ---------------------------------------------------------------------------
+// GPIO — the thin Zephyr-shaped digital pin class
+//
+// One configured pin handle ≈ gpio_dt_spec + flags, mirroring Zephyr's verbs:
+// construction carries the flag combination (GPIO.OUTPUT | GPIO.PULL_UP),
+// set/get/toggle lower to gpio_pin_set_dt / get_dt / toggle_dt (logical
+// levels — polarity comes from the board's DT node when the pin has a dtSpec),
+// and the configure itself is emitted guarded-per-pin ahead of the first use,
+// so construction flags apply exactly once. No mode strings, no shadow reads.
+//
+// Flag and interrupt tokens are Zephyr's names under the GPIO. namespace
+// (GPIO_OUTPUT ↔ GPIO.OUTPUT, GPIO_INT_EDGE_FALLING ↔ GPIO.INT_EDGE_FALLING);
+// the lowering maps token NAMES to macros, so any Zephyr doc greps both ways.
+// ----------------------------------------------------------------------------
+import { gpioWrite, gpioReadCfg, gpioToggle, gpioConfigure, interruptAttachFlags, interruptDetach } from './emit.js';
+import { callback } from './callback.js';
+export class GPIO {
+    /** Construct a configured pin. `flags` is a combination of the GPIO.*
+     *  statics (the transpiler carries the token text; the values are for the
+     *  editor only). The configure applies once, ahead of the first
+     *  set/get/toggle/onInterrupt call. */
+    constructor(pin, flags) {
+        this._pin = typeof pin === 'number' ? pin : pin.number;
+        this._flags = flags;
+    }
+    /** Drive the pin (gpio_pin_set_dt / set_raw). Logical level: on a pin with
+     *  a board dtSpec (LED, BUTTON), true means "active" — the DT node's
+     *  GPIO_ACTIVE_LOW is honored. */
+    set(value) {
+        gpioConfigure(this._pin, this._flags);
+        gpioWrite(this._pin, value);
+    }
+    /** Read the pin (gpio_pin_get_dt / get_raw). Logical level. The guarded
+     *  configure is FUSED into the read's lowering (one statement-expression),
+     *  so the pin is correctly configured even when the call sits in a pure
+     *  expression position (if-conditions, comparisons) where a method's
+     *  leading side-effect ops would otherwise be dropped. */
+    get() {
+        return gpioReadCfg(this._pin, this._flags);
+    }
+    /** Toggle the pin (gpio_pin_toggle_dt — the driver's atomic toggle). */
+    toggle() {
+        gpioConfigure(this._pin, this._flags);
+        gpioToggle(this._pin);
+    }
+    /** Attach an interrupt (gpio_pin_interrupt_configure_dt +
+     *  gpio_init_callback + gpio_add_callback). `intFlags` is one GPIO.INT_*
+     *  token — Zephyr's names verbatim, covering the level modes the legacy
+     *  onHigh/onLow strings could not express. */
+    onInterrupt(intFlags, handler) {
+        gpioConfigure(this._pin, this._flags);
+        interruptAttachFlags(this._pin, callback(handler), intFlags);
+    }
+    /** Detach the interrupt (disable + remove callback). */
+    offInterrupt() {
+        interruptDetach(this._pin);
+    }
+}
+// ── Config flags (gpio.h) ──────────────────────────────────────────────
+GPIO.INPUT = 0x001;
+GPIO.OUTPUT = 0x002;
+/** Configure the output buffer's initial level atomically — no
+ *  configure-then-write glitch window. */
+GPIO.OUTPUT_INIT_LOW = 0x004;
+GPIO.OUTPUT_INIT_HIGH = 0x008;
+GPIO.PULL_UP = 0x010;
+GPIO.PULL_DOWN = 0x020;
+GPIO.OPEN_DRAIN = 0x040;
+GPIO.OPEN_SOURCE = 0x080;
+GPIO.DISCONNECTED = 0x100;
+// ── Interrupt flags (GPIO_INT_* minus the prefix) ──────────────────────
+GPIO.INT_DISABLE = 0x01;
+GPIO.INT_EDGE_RISING = 0x02;
+GPIO.INT_EDGE_FALLING = 0x04;
+GPIO.INT_EDGE_BOTH = 0x08;
+GPIO.INT_LEVEL_LOW = 0x10;
+GPIO.INT_LEVEL_HIGH = 0x20;

package/dist/gpio.d.ts

@@ -1,87 +1,3 @@
-export declare class OutputPin {
-    private _pin;
-    readonly number: number;
-    readonly gpio: number;
-    constructor(pin: number);
-    high(): void;
-    low(): void;
-    toggle(): void;
-    write(value: number | boolean): void;
-    /**
-     * Returns the level the program last drove onto this output pin.
-     *
-     * The transpiler tracks every write (high/low/write/toggle and the
-     * asOutput initial value) and lowers this to a compile-time constant
-     * when the state is statically known, or to a tracked shadow variable
-     * the generated writes keep updated. No hardware pin read is performed —
-     * reading back an OUTPUT-only pin is not portable (e.g. Zephyr), so this
-     * reports software truth, not electrical truth.
-     */
-    read(): boolean;
-    isHigh(): boolean;
-    isLow(): boolean;
-    pulse(durationMs: number): void;
-    tone(frequency: number): ToneChain;
-    toneFor(frequency: number, duration: number): void;
-    noTone(): void;
-    pwm(duty: number): void;
-    getPwmFrequency(): number;
-    getPwmResolution(): number;
-}
-export declare class InputPin {
-    private _pin;
-    readonly number: number;
-    readonly gpio: number;
-    constructor(pin: number);
-    read(): boolean;
-    isHigh(): boolean;
-    isLow(): boolean;
-    readAnalog(): number;
-    readVoltage(): number;
-    getAnalogResolution(): number;
-    setAnalogReference(ref: string): void;
-    onFalling(handler: () => void): void;
-    onRising(handler: () => void): void;
-    onChange(handler: () => void): void;
-    offAll(): void;
-    /** Alias matching the BasePin.offInterrupts() interface name. */
-    offInterrupts(): void;
-    /**
-     * Wait for a RISING edge on this input pin.
-     * Returns a Promise<void> that resolves when the pin transitions from LOW to HIGH.
-     * The platform strategy controls whether this uses interrupts, polling, or a stub.
-     *
-     * @param timeout Optional timeout in milliseconds. If provided, the promise
-     *   rejects (or resolves with a false/error) after the timeout expires.
-     */
-    waitForRising(timeout?: number): Promise<void>;
-    /**
-     * Wait for a FALLING edge on this input pin.
-     * Returns a Promise<void> that resolves when the pin transitions from HIGH to LOW.
-     *
-     * @param timeout Optional timeout in milliseconds. If provided, the promise
-     *   rejects (or resolves with a false/error) after the timeout expires.
-     */
-    waitForFalling(timeout?: number): Promise<void>;
-}
-export declare class ToneChain {
-    private _pin;
-    private _lastFreq;
-    constructor(pin: number, frequency: number);
-    for(duration: number): void;
-}
-/**
- * Represents a physical hardware pin before it has been configured for a specific mode.
- * Use `.asInput()` or `.asOutput()` to obtain a functional pin instance.
- *
- * Pins can be created two ways:
- * - `new Pin(number)` — legacy, using framework pin number (e.g. Arduino pin 13)
- * - `Pin.fromPort("PB5")` — preferred, using MCU datasheet port name
- *
- * When created via `fromPort()`, the pin carries its canonical port identity.
- * The transpiler resolves the port name to a framework pin number at compile time
- * using the MCU package's pin mapping (e.g. arduino-map.ts).
- */
 export declare class Pin {
     /** MCU port name (e.g. "PB5") — empty string for legacy numeric pins */
     private _port;
@@ -99,23 +15,4 @@ export declare class Pin {
      * are resolved at transpile time via the MCU package's pin mapping.
      */
     static fromPort(portName: string): Pin;
-    asOutput(initial?: number | boolean): OutputPin;
-    /** Alias for asOutput() — shorter fluent form. */
-    output(initial?: number | boolean): OutputPin;
-    asInput(): InputPin;
-    asInputPullUp(): InputPin;
-    asInputPullDown(): InputPin;
-    inputPullUp(): InputPin;
-    /** Alias for asInputPullDown() — shorter fluent form. */
-    inputPullDown(): InputPin;
-    read(): boolean;
-    isHigh(): boolean;
-    isLow(): boolean;
-    write(value: number | boolean): void;
-    high(): void;
-    low(): void;
-    toggle(): void;
-    pwm(duty: number): void;
-    tone(frequency: number): ToneChain;
-    noTone(): void;
 }

package/dist/gpio.js

@@ -1,157 +1,19 @@
-import { gpioWrite, gpioRead, gpioToggle, gpioSetMode, tonePlay, toneStop, adcRead, adcReadVoltage, adcSetReference, interruptAttach, interruptDetach, pwmWrite, rawCpp, boardResolve } from './emit.js';
-import { callback } from './callback.js';
-import { ADC } from './adc.js';
-export class OutputPin {
-    constructor(pin) {
-        this._pin = pin;
-        this.number = pin;
-        this.gpio = pin;
-    }
-    high() {
-        gpioWrite(this._pin, 1);
-    }
-    low() {
-        gpioWrite(this._pin, 0);
-    }
-    toggle() {
-        gpioToggle(this._pin);
-    }
-    write(value) {
-        gpioWrite(this._pin, value);
-    }
-    /**
-     * Returns the level the program last drove onto this output pin.
-     *
-     * The transpiler tracks every write (high/low/write/toggle and the
-     * asOutput initial value) and lowers this to a compile-time constant
-     * when the state is statically known, or to a tracked shadow variable
-     * the generated writes keep updated. No hardware pin read is performed —
-     * reading back an OUTPUT-only pin is not portable (e.g. Zephyr), so this
-     * reports software truth, not electrical truth.
-     */
-    read() {
-        return gpioRead(this._pin);
-    }
-    isHigh() {
-        return this.read();
-    }
-    isLow() {
-        return !this.read();
-    }
-    pulse(durationMs) {
-        gpioWrite(this._pin, 1);
-        rawCpp(`delay(${durationMs});`);
-        gpioWrite(this._pin, 0);
-    }
-    tone(frequency) {
-        tonePlay(this._pin, frequency);
-        return new ToneChain(this._pin, frequency);
-    }
-    toneFor(frequency, duration) {
-        tonePlay(this._pin, frequency, duration);
-    }
-    noTone() {
-        toneStop(this._pin);
-    }
-    pwm(duty) {
-        pwmWrite(this._pin, duty);
-    }
-    getPwmFrequency() {
-        return boardResolve("peripherals.pwm.maxFrequency");
-    }
-    getPwmResolution() {
-        return boardResolve("peripherals.pwm.resolution");
-    }
-}
-export class InputPin {
-    constructor(pin) {
-        this._pin = pin;
-        this.number = pin;
-        this.gpio = pin;
-    }
-    read() {
-        return gpioRead(this._pin);
-    }
-    isHigh() {
-        return this.read();
-    }
-    isLow() {
-        return !this.read();
-    }
-    readAnalog() {
-        return adcRead(this._pin);
-    }
-    readVoltage() {
-        return adcReadVoltage(this._pin);
-    }
-    getAnalogResolution() {
-        return boardResolve("peripherals.adc.0.resolution");
-    }
-    setAnalogReference(ref) {
-        ADC._reference = ref;
-        adcSetReference(ref);
-    }
-    onFalling(handler) {
-        interruptAttach(this._pin, callback(handler), "FALLING");
-    }
-    onRising(handler) {
-        interruptAttach(this._pin, callback(handler), "RISING");
-    }
-    onChange(handler) {
-        interruptAttach(this._pin, callback(handler), "CHANGE");
-    }
-    offAll() {
-        interruptDetach(this._pin);
-    }
-    /** Alias matching the BasePin.offInterrupts() interface name. */
-    offInterrupts() {
-        interruptDetach(this._pin);
-    }
-    /**
-     * Wait for a RISING edge on this input pin.
-     * Returns a Promise<void> that resolves when the pin transitions from LOW to HIGH.
-     * The platform strategy controls whether this uses interrupts, polling, or a stub.
-     *
-     * @param timeout Optional timeout in milliseconds. If provided, the promise
-     *   rejects (or resolves with a false/error) after the timeout expires.
-     */
-    waitForRising(timeout) {
-        rawCpp(`__cuttlefish_wait_pin_edge(${this._pin}, RISING, ${timeout ?? -1});`);
-        return Promise.resolve();
-    }
-    /**
-     * Wait for a FALLING edge on this input pin.
-     * Returns a Promise<void> that resolves when the pin transitions from HIGH to LOW.
-     *
-     * @param timeout Optional timeout in milliseconds. If provided, the promise
-     *   rejects (or resolves with a false/error) after the timeout expires.
-     */
-    waitForFalling(timeout) {
-        rawCpp(`__cuttlefish_wait_pin_edge(${this._pin}, FALLING, ${timeout ?? -1});`);
-        return Promise.resolve();
-    }
-}
-export class ToneChain {
-    constructor(pin, frequency) {
-        this._pin = pin;
-        this._lastFreq = frequency;
-    }
-    for(duration) {
-        tonePlay(this._pin, this._lastFreq, duration);
-    }
-}
-/**
- * Represents a physical hardware pin before it has been configured for a specific mode.
- * Use `.asInput()` or `.asOutput()` to obtain a functional pin instance.
- *
- * Pins can be created two ways:
- * - `new Pin(number)` — legacy, using framework pin number (e.g. Arduino pin 13)
- * - `Pin.fromPort("PB5")` — preferred, using MCU datasheet port name
- *
- * When created via `fromPort()`, the pin carries its canonical port identity.
- * The transpiler resolves the port name to a framework pin number at compile time
- * using the MCU package's pin mapping (e.g. arduino-map.ts).
- */
+// ---------------------------------------------------------------------------
+// Pin — the board-addressable pin identity (legacy GPIO classes removed)
+//
+// A Pin carries its canonical datasheet port name (Pin.fromPort("PB5")) and/or
+// framework pin number; the transpiler resolves it via the MCU package's pin
+// mapping. It is an ADDRESS, not a configured peripheral — configure pins by
+// constructing the thin peripherals with them:
+//
+//   new GPIO(PB5, GPIO.OUTPUT | GPIO.PULL_UP)
+//   new PWM(PA5, { periodNs: 20_000_000 })
+//   new ADC(A1)
+//
+// The former OutputPin/InputPin/ToneChain classes (and their as*/read/write/
+// pwm methods) were removed with the legacy Arduino surface. Their thin
+// replacements are gpio-pin.ts / pwm-pin.ts / adc-pin.ts.
+// ---------------------------------------------------------------------------
 export class Pin {
     /** Legacy constructor — creates a Pin from a framework pin number */
     constructor(pin) {
@@ -173,77 +35,4 @@ export class Pin {
         p.port = portName;
         return p;
     }
-    asOutput(initial) {
-        gpioSetMode(this._pin, "OUTPUT");
-        if (initial !== undefined) {
-            gpioWrite(this._pin, initial);
-        }
-        // Returns `this` so the transpiler can suppress the C++ return emission
-        // (it resolves `this` to the same instance and tracks the result as an
-        // OutputPin via the method name). Returning `new OutputPin(this._pin)`
-        // would leak the literal text into generated C++. The cast is required
-        // because Pin and OutputPin are structurally distinct classes; the
-        // transpiler handles the mode transition semantically.
-        return this;
-    }
-    /** Alias for asOutput() — shorter fluent form. */
-    output(initial) {
-        gpioSetMode(this._pin, "OUTPUT");
-        if (initial !== undefined) {
-            gpioWrite(this._pin, initial);
-        }
-        return this;
-    }
-    asInput() {
-        gpioSetMode(this._pin, "INPUT");
-        return this;
-    }
-    asInputPullUp() {
-        gpioSetMode(this._pin, "INPUT_PULLUP");
-        return this;
-    }
-    asInputPullDown() {
-        gpioSetMode(this._pin, "INPUT_PULLDOWN");
-        return this;
-    }
-    inputPullUp() {
-        gpioSetMode(this._pin, "INPUT_PULLUP");
-        return this;
-    }
-    /** Alias for asInputPullDown() — shorter fluent form. */
-    inputPullDown() {
-        gpioSetMode(this._pin, "INPUT_PULLDOWN");
-        return this;
-    }
-    read() {
-        return gpioRead(this._pin);
-    }
-    isHigh() {
-        return this.read();
-    }
-    isLow() {
-        return !this.read();
-    }
-    write(value) {
-        gpioWrite(this._pin, value);
-    }
-    high() {
-        gpioWrite(this._pin, 1);
-    }
-    low() {
-        gpioWrite(this._pin, 0);
-    }
-    toggle() {
-        gpioToggle(this._pin);
-    }
-    pwm(duty) {
-        pwmWrite(this._pin, duty);
-    }
-    tone(frequency) {
-        tonePlay(this._pin, frequency);
-        return new ToneChain(this._pin, frequency);
-    }
-    noTone() {
-        toneStop(this._pin);
-    }
 }

package/dist/http.d.ts

@@ -1,48 +1,47 @@
-export declare enum HttpMethod {
-    GET = 0,
-    POST = 1,
-    PUT = 2,
-    DELETE = 3,
-    HEAD = 4,
-    PATCH = 5
+/** Request construction facts beyond method + URL. */
+export interface RequestOpts {
+    /** Response timeout in ms (default 10_000). */
+    timeoutMs?: number;
+    /** Request body (raw). */
+    body?: string;
+    /** The body is JSON — sets the JSON content type. */
+    json?: boolean;
+    /** Skip TLS certificate verification (development only). */
+    insecure?: boolean;
+    /** PEM of a trusted CA — enables verified TLS. */
+    caCert?: string;
 }
-/**
- * Fluent HTTP/S request builder, lowered to native ESP-IDF
- * `esp_http_client` by framework-esp32 (TLS via esp-tls / mbedTLS bundle).
- * Response fields are read from this object after send() — mirrors
- * `await WiFi.connect(); WiFi.localIP()`.
- *
- * No `include()` calls here — ESP-IDF headers are framework-owned and added
- * via forcedIncludes when the program uses http.* ops.
- */
-export declare class HttpRequest {
-    private _method;
-    private _url;
-    constructor(method: string, url: string);
+export declare class Request {
+    static readonly GET = "GET";
+    static readonly POST = "POST";
+    static readonly PUT = "PUT";
+    static readonly DELETE = "DELETE";
+    static readonly HEAD = "HEAD";
+    static readonly PATCH = "PATCH";
+    private readonly _method;
+    private readonly _url;
+    private readonly _timeoutMs;
+    private readonly _body;
+    private readonly _json;
+    private readonly _insecure;
+    private readonly _caCert;
+    constructor(method: string, url: string, opts?: RequestOpts);
+    /** Attach a request header. Chainable — one per header. */
     header(name: string, value: string): this;
-    timeout(ms: number): this;
-    maxBody(bytes: number): this;
-    body(data: string): this;
-    jsonBody(json: string): this;
-    /** Skip TLS certificate verification (development only). */
-    insecure(): this;
-    caCert(pem: string): this;
-    /** Blocking at top level; cooperatively awaitable inside async functions. */
-    send(): Promise<boolean>;
+    /** Send the request (blocking). The construction facts lower into the
+     *  shim first (timeout/body/TLS mode), then the request performs.
+     *  Awaitable inside async functions — the async machinery splits the
+     *  send into a background request + done-poll. */
+    send(): boolean;
+    /** Response status code (0 before a completed send). */
     status(): number;
+    /** True when the response status is 2xx. */
     ok(): boolean;
     /** Response body as a C string (valid until the next request). */
     text(): string;
+    /** Response Content-Length (0 when absent). */
     contentLength(): number;
+    /** One response header value ("" when absent; valid until the next
+     *  request). */
     responseHeader(name: string): string;
 }
-export declare class HttpClass {
-    static readonly __instance_name = "Http";
-    get(url: string): HttpRequest;
-    post(url: string): HttpRequest;
-    put(url: string): HttpRequest;
-    del(url: string): HttpRequest;
-    head(url: string): HttpRequest;
-    patch(url: string): HttpRequest;
-}
-export declare const Http: HttpClass;