knx.ts 1.0.0

package/dist/core/layers/data/NPDU.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NPDU = void 0;
+const EnumControlFieldExtended_1 = require("../../enum/EnumControlFieldExtended");
+const TPDU_1 = require("./TPDU");
+/**
+ * Clase que representa la Network Protocol Data Unit (NPDU).
+ * * Responsabilidades:
+ * 1. Gestionar el Hop Count (Contador de saltos) para el enrutamiento.
+ * 2. Gestionar la longitud de la trama de datos (Length).
+ * 3. Encapsular el TPDU (Transport Layer PDU), que a su vez contiene el TPCI y el APDU.
+ * * Estructura del Byte NPCI (Network Protocol Control Information):
+ * Bits [7]   : Reservado (normalmente 0 en tramas estándar)
+ * Bits [6-4] : Hop Count (0-7)
+ * Bits [3-0] : Longitud del Payload (APDU)
+ * @see 03_03_03 Network Layer v02.01.01 AS
+ */
+class NPDU {
+    _hopCount = 6; // Valor por defecto estándar en KNX
+    TPDU; // Datos puros (payload del usuario)
+    _addressType;
+    constructor(InstanceOfTPDU = new TPDU_1.TPDU(), addressType = EnumControlFieldExtended_1.AddressType.GROUP, hopCount = 6) {
+        this._addressType = addressType;
+        this.hopCount = hopCount; // Usa el setter para validar
+        this.TPDU = InstanceOfTPDU;
+    }
+    /**
+     * Obtiene el Hop Count (0-7).
+     */
+    get hopCount() {
+        return this._hopCount;
+    }
+    /**
+     * Establece el Hop Count. Lanza error si está fuera de rango (0-7).
+     */
+    set hopCount(value) {
+        if (value < 0 || value > 7) {
+            throw new Error("Hop Count must be between 0 and 7");
+        }
+        this._hopCount = value;
+    }
+    get addressType() {
+        return this._addressType;
+    }
+    set addressType(value) {
+        if (value > 1 || value < 0)
+            throw new Error("The address type is not mayor or minor than 0..1");
+        this._addressType = value;
+    }
+    toBuffer() {
+        const tpduBuffer = this.TPDU.toBuffer();
+        const length = tpduBuffer.length;
+        // Construcción del Byte NPCI (Octeto 0 del NPDU)
+        // Bits 7: Reservado (0) -> parece ser el AddressType
+        // Bits 6-4: Hop Count
+        // Bits 3-0: Length (Longitud del TPDU)
+        const npciByte = (this.addressType << 7) | (this._hopCount << 4) | (length & 0x0f);
+        const buffer = Buffer.alloc(1 + length);
+        buffer.writeUInt8(npciByte, 0);
+        tpduBuffer.copy(buffer, 1);
+        return buffer;
+    }
+    describe() {
+        return {
+            layer: "Network Layer (NPDU)",
+            addressType: EnumControlFieldExtended_1.AddressType[this.addressType],
+            hopCount: this.hopCount,
+            TPDU: this.TPDU.describe(),
+        };
+    }
+    /**
+     * Crea una instancia de NPDU a partir de un Buffer crudo.
+     * Estructura: [NPCI] [TPDU...]
+     * @param buffer El buffer completo comenzando con el byte NPCI.
+     */
+    static fromBuffer(buffer) {
+        if (buffer.length < 2) {
+            // Mínimo 1 byte NPCI + 1 byte payload
+            throw new Error("Buffer too short for NPDU");
+        }
+        // 1. Parsear el Byte NPCI (Octeto 0)
+        // Bits 7: Reservado (0)
+        // Bits 6-4: Hop Count
+        // Bits 3-0: Length (Longitud del TPDU)
+        const npci = buffer.readUInt8(0);
+        const hopCount = (npci >> 4) & 0x07;
+        const length = npci & 0x0f;
+        // Validación de longitud según especificación 03_03_03
+        // Nota: 'length' en NPCI indica la longitud del TPDU en bytes.
+        if (buffer.length - 1 < length) {
+            throw new Error(`NPDU declared length ${length} but buffer has only ${buffer.length - 1} bytes payload`);
+        }
+        // 2. Extraer el TPDU (Transport Layer PDU)
+        // El payload comienza en el índice 1.
+        const tpduBuffer = buffer.subarray(1, 1 + length);
+        // Llamada estática recursiva a la siguiente capa
+        const tpdu = TPDU_1.TPDU.fromBuffer(tpduBuffer);
+        // 3. Retornar nueva instancia
+        // Nota: AddressType no viene en el NPDU, viene del cEMI. Asumimos GROUP por defecto.
+        return new NPDU(tpdu, EnumControlFieldExtended_1.AddressType.GROUP, hopCount);
+    }
+}
+exports.NPDU = NPDU;

package/dist/core/layers/data/TPDU.d.ts

@@ -0,0 +1,53 @@
+import { ServiceMessage } from "../../../@types/interfaces/ServiceMessage";
+import { TPCI } from "../interfaces/TPCI";
+import { APDU } from "./APDU";
+export declare class TPDU implements ServiceMessage {
+    tpci: TPCI;
+    apdu: APDU;
+    data: Buffer;
+    constructor(tpci?: TPCI, apdu?: APDU, data?: Buffer);
+    /**
+     * Get length all TPDU
+     */
+    get length(): number;
+    get TSDU(): APDU;
+    /**
+     * Devuelve un buffer con TPCI/APCI + data
+     */
+    toBuffer(): Buffer;
+    describe(): {
+        layer: string;
+        tpci: {
+            buffer: Buffer<ArrayBufferLike>;
+            hex: string;
+            dataOrControlFlag: string;
+            numbered: boolean;
+            sequenceNumber: number;
+            firstTwoBitsFromAPCI: number;
+            TPCIType: string;
+        };
+        APDU: {
+            layer: string;
+            tpci: {
+                buffer: Buffer<ArrayBufferLike>;
+                hex: string;
+                dataOrControlFlag: string;
+                numbered: boolean;
+                sequenceNumber: number;
+                firstTwoBitsFromAPCI: number;
+                TPCIType: string;
+            };
+            apci: {
+                obj: string;
+                command: string;
+                value: string;
+            };
+            data: Buffer<ArrayBufferLike>;
+        };
+    };
+    /**
+     * Crea una instancia de TPDU.
+     * Estructura: [TPCI + APCI_High] [APCI_Low + Data] [Data...]
+     */
+    static fromBuffer(buffer: Buffer): TPDU;
+}

package/dist/core/layers/data/TPDU.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPDU = void 0;
+const KNXHelper_1 = require("../../../utils/KNXHelper");
+const TPCI_1 = require("../interfaces/TPCI");
+const APDU_1 = require("./APDU");
+class TPDU {
+    tpci;
+    apdu;
+    data;
+    constructor(tpci = new TPCI_1.TPCI(TPCI_1.TPCIType.T_DATA_GROUP_PDU), apdu = new APDU_1.APDU(), data = Buffer.alloc(0)) {
+        this.tpci = tpci;
+        this.apdu = apdu;
+        this.data = data;
+    }
+    /**
+     * Get length all TPDU
+     */
+    get length() {
+        return this.toBuffer().length;
+    }
+    get TSDU() {
+        return this.apdu;
+    }
+    /**
+     * Devuelve un buffer con TPCI/APCI + data
+     */
+    toBuffer() {
+        if (this.tpci.dataControlFlag) {
+            const buffer = Buffer.alloc(1);
+            buffer.writeUint8(this.tpci.getValue(), 0);
+            return buffer;
+        }
+        const buffer = Buffer.alloc(1 + this.apdu.length);
+        // La clase APDU tiene el tpci y el apci en su buffer
+        // para simplificar la envoltura de los octetos por lo tanto
+        // se escribe el tpci desde del apdu para evitar problemas
+        buffer.writeUint8(this.tpci.getValue(), 0);
+        const packNumber = this.apdu.apci.packNumber();
+        buffer.writeUInt8(packNumber[1], 1);
+        KNXHelper_1.KNXHelper.WriteData(buffer, this.data, 1);
+        return buffer;
+    }
+    describe() {
+        return {
+            layer: "Transport Layer (TPDU)",
+            tpci: this.tpci.describe(),
+            APDU: this.apdu.describe(),
+        };
+    }
+    /**
+     * Crea una instancia de TPDU.
+     * Estructura: [TPCI + APCI_High] [APCI_Low + Data] [Data...]
+     */
+    static fromBuffer(buffer) {
+        if (buffer.length < 1)
+            throw new Error("Buffer too short for TPDU");
+        // 1. Extraer TPCI (Transport Protocol Control Information)
+        // El TPCI ocupa los primeros 6 bits del primer octeto.
+        // Máscara: 1111 1100 (0xFC)
+        // ** Se evita usar la mascara 0xfc para que el tpci tenga los dos bits más
+        // ** significativos del APCI
+        const tpciByte = buffer.readUInt8(0);
+        const tpciValue = tpciByte;
+        const tpci = new TPCI_1.TPCI(tpciValue);
+        // 2. Extraer APDU (Application Protocol Data Unit)
+        // IMPORTANTE: Pasamos TODO el buffer, porque el APDU necesita los
+        // últimos 2 bits del primer byte (que son parte del APCI).
+        const apdu = APDU_1.APDU.fromBuffer(buffer);
+        return new TPDU(tpci, apdu, apdu.data);
+    }
+}
+exports.TPDU = TPDU;

package/dist/core/layers/interfaces/APCI.d.ts

@@ -0,0 +1,61 @@
+import { APCIEnum } from "../../enum/APCIEnum";
+/**
+ * Clase para manejar el Application Control Field (APCI) en comunicaciones KNX,
+ * específicamente para el modo T_Data_Group.
+ *
+ * El APCI se compone de 4 o 10 bits
+ *
+ * @see {@link https://my.knx.org/es/shop/knx-specifications?product_type=knx-specifications} - "Application Layer of the KNX System, Version 02.01.01"
+ *
+ */
+export declare class APCI {
+    private _value;
+    constructor(apci?: APCIEnum);
+    /**
+     * Obtiene el valor crudo del APCI (10 bits).
+     */
+    get value(): number;
+    /**
+     * Asigna un nuevo valor crudo al APCI.
+     * Se preservan solo en la máscara de 10 bits (0x3FF).
+     * @param val Valor numérico (0-1023) que representa el APCI
+     */
+    set value(val: number);
+    /**
+     * Obtiene el comando APCI
+     */
+    get command(): string;
+    /**
+     * Establece el comando APCI.
+     * @param cmd Comando APCI (uno de los valores del enum APCIEnum)
+     */
+    set command(cmd: APCIEnum);
+    /**
+     * Retorna una representación hexadecimal del APCI.
+     */
+    toHex(): string;
+    /**
+     * Devuelve el APCI como Buffer (2 octeto).
+     */
+    toBuffer(): Buffer;
+    /**
+     * Enpaqueta el valor del APCI en una mascara 0000 0011 1111 1111 o 0000 0011 1100 0000 (dependiendo si el valor es de 4 bits o 10 bits)
+     * @returns {[number, number]}
+     */
+    packNumber(): [number, number];
+    /**
+     * Desenpaqueta el valor real del APCI apartir de dos octetos
+     * @param octet1
+     * @param octet2
+     * @returns {number}
+     */
+    unpackNumber(octet1: number, octet2: number): number;
+    /**
+     * Proporciona una descripción legible del APCI.
+     */
+    describe(): {
+        obj: string;
+        command: string;
+        value: string;
+    };
+}

package/dist/core/layers/interfaces/APCI.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APCI = void 0;
+const APCIEnum_1 = require("../../enum/APCIEnum");
+/**
+ * Clase para manejar el Application Control Field (APCI) en comunicaciones KNX,
+ * específicamente para el modo T_Data_Group.
+ *
+ * El APCI se compone de 4 o 10 bits
+ *
+ * @see {@link https://my.knx.org/es/shop/knx-specifications?product_type=knx-specifications} - "Application Layer of the KNX System, Version 02.01.01"
+ *
+ */
+class APCI {
+    _value;
+    constructor(apci = APCIEnum_1.APCIEnum.A_GroupValue_Write_Protocol_Data_Unit) {
+        this._value = apci & 0x3ff;
+    }
+    /**
+     * Obtiene el valor crudo del APCI (10 bits).
+     */
+    get value() {
+        return this._value;
+    }
+    /**
+     * Asigna un nuevo valor crudo al APCI.
+     * Se preservan solo en la máscara de 10 bits (0x3FF).
+     * @param val Valor numérico (0-1023) que representa el APCI
+     */
+    set value(val) {
+        this._value = val & 0x3ff;
+    }
+    /**
+     * Obtiene el comando APCI
+     */
+    get command() {
+        return APCIEnum_1.APCIEnum[this._value & 0x3ff];
+    }
+    /**
+     * Establece el comando APCI.
+     * @param cmd Comando APCI (uno de los valores del enum APCIEnum)
+     */
+    set command(cmd) {
+        this._value = cmd;
+    }
+    /**
+     * Retorna una representación hexadecimal del APCI.
+     */
+    toHex() {
+        return `0x${this._value.toString(16).padStart(2, "0").toUpperCase()}`;
+    }
+    /**
+     * Devuelve el APCI como Buffer (2 octeto).
+     */
+    toBuffer() {
+        return Buffer.from([this._value >> 8, this._value & 0xff]);
+    }
+    /**
+     * Enpaqueta el valor del APCI en una mascara 0000 0011 1111 1111 o 0000 0011 1100 0000 (dependiendo si el valor es de 4 bits o 10 bits)
+     * @returns {[number, number]}
+     */
+    packNumber() {
+        // bits altos -> posiciones 0 y 1 del primer octeto
+        const high = (this.value >> 8) & 0x03; // b9 b8
+        const low = this.value & 0xff; // b7..b0
+        const octet1 = high; // ya queda en los 2 LSB
+        const octet2 = low;
+        return [octet1, octet2];
+    }
+    /**
+     * Desenpaqueta el valor real del APCI apartir de dos octetos
+     * @param octet1
+     * @param octet2
+     * @returns {number}
+     */
+    unpackNumber(octet1, octet2) {
+        const high = octet1 & 0x03; // bits en posiciones 0 y 1
+        const low = octet2;
+        return (high << 8) | low;
+    }
+    /**
+     * Proporciona una descripción legible del APCI.
+     */
+    describe() {
+        return {
+            obj: this.constructor.name,
+            command: this.command,
+            value: `${this.toHex()} (Buffer: ${this.toBuffer().toString("hex").toUpperCase()})`
+        };
+    }
+}
+exports.APCI = APCI;

package/dist/core/layers/interfaces/TPCI.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Este enumerable se basa en el esquema numero 3 del titulo "2. TPDU" del documento "Transport Layer of the KNX System, Version 01.02.03"
+ * @see {@link https://my.knx.org/es/shop/knx-specifications?product_type=knx-specifications} - "Transport Layer of the KNX System, Version 01.02.03"
+ */
+export declare enum TPCIType {
+    /** Destination address = 0
+     * - The T_Data_Broadcast service shall be applied by the user of Transport Layer, to transmit a TSDU (Transport Service Data Unit) over a connectionless communication mode to all remote partners.
+     */
+    T_DATA_BROADCAST_PDU = 0,
+    /** Destination address ≠ 0
+     * - The T_Data_Group service shall be applied by the user of Transport Layer, to transmit a TSDU (Transport Service Data Unit) over a multicast communication mode to one or more remote partners.
+     */
+    T_DATA_GROUP_PDU = 0,
+    /** The T_Data_Tag_Group-service shall be applied by the user of Transport Layer, to transmit a TSDU over a multicast communication mode to one or more remote partners. */
+    T_DATA_TAG_GROUP_PDU = 4,
+    /** PDU (Protocol Data Unit) individual
+     * - The T_Data_Individual service shall be applied by the user of Transport Layer, to transmit a TSDU over a connectionless point-to-point communication mode to exactly one remote partner.
+     */
+    T_DATA_INDIVIDUAL_PDU = 0,
+    /** PDU (Protocol Data Unit) connected
+     * - The T_Data_Connected service shall b applied by the user of Transport Layer, to transmit a TSDU over a Transport Layer connection on a connection-oriented communication mode to a remote partner.
+     */
+    T_DATA_CONNECTED_PDU = 64,
+    /** Establish connection
+     * - The T_Connect service shall be applied by the user of Transport Layer, to establish a Transport Layer connection on a connection-oriented point-to-point communication mode.
+     */
+    T_CONNECT_PDU = 128,
+    /** End connection
+     * - The T_Disconnect service shall be applied by the user of Transport Layer, to release a Transport Layer connection on a connection-oriented point-to-point communication mode.
+     */
+    T_DISCONNECT_PDU = 129,
+    /** Acknowledgement */
+    T_ACK_PDU = 194,
+    /** Negative Acknowledgement */
+    T_NAK_PDU = 195
+}
+/**
+ * Clase para manejar el TPCI (Transport Protocol Control Field)
+ * en KNX, correspondiente al primer octeto del TPDU (Transport Layer Protocol Data Unit).
+ *
+ * **Estructura del TPCI (8 bits):**
+ *   - Bit 7         : Data/Control Flag (1 = Control, 0 = Data)
+ *   - Bit 6         : Numbered flag (1 = Mensaje numerado, 0 = No numerado)
+ *   - Bits 5..2     : Número de secuencia (4 bits: 0..15)
+ *   - Bits 1..0     : Reservados para el Application Layer Control Field (APCI) (se fijan a 0)
+ *
+ * @see {@link https://my.knx.org/es/shop/knx-specifications?product_type=knx-specifications} - "Transport Layer of the KNX System, Version 01.02.03"
+ */
+export declare class TPCI {
+    private _buffer;
+    constructor(initialValue?: TPCIType);
+    /**
+     * Devuelve el valor crudo (8 bits) del TPCI/APCI.
+     */
+    getValue(): number;
+    /**
+     * Asigna el valor crudo (8 bits) del TPCI.
+     */
+    setValue(value: number): void;
+    /**
+     * Data/Control Flag (Bit 7):
+     * - true  → Bit 7 = 1 (Control)
+     * - false → Bit 7 = 0 (Data)
+     */
+    get dataControlFlag(): boolean;
+    set dataControlFlag(flag: boolean);
+    /**
+     * Numbered Flag (Bit 6):
+     * - true  → Bit 6 = 1 (Mensaje numerado)
+     * - false → Bit 6 = 0 (No numerado)
+     */
+    get numberedFlag(): boolean;
+    set numberedFlag(flag: boolean);
+    /**
+     * Número de Secuencia (Bits 5 a 2):
+     * Valor de 0 a 15.
+     */
+    get sequenceNumber(): number;
+    set sequenceNumber(seq: number);
+    /**
+     * Bits Reservados para APCI (Bits 1 a 0).
+     * En esta clase se asumen en 0
+     */
+    get first2bitsOfAPCI(): number;
+    /**
+     * Primeros dos bits para el Application Layer Control Field (APCI)
+     */
+    set first2bitsOfAPCI(val: number);
+    /**
+     * Representa el TPCI como un Buffer (1 octeto).
+     */
+    toBuffer(): Buffer;
+    /**
+     * Representa el TPCI en hexadecimal.
+     */
+    toHex(): string;
+    /**
+     * Describe la codificación actual del objecto KNXTPCI (Transport Layer Control Field)
+     */
+    describe(): {
+        buffer: Buffer<ArrayBufferLike>;
+        hex: string;
+        dataOrControlFlag: string;
+        numbered: boolean;
+        sequenceNumber: number;
+        firstTwoBitsFromAPCI: number;
+        TPCIType: string;
+    };
+    mapTPCIType(value: TPCIType | number, isForce?: boolean): string;
+}

package/dist/core/layers/interfaces/TPCI.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPCI = exports.TPCIType = void 0;
+/**
+ * Este enumerable se basa en el esquema numero 3 del titulo "2. TPDU" del documento "Transport Layer of the KNX System, Version 01.02.03"
+ * @see {@link https://my.knx.org/es/shop/knx-specifications?product_type=knx-specifications} - "Transport Layer of the KNX System, Version 01.02.03"
+ */
+var TPCIType;
+(function (TPCIType) {
+    /** Destination address = 0
+     * - The T_Data_Broadcast service shall be applied by the user of Transport Layer, to transmit a TSDU (Transport Service Data Unit) over a connectionless communication mode to all remote partners.
+     */
+    TPCIType[TPCIType["T_DATA_BROADCAST_PDU"] = 0] = "T_DATA_BROADCAST_PDU";
+    /** Destination address ≠ 0
+     * - The T_Data_Group service shall be applied by the user of Transport Layer, to transmit a TSDU (Transport Service Data Unit) over a multicast communication mode to one or more remote partners.
+     */
+    TPCIType[TPCIType["T_DATA_GROUP_PDU"] = 0] = "T_DATA_GROUP_PDU";
+    /** The T_Data_Tag_Group-service shall be applied by the user of Transport Layer, to transmit a TSDU over a multicast communication mode to one or more remote partners. */
+    TPCIType[TPCIType["T_DATA_TAG_GROUP_PDU"] = 4] = "T_DATA_TAG_GROUP_PDU";
+    /** PDU (Protocol Data Unit) individual
+     * - The T_Data_Individual service shall be applied by the user of Transport Layer, to transmit a TSDU over a connectionless point-to-point communication mode to exactly one remote partner.
+     */
+    TPCIType[TPCIType["T_DATA_INDIVIDUAL_PDU"] = 0] = "T_DATA_INDIVIDUAL_PDU";
+    /** PDU (Protocol Data Unit) connected
+     * - The T_Data_Connected service shall b applied by the user of Transport Layer, to transmit a TSDU over a Transport Layer connection on a connection-oriented communication mode to a remote partner.
+     */
+    TPCIType[TPCIType["T_DATA_CONNECTED_PDU"] = 64] = "T_DATA_CONNECTED_PDU";
+    /** Establish connection
+     * - The T_Connect service shall be applied by the user of Transport Layer, to establish a Transport Layer connection on a connection-oriented point-to-point communication mode.
+     */
+    TPCIType[TPCIType["T_CONNECT_PDU"] = 128] = "T_CONNECT_PDU";
+    /** End connection
+     * - The T_Disconnect service shall be applied by the user of Transport Layer, to release a Transport Layer connection on a connection-oriented point-to-point communication mode.
+     */
+    TPCIType[TPCIType["T_DISCONNECT_PDU"] = 129] = "T_DISCONNECT_PDU";
+    /** Acknowledgement */
+    TPCIType[TPCIType["T_ACK_PDU"] = 194] = "T_ACK_PDU";
+    /** Negative Acknowledgement */
+    TPCIType[TPCIType["T_NAK_PDU"] = 195] = "T_NAK_PDU";
+})(TPCIType || (exports.TPCIType = TPCIType = {}));
+/**
+ * Clase para manejar el TPCI (Transport Protocol Control Field)
+ * en KNX, correspondiente al primer octeto del TPDU (Transport Layer Protocol Data Unit).
+ *
+ * **Estructura del TPCI (8 bits):**
+ *   - Bit 7         : Data/Control Flag (1 = Control, 0 = Data)
+ *   - Bit 6         : Numbered flag (1 = Mensaje numerado, 0 = No numerado)
+ *   - Bits 5..2     : Número de secuencia (4 bits: 0..15)
+ *   - Bits 1..0     : Reservados para el Application Layer Control Field (APCI) (se fijan a 0)
+ *
+ * @see {@link https://my.knx.org/es/shop/knx-specifications?product_type=knx-specifications} - "Transport Layer of the KNX System, Version 01.02.03"
+ */
+class TPCI {
+    _buffer;
+    constructor(initialValue = 0) {
+        this._buffer = Buffer.alloc(1);
+        this._buffer.writeUint8(initialValue, 0);
+    }
+    /**
+     * Devuelve el valor crudo (8 bits) del TPCI/APCI.
+     */
+    getValue() {
+        return this._buffer[0];
+    }
+    /**
+     * Asigna el valor crudo (8 bits) del TPCI.
+     */
+    setValue(value) {
+        this._buffer[0] = (value & 0x3f) << 2;
+    }
+    /**
+     * Data/Control Flag (Bit 7):
+     * - true  → Bit 7 = 1 (Control)
+     * - false → Bit 7 = 0 (Data)
+     */
+    get dataControlFlag() {
+        return ((this._buffer[0] >> 7) & 0x01) === 1;
+    }
+    set dataControlFlag(flag) {
+        if (flag) {
+            this._buffer[0] |= 0x80; // Fija bit7 en 1
+        }
+        else {
+            this._buffer[0] &= 0x7f; // Limpia bit7
+        }
+    }
+    /**
+     * Numbered Flag (Bit 6):
+     * - true  → Bit 6 = 1 (Mensaje numerado)
+     * - false → Bit 6 = 0 (No numerado)
+     */
+    get numberedFlag() {
+        return ((this._buffer[0] >> 6) & 0x01) === 1;
+    }
+    set numberedFlag(flag) {
+        if (flag) {
+            this._buffer[0] |= 0x40; // Fija bit6 en 1
+        }
+        else {
+            this._buffer[0] &= 0xbf; // 0xBF = 10111111, limpia bit6
+        }
+    }
+    /**
+     * Número de Secuencia (Bits 5 a 2):
+     * Valor de 0 a 15.
+     */
+    get sequenceNumber() {
+        return (this._buffer[0] >> 2) & 0x0f;
+    }
+    set sequenceNumber(seq) {
+        if (seq < 0 || seq > 15) {
+            throw new Error("El número de secuencia debe estar entre 0 y 15");
+        }
+        // Limpiar bits 5..2: máscara para bits 5..2 es 0x3C (0011 1100)
+        this._buffer[0] &= ~0x3c;
+        // Pegar seq en bits 5..2
+        this._buffer[0] |= (seq & 0x0f) << 2;
+    }
+    /**
+     * Bits Reservados para APCI (Bits 1 a 0).
+     * En esta clase se asumen en 0
+     */
+    get first2bitsOfAPCI() {
+        return this._buffer[0] & 0x03; // Máscara 00000011
+    }
+    /**
+     * Primeros dos bits para el Application Layer Control Field (APCI)
+     */
+    set first2bitsOfAPCI(val) {
+        if (val < 0 || val > 3) {
+            throw new Error("Los bits reservados deben estar entre 0 y 3");
+        }
+        this._buffer[0] |= val & 0x03;
+    }
+    /**
+     * Representa el TPCI como un Buffer (1 octeto).
+     */
+    toBuffer() {
+        return Buffer.from(this._buffer);
+    }
+    /**
+     * Representa el TPCI en hexadecimal.
+     */
+    toHex() {
+        return `0x${this._buffer[0].toString(16).padStart(2, "0").toUpperCase()}`;
+    }
+    /**
+     * Describe la codificación actual del objecto KNXTPCI (Transport Layer Control Field)
+     */
+    describe() {
+        return {
+            buffer: this.toBuffer(),
+            hex: this.toHex(),
+            dataOrControlFlag: this.dataControlFlag ? "Control" : "Data",
+            numbered: this.numberedFlag,
+            sequenceNumber: this.sequenceNumber,
+            firstTwoBitsFromAPCI: this.first2bitsOfAPCI,
+            TPCIType: this.mapTPCIType(this.getValue())
+        };
+    }
+    mapTPCIType(value, isForce = false) {
+        switch (value) {
+            case TPCIType.T_DATA_BROADCAST_PDU:
+                return "T_Data_Broadcast_PDU";
+            case TPCIType.T_DATA_GROUP_PDU:
+                return "T_Data_Group_PDU";
+            case TPCIType.T_DATA_CONNECTED_PDU:
+                return "T_DATA_CONNECTED_PDU";
+            case TPCIType.T_CONNECT_PDU:
+                return "T_CONNECT_PDU";
+            case TPCIType.T_DISCONNECT_PDU:
+                return "T_DISCONNECT_PDU";
+            case TPCIType.T_ACK_PDU:
+                return "T_ACK_PDU";
+            case TPCIType.T_NAK_PDU:
+                return "T_NAK_PDU";
+            default:
+                if (!isForce) {
+                    /**
+                     * This is to try to analyze if it is:
+                     * T_Data_Broadcast-PDU (destination_address = 0)
+                     * T_Data_Group-PDU (destination_address <> 0)
+                     * T_Data_Tag_Group-PDU
+                     * T_Data_Individual-PDU
+                     * T_Data_Connected-PDU
+                     */
+                    const forceAnalysis = value & 0xFC;
+                    return this.mapTPCIType(forceAnalysis, true);
+                }
+                else {
+                    return 'Unknown PDU';
+                }
+        }
+    }
+}
+exports.TPCI = TPCI;