Merge branch 'improveDeviceControllerDiag' into pu/integration

src/ATBAPP/ATBDeviceControllerPlugin.cpp

@@ -663,8 +663,6 @@ void ATBDeviceControllerPlugin::onCBinAndAllDoorsClosed()
 {
     qCritical() << "ATBDeviceControllerPlugin::onCBinAndAllDoorsClosed()";
 
-    this->diag->diagReInit();
-
     QTimer::singleShot(2000, this, SIGNAL(requestModeIDLE()));
 
     this->dbus->finishedBackgroundTask("DOOR_OPEN");

src/ATBAPP/DeviceControllerDiag.cpp

@@ -45,6 +45,7 @@ void DeviceControllerDiag::init(hwinf *hw, DBusControllerInterface *dbus, QObjec
 void DeviceControllerDiag::diagReInit()
 {
     this->machineEventSet.clear();
+    this->previousMachineEventSet.clear();
     this->_isErrorState = false;
 }
 
@@ -95,8 +96,11 @@ bool DeviceControllerDiag::isOperatingState()
     return !this->_isErrorState;
 }
 
-QSet<DeviceController::State> DeviceControllerDiag::getCurrentMachineState()
+QSet<DCMachineEvent> DeviceControllerDiag::getCurrentMachineState()
 {
+    // ensure that currentMachineEventSet is delivered here
+    if (this->isRequestRunning) return this->previousMachineEventSet;
+
     return this->machineEventSet;
 }
 
@@ -107,9 +111,11 @@ void DeviceControllerDiag::private_startDiag()
     // check for DiagRequestTimeoutTimerTimeout:
     if (this->flagInterruptDiag) {
         qCritical() << "DeviceControllerDiag::private_startDiag() interrupted!";
-        this->private_setDiagEvent(DeviceController::State::E255);
+        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::E255);
-        this->isRequestRunning  = false;
+        if (!this->previousMachineEventSet.contains(E255Event)) {
-        this->flagInterruptDiag = false;
+            machineEventSet.insert(E255Event);
+            private_sendDiagEvent(E255Event, DeviceController::Action::SET);
+        }
         if (this->E255counter > 5) {
             this->restartCArun();
             // try it again, until success:
@@ -126,6 +132,9 @@ void DeviceControllerDiag::private_startDiag()
              * - diag is called again in ModeOOO wokeup()
              */
         }
+        this->diagRequestTimeoutTimer->stop();
+        this->isRequestRunning  = false;
+        this->flagInterruptDiag = false;
         return;
     }
 
@@ -134,6 +143,8 @@ void DeviceControllerDiag::private_startDiag()
 
     if (result) {
         qCritical() << "DeviceControllerDiag::private_startDiag() DCdata is valid";
+        this->machineEventSet.remove(DCMachineEvent(DeviceController::State::E255));
+        this->machineEventSet.remove(DCMachineEvent(DeviceController::State::W255));
         QTimer::singleShot(200, this, &DeviceControllerDiag::sys_superviseSystem);
     }
     else {
@@ -164,12 +175,18 @@ void DeviceControllerDiag::sys_superviseSystem()
     // check for DiagRequestTimeoutTimerTimeout:
     if (this->flagInterruptDiag) {
         qCritical() << "DeviceControllerDiag::sys_superviseSystem() interrupted!";
-        this->private_setDiagEvent(DeviceController::State::E255);
+        // send
-        this->flagInterruptDiag = false;
+        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::E255);
-        this->isRequestRunning  = false;
+        if (!this->previousMachineEventSet.contains(E255Event)) {
+            machineEventSet.insert(E255Event);
+            private_sendDiagEvent(E255Event, DeviceController::Action::SET);
+        }
         if (this->E255counter > 5) { this->restartCArun(); }
                               else { this->E255counter++; }
         QTimer::singleShot(400, this, &DeviceControllerDiag::diagRequest);
+        this->diagRequestTimeoutTimer->stop();
+        this->isRequestRunning  = false;
+        this->flagInterruptDiag = false;
         return;
     }
 
@@ -178,12 +195,17 @@ void DeviceControllerDiag::sys_superviseSystem()
         // es gibt keinerlei gültige Daten vom DC
         qCritical() << "DeviceControllerDiag::sys_superviseSystem() no valid data!";
         hw->dc_autoRequest(true);
-        this->private_setDiagEvent(DeviceController::State::M0254);
+
-        this->diagRequestTimeoutTimer->stop();
+        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::M0254);
-        this->isRequestRunning  = false;
+        previousMachineEventSet.insert(E255Event);
+        private_sendDiagEvent(E255Event, DeviceController::Action::SET);
+
         if (this->E255counter > 5) { this->restartCArun(); }
                               else { this->E255counter++; }
         QTimer::singleShot(400, this, &DeviceControllerDiag::diagRequest);
+        this->diagRequestTimeoutTimer->stop();
+        this->isRequestRunning  = false;
+        this->flagInterruptDiag = false;
         return;
     }
 
@@ -215,6 +237,8 @@ void DeviceControllerDiag::sys_superviseSystem()
 
 void DeviceControllerDiag::sub_componentAssessment()
 {
+    this->machineEventSet.clear();
+
     bool flag_sendOperate = true;
 
     struct T_moduleCondition modCond = {};
@@ -414,48 +438,62 @@ void DeviceControllerDiag::sub_componentAssessment()
         this->private_setDiagEvent(DeviceController::State::W004);
     }
 
-    if (flag_sendOperate) {
-        this->private_setDiagEvent(DeviceController::State::O000);
-    }
-
 
     // compare machineEventSets
     // New events: present in current but not previous
-    QSet<DeviceController::State> newEvents = this->machineEventSet - this->previousMachineEventSet;
+    QSet<DCMachineEvent> newEvents = this->machineEventSet - this->previousMachineEventSet;
 
     // Reset events: present in previous but not current
-    QSet<DeviceController::State> resetEvents = this->previousMachineEventSet - this->machineEventSet;
+    QSet<DCMachineEvent> resetEvents = this->previousMachineEventSet - this->machineEventSet;
 
-    // Triggering Actions
+    // DEBUG EventSets:
-    // Iterate through the results
+    qCritical() << "sub_componentAssessment():";
-    for (const DeviceController::State& event : newEvents) {
+    qCritical() << "    newEvents: " << newEvents.size();
-        private_sendDiagEvent(event, DeviceController::Action::SET);  // New event detected
+    qCritical() << "  resetEvents: " << resetEvents.size();
-    }
-
-    // Proposal: send reset
-    /*
-    for (const DeviceController::State& event : resetEvents) {
-        private_sendDiagEvent(event, DeviceController::Action::RESET);  // Event no longer present
-    }
-    */
-
-    // DEBUG 
-    // print all current states
     QStringList DeviceControllerStateStringList;
-    for (const DeviceController::State& event : this->machineEventSet) {
+    for (const DCMachineEvent& event : this->machineEventSet) {
-        DeviceControllerStateStringList.append(QMetaEnum::fromType<DeviceController::State>().valueToKey(event));
+        DeviceControllerStateStringList.append(QMetaEnum::fromType<DeviceController::State>().valueToKey(event.state));
     }
     qCritical() << "diagReq result: " << DeviceControllerStateStringList;
 
+    // Triggering Actions
+    // Iterate through the results
+    // send SET:
+    for (const DCMachineEvent& event : newEvents) {
+        private_sendDiagEvent(event, DeviceController::Action::SET);  // New event detected
+    }
+
+    // send RESET:
+    for (const DCMachineEvent& event : resetEvents) {
+        private_sendDiagEvent(event, DeviceController::Action::RESET);  // Event no longer present
+    }
+
+    // send Operate if there is no error
+    if (flag_sendOperate) {
+        // O000 must not be part of machineEventSet
+        DCMachineEvent O000DCMachineEvent = DCMachineEvent(DeviceController::State::O000);
+        this->private_sendDiagEvent(O000DCMachineEvent, DeviceController::Action::SET);
+    }
+
 
     // finish diag
+    this->private_finishDiag();
+}
 
+/**
+ * @brief DeviceControllerDiag::private_finishDiag
+ *
+ * Single point to finish a diag process:
+ *  -
+ */
+void DeviceControllerDiag::private_finishDiag()
+{
     this->diagRequestTimeoutTimer->stop();
     this->isRequestRunning  = false;
     this->flagInterruptDiag = false;
 
-    this->previousMachineEventSet = machineEventSet;
+    this->previousMachineEventSet.unite(machineEventSet);      // add new elements from machineEventSet
-    this->machineEventSet.clear();
+    this->previousMachineEventSet.intersect(machineEventSet);  // remove elements not in machineEventSet
 
     if (this->isDiagBackgroundTask) {
         this->isDiagBackgroundTask = false;
@@ -464,6 +502,7 @@ void DeviceControllerDiag::sub_componentAssessment()
 }
 
 
+
 /**
  * @brief DeviceControllerDiag::private_setDiagEvent
  * @param result - result value from 'sub_componentAssessment()',
@@ -482,18 +521,29 @@ void DeviceControllerDiag::private_setDiagEvent(DeviceController::State result)
         return;
     }
 
-    machineEventSet.insert(result);
+    DCMachineEvent newState = DCMachineEvent(result);
+
+    // DEBUG
+    qCritical() << "----> setDiagEvent: " << newState.state << " with id: " << newState.eventId;
+
+    machineEventSet.insert(newState);
 }
 
 
-void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result, DeviceController::Action action)
-{
-    QString eventId = QUuid::createUuid().toString(QUuid::WithoutBraces).mid(0, 8);
 
-    QString eventName = QMetaEnum::fromType<DeviceController::State>().valueToKey(result);;
+/**
+ * @brief DeviceControllerDiag::private_sendDiagEvent
+ * @param result   WXXX | EXXX | O000
+ * @param action   SET|RESET
+ */
+void DeviceControllerDiag::private_sendDiagEvent(DCMachineEvent result, DeviceController::Action action)
+{
+    QString eventId = result.eventId;
+
+    QString eventName = QMetaEnum::fromType<DeviceController::State>().valueToKey(result.state);
     EVENT_CLASS eventClass = EVENT_CLASS::STATE;
     QString parameter;
-    switch (result) {
+    switch (result.state) {
 
     case DeviceController::State::INITIAL_STATE:
         break;
@@ -602,7 +652,6 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result,
         parameter  = "no valid data from DeviceController";
         break;
     case DeviceController::State::O000:   // everything is fine
-        this->machineEventSet.clear();
         this->_isErrorState = false;
         eventClass = EVENT_CLASS::OPERATE;
         parameter  = "";
@@ -637,7 +686,7 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result,
         break;
     }
 
-    this->lastState = result;
+    this->lastState = result.state;
 
     /**
      * Variant: send 'parameter' as JSON:
@@ -671,6 +720,27 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result,
 void DeviceControllerDiag::restartCArun()
 {
     this->E255counter = 0;
-    this->private_setDiagEvent(DeviceController::State::W255);
+
+
+    DCMachineEvent W255Event = DCMachineEvent(DeviceController::State::W255);
+    if (!this->previousMachineEventSet.contains(W255Event)) {
+        machineEventSet.insert(W255Event);
+        private_sendDiagEvent(W255Event, DeviceController::Action::SET);
+    }
+
     QProcess::startDetached("/bin/systemctl", {"restart", "carun"});
 }
+
+
+
+
+/****************************************************************************************************
+ *
+ *                                 DCMachineEvent
+ */
+DCMachineEvent::DCMachineEvent(DeviceController::State state) : state(state)
+{
+    this->eventId = QUuid::createUuid().toString(QUuid::WithoutBraces).mid(0, 8);
+}
+
+

src/ATBAPP/DeviceControllerDiag.h

@@ -73,6 +73,30 @@ namespace DeviceController {
 }
 
 
+// ----------------------------- DCMachineEvent -----------------------------------------
+
+class DCMachineEvent {
+public:
+    DCMachineEvent() = default;
+    DCMachineEvent(DeviceController::State state);
+
+    DeviceController::State state;
+    QString eventId;
+
+    // Equality operator (required for QSet)
+    bool operator==(const DCMachineEvent& other) const {
+        return (state == other.state);
+    }
+};
+
+// Hash function (required for QSet)
+inline uint qHash(const DCMachineEvent& key, uint seed = 0) {
+    return qHash(static_cast<int>(key.state), seed);
+}
+
+
+// ------------------------ DeviceControllerDiag --------------------------------------
+
 class DeviceControllerDiag : public QObject
 {
     Q_OBJECT
@@ -90,7 +114,7 @@ public:
      */
     bool isErrorState();
     bool isOperatingState();
-    QSet<DeviceController::State> getCurrentMachineState();
+    QSet<DCMachineEvent> getCurrentMachineState();
 
     void setTimeout(int timeout);
 
@@ -132,8 +156,8 @@ private:
     int lastVoltage;
 
     DeviceController::State lastState;
-    QSet<DeviceController::State> machineEventSet;
+    QSet<DCMachineEvent> machineEventSet;
-    QSet<DeviceController::State> previousMachineEventSet;
+    QSet<DCMachineEvent> previousMachineEventSet;
     bool _isErrorState;
 
     PersistentData* pData;
@@ -145,7 +169,9 @@ private slots:
 
     void private_startDiag();                                    // diag entry method
     void private_setDiagEvent(DeviceController::State result);
-    void private_sendDiagEvent(DeviceController::State result, DeviceController::Action action);
+    void private_sendDiagEvent(DCMachineEvent result, DeviceController::Action action);
+
+    void private_finishDiag();
 
     void sys_superviseSystem();