CAN decode fallback, signed ID support

Author: haoruizhou

pecan/src/utils/canProcessor.test.ts

@@ -462,5 +462,37 @@ describe('CAN Processor Unit Tests', () => {
             expect(chargerCmd?.messageName).toBe('Charger_Command');
             expect(chargerSts?.messageName).toBe('Charger_Status');
         });
+
+        it('should handle IDs that already have the EFF bit set', () => {
+            const CHARGER_CMD_DBC_ID = 2550588916; // 0x9806E5F4
+            const data = [0x68, 0x10, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00];
+            const result = decodeCanMessage(can, CHARGER_CMD_DBC_ID, data, 7000);
+            expect(result).not.toBeNull();
+            expect(result?.messageName).toBe('Charger_Command');
+        });
+
+        it('should handle negative IDs (if bridge sends signed uint32)', () => {
+            const CHARGER_CMD_SIGNED_ID = -1744378380; // 0x9806E5F4 as signed 32-bit
+            const data = [0x68, 0x10, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00];
+            const result = decodeCanMessage(can, CHARGER_CMD_SIGNED_ID, data, 8000);
+            
+            // With the new fallback, this should now be decoded correctly
+            expect(result).not.toBeNull();
+            expect(result?.messageName).toBe('Charger_Command');
+        });
+
+        it('should handle small extended IDs using fallback', () => {
+            // If we have an extended message with ID 0x123 in DBC,
+            // but we send it as standard ID 0x123.
+            // (Note: example.dbc doesn't have this, but we can simulate the logic)
+            // For now, testing that EFF bit toggling works for known IDs.
+            const CHARGER_CMD_WITHOUT_EFF = 0x1806E5F4; // Raw arbitration ID
+            const data = [0x68, 0x10, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00];
+            const result = decodeCanMessage(can, CHARGER_CMD_WITHOUT_EFF, data, 9000);
+            
+            expect(result).not.toBeNull();
+            expect(result?.messageName).toBe('Charger_Command');
+            expect(result?.canId).toBe(2550588916); // Should return the DBC ID
+        });
     });
 });

pecan/src/utils/canProcessor.ts

@@ -15,11 +15,13 @@ const CAN_EFF_FLAG = 0x80000000;
 const CAN_STD_MAX = 0x7FF;
 
 function toDbcId(rawCanId: number): number {
-  return rawCanId > CAN_STD_MAX ? (rawCanId | CAN_EFF_FLAG) >>> 0 : rawCanId;
+  const unsignedId = rawCanId >>> 0;
+  return unsignedId > CAN_STD_MAX ? (unsignedId | CAN_EFF_FLAG) >>> 0 : unsignedId;
 }
 
 export function formatCanId(canId: number): string {
-  const raw = canId > CAN_STD_MAX ? canId & ~CAN_EFF_FLAG : canId;
+  const unsignedId = canId >>> 0;
+  const raw = unsignedId > CAN_STD_MAX ? unsignedId & ~CAN_EFF_FLAG : unsignedId;
   if (raw > CAN_STD_MAX) {
     return `0x${raw.toString(16).toUpperCase().padStart(8, "0")}`;
   }
@@ -393,9 +395,32 @@ export function decodeCanMessage(
   time: number
 ): DecodedMessage | null {
   try {
-    const dbcId = toDbcId(canId);
-    const frame = canInstance.createFrame(dbcId, messageData);
-    const decoded = canInstance.decode(frame);
+    let dbcId = toDbcId(canId);
+    let frame = canInstance.createFrame(dbcId, messageData);
+    let decoded = canInstance.decode(frame);
+
+    // Fallback: If decoding fails, try toggling the EFF bit (bit 31)
+    // This handles cases where a small ID is actually an extended frame 
+    // or the bridge sends a raw arbitration ID without the flag.
+    if (!decoded) {
+      const fallbackId = (dbcId & 0x80000000) ? (dbcId & 0x7FFFFFFF) : (dbcId | 0x80000000);
+      try {
+        const fallbackFrame = canInstance.createFrame(fallbackId, messageData);
+        const fallbackDecoded = canInstance.decode(fallbackFrame);
+        if (fallbackDecoded) {
+          console.log(`[DBC Fallback] Decoded message ${canId} (0x${canId.toString(16)}) using fallback ID ${fallbackId} (0x${fallbackId.toString(16)})`);
+          dbcId = fallbackId;
+          frame = fallbackFrame;
+          decoded = fallbackDecoded;
+        }
+      } catch (e) {
+        // Silently fail fallback attempt
+      }
+    }
+
+    if (canId === 0x18FF50E5 || canId > 0x7FF || (decoded === null && canId !== 1999)) {
+       console.debug(`[DBC Debug] rawId=${canId} (0x${canId.toString(16)}), dbcId=${dbcId} (0x${dbcId.toString(16)}), decodedName=${decoded?.name ?? 'null'}`);
+    }
 
     const rawDataStr = messageData
       .map((b) => b.toString(16).padStart(2, "0").toUpperCase())