grenton-ts 1.0.0 → 1.1.0

package/README.md

@@ -1,5 +1,7 @@
 # grenton-ts
 
+🇵🇱 [Czytaj po polsku](README.pl.md)
+
 TypeScript API library for [Grenton](https://grenton.com) smart home hardware modules. Provides type-safe wrappers around the low-level Grenton hardware interfaces, making it easier to interact with Grenton devices in TypeScript projects.
 
 ## Overview
@@ -43,7 +45,7 @@ const shutter = new RollerShutter(rawRollerShutter);
 
 // Events
 shutter.addOnPositionChange(() => {
-    console.log('Position:', shutter.position);
+    logInfo('Position:', shutter.position);
 });
 
 // Methods
@@ -72,6 +74,17 @@ shutter.setPosition(75);
 ```
 
 
+## Getting Started
+
+If you want to start your own Grenton project in TypeScript, begin with the template repository:
+
+```bash
+git clone https://github.com/rpaczkow/grenton-ts-template
+```
+
+That template is already configured to reference the published package built from this repository:
+- `https://github.com/rpaczkow/grenton-ts`
+
 ## Build
 
 ```bash

package/README.pl.md

@@ -0,0 +1,97 @@
+# grenton-ts
+
+Biblioteka API w TypeScript dla modułów sprzętowych inteligentnego domu [Grenton](https://grenton.com). Dostarcza typowane wrappery dla niskopoziomowych interfejsów sprzętowych Grenton, ułatwiając interakcję z urządzeniami Grenton w projektach TypeScript.
+
+## Przegląd
+
+Urządzenia Grenton udostępniają surowe API oparte na Lua. Ta biblioteka opakowuje te surowe interfejsy typowanymi klasami TypeScript, dając:
+
+- **Typowane właściwości** z getterami/setterami
+- **Typowane zdarzenia** z rejestracją callbacków
+- **Typowane metody** do wykonywania komend urządzeń
+- **Warianty zdalne (Remote)** do komunikacji między bramami (CLU-to-CLU)
+
+
+
+Każdy katalog modułu sprzętowego zawiera podkatalogi oznaczone wersją firmware (np. `fv03_02`), dzięki czemu wiele wersji firmware tego samego modułu może współistnieć.
+
+## Architektura
+
+Każdy moduł podąża za tym samym trójwarstwowym wzorcem:
+
+### 1. Interfejs surowy (`*Raw`)
+
+`declare class` odzwierciedlająca niskopoziomowe API sprzętowe:
+
+```typescript
+declare class RollerShutterRaw {
+    add_event(event: EventType, callback: () => void): void;
+    get(property: PropertyType): any;
+    set(property: PropertyType, value: any): void;
+    execute(method: MethodType, ...args: any[]): any;
+}
+```
+
+### 2. Klasa wrappera
+
+Klasa wysokopoziomowa, która przyjmuje surowy interfejs w konstruktorze i udostępnia typowane metody, właściwości oraz rejestrację zdarzeń:
+
+```typescript
+import { RollerShutter, RollerShutterRaw } from './roller-shutter-din-3/fv03_02/roller-shutter';
+
+const shutter = new RollerShutter(rawRollerShutter);
+
+// Zdarzenia
+shutter.addOnPositionChange(() => {
+    logInfo('Pozycja:', shutter.position);
+});
+
+// Metody
+shutter.moveUp(5000);     // ruch w górę przez 5 sekund
+shutter.setPosition(50);  // ustawienie na 50% otwarcia
+
+// Właściwości
+logInfo(shutter.state);    // wartość enuma StateType
+logInfo(shutter.position); // liczba (0–100)
+shutter.maxTime = 30000;       // właściwość do odczytu i zapisu
+```
+
+### 3. Wariant zdalny (`*Remote`)
+
+Do sterowania urządzeniami znajdującymi się na innym CLU za pomocą `RemoteGate`. Wykorzystuje `rawExecutionBuilderFactory` do budowania ciągów komend wysyłanych przez bramę. Zdarzenia zdalne nie są obsługiwane.
+
+```typescript
+import { RollerShutterRemote } from './roller-shutter-din-3/fv03_02/roller-shutter';
+import { RemoteGate } from './core/remote-gate';
+
+const gate = new RemoteGate(rawRemoteGate);
+const shutter = new RollerShutterRemote('ROLLER_SHUTTER_1', gate);
+
+shutter.moveUp(5000);
+shutter.setPosition(75);
+```
+
+
+## Pierwsze kroki
+
+Jeśli chcesz rozpocząć własny projekt Grenton w TypeScript, zacznij od repozytorium szablonu:
+
+```bash
+git clone https://github.com/rpaczkow/grenton-ts-template
+```
+
+Ten szablon jest już skonfigurowany tak, aby odwoływać się do opublikowanego pakietu zbudowanego z tego repozytorium:
+- `https://github.com/rpaczkow/grenton-ts`
+
+## Budowanie
+
+```bash
+npm run build   # kompilacja TypeScript → dist/
+npm run watch   # tryb watch
+```
+
+Wymaga Node.js z TypeScript 5.x (`devDependency`). Skompilowany kod trafia do `dist/`.
+
+## Licencja
+
+MIT

package/dist/analog-din/fv01_02/analog-out.ts

@@ -0,0 +1,442 @@
+// Created from: src/interfaces/module_2_0_ANALOG_DIN_fv01_02.xml, object name="AnalogOUT"
+
+import { rawExecutionBuilderFactory } from "../../core/execution-builder"
+import { RemoteGate } from "../../core/remote-gate"
+
+enum EventType {
+    OnValueChange = 0,
+    OnValueLower = 1,
+    OnValueRise = 2,
+    OnOutOfRange = 3,
+    OnSwitchOn = 4,
+    OnSwitchOff = 5,
+}
+
+enum PropertyType {
+    Value = 0,
+    ScaledValue = 1,
+    Scale = 2,
+    Ramp = 3,
+    MinValue = 4,
+    MaxValue = 5,
+}
+
+enum MethodType {
+    SetValue = 0,
+    SetScaledValue = 1,
+    SetScale = 2,
+    SetRamp = 3,
+    HoldValue = 6,
+    Switch = 7,
+    SwitchOn = 8,
+    SwitchOff = 9,
+}
+
+declare class AnalogOutRaw {
+    add_event(event: EventType, callback: () => void): void;
+    get(property: PropertyType): any;
+    set(property: PropertyType, value: any): void;
+    execute(method: MethodType, ...args: any[]): void;
+}
+
+interface IAnalogOut {
+    /**
+     * Zdarzenie wywoływane przy zmianie wartości wyjścia
+     * @param callback
+     */
+    addOnValueChange: (callback: () => void) => void
+    /**
+     * Zdarzenie wywoływane przy zmianie wartości na niższą (zbocze opadające)
+     * @param callback
+     */
+    addOnValueLower: (callback: () => void) => void
+    /**
+     * Zdarzenie wywoływane przy zmianie wartości na wyższą (zbocze narastające)
+     * @param callback
+     */
+    addOnValueRise: (callback: () => void) => void
+    /**
+     * Zdarzenie wywoływane gdy wartość na wyjściu znajduje się poza wyznaczonym zakresem (MinValue - MaxValue)
+     * @param callback
+     */
+    addOnOutOfRange: (callback: () => void) => void
+    /**
+     * Zdarzenie wywoływane gdy wyjście ma wartość większą od zera
+     * @param callback
+     */
+    addOnSwitchOn: (callback: () => void) => void
+    /**
+     * Zdarzenie wywoływane gdy wyjście osiągnie wartość MinValue
+     * @param callback
+     */
+    addOnSwitchOff: (callback: () => void) => void
+    /** Wartość wyjścia */
+    value: number
+    /**
+     * Ustawia wartość wyjścia (0.0-10.0V)
+     * @param {number} value
+     */
+    setValue: (value: number) => void
+    /** Przeskalowana wartość wyjścia */
+    readonly scaledValue: number
+    /**
+     * Ustawia wartość po przeskalowaniu
+     * @param {number} scaledValue
+     */
+    setScaledValue: (scaledValue: number) => void
+    /** Skala */
+    scale: number
+    /**
+     * Ustawia skalę
+     * @param {number} scale
+     */
+    setScale: (scale: number) => void
+    /** Czas narastania */
+    ramp: number
+    /**
+     * Ustawia czas narastania
+     * @param {number} ramp
+     */
+    setRamp: (ramp: number) => void
+    /** Wartość minimalna po przekroczeniu której generowane jest zdarzenie OnOutRange */
+    minValue: number
+    /**
+     * Ustawia wartość minimalną
+     * @param {number} minValue
+     */
+    setMinValue: (minValue: number) => void
+    /** Wartość maksymalna po przekroczeniu której generowane jest zdarzenie OnOutRange */
+    maxValue: number
+    /**
+     * Ustawia wartość maksymalną
+     * @param {number} maxValue
+     */
+    setMaxValue: (maxValue: number) => void
+    /**
+     * Zmniejsza lub zwiększa wartość wyjścia z użyciem rampy podanej w parametrze. Jeśli parametr rampy nie zostanie podany, używa rampy domyślnej
+     * @param {number} ramp
+     */
+    holdValue: (ramp: number) => void
+    /**
+     * Przełącza stan wyjścia na przeciwny (MinValue - MaxValue)
+     * @param {number} time
+     * @param {number} ramp
+     */
+    switch: (time: number, ramp?: number) => void
+    /**
+     * Ustawia na wyjściu wartość MaxValue
+     * @param {number} time
+     * @param {number} ramp
+     */
+    switchOn: (time: number, ramp?: number) => void
+    /**
+     * Ustawia na wyjściu wartość MinValue
+     * @param {number} time
+     * @param {number} ramp
+     */
+    switchOff: (time: number, ramp?: number) => void
+}
+
+class AnalogOut implements IAnalogOut {
+    private onValueChangeCallbacks: Array<() => void> = [];
+    private onValueLowerCallbacks: Array<() => void> = [];
+    private onValueRiseCallbacks: Array<() => void> = [];
+    private onOutOfRangeCallbacks: Array<() => void> = [];
+    private onSwitchOnCallbacks: Array<() => void> = [];
+    private onSwitchOffCallbacks: Array<() => void> = [];
+
+    constructor(private raw: AnalogOutRaw) {
+        this.raw.add_event(EventType.OnValueChange, () => {
+            this.onValueChangeCallbacks.forEach(callback => { callback(); });
+        });
+        this.raw.add_event(EventType.OnValueLower, () => {
+            this.onValueLowerCallbacks.forEach(callback => { callback(); });
+        });
+        this.raw.add_event(EventType.OnValueRise, () => {
+            this.onValueRiseCallbacks.forEach(callback => { callback(); });
+        });
+        this.raw.add_event(EventType.OnOutOfRange, () => {
+            this.onOutOfRangeCallbacks.forEach(callback => { callback(); });
+        });
+        this.raw.add_event(EventType.OnSwitchOn, () => {
+            this.onSwitchOnCallbacks.forEach(callback => { callback(); });
+        });
+        this.raw.add_event(EventType.OnSwitchOff, () => {
+            this.onSwitchOffCallbacks.forEach(callback => { callback(); });
+        });
+    }
+
+    addOnValueChange(callback: () => void): void {
+        this.onValueChangeCallbacks.push(callback);
+    }
+    addOnValueLower(callback: () => void): void {
+        this.onValueLowerCallbacks.push(callback);
+    }
+    addOnValueRise(callback: () => void): void {
+        this.onValueRiseCallbacks.push(callback);
+    }
+    addOnOutOfRange(callback: () => void): void {
+        this.onOutOfRangeCallbacks.push(callback);
+    }
+    addOnSwitchOn(callback: () => void): void {
+        this.onSwitchOnCallbacks.push(callback);
+    }
+    addOnSwitchOff(callback: () => void): void {
+        this.onSwitchOffCallbacks.push(callback);
+    }
+    get value(): number {
+        return this.raw.get(PropertyType.Value);
+    }
+    set value(value: number) {
+        this.raw.set(PropertyType.Value, value);
+    }
+    setValue(value: number): void {
+        this.raw.set(PropertyType.Value, value);
+    }
+    get scaledValue(): number {
+        return this.raw.get(PropertyType.ScaledValue);
+    }
+    setScaledValue(scaledValue: number): void {
+        this.raw.set(PropertyType.ScaledValue, scaledValue);
+    }
+    get scale(): number {
+        return this.raw.get(PropertyType.Scale);
+    }
+    set scale(value: number) {
+        this.raw.set(PropertyType.Scale, value);
+    }
+    setScale(scale: number): void {
+        this.raw.set(PropertyType.Scale, scale);
+    }
+    get ramp(): number {
+        return this.raw.get(PropertyType.Ramp);
+    }
+    set ramp(value: number) {
+        this.raw.set(PropertyType.Ramp, value);
+    }
+    setRamp(ramp: number): void {
+        this.raw.set(PropertyType.Ramp, ramp);
+    }
+    get minValue(): number {
+        return this.raw.get(PropertyType.MinValue);
+    }
+    set minValue(value: number) {
+        this.raw.set(PropertyType.MinValue, value);
+    }
+    setMinValue(minValue: number): void {
+        this.raw.set(PropertyType.MinValue, minValue);
+    }
+    get maxValue(): number {
+        return this.raw.get(PropertyType.MaxValue);
+    }
+    set maxValue(value: number) {
+        this.raw.set(PropertyType.MaxValue, value);
+    }
+    setMaxValue(maxValue: number): void {
+        this.raw.set(PropertyType.MaxValue, maxValue);
+    }
+    holdValue(ramp: number): void {
+        this.raw.execute(MethodType.HoldValue, ramp);
+    }
+    switch(time: number, ramp: number = 0): void {
+        this.raw.execute(MethodType.Switch, time, ramp);
+    }
+    switchOn(time: number, ramp: number = 0): void {
+        this.raw.execute(MethodType.SwitchOn, time, ramp);
+    }
+    switchOff(time: number, ramp: number = 0): void {
+        this.raw.execute(MethodType.SwitchOff, time, ramp);
+    }
+}
+
+class AnalogOutRemote implements IAnalogOut {
+    constructor(private objectName: string, private gate: RemoteGate) {
+    }
+
+    addOnValueChange(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnValueLower(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnValueRise(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnOutOfRange(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnSwitchOn(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnSwitchOff(_callback: () => void): void {
+        // Remote events are not supported
+    }
+
+    get value(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.Value)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    set value(value: number) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.Value)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    setValue(value: number): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.Value)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    get scaledValue(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.ScaledValue)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    setScaledValue(scaledValue: number): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.ScaledValue)
+            .addParameter(scaledValue)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    get scale(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.Scale)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    set scale(value: number) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.Scale)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    setScale(scale: number): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.Scale)
+            .addParameter(scale)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    get ramp(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.Ramp)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    set ramp(value: number) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.Ramp)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    setRamp(ramp: number): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.Ramp)
+            .addParameter(ramp)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    get minValue(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.MinValue)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    set minValue(value: number) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.MinValue)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    setMinValue(minValue: number): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.MinValue)
+            .addParameter(minValue)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    get maxValue(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.MaxValue)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    set maxValue(value: number) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.MaxValue)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    setMaxValue(maxValue: number): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.MaxValue)
+            .addParameter(maxValue)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    holdValue(ramp: number): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .execute()
+            .addParameter(MethodType.HoldValue)
+            .addParameter(ramp)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    switch(time: number, ramp: number = 0): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .execute()
+            .addParameter(MethodType.Switch)
+            .addParameter(time)
+            .addParameter(ramp)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    switchOn(time: number, ramp: number = 0): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .execute()
+            .addParameter(MethodType.SwitchOn)
+            .addParameter(time)
+            .addParameter(ramp)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    switchOff(time: number, ramp: number = 0): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .execute()
+            .addParameter(MethodType.SwitchOff)
+            .addParameter(time)
+            .addParameter(ramp)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+}
+
+export { AnalogOut, AnalogOutRaw, AnalogOutRemote }

package/dist/analog-din/latest/analog-in.ts

@@ -0,0 +1 @@
+export * from '../fv01_02/analog-in';

package/dist/analog-din/latest/analog-out.ts

@@ -0,0 +1 @@
+export * from '../fv01_02/analog-out';