Extend getString().

nChangedProgramModeToIDLE(), onChangedProgramModeToOOO(), startPhysicalLayer(),
stopPhysicalLayer(), reboot(), reset().
Add signals printTicketFinished,...,Error.

DCPlugin.pro

@@ -9,7 +9,7 @@ QT += serialport
 INCLUDEPATH += $${PWD}/plugins
 INCLUDEPATH += $${PWD}/include
 
-QMAKE_CXXFLAGS += -Wno-deprecated-copy
+QMAKE_CXXFLAGS += -Wno-deprecated-copy -O
 
 # default
 ARCH = PTU5
@@ -30,14 +30,7 @@ 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 ) {
@@ -45,8 +38,8 @@ contains( CONFIG, PTU5_YOCTO ) {
     PTU5BASEPATH = /opt/devel/ptu5
     ARCH = PTU5
 
-    LIBS += -lCAslave
+    # add qmqtt lib
-    LIBS += -lCAmaster
+    #LIBS += -lQt5Qmqtt
 }
 
 TARGET   = ATBDeviceControllerPlugin
@@ -56,6 +49,8 @@ INTERFACE_DEFINITION = $${PWD}/src/ATBAPP/DeviceControllerInterface.h
 
 DEFINES += DEVICECONTROLLERPLUGIN_LIBRARY
 
+DEFINES += USE_DC_VMC_UNIFICATION
+
 # The following define makes your compiler emit warnings if you use
 # any Qt feature that has been marked deprecated (the exact warnings
 # depend on your compiler). Please consult the documentation of the
@@ -76,6 +71,7 @@ DEFINES += QT_DEPRECATED_WARNINGS
 
 # ATBAPP interface
 HEADERS += \
+    include/interfaces.h \
     src/ATBAPP/ATBAPPplugin.h \
     src/ATBAPP/DeviceControllerDiag.h \
     src/ATBAPP/DeviceControllerInterface.h \
@@ -83,13 +79,10 @@ HEADERS += \
     src/ATBAPP/ATBMachineEvent.h \
     src/ATBAPP/ATBDeviceControllerPlugin.h \
     src/ATBAPP/Utils.h \
-    src/ATBAPP/support/CashUtils.h \
+    src/ATBAPP/UnifiedDCVMCInterface.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 \
@@ -97,13 +90,9 @@ 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

src/ATBAPP/ATBAPPplugin.h

@@ -5,18 +5,63 @@
  * a simple class with only one method for plugin info
  */
 #include <QObject>
-#include <QString>
+#include <QStringList>
 
-class ATBAPPplugin
+struct ATBAPPplugin {
-{
+    enum class PLUGIN_STATE : quint8 {
+        NOT_INITIALIZED = 0,
+        INITIALIZED = 1
+    };
+    enum class RESULT_STATE : quint8 {
+        SUCCESS = 1,                // operation was successfull
+        ERROR_BACKEND,              // error from backend (e.g. backend replies with error)
+        ERROR_NETWORK,
+        ERROR_TIMEOUT,              // the operation timed out
+        ERROR_PROCESS,              // internal plugin error, should not occur (this is a bug in implementation)
+        ERROR_BUSY,
+        ERROR_STATE,
+        ERROR_RETRY,                // retry operation
+        INFO                        // informational (e.g. display a message, log something etc.)
+    };
+    enum class CASH_STATE   : quint8 {
+        CACHE_EMPTY,                // Cache still empty, default state
+        CACHE_INPUT,                // Coins are in Cache
+        OVERPAYED,
+        /* t.b.d. */
+    };
+    enum class TICKET_VARIANT : quint8 {
+        PARKING_TICKET,
+        RECEIPT,
+        ERROR_RECEIPT,
+        START_RECEIPT,   // e.g. Szeged Start
+        STOP_RECEIPT,    // e.g. Szeged Stop
+    };
+    enum class STEP : quint8 {
+        UP = 1,
+        DOWN = 2
+    };
+    enum class TERMINAL_STATE : quint8 {
+        NOT_AVAILABLE = 1,
+        AVAILABLE,
+        PREPARED_FOR_VENDING,
+        BUSY,
+        NEEDS_MAINTENANCE
+    };
 
-public:
+    virtual const QString &getPluginInfo() = 0;
-    virtual const QString & getPluginInfo() = 0;
+    virtual QStringList getPluginInfoList() {
+        return QStringList(QString());
+    }
 };
 
+using PLUGIN_STATE = ATBAPPplugin::PLUGIN_STATE;
+using RESULT_STATE = ATBAPPplugin::RESULT_STATE;
+using CASH_STATE = ATBAPPplugin::CASH_STATE;
+using TICKET_VARIANT = ATBAPPplugin::TICKET_VARIANT;
+using STEP = ATBAPPplugin::STEP;
+using TERMINAL_STATE = ATBAPPplugin::TERMINAL_STATE;
+
 Q_DECLARE_INTERFACE(ATBAPPplugin,
                     "eu.atb.ptu.plugin.ATBAPPplugin/0.9")
 
-
-
 #endif // ATBAPPPLUGIN_H

src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -2,32 +2,27 @@
 #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 <DeviceController/interfaces.h>
 
-#include <unistd.h>
+#include "interfaces.h"
 
 
 class DBusControllerInterface;
 class QTextCodec;
 
-using namespace nsDeviceControllerInterface;
+
+// using namespace nsDeviceControllerInterface;
 
 class QSettings;
 
-
+class ATBDeviceControllerPlugin : public DeviceControllerInterface
-class ATBDeviceControllerPlugin :
-        public DeviceControllerInterface
 {
     Q_OBJECT
     Q_INTERFACES(ATBAPPplugin)
@@ -38,25 +33,21 @@ class ATBDeviceControllerPlugin :
 
 public:
     explicit ATBDeviceControllerPlugin(QObject *parent = nullptr);
-    ~ATBDeviceControllerPlugin();
+    virtual ~ATBDeviceControllerPlugin();
 
     // ----------------------------------------------------------------------------
     // interface:
-    PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings);
+    virtual PLUGIN_STATE initPlugin(QObject *eventReceiver, QObject *atbSystem, QObject *hmiConfig, QSettings const &settings) override;
-
+    virtual PLUGIN_STATE initPlugin(QObject *eventReceiver, QSettings const &settings) override;
-    void sendDeviceParameter(const QJsonObject & jsonObject);
+    virtual PLUGIN_STATE initVMCPlugin(QObject *eventReceiver, QObject *atbSystem, QObject *hmiConfig, const QSettings & settings) override;
+    virtual PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings) override;
 
     // 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);
@@ -67,43 +58,106 @@ public:
     void requestAccount();
 
     // mandantory ATBAPP plugin methods: ------------------------------------------
-    nsDeviceControllerInterface::PLUGIN_STATE getState();
+    nsDeviceControllerInterface::PLUGIN_STATE getState() override;
-    QString & getLastError();
+    QString const &getLastError() override;
-    const QString & getLastErrorDescription();
+    QString const &getLastErrorDescription() override;
 
-    const QString & getPluginInfo();
+    virtual QStringList getPluginInfoList() override;
+    virtual const QString &getPluginInfo() override;
 
     // helpers e.g. for debug / log
-    const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState);;
+    virtual QString const &getString(RESULT_STATE resultState) override;
 
 public slots:
-    void onChangedProgramModeToSELL();
+    virtual void onChangedProgramModeToSELL() override;
-    void onChangedProgramModeToSERVICE();
+    virtual void onChangedProgramModeToSERVICE() override;
-    void onChangedProgramModeToIDLE();
+    virtual void onChangedProgramModeToIDLE() override;
-    void onChangedProgramModeToOOO();
+    virtual void onChangedProgramModeToOOO() override;
 
-    void startPhysicalLayer();
+    virtual void startPhysicalLayer() override;
-    void stopPhysicalLayer();
+    virtual void stopPhysicalLayer() override;
-    void reboot();
+    virtual void reboot() override;
-    void reset();
+    virtual void reset() override;
 
 
 
 signals:
-    // public Signals are defined in interface
+    void printTicketFinished(RESULT_STATE resultState,
+                             const QString & errorCode,
+                             const QString & errorDescription);
+    void printReceiptFinished(RESULT_STATE resultState,
+                              const QString & errorCode,
+                              const QString & errorDescription);
+
+    /**
+     * emitted on e.g. a coin input
+     */
+    void cashInputEvent(RESULT_STATE resultState,
+                                CASH_STATE cashState,
+                                const QString & newCashValue,
+                                /* additional variables? */
+                                const QString & errorCode,
+                                const QString & errorDescription);
+
+    /**
+     * emitted if cashInput has been stopped, e.g. in result to task requestStopCashInput():
+     *  -> shutter is blocked
+     *  -> no cash input is possible
+     *  -> coins are in cache
+     */
+    void cashInputFinished(RESULT_STATE resultState,
+                                     const QString & newCashValue,
+                                     /*  additional variables? */
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+
+
+    /**
+     * emitted e.g. if service door is opened
+     */
+    void requestModeSERVICE();
+
+    /**
+     * emitted e.g. if doors are closed
+     */
+    void requestModeIDLE();
+
+    /**
+     * emitted e.g. on severe errors
+     */
+    void requestModeOOO();
+
+    /**
+     * emitted e.g. if service door is opened
+     */
+    void requestAccountResponse(const QHash<QString, QVariant> & accountData);
+
+    /**
+     * emitted on error
+     * depending on errorCode:
+     * -> interrupt selling process
+     * -> machine can go to state OOO
+     * -> send error event to ISMAS
+     * -> ...
+     */
+    void Error(
+            /*  additional variables? */
+            const QString & errorCode,
+            const QString & errorDescription);
 
 
 private:
    QString errorCode;
    QString errorDescription;
    QString pluginInfo;
+   QStringList pluginInfoList;
+
+   QList<int> templateList;
 
    QString serialPortName;
 
    bool useDebug;
 
-   bool isMaster;
-
    PLUGIN_STATE pluginState;
 
    QObject* eventReceiver;
@@ -114,10 +168,6 @@ private:
 
    DeviceControllerDiag* diag;
 
-   PersistentData *persistentData;
-
-   uint32_t cashStartAmountInt;
-
 
    QTextCodec *codec;
 
@@ -130,30 +180,9 @@ 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
 
@@ -163,8 +192,6 @@ private slots:
    void onPrinterWaitForPrintingTicket();
    void onPrinterWaitForPrintingReceipt();
 
-   void onPrinterPrepareDynTemplateData();
-
    void onPrintFinishedOK();
    void onPrintFinishedERR();
 
@@ -172,11 +199,9 @@ 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,55 +5,29 @@
 #include <QUuid>
 #include <QDebug>
 
-#include <QProcess>
+DeviceControllerDiag::DeviceControllerDiag(QObject *parent)
-
-#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*45);
+    diagRequestTimeoutTimer->setInterval(1000*20);  // 20s
     diagRequestTimeoutTimer->setSingleShot(true);
     connect(diagRequestTimeoutTimer, &QTimer::timeout, this, &DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout);
 }
 
 
-void DeviceControllerDiag::init(hwinf *hw, DBusControllerInterface *dbus, QObject* eventReceiver)
+void DeviceControllerDiag::init(hwinf *hw, 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()";
@@ -62,21 +36,10 @@ void DeviceControllerDiag::diagRequest()
         qCritical() << "DeviceControllerDiag::diagRequest() is already running";
         return;
     }
-    this->machineEventSet.clear();
     this->isRequestRunning = true;
     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();
 }
 
 
@@ -86,54 +49,12 @@ 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!";
-        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::E255);
+        this->private_sendDiagEvent(DeviceController::State::E255);
-        if (!this->previousMachineEventSet.contains(E255Event)) {
-            machineEventSet.insert(E255Event);
-            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();
         return;
     }
 
@@ -142,20 +63,11 @@ 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 {
         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);
     }
@@ -164,8 +76,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_dynamicCondition dynMaCond;
-    struct T_moduleCondition  modCond = {};
+    struct T_moduleCondition  modCond;
 
 
     qCritical() << "      sys_superviseSystem()";
@@ -174,16 +86,7 @@ void DeviceControllerDiag::sys_superviseSystem()
     // check for DiagRequestTimeoutTimerTimeout:
     if (this->flagInterruptDiag) {
         qCritical() << "DeviceControllerDiag::sys_superviseSystem() interrupted!";
-        // send
+        this->private_sendDiagEvent(DeviceController::State::E255);
-        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::E255);
-        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->private_finishDiag();
         return;
     }
 
@@ -191,16 +94,7 @@ 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_sendDiagEvent(DeviceController::State::E254);
-
-        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::M0254);
-        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->private_finishDiag();
         return;
     }
 
@@ -213,7 +107,7 @@ void DeviceControllerDiag::sys_superviseSystem()
     {
         // noch keine Testergebnisse
         if (dynMaCond.startupTestIsRunning) {
-            qCritical() << "            startupTestIsRunning --> call again";
+            // TODO?
         }
 
 
@@ -223,6 +117,18 @@ 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();
@@ -234,13 +140,13 @@ void DeviceControllerDiag::sub_componentAssessment()
 {
     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:
@@ -253,50 +159,35 @@ void DeviceControllerDiag::sub_componentAssessment()
 
     if (dynMaCond.onAlarm>0) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::A000);
+        this->private_sendDiagEvent(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_setDiagEvent(DeviceController::State::E002);
+        this->private_sendDiagEvent(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_setDiagEvent(DeviceController::State::E020);
+        this->private_sendDiagEvent(DeviceController::State::E020);
     }
     if (modCond.printer==202) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::E018);
+        this->private_sendDiagEvent(DeviceController::State::E018);
     }
 
     if (modCond.coinBlocker>=200) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::E025);
+        this->private_sendDiagEvent(DeviceController::State::E025);
     }
     if (modCond.mdbBus>=200) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::E034);
+        this->private_sendDiagEvent(DeviceController::State::E034);
     }
     if (modCond.intEe>=200) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::E011);
+        this->private_sendDiagEvent(DeviceController::State::E011);
     }
 
     // 2023-07-26: workaround for 00281/Szeged --------------------------------------------------------------
@@ -306,47 +197,32 @@ void DeviceControllerDiag::sub_componentAssessment()
     if (devPara.kindOfCoinChecker > 0) {
         if (modCond.coinSafe==201) { // full
             flag_sendOperate = false;
-            this->private_setDiagEvent(DeviceController::State::E007);
+            this->private_sendDiagEvent(DeviceController::State::E007);
         }
         if (modCond.coinSafe==200)  {         // 200: kasse fehlt 201: voll  100:fast voll  1:ok
             flag_sendOperate = false;
-            this->private_setDiagEvent(DeviceController::State::E009);
+            this->private_sendDiagEvent(DeviceController::State::E009);
         }
         if (modCond.coinEscrow>=200) {
             flag_sendOperate = false;
-            // coinEscrow>200 is considered a warning:
+            this->private_sendDiagEvent(DeviceController::State::E010);
-            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;
-            // coinEscrow>200 is considered a warning:
+            this->private_sendDiagEvent(DeviceController::State::E010);
-            this->private_setDiagEvent(DeviceController::State::W010);
         }
         if (modCond.coinSafe==201)  { // full
             flag_sendOperate = false;
-            this->private_setDiagEvent(DeviceController::State::E007);
+            this->private_sendDiagEvent(DeviceController::State::E007);
         }
         if (modCond.coinSafe==200) {          // 200: kasse fehlt 201: voll  100:fast voll  1:ok
             flag_sendOperate = false;
-            this->private_setDiagEvent(DeviceController::State::E009);
+            this->private_sendDiagEvent(DeviceController::State::E009);
         }
     } else
     if (devPara.kindOfCoinChecker==3)
@@ -354,27 +230,18 @@ void DeviceControllerDiag::sub_componentAssessment()
         if (modCond.changer>=200) {
             // Fehler Münzver.
             flag_sendOperate = false;
-            this->private_setDiagEvent(DeviceController::State::E026);
+            this->private_sendDiagEvent(DeviceController::State::E026);
         }
         if (modCond.coinSafe==201) { // full
             flag_sendOperate = false;
-            this->private_setDiagEvent(DeviceController::State::E007);
+            this->private_sendDiagEvent(DeviceController::State::E007);
         }
         if (modCond.coinSafe == 200)  {          // 200: kasse fehlt 201: voll  100:fast voll  1:ok
             flag_sendOperate = false;
-            this->private_setDiagEvent(DeviceController::State::E009);
+            this->private_sendDiagEvent(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)
     {
@@ -391,113 +258,61 @@ void DeviceControllerDiag::sub_componentAssessment()
 
     if (dynMaCond.modeAbrech>0) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::E011);
+        this->private_sendDiagEvent(DeviceController::State::E011);
     }
 
     if (dynMaCond.nowCardTest>0) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::M0072);
+        this->private_sendDiagEvent(DeviceController::State::E072);
     }
 
     if (dynMaCond.startupTestIsRunning>0) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::M0073);
+        this->private_sendDiagEvent(DeviceController::State::E073);
     }
 
     if (modCond.voltage>=200) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::E003);
+        this->private_sendDiagEvent(DeviceController::State::E003);
     }
     if (modCond.temper>=200) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::W004);
+        this->private_sendDiagEvent(DeviceController::State::E004);
     }
 
     // check for warnings
     if (modCond.printer>=100 && modCond.printer<200) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::W001);
+        this->private_sendDiagEvent(DeviceController::State::W001);
     }
     if (modCond.coinSafe>=100 && modCond.coinSafe<200) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::W002);
+        this->private_sendDiagEvent(DeviceController::State::W002);
     }
     if (modCond.voltage>=100 && modCond.voltage<200) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::W003);
+        this->private_sendDiagEvent(DeviceController::State::W003);
     }
     if (modCond.temper>=100 && modCond.temper<200) {
         flag_sendOperate = false;
-        this->private_setDiagEvent(DeviceController::State::W004);
+        this->private_sendDiagEvent(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) {
-        // O000 must not be part of machineEventSet
+        this->private_sendDiagEvent(DeviceController::State::O000);
-        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.unite(machineEventSet);      // add new elements from machineEventSet
-    this->previousMachineEventSet.intersect(machineEventSet);  // remove elements not in machineEventSet
-
-    if (this->isDiagBackgroundTask) {
-        this->isDiagBackgroundTask = false;
-        this->dbus->finishedBackgroundTask("E255");
-    }
 }
 
 
-
 /**
- * @brief DeviceControllerDiag::private_setDiagEvent
+ * @brief DeviceControllerDiag::private_sendDiagEvent
  * @param result - result value from 'sub_componentAssessment()',
  *               - 0x00 everything is fine
  *               - 0xFF on timer interrupt
@@ -505,156 +320,126 @@ void DeviceControllerDiag::private_finishDiag()
  *               - 0xFD Service or battery door is open
  *               - 0xFE vault door is open
  */
-void DeviceControllerDiag::private_setDiagEvent(DeviceController::State result)
+void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
 {
-    qCritical() << "DeviceControllerDiag::private_setDiagEvent() result: " << result;
+    qCritical() << "DeviceControllerDiag::private_sendDiagEvent() result: " << result;
+
 
     if (this->eventReceiver == nullptr) {
         qCritical() << "DeviceControllerDiag: no eventReceiver";
         return;
     }
 
-    DCMachineEvent newState = DCMachineEvent(result);
+    if (machineEventSet.contains(result)) {
-
+        // do not send already sent events
-    // DEBUG
+        qCritical() << "       ... is in machineEventList";
-    qCritical() << "----> setDiagEvent: " << newState.state << " with id: " << newState.eventId;
+        return;
-
+    }
-    machineEventSet.insert(newState);
+    else {
-}
+        machineEventSet.insert(result);
+    }
 
 
+    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.state) {
+    switch (result) {
 
-    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::M0071:   // cash box change is ongoing
+    case DeviceController::State::E071:   // cash box change is ongoing
         eventClass = EVENT_CLASS::STATE;
         parameter  = "cash box change is ongoing";
         break;
-    case DeviceController::State::M0072:   // card test running
+    case DeviceController::State::E072:   // card test running
         eventClass = EVENT_CLASS::STATE;
         parameter  = "card test running";
         break;
-    case DeviceController::State::M0073:   // startup-test is running
+    case DeviceController::State::E073:   // startup-test is running
         eventClass = EVENT_CLASS::STATE;
         parameter  = "startup-test is running";
         break;
 
-    case DeviceController::State::M0252:   // cash box door open
+    case DeviceController::State::E252:   // cash box door open
         eventClass = EVENT_CLASS::STATE;
         parameter  = "cash box door open";
         break;
-    case DeviceController::State::M0253:   // service or battery door open
+    case DeviceController::State::E253:   // service or battery door open
         eventClass = EVENT_CLASS::STATE;
         parameter  = "service or battery door open";
         break;
-    case DeviceController::State::M0254:   // no valid data from DeviceController
+    case DeviceController::State::E254:   // 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::ERROR;
+        eventClass = EVENT_CLASS::STATE;
-        parameter  = "no valid data from DeviceController";
+        parameter  = "";
+        qCritical() << "                ... ignore " << QMetaEnum::fromType<DeviceController::State>().valueToKey(result);
+        return;
         break;
     case DeviceController::State::O000:   // everything is fine
-        this->_isErrorState = false;
+        this->machineEventSet.clear();
         eventClass = EVENT_CLASS::OPERATE;
         parameter  = "";
-        if (this->lastState == DeviceController::State::O000) {
+        qCritical() << "                ... everything fine";
-            qCritical() << "   ... everything fine, no state change -> skip sending";
-            return;
-        }
-        else {
-            qCritical() << "   ... everything fine";
-        }
         break;
 
     case DeviceController::State::W001:   // paper low
@@ -673,65 +458,23 @@ void DeviceControllerDiag::private_sendDiagEvent(DCMachineEvent result, DeviceCo
         eventClass = EVENT_CLASS::WARNING;
         parameter  = "temperatur warning";
         break;
-    case DeviceController::State::W255:   // restart carun
-        eventClass = EVENT_CLASS::WARNING;
-        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,
-                action,         // eventState
+                1,
                 parameter,
                 ""         // second level info
                 );
 
+    //emit diagResponse(machineEvent);
+
     QCoreApplication::postEvent(eventReceiver, machineEvent);
 
 }
 
 
-
-/**
- * reset / restart / reinit deviceController
- */
-void DeviceControllerDiag::restartCArun()
-{
-    this->E255counter = 0;
-
-
-    DCMachineEvent W255Event = DCMachineEvent(DeviceController::State::W255);
-    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

@@ -5,14 +5,8 @@
 #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
@@ -30,7 +24,6 @@ namespace DeviceController {
         E008,
         E009,
         E010,
-        W010,   // Coin Escrow
         E011,
 
         E018,
@@ -42,99 +35,36 @@ namespace DeviceController {
 
         E034,
 
-        M0071, // cashbox change is ongoing
+        E071,
-        M0072, // cardtest is running
+        E072,
-        M0073, // startup-test is running
+        E073,
-
-        M0252, // cashbox door open
-        M0253, // service or battery door is open
-        M0254, // no valid data from DC
 
+        E252,
+        E253,
+        E254,
         E255,
 
         W001,
         W002,
         W003,
-        W004,
+        W004
-
-        W255,
-
-        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(PersistentData *pData, QObject *parent = nullptr);
+    DeviceControllerDiag(QObject *parent = nullptr);
 
-    void init(hwinf* hw, DBusControllerInterface *dbus, QObject* eventReceiver);
+    void init(hwinf* hw, 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);
 
@@ -143,11 +73,9 @@ signals:
 private:
     QObject *eventReceiver;
     hwinf* hw;
-    DBusControllerInterface* dbus;
 
     bool isRequestRunning;
     bool flagInterruptDiag;
-    bool isDiagBackgroundTask;
 
     QTimer *diagRequestTimeoutTimer;
 
@@ -155,26 +83,17 @@ private:
 
     int lastVoltage;
 
-    DeviceController::State lastState;
+    QSet<DeviceController::State> machineEventSet;
-    QSet<DCMachineEvent> machineEventSet;
-    QSet<DCMachineEvent> previousMachineEventSet;
-    bool _isErrorState;
-
-    PersistentData* pData;
-
-    int E255counter;
 
 private slots:
     void onDiagRequestTimeoutTimerTimeout();
 
     void private_startDiag();                                    // diag entry method
-    void private_setDiagEvent(DeviceController::State result);
+    void private_sendDiagEvent(DeviceController::State result);
-    void private_sendDiagEvent(DCMachineEvent result, DeviceController::Action action);
-
-    void private_finishDiag();
 
     void sys_superviseSystem();
 
+
 };
 
 #endif // DEVICECONTROLLERDIAG_H

src/ATBAPP/DeviceControllerInterface.h

@@ -5,31 +5,25 @@
 
 #include <QSettings>
 #include <QString>
-#include <QJsonObject>
-#include <QtCore/QHash>
 
 #include "ATBAPPplugin.h"
+#include "UnifiedDCVMCInterface.h"
 
 namespace nsDeviceControllerInterface {
-    enum class PLUGIN_STATE : quint8;
+    using PLUGIN_STATE = ATBAPPplugin::PLUGIN_STATE;
-    enum class RESULT_STATE : quint8;
+    using RESULT_STATE = ATBAPPplugin::RESULT_STATE;
-    enum class CASH_STATE   : quint8;
+    using CASH_STATE = ATBAPPplugin::CASH_STATE;
-    enum class TICKET_VARIANT : quint8;
+    using TICKET_VARIANT = ATBAPPplugin::TICKET_VARIANT;
-    enum class COIN_PROCESSOR : quint8;
-    enum class BILL_ACCEPTOR  : quint8;
-
-
-    enum class SERVICE_TEXT  : quint16;
 }
 
-
+class DeviceControllerInterface : public QObject, public UnifiedDCVMCInterface
-class DeviceControllerInterface : public QObject
-                                , public ATBAPPplugin
 {
     Q_OBJECT
     Q_INTERFACES(ATBAPPplugin)
+    Q_INTERFACES(UnifiedDCVMCInterface)
 
 public:
+
     virtual ~DeviceControllerInterface() {}
 
     /**
@@ -38,14 +32,7 @@ public:
      * @param settings
      * @return
      */
-    virtual nsDeviceControllerInterface::PLUGIN_STATE initDCPlugin(QObject *eventReceiver,
+    virtual PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings) = 0;
-                                                                   const QSettings & settings) = 0;
-
-    /**
-     * e.g. send location
-     */
-    virtual void sendDeviceParameter(const QJsonObject & jsonObject) = 0;
-
 
     // TASKS: Cash handling -------------------------------------------------------
     /**
@@ -61,10 +48,9 @@ public:
     virtual void requestStopCashInput() = 0;
 
     /**
-     * called e.g. after printing
+     * called e.g. on Button "NEXT" in pay-up (direct coin input)
      */
     virtual void cashCollect() = 0;
-    virtual void cashCollect(const QString & amount) = 0;
     virtual void cashAbort() = 0;
 
     // TASKS: Account -------------------------------------------------------------
@@ -74,13 +60,10 @@ public:
 
     // TASKS: printing ------------------------------------------------------------
     virtual void requestPrintTicket(const QHash<QString, QVariant> & printingData) = 0;
-    virtual void requestPrintTicket(nsDeviceControllerInterface::TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData) = 0;
+    virtual void requestPrintTicket(TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData) = 0;
     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;
@@ -91,7 +74,7 @@ public:
     // -> ATBAPPplugin::getPluginInfo()
 
     // helpers e.g. for debug / log
-    virtual const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState) = 0;
+    virtual const QString &getString(nsDeviceControllerInterface::RESULT_STATE resultState) = 0;
 
 public slots:
     virtual void onChangedProgramModeToSELL() = 0;
@@ -104,7 +87,6 @@ public slots:
     virtual void reboot() = 0;
     virtual void reset() = 0;
 
-
 signals:
     void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
                                      const QString & errorCode,
@@ -113,9 +95,6 @@ signals:
                                      const QString & errorCode,
                                      const QString & errorDescription);
 
-
-    void coinAttached();
-
     /**
      * emitted on e.g. a coin input
      */
@@ -134,46 +113,15 @@ signals:
      */
     void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
                                      const QString & newCashValue,
-                                     const QString & coinValue,
+                                     /*  additional variables? */
-                                     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
      */
@@ -190,12 +138,6 @@ signals:
     void requestAccountResponse(const QHash<QString, QVariant> & accountData);
 
 
-    /**
-     * show text messages in service mode
-     */
-    void showServiceText(nsDeviceControllerInterface::SERVICE_TEXT serviceText, const QString & text);
-
-
     /**
      * emitted on error
      * depending on errorCode:
@@ -211,95 +153,7 @@ signals:
 
 };
 
-
 Q_DECLARE_INTERFACE(DeviceControllerInterface,
-                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.2.1")
+                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.0")
-
-
-namespace nsDeviceControllerInterface {
-    Q_NAMESPACE
-
-    enum class PLUGIN_STATE : quint8 {
-        NOT_INITIALIZED = 0,
-        INITIALIZED = 1
-    };
-
-    enum class RESULT_STATE : quint8 {
-        SUCCESS = 1,                // operation was successfull
-        ERROR_BACKEND,              // error from backend (e.g. backend replies with error)
-        ERROR_TIMEOUT,              // the operation timed out
-        ERROR_PROCESS,              // internal plugin error, should not occur (this is a bug in implementation)
-        ERROR_RETRY,                // retry operation
-        INFO                        // informational (e.g. display a message, log something etc.)
-    };
-
-    enum class CASH_STATE   : quint8 {
-        CACHE_EMPTY,                // Cache still empty, default state
-        CACHE_INPUT,                // Coins are in Cache
-        OVERPAYED,
-        /* t.b.d. */
-    };
-
-
-    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/UnifiedDCInterface.cpp

@@ -0,0 +1,19 @@
+#include "DeviceControllerInterface.h"
+
+
+using UNIFIED_PLUGIN_STATE = UnifiedDCVMCInterface<DeviceControllerInterface>::UNIFIED_PLUGIN_STATE;
+
+
+template<>
+UNIFIED_PLUGIN_STATE UnifiedDCVMCInterface<DeviceControllerInterface>::initPlugin(QObject *eventReceiver, QSettings const &settings) {
+
+
+    switch(static_cast<DeviceControllerInterface*>(this)->initDCPlugin(eventReceiver, settings)) {
+    case nsDeviceControllerInterface::PLUGIN_STATE::INITIALIZED:
+        return UNIFIED_PLUGIN_STATE::INITIALIZED;
+    case nsDeviceControllerInterface::PLUGIN_STATE::NOT_INITIALIZED:
+        return UNIFIED_PLUGIN_STATE::NOT_INITIALIZED;
+    }
+
+    return UNIFIED_PLUGIN_STATE::NOT_INITIALIZED;
+}

src/ATBAPP/UnifiedDCVMCInterface.h

@@ -0,0 +1,62 @@
+#ifndef UNIFIED_DCVMC_INTERFACE_H_INCLUDED
+#define UNIFIED_DCVMC_INTERFACE_H_INCLUDED
+
+#include <QObject>
+#include <QSettings>
+
+#include <QtPlugin>
+
+#include <QSettings>
+#include <QString>
+
+#include "ATBAPPplugin.h"
+
+
+class UnifiedDCVMCInterface : public ATBAPPplugin {
+    Q_INTERFACES(ATBAPPplugin)
+
+public:
+    explicit UnifiedDCVMCInterface() = default;
+    virtual ~UnifiedDCVMCInterface() = default;
+
+    virtual QStringList getPluginInfoList() = 0;
+    virtual const QString &getPluginInfo() = 0;
+
+    // mandantory ATBAPP plugin methods:
+    virtual PLUGIN_STATE getState() = 0;
+    virtual QString const &getLastError() = 0;
+    virtual QString const &getLastErrorDescription() = 0;
+
+    virtual PLUGIN_STATE initPlugin(QObject *eventReceiver,
+                                    QObject *atbSystem,
+                                    QObject *hmiConfig,
+                                    QSettings const &settings) = 0;
+
+    virtual PLUGIN_STATE initPlugin(QObject *eventReceiver, QSettings const &settings) = 0;
+
+    virtual PLUGIN_STATE initDCPlugin(QObject *eventReceiver,
+                                      const QSettings & settings) = 0;
+
+    virtual PLUGIN_STATE initVMCPlugin(QObject *eventReceiver,
+                                       QObject *atbSystem, QObject *hmiConfig,
+                                       const QSettings & settings) = 0;
+
+
+    virtual QString const &getString(RESULT_STATE resultState) = 0;
+
+public slots:
+    virtual void onChangedProgramModeToSELL() = 0;
+    virtual void onChangedProgramModeToSERVICE() = 0;
+    virtual void onChangedProgramModeToIDLE() = 0;
+    virtual void onChangedProgramModeToOOO() = 0;
+
+    virtual void startPhysicalLayer() = 0;
+    virtual void stopPhysicalLayer() = 0;
+    virtual void reboot() = 0;
+    virtual void reset() = 0;
+};
+
+Q_DECLARE_INTERFACE(UnifiedDCVMCInterface,
+                    "eu.atb.ptu.plugin.UnifiedDCVMCInterface/1.0")
+
+#endif // UNIFIED_DCVMC_INTERFACE_H_INCLUDED

src/ATBAPP/support/CashUtils.cpp

@@ -1,74 +0,0 @@
-#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

@@ -1,14 +0,0 @@
-#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

@@ -1,145 +0,0 @@
-#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

@@ -1,49 +0,0 @@
-#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

@@ -1,297 +0,0 @@
-#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

@@ -1,88 +0,0 @@
-#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

@@ -1,26 +0,0 @@
-#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

@@ -1,34 +0,0 @@
-#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