Diag: set E255 only once

Diag: clear machineEventSet on diagRequest
Diag: remove E255 / W255 on valid data
2025-06-12 16:33:32 +02:00 · 2025-06-12 10:50:29 +02:00 · 2025-06-12 10:37:26 +02:00 · 2025-06-12 10:24:25 +02:00 · 2025-06-12 08:40:59 +02:00 · 2025-06-12 08:35:58 +02:00
6 changed files with 569 additions and 85 deletions
--- a/src/ATBAPP/ATBDeviceControllerPlugin.cpp
+++ b/src/ATBAPP/ATBDeviceControllerPlugin.cpp
@@ -45,6 +45,7 @@ PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *eventReceiver, con
    QString printerLocaleString = settings.value("ATBDeviceControllerPlugin/printerLocale", "de_DE").toString().toLatin1();
    this->printerLocale = QLocale(printerLocaleString);

+    this->initTicketTemplateList(&settings);

    this->init_sc_dbus();

@@ -132,7 +133,7 @@ PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *eventReceiver, con
        qCritical() << "ATBDeviceControllerPlugin: Set printer encoding to " << printerEncoding;
    }

-    this->diag->init(this->hw, this->eventReceiver);
+    this->diag->init(this->hw, this->dbus, this->eventReceiver);

    this->pluginState = PLUGIN_STATE::INITIALIZED;

@@ -140,6 +141,58 @@ PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *eventReceiver, con
 }


+void ATBDeviceControllerPlugin::initTicketTemplateList(const QSettings * settings)
+{
+    QList<quint8> templateList;
+    QString templateListString;
+
+
+    QMetaEnum metaTicketVariants = QMetaEnum::fromType<nsDeviceControllerInterface::TICKET_VARIANT>();
+    for (int i = 0; i < metaTicketVariants.keyCount(); i++) {
+        const char* ticketVariant_char = metaTicketVariants.key(i);
+        quint8 intValue = metaTicketVariants.value(i);
+
+        // DEBUG
+        //qCritical() << " processing TICKET_VARIANT::" << ticketVariant_char;
+
+        QString configKey = QString("TICKET_TEMPLATES/") + ticketVariant_char;
+        QVariant raw_templateList = settings->value(configKey, "");
+        if (raw_templateList.type() == QVariant::StringList) {
+            templateListString = raw_templateList.toStringList().join(",");
+        } else {
+            templateListString = raw_templateList.toString();
+        }
+
+        // DEBUG
+        //qCritical() << "                 configKey: " << configKey;
+        //qCritical() << "        templateListString: " << templateListString;
+
+        QStringList templateListStringList = templateListString.split(",", QString::SplitBehavior::SkipEmptyParts);
+
+        quint8 templateEntry;
+        bool ok;
+        for (const auto & ListEntry : templateListStringList) {
+            templateEntry = ListEntry.toInt(&ok);
+            if (ok) {
+                templateList.append(templateEntry);
+            }
+        }
+
+        // DEBUG
+        /*
+        QStringList elements;
+        for (const auto &item : templateList) {
+            elements << QString::number(item);
+        }
+        qCritical() << "             template list: " <<  elements.join(',');
+        */
+
+        this->ticketTemplateList.insert(static_cast<nsDeviceControllerInterface::TICKET_VARIANT>(intValue), templateList);
+        templateList.clear();
+    }
+}
+
+
 void ATBDeviceControllerPlugin::sendDeviceParameter(const QJsonObject &jsonObject)
 {

@@ -610,8 +663,6 @@ void ATBDeviceControllerPlugin::onCBinAndAllDoorsClosed()
 {
    qCritical() << "ATBDeviceControllerPlugin::onCBinAndAllDoorsClosed()";

-    this->diag->diagReInit();
-
    QTimer::singleShot(2000, this, SIGNAL(requestModeIDLE()));

    this->dbus->finishedBackgroundTask("DOOR_OPEN");
@@ -678,17 +729,32 @@ void ATBDeviceControllerPlugin::onNewVoltage(uint32_t voltage)
 */
 void ATBDeviceControllerPlugin::requestPrintTicket(nsDeviceControllerInterface::TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData)
 {
-    QList<quint8> templateList;
-
-    // TODO: read template list from .ini
+    QList<quint8> templateList = this->ticketTemplateList[ticketVariant];

+    if (templateList.isEmpty()) {
+        qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket()";
+        qCritical() << "     TICKET_VARIANT: " << ticketVariant;
+        qCritical() << "     -> templateList is empty!";
+        qCritical() << "     -> switching to legacy interface";
+        this->requestPrintTicket(printingData);
+        return;
+    }

    // DEBUG
    qCritical() << "------------------------------------------------------------------------";
    qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket()";
    qCritical() << "     TICKET_VARIANT: " << ticketVariant;
+    if (ticketVariant == nsDeviceControllerInterface::TICKET_VARIANT::FOOD_STAMP) {
    qCritical() << "          dyn1_list: " << printingData["dyn1_list"].toStringList();
    qCritical() << "          dyn2_list: " << printingData["dyn2_list"].toStringList();
+    }
+    QStringList listElements;
+    for (const auto &item : templateList) {
+        listElements << QString::number(item);
+    }
+    qCritical() << "      template list: " <<  listElements.join(',');
+
+
    qCritical() << "------------------------------------------------------------------------";


@@ -738,7 +804,7 @@ void ATBDeviceControllerPlugin::requestPrintReceipt(const QString & printingStri


    this->printResultCheckCounter = 0;
-    QTimer::singleShot(4000, this, SLOT(onPrinterWaitForPrintingReceipt()));
+    QTimer::singleShot(2000, this, SLOT(onPrinterWaitForPrintingReceipt()));

    //QTimer::singleShot(2000, this, [this](){ hw->prn_cut(3);  } );
 }
@@ -759,7 +825,7 @@ void ATBDeviceControllerPlugin::onPrinterWaitForPrintingReceipt()
                                        "",
                                        "");
        hw->prn_switchPower(true);
-        hw->prn_cut(3);
+        QTimer::singleShot(200, this, [this](){ hw->prn_cut(3);  } );
        break;
    case 2:    // printing finished, Error
        qCritical() << "DC Error: wait for printing receipt";
@@ -769,15 +835,21 @@ void ATBDeviceControllerPlugin::onPrinterWaitForPrintingReceipt()
        emit this->printReceiptFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
                                       this->errorCode,
                                       this->errorDescription);
+        hw->prn_switchPower(true);
+        QTimer::singleShot(200, this, [this](){ hw->prn_cut(3);  } );
        break;
    default:
-        qCritical() << "DC Error: wait for printing receipt";
+        qCritical() << "DC Error: wait for printing receipt: printerResult = " << printerResult;
        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
+        this->errorDescription = "Printer error(" + QString(printerResult) + ")";

        emit this->printReceiptFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
                                       this->errorCode,
                                       this->errorDescription);
+        // do an emergency cut
+        hw->prn_switchPower(true);
+        QTimer::singleShot(200, this, [this](){ hw->prn_cut(3);  } );
+
        break;
    }

@@ -1110,10 +1182,13 @@ void ATBDeviceControllerPlugin::prepareDynTemplateData()
        private_setupDynTemplatData_FINE_PAYMENT(dynTicketData, this->currentTicket);
        break;
    case nsDeviceControllerInterface::TICKET_VARIANT::RECEIPT:
+        private_setupDynTemplateData_DEFAULT(dynTicketData, this->currentTicket);
        break;
    case nsDeviceControllerInterface::TICKET_VARIANT::ERROR_RECEIPT:
+        private_setupDynTemplateData_DEFAULT(dynTicketData, this->currentTicket);
        break;
    case nsDeviceControllerInterface::TICKET_VARIANT::PARKING_TICKET:
+        private_setupDynTemplateData_DEFAULT(dynTicketData, this->currentTicket);
        break;
    case nsDeviceControllerInterface::TICKET_VARIANT::FREE_TICKET:
        private_setupDynTemplatData_FREE_TICKET(dynTicketData, this->currentTicket);
@@ -1121,6 +1196,39 @@ void ATBDeviceControllerPlugin::prepareDynTemplateData()
    case nsDeviceControllerInterface::TICKET_VARIANT::FOOD_STAMP:
        private_setupDynTemplatData_FOOD_STAMP(dynTicketData, this->currentTicket);
        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_1:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_2:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_3:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_4:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_5:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_6:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_7:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_8:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_9:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    case nsDeviceControllerInterface::TICKET_VARIANT::FIXED_PRICE_10:
+        private_setupDynTemplateData_FIXED_PRICE(dynTicketData, this->currentTicket);
+        break;
+    default:
+        private_setupDynTemplateData_DEFAULT(dynTicketData, this->currentTicket);
+        break;
    }

    // C-Programmierung: wird hier nur 'licensePlate' gedruckt?
@@ -1276,6 +1384,83 @@ void ATBDeviceControllerPlugin::private_setupDynTemplatData_FREE_TICKET(struct T
    // ! and yes... 'ParkingEndDate' is 'currentTime'
 }

+void ATBDeviceControllerPlugin::private_setupDynTemplateData_DEFAULT(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 = TicketUtils::getLocaleDateString(this->printerLocale, parkingEndDateTime.date());
+    QString currentDateString    = TicketUtils::getLocaleDateString(this->printerLocale, currentDateTime.date());
+
+
+    // 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));
+
+    // Product-Text
+    QByteArray ba_productText = codec->fromUnicode(ticket->getPrintingData()["productText"].toString());
+    memcpy((char*)dynTicketData->dynDat5,      ba_productText.data(), std::min(ba_productText.size(),8));
+
+    // Ticket-Number
+    QByteArray ba_ticketNumber = codec->fromUnicode(ticket->getPrintingData()["ticketNumber"].toString());
+    memcpy((char*)dynTicketData->dynDat7,      ba_ticketNumber.data(), std::min(ba_ticketNumber.size(),8));
+}
+
+
+
+void ATBDeviceControllerPlugin::private_setupDynTemplateData_FIXED_PRICE(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 = TicketUtils::getLocaleDateString(this->printerLocale, parkingEndDateTime.date());
+    QString currentDateString    = TicketUtils::getLocaleDateString(this->printerLocale, currentDateTime.date());
+
+
+    // 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));
+
+    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));
+
+    // Ticket-Number
+    QByteArray ba_ticketNumber = codec->fromUnicode(ticket->getPrintingData()["ticketNumber"].toString());
+    memcpy((char*)dynTicketData->dynDat5,      ba_ticketNumber.data(), std::min(ba_ticketNumber.size(),8));
+
+    // Product-Text 1
+    QByteArray ba_productText1 = codec->fromUnicode(ticket->getPrintingData()["productText"].toString()).left(8);
+    memcpy((char*)dynTicketData->dynDat6,      ba_productText1.data(), std::min(ba_productText1.size(),8));
+
+    // Product-Text 2
+    QByteArray ba_productText2 = codec->fromUnicode(ticket->getPrintingData()["productText"].toString()).mid(8,8);
+    memcpy((char*)dynTicketData->dynDat7,      ba_productText2.data(), std::min(ba_productText2.size(),8));
+}
+

 /************************************************************************************************
 * cash payment
--- a/src/ATBAPP/ATBDeviceControllerPlugin.h
+++ b/src/ATBAPP/ATBDeviceControllerPlugin.h
@@ -140,8 +140,13 @@ private:
   Ticket * currentTicket;
   QLocale printerLocale;

+   QHash<TICKET_VARIANT, QList<quint8>> ticketTemplateList;
+
+   void initTicketTemplateList(const QSettings * settings);
   void prepareDynTemplateData();

+   void private_setupDynTemplateData_DEFAULT(struct T_dynDat *dynTicketData, Ticket *ticket);
+   void private_setupDynTemplateData_FIXED_PRICE(struct T_dynDat *dynTicketData, Ticket *ticket);
   void private_setupDynTemplateData_START_RECEIPT(struct T_dynDat *dynTicketData, Ticket *ticket);
   void private_setupDynTemplatData_STOP_RECEIPT(struct T_dynDat *dynTicketData,   Ticket *ticket);
   void private_setupDynTemplatData_FOOD_STAMP(struct T_dynDat *dynTicketData,     Ticket *ticket);
--- a/src/ATBAPP/DeviceControllerDiag.cpp
+++ b/src/ATBAPP/DeviceControllerDiag.cpp
@@ -8,6 +8,7 @@
 #include <QProcess>

 #include "support/JSON.h"
+#include "src/ATBAPP/support/DBusControllerInterface.h"


 DeviceControllerDiag::DeviceControllerDiag(PersistentData *pData, QObject *parent)
@@ -17,6 +18,7 @@ DeviceControllerDiag::DeviceControllerDiag(PersistentData *pData, QObject *paren
    , eventReceiver(nullptr)
    , isRequestRunning(false)
    , flagInterruptDiag(false)
+    , isDiagBackgroundTask(false)
    , lastState(DeviceController::State::INITIAL_STATE)
    , _isErrorState(false)
    , pData(pData)
@@ -29,10 +31,11 @@ DeviceControllerDiag::DeviceControllerDiag(PersistentData *pData, QObject *paren
 }


-void DeviceControllerDiag::init(hwinf *hw, QObject* eventReceiver)
+void DeviceControllerDiag::init(hwinf *hw, DBusControllerInterface *dbus, QObject* eventReceiver)
 {
    this->hw = hw;
    this->eventReceiver = eventReceiver;
+    this->dbus = dbus;

    // make a system check on startup:
    QTimer::singleShot(2000, this, &DeviceControllerDiag::diagRequest);
@@ -42,6 +45,7 @@ void DeviceControllerDiag::init(hwinf *hw, QObject* eventReceiver)
 void DeviceControllerDiag::diagReInit()
 {
    this->machineEventSet.clear();
+    this->previousMachineEventSet.clear();
    this->_isErrorState = false;
 }

@@ -58,6 +62,7 @@ void DeviceControllerDiag::diagRequest()
        qCritical() << "DeviceControllerDiag::diagRequest() is already running";
        return;
    }
+    this->machineEventSet.clear();
    this->isRequestRunning = true;
    this->diagRequestTimeoutTimer->start();

@@ -92,8 +97,11 @@ bool DeviceControllerDiag::isOperatingState()
    return !this->_isErrorState;
 }

-QSet<DeviceController::State> DeviceControllerDiag::getCurrentMachineState()
+QSet<DCMachineEvent> DeviceControllerDiag::getCurrentMachineState()
 {
+    // ensure that currentMachineEventSet is delivered here
+    if (this->isRequestRunning) return this->previousMachineEventSet;
+
    return this->machineEventSet;
 }

@@ -104,11 +112,15 @@ void DeviceControllerDiag::private_startDiag()
    // check for DiagRequestTimeoutTimerTimeout:
    if (this->flagInterruptDiag) {
        qCritical() << "DeviceControllerDiag::private_startDiag() interrupted!";
-        this->private_sendDiagEvent(DeviceController::State::E255);
-        this->isRequestRunning  = false;
-        this->flagInterruptDiag = false;
+        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::E255);
+        if (!this->previousMachineEventSet.contains(E255Event)) {
+            machineEventSet.insert(E255Event);
+            private_sendDiagEvent(E255Event, DeviceController::Action::SET);
+        }
        if (this->E255counter > 5) {
            this->restartCArun();
+            // try it again, until success:
+            QTimer::singleShot(1000, this, &DeviceControllerDiag::diagRequest);
        }
        else {
            this->E255counter++;
@@ -121,6 +133,7 @@ void DeviceControllerDiag::private_startDiag()
             * - diag is called again in ModeOOO wokeup()
             */
        }
+        this->private_finishDiag();
        return;
    }

@@ -129,13 +142,21 @@ void DeviceControllerDiag::private_startDiag()

    if (result) {
        qCritical() << "DeviceControllerDiag::private_startDiag() DCdata is valid";
+        this->machineEventSet.remove(DCMachineEvent(DeviceController::State::E255));
+        this->machineEventSet.remove(DCMachineEvent(DeviceController::State::W255));
        QTimer::singleShot(200, this, &DeviceControllerDiag::sys_superviseSystem);
    }
    else {
        qCritical() << "DeviceControllerDiag::private_startDiag() DCdata is +++not+++ valid";

-        // try it again
        hw->dc_autoRequest(true);
+
+        if (! this->isDiagBackgroundTask) {
+            this->isDiagBackgroundTask = true;
+            this->dbus->startBackgroundTask("E255");
+        }
+
+        // try it again
        QTimer::singleShot(200, this, &DeviceControllerDiag::private_startDiag);
    }
 }
@@ -153,11 +174,16 @@ void DeviceControllerDiag::sys_superviseSystem()
    // check for DiagRequestTimeoutTimerTimeout:
    if (this->flagInterruptDiag) {
        qCritical() << "DeviceControllerDiag::sys_superviseSystem() interrupted!";
-        this->private_sendDiagEvent(DeviceController::State::E255);
-        this->flagInterruptDiag = false;
-        this->isRequestRunning  = false;
+        // send
+        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::E255);
+        if (!this->previousMachineEventSet.contains(E255Event)) {
+            machineEventSet.insert(E255Event);
+            private_sendDiagEvent(E255Event, DeviceController::Action::SET);
+        }
        if (this->E255counter > 5) { this->restartCArun(); }
                              else { this->E255counter++; }
+        QTimer::singleShot(400, this, &DeviceControllerDiag::diagRequest);
+        this->private_finishDiag();
        return;
    }

@@ -166,11 +192,15 @@ void DeviceControllerDiag::sys_superviseSystem()
        // es gibt keinerlei gültige Daten vom DC
        qCritical() << "DeviceControllerDiag::sys_superviseSystem() no valid data!";
        hw->dc_autoRequest(true);
-        this->private_sendDiagEvent(DeviceController::State::M0254);
-        this->diagRequestTimeoutTimer->stop();
-        this->isRequestRunning  = false;
+
+        DCMachineEvent E255Event = DCMachineEvent(DeviceController::State::M0254);
+        machineEventSet.insert(E255Event);
+        private_sendDiagEvent(E255Event, DeviceController::Action::SET);
+
        if (this->E255counter > 5) { this->restartCArun(); }
                              else { this->E255counter++; }
+        QTimer::singleShot(400, this, &DeviceControllerDiag::diagRequest);
+        this->private_finishDiag();
        return;
    }

@@ -223,7 +253,7 @@ void DeviceControllerDiag::sub_componentAssessment()

    if (dynMaCond.onAlarm>0) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::A000);
+        this->private_setDiagEvent(DeviceController::State::A000);
    }

    // check for open doors
@@ -232,41 +262,41 @@ void DeviceControllerDiag::sub_componentAssessment()
        // Service or battery door is open
        flag_sendOperate = false;
        qCritical() << "DeviceControllerDiag::sys_superviseSystem() Service or battery door is open, goto INTRUSION MODE";
-        this->private_sendDiagEvent(DeviceController::State::M0253);
+        this->private_setDiagEvent(DeviceController::State::M0253);
    }
    if (dynMaCond.middleDoor) {
        // vault door is open
        flag_sendOperate = false;
        qCritical() << "DeviceControllerDiag::sys_superviseSystem() vault door is open, goto INTRUSION MODE";
-        this->private_sendDiagEvent(DeviceController::State::M0252);
+        this->private_setDiagEvent(DeviceController::State::M0252);
    }

    // check for invalid states:

    if (modCond.rtc>=200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E002);
+        this->private_setDiagEvent(DeviceController::State::E002);
    }
    if (modCond.printer==200 || modCond.printer==201) {   // 200: not connected  201: printer-HW-error  202: no paper
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E020);
+        this->private_setDiagEvent(DeviceController::State::E020);
    }
    if (modCond.printer==202) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E018);
+        this->private_setDiagEvent(DeviceController::State::E018);
    }

    if (modCond.coinBlocker>=200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E025);
+        this->private_setDiagEvent(DeviceController::State::E025);
    }
    if (modCond.mdbBus>=200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E034);
+        this->private_setDiagEvent(DeviceController::State::E034);
    }
    if (modCond.intEe>=200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E011);
+        this->private_setDiagEvent(DeviceController::State::E011);
    }

    // 2023-07-26: workaround for 00281/Szeged --------------------------------------------------------------
@@ -276,16 +306,16 @@ void DeviceControllerDiag::sub_componentAssessment()
    if (devPara.kindOfCoinChecker > 0) {
        if (modCond.coinSafe==201) { // full
            flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E007);
+            this->private_setDiagEvent(DeviceController::State::E007);
        }
        if (modCond.coinSafe==200)  {         // 200: kasse fehlt 201: voll  100:fast voll  1:ok
            flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E009);
+            this->private_setDiagEvent(DeviceController::State::E009);
        }
        if (modCond.coinEscrow>=200) {
            flag_sendOperate = false;
            // coinEscrow>200 is considered a warning:
-            this->private_sendDiagEvent(DeviceController::State::W010);
+            this->private_setDiagEvent(DeviceController::State::W010);
        }
    }
    // -----------------------------------------------------------------------------------------------
@@ -308,15 +338,15 @@ void DeviceControllerDiag::sub_componentAssessment()
        if (modCond.coinEscrow>=200) {
            flag_sendOperate = false;
            // coinEscrow>200 is considered a warning:
-            this->private_sendDiagEvent(DeviceController::State::W010);
+            this->private_setDiagEvent(DeviceController::State::W010);
        }
        if (modCond.coinSafe==201)  { // full
            flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E007);
+            this->private_setDiagEvent(DeviceController::State::E007);
        }
        if (modCond.coinSafe==200) {          // 200: kasse fehlt 201: voll  100:fast voll  1:ok
            flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E009);
+            this->private_setDiagEvent(DeviceController::State::E009);
        }
    } else
    if (devPara.kindOfCoinChecker==3)
@@ -324,15 +354,15 @@ void DeviceControllerDiag::sub_componentAssessment()
        if (modCond.changer>=200) {
            // Fehler Münzver.
            flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E026);
+            this->private_setDiagEvent(DeviceController::State::E026);
        }
        if (modCond.coinSafe==201) { // full
            flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E007);
+            this->private_setDiagEvent(DeviceController::State::E007);
        }
        if (modCond.coinSafe == 200)  {          // 200: kasse fehlt 201: voll  100:fast voll  1:ok
            flag_sendOperate = false;
-            this->private_sendDiagEvent(DeviceController::State::E009);
+            this->private_setDiagEvent(DeviceController::State::E009);
        }
    }

@@ -361,61 +391,113 @@ void DeviceControllerDiag::sub_componentAssessment()

    if (dynMaCond.modeAbrech>0) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E011);
+        this->private_setDiagEvent(DeviceController::State::E011);
    }

    if (dynMaCond.nowCardTest>0) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::M0072);
+        this->private_setDiagEvent(DeviceController::State::M0072);
    }

    if (dynMaCond.startupTestIsRunning>0) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::M0073);
+        this->private_setDiagEvent(DeviceController::State::M0073);
    }

    if (modCond.voltage>=200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::E003);
+        this->private_setDiagEvent(DeviceController::State::E003);
    }
    if (modCond.temper>=200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::W004);
+        this->private_setDiagEvent(DeviceController::State::W004);
    }

    // check for warnings
    if (modCond.printer>=100 && modCond.printer<200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::W001);
+        this->private_setDiagEvent(DeviceController::State::W001);
    }
    if (modCond.coinSafe>=100 && modCond.coinSafe<200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::W002);
+        this->private_setDiagEvent(DeviceController::State::W002);
    }
    if (modCond.voltage>=100 && modCond.voltage<200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::W003);
+        this->private_setDiagEvent(DeviceController::State::W003);
    }
    if (modCond.temper>=100 && modCond.temper<200) {
        flag_sendOperate = false;
-        this->private_sendDiagEvent(DeviceController::State::W004);
+        this->private_setDiagEvent(DeviceController::State::W004);
    }

+
+    // compare machineEventSets
+    // New events: present in current but not previous
+    QSet<DCMachineEvent> newEvents = this->machineEventSet - this->previousMachineEventSet;
+
+    // Reset events: present in previous but not current
+    QSet<DCMachineEvent> resetEvents = this->previousMachineEventSet - this->machineEventSet;
+
+    // DEBUG EventSets:
+    qCritical() << "sub_componentAssessment():";
+    qCritical() << "    newEvents: " << newEvents.size();
+    qCritical() << "  resetEvents: " << resetEvents.size();
+    QStringList DeviceControllerStateStringList;
+    for (const DCMachineEvent& event : this->machineEventSet) {
+        DeviceControllerStateStringList.append(QMetaEnum::fromType<DeviceController::State>().valueToKey(event.state));
+    }
+    qCritical() << "diagReq result: " << DeviceControllerStateStringList;
+
+    // Triggering Actions
+    // Iterate through the results
+    // send SET:
+    for (const DCMachineEvent& event : newEvents) {
+        private_sendDiagEvent(event, DeviceController::Action::SET);  // New event detected
+    }
+
+    // send RESET:
+    for (const DCMachineEvent& event : resetEvents) {
+        private_sendDiagEvent(event, DeviceController::Action::RESET);  // Event no longer present
+    }
+
+    // send Operate if there is no error
    if (flag_sendOperate) {
-        this->private_sendDiagEvent(DeviceController::State::O000);
+        // O000 must not be part of machineEventSet
+        DCMachineEvent O000DCMachineEvent = DCMachineEvent(DeviceController::State::O000);
+        this->private_sendDiagEvent(O000DCMachineEvent, DeviceController::Action::SET);
    }


    // finish diag
+    this->private_finishDiag();
+}

+/**
+ * @brief DeviceControllerDiag::private_finishDiag
+ *
+ * Single point to finish a diag process:
+ *  -
+ */
+void DeviceControllerDiag::private_finishDiag()
+{
    this->diagRequestTimeoutTimer->stop();
    this->isRequestRunning  = false;
    this->flagInterruptDiag = false;
+
+    this->previousMachineEventSet.unite(machineEventSet);      // add new elements from machineEventSet
+    this->previousMachineEventSet.intersect(machineEventSet);  // remove elements not in machineEventSet
+
+    if (this->isDiagBackgroundTask) {
+        this->isDiagBackgroundTask = false;
+        this->dbus->finishedBackgroundTask("E255");
+    }
 }


+
 /**
- * @brief DeviceControllerDiag::private_sendDiagEvent
+ * @brief DeviceControllerDiag::private_setDiagEvent
 * @param result - result value from 'sub_componentAssessment()',
 *               - 0x00 everything is fine
 *               - 0xFF on timer interrupt
@@ -423,31 +505,38 @@ void DeviceControllerDiag::sub_componentAssessment()
 *               - 0xFD Service or battery door is open
 *               - 0xFE vault door is open
 */
-void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
+void DeviceControllerDiag::private_setDiagEvent(DeviceController::State result)
 {
-    qCritical() << "DeviceControllerDiag::private_sendDiagEvent() result: " << result;
+    qCritical() << "DeviceControllerDiag::private_setDiagEvent() result: " << result;

    if (this->eventReceiver == nullptr) {
        qCritical() << "DeviceControllerDiag: no eventReceiver";
        return;
    }

-    if (machineEventSet.contains(result)) {
-        // do not send already sent events
-        qCritical() << "       ... is in machineEventList";
-        return;
-    }
-    else {
-        machineEventSet.insert(result);
-    }
+    DCMachineEvent newState = DCMachineEvent(result);
+
+    // DEBUG
+    qCritical() << "----> setDiagEvent: " << newState.state << " with id: " << newState.eventId;
+
+    machineEventSet.insert(newState);
+}


-    QString eventId = QUuid::createUuid().toString(QUuid::WithoutBraces).mid(0, 8);

-    QString eventName = QMetaEnum::fromType<DeviceController::State>().valueToKey(result);;
+/**
+ * @brief DeviceControllerDiag::private_sendDiagEvent
+ * @param result   WXXX | EXXX | O000
+ * @param action   SET|RESET
+ */
+void DeviceControllerDiag::private_sendDiagEvent(DCMachineEvent result, DeviceController::Action action)
+{
+    QString eventId = result.eventId;
+
+    QString eventName = QMetaEnum::fromType<DeviceController::State>().valueToKey(result.state);
    EVENT_CLASS eventClass = EVENT_CLASS::STATE;
    QString parameter;
-    switch (result) {
+    switch (result.state) {

    case DeviceController::State::INITIAL_STATE:
        break;
@@ -556,7 +645,6 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
        parameter  = "no valid data from DeviceController";
        break;
    case DeviceController::State::O000:   // everything is fine
-        this->machineEventSet.clear();
        this->_isErrorState = false;
        eventClass = EVENT_CLASS::OPERATE;
        parameter  = "";
@@ -591,7 +679,7 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
        break;
    }

-    this->lastState = result;
+    this->lastState = result.state;

    /**
     * Variant: send 'parameter' as JSON:
@@ -608,7 +696,7 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
                "DC",
                eventClass,
                eventName,
-                1,         // eventState
+                action,         // eventState
                parameter,
                ""         // second level info
                );
@@ -625,6 +713,25 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
 void DeviceControllerDiag::restartCArun()
 {
    this->E255counter = 0;
-    this->private_sendDiagEvent(DeviceController::State::W255);
+
+
+    DCMachineEvent W255Event = DCMachineEvent(DeviceController::State::W255);
+    machineEventSet.insert(W255Event);
+    private_sendDiagEvent(W255Event, DeviceController::Action::SET);
+
    QProcess::startDetached("/bin/systemctl", {"restart", "carun"});
 }
+
+
+
+
+/****************************************************************************************************
+ *
+ *                                 DCMachineEvent
+ */
+DCMachineEvent::DCMachineEvent(DeviceController::State state) : state(state)
+{
+    this->eventId = QUuid::createUuid().toString(QUuid::WithoutBraces).mid(0, 8);
+}
+
+
--- a/src/ATBAPP/DeviceControllerDiag.h
+++ b/src/ATBAPP/DeviceControllerDiag.h
@@ -12,6 +12,7 @@

 #include "support/PersistentData.h"

+class DBusControllerInterface;

 namespace DeviceController {
    Q_NAMESPACE
@@ -61,9 +62,41 @@ namespace DeviceController {
        INITIAL_STATE
    };
    Q_ENUM_NS(State)
+
+
+    enum Action {
+        SET   = 1,
+        RESET = 0
+    };
+    Q_ENUM_NS(Action)
+
 }


+// ----------------------------- DCMachineEvent -----------------------------------------
+
+class DCMachineEvent {
+public:
+    DCMachineEvent() = default;
+    DCMachineEvent(DeviceController::State state);
+
+    DeviceController::State state;
+    QString eventId;
+
+    // Equality operator (required for QSet)
+    bool operator==(const DCMachineEvent& other) const {
+        return (state == other.state);
+    }
+};
+
+// Hash function (required for QSet)
+inline uint qHash(const DCMachineEvent& key, uint seed = 0) {
+    return qHash(static_cast<int>(key.state), seed);
+}
+
+
+// ------------------------ DeviceControllerDiag --------------------------------------
+
 class DeviceControllerDiag : public QObject
 {
    Q_OBJECT
@@ -71,7 +104,7 @@ class DeviceControllerDiag : public QObject
 public:
    DeviceControllerDiag(PersistentData *pData, QObject *parent = nullptr);

-    void init(hwinf* hw, QObject* eventReceiver);
+    void init(hwinf* hw, DBusControllerInterface *dbus, QObject* eventReceiver);

    nsDeviceControllerInterface::COIN_PROCESSOR coinProcessorType;
    nsDeviceControllerInterface::BILL_ACCEPTOR  billAcceptor;
@@ -81,7 +114,7 @@ public:
     */
    bool isErrorState();
    bool isOperatingState();
-    QSet<DeviceController::State> getCurrentMachineState();
+    QSet<DCMachineEvent> getCurrentMachineState();

    void setTimeout(int timeout);

@@ -110,9 +143,11 @@ signals:
 private:
    QObject *eventReceiver;
    hwinf* hw;
+    DBusControllerInterface* dbus;

    bool isRequestRunning;
    bool flagInterruptDiag;
+    bool isDiagBackgroundTask;

    QTimer *diagRequestTimeoutTimer;

@@ -121,7 +156,8 @@ private:
    int lastVoltage;

    DeviceController::State lastState;
-    QSet<DeviceController::State> machineEventSet;
+    QSet<DCMachineEvent> machineEventSet;
+    QSet<DCMachineEvent> previousMachineEventSet;
    bool _isErrorState;

    PersistentData* pData;
@@ -132,7 +168,10 @@ private slots:
    void onDiagRequestTimeoutTimerTimeout();

    void private_startDiag();                                    // diag entry method
-    void private_sendDiagEvent(DeviceController::State result);
+    void private_setDiagEvent(DeviceController::State result);
+    void private_sendDiagEvent(DCMachineEvent result, DeviceController::Action action);
+
+    void private_finishDiag();

    void sys_superviseSystem();

--- a/src/ATBAPP/DeviceControllerInterface.h
+++ b/src/ATBAPP/DeviceControllerInterface.h
@@ -6,6 +6,7 @@
 #include <QSettings>
 #include <QString>
 #include <QJsonObject>
+#include <QtCore/QHash>

 #include "ATBAPPplugin.h"

@@ -212,10 +213,11 @@ signals:


 Q_DECLARE_INTERFACE(DeviceControllerInterface,
-                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.2.0")
+                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.2.1")


 namespace nsDeviceControllerInterface {
+    Q_NAMESPACE

    enum class PLUGIN_STATE : quint8 {
        NOT_INITIALIZED = 0,
@@ -240,15 +242,43 @@ namespace nsDeviceControllerInterface {


    enum class TICKET_VARIANT : quint8 {
+        INVALID,
+        NO_TICKET,
        PARKING_TICKET,
+        PARKING_TICKET_CAR,
+        PARKING_TICKET_VAN,
+        PARKING_TICKET_CAMPER,
+        DAY_TICKET,
+        DAY_TICKET_ADULT,
+        DAY_TICKET_TEEN,
+        DAY_TICKET_CHILD,
+        DAY_TICKET_CAR,
+        DAY_TICKET_VAN,
+        DAY_TICKET_CAMPER,
        RECEIPT,
        ERROR_RECEIPT,
        START_RECEIPT,   // e.g. Szeged Start
        STOP_RECEIPT,    // e.g. Szeged Stop
        FINE_PAYMENT,    // e.g. Klaipeda
        FOOD_STAMP,
+        FIXED_PRICE_1,
+        FIXED_PRICE_2,
+        FIXED_PRICE_3,
+        FIXED_PRICE_4,
+        FIXED_PRICE_5,
+        FIXED_PRICE_6,
+        FIXED_PRICE_7,
+        FIXED_PRICE_8,
+        FIXED_PRICE_9,
+        FIXED_PRICE_10,
        FREE_TICKET
    };
+    Q_ENUM_NS(TICKET_VARIANT)
+
+    inline uint qHash(const nsDeviceControllerInterface::TICKET_VARIANT &key, uint seed = 0)
+    {
+        return ::qHash(static_cast<quint8>(key), seed);
+    }

    enum class COIN_PROCESSOR : quint8 {
        CHANGER,
@@ -270,4 +300,6 @@ namespace nsDeviceControllerInterface {
    };
 }

+
+
 #endif // DEVICECONTROLLERINTERFACE_H
--- a/src/ATBAPP/support/Ticket.cpp
+++ b/src/ATBAPP/support/Ticket.cpp
@@ -50,25 +50,42 @@ bool Ticket::initNew(TICKET_VARIANT ticketVariant, const QList<quint8> & templat
    qCritical() << "      -> " << ticketVariant;

    int multiplicatorInt = 1;  // default
+    quint8 headerTemplate;
+    quint8 multiTemplate;
+    quint8 footerTemplate;

    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;
+        if (templateList.isEmpty()) {
+            this->_templateList << 21 << 22 << 23;
+        }
+        else {
+            this->_templateList = templateList;
+        }
        break;
    case TICKET_VARIANT::STOP_RECEIPT:
-        this->_templateList << 24 << 25 << 26;
+        if (templateList.isEmpty()) {
+            this->_templateList << 24 << 25 << 26;
+        }
+        else {
+            this->_templateList = templateList;
+        }
        break;
    case TICKET_VARIANT::FINE_PAYMENT:
-        this->_templateList << 24 << 25 << 26;
+        if (templateList.isEmpty()) {
+            this->_templateList << 24 << 25 << 26;
+        }
+        else {
+            this->_templateList = templateList;
+        }
        break;
    case TICKET_VARIANT::FREE_TICKET:
-        this->_templateList << 24 << 25 << 26;
+        if (templateList.isEmpty()) {
+            this->_templateList << 24 << 25 << 26;
+        }
+        else {
+            this->_templateList = templateList;
+        }
        break;
    case TICKET_VARIANT::FOOD_STAMP:
         if (printingData.contains("dyn1_list")) {
@@ -78,19 +95,52 @@ bool Ticket::initNew(TICKET_VARIANT ticketVariant, const QList<quint8> & templat
            this->dyn2List = printingData["dyn2_list"].toStringList();
         }

+         if (templateList.isEmpty()) {
+             headerTemplate  = 0;
+             multiTemplate   = 1;
+             footerTemplate  = 2;
+         }
+         else
+         if (templateList.size() == 2) {
+             headerTemplate  = 0;
+             multiTemplate   = templateList.at(0);
+             footerTemplate  = templateList.at(1);
+         }
+         else
+         if (templateList.size() == 3) {
+             headerTemplate  = templateList.at(0);
+             multiTemplate   = templateList.at(1);
+             footerTemplate  = templateList.at(2);
+         }
+         else {
+             headerTemplate  = 0;
+             multiTemplate   = 1;
+             footerTemplate  = 2;
+         }
+
+         // header is optional:
+         if (headerTemplate != 0) {
+             this->_templateList << headerTemplate;
+         }
+
         if (printingData.contains("multiplicator")) {
             multiplicatorInt = printingData["multiplicator"].toInt();
             for (int i = 1; i < multiplicatorInt; i++) {
-                 this->_templateList << 1;
+                 this->_templateList << multiTemplate;
             }
             // last template:
-             this->_templateList << 2;
+             this->_templateList << footerTemplate;
+         }
+         else {
+             this->_templateList = templateList;
         }

         // DEBUG FOOD_STAMP:
         qCritical() << "     --> printingData[\"multiplicator\"]" << multiplicatorInt;

        break;
+    default:
+        this->_templateList = templateList;
    }


@@ -154,6 +204,66 @@ QDebug operator<<(QDebug debug, TICKET_VARIANT ticketVariant)
        case TICKET_VARIANT::PARKING_TICKET:
            debug << "TICKET_VARIANT::PARKING_TICKET";
            break;
+        case TICKET_VARIANT::PARKING_TICKET_CAR:
+            debug << "TICKET_VARIANT::PARKING_TICKET_CAR";
+            break;
+        case TICKET_VARIANT::PARKING_TICKET_CAMPER:
+            debug << "TICKET_VARIANT::PARKING_TICKET_CAMPER";
+            break;
+        case TICKET_VARIANT::PARKING_TICKET_VAN:
+            debug << "TICKET_VARIANT::PARKING_TICKET_VAN";
+            break;
+        case TICKET_VARIANT::DAY_TICKET:
+            debug << "TICKET_VARIANT::DAY_TICKET";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_CHILD:
+            debug << "TICKET_VARIANT::DAY_TICKET_CHILD";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_TEEN:
+            debug << "TICKET_VARIANT::DAY_TICKET_TEEN";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_ADULT:
+            debug << "TICKET_VARIANT::DAY_TICKET_ADULT";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_CAR:
+            debug << "TICKET_VARIANT::DAY_TICKET_CAR";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_CAMPER:
+            debug << "TICKET_VARIANT::DAY_TICKET_CAMPER";
+            break;
+        case TICKET_VARIANT::DAY_TICKET_VAN:
+            debug << "TICKET_VARIANT::DAY_TICKET_VAN";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_1:
+            debug << "TICKET_VARIANT::FIXED_PRICE_1";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_2:
+            debug << "TICKET_VARIANT::FIXED_PRICE_2";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_3:
+            debug << "TICKET_VARIANT::FIXED_PRICE_3";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_4:
+            debug << "TICKET_VARIANT::FIXED_PRICE_4";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_5:
+            debug << "TICKET_VARIANT::FIXED_PRICE_5";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_6:
+            debug << "TICKET_VARIANT::FIXED_PRICE_6";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_7:
+            debug << "TICKET_VARIANT::FIXED_PRICE_7";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_8:
+            debug << "TICKET_VARIANT::FIXED_PRICE_8";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_9:
+            debug << "TICKET_VARIANT::FIXED_PRICE_9";
+            break;
+        case TICKET_VARIANT::FIXED_PRICE_10:
+            debug << "TICKET_VARIANT::FIXED_PRICE_10";
+            break;
        case TICKET_VARIANT::RECEIPT:
            debug << "TICKET_VARIANT::RECEIPT";
            break;
@@ -175,6 +285,12 @@ QDebug operator<<(QDebug debug, TICKET_VARIANT ticketVariant)
        case TICKET_VARIANT::FREE_TICKET:
            debug << "TICKET_VARIANT::FREE_TICKET";
            break;
+        case TICKET_VARIANT::NO_TICKET:
+            debug << "TICKET_VARIANT::NO_TICKET";
+            break;
+        case TICKET_VARIANT::INVALID:
+            debug << "TICKET_VARIANT::INVALID";
+            break;
    }

    return debug;
Author	SHA1	Message	Date
Siegfried Siegert	cc6dfee0e2	Diag: set E255 only once	2025-06-12 16:33:32 +02:00
Siegfried Siegert	91d8eb03b3	Diag: clear machineEventSet on diagRequest	2025-06-12 10:50:29 +02:00
Siegfried Siegert	3bef73ce4b	Diag: remove E255 / W255 on valid data	2025-06-12 10:37:26 +02:00
Siegfried Siegert	8d03926de4	Diag: do no clear machineEventSet on diagRequest	2025-06-12 10:24:25 +02:00
Siegfried Siegert	b34716ef93	Minor: order debug output	2025-06-12 08:40:59 +02:00
Siegfried Siegert	f75f2c57df	Diag: E255 / W255 / M0254 -> set, send and finish diag This states are rather meta infos about dc condition. Therefore the where created and sent outside of superviseSystem()-method. This commit should ensure that: - this states are sent to ISMAS - this states are inserted in machineEventSet in order to enable a reset in next diagRun	2025-06-12 08:35:58 +02:00
Siegfried Siegert	18a35acf20	Diag: add single exit method for ReqDiag	2025-06-12 08:35:00 +02:00
Siegfried Siegert	ccc2b8120d	Diag: new constructor for DCMachineEvent	2025-06-12 08:33:28 +02:00
Siegfried Siegert	ccc1c6033f	Diag: Send operate O000 as last event (after set/reset events)	2025-06-11 14:13:09 +02:00
Siegfried Siegert	c23364874e	Diag: machineEventSet: - do not overwrite previous events, only insert new events (unite) - remove all events not in machineEventSet	2025-06-11 12:35:27 +02:00
Siegfried Siegert	1e5020132f	Diag: DEBUG EventSets	2025-06-11 09:58:31 +02:00
Siegfried Siegert	6bd02f1831	Diag: care about EventSet.clear() (-> TEST / TODO)	2025-06-11 09:58:31 +02:00
Siegfried Siegert	923bff1117	Diag: Operate O000 is not part of machineEventSet - O000 is not a direct result from DC - O000 is constructed in DCDiag, if no Error EXXXX and no Warning WXXXX ocurred -> O000 must not be part of machineEventSet (e.g. O000 can not be reset)	2025-06-11 09:58:31 +02:00
Siegfried Siegert	12be31ee49	Diag: getCurrentMachineState: return previousState ... ... if diag is running. This method is currently not used, but maybe in future it could be usefull to read current state.	2025-06-11 09:58:31 +02:00
Siegfried Siegert	f8757b352d	Diag: clear machineEventSet on the begin of DCDiag ... ... not on end. This is to keep current machineEventSet during normal IDLE process.	2025-06-11 09:58:25 +02:00
Siegfried Siegert	4567aed6d1	Introduce DCMachineEvent ... ... this is an DC-Plugin internal data-structure which can be transformed to an ATBMachineEvent and sent to ISMAS. DCMachineEvent is in fact a couple ot DeviceController::State and a QString eventID. Thi eventID is necessary to send a state-reset to ISMAS. ISMAS needs same enventID for set- and reset Events.	2025-06-11 09:55:25 +02:00
Siegfried Siegert	4df3a83126	Debug diag: print machineEventSet	2025-06-11 09:43:53 +02:00
Siegfried Siegert	5c66abfd87	Improve E255 handling: - start BackgroundTask on first data not valid - in any case of E255/data-no-valid: try to restart diag; This is because there were only 'returns' without initiating something, so that next check/restart carun happened first on next wokeup.	2025-05-28 13:57:48 +02:00
Siegfried Siegert	efe56672ff	DCDiag: add dbus interface	2025-05-27 12:59:12 +02:00
Siegfried Siegert	58c99753a9	PrintTicket: Support FIXED_PRICE Tickets	2025-05-16 08:48:58 +02:00
Siegfried Siegert	e703befb2f	Merge branch 'improveTicketPrint' into pu/integration	2025-05-13 13:46:48 +02:00
Siegfried Siegert	83bcdcb47e	Print: improve printing receipt: - call prn_cut() 200ms after prn_switchPower(true) - make an "emergency cut" on error - improve log output on error	2025-05-13 13:44:12 +02:00
Siegfried Siegert	70e6ec293d	Merge branch 'improveDeviceControllerDiag' into pu/integration	2025-05-08 10:12:54 +02:00
Siegfried Siegert	3601f2d868	Merge branch 'improveTICKET_VARIANTS' into pu/integration	2025-05-08 10:12:46 +02:00
Siegfried Siegert	0876fa229e	Diag: do not send reset errors/warnings ... ... this is a proposal for future.	2025-05-08 10:11:19 +02:00
Siegfried Siegert	1c13d92171	New proposal for DeviceControllerDiag: Manage two sets of errors and compare to previous run.	2025-04-14 08:18:11 +02:00
Siegfried Siegert	10b0e494b2	requestPrintTicket: switch to legacy, if no template list is configured	2025-04-08 08:58:29 +02:00
Siegfried Siegert	24a1390a11	Interface: add TICKET_VARIANTS for FIXED_PRICE_TICKETS	2025-04-07 14:30:27 +02:00
Siegfried Siegert	c8508a0c62	Read config TICKET_TEMPLATES: read list- or string-value	2025-03-25 12:26:18 +01:00
Siegfried Siegert	fbfbe3d243	prepareDynTemplateData: setup for all TICKET_VARIANTs	2025-03-12 16:12:44 +01:00
Siegfried Siegert	cbc0dd0ad6	Ticket: Use printer templates from config	2025-03-12 15:56:51 +01:00
Siegfried Siegert	1abd6bfa90	default templateList is empty	2025-03-12 14:25:33 +01:00
Siegfried Siegert	a03dfe87a5	requestPrintTicket: improve debug output: print template list	2025-03-12 14:07:23 +01:00
Siegfried Siegert	03b192fb60	Read ticket templates from config: - config group is [TICKET_TEMPLATES] - reads list of printer templates for each TICKET_VARIANT	2025-03-12 13:57:36 +01:00
Siegfried Siegert	e8b3bb1aa0	Interface: 1.2.1 (add additional TICKET_VARIANTs)	2025-03-12 13:55:14 +01:00