node-red-contrib-lorawan-bacnet-server 1.2.0

package/nodes/bacnet-server/bacnet-server.js

@@ -0,0 +1,817 @@
+/**
+ * BACnet Server Configuration Node
+ *
+ * This node manages the BACnet server that exposes Node-RED as a BACnet device
+ * on the network. It handles:
+ * - UDP listener initialization
+ * - Who-Is / I-Am discovery protocol
+ * - Object registry management
+ * - Read/Write Property requests from external BACnet clients
+ * - COV (Change of Value) subscriptions
+ */
+
+module.exports = function (RED) {
+    const bacnet = require('node-bacnet');
+
+    // BACnet object type constants
+    const ObjectType = {
+        ANALOG_INPUT: 0,
+        ANALOG_OUTPUT: 1,
+        ANALOG_VALUE: 2,
+        BINARY_INPUT: 3,
+        BINARY_OUTPUT: 4,
+        BINARY_VALUE: 5,
+        DEVICE: 8,
+        MULTI_STATE_VALUE: 19
+    };
+
+    // BACnet property identifiers
+    const PropertyId = {
+        OBJECT_IDENTIFIER: 75,
+        OBJECT_NAME: 77,
+        OBJECT_TYPE: 79,
+        PRESENT_VALUE: 85,
+        STATUS_FLAGS: 111,
+        EVENT_STATE: 36,
+        OUT_OF_SERVICE: 81,
+        UNITS: 117,
+        DESCRIPTION: 28,
+        PRIORITY_ARRAY: 87,
+        RELINQUISH_DEFAULT: 104,
+        COV_INCREMENT: 22,
+        NUMBER_OF_STATES: 74,
+        STATE_TEXT: 110,
+        VENDOR_NAME: 121,
+        VENDOR_IDENTIFIER: 120,
+        MODEL_NAME: 70,
+        FIRMWARE_REVISION: 44,
+        APPLICATION_SOFTWARE_VERSION: 12,
+        PROTOCOL_VERSION: 98,
+        PROTOCOL_REVISION: 139,
+        PROTOCOL_SERVICES_SUPPORTED: 97,
+        PROTOCOL_OBJECT_TYPES_SUPPORTED: 96,
+        MAX_APDU_LENGTH_ACCEPTED: 62,
+        SEGMENTATION_SUPPORTED: 107,
+        APDU_TIMEOUT: 11,
+        NUMBER_OF_APDU_RETRIES: 73,
+        DEVICE_ADDRESS_BINDING: 30,
+        DATABASE_REVISION: 155,
+        OBJECT_LIST: 76,
+        SYSTEM_STATUS: 112
+    };
+
+    // BACnet application tags
+    const ApplicationTag = {
+        NULL: 0,
+        BOOLEAN: 1,
+        UNSIGNED_INTEGER: 2,
+        SIGNED_INTEGER: 3,
+        REAL: 4,
+        DOUBLE: 5,
+        OCTET_STRING: 6,
+        CHARACTER_STRING: 7,
+        BIT_STRING: 8,
+        ENUMERATED: 9,
+        DATE: 10,
+        TIME: 11,
+        OBJECT_IDENTIFIER: 12
+    };
+
+    function BacnetServerNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Configuration
+        node.deviceId = parseInt(config.deviceId) || 123456;
+        node.deviceName = config.deviceName || 'Node-RED-BACnet';
+        node.vendorId = parseInt(config.vendorId) || 999;
+        node.port = parseInt(config.port) || 47808;
+        node.interface = config.interface || '';
+        node.broadcastAddress = config.broadcastAddress || '255.255.255.255';
+
+        // Object registry: Map of objectKey -> object data
+        // objectKey format: "type:instance" e.g., "2:1" for Analog Value instance 1
+        node.objects = new Map();
+
+        // Point nodes registered with this server
+        node.pointNodes = new Map();
+
+        // COV subscriptions: Map of subscriberKey -> subscription data
+        node.covSubscriptions = new Map();
+
+        // BACnet client instance
+        node.client = null;
+
+        // Initialize the BACnet server
+        node.init = function () {
+            try {
+                const clientOptions = {
+                    port: node.port,
+                    interface: node.interface || undefined,
+                    broadcastAddress: node.broadcastAddress
+                };
+
+                node.client = new bacnet(clientOptions);
+
+                // Handle Who-Is requests
+                node.client.on('whoIs', (data) => {
+                    node.handleWhoIs(data);
+                });
+
+                // Handle Read Property requests
+                node.client.on('readProperty', (data) => {
+                    node.handleReadProperty(data);
+                });
+
+                // Handle Write Property requests
+                node.client.on('writeProperty', (data) => {
+                    node.handleWriteProperty(data);
+                });
+
+                // Handle Read Property Multiple requests
+                node.client.on('readPropertyMultiple', (data) => {
+                    node.handleReadPropertyMultiple(data);
+                });
+
+                // Handle COV subscriptions
+                node.client.on('subscribeCov', (data) => {
+                    node.handleSubscribeCov(data);
+                });
+
+                // Handle COV subscription cancellation
+                node.client.on('subscribeProperty', (data) => {
+                    node.handleSubscribeProperty(data);
+                });
+
+                node.log(`BACnet Server started - Device ID: ${node.deviceId}, Port: ${node.port}`);
+                node.emit('ready');
+
+            } catch (err) {
+                node.error(`Failed to initialize BACnet server: ${err.message}`);
+            }
+        };
+
+        // Handle Who-Is discovery requests
+        node.handleWhoIs = function (data) {
+            const lowLimit = data.lowLimit;
+            const highLimit = data.highLimit;
+
+            // Check if our device ID is within the requested range
+            if ((lowLimit === undefined || node.deviceId >= lowLimit) &&
+                (highLimit === undefined || node.deviceId <= highLimit)) {
+
+                // Respond with I-Am
+                node.client.iAmResponse(
+                    node.deviceId,
+                    bacnet.enum.Segmentation.NO_SEGMENTATION,
+                    node.vendorId
+                );
+
+                node.debug(`Responded to Who-Is from ${data.address}`);
+            }
+        };
+
+        // Handle Read Property requests
+        node.handleReadProperty = function (data) {
+            const objectId = data.request.objectId;
+            const propertyId = data.request.property.id;
+            const arrayIndex = data.request.property.index;
+
+            try {
+                const value = node.getPropertyValue(objectId, propertyId, arrayIndex);
+
+                if (value !== null && value !== undefined) {
+                    node.client.readPropertyResponse(
+                        data.address,
+                        data.invokeId,
+                        objectId,
+                        { id: propertyId, index: arrayIndex },
+                        value
+                    );
+
+                    // Notify point node if configured
+                    const pointNode = node.getPointNode(objectId);
+                    if (pointNode && pointNode.outputOnRead) {
+                        pointNode.emitReadEvent(value);
+                    }
+                } else {
+                    node.client.errorResponse(
+                        data.address,
+                        bacnet.enum.ConfirmedService.READ_PROPERTY,
+                        data.invokeId,
+                        bacnet.enum.ErrorClass.PROPERTY,
+                        bacnet.enum.ErrorCode.UNKNOWN_PROPERTY
+                    );
+                }
+            } catch (err) {
+                node.error(`Read Property error: ${err.message}`);
+                node.client.errorResponse(
+                    data.address,
+                    bacnet.enum.ConfirmedService.READ_PROPERTY,
+                    data.invokeId,
+                    bacnet.enum.ErrorClass.OBJECT,
+                    bacnet.enum.ErrorCode.UNKNOWN_OBJECT
+                );
+            }
+        };
+
+        // Handle Write Property requests
+        node.handleWriteProperty = function (data) {
+            const objectId = data.request.objectId;
+            const propertyId = data.request.property.id;
+            const priority = data.request.priority || 16;
+            const value = data.request.value;
+
+            try {
+                const result = node.setPropertyValue(objectId, propertyId, value, priority);
+
+                if (result.success) {
+                    node.client.simpleAckResponse(
+                        data.address,
+                        bacnet.enum.ConfirmedService.WRITE_PROPERTY,
+                        data.invokeId
+                    );
+
+                    // Notify point node
+                    const pointNode = node.getPointNode(objectId);
+                    if (pointNode) {
+                        pointNode.emitWriteEvent(result.value, priority, data.address);
+                    }
+
+                    // Check COV notifications
+                    node.checkCovNotifications(objectId);
+                } else {
+                    node.client.errorResponse(
+                        data.address,
+                        bacnet.enum.ConfirmedService.WRITE_PROPERTY,
+                        data.invokeId,
+                        bacnet.enum.ErrorClass.PROPERTY,
+                        result.errorCode || bacnet.enum.ErrorCode.WRITE_ACCESS_DENIED
+                    );
+                }
+            } catch (err) {
+                node.error(`Write Property error: ${err.message}`);
+                node.client.errorResponse(
+                    data.address,
+                    bacnet.enum.ConfirmedService.WRITE_PROPERTY,
+                    data.invokeId,
+                    bacnet.enum.ErrorClass.OBJECT,
+                    bacnet.enum.ErrorCode.UNKNOWN_OBJECT
+                );
+            }
+        };
+
+        // Handle Read Property Multiple requests
+        node.handleReadPropertyMultiple = function (data) {
+            const properties = data.request.properties;
+            const results = [];
+
+            for (const prop of properties) {
+                const objectId = prop.objectId;
+                const propResults = [];
+
+                for (const propRef of prop.properties) {
+                    const propertyId = propRef.id;
+                    const arrayIndex = propRef.index;
+
+                    try {
+                        const value = node.getPropertyValue(objectId, propertyId, arrayIndex);
+
+                        if (value !== null && value !== undefined) {
+                            propResults.push({
+                                property: { id: propertyId, index: arrayIndex },
+                                value: value
+                            });
+                        } else {
+                            propResults.push({
+                                property: { id: propertyId, index: arrayIndex },
+                                error: {
+                                    errorClass: bacnet.enum.ErrorClass.PROPERTY,
+                                    errorCode: bacnet.enum.ErrorCode.UNKNOWN_PROPERTY
+                                }
+                            });
+                        }
+                    } catch (err) {
+                        propResults.push({
+                            property: { id: propertyId, index: arrayIndex },
+                            error: {
+                                errorClass: bacnet.enum.ErrorClass.OBJECT,
+                                errorCode: bacnet.enum.ErrorCode.UNKNOWN_OBJECT
+                            }
+                        });
+                    }
+                }
+
+                results.push({
+                    objectId: objectId,
+                    values: propResults
+                });
+            }
+
+            node.client.readPropertyMultipleResponse(
+                data.address,
+                data.invokeId,
+                results
+            );
+        };
+
+        // Handle Subscribe COV requests
+        node.handleSubscribeCov = function (data) {
+            const subscriberProcessId = data.request.subscriberProcessId;
+            const objectId = data.request.monitoredObjectId;
+            const issueConfirmedNotifications = data.request.issueConfirmedNotifications;
+            const lifetime = data.request.lifetime || 0;
+
+            const objectKey = `${objectId.type}:${objectId.instance}`;
+            const obj = node.objects.get(objectKey);
+
+            if (!obj) {
+                node.client.errorResponse(
+                    data.address,
+                    bacnet.enum.ConfirmedService.SUBSCRIBE_COV,
+                    data.invokeId,
+                    bacnet.enum.ErrorClass.OBJECT,
+                    bacnet.enum.ErrorCode.UNKNOWN_OBJECT
+                );
+                return;
+            }
+
+            const subscriptionKey = `${data.address}:${subscriberProcessId}:${objectKey}`;
+
+            if (lifetime === 0 && data.request.cancellationRequest) {
+                // Cancel subscription
+                node.covSubscriptions.delete(subscriptionKey);
+                node.debug(`COV subscription cancelled: ${subscriptionKey}`);
+            } else {
+                // Create/update subscription
+                node.covSubscriptions.set(subscriptionKey, {
+                    address: data.address,
+                    processId: subscriberProcessId,
+                    objectId: objectId,
+                    confirmed: issueConfirmedNotifications,
+                    lifetime: lifetime,
+                    expiresAt: lifetime > 0 ? Date.now() + (lifetime * 1000) : null,
+                    lastValue: obj.presentValue
+                });
+                node.debug(`COV subscription created: ${subscriptionKey}, lifetime: ${lifetime}s`);
+            }
+
+            node.client.simpleAckResponse(
+                data.address,
+                bacnet.enum.ConfirmedService.SUBSCRIBE_COV,
+                data.invokeId
+            );
+        };
+
+        // Handle Subscribe Property requests (COV-P)
+        node.handleSubscribeProperty = function (data) {
+            // Similar to COV but for specific properties
+            node.handleSubscribeCov(data);
+        };
+
+        // Check and send COV notifications
+        node.checkCovNotifications = function (objectId) {
+            const objectKey = `${objectId.type}:${objectId.instance}`;
+            const obj = node.objects.get(objectKey);
+
+            if (!obj) return;
+
+            const now = Date.now();
+
+            for (const [key, sub] of node.covSubscriptions) {
+                // Check if subscription is for this object
+                if (`${sub.objectId.type}:${sub.objectId.instance}` !== objectKey) continue;
+
+                // Check if subscription has expired
+                if (sub.expiresAt && now > sub.expiresAt) {
+                    node.covSubscriptions.delete(key);
+                    continue;
+                }
+
+                // Check if value has changed enough to notify
+                const covIncrement = obj.covIncrement || 0;
+                const valueDiff = Math.abs(obj.presentValue - sub.lastValue);
+
+                if (valueDiff >= covIncrement || obj.objectType === ObjectType.BINARY_VALUE ||
+                    obj.objectType === ObjectType.BINARY_INPUT || obj.objectType === ObjectType.BINARY_OUTPUT) {
+
+                    // Send COV notification
+                    const values = [
+                        { property: { id: PropertyId.PRESENT_VALUE }, value: node.encodeValue(obj.presentValue, obj.objectType) },
+                        { property: { id: PropertyId.STATUS_FLAGS }, value: [{ type: ApplicationTag.BIT_STRING, value: { bitsUsed: 4, value: [0] } }] }
+                    ];
+
+                    try {
+                        if (sub.confirmed) {
+                            node.client.confirmedCovNotification(
+                                sub.address,
+                                { type: ObjectType.DEVICE, instance: node.deviceId },
+                                objectId,
+                                sub.lifetime,
+                                values
+                            );
+                        } else {
+                            node.client.unconfirmedCovNotification(
+                                sub.address,
+                                sub.processId,
+                                { type: ObjectType.DEVICE, instance: node.deviceId },
+                                objectId,
+                                sub.lifetime,
+                                values
+                            );
+                        }
+
+                        sub.lastValue = obj.presentValue;
+                        node.debug(`COV notification sent to ${sub.address} for ${objectKey}`);
+                    } catch (err) {
+                        node.error(`Failed to send COV notification: ${err.message}`);
+                    }
+                }
+            }
+        };
+
+        // Get property value for an object
+        node.getPropertyValue = function (objectId, propertyId, arrayIndex) {
+            // Handle Device object properties
+            if (objectId.type === ObjectType.DEVICE && objectId.instance === node.deviceId) {
+                return node.getDeviceProperty(propertyId, arrayIndex);
+            }
+
+            const objectKey = `${objectId.type}:${objectId.instance}`;
+            const obj = node.objects.get(objectKey);
+
+            if (!obj) return null;
+
+            switch (propertyId) {
+                case PropertyId.OBJECT_IDENTIFIER:
+                    return [{ type: ApplicationTag.OBJECT_IDENTIFIER, value: objectId }];
+
+                case PropertyId.OBJECT_NAME:
+                    return [{ type: ApplicationTag.CHARACTER_STRING, value: obj.objectName }];
+
+                case PropertyId.OBJECT_TYPE:
+                    return [{ type: ApplicationTag.ENUMERATED, value: objectId.type }];
+
+                case PropertyId.PRESENT_VALUE:
+                    return node.encodeValue(obj.presentValue, objectId.type);
+
+                case PropertyId.STATUS_FLAGS:
+                    return [{ type: ApplicationTag.BIT_STRING, value: { bitsUsed: 4, value: [0] } }];
+
+                case PropertyId.EVENT_STATE:
+                    return [{ type: ApplicationTag.ENUMERATED, value: 0 }]; // NORMAL
+
+                case PropertyId.OUT_OF_SERVICE:
+                    return [{ type: ApplicationTag.BOOLEAN, value: obj.outOfService || false }];
+
+                case PropertyId.UNITS:
+                    if (obj.units !== undefined) {
+                        return [{ type: ApplicationTag.ENUMERATED, value: obj.units }];
+                    }
+                    return null;
+
+                case PropertyId.DESCRIPTION:
+                    return [{ type: ApplicationTag.CHARACTER_STRING, value: obj.description || '' }];
+
+                case PropertyId.PRIORITY_ARRAY:
+                    if (obj.priorityArray) {
+                        if (arrayIndex !== undefined && arrayIndex >= 1 && arrayIndex <= 16) {
+                            const val = obj.priorityArray[arrayIndex - 1];
+                            if (val === null) {
+                                return [{ type: ApplicationTag.NULL, value: null }];
+                            }
+                            return node.encodeValue(val, objectId.type);
+                        }
+                        // Return full array
+                        return obj.priorityArray.map(val => {
+                            if (val === null) {
+                                return { type: ApplicationTag.NULL, value: null };
+                            }
+                            return node.encodeValue(val, objectId.type)[0];
+                        });
+                    }
+                    return null;
+
+                case PropertyId.RELINQUISH_DEFAULT:
+                    if (obj.relinquishDefault !== undefined) {
+                        return node.encodeValue(obj.relinquishDefault, objectId.type);
+                    }
+                    return null;
+
+                case PropertyId.COV_INCREMENT:
+                    if (obj.covIncrement !== undefined) {
+                        return [{ type: ApplicationTag.REAL, value: obj.covIncrement }];
+                    }
+                    return null;
+
+                case PropertyId.NUMBER_OF_STATES:
+                    if (obj.numberOfStates !== undefined) {
+                        return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: obj.numberOfStates }];
+                    }
+                    return null;
+
+                case PropertyId.STATE_TEXT:
+                    if (obj.stateText) {
+                        if (arrayIndex !== undefined && arrayIndex >= 1 && arrayIndex <= obj.stateText.length) {
+                            return [{ type: ApplicationTag.CHARACTER_STRING, value: obj.stateText[arrayIndex - 1] }];
+                        }
+                        return obj.stateText.map(text => ({ type: ApplicationTag.CHARACTER_STRING, value: text }));
+                    }
+                    return null;
+
+                default:
+                    return null;
+            }
+        };
+
+        // Get device object property
+        node.getDeviceProperty = function (propertyId, arrayIndex) {
+            switch (propertyId) {
+                case PropertyId.OBJECT_IDENTIFIER:
+                    return [{ type: ApplicationTag.OBJECT_IDENTIFIER, value: { type: ObjectType.DEVICE, instance: node.deviceId } }];
+
+                case PropertyId.OBJECT_NAME:
+                    return [{ type: ApplicationTag.CHARACTER_STRING, value: node.deviceName }];
+
+                case PropertyId.OBJECT_TYPE:
+                    return [{ type: ApplicationTag.ENUMERATED, value: ObjectType.DEVICE }];
+
+                case PropertyId.SYSTEM_STATUS:
+                    return [{ type: ApplicationTag.ENUMERATED, value: 0 }]; // OPERATIONAL
+
+                case PropertyId.VENDOR_NAME:
+                    return [{ type: ApplicationTag.CHARACTER_STRING, value: 'Node-RED' }];
+
+                case PropertyId.VENDOR_IDENTIFIER:
+                    return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: node.vendorId }];
+
+                case PropertyId.MODEL_NAME:
+                    return [{ type: ApplicationTag.CHARACTER_STRING, value: 'BACnet Server Node' }];
+
+                case PropertyId.FIRMWARE_REVISION:
+                    return [{ type: ApplicationTag.CHARACTER_STRING, value: '1.0.0' }];
+
+                case PropertyId.APPLICATION_SOFTWARE_VERSION:
+                    return [{ type: ApplicationTag.CHARACTER_STRING, value: '1.0.0' }];
+
+                case PropertyId.PROTOCOL_VERSION:
+                    return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: 1 }];
+
+                case PropertyId.PROTOCOL_REVISION:
+                    return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: 14 }];
+
+                case PropertyId.PROTOCOL_SERVICES_SUPPORTED:
+                    // Bit string indicating supported services
+                    return [{ type: ApplicationTag.BIT_STRING, value: { bitsUsed: 40, value: [0x0F, 0x0C, 0x00, 0x00, 0x00] } }];
+
+                case PropertyId.PROTOCOL_OBJECT_TYPES_SUPPORTED:
+                    // Bit string indicating supported object types
+                    return [{ type: ApplicationTag.BIT_STRING, value: { bitsUsed: 25, value: [0xFF, 0x03, 0x00, 0x08] } }];
+
+                case PropertyId.MAX_APDU_LENGTH_ACCEPTED:
+                    return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: 1476 }];
+
+                case PropertyId.SEGMENTATION_SUPPORTED:
+                    return [{ type: ApplicationTag.ENUMERATED, value: 3 }]; // NO_SEGMENTATION
+
+                case PropertyId.APDU_TIMEOUT:
+                    return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: 3000 }];
+
+                case PropertyId.NUMBER_OF_APDU_RETRIES:
+                    return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: 3 }];
+
+                case PropertyId.DEVICE_ADDRESS_BINDING:
+                    return [];
+
+                case PropertyId.DATABASE_REVISION:
+                    return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: 1 }];
+
+                case PropertyId.OBJECT_LIST:
+                    const objectList = [{ type: ObjectType.DEVICE, instance: node.deviceId }];
+                    for (const [key, obj] of node.objects) {
+                        const [type, instance] = key.split(':').map(Number);
+                        objectList.push({ type, instance });
+                    }
+                    if (arrayIndex !== undefined) {
+                        if (arrayIndex === 0) {
+                            return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: objectList.length }];
+                        }
+                        if (arrayIndex >= 1 && arrayIndex <= objectList.length) {
+                            return [{ type: ApplicationTag.OBJECT_IDENTIFIER, value: objectList[arrayIndex - 1] }];
+                        }
+                        return null;
+                    }
+                    return objectList.map(obj => ({ type: ApplicationTag.OBJECT_IDENTIFIER, value: obj }));
+
+                default:
+                    return null;
+            }
+        };
+
+        // Set property value for an object
+        node.setPropertyValue = function (objectId, propertyId, value, priority) {
+            const objectKey = `${objectId.type}:${objectId.instance}`;
+            const obj = node.objects.get(objectKey);
+
+            if (!obj) {
+                return { success: false, errorCode: bacnet.enum.ErrorCode.UNKNOWN_OBJECT };
+            }
+
+            if (!obj.writable && propertyId === PropertyId.PRESENT_VALUE) {
+                return { success: false, errorCode: bacnet.enum.ErrorCode.WRITE_ACCESS_DENIED };
+            }
+
+            if (propertyId === PropertyId.PRESENT_VALUE) {
+                const decodedValue = node.decodeValue(value, objectId.type);
+
+                if (obj.priorityArray) {
+                    // Handle priority array for commandable objects
+                    const priorityIndex = (priority || 16) - 1;
+
+                    if (decodedValue === null) {
+                        // Relinquish command at this priority
+                        obj.priorityArray[priorityIndex] = null;
+                    } else {
+                        obj.priorityArray[priorityIndex] = decodedValue;
+                    }
+
+                    // Calculate present value from priority array
+                    obj.presentValue = node.calculatePresentValue(obj);
+                } else {
+                    obj.presentValue = decodedValue;
+                }
+
+                return { success: true, value: obj.presentValue };
+            }
+
+            if (propertyId === PropertyId.OUT_OF_SERVICE) {
+                obj.outOfService = node.decodeValue(value, 'boolean');
+                return { success: true, value: obj.outOfService };
+            }
+
+            return { success: false, errorCode: bacnet.enum.ErrorCode.WRITE_ACCESS_DENIED };
+        };
+
+        // Calculate present value from priority array
+        node.calculatePresentValue = function (obj) {
+            if (!obj.priorityArray) {
+                return obj.presentValue;
+            }
+
+            for (let i = 0; i < 16; i++) {
+                if (obj.priorityArray[i] !== null) {
+                    return obj.priorityArray[i];
+                }
+            }
+
+            return obj.relinquishDefault !== undefined ? obj.relinquishDefault : 0;
+        };
+
+        // Encode value based on object type
+        node.encodeValue = function (value, objectType) {
+            switch (objectType) {
+                case ObjectType.BINARY_INPUT:
+                case ObjectType.BINARY_OUTPUT:
+                case ObjectType.BINARY_VALUE:
+                    return [{ type: ApplicationTag.ENUMERATED, value: value ? 1 : 0 }];
+
+                case ObjectType.MULTI_STATE_VALUE:
+                    return [{ type: ApplicationTag.UNSIGNED_INTEGER, value: value }];
+
+                case ObjectType.ANALOG_INPUT:
+                case ObjectType.ANALOG_OUTPUT:
+                case ObjectType.ANALOG_VALUE:
+                default:
+                    return [{ type: ApplicationTag.REAL, value: parseFloat(value) || 0 }];
+            }
+        };
+
+        // Decode value from BACnet format
+        node.decodeValue = function (value, objectType) {
+            if (!value || !value.length) return null;
+
+            const firstValue = value[0];
+
+            if (firstValue.type === ApplicationTag.NULL) {
+                return null;
+            }
+
+            switch (objectType) {
+                case ObjectType.BINARY_INPUT:
+                case ObjectType.BINARY_OUTPUT:
+                case ObjectType.BINARY_VALUE:
+                case 'boolean':
+                    return firstValue.value ? 1 : 0;
+
+                case ObjectType.MULTI_STATE_VALUE:
+                    return parseInt(firstValue.value) || 1;
+
+                case ObjectType.ANALOG_INPUT:
+                case ObjectType.ANALOG_OUTPUT:
+                case ObjectType.ANALOG_VALUE:
+                default:
+                    return parseFloat(firstValue.value) || 0;
+            }
+        };
+
+        // Register a point object
+        node.registerObject = function (objectData, pointNode) {
+            const objectKey = `${objectData.objectType}:${objectData.instanceNumber}`;
+
+            node.objects.set(objectKey, {
+                objectType: objectData.objectType,
+                instanceNumber: objectData.instanceNumber,
+                objectName: objectData.objectName,
+                presentValue: objectData.initialValue,
+                units: objectData.units,
+                description: objectData.description || '',
+                writable: objectData.writable,
+                outOfService: false,
+                priorityArray: objectData.priorityArray ? new Array(16).fill(null) : null,
+                relinquishDefault: objectData.relinquishDefault,
+                covIncrement: objectData.covIncrement,
+                numberOfStates: objectData.numberOfStates,
+                stateText: objectData.stateText
+            });
+
+            node.pointNodes.set(objectKey, pointNode);
+            node.debug(`Registered object: ${objectData.objectName} (${objectKey})`);
+        };
+
+        // Unregister a point object
+        node.unregisterObject = function (objectType, instanceNumber) {
+            const objectKey = `${objectType}:${instanceNumber}`;
+            node.objects.delete(objectKey);
+            node.pointNodes.delete(objectKey);
+
+            // Remove COV subscriptions for this object
+            for (const [key, sub] of node.covSubscriptions) {
+                if (`${sub.objectId.type}:${sub.objectId.instance}` === objectKey) {
+                    node.covSubscriptions.delete(key);
+                }
+            }
+
+            node.debug(`Unregistered object: ${objectKey}`);
+        };
+
+        // Update object value from Node-RED flow
+        node.updateObjectValue = function (objectType, instanceNumber, value) {
+            const objectKey = `${objectType}:${instanceNumber}`;
+            const obj = node.objects.get(objectKey);
+
+            if (obj) {
+                const oldValue = obj.presentValue;
+                obj.presentValue = value;
+
+                // Check COV notifications
+                if (oldValue !== value) {
+                    node.checkCovNotifications({ type: objectType, instance: instanceNumber });
+                }
+
+                return true;
+            }
+            return false;
+        };
+
+        // Get point node for an object
+        node.getPointNode = function (objectId) {
+            const objectKey = `${objectId.type}:${objectId.instance}`;
+            return node.pointNodes.get(objectKey);
+        };
+
+        // Clean up expired COV subscriptions periodically
+        node.covCleanupInterval = setInterval(() => {
+            const now = Date.now();
+            for (const [key, sub] of node.covSubscriptions) {
+                if (sub.expiresAt && now > sub.expiresAt) {
+                    node.covSubscriptions.delete(key);
+                    node.debug(`COV subscription expired: ${key}`);
+                }
+            }
+        }, 60000); // Check every minute
+
+        // Initialize the server
+        node.init();
+
+        // Handle node close
+        node.on('close', function (done) {
+            if (node.covCleanupInterval) {
+                clearInterval(node.covCleanupInterval);
+            }
+
+            if (node.client) {
+                node.client.close();
+                node.client = null;
+            }
+
+            node.objects.clear();
+            node.pointNodes.clear();
+            node.covSubscriptions.clear();
+
+            node.log('BACnet Server stopped');
+            done();
+        });
+    }
+
+    RED.nodes.registerType('bacnet-server', BacnetServerNode);
+};