Diag: check doors in sub_componentAssessment ...

... this prevents sending Operate "O000" in case of an opend door and
enables sending Operate "O000" after closing all doors because
'lastResult' has not changed.

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,14 +45,14 @@ contains( CONFIG, PTU5_YOCTO ) {
     PTU5BASEPATH = /opt/devel/ptu5
     ARCH = PTU5
 
-    # add qmqtt lib
-    #LIBS += -lQt5Qmqtt
+    LIBS += -lCAslave
+    LIBS += -lCAmaster
 }
 
 TARGET   = ATBDeviceControllerPlugin
 #DESTDIR  = ../plugins
 INTERFACE = DeviceController
-INTERFACE_DEFINITION = $${PWD}/include/ATBAPP/DeviceControllerInterface.h
+INTERFACE_DEFINITION = $${PWD}/src/ATBAPP/DeviceControllerInterface.h
 
 DEFINES += DEVICECONTROLLERPLUGIN_LIBRARY
 
@@ -69,17 +76,32 @@ DEFINES += QT_DEPRECATED_WARNINGS
 
 # ATBAPP interface
 HEADERS += \
-    include/interfaces.h \
     src/ATBAPP/ATBAPPplugin.h \
+    src/ATBAPP/DeviceControllerDiag.h \
     src/ATBAPP/DeviceControllerInterface.h \
     src/ATBAPP/ATBHealthEvent.h \
+    src/ATBAPP/ATBMachineEvent.h \
     src/ATBAPP/ATBDeviceControllerPlugin.h \
-    src/ATBAPP/Utils.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/PersistentData.h \
+    src/ATBAPP/support/Ticket.h
 
 SOURCES += \
     src/ATBAPP/ATBHealthEvent.cpp \
+    src/ATBAPP/ATBMachineEvent.cpp \
     src/ATBAPP/ATBDeviceControllerPlugin.cpp \
-    src/ATBAPP/Utils.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/PersistentData.cpp \
+    src/ATBAPP/support/Ticket.cpp
 
 DISTFILES += \
     generate-version.sh

generate-version.sh

@@ -70,6 +70,8 @@ fi
 #
 #Q_DECLARE_INTERFACE(CCInterface,
 #         "eu.atb.ptu.plugin.CCInterface/2.9.0")
+#Q_DECLARE_INTERFACE(DeviceControllerInterface,
+#         "eu.atb.ptu.plugin.DeviceControllerInterface/1.0")
 # -> extract whole string within quotation marks
 INTERFACE_VERSION=$(grep 'eu.atb.ptu.plugin.' ${INTERFACE_DEFINITION})
 # get string within quotes:

src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -2,29 +2,31 @@
 #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>
-#include <thread>
-#include <memory>
-#include <QSharedMemory>
 
 
+class DBusControllerInterface;
 class QTextCodec;
 
-
 using namespace nsDeviceControllerInterface;
 
 class QSettings;
 
-class ATBDeviceControllerPlugin : public QObject,
+
+class ATBDeviceControllerPlugin :
         public DeviceControllerInterface
 {
     Q_OBJECT
@@ -40,7 +42,9 @@ public:
 
     // ----------------------------------------------------------------------------
     // interface:
-    PLUGIN_STATE initDCPlugin(QObject *healthEventReceiver, const QSettings & settings);
+    PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings);
+
+    void sendDeviceParameter(const QJsonObject & jsonObject);
 
     // TASKS: Cash handling -------------------------------------------------------
     void requestStartCashInput(const QString & amount);
@@ -48,8 +52,15 @@ public:
     void cashCollect();
     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);
+    void requestPrintReceipt(const QHash<QString, QVariant> & printingData);
+    void requestPrintReceipt(const QString & printingString);
 
     // TASKS: Account -------------------------------------------------------------
     void requestAccount();
@@ -70,39 +81,15 @@ public slots:
     void onChangedProgramModeToIDLE();
     void onChangedProgramModeToOOO();
 
-
+    void startPhysicalLayer();
+    void stopPhysicalLayer();
+    void reboot();
+    void reset();
 
 
 
 signals:
-    void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
-                                     const QString & errorCode,
-                                     const QString & errorDescription);
-
-    void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
-                        nsDeviceControllerInterface::CASH_STATE cashState,
-                        const QString & newCashValue,
-                        const QString & errorCode,
-                        const QString & errorDescription);
-
-    void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
-                                     const QString & newCashValue,
-                                     const QString & errorCode,
-                                     const QString & errorDescription);
-
-    void requestModeSERVICE();
-    void requestModeIDLE();
-    void requestModeOOO();
-
-    void requestAccountResponse(const QHash<QString, QVariant> & accountData);
-
-
-
-    void Error(
-            const QString & errorCode,
-            const QString & errorDescription);
-
-
+    // public Signals are defined in interface
 
 
 private:
@@ -110,17 +97,27 @@ private:
    QString errorDescription;
    QString pluginInfo;
 
-   int currentTemplate;
-
+   QString serialPortName;
 
    bool useDebug;
 
+   bool isMaster;
+
    PLUGIN_STATE pluginState;
 
-   QObject* healthEventReceiver;
+   QObject* eventReceiver;
+
+   DBusControllerInterface* dbus;
 
    hwinf* hw;
 
+   DeviceControllerDiag* diag;
+
+   PersistentData *persistentData;
+
+   uint32_t cashStartAmountInt;
+
+
    QTextCodec *codec;
 
    bool private_loadCashAgentLib(QString pluginName);
@@ -132,12 +129,33 @@ 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;
+
+   void prepareDynTemplateData();
+
+   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);
+   // ---------------------------------------------------------------------------------------------
 
 private slots:
    // printer
 
    void onPrinterDataPrepared();
+   void onPrinterDataPreparedForTemplates();
    void onPrinterPrintNextTemplate();
+   void onPrinterWaitForPrintingTicket();
+   void onPrinterWaitForPrintingReceipt();
+
+   void onPrinterPrepareDynTemplateData();
 
    void onPrintFinishedOK();
    void onPrintFinishedERR();
@@ -146,9 +164,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();
@@ -156,11 +176,17 @@ private slots:
    void onCoinBoxRemoved();
    void onCoinBoxInserted();
    void onAllDoorsClosed();
+   void onCBinAndAllDoorsClosed();
 
    // account handling
    void private_startAccount();
    void private_checkAccountData();
    void private_getAccountData();
+
+   // measurement values
+   void onNewVoltage(uint32_t voltage);
+
+   void onWokeUp(uchar source);
 };
 
 #endif // ATBDEVICECONTROLLERPLUGIN_H

src/ATBAPP/ATBMachineEvent.cpp

@@ -0,0 +1,69 @@
+/* Machine Event
+ *
+ * Used e.g. to send events to ISMAS
+ *
+ * Note: It's an Event, not a State!
+ * -> An Event may cause a transition to a different state, depending on the current state.
+ * -> Compare to edge/level trigger: Event is an "edge", State is a "level"
+ * => Do not mix both
+ *
+ */
+#include <QDateTime>
+
+#include "ATBMachineEvent.h"
+
+
+ATBMachineEvent::ATBMachineEvent(
+            const QString & id,
+            const QString & deviceName,      // PTU/PRINTER/DC/...
+            EVENT_CLASS eventClass,          // reason of event: Error/Warning/Alarm
+            const QString & name,            // 'Event': "E001", "W003"
+            const int state,
+            const QString & parameter,
+            const QString & secondLevelInfo)
+    : QEvent(ATB_MACHINE_EVENT)
+    , eventId(id)
+    , deviceName(deviceName)
+    , machineEventClass(eventClass)
+    , eventName(name)
+    , eventState(state)
+    // timestamp including timezone offset
+    , timestampString(QDateTime::currentDateTime().toOffsetFromUtc(
+                         QDateTime::currentDateTime().offsetFromUtc()).toString(Qt::ISODate)
+                     )
+    , parameterString(parameter)
+    , secondLevelInfoString(secondLevelInfo)
+{
+
+}
+
+
+QString ATBMachineEvent::getEventClassString(EVENT_CLASS eventClass)
+{
+    switch (eventClass) {
+    case EVENT_CLASS::WARNING:
+        return "WARNING";
+        break;
+    case EVENT_CLASS::ERROR:
+        return "ERROR";
+        break;
+    case EVENT_CLASS::ALARM:
+        return "ALARM";
+        break;
+    case EVENT_CLASS::DEBUG:
+        return "DEBUG";
+        break;
+    case EVENT_CLASS::STATE:
+        return "STATE";
+        break;
+    case EVENT_CLASS::OPERATE:
+        return "OPERATE";
+        break;
+    case EVENT_CLASS::NOT_DEFINED:
+        return "NOT_DEFINED";
+        break;
+    }
+
+    return "NOT_DEFINED";
+}
+

src/ATBAPP/ATBMachineEvent.h

@@ -0,0 +1,48 @@
+#ifndef ATBMACHINECONDITIONEVENT_H
+#define ATBMACHINECONDITIONEVENT_H
+
+#include <QEvent>
+#include <QString>
+
+enum class EVENT_CLASS : quint8;
+
+const QEvent::Type ATB_MACHINE_EVENT = static_cast<QEvent::Type>(QEvent::User + 2);
+
+
+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
+                const QString & name,                    // 'Event': "E001", "W003"
+                const int state,
+                const QString & parameter,
+                const QString & secondLevelInfo
+            );
+
+    QString eventId;
+    QString deviceName;
+    EVENT_CLASS machineEventClass;
+    QString eventName;
+    int eventState;
+    QString timestampString;
+    QString parameterString;
+    QString secondLevelInfoString;
+
+    static QString getEventClassString(EVENT_CLASS eventClass);
+};
+
+
+enum class EVENT_CLASS : quint8 {
+    WARNING,
+    ERROR,
+    ALARM,
+    DEBUG,
+    STATE,
+    OPERATE,
+    NOT_DEFINED
+};
+
+#endif // ATBMACHINEEVENT_H

src/ATBAPP/DeviceControllerDiag.cpp

@@ -0,0 +1,601 @@
+#include "DeviceControllerDiag.h"
+
+#include <QCoreApplication>
+#include <QMetaEnum>
+#include <QUuid>
+#include <QDebug>
+
+#include "support/JSON.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)
+    , lastState(DeviceController::State::INITIAL_STATE)
+    , _isErrorState(false)
+    , pData(pData)
+{
+    diagRequestTimeoutTimer = new QTimer(this);
+    diagRequestTimeoutTimer->setInterval(1000*45);
+    diagRequestTimeoutTimer->setSingleShot(true);
+    connect(diagRequestTimeoutTimer, &QTimer::timeout, this, &DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout);
+}
+
+
+void DeviceControllerDiag::init(hwinf *hw, QObject* eventReceiver)
+{
+    this->hw = hw;
+    this->eventReceiver = eventReceiver;
+
+    // make a system check on startup:
+    QTimer::singleShot(2000, this, &DeviceControllerDiag::diagRequest);
+}
+
+
+void DeviceControllerDiag::diagReInit()
+{
+    this->machineEventSet.clear();
+    this->_isErrorState = false;
+}
+
+void DeviceControllerDiag::setTimeout(int timeout)
+{
+    this->diagRequestTimeoutTimer->setInterval(1000 * timeout);
+}
+
+void DeviceControllerDiag::diagRequest()
+{
+    qCritical() << "DeviceControllerDiag::diagRequest()";
+
+    if (this->isRequestRunning) {
+        qCritical() << "DeviceControllerDiag::diagRequest() is already running";
+        return;
+    }
+    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();
+}
+
+
+void DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout()
+{
+    qCritical() << "DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout()";
+    this->flagInterruptDiag = true;
+}
+
+
+bool DeviceControllerDiag::isErrorState()
+{
+    return this->_isErrorState;
+}
+
+bool DeviceControllerDiag::isOperatingState()
+{
+    return !this->_isErrorState;
+}
+
+QSet<DeviceController::State> DeviceControllerDiag::getCurrentMachineState()
+{
+    return this->machineEventSet;
+}
+
+
+
+void DeviceControllerDiag::private_startDiag()
+{
+    // check for DiagRequestTimeoutTimerTimeout:
+    if (this->flagInterruptDiag) {
+        qCritical() << "DeviceControllerDiag::private_startDiag() interrupted!";
+        this->private_sendDiagEvent(DeviceController::State::E255);
+        this->isRequestRunning  = false;
+        this->flagInterruptDiag = false;
+
+        // 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()
+         */
+        return;
+    }
+
+    bool result;
+    result = hw->sys_areDCdataValid();
+
+    if (result) {
+        qCritical() << "DeviceControllerDiag::private_startDiag() DCdata is valid";
+        QTimer::singleShot(200, this, &DeviceControllerDiag::sys_superviseSystem);
+    }
+    else {
+        qCritical() << "DeviceControllerDiag::private_startDiag() DCdata is +++not+++ valid";
+
+        // try it again
+        QTimer::singleShot(200, this, &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;
+
+
+    qCritical() << "      sys_superviseSystem()";
+
+
+    // check for DiagRequestTimeoutTimerTimeout:
+    if (this->flagInterruptDiag) {
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() interrupted!";
+        this->private_sendDiagEvent(DeviceController::State::E255);
+        this->flagInterruptDiag = false;
+        this->isRequestRunning  = false;
+        return;
+    }
+
+    if (!hw->sys_areDCdataValid())
+    {
+        // es gibt keinerlei gültige Daten vom DC
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() no valid data!";
+        this->private_sendDiagEvent(DeviceController::State::E254);
+        this->diagRequestTimeoutTimer->stop();
+        this->isRequestRunning  = false;
+        return;
+    }
+
+    // jetzt sind die DC-Daten aktuell, also reinholen:
+    hw->sys_getDynMachineConditions(&dynMaCond);
+    hw->sys_getDeviceConditions(&modCond);
+
+    qCritical() << "DeviceControllerDiag::sys_superviseSystem() get condition data";
+    if (!modCond.allModulesChecked)
+    {
+        // noch keine Testergebnisse
+        if (dynMaCond.startupTestIsRunning) {
+            // TODO?
+        }
+
+
+        qCritical() << "            allModulesChecked is false --> call again";
+
+        QTimer::singleShot(200, this, &DeviceControllerDiag::sys_superviseSystem);
+        return;
+    }
+
+    qCritical() << "      --> call  sub_componentAssessment()";
+
+    sub_componentAssessment();
+}
+
+
+
+void DeviceControllerDiag::sub_componentAssessment()
+{
+    bool flag_sendOperate = true;
+
+    struct T_moduleCondition modCond;
+    hw->sys_getDeviceConditions(&modCond);
+
+    struct T_dynamicCondition dynMaCond;
+    hw->sys_getDynMachineConditions(&dynMaCond);
+
+    struct T_devices devPara;
+    hw->sys_restoreDeviceParameter(&devPara);
+
+    // store some interesting results:
+    // -> voltage:
+    uint32_t voltage = hw->dc_getVoltage();
+    emit newVoltage(voltage);
+
+
+    // check for alarm:
+
+    if (dynMaCond.onAlarm>0) {
+        flag_sendOperate = false;
+        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_sendDiagEvent(DeviceController::State::E253);
+    }
+    if (dynMaCond.middleDoor) {
+        // vault door is open
+        flag_sendOperate = false;
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() vault door is open, goto INTRUSION MODE";
+        this->private_sendDiagEvent(DeviceController::State::E252);
+    }
+
+    // check for invalid states:
+
+    if (modCond.rtc>=200) {
+        flag_sendOperate = false;
+        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_sendDiagEvent(DeviceController::State::E020);
+    }
+    if (modCond.printer==202) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E018);
+    }
+
+    if (modCond.coinBlocker>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E025);
+    }
+    if (modCond.mdbBus>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E034);
+    }
+    if (modCond.intEe>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E011);
+    }
+
+    // 2023-07-26: workaround for 00281/Szeged --------------------------------------------------------------
+    // because we need certain errors and we do get for 'kindOfCoinChecker' -> 16 !
+    qCritical() << "-----------diag: kindOfCoinChecker = " << devPara.kindOfCoinChecker;
+    qCritical() << "                  modCond.coinSafe = " << modCond.coinSafe;
+    if (devPara.kindOfCoinChecker > 0) {
+        if (modCond.coinSafe==201) { // full
+            flag_sendOperate = false;
+            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_sendDiagEvent(DeviceController::State::E009);
+        }
+        if (modCond.coinEscrow>=200) {
+            flag_sendOperate = false;
+            // coinEscrow>200 is considered a warning:
+            this->private_sendDiagEvent(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::W010);
+        }
+        if (modCond.coinSafe==201)  { // full
+            flag_sendOperate = false;
+            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_sendDiagEvent(DeviceController::State::E009);
+        }
+    } else
+    if (devPara.kindOfCoinChecker==3)
+    {
+        if (modCond.changer>=200) {
+            // Fehler Münzver.
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E026);
+        }
+        if (modCond.coinSafe==201) { // full
+            flag_sendOperate = false;
+            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_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)
+    {
+        if (modCond.billReader == 200)           // 200: kasse fehlt 201: voll  100:fast voll  1:ok
+        {
+            return TODO;
+        }
+        if (modCond.billReader == 201)           // 200: kasse fehlt 201: voll  100:fast voll  1:ok
+        {
+            return TODO;
+        }
+    }
+    */
+
+    if (dynMaCond.modeAbrech>0) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E011);
+    }
+
+    if (dynMaCond.nowCardTest>0) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E072);
+    }
+
+    if (dynMaCond.startupTestIsRunning>0) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E073);
+    }
+
+    if (modCond.voltage>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E003);
+    }
+    if (modCond.temper>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::W004);
+    }
+
+    // check for warnings
+    if (modCond.printer>=100 && modCond.printer<200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::W001);
+    }
+    if (modCond.coinSafe>=100 && modCond.coinSafe<200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::W002);
+    }
+    if (modCond.voltage>=100 && modCond.voltage<200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::W003);
+    }
+    if (modCond.temper>=100 && modCond.temper<200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::W004);
+    }
+
+    if (flag_sendOperate) {
+        this->private_sendDiagEvent(DeviceController::State::O000);
+    }
+
+
+    // finish diag
+
+    this->diagRequestTimeoutTimer->stop();
+    this->isRequestRunning  = false;
+    this->flagInterruptDiag = false;
+}
+
+
+/**
+ * @brief DeviceControllerDiag::private_sendDiagEvent
+ * @param result - result value from 'sub_componentAssessment()',
+ *               - 0x00 everything is fine
+ *               - 0xFF on timer interrupt
+ *               - 0xFE no valid data from DeviceController
+ *               - 0xFD Service or battery door is open
+ *               - 0xFE vault door is open
+ */
+void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
+{
+    qCritical() << "DeviceControllerDiag::private_sendDiagEvent() 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);
+    }
+
+
+    QString eventId = QUuid::createUuid().toString(QUuid::WithoutBraces).mid(0, 8);
+
+    QString eventName = QMetaEnum::fromType<DeviceController::State>().valueToKey(result);;
+    EVENT_CLASS eventClass = EVENT_CLASS::STATE;
+    QString parameter;
+    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::E071:   // cash box change is ongoing
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "cash box change is ongoing";
+        break;
+    case DeviceController::State::E072:   // card test running
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "card test running";
+        break;
+    case DeviceController::State::E073:   // startup-test is running
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "startup-test is running";
+        break;
+
+    case DeviceController::State::E252:   // cash box door open
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "cash box door open";
+        break;
+    case DeviceController::State::E253:   // 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
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "no valid data from DeviceController";
+        break;
+    case DeviceController::State::E255:   // no valid data from DeviceController
+        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  = "";
+        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
+        eventClass = EVENT_CLASS::WARNING;
+        parameter  = "paper low";
+        break;
+    case DeviceController::State::W002:   // cashbox almost full
+        eventClass = EVENT_CLASS::WARNING;
+        parameter  = "cashbox almost full";
+        break;
+    case DeviceController::State::W003:   // voltage low
+        eventClass = EVENT_CLASS::WARNING;
+        parameter  = "voltage low";
+        break;
+    case DeviceController::State::W004:   // temperatur warning
+        eventClass = EVENT_CLASS::WARNING;
+        parameter  = "temperatur warning";
+        break;
+    }
+
+    this->lastState = result;
+
+    /**
+     * 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,
+                parameter,
+                ""         // second level info
+                );
+
+    QCoreApplication::postEvent(eventReceiver, machineEvent);
+
+}
+
+

src/ATBAPP/DeviceControllerDiag.h

@@ -0,0 +1,132 @@
+#ifndef DEVICECONTROLLERDIAG_H
+#define DEVICECONTROLLERDIAG_H
+
+#include <QObject>
+#include <QSet>
+#include <QTimer>
+
+#include <DeviceController/interfaces.h>
+
+#include "DeviceControllerInterface.h"
+#include "ATBMachineEvent.h"
+
+#include "support/PersistentData.h"
+
+
+namespace DeviceController {
+    Q_NAMESPACE
+
+    enum State {
+        O000,
+
+        A000,
+
+        E002,
+        E003,
+        E004,
+
+        E007,
+        E008,
+        E009,
+        E010,
+        W010,   // Coin Escrow
+        E011,
+
+        E018,
+
+        E020,
+
+        E025,
+        E026,
+
+        E034,
+
+        E071,
+        E072,
+        E073,
+
+        E252,
+        E253,
+        E254,
+        E255,
+
+        W001,
+        W002,
+        W003,
+        W004,
+
+        INITIAL_STATE
+    };
+    Q_ENUM_NS(State)
+}
+
+
+class DeviceControllerDiag : public QObject
+{
+    Q_OBJECT
+
+public:
+    DeviceControllerDiag(PersistentData *pData, QObject *parent = nullptr);
+
+    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<DeviceController::State> 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();
+
+signals:
+    void diagResponse(ATBMachineEvent* machineEvent);
+
+    void newVoltage(uint32_t voltage);
+
+private:
+    QObject *eventReceiver;
+    hwinf* hw;
+
+    bool isRequestRunning;
+    bool flagInterruptDiag;
+
+    QTimer *diagRequestTimeoutTimer;
+
+    void sub_componentAssessment(); // diag exit method
+
+    int lastVoltage;
+
+    DeviceController::State lastState;
+    QSet<DeviceController::State> machineEventSet;
+    bool _isErrorState;
+
+    PersistentData* pData;
+
+private slots:
+    void onDiagRequestTimeoutTimerTimeout();
+
+    void private_startDiag();                                    // diag entry method
+    void private_sendDiagEvent(DeviceController::State result);
+
+    void sys_superviseSystem();
+
+
+};
+
+#endif // DEVICECONTROLLERDIAG_H

src/ATBAPP/DeviceControllerInterface.h

@@ -5,6 +5,7 @@
 
 #include <QSettings>
 #include <QString>
+#include <QJsonObject>
 
 #include "ATBAPPplugin.h"
 
@@ -12,19 +13,39 @@ namespace nsDeviceControllerInterface {
     enum class PLUGIN_STATE : quint8;
     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;
 }
 
 
-class DeviceControllerInterface : public ATBAPPplugin
+class DeviceControllerInterface : public QObject
+                                , public ATBAPPplugin
 {
+    Q_OBJECT
     Q_INTERFACES(ATBAPPplugin)
 
 public:
     virtual ~DeviceControllerInterface() {}
 
-    virtual nsDeviceControllerInterface::PLUGIN_STATE initDCPlugin(QObject *healthEventReceiver,
+    /**
+     * @brief initDCPlugin
+     * @param eventReceiver - QObject to receive ATBMachineEvents or HealthEvents
+     * @param settings
+     * @return
+     */
+    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
@@ -51,7 +72,13 @@ 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 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;
@@ -70,20 +97,32 @@ public slots:
     virtual void onChangedProgramModeToIDLE() = 0;
     virtual void onChangedProgramModeToOOO() = 0;
 
+    virtual void startPhysicalLayer() = 0;
+    virtual void stopPhysicalLayer() = 0;
+    virtual void reboot() = 0;
+    virtual void reset() = 0;
+
+
 signals:
-    virtual void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+    void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
                                      const QString & errorCode,
-                                     const QString & errorDescription) = 0;
+                                     const QString & errorDescription);
+    void printReceiptFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+
+
+    void coinAttached();
 
     /**
      * emitted on e.g. a coin input
      */
-    virtual void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
+    void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
                                 nsDeviceControllerInterface::CASH_STATE cashState,
                                 const QString & newCashValue,
                                 /* additional variables? */
                                 const QString & errorCode,
-                                const QString & errorDescription) = 0;
+                                const QString & errorDescription);
 
     /**
      * emitted if cashInput has been stopped, e.g. in result to task requestStopCashInput():
@@ -91,32 +130,61 @@ signals:
      *  -> no cash input is possible
      *  -> coins are in cache
      */
-    virtual void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+    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) = 0;
+                                     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 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
      */
-    virtual void requestModeSERVICE() = 0;
+    void requestModeSERVICE();
+
+    /**
+     * emitted e.g. if vault door is opened
+     */
+    void requestModeACCOUNT();
 
     /**
      * emitted e.g. if doors are closed
      */
-    virtual void requestModeIDLE() = 0;
+    void requestModeIDLE();
 
     /**
      * emitted e.g. on severe errors
      */
-    virtual void requestModeOOO() = 0;
+    void requestModeOOO();
 
     /**
      * emitted e.g. if service door is opened
      */
-    virtual void requestAccountResponse(const QHash<QString, QVariant> & accountData) = 0;
+    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
@@ -126,16 +194,16 @@ signals:
      * -> send error event to ISMAS
      * -> ...
      */
-    virtual void Error(
+    void Error(
             /*  additional variables? */
             const QString & errorCode,
-            const QString & errorDescription) = 0;
+            const QString & errorDescription);
 
 };
 
 
 Q_DECLARE_INTERFACE(DeviceControllerInterface,
-                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.0")
+                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.1.4")
 
 
 namespace nsDeviceControllerInterface {
@@ -160,6 +228,35 @@ namespace nsDeviceControllerInterface {
         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
+        FOOD_STAMP
+    };
+
+    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/Utils.cpp

@@ -9,8 +9,8 @@ Utils::Utils(QObject *parent) : QObject(parent)
 
 int Utils::compare(const void* a, const void* b)
 {
-    int int_a = * ( (int*) a );
-    int int_b = * ( (int*) b );
+    uint16_t int_a = * ( (uint16_t*) a );
+    uint16_t int_b = * ( (uint16_t*) b );
 
     if ( int_a == int_b ) return 0;
     else if ( int_a < int_b ) return -1;

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/DBusController.xml

@@ -0,0 +1,14 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+  <interface name="eu.atb.ptu.systemcontrol">
+    <signal name="wokeUpFrom">
+      <arg name="source" type="y" direction="out"/>
+    </signal>
+    <method name="startBackgroundTask">
+      <arg name="id" type="s" direction="in"/>
+    </method>
+    <method name="finishedBackgroundTask">
+      <arg name="id" type="s" direction="in"/>
+    </method>
+  </interface>
+</node>

src/ATBAPP/support/DBusControllerInterface.cpp

@@ -0,0 +1,26 @@
+/*
+ * This file was generated by qdbusxml2cpp version 0.7
+ * Command line was: qdbusxml2cpp -p DBusControllerInterface -c DBusControllerInterface DBusController.xml
+ *
+ * qdbusxml2cpp is Copyright (C) 2015 The Qt Company Ltd.
+ *
+ * This is an auto-generated file.
+ * This file may have been hand-edited. Look for HAND-EDIT comments
+ * before re-generating it.
+ */
+
+#include "DBusControllerInterface.h"
+
+/*
+ * Implementation of interface class DBusControllerInterface
+ */
+
+DBusControllerInterface::DBusControllerInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent)
+    : QDBusAbstractInterface(service, path, staticInterfaceName(), connection, parent)
+{
+}
+
+DBusControllerInterface::~DBusControllerInterface()
+{
+}
+

src/ATBAPP/support/DBusControllerInterface.h

@@ -0,0 +1,64 @@
+/*
+ * This file was generated by qdbusxml2cpp version 0.7
+ * Command line was: qdbusxml2cpp -p DBusControllerInterface -c DBusControllerInterface DBusController.xml
+ *
+ * qdbusxml2cpp is Copyright (C) 2015 The Qt Company Ltd.
+ *
+ * This is an auto-generated file.
+ * Do not edit! All changes made to it will be lost.
+ */
+
+#ifndef DBUSCONTROLLERINTERFACE_H
+#define DBUSCONTROLLERINTERFACE_H
+
+#include <QtCore/QObject>
+#include <QtCore/QByteArray>
+#include <QtCore/QList>
+#include <QtCore/QMap>
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QVariant>
+#include <QtDBus/QtDBus>
+
+/*
+ * Proxy class for interface eu.atb.ptu.systemcontrol
+ */
+class DBusControllerInterface: public QDBusAbstractInterface
+{
+    Q_OBJECT
+public:
+    static inline const char *staticInterfaceName()
+    { return "eu.atb.ptu.systemcontrol"; }
+
+public:
+    DBusControllerInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = 0);
+
+    ~DBusControllerInterface();
+
+public Q_SLOTS: // METHODS
+    inline QDBusPendingReply<> finishedBackgroundTask(const QString &id)
+    {
+        QList<QVariant> argumentList;
+        argumentList << QVariant::fromValue(id);
+        return asyncCallWithArgumentList(QLatin1String("finishedBackgroundTask"), argumentList);
+    }
+
+    inline QDBusPendingReply<> startBackgroundTask(const QString &id)
+    {
+        QList<QVariant> argumentList;
+        argumentList << QVariant::fromValue(id);
+        return asyncCallWithArgumentList(QLatin1String("startBackgroundTask"), argumentList);
+    }
+
+Q_SIGNALS: // SIGNALS
+    void wokeUpFrom(uchar source);
+};
+
+namespace eu {
+  namespace atb {
+    namespace ptu {
+      typedef ::DBusControllerInterface systemcontrol;
+    }
+  }
+}
+#endif

src/ATBAPP/support/JSON.cpp

@@ -0,0 +1,735 @@
+#include <QDateTime>
+#include <QStringList>
+#include "JSON.h"
+
+
+
+namespace JSON {
+    static QString dateFormat, dateTimeFormat;
+    static bool prettySerialize = false;
+
+    static QString sanitizeString(QString str);
+    static QByteArray join(const QList<QByteArray> &list, const QByteArray &sep);
+    static QVariant parseValue(const QString &json, int &index, bool &success);
+    static QVariant parseObject(const QString &json, int &index, bool &success);
+    static QVariant parseArray(const QString &json, int &index, bool &success);
+    static QVariant parseString(const QString &json, int &index, bool &success);
+    static QVariant parseNumber(const QString &json, int &index);
+    static int lastIndexOfNumber(const QString &json, int index);
+    static void eatWhitespace(const QString &json, int &index);
+    static int lookAhead(const QString &json, int index);
+    static int nextToken(const QString &json, int &index);
+
+
+    template<typename T>
+    QByteArray serializeMap(const T &map, bool &success, int _level = 0) {
+        QByteArray newline;
+        QByteArray tabs;
+        QByteArray tabsFields;
+        if (prettySerialize && !map.isEmpty()) {
+            newline = "\n";
+            for (int l=1; l<_level; l++) {
+                tabs += "    ";
+            }
+            tabsFields = tabs + "    ";
+        }
+
+        QByteArray str = "{" + newline;
+        QList<QByteArray> pairs;
+        for (typename T::const_iterator it = map.begin(), itend = map.end(); it != itend; ++it) {
+            bool otherSuccess = true;
+            QByteArray serializedValue = serialize(it.value(), otherSuccess, _level);
+            if (serializedValue.isNull()) {
+                success = false;
+                break;
+            }
+            pairs << tabsFields + sanitizeString(it.key()).toUtf8() + ":" + (prettySerialize ? " " : "") + serializedValue;
+        }
+
+        str += join(pairs, "," + newline) + newline;
+        str += tabs + "}";
+        return str;
+    }
+
+
+    void insert(QVariant &v, const QString &key, const QVariant &value);
+    void append(QVariant &v, const QVariant &value);
+
+    template<typename T>
+    void cloneMap(QVariant &json, const T &map) {
+    for (typename T::const_iterator it = map.begin(), itend = map.end(); it != itend; ++it) {
+        insert(json, it.key(), (*it));
+    }
+    }
+
+    template<typename T>
+    void cloneList(QVariant &json, const T &list) {
+    for (typename T::const_iterator it = list.begin(), itend = list.end(); it != itend; ++it) {
+        append(json, (*it));
+    }
+    }
+
+
+    /**
+     * parse
+     */
+    QVariant parse(const QString &json) {
+        bool success = true;
+        return parse(json, success);
+    }
+
+    /**
+     * parse
+     */
+    QVariant parse(const QString &json, bool &success) {
+        success = true;
+
+        // Return an empty QVariant if the JSON data is either null or empty
+        if (!json.isNull() || !json.isEmpty()) {
+            QString data = json;
+            // We'll start from index 0
+            int index = 0;
+
+            // Parse the first value
+            QVariant value = parseValue(data, index, success);
+
+            // Return the parsed value
+            return value;
+        } else {
+            // Return the empty QVariant
+            return QVariant();
+        }
+    }
+
+
+
+    /**
+     * clone
+     */
+    QVariant clone(const QVariant &data) {
+    QVariant v;
+
+    if (data.type() == QVariant::Map) {
+        cloneMap(v, data.toMap());
+    } else if (data.type() == QVariant::Hash) {
+        cloneMap(v, data.toHash());
+    } else if (data.type() == QVariant::List) {
+        cloneList(v, data.toList());
+    } else if (data.type() == QVariant::StringList) {
+        cloneList(v, data.toStringList());
+    } else {
+        v = QVariant(data);
+    }
+
+    return v;
+    }
+
+    /**
+     * insert value (map case)
+     */
+    void insert(QVariant &v, const QString &key, const QVariant &value) {
+    if (!v.canConvert<QVariantMap>()) v = QVariantMap();
+    QVariantMap *p = (QVariantMap *)v.data();
+    p->insert(key, clone(value));
+    }
+
+    /**
+     * append value (list case)
+     */
+    void append(QVariant &v, const QVariant &value) {
+    if (!v.canConvert<QVariantList>()) v = QVariantList();
+    QVariantList *p = (QVariantList *)v.data();
+    p->append(value);
+    }
+
+    QByteArray serialize(const QVariant &data) {
+        bool success = true;
+        return serialize(data, success);
+    }
+
+
+
+    QByteArray serialize(const QVariant &data, bool &success, int _level /*= 0*/) {
+        QByteArray newline;
+        QByteArray tabs;
+        QByteArray tabsFields;
+        if (prettySerialize) {
+            newline = "\n";
+            for (int l=0; l<_level; l++) {
+                tabs += "    ";
+            }
+            tabsFields = tabs + "    ";
+        }
+
+        QByteArray str;
+        success = true;
+
+        if (!data.isValid()) { // invalid or null?
+            str = "null";
+        } else if ((data.type() == QVariant::List) ||
+                   (data.type() == QVariant::StringList)) { // variant is a list?
+            QList<QByteArray> values;
+            const QVariantList list = data.toList();
+            Q_FOREACH(const QVariant& v, list) {
+                bool otherSuccess = true;
+                QByteArray serializedValue = serialize(v, otherSuccess, _level+1);
+                if (serializedValue.isNull()) {
+                    success = false;
+                    break;
+                }
+                values << tabsFields + serializedValue;
+            }
+
+            if (!values.isEmpty()) {
+                str = "[" + newline + join( values, "," + newline ) + newline + tabs + "]";
+            } else {
+                str = "[]";
+            }
+        } else if (data.type() == QVariant::Hash) { // variant is a hash?
+            str = serializeMap<>(data.toHash(), success, _level+1);
+        } else if (data.type() == QVariant::Map) { // variant is a map?
+            str = serializeMap<>(data.toMap(), success, _level+1);
+        } else if ((data.type() == QVariant::String) ||
+                   (data.type() == QVariant::ByteArray)) {// a string or a byte array?
+            str = sanitizeString(data.toString()).toUtf8();
+        } else if (data.type() == QVariant::Double) { // double?
+            double value = data.toDouble(&success);
+            if (success) {
+                str = QByteArray::number(value, 'g');
+                if (!str.contains(".") && ! str.contains("e")) {
+                    str += ".0";
+                }
+            }
+        } else if (data.type() == QVariant::Bool) { // boolean value?
+            str = data.toBool() ? "true" : "false";
+        } else if (data.type() == QVariant::ULongLong) { // large unsigned number?
+            str = QByteArray::number(data.value<qulonglong>());
+        } else if (data.canConvert<qlonglong>()) { // any signed number?
+            str = QByteArray::number(data.value<qlonglong>());
+        } else if (data.canConvert<long>()) { //TODO: this code is never executed because all smaller types can be converted to qlonglong
+            str = QString::number(data.value<long>()).toUtf8();
+        } else if (data.type() == QVariant::DateTime) { // datetime value?
+            str = sanitizeString(dateTimeFormat.isEmpty()
+                                 ? data.toDateTime().toString()
+                                 : data.toDateTime().toString(dateTimeFormat)).toUtf8();
+        } else if (data.type() == QVariant::Date) { // date value?
+            str = sanitizeString(dateTimeFormat.isEmpty()
+                                 ? data.toDate().toString()
+                                 : data.toDate().toString(dateFormat)).toUtf8();
+        } else if (data.canConvert<QString>()) { // can value be converted to string?
+            // this will catch QUrl, ... (all other types which can be converted to string)
+            str = sanitizeString(data.toString()).toUtf8();
+        } else {
+            success = false;
+        }
+
+        if (success) {
+            return str;
+        }
+        return QByteArray();
+    }
+
+    QString serializeStr(const QVariant &data) {
+        return QString::fromUtf8(serialize(data));
+    }
+
+    QString serializeStr(const QVariant &data, bool &success) {
+        return QString::fromUtf8(serialize(data, success));
+    }
+
+
+
+
+    /**
+     * \enum JsonToken
+     */
+    enum JsonToken {
+        JsonTokenNone = 0,
+        JsonTokenCurlyOpen = 1,
+        JsonTokenCurlyClose = 2,
+        JsonTokenSquaredOpen = 3,
+        JsonTokenSquaredClose = 4,
+        JsonTokenColon = 5,
+        JsonTokenComma = 6,
+        JsonTokenString = 7,
+        JsonTokenNumber = 8,
+        JsonTokenTrue = 9,
+        JsonTokenFalse = 10,
+        JsonTokenNull = 11
+    };
+
+    static QString sanitizeString(QString str) {
+        str.replace(QLatin1String("\\"), QLatin1String("\\\\"));
+        str.replace(QLatin1String("\""), QLatin1String("\\\""));
+        str.replace(QLatin1String("\b"), QLatin1String("\\b"));
+        str.replace(QLatin1String("\f"), QLatin1String("\\f"));
+        str.replace(QLatin1String("\n"), QLatin1String("\\n"));
+        str.replace(QLatin1String("\r"), QLatin1String("\\r"));
+        str.replace(QLatin1String("\t"), QLatin1String("\\t"));
+        return QString(QLatin1String("\"%1\"")).arg(str);
+    }
+
+
+
+    static QByteArray join(const QList<QByteArray> &list, const QByteArray &sep) {
+        QByteArray res;
+        Q_FOREACH(const QByteArray &i, list) {
+            if (!res.isEmpty()) {
+                res += sep;
+            }
+            res += i;
+        }
+        return res;
+    }
+
+
+
+
+    /**
+     * parseValue
+     */
+    static QVariant parseValue(const QString &json, int &index, bool &success) {
+        // Determine what kind of data we should parse by
+        // checking out the upcoming token
+        switch(lookAhead(json, index)) {
+            case JsonTokenString:
+                return parseString(json, index, success);
+            case JsonTokenNumber:
+                return parseNumber(json, index);
+            case JsonTokenCurlyOpen:
+                return parseObject(json, index, success);
+            case JsonTokenSquaredOpen:
+                return parseArray(json, index, success);
+            case JsonTokenTrue:
+                nextToken(json, index);
+                return QVariant(true);
+            case JsonTokenFalse:
+                nextToken(json, index);
+                return QVariant(false);
+            case JsonTokenNull:
+                nextToken(json, index);
+                return QVariant();
+            case JsonTokenNone:
+                break;
+        }
+
+        // If there were no tokens, flag the failure and return an empty QVariant
+        success = false;
+        return QVariant();
+    }
+
+
+
+
+    /**
+     * parseObject
+     */
+    static QVariant parseObject(const QString &json, int &index, bool &success) {
+        QVariantMap map;
+        int token;
+
+        // Get rid of the whitespace and increment index
+        nextToken(json, index);
+
+        // Loop through all of the key/value pairs of the object
+        bool done = false;
+        while (!done) {
+            // Get the upcoming token
+            token = lookAhead(json, index);
+
+            if (token == JsonTokenNone) {
+                success = false;
+                return QVariantMap();
+            } else if (token == JsonTokenComma) {
+                nextToken(json, index);
+            } else if (token == JsonTokenCurlyClose) {
+                nextToken(json, index);
+                return map;
+            } else {
+                // Parse the key/value pair's name
+                QString name = parseString(json, index, success).toString();
+
+                if (!success) {
+                    return QVariantMap();
+                }
+
+                // Get the next token
+                token = nextToken(json, index);
+
+                // If the next token is not a colon, flag the failure
+                // return an empty QVariant
+                if (token != JsonTokenColon) {
+                    success = false;
+                    return QVariant(QVariantMap());
+                }
+
+                // Parse the key/value pair's value
+                QVariant value = parseValue(json, index, success);
+
+                if (!success) {
+                    return QVariantMap();
+                }
+
+                // Assign the value to the key in the map
+                map[name] = value;
+            }
+        }
+
+        // Return the map successfully
+        return QVariant(map);
+    }
+
+
+    /**
+     * parseArray
+     */
+    static QVariant parseArray(const QString &json, int &index, bool &success) {
+        QVariantList list;
+
+        nextToken(json, index);
+
+        bool done = false;
+        while(!done) {
+            int token = lookAhead(json, index);
+
+            if (token == JsonTokenNone) {
+                success = false;
+                return QVariantList();
+            } else if (token == JsonTokenComma) {
+                nextToken(json, index);
+            } else if (token == JsonTokenSquaredClose) {
+                nextToken(json, index);
+                break;
+            } else {
+                QVariant value = parseValue(json, index, success);
+                if (!success) {
+                    return QVariantList();
+                }
+                list.push_back(value);
+            }
+        }
+
+        return QVariant(list);
+    }
+
+
+
+
+    /**
+     * parseString
+     */
+    static QVariant parseString(const QString &json, int &index, bool &success) {
+        QString s;
+        QChar c;
+
+        eatWhitespace(json, index);
+
+        c = json[index++];
+
+        bool complete = false;
+        while(!complete) {
+            if (index == json.size()) {
+                break;
+            }
+
+            c = json[index++];
+
+            if (c == '\"') {
+                complete = true;
+                break;
+            } else if (c == '\\') {
+                if (index == json.size()) {
+                    break;
+                }
+
+                c = json[index++];
+
+                if (c == '\"') {
+                    s.append('\"');
+                } else if (c == '\\') {
+                    s.append('\\');
+                } else if (c == '/') {
+                    s.append('/');
+                } else if (c == 'b') {
+                    s.append('\b');
+                } else if (c == 'f') {
+                    s.append('\f');
+                } else if (c == 'n') {
+                    s.append('\n');
+                } else if (c == 'r') {
+                    s.append('\r');
+                } else if (c == 't') {
+                    s.append('\t');
+                } else if (c == 'u') {
+                    int remainingLength = json.size() - index;
+                    if (remainingLength >= 4) {
+                        QString unicodeStr = json.mid(index, 4);
+
+                        int symbol = unicodeStr.toInt(0, 16);
+
+                        s.append(QChar(symbol));
+
+                        index += 4;
+                    } else {
+                        break;
+                    }
+                }
+            } else {
+                s.append(c);
+            }
+        }
+
+        if (!complete) {
+            success = false;
+            return QVariant();
+        }
+
+        return QVariant(s);
+    }
+
+
+
+    /**
+     * parseNumber
+     */
+    static QVariant parseNumber(const QString &json, int &index) {
+        eatWhitespace(json, index);
+
+        int lastIndex = lastIndexOfNumber(json, index);
+        int charLength = (lastIndex - index) + 1;
+        QString numberStr;
+
+        numberStr = json.mid(index, charLength);
+
+        index = lastIndex + 1;
+        bool ok;
+
+        if (numberStr.contains('.')) {
+            return QVariant(numberStr.toDouble(NULL));
+        } else if (numberStr.startsWith('-')) {
+            int i = numberStr.toInt(&ok);
+            if (!ok) {
+                qlonglong ll = numberStr.toLongLong(&ok);
+                return ok ? ll : QVariant(numberStr);
+            }
+            return i;
+        } else {
+            uint u = numberStr.toUInt(&ok);
+            if (!ok) {
+                qulonglong ull = numberStr.toULongLong(&ok);
+                return ok ? ull : QVariant(numberStr);
+            }
+            return u;
+        }
+    }
+
+    /**
+     * lastIndexOfNumber
+     */
+    static int lastIndexOfNumber(const QString &json, int index) {
+        int lastIndex;
+
+        for(lastIndex = index; lastIndex < json.size(); lastIndex++) {
+            if (QString("0123456789+-.eE").indexOf(json[lastIndex]) == -1) {
+                break;
+            }
+        }
+
+        return lastIndex -1;
+    }
+
+    /**
+     * eatWhitespace
+     */
+    static void eatWhitespace(const QString &json, int &index) {
+        for(; index < json.size(); index++) {
+            if (QString(" \t\n\r").indexOf(json[index]) == -1) {
+                break;
+            }
+        }
+    }
+
+    /**
+     * lookAhead
+     */
+    static int lookAhead(const QString &json, int index) {
+        int saveIndex = index;
+        return nextToken(json, saveIndex);
+    }
+
+    /**
+     * nextToken
+     */
+    static int nextToken(const QString &json, int &index) {
+        eatWhitespace(json, index);
+
+        if (index == json.size()) {
+            return JsonTokenNone;
+        }
+
+        QChar c = json[index];
+        index++;
+        switch(c.toLatin1()) {
+            case '{': return JsonTokenCurlyOpen;
+            case '}': return JsonTokenCurlyClose;
+            case '[': return JsonTokenSquaredOpen;
+            case ']': return JsonTokenSquaredClose;
+            case ',': return JsonTokenComma;
+            case '"': return JsonTokenString;
+            case '0': case '1': case '2': case '3': case '4':
+            case '5': case '6': case '7': case '8': case '9':
+            case '-': return JsonTokenNumber;
+            case ':': return JsonTokenColon;
+        }
+        index--; // ^ WTF?
+
+        int remainingLength = json.size() - index;
+
+        // True
+        if (remainingLength >= 4) {
+            if (json[index] == 't' && json[index + 1] == 'r' &&
+                json[index + 2] == 'u' && json[index + 3] == 'e') {
+                index += 4;
+                return JsonTokenTrue;
+            }
+        }
+
+        // False
+        if (remainingLength >= 5) {
+            if (json[index] == 'f' && json[index + 1] == 'a' &&
+                json[index + 2] == 'l' && json[index + 3] == 's' &&
+                json[index + 4] == 'e') {
+                index += 5;
+                return JsonTokenFalse;
+            }
+        }
+
+        // Null
+        if (remainingLength >= 4) {
+            if (json[index] == 'n' && json[index + 1] == 'u' &&
+                json[index + 2] == 'l' && json[index + 3] == 'l') {
+                index += 4;
+                return JsonTokenNull;
+            }
+        }
+
+        return JsonTokenNone;
+    }
+
+    void setDateTimeFormat(const QString &format) {
+        dateTimeFormat = format;
+    }
+
+    void setDateFormat(const QString &format) {
+        dateFormat = format;
+    }
+
+    QString getDateTimeFormat() {
+        return dateTimeFormat;
+    }
+
+    QString getDateFormat() {
+        return dateFormat;
+    }
+
+    void setPrettySerialize(bool enabled) {
+        prettySerialize = enabled;
+    }
+
+    bool isPrettySerialize() {
+        return prettySerialize;
+    }
+
+
+
+    QQueue<BuilderJsonObject *> BuilderJsonObject::created_list;
+
+    BuilderJsonObject::BuilderJsonObject() {
+        // clean objects previous "created"
+        while (!BuilderJsonObject::created_list.isEmpty()) {
+            delete BuilderJsonObject::created_list.dequeue();
+        }
+    }
+
+    BuilderJsonObject::BuilderJsonObject(JsonObject &json) {
+        BuilderJsonObject();
+
+        obj = json;
+    }
+
+    BuilderJsonObject *BuilderJsonObject::set(const QString &key, const QVariant &value) {
+        obj[key] = value;
+
+        return this;
+    }
+
+    BuilderJsonObject *BuilderJsonObject::set(const QString &key, BuilderJsonObject *builder) {
+        return set(key, builder->create());
+    }
+
+    BuilderJsonObject *BuilderJsonObject::set(const QString &key, BuilderJsonArray *builder) {
+        return set(key, builder->create());
+    }
+
+    JsonObject BuilderJsonObject::create() {
+        BuilderJsonObject::created_list.enqueue(this);
+
+        return obj;
+    }
+
+
+    QQueue<BuilderJsonArray *> BuilderJsonArray::created_list;
+
+    BuilderJsonArray::BuilderJsonArray() {
+        // clean objects previous "created"
+        while (!BuilderJsonArray::created_list.isEmpty()) {
+            delete BuilderJsonArray::created_list.dequeue();
+        }
+    }
+
+    BuilderJsonArray::BuilderJsonArray(JsonArray &json) {
+        BuilderJsonArray();
+
+        array = json;
+    }
+
+    BuilderJsonArray *BuilderJsonArray::add(const QVariant &element) {
+        array.append(element);
+
+        return this;
+    }
+
+    BuilderJsonArray *BuilderJsonArray::add(BuilderJsonObject *builder) {
+        return add(builder->create());
+    }
+
+    BuilderJsonArray *BuilderJsonArray::add(BuilderJsonArray *builder) {
+        return add(builder->create());
+    }
+
+    JsonArray BuilderJsonArray::create() {
+        BuilderJsonArray::created_list.enqueue(this);
+
+        return array;
+    }
+
+
+
+
+    BuilderJsonObject *objectBuilder() {
+        return new BuilderJsonObject();
+    }
+
+    BuilderJsonObject *objectBuilder(JsonObject &json) {
+        return new BuilderJsonObject(json);
+    }
+
+    BuilderJsonArray *arrayBuilder() {
+        return new BuilderJsonArray();
+    }
+
+    BuilderJsonArray *arrayBuilder(JsonArray &json) {
+        return new BuilderJsonArray(json);
+    }
+
+} //end namespace

src/ATBAPP/support/JSON.h

@@ -0,0 +1,250 @@
+#ifndef JSON_H
+#define JSON_H
+
+
+#include <QVariant>
+#include <QString>
+#include <QQueue>
+
+/**********************************************
+ * based on: https://github.com/qt-json/qt-json
+ */
+
+/**
+ * \namespace JSON
+ * \brief A JSON data parser
+ *
+ * Json parses a JSON data into a QVariant hierarchy.
+ */
+namespace JSON {
+    typedef QVariantMap JsonObject;
+    typedef QVariantList JsonArray;
+
+
+    /**
+     * Clone a JSON object (makes a deep copy)
+     *
+     * \param data The JSON object
+     */
+    QVariant clone(const QVariant &data);
+
+    /**
+     * Insert value to JSON object (QVariantMap)
+     *
+     * \param v The JSON object
+     * \param key The key
+     * \param value The value
+     */
+    void insert(QVariant &v, const QString &key, const QVariant &value);
+
+    /**
+     * Append value to JSON array (QVariantList)
+     *
+     * \param v The JSON array
+     * \param value The value
+     */
+    void append(QVariant &v, const QVariant &value);
+
+    /**
+     * Parse a JSON string
+     *
+     * \param json The JSON data
+     */
+    QVariant parse(const QString &json);
+
+    /**
+     * Parse a JSON string
+     *
+     * \param json The JSON data
+     * \param success The success of the parsing
+     */
+    QVariant parse(const QString &json, bool &success);
+
+    /**
+     * This method generates a textual JSON representation
+     *
+     * \param data The JSON data generated by the parser.
+     *
+     * \return QByteArray Textual JSON representation in UTF-8
+     */
+    QByteArray serialize(const QVariant &data);
+
+    /**
+     * This method generates a textual JSON representation
+     *
+     * \param data The JSON data generated by the parser.
+     * \param success The success of the serialization
+     *
+     * \return QByteArray Textual JSON representation in UTF-8
+     */
+    QByteArray serialize(const QVariant &data, bool &success, int _level = 0);
+
+    /**
+     * This method generates a textual JSON representation
+     *
+     * \param data The JSON data generated by the parser.
+     *
+     * \return QString Textual JSON representation
+     */
+    QString serializeStr(const QVariant &data);
+
+    /**
+     * This method generates a textual JSON representation
+     *
+     * \param data The JSON data generated by the parser.
+     * \param success The success of the serialization
+     *
+     * \return QString Textual JSON representation
+     */
+    QString serializeStr(const QVariant &data, bool &success, int _level = 0);
+
+    /**
+     * This method sets date(time) format to be used for QDateTime::toString
+     * If QString is empty, Qt::TextDate is used.
+     *
+     * \param format The JSON data generated by the parser.
+     */
+    void setDateTimeFormat(const QString& format);
+    void setDateFormat(const QString& format);
+
+    /**
+     * This method gets date(time) format to be used for QDateTime::toString
+     * If QString is empty, Qt::TextDate is used.
+     */
+    QString getDateTimeFormat();
+    QString getDateFormat();
+
+    /**
+     * @brief setPrettySerialize enable/disabled pretty-print when serialize() a json
+     * @param enabled
+     */
+    void setPrettySerialize(bool enabled);
+
+    /**
+     * @brief isPrettySerialize check if is enabled pretty-print when serialize() a json
+     * @return
+     */
+    bool isPrettySerialize();
+
+
+
+    /**
+     * QVariant based Json object
+     */
+    class Object : public QVariant {
+        template<typename T>
+        Object& insertKey(Object* ptr, const QString& key) {
+            T* p = (T*)ptr->data();
+            if (!p->contains(key)) p->insert(key, QVariant());
+            return *reinterpret_cast<Object*>(&p->operator[](key));
+        }
+        template<typename T>
+        void removeKey(Object *ptr, const QString& key) {
+            T* p = (T*)ptr->data();
+            p->remove(key);
+        }
+    public:
+        Object() : QVariant() {}
+        Object(const Object& ref) : QVariant(ref) {}
+
+        Object& operator=(const QVariant& rhs) {
+            /** It maybe more robust when running under Qt versions below 4.7 */
+            QObject * obj = qvariant_cast<QObject *>(rhs);
+            //  setValue(rhs);
+            setValue(obj);
+            return *this;
+        }
+        Object& operator[](const QString& key) {
+            if (type() == QVariant::Map)
+                return insertKey<QVariantMap>(this, key);
+            else if (type() == QVariant::Hash)
+                return insertKey<QVariantHash>(this, key);
+
+            setValue(QVariantMap());
+
+            return insertKey<QVariantMap>(this, key);
+        }
+        const Object& operator[](const QString& key) const {
+            return const_cast<Object*>(this)->operator[](key);
+        }
+        void remove(const QString& key) {
+            if (type() == QVariant::Map)
+                removeKey<QVariantMap>(this, key);
+            else if (type() == QVariant::Hash)
+                removeKey<QVariantHash>(this, key);
+        }
+    };
+
+
+    class BuilderJsonArray;
+
+    /**
+     * @brief The BuilderJsonObject class
+     */
+    class BuilderJsonObject {
+
+        public:
+            BuilderJsonObject();
+            BuilderJsonObject(JsonObject &json);
+
+            BuilderJsonObject *set(const QString &key, const QVariant &value);
+            BuilderJsonObject *set(const QString &key, BuilderJsonObject *builder);
+            BuilderJsonObject *set(const QString &key, BuilderJsonArray *builder);
+            JsonObject create();
+
+        private:
+            static QQueue<BuilderJsonObject *> created_list;
+
+            JsonObject obj;
+    };
+
+
+    /**
+     * @brief The BuilderJsonArray class
+     */
+    class BuilderJsonArray {
+
+        public:
+            BuilderJsonArray();
+            BuilderJsonArray(JsonArray &json);
+
+            BuilderJsonArray *add(const QVariant &element);
+            BuilderJsonArray *add(BuilderJsonObject *builder);
+            BuilderJsonArray *add(BuilderJsonArray *builder);
+            JsonArray create();
+
+        private:
+            static QQueue<BuilderJsonArray *> created_list;
+
+            JsonArray array;
+    };
+
+
+    /**
+     * @brief Create a BuilderJsonObject
+     * @return
+     */
+    BuilderJsonObject *objectBuilder();
+
+    /**
+     * @brief Create a BuilderJsonObject starting from copy of another json
+     * @return
+     */
+    BuilderJsonObject *objectBuilder(JsonObject &json);
+
+    /**
+     * @brief Create a BuilderJsonArray
+     * @return
+     */
+    BuilderJsonArray *arrayBuilder();
+
+    /**
+     * @brief Create a BuilderJsonArray starting from copy of another json
+     * @return
+     */
+    BuilderJsonArray *arrayBuilder(JsonArray &json);
+}
+
+
+
+#endif // JSON_H

src/ATBAPP/support/PTUSystem.cpp

@@ -0,0 +1,109 @@
+#include "PTUSystem.h"
+
+#include <QDebug>
+#include <QDir>
+#include <QFileInfo>
+
+
+PTUSystem::PTUSystem(QObject *parent) : QObject(parent)
+{
+
+}
+
+
+
+
+quint16 PTUSystem::readCustomerNumber()
+{
+    QString resultFilename;
+    QStringList fileNameList;
+    fileNameList << "/mnt/system_data/cust_nr"
+                 << "/etc/cust_nr";
+    for (const auto& filename : fileNameList) {
+        if (QFileInfo(filename).isReadable()) {
+            resultFilename = filename;
+            break;
+        }
+    }
+
+    QString resultString = PTUSystem::readConfigString(resultFilename);
+    return static_cast<quint16>(resultString.toInt());
+}
+
+quint16 PTUSystem::readMachineNumber()
+{
+    QString resultFilename;
+    QStringList fileNameList;
+    fileNameList << "/mnt/system_data/machine_nr"
+                 << "/etc/machine_nr";
+    for (const auto& filename : fileNameList) {
+        if (QFileInfo(filename).isReadable()) {
+            resultFilename = filename;
+            break;
+        }
+    }
+
+    QString resultString = PTUSystem::readConfigString(resultFilename);
+    return static_cast<quint16>(resultString.toInt());
+}
+
+quint16 PTUSystem::readZoneNumber()
+{
+    QString resultFilename;
+    QStringList fileNameList;
+    fileNameList << "/mnt/system_data/zone_nr"
+                 << "/etc/zone_nr";
+    for (const auto& filename : fileNameList) {
+        if (QFileInfo(filename).isReadable()) {
+            resultFilename = filename;
+            break;
+        }
+    }
+
+    QString resultString = PTUSystem::readConfigString(resultFilename);
+    return static_cast<quint16>(resultString.toInt());
+}
+
+quint16 PTUSystem::readGroupNumber()
+{
+    QString resultFilename;
+    QStringList fileNameList;
+    fileNameList << "/mnt/system_data/group_nr"
+                 << "/etc/group_nr";
+    for (const auto& filename : fileNameList) {
+        if (QFileInfo(filename).isReadable()) {
+            resultFilename = filename;
+            break;
+        }
+    }
+
+    QString resultString = PTUSystem::readConfigString(resultFilename);
+    return static_cast<quint16>(resultString.toInt());
+}
+
+
+QString PTUSystem::readConfigString(const QString & filename)
+{
+    QFileInfo fileinfo(filename);
+
+    if (! fileinfo.isReadable() ) {
+        qDebug() << "PTUSystem::readConfigString(): \"" << filename << "\" is not readable";
+        return "";
+    }
+
+    QFile file(filename);
+
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        qDebug() << "PTUSystem::readConfigString() cannot open file: " << filename;
+        return "";
+    }
+
+    QTextStream in(&file);
+
+    QString stringValue = in.readLine(100);
+    qDebug() << "PTUSystem::readConfigString() stringValue = " << stringValue;
+
+    file.close();
+
+    return stringValue;
+}

src/ATBAPP/support/PTUSystem.h

@@ -0,0 +1,24 @@
+#ifndef PTUSYSTEM_H
+#define PTUSYSTEM_H
+
+#include <QObject>
+
+class PTUSystem : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PTUSystem(QObject *parent = nullptr);
+
+    static quint16 readCustomerNumber();
+    static quint16 readMachineNumber();
+    static quint16 readZoneNumber();
+    static quint16 readGroupNumber();
+
+private:
+    static QString readConfigString(const QString & filename);
+
+signals:
+
+};
+
+#endif // PTUSYSTEM_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,169 @@
+#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
+
+    switch (this->ticketVariant) {
+    case TICKET_VARIANT::PARKING_TICKET:
+        break;
+    case TICKET_VARIANT::RECEIPT:
+        break;
+    case TICKET_VARIANT::ERROR_RECEIPT:
+        break;
+    case TICKET_VARIANT::START_RECEIPT:
+        this->_templateList << 21 << 22 << 23;
+        break;
+    case TICKET_VARIANT::STOP_RECEIPT:
+        this->_templateList << 24 << 25 << 26;
+        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 (printingData.contains("multiplicator")) {
+             multiplicatorInt = printingData["multiplicator"].toInt();
+             for (int i = 1; i < multiplicatorInt; i++) {
+                 this->_templateList << 1;
+             }
+             // last template:
+             this->_templateList << 2;
+         }
+
+         // DEBUG FOOD_STAMP:
+         qCritical() << "     --> printingData[\"multiplicator\"]" << multiplicatorInt;
+
+        break;
+    }
+
+
+    // 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::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::FOOD_STAMP:
+            debug << "TICKET_VARIANT::FOOD_STAMP";
+            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