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

package/nodes/bacnet-point/bacnet-point.js

@@ -0,0 +1,293 @@
+/**
+ * BACnet Point Node
+ *
+ * This node represents a BACnet object (Analog Value, Binary Value, etc.)
+ * that is exposed through the BACnet Server. It:
+ * - Registers itself with the parent bacnet-server config node
+ * - Accepts input messages to update the present value
+ * - Emits output messages when external clients read/write the point
+ * - Supports Priority Array for commandable objects
+ * - Supports COV (Change of Value) threshold configuration
+ */
+
+module.exports = function (RED) {
+
+    // BACnet object type constants
+    const ObjectTypes = {
+        'analogInput': 0,
+        'analogOutput': 1,
+        'analogValue': 2,
+        'binaryInput': 3,
+        'binaryOutput': 4,
+        'binaryValue': 5,
+        'multiStateValue': 19
+    };
+
+    // Object types that support Priority Array (commandable objects)
+    const CommandableTypes = ['analogOutput', 'analogValue', 'binaryOutput', 'binaryValue'];
+
+    function BacnetPointNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Get the server config node
+        node.server = RED.nodes.getNode(config.server);
+
+        if (!node.server) {
+            node.status({ fill: 'red', shape: 'ring', text: 'No server configured' });
+            node.error('No BACnet server configured');
+            return;
+        }
+
+        // Configuration
+        node.objectType = config.objectType || 'analogValue';
+        node.objectTypeId = ObjectTypes[node.objectType];
+        node.instanceNumber = parseInt(config.instanceNumber) || 0;
+        node.objectName = config.objectName || `${node.objectType}_${node.instanceNumber}`;
+        node.initialValue = parseFloat(config.initialValue) || 0;
+        node.units = config.units !== '' ? parseInt(config.units) : undefined;
+        node.description = config.description || '';
+        node.writable = config.writable !== false;
+        node.usePriorityArray = config.usePriorityArray === true && CommandableTypes.includes(node.objectType);
+        node.relinquishDefault = parseFloat(config.relinquishDefault) || 0;
+        node.covIncrement = parseFloat(config.covIncrement) || 0;
+        node.numberOfStates = parseInt(config.numberOfStates) || 3;
+        node.stateText = config.stateText ? config.stateText.split(',').map(s => s.trim()) : undefined;
+
+        // Output options
+        node.outputOnRead = config.outputOnRead === true;
+        node.outputOnWrite = config.outputOnWrite !== false;
+        node.outputOnCov = config.outputOnCov === true;
+
+        // Current value
+        node.currentValue = node.initialValue;
+
+        // Register with server
+        node.registerWithServer = function () {
+            if (!node.server) return;
+
+            const objectData = {
+                objectType: node.objectTypeId,
+                instanceNumber: node.instanceNumber,
+                objectName: node.objectName,
+                initialValue: node.initialValue,
+                units: node.units,
+                description: node.description,
+                writable: node.writable,
+                priorityArray: node.usePriorityArray,
+                relinquishDefault: node.relinquishDefault,
+                covIncrement: node.covIncrement,
+                numberOfStates: node.objectType === 'multiStateValue' ? node.numberOfStates : undefined,
+                stateText: node.objectType === 'multiStateValue' ? node.stateText : undefined
+            };
+
+            node.server.registerObject(objectData, node);
+            node.updateStatus();
+        };
+
+        // Update node status
+        node.updateStatus = function () {
+            const typeLabel = node.objectType.replace(/([A-Z])/g, ' $1').trim();
+            node.status({
+                fill: 'green',
+                shape: 'dot',
+                text: `${typeLabel} ${node.instanceNumber}: ${formatValue(node.currentValue)}`
+            });
+        };
+
+        // Format value for status display
+        function formatValue(val) {
+            if (typeof val === 'number') {
+                if (Number.isInteger(val)) {
+                    return val.toString();
+                }
+                return val.toFixed(2);
+            }
+            return String(val);
+        }
+
+        // Emit message when external client reads the point
+        node.emitReadEvent = function (value) {
+            if (!node.outputOnRead) return;
+
+            const msg = {
+                payload: value,
+                topic: node.objectName,
+                bacnet: {
+                    event: 'read',
+                    objectType: node.objectType,
+                    objectTypeId: node.objectTypeId,
+                    instanceNumber: node.instanceNumber,
+                    objectName: node.objectName
+                }
+            };
+
+            node.send(msg);
+        };
+
+        // Emit message when external client writes to the point
+        node.emitWriteEvent = function (value, priority, address) {
+            node.currentValue = value;
+            node.updateStatus();
+
+            if (!node.outputOnWrite) return;
+
+            const msg = {
+                payload: value,
+                topic: node.objectName,
+                bacnet: {
+                    event: 'write',
+                    objectType: node.objectType,
+                    objectTypeId: node.objectTypeId,
+                    instanceNumber: node.instanceNumber,
+                    objectName: node.objectName,
+                    priority: priority,
+                    source: address
+                }
+            };
+
+            node.send(msg);
+        };
+
+        // Emit message on COV notification
+        node.emitCovEvent = function (value) {
+            if (!node.outputOnCov) return;
+
+            const msg = {
+                payload: value,
+                topic: node.objectName,
+                bacnet: {
+                    event: 'cov',
+                    objectType: node.objectType,
+                    objectTypeId: node.objectTypeId,
+                    instanceNumber: node.instanceNumber,
+                    objectName: node.objectName
+                }
+            };
+
+            node.send(msg);
+        };
+
+        // Handle incoming messages to update value
+        node.on('input', function (msg, send, done) {
+            let newValue;
+            let priority = 16;
+
+            // Extract value from message
+            if (typeof msg.payload === 'object' && msg.payload !== null) {
+                // Structured payload
+                if (msg.payload.value !== undefined) {
+                    newValue = msg.payload.value;
+                }
+                if (msg.payload.priority !== undefined) {
+                    priority = parseInt(msg.payload.priority);
+                    if (priority < 1 || priority > 16) priority = 16;
+                }
+            } else {
+                // Simple payload
+                newValue = msg.payload;
+            }
+
+            // Check for priority in msg.bacnet
+            if (msg.bacnet && msg.bacnet.priority !== undefined) {
+                priority = parseInt(msg.bacnet.priority);
+                if (priority < 1 || priority > 16) priority = 16;
+            }
+
+            // Validate and convert value based on object type
+            if (newValue === undefined || newValue === null) {
+                // Null value means relinquish at this priority (for priority array)
+                if (node.usePriorityArray) {
+                    newValue = null;
+                } else {
+                    if (done) done();
+                    return;
+                }
+            } else {
+                switch (node.objectType) {
+                    case 'binaryInput':
+                    case 'binaryOutput':
+                    case 'binaryValue':
+                        // Convert to binary (0 or 1)
+                        if (typeof newValue === 'boolean') {
+                            newValue = newValue ? 1 : 0;
+                        } else if (typeof newValue === 'string') {
+                            const lower = newValue.toLowerCase();
+                            if (lower === 'true' || lower === 'on' || lower === 'active' || lower === '1') {
+                                newValue = 1;
+                            } else {
+                                newValue = 0;
+                            }
+                        } else {
+                            newValue = newValue ? 1 : 0;
+                        }
+                        break;
+
+                    case 'multiStateValue':
+                        // Convert to integer, ensure within valid range
+                        newValue = parseInt(newValue);
+                        if (isNaN(newValue) || newValue < 1) newValue = 1;
+                        if (newValue > node.numberOfStates) newValue = node.numberOfStates;
+                        break;
+
+                    case 'analogInput':
+                    case 'analogOutput':
+                    case 'analogValue':
+                    default:
+                        // Convert to float
+                        newValue = parseFloat(newValue);
+                        if (isNaN(newValue)) newValue = 0;
+                        break;
+                }
+            }
+
+            // Update the server object
+            if (node.server) {
+                // For priority array objects, we need to handle priority
+                if (node.usePriorityArray) {
+                    // Update through the server which handles priority array
+                    const objectId = { type: node.objectTypeId, instance: node.instanceNumber };
+                    const result = node.server.setPropertyValue(
+                        objectId,
+                        85, // PRESENT_VALUE property ID
+                        [{ type: newValue === null ? 0 : 4, value: newValue }],
+                        priority
+                    );
+                    if (result.success) {
+                        node.currentValue = result.value;
+                    }
+                } else {
+                    node.server.updateObjectValue(node.objectTypeId, node.instanceNumber, newValue);
+                    node.currentValue = newValue;
+                }
+            } else {
+                node.currentValue = newValue;
+            }
+
+            node.updateStatus();
+
+            if (done) done();
+        });
+
+        // Wait for server to be ready before registering
+        if (node.server.client) {
+            // Server already initialized
+            node.registerWithServer();
+        } else {
+            // Wait for server ready event
+            node.server.on('ready', function () {
+                node.registerWithServer();
+            });
+        }
+
+        // Handle node close
+        node.on('close', function (done) {
+            if (node.server) {
+                node.server.unregisterObject(node.objectTypeId, node.instanceNumber);
+            }
+            done();
+        });
+    }
+
+    RED.nodes.registerType('bacnet-point', BacnetPointNode);
+};

package/nodes/bacnet-server/bacnet-server.html

@@ -0,0 +1,138 @@
+<script type="text/javascript">
+  RED.nodes.registerType('bacnet-server', {
+    category: 'config',
+    defaults: {
+      name: { value: '' },
+      deviceId: { value: 123456, required: true, validate: RED.validators.number() },
+      deviceName: { value: 'Node-RED-BACnet', required: true },
+      vendorId: { value: 999, required: true, validate: RED.validators.number() },
+      port: { value: 47808, required: true, validate: RED.validators.number() },
+      interface: { value: '' },
+      broadcastAddress: { value: '255.255.255.255' }
+    },
+    label: function () {
+      return this.name || this.deviceName || 'BACnet Server';
+    },
+    oneditprepare: function () {
+      var node = this;
+
+      // Validate device ID range (0 to 4194302)
+      $('#node-config-input-deviceId').on('change', function () {
+        var val = parseInt($(this).val());
+        if (isNaN(val) || val < 0 || val > 4194302) {
+          RED.notify('Device ID must be between 0 and 4194302', 'error');
+          $(this).val(123456);
+        }
+      });
+
+      // Validate port range
+      $('#node-config-input-port').on('change', function () {
+        var val = parseInt($(this).val());
+        if (isNaN(val) || val < 1 || val > 65535) {
+          RED.notify('Port must be between 1 and 65535', 'error');
+          $(this).val(47808);
+        }
+      });
+
+      // Validate vendor ID range (0 to 65535)
+      $('#node-config-input-vendorId').on('change', function () {
+        var val = parseInt($(this).val());
+        if (isNaN(val) || val < 0 || val > 65535) {
+          RED.notify('Vendor ID must be between 0 and 65535', 'error');
+          $(this).val(999);
+        }
+      });
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="bacnet-server">
+  <div class="form-row">
+    <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-config-input-name" placeholder="Optional name">
+  </div>
+
+  <div class="form-row">
+    <h4><i class="fa fa-server"></i> Device Configuration</h4>
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-deviceId"><i class="fa fa-hashtag"></i> Device ID</label>
+    <input type="number" id="node-config-input-deviceId" min="0" max="4194302" style="width: 120px;">
+    <span class="form-tips" style="margin-left: 10px;">Instance number (0-4194302)</span>
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-deviceName"><i class="fa fa-bookmark"></i> Device Name</label>
+    <input type="text" id="node-config-input-deviceName" placeholder="Node-RED-BACnet">
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-vendorId"><i class="fa fa-building"></i> Vendor ID</label>
+    <input type="number" id="node-config-input-vendorId" min="0" max="65535" style="width: 100px;">
+  </div>
+
+  <div class="form-row">
+    <h4><i class="fa fa-plug"></i> Network Configuration</h4>
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-port"><i class="fa fa-globe"></i> UDP Port</label>
+    <input type="number" id="node-config-input-port" min="1" max="65535" style="width: 100px;">
+    <span class="form-tips" style="margin-left: 10px;">Default: 47808 (0xBAC0)</span>
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-interface"><i class="fa fa-ethernet"></i> Interface</label>
+    <input type="text" id="node-config-input-interface" placeholder="Leave empty for all interfaces">
+    <span class="form-tips" style="margin-left: 10px;">e.g., 192.168.1.100</span>
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-broadcastAddress"><i class="fa fa-broadcast-tower"></i> Broadcast</label>
+    <input type="text" id="node-config-input-broadcastAddress" placeholder="255.255.255.255">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="bacnet-server">
+  <p>BACnet Server configuration node that exposes Node-RED as a BACnet device on the network.</p>
+
+  <h3>Configuration</h3>
+  <dl class="message-properties">
+    <dt>Device ID <span class="property-type">number</span></dt>
+    <dd>The BACnet device instance number (0-4194302). Must be unique on the network.</dd>
+
+    <dt>Device Name <span class="property-type">string</span></dt>
+    <dd>The name of this BACnet device as it will appear to other devices.</dd>
+
+    <dt>Vendor ID <span class="property-type">number</span></dt>
+    <dd>The BACnet vendor identifier (0-65535). Use 999 for experimental/private use.</dd>
+
+    <dt>UDP Port <span class="property-type">number</span></dt>
+    <dd>The UDP port for BACnet communication. Default is 47808 (0xBAC0).</dd>
+
+    <dt>Interface <span class="property-type">string</span></dt>
+    <dd>Network interface IP to bind to. Leave empty to listen on all interfaces.</dd>
+
+    <dt>Broadcast Address <span class="property-type">string</span></dt>
+    <dd>The broadcast address for BACnet discovery. Usually 255.255.255.255.</dd>
+  </dl>
+
+  <h3>Details</h3>
+  <p>This configuration node manages the BACnet server infrastructure:</p>
+  <ul>
+    <li><b>Who-Is / I-Am</b>: Responds to device discovery requests</li>
+    <li><b>Read Property</b>: Allows external clients to read object values</li>
+    <li><b>Write Property</b>: Allows external clients to write object values</li>
+    <li><b>COV Subscriptions</b>: Supports Change of Value notifications</li>
+  </ul>
+
+  <p>Use <code>bacnet-point</code> nodes to create BACnet objects (Analog Value, Binary Value, etc.)
+  that are exposed through this server.</p>
+
+  <h3>References</h3>
+  <ul>
+    <li><a href="http://www.bacnet.org/">BACnet International</a></li>
+    <li><a href="https://github.com/BACnet-IT/node-bacnet">node-bacnet library</a></li>
+  </ul>
+</script>