@blokcert/node-red-contrib-ocpp 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.2.0] - 2026-02-12
+
+### Changed
+- **BREAKING**: `ocpp-command` node now has single output (device response only)
+- `ocpp-command` now subscribes to Redis Pub/Sub to receive responses directly
+- Removed "Command Sent" output - node only outputs when device responds or times out
+
+### Removed
+- **Removed `ocpp-response` node** - No longer needed, `ocpp-command` handles responses directly
+
+### Fixed
+- Responses from chargers now properly route back to `ocpp-command` node via WS Server
+
+## [1.1.1] - 2026-02-12
+
+### Fixed
+- Fixed `ocpp-response` node to correctly find and notify `ocpp-command` nodes using `RED.nodes.getNode()` instead of `RED.nodes.eachNode()`
+
 ## [1.1.0] - 2026-02-12
 
 ### Added

package/nodes/ocpp-command.html

@@ -8,11 +8,10 @@
             command: { value: '' },
             timeout: { value: 30000, validate: RED.validators.number() },
             streamMaxLen: { value: 1000, validate: RED.validators.number() },
-            waitForResponse: { value: true },
         },
         inputs: 1,
-        outputs: 2,
-        outputLabels: ['sent', 'response/error'],
+        outputs: 1,
+        outputLabels: ['response'],
         icon: 'font-awesome/fa-bolt',
         paletteLabel: 'ocpp command',
         label: function () {
@@ -75,11 +74,6 @@
         <label for="node-input-timeout"><i class="fa fa-clock-o"></i> Timeout (ms)</label>
         <input type="number" id="node-input-timeout" placeholder="30000">
     </div>
-    <div class="form-row">
-        <label for="node-input-waitForResponse"><i class="fa fa-reply"></i> Wait Response</label>
-        <input type="checkbox" id="node-input-waitForResponse" style="width: auto; margin-left: 0;">
-        <span style="margin-left: 10px;">Wait for device response (enables second output)</span>
-    </div>
     <div class="form-row">
         <label for="node-input-streamMaxLen"><i class="fa fa-list-ol"></i> Stream Max Len</label>
         <input type="number" id="node-input-streamMaxLen" placeholder="1000">
@@ -87,7 +81,7 @@
 </script>
 
 <script type="text/html" data-help-name="ocpp-command">
-    <p>Sends CSMS-initiated commands to charging stations.</p>
+    <p>Sends CSMS-initiated commands to charging stations and outputs the device response.</p>
 
     <h3>Inputs</h3>
     <dl class="message-properties">
@@ -107,31 +101,23 @@
         <dd>Custom message ID (auto-generated if not provided).</dd>
     </dl>
 
-    <h3>Outputs</h3>
-    <ol class="node-ports">
-        <li>Command Sent
-            <dl class="message-properties">
-                <dt>payload <span class="property-type">object</span></dt>
-                <dd>Original payload</dd>
-                <dt>ocpp.messageId <span class="property-type">string</span></dt>
-                <dd>Generated/provided message ID</dd>
-                <dt>ocpp.sentAt <span class="property-type">number</span></dt>
-                <dd>Timestamp when command was sent</dd>
-            </dl>
-        </li>
-        <li>Response/Error (when Wait Response is enabled)
-            <dl class="message-properties">
-                <dt>payload <span class="property-type">object</span></dt>
-                <dd>Response payload from device</dd>
-                <dt>ocpp.response <span class="property-type">boolean</span></dt>
-                <dd>True if this is a response</dd>
-                <dt>ocpp.error <span class="property-type">boolean</span></dt>
-                <dd>True if this is an error/timeout</dd>
-                <dt>ocpp.receivedAt <span class="property-type">number</span></dt>
-                <dd>Timestamp when response was received</dd>
-            </dl>
-        </li>
-    </ol>
+    <h3>Output</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">object</span></dt>
+        <dd>Response payload from device (or null on timeout)</dd>
+        <dt>ocpp.messageId <span class="property-type">string</span></dt>
+        <dd>Message ID of the command</dd>
+        <dt>ocpp.action <span class="property-type">string</span></dt>
+        <dd>Command action that was sent</dd>
+        <dt>ocpp.response <span class="property-type">boolean</span></dt>
+        <dd>Always true for output messages</dd>
+        <dt>ocpp.error <span class="property-type">boolean</span></dt>
+        <dd>True if this is an error or timeout</dd>
+        <dt>ocpp.errorCode <span class="property-type">string</span></dt>
+        <dd>Error code (if error)</dd>
+        <dt>ocpp.latency <span class="property-type">number</span></dt>
+        <dd>Round-trip time in milliseconds</dd>
+    </dl>
 
     <h3>Properties</h3>
     <dl class="message-properties">
@@ -139,16 +125,14 @@
         <dd>OCPP command to send. Can be overridden via <code>msg.ocpp.command</code>.</dd>
 
         <dt>Timeout <span class="property-type">number</span></dt>
-        <dd>How long to wait for device response (ms).</dd>
-
-        <dt>Wait Response <span class="property-type">boolean</span></dt>
-        <dd>If enabled, waits for device response and outputs on second port.</dd>
+        <dd>How long to wait for device response (ms). Default: 30000</dd>
     </dl>
 
     <h3>Common Commands</h3>
     <table>
         <tr><th>Command</th><th>Description</th></tr>
         <tr><td>Reset</td><td>Reboot the charging station</td></tr>
+        <tr><td>GetConfiguration</td><td>Get device configuration keys</td></tr>
         <tr><td>RemoteStartTransaction</td><td>Start charging remotely (1.6)</td></tr>
         <tr><td>RequestStartTransaction</td><td>Start charging remotely (2.0.1)</td></tr>
         <tr><td>UnlockConnector</td><td>Unlock a connector</td></tr>
@@ -156,34 +140,18 @@
         <tr><td>ChangeAvailability</td><td>Set connector availability</td></tr>
     </table>
 
-    <h3>Example: Remote Start</h3>
+    <h3>Example: GetConfiguration</h3>
     <pre>
-// For OCPP 1.6
 msg.ocpp = {
-    tenant: "operator1",
+    tenant: "test",
     deviceId: "charger001",
-    command: "RemoteStartTransaction"
-};
-msg.payload = {
-    connectorId: 1,
-    idTag: "USER123"
+    command: "GetConfiguration"
 };
+msg.payload = {};  // Empty = get all keys
 return msg;
 
-// For OCPP 2.0.1
-msg.ocpp = {
-    tenant: "operator1",
-    deviceId: "station001",
-    command: "RequestStartTransaction"
-};
-msg.payload = {
-    evseId: 1,
-    idToken: {
-        idToken: "USER123",
-        type: "ISO14443"
-    }
-};
-return msg;
+// Response will contain:
+// msg.payload.configurationKey = [...]
     </pre>
 
     <h3>Example: Reset</h3>

package/nodes/ocpp-command.js

@@ -1,6 +1,8 @@
 /**
  * OCPP Command Node
  * Sends CSMS-initiated commands to charging stations
+ *
+ * Output: Device response (or timeout error)
  */
 const { Keys } = require('../lib/redis-client');
 const { buildCall } = require('../lib/ocpp-normalizer');
@@ -23,13 +25,16 @@ module.exports = function (RED) {
         node.command = config.command || ''; // Can be overridden by msg
         node.timeout = parseInt(config.timeout, 10) || 30000;
         node.streamMaxLen = parseInt(config.streamMaxLen, 10) || 1000;
-        node.waitForResponse = config.waitForResponse !== false; // Default true
 
         const redis = node.server.redis;
 
-        // Pending commands waiting for response
+        // Create a separate Redis connection for Pub/Sub
+        let subRedis = null;
         const pendingCommands = new Map();
 
+        // Generate unique server ID for this node instance
+        const nodeServerId = `nodered-${node.id.slice(0, 8)}-${Date.now()}`;
+
         /**
          * Generate unique message ID
          */
@@ -37,6 +42,101 @@ module.exports = function (RED) {
             return crypto.randomUUID();
         }
 
+        /**
+         * Initialize Pub/Sub subscriber
+         */
+        async function initSubscriber() {
+            try {
+                // Duplicate the Redis connection for Pub/Sub
+                subRedis = redis.duplicate();
+
+                subRedis.on('error', (err) => {
+                    node.error(`Subscriber Redis error: ${err.message}`);
+                });
+
+                // Subscribe to our response channel
+                const respChannel = `ws:resp:${nodeServerId}`;
+                await subRedis.subscribe(respChannel);
+                node.log(`Subscribed to ${respChannel}`);
+
+                // Handle incoming messages
+                subRedis.on('message', (channel, message) => {
+                    try {
+                        const data = JSON.parse(message);
+                        const messageId = data.messageId || data.uniqueID;
+
+                        if (!messageId) {
+                            node.warn('Received response without messageId');
+                            return;
+                        }
+
+                        const pending = pendingCommands.get(messageId);
+                        if (!pending) {
+                            // Not our command, ignore
+                            return;
+                        }
+
+                        // Clear timeout
+                        clearTimeout(pending.timeoutId);
+                        pendingCommands.delete(messageId);
+
+                        // Remove from Redis pending hash
+                        const pendingKey = Keys.pending(pending.tenant, pending.deviceId);
+                        redis.hdel(pendingKey, messageId).catch(() => {});
+
+                        // Determine if error
+                        const isError = data.messageType === 4 || data.error === true;
+
+                        // Update status
+                        node.status({
+                            fill: isError ? 'red' : 'green',
+                            shape: 'dot',
+                            text: `${pending.action}: ${isError ? 'error' : 'ok'}`,
+                        });
+
+                        // Build output message with device response
+                        const responseMsg = {
+                            payload: data.payload || data,
+                            ocpp: {
+                                messageId,
+                                action: pending.action,
+                                tenant: pending.tenant,
+                                deviceId: pending.deviceId,
+                                identity: `${pending.tenant}:${pending.deviceId}`,
+                                response: true,
+                                error: isError,
+                                errorCode: data.errorCode,
+                                errorDescription: data.errorDescription,
+                                sentAt: pending.sentAt,
+                                receivedAt: Date.now(),
+                                latency: Date.now() - pending.sentAt,
+                            },
+                        };
+
+                        node.send(responseMsg);
+
+                    } catch (err) {
+                        node.error(`Error processing response: ${err.message}`);
+                    }
+                });
+
+                node.status({ fill: 'green', shape: 'ring', text: 'ready' });
+
+            } catch (err) {
+                node.error(`Failed to initialize subscriber: ${err.message}`);
+                node.status({ fill: 'red', shape: 'ring', text: 'sub error' });
+            }
+        }
+
+        // Initialize subscriber when Redis is ready
+        if (redis.status === 'ready') {
+            initSubscriber();
+        } else {
+            redis.once('ready', () => {
+                initSubscriber();
+            });
+        }
+
         /**
          * Handle incoming messages
          */
@@ -65,6 +165,22 @@ module.exports = function (RED) {
                 // Build OCPP CALL message
                 const callMessage = buildCall(messageId, action, payload);
 
+                // Store pending command for response matching
+                const pendingKey = Keys.pending(tenant, deviceId);
+                const sentAt = Date.now();
+
+                // Store command info in Redis for response matching
+                // Include our serverId so WS Server knows where to send response
+                await redis.hset(pendingKey,
+                    messageId, JSON.stringify({
+                        action,
+                        sentAt,
+                        timeout: node.timeout,
+                        serverId: nodeServerId, // This tells WS Server where to send response
+                    })
+                );
+                await redis.expire(pendingKey, Math.ceil(node.timeout / 1000) + 10);
+
                 // Send to device
                 const outboundKey = Keys.outbound(tenant, deviceId);
                 await redis.xadd(
@@ -73,10 +189,11 @@ module.exports = function (RED) {
                     '*',
                     'id', messageId,
                     'payload', callMessage,
-                    'timestamp', Date.now().toString()
+                    'timestamp', sentAt.toString(),
+                    'serverId', nodeServerId // Include serverId in outbound message
                 );
 
-                node.log(`Sent command ${action} to ${tenant}:${deviceId} (${messageId})`);
+                node.log(`Sent ${action} to ${tenant}:${deviceId} (${messageId})`);
 
                 // Update status
                 node.status({
@@ -85,82 +202,52 @@ module.exports = function (RED) {
                     text: `${action} → ${tenant}:${deviceId}`,
                 });
 
-                // Prepare output message
-                const outMsg = {
-                    ...msg,
-                    ocpp: {
-                        ...msg.ocpp,
-                        messageId,
-                        action,
-                        tenant,
-                        deviceId,
-                        identity: `${tenant}:${deviceId}`,
-                        sentAt: Date.now(),
-                    },
-                };
-
-                if (node.waitForResponse) {
-                    // Store pending command for response matching
-                    const pendingKey = Keys.pending(tenant, deviceId);
-
-                    // Store command info in Redis for response matching
-                    await redis.hset(pendingKey,
-                        messageId, JSON.stringify({
-                            action,
-                            sentAt: Date.now(),
-                            timeout: node.timeout,
-                        })
-                    );
-                    await redis.expire(pendingKey, Math.ceil(node.timeout / 1000) + 10);
-
-                    // Set up timeout
-                    const timeoutId = setTimeout(async () => {
-                        pendingCommands.delete(messageId);
-
-                        // Remove from Redis
-                        await redis.hdel(pendingKey, messageId).catch(() => {});
-
-                        node.status({
-                            fill: 'yellow',
-                            shape: 'dot',
-                            text: `timeout: ${action}`,
-                        });
+                // Set up timeout
+                const timeoutId = setTimeout(async () => {
+                    pendingCommands.delete(messageId);
 
-                        // Send timeout error on second output
-                        const timeoutMsg = {
-                            ...outMsg,
-                            ocpp: {
-                                ...outMsg.ocpp,
-                                error: true,
-                                errorCode: 'Timeout',
-                                errorDescription: `Command ${action} timed out after ${node.timeout}ms`,
-                            },
-                        };
+                    // Remove from Redis
+                    await redis.hdel(pendingKey, messageId).catch(() => {});
 
-                        node.send([null, timeoutMsg]);
-                    }, node.timeout);
-
-                    // Store for cleanup
-                    pendingCommands.set(messageId, {
-                        timeoutId,
-                        msg: outMsg,
-                        action,
+                    node.status({
+                        fill: 'yellow',
+                        shape: 'dot',
+                        text: `timeout: ${action}`,
                     });
 
-                    // Send on first output (command sent)
-                    if (send) {
-                        send([outMsg, null]);
-                    } else {
-                        node.send([outMsg, null]);
-                    }
-                } else {
-                    // Don't wait for response, just send confirmation
+                    // Send timeout error
+                    const timeoutMsg = {
+                        payload: null,
+                        ocpp: {
+                            messageId,
+                            action,
+                            tenant,
+                            deviceId,
+                            identity: `${tenant}:${deviceId}`,
+                            response: true,
+                            error: true,
+                            errorCode: 'Timeout',
+                            errorDescription: `Command ${action} timed out after ${node.timeout}ms`,
+                            sentAt,
+                            receivedAt: Date.now(),
+                        },
+                    };
+
                     if (send) {
-                        send(outMsg);
+                        send(timeoutMsg);
                     } else {
-                        node.send(outMsg);
+                        node.send(timeoutMsg);
                     }
-                }
+                }, node.timeout);
+
+                // Store for response matching
+                pendingCommands.set(messageId, {
+                    timeoutId,
+                    action,
+                    tenant,
+                    deviceId,
+                    sentAt,
+                });
 
                 if (done) {
                     done();
@@ -176,63 +263,27 @@ module.exports = function (RED) {
             }
         });
 
-        /**
-         * Handle response messages (can be connected from another ocpp-in node filtering for responses)
-         */
-        node.handleResponse = function (messageId, response, isError) {
-            const pending = pendingCommands.get(messageId);
-            if (!pending) {
-                return false; // Not our command
-            }
-
-            // Clear timeout
-            clearTimeout(pending.timeoutId);
-            pendingCommands.delete(messageId);
-
-            // Update status
-            node.status({
-                fill: isError ? 'red' : 'green',
-                shape: 'dot',
-                text: `${pending.action}: ${isError ? 'error' : 'response'}`,
-            });
-
-            // Send response on second output
-            const responseMsg = {
-                ...pending.msg,
-                payload: response,
-                ocpp: {
-                    ...pending.msg.ocpp,
-                    response: true,
-                    error: isError,
-                    receivedAt: Date.now(),
-                },
-            };
-
-            node.send([null, responseMsg]);
-            return true;
-        };
-
         // Initial status
-        node.status({ fill: 'grey', shape: 'ring', text: 'ready' });
-
-        // Update status when Redis is ready
-        if (redis) {
-            redis.once('ready', () => {
-                node.status({ fill: 'green', shape: 'ring', text: 'connected' });
-            });
-
-            if (redis.status === 'ready') {
-                node.status({ fill: 'green', shape: 'ring', text: 'connected' });
-            }
-        }
+        node.status({ fill: 'grey', shape: 'ring', text: 'initializing' });
 
         // Cleanup on close
-        node.on('close', (done) => {
+        node.on('close', async (done) => {
             // Clear all pending timeouts
             for (const [, pending] of pendingCommands) {
                 clearTimeout(pending.timeoutId);
             }
             pendingCommands.clear();
+
+            // Cleanup subscriber
+            if (subRedis) {
+                try {
+                    await subRedis.unsubscribe();
+                    await subRedis.quit();
+                } catch (e) {
+                    // Ignore cleanup errors
+                }
+            }
+
             done();
         });
     }

package/nodes/ocpp-response.js

@@ -81,16 +81,32 @@ module.exports = function (RED) {
 
                 // Find and notify all ocpp-command nodes
                 let handled = false;
+
+                // Get all flows and find ocpp-command nodes
+                const allNodes = [];
                 RED.nodes.eachNode((n) => {
-                    if (n.type === 'ocpp-command' && n.handleResponse) {
-                        // Try to handle this response
-                        const wasHandled = n.handleResponse(messageId, msg.payload, isError);
-                        if (wasHandled) {
-                            handled = true;
-                        }
+                    if (n.type === 'ocpp-command') {
+                        allNodes.push(n.id);
                     }
                 });
 
+                // Try to get the runtime node instance and call handleResponse
+                for (const nodeId of allNodes) {
+                    try {
+                        const commandNode = RED.nodes.getNode(nodeId);
+                        if (commandNode && typeof commandNode.handleResponse === 'function') {
+                            const wasHandled = commandNode.handleResponse(messageId, msg.payload, isError);
+                            if (wasHandled) {
+                                handled = true;
+                                node.log(`Response ${messageId} handled by ocpp-command node ${nodeId}`);
+                                break; // Only one node should handle each response
+                            }
+                        }
+                    } catch (e) {
+                        node.warn(`Error calling handleResponse on node ${nodeId}: ${e.message}`);
+                    }
+                }
+
                 // Update status
                 if (handled) {
                     node.status({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blokcert/node-red-contrib-ocpp",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Node-RED nodes for OCPP (Open Charge Point Protocol) message handling via Redis Streams",
   "keywords": [
     "node-red",
@@ -22,7 +22,6 @@
       "ocpp-in": "nodes/ocpp-in.js",
       "ocpp-out": "nodes/ocpp-out.js",
       "ocpp-command": "nodes/ocpp-command.js",
-      "ocpp-response": "nodes/ocpp-response.js",
       "ocpp-config": "nodes/ocpp-config.js"
     }
   },