knx.ts 1.0.0

package/dist/core/data/KNXDataDecode.d.ts

@@ -0,0 +1,396 @@
+import { DecodedDPTType } from "../../@types/types/DecodedDPTType";
+import { KNXData } from "./KNXData";
+/**
+ * Represents KNX DPTs (Data Point Types), decodes them according to their specification
+ */
+export declare class KnxDataDecode extends KNXData {
+    private constructor();
+    static decodeThis<T extends typeof KnxDataDecode.dptEnum[number] | string>(dpt: T, buffer: Buffer): DecodedDPTType<T>;
+    static get dptEnum(): readonly [1, 2, 3007, 3008, 4001, 4002, 5, 5001, 5002, 6, 6001, 6010, 6020, 7, 7001, 7002, 7003, 7004, 7005, 7006, 7007, 7011, 7012, 7013, 8, 9, 10001, 11001, 12001, 12002, 13, 13001, 13002, 13010, 13011, 13012, 13013, 13014, 13015, 13016, 13100, 14, 15000, 16, 16002, 20, 20001, 20002, 20003, 20004, 20005, 20006, 20007, 20008, 20011, 20012, 20013, 20014, 20017, 20020, 20021, 20022, 27001, 28001, 29, 29010, 29011, 29012, 232600, 238600, 245600, 250600, 251600];
+    private static toPercentage;
+    private static toAngle;
+    /**
+     * Interpret the underlying data as boolean value
+     * @returns
+     */
+    static asDpt1(buffer: Buffer): boolean;
+    /**
+     * Interpretar la información del DPT2 (B2) y devolver un objeto con los campos:
+     * - control (c): 0 o 1
+     * - value (v): 0 o 1
+     * - description: descripción basada en la combinación de bits
+     *
+     * Los datos se encuentran en el primer octeto (buffer[0]), y solo se toman en cuenta los dos bits menos significativos.
+     */
+    static asDpt2(buffer: Buffer): {
+        control: number;
+        value: number;
+        description: string;
+    };
+    /**
+     * Interpretar la información del DPT3007 (B1U3) y devolver un objeto con:
+     * - control: 0 (Decrease) o 1 (Increase)
+     * - stepCode: valor de 3 bits (0…7)
+     * - action: descripción de la acción (Decrease o Increase)
+     * - description: "Break" si stepCode es 0 o el detalle de step con el número de intervalos
+     *
+     * Se asume que el dato se encuentra en el primer octeto útil, es decir, en buffer[0].
+     * Como la información es de 4 bits, se toma el nibble inferior del byte.
+     */
+    static asDpt3007(buffer: Buffer): {
+        control: number;
+        stepCode: number;
+        action: string;
+        description: string;
+    };
+    /**
+     * Interpretar la información del DPT3008 (DPT_Control_Blinds).
+     * Se asume que los datos se encuentran en el primer octeto de la carga útil.
+     *
+     * Formato: 4 bit: B1U3
+     * Campos:
+     *  - c: 1 bit (0 = Up, 1 = Down)
+     *  - stepCode: 3 bits
+     *
+     * Retorna un objeto con:
+     *  - control: 0 o 1
+     *  - stepCode: valor numérico de 0 a 7
+     *  - description: texto descriptivo (p.ej. "Up" o "Down")
+     *  - intervals: Si stepCode es distinto de 0, se calcula como 2^(stepCode - 1), o bien se indica "Break" si es 0.
+     */
+    static asDpt3008(buffer: Buffer): {
+        control: number;
+        stepCode: number;
+        description: string;
+        intervals: string | number;
+    };
+    /**
+     * Interpreta la información del DPT4001 (DPT_Char_ASCII).
+     * Se asume que el dato se encuentra en el primer octeto de la carga útil.
+     *
+     * - Valida que el MSB sea 0 (valor en el rango 0...127).
+     * - Retorna el carácter ASCII correspondiente.
+     */
+    static asDpt4001(buffer: Buffer): string;
+    /**
+     * Interpreta la información del DPT4002 (DPT_Char_8859_1).
+     * Se asume que el dato se encuentra en el primer octeto de la carga útil.
+     *
+     * - No se impone restricción en el MSB (valor en el rango 0...255).
+     * - Retorna el carácter correspondiente en ISO-8859-1.
+     */
+    static asDpt4002(buffer: Buffer): string;
+    /**
+     * Interpret the underlying data as 1 Byte unsigned value
+     * @returns
+     */
+    static asDpt5(buffer: Buffer): number;
+    static asDpt5001(buffer: Buffer): string;
+    static asDpt5002(buffer: Buffer): string;
+    static asDpt6(buffer: Buffer): number;
+    static asDpt6001(buffer: Buffer): string;
+    static asDpt6010(buffer: Buffer): string;
+    static asDpt6020(buffer: Buffer): {
+        status: string;
+        mode: string;
+    };
+    static asDpt7(buffer: Buffer): number;
+    static asDpt7001(buffer: Buffer): string;
+    static asDpt7002(buffer: Buffer): string;
+    static asDpt7003(buffer: Buffer): string;
+    static asDpt7004(buffer: Buffer): string;
+    static asDpt7005(buffer: Buffer): string;
+    static asDpt7006(buffer: Buffer): string;
+    static asDpt7007(buffer: Buffer): string;
+    static asDpt7011(buffer: Buffer): string;
+    static asDpt7012(buffer: Buffer): {
+        value: number;
+        status: string;
+    } | {
+        value: string;
+        status: string;
+    };
+    static asDpt7013(buffer: Buffer): string;
+    static asDpt8(buffer: Buffer): number;
+    /**
+     * Decodifica un DPT9 (2-octetos) según la especificación KNX:
+     *   FloatValue = 0.01 * M * 2^(E)
+     *   S (1 bit) = Signo de la mantisa
+     *   E (4 bits) = [0…15]
+     *   M (11 bits) = Mantisa
+     * Si el valor codificado es 0x7FFF, se considera inválido.
+     *
+     * @returns El valor en punto flotante.
+     */
+    static asDpt9(buffer: Buffer): number;
+    /**
+     * Interpreta la información del DPT 10001 (Time of Day).
+     * Se asume que la carga útil contiene 3 octetos codificados según:
+     *
+     * Octeto 1: NNNUUUUU -> 3 bits para el Día y 5 bits para la Hora.
+     * Octeto 2: rrUUUUUU -> 6 bits para los Minutos (dos bits reservados).
+     * Octeto 3: rrUUUUUU -> 6 bits para los Segundos (dos bits reservados).
+     *
+     * Retorna un objeto con:
+     *   - day: número del día (0 = no day, 1 = lunes, …, 7 = domingo)
+     *   - dayName: nombre del día (o "No day")
+     *   - hour: hora (0...23)
+     *   - minutes: minutos (0...59)
+     *   - seconds: segundos (0...59)
+     */
+    static asDpt10001(buffer: Buffer): {
+        day: number;
+        dayName: string;
+        hour: number;
+        minutes: number;
+        seconds: number;
+    };
+    /**
+     * Interpreta la información del DPT 11001 (Date).
+     * Se asume que la carga útil contiene 3 octetos codificados según:
+     *
+     * Octeto 1: r3U5 => Day: 5 bits (bits [4:0])
+     * Octeto 2: r4U4 => Month: 4 bits (bits [3:0])
+     * Octeto 3: r1U7 => Year: 7 bits (bits [6:0])
+     *
+     * La interpretación del año es:
+     *   - Si el valor es >= 90: año = 1900 + valor (siglo XX)
+     *   - Si el valor es < 90:  año = 2000 + valor (siglo XXI)
+     *
+     * Retorna un objeto con los campos day, month, year y una cadena formateada.
+     */
+    static asDpt11001(buffer: Buffer): {
+        day: number;
+        month: number;
+        year: number;
+        dateString: string;
+    };
+    /**
+     * Interpreta la información del DPT 12.001 (4-Octet Unsigned Value para counter pulses).
+     * Se asume que la carga útil contiene 4 octetos.
+     *
+     * @returns Un objeto con el valor sin signo y la unidad ("pulses").
+     */
+    static asDpt12001(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * Interpreta la información de los DPT LongTimePeriod (12.100, 12.101, 12.102) para operating hours.
+     * Se asume que la carga útil contiene 4 octetos.
+     *
+     * @param variant Puede ser:
+     *   - "sec" para DPT_LongTimePeriod_Sec (12.100, segundos),
+     *   - "min" para DPT_LongTimePeriod_Min (12.101, minutos),
+     *   - "hrs" para DPT_LongTimePeriod_Hrs (12.102, horas).
+     *   Por defecto se usa "sec".
+     *
+     * @returns Un objeto con el valor sin signo y la unidad seleccionada.
+     */
+    static asDpt12002(buffer: Buffer, variant?: 'sec' | 'min' | 'hrs'): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * Interpret the underlying data as 4 byte signed integer
+     * @returns
+     */
+    static asDpt13(buffer: Buffer): number;
+    /**
+     * DPT 13.001: DPT_Value_4_Count
+     * Interpreta un contador de pulsos (valor de 4 octetos con signo).
+     */
+    static asDpt13001(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * DPT 13.002: DPT_FlowRate_m3/h
+     * Interpreta el flujo en m³/h (valor de 4 octetos con signo) con alta resolución.
+     */
+    static asDpt13002(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * DPT 13.010: DPT_ActiveEnergy
+     * Interpreta la energía activa en Wh.
+     */
+    static asDpt13010(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * DPT 13.011: DPT_ApparantEnergy
+     * Interpreta la energía aparente en VAh.
+     */
+    static asDpt13011(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * DPT 13.012: DPT_ReactiveEnergy
+     * Interpreta la energía reactiva en VARh.
+     */
+    static asDpt13012(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * DPT 13.013: DPT_ActiveEnergy_kWh
+     * Interpreta la energía activa en kWh.
+     */
+    static asDpt13013(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * DPT 13.014: DPT_ApparantEnergy_kVAh
+     * Interpreta la energía aparente en kVAh.
+     */
+    static asDpt13014(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * DPT 13.015: DPT_ReactiveEnergy_kVARh
+     * Interpreta la energía reactiva en kVARh.
+     */
+    static asDpt13015(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * DPT 13.016: DPT_ActiveEnergy_MWh
+     * Interpreta la energía activa en MWh.
+     */
+    static asDpt13016(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * DPT 13.100: DPT_LongDeltaTimeSec
+     * Interpreta un periodo de tiempo en segundos.
+     */
+    static asDpt13100(buffer: Buffer): {
+        value: number;
+        unit: string;
+    };
+    /**
+     * Interpret the underlying data as 4 byte floating point number
+     */
+    static asDpt14(buffer: Buffer): number;
+    /**
+     * DPT 15.000: DPT_Access_Data
+     * Decodifica un valor de 4 bytes con información de acceso.
+     */
+    static asDpt15000(buffer: Buffer): {
+        accessCode: string;
+        error: boolean;
+        permission: boolean;
+        readDirection: boolean;
+        encryption: boolean;
+        index: number;
+    };
+    /**
+     * DPT 16.000 / 16.001: DPT_String
+     * Decodifica una cadena de 14 bytes en ASCII o ISO-8859-1.
+     */
+    static asDpt16(buffer: Buffer): string;
+    /**
+     * Decodifica un buffer de 14 bytes en formato hexadecimal (DPT 16.002).
+     * (No oficial en la especificacion del DataPointType de Knx en la version 02.02.01)
+     */
+    static asDpt16002(buffer: Buffer): {
+        hex: string;
+        decimal: string;
+    };
+    static asDpt20(buffer: Buffer): number;
+    static asDpt20001(buffer: Buffer): string;
+    static asDpt20002(buffer: Buffer): string;
+    static asDpt20003(buffer: Buffer): string;
+    static asDpt20004(buffer: Buffer): string;
+    static asDpt20005(buffer: Buffer): string;
+    static asDpt20006(buffer: Buffer): string;
+    static asDpt20007(buffer: Buffer): string;
+    static asDpt20008(buffer: Buffer): string;
+    static asDpt20011(buffer: Buffer): string;
+    static asDpt20012(buffer: Buffer): string;
+    static asDpt20013(buffer: Buffer): string;
+    static asDpt20014(buffer: Buffer): string;
+    static asDpt20017(buffer: Buffer): string;
+    static asDpt20020(buffer: Buffer): string;
+    static asDpt20021(buffer: Buffer): string;
+    static asDpt20022(buffer: Buffer): string;
+    static asDpt27001(buffer: Buffer): {
+        outputs: boolean[];
+        masks: boolean[];
+    };
+    static asDpt28001(buffer: Buffer): string;
+    static asDpt29(buffer: Buffer): number;
+    static asDpt29010(buffer: Buffer): number;
+    static asDpt29011(buffer: Buffer): number;
+    static asDpt29012(buffer: Buffer): number;
+    static asDpt232600(buffer: Buffer): {
+        dataBuffer: Buffer<ArrayBufferLike>;
+        rgb: {
+            R: number;
+            G: number;
+            B: number;
+        };
+    };
+    static asDpt238600(buffer: Buffer): {
+        addr: number;
+        lf: boolean;
+        bf: boolean;
+    };
+    static asDpt245600(buffer: Buffer): {
+        LTRF: number;
+        LTRD: number;
+        LTRP: number;
+        SF: number;
+        SD: number;
+        SP: number;
+        LDTR: number;
+        LPDTR: number;
+    };
+    static asDpt250600(buffer: Buffer): {
+        r4_1: number;
+        r4_2: number;
+        r4_3: number;
+        r4_4: number;
+        C: number;
+        StepCodeColourTemp: number;
+        r4_5: number;
+        r4_6: number;
+        r4_7: number;
+        r4_8: number;
+        B: number;
+        StepCodeBrightness: number;
+        reserved: number;
+        validityColourTemp: number;
+        validityBrightness: number;
+    };
+    /**
+     * DPT 251.600: DPT_Colour_RGBW
+     * Decodifica un valor RGBW de 6 bytes con indicadores de validez.
+     */
+    static asDpt251600(buffer: Buffer): {
+        R: {
+            value: number;
+            valid: boolean;
+        };
+        G: {
+            value: number;
+            valid: boolean;
+        };
+        B: {
+            value: number;
+            valid: boolean;
+        };
+        W: {
+            value: number;
+            valid: boolean;
+        };
+    };
+}