Add batch processing for CAN messages

Dashboard and CAN processor now support handling arrays of CAN messages for improved performance and flexibility

Author: haoruizhou

pecan/Frontend/pecan-live-dashboard/src/pages/Dashboard.tsx

@@ -57,22 +57,35 @@ function Dashboard() {
           messageData = event.data;
         }
 
-        // Use the processor to decode the raw CAN message
+        // Use the processor to decode the raw CAN message(s)
         const decoded = processor.processWebSocketMessage(messageData);
-        console.log('Decoded message:', decoded);
+        console.log('Decoded message(s):', decoded);
 
-        if (decoded && decoded.signals) {
-          const canId = decoded.canId.toString();
-          console.log(`Updating dashboard with CAN ID ${canId}:`, decoded.signals);
-          
-          // Update or create new message entry
+        // Handle both single messages and arrays of messages
+        const messagesToProcess = Array.isArray(decoded) ? decoded : [decoded];
+        
+        // Process each decoded message
+        const updates: { [canId: string]: any } = {};
+        
+        for (const message of messagesToProcess) {
+          if (message && message.signals) {
+            const canId = message.canId.toString();
+            console.log(`Processing CAN ID ${canId}:`, message.signals);
+            
+            updates[canId] = {
+              messageName: message.messageName || `CAN_${canId}`,
+              signals: message.signals,
+              lastUpdated: Date.now()
+            };
+          }
+        }
+        
+        // Batch update all messages at once for better performance
+        if (Object.keys(updates).length > 0) {
+          console.log(`Updating dashboard with ${Object.keys(updates).length} messages`);
           setCanMessages(prev => ({
             ...prev,
-            [canId]: {
-              messageName: decoded.messageName || `CAN_${canId}`,
-              signals: decoded.signals,
-              lastUpdated: Date.now()
-            }
+            ...updates
           }));
         }
       } catch (error) {

pecan/Frontend/pecan-live-dashboard/src/utils/canProcessor.ts

@@ -15,6 +15,20 @@ interface DecodedMessage {
   };
 }
 
+// Type for batch processing results
+type ProcessResult = DecodedMessage | DecodedMessage[] | null;
+
+// Type for input WebSocket messages
+interface WebSocketMessage {
+  time?: number;
+  timestamp?: number;
+  canId?: number;
+  id?: number;
+  data?: number[];
+}
+
+type WebSocketInput = string | WebSocketMessage | WebSocketMessage[];
+
 /**
  * Parse the physValue string from Candied (format: "123.45 voltage:V")
  * @param physValue - Physical value string from Candied
@@ -301,19 +315,61 @@ export async function createCanProcessor(dbcPath: string): Promise<any> {
       return decodeCanMessage(can, parsed.canId, parsed.data, parsed.time);
     },
 
+    /**
+     * Process multiple CAN messages in batch
+     * @param messages - Array of CAN messages
+     * @returns Array of decoded messages
+     */
+    processBatchMessages: function(messages: WebSocketInput[]): DecodedMessage[] {
+      const decodedMessages: DecodedMessage[] = [];
+      
+      for (const message of messages) {
+        const decoded = this.processWebSocketMessage(message);
+        if (decoded) {
+          // If the result is an array, flatten it
+          if (Array.isArray(decoded)) {
+            decodedMessages.push(...decoded);
+          } else {
+            decodedMessages.push(decoded);
+          }
+        }
+      }
+      
+      return decodedMessages;
+    },
+
     /**
      * Process WebSocket CAN message
-     * @param wsMessage - WebSocket message (can be string or object)
-     * @returns Decoded message or null
+     * @param wsMessage - WebSocket message (can be string, object, or array of objects)
+     * @returns Decoded message or array of decoded messages or null
      */
-    processWebSocketMessage: function(wsMessage: any): DecodedMessage | null {
+    processWebSocketMessage: function(wsMessage: WebSocketInput): ProcessResult {
       // Handle different WebSocket message formats
 
       // If it's a string, try parsing as CSV line
       if (typeof wsMessage === 'string') {
         return this.processLogLine(wsMessage);
       }
 
+      // If it's an array of messages, process each one
+      if (Array.isArray(wsMessage)) {
+        const decodedMessages: DecodedMessage[] = [];
+        
+        for (const message of wsMessage) {
+          const decoded = this.processWebSocketMessage(message);
+          if (decoded) {
+            // If the recursive call returns an array, flatten it
+            if (Array.isArray(decoded)) {
+              decodedMessages.push(...decoded);
+            } else {
+              decodedMessages.push(decoded);
+            }
+          }
+        }
+        
+        return decodedMessages.length > 0 ? decodedMessages : null;
+      }
+      
       // If it's an object with time, canId/id and data properties
       if (typeof wsMessage === 'object') {
         const time = wsMessage.time || wsMessage.timestamp || Date.now();
@@ -364,20 +420,31 @@ export async function createCanProcessor(dbcPath: string): Promise<any> {
  * 
  * ws.onmessage = (event) => {
  *   const decoded = processor.processWebSocketMessage(event.data);
- *   if (decoded) {
- *     console.log('Time:', decoded.time);
- *     console.log('CAN ID:', decoded.canId);
- *     console.log('Message:', decoded.messageName);
- *     console.log('Signals:', decoded.signals);
- *     
- *     // Next step to tabel or graph
- *   }
+ *   
+ *   // Handle both single messages and arrays of messages
+ *   const messages = Array.isArray(decoded) ? decoded : [decoded];
+ *   
+ *   messages.forEach(message => {
+ *     if (message) {
+ *       console.log('Time:', message.time);
+ *       console.log('CAN ID:', message.canId);
+ *       console.log('Message:', message.messageName);
+ *       console.log('Signals:', message.signals);
+ *       
+ *       // Next step to table or graph
+ *     }
+ *   });
  * };
  * 
  * // Supported WebSocket message formats:
  * // 1. CSV string: "2952,CAN,170,4,12,9,0,0,16,64,0"
  *                      ^ relative timestamp will be rejected automatically in the future
  *      The 2025-2026 DAQ system will have absolute timestamps
- * // 2. JSON object: { time: 2952, canId: 170, data: [4,12,9,0,0,16,64,0] }
+ * // 2. Single JSON object: { time: 2952, canId: 170, data: [4,12,9,0,0,16,64,0] }
  * // 3. JSON with timestamp: { timestamp: 1234567890, id: 170, data: [...] }
+ * // 4. Array of JSON objects: [
+ *      { time: 2952, canId: 170, data: [4,12,9,0,0,16,64,0] },
+ *      { time: 2953, canId: 176, data: [215,1,19,254,51,9,170,14] },
+ *      { time: 2954, canId: 192, data: [216,1,0,0,0,1,252,8] }
+ *    ]
  */

pecan/Frontend/pecan-live-dashboard/src/utils/testing-messages.txt

@@ -92,4 +92,23 @@ curl -X POST http://localhost:8080/send \
 
 curl -X POST http://localhost:8080/send \
   -H "Content-Type: application/json" \
-  -d '{"time":2728,"canId":176,"data":[0,0,0,0,0,0,0,0]}'
+  -d '{"time":2728,"canId":176,"data":[0,0,0,0,0,0,0,0]}'
+
+# Test batch processing with multiple JSON messages in an array
+curl -X POST http://localhost:8080/send \
+  -H "Content-Type: application/json" \
+  -d '[
+    {"time":3000,"canId":176,"data":[215,1,19,254,51,9,170,14]},
+    {"time":3001,"canId":177,"data":[178,7,250,246,0,0,0,0]},
+    {"time":3002,"canId":192,"data":[216,1,0,0,0,1,252,8]}
+  ]'
+
+# Test mixed batch with different CAN IDs
+curl -X POST http://localhost:8080/send \
+  -H "Content-Type: application/json" \
+  -d '[
+    {"time":3100,"canId":2018,"data":[63,0,83,0,59,0,49,0]},
+    {"time":3101,"canId":2019,"data":[32,0,32,0,32,0,33,0]},
+    {"time":3102,"canId":2020,"data":[38,0,57,0,57,0,76,0]},
+    {"time":3103,"canId":163,"data":[243,205,55,31,16,0,0,0]}
+  ]'

pecan/Frontend/pecan-live-dashboard/ws-server.js

@@ -24,7 +24,8 @@ const server = http.createServer((req, res) => {
     req.on('end', () => {
       try {
         const data = JSON.parse(body);
-        console.log('Received message to broadcast:', data);
+        const messageCount = Array.isArray(data) ? data.length : 1;
+        console.log(`Received ${messageCount} message(s) to broadcast:`, data);
 
         // Broadcast to all connected WebSocket clients
         wss.clients.forEach(client => {
@@ -34,7 +35,10 @@ const server = http.createServer((req, res) => {
         });
 
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: true, message: 'Message broadcasted' }));
+        res.end(JSON.stringify({ 
+          success: true, 
+          message: `${messageCount} message(s) broadcasted` 
+        }));
       } catch (error) {
         console.error('Error parsing message:', error);
         res.writeHead(400, { 'Content-Type': 'application/json' });