@blokcert/node-red-contrib-ocpp 1.1.1 → 1.2.1

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 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

package/README.md

@@ -89,7 +89,7 @@ msg.ocpp.errorDescription = "Action not supported";
 
 ### ocpp command
 
-Sends CSMS-initiated commands to charging stations.
+Sends CSMS-initiated commands to charging stations and receives responses.
 
 **Supported Commands:**
 - Reset
@@ -103,9 +103,29 @@ Sends CSMS-initiated commands to charging stations.
 - ClearCache
 - And more...
 
-**Outputs:**
-- Output 1: Command sent confirmation
-- Output 2: Device response or timeout error (when "Wait for Response" is enabled)
+**Output:**
+Single output that emits when the device responds (or when a timeout occurs).
+
+**Response Message:**
+```javascript
+{
+  payload: { /* device response payload */ },
+  ocpp: {
+    messageId: "abc123",
+    action: "GetConfiguration",  // Original command
+    tenant: "operator1",
+    deviceId: "charger001",
+    identity: "operator1:charger001",
+    response: true,
+    error: false,  // true for CALLERROR or timeout
+    errorCode: null,  // Set for errors
+    errorDescription: null,  // Set for errors
+    sentAt: 1699999999999,
+    receivedAt: 1699999999150,
+    latency: 150  // Round-trip time in ms
+  }
+}
+```
 
 **Example:**
 ```javascript
@@ -120,37 +140,6 @@ msg.payload = {
 return msg;
 ```
 
-### ocpp response
-
-Routes CALLRESULT/CALLERROR responses back to the originating ocpp-command nodes.
-
-**Features:**
-- Automatically matches responses to pending commands
-- Notifies ocpp-command nodes of responses
-- Calculates round-trip latency
-
-**Setup:**
-Connect this node to an `ocpp in` node (optionally filtered by `_Response`) to receive device responses:
-
-```
-[ocpp in (filter: _Response)] → [ocpp response] → [debug]
-```
-
-**Output:**
-```javascript
-{
-  payload: { /* device response */ },
-  ocpp: {
-    messageId: "abc123",
-    action: "GetConfiguration",  // Original command
-    response: true,
-    error: false,
-    latency: 150,  // Round-trip time in ms
-    handled: true  // Whether an ocpp-command node was notified
-  }
-}
-```
-
 ## Example Flow
 
 ```

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,110 @@ 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}`);
+
+                subRedis.on('subscribe', (channel, count) => {
+                    node.log(`Subscribe confirmed: ${channel} (total: ${count})`);
+                });
+
+                // Handle incoming messages
+                subRedis.on('message', (channel, message) => {
+                    node.log(`Pub/Sub message received on ${channel}`);
+                    try {
+                        const data = JSON.parse(message);
+                        const messageId = data.messageId || data.uniqueID;
+
+                        if (!messageId) {
+                            node.warn('Received response without messageId');
+                            return;
+                        }
+
+                        node.log(`Looking up pending for messageId: ${messageId}`);
+                        const pending = pendingCommands.get(messageId);
+                        if (!pending) {
+                            node.log(`No pending command found for ${messageId}, pendingCommands size: ${pendingCommands.size}`);
+                            // 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'}`,
+                        });
+
+                        node.log(`Found pending command for ${messageId}, sending to output`);
+
+                        // 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 +174,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 +198,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 +211,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}`,
-                        });
-
-                        // 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`,
-                            },
-                        };
+                // Set up timeout
+                const timeoutId = setTimeout(async () => {
+                    pendingCommands.delete(messageId);
 
-                        node.send([null, timeoutMsg]);
-                    }, node.timeout);
+                    // Remove from Redis
+                    await redis.hdel(pendingKey, messageId).catch(() => {});
 
-                    // 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 +272,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-in.html

@@ -10,6 +10,7 @@
             autoAck: { value: true },
             normalizePayload: { value: true },
             filterAction: { value: '' },
+            includeResponses: { value: false },
         },
         inputs: 0,
         outputs: 1,
@@ -58,6 +59,11 @@
         <label for="node-input-filterAction"><i class="fa fa-filter"></i> Filter Action</label>
         <input type="text" id="node-input-filterAction" placeholder="(all actions)">
     </div>
+    <div class="form-row">
+        <label for="node-input-includeResponses"><i class="fa fa-reply"></i> Include Responses</label>
+        <input type="checkbox" id="node-input-includeResponses" style="width: auto; margin-left: 0;">
+        <span style="margin-left: 10px;">Include CallResult/CallError (normally handled by ocpp-command)</span>
+    </div>
 </script>
 
 <script type="text/html" data-help-name="ocpp-in">
@@ -108,12 +114,21 @@
         <dt>Filter Action <span class="property-type">string</span></dt>
         <dd>Optional. Only output messages matching this filter.
         Leave empty to receive all messages.</dd>
+
+        <dt>Include Responses <span class="property-type">boolean</span></dt>
+        <dd>If enabled, includes CallResult (3) and CallError (4) messages.
+        By default, these are skipped because <code>ocpp-command</code> nodes handle responses via Pub/Sub.
+        Enable this only if you need to monitor or log all response traffic.</dd>
     </dl>
 
     <h3>Details</h3>
     <p>This node reads from the <code>ws:inbound</code> Redis Stream using consumer groups,
     allowing multiple Node-RED instances to share the message load.</p>
 
+    <p><strong>Note:</strong> By default, this node only outputs CALL messages (requests from charging stations).
+    Response messages (CallResult/CallError) are handled by <code>ocpp-command</code> nodes via Redis Pub/Sub.
+    Enable "Include Responses" only if you need to monitor or log all traffic.</p>
+
     <h3>Filter Options</h3>
     <p>The Filter Action field supports these values:</p>
     <ul>

package/nodes/ocpp-in.js

@@ -24,6 +24,7 @@ module.exports = function (RED) {
         node.autoAck = config.autoAck !== false; // Default true
         node.normalizePayload = config.normalizePayload !== false; // Default true
         node.filterAction = config.filterAction || ''; // Optional action filter
+        node.includeResponses = config.includeResponses === true; // Default false - skip CallResult/CallError
 
         // State
         let running = false;
@@ -111,6 +112,21 @@ module.exports = function (RED) {
                 let msg = parseStreamMessage(data);
                 msg.streamId = streamId;
 
+                // Skip CallResult (3) and CallError (4) messages by default
+                // These responses should be handled by ocpp-command nodes via Pub/Sub
+                // Only allow them through if explicitly configured with includeResponses option
+                // Check both: ocppMessageType (numeric: 3, 4) and messageType (string: 'result', 'error')
+                const isResponse = msg.ocppMessageType === 3 || msg.ocppMessageType === 4 ||
+                                   msg.messageType === 'result' || msg.messageType === 'error';
+
+                if (isResponse && !node.includeResponses) {
+                    // Auto-ack response messages silently
+                    if (node.autoAck) {
+                        await redis.xack(streamKey, consumerGroup, streamId);
+                    }
+                    return;
+                }
+
                 // Apply action filter if configured
                 // Special filter values:
                 //   - "_CallResult" - only CALLRESULT responses

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blokcert/node-red-contrib-ocpp",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "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"
     }
   },