Add last CAN error time

sdarrow3 · sdarrow3 · commit b155c2cf6347 · 2021-01-07T16:04:22.000-06:00
diff --git a/CANBridge/rev/CANDevice.h b/CANBridge/rev/CANDevice.h
@@ -59,10 +59,12 @@ class CANDevice {
     virtual CANStatus ReadStreamSession(uint32_t sessionHandle, HAL_CANStreamMessage* msgs, uint32_t messagesToRead, uint32_t* messagesRead) = 0;
 
     virtual CANStatus GetCANDetailStatus(float* percentBusUtilization, uint32_t* busOff, uint32_t* txFull, uint32_t* receiveErr, uint32_t* transmitErr) = 0;
+    virtual CANStatus GetCANDetailStatus(float* percentBusUtilization, uint32_t* busOff, uint32_t* txFull, uint32_t* receiveErr, uint32_t* transmitErr, uint32_t* lastErrorTime) = 0;
 
     virtual bool IsConnected() = 0;
     virtual void setThreadPriority(utils::ThreadPriority priority) {};
     virtual void stopRepeatedMessage(uint32_t messageId) {};
+    virtual void ClearSendQueue() {};
 };
 
 } // namespace usb
diff --git a/CANBridge/rev/Drivers/CandleWinUSB/CandleWinUSBDevice.h b/CANBridge/rev/Drivers/CandleWinUSB/CandleWinUSBDevice.h
@@ -60,10 +60,11 @@ class CandleWinUSBDevice : public CANDevice {
     virtual CANStatus ReadStreamSession(uint32_t sessionHandle, HAL_CANStreamMessage* msgs, uint32_t messagesToRead, uint32_t* messagesRead) override;
 
     virtual CANStatus GetCANDetailStatus(float* percentBusUtilization, uint32_t* busOff, uint32_t* txFull, uint32_t* receiveErr, uint32_t* transmitErr) override;
-
+    virtual CANStatus GetCANDetailStatus(float* percentBusUtilization, uint32_t* busOff, uint32_t* txFull, uint32_t* receiveErr, uint32_t* transmitErr, uint32_t* lastErrorTime) override;
     virtual bool IsConnected() override;
     virtual void setThreadPriority(utils::ThreadPriority priority);
     virtual void stopRepeatedMessage(uint32_t messageId);
+    virtual void ClearSendQueue();
 private:
     candle_handle m_handle;
     CandleWinUSBDeviceThread m_thread;
diff --git a/CANBridge/rev/Drivers/CandleWinUSB/CandleWinUSBDeviceThread.h b/CANBridge/rev/Drivers/CandleWinUSB/CandleWinUSBDeviceThread.h
@@ -83,6 +83,11 @@ class CandleWinUSBDeviceThread :public DriverDeviceThread {
             utils::SetThreadPriority(m_thread.get(), priority);
     }
 
+    void clearQueue() {
+        std::cout << "Queue Size: " << m_sendQueue.size() << std::endl;
+        bool empty = m_sendQueue.empty();
+    }
+
     void stopRepeatedMessage(uint32_t messageId) {
         for (int i = 0; i < m_sendQueue.size(); i++) {
             detail::CANThreadSendQueueElement el = m_sendQueue.front();
@@ -112,11 +117,11 @@ class CandleWinUSBDeviceThread :public DriverDeviceThread {
        candle_frame_t incomingFrame;
     
         reading = candle_frame_read(m_device, &incomingFrame, 0);
-
         // Received a new frame, store it
         if (reading) {
             candle_frametype_t frameType = candle_frame_type(&incomingFrame);
             if(frameType == CANDLE_FRAMETYPE_ERROR) {
+                time(&lastErrorTime);
                 // Parse error data
                 if (incomingFrame.can_id & 0x00000040) {
                     m_statusDetails.busOffCount++;
@@ -172,7 +177,7 @@ class CandleWinUSBDeviceThread :public DriverDeviceThread {
 
             // TODO: Feed back an error
             if (candle_frame_send(m_device, 0, &frame, false, 20) == false) {
-                // std::cout << "Failed to send message: " << std::hex << (int)el.m_msg.GetMessageId() << std::dec << "  " << candle_error_text(candle_dev_last_error(m_device)) << std::endl;
+                std::cout << "Failed to send message: " << std::hex << (int)el.m_msg.GetMessageId() << std::dec << "  " << candle_error_text(candle_dev_last_error(m_device)) << std::endl;
                 m_threadStatus = CANStatus::kDeviceWriteError;
                 m_statusErrCount++;
                 return false;
diff --git a/CANBridge/rev/Drivers/DriverDeviceThread.h b/CANBridge/rev/Drivers/DriverDeviceThread.h
@@ -37,6 +37,7 @@
 #include <map>
 #include <queue>
 #include <memory>
+#include <time.h>
 
 #include <iostream>
 
@@ -133,6 +134,14 @@ class DriverDeviceThread {
         details = &m_statusDetails;
     }
 
+    void GetCANStatusDetails(uint32_t* busOff, uint32_t* txFull, uint32_t* receiveErr, uint32_t* transmitErr, uint32_t* errorTime) {
+        *busOff = m_statusDetails.busOffCount;
+        *txFull = m_statusDetails.txFullCount;
+        *receiveErr = m_statusDetails.receiveErrCount;
+        *transmitErr = m_statusDetails.transmitErrCount;
+        *errorTime = lastErrorTime;
+    }
+
     CANStatus GetLastThreadError() {
         CANStatus last = m_threadStatus;
         m_threadStatus = CANStatus::kOk;
@@ -156,6 +165,7 @@ class DriverDeviceThread {
     uint32_t m_counter;
 
     CANStatusDetails m_statusDetails;
+    time_t lastErrorTime;
     int m_statusErrCount = 0;
     CANStatus m_threadStatus = CANStatus::kOk;
 
diff --git a/CANBridge/rev/Drivers/SerialPort/SerialDevice.h b/CANBridge/rev/Drivers/SerialPort/SerialDevice.h
@@ -58,6 +58,7 @@ class SerialDevice : public CANDevice {
     virtual CANStatus ReadStreamSession(uint32_t sessionHandle, HAL_CANStreamMessage* msgs, uint32_t messagesToRead, uint32_t* messagesRead) override;
 
     virtual CANStatus GetCANDetailStatus(float* percentBusUtilization, uint32_t* busOff, uint32_t* txFull, uint32_t* receiveErr, uint32_t* transmitErr) override;
+    virtual CANStatus GetCANDetailStatus(float* percentBusUtilization, uint32_t* busOff, uint32_t* txFull, uint32_t* receiveErr, uint32_t* transmitErr, uint32_t* lastErrorTime) override;
 
     virtual bool IsConnected() override;
 private:
diff --git a/CANBridge/static/CANBridge.lib b/CANBridge/static/CANBridge.lib
diff --git a/CANBridge/x86-64/CANBridge.lib b/CANBridge/x86-64/CANBridge.lib
diff --git a/dist/binding.d.ts b/dist/binding.d.ts
@@ -15,6 +15,7 @@ export interface CanDeviceStatus {
     receiveErr: number;
     transmitErr: number;
     percentBusUtilization: number;
+    lastErrorTime: number;
 }
 export declare enum ThreadPriority {
     Low = 0,
diff --git a/lib/binding.ts b/lib/binding.ts
@@ -20,6 +20,7 @@ export interface CanDeviceStatus {
     receiveErr: number;
     transmitErr: number;
     percentBusUtilization: number;
+    lastErrorTime: number;
 }
 
 export enum ThreadPriority {
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "node-can-bridge",
-    "version": "1.0.10",
+    "version": "1.0.11",
     "author": "REV Robotics",
     "description": "Get CAN Data",
     "license": "MIT",
diff --git a/src/canWrapper.cc b/src/canWrapper.cc
@@ -380,7 +380,7 @@ Napi::Number closeStreamSession(const Napi::CallbackInfo& info) {
 // Params:
 //   descriptor: String
 // Returns:
-//   status: Object{percentBusUtilization:Number, busOff:Number, txFull:Number, receiveErr:Number, transmitError:Number}
+//   status: Object{percentBusUtilization:Number, busOff:Number, txFull:Number, receiveErr:Number, transmitError:Number, lastErrorTime:Number}
 Napi::Object getCANDetailStatus(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     std::string descriptor = info[0].As<Napi::String>().Utf8Value();
@@ -397,14 +397,16 @@ Napi::Object getCANDetailStatus(const Napi::CallbackInfo& info) {
     uint32_t txFull;
     uint32_t receiveErr;
     uint32_t transmitErr;
-    deviceIterator->second->GetCANDetailStatus(&percentBusUtilization, &busOff, &txFull, &receiveErr, &transmitErr);
+    uint32_t lastErrorTime;
+    deviceIterator->second->GetCANDetailStatus(&percentBusUtilization, &busOff, &txFull, &receiveErr, &transmitErr, &lastErrorTime);
 
     Napi::Object status = Napi::Object::New(env);
     status.Set("percentBusUtilization", percentBusUtilization);
     status.Set("busOff", busOff);
     status.Set("txFull", txFull);
     status.Set("receiveErr", receiveErr);
     status.Set("transmitErr", transmitErr);
+    status.Set("lastErrorTime", lastErrorTime);
     return status;
 }
 
@@ -640,7 +642,7 @@ void setSparkMaxHeartbeatData(const Napi::CallbackInfo& info) {
         }
     }
     else {
-        _sendCANMessage(descriptor, 0x2052C80, heartbeat, 8, 1);
+        _sendCANMessage(descriptor, 0x2052C80, heartbeat, 8, 10);
         if (heartbeatsRunning.size() == 0) {
             heartbeatsRunning.push_back(descriptor);
             latestHeartbeatAck = std::chrono::system_clock::now();
diff --git a/test/test_binding.js b/test/test_binding.js
@@ -136,7 +136,8 @@ async function testSendHALMessage() {
     try {
         if (devices.length ===  0) return;
         // Send identify to SparkMax #1
-        const status = addon.sendHALMessage(0x2051D81, [], 0);
+        const status = addon.sendHALMessage(0x2051D81, [], 500);
+        await new Promise(resolve => {setTimeout(resolve, 2000)});
         console.log("Status:", status);
     } catch(error) {
         assert.fail(error);

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ export interface CanDeviceStatus {`
`15`	`15`	`receiveErr: number;`
`16`	`16`	`transmitErr: number;`
`17`	`17`	`percentBusUtilization: number;`
	`18`	`+ lastErrorTime: number;`
`18`	`19`	`}`
`19`	`20`	`export declare enum ThreadPriority {`
`20`	`21`	`Low = 0,`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ export interface CanDeviceStatus {`
`20`	`20`	`receiveErr: number;`
`21`	`21`	`transmitErr: number;`
`22`	`22`	`percentBusUtilization: number;`
	`23`	`+ lastErrorTime: number;`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`export enum ThreadPriority {`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "node-can-bridge",`
`3`		`- "version": "1.0.10",`
	`3`	`+ "version": "1.0.11",`
`4`	`4`	`"author": "REV Robotics",`
`5`	`5`	`"description": "Get CAN Data",`
`6`	`6`	`"license": "MIT",`