Update interfaces.h

- using DC prn_sendText
 - this is a rather general print method

.gitignore

@@ -0,0 +1,41 @@
+# C++ objects and libs
+
+*.slo
+*.lo
+*.o
+*.a
+*.la
+*.lai
+*.so
+*.dll
+*.dylib
+
+# Qt-es
+
+*.pro.user
+*.pro.user.*
+moc_*.cpp
+qrc_*.cpp
+Makefile
+Makefile.*
+*-build-*
+
+#
+*.autosave
+ui_*.h
+version.h
+version.txt
+
+packages/*
+*.pro.orig
+Output/setup.exe
+.directory
+
+*~
+resources/icons/*.png
+resources/icons/*.jpg
+resources/icons/*.gif
+resources/style/*.qss
+text/*.html
+!text/*_template.html
+text/*.xml

DCPlugin.pro

@@ -0,0 +1,106 @@
+TEMPLATE = lib
+CONFIG += plugin
+#CONFIG += c++11 console
+#CONFIG -= app_bundle
+#QT += widgets
+QT -= gui
+QT += serialport
+
+INCLUDEPATH += $${PWD}/plugins
+INCLUDEPATH += $${PWD}/include
+
+QMAKE_CXXFLAGS += -Wno-deprecated-copy
+
+# default
+ARCH = PTU5
+
+
+contains( CONFIG, DesktopLinux ) {
+    QMAKE_CC = ccache $$QMAKE_CC
+    QMAKE_CXX = ccache $$QMAKE_CXX
+    QMAKE_CXXFLAGS += -std=c++11
+    # QMAKE_CXXFLAGS += -Wno-deprecated-ctor
+    linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
+    ARCH = DesktopLinux
+}
+
+contains( CONFIG, PTU5 ) {
+    # QMAKE_CC = ccache $$QMAKE_CC
+    # QMAKE_CXX = ccache $$QMAKE_CXX
+    QMAKE_CXXFLAGS += -std=c++11
+    linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
+    CONFIG += link_pkgconfig
+    ARCH = PTU5
+}
+
+contains( CONFIG, PTU5_YOCTO ) {
+    greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
+    PTU5BASEPATH = /opt/devel/ptu5
+    ARCH = PTU5
+
+    # add qmqtt lib
+    #LIBS += -lQt5Qmqtt
+}
+
+TARGET   = ATBDeviceControllerPlugin
+#DESTDIR  = ../plugins
+INTERFACE = DeviceController
+INTERFACE_DEFINITION = $${PWD}/src/ATBAPP/DeviceControllerInterface.h
+
+DEFINES += DEVICECONTROLLERPLUGIN_LIBRARY
+
+# The following define makes your compiler emit warnings if you use
+# any Qt feature that has been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if it uses deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+
+
+# Default rules for deployment.
+#qnx: target.path = /tmp/$${TARGET}/bin
+#else: unix:!android: target.path = /opt/$${TARGET}/bin
+#!isEmpty(target.path): INSTALLS += target
+
+# ATBAPP interface
+HEADERS += \
+    include/interfaces.h \
+    src/ATBAPP/ATBAPPplugin.h \
+    src/ATBAPP/DeviceControllerDiag.h \
+    src/ATBAPP/DeviceControllerInterface.h \
+    src/ATBAPP/ATBHealthEvent.h \
+    src/ATBAPP/ATBMachineEvent.h \
+    src/ATBAPP/ATBDeviceControllerPlugin.h \
+    src/ATBAPP/Utils.h \
+    src/ATBAPP/support/DBusControllerInterface.h \
+    src/ATBAPP/support/JSON.h \
+    src/ATBAPP/support/PTUSystem.h
+
+SOURCES += \
+    src/ATBAPP/ATBHealthEvent.cpp \
+    src/ATBAPP/ATBMachineEvent.cpp \
+    src/ATBAPP/ATBDeviceControllerPlugin.cpp \
+    src/ATBAPP/DeviceControllerDiag.cpp \
+    src/ATBAPP/Utils.cpp \
+    src/ATBAPP/support/DBusControllerInterface.cpp \
+    src/ATBAPP/support/JSON.cpp \
+    src/ATBAPP/support/PTUSystem.cpp
+
+DISTFILES += \
+    generate-version.sh
+
+
+# Define how to create version.h
+VERSION_H = $$PWD/include/version.h
+version.output = $$PWD/include/version.h
+version.commands = $$PWD/generate-version.sh $${ARCH} $${TARGET} $${INTERFACE} $${INTERFACE_DEFINITION} $${VERSION_H}
+version.depends = FORCE
+version.input = VERSION_H
+version.variable_out = HEADERS
+QMAKE_EXTRA_COMPILERS += version
+QMAKE_CLEAN += $${PWD}/include/version.h

generate-version.sh

@@ -0,0 +1,157 @@
+#!/bin/bash
+
+VERSION_STRING=""
+
+#GIT='/cygdrive/c/Program Files \(x86\)/Git/bin/git'
+GIT=git
+
+
+
+
+parse_git_branch () {
+    $GIT branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e "s/* \(.*\)/\1/"
+}
+
+
+ARCH=$1
+TARGET=$2
+INTERFACE=$3
+INTERFACE_DEFINITION=$4
+VERSION_H=$5
+
+SCRIPT=$(readlink -f $0)
+SCRIPTPATH=`dirname $SCRIPT`
+OUTPUTDIR=$(pwd)
+echo " current dir is : " $(pwd)
+echo $SCRIPT
+echo $SCRIPTPATH
+
+echo "changing dir to script path: " $SCRIPTPATH
+cd $SCRIPTPATH
+
+# set version string ##################################################################
+if [ -z $VERSION_STRING ] ; then
+  VERSION_STRING=$(date +%Y%m%d_%H%M)
+fi
+GIT_DESCRIBE=$($GIT describe)
+GIT_BRANCH=$(parse_git_branch)
+
+# extract path from branchname:
+IFS='_' read -ra TMP_ARRAY <<< "${GIT_BRANCH}"
+BRANCH_PATH=${TMP_ARRAY[0]}
+
+
+
+# detect if we have a development version:
+if [ ${#TMP_ARRAY[1]} -gt 0 ] ; then
+  DEV_SUFFIX="_dev"
+else
+  DEV_SUFFIX=""
+fi
+
+# detect if git status is dirty
+GIT_DESCRIBE_DIRTY=$($GIT describe --dirty)
+if [ "${GIT_DESCRIBE_DIRTY:(-6)}" == "-dirty" ] ; then
+  DIRTY_SUFFIX="_dirty"
+else
+  DIRTY_SUFFIX=""
+fi
+
+
+if [ -n "$DIRTY_SUFFIX" ] || [ -n "$DEV_SUFFIX" ] ; then
+  DEVDIRTY=true
+else
+  DEVDIRTY=false
+fi
+
+
+# extract interface definition 
+
+#
+#Q_DECLARE_INTERFACE(CCInterface,
+#         "eu.atb.ptu.plugin.CCInterface/2.9.0")
+#Q_DECLARE_INTERFACE(DeviceControllerInterface,
+#         "eu.atb.ptu.plugin.DeviceControllerInterface/1.0")
+# -> extract whole string within quotation marks
+INTERFACE_VERSION=$(grep 'eu.atb.ptu.plugin.' ${INTERFACE_DEFINITION})
+# get string within quotes:
+INTERFACE_VERSION=`echo ${INTERFACE_VERSION} | awk -F \" '{print $2}'`
+
+
+#
+# write version.h
+
+
+echo "     TARGET is: $TARGET"
+echo "     ARCH   is: $ARCH"
+echo " "
+echo "     PluginName: $TARGET"
+echo "     Interface:  $INTERFACE"
+echo "     InterfaceVersion: $INTERFACE_VERSION"
+echo " "
+echo "     new version is:  $VERSION_STRING"
+echo "     git describe is: $GIT_DESCRIBE"
+echo "     git branch is:   $GIT_BRANCH"
+echo "     branch-path is:  $BRANCH_PATH"
+echo "  "
+
+echo "     dev suffix:     $DEV_SUFFIX"
+echo "     dirty suffix:   $DIRTY_SUFFIX"
+
+
+PLUGIN_VERSION=${VERSION_STRING}
+#ATB_QT_GIT_DESCRIBE=${GIT_DESCRIBE}_${GIT_BRANCH}
+PLUGIN_GIT_DESCRIBE=${GIT_DESCRIBE}_${BRANCH_PATH}${DEV_SUFFIX}${DIRTY_SUFFIX}
+
+#TARGET=IngenicoZVT_CCPlugin
+
+
+# build version.h #####################################################################
+
+echo "     building new version info (version.h) ..."
+
+
+
+
+echo "#ifndef VERSION_H"   >  ${VERSION_H}
+echo "#define VERSION_H"   >> ${VERSION_H}
+echo ""                    >> ${VERSION_H}
+echo ""                    >> ${VERSION_H}
+echo "#define INTERFACE_VERSION \"${INTERFACE_VERSION}\""      >> ${VERSION_H}
+echo "#define PLUGIN_VERSION \"${PLUGIN_VERSION}\""           >> ${VERSION_H}
+echo ""                                                       >> ${VERSION_H}
+echo "#define PLUGIN_GIT_DESCRIBE \"${PLUGIN_GIT_DESCRIBE}\"" >> ${VERSION_H}
+echo ""                                                       >> ${VERSION_H}
+echo ""                                                       >> ${VERSION_H}
+
+cat <<EOT >> ${VERSION_H}
+
+const std::string pluginInfoString = R"(
+{
+    "Interface": "${INTERFACE}",
+    "InterfaceVersion": "${INTERFACE_VERSION}",
+    "PluginName": "${TARGET}",
+    "Version": "${PLUGIN_VERSION}",
+    "git-describe": "${PLUGIN_GIT_DESCRIBE}",
+}
+)";
+
+EOT
+
+echo ""                                              >> ${VERSION_H}
+echo ""                                              >> ${VERSION_H}
+if [ ${DEVDIRTY} == "true" ] ; then
+echo "#define DEVDIRTY"                              >> ${VERSION_H}
+echo ""                                              >> ${VERSION_H}
+echo ""                                              >> ${VERSION_H}
+fi
+echo "#define SYSTEM_ARCH \"${ARCH}\""               >> ${VERSION_H}
+echo "#define ARCH_${ARCH}"                          >> ${VERSION_H}
+echo ""                                              >> ${VERSION_H}
+echo "" 					     >> ${VERSION_H}
+echo "#endif //VERSION_H"  >> ${VERSION_H}
+
+
+
+
+

src/ATBAPP/ATBAPPplugin.h

@@ -0,0 +1,22 @@
+#ifndef ATBAPPPLUGIN_H
+#define ATBAPPPLUGIN_H
+
+/***********************************************************
+ * a simple class with only one method for plugin info
+ */
+#include <QObject>
+#include <QString>
+
+class ATBAPPplugin
+{
+
+public:
+    virtual const QString & getPluginInfo() = 0;
+};
+
+Q_DECLARE_INTERFACE(ATBAPPplugin,
+                    "eu.atb.ptu.plugin.ATBAPPplugin/0.9")
+
+
+
+#endif // ATBAPPPLUGIN_H

src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -0,0 +1,164 @@
+#ifndef ATBDEVICECONTROLLERPLUGIN_H
+#define ATBDEVICECONTROLLERPLUGIN_H
+
+#include <QObject>
+
+#include "src/ATBAPP/DeviceControllerInterface.h"
+#include "src/ATBAPP/ATBAPPplugin.h"
+#include "src/ATBAPP/DeviceControllerDiag.h"
+
+#include "version.h"
+
+
+
+#include "interfaces.h"
+
+#include <unistd.h>
+
+
+class DBusControllerInterface;
+class QTextCodec;
+
+
+using namespace nsDeviceControllerInterface;
+
+class QSettings;
+
+class ATBDeviceControllerPlugin :
+        public DeviceControllerInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(ATBAPPplugin)
+    Q_INTERFACES(DeviceControllerInterface)
+    #if QT_VERSION >= 0x050000
+    Q_PLUGIN_METADATA( IID "ATBDeviceControllerPlugin" )
+    #endif
+
+public:
+    explicit ATBDeviceControllerPlugin(QObject *parent = nullptr);
+    ~ATBDeviceControllerPlugin();
+
+    // ----------------------------------------------------------------------------
+    // interface:
+    PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings);
+
+    // TASKS: Cash handling -------------------------------------------------------
+    void requestStartCashInput(const QString & amount);
+    void requestStopCashInput();
+    void cashCollect();
+    void cashAbort();
+
+    // TASKS: printing ------------------------------------------------------------
+    void requestPrintTicket(const QHash<QString, QVariant> & printingData);
+    void requestPrintTicket(nsDeviceControllerInterface::TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData);
+    void requestPrintReceipt(const QHash<QString, QVariant> & printingData);
+    void requestPrintReceipt(const QString & printingString);
+
+    // TASKS: Account -------------------------------------------------------------
+    void requestAccount();
+
+    // mandantory ATBAPP plugin methods: ------------------------------------------
+    nsDeviceControllerInterface::PLUGIN_STATE getState();
+    QString & getLastError();
+    const QString & getLastErrorDescription();
+
+    const QString & getPluginInfo();
+
+    // helpers e.g. for debug / log
+    const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState);;
+
+public slots:
+    void onChangedProgramModeToSELL();
+    void onChangedProgramModeToSERVICE();
+    void onChangedProgramModeToIDLE();
+    void onChangedProgramModeToOOO();
+
+    void startPhysicalLayer();
+    void stopPhysicalLayer();
+    void reboot();
+    void reset();
+
+
+
+signals:
+    // public Signals are defined in interface
+
+
+private:
+   QString errorCode;
+   QString errorDescription;
+   QString pluginInfo;
+
+   QList<int> templateList;
+
+   QString serialPortName;
+
+   bool useDebug;
+
+   bool isMaster;
+
+   PLUGIN_STATE pluginState;
+
+   QObject* eventReceiver;
+
+   DBusControllerInterface* dbus;
+
+   hwinf* hw;
+
+   DeviceControllerDiag* diag;
+
+
+   QTextCodec *codec;
+
+   bool private_loadCashAgentLib(QString pluginName);
+
+   quint8 currentSelectedTicketType;
+
+   nsDeviceControllerInterface::CASH_STATE currentCashState;
+
+   // counts failed hw->log_chkIfVaultRecordAvailable()
+   int accountCheckCounter;
+
+   // dbus
+   int init_sc_dbus();
+
+private slots:
+   // printer
+
+   void onPrinterDataPrepared();
+   void onPrinterDataPreparedForTemplates();
+   void onPrinterPrintNextTemplate();
+   void onPrinterWaitForPrintingTicket();
+   void onPrinterWaitForPrintingReceipt();
+
+   void onPrintFinishedOK();
+   void onPrintFinishedERR();
+
+   // cash payment
+   void onCashGotCoin();
+   void onCashPayStopedSuccess();
+   void onCashPayStopByMax();
+   void onCashPayStopByEscrow();
+   void onCashPayStopByError();
+   void onCashPayStopByTimeout();
+
+   // doors and hardware contacts
+   void onServiceDoorOpened();
+   void onVaultDoorOpened();
+   void onCoinBoxRemoved();
+   void onCoinBoxInserted();
+   void onAllDoorsClosed();
+   void onCBinAndAllDoorsClosed();
+
+   // account handling
+   void private_startAccount();
+   void private_checkAccountData();
+   void private_getAccountData();
+
+   // measurement values
+   void onNewVoltage(uint32_t voltage);
+
+   void onWokeUp(uchar source);
+};
+
+#endif // ATBDEVICECONTROLLERPLUGIN_H

src/ATBAPP/ATBHealthEvent.cpp

@@ -0,0 +1,25 @@
+#include "src/ATBAPP/ATBHealthEvent.h"
+
+ATBHealthEvent::ATBHealthEvent(ATB_HEALTH_MODE mode, const QString & errorNumber, const QString & errorDescription) :
+    QEvent(ATB_HEALTH_EVENT),
+    healthMode(mode),
+    errorNumber(errorNumber),
+    errorDescription(errorDescription)
+{
+
+}
+
+QString ATBHealthEvent::getErrorNumber()
+{
+    return this->errorNumber;
+}
+
+QString ATBHealthEvent::getErrorDescription()
+{
+    return this->errorDescription;
+}
+
+ATB_HEALTH_MODE ATBHealthEvent::getMode()
+{
+    return this->healthMode;
+}

src/ATBAPP/ATBHealthEvent.h

@@ -0,0 +1,44 @@
+#ifndef ATBHEALTHEVENT_H
+#define ATBHEALTHEVENT_H
+
+#include <QEvent>
+#include <QString>
+
+enum class ATB_HEALTH_MODE : quint8;
+
+const QEvent::Type ATB_HEALTH_EVENT = static_cast<QEvent::Type>(QEvent::User + 1);
+
+
+class ATBHealthEvent : public QEvent
+{
+
+public:
+    ATBHealthEvent(ATB_HEALTH_MODE mode, const QString & errorNumber, const QString & errorDescription);
+
+    QString getErrorNumber();
+    QString getErrorDescription();
+    ATB_HEALTH_MODE getMode();
+
+signals:
+
+public slots:
+
+
+private:
+    ATB_HEALTH_MODE healthMode;
+    QString errorNumber;
+    QString errorDescription;
+};
+
+
+enum class ATB_HEALTH_MODE : quint8 {
+    WARNING,
+    ERROR,
+    WARNING_CORRECTION,
+    ERROR_CORRECTION,
+    DEBUG,
+    STATE,
+    UNSPECIFIED
+};
+
+#endif // ATBHEALTHEVENT_H

src/ATBAPP/ATBMachineEvent.cpp

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

src/ATBAPP/ATBMachineEvent.h

@@ -0,0 +1,48 @@
+#ifndef ATBMACHINECONDITIONEVENT_H
+#define ATBMACHINECONDITIONEVENT_H
+
+#include <QEvent>
+#include <QString>
+
+enum class EVENT_CLASS : quint8;
+
+const QEvent::Type ATB_MACHINE_EVENT = static_cast<QEvent::Type>(QEvent::User + 2);
+
+
+class ATBMachineEvent : public QEvent
+{
+
+public:
+    explicit ATBMachineEvent(const QString & id,
+                const QString & deviceName,              // PTU/PRINTER/DC/...
+                EVENT_CLASS eventClass,          // reason of event: Error/Warning/Alarm
+                const QString & name,                    // 'Event': "E001", "W003"
+                const int state,
+                const QString & parameter,
+                const QString & secondLevelInfo
+            );
+
+    QString eventId;
+    QString deviceName;
+    EVENT_CLASS machineEventClass;
+    QString eventName;
+    int eventState;
+    QString timestampString;
+    QString parameterString;
+    QString secondLevelInfoString;
+
+    static QString getEventClassString(EVENT_CLASS eventClass);
+};
+
+
+enum class EVENT_CLASS : quint8 {
+    WARNING,
+    ERROR,
+    ALARM,
+    DEBUG,
+    STATE,
+    OPERATE,
+    NOT_DEFINED
+};
+
+#endif // ATBMACHINEEVENT_H

src/ATBAPP/DeviceControllerDiag.cpp

@@ -0,0 +1,480 @@
+#include "DeviceControllerDiag.h"
+
+#include <QCoreApplication>
+#include <QMetaEnum>
+#include <QUuid>
+#include <QDebug>
+
+DeviceControllerDiag::DeviceControllerDiag(QObject *parent)
+    : QObject(parent)
+    , eventReceiver(nullptr)
+    , isRequestRunning(false)
+    , flagInterruptDiag(false)
+{
+    diagRequestTimeoutTimer = new QTimer(this);
+    diagRequestTimeoutTimer->setInterval(1000*20);  // 20s
+    diagRequestTimeoutTimer->setSingleShot(true);
+    connect(diagRequestTimeoutTimer, &QTimer::timeout, this, &DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout);
+}
+
+
+void DeviceControllerDiag::init(hwinf *hw, QObject* eventReceiver)
+{
+    this->hw = hw;
+    this->eventReceiver = eventReceiver;
+
+    // make a system check on startup:
+    QTimer::singleShot(2000, this, &DeviceControllerDiag::diagRequest);
+}
+
+
+void DeviceControllerDiag::diagRequest()
+{
+    qCritical() << "DeviceControllerDiag::diagRequest()";
+
+    if (this->isRequestRunning) {
+        qCritical() << "DeviceControllerDiag::diagRequest() is already running";
+        return;
+    }
+    this->isRequestRunning = true;
+    this->diagRequestTimeoutTimer->start();
+
+    this->private_startDiag();
+}
+
+
+void DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout()
+{
+    qCritical() << "DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout()";
+    this->flagInterruptDiag = true;
+}
+
+void DeviceControllerDiag::private_startDiag()
+{
+    // check for DiagRequestTimeoutTimerTimeout:
+    if (this->flagInterruptDiag) {
+        qCritical() << "DeviceControllerDiag::private_startDiag() interrupted!";
+        this->private_sendDiagEvent(DeviceController::State::E255);
+        return;
+    }
+
+    bool result;
+    result = hw->sys_areDCdataValid();
+
+    if (result) {
+        qCritical() << "DeviceControllerDiag::private_startDiag() DCdata is valid";
+        QTimer::singleShot(200, this, &DeviceControllerDiag::sys_superviseSystem);
+    }
+    else {
+        qCritical() << "DeviceControllerDiag::private_startDiag() DCdata is +++not+++ valid";
+
+        // try it again
+        QTimer::singleShot(200, this, &DeviceControllerDiag::private_startDiag);
+    }
+}
+
+void DeviceControllerDiag::sys_superviseSystem()
+{    // this function proofs if vending is possible depending of doors state
+
+    struct T_dynamicCondition dynMaCond;
+    struct T_moduleCondition  modCond;
+
+
+    qCritical() << "      sys_superviseSystem()";
+
+
+    // check for DiagRequestTimeoutTimerTimeout:
+    if (this->flagInterruptDiag) {
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() interrupted!";
+        this->private_sendDiagEvent(DeviceController::State::E255);
+        return;
+    }
+
+    if (!hw->sys_areDCdataValid())
+    {
+        // es gibt keinerlei gültige Daten vom DC
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() no valid data!";
+        this->private_sendDiagEvent(DeviceController::State::E254);
+        return;
+    }
+
+    // jetzt sind die DC-Daten aktuell, also reinholen:
+    hw->sys_getDynMachineConditions(&dynMaCond);
+    hw->sys_getDeviceConditions(&modCond);
+
+    qCritical() << "DeviceControllerDiag::sys_superviseSystem() get condition data";
+    if (!modCond.allModulesChecked)
+    {
+        // noch keine Testergebnisse
+        if (dynMaCond.startupTestIsRunning) {
+            // TODO?
+        }
+
+
+        qCritical() << "            allModulesChecked is false --> call again";
+
+        QTimer::singleShot(200, this, &DeviceControllerDiag::sys_superviseSystem);
+        return;
+    }
+
+    // all doors: 99: undefined  0:closed  1:open
+    if (dynMaCond.lowerDoor || dynMaCond.upperDoor) {
+        // Service or battery door is open, goto INTRUSION MODE
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() Service or battery door is open, goto INTRUSION MODE";
+        this->private_sendDiagEvent(DeviceController::State::E253);
+    }
+    if (dynMaCond.middleDoor) {
+        // vault door is open, goto INTRUSION MODE
+        qCritical() << "DeviceControllerDiag::sys_superviseSystem() vault door is open, goto INTRUSION MODE";
+        this->private_sendDiagEvent(DeviceController::State::E252);
+    }
+
+    qCritical() << "      --> call  sub_componentAssessment()";
+
+    sub_componentAssessment();
+}
+
+
+
+void DeviceControllerDiag::sub_componentAssessment()
+{
+    bool flag_sendOperate = true;
+
+    struct T_moduleCondition modCond;
+    hw->sys_getDeviceConditions(&modCond);
+
+    struct T_dynamicCondition dynMaCond;
+    hw->sys_getDynMachineConditions(&dynMaCond);
+
+    struct T_devices devPara;
+    hw->sys_restoreDeviceParameter(&devPara);
+
+    // store some interesting results:
+    // -> voltage:
+    uint32_t voltage = hw->dc_getVoltage();
+    emit newVoltage(voltage);
+
+
+    // check for alarm:
+
+    if (dynMaCond.onAlarm>0) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::A000);
+    }
+
+    // check for invalid states:
+
+    if (modCond.rtc>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E002);
+    }
+    if (modCond.printer==200 || modCond.printer==201) {   // 200: not connected  201: printer-HW-error  202: no paper
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E020);
+    }
+    if (modCond.printer==202) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E018);
+    }
+
+    if (modCond.coinBlocker>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E025);
+    }
+    if (modCond.mdbBus>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E034);
+    }
+    if (modCond.intEe>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E011);
+    }
+
+    // 2023-07-26: workaround for 00281/Szeged --------------------------------------------------------------
+    // because we need certain errors and we do get for 'kindOfCoinChecker' -> 16 !
+    qCritical() << "-----------diag: kindOfCoinChecker = " << devPara.kindOfCoinChecker;
+    qCritical() << "                  modCond.coinSafe = " << modCond.coinSafe;
+    if (devPara.kindOfCoinChecker > 0) {
+        if (modCond.coinSafe==201) { // full
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E007);
+        }
+        if (modCond.coinSafe==200)  {         // 200: kasse fehlt 201: voll  100:fast voll  1:ok
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E009);
+        }
+        if (modCond.coinEscrow>=200) {
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E010);
+        }
+    }
+    // -----------------------------------------------------------------------------------------------
+
+    if (devPara.kindOfCoinChecker==1 || devPara.kindOfCoinChecker==2)  // 0: without  1=EMP820   2=EMP900    3=currenza c²	(MW)
+    {
+        if (modCond.coinEscrow>=200) {
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E010);
+        }
+        if (modCond.coinSafe==201)  { // full
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E007);
+        }
+        if (modCond.coinSafe==200) {          // 200: kasse fehlt 201: voll  100:fast voll  1:ok
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E009);
+        }
+    } else
+    if (devPara.kindOfCoinChecker==3)
+    {
+        if (modCond.changer>=200) {
+            // Fehler Münzver.
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E026);
+        }
+        if (modCond.coinSafe==201) { // full
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E007);
+        }
+        if (modCond.coinSafe == 200)  {          // 200: kasse fehlt 201: voll  100:fast voll  1:ok
+            flag_sendOperate = false;
+            this->private_sendDiagEvent(DeviceController::State::E009);
+        }
+    }
+
+    /*
+    if ( modCond.billReader>=200 && devPara.BillAcceptor>0)
+    {
+        if (modCond.billReader == 200)           // 200: kasse fehlt 201: voll  100:fast voll  1:ok
+        {
+            return TODO;
+        }
+        if (modCond.billReader == 201)           // 200: kasse fehlt 201: voll  100:fast voll  1:ok
+        {
+            return TODO;
+        }
+    }
+    */
+
+    if (dynMaCond.modeAbrech>0) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E011);
+    }
+
+    if (dynMaCond.nowCardTest>0) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E072);
+    }
+
+    if (dynMaCond.startupTestIsRunning>0) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E073);
+    }
+
+    if (modCond.voltage>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E003);
+    }
+    if (modCond.temper>=200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::E004);
+    }
+
+    // check for warnings
+    if (modCond.printer>=100 && modCond.printer<200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::W001);
+    }
+    if (modCond.coinSafe>=100 && modCond.coinSafe<200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::W002);
+    }
+    if (modCond.voltage>=100 && modCond.voltage<200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::W003);
+    }
+    if (modCond.temper>=100 && modCond.temper<200) {
+        flag_sendOperate = false;
+        this->private_sendDiagEvent(DeviceController::State::W004);
+    }
+
+    if (flag_sendOperate) {
+        this->private_sendDiagEvent(DeviceController::State::O000);
+    }
+
+
+    // finish diag
+
+    this->diagRequestTimeoutTimer->stop();
+    this->isRequestRunning  = false;
+    this->flagInterruptDiag = false;
+}
+
+
+/**
+ * @brief DeviceControllerDiag::private_sendDiagEvent
+ * @param result - result value from 'sub_componentAssessment()',
+ *               - 0x00 everything is fine
+ *               - 0xFF on timer interrupt
+ *               - 0xFE no valid data from DeviceController
+ *               - 0xFD Service or battery door is open
+ *               - 0xFE vault door is open
+ */
+void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
+{
+    qCritical() << "DeviceControllerDiag::private_sendDiagEvent() result: " << result;
+
+
+    if (this->eventReceiver == nullptr) {
+        qCritical() << "DeviceControllerDiag: no eventReceiver";
+        return;
+    }
+
+    if (machineEventSet.contains(result)) {
+        // do not send already sent events
+        qCritical() << "       ... is in machineEventList";
+        return;
+    }
+    else {
+        machineEventSet.insert(result);
+    }
+
+
+    QString eventId = QUuid::createUuid().toString(QUuid::WithoutBraces).mid(0, 8);
+
+    QString eventName = QMetaEnum::fromType<DeviceController::State>().valueToKey(result);;
+    EVENT_CLASS eventClass = EVENT_CLASS::STATE;
+    QString parameter;
+    switch (result) {
+
+    case DeviceController::State::A000:   // alarm / intrusion
+        eventClass = EVENT_CLASS::ALARM;
+        parameter  = "alarm / intrusion";
+        break;
+    case DeviceController::State::E002:    // real time clock error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "real time clock error";
+        break;
+    case DeviceController::State::E003:   // voltage error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "voltage error";
+        break;
+    case DeviceController::State::E004:   // temperature error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "temperature error";
+        break;
+    case DeviceController::State::E007:    // coin safe full
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "coin safe full";
+        break;
+    case DeviceController::State::E008:    // bill acceptor full
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "bill acceptor full";
+        break;
+    case DeviceController::State::E009:    // no cash box
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "no cash box";
+        break;
+    case DeviceController::State::E010:    // coin escrow
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "coin escrow";
+        break;
+    case DeviceController::State::E011:    // mem error int.ee.
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "mem error int.ee.";
+        break;
+    case DeviceController::State::E018:    // no paper
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "no paper";
+        break;
+    case DeviceController::State::E020:    // printer error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "printer error";
+        break;
+    case DeviceController::State::E025:    // coin blocker
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "coin blocker";
+        break;
+    case DeviceController::State::E026:    // error coin validator
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "error coin validator";
+        break;
+    case DeviceController::State::E034:    // mdb error
+        eventClass = EVENT_CLASS::ERROR;
+        parameter  = "mdb error";
+        break;
+
+    case DeviceController::State::E071:   // cash box change is ongoing
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "cash box change is ongoing";
+        break;
+    case DeviceController::State::E072:   // card test running
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "card test running";
+        break;
+    case DeviceController::State::E073:   // startup-test is running
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "startup-test is running";
+        break;
+
+    case DeviceController::State::E252:   // cash box door open
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "cash box door open";
+        break;
+    case DeviceController::State::E253:   // service or battery door open
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "service or battery door open";
+        break;
+    case DeviceController::State::E254:   // no valid data from DeviceController
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "no valid data from DeviceController";
+        break;
+    case DeviceController::State::E255:   // no valid data from DeviceController
+        eventClass = EVENT_CLASS::STATE;
+        parameter  = "";
+        qCritical() << "                ... ignore " << QMetaEnum::fromType<DeviceController::State>().valueToKey(result);
+        return;
+        break;
+    case DeviceController::State::O000:   // everything is fine
+        this->machineEventSet.clear();
+        eventClass = EVENT_CLASS::OPERATE;
+        parameter  = "";
+        qCritical() << "                ... everything fine";
+        break;
+
+    case DeviceController::State::W001:   // paper low
+        eventClass = EVENT_CLASS::WARNING;
+        parameter  = "paper low";
+        break;
+    case DeviceController::State::W002:   // cashbox almost full
+        eventClass = EVENT_CLASS::WARNING;
+        parameter  = "cashbox almost full";
+        break;
+    case DeviceController::State::W003:   // voltage low
+        eventClass = EVENT_CLASS::WARNING;
+        parameter  = "voltage low";
+        break;
+    case DeviceController::State::W004:   // temperatur warning
+        eventClass = EVENT_CLASS::WARNING;
+        parameter  = "temperatur warning";
+        break;
+    }
+
+
+    ATBMachineEvent *machineEvent = new ATBMachineEvent(
+                eventId,
+                "DC",
+                eventClass,
+                eventName,
+                1,
+                parameter,
+                ""         // second level info
+                );
+
+    //emit diagResponse(machineEvent);
+
+    QCoreApplication::postEvent(eventReceiver, machineEvent);
+
+}
+
+

src/ATBAPP/DeviceControllerDiag.h

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

src/ATBAPP/DeviceControllerInterface.h

@@ -0,0 +1,199 @@
+#ifndef DEVICECONTROLLERINTERFACE_H
+#define DEVICECONTROLLERINTERFACE_H
+
+#include <QtPlugin>
+
+#include <QSettings>
+#include <QString>
+
+#include "ATBAPPplugin.h"
+
+namespace nsDeviceControllerInterface {
+    enum class PLUGIN_STATE : quint8;
+    enum class RESULT_STATE : quint8;
+    enum class CASH_STATE   : quint8;
+    enum class TICKET_VARIANT : quint8;
+}
+
+
+class DeviceControllerInterface : public QObject
+                                , public ATBAPPplugin
+{
+    Q_OBJECT
+    Q_INTERFACES(ATBAPPplugin)
+
+public:
+    virtual ~DeviceControllerInterface() {}
+
+    /**
+     * @brief initDCPlugin
+     * @param eventReceiver - QObject to receive ATBMachineEvents or HealthEvents
+     * @param settings
+     * @return
+     */
+    virtual nsDeviceControllerInterface::PLUGIN_STATE initDCPlugin(QObject *eventReceiver,
+                                                                   const QSettings & settings) = 0;
+
+    // TASKS: Cash handling -------------------------------------------------------
+    /**
+     * enables coin input
+     * amount = "0": pay-up
+     * amount > "0": pay-down
+     */
+    virtual void requestStartCashInput(const QString & amount) = 0;
+
+    /**
+     * called e.g. on Button "NEXT" in pay-up (direct coin input)
+     */
+    virtual void requestStopCashInput() = 0;
+
+    /**
+     * called e.g. on Button "NEXT" in pay-up (direct coin input)
+     */
+    virtual void cashCollect() = 0;
+    virtual void cashAbort() = 0;
+
+    // TASKS: Account -------------------------------------------------------------
+
+    virtual void requestAccount() = 0;
+
+
+    // TASKS: printing ------------------------------------------------------------
+    virtual void requestPrintTicket(const QHash<QString, QVariant> & printingData) = 0;
+    virtual void requestPrintTicket(nsDeviceControllerInterface::TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData) = 0;
+    virtual void requestPrintReceipt(const QHash<QString, QVariant> & printingData) = 0;
+    virtual void requestPrintReceipt(const QString & printingString) = 0;
+
+    // mandantory ATBAPP plugin methods:
+    virtual nsDeviceControllerInterface::PLUGIN_STATE getState() = 0;
+    virtual const QString & getLastError() = 0;
+    virtual const QString & getLastErrorDescription() = 0;
+
+    // return a plugin description in JSON or XML
+    // -> ATBAPPplugin::getPluginInfo()
+
+    // helpers e.g. for debug / log
+    virtual const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState) = 0;
+
+public slots:
+    virtual void onChangedProgramModeToSELL() = 0;
+    virtual void onChangedProgramModeToSERVICE() = 0;
+    virtual void onChangedProgramModeToIDLE() = 0;
+    virtual void onChangedProgramModeToOOO() = 0;
+
+    virtual void startPhysicalLayer() = 0;
+    virtual void stopPhysicalLayer() = 0;
+    virtual void reboot() = 0;
+    virtual void reset() = 0;
+
+
+signals:
+    void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+    void printReceiptFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+
+    /**
+     * emitted on e.g. a coin input
+     */
+    void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                nsDeviceControllerInterface::CASH_STATE cashState,
+                                const QString & newCashValue,
+                                /* additional variables? */
+                                const QString & errorCode,
+                                const QString & errorDescription);
+
+    /**
+     * emitted if cashInput has been stopped, e.g. in result to task requestStopCashInput():
+     *  -> shutter is blocked
+     *  -> no cash input is possible
+     *  -> coins are in cache
+     */
+    void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & newCashValue,
+                                     /*  additional variables? */
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+
+
+    /**
+     * emitted e.g. if service door is opened
+     */
+    void requestModeSERVICE();
+
+    /**
+     * emitted e.g. if doors are closed
+     */
+    void requestModeIDLE();
+
+    /**
+     * emitted e.g. on severe errors
+     */
+    void requestModeOOO();
+
+    /**
+     * emitted e.g. if service door is opened
+     */
+    void requestAccountResponse(const QHash<QString, QVariant> & accountData);
+
+
+
+
+
+    /**
+     * emitted on error
+     * depending on errorCode:
+     * -> interrupt selling process
+     * -> machine can go to state OOO
+     * -> send error event to ISMAS
+     * -> ...
+     */
+    void Error(
+            /*  additional variables? */
+            const QString & errorCode,
+            const QString & errorDescription);
+
+};
+
+
+Q_DECLARE_INTERFACE(DeviceControllerInterface,
+                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.0")
+
+
+namespace nsDeviceControllerInterface {
+
+    enum class PLUGIN_STATE : quint8 {
+        NOT_INITIALIZED = 0,
+        INITIALIZED = 1
+    };
+
+    enum class RESULT_STATE : quint8 {
+        SUCCESS = 1,                // operation was successfull
+        ERROR_BACKEND,              // error from backend (e.g. backend replies with error)
+        ERROR_TIMEOUT,              // the operation timed out
+        ERROR_PROCESS,              // internal plugin error, should not occur (this is a bug in implementation)
+        ERROR_RETRY,                // retry operation
+        INFO                        // informational (e.g. display a message, log something etc.)
+    };
+
+    enum class CASH_STATE   : quint8 {
+        CACHE_EMPTY,                // Cache still empty, default state
+        CACHE_INPUT,                // Coins are in Cache
+        OVERPAYED,
+        /* t.b.d. */
+    };
+
+
+    enum class TICKET_VARIANT : quint8 {
+        PARKING_TICKET,
+        RECEIPT,
+        ERROR_RECEIPT,
+        START_RECEIPT,   // e.g. Szeged Start
+        STOP_RECEIPT,    // e.g. Szeged Stop
+    };
+
+}
+
+#endif // DEVICECONTROLLERINTERFACE_H

src/ATBAPP/Utils.cpp

@@ -0,0 +1,18 @@
+#include "Utils.h"
+
+Utils::Utils(QObject *parent) : QObject(parent)
+{
+
+}
+
+
+
+int Utils::compare(const void* a, const void* b)
+{
+    uint16_t int_a = * ( (uint16_t*) a );
+    uint16_t int_b = * ( (uint16_t*) b );
+
+    if ( int_a == int_b ) return 0;
+    else if ( int_a < int_b ) return -1;
+    else return 1;
+}

src/ATBAPP/Utils.h

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

src/ATBAPP/support/DBusController.xml

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

src/ATBAPP/support/DBusControllerInterface.cpp

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

src/ATBAPP/support/DBusControllerInterface.h

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

src/ATBAPP/support/JSON.cpp

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

src/ATBAPP/support/JSON.h

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

src/ATBAPP/support/PTUSystem.cpp

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

src/ATBAPP/support/PTUSystem.h

@@ -0,0 +1,24 @@
+#ifndef PTUSYSTEM_H
+#define PTUSYSTEM_H
+
+#include <QObject>
+
+class PTUSystem : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PTUSystem(QObject *parent = nullptr);
+
+    static quint16 readCustomerNumber();
+    static quint16 readMachineNumber();
+    static quint16 readZoneNumber();
+    static quint16 readGroupNumber();
+
+private:
+    static QString readConfigString(const QString & filename);
+
+signals:
+
+};
+
+#endif // PTUSYSTEM_H