Check error-state if doors are closed

See DC_printer_interface.graphml/pdf

DCPlugin.pro

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

include/interfaces.h

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

src/ATBAPP/ATBDeviceControllerPlugin.cpp

@@ -47,6 +47,7 @@ ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent)
     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_coinAttached()),        this, SIGNAL(coinAttached()),            Qt::QueuedConnection);     // check for errors, switch to mode IDLE
 
     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
@@ -60,12 +61,17 @@ ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent)
     dynamic_cast<QObject*>(hw)->moveToThread(hwThread);
     hwThread->start();
 
+    QString persistentDataFile = "/mnt/system_data/dc_persistentData.dat";
+    this->persistentData = new PersistentData(persistentDataFile);
 
-    this->diag = new DeviceControllerDiag(this);
+    this->diag = new DeviceControllerDiag(this->persistentData, this);
     connect(this->diag, &DeviceControllerDiag::newVoltage, this, &ATBDeviceControllerPlugin::onNewVoltage);
 
 
+    // currentSelectedTicketType - number of used "Kombiticket" (deprecated) use TICKET_VARIANT in future
     this->currentSelectedTicketType = 0;
+    this->currentTicket = new Ticket(TICKET_VARIANT::PARKING_TICKET, this);
+
     this->currentCashState = CASH_STATE::CACHE_EMPTY;
 
     this->cashStartAmountInt = 0;
@@ -101,6 +107,11 @@ PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *eventReceiver, con
     // this is necessary to init the CashAgentLib (!)
     hw->vend_failed();
 
+    // read sw-version and store it in persistentData, if changed
+    QString dc_fw_version = hw->dc_getSWversion().remove(QChar('\0'));
+    qCritical() << "ATBDeviceControllerPlugin: DC firmware version: " << dc_fw_version;
+    this->persistentData->setDCFirmwareVersion(dc_fw_version);
+    this->persistentData->serializeToFile();
 
     // text encoding for printer
     this->codec = QTextCodec::codecForName(printerEncoding);
@@ -123,6 +134,37 @@ PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *eventReceiver, con
 }
 
 
+void ATBDeviceControllerPlugin::sendDeviceParameter(const QJsonObject &jsonObject)
+{
+
+    qCritical() << "ATBDeviceControllerPlugin::sendDeviceParameter:";
+
+
+    // extract location info and store location info in persistent data:
+    QJsonValue jsonSubVal;
+    jsonSubVal = jsonObject["Location"];
+
+    QString locationString = jsonSubVal.toString("");
+
+    if (locationString == "") {
+
+        qCritical() << "    -->  locationString NULL";
+        return;
+    }
+
+
+    uint16_t customerNr = PTUSystem::readCustomerNumber();
+    uint16_t machineNr  = PTUSystem::readMachineNumber();
+    uint16_t borough    = PTUSystem::readZoneNumber();
+    uint16_t zone       = PTUSystem::readGroupNumber();
+    uint16_t alias      = 0;
+    QByteArray locationBa = locationString.toLocal8Bit();
+
+    this->hw->sendMachineID(customerNr, machineNr, borough, zone, alias, locationBa.data());
+}
+
+
+
 void ATBDeviceControllerPlugin::startPhysicalLayer()
 {
     if (!this->isMaster) return;
@@ -133,6 +175,11 @@ void ATBDeviceControllerPlugin::startPhysicalLayer()
         return;
     }
 
+    qCritical() << "ATBDeviceControllerPlugin::startPhysicalLayer() " << endl
+                << "     -> use master lib " << endl
+                << "     -> start physical layer";
+
+
     // open serial port
     hw->dc_openSerial(5, "115200", this->serialPortName, 1);
 
@@ -141,6 +188,10 @@ void ATBDeviceControllerPlugin::startPhysicalLayer()
 
 void ATBDeviceControllerPlugin::stopPhysicalLayer()
 {
+    // store persistent data
+    this->persistentData->serializeToFile();
+
+    // skip, if we use slave lib
     if (!this->isMaster) return;
 
     if (this->pluginState == PLUGIN_STATE::NOT_INITIALIZED)
@@ -499,10 +550,14 @@ void ATBDeviceControllerPlugin::onAllDoorsClosed()
 {
     qCritical() << "ATBDeviceControllerPlugin::onAllDoorsClosed()";
 
-    emit this->requestModeIDLE();
-    this->dbus->finishedBackgroundTask("DOOR_OPEN");
+    if (this->diag->isErrorState()) {
+        emit this->requestModeOOO();
+    }
+    else {
+        emit this->requestModeIDLE();
+    }
 
-    // TODO: check for errors and create a machine event
+    this->dbus->finishedBackgroundTask("DOOR_OPEN");    
 }
 
 void ATBDeviceControllerPlugin::onNewVoltage(uint32_t voltage)
@@ -538,86 +593,40 @@ void ATBDeviceControllerPlugin::onNewVoltage(uint32_t voltage)
 
 
 
-
+/**
+ * @brief ATBDeviceControllerPlugin::requestPrintTicket
+ * @param ticketVariant
+ * @param printingData
+ *
+ * Setup (initNew()) Ticket-Object
+ *
+ */
 void ATBDeviceControllerPlugin::requestPrintTicket(nsDeviceControllerInterface::TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData)
 {
-    struct T_dynDat *dynTicketData = new T_dynDat;
-    memset(dynTicketData, 0, sizeof(*dynTicketData));
+    QList<quint8> templateList;
 
-    QDateTime parkingEndDateTime = QDateTime::fromString(printingData["parkingEnd"].toString(),  Qt::ISODate);
-    QDateTime currentDateTime    = QDateTime::fromString(printingData["currentDateTime"].toString(), Qt::ISODate);
+    // TODO: read template list from .ini
 
-    QString parkingEndDateString = this->printerLocale.toString(parkingEndDateTime.date(), QLocale::ShortFormat);
-    QString currentDateString    = this->printerLocale.toString(currentDateTime.date(),    QLocale::ShortFormat);
-
-
-    // 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(parkingEndDateString);
-    memcpy((char*)dynTicketData->currentTime,  ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
-    // ! and yes... 'ParkingEndDate' is 'currentTime'
-
-    QByteArray ba_currentDate = codec->fromUnicode(currentDateString);
-    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() << "------------------------------------------------------------------------";
     qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket()";
-    for (int i =0; i < this->templateList.size(); ++i) {
-        qCritical() << "     template: " << this->templateList.at(i);
-    }
+    qCritical() << "     TICKET_VARIANT: " << ticketVariant;
+    qCritical() << "          dyn1_list: " << printingData["dyn1_list"].toStringList();
+    qCritical() << "          dyn2_list: " << printingData["dyn2_list"].toStringList();
+    qCritical() << "------------------------------------------------------------------------";
 
 
+    if (!this->currentTicket->initNew(ticketVariant, templateList, printingData)) {
+        this->errorCode = this->currentTicket->getErrorCode();
+        this->errorDescription = this->currentTicket->getErrorCode();
+
+        qCritical() << "ERROR: ticket->initNew: " << ticketVariant;
+
+        this->onPrintFinishedERR();
+        return;
+    }
+
     /*
     if (!this->hw->dc_isPortOpen()) {
         qCritical() << "    ... serial port is not open!";
@@ -626,26 +635,7 @@ void ATBDeviceControllerPlugin::requestPrintTicket(nsDeviceControllerInterface::
     }
     */
 
-    // 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()));
-
+    this->prepareDynTemplateData();
 }
 
 void ATBDeviceControllerPlugin::requestPrintReceipt(const QHash<QString, QVariant> & printingData)
@@ -794,24 +784,37 @@ void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant
     //          2 - Card / ShortTimeParking
     //          3 - Cash / DayTicket
     //          4 - Card / DayTicket
+    //      00744 - NeuhauserVT/NAZ:
+    //          1 - Erwachsene
+    //          2 - Jugendliche
+    //      00741 - NeuhauserVT/Linsinger Maschinenbau
+    //          t.b.d.
     QString paymentType = printingData["paymentType"].toString(); // must be "CASH" | "CARD"
     QString productName = printingData["product"].toString();     // must be "ShortTimeParking" | "DayTicket"
 
-    if ( (paymentType == "CASH") && (productName == "ShortTimeParking") ) {
+    if ( (paymentType == "CASH") && (productName == "SHORT_TERM_PARKING") ) {
+        this->currentSelectedTicketType = 1; // "Kombiticket #1"
+    }
+    else
+    if ( (paymentType == "CARD") && (productName == "SHORT_TERM_PARKING") ) {
+        this->currentSelectedTicketType = 2; // "Kombiticket #2"
+    }
+    else
+    if ( (paymentType == "CASH") && (productName == "DAY_TICKET") ) {
+        this->currentSelectedTicketType = 3; // "Kombiticket #3"
+    }
+    else
+    if ( (paymentType == "CARD") && (productName == "DAY_TICKET") ) {
+        this->currentSelectedTicketType = 4; // "Kombiticket #4"
+    }
+    else
+    if ( productName == "DAY_TICKET_ADULT") {
         this->currentSelectedTicketType = 1;
     }
     else
-    if ( (paymentType == "CARD") && (productName == "ShortTimeParking") ) {
+    if ( productName == "DAY_TICKET_TEEN") {
         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
@@ -826,7 +829,7 @@ void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant
 
 void ATBDeviceControllerPlugin::onPrinterDataPreparedForTemplates()
 {
-    if (this->templateList.isEmpty()) return;
+    if (this->currentTicket->templateList()->isEmpty()) return;
 
     this->onPrinterPrintNextTemplate();
 }
@@ -871,30 +874,37 @@ void ATBDeviceControllerPlugin::onPrinterWaitForPrintingTicket()
 void ATBDeviceControllerPlugin::onPrinterPrintNextTemplate()
 {
     // template list must not be empty
-    if (this->templateList.isEmpty()) {
+    if (this->currentTicket->templateList()->isEmpty()) {
         this->onPrintFinishedERR();
         return;
     }
 
-    qCritical() << "     ... print template " << this->templateList.first();
+    qCritical() << "     ... print template " << this->currentTicket->templateList()->first();
 
-    if (!this->hw->prn_printTemplate(this->templateList.first())) {
+    if (!this->hw->prn_printTemplate(this->currentTicket->templateList()->first())) {
         this->errorCode = "hwapi::prn_printTemplate";
-        this->errorDescription = QString("hwapi method 'hwapi::onPrinterPrintNextTemplate(%1)' result is false").arg(this->templateList.first());
+        this->errorDescription = QString("hwapi method 'hwapi::onPrinterPrintNextTemplate(%1)' result is false").arg(this->currentTicket->templateList()->first());
         this->onPrintFinishedERR();
         return;
     }
-    this->templateList.removeFirst();
+    this->currentTicket->templateList()->removeFirst();
+    this->currentTicket->setCurrentTemplateProcessed();
 
-    if (templateList.isEmpty()) {
+    if (this->currentTicket->templateList()->isEmpty()) {
         // all templates are printed
         QTimer::singleShot(2000, this, SLOT(onPrinterWaitForPrintingTicket()));
     }
     else {
-        // print next template
-        QTimer::singleShot(2000, this, SLOT(onPrinterPrintNextTemplate()));
-    }
 
+        if (this->currentTicket->hasTemplateDynData()) {
+            // set new dyn data:
+            QTimer::singleShot(2000, this, SLOT(onPrinterPrepareDynTemplateData()));
+        }
+        else {
+            // print next template
+            QTimer::singleShot(2000, this, SLOT(onPrinterPrintNextTemplate()));
+        }
+    }
 }
 
 /************************************************************************************************
@@ -927,6 +937,141 @@ void ATBDeviceControllerPlugin::onPrintFinishedERR()
 
 
 
+void ATBDeviceControllerPlugin::onPrinterPrepareDynTemplateData()
+{
+    this->prepareDynTemplateData();
+}
+void ATBDeviceControllerPlugin::prepareDynTemplateData()
+{
+    struct T_dynDat *dynTicketData = new T_dynDat;
+    memset(dynTicketData, 0, sizeof(*dynTicketData));
+
+    // setup dynTicketData dependent on currentTicket
+
+    // DEBUG:
+    qCritical() << "---------------------------------------------------";
+    qCritical() << "ATBDeviceControllerPlugin::prepareDynTemplateData():";
+    qCritical() << "    -> currentProcessedTemplateNumber: " << this->currentTicket->getCurrentProcessedTemplateNumber();
+    qCritical() << "    -> this->currentTicket->variant(): " << this->currentTicket->variant();
+    qCritical() << "---------------------------------------------------";
+
+    switch (this->currentTicket->variant()) {
+    case nsDeviceControllerInterface::TICKET_VARIANT::START_RECEIPT:
+        private_setupDynTemplateData_START_RECEIPT(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::STOP_RECEIPT:
+        private_setupDynTemplatData_STOP_RECEIPT(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::RECEIPT:
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::ERROR_RECEIPT:
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::PARKING_TICKET:
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FOOD_STAMP:
+        private_setupDynTemplatData_FOOD_STAMP(dynTicketData, this->currentTicket);
+        break;
+    }
+
+    // C-Programmierung: 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: hw->prn_sendDynamicPrnValues";
+
+        this->onPrintFinishedERR();
+        return;
+    }
+
+    QTimer::singleShot(1000, this, SLOT(onPrinterDataPreparedForTemplates()));
+}
+
+
+void ATBDeviceControllerPlugin::private_setupDynTemplateData_START_RECEIPT(struct T_dynDat *dynTicketData, Ticket *ticket)
+{
+    QDateTime parkingEndDateTime = QDateTime::fromString(ticket->getPrintingData()["parkingEnd"].toString(),  Qt::ISODate);
+    QDateTime currentDateTime    = QDateTime::fromString(ticket->getPrintingData()["currentDateTime"].toString(), Qt::ISODate);
+
+    QString parkingEndDateString = this->printerLocale.toString(parkingEndDateTime.date(), QLocale::ShortFormat);
+    QString currentDateString    = this->printerLocale.toString(currentDateTime.date(),    QLocale::ShortFormat);
+
+
+    // set dynamic printer data:
+    QByteArray ba_licenseplate = codec->fromUnicode(ticket->getPrintingData()["licenseplate"].toString());
+    memcpy((char*)dynTicketData->licensePlate, ba_licenseplate.data(), std::min(ba_licenseplate.size(),8));
+
+    QByteArray ba_amount = codec->fromUnicode(ticket->getPrintingData()["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(parkingEndDateString);
+    memcpy((char*)dynTicketData->currentTime,  ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
+    // ! and yes... 'ParkingEndDate' is 'currentTime'
+
+    QByteArray ba_currentDate = codec->fromUnicode(currentDateString);
+    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(ticket->getPrintingData()["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);
+
+
+    // --------------------------------------------------------------------------------------
+
+    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));
+}
+
+void ATBDeviceControllerPlugin::private_setupDynTemplatData_STOP_RECEIPT(struct T_dynDat *dynTicketData,  Ticket *ticket)
+{
+    // same as START_RECEIPT
+    this->private_setupDynTemplateData_START_RECEIPT(dynTicketData, ticket);
+}
+
+void ATBDeviceControllerPlugin::private_setupDynTemplatData_FOOD_STAMP(struct T_dynDat *dynTicketData, Ticket *ticket)
+{
+    quint8 currentProcessedTemplateNumber = ticket->getCurrentProcessedTemplateNumber();
+
+    // TODO: check DynXList size / or ensure that DynXList has value
+
+    // "Mitarbeiter-Nummer": dynPr1 -> licenceplate
+    QString currentEMP_Nr = ticket->getDyn1List().at(currentProcessedTemplateNumber);
+    QByteArray ba_licenseplate = codec->fromUnicode(currentEMP_Nr);
+    memcpy((char*)dynTicketData->licensePlate, ba_licenseplate.data(), std::min(ba_licenseplate.size(),8));
+
+    // "Lauf.Nr": dynPr2 -> vendingPrice
+    QString currentStampNumber = ticket->getDyn2List().at(currentProcessedTemplateNumber);
+    QByteArray ba_amount = codec->fromUnicode(currentStampNumber);
+    memcpy((char*)dynTicketData->vendingPrice, ba_amount.data(), std::min(ba_amount.size(),8));
+
+    // DEBUG
+    qCritical() << "-------------------------------------------------------";
+    qCritical() << "private_setupDynTemplatData_FOOD_STAMP()";
+    qCritical() << "       currentProcessedTemplateNumber: " << currentProcessedTemplateNumber;
+    qCritical() << "                        currentEMP_Nr: " << currentEMP_Nr;
+    qCritical() << "                   currentStampNumber: " << currentStampNumber;
+    qCritical() << "-------------------------------------------------------";
+}
+
+
+
 /************************************************************************************************
  * cash payment
  */
@@ -1308,6 +1453,10 @@ bool ATBDeviceControllerPlugin::private_loadCashAgentLib(QString pluginName)
 
     qCritical() << "ATBDeviceControllerPlugin: loaded CashAgentLib";
 
+    if (this->isMaster) {
+        QTimer::singleShot(500, this, &ATBDeviceControllerPlugin::startPhysicalLayer);
+    }
+
     return true;
 }
 

src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -7,12 +7,13 @@
 #include "src/ATBAPP/DeviceControllerInterface.h"
 #include "src/ATBAPP/ATBAPPplugin.h"
 #include "src/ATBAPP/DeviceControllerDiag.h"
+#include "src/ATBAPP/support/Ticket.h"
 
 #include "version.h"
 
+#include "support/PersistentData.h"
 
-
-#include "interfaces.h"
+#include <DeviceController/interfaces.h>
 
 #include <unistd.h>
 
@@ -20,11 +21,11 @@
 class DBusControllerInterface;
 class QTextCodec;
 
-
 using namespace nsDeviceControllerInterface;
 
 class QSettings;
 
+
 class ATBDeviceControllerPlugin :
         public DeviceControllerInterface
 {
@@ -43,6 +44,8 @@ public:
     // interface:
     PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings);
 
+    void sendDeviceParameter(const QJsonObject & jsonObject);
+
     // TASKS: Cash handling -------------------------------------------------------
     void requestStartCashInput(const QString & amount);
     void requestStopCashInput();
@@ -94,8 +97,6 @@ private:
    QString errorDescription;
    QString pluginInfo;
 
-   QList<int> templateList;
-
    QString serialPortName;
 
    bool useDebug;
@@ -112,6 +113,8 @@ private:
 
    DeviceControllerDiag* diag;
 
+   PersistentData *persistentData;
+
    uint32_t cashStartAmountInt;
 
 
@@ -129,8 +132,17 @@ private:
    // dbus
    int init_sc_dbus();
 
+   // printer privates ----------------------------------------------------------------------------
+   Ticket * currentTicket;
    QLocale printerLocale;
 
+   void prepareDynTemplateData();
+
+   void private_setupDynTemplateData_START_RECEIPT(struct T_dynDat *dynTicketData, Ticket *ticket);
+   void private_setupDynTemplatData_STOP_RECEIPT(struct T_dynDat *dynTicketData,   Ticket *ticket);
+   void private_setupDynTemplatData_FOOD_STAMP(struct T_dynDat *dynTicketData,     Ticket *ticket);
+   // ---------------------------------------------------------------------------------------------
+
 private slots:
    // printer
 
@@ -140,6 +152,8 @@ private slots:
    void onPrinterWaitForPrintingTicket();
    void onPrinterWaitForPrintingReceipt();
 
+   void onPrinterPrepareDynTemplateData();
+
    void onPrintFinishedOK();
    void onPrintFinishedERR();
 

src/ATBAPP/DeviceControllerDiag.cpp

@@ -5,13 +5,16 @@
 #include <QUuid>
 #include <QDebug>
 
-DeviceControllerDiag::DeviceControllerDiag(QObject *parent)
+DeviceControllerDiag::DeviceControllerDiag(PersistentData *pData, QObject *parent)
     : QObject(parent)
     , coinProcessorType(nsDeviceControllerInterface::COIN_PROCESSOR::ESCROW)
     , billAcceptor(nsDeviceControllerInterface::BILL_ACCEPTOR::NO)
     , eventReceiver(nullptr)
     , isRequestRunning(false)
     , flagInterruptDiag(false)
+    , lastState(DeviceController::State::INITIAL_STATE)
+    , _isErrorState(false)
+    , pData(pData)
 {
     diagRequestTimeoutTimer = new QTimer(this);
     diagRequestTimeoutTimer->setInterval(1000*20);  // 20s
@@ -42,6 +45,16 @@ void DeviceControllerDiag::diagRequest()
     this->diagRequestTimeoutTimer->start();
 
     this->private_startDiag();
+
+    // read dc-fw-version:
+    /* note: dc_getSWVersion() returns always 32 characters (QString)...
+     * if no version string could be read it will contain 32 null-characters:
+     * "\u0000\u0000..."
+     */
+    QString dc_fw_version = hw->dc_getSWversion().remove(QChar('\0'));
+    qCritical() << "ATBDeviceControllerPlugin: DC firmware version: " << dc_fw_version;
+    this->pData->setDCFirmwareVersion(dc_fw_version);
+    this->pData->serializeToFile();
 }
 
 
@@ -51,6 +64,24 @@ void DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout()
     this->flagInterruptDiag = true;
 }
 
+
+bool DeviceControllerDiag::isErrorState()
+{
+    return this->_isErrorState;
+}
+
+bool DeviceControllerDiag::isOperatingState()
+{
+    return !this->_isErrorState;
+}
+
+QSet<DeviceController::State> DeviceControllerDiag::getCurrentMachineState()
+{
+    return this->machineEventSet;
+}
+
+
+
 void DeviceControllerDiag::private_startDiag()
 {
     // check for DiagRequestTimeoutTimerTimeout:
@@ -219,6 +250,9 @@ void DeviceControllerDiag::sub_componentAssessment()
     // -----------------------------------------------------------------------------------------------
 
     switch (devPara.kindOfCoinChecker) {
+        case 0:
+            this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::NONE;
+            break;
         case 1:
         case 2:
             this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::ESCROW;
@@ -351,7 +385,6 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
 {
     qCritical() << "DeviceControllerDiag::private_sendDiagEvent() result: " << result;
 
-
     if (this->eventReceiver == nullptr) {
         qCritical() << "DeviceControllerDiag: no eventReceiver";
         return;
@@ -374,61 +407,77 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
     QString parameter;
     switch (result) {
 
+    case DeviceController::State::INITIAL_STATE:
+        break;
     case DeviceController::State::A000:   // alarm / intrusion
         eventClass = EVENT_CLASS::ALARM;
         parameter  = "alarm / intrusion";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E002:    // real time clock error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "real time clock error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E003:   // voltage error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "voltage error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E004:   // temperature error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "temperature error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E007:    // coin safe full
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "coin safe full";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E008:    // bill acceptor full
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "bill acceptor full";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E009:    // no cash box
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "no cash box";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E010:    // coin escrow
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "coin escrow";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E011:    // mem error int.ee.
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "mem error int.ee.";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E018:    // no paper
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "no paper";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E020:    // printer error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "printer error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E025:    // coin blocker
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "coin blocker";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E026:    // error coin validator
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "error coin validator";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E034:    // mdb error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "mdb error";
+        this->_isErrorState = true;
         break;
 
     case DeviceController::State::E071:   // cash box change is ongoing
@@ -459,14 +508,21 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
     case DeviceController::State::E255:   // no valid data from DeviceController
         eventClass = EVENT_CLASS::STATE;
         parameter  = "";
-        qCritical() << "                ... ignore " << QMetaEnum::fromType<DeviceController::State>().valueToKey(result);
+        qCritical() << "       ... ignore " << QMetaEnum::fromType<DeviceController::State>().valueToKey(result);
         return;
         break;
     case DeviceController::State::O000:   // everything is fine
         this->machineEventSet.clear();
+        this->_isErrorState = false;
         eventClass = EVENT_CLASS::OPERATE;
         parameter  = "";
-        qCritical() << "                ... everything fine";
+        if (this->lastState == DeviceController::State::O000) {
+            qCritical() << "   ... everything fine, no state change -> skip sending";
+            return;
+        }
+        else {
+            qCritical() << "   ... everything fine";
+        }
         break;
 
     case DeviceController::State::W001:   // paper low
@@ -487,6 +543,7 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
         break;
     }
 
+    this->lastState = result;
 
     ATBMachineEvent *machineEvent = new ATBMachineEvent(
                 eventId,

src/ATBAPP/DeviceControllerDiag.h

@@ -5,9 +5,12 @@
 #include <QSet>
 #include <QTimer>
 
-#include "ATBMachineEvent.h"
-#include "interfaces.h"
+#include <DeviceController/interfaces.h>
+
 #include "DeviceControllerInterface.h"
+#include "ATBMachineEvent.h"
+
+#include "support/PersistentData.h"
 
 
 namespace DeviceController {
@@ -49,7 +52,9 @@ namespace DeviceController {
         W001,
         W002,
         W003,
-        W004
+        W004,
+
+        INITIAL_STATE
     };
     Q_ENUM_NS(State)
 }
@@ -60,13 +65,20 @@ class DeviceControllerDiag : public QObject
     Q_OBJECT
 
 public:
-    DeviceControllerDiag(QObject *parent = nullptr);
+    DeviceControllerDiag(PersistentData *pData, QObject *parent = nullptr);
 
     void init(hwinf* hw, QObject* eventReceiver);
 
     nsDeviceControllerInterface::COIN_PROCESSOR coinProcessorType;
     nsDeviceControllerInterface::BILL_ACCEPTOR  billAcceptor;
 
+    /**
+     * return true, if machineEventSet contains an error
+     */
+    bool isErrorState();
+    bool isOperatingState();
+    QSet<DeviceController::State> getCurrentMachineState();
+
 public slots:
     void diagRequest();
 
@@ -88,9 +100,11 @@ private:
 
     int lastVoltage;
 
+    DeviceController::State lastState;
     QSet<DeviceController::State> machineEventSet;
+    bool _isErrorState;
 
-
+    PersistentData* pData;
 
 private slots:
     void onDiagRequestTimeoutTimerTimeout();

src/ATBAPP/DeviceControllerInterface.h

@@ -5,6 +5,7 @@
 
 #include <QSettings>
 #include <QString>
+#include <QJsonObject>
 
 #include "ATBAPPplugin.h"
 
@@ -39,6 +40,12 @@ public:
     virtual nsDeviceControllerInterface::PLUGIN_STATE initDCPlugin(QObject *eventReceiver,
                                                                    const QSettings & settings) = 0;
 
+    /**
+     * e.g. send location
+     */
+    virtual void sendDeviceParameter(const QJsonObject & jsonObject) = 0;
+
+
     // TASKS: Cash handling -------------------------------------------------------
     /**
      * enables coin input
@@ -104,6 +111,9 @@ signals:
                                      const QString & errorCode,
                                      const QString & errorDescription);
 
+
+    void coinAttached();
+
     /**
      * emitted on e.g. a coin input
      */
@@ -193,7 +203,7 @@ signals:
 
 
 Q_DECLARE_INTERFACE(DeviceControllerInterface,
-                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.1.1")
+                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.1.4")
 
 
 namespace nsDeviceControllerInterface {
@@ -226,11 +236,13 @@ namespace nsDeviceControllerInterface {
         ERROR_RECEIPT,
         START_RECEIPT,   // e.g. Szeged Start
         STOP_RECEIPT,    // e.g. Szeged Stop
+        FOOD_STAMP
     };
 
     enum class COIN_PROCESSOR : quint8 {
         CHANGER,
-        ESCROW
+        ESCROW,
+        NONE
     };
 
     enum class BILL_ACCEPTOR  : quint8 {

src/ATBAPP/support/CashUtils.h

@@ -2,7 +2,7 @@
 #define CASHUTILS_H
 
 #include <QObject>
-#include "interfaces.h"
+#include <DeviceController/interfaces.h>
 
 namespace CashUtils {
 

src/ATBAPP/support/PersistentData.cpp

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

src/ATBAPP/support/PersistentData.h

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

src/ATBAPP/support/Ticket.cpp

@@ -0,0 +1,169 @@
+#include "Ticket.h"
+
+#include <QDebug>
+
+Ticket::Ticket(TICKET_VARIANT ticketVariant, QObject *parent )
+    : QObject(parent)
+    , ticketVariant(ticketVariant)
+    , _hasTemplateDynData(false)
+{
+
+}
+
+TICKET_VARIANT Ticket::variant()
+{
+    return this->ticketVariant;
+}
+
+QList<quint8> * Ticket::templateList()
+{
+    return &(this->_templateList);
+}
+
+bool Ticket::hasTemplateDynData()
+{
+    return this->_hasTemplateDynData;
+}
+
+quint8 Ticket::getCurrentProcessedTemplateNumber()
+{
+    return this->currentProcessedTemplateNumber;
+}
+
+void Ticket::setCurrentTemplateProcessed()
+{
+    this->currentProcessedTemplateNumber++;
+}
+
+
+bool Ticket::initNew(TICKET_VARIANT ticketVariant, const QList<quint8> & templateList, const QHash<QString, QVariant> & printingData)
+{
+    this->clear();
+
+    this->ticketVariant = ticketVariant;
+    this->printingData = printingData;
+    this->_templateList = templateList;
+    this->currentProcessedTemplateNumber = 0;
+
+    // DEBUG
+    qCritical() << "Ticket::initNew():";
+    qCritical() << "      -> " << ticketVariant;
+
+    int multiplicatorInt = 1;  // default
+
+    switch (this->ticketVariant) {
+    case TICKET_VARIANT::PARKING_TICKET:
+        break;
+    case TICKET_VARIANT::RECEIPT:
+        break;
+    case TICKET_VARIANT::ERROR_RECEIPT:
+        break;
+    case TICKET_VARIANT::START_RECEIPT:
+        this->_templateList << 21 << 22 << 23;
+        break;
+    case TICKET_VARIANT::STOP_RECEIPT:
+        this->_templateList << 24 << 25 << 26;
+        break;
+    case TICKET_VARIANT::FOOD_STAMP:
+         if (printingData.contains("dyn1_list")) {
+            this->_hasTemplateDynData = true;
+
+            this->dyn1List = printingData["dyn1_list"].toStringList();
+            this->dyn2List = printingData["dyn2_list"].toStringList();
+         }
+
+         if (printingData.contains("multiplicator")) {
+             multiplicatorInt = printingData["multiplicator"].toInt();
+             for (int i = 1; i < multiplicatorInt; i++) {
+                 this->_templateList << 1;
+             }
+             // last template:
+             this->_templateList << 2;
+         }
+
+         // DEBUG FOOD_STAMP:
+         qCritical() << "     --> printingData[\"multiplicator\"]" << multiplicatorInt;
+
+        break;
+    }
+
+
+    // DEBUG
+    QString templateListString;
+    for (int i =0; i < this->_templateList.size(); ++i) {
+        templateListString.append(QString(" %1").arg(this->_templateList.at(i)));
+    }
+    qCritical() << "     -> templates: " << templateListString;
+
+
+    return true;
+}
+
+void Ticket::clear()
+{
+    this->ticketVariant = TICKET_VARIANT::PARKING_TICKET;
+    this->printingData.clear();
+    this->_templateList.clear();
+    this->errorCode.clear();
+    this->errorDescription.clear();
+
+    this->_hasTemplateDynData = false;
+    this->dyn1List.clear();
+    this->dyn1List.clear();
+}
+
+QString Ticket::getErrorCode()         {  return this->errorCode;        }
+QString Ticket::getErrorDescription()  {  return this->errorDescription; }
+
+
+
+
+/**
+ */
+QStringList Ticket::getDyn1List()
+{
+    return this->dyn1List;
+}
+
+QStringList Ticket::getDyn2List()
+{
+    return this->dyn2List;
+}
+
+QHash<QString, QVariant> & Ticket::getPrintingData()
+{
+    return this->printingData;
+}
+
+
+
+
+/************************************************************************************************
+ * operator
+ *
+ */
+QDebug operator<<(QDebug debug, TICKET_VARIANT ticketVariant)
+{
+    switch (ticketVariant) {
+        case TICKET_VARIANT::PARKING_TICKET:
+            debug << "TICKET_VARIANT::PARKING_TICKET";
+            break;
+        case TICKET_VARIANT::RECEIPT:
+            debug << "TICKET_VARIANT::RECEIPT";
+            break;
+        case TICKET_VARIANT::ERROR_RECEIPT:
+            debug << "TICKET_VARIANT::ERROR_RECEIPT";
+            break;
+        case TICKET_VARIANT::START_RECEIPT:
+            debug << "TICKET_VARIANT::START_RECEIPT";
+            break;
+        case TICKET_VARIANT::STOP_RECEIPT:
+            debug << "TICKET_VARIANT::STOP_RECEIPT";
+            break;
+        case TICKET_VARIANT::FOOD_STAMP:
+            debug << "TICKET_VARIANT::FOOD_STAMP";
+            break;
+    }
+
+    return debug;
+}

src/ATBAPP/support/Ticket.h

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