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

package/dist/ble.js

@@ -1,4 +1,22 @@
-import { bleServerBegin, bleAdvertiseStart, bleAdvertiseStop, bleAddService, bleAddChar, bleOnRead, bleOnWrite, bleOnConnect, bleOnDisconnect, bleNotify, bleIsConnected, bleClientCount, bleSetName, bleUntilConnected, bleUntilConnectedStart, bleSetTxPower, bleStatus, } from './emit.js';
+// ---------------------------------------------------------------------------
+// BLE — the thin Zephyr-shaped GATT peripheral
+//
+// The advertised identity is a CONSTRUCTION fact: `new BLE('TempSensor')`.
+// The GATT database is declared through service()/char() chains (each char's
+// uuid/type/perms ride its add op — the sensor discipline), handlers attach
+// with onRead/onWrite, and the verbs map 1:1 onto Zephyr's bt_* GATT surface:
+//
+//   start()   → register the deferred service table + bt_enable + advertise
+//   stop()    → bt_le_adv_stop
+//   linked()  → a central is connected
+//   onConnect()/onDrop() → bt_conn callbacks
+//   notify(i, v) → bt_gatt_notify on the declared characteristic i
+//
+// Ordering contract (same as the runtime shim's current_char keying):
+// onRead/onWrite/notify bind to the char() they immediately follow in the
+// chain. Declare handlers right where the characteristic is declared.
+// ----------------------------------------------------------------------------
+import { bleServerBegin, bleAdvertiseStart, bleAdvertiseStop, bleAddService, bleAddChar, bleOnRead, bleOnWrite, bleOnConnect, bleOnDisconnect, bleNotify, bleIsConnected, bleClientCount, } from './emit.js';
 import { callback } from './callback.js';
 /** Characteristic value encoding — drives both TS callback types and C++ marshalling. */
 export var BleValueType;
@@ -21,24 +39,11 @@ export var BlePerm;
     BlePerm[BlePerm["Write"] = 2] = "Write";
     BlePerm[BlePerm["Notify"] = 4] = "Notify";
 })(BlePerm || (BlePerm = {}));
-/** BLE peripheral status (mirrored by the runtime shim). */
-export var BleStatus;
-(function (BleStatus) {
-    BleStatus[BleStatus["Idle"] = 0] = "Idle";
-    BleStatus[BleStatus["Initializing"] = 1] = "Initializing";
-    BleStatus[BleStatus["Advertising"] = 2] = "Advertising";
-    BleStatus[BleStatus["Connected"] = 3] = "Connected";
-    BleStatus[BleStatus["Error"] = 4] = "Error";
-})(BleStatus || (BleStatus = {}));
-export var BleAdvertisingMode;
-(function (BleAdvertisingMode) {
-    BleAdvertisingMode["Connectable"] = "connectable";
-    BleAdvertisingMode["NonConnectable"] = "non_connectable";
-})(BleAdvertisingMode || (BleAdvertisingMode = {}));
 /**
- * Standard GATT services/characteristics. Autocomplete walks the hierarchy:
- *   GATT.ENVIRONMENTAL. -> TEMPERATURE, HUMIDITY, ...
- * Pass the .uuid, .type, and computed perms to BleServer.characteristic().
+ * Standard GATT services/characteristics — uuid/type/perms reference data.
+ * Pass the pieces explicitly to char():
+ *   GATT.ENVIRONMENTAL.TEMPERATURE →
+ *     char('2A6E', BleValueType.Int16, BlePerm.Read | BlePerm.Notify)
  */
 export const GATT = {
     DEVICE_INFO: {
@@ -56,102 +61,78 @@ export const GATT = {
     },
 };
 /**
- * BLE GATT peripheral control, lowered to native ESP-IDF NimBLE
- * (`nimble_host` / `ble_gap` / `ble_gatts`) by framework-esp32.
- *
- * No `include()` calls here — NimBLE headers are framework-owned and added via
- * forcedIncludes when the program uses ble.* ops.
- *
- * Transpiler note: method bodies pass parameters directly into semantic calls
- * (no local consts / module counters) so the resolver can statically track every
- * argument. The characteristic index is carried through the chain via
- * `this._charCount` fieldValues, mirroring how HttpRequest carries _method/_url.
+ * The GATT declaration chain returned by BLE.service()/BLE.char(). Each char()
+ * appends a characteristic; onRead/onWrite/notify bind to the most recent one.
  */
-export class BleClass {
-    /** Begin building a GATT server with the given advertised device name. */
-    server(name) {
-        bleSetName(name);
-        return new BleServer(name, 0, 1);
+export class BleChain {
+    /** Begin a new service grouping; subsequent char() calls attach to it. */
+    service(uuid) {
+        bleAddService(uuid);
+        return this;
     }
-    /** Initialize NimBLE, register services, and start advertising. */
-    begin() {
-        bleServerBegin("TypeCAD");
-        bleAdvertiseStart();
+    /** Append a characteristic by uuid, value type, and permissions
+     *  (`BlePerm.Read | BlePerm.Notify`). Returns this for chaining. */
+    char(uuid, type, perms) {
+        bleAddChar(0, uuid, type, perms, 0);
+        return this;
     }
-    advertise() { bleAdvertiseStart(); }
-    stopAdvertising() { bleAdvertiseStop(); }
-    /** Blocking at top level; cooperatively awaitable inside async functions. */
-    untilConnected(timeoutMs = 0) {
-        bleUntilConnected(timeoutMs);
-        return Promise.resolve(false);
+    /** Read handler for the most recently declared characteristic. */
+    onRead(handler) {
+        bleOnRead(0, callback(handler));
+        return this;
+    }
+    /** Write handler for the most recently declared characteristic. */
+    onWrite(handler) {
+        bleOnWrite(0, callback(handler));
+        return this;
     }
-    untilConnectedStart() { bleUntilConnectedStart(); }
-    isConnected() { return bleIsConnected(); }
-    status() { return bleStatus(); }
-    clientCount() { return bleClientCount(); }
-    txPower(dbm) { bleSetTxPower(dbm); return this; }
-    notify(index, value) { bleNotify(index, value); }
 }
-BleClass.__instance_name = "Ble";
-/**
- * Fluent GATT server builder. Returned by `Ble.server()`.
- *
- * Single-class fluent chain (like HttpRequest): characteristic() returns `this`,
- * so onRead/onWrite/onSubscribe chain directly. The _charCount field tracks
- * which characteristic slot the callbacks attach to.
- *
- * Field tracking (read by the transpiler resolver via ctor field assignment):
- *   _name      — advertised device name
- *   _charCount — current characteristic index (the last characteristic() target)
- *   _svcCount  — current service index
- */
-export class BleServer {
-    constructor(name, charCount, svcCount) {
+/** A GATT peripheral. The advertised device name is the construction fact. */
+export class BLE {
+    constructor(name) {
         this._name = name;
-        this._charCount = charCount;
-        this._lastChar = charCount;
-        this._svcCount = svcCount;
     }
-    /** Add a characteristic by UUID, value type, and permissions.
-     *  Combine permissions with `|`: `BlePerm.Read | BlePerm.Notify`.
-     *  Returns this for chaining. */
-    characteristic(uuid, type, perms) {
-        bleAddChar(this._charCount, uuid, type, perms, this._svcCount);
-        return this;
-    }
-    /** Begin a new service grouping. Subsequent characteristics attach to it. */
+    /** Begin a service grouping; chain char() declarations off it. */
     service(uuid) {
         bleAddService(uuid);
-        return this;
+        return new BleChain();
     }
-    /** Register a read handler for the most recently added characteristic. */
-    onRead(handler) {
-        bleOnRead(this._lastChar, callback(handler));
-        return this;
+    /** Append a characteristic under the default (Environmental Sensing)
+     *  service — the common single-service case. */
+    char(uuid, type, perms) {
+        bleAddChar(0, uuid, type, perms, 0);
+        return new BleChain();
     }
-    /** Register a write handler for the most recently added characteristic. */
-    onWrite(handler) {
-        bleOnWrite(this._lastChar, callback(handler));
-        return this;
+    /** Register the declared GATT database, enable the stack, and start
+     *  advertising the construction name. */
+    start() {
+        bleServerBegin(this._name);
+        bleAdvertiseStart();
+    }
+    /** Stop advertising (the GATT database and any link stay up). */
+    stop() {
+        bleAdvertiseStop();
     }
-    /** Register a connect handler (called when a central connects). */
+    /** True while a central is connected. */
+    linked() {
+        return bleIsConnected();
+    }
+    /** Number of connected centrals (0 or 1 — the shim is single-connection). */
+    clients() {
+        return bleClientCount();
+    }
+    /** Fires when a central connects. */
     onConnect(handler) {
         bleOnConnect(callback(handler));
-        return this;
     }
-    /** Register a disconnect handler (called when a central disconnects). */
-    onDisconnect(handler) {
+    /** Fires when the central disconnects. */
+    onDrop(handler) {
         bleOnDisconnect(callback(handler));
-        return this;
     }
-    /** Push a new value to subscribed clients on the most recently added characteristic. */
-    notify(value) {
-        bleNotify(this._lastChar, value);
-    }
-    /** Initialize NimBLE, register services, and start advertising. */
-    begin() {
-        bleServerBegin(this._name);
-        bleAdvertiseStart();
+    /** Push a value to subscribed clients on a characteristic
+     *  (bt_gatt_notify). `index` is the characteristic's declaration order
+     *  (0-based — the first char() is 0). */
+    notify(index, value) {
+        bleNotify(index, value);
     }
 }
-export const Ble = new BleClass();

package/dist/counter.d.ts

@@ -0,0 +1,16 @@
+export declare class Counter {
+    private readonly _instance;
+    private readonly _hz;
+    /** Construct a counter handle. `hz` is the alarm frequency — start()
+     *  realizes it as a top value of counter_freq / hz. */
+    constructor(instance: number, opts: {
+        hz: number;
+    });
+    /** Register the alarm handler (fires once per top-value wrap). */
+    onAlarm(handler: () => void): void;
+    /** Apply hz as the top value, arm the alarm, and start counting
+     *  (counter_set_top_value + counter_start). */
+    start(): void;
+    /** Stop counting (counter_stop). */
+    stop(): void;
+}

package/dist/counter.js

@@ -0,0 +1,32 @@
+// ---------------------------------------------------------------------------
+// Counter — the thin Zephyr-shaped hardware counter/timer
+//
+// Zephyr's counter driver with Zephyr's verbs. The instance index selects
+// one of the chip's declared free counters (instance 0 = the first, e.g.
+// RTC1 on the nRF52840; the build errors name the available ones). The alarm
+// frequency is a construction fact: start() applies hz as the top value
+// (counter_freq / hz) and arms the alarm callback.
+// ----------------------------------------------------------------------------
+import { counterOnAlarm, counterStart, counterStop } from './emit.js';
+import { callback } from './callback.js';
+export class Counter {
+    /** Construct a counter handle. `hz` is the alarm frequency — start()
+     *  realizes it as a top value of counter_freq / hz. */
+    constructor(instance, opts) {
+        this._instance = instance;
+        this._hz = opts.hz;
+    }
+    /** Register the alarm handler (fires once per top-value wrap). */
+    onAlarm(handler) {
+        counterOnAlarm(this._instance, callback(handler));
+    }
+    /** Apply hz as the top value, arm the alarm, and start counting
+     *  (counter_set_top_value + counter_start). */
+    start() {
+        counterStart(this._instance, this._hz);
+    }
+    /** Stop counting (counter_stop). */
+    stop() {
+        counterStop(this._instance);
+    }
+}

package/dist/dac-pin.d.ts

@@ -0,0 +1,13 @@
+import type { Pin } from './gpio.js';
+export declare class DAC {
+    private readonly _pin;
+    private readonly _resolution;
+    /** Construct a DAC channel. `resolution` in bits; 0/omitted = the chip
+     *  descriptor's channel resolution (e.g. 8 on the ESP32's two channels). */
+    constructor(pin: number | Pin, opts?: {
+        resolution?: number;
+    });
+    /** Write the raw code (dac_write_value). For an 8-bit channel the range
+     *  is 0–255; for 12-bit, 0–4095 — the channel's resolution decides. */
+    write(value: number): void;
+}

package/dist/dac-pin.js

@@ -0,0 +1,21 @@
+// ---------------------------------------------------------------------------
+// DAC — the thin Zephyr-shaped analog output
+//
+// Construction carries the resolution (default: the chip descriptor's channel
+// resolution); write() lowers to a lazy dac_channel_setup (once) +
+// dac_write_value with the RAW code — no 0–255 Arduino range.
+// ----------------------------------------------------------------------------
+import { dacWriteValue } from './emit.js';
+export class DAC {
+    /** Construct a DAC channel. `resolution` in bits; 0/omitted = the chip
+     *  descriptor's channel resolution (e.g. 8 on the ESP32's two channels). */
+    constructor(pin, opts) {
+        this._pin = typeof pin === 'number' ? pin : pin.number;
+        this._resolution = opts?.resolution ?? 0;
+    }
+    /** Write the raw code (dac_write_value). For an 8-bit channel the range
+     *  is 0–255; for 12-bit, 0–4095 — the channel's resolution decides. */
+    write(value) {
+        dacWriteValue(this._pin, value, this._resolution);
+    }
+}