TicketPrint: 'amount' on dynDat6 ...

Additionally to vedingPrice (Szeged).
TODO: make configurable?

DCPlugin.pro

@@ -45,7 +45,7 @@ contains( CONFIG, PTU5_YOCTO ) {
 TARGET   = ATBDeviceControllerPlugin
 #DESTDIR  = ../plugins
 INTERFACE = DeviceController
-INTERFACE_DEFINITION = $${PWD}/include/ATBAPP/DeviceControllerInterface.h
+INTERFACE_DEFINITION = $${PWD}/src/ATBAPP/DeviceControllerInterface.h
 
 DEFINES += DEVICECONTROLLERPLUGIN_LIBRARY
 
@@ -71,13 +71,25 @@ DEFINES += QT_DEPRECATED_WARNINGS
 HEADERS += \
     include/interfaces.h \
     src/ATBAPP/ATBAPPplugin.h \
+    src/ATBAPP/DeviceControllerDiag.h \
     src/ATBAPP/DeviceControllerInterface.h \
     src/ATBAPP/ATBHealthEvent.h \
-    src/ATBAPP/ATBDeviceControllerPlugin.h
+    src/ATBAPP/ATBMachineEvent.h \
+    src/ATBAPP/ATBDeviceControllerPlugin.h \
+    src/ATBAPP/Utils.h \
+    src/ATBAPP/support/DBusControllerInterface.h \
+    src/ATBAPP/support/JSON.h \
+    src/ATBAPP/support/PTUSystem.h
 
 SOURCES += \
     src/ATBAPP/ATBHealthEvent.cpp \
-    src/ATBAPP/ATBDeviceControllerPlugin.cpp
+    src/ATBAPP/ATBMachineEvent.cpp \
+    src/ATBAPP/ATBDeviceControllerPlugin.cpp \
+    src/ATBAPP/DeviceControllerDiag.cpp \
+    src/ATBAPP/Utils.cpp \
+    src/ATBAPP/support/DBusControllerInterface.cpp \
+    src/ATBAPP/support/JSON.cpp \
+    src/ATBAPP/support/PTUSystem.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.cpp

@@ -1,57 +1,114 @@
 #include "src/ATBAPP/ATBDeviceControllerPlugin.h"
 #include "src/ATBAPP/ATBHealthEvent.h"
+#include "src/ATBAPP/ATBMachineEvent.h"
+#include "src/ATBAPP/Utils.h"
+#include "src/ATBAPP/support/JSON.h"
+#include "src/ATBAPP/support/DBusControllerInterface.h"
+#include "src/ATBAPP/support/PTUSystem.h"
 
 #include <QTimer>
+#include <QThread>
 #include <QTextCodec>
 #include <QDebug>
 
 #include <QPluginLoader>
 #include <QDateTime>
+#include <QFileInfo>
+#include <QCoreApplication>
+#include <QUuid>
+
+#include <cstdlib>
 
 
-ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent) : QObject(parent),
-    pluginState(PLUGIN_STATE::NOT_INITIALIZED)
+
+ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent)
+    : isMaster(false)
+    , pluginState(PLUGIN_STATE::NOT_INITIALIZED)
+    , eventReceiver(nullptr)
 {
+    this->setParent(parent);
+
     this->pluginInfo = QString::fromUtf8(pluginInfoString.c_str());
 
     if (!this->private_loadCashAgentLib("")) {
         return;
     }
 
+    this->init_sc_dbus();
 
 
+    //connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_OK()),  this, SLOT(onPrintFinishedOK()),  Qt::QueuedConnection);
+    //connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_Err()), this, SLOT(onPrintFinishedERR()), Qt::QueuedConnection);
 
-    //connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_OK()),  this, SLOT(onPrintFinishedOK()));
-    //connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_Err()), this, SLOT(onPrintFinishedERR()));
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_gotNewCoin()),          this, SLOT(onCashGotCoin()),             Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByMax()),        this, SLOT(onCashPayStopByMax()),        Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByPushbutton()), this, SLOT(onCashPayStopByPushbutton()), Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByEscrow()),     this, SLOT(onCashPayStopByEscrow()),     Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByError()),      this, SLOT(onCashPayStopByError()),      Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByTimeout()),    this, SLOT(onCashPayStopByTimeout()),    Qt::QueuedConnection);
 
-    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_gotNewCoin()),       this, SLOT(onCashGotCoin()));
-    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByMax()),     this, SLOT(onCashPayStopByMax()));
-    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByEscrow()),  this, SLOT(onCashPayStopByEscrow()));
-    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByError()),   this, SLOT(onCashPayStopByError()));
-    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByTimeout()), this, SLOT(onCashPayStopByTimeout()));
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorServiceDoorOpened()),     this, SLOT(onServiceDoorOpened()), Qt::QueuedConnection);  // switch to ModeSERVICE
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorVaultDoorOpened()),       this, SLOT(onVaultDoorOpened()),   Qt::QueuedConnection);    // Screen?? with message
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCoinBoxRemoved()),        this, SLOT(onCoinBoxRemoved()),    Qt::QueuedConnection);     // Create/Send Account
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCoinBoxInserted()),       this, SLOT(onCoinBoxInserted()),   Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCBinAndAllDoorsClosed()), this, SLOT(onCBinAndAllDoorsClosed()), Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorAllDoorsClosed()),        this, SLOT(onAllDoorsClosed()),    Qt::QueuedConnection);     // check for errors, switch to mode IDLE
+
+    // move hw object to separate thread:
+    auto hwThread = new QThread;
+    dynamic_cast<QObject*>(hw)->moveToThread(hwThread);
+    hwThread->start();
+
+
+    this->diag = new DeviceControllerDiag(this);
+    connect(this->diag, &DeviceControllerDiag::newVoltage, this, &ATBDeviceControllerPlugin::onNewVoltage);
+
+
+    this->currentSelectedTicketType = 0;
+    this->currentCashState = CASH_STATE::CACHE_EMPTY;
 }
 
 ATBDeviceControllerPlugin::~ATBDeviceControllerPlugin() {}
 
-PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *healthEventReceiver, const QSettings & settings)
+PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *eventReceiver, const QSettings & settings)
 {
-    this->healthEventReceiver = healthEventReceiver;
+    this->eventReceiver = eventReceiver;
 
     // read variables from setting
-    QString serialPort = settings.value("DEVICE_CONTROLLER/serialPort", "ttymxc2").toString();
-    QByteArray printerEncoding = settings.value("DEVICE_CONTROLLER/printerEnconding", "ISO 8859-2").toString().toLatin1();
+    this->serialPortName = settings.value("ATBDeviceControllerPlugin/serialPort", "ttymxc2").toString();
+    QByteArray printerEncoding = settings.value("ATBDeviceControllerPlugin/printerEncoding", "ISO 8859-2").toString().toLatin1();
 
+    if (this->isMaster) {
+        // open serial port
+        hw->dc_openSerial(5, "115200", this->serialPortName, 1);
+        hw->dc_autoRequest(true);
+    }
 
-    hw->dc_autoRequest(true);
+    hw->dc_setNewCustomerNumber(PTUSystem::readCustomerNumber());
+    hw->dc_setNewMachineNumber(PTUSystem::readMachineNumber());
+    hw->dc_setNewZone(PTUSystem::readZoneNumber());
+    hw->dc_setNewBorough(PTUSystem::readGroupNumber());
 
-    // open serial port
-    hw->dc_openSerial(5, "115200", serialPort, 1);
+    hw->rtc_setDateTime();
+
+    // this is necessary to init the CashAgentLib (!)
+    hw->vend_failed();
 
 
     // text encoding for printer
     this->codec = QTextCodec::codecForName(printerEncoding);
 
+    if (this->codec == nullptr) {
+        printerEncoding = "ISO 8859-1";
+        qCritical() << "ATBDeviceControllerPlugin: ERROR: printer encoding \"" << printerEncoding << "\" is not supported!";
+        qCritical() << "     ... use default encoding: " << printerEncoding;
+        this->codec = QTextCodec::codecForName(printerEncoding);
+    }
+    else {
+        qCritical() << "ATBDeviceControllerPlugin: Set printer encoding to " << printerEncoding;
+    }
 
+    this->diag->init(this->hw, this->eventReceiver);
 
     this->pluginState = PLUGIN_STATE::INITIALIZED;
 
@@ -59,6 +116,82 @@ PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *healthEventReceive
 }
 
 
+void ATBDeviceControllerPlugin::startPhysicalLayer()
+{
+    if (!this->isMaster) return;
+
+    if (this->pluginState == PLUGIN_STATE::NOT_INITIALIZED)
+    {
+        qCritical() << "ATBDeviceControllerPlugin::startPhysicalLayer(): plugin is not initialized";
+        return;
+    }
+
+    // open serial port
+    hw->dc_openSerial(5, "115200", this->serialPortName, 1);
+
+    hw->dc_autoRequest(true);
+}
+
+void ATBDeviceControllerPlugin::stopPhysicalLayer()
+{
+    if (!this->isMaster) return;
+
+    if (this->pluginState == PLUGIN_STATE::NOT_INITIALIZED)
+    {
+        qCritical() << "ATBDeviceControllerPlugin::startPhysicalLayer(): plugin is not initialized";
+        return;
+    }
+
+    hw->dc_autoRequest(false);
+
+    hw->dc_closeSerial();
+}
+
+
+void ATBDeviceControllerPlugin::reboot()
+{
+    // note:
+    // - dc reset lasts about ~5s !
+    // - makes a power cycle to certain components, e.g. card terminal
+    hw->bl_rebootDC();
+}
+
+void ATBDeviceControllerPlugin::reset()
+{
+    // note:
+    // - dc reset lasts about ~5s !
+    // - makes a power cycle to certain components, e.g. card terminal
+    hw->dc_OrderToReset();
+}
+
+
+
+// Handle Mode-Changes --------------------------------------------------------
+
+void ATBDeviceControllerPlugin::onChangedProgramModeToSELL()
+{
+    hw->rtc_setDateTime();
+}
+
+void ATBDeviceControllerPlugin::onChangedProgramModeToSERVICE()
+{
+    //hw->dc_autoRequest(true);
+}
+
+void ATBDeviceControllerPlugin::onChangedProgramModeToIDLE()
+{
+    //hw->dc_autoRequest(false);  // <-- TODO: ???
+
+    this->diag->diagRequest();
+
+}
+
+void ATBDeviceControllerPlugin::onChangedProgramModeToOOO()
+{
+
+}
+
+
 // TASKS: Cash handling -------------------------------------------------------
 void ATBDeviceControllerPlugin::requestStartCashInput(const QString & amount)
 {
@@ -76,27 +209,431 @@ void ATBDeviceControllerPlugin::requestStopCashInput()
     hw->cash_stopPayment();
 
     // we need new cash value in application...
-    QTimer::singleShot(500, this, SLOT(onCashPayStoped()));
+    QTimer::singleShot(2500, this, SLOT(onCashPayStopedSuccess()));
 }
 
 void ATBDeviceControllerPlugin::cashCollect()
 {
     hw->vend_success();
+    this->currentCashState = CASH_STATE::CACHE_EMPTY;
 }
 
 void ATBDeviceControllerPlugin::cashAbort()
 {
     hw->vend_failed();
+    this->currentCashState = CASH_STATE::CACHE_EMPTY;
 }
 
+// Coin/Cash processing variants ----------------------------------------------
+
+nsDeviceControllerInterface::COIN_PROCESSOR ATBDeviceControllerPlugin::coinProcessor()
+{
+    return this->diag->coinProcessorType;
+}
+
+nsDeviceControllerInterface::BILL_ACCEPTOR  ATBDeviceControllerPlugin::billAcceptor()
+{
+    return this->diag->billAcceptor;
+}
+
+
 // TASKS: Account -------------------------------------------------------------
+
+// for an external account request, e.g. by an ui-button:
 void ATBDeviceControllerPlugin::requestAccount()
 {
-    qCritical() << "TODO: implement ATBDeviceControllerPlugin::requestAccount()";
+    qCritical() << "ATBDeviceControllerPlugin::requestAccount()";
+
+    this->private_startAccount();
 }
 
+void ATBDeviceControllerPlugin::private_startAccount()
+{
+    uint16_t backupedAccNumbers[8];    // array of account numbers
+    uint8_t nrOfVals;                  // number of saved accounts
+
+    // it is not defined which one is the latest account
+    hw->log_getHoldAccountNumbers(&nrOfVals, backupedAccNumbers);
+
+    // DEBUG
+    qCritical() << "Start account: ";
+    qCritical() << "                  nrOfVals = " << nrOfVals;
+    for (int i=0; i<nrOfVals; ++i) {
+        qCritical() << "      backupedAccNumbers[" << i << "] = " << backupedAccNumbers[i];
+    }
+
+    qsort( backupedAccNumbers, nrOfVals, sizeof (uint16_t), Utils::compare );
+
+    uint16_t latestAccountNumber = backupedAccNumbers[nrOfVals-1];
+
+
+    // DEBUG
+    qCritical() << "       latestAccountNumber = " << latestAccountNumber;
+
+    hw->log_selectVaultRecord(latestAccountNumber);
+
+    this->accountCheckCounter = 0;
+    QTimer::singleShot(500, this, SLOT(private_checkAccountData()));
+}
+
+void ATBDeviceControllerPlugin::private_checkAccountData()
+{
+    // DEBUG
+    qCritical() << "      --> private_checkAccountData()";
+
+    if (hw->log_chkIfVaultRecordAvailable()) {
+        this->private_getAccountData();
+    }
+    else {
+        if (this->accountCheckCounter < 10) {
+            this->accountCheckCounter++;
+            QTimer::singleShot(500, this, SLOT(private_checkAccountData()));
+        }
+        else {
+            // cannot get accountData within ~10*500ms
+            qCritical() << "checkAccountData() failed";
+
+            // simulate:
+            this->private_getAccountData();
+
+
+            // TODO: create and send an HealthEvent...
+        }
+    }
+}
+
+
+void ATBDeviceControllerPlugin::private_getAccountData()
+{
+    // DEBUG
+    qCritical() << "      --> private_getAccountData()";
+
+    struct T_vaultRecord retVR;
+
+    hw->log_getVaultRecord(&retVR);
+
+    QHash<QString, QVariant> accountData;
+
+    accountData.insert("AccountingNumber", QString::number(retVR.AccountingNumber));
+
+
+    // build dateTime: -------------------------------------------------------
+    // Example: "2023-07-19T18:24:01.063+02:00"
+    QString startDateTimeString;
+    QString formatString = "yyyy-MM-ddThh:mm:ss";
+    uint year = retVR.year + 2000;
+    startDateTimeString.append(QString::number(year)).append("-");
+    uint month = retVR.month;
+    startDateTimeString.append(QString::number(month).rightJustified(2, '0')).append("-");
+    uint day = retVR.dom;
+    startDateTimeString.append(QString::number(day).rightJustified(2, '0')).append("T");
+    uint hour = retVR.hour;
+    startDateTimeString.append(QString::number(hour).rightJustified(2, '0')).append(":");
+    uint minute = retVR.min;
+    startDateTimeString.append(QString::number(minute).rightJustified(2, '0')).append(":");
+    uint seconds = retVR.sec;
+    startDateTimeString.append(QString::number(seconds).rightJustified(2, '0'));
+
+    qCritical() << "     startDateTimeString = " << startDateTimeString;
+
+    QDateTime startDateTime = QDateTime::fromString(startDateTimeString, formatString);
+    accountData.insert("accountStartTime", startDateTime);
+    //-------------------------------------------------------------------------
+
+
+
+    int numberOfCoinVariants = sizeof(retVR.coinsInVault);
+
+    // DEBUG
+    qCritical() << "      NumberOfCoinVariants = " << numberOfCoinVariants;
+
+    // limit numberOfCoinVariants:
+    if (numberOfCoinVariants > 16) { numberOfCoinVariants = 16; }
+
+    accountData.insert("NumberOfCoinVariants", numberOfCoinVariants);
+    for (int i = 0; i < numberOfCoinVariants; ++i) {
+        accountData.insert("COIN_" + QString::number(i) + "_Quantity",  retVR.coinsInVault[i]);
+        accountData.insert("COIN_" + QString::number(i) + "_Value",     retVR.coinDenomination[i]);
+
+        // DEBUG
+        qCritical() << "COIN_" + QString::number(i) + "_Quantity = " << accountData["COIN_" + QString::number(i) + "_Quantity"];
+        qCritical() << "COIN_" + QString::number(i) + "_Value    = " << accountData["COIN_" + QString::number(i) + "_Value"];
+    }
+
+    emit requestAccountResponse(accountData);
+}
+
+
+// Door Events / Hardware contacts --------------------------------------------
+void ATBDeviceControllerPlugin::onServiceDoorOpened()
+{
+    qCritical() << "ATBDeviceControllerPlugin::onServiceDoorOpened()";
+
+    // ... to detect alarm etc.
+    this->diag->diagRequest();
+
+    // switch to mode service
+    emit this->requestModeSERVICE();
+
+    // TODO:
+    // - create an HealthEvent (-> ISMAS-Event)
+}
+
+void ATBDeviceControllerPlugin::onVaultDoorOpened()
+{
+    // TODO:
+    // - show special screen / message on screen
+    // - create an HealthEvent (-> ISMAS-Event)
+    qCritical() << "ATBDeviceControllerPlugin::onVaultDoorOpened()";
+
+    // ... to detect alarm etc.
+    this->diag->diagRequest();
+
+    // this is started here because we want to keep ptu awake in order to get
+    // coin box removed / inserted etc.
+    // BackgroundTask("ACCOUNT") is finished, if account message is sent to ISMAS!
+    this->dbus->startBackgroundTask("DOOR_OPEN");
+
+    // do not: emit this->requestModeSERVICE();
+}
+
+void ATBDeviceControllerPlugin::onCoinBoxRemoved()
+{
+    qCritical() << "ATBDeviceControllerPlugin::onCoinBoxRemoved()";
+
+    // BackgroundTask("ACCOUNT") is finished, if account message is sent to ISMAS!
+    this->dbus->startBackgroundTask("ACCOUNT");
+
+    QTimer::singleShot(4000, this, SLOT(private_startAccount()));
+}
+
+void ATBDeviceControllerPlugin::onCoinBoxInserted()
+{
+    qCritical() << "ATBDeviceControllerPlugin::onCoinBoxInserted()";
+}
+
+/**
+ * This is called, when all CoinBox is inserted and all doors
+ * are closed.
+ */
+void ATBDeviceControllerPlugin::onCBinAndAllDoorsClosed()
+{
+    qCritical() << "ATBDeviceControllerPlugin::onCBinAndAllDoorsClosed()";
+
+    QTimer::singleShot(2000, this, SIGNAL(requestModeIDLE()));
+
+    this->dbus->finishedBackgroundTask("DOOR_OPEN");
+}
+
+/**
+ *  This is called, when all no coinbox is inserted and all doors are
+ *  closed.
+ */
+void ATBDeviceControllerPlugin::onAllDoorsClosed()
+{
+    qCritical() << "ATBDeviceControllerPlugin::onAllDoorsClosed()";
+
+    emit this->requestModeIDLE();
+    this->dbus->finishedBackgroundTask("DOOR_OPEN");
+
+    // TODO: check for errors and create a machine event
+}
+
+void ATBDeviceControllerPlugin::onNewVoltage(uint32_t voltage)
+{
+    qCritical() << "ATBDeviceControllerPlugin::onNewVoltage() = " << voltage;
+
+    QString voltageString = QString::number(voltage);
+
+    JSON::setPrettySerialize(true);
+    JSON::JsonObject json;
+
+    json = JSON::objectBuilder()
+                  ->set("Name", "batt")
+                  ->set("Value", voltageString)
+                  ->set("Unit", "V")
+            ->create();
+
+
+    ATBHealthEvent *healthEvent = new ATBHealthEvent(
+                ATB_HEALTH_MODE::STATE,
+                "VOLTAGE",
+                JSON::serialize(json)
+                );
+
+    QCoreApplication::postEvent(eventReceiver, healthEvent);
+}
+
+
+
+
 
 // TASKS: printing ------------------------------------------------------------
+
+
+
+
+void ATBDeviceControllerPlugin::requestPrintTicket(nsDeviceControllerInterface::TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData)
+{
+    struct T_dynDat *dynTicketData = new T_dynDat;
+    memset(dynTicketData, 0, sizeof(*dynTicketData));
+
+    QDateTime parkingEndDateTime = QDateTime::fromString(printingData["parkingEnd"].toString(),  Qt::ISODate);
+    QDateTime currentDateTime    = QDateTime::fromString(printingData["currentDateTime"].toString(), Qt::ISODate);
+
+    // set dynamic printer data:
+    QByteArray ba_licenseplate = codec->fromUnicode(printingData["licenseplate"].toString());
+    memcpy((char*)dynTicketData->licensePlate, ba_licenseplate.data(), std::min(ba_licenseplate.size(),8));
+
+    QByteArray ba_amount = codec->fromUnicode(printingData["amount"].toString());
+    memcpy((char*)dynTicketData->vendingPrice,  ba_amount.data(), std::min(ba_amount.size(),8));  // Szeged
+    memcpy((char*)dynTicketData->dynDat6,       ba_amount.data(), std::min(ba_amount.size(),8));  // Schoenau
+
+    QByteArray ba_parkingEndTime = codec->fromUnicode(parkingEndDateTime.toString("hh:mm"));
+    memcpy((char*)dynTicketData->parkingEnd,  ba_parkingEndTime.data(), std::min(ba_parkingEndTime.size(),8));
+
+    QByteArray ba_parkingEndDate = codec->fromUnicode(parkingEndDateTime.toString("yy.MM.dd"));
+    memcpy((char*)dynTicketData->currentTime,  ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
+    // ! and yes... 'ParkingEndDate' is 'currentTime'
+
+    QByteArray ba_currentDate = codec->fromUnicode(currentDateTime.toString("yy.MM.dd"));
+    memcpy((char*)dynTicketData->currentDate,  ba_currentDate.data(), std::min(ba_currentDate.size(),8));
+
+    // STAN for Szeged Start/Stop: must be 9 digits
+    // --------------------------------------------------------------------------------------
+    QString stan = codec->fromUnicode(printingData["STAN"].toString());
+    qCritical() << "   requestPrintTicket() STAN = " << stan;
+    QString stan1;
+    QString stan2;
+    if (stan.length() == 9) {
+        stan1 = "     " + stan.mid(0,3);
+        stan2 = stan.mid(3,3) + " " + stan.mid(6,3);
+    }
+    else {
+        qCritical() << "ASSERT: ATBDeviceControllerPlugin::requestPrintTicket() invalid STAN: " << stan;
+        stan1 = "     000";
+        stan2 = "000 000";
+    }
+    QByteArray ba_stan1 = codec->fromUnicode(stan1);
+    QByteArray ba_stan2 = codec->fromUnicode(stan2);
+    // --------------------------------------------------------------------------------------
+
+    this->templateList.clear();
+
+    switch (ticketVariant) {
+    case nsDeviceControllerInterface::TICKET_VARIANT::START_RECEIPT:
+        qCritical() << "      -> TICKET_VARIANT::START_RECEIPT";
+        memcpy((char*)dynTicketData->dynDat6, ba_stan1.data(), std::min(ba_stan1.size(),8));
+        memcpy((char*)dynTicketData->dynDat7, ba_stan2.data(), std::min(ba_stan2.size(),8));
+        this->templateList << 21 << 22 << 23;
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::STOP_RECEIPT:
+        qCritical() << "      -> TICKET_VARIANT::STOP_RECEIPT";
+        memcpy((char*)dynTicketData->dynDat6, ba_stan1.data(), std::min(ba_stan1.size(),8));
+        memcpy((char*)dynTicketData->dynDat7, ba_stan2.data(), std::min(ba_stan2.size(),8));
+        this->templateList << 24 << 25 << 26;
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::RECEIPT:
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::ERROR_RECEIPT:
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::PARKING_TICKET:
+        break;
+    }
+
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket()";
+    for (int i =0; i < this->templateList.size(); ++i) {
+        qCritical() << "     template: " << this->templateList.at(i);
+    }
+
+
+    if (!this->hw->dc_isPortOpen()) {
+        qCritical() << "    ... serial port is not open!";
+        this->onPrintFinishedERR();
+        return;
+    }
+
+    // TODO: wird hier nur 'licensePlate' gedruckt?
+    if (!this->hw->prn_sendDynamicPrnValues(dynTicketData->licensePlate)) {
+        this->errorCode = "hwapi::prn_sendDynamicPrnValues";
+        this->errorDescription = "hwapi method 'hwapi::prn_sendDynamicPrnValues' result is false";
+
+        qCritical() << "ERROR:";
+        qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket( "        << endl
+                    << "     licenseplate = " << printingData["licenseplate"]   << endl
+                    << "           amount = " << printingData["amount"]         << endl
+                    << "       parkingEnd = " << printingData["parkingEnd"]     << endl
+                    << "      currentTime = " << printingData["currentTime"]    << endl
+                    << "      currentDate = " << printingData["currentDate"]    << endl
+                    << "             stan = " << printingData["STAN"]           << endl;
+
+        this->onPrintFinishedERR();
+        return;
+    }
+
+    QTimer::singleShot(1000, this, SLOT(onPrinterDataPreparedForTemplates()));
+
+}
+
+void ATBDeviceControllerPlugin::requestPrintReceipt(const QHash<QString, QVariant> & printingData)
+{
+    Q_UNUSED(printingData)
+
+    qCritical() << "ATBDeviceControllerPlugin::requestPrintReceipt() is currently not implemented";
+}
+
+void ATBDeviceControllerPlugin::requestPrintReceipt(const QString & printingString)
+{
+    QByteArray ba = printingString.toUtf8();
+    hw->prn_switchPower(true);
+    hw->prn_sendText(&ba);
+    QTimer::singleShot(4000, this, SLOT(onPrinterWaitForPrintingReceipt()));
+
+    //QTimer::singleShot(2000, this, [this](){ hw->prn_cut(3);  } );
+}
+
+void ATBDeviceControllerPlugin::onPrinterWaitForPrintingReceipt()
+{
+    quint8 printerResult = this->hw->prn_getPrintResult();
+
+    switch (printerResult) {
+    case 0:    // still printing
+        qCritical() << "--> printer: WaitForPrintingReceipt";
+        QTimer::singleShot(2000, this, SLOT(onPrinterWaitForPrintingReceipt()));
+        break;
+    case 1:    // printing finished, Ok
+        qCritical() << "DC Finished printing receipt";
+        emit this->printReceiptFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
+                                        // TODO: TicketNumber
+                                        "",
+                                        "");
+        hw->prn_switchPower(true);
+        hw->prn_cut(3);
+        break;
+    case 2:    // printing finished, Error
+        qCritical() << "DC Error: wait for printing receipt";
+        this->errorCode = "PRINTER";               // TODO: get more detailed error code from low level API
+        this->errorDescription = "Printer error";  // TODO: get more detailed error description from low level API
+
+        emit this->printReceiptFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
+                                       this->errorCode,
+                                       this->errorDescription);
+        break;
+    default:
+        qCritical() << "DC Error: wait for printing receipt";
+        this->errorCode = "PRINTER";               // TODO: get more detailed error code from low level API
+        this->errorDescription = "Printer error";  // TODO: get more detailed error description from low level API
+
+        emit this->printReceiptFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
+                                       this->errorCode,
+                                       this->errorDescription);
+        break;
+    }
+
+}
+
+
 void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant> & printingData)
 {
     struct T_dynDat *dynTicketData = new T_dynDat;
@@ -121,16 +658,18 @@ void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant
     memcpy((char*)dynTicketData->licensePlate, ba_licenseplate.data(), std::min(ba_licenseplate.size(),8));
 
     QByteArray ba_amount = codec->fromUnicode(printingData["amount"].toString());
-    memcpy((char*)dynTicketData->vendingPrice,  ba_amount.data(), std::min(ba_amount.size(),8));
+    memcpy((char*)dynTicketData->vendingPrice,  ba_amount.data(), std::min(ba_amount.size(),8));  // Szeged
+    memcpy((char*)dynTicketData->dynDat6,       ba_amount.data(), std::min(ba_amount.size(),8));  // Schoenau
+
 
     QByteArray ba_parkingEndTime = codec->fromUnicode(parkingEndDateTime.toString("hh:mm"));
     memcpy((char*)dynTicketData->parkingEnd,  ba_parkingEndTime.data(), std::min(ba_parkingEndTime.size(),8));
 
-    QByteArray ba_parkingEndDate = codec->fromUnicode(parkingEndDateTime.toString("dd.MM.yy"));
+    QByteArray ba_parkingEndDate = codec->fromUnicode(parkingEndDateTime.toString("yy.MM.dd"));
     memcpy((char*)dynTicketData->currentTime,  ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
     // ! and yes... 'ParkingEndDate' is 'currentTime'
 
-    QByteArray ba_currentDate = codec->fromUnicode(currentDateTime.toString("dd.MM.yy"));
+    QByteArray ba_currentDate = codec->fromUnicode(currentDateTime.toString("yy.MM.dd"));
     memcpy((char*)dynTicketData->currentDate,  ba_currentDate.data(), std::min(ba_currentDate.size(),8));
 
 
@@ -154,8 +693,6 @@ void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant
     }
 
 
-
-
     // TODO: wird hier nur 'licensePlate' gedruckt?
     if (!this->hw->prn_sendDynamicPrnValues(dynTicketData->licensePlate)) {
         this->errorCode = "hwapi::prn_sendDynamicPrnValues";
@@ -174,45 +711,115 @@ void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant
         return;
     }
 
-    QTimer::singleShot(1000, this, SLOT(onPrinterDataPrepared()));
+    // set ticket type:
+    //      00281 - Szeged:
+    //          1 - Cash / ShortTimeParking
+    //          2 - Card / ShortTimeParking
+    //          3 - Cash / DayTicket
+    //          4 - Card / DayTicket
+    QString paymentType = printingData["paymentType"].toString(); // must be "CASH" | "CARD"
+    QString productName = printingData["product"].toString();     // must be "ShortTimeParking" | "DayTicket"
+
+    if ( (paymentType == "CASH") && (productName == "ShortTimeParking") ) {
+        this->currentSelectedTicketType = 1;
+    }
+    else
+    if ( (paymentType == "CARD") && (productName == "ShortTimeParking") ) {
+        this->currentSelectedTicketType = 2;
+    }
+    else
+    if ( (paymentType == "CASH") && (productName == "DayTicket") ) {
+        this->currentSelectedTicketType = 3;
+    }
+    else
+    if ( (paymentType == "CARD") && (productName == "DayTicket") ) {
+        this->currentSelectedTicketType = 4;
+    }
+    else {
+        qCritical() << "ERROR: requestPrintTicket(): invalid payment data:";
+        qCritical() << "       paymentType = " << paymentType   << endl
+                    << "       productName = " << productName   << endl;
+        this->onPrintFinishedERR();
+        return;
+    }
+
+    QTimer::singleShot(3000, this, SLOT(onPrinterDataPrepared()));
 }
 
 
+void ATBDeviceControllerPlugin::onPrinterDataPreparedForTemplates()
+{
+    if (this->templateList.isEmpty()) return;
+
+    this->onPrinterPrintNextTemplate();
+}
 
 void ATBDeviceControllerPlugin::onPrinterDataPrepared()
 {
-    this->currentTemplate = 1;
-    this->onPrinterPrintNextTemplate();
+    this->hw->prn_printKombiticket(this->currentSelectedTicketType);
+
+    // note: calling prn_getPrintResult() immediately may result in wrong answer!
+    // We have to wait "about some seconds" until calling this function!
+    QTimer::singleShot(4000, this, SLOT(onPrinterWaitForPrintingTicket()));
+
+    // old: use printer templates:
+    // this->currentTemplate = 1;
+    // this->onPrinterPrintNextTemplate();
+}
+
+void ATBDeviceControllerPlugin::onPrinterWaitForPrintingTicket()
+{
+    quint8 printerResult = this->hw->prn_getPrintResult();
+
+    switch (printerResult) {
+    case 0:    // still printing
+        qCritical() << "--> printer: WaitForPrintingTicket";
+        QTimer::singleShot(2000, this, SLOT(onPrinterWaitForPrintingTicket()));
+        break;
+    case 1:    // printing finished, Ok
+        this->onPrintFinishedOK();
+        break;
+    case 2:    // printing finished, Error
+        this->onPrintFinishedERR();
+        break;
+    default:
+        qCritical() << "DC Error: wait for printing";
+        this->onPrintFinishedERR();
+        break;
+    }
+
 }
 
 
 void ATBDeviceControllerPlugin::onPrinterPrintNextTemplate()
 {
-    qCritical() << "     ... print template " << this->currentTemplate;
-
-    if (!this->hw->prn_printTemplate(this->currentTemplate)) {
-        this->errorCode = "hwapi::prn_printTemplate";
-        this->errorDescription = QString("hwapi method 'hwapi::onPrinterPrintNextTemplate(%1)' result is false").arg(this->currentTemplate);
+    // template list must not be empty
+    if (this->templateList.isEmpty()) {
         this->onPrintFinishedERR();
         return;
     }
 
-    if (this->currentTemplate >= 3) {
-        // all templates are printed
-        this->currentTemplate = 0;
+    qCritical() << "     ... print template " << this->templateList.first();
 
-        // FAKE SIGNAL:
-        QTimer::singleShot(500, this, SLOT(onPrintFinishedOK()));
+    if (!this->hw->prn_printTemplate(this->templateList.first())) {
+        this->errorCode = "hwapi::prn_printTemplate";
+        this->errorDescription = QString("hwapi method 'hwapi::onPrinterPrintNextTemplate(%1)' result is false").arg(this->templateList.first());
+        this->onPrintFinishedERR();
+        return;
+    }
+    this->templateList.removeFirst();
+
+    if (templateList.isEmpty()) {
+        // all templates are printed
+        QTimer::singleShot(2000, this, SLOT(onPrinterWaitForPrintingTicket()));
     }
     else {
         // print next template
-        this->currentTemplate++;
         QTimer::singleShot(2000, this, SLOT(onPrinterPrintNextTemplate()));
     }
 
 }
 
-
 /************************************************************************************************
  * private slots, interface to low level hwapi
  *
@@ -223,6 +830,7 @@ void ATBDeviceControllerPlugin::onPrintFinishedOK()
     qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedOK()";
 
     emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
+                                   // TODO: TicketNumber
                                    "",
                                    "");
 }
@@ -250,6 +858,8 @@ void ATBDeviceControllerPlugin::onCashGotCoin()
     // DEBUG
     qCritical() << "ATBDeviceControllerPlugin::onGotCoin()";
 
+    this->currentCashState = CASH_STATE::CACHE_INPUT;
+
     uint32_t amountInt = this->hw->getInsertedAmount();
 
     QString amountString = QString::number(amountInt);
@@ -262,20 +872,23 @@ void ATBDeviceControllerPlugin::onCashGotCoin()
                               "");
 }
 
+void ATBDeviceControllerPlugin::onCashPayStopByPushbutton()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByPushbutton()";
+
+    // we need new cash value in application...
+    QTimer::singleShot(500, this, SLOT(onCashPayStopedSuccess()));
+
+}
 
 void ATBDeviceControllerPlugin::onCashPayStopByMax()
 {
     // DEBUG
     qCritical() << "ATBDeviceControllerPlugin::onCashVendStopByMax()";
 
-    uint32_t amountInt = this->hw->getInsertedAmount();
-
-    QString amountString = QString::number(amountInt);
-
-    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
-                              amountString,
-                              "",
-                              "");
+    // we need new cash value in application...
+    QTimer::singleShot(500, this, SLOT(onCashPayStopedSuccess()));
 
 }
 
@@ -324,15 +937,18 @@ void ATBDeviceControllerPlugin::onCashPayStopByTimeout()
                               "");
 }
 
-void ATBDeviceControllerPlugin::onCashPayStoped()
+void ATBDeviceControllerPlugin::onCashPayStopedSuccess()
 {
     // DEBUG
-    qCritical() << "ATBDeviceControllerPlugin::onCashPayStoped()";
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopedSuccess()";
 
     uint32_t amountInt = this->hw->getInsertedAmount();
 
     QString amountString = QString::number(amountInt);
 
+    qCritical() << "      insertedAmount (int) = " << amountInt;
+    qCritical() << "            insertedAmount = " << amountString;
+
     emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
                               amountString,
                               "",
@@ -350,29 +966,60 @@ void ATBDeviceControllerPlugin::onCashPayStoped()
 bool ATBDeviceControllerPlugin::private_loadCashAgentLib(QString pluginName)
 {
     if (pluginName == "") {
-        pluginName = "/usr/lib/libCashAgentLib.so";
+
+        // search list for plugin (.so) file:
+        QStringList pluginNameList;
+        pluginNameList << "/usr/lib/libCAslave.so"
+                       << "/usr/lib/libCAmaster.so"
+                       << "/usr/lib/libCashAgentLib.so";
+        // using C++11 range based loop:
+        for (const auto& filename : pluginNameList) {
+            if (QFileInfo(filename).isReadable()) {
+                pluginName = filename;
+                break;
+            }
+        }
+
+        if (pluginName == "") {
+            qCritical() << "ATBDeviceControllerPlugin: CashAgentLib not installed!";
+            this->errorCode = "CashAgentLib::NOT_FOUND";
+            this->errorDescription = "ERROR: no CashAgentLib: ";
+            return false;
+        }
+
     }
 
     if (!QLibrary::isLibrary(pluginName)) {
         qCritical() << "ATBDeviceControllerPlugin: can not load CashAgentLib: " << pluginName;
-        this->errorCode = 5;
+        this->errorCode = "CashAgentLib::NO_LIBRARY";
         this->errorDescription = "ERROR: can not load CashAgentLib: " + pluginName;
         return false;
     }
 
+    if (pluginName.contains("slave", Qt::CaseInsensitive)) {
+        this->isMaster = false;
+    }
+    else
+    if (pluginName.contains("master", Qt::CaseInsensitive)) {
+        this->isMaster = true;
+    }
+
     QPluginLoader* pluginLoader = new QPluginLoader();
     pluginLoader->setFileName(pluginName);
 
     QObject* plugin = pluginLoader->instance();
     if (!pluginLoader->isLoaded()) {
         qCritical() << "ATBDeviceControllerPlugin: can not instantiate CashAgentLib: " << pluginName;
-        this->errorCode = 6;
+        qCritical() << "               error: " << pluginLoader->errorString();
+        this->errorCode = "CashAgentLib::NO_INSTANCE";
         this->errorDescription = "ERROR: can not instantiate CashAgentLib: " + pluginName;
         return false;
     }
 
     if (plugin == nullptr) {
         qCritical() << "ATBDeviceControllerPlugin: plugin is NULL";
+        this->errorCode = "CashAgentLib::INSTANCE_IS_NULL";
+        this->errorDescription = "ERROR: CashAgentLib instance is NULL: " + pluginName;
     }
 
     qCritical() << "ATBDeviceControllerPlugin: instantiate CashAgentLib: " << pluginName;
@@ -381,13 +1028,64 @@ bool ATBDeviceControllerPlugin::private_loadCashAgentLib(QString pluginName)
 
     if (this->hw == nullptr) {
         qCritical() << "ATBDeviceControllerPlugin: hw is NULL";
+        this->errorCode = "CashAgentLib::HW_IS_NULL";
+        this->errorDescription = "ERROR: CashAgentLib object_cast is NULL: " + pluginName;
+        return false;
     }
 
+    qCritical() << "ATBDeviceControllerPlugin: loaded CashAgentLib";
+
     return true;
 }
 
 
 
+
+
+/***********************************************************************************************
+ *  dbus
+ */
+int ATBDeviceControllerPlugin::init_sc_dbus()
+{
+#if defined (ARCH_PTU4)
+    this->dbus = new DBusControllerInterface("eu.atb.ptu", "/systemcontrol", QDBusConnection::systemBus(), 0);
+#elif defined (ARCH_PTU5)
+    this->dbus = new DBusControllerInterface("eu.atb.ptu.systemcontrol", "/systemcontrol", QDBusConnection::systemBus(), 0);
+#else
+    this->dbus = new DBusControllerInterface("eu.atb.ptu", "/systemcontrol", QDBusConnection::sessionBus(), 0);
+#endif
+    if (!dbus->isValid()) {
+        QString errorString = QDBusError::errorString(dbus->lastError().type());
+        qCritical() << errorString;
+
+        if (dbus->lastError().isValid()){
+            qCritical() << "last error is valid.";
+        }
+
+        qCritical() << "message: " << dbus->lastError().message();
+        qCritical() << "SystemController is not valid.";
+        return 0;
+    }
+
+    if (!dbus->connection().isConnected()) {
+        qCritical() << "SystemController is not connected.";
+        return 0;
+    }
+
+    connect(this->dbus, SIGNAL(wokeUpFrom(uchar)), this, SLOT(onWokeUp(uchar)));
+
+    return 1;
+}
+
+void ATBDeviceControllerPlugin::onWokeUp(uchar source)
+{
+    if (source == 0x01) {
+        // woke up from device controller
+        this->diag->diagRequest();
+    }
+}
+
+
 /************************************************************************************************
  * Mandatory plugin methods
  *

src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -5,6 +5,8 @@
 
 #include "src/ATBAPP/DeviceControllerInterface.h"
 #include "src/ATBAPP/ATBAPPplugin.h"
+#include "src/ATBAPP/DeviceControllerDiag.h"
+
 #include "version.h"
 
 
@@ -12,11 +14,9 @@
 #include "interfaces.h"
 
 #include <unistd.h>
-#include <thread>
-#include <memory>
-#include <QSharedMemory>
 
 
+class DBusControllerInterface;
 class QTextCodec;
 
 
@@ -24,7 +24,7 @@ using namespace nsDeviceControllerInterface;
 
 class QSettings;
 
-class ATBDeviceControllerPlugin : public QObject,
+class ATBDeviceControllerPlugin :
         public DeviceControllerInterface
 {
     Q_OBJECT
@@ -40,7 +40,7 @@ public:
 
     // ----------------------------------------------------------------------------
     // interface:
-    PLUGIN_STATE initDCPlugin(QObject *healthEventReceiver, const QSettings & settings);
+    PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings);
 
     // TASKS: Cash handling -------------------------------------------------------
     void requestStartCashInput(const QString & amount);
@@ -48,8 +48,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();
@@ -62,38 +69,23 @@ public:
     const QString & getPluginInfo();
 
     // helpers e.g. for debug / log
-    const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState);
+    const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState);;
 
+public slots:
+    void onChangedProgramModeToSELL();
+    void onChangedProgramModeToSERVICE();
+    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 requestServiceMode();
-
-    void requestAccountResponse(const QHash<QString, QVariant> & accountData);
-
-
-    void Error(
-            const QString & errorCode,
-            const QString & errorDescription);
-
-
+    // public Signals are defined in interface
 
 
 private:
@@ -101,37 +93,77 @@ private:
    QString errorDescription;
    QString pluginInfo;
 
-   int currentTemplate;
+   QList<int> templateList;
 
+   QString serialPortName;
 
    bool useDebug;
 
+   bool isMaster;
+
    PLUGIN_STATE pluginState;
 
-   QObject* healthEventReceiver;
+   QObject* eventReceiver;
+
+   DBusControllerInterface* dbus;
 
    hwinf* hw;
 
+   DeviceControllerDiag* diag;
+
+
    QTextCodec *codec;
 
    bool private_loadCashAgentLib(QString pluginName);
 
+   quint8 currentSelectedTicketType;
+
+   nsDeviceControllerInterface::CASH_STATE currentCashState;
+
+   // counts failed hw->log_chkIfVaultRecordAvailable()
+   int accountCheckCounter;
+
+   // dbus
+   int init_sc_dbus();
+
 private slots:
    // printer
 
    void onPrinterDataPrepared();
+   void onPrinterDataPreparedForTemplates();
    void onPrinterPrintNextTemplate();
+   void onPrinterWaitForPrintingTicket();
+   void onPrinterWaitForPrintingReceipt();
 
    void onPrintFinishedOK();
    void onPrintFinishedERR();
 
    // cash payment
    void onCashGotCoin();
-   void onCashPayStoped();
+   void onCashPayStopedSuccess();
    void onCashPayStopByMax();
+   void onCashPayStopByPushbutton();
    void onCashPayStopByEscrow();
    void onCashPayStopByError();
    void onCashPayStopByTimeout();
+
+   // doors and hardware contacts
+   void onServiceDoorOpened();
+   void onVaultDoorOpened();
+   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,501 @@
+#include "DeviceControllerDiag.h"
+
+#include <QCoreApplication>
+#include <QMetaEnum>
+#include <QUuid>
+#include <QDebug>
+
+DeviceControllerDiag::DeviceControllerDiag(QObject *parent)
+    : QObject(parent)
+    , coinProcessorType(nsDeviceControllerInterface::COIN_PROCESSOR::ESCROW)
+    , billAcceptor(nsDeviceControllerInterface::BILL_ACCEPTOR::NO)
+    , eventReceiver(nullptr)
+    , isRequestRunning(false)
+    , flagInterruptDiag(false)
+{
+    diagRequestTimeoutTimer = new QTimer(this);
+    diagRequestTimeoutTimer->setInterval(1000*20);  // 20s
+    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::diagRequest()
+{
+    qCritical() << "DeviceControllerDiag::diagRequest()";
+
+    if (this->isRequestRunning) {
+        qCritical() << "DeviceControllerDiag::diagRequest() is already running";
+        return;
+    }
+    this->isRequestRunning = true;
+    this->diagRequestTimeoutTimer->start();
+
+    this->private_startDiag();
+}
+
+
+void DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout()
+{
+    qCritical() << "DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout()";
+    this->flagInterruptDiag = true;
+}
+
+void DeviceControllerDiag::private_startDiag()
+{
+    // check for DiagRequestTimeoutTimerTimeout:
+    if (this->flagInterruptDiag) {
+        qCritical() << "DeviceControllerDiag::private_startDiag() interrupted!";
+        this->private_sendDiagEvent(DeviceController::State::E255);
+        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);
+        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);
+        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;
+    }
+
+    // all doors: 99: undefined  0:closed  1:open
+    if (dynMaCond.lowerDoor || dynMaCond.upperDoor) {
+        // Service or battery door is open, goto INTRUSION MODE
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() Service or battery door is open, goto INTRUSION MODE";
+        this->private_sendDiagEvent(DeviceController::State::E253);
+    }
+    if (dynMaCond.middleDoor) {
+        // vault door is open, goto INTRUSION MODE
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() vault door is open, goto INTRUSION MODE";
+        this->private_sendDiagEvent(DeviceController::State::E252);
+    }
+
+    qCritical() << "      --> call  sub_componentAssessment()";
+
+    sub_componentAssessment();
+}
+
+
+
+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 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;
+            this->private_sendDiagEvent(DeviceController::State::E010);
+        }
+    }
+    // -----------------------------------------------------------------------------------------------
+
+    switch (devPara.kindOfCoinChecker) {
+        case 1:
+        case 2:
+            this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::ESCROW;
+            break;
+        case 3:
+            this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::CHANGER;
+            break;
+    }
+
+    if (devPara.kindOfCoinChecker==1 || devPara.kindOfCoinChecker==2)  // 0: without  1=EMP820   2=EMP900    3=currenza c²	(MW)
+    {
+        if (modCond.coinEscrow>=200) {
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E010);
+        }
+        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::E004);
+    }
+
+    // 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::A000:   // alarm / intrusion
+        eventClass = EVENT_CLASS::ALARM;
+        parameter  = "alarm / intrusion";
+        break;
+    case DeviceController::State::E002:    // real time clock error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "real time clock error";
+        break;
+    case DeviceController::State::E003:   // voltage error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "voltage error";
+        break;
+    case DeviceController::State::E004:   // temperature error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "temperature error";
+        break;
+    case DeviceController::State::E007:    // coin safe full
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "coin safe full";
+        break;
+    case DeviceController::State::E008:    // bill acceptor full
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "bill acceptor full";
+        break;
+    case DeviceController::State::E009:    // no cash box
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "no cash box";
+        break;
+    case DeviceController::State::E010:    // coin escrow
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "coin escrow";
+        break;
+    case DeviceController::State::E011:    // mem error int.ee.
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "mem error int.ee.";
+        break;
+    case DeviceController::State::E018:    // no paper
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "no paper";
+        break;
+    case DeviceController::State::E020:    // printer error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "printer error";
+        break;
+    case DeviceController::State::E025:    // coin blocker
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "coin blocker";
+        break;
+    case DeviceController::State::E026:    // error coin validator
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "error coin validator";
+        break;
+    case DeviceController::State::E034:    // mdb error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "mdb error";
+        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::STATE;
+        parameter  = "";
+        qCritical() << "                ... ignore " << QMetaEnum::fromType<DeviceController::State>().valueToKey(result);
+        return;
+        break;
+    case DeviceController::State::O000:   // everything is fine
+        this->machineEventSet.clear();
+        eventClass = EVENT_CLASS::OPERATE;
+        parameter  = "";
+        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;
+    }
+
+
+    ATBMachineEvent *machineEvent = new ATBMachineEvent(
+                eventId,
+                "DC",
+                eventClass,
+                eventName,
+                1,
+                parameter,
+                ""         // second level info
+                );
+
+    //emit diagResponse(machineEvent);
+
+    QCoreApplication::postEvent(eventReceiver, machineEvent);
+
+}
+
+

src/ATBAPP/DeviceControllerDiag.h

@@ -0,0 +1,106 @@
+#ifndef DEVICECONTROLLERDIAG_H
+#define DEVICECONTROLLERDIAG_H
+
+#include <QObject>
+#include <QSet>
+#include <QTimer>
+
+#include "ATBMachineEvent.h"
+#include "interfaces.h"
+#include "DeviceControllerInterface.h"
+
+
+namespace DeviceController {
+    Q_NAMESPACE
+
+    enum State {
+        O000,
+
+        A000,
+
+        E002,
+        E003,
+        E004,
+
+        E007,
+        E008,
+        E009,
+        E010,
+        E011,
+
+        E018,
+
+        E020,
+
+        E025,
+        E026,
+
+        E034,
+
+        E071,
+        E072,
+        E073,
+
+        E252,
+        E253,
+        E254,
+        E255,
+
+        W001,
+        W002,
+        W003,
+        W004
+    };
+    Q_ENUM_NS(State)
+}
+
+
+class DeviceControllerDiag : public QObject
+{
+    Q_OBJECT
+
+public:
+    DeviceControllerDiag(QObject *parent = nullptr);
+
+    void init(hwinf* hw, QObject* eventReceiver);
+
+    nsDeviceControllerInterface::COIN_PROCESSOR coinProcessorType;
+    nsDeviceControllerInterface::BILL_ACCEPTOR  billAcceptor;
+
+public slots:
+    void diagRequest();
+
+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;
+
+    QSet<DeviceController::State> machineEventSet;
+
+
+
+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

@@ -12,17 +12,28 @@ 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;
 }
 
 
-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;
 
     // TASKS: Cash handling -------------------------------------------------------
@@ -51,7 +62,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;
@@ -64,21 +81,35 @@ public:
     // helpers e.g. for debug / log
     virtual const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState) = 0;
 
+public slots:
+    virtual void onChangedProgramModeToSELL() = 0;
+    virtual void onChangedProgramModeToSERVICE() = 0;
+    virtual void onChangedProgramModeToIDLE() = 0;
+    virtual void onChangedProgramModeToOOO() = 0;
+
+    virtual void startPhysicalLayer() = 0;
+    virtual void stopPhysicalLayer() = 0;
+    virtual void reboot() = 0;
+    virtual void reset() = 0;
+
 
 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);
 
     /**
      * 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():
@@ -86,22 +117,36 @@ 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 & errorCode,
-                                     const QString & errorDescription) = 0;
+                                     const QString & errorDescription);
 
 
     /**
      * emitted e.g. if service door is opened
      */
-    virtual void requestServiceMode() = 0;
+    void requestModeSERVICE();
+
+    /**
+     * emitted e.g. if doors are closed
+     */
+    void requestModeIDLE();
+
+    /**
+     * emitted e.g. on severe errors
+     */
+    void requestModeOOO();
 
     /**
      * emitted e.g. if service door is opened
      */
-    virtual void requestAccountResponse(const QHash<QString, QVariant> & accountData) = 0;
+    void requestAccountResponse(const QHash<QString, QVariant> & accountData);
+
+
+
+
 
     /**
      * emitted on error
@@ -111,16 +156,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.0.1")
 
 
 namespace nsDeviceControllerInterface {
@@ -145,6 +190,25 @@ 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
+    };
+
+    enum class COIN_PROCESSOR : quint8 {
+        CHANGER,
+        ESCROW
+    };
+
+    enum class BILL_ACCEPTOR  : quint8 {
+        YES,
+        NO
+    };
 }
 
 #endif // DEVICECONTROLLERINTERFACE_H

src/ATBAPP/Utils.cpp

@@ -0,0 +1,18 @@
+#include "Utils.h"
+
+Utils::Utils(QObject *parent) : QObject(parent)
+{
+
+}
+
+
+
+int Utils::compare(const void* a, const void* 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;
+    else return 1;
+}

src/ATBAPP/Utils.h

@@ -0,0 +1,23 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <QObject>
+
+
+class Utils : public QObject
+{
+    Q_OBJECT
+public:
+    static int compare(const void* a, const void* b);
+
+private:
+    explicit Utils(QObject *parent = nullptr);
+
+
+
+
+signals:
+
+};
+
+#endif // UTILS_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