fix: correct PCAN timestamps (uptime-based backends)

connections/canconmanager.cpp

@@ -39,6 +39,11 @@ void CANConManager::resetTimeBasis()
 {
     mTimestampBasis = QDateTime::currentMSecsSinceEpoch() * 1000;
     mElapsedTimer.restart();
+    // Flush any frames already queued by connections — they carry timestamps
+    // computed against the old mElapsedTimer and would appear with incorrect
+    // (large) values after the reset if not discarded now.
+    foreach (CANConnection* conn_p, mConns)
+        conn_p->getQueue().flush();
 }
 
 CANConManager::~CANConManager()
@@ -134,6 +139,11 @@ uint64_t CANConManager::getTimeBasis()
     return mTimestampBasis;
 }
 
+uint64_t CANConManager::getElapsedUs()
+{
+    return static_cast<uint64_t>(mElapsedTimer.nsecsElapsed()) / 1000ULL;
+}
+
 QList<CANConnection*>& CANConManager::getConnections()
 {
     return mConns;

connections/canconmanager.h

@@ -25,6 +25,7 @@ class CANConManager : public QObject
     CANConnection* getByName(const QString& pName) const;
 
     uint64_t getTimeBasis();
+    uint64_t getElapsedUs(); // µs elapsed since last resetTimeBasis() — same reference as Tx timestamps
     void resetTimeBasis();
 
     int getNumBuses();

connections/serialbusconnection.cpp

@@ -151,6 +151,22 @@ void SerialBusConnection::disconnectDevice() {
     }
 }
 
+/* Immediately update status when the device state changes */
+void SerialBusConnection::deviceStateChanged(QCanBusDevice::CanBusDeviceState state)
+{
+    CANConStatus stats;
+    if (state == QCanBusDevice::ConnectedState) {
+        setStatus(CANCon::CONNECTED);
+        stats.conStatus = getStatus();
+        stats.numHardwareBuses = mNumBuses;
+        emit status(stats);
+    } else if (state == QCanBusDevice::UnconnectedState && getStatus() == CANCon::CONNECTED) {
+        setStatus(CANCon::NOT_CONNECTED);
+        stats.conStatus = getStatus();
+        stats.numHardwareBuses = mNumBuses;
+        emit status(stats);
+    }
+}
 
 void SerialBusConnection::errorReceived(QCanBusDevice::CanBusError error) const
 {
@@ -229,7 +245,22 @@ void SerialBusConnection::framesReceived()
                 if (useSystemTime) {
                     frame_p->setTimeStamp(CommFrame::TimeStamp::fromMicroSeconds(QDateTime::currentMSecsSinceEpoch() * 1000ul));
                 }
-                else frame_p->setTimeStamp(CommFrame::TimeStamp(0, (recFrame.timeStamp().seconds() * 1000000ul + recFrame.timeStamp().microSeconds()) - timeBasis));
+                else {
+                    uint64_t hwTimestamp = static_cast<uint64_t>(recFrame.timeStamp().seconds()) * 1000000ULL
+                                          + static_cast<uint64_t>(recFrame.timeStamp().microSeconds());
+                    uint64_t relTimestamp;
+                    if (hwTimestamp >= timeBasis) {
+                        // Epoch-based hw timestamp (e.g. SocketCAN): subtract session basis.
+                        relTimestamp = hwTimestamp - timeBasis;
+                    } else {
+                        // Uptime-based hw timestamp (e.g. PCAN): the hw clock cannot be
+                        // synchronised to the elapsed timer without a fixed anchor bias,
+                        // so use the elapsed timer directly — the same source as Tx timestamps.
+                        // This guarantees Tx and Rx share one consistent clock with no drift.
+                        relTimestamp = CANConManager::getInstance()->getElapsedUs();
+                    }
+                    frame_p->setTimeStamp(CommFrame::TimeStamp(0, relTimestamp));
+                }
 
                 checkTargettedFrame(*frame_p);