Merge branch 'ImproveE255Handling' into pu/integration

- allways run through finishDiag() method
 - on finishing diag: only remove elements in previousMachineEventSet if
data is valid

DCPlugin.pro

@@ -30,7 +30,14 @@ contains( CONFIG, PTU5 ) {
     QMAKE_CXXFLAGS += -std=c++11
     linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
     CONFIG += link_pkgconfig
+    PTU5BASEPATH = /opt/devel/ptu5
     ARCH = PTU5
+
+    INCLUDEPATH += $$PTU5BASEPATH/qt/libs/deviceController/include/
+    LIBS += -L$$PTU5BASEPATH/qt/libs/deviceController/library
+
+    LIBS += -lCAslave
+    LIBS += -lCAmaster
 }
 
 contains( CONFIG, PTU5_YOCTO ) {
@@ -38,8 +45,8 @@ contains( CONFIG, PTU5_YOCTO ) {
     PTU5BASEPATH = /opt/devel/ptu5
     ARCH = PTU5
 
-    # add qmqtt lib
-    #LIBS += -lQt5Qmqtt
+    LIBS += -lCAslave
+    LIBS += -lCAmaster
 }
 
 TARGET   = ATBDeviceControllerPlugin
@@ -69,7 +76,6 @@ DEFINES += QT_DEPRECATED_WARNINGS
 
 # ATBAPP interface
 HEADERS += \
-    include/interfaces.h \
     src/ATBAPP/ATBAPPplugin.h \
     src/ATBAPP/DeviceControllerDiag.h \
     src/ATBAPP/DeviceControllerInterface.h \
@@ -77,9 +83,13 @@ HEADERS += \
     src/ATBAPP/ATBMachineEvent.h \
     src/ATBAPP/ATBDeviceControllerPlugin.h \
     src/ATBAPP/Utils.h \
+    src/ATBAPP/support/CashUtils.h \
     src/ATBAPP/support/DBusControllerInterface.h \
     src/ATBAPP/support/JSON.h \
-    src/ATBAPP/support/PTUSystem.h
+    src/ATBAPP/support/PTUSystem.h \
+    src/ATBAPP/support/PersistentData.h \
+    src/ATBAPP/support/Ticket.h \
+    src/ATBAPP/support/TicketUtils.h
 
 SOURCES += \
     src/ATBAPP/ATBHealthEvent.cpp \
@@ -87,9 +97,13 @@ SOURCES += \
     src/ATBAPP/ATBDeviceControllerPlugin.cpp \
     src/ATBAPP/DeviceControllerDiag.cpp \
     src/ATBAPP/Utils.cpp \
+    src/ATBAPP/support/CashUtils.cpp \
     src/ATBAPP/support/DBusControllerInterface.cpp \
     src/ATBAPP/support/JSON.cpp \
-    src/ATBAPP/support/PTUSystem.cpp
+    src/ATBAPP/support/PTUSystem.cpp \
+    src/ATBAPP/support/PersistentData.cpp \
+    src/ATBAPP/support/Ticket.cpp \
+    src/ATBAPP/support/TicketUtils.cpp
 
 DISTFILES += \
     generate-version.sh

include/interfaces.h

@@ -24,7 +24,8 @@ struct T_emp
 
    // dynamic:
    uint8_t state;      // step counter of EMP (electronic coin checker) FSM (finite state machine):
-       // 0=start command
+   /*
+   // 0=start command
        // 1=powered, do emp ini, send reset
        // 2=delay
        // 3=wait for response, requesting status after response
@@ -39,7 +40,7 @@ struct T_emp
        // 90: stop all, 1s delay
        // 99: off, all stopped
 
-
+*/
    uint8_t pollingRunning;
    uint8_t paymentRunning;
 
@@ -238,6 +239,7 @@ struct T_dynamicCondition
         uint8_t lastVDoorState;
         uint8_t lastCBstate;
         char        paymentInProgress;
+        // Version Szeged:  aug2023
         //	0: stopped by timeout
         //  1: running  2: wait4lastCoin
         //				3: payment stopped manually, coins in Escrow
@@ -246,6 +248,21 @@ struct T_dynamicCondition
         //			    6: coins encashed   7:coins returned
         //				8: CoinChecker or MDB on Error
 
+        // since Schoenau with bill and changer, nov2023
+        //0 = no payment
+        //will be set to 1 by cash_startCollection()
+        //neu 1: wait for devices getting ready for payment
+        //2 = payment,
+        //3 = wait for last coin/bill
+        //4 = Bezahlvorgang manuell beendet
+        //5 = payment stopped autom, amount collected, coins in Escrow
+        //6 = Bezahlvorgang beendet weil ZK voll
+        //4,5,6: payment done, keep on polling, wait for cash or return command
+        //7 = encash collected money from coin escrow into cash box
+        //8 = return "amountToReturn", can be complete inserted amount or only overpayment
+        //9 = wait for changer result
+        //10= print refund receipt with "amountToReturn"
+
 
         char        res1;
         uint16_t    U_Batt;
@@ -397,6 +414,7 @@ struct T_bna
 
 };
 
+class DownloadThread;
 class hwinf
 {
 
@@ -1834,6 +1852,9 @@ public:
     virtual uint8_t prn_getPrintResult() const {
        return 0;
     }
+    // return:  0: just printing, wait
+    //          1: OK - last print was succesful
+    //          2: error - not printed
 
 
 
@@ -2249,14 +2270,23 @@ public:
     virtual void bna_requestCurrentNotes() const {}
     // send command to DC in order to get transaction data
 
-    virtual uint8_t bna_getCurrentNotes(uint16_t latestBill, uint16_t *currentNotes) const {
+    virtual uint8_t bna_getCurrentNotes(uint16_t latestBill, uint16_t *currentNotes) const
+    {
         Q_UNUSED(latestBill);
         Q_UNUSED(currentNotes);
         return 0;
     }
     // returns number of collected bank notes since start-command (current transaction)
-    //  latestBill: last accepted bank note, value in cent
-    //  currentNotes an array with up to 16 (further) notes collected
+    // return value: numbers of bills or 99 in case of error
+    //  latestBill: not used
+    // in case of error: currentNotes[0,1,2,3] = 1..4 error number(s)
+    // in normal case:
+    //  currentNotes[0]: last bill in cent (e.g. 1000 = 10€)
+    //  currentNotes[1]: bin 1 = bill is still in escrow   else bill is stacked
+    //       note: by now (dec2023) escrow is not used, bills always go to stacker (box)
+    //  currentNotes[2]: total sum of bills in cent, low word (16bit)
+    //  currentNotes[3]: total sum of bills in cent, high word (16bit)
+
 
     virtual void bna_requestStackerLevel() const {}
 
@@ -2270,10 +2300,100 @@ public:
     //                                          countOfBills[1] for 10€   and so on
 
 
+    // download device controller
+    virtual bool dcDownloadRequest(QString const &fileToDownload) const {
+        Q_UNUSED(fileToDownload);
+        return false;
+    }
+    virtual bool dcDownloadRequested() const { return false; }
+    virtual bool dcDownloadResetRequest() const { return false; }
+    virtual bool dcDownloadRequestAck() const { return false; }
+    virtual bool dcDownloadRunning() const { return false; }
+    virtual bool dcDownloadFinished() { return false; }
+
+    virtual bool dcDownloadReportStart() const { return false; }
+    virtual bool dcDownloadReportRunning() const { return true; }
+    virtual bool dcDownloadReportFinished() { return true; }
+
+    virtual bool dcDownloadThreadStart() { return false; }
+    virtual bool dcDownloadThreadRunning() const { return true; }
+    virtual void dcDownloadThreadFinalize(DownloadThread *) {}
+    virtual bool dcDownloadThreadFinished() const { return true; }
+    virtual bool dcDownloadReportThreadStart() { return false; }
+    virtual bool dcDownloadReportThreadRunning() const { return true; }
+    virtual void dcDownloadReportThreadFinalize() {}
+    virtual void dcDownloadReportThreadQuit() {}
+    virtual bool dcDownloadReportThreadFinished() const { return true; }
+
+
+    virtual QString dcDownloadFileName() const { return ""; }
+    virtual bool dcDownloadSetRequested(bool requested) {
+       Q_UNUSED(requested); return false;
+    }
+    virtual bool dcDownloadSetRunning(bool running) {
+       Q_UNUSED(running); return false;
+    }
+    virtual bool dcDownloadSetFinished(bool finished) {
+       Q_UNUSED(finished); return false;
+    }
+    virtual void dcDownloadSetTotalBlockNumber(uint16_t totalBlockNumber) {
+       Q_UNUSED(totalBlockNumber);
+    }
+    virtual void dcDownloadSetCurrentBlockNumber(uint16_t currentBlockNumber) {
+       Q_UNUSED(currentBlockNumber);
+    }
+    virtual bool dcDownloadGetRequested() const { return false; }
+    virtual bool dcDownloadGetRunning() const { return false; }
+    virtual bool dcDownloadGetFinished() const { return false; }
+    virtual uint16_t dcDownloadGetTotalBlockNumber() const { return 0; }
+    virtual uint16_t dcDownloadGetCurrentBlockNumber() const { return 0; }
+
+    virtual QObject const *getAPI() { return nullptr; }
 
 
 signals:
+    /*
+        NOTE: the difference between a virtual Qt signal and a normal Qt signal:
+        A Qt virtual signal is a connection that is established using a pointer
+        or reference and is not connected to an object or data. It is therefore
+        not bound to a particular object, but to a specific class (object type).
+        Qt virtual signals are useful because they allow you to create
+        connections without worrying about whether an object or a specific data
+        element has been destroyed.
+        https://www.youtube.com/watch?v=HTH3VFfqsXw
+
+     */
+    virtual void hwapi_reportDCDownloadStatus(QString const&) const {}
+    virtual void hwapi_reportDCDownloadSuccess(QString const&) const {}
+    virtual void hwapi_reportDCDownloadFailure(QString const&) const {}
+
+    virtual void hwapi_templatePrintFinished_OK(void) const=0;
+    virtual void hwapi_templatePrintFinished_Err(void) const=0;
+
+    virtual void hwapi_coinCollectionJustStarted(void) const=0;
+    virtual void hwapi_coinCollectionAborted(void) const=0;
+
+    virtual void hwapi_gotNewCoin(void) const=0;
+    virtual void hwapi_payStopByMax(void) const=0;
+    virtual void hwapi_payStopByPushbutton(void) const=0;
+
+    virtual void hwapi_payStopByEscrow(void) const=0;
+    virtual void hwapi_payStopByError(void) const=0;
+    virtual void hwapi_payStopByTimeout(void) const=0;
+    virtual void hwapi_payCancelled(void) const=0;
+    virtual void hwapi_coinProcessJustStopped(void) const=0;
+
+    virtual void hwapi_doorServiceDoorOpened(void) const=0;
+    virtual void hwapi_doorVaultDoorOpened(void) const=0;
+    virtual void hwapi_doorCoinBoxRemoved(void) const=0;
+    virtual void hwapi_doorCoinBoxInserted(void) const=0;
+    virtual void hwapi_doorCBinAndAllDoorsClosed(void) const=0;
+    virtual void hwapi_doorAllDoorsClosed(void) const=0;
+
+    virtual void hwapi_coinAttached() const = 0;
+
     // NOTE: declaring a "pure virtual" "signal" should be an error and thus not valid.
+    /* GH Version, bringt Fehler
     void hwapi_templatePrintFinished_OK() const;
     void hwapi_templatePrintFinished_Err() const;
 
@@ -2296,6 +2416,7 @@ signals:
     void hwapi_doorCoinBoxInserted() const;
     void hwapi_doorCBinAndAllDoorsClosed() const;
     void hwapi_doorAllDoorsClosed() const;
+    */
 };
 
 

src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -2,16 +2,18 @@
 #define ATBDEVICECONTROLLERPLUGIN_H
 
 #include <QObject>
+#include <QLocale>
 
 #include "src/ATBAPP/DeviceControllerInterface.h"
 #include "src/ATBAPP/ATBAPPplugin.h"
 #include "src/ATBAPP/DeviceControllerDiag.h"
+#include "src/ATBAPP/support/Ticket.h"
 
 #include "version.h"
 
+#include "support/PersistentData.h"
 
-
-#include "interfaces.h"
+#include <DeviceController/interfaces.h>
 
 #include <unistd.h>
 
@@ -19,11 +21,21 @@
 class DBusControllerInterface;
 class QTextCodec;
 
-
 using namespace nsDeviceControllerInterface;
 
 class QSettings;
 
+enum class PROGRAM_MODE {
+    INIT,
+    IDLE,
+    SELL,
+    SERVICE,
+    OOO,
+    NOT_DEFINED
+};
+
+
+
 class ATBDeviceControllerPlugin :
         public DeviceControllerInterface
 {
@@ -42,12 +54,19 @@ public:
     // interface:
     PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings);
 
+    void sendDeviceParameter(const QJsonObject & jsonObject);
+
     // TASKS: Cash handling -------------------------------------------------------
     void requestStartCashInput(const QString & amount);
     void requestStopCashInput();
     void cashCollect();
+    void cashCollect(const QString & amount);
     void cashAbort();
 
+    // read coin/cash processing variants -----------------------------------------
+    nsDeviceControllerInterface::COIN_PROCESSOR coinProcessor();
+    nsDeviceControllerInterface::BILL_ACCEPTOR  billAcceptor();
+
     // TASKS: printing ------------------------------------------------------------
     void requestPrintTicket(const QHash<QString, QVariant> & printingData);
     void requestPrintTicket(nsDeviceControllerInterface::TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData);
@@ -89,10 +108,10 @@ private:
    QString errorDescription;
    QString pluginInfo;
 
-   QList<int> templateList;
-
    QString serialPortName;
 
+   PROGRAM_MODE currentProgramMode;
+
    bool useDebug;
 
    bool isMaster;
@@ -107,6 +126,10 @@ private:
 
    DeviceControllerDiag* diag;
 
+   PersistentData *persistentData;
+
+   uint32_t cashStartAmountInt;
+
 
    QTextCodec *codec;
 
@@ -119,9 +142,30 @@ private:
    // counts failed hw->log_chkIfVaultRecordAvailable()
    int accountCheckCounter;
 
+   // counts faild hw->prn-getPrintResult()
+   int printResultCheckCounter;
+
    // dbus
    int init_sc_dbus();
 
+   // printer privates ----------------------------------------------------------------------------
+   Ticket * currentTicket;
+   QLocale printerLocale;
+
+   QHash<TICKET_VARIANT, QList<quint8>> ticketTemplateList;
+
+   void initTicketTemplateList(const QSettings * settings);
+   void prepareDynTemplateData();
+
+   void private_setupDynTemplateData_DEFAULT(struct T_dynDat *dynTicketData, Ticket *ticket);
+   void private_setupDynTemplateData_FIXED_PRICE(struct T_dynDat *dynTicketData, Ticket *ticket);
+   void private_setupDynTemplateData_START_RECEIPT(struct T_dynDat *dynTicketData, Ticket *ticket);
+   void private_setupDynTemplatData_STOP_RECEIPT(struct T_dynDat *dynTicketData,   Ticket *ticket);
+   void private_setupDynTemplatData_FOOD_STAMP(struct T_dynDat *dynTicketData,     Ticket *ticket);
+   void private_setupDynTemplatData_FINE_PAYMENT(struct T_dynDat *dynTicketData,   Ticket *ticket);
+   void private_setupDynTemplatData_FREE_TICKET(struct T_dynDat *dynTicketData,   Ticket *ticket);
+   // ---------------------------------------------------------------------------------------------
+
 private slots:
    // printer
 
@@ -131,6 +175,8 @@ private slots:
    void onPrinterWaitForPrintingTicket();
    void onPrinterWaitForPrintingReceipt();
 
+   void onPrinterPrepareDynTemplateData();
+
    void onPrintFinishedOK();
    void onPrintFinishedERR();
 
@@ -138,9 +184,11 @@ private slots:
    void onCashGotCoin();
    void onCashPayStopedSuccess();
    void onCashPayStopByMax();
+   void onCashPayStopByPushbutton();
    void onCashPayStopByEscrow();
    void onCashPayStopByError();
    void onCashPayStopByTimeout();
+   void onCashChangerState();
 
    // doors and hardware contacts
    void onServiceDoorOpened();

src/ATBAPP/ATBMachineEvent.h

@@ -15,7 +15,7 @@ class ATBMachineEvent : public QEvent
 public:
     explicit ATBMachineEvent(const QString & id,
                 const QString & deviceName,              // PTU/PRINTER/DC/...
-                EVENT_CLASS eventClass,          // reason of event: Error/Warning/Alarm
+                EVENT_CLASS eventClass,                  // reason of event: Error/Warning/Alarm
                 const QString & name,                    // 'Event': "E001", "W003"
                 const int state,
                 const QString & parameter,

src/ATBAPP/DeviceControllerDiag.cpp

@@ -5,29 +5,55 @@
 #include <QUuid>
 #include <QDebug>
 
-DeviceControllerDiag::DeviceControllerDiag(QObject *parent)
+#include <QProcess>
+
+#include "support/JSON.h"
+#include "src/ATBAPP/support/DBusControllerInterface.h"
+
+
+DeviceControllerDiag::DeviceControllerDiag(PersistentData *pData, QObject *parent)
     : QObject(parent)
+    , coinProcessorType(nsDeviceControllerInterface::COIN_PROCESSOR::ESCROW)
+    , billAcceptor(nsDeviceControllerInterface::BILL_ACCEPTOR::NO)
     , eventReceiver(nullptr)
     , isRequestRunning(false)
     , flagInterruptDiag(false)
+    , isDiagBackgroundTask(false)
+    , lastState(DeviceController::State::INITIAL_STATE)
+    , _isErrorState(false)
+    , pData(pData)
+    , E255counter(0)
 {
     diagRequestTimeoutTimer = new QTimer(this);
-    diagRequestTimeoutTimer->setInterval(1000*20);  // 20s
+    diagRequestTimeoutTimer->setInterval(1000*45);
     diagRequestTimeoutTimer->setSingleShot(true);
     connect(diagRequestTimeoutTimer, &QTimer::timeout, this, &DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout);
 }
 
 
-void DeviceControllerDiag::init(hwinf *hw, QObject* eventReceiver)
+void DeviceControllerDiag::init(hwinf *hw, DBusControllerInterface *dbus, QObject* eventReceiver)
 {
     this->hw = hw;
     this->eventReceiver = eventReceiver;
+    this->dbus = dbus;
 
     // make a system check on startup:
     QTimer::singleShot(2000, this, &DeviceControllerDiag::diagRequest);
 }
 
 
+void DeviceControllerDiag::diagReInit()
+{
+    this->machineEventSet.clear();
+    this->previousMachineEventSet.clear();
+    this->_isErrorState = false;
+}
+
+void DeviceControllerDiag::setTimeout(int timeout)
+{
+    this->diagRequestTimeoutTimer->setInterval(1000 * timeout);
+}
+
 void DeviceControllerDiag::diagRequest()
 {
     qCritical() << "DeviceControllerDiag::diagRequest()";
@@ -40,6 +66,16 @@ void DeviceControllerDiag::diagRequest()
     this->diagRequestTimeoutTimer->start();
 
     this->private_startDiag();
+
+    // read dc-fw-version:
+    /* note: dc_getSWVersion() returns always 32 characters (QString)...
+     * if no version string could be read it will contain 32 null-characters:
+     * "\u0000\u0000..."
+     */
+    QString dc_fw_version = hw->dc_getSWversion().remove(QChar('\0'));
+    qCritical() << "ATBDeviceControllerPlugin: DC firmware version: " << dc_fw_version;
+    this->pData->setDCFirmwareVersion(dc_fw_version);
+    this->pData->serializeToFile();
 }
 
 
@@ -49,12 +85,56 @@ void DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout()
     this->flagInterruptDiag = true;
 }
 
+
+bool DeviceControllerDiag::isErrorState()
+{
+    return this->_isErrorState;
+}
+
+bool DeviceControllerDiag::isOperatingState()
+{
+    return !this->_isErrorState;
+}
+
+QSet<DCMachineEvent> DeviceControllerDiag::getCurrentMachineState()
+{
+    // ensure that currentMachineEventSet is delivered here
+    if (this->isRequestRunning) return this->previousMachineEventSet;
+
+    return this->machineEventSet;
+}
+
+
+
 void DeviceControllerDiag::private_startDiag()
 {
     // check for DiagRequestTimeoutTimerTimeout:
     if (this->flagInterruptDiag) {
         qCritical() << "DeviceControllerDiag::private_startDiag() interrupted!";
-        this->private_sendDiagEvent(DeviceController::State::E255);
+        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::E255);
+        if (!this->previousMachineEventSet.contains(E255Event)) {
+            this->private_setDiagEvent(DeviceController::State::E255);
+            this->private_sendDiagEvent(E255Event, DeviceController::Action::SET);
+        }
+        if (this->E255counter > 5) {
+            this->restartCArun();
+            // try it again, until success:
+            QTimer::singleShot(1000, this, &DeviceControllerDiag::diagRequest);
+        }
+        else {
+            this->E255counter++;
+
+            // try it again, until success:
+            QTimer::singleShot(400, this, &DeviceControllerDiag::diagRequest);
+            /**
+             * But please note:
+             * - diag does currently not stop suspend (start a background task)
+             * - diag is called again in ModeOOO wokeup()
+             */
+        }
+
+        this->private_finishDiag(false);
+
         return;
     }
 
@@ -63,11 +143,20 @@ 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::M0255));
         QTimer::singleShot(200, this, &DeviceControllerDiag::sys_superviseSystem);
     }
     else {
         qCritical() << "DeviceControllerDiag::private_startDiag() DCdata is +++not+++ valid";
 
+        hw->dc_autoRequest(true);
+
+        if (! this->isDiagBackgroundTask) {
+            this->isDiagBackgroundTask = true;
+            this->dbus->startBackgroundTask("E255");
+        }
+
         // try it again
         QTimer::singleShot(200, this, &DeviceControllerDiag::private_startDiag);
     }
@@ -76,8 +165,8 @@ void DeviceControllerDiag::private_startDiag()
 void DeviceControllerDiag::sys_superviseSystem()
 {    // this function proofs if vending is possible depending of doors state
 
-    struct T_dynamicCondition dynMaCond;
-    struct T_moduleCondition  modCond;
+    struct T_dynamicCondition dynMaCond = {};
+    struct T_moduleCondition  modCond = {};
 
 
     qCritical() << "      sys_superviseSystem()";
@@ -86,7 +175,19 @@ void DeviceControllerDiag::sys_superviseSystem()
     // check for DiagRequestTimeoutTimerTimeout:
     if (this->flagInterruptDiag) {
         qCritical() << "DeviceControllerDiag::sys_superviseSystem() interrupted!";
-        this->private_sendDiagEvent(DeviceController::State::E255);
+        // send
+        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::E255);
+        if (!this->previousMachineEventSet.contains(E255Event)) {
+            this->private_setDiagEvent(DeviceController::State::E255);
+            this->private_sendDiagEvent(E255Event, DeviceController::Action::SET);
+        }
+        if (this->E255counter > 5) { this->restartCArun(); }
+                              else { this->E255counter++; }
+
+        QTimer::singleShot(400, this, &DeviceControllerDiag::diagRequest);
+
+        this->private_finishDiag(false);
+
         return;
     }
 
@@ -94,7 +195,16 @@ void DeviceControllerDiag::sys_superviseSystem()
     {
         // es gibt keinerlei gültige Daten vom DC
         qCritical() << "DeviceControllerDiag::sys_superviseSystem() no valid data!";
-        this->private_sendDiagEvent(DeviceController::State::E254);
+        hw->dc_autoRequest(true);
+
+        DCMachineEvent M0254Event = DCMachineEvent(DeviceController::State::M0254);
+        this->private_setDiagEvent(DeviceController::State::M0254);
+        this->private_sendDiagEvent(M0254Event, DeviceController::Action::SET);
+
+        if (this->E255counter > 5) { this->restartCArun(); }
+                              else { this->E255counter++; }
+        QTimer::singleShot(400, this, &DeviceControllerDiag::diagRequest);
+        this->private_finishDiag(false);
         return;
     }
 
@@ -107,7 +217,7 @@ void DeviceControllerDiag::sys_superviseSystem()
     {
         // noch keine Testergebnisse
         if (dynMaCond.startupTestIsRunning) {
-            // TODO?
+            qCritical() << "            startupTestIsRunning --> call again";
         }
 
 
@@ -117,18 +227,6 @@ void DeviceControllerDiag::sys_superviseSystem()
         return;
     }
 
-    // all doors: 99: undefined  0:closed  1:open
-    if (dynMaCond.lowerDoor || dynMaCond.upperDoor) {
-        // Service or battery door is open, goto INTRUSION MODE
-        qCritical() << "DeviceControllerDiag::sys_superviseSystem() Service or battery door is open, goto INTRUSION MODE";
-        this->private_sendDiagEvent(DeviceController::State::E253);
-    }
-    if (dynMaCond.middleDoor) {
-        // vault door is open, goto INTRUSION MODE
-        qCritical() << "DeviceControllerDiag::sys_superviseSystem() vault door is open, goto INTRUSION MODE";
-        this->private_sendDiagEvent(DeviceController::State::E252);
-    }
-
     qCritical() << "      --> call  sub_componentAssessment()";
 
     sub_componentAssessment();
@@ -138,15 +236,17 @@ void DeviceControllerDiag::sys_superviseSystem()
 
 void DeviceControllerDiag::sub_componentAssessment()
 {
+    this->machineEventSet.clear();
+
     bool flag_sendOperate = true;
 
-    struct T_moduleCondition modCond;
+    struct T_moduleCondition modCond = {};
     hw->sys_getDeviceConditions(&modCond);
 
-    struct T_dynamicCondition dynMaCond;
+    struct T_dynamicCondition dynMaCond = {};
     hw->sys_getDynMachineConditions(&dynMaCond);
 
-    struct T_devices devPara;
+    struct T_devices devPara = {};
     hw->sys_restoreDeviceParameter(&devPara);
 
     // store some interesting results:
@@ -159,35 +259,50 @@ void DeviceControllerDiag::sub_componentAssessment()
 
     if (dynMaCond.onAlarm>0) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::A000);
+        this->private_setDiagEvent(DeviceController::State::A000);
+    }
+
+    // check for open doors
+    // all doors: 99: undefined  0:closed  1:open
+    if (dynMaCond.lowerDoor || dynMaCond.upperDoor) {
+        // Service or battery door is open
+        flag_sendOperate = false;
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() Service or battery door is open, goto INTRUSION MODE";
+        this->private_setDiagEvent(DeviceController::State::M0253);
+    }
+    if (dynMaCond.middleDoor) {
+        // vault door is open
+        flag_sendOperate = false;
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() vault door is open, goto INTRUSION MODE";
+        this->private_setDiagEvent(DeviceController::State::M0252);
     }
 
     // check for invalid states:
 
     if (modCond.rtc>=200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E002);
+        this->private_setDiagEvent(DeviceController::State::E002);
     }
     if (modCond.printer==200 || modCond.printer==201) {   // 200: not connected  201: printer-HW-error  202: no paper
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E020);
+        this->private_setDiagEvent(DeviceController::State::E020);
     }
     if (modCond.printer==202) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E018);
+        this->private_setDiagEvent(DeviceController::State::E018);
     }
 
     if (modCond.coinBlocker>=200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E025);
+        this->private_setDiagEvent(DeviceController::State::E025);
     }
     if (modCond.mdbBus>=200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E034);
+        this->private_setDiagEvent(DeviceController::State::E034);
     }
     if (modCond.intEe>=200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E011);
+        this->private_setDiagEvent(DeviceController::State::E011);
     }
 
     // 2023-07-26: workaround for 00281/Szeged --------------------------------------------------------------
@@ -197,32 +312,47 @@ void DeviceControllerDiag::sub_componentAssessment()
     if (devPara.kindOfCoinChecker > 0) {
         if (modCond.coinSafe==201) { // full
             flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E007);
+            this->private_setDiagEvent(DeviceController::State::E007);
         }
         if (modCond.coinSafe==200)  {         // 200: kasse fehlt 201: voll  100:fast voll  1:ok
             flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E009);
+            this->private_setDiagEvent(DeviceController::State::E009);
         }
         if (modCond.coinEscrow>=200) {
             flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E010);
+            // coinEscrow>200 is considered a warning:
+            this->private_setDiagEvent(DeviceController::State::W010);
         }
     }
     // -----------------------------------------------------------------------------------------------
 
+    switch (devPara.kindOfCoinChecker) {
+        case 0:
+            this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::NONE;
+            break;
+        case 1:
+        case 2:
+            this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::ESCROW;
+            break;
+        case 3:
+            this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::CHANGER;
+            break;
+    }
+
     if (devPara.kindOfCoinChecker==1 || devPara.kindOfCoinChecker==2)  // 0: without  1=EMP820   2=EMP900    3=currenza c²	(MW)
     {
         if (modCond.coinEscrow>=200) {
             flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E010);
+            // coinEscrow>200 is considered a warning:
+            this->private_setDiagEvent(DeviceController::State::W010);
         }
         if (modCond.coinSafe==201)  { // full
             flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E007);
+            this->private_setDiagEvent(DeviceController::State::E007);
         }
         if (modCond.coinSafe==200) {          // 200: kasse fehlt 201: voll  100:fast voll  1:ok
             flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E009);
+            this->private_setDiagEvent(DeviceController::State::E009);
         }
     } else
     if (devPara.kindOfCoinChecker==3)
@@ -230,18 +360,27 @@ void DeviceControllerDiag::sub_componentAssessment()
         if (modCond.changer>=200) {
             // Fehler Münzver.
             flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E026);
+            this->private_setDiagEvent(DeviceController::State::E026);
         }
         if (modCond.coinSafe==201) { // full
             flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E007);
+            this->private_setDiagEvent(DeviceController::State::E007);
         }
         if (modCond.coinSafe == 200)  {          // 200: kasse fehlt 201: voll  100:fast voll  1:ok
             flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E009);
+            this->private_setDiagEvent(DeviceController::State::E009);
         }
     }
 
+    switch (devPara.BillAcceptor) {
+        case 0:
+            this->billAcceptor = nsDeviceControllerInterface::BILL_ACCEPTOR::NO;
+            break;
+        default:
+            this->billAcceptor = nsDeviceControllerInterface::BILL_ACCEPTOR::YES;
+            break;
+    }
+
     /*
     if ( modCond.billReader>=200 && devPara.BillAcceptor>0)
     {
@@ -258,61 +397,119 @@ void DeviceControllerDiag::sub_componentAssessment()
 
     if (dynMaCond.modeAbrech>0) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E011);
+        this->private_setDiagEvent(DeviceController::State::E011);
     }
 
     if (dynMaCond.nowCardTest>0) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E072);
+        this->private_setDiagEvent(DeviceController::State::M0072);
     }
 
     if (dynMaCond.startupTestIsRunning>0) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E073);
+        this->private_setDiagEvent(DeviceController::State::M0073);
     }
 
     if (modCond.voltage>=200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E003);
+        this->private_setDiagEvent(DeviceController::State::E003);
     }
     if (modCond.temper>=200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E004);
+        this->private_setDiagEvent(DeviceController::State::W004);
     }
 
     // check for warnings
     if (modCond.printer>=100 && modCond.printer<200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::W001);
+        this->private_setDiagEvent(DeviceController::State::W001);
     }
     if (modCond.coinSafe>=100 && modCond.coinSafe<200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::W002);
+        this->private_setDiagEvent(DeviceController::State::W002);
     }
     if (modCond.voltage>=100 && modCond.voltage<200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::W003);
+        this->private_setDiagEvent(DeviceController::State::W003);
     }
     if (modCond.temper>=100 && modCond.temper<200) {
         flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::W004);
+        this->private_setDiagEvent(DeviceController::State::W004);
     }
 
+
+    // compare machineEventSets
+    // New events: present in current but not previous
+    QSet<DCMachineEvent> newEvents = this->machineEventSet - this->previousMachineEventSet;
+
+    // Reset events: present in previous but not current
+    QSet<DCMachineEvent> resetEvents = this->previousMachineEventSet - this->machineEventSet;
+
+    // DEBUG EventSets:
+    qCritical() << "sub_componentAssessment():";
+    qCritical() << "    newEvents: " << newEvents.size();
+    qCritical() << "  resetEvents: " << resetEvents.size();
+    QStringList DeviceControllerStateStringList;
+    for (const DCMachineEvent& event : this->machineEventSet) {
+        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) {
-        this->private_sendDiagEvent(DeviceController::State::O000);
+        // 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(true);
+}
 
+/**
+ * @brief DeviceControllerDiag::private_finishDiag
+ *
+ * Single point to finish a diag process:
+ *  -
+ */
+void DeviceControllerDiag::private_finishDiag(bool dataValid)
+{
     this->diagRequestTimeoutTimer->stop();
     this->isRequestRunning  = false;
     this->flagInterruptDiag = false;
+
+    // add new elements from machineEventSet
+    this->previousMachineEventSet.unite(machineEventSet);
+
+    if (dataValid) {
+        // remove elements not in machineEventSet
+        // ... only if data is valid
+        this->previousMachineEventSet.intersect(machineEventSet);
+    }
+
+    if (this->isDiagBackgroundTask) {
+        this->isDiagBackgroundTask = false;
+        this->dbus->finishedBackgroundTask("E255");
+    }
 }
 
 
+
 /**
- * @brief DeviceControllerDiag::private_sendDiagEvent
+ * @brief DeviceControllerDiag::private_setDiagEvent
  * @param result - result value from 'sub_componentAssessment()',
  *               - 0x00 everything is fine
  *               - 0xFF on timer interrupt
@@ -320,126 +517,156 @@ void DeviceControllerDiag::sub_componentAssessment()
  *               - 0xFD Service or battery door is open
  *               - 0xFE vault door is open
  */
-void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
+void DeviceControllerDiag::private_setDiagEvent(DeviceController::State result)
 {
-    qCritical() << "DeviceControllerDiag::private_sendDiagEvent() result: " << result;
-
+    qCritical() << "DeviceControllerDiag::private_setDiagEvent() result: " << result;
 
     if (this->eventReceiver == nullptr) {
         qCritical() << "DeviceControllerDiag: no eventReceiver";
         return;
     }
 
-    if (machineEventSet.contains(result)) {
-        // do not send already sent events
-        qCritical() << "       ... is in machineEventList";
-        return;
-    }
-    else {
-        machineEventSet.insert(result);
-    }
+    DCMachineEvent newState = DCMachineEvent(result);
+
+    // DEBUG
+    qCritical() << "----> setDiagEvent: " << newState.state << " with id: " << newState.eventId;
+
+    machineEventSet.insert(newState);
+}
 
 
-    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;
     case DeviceController::State::A000:   // alarm / intrusion
         eventClass = EVENT_CLASS::ALARM;
         parameter  = "alarm / intrusion";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E002:    // real time clock error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "real time clock error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E003:   // voltage error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "voltage error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E004:   // temperature error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "temperature error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E007:    // coin safe full
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "coin safe full";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E008:    // bill acceptor full
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "bill acceptor full";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E009:    // no cash box
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "no cash box";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E010:    // coin escrow
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "coin escrow";
+        this->_isErrorState = true;
+        break;
+    case DeviceController::State::W010:    // coin escrow
+        eventClass = EVENT_CLASS::WARNING;
+        parameter  = "coin escrow";
         break;
     case DeviceController::State::E011:    // mem error int.ee.
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "mem error int.ee.";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E018:    // no paper
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "no paper";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E020:    // printer error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "printer error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E025:    // coin blocker
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "coin blocker";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E026:    // error coin validator
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "error coin validator";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E034:    // mdb error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "mdb error";
+        this->_isErrorState = true;
         break;
 
-    case DeviceController::State::E071:   // cash box change is ongoing
+    case DeviceController::State::M0071:   // cash box change is ongoing
         eventClass = EVENT_CLASS::STATE;
         parameter  = "cash box change is ongoing";
         break;
-    case DeviceController::State::E072:   // card test running
+    case DeviceController::State::M0072:   // card test running
         eventClass = EVENT_CLASS::STATE;
         parameter  = "card test running";
         break;
-    case DeviceController::State::E073:   // startup-test is running
+    case DeviceController::State::M0073:   // startup-test is running
         eventClass = EVENT_CLASS::STATE;
         parameter  = "startup-test is running";
         break;
 
-    case DeviceController::State::E252:   // cash box door open
+    case DeviceController::State::M0252:   // cash box door open
         eventClass = EVENT_CLASS::STATE;
         parameter  = "cash box door open";
         break;
-    case DeviceController::State::E253:   // service or battery door open
+    case DeviceController::State::M0253:   // service or battery door open
         eventClass = EVENT_CLASS::STATE;
         parameter  = "service or battery door open";
         break;
-    case DeviceController::State::E254:   // no valid data from DeviceController
+    case DeviceController::State::M0254:   // no valid data from DeviceController
         eventClass = EVENT_CLASS::STATE;
         parameter  = "no valid data from DeviceController";
         break;
     case DeviceController::State::E255:   // no valid data from DeviceController
-        eventClass = EVENT_CLASS::STATE;
-        parameter  = "";
-        qCritical() << "                ... ignore " << QMetaEnum::fromType<DeviceController::State>().valueToKey(result);
-        return;
+        eventClass = EVENT_CLASS::ERROR;
+        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  = "";
-        qCritical() << "                ... everything fine";
+        if (this->lastState == DeviceController::State::O000) {
+            qCritical() << "   ... everything fine, no state change -> skip sending";
+            return;
+        }
+        else {
+            qCritical() << "   ... everything fine";
+        }
         break;
 
     case DeviceController::State::W001:   // paper low
@@ -458,23 +685,67 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
         eventClass = EVENT_CLASS::WARNING;
         parameter  = "temperatur warning";
         break;
+    case DeviceController::State::M0255:   // restart carun
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "restart carun";
+        break;
     }
 
+    this->lastState = result.state;
+
+    /**
+     * Variant: send 'parameter' as JSON:
+     *
+        JSON::setPrettySerialize(false);
+        JSON::JsonObject json = JSON::objectBuilder()
+                  ->set("description", parameter)
+            ->create();
+        QString parameterJsonString = JSON::serialize(json);
+    */
 
     ATBMachineEvent *machineEvent = new ATBMachineEvent(
                 eventId,
                 "DC",
                 eventClass,
                 eventName,
-                1,
+                action,         // eventState
                 parameter,
                 ""         // second level info
                 );
 
-    //emit diagResponse(machineEvent);
-
     QCoreApplication::postEvent(eventReceiver, machineEvent);
 
 }
 
 
+
+/**
+ * reset / restart / reinit deviceController
+ */
+void DeviceControllerDiag::restartCArun()
+{
+    this->E255counter = 0;
+
+
+    DCMachineEvent M0255Event = DCMachineEvent(DeviceController::State::M0255);
+    if (!this->previousMachineEventSet.contains(M0255Event)) {
+        machineEventSet.insert(M0255Event);
+        private_sendDiagEvent(M0255Event, 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

@@ -5,8 +5,14 @@
 #include <QSet>
 #include <QTimer>
 
+#include <DeviceController/interfaces.h>
+
+#include "DeviceControllerInterface.h"
 #include "ATBMachineEvent.h"
-#include "interfaces.h"
+
+#include "support/PersistentData.h"
+
+class DBusControllerInterface;
 
 namespace DeviceController {
     Q_NAMESPACE
@@ -24,6 +30,7 @@ namespace DeviceController {
         E008,
         E009,
         E010,
+        W010,   // Coin Escrow
         E011,
 
         E018,
@@ -35,36 +42,98 @@ namespace DeviceController {
 
         E034,
 
-        E071,
-        E072,
-        E073,
+        M0071, // cashbox change is ongoing
+        M0072, // cardtest is running
+        M0073, // startup-test is running
+
+        M0252, // cashbox door open
+        M0253, // service or battery door is open
+        M0254, // no valid data from DC
+        M0255, // restart carun
 
-        E252,
-        E253,
-        E254,
         E255,
 
         W001,
         W002,
         W003,
-        W004
+        W004,
+
+        INITIAL_STATE
     };
     Q_ENUM_NS(State)
+
+
+    enum Action {
+        SET   = 1,
+        RESET = 0
+    };
+    Q_ENUM_NS(Action)
+
 }
 
 
+// ----------------------------- 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
 
 public:
-    DeviceControllerDiag(QObject *parent = nullptr);
+    DeviceControllerDiag(PersistentData *pData, QObject *parent = nullptr);
 
-    void init(hwinf* hw, QObject* eventReceiver);
+    void init(hwinf* hw, DBusControllerInterface *dbus, QObject* eventReceiver);
+
+    nsDeviceControllerInterface::COIN_PROCESSOR coinProcessorType;
+    nsDeviceControllerInterface::BILL_ACCEPTOR  billAcceptor;
+
+    /**
+     * return true, if machineEventSet contains an error
+     */
+    bool isErrorState();
+    bool isOperatingState();
+    QSet<DCMachineEvent> getCurrentMachineState();
+
+    void setTimeout(int timeout);
 
 public slots:
+    /**
+     * start diag request
+     */
     void diagRequest();
 
+    /**
+     * reset / re-init diag request.
+     * Called e.g. when doors are closed.
+     */
+    void diagReInit();
+
+    /**
+     * reset / restart / reinit deviceController
+     */
+    void restartCArun();
+
 signals:
     void diagResponse(ATBMachineEvent* machineEvent);
 
@@ -73,9 +142,11 @@ signals:
 private:
     QObject *eventReceiver;
     hwinf* hw;
+    DBusControllerInterface* dbus;
 
     bool isRequestRunning;
     bool flagInterruptDiag;
+    bool isDiagBackgroundTask;
 
     QTimer *diagRequestTimeoutTimer;
 
@@ -83,17 +154,26 @@ private:
 
     int lastVoltage;
 
-    QSet<DeviceController::State> machineEventSet;
+    DeviceController::State lastState;
+    QSet<DCMachineEvent> machineEventSet;
+    QSet<DCMachineEvent> previousMachineEventSet;
+    bool _isErrorState;
+
+    PersistentData* pData;
+
+    int E255counter;
 
 private slots:
     void onDiagRequestTimeoutTimerTimeout();
 
     void private_startDiag();                                    // diag entry method
-    void private_sendDiagEvent(DeviceController::State result);
+    void private_setDiagEvent(DeviceController::State result);
+    void private_sendDiagEvent(DCMachineEvent result, DeviceController::Action action);
+
+    void private_finishDiag(bool dataValid = false);
 
     void sys_superviseSystem();
 
-
 };
 
 #endif // DEVICECONTROLLERDIAG_H

src/ATBAPP/DeviceControllerInterface.h

@@ -5,6 +5,8 @@
 
 #include <QSettings>
 #include <QString>
+#include <QJsonObject>
+#include <QtCore/QHash>
 
 #include "ATBAPPplugin.h"
 
@@ -13,6 +15,11 @@ namespace nsDeviceControllerInterface {
     enum class RESULT_STATE : quint8;
     enum class CASH_STATE   : quint8;
     enum class TICKET_VARIANT : quint8;
+    enum class COIN_PROCESSOR : quint8;
+    enum class BILL_ACCEPTOR  : quint8;
+
+
+    enum class SERVICE_TEXT  : quint16;
 }
 
 
@@ -34,6 +41,12 @@ public:
     virtual nsDeviceControllerInterface::PLUGIN_STATE initDCPlugin(QObject *eventReceiver,
                                                                    const QSettings & settings) = 0;
 
+    /**
+     * e.g. send location
+     */
+    virtual void sendDeviceParameter(const QJsonObject & jsonObject) = 0;
+
+
     // TASKS: Cash handling -------------------------------------------------------
     /**
      * enables coin input
@@ -48,9 +61,10 @@ public:
     virtual void requestStopCashInput() = 0;
 
     /**
-     * called e.g. on Button "NEXT" in pay-up (direct coin input)
+     * called e.g. after printing
      */
     virtual void cashCollect() = 0;
+    virtual void cashCollect(const QString & amount) = 0;
     virtual void cashAbort() = 0;
 
     // TASKS: Account -------------------------------------------------------------
@@ -64,6 +78,10 @@ public:
     virtual void requestPrintReceipt(const QHash<QString, QVariant> & printingData) = 0;
     virtual void requestPrintReceipt(const QString & printingString) = 0;
 
+    // read coin/cash processing variants
+    virtual nsDeviceControllerInterface::COIN_PROCESSOR coinProcessor() = 0;
+    virtual nsDeviceControllerInterface::BILL_ACCEPTOR  billAcceptor() = 0;
+
     // mandantory ATBAPP plugin methods:
     virtual nsDeviceControllerInterface::PLUGIN_STATE getState() = 0;
     virtual const QString & getLastError() = 0;
@@ -95,6 +113,9 @@ signals:
                                      const QString & errorCode,
                                      const QString & errorDescription);
 
+
+    void coinAttached();
+
     /**
      * emitted on e.g. a coin input
      */
@@ -113,16 +134,46 @@ signals:
      */
     void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
                                      const QString & newCashValue,
-                                     /*  additional variables? */
+                                     const QString & coinValue,
+                                     const QString & noteValue,
+                                     const QString & changeValue,
                                      const QString & errorCode,
                                      const QString & errorDescription);
 
+    /**
+     * emitted if cashPayment has been finished, e.g. in result to task cashCollect():
+     * if coins in changer must be given back to user.
+     */
+    void cashPaymentChanging(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & changeValue,        // amount changed by changer/escrow
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+    /**
+     * emitted if cashPayment has been finished, e.g. in result to task cashCollect():
+     *  -> ticket should be printed sucessfully
+     *  -> coins in excrow or changer are given back to user
+     * Provides data for logging, especially changed value
+     */
+    void cashPaymentFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & newCashValue,  // total inserted amount
+                                     const QString & coinValue,     // inserted amount, paid with coins
+                                     const QString & noteValue,     // inserted amount, paid with notes
+                                     const QString & changeValue,   // amount changed by changer/escrow
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+
+
 
     /**
      * emitted e.g. if service door is opened
      */
     void requestModeSERVICE();
 
+    /**
+     * emitted e.g. if vault door is opened
+     */
+    void requestModeACCOUNT();
+
     /**
      * emitted e.g. if doors are closed
      */
@@ -139,7 +190,10 @@ signals:
     void requestAccountResponse(const QHash<QString, QVariant> & accountData);
 
 
-
+    /**
+     * show text messages in service mode
+     */
+    void showServiceText(nsDeviceControllerInterface::SERVICE_TEXT serviceText, const QString & text);
 
 
     /**
@@ -159,10 +213,11 @@ signals:
 
 
 Q_DECLARE_INTERFACE(DeviceControllerInterface,
-                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.0")
+                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.2.1")
 
 
 namespace nsDeviceControllerInterface {
+    Q_NAMESPACE
 
     enum class PLUGIN_STATE : quint8 {
         NOT_INITIALIZED = 0,
@@ -187,13 +242,64 @@ namespace nsDeviceControllerInterface {
 
 
     enum class TICKET_VARIANT : quint8 {
+        INVALID,
+        NO_TICKET,
         PARKING_TICKET,
+        PARKING_TICKET_CAR,
+        PARKING_TICKET_VAN,
+        PARKING_TICKET_CAMPER,
+        DAY_TICKET,
+        DAY_TICKET_ADULT,
+        DAY_TICKET_TEEN,
+        DAY_TICKET_CHILD,
+        DAY_TICKET_CAR,
+        DAY_TICKET_VAN,
+        DAY_TICKET_CAMPER,
         RECEIPT,
         ERROR_RECEIPT,
         START_RECEIPT,   // e.g. Szeged Start
         STOP_RECEIPT,    // e.g. Szeged Stop
+        FINE_PAYMENT,    // e.g. Klaipeda
+        FOOD_STAMP,
+        FIXED_PRICE_1,
+        FIXED_PRICE_2,
+        FIXED_PRICE_3,
+        FIXED_PRICE_4,
+        FIXED_PRICE_5,
+        FIXED_PRICE_6,
+        FIXED_PRICE_7,
+        FIXED_PRICE_8,
+        FIXED_PRICE_9,
+        FIXED_PRICE_10,
+        FREE_TICKET
+    };
+    Q_ENUM_NS(TICKET_VARIANT)
+
+    inline uint qHash(const nsDeviceControllerInterface::TICKET_VARIANT &key, uint seed = 0)
+    {
+        return ::qHash(static_cast<quint8>(key), seed);
+    }
+
+    enum class COIN_PROCESSOR : quint8 {
+        CHANGER,
+        ESCROW,
+        NONE
     };
 
+    enum class BILL_ACCEPTOR  : quint8 {
+        YES,
+        NO
+    };
+
+    enum class SERVICE_TEXT  : quint16 {
+        SERVICE_DOOR_OPENED,
+        VAULT_DOOR_OPENED,
+        COIN_BOX_REMOVED,
+        COIN_BOX_INSERTED
+        /* t.b.d. */
+    };
 }
 
+
+
 #endif // DEVICECONTROLLERINTERFACE_H

src/ATBAPP/support/CashUtils.cpp

@@ -0,0 +1,74 @@
+#include "CashUtils.h"
+
+#include <QDebug>
+
+#define MAX_COINS 64
+#define MAX_NOTES 16
+
+/*****************************************************************************
+* Get current inserted coins
+*
+* getAllInsertedCoins(uint16_t *types, uint16_t *values)
+*       all inserted coins of this past transaction are stored, max 64
+*/
+uint32_t CashUtils::getAmountOfInsertedCoins(hwinf* hw)
+{
+    uint32_t result = 0;
+
+    uint16_t types[MAX_COINS];
+    uint16_t values[MAX_COINS];
+    hw->getAllInsertedCoins(types, values);
+
+    for (int i = 0; i < MAX_COINS; i++) {
+        result += values[i];
+    }
+
+    return result;
+}
+
+
+/*****************************************************************************
+ * Get current inserted notes
+ *
+ * virtual uint8_t bna_getCurrentNotes(uint16_t latestBill, uint16_t *currentNotes) const =0;
+ * returns number of collected bank notes since start-command (current transaction)
+ *    latestBill: last accepted bank note, value in cent
+ *    currentNotes an array with up to 16 (further) notes collected
+ *
+ */
+uint32_t CashUtils::getAmountOfInsertedNotes(hwinf* hw)
+{
+    uint32_t result = 0;
+    uint8_t numberOfInsertedNotes;
+
+    uint16_t beforeArray = 0;
+    uint16_t currentNotes[4];
+    uint16_t afterArray = 0;
+    numberOfInsertedNotes = hw->bna_getCurrentNotes(0, currentNotes);
+
+    if ( (beforeArray != 0) || (afterArray != 0) ) {
+        qCritical() << "CashUtils::getAmountOfInsertedNotes() ERROR: Array";
+    }
+
+    if (numberOfInsertedNotes == 99) {
+        // Error
+        qCritical() << "CashUtils::getAmountOfInsertedNotes() ERROR: ";
+        for (int i = 0; i < 4; i++) {
+        qCritical() << "   currentNotes[" << i << "] = " << currentNotes[i];
+        }
+    }
+    else {
+        // no error
+        result = currentNotes[3];
+        result = ( result << 16 ) | currentNotes[2];
+    }
+
+    // DEBUG
+    qCritical() << "--------------------------------------------------";
+    qCritical() << "CashUtils::getAmountOfInsertedNotes()";
+    qCritical() << "          numberOfInsertedNotes = " << numberOfInsertedNotes;
+    qCritical() << "                         result = " << result;
+    qCritical() << "--------------------------------------------------";
+
+    return result;
+}

src/ATBAPP/support/CashUtils.h

@@ -0,0 +1,14 @@
+#ifndef CASHUTILS_H
+#define CASHUTILS_H
+
+#include <QObject>
+#include <DeviceController/interfaces.h>
+
+namespace CashUtils {
+
+uint32_t getAmountOfInsertedCoins(hwinf* hw);
+uint32_t getAmountOfInsertedNotes(hwinf* hw);
+
+}
+
+#endif // CASHUTILS_H

src/ATBAPP/support/PersistentData.cpp

@@ -0,0 +1,145 @@
+#include "PersistentData.h"
+
+#include <QFile>
+#include <QFileInfo>
+#include <QDir>
+#include <QDateTime>
+#include <QDataStream>
+#include <QDebug>
+
+PersistentData::PersistentData(const QString &datafileName, QObject *parent)
+    : QObject(parent)
+    , isChangedFlag(false)
+{
+    // load persistant data, if available
+    this->filename = datafileName;
+
+    QFileInfo dataFileInfo(this->filename);
+    QString dataFilePath = dataFileInfo.path();
+
+    QDir dir;
+    if ( ! dir.exists(dataFilePath)) {
+        qCritical() << "Persistent data file does not exist!";
+        qCritical() << "          --> create new: " << this->filename;
+        dir.mkpath(dataFilePath);
+    }
+
+    this->read();
+}
+
+
+void PersistentData::serializeToFile()
+{
+    if (this->isChangedFlag) {
+        qCritical() << "PersistentData::isChanged -> save";
+        this->save();
+    }
+}
+
+void PersistentData::save()
+{
+    QFile fileOut(this->filename);
+    if (fileOut.open(QIODevice::WriteOnly))
+    {
+        QDataStream out(&fileOut);
+        out.setVersion(QDataStream::Qt_4_6);
+
+        out << this->hash;
+        fileOut.flush();
+        fileOut.close();
+
+        this->isChangedFlag = false;
+    }
+}
+
+void PersistentData::read()
+{
+    QFile fileIn(this->filename);
+    if (fileIn.open(QIODevice::ReadOnly))
+    {
+        QDataStream in(&fileIn);
+        in.setVersion(QDataStream::Qt_4_6);
+
+        in >> hash;
+
+        fileIn.close();
+    }
+}
+
+
+
+QVariant PersistentData::getParameter(const QString & key) const {
+#if defined (ARCH_DesktopLinux)
+    // note: QVariant.toString() returns empty string for custom types
+    qDebug() << "VendingData::getParameter() key = " << key << " value = " << hash.value(key).toString();
+#endif
+    return hash.value(key);
+}
+
+QVariant PersistentData::getParameter(const QString & key)
+{
+    #if defined (ARCH_DesktopLinux)
+    // note: QVariant.toString() returns empty string for custom types
+    qDebug() << "VendingData::getParameter() key = " << key << " value = " << hash.value(key).toString();
+    #endif
+
+    return hash.value(key);
+}
+
+void PersistentData::setParameter(const QString & key, QVariant value)
+{
+    this->isChangedFlag = true;
+
+    #if defined (ARCH_DesktopLinux)
+    // note: QVariant.toString() returns empty string for custom types
+    qDebug() << "VendingData::setParameter() key = " << key << " value = " << value.toString();
+    #endif
+
+    this->hash.insert(key, value);
+}
+
+void PersistentData::clearParameter(const QString & key)
+{
+    this->isChangedFlag = true;
+    this->hash.remove(key);
+}
+
+bool PersistentData::hasParameter(const QString & key) const
+{
+    return hash.contains(key);
+}
+
+
+uint PersistentData::getUintParameter(const QString & key) const
+{
+    qDebug() << "PersistentData::getUintParameter() key = " << key << " value = " << hash.value(key).toString();
+
+    uint returnValue = 0;
+    bool ok;
+
+    returnValue = hash.value(key).toString().toUInt(&ok);
+    if (!ok) returnValue = 0;
+
+    return returnValue;
+}
+
+QList<QString> PersistentData::uniqueKeys() const {
+    return hash.uniqueKeys();
+}
+
+
+void PersistentData::setDCFirmwareVersion(const QString & fw_version)
+{
+    // there must be a version string!
+    if (fw_version.size() < 1) return;
+
+    if (this->hash["dc_fw_version"].toString() != fw_version) {
+        this->isChangedFlag = true;
+        this->hash.insert("dc_fw_version", fw_version);
+    }
+}
+
+QString PersistentData::getDCFirmwareVersion()
+{
+    return this->hash["dc_fw_version"].toString();
+}

src/ATBAPP/support/PersistentData.h

@@ -0,0 +1,49 @@
+#ifndef PERSISTENTDATA_H
+#define PERSISTENTDATA_H
+
+#include <QObject>
+#include <QHash>
+#include <QVariant>
+#include <QList>
+#include <QString>
+
+class PersistentData : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PersistentData(const QString &datafileName, QObject *parent = nullptr);
+
+    void setDCFirmwareVersion(const QString & fw_version);
+    QString getDCFirmwareVersion();
+
+
+    QVariant getParameter(const QString & key);
+    QVariant getParameter(const QString & key) const;
+    void setParameter(const QString & key, QVariant value);
+    void clearParameter(const QString & key);
+    bool hasParameter(const QString & key) const;
+
+    uint getUintParameter(const QString & key) const;
+    QList<QString> uniqueKeys() const;
+
+
+public slots:
+    void serializeToFile();
+
+signals:
+
+
+private:
+    QHash<QString, QVariant> hash;
+
+    QString dc_fw_version;
+
+    QString filename;
+
+    void save();
+    void read();
+
+    bool isChangedFlag;
+};
+
+#endif // PERSISTENTDATA_H

src/ATBAPP/support/Ticket.cpp

@@ -0,0 +1,297 @@
+#include "Ticket.h"
+
+#include <QDebug>
+
+Ticket::Ticket(TICKET_VARIANT ticketVariant, QObject *parent )
+    : QObject(parent)
+    , ticketVariant(ticketVariant)
+    , _hasTemplateDynData(false)
+{
+
+}
+
+TICKET_VARIANT Ticket::variant()
+{
+    return this->ticketVariant;
+}
+
+QList<quint8> * Ticket::templateList()
+{
+    return &(this->_templateList);
+}
+
+bool Ticket::hasTemplateDynData()
+{
+    return this->_hasTemplateDynData;
+}
+
+quint8 Ticket::getCurrentProcessedTemplateNumber()
+{
+    return this->currentProcessedTemplateNumber;
+}
+
+void Ticket::setCurrentTemplateProcessed()
+{
+    this->currentProcessedTemplateNumber++;
+}
+
+
+bool Ticket::initNew(TICKET_VARIANT ticketVariant, const QList<quint8> & templateList, const QHash<QString, QVariant> & printingData)
+{
+    this->clear();
+
+    this->ticketVariant = ticketVariant;
+    this->printingData = printingData;
+    this->_templateList = templateList;
+    this->currentProcessedTemplateNumber = 0;
+
+    // DEBUG
+    qCritical() << "Ticket::initNew():";
+    qCritical() << "      -> " << ticketVariant;
+
+    int multiplicatorInt = 1;  // default
+    quint8 headerTemplate;
+    quint8 multiTemplate;
+    quint8 footerTemplate;
+
+    switch (this->ticketVariant) {
+    case TICKET_VARIANT::START_RECEIPT:
+        if (templateList.isEmpty()) {
+            this->_templateList << 21 << 22 << 23;
+        }
+        else {
+            this->_templateList = templateList;
+        }
+        break;
+    case TICKET_VARIANT::STOP_RECEIPT:
+        if (templateList.isEmpty()) {
+            this->_templateList << 24 << 25 << 26;
+        }
+        else {
+            this->_templateList = templateList;
+        }
+        break;
+    case TICKET_VARIANT::FINE_PAYMENT:
+        if (templateList.isEmpty()) {
+            this->_templateList << 24 << 25 << 26;
+        }
+        else {
+            this->_templateList = templateList;
+        }
+        break;
+    case TICKET_VARIANT::FREE_TICKET:
+        if (templateList.isEmpty()) {
+            this->_templateList << 24 << 25 << 26;
+        }
+        else {
+            this->_templateList = templateList;
+        }
+        break;
+    case TICKET_VARIANT::FOOD_STAMP:
+         if (printingData.contains("dyn1_list")) {
+            this->_hasTemplateDynData = true;
+
+            this->dyn1List = printingData["dyn1_list"].toStringList();
+            this->dyn2List = printingData["dyn2_list"].toStringList();
+         }
+
+         if (templateList.isEmpty()) {
+             headerTemplate  = 0;
+             multiTemplate   = 1;
+             footerTemplate  = 2;
+         }
+         else
+         if (templateList.size() == 2) {
+             headerTemplate  = 0;
+             multiTemplate   = templateList.at(0);
+             footerTemplate  = templateList.at(1);
+         }
+         else
+         if (templateList.size() == 3) {
+             headerTemplate  = templateList.at(0);
+             multiTemplate   = templateList.at(1);
+             footerTemplate  = templateList.at(2);
+         }
+         else {
+             headerTemplate  = 0;
+             multiTemplate   = 1;
+             footerTemplate  = 2;
+         }
+
+         // header is optional:
+         if (headerTemplate != 0) {
+             this->_templateList << headerTemplate;
+         }
+
+         if (printingData.contains("multiplicator")) {
+             multiplicatorInt = printingData["multiplicator"].toInt();
+             for (int i = 1; i < multiplicatorInt; i++) {
+                 this->_templateList << multiTemplate;
+             }
+             // last template:
+             this->_templateList << footerTemplate;
+         }
+         else {
+             this->_templateList = templateList;
+         }
+
+         // DEBUG FOOD_STAMP:
+         qCritical() << "     --> printingData[\"multiplicator\"]" << multiplicatorInt;
+
+        break;
+    default:
+        this->_templateList = templateList;
+    }
+
+
+    // DEBUG
+    QString templateListString;
+    for (int i =0; i < this->_templateList.size(); ++i) {
+        templateListString.append(QString(" %1").arg(this->_templateList.at(i)));
+    }
+    qCritical() << "     -> templates: " << templateListString;
+
+
+    return true;
+}
+
+void Ticket::clear()
+{
+    this->ticketVariant = TICKET_VARIANT::PARKING_TICKET;
+    this->printingData.clear();
+    this->_templateList.clear();
+    this->errorCode.clear();
+    this->errorDescription.clear();
+
+    this->_hasTemplateDynData = false;
+    this->dyn1List.clear();
+    this->dyn1List.clear();
+}
+
+QString Ticket::getErrorCode()         {  return this->errorCode;        }
+QString Ticket::getErrorDescription()  {  return this->errorDescription; }
+
+
+
+
+/**
+ */
+QStringList Ticket::getDyn1List()
+{
+    return this->dyn1List;
+}
+
+QStringList Ticket::getDyn2List()
+{
+    return this->dyn2List;
+}
+
+QHash<QString, QVariant> & Ticket::getPrintingData()
+{
+    return this->printingData;
+}
+
+
+
+
+/************************************************************************************************
+ * operator
+ *
+ */
+QDebug operator<<(QDebug debug, TICKET_VARIANT ticketVariant)
+{
+    switch (ticketVariant) {
+        case TICKET_VARIANT::PARKING_TICKET:
+            debug << "TICKET_VARIANT::PARKING_TICKET";
+            break;
+        case TICKET_VARIANT::PARKING_TICKET_CAR:
+            debug << "TICKET_VARIANT::PARKING_TICKET_CAR";
+            break;
+        case TICKET_VARIANT::PARKING_TICKET_CAMPER:
+            debug << "TICKET_VARIANT::PARKING_TICKET_CAMPER";
+            break;
+        case TICKET_VARIANT::PARKING_TICKET_VAN:
+            debug << "TICKET_VARIANT::PARKING_TICKET_VAN";
+            break;
+        case TICKET_VARIANT::DAY_TICKET:
+            debug << "TICKET_VARIANT::DAY_TICKET";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_CHILD:
+            debug << "TICKET_VARIANT::DAY_TICKET_CHILD";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_TEEN:
+            debug << "TICKET_VARIANT::DAY_TICKET_TEEN";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_ADULT:
+            debug << "TICKET_VARIANT::DAY_TICKET_ADULT";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_CAR:
+            debug << "TICKET_VARIANT::DAY_TICKET_CAR";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_CAMPER:
+            debug << "TICKET_VARIANT::DAY_TICKET_CAMPER";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_VAN:
+            debug << "TICKET_VARIANT::DAY_TICKET_VAN";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_1:
+            debug << "TICKET_VARIANT::FIXED_PRICE_1";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_2:
+            debug << "TICKET_VARIANT::FIXED_PRICE_2";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_3:
+            debug << "TICKET_VARIANT::FIXED_PRICE_3";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_4:
+            debug << "TICKET_VARIANT::FIXED_PRICE_4";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_5:
+            debug << "TICKET_VARIANT::FIXED_PRICE_5";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_6:
+            debug << "TICKET_VARIANT::FIXED_PRICE_6";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_7:
+            debug << "TICKET_VARIANT::FIXED_PRICE_7";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_8:
+            debug << "TICKET_VARIANT::FIXED_PRICE_8";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_9:
+            debug << "TICKET_VARIANT::FIXED_PRICE_9";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_10:
+            debug << "TICKET_VARIANT::FIXED_PRICE_10";
+            break;
+        case TICKET_VARIANT::RECEIPT:
+            debug << "TICKET_VARIANT::RECEIPT";
+            break;
+        case TICKET_VARIANT::ERROR_RECEIPT:
+            debug << "TICKET_VARIANT::ERROR_RECEIPT";
+            break;
+        case TICKET_VARIANT::START_RECEIPT:
+            debug << "TICKET_VARIANT::START_RECEIPT";
+            break;
+        case TICKET_VARIANT::STOP_RECEIPT:
+            debug << "TICKET_VARIANT::STOP_RECEIPT";
+            break;
+        case TICKET_VARIANT::FINE_PAYMENT:
+            debug << "TICKET_VARIANT::FINE_PAYMENT";
+            break;
+        case TICKET_VARIANT::FOOD_STAMP:
+            debug << "TICKET_VARIANT::FOOD_STAMP";
+            break;
+        case TICKET_VARIANT::FREE_TICKET:
+            debug << "TICKET_VARIANT::FREE_TICKET";
+            break;
+        case TICKET_VARIANT::NO_TICKET:
+            debug << "TICKET_VARIANT::NO_TICKET";
+            break;
+        case TICKET_VARIANT::INVALID:
+            debug << "TICKET_VARIANT::INVALID";
+            break;
+    }
+
+    return debug;
+}

src/ATBAPP/support/Ticket.h

@@ -0,0 +1,88 @@
+#ifndef TICKET_H
+#define TICKET_H
+
+#include <QObject>
+#include <QHash>
+
+#include "../DeviceControllerInterface.h"
+
+using namespace nsDeviceControllerInterface;
+
+QDebug operator<<(QDebug debug, TICKET_VARIANT ticketVariant);
+
+
+
+class Ticket : public QObject
+{
+    Q_OBJECT
+
+public:
+    Ticket(TICKET_VARIANT ticketVariant, QObject *parent = nullptr);
+
+    bool initNew(TICKET_VARIANT ticketVariant, const QList<quint8> & templateList, const QHash<QString, QVariant> & printingData);
+    void clear();
+
+    TICKET_VARIANT variant();
+
+    QList<quint8> * templateList();
+
+    /**
+     * @brief getPrintingData - generic getter for printingData
+     * Used mainly for simple tickets (single tickets e.g. ParkingTicket)
+     * @return
+     */
+    QHash<QString, QVariant> & getPrintingData();
+
+    /**
+     * @brief hasTemplateDynData
+     * @return true, if ticket has dynamic data for each template.
+     *
+     * This depends on TICKET_VARIANT and printingData
+     */
+    bool hasTemplateDynData();
+
+    /**
+     * @brief getDyn1List
+     * contains dynamic template data
+     * The size of the lists must be exactly the same as the number of templates.
+     */
+    QStringList getDyn1List();
+    QStringList getDyn2List();
+
+    quint8 getCurrentProcessedTemplateNumber();
+
+    /**
+     * Mark current template as processed
+     */
+    void setCurrentTemplateProcessed();
+
+
+    // error handling
+    QString getErrorCode();
+    QString getErrorDescription();
+
+
+
+
+private:
+    TICKET_VARIANT ticketVariant;
+
+    // printingData from application
+    QHash<QString, QVariant> printingData;
+
+    // templateList, from .ini or created by ticketVariant...
+    QList<quint8> _templateList;
+
+    bool _hasTemplateDynData;
+
+    quint8 currentProcessedTemplateNumber;
+
+    QStringList dyn1List;
+    QStringList dyn2List;
+
+    // error handling
+    QString errorCode;
+    QString errorDescription;
+};
+
+#endif // TICKET_H

src/ATBAPP/support/TicketUtils.cpp

@@ -0,0 +1,26 @@
+#include "TicketUtils.h"
+
+#include <QLocale>
+#include <QDate>
+
+TicketUtils::TicketUtils(QObject *parent) : QObject(parent)
+{
+
+}
+
+
+QString TicketUtils::getLocaleDateString(const QLocale & qLocale, const QDate & qDate)
+{
+    QString dateString;
+
+    if (qLocale.language() == QLocale::Lithuanian) {
+        // QLocale::ShortFormat produces date string: "yyyy-mm-dd" ...
+        // this is to long for the printer.
+        dateString = qDate.toString("yy-MM-dd");
+    }
+    else {
+        dateString = qLocale.toString(qDate, QLocale::ShortFormat);
+    }
+
+    return dateString;
+}

src/ATBAPP/support/TicketUtils.h

@@ -0,0 +1,34 @@
+#ifndef TICKETUTILS_H
+#define TICKETUTILS_H
+
+#include <QObject>
+
+class TicketUtils : public QObject
+{
+    Q_OBJECT
+public:
+    explicit TicketUtils(QObject *parent = nullptr);
+
+    /**
+     * @brief getLocaleDateString
+     * @param qLocale
+     * @param qDate
+     * @return a localized date string short format
+     *
+     * Note QLocale::ShortFormat does not result to the
+     * string we need for ticket printing therefore this
+     * helper method was created.
+     *
+     * e.g. using Lithuanian (lt_LT) we get a date in short format:
+     *      "2024-08-08" unfortunately this is to long, we need
+     * the year with only two digits.
+     * e.g. in German (de_DE) it is enought: "08.08.24"
+     *
+     */
+    static QString getLocaleDateString(const QLocale &qLocale, const QDate &qDate);
+
+signals:
+
+};
+
+#endif // TICKETUTILS_H