Set version to 1.3.2

using cutom-events of type update-dc-event.

DC2C_print01.json

@@ -0,0 +1,36 @@
+{
+"title":"DC2C_pri01",
+"project":"DBM Szeged park_coins",
+"issued":"13.04.2023 01.01",
+"styl":"size 01",
+"text":"PARKOLÓJEGY",
+"styl":"size 11",
+"feed":"nl",
+"text":"Nyugta",
+"styl":"size 00",
+"feed":"nl",
+"feed":"nl",
+"text":"mögé jól láthatóan", 
+"feed":"nl",
+"text":"elhelyezni!",
+"feed":"nl",
+"text":"A PARKOLÓ NEM ŐRZÖTT!",
+"feed":"nl",
+"styl":"size 10",
+"text":"Rendszám: ",
+"styl":"size 00",
+"feed":"nl",
+"vari":"Dynamic01",
+"feed":"nl",
+"text":"Parkolási idõ vége:",
+"vari":"Dynamic02",
+"vari":"Dynamic03",
+"feed":"nl",
+"text":"Parkolás helye:",
+"vari":"location",
+"text":"Összeg: ",
+"vari":"Dynamic04",
+"feed":"nl",
+}
+
+

DC2C_print02.json

@@ -0,0 +1,30 @@
+{
+"title":"DC2C_pri02",
+"project":"DBM Szeged park_coins",
+"issued":"13.04.2023 01.01",
+"text":"Kiadás időpontja:",
+"vari":"date us",	
+"vari":"time long",	
+"text":"Automata száma: ",
+"vari":"manu",
+"feed":"nl",
+"text":"Park.jegy sorsz.: ",
+"vari":"TickCtr",
+"feed":"nl",
+"text":"Szegedi Közlekedési Kft",
+"feed":"nl",
+"text":"6720 Szeged ",
+"feed":"nl",
+"text":"Zrínyi utca 4-8",
+"feed":"nl",
+"text":"Adósz: 11092612-2-06", 
+"feed":"nl",
+"text":"A jegy ára az ÁFA-t", 
+"feed":"nl",
+"text":"     tartalmazza!",
+"feed":"nl",
+"text":"Üf. szolg nyitvatartás:",
+"feed":"nl",
+}
+
+

DC2C_print03.json

@@ -0,0 +1,20 @@
+{
+"title":"DC2C_pri03",
+"project":"DBM Szeged park_coins",
+"issued":"13.04.2023 01.01",
+"text":"H - P: 7:45 - 17:00",
+"feed":"nl",
+"text":"Tel: (80) 820-500",
+"feed":"nl",
+"text":"Parkoljon egy érintéssel. ",
+"feed":"nl",
+"text":"Használja bankkártyáját ",
+"feed":"nl",
+"text":"  automatáinknál is!",
+"feed":"nl",
+"feed":"nl",
+"feed":"nl",
+"feed":"eject",
+}
+
+

DCPlugin/.gitignore

@@ -1 +1,41 @@
-*.user
+# 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/DCPlugin.pri

@@ -10,7 +10,8 @@ HEADERS += $${PWD}/include/com.h \
     $${PWD}/include/prot.h \
     $${PWD}/include/sendWRcmd.h \
     $${PWD}/include/storeINdata.h \
-    $${PWD}/include/tslib.h
+    $${PWD}/include/tslib.h \
+    $${PWD}/include/shared_mem_buffer.h
 
 SOURCES += $${PWD}/src/com.cpp \
     $${PWD}/src/controlBus.cpp \
@@ -20,4 +21,5 @@ SOURCES += $${PWD}/src/com.cpp \
     $${PWD}/src/prot.cpp \
     $${PWD}/src/sendWRcmd.cpp \
     $${PWD}/src/storeINdata.cpp \
-    $${PWD}/src/tslib.cpp
+    $${PWD}/src/tslib.cpp \
+    $${PWD}/src/shared_mem_buffer.cpp

DCPlugin/DCPlugin.pro

@@ -14,6 +14,8 @@ QMAKE_CXXFLAGS += -Wno-deprecated-copy
 # default
 ARCH = PTU5
 
+include(DCPlugin.pri)
+
 contains( CONFIG, DesktopLinux ) {
     QMAKE_CC = ccache $$QMAKE_CC
     QMAKE_CXX = ccache $$QMAKE_CXX
@@ -21,7 +23,6 @@ contains( CONFIG, DesktopLinux ) {
     # QMAKE_CXXFLAGS += -Wno-deprecated-ctor
     linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
     ARCH = DesktopLinux
-    include(DCPlugin.pri)
 }
 
 contains( CONFIG, PTU5 ) {
@@ -31,22 +32,23 @@ contains( CONFIG, PTU5 ) {
     linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
     CONFIG += link_pkgconfig
     ARCH = PTU5
-
-    # NOTE: include contents of DCPlugin.pri. Also used by ATBQT.
-    # Add new files in DCPlugin.pri.
-    include(DCPlugin.pri)
 }
 
 contains( CONFIG, PTU5_YOCTO ) {
+    greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
+    PTU5BASEPATH = /opt/devel/ptu5
     ARCH = PTU5
 
     # add qmqtt lib
     #LIBS += -lQt5Qmqtt
 }
 
-TARGET   = CashAgentLib
-DESTDIR  = ../plugins
+TARGET   = ATBDeviceControllerPlugin
+#DESTDIR  = ../plugins
+INTERFACE = DeviceController
+INTERFACE_DEFINITION = $${PWD}/include/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
@@ -66,3 +68,27 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #else: unix:!android: target.path = /opt/$${TARGET}/bin
 #!isEmpty(target.path): INSTALLS += target
 
+# ATBAPP interface
+HEADERS += \
+    src/ATBAPP/ATBAPPplugin.h \
+    src/ATBAPP/DeviceControllerInterface.h \
+    src/ATBAPP/ATBHealthEvent.h \
+    src/ATBAPP/ATBDeviceControllerPlugin.h
+
+SOURCES += \
+    src/ATBAPP/ATBHealthEvent.cpp \
+    src/ATBAPP/ATBDeviceControllerPlugin.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

DCPlugin/generate-version.sh

@@ -0,0 +1,155 @@
+#!/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")
+# -> 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}
+
+
+
+
+

DCPlugin/include/controlBus.h

@@ -170,7 +170,7 @@ uint8_t epi_getResultOfLastRequest();
     // retval: 0: in progress  1: OK  2: error
 
 
-void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t *receivedData);
+void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t const *receivedData);
     // stored by Datif
 
 uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad);

DCPlugin/include/datIf.h

@@ -324,12 +324,18 @@ public:
         // Sende Schreibbefehle die bereits vorher asynchron gespeichert wurden
     void send_requests(uint16_t nextWrCmd);
     void sendHighLevel(uint16_t nxtHLCmd);
+    bool areDataValid(void);
 
 signals:
     void ResponseRecieved();
         //the requested data are stored in peripheral image
         // can be loaded with epi
 
+    void datif_templatePrintFinished_OK();
+    void datif_templatePrintFinished_Err();
+
+    void datif_gotNewCoin();
+
 };
 
 #endif // CI_H

DCPlugin/include/hwChk.h

@@ -0,0 +1,35 @@
+
+#ifndef hwchk_H
+#define hwchk_H
+
+#include <stdint.h>
+#include <QTabWidget>
+#include <QObject>
+#include "interfaces.h"
+//#include "datIf.h"
+#include <QDebug>
+#include <QSharedMemory>
+#include "hwapi.h"
+
+//class QSharedMemory;
+class hwChk :   public QObject,
+                public hwinf
+{
+    Q_OBJECT
+//    Q_PLUGIN_METADATA(IID "Atb.Psa2020.software.HWapi/1.0" )   //FILE "HWapi.json")
+//    Q_INTERFACES(hwinf)
+//private:
+//    QSharedMemory *m_sharedMem;
+
+public:
+    explicit hwChk(QWidget *parent = nullptr);
+    virtual ~hwChk();
+
+
+public:
+    hwinf *HWaccess;
+
+
+};
+
+#endif

DCPlugin/include/hwapi.h

@@ -1,106 +1,20 @@
-/*
-matching interfaces.h:
-
-// History
-// 11.10.2021: V1.0  222 functions
-// 23.12.2021: V1.1  added block-parameter to function "read mifare data"
-// 30.12.2021: V1.2  added function: mif_clearDataBuffer(), mif_isBlockAvailable(uint8_t blkNr) and mif_getAvailableDataBlocks()
-// 1.1.2022: V1.3    Mifare extended. ( background: read 16 x 48byte from card to DC, read 12 x 64byte from DC to CA)
-//                   new:  read full card with 768bytes from HWapi without block borders
-//                   added: mif_getNrOfAvailableDataBytes     mif_getCardData768byteDec(uint8_t *buf, uint16_t bufferSize)
-//                           mif_getCardDataDec(uint16_t fromAddr, uint16_t toAddr, uint8_t *buf, uint16_t bufferSize)
-//                            mif_getCardDataStr(bool useHexFormat, char seperator)
-// 29.03.2023: V3.1 some extensions for PSA1256_ptu5,
-//             V3.2 Bootloader improvement
-// 12.04.2023: V3.3 new features extended: loading and using Json-files, cash-collection, cash-data-logging
-
-//#define HWINF_iid "Atb.Psa2020.software.HWapi/3.1"
-//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.1"
-#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.3"
-
-
-PSA1259 hardware control using the DeviceController DC2
-
-covering enclosure (switches and doors) and money devices,
-controls mifare card to access or program
-optional it can control printer, modem, bar code reader and credit card
-
- * API to the PSA1259 Hardware
- * All data come in from device controller via serial interface and will be stored
- * in "PI" = peripheral image
- * PI is updated every 100ms (up to 30ms possible)
- * This api uses stored pi data and returns them in the following functions
- * created: Q1/2020 TS
- *
-
-The devices, connected to device controller2 (DC2) can be controlled in different access levels.
-Level 1:
-    direct connection to DC2, check versions, state and parameters
-    control serial interfaces
-    digital/analog IO's
-    read and write to connected devices on lowest level, this is a kind of fall-back-level
-    in case higher levels fail or do not support the needed (new) function
-    Example: send a specific printer command, several bytes that need to be conform to
-            printer manual. This command is routed to the printer through the DC2 without
-            any action of the DC. You can write your own device driver that way.
-    Level 1 is flexible but complicated
-
-Level 2:
-   The DC controls the connected devices containing a device driver. The DC offers
-   usage of the device by simple commands,
-   Example: "Printer on", "set Font size 3" "print "hello world"", "cut"
-   In opposite to level 1 where you had to send a set of numbers and letters.
-   In other words: you "talk" to the device controller, not to the device itself.
-
-Level 3:
-    start/stop complete processes.
-    Example: 1) print (predefined) document nr 3 with Text, letter size, font set, cut.
-                Also power up/down the printer, check if paper ok and so on.
-*/
-
-/*
-Another access example: control the coin unit
-
-Level 1): read digital inputs to detect coin,
-          switch digital output which opens coin slot
-          communicate with coin checker by certain mdb-commands (manual conform)
-          poll coin checker for inserted coins
-          close coin slot after 3seconds by setting DO to 0....
-
-Level 2): get message of attached coin from DC
-          send command "initialize coin checker" to DC
-          send command "open slot for 3s"
-          poll DC for inserted coins, DC polls coin checker in right way, no need
-                to know the data sheet of the coin checker or mdb-bus
-          command to DC "open coin escrow's return flap for 1s"
-
-Level 3): send command: "start payment process"
-          all coin devices are started up
-          coin blocker opens for 3s if a coin is attached
-          coin checker summarizes inserted value and reports sum
-          later send command "stop payment process" (puts coins to vault) or
-          send command "cancel payment process" (returns coins to user)
-
-*/
 
 #ifndef hwapi_H
 #define hwapi_H
 
 #include <stdint.h>
-#include <QTabWidget>
-#include <QtPlugin>
 #include <QObject>
 #include "interfaces.h"
 #include "datIf.h"
 
-
-
+class QSharedMemory;
 class hwapi :   public QObject,
                 public hwinf
 {
     Q_OBJECT
-    Q_PLUGIN_METADATA(IID "Atb.Psa2020.software.HWapi/1.0" )   //FILE "HWapi.json")
     Q_INTERFACES(hwinf)
+private:
+    void sub_storeSendingText(QByteArray *buf) const;
 
     DownloadResult sendNextAddress(int bNum) const;
     DownloadResult sendNextDataBlock(QByteArray const &b, int bNum) const;
@@ -114,12 +28,17 @@ class hwapi :   public QObject,
     bool resetDeviceController() const;
     QByteArray loadBinaryDCFile(QString filename) const;
     bool downloadBinaryToDC(QString const &bFile) const;
+
+    QSharedMemory *m_sharedMem;
 public:
-    explicit hwapi(QWidget *parent = nullptr);
+    explicit hwapi(QObject *parent = nullptr);
+    virtual ~hwapi();
 
     T_datif *myDatif;
 
 
+    virtual QStringList dc_getStatus() const override;
+
     // ------------------------------------------------------------------------------
     // Level 0 commands, interface
     // open, close, change serial interface
@@ -148,12 +67,12 @@ public:
                                   QVector<int> templateIdx,
                                   QVector<QString> fnames,
                                   QString br,
-                                  QString serial) const override;
+                                  QString serial = QString()) const override;
 
     bool dc_printTemplate(enum FileTypeJson type,
                           QVector<int> templateIdx,
                           QString br,
-                          QString serial) const override;
+                          QString serial = QString()) const override;
     // ------------------------------------------------------------------------------
     // Level 1, control device-controller (functions of µC)
     // check serial connection to deviceController
@@ -990,24 +909,12 @@ public:
     //                          uint16_t borough, uint16_t zone,
     //                          uint16_t alias,   char *location) const override;
 
-    /*
-    uint8_t emp_getInsertedCoinSignal(void) const override;
-        // can be called one time after each coin
-        // emp_chkIfCoinInserted() must be called before!
-
-    uint16_t emp_getInsertedCoinValue(void) const override;
-        // can be called one time after each coin
-        // emp_chkIfCoinInserted() must be called before!
-
-    uint8_t emp_getCoinError(void) const override;
-        // can be called one time after each coin
-        // emp_chkIfCoinInserted() must be called before!
-    */
 
     bool rtc_setTimeDateDirect(struct Trtc_DateTime *DateTime) const override;
         // return true if successful. could fail if more the 8 commands are waiting
 
     bool rtc_getExtendedTime(uint8_t *leng, uint8_t *data) const override;
+    bool rtc_getExtendedTime(struct T_extTime *exTime) const override;
 
     bool sys_runCompleteTest(void) const override;
         // warning: lasts 20s in one pace
@@ -1032,15 +939,18 @@ public:
         // nr = 1..32
         // return true if sending, false if cmd-stack is full
 
-    void log_getHoldAccountNumbers(uint32_t *accNr ) const override;
+    void log_getHoldAccountNumbers(uint8_t *nrOfVals, uint16_t *accNr ) const override;
     // returns all acc nrs of the backuped vault records
-        // use: uint32_t backupedAccNumbers[8]
+    // use: uint16_t backupedAccNumbers[8]
 
     bool log_selectVaultRecord(uint16_t accountNr ) const override;
         // return true if sending, false if cmd-stack is full
+        // and trigger transfer
 
-//request, isAvailable
-    void log_getVaultRecord(struct T_vaultRecord *retVR) const override;
+    bool log_chkIfVaultRecordAvailable(void) const override;
+        // return true if completly received
+
+    bool log_getVaultRecord(struct T_vaultRecord *retVR) const override;
         // which was selected by: log_selectVaultRecord()
         // to be forwarded to Ismas
 
@@ -1050,7 +960,8 @@ public:
     bool prn_printTestTicket(void) const override;
         // return true if sending to DC OK, false if cmd-stack is full
 
-    bool cash_startPayment(uint16_t amount) const override;
+    bool cash_startPayment(uint32_t amount) const override;
+        // 17.4.23TS: extended to 32bit
 
     bool cash_cancelPayment(void) const override;
         // and return coins
@@ -1078,30 +989,101 @@ public:
 
 
 
-    uint8_t mif_getCardType(QString cardholder) const override;
+    uint8_t mif_getCardType(QString *cardholder) const override;
         // return 1,2,3,4 = upper, lower access card, printer test, coin test
         // cardholder: 7byte Name-String
 
     uint64_t sys_getWakeSource(void) const override;
         // retval: 6 bytes, bit coded, 1=event keeps DC awake
 
-    //void sys_getDeviceConditions(struct T_moduleCondition *devCond) const override;
+    uint8_t sys_getWakeReason(void) const override;
+         // Master was woken by following reason:
+         // 1: MDB Event
+         // 2: Coin Event
+         // ( 3: Master Event) - will not set the wake line
+         // ( 4: 32s pulse) - will not set the wake line
+         // 5: Door Event
+         // ( 6: Diag Event) - will not set the wake line
+         // 7: 30min-Pulse for HB
+
     void sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const override;
 
-    //void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const override;
+    void sys_getDeviceConditions(struct T_moduleCondition *devCond) const override;
+
     void sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const override;
+    void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const override;
 
 
+    uint32_t cash_getAmountInVault(void) const override;
+
+    uint16_t cash_getNrCoinsInVault(void) const override;
+
+    uint8_t prn_getPrintResult() const override;
+
+    uint8_t prn_getCurrentPrinterState() const override;
+        //        0: printer OK
+        //          bit0: near paper end          bit1: no paper
+        //          bit2: temperature error       bit3: error head open
+        //          bit4: paper jam in cutter
+        //          bit6: no response             bit7: serial rec. error
+        //			bit5: printer not ready
+
+    void sys_sendDeviceParameter(struct T_devices *deviceSettings) const override;
+
+    void sys_restoreDeviceParameter(struct T_devices *deviceSettings) const override;
 
 
+    /* ---------------------------------------------------------------------------------------------
+    // ------------   supervise  all hardware components
+    // ------------    assess the machine state
 
-private:
-    void sub_storeSendingText(QByteArray *buf) const;
+    1. check if DC startup test is through, retrigger if not
+    2. get results and find errors
+    3. in case of error check if component is used (e.g. billreader is seldom used)
+    4: check doors
+    5. return value: 0: no response from DC
+                     1: no Test results and Test not running. need retrigger!
+                     2: state not clear by now, test ongoing, wait
+                     3: Service or battery door is open, goto INTRUSION MODE
+                            from here: after valid ID-card goto SERVICE MODE
+                     4: vault door is open, goto INTRUSION MODE
+                            from here: after valid ID-card and vault door closed goto TEST MODE
+                            in TEST MODE: complete system check decides if vending mode allowed
+                     5: All doors are closed but errors found,
+                            goto OOO MODE (out-of-order)
+                            from here: run system test until problem is fixed
+                     6: All doors are closed, no error, maybe warnings,
+                            goto VENDING MODE (normal operation)
+                    (priority sinks from 0 to 6)
+
+     --------------------------------------------------------------------------------------------- */
+
+    uint8_t sys_componentAssessment(void) const override;
+    // this function decides if vending mode is possible, independant from door
+    // return >0 in case of error
+    // is inncluded in sys_superviseSystem
+
+    uint8_t sys_superviseSystem(void) const override;
+    // this function proofs if vending is possible depending of doors state
 
 
+    uint8_t sys_getSystemErrors(void) const override;
 
+    // ---------------------------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------------------------
 
+signals:
+    void hwapi_templatePrintFinished_OK(void) const override;
+    void hwapi_templatePrintFinished_Err(void) const override;
+    void hwapi_gotNewCoin(void) const override;
+    void hwapi_vendStopByMax(void) const override;
+    void hwapi_vendStopByPushbutton(void) const override;
 
+ private slots:
+    void hwapi_slotPrintFinished_OK(void);
+    void hwapi_slotPrintFinished_Err(void);
+    void hwapi_slotGotCoin(void);
 
 };
 

DCPlugin/include/interfaces.h

@@ -2,12 +2,9 @@
 #define INTERFACE_H
 
 #include <QtPlugin>
+#include <QStringList>
 
-
-
-struct T_emp
-{
-
+struct T_emp {
    // Fixdata from EMP:
    uint8_t shaft;      // = changer level
    uint16_t countryCode;
@@ -34,11 +31,9 @@ struct T_emp
 
    uint8_t pollingRunning;
    uint8_t paymentRunning;
-
 };
 
-struct Trtc_DateTime
-{
+struct Trtc_DateTime {
    uint8_t rtc_hour;
    uint8_t rtc_min;
    uint8_t rtc_sec;
@@ -48,8 +43,7 @@ struct Trtc_DateTime
    uint8_t rtc_dayOfWeek;
 };
 
-struct Tprn_hw_state
-{
+struct Tprn_hw_state {
     // hardware (IO's)
     bool powerRdBk;     // prn pwr is on
     bool rsSwOk;        // serial switch (printer or modem) is set to printer
@@ -66,8 +60,7 @@ struct Tprn_hw_state
     bool badResponse;
 };
 
- struct Tprn_currentSettings
-{
+struct Tprn_currentSettings {
     uint8_t currFont;
     uint8_t currSize;
     uint8_t currHeigth;
@@ -80,8 +73,7 @@ struct Tprn_hw_state
     bool    nowAligned;
 };
 
- struct T_dynDat
-{
+struct T_dynDat {
     uint8_t licensePlate[8];
     uint8_t vendingPrice[8];
     uint8_t parkingEnd[8];
@@ -92,10 +84,7 @@ struct Tprn_hw_state
     uint8_t dynDat7[8];
 };
 
-
-struct T_vaultRecord
-{
-
+struct T_vaultRecord {
     // Kassenbeleg (Abrechnungsdatensatz = Kassenwechsel-Datensatz)
     char startbuffer[4];		// Psa>  // never move or change this 1st entry
     uint16_t AccountingNumber;
@@ -126,7 +115,6 @@ struct T_vaultRecord
     uint32_t VKcoinsInserted[16];		// nur für Wechsler, soviel wurde eingeworfen
     uint32_t VKcoinsReturned[6];		// nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
 //88
-
     // Service, Tür offen:
     uint16_t ServCoinsInserted[16];		// nur für Wechsler, soviel wurde eingeworfen
     uint16_t ServCoinsReturned[6];		// nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
@@ -136,12 +124,10 @@ struct T_vaultRecord
     uint16_t resint5;
     uint16_t resint6;
 // 56
-
     char label4buffer[4];	// box>
     uint16_t coinsInVault[16];
     uint16_t billsInStacker[8];
 // 48
-
     char label5buffer[4];	// val>
     // actually constant unless exchange rate is changed
     uint16_t coinDenomination[16];	// 5..50000 (z.B. 2? sind in Ungarn 760Ft)
@@ -149,17 +135,12 @@ struct T_vaultRecord
     uint16_t tubeDenom[6];
     uint16_t exchangeRate;
     uint16_t resint9;
-
 // 64
-
     char endofblock[4];	// end>
-
 // 316 byte Block im Speicher
-
 };
 
-struct T_moduleCondition
-{
+struct T_moduleCondition {
     // store conditon of all system components, hold in RAM
     // 0 means unknown, not yet tested/used
     // 1 means OK
@@ -167,30 +148,29 @@ struct T_moduleCondition
     // 100..150	= WARNING
     // 200..250	= ERROR
 
-        uint8_t	structStart;		// always first!!!
-        uint8_t	ram;				// v
-        uint8_t	intEe;				// v
-        uint8_t	extEe;				// v
+    uint8_t	ram;
+    uint8_t	intEe;
+    uint8_t	extEe;
 
     uint8_t	rtc;				// 1: time/date OK   100: time not plausible  200: hardware error
-        uint8_t	boardHw;			// v
-        uint8_t	printer;			// v
-        uint8_t	modem;				// v
+    uint8_t	boardHw;
+    uint8_t	printer;
+    uint8_t	modem;
 
     uint8_t	signal;				//		1...99
     uint8_t	regist;				// 100:not  1:reg  2:ping OK   3:gotTime
     uint8_t	mdbBus;
     uint8_t	coinChecker;		// EMP, OMP or mei-cashflow
 
-        uint8_t	coinEscrow;			// v
-        uint8_t	mifareReader;		// v
-        uint8_t	creditTerm;			// not available
-        uint8_t	coinReject;			// v
+    uint8_t	coinEscrow;
+    uint8_t	mifareReader;
+    uint8_t	creditTerm;
+    uint8_t	coinReject;
 
-        uint8_t	coinSafe;			// v
-        uint8_t   billSafe;			// v
-        uint8_t	voltage;			// v	// 1:11..14V
-        uint8_t   temper;				// v
+    uint8_t	coinSafe;
+    uint8_t   billSafe;
+    uint8_t	voltage;			// 1:11..14V
+    uint8_t   temper;
 
     uint8_t	poweronTest;
     uint8_t   doorState;			// 1: alles zu  200: t?r offen + bit1(S) +bit2(CB) + bit3(CB)
@@ -202,74 +182,125 @@ struct T_moduleCondition
     uint8_t   ResetReason;
     uint8_t	allModulesChecked;
 
-        uint8_t   alarmState;
-        uint8_t   res11;
-        uint8_t   res12;
-        uint8_t   res13;
-
 };
 
-struct T_dynamicCondition
-{
-        // dynamic conditions, change rapidly and frequently
-        // these are values for the Heartbeat
-
-        // T?rschalter entprellt:
-        char upperDoor;		// 0:fehlt  1:drin
-        char middleDoor;
-        char lowerDoor;
-        char coinBox;
-
+struct T_dynamicCondition {
+    char allDoorsDebounced;     // 99: undefined, 0=all closed, bit1=upper door open  2=midlle door open 3=lower door open
+    char openedAuthorized;
+    uint8_t CBinDebounced;
+    char upperDoor;		// 99: undefined  0:closed  1:open
+    char middleDoor;    // 99: undefined  0:closed  1:open
+    char lowerDoor;     // 99: undefined  0:closed  1:open
+    char reserve;       // not used, always 0
     char billBox;
     char modeAbrech;
-        char onAlarm;
+    char onAlarm;       // 0:alarm aus  1:alarm  2:alarm mit Sirene   3: Sirenentest
     char nowCardTest;
-
     char nowPayment;
     char lastMifCardType;
-        char openedAuthorized;
-        char allDoorsDebounced;
-
     uint8_t lastSDoorState;
     uint8_t lastVDoorState;
-        uint8_t CBinDebounced;
-        uint8_t lastCBstate;
-
+    uint8_t lastCBstate;        // 99: undefined  0:not there   1:insered
     char        paymentInProgress;
     char        res1;
-        char res2;
-        char res3;
-
     uint16_t    U_Batt;
     uint16_t	Temperatur;
-
-        uint16_t	cash_storedaccNumbers[8];	// List all stored accounting numbers in ext. eeprom
-
     uint16_t	nrCoinsInBox;
-        uint16_t	resui1;
-
     uint32_t	amountInBox;
-        uint32_t	amountJustPaid;
-
-        uint16_t	lastInsCoinType;	// wahrscheinlich uchar
-        uint16_t	resui2;
-
     uint32_t	totalTransVolume;
     uint32_t	totalNrOfVends;
+    char        jsonValid_config;
+    char        jsonValid_device;
+    char        jsonValid_cash;
+    char        jsonValid_print;
+    char        jsonValid_serial;
+    char        jsonValid_time;
+    char        lastFileType;
+// 44
+    uint8_t     MifCardHolder[8];
+    uint8_t     resultOfLastTemplPrint;
+                // 0: unknown or printing in progress
+                // 1: OK, doc was printed   2: error, doc was not printed
+    uint8_t     lastPrinterStatus;
+                //        0: printer OK
+                //          bit0: near paper end          bit1: no paper
+                //          bit2: temperature error       bit3: error head open
+                //          bit4: paper jam in cutter
+                //          bit6: no response             bit7: serial rec. error
+                //			bit5: printer not ready
+    uint8_t     startupTestIsRunning;
+    //54
+};
+
+struct T_extTime {
+    uint8_t     Hours;
+    uint8_t     Min;
+    uint8_t     Sec;
+    uint8_t     Year;
+    uint8_t     Month;
+    uint8_t     Day;
+    uint8_t     DOW;
+    uint8_t     res1;
+    uint16_t    MinOfDay;
+    uint16_t    res2;
+    uint32_t    SecOfDay;
+    uint8_t     isLeapYear;
+    uint8_t     nxtLeapYear;
+    uint8_t     lastLeapYear;
+    uint8_t     hoursOfThisWeek;
+    uint16_t    minutesOfThisWeek;
+    uint16_t    hoursOfThisMonth;
+    uint16_t    daysOfThisYear;
+    uint16_t    GetHoursOfYear;
+    uint16_t    res3;
+    uint32_t    GetMinutesOfYear;
+    uint8_t     getWakeIntvSec;
+    uint8_t     res4;
+    uint16_t    res5;
+    uint32_t    MinutesOfMillenium;
+};
+
+typedef uint8_t UCHAR;
+typedef uint16_t UINT;
+
+struct T_devices
+{
+    // set by master, used(1) or notused (0) or type 2....20
+
+    UCHAR   kindOfPrinter;			// 0:off   1:Gebe
+    UCHAR	kindOfCoinChecker;		// 0: without  1=EMP820   2=EMP900    3=currenza c²	(MW)
+    UCHAR	kindOfMifareReader;		// by now only stronglink SL025 =1
+    UCHAR   suppressSleepMode;		// 0:sleep allowed   1: no sleep
+
+    UCHAR	kindOfModem;			// 0:off    1:Sunlink
+    UCHAR	kindOfCreditcard;		// 0:off    1:Feig NFC
+    UCHAR	CoinEscrow;
+    UCHAR   CoinRejectUnit;
+
+    UCHAR	CoinShutter;
+    UCHAR	BillAcceptor;
+    UCHAR	usevaultLock;
+    UCHAR	autoAlarm;				// 1: switch on siren for 1min in doors opened unauthorized
+
+    UCHAR	autoOpen;				// 1: open door covers after valid ATBcard
+    UCHAR	printAccReceipt;		// 0/1
+    UCHAR   printDoorReceipt;
+    UCHAR   printTokenTicket;
+
+    UINT	VaultFullWarnLevel;
+    UINT	VaultFullErrorLevel;
 
 };
 
 
-class hwinf
-{
-
+class hwinf {
 public:
     enum class DownloadResult {OK, ERROR, TIMEOUT, NOP};
     enum class FileTypeJson {CONFIG=1, DEVICE, CASH, SERIAL, TIME, PRINTER};
 
     virtual ~hwinf() {}
                
-    
+    virtual QStringList dc_getStatus() const = 0;
                                            
     // $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$    
     //       Use serial interface and protocol stack in Cashagent-Library
@@ -310,12 +341,12 @@ public:
                                           QVector<int> templateIdx,
                                           QVector<QString> fnames,
                                           QString br,
-                                          QString serial) const = 0;
+                                          QString serial = QString()) const = 0;
 
     virtual bool dc_printTemplate(enum FileTypeJson type,
                                   QVector<int> templateIdx,
                                   QString br,
-                                  QString serial) const = 0;
+                                  QString serial = QString()) const = 0;
 
     virtual void dc_autoRequest(bool on)  const =0;
         // on = true:  select that all READ-Requests are sent automatically 
@@ -1371,6 +1402,8 @@ public:
 
  */
 
+    virtual bool rtc_getExtendedTime(struct T_extTime *exTime) const=0;
+
     virtual bool sys_runCompleteTest(void) const=0;
         // warning: lasts 20s in one pace
         // return true if sending, false if cmd-stack is full
@@ -1395,15 +1428,18 @@ public:
         // nr = 1..32
         // return true if sending, false if cmd-stack is full
 
-        virtual void log_getHoldAccountNumbers(uint32_t *accNr ) const=0;
+    virtual void log_getHoldAccountNumbers(uint8_t *nrOfVals, uint16_t *accNr ) const=0;
         // returns all acc nrs of the backuped vault records
-        // use: uint32_t backupedAccNumbers[8]
+        // use: uint16_t backupedAccNumbers[8]
 
     virtual bool log_selectVaultRecord(uint16_t accountNr ) const=0;
         // return true if sending, false if cmd-stack is full
+        // and trigger transfer
 
-//request, isAvailable
-virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
+    virtual bool log_chkIfVaultRecordAvailable(void) const=0;
+        // return true if completly received
+
+    virtual bool log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
         // which was selected by: log_selectVaultRecord()
         // to be forwarded to Ismas
 
@@ -1413,7 +1449,8 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
     virtual bool prn_printTestTicket(void) const=0;
         // return true if sending to DC OK, false if cmd-stack is full
 
-    virtual bool cash_startPayment(uint16_t amount) const=0;
+    virtual bool cash_startPayment(uint32_t amount) const=0;
+        // 17.4.23TS: extended to 32bit
 
     virtual uint32_t getInsertedAmount(void) const=0;
 
@@ -1437,18 +1474,23 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
         // conclude payment process and return all inserted coins
 
 
-
-
-
-
-    virtual uint8_t mif_getCardType(QString cardholder) const=0;
+    virtual uint8_t mif_getCardType(QString *cardholder) const=0;
         // return 1,2,3,4 = upper, lower access card, printer test, coin test
         // cardholder: 7byte Name-String
 
     virtual uint64_t sys_getWakeSource(void) const =0;
         // retval: 6 bytes, bit coded, 1=event keeps DC awake
 
-    //virtual void sys_getDeviceConditions(struct T_moduleCondition *devCond) const=0;
+    virtual uint8_t sys_getWakeReason(void) const=0;
+         // Master was woken by following reason:
+         // 1: MDB Event
+         // 2: Coin Event
+         // ( 3: Master Event) - will not set the wake line
+         // ( 4: 32s pulse) - will not set the wake line
+         // 5: Door Event
+         // ( 6: Diag Event) - will not set the wake line
+         // 7: 30min-Pulse for HB
+
     virtual void sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const=0;
     /*
 
@@ -1485,8 +1527,7 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
 
      */
 
-
-    //virtual void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const=0;
+    virtual void sys_getDeviceConditions(struct T_moduleCondition *devCond) const=0;
     virtual void sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const=0;
 /*
 
@@ -1552,6 +1593,85 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
 
 */
 
+    virtual void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const=0;
+
+    // content of Cashbox
+    virtual uint32_t cash_getAmountInVault(void) const=0;
+
+    virtual uint16_t cash_getNrCoinsInVault(void) const=0;
+
+
+    virtual uint8_t prn_getPrintResult() const=0;
+
+    // in case of print-error get detailed error:
+    virtual uint8_t prn_getCurrentPrinterState() const=0;
+        //        0: printer OK
+        //          bit0: near paper end          bit1: no paper
+        //          bit2: temperature error       bit3: error head open
+        //          bit4: paper jam in cutter
+        //          bit6: no response             bit7: serial rec. error
+        //			bit5: printer not ready
+
+    virtual void sys_sendDeviceParameter(struct T_devices *deviceSettings) const=0;
+
+    virtual void sys_restoreDeviceParameter(struct T_devices *deviceSettings) const=0;
+
+    /* ---------------------------------------------------------------------------------------------
+    // ------------   supervise  all hardware components
+    // ------------    assess the machine state
+
+    1. check if DC startup test is through, retrigger if not
+    2. get results and find errors
+    3. in case of error check if component is used (e.g. billreader is seldom used)
+    4: check doors
+    5. return value: 0: no response from DC
+                     1: no Test results and Test not running. need retrigger!
+                     2: state not clear by now, test ongoing, wait
+                     3: Service or battery door is open, goto INTRUSION MODE
+                            from here: after valid ID-card goto SERVICE MODE
+                     4: vault door is open, goto INTRUSION MODE
+                            from here: after valid ID-card and vault door closed goto TEST MODE
+                            in TEST MODE: complete system check decides if vending mode allowed
+                     5: All doors are closed but errors found,
+                            goto OOO MODE (out-of-order)
+                            from here: run system test until problem is fixed
+                     6: All doors are closed, no error, maybe warnings,
+                            goto VENDING MODE (normal operation)
+                    (priority sinks from 0 to 6)
+
+     --------------------------------------------------------------------------------------------- */
+
+    virtual uint8_t sys_componentAssessment(void) const=0;
+    // this function decides if vending mode is possible, independant from door
+    // return >0 in case of error
+    // is inncluded in sys_superviseSystem
+
+    virtual uint8_t sys_superviseSystem(void) const=0;
+    // this function proofs if vending is possible depending of doors state
+
+    virtual uint8_t sys_getSystemErrors(void) const=0;
+
+
+    // retrigger System-Check with:
+    // bool hwapi::sys_runCompleteTest(void) const
+
+
+
+
+
+
+
+
+    // ---------------------------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------------------------
+
+signals:
+    virtual void hwapi_templatePrintFinished_OK(void) const=0;
+    virtual void hwapi_templatePrintFinished_Err(void) const=0;
+    virtual void hwapi_gotNewCoin(void) const=0;
+    virtual void hwapi_vendStopByMax(void) const=0;
+    virtual void hwapi_vendStopByPushbutton(void) const=0;
 
 };
 
@@ -1569,10 +1689,15 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
 // 29.03.2023: V3.1 some extensions for PSA1256_ptu5,
 //             V3.2 Bootloader improvement
 // 12.04.2023: V3.3 new features extended: loading and using Json-files, cash-collection, cash-data-logging
+// 14.04.2023: V3.4 new features extended: sys_getDynMachineConditions, sys_getDeviceConditions and
+//                    rtc_getExtendedTime return struct in addition. New function to select and get VaultRecord
+//
 
 //#define HWINF_iid "Atb.Psa2020.software.HWapi/3.1"
 //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.1"
-#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.3"
+//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.3"
+//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.4"
+#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.5"
 
 
 

DCPlugin/include/sendWRcmd.h

@@ -218,7 +218,10 @@ bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8
 bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4);
 
 uint8_t check4FDshortCmd(void);
-    // returns number of waiting command
+    // returns number of waiting command, maxFDCMD_STACKDEPTH
+
+uint8_t check4freeFDshortCmd(void);
+    // returns number of free places in short-command stack
 
 #define     FDLONG_STACKDEPTH    16
 void longFDcmd_clrStack(void);
@@ -230,6 +233,17 @@ bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, ui
 uint8_t check4FDlongCmd(void);
     // returns number of waiting command
 
+uint8_t check4freeFDlongCmd(void);
+    // returns number of free places in long-command stack
+
+
+
+uint8_t epi_store64BdevParameter(uint8_t length, uint8_t *buf);
+    // HWapi writes data to be stored
+
+uint8_t epi_restore64BdevParameter(uint8_t *length, uint8_t *buf);
+
+
 
 #endif
 

DCPlugin/include/shared_mem_buffer.h

@@ -0,0 +1,296 @@
+#ifndef SHARED_MEM_BUFFER_INCLUDED_H
+#define SHARED_MEM_BUFFER_INCLUDED_H
+
+#include <cinttypes>
+#include <atomic>
+
+#include <QSharedMemory>
+
+struct SharedMemBuffer {
+    struct rs {
+        char comportName[16]; // z.B. "COM48"
+        char baudStr[16];     // z.B. "19200"
+        int  baudNr;          // 0...5 oder -1
+        uint8_t connect;      // 0,1
+        bool portIsOpen;
+    } rs;
+
+    char AutoEmissionOn;     // 1: zyklisch Anfragen zum Slave senden
+
+    struct datif {
+        uint16_t sendingPeriod;
+        bool     sendingPer_changed;
+    } datif;
+
+#if 0
+    // controlBus.cpp
+    char        txt4comStateLine[32];
+    char        txt4HsStateLine[32];
+    char        txt4masterStateLine[32];
+    char        txt4resultStateLine[32];
+    char        txt4dataLine[32];
+    char        txt4datifReceive[32];
+    char        txt4diagWindow[32];
+    char        sndTxt4diagWindow[32];
+    bool        Sdata_serialTestResult[32];
+    uint8_t     Sdata_pProtResultOk[32];
+    uint16_t    Sdata_receivedDataLength[32];
+    uint8_t     Sdata_receivedDataBlock[64];
+
+    // datif.cpp
+    uint8_t     dif_dataStep;
+    uint8_t     dif_scanStep;
+    uint8_t     RDBLKNR;
+    uint8_t     datif_OutCmdpara1;
+    uint8_t     datif_OutCmdpara2;
+    uint8_t     datif_OutCmdpara3;
+    uint8_t     datif_OutCmdpara4;
+
+    uint16_t    datif_OutCmdpara5;
+    uint32_t    datif_OutCmdpara6;
+    uint8_t     cycl_running;
+
+    // dcBL.cpp
+    uint8_t     dcBL_LastBLcmd;   // stored the last sent cmd in order to analys response
+    uint8_t     dcBL_AtbBinFile[300000];
+    uint32_t    dcBL_fileSize;
+    uint16_t    dcBL_nrOfBlocks;
+    uint16_t    dcBL_fileCrc;
+    uint8_t     dcBL_myBuf[300000]; // same content like "dcBL_AtbBinFile" but bytewise
+
+    char        BlResp[50][32];
+    uint8_t     dcBL_step;
+    uint8_t     dcBL_state;
+    uint16_t    dcBL_BlkCtr;
+    uint16_t    dcBL_cyclCtr;
+    uint16_t    repeatCtr;
+    uint8_t     Sdata_rawData[150];
+    uint8_t     Sdata_LengthRawData;
+
+    // hwapi.cpp
+    uint16_t    hwapi_shutterTime;
+    char        ticketTemplate[1024];
+
+    // sendWRcmd.cpp
+    uint16_t    nextAsynchsendCmd0[16];
+    uint8_t     nrOfCmdsInQueue;
+    uint16_t    nextAsynchsendCmd4[8];
+    uint8_t     nextCmd4para1[8];
+    uint8_t     nextCmd4para2[8];
+    uint8_t     nextCmd4para3[8];
+    uint8_t     nextCmd4para4[8];
+    uint8_t     nrOfCmds4InQueue;
+    uint16_t    nextAsynchsendCmd8[4];
+    uint8_t     nextCmd8para1[4];
+    uint8_t     nextCmd8para2[4];
+    uint16_t    nextCmd8para3[4];
+    uint32_t    nextCmd8para4[4];
+    uint8_t     nrOfCmds8InQueue;
+    uint8_t     sendAsynchDataBuf[160]; // no stack, only ONE buffer
+    uint8_t     sendAsyDatLen;
+    uint8_t     Sdata_mdbSendBuffer[64];
+    uint8_t     Sdata_mdbSendLen;
+    uint8_t     prnDataParameters[4];
+    uint8_t     prnDataBufferUser;
+    char        Sdata_PRN_TEXT[20][64];
+    uint8_t     pPrnDataBuff;        // points to next PRINTER_BLOCK
+    uint8_t     nextFDwrCmd[16];
+    uint8_t     nextFDrdCmd[16];
+    uint8_t     nextFDblkNr[16];
+
+    uint8_t     nextFDpara1[16];
+    uint8_t     nextFDpara2[16];
+    uint8_t     nextFDpara3[16];
+    uint8_t     nextFDpara4[16];
+    uint8_t     p_nextFDcmdsInQueue;
+    uint8_t     longFDwrCmd[16];
+    uint8_t     longFDrdCmd[16];
+    uint8_t     longFDblkNr[16];
+    uint8_t     longFDlength[16];
+
+    uint8_t     longFDpara[16][64];
+    uint8_t     p_longFDcmdsInQueue;
+
+    // storeInData.cpp
+    bool        indat_savePrnPwr;
+    bool        indat_saveMifPwr;
+    bool        indat_MdbIsOn;
+#endif
+
+    uint8_t     ndbs;
+    uint8_t     pari;
+    uint8_t     nsb;
+    uint8_t     br;
+
+#define MAXNROF_GENSTR 16
+    char        genStrings[MAXNROF_GENSTR][64];
+
+#define MAXNROF_AI 4
+    uint16_t    AI_val[MAXNROF_AI];
+
+    struct DigitalInputs {
+        uint8_t doorSwitch;
+        uint8_t vaultSwitch;
+        uint8_t lockSwitch;
+        uint8_t opto;
+        uint8_t aux;
+        bool wakeFromPtu;
+        bool wakeFromMdb;
+        bool wakeFromModem;
+        bool PrnReady;
+        bool CoinAttach;
+        bool CoinEscrowOpen;
+        bool mifCardTap;
+        bool contactPwrOn;
+        bool mifarePwrOn;
+        bool rdbk_mdbTxd;
+        bool AuxPwrOn;
+        bool gsmPwrOn;
+        bool creditPwrOn;
+        bool printerPwrOn;
+        bool mdbPwrOn;
+        bool rejMot_home;
+        uint8_t npe_sensor;
+    } din;
+
+    struct DigitalOutputs {
+        uint8_t mbdRxTst;
+        uint8_t motorBits;
+        uint8_t serialSwitch;                 // serial drv on/off, Serial mux1, Serial mux2
+        uint8_t ledsAndFan;
+        uint8_t laermUndRelay;
+        uint8_t ptuWake;
+        uint8_t auxPower;
+        uint8_t coinShutter;
+        uint8_t coinEscrow;
+        uint8_t printerPower;
+    } dout;
+
+    struct Sdata {
+#define NROFMIFSTATEBYTES       40
+#define PRN_STATE_ARRAY_SIZE    20
+#define PRN_STATE_FONT_SIZE     20
+        uint8_t MIF_STATE[NROFMIFSTATEBYTES];
+        uint8_t MIF_DATA[12][64];
+        uint8_t PRN_STATE[PRN_STATE_ARRAY_SIZE];
+        uint8_t PRN_FONTS[PRN_STATE_FONT_SIZE];
+        bool mdb_busRdy;
+        bool mdb_V12on;
+        bool mdb_V5on;
+        uint8_t mdbNrOfRecData;
+        uint8_t RecBuff[40];
+        uint8_t empNrOfsettings;
+        uint8_t emp_settingsBuff[66];
+        uint8_t NrOfDeviceSetting;
+        uint8_t DeviceSettingBuff[66];
+        uint8_t NrOfMachineIDSetting;
+        uint8_t NrOfMachineIDBuff[66];
+        uint64_t slaveUID;
+        uint8_t UIDstr[8];
+#define MAXNROF_MEASURE 4
+        uint32_t measurement[MAXNROF_MEASURE];
+        bool serialTestResult;
+        uint8_t pProtResultOk;
+        uint16_t receivedDataLength;
+        uint8_t receivedDataBlock[64];
+    } Sdata;
+
+    uint8_t mif_cardType;
+    uint8_t mif_cardHolder[8];
+
+#define MEMDEPTH_GOTCOINS (16)
+    struct T_coin {
+        uint8_t valid;
+        uint8_t signal;
+        uint8_t error;
+        uint8_t pad;
+        uint16_t value;
+    } gotCoin[MEMDEPTH_GOTCOINS];
+    uint8_t ctr_gotCoin;
+
+    struct store {
+        uint32_t insertedAmount;
+        uint16_t lastCoinType[64];
+        uint16_t lastCoinValue[64];
+        uint64_t wakeSrc;
+        uint8_t rbDevParamLen;
+        uint8_t rbDevParams[66];
+        uint8_t deviceCondLen;
+        uint8_t deviceCond[66];
+        uint8_t machCondLen;
+        uint8_t machCond[66];
+        uint8_t DcBackupNrOfAccNr;
+        uint16_t DcBackupAccNr[16];    // z.Z. nur 8
+        uint8_t gotNrBlocksOfVaultRec;
+        uint8_t vaultrecord[360];
+        uint32_t amount;
+        uint16_t nrOfCoins;
+        bool    dcDataValid;
+        uint8_t wakeReason;
+
+    } store;
+
+    struct T_globTime {
+        // Reihenfolge nicht vertauschen!!!!!
+        uint8_t     hour;
+        uint8_t     minute;
+        uint8_t     second;
+        uint8_t     Year;
+        uint8_t     Month;
+        uint8_t     DayOfMonth;
+        uint8_t     DayOfWeek;          // 1=monday...7
+        uint8_t     reserve1;
+
+        uint16_t     MinutesOfToday;
+        uint16_t     reserve2;
+
+        uint32_t     SecondsOfToday;
+
+        uint8_t      IsLeapyear;
+        uint8_t      nextLeap;
+        uint8_t      lastLeap;
+        uint8_t      hoursOfWeek;
+
+        uint16_t     minOfWeek;
+        uint16_t     hoursOfMonth;
+        uint16_t     minOfMonth;
+        uint16_t     dayOfYear;
+        uint16_t     hoursOfYear;
+        uint16_t     reserve3;
+
+        uint32_t     minOfYear;
+
+        uint8_t      squareOutMode;
+        uint8_t      free1;
+        uint16_t     reserve4;
+        uint32_t     minOfMillenium;
+        // bis hierher 44byts
+        uint32_t    free2;
+        uint32_t    free3;
+        uint32_t    free4;
+    } getGlobalTime;
+
+    static QSharedMemory *getShm(std::size_t s = 0);
+    static SharedMemBuffer *getData() {
+        return (SharedMemBuffer *)getShm()->data();
+    }
+    static SharedMemBuffer const *getDataConst() {
+        return (SharedMemBuffer const *)getShm()->data();
+    }
+
+#if 0
+    static std::atomic<bool> __sharedMemLocked;
+
+    static bool sharedMemLocked() {
+        return __sharedMemLocked;
+    }
+    static void setSharedMemLocked() {
+        __sharedMemLocked = true;
+    }
+    static void setSharedMemUnlocked() {
+        __sharedMemLocked = false;
+    }
+#endif
+};
+
+#endif // SHARED_MEM_BUFFER_INCLUDED_H

DCPlugin/include/storeINdata.h

@@ -3,12 +3,12 @@
 #define STOREINDATA_H
 
 #include <stdint.h>
-#include "tslib.h"
+//#include "tslib.h"
 #include <QString>
 
 
 #define MAXNROF_AO              3
-#define MAXNROF_GENSTR          16
+//#define MAXNROF_GENSTR          16
 #define MAXNROF_CONTR_PORTS     11
 #define MAXNROF_DIports         2
 #define MAXNROF_DOports         2
@@ -32,9 +32,6 @@ bool indat_isMifareOn();
 void indat_storeMDBisOn(bool isOn);
 bool indat_isMdbOn();
 
-
-
-
 void gpi_storeSlaveSerParams(uint8_t slaveBaudRate, uint8_t NrDataBits,
                              uint8_t parity, uint8_t NrStopBits);
 
@@ -43,23 +40,16 @@ void epi_getSlaveSerParams(uint8_t *slaveBaudRate, uint8_t *NrDataBits,
 
 QString epi_getSlaveParamSTR();
 
-
-
-
-
 void gpi_storeGenerals(uint8_t genNr, QString text);
     // 0=HW   1=SW  2=State
-
 QString epi_loadGenerals(uint8_t genNr);
 // genNr=0=HW   1=SW  2=State
 
 
-void gpi_storeUID(uint8_t *buf8byteUid);
+void gpi_storeUID(uint8_t const *buf8byteUid);
 // buffer size: 8 byte
-
 void epi_getUIDdec(uint8_t *buf8byteUid);
 // buffer size: 8 byte
-
 QString epi_getUIDstr();
 
 
@@ -89,7 +79,7 @@ void epi_getSpecialYearTimeDate(uint16_t *DayOfYear, uint16_t *HoursOfYear, uint
 // ///////////////////////////////////////////////////////////////////////////////////
 
 
-#define MAXNROF_AI              4
+// #define MAXNROF_AI              4
 
 void gpi_storeAIs(uint8_t aiNr, uint16_t val);   // rs -> Sdata
 
@@ -138,185 +128,119 @@ void gpi_storeDI_optos(uint8_t indatOpto);
 uint8_t epi_getDI_optos(void);
     // bit0: opto in 1    1: opto in 2
 
-void gpi_storeDI_auxIn(uint8_t indatAuxIn);
-    // Aux0...5
-
-uint8_t epi_getDI_auxIn(void);
-    // bit0: auxin 1  ...  5: auxin 6
-
-void gpi_storeDI_ptuWake(uint8_t indat);
+uint8_t gpi_storeDI_auxIn(uint8_t indatAuxIn); // Aux0...5
+uint8_t epi_getDI_auxIn(void);                 // bit0: auxin 1  ...  5: auxin 6
 
+bool gpi_storeDI_ptuWake(bool w);
 bool epi_getDI_ptuWake(void);
 
-void gpi_storeDI_mbdWake(uint8_t indat);
-
+bool gpi_storeDI_mbdWake(bool w);
 bool epi_getDI_mdbWake(void);
 
-void gpi_storeDI_prnReady(uint8_t indat);
-
+bool gpi_storeDI_prnReady(bool ready);
 bool epi_getDI_prnReady(void);
 
-void gpi_storeDI_CoinAttach(uint8_t indat);
-
+bool gpi_storeDI_CoinAttach(bool attach);
 bool epi_getDI_CoinAttach(void);
 
-void gpi_storeDI_CoinEscrow(uint8_t indat);
-
+bool gpi_storeDI_CoinEscrow(bool ce);
 bool epi_getDI_CoinEscrow(void);
 
-void gpi_storeDI_mifareCardTapped(uint8_t indat);
-
+bool gpi_storeDI_mifareCardTapped(bool tapped);
 bool epi_getDI_mifareCardTapped(void);
 
-void gpi_storeDI_modemWake(uint8_t indat);
-
+bool gpi_storeDI_modemWake(bool w);
 bool epi_getDI_modemWake(void);
 
-
-void gpi_storeDI_contactPowerIsOn(bool di_contact_PwrOn);
-
+bool gpi_storeDI_contactPowerIsOn(bool on);
 bool epi_getDI_contactPwr(void);
 
-void gpi_storeDI_MifarePowerIsOn(bool di_mifare_PwrOn);
-
+bool gpi_storeDI_MifarePowerIsOn(bool on);
 bool epi_getDI_mifarePwr(void);
 
-void gpi_storeDI_readbackMdbTxD(bool di_rdbkMdbTxd);
-
+bool gpi_storeDI_readbackMdbTxD(bool rdbkMdbTxd);
 bool epi_getDI_mdbTxd(void);
 
-void gpi_storeDI_AuxPowerIsOn(bool di_Aux_PwrOn);
-
+bool gpi_storeDI_AuxPowerIsOn(bool on);
 bool epi_getDI_auxPwr(void);
 
-void gpi_storeDI_GsmPowerIsOn(bool di_gsm_PwrOn);
-
+bool gpi_storeDI_GsmPowerIsOn(bool on);
 bool epi_getDI_gsmPwr(void);
 
-void gpi_storeDI_CreditPowerIsOn(bool di_credit_PwrOn);
-
+bool gpi_storeDI_CreditPowerIsOn(bool on);
 bool epi_getDI_creditPwr(void);
 
-void gpi_storeDI_PrinterPowerIsOn(bool di_printer_PwrOn);
-
+bool gpi_storeDI_PrinterPowerIsOn(bool on);
 bool epi_getDI_printerPwr(void);
 
-void gpi_storeDI_MdbPowerIsOn(bool di_mdb_PwrOn);
-
+bool gpi_storeDI_MdbPowerIsOn(bool on);
 bool epi_getDI_mdbPwr(void);
 
-
-void gpi_storeDI_rejMot_home(bool di);
-
+bool gpi_storeDI_rejMot_home(bool reject);
 bool epi_getDI_rejectMotor_homepos(void);
 
-void gpi_storeDI_paperLow(uint8_t di);
-
+uint8_t gpi_storeDI_paperLow(uint8_t di);
 uint8_t epi_getDI_npe_sensor(void);
     // 0: Sensor sees paper 1: no paper 99: off
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 // ///////////////////////////////////////////////////////////////////////////////////
 //          readback digital outputs
 // ///////////////////////////////////////////////////////////////////////////////////
 
-void gpi_storeDO_mdbRxTst(uint8_t do_mbdRxTst);
-
+uint8_t gpi_storeDO_mdbRxTst(uint8_t do_mbdRxTst);
 bool epi_getDO_mdbRxTestOut(void);
 
-
-void gpi_storeDO_motorOutputs(uint8_t Pwr);
-
+uint8_t gpi_storeDO_motorOutputs(uint8_t Pwr);
 uint8_t epi_getDO_motorOuts(void);
     // bit0: upper lock forward    bit 1 backward
     // bit2: lower lock forward    bit 3 backward
 
-
-void gpi_storeDO_serialSwitch(uint8_t state);
+uint8_t gpi_storeDO_serialSwitch(uint8_t state);
     // serial drv on/off, Serial mux1, Serial mux2
-
 uint8_t epi_getDO_serialSwitch(void);
     // serial drv on/off, Serial mux1, Serial mux2
 
 bool epi_getDO_serialDriverIsOn(void);
-
 bool epi_getDO_serialMux1isSetToPrinter(void);
     // mux1 off: serial is switched to printer
 
 bool epi_getDO_serialMux1isSetToModem(void);
     // mux1 on: serial is switched to modem
-
 bool epi_getDO_serialMux2isSetToCredit(void);
     // mux2 off: serial is switched to credit card terminal
-
 bool epi_getDO_serialMux2isSetToMifare(void);
     // mux2 on: serial is switched to mifare reader
 
-
-void gpi_storeDO_ledsAndFan(uint8_t ledState);
-
+uint8_t gpi_storeDO_ledsAndFan(uint8_t ledState);
 bool epi_getDO_led_coin(void);
-
 bool epi_getDO_led_front(void);
-
 bool epi_getDO_led_ticket(void);
-
 bool epi_getDO_led_pin(void);
-
 bool epi_getDO_led_start(void);
-
 bool epi_getDO_led_inside(void);
-
 bool epi_getDO_fan(void);
 
-void gpi_storeDO_sirenAndRelay(uint8_t sirenRelay);
-
+uint8_t gpi_storeDO_sirenAndRelay(uint8_t sirenRelay);
 bool epi_getDO_sirene(void);
-
 bool epi_getDO_relay(void);
 
-void gpi_storeDO_ptuWake(uint8_t state);
-
+uint8_t gpi_storeDO_ptuWake(uint8_t state);
 bool epi_getDO_ptuWake(void);
 
-void gpi_storeDO_auxPower(uint8_t pwr);
-
+uint8_t gpi_storeDO_auxPower(uint8_t pwr);
 bool epi_getDO_auxPower(void);
 
-
-void gpi_storeDO_coinShutter(uint8_t state);
-
+uint8_t gpi_storeDO_coinShutter(uint8_t state);
 bool epi_getDO_coinShutterOpen(void);
-
 bool epi_getDO_coinShutterTest(void);
 
-
-void gpi_storeDO_coinEscrow(uint8_t state);
-
+uint8_t gpi_storeDO_coinEscrow(uint8_t state);
 uint8_t epi_getDO_coinEscrow(void);
     // retval: 1:return flap is open   2:take flap is open    0:closed
 
-
-void gpi_storeDO_printerPwrOn(uint8_t state);
-
+uint8_t gpi_storeDO_printerPwrOn(uint8_t state);
 uint8_t epi_getDO_printerPwr(void);
 
-
-
 // ---------------------------------------------------------------------------------------------
 // counterchecks, make sure that DC-outputs are correct
 
@@ -363,21 +287,14 @@ bool epi_cntchk_Mot2Fon(void);
 
 uint8_t gpi_storeMdbRecData(uint8_t length, uint8_t *buf);
     // datif store received mdb data
-
 uint8_t epi_getMdbResponse(void);
      // 0=no response  1=ACK  2=NAK  3=ACK with data
-
 uint8_t epi_getMdbRecLength(void);
     // 0...31
-
 uint8_t epi_restoreMdbRecData(uint8_t *buf);
     // hwapi reads received mdb data from PI
 
-
-
-
-
-uint8_t gpi_storeMifReaderStateAndCardType(uint8_t *buf);
+uint8_t gpi_storeMifReaderStateAndCardType(uint8_t const *buf);
 
 /* data description:
 byte 0: current read state: 0=power off  1=reader-fault 2=ready
@@ -401,41 +318,24 @@ byte 32: result, always 0
 
 uint8_t epi_restoreMifState(uint8_t *buf, uint8_t maxBufferSize);
     // retval 0=OK 1=error host buffer too small
-
-void gpi_storeMifCardData(uint8_t blkNr, uint8_t *receivedData);
+bool gpi_storeMifCardData(uint8_t blkNr, uint8_t const *receivedData);
     // blkNr=0...11    receivedData[64]
-
 uint8_t epi_restoreMifData(uint8_t blkNr, uint8_t *buf, uint8_t maxBufferSize);
     // blkNr=0...11    return buf[64]
     // retval: 1=error 0=OK
 
-
-
-#define pi_prnStateArraySize    20
-#define pi_prnFontArraySize     20
-
 void epi_restorePrinterState(uint8_t *buf);
-
-void gpi_storePrinterState(uint8_t *buf);
+void gpi_storePrinterState(uint8_t const *buf);
 
 void epi_restorePrinterFonts(uint8_t *buf);
+void gpi_storePrinterFonts(uint8_t const *buf);
 
-void gpi_storePrinterFonts(uint8_t *buf);
-
-
-
-
-void gpi_storeMdbState(uint8_t busReady, uint8_t V12on, uint8_t V5on );
-
+bool gpi_storeMdbState(bool busReady, bool V12on, bool V5on);
 bool epi_restoreMdbBusReady(void);
-
 bool epi_restoreMdbV12Ready(void);
-
 bool epi_restoreMdbV5Ready(void);
 
-
-void gpi_storeMdbResponse(uint8_t leng, uint8_t *data);
-
+void gpi_storeMdbResponse(uint8_t leng, uint8_t const *data);
 void epi_restoreMdbResponse(uint8_t *leng, uint8_t *data);
     // last received mdb answer (from mdb device)
     // only needed if a special command was sent directly
@@ -444,12 +344,9 @@ void epi_restoreMdbResponse(uint8_t *leng, uint8_t *data);
     // DB2: nr of received (payload) data bytes (apart from ACK, can be 0....34)
     // DB3...DB38: rec.data (payload)
 
-
-void gpi_storeEmpSettings(uint8_t leng, uint8_t *data);
-
+void gpi_storeEmpSettings(uint8_t leng, uint8_t const *data);
 void epi_restoreEmpSettings(uint8_t *leng, uint8_t *data);
 
-
 /*
 void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t *data);
 
@@ -463,65 +360,64 @@ void epi_restoreEmpCoinSignal(uint8_t *leng, uint8_t *data);
 void epi_clearEmpCoinSignal();
 */
 
-#define     MEMDEPTH_GOTCOINS       16
 
-void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t *data);
+void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t const *data);
 
 uint8_t epi_isNewCoinLeft(void);
     // retval: 0...16 coins left in FIFO
-
 void epi_restoreEmpCoinSignal(uint8_t *valid, uint8_t *signal, uint8_t *error, uint16_t *value);
 
-
-
-void gpi_storeRbDeviceSettings(uint8_t leng, uint8_t *data);
-
+void gpi_storeRbDeviceSettings(uint8_t leng, uint8_t const *data);
 void epi_restoreRbDeviceSettings(uint8_t *leng, uint8_t *data);
 
-
-void gpi_storeMachineIDsettings(uint8_t leng, uint8_t *data);
-
+void gpi_storeMachineIDsettings(uint8_t leng, uint8_t const *data);
 void epi_restoreMachineIDsettings(uint8_t *leng, uint8_t *data);
 
-
-
-
 void epi_clearCurrentPayment(void);
-
 void gpi_storeCurrentPayment(uint32_t insertedAmount, uint16_t lastCoinType, uint16_t lastCoinValue);
 
 uint32_t epi_CurrentPaymentGetAmount(void);
-
 uint16_t epi_CurrentPaymentGetLastCoin(void);
 
 bool epi_CurrentPaymentGetAllCoins(uint16_t *types, uint16_t *values);
     // alle bei diesem Verkauf eingeworfenen Münzen sind gespeichert falls die jmd. braucht
 
-
-void gpi_storeWakeSources(uint8_t *receivedData);
-
+void gpi_storeWakeSources(uint8_t const *receivedData);
 uint64_t epi_getWakeSources(void);
+uint8_t epi_getWakeReason(void);
 
-
-
-void gpi_storeExtendedTime(uint8_t leng, uint8_t *data);
-
+void gpi_storeExtendedTime(uint8_t leng, uint8_t const *data);
 void epi_restoreExtendedTime(uint8_t *leng, uint8_t *data);
 
-
-
-void gpi_storeDeviceConditions(uint8_t leng, uint8_t *data);
-
+void gpi_storeDeviceConditions(uint8_t leng, uint8_t const *data);
 void epi_restoreDeviceConditions(uint8_t *leng, uint8_t *data);
 
-
-void gpi_storeDynMachineConditions(uint8_t leng, uint8_t *data);
-
+void gpi_storeDynMachineConditions(uint8_t leng, uint8_t const *data);
 void epi_restoreDynMachineConditions(uint8_t *leng, uint8_t *data);
 
+void gpi_storeDCbackupAccNr(uint8_t leng, uint8_t const *data);
+void epi_restoreDCbackupAccNr(uint8_t *leng, uint16_t *accNrs);
+    // return accNrs[0..7]
 
+void epi_iniVRstorage(void);
+void gpi_storeVaultRecord(uint8_t blkNr, uint8_t const *data);
+bool epi_checkIfVaultRecordAvailable(void);
+bool epi_restoreVaultRecord(uint16_t *length, uint8_t *buf);
+    // true if completly received
 
+void gpi_storeCBlevel(uint32_t amount, uint16_t nrOfCoins);
 
+uint32_t epi_getCashBoxContent(void);
+uint16_t epi_getNrOfCoinsInCashBox(void);
+
+void gpi_storeNewMifareCard(uint8_t typ, uint8_t const *holder);
+
+uint8_t epi_mifGetCardType(uint8_t const *holder);
+    //holder[8] = name of card holder
+    // retval Type of MifareCard, 1=upper door, 2=lower door 3=test printer 4=test coins
+
+void gpi_storeDcDataValid(bool isVal);
+bool gpi_areDcDataValid();
 
 
 

DCPlugin/include/tslib.h

@@ -13,6 +13,9 @@ uint32_t uchar2ulong(uint8_t Highbyte, uint8_t MHbyte, uint8_t MLbyte, uint8_t L
 
 uint8_t  uint2uchar(uint16_t uival, bool getHighB);
 
+uint8_t ulong2uchar(uint32_t ulval, uint8_t getBytNr);
+    // getBytNr: 0=LSB  3=MSB
+
 
 void delay(uint16_t MilliSec);
 

DCPlugin/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

DCPlugin/src/ATBAPP/ATBDeviceControllerPlugin.cpp

@@ -0,0 +1,293 @@
+#include "src/ATBAPP/ATBDeviceControllerPlugin.h"
+#include "src/ATBAPP/ATBHealthEvent.h"
+
+#include <QTimer>
+#include <QTextCodec>
+
+
+ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent) : QObject(parent),
+    pluginState(PLUGIN_STATE::NOT_INITIALIZED)
+{
+    this->pluginInfo = QString::fromUtf8(pluginInfoString.c_str());
+
+    this->hw = new hwapi();
+
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_OK()),  this, SLOT(onPrintFinishedOK()));
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_Err()), this, SLOT(onPrintFinishedERR()));
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_gotNewCoin()),    this, SLOT(onCashGotCoin()));
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_vendStopByMax()), this, SLOT(onCashVendStopByMax()));
+}
+
+ATBDeviceControllerPlugin::~ATBDeviceControllerPlugin() {}
+
+PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *healthEventReceiver, const QSettings & settings)
+{
+    this->healthEventReceiver = healthEventReceiver;
+
+    // read variables from setting
+    QString serialPort = settings.value("DEVICE_CONTROLLER/serialPort", "ttymxc2").toString();
+    QByteArray printerEncoding = settings.value("DEVICE_CONTROLLER/printerEnconding", "ISO 8859-2").toString().toLatin1();
+
+
+
+    // open serial port
+    hw->dc_openSerial(5, "115200", serialPort, 1);
+
+
+    // text encoding for printer
+    this->codec = QTextCodec::codecForName(printerEncoding);
+
+
+
+    this->pluginState = PLUGIN_STATE::INITIALIZED;
+
+    return pluginState;
+}
+
+
+// TASKS: Cash handling -------------------------------------------------------
+void ATBDeviceControllerPlugin::requestStartCashInput(const QString & amount)
+{
+    qCritical() << "Start Cash vending with amount = " << amount;
+
+    uint32_t amountInt = static_cast<uint32_t>(amount.toUInt());
+    hw->cash_startPayment(amountInt);
+}
+
+void ATBDeviceControllerPlugin::requestStopCashInput()
+{
+    hw->cash_stopPayment();
+}
+
+void ATBDeviceControllerPlugin::cashCollect()
+{
+    hw->vend_success();
+}
+
+void ATBDeviceControllerPlugin::cashAbort()
+{
+    hw->vend_failed();
+}
+
+
+// TASKS: printing ------------------------------------------------------------
+void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant> & printingData)
+{
+    struct T_dynDat *dynTicketData = new T_dynDat;
+    memset(dynTicketData, 0, sizeof(*dynTicketData));
+
+    qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket( "        << endl
+                << "     licenseplate = " << printingData["licenseplate"]   << endl
+                << "           amount = " << printingData["amount"]         << endl
+                << "       parkingEnd = " << printingData["parkingEnd"]     << endl
+                << "      currentTime = " << printingData["currentTime"]    << endl
+                << "      currentDate = " << printingData["currentDate"]    << endl;
+
+
+    // set dynamic printer data:
+    memcpy((char*)dynTicketData->licensePlate, codec->fromUnicode(printingData["licenseplate"].toString()).data(), 8);
+    memcpy((char*)dynTicketData->vendingPrice, codec->fromUnicode(printingData["amount"].toString()).data(), 8);
+
+    QDateTime parkingEndQDateTime = QDateTime::fromString(printingData["parkingEnd"].toString(), Qt::ISODate);
+    QDateTime currentDateTime     = QDateTime::fromString(printingData["currentTime"].toString(), Qt::ISODate);
+
+    memcpy((char*)dynTicketData->parkingEnd,   codec->fromUnicode(parkingEndQDateTime.toString("hh:mm")).data(), 8);
+    memcpy((char*)dynTicketData->currentTime,  codec->fromUnicode(currentDateTime.toString("hh:mm")).data(), 8);
+    memcpy((char*)dynTicketData->currentDate,  codec->fromUnicode(currentDateTime.toString("dd.MM.yy")).data(), 8);
+
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket()";
+
+    if (!this->hw->dc_isPortOpen()) {
+        qCritical() << "    ... serial port is not open!";
+        this->onPrintFinishedERR();
+        return;
+    }
+
+
+    // TODO: wird hier nur 'licensePlate' gedruckt?
+    if (!this->hw->prn_sendDynamicPrnValues(dynTicketData->licensePlate)) {
+        this->errorCode = "hwapi::prn_sendDynamicPrnValues";
+        this->errorDescription = "hwapi method 'hwapi::prn_sendDynamicPrnValues' result is false";
+
+        qCritical() << "ERROR:";
+        qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket( "        << endl
+                    << "     licenseplate = " << printingData["licenseplate"]   << endl
+                    << "           amount = " << printingData["amount"]         << endl
+                    << "       parkingEnd = " << printingData["parkingEnd"]     << endl
+                    << "      currentTime = " << printingData["currentTime"]    << endl
+                    << "      currentDate = " << printingData["currentDate"]    << endl;
+
+
+        this->onPrintFinishedERR();
+        return;
+    }
+
+    QTimer::singleShot(1000, this, SLOT(onPrinterDataPrepared()));
+}
+
+
+
+void ATBDeviceControllerPlugin::onPrinterDataPrepared()
+{
+    this->currentTemplate = 1;
+    this->onPrinterPrintNextTemplate();
+}
+
+
+void ATBDeviceControllerPlugin::onPrinterPrintNextTemplate()
+{
+    qCritical() << "     ... print template " << this->currentTemplate;
+
+    if (!this->hw->prn_printTemplate(this->currentTemplate)) {
+        this->errorCode = "hwapi::prn_printTemplate";
+        this->errorDescription = QString("hwapi method 'hwapi::onPrinterPrintNextTemplate(%1)' result is false").arg(this->currentTemplate);
+        this->onPrintFinishedERR();
+        return;
+    }
+
+    if (this->currentTemplate >= 3) {
+        // all templates are printed
+        this->currentTemplate = 0;
+
+        // FAKE SIGNAL:
+        QTimer::singleShot(1000, this, SLOT(onPrintFinishedOK()));
+    }
+    else {
+        // print next template
+        this->currentTemplate++;
+        QTimer::singleShot(3000, this, SLOT(onPrinterPrintNextTemplate()));
+    }
+
+}
+
+
+/************************************************************************************************
+ * private slots, interface to low level hwapi
+ *
+ */
+void ATBDeviceControllerPlugin::onPrintFinishedOK()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedOK()";
+
+    emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
+                                   "",
+                                   "");
+}
+void ATBDeviceControllerPlugin::onPrintFinishedERR()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedERR()";
+
+
+    this->errorCode = "PRINTER";               // TODO: get more detailed error code from low level API
+    this->errorDescription = "Printer error";  // TODO: get more detailed error description from low level API
+
+    emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
+                                   this->errorCode,
+                                   this->errorDescription);
+}
+
+
+
+/************************************************************************************************
+ * cash payment
+ */
+void ATBDeviceControllerPlugin::onCashGotCoin()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onGotCoin()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+
+    emit this->cashInputEvent(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
+                              nsDeviceControllerInterface::CASH_STATE::CACHE_INPUT,
+                              amountString,
+                              "",
+                              "");
+}
+
+
+void ATBDeviceControllerPlugin::onCashVendStopByMax()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashVendStopByMax()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
+                              amountString,
+                              "",
+                              "");
+
+}
+
+/************************************************************************************************
+ * Mandatory plugin methods
+ *
+ */
+
+PLUGIN_STATE ATBDeviceControllerPlugin::getState()
+{
+    return this->pluginState;
+}
+
+QString & ATBDeviceControllerPlugin::getLastError()
+{
+    return this->errorCode;
+}
+
+const QString & ATBDeviceControllerPlugin::getLastErrorDescription()
+{
+    return this->errorDescription;
+}
+
+const QString & ATBDeviceControllerPlugin::getPluginInfo()
+{
+    return this->pluginInfo;
+}
+
+
+const QString ATBDeviceControllerPlugin::getString(nsDeviceControllerInterface::RESULT_STATE resultState)
+{
+    QString str;
+
+    switch (resultState) {
+    case nsDeviceControllerInterface::RESULT_STATE::SUCCESS:
+        str = QString("RESULT_STATE::SUCCESS");
+        break;
+    case nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND:
+        str = QString("RESULT_STATE::ERROR_BACKEND");
+        break;
+    case nsDeviceControllerInterface::RESULT_STATE::ERROR_TIMEOUT:
+        str = QString("RESULT_STATE::ERROR_TIMEOUT");
+        break;
+    case nsDeviceControllerInterface::RESULT_STATE::ERROR_PROCESS:
+        str = QString("RESULT_STATE::ERROR_PROCESS");
+        break;
+    case nsDeviceControllerInterface::RESULT_STATE::ERROR_RETRY:
+        str = QString("RESULT_STATE::ERROR_RETRY");
+        break;
+    case nsDeviceControllerInterface::RESULT_STATE::INFO:
+        str = QString("RESULT_STATE::INFO");
+        break;
+    }
+    return str;
+
+}
+
+
+
+/************************************************************************************************
+ * ... end
+ */
+
+#if QT_VERSION < 0x050000
+Q_EXPORT_PLUGIN2( ATBDeviceControllerPlugin, ATBDeviceControllerPlugin )
+#endif

DCPlugin/src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -0,0 +1,125 @@
+#ifndef ATBDEVICECONTROLLERPLUGIN_H
+#define ATBDEVICECONTROLLERPLUGIN_H
+
+#include <QObject>
+
+#include "src/ATBAPP/DeviceControllerInterface.h"
+#include "src/ATBAPP/ATBAPPplugin.h"
+#include "version.h"
+
+
+
+#include "hwapi.h"
+
+#include <unistd.h>
+#include <thread>
+#include <memory>
+#include <QSharedMemory>
+
+
+class QTextCodec;
+
+
+using namespace nsDeviceControllerInterface;
+
+class QSettings;
+
+class ATBDeviceControllerPlugin : public QObject,
+        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 *healthEventReceiver, 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);
+
+    // 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);
+
+
+
+
+
+signals:
+    void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+
+    void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
+                        nsDeviceControllerInterface::CASH_STATE cashState,
+                        const QString & newCashValue,
+                        const QString & errorCode,
+                        const QString & errorDescription);
+
+    void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & newCashValue,
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+
+    void requestServiceMode();
+
+    void Error(
+            const QString & errorCode,
+            const QString & errorDescription);
+
+
+
+
+private:
+   QString errorCode;
+   QString errorDescription;
+   QString pluginInfo;
+
+   int currentTemplate;
+
+
+   bool useDebug;
+
+   PLUGIN_STATE pluginState;
+
+   QObject* healthEventReceiver;
+
+   hwinf* hw;
+
+   QTextCodec *codec;
+
+private slots:
+   // printer
+
+   void onPrinterDataPrepared();
+   void onPrinterPrintNextTemplate();
+
+   void onPrintFinishedOK();
+   void onPrintFinishedERR();
+
+   // cash payment
+   void onCashGotCoin();
+   void onCashVendStopByMax();
+};
+
+#endif // ATBDEVICECONTROLLERPLUGIN_H

DCPlugin/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;
+}

DCPlugin/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

DCPlugin/src/ATBAPP/DeviceControllerInterface.h

@@ -0,0 +1,142 @@
+#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;
+}
+
+
+class DeviceControllerInterface : public ATBAPPplugin
+{
+    Q_INTERFACES(ATBAPPplugin)
+
+public:
+    virtual ~DeviceControllerInterface() {}
+
+    virtual nsDeviceControllerInterface::PLUGIN_STATE initDCPlugin(QObject *healthEventReceiver,
+                                                                   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: printing ------------------------------------------------------------
+    virtual void requestPrintTicket(const QHash<QString, QVariant> & printingData) = 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;
+
+
+signals:
+    virtual void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & errorCode,
+                                     const QString & errorDescription) = 0;
+
+    /**
+     * emitted on e.g. a coin input
+     */
+    virtual void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                nsDeviceControllerInterface::CASH_STATE cashState,
+                                const QString & newCashValue,
+                                /* additional variables? */
+                                const QString & errorCode,
+                                const QString & errorDescription) = 0;
+
+    /**
+     * 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
+     */
+    virtual void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & newCashValue,
+                                     /*  additional variables? */
+                                     const QString & errorCode,
+                                     const QString & errorDescription) = 0;
+
+
+    /**
+     * emitted e.g. if service door is opened
+     */
+    virtual void requestServiceMode() = 0;
+
+    /**
+     * emitted on error
+     * depending on errorCode:
+     * -> interrupt selling process
+     * -> machine can go to state OOO
+     * -> send error event to ISMAS
+     * -> ...
+     */
+    virtual void Error(
+            /*  additional variables? */
+            const QString & errorCode,
+            const QString & errorDescription) = 0;
+
+};
+
+
+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. */
+    };
+}
+
+#endif // DEVICECONTROLLERINTERFACE_H

DCPlugin/src/controlBus.cpp

@@ -1,141 +1,110 @@
 #include <stdint.h>
+#include <algorithm>
+
 #include <QString>
 #include <QDebug>
 #include "tslib.h"
-//#include "controlBus.h"
+#include "shared_mem_buffer.h"
 
 // ///////////////////////////////////////////////////////////////////////////////////
 //          control serial interface   gui <--> serial
 // ///////////////////////////////////////////////////////////////////////////////////
+void epi_setSerial(int BaudNr,
+                   QString BaudStr,
+                   QString ComName,
+                   uint8_t connect) {
+    memset(&SharedMemBuffer::getData()->rs.comportName[0], 0x00,
+           sizeof(SharedMemBuffer::getData()->rs.comportName));
+    strncpy(SharedMemBuffer::getData()->rs.comportName,
+            ComName.toStdString().c_str(),
+            sizeof(SharedMemBuffer::getData()->rs.comportName)-1);
 
-static QString    rs_comportName;   // z.B. "COM48"
-static QString    rs_baudStr;       // z.B. "19200"
-static int        rs_baudNr;        //0...5 oder -1
-static uint8_t    rs_connect;       // 0,1
+    memset(&SharedMemBuffer::getData()->rs.baudStr[0], 0x00,
+           sizeof(SharedMemBuffer::getData()->rs.baudStr));
+    strncpy(SharedMemBuffer::getData()->rs.baudStr,
+            BaudStr.toStdString().c_str(),
+            sizeof(SharedMemBuffer::getData()->rs.baudStr)-1);
 
-void epi_setSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect)
-{
-//    qDebug() << "ENTER" << BaudNr << BaudStr << ComName << connect;
-
-    rs_comportName = ComName;
-    rs_baudStr     = BaudStr;
-    rs_baudNr      = BaudNr;    // 0=1200  1=9600  2=19200  3=38400  4=57600  5=115200  oder -1
-    rs_connect     = connect;     // 0/1
-
-//    qDebug() << "LEAVE" << rs_baudNr << rs_baudStr << rs_comportName << rs_connect;
+    SharedMemBuffer::getData()->rs.baudNr = BaudNr;
+    SharedMemBuffer::getData()->rs.connect = connect;
 }
 
-void epi_closeSerial(void)
-{
-    rs_connect=0;
-//    qDebug() << "ENTER/LEAVE rc_connect=0";
+void epi_closeSerial(void) {
+    SharedMemBuffer::getData()->rs.connect = 0;
 }
 
-
-void gpi_serialChanged(void)
-{
+void gpi_serialChanged(void) {
     // serial confirms that port was closed or opened
-    rs_connect=2;   // Flanke, nur 1x öffnen/schließen
-    //qDebug() << "ENTER/LEAVE rc_connect=2";
+    // rs_connect=2;   // Flanke, nur 1x öffnen/schließen
+    SharedMemBuffer::getData()->rs.connect = 2;
 }
 
-uint8_t gpi_getSerialConn(void)
-{
-    return rs_connect;
+uint8_t gpi_getSerialConn(void) {
+    return SharedMemBuffer::getDataConst()->rs.connect;
 }
 
-
-int gpi_getBaudNr(void)
-{
-    return rs_baudNr;
+int gpi_getBaudNr(void) {
+    return SharedMemBuffer::getDataConst()->rs.baudNr;
 }
 
-QString gpi_getComPortName(void)
-{
-    return rs_comportName;
+QString gpi_getComPortName(void) {
+    return SharedMemBuffer::getDataConst()->rs.comportName;
 }
 
-static bool rs_portIsOpen;
-
-void gpi_serialIsOpen(bool offen)
-{
-    //qDebug() << "ENTER/LEAVE offen=" << offen;
-    rs_portIsOpen=offen;
+void gpi_serialIsOpen(bool offen) {
+    SharedMemBuffer::getData()->rs.portIsOpen = offen;
 }
 
-bool epi_isSerialPortOpen()
-{
+bool epi_isSerialPortOpen() {
     // true: port is open   false: port is closed
-    //qDebug() << "ENTER/LEAVE offen=" << rs_portIsOpen;
-    return rs_portIsOpen;
+    return SharedMemBuffer::getDataConst()->rs.portIsOpen;
 }
 
 // ///////////////////////////////////////////////////////////////////////////////////
 //          Control transfer   gui <--> serial
 // ///////////////////////////////////////////////////////////////////////////////////
 
-
-static char       AutoEmissionOn;     // 1: zyklisch Anfragen zum Slave senden
-
-void epi_startEmmision(char start)
-{
-    AutoEmissionOn=start;
+void epi_startEmmision(char start) {
+    SharedMemBuffer::getData()->AutoEmissionOn = start;
 }
 
-bool gpi_isEmmisionOn(void)
-{
-    return AutoEmissionOn;
+bool gpi_isEmmisionOn(void) {
+    return SharedMemBuffer::getDataConst()->AutoEmissionOn;
 }
 
-//-----------------------------------------------------
-
-static uint16_t datif_sendingPeriod;
-static bool     datif_sendingPer_changed;
-
-uint16_t gpi_getPeriodicSendTimeVal()
-{
-    datif_sendingPer_changed=0;
-    if (datif_sendingPeriod<3 || datif_sendingPeriod>10000)
+uint16_t gpi_getPeriodicSendTimeVal() {
+    SharedMemBuffer::getData()->datif.sendingPer_changed = 0;
+    if ((SharedMemBuffer::getDataConst()->datif.sendingPeriod < 3) ||
+        (SharedMemBuffer::getDataConst()->datif.sendingPeriod > 10000)) {
         return 130;         // ms, default
-    else
-        return datif_sendingPeriod;
+    }
+    return SharedMemBuffer::getDataConst()->datif.sendingPeriod;
 }
 
-void epi_setPeriodicSendTimeVal(uint16_t val)
-{
-    if (val>=3 && val<10000)
-    {
-        datif_sendingPer_changed=1;
-        datif_sendingPeriod=val;
+void epi_setPeriodicSendTimeVal(uint16_t val) {
+    if (val>=3 && val<10000) {
+        SharedMemBuffer::getData()->datif.sendingPer_changed = 1;
+        SharedMemBuffer::getData()->datif.sendingPeriod = val;
     }
 }
 
-bool gpi_PeriodicSendTimeHasChanged()
-{
-    return datif_sendingPer_changed;
+bool gpi_PeriodicSendTimeHasChanged() {
+    return SharedMemBuffer::getDataConst()->datif.sendingPer_changed;
 }
 
-//-----------------------------------------------------
-
-
-//-----------------------------------------------------
-
 // ///////////////////////////////////////////////////////////////////////////////////
 //          Status Display    gui <--> serial
 // ///////////////////////////////////////////////////////////////////////////////////
 
-
 //              linke Spalte, über Connect Button
 static QString txt4comStateLine;
 
-QString epi_getTxt4comStateLine(void)
-{
+QString epi_getTxt4comStateLine(void) {
     // GUI: get Text for serial Comport-State Line
     return txt4comStateLine;
 }
 
-void gpi_setTxt4comStateLine(QString txtline)     // gpi
-{
+void gpi_setTxt4comStateLine(QString txtline) {
     // serial: write Text to be displayed in serial Comport-State line (like "connected")
     txt4comStateLine.clear();
     if (txtline=="")
@@ -144,26 +113,20 @@ void gpi_setTxt4comStateLine(QString txtline)     // gpi
         txt4comStateLine=txtline;
 }
 
-void epi_clrTxt4comStateLine()
-{
+void epi_clrTxt4comStateLine() {
     txt4comStateLine.clear();
 }
 
-
-//---------------------------------------------------------------------------------------------
-
 // rechte Spalte, oberste Statuszeile
 // I) "Handshakes" (serial Control)   flow.cpp
 // geht überhaupt was raus? kommt überhaupt was zurück?
 static QString txt4HsStateLine;
 
-QString epi_getTxt4HsStateLine(void)
-{
+QString epi_getTxt4HsStateLine(void) {
     return txt4HsStateLine;
 }
 
-void gpi_setTxt4HsStateLine(QString txtline)
-{
+void gpi_setTxt4HsStateLine(QString txtline) {
     txt4HsStateLine.clear();
     if (txtline=="")
         txt4HsStateLine.clear();
@@ -171,26 +134,19 @@ void gpi_setTxt4HsStateLine(QString txtline)
         txt4HsStateLine=txtline;
 }
 
-void epi_clrTxt4HsStateLine()
-{
+void epi_clrTxt4HsStateLine() {
     txt4HsStateLine.clear();
 }
 
-
-
-//---------------------------------------------------------------------------------------------
-
 // II) Master receive state (empfangenes Telgramm OK? crc? length?  )
 // Statuszeile Auswertung der SlaveResponse (serial Frame, CRC usw)  (prot.cpp)
 static QString txt4masterStateLine;
 
-QString epi_getTxt4masterStateLine(void)
-{
+QString epi_getTxt4masterStateLine(void) {
     return txt4masterStateLine;
 }
 
-void gpi_setTxt4masterStateLine(QString txtline)
-{
+void gpi_setTxt4masterStateLine(QString txtline) {
     txt4masterStateLine.clear();
     if (txtline=="")
         txt4masterStateLine.clear();
@@ -198,13 +154,10 @@ void gpi_setTxt4masterStateLine(QString txtline)
         txt4masterStateLine=txtline;
 }
 
-void epi_clrTxt4masterStateLine()
-{
+void epi_clrTxt4masterStateLine() {
     txt4masterStateLine.clear();
 }
 
-
-
 //---------------------------------------------------------------------------------------------
 
 // III   Slave receive (from Master) OK? if then show results, if not then show errors
@@ -214,13 +167,11 @@ void epi_clrTxt4masterStateLine()
 
 static QString txt4resultStateLine;
 
-QString epi_getTxt4resultStateLine(void)
-{
+QString epi_getTxt4resultStateLine(void) {
     return txt4resultStateLine;
 }
 
-void gpi_setTxt4resultStateLine(QString txtline)
-{
+void gpi_setTxt4resultStateLine(QString txtline) {
     txt4resultStateLine.clear();
     if (txtline=="")
         txt4resultStateLine.clear();
@@ -228,26 +179,22 @@ void gpi_setTxt4resultStateLine(QString txtline)
         txt4resultStateLine=txtline;
 }
 
-void epi_clrTxt4resultStateLine()
-{
+void epi_clrTxt4resultStateLine() {
     txt4resultStateLine.clear();
 }
 
-
 //---------------------------------------------------------------------------------------------
 
 // IV  Statuszeile Empfangsdaten
 static QString txt4dataLine;
 
-QString epi_getTxt4dataStateLine(void)
-{
+QString epi_getTxt4dataStateLine(void) {
     // GUI: get Text for serial Comport-State Line
     return txt4dataLine;
 
 }
 
-void gpi_setTxt4dataStateLine(QString txtline)
-{
+void gpi_setTxt4dataStateLine(QString txtline) {
     // serial: write Text to be displayed in serial Comport-State line (like "connected")
     txt4dataLine.clear();
     if (txtline=="")
@@ -256,8 +203,7 @@ void gpi_setTxt4dataStateLine(QString txtline)
         txt4dataLine=txtline;
 }
 
-void epi_clrTxt4dataStateLine()
-{
+void epi_clrTxt4dataStateLine() {
     txt4dataLine.clear();
 }
 
@@ -267,16 +213,11 @@ void epi_clrTxt4dataStateLine()
 
 static QString txt4datifReceive;
 
-QString epi_getTxt4datifLine(void)
-{
-
+QString epi_getTxt4datifLine(void) {
     return txt4datifReceive;
-
 }
 
-void gpi_setTxt4datifLine(QString txtline)
-{
-
+void gpi_setTxt4datifLine(QString txtline) {
     txt4datifReceive.clear();
     if (txtline=="")
         txt4datifReceive.clear();
@@ -284,8 +225,7 @@ void gpi_setTxt4datifLine(QString txtline)
         txt4datifReceive=txtline;
 }
 
-void epi_clrTxt4datifLine()
-{
+void epi_clrTxt4datifLine() {
     txt4datifReceive.clear();
 }
 
@@ -294,14 +234,11 @@ void epi_clrTxt4datifLine()
 
 static QString txt4diagWindow;
 
-QString epi_getTxt4RsDiagWin(void)
-{
+QString epi_getTxt4RsDiagWin(void) {
     return txt4diagWindow;
-
 }
 
-void gpi_setTxt4RsDiagWin(QString txtline)
-{
+void gpi_setTxt4RsDiagWin(QString txtline) {
     txt4diagWindow.clear();
     if (txtline=="")
         txt4diagWindow.clear();
@@ -309,8 +246,7 @@ void gpi_setTxt4RsDiagWin(QString txtline)
         txt4diagWindow=txtline;
 }
 
-void epi_clrTxt4RsDiagWin()
-{
+void epi_clrTxt4RsDiagWin() {
     txt4diagWindow.clear();
 }
 
@@ -318,14 +254,11 @@ void epi_clrTxt4RsDiagWin()
 
 static QString sndTxt4diagWindow;
 
-QString epi_get2ndTxt4RsDiagWin(void)
-{
+QString epi_get2ndTxt4RsDiagWin(void) {
     return sndTxt4diagWindow;
-
 }
 
-void gpi_set2ndTxt4RsDiagWin(QString txtline)
-{
+void gpi_set2ndTxt4RsDiagWin(QString txtline) {
     sndTxt4diagWindow.clear();
     if (txtline=="")
         sndTxt4diagWindow.clear();
@@ -333,90 +266,61 @@ void gpi_set2ndTxt4RsDiagWin(QString txtline)
         sndTxt4diagWindow=txtline;
 }
 
-void epi_clr2ndTxt4RsDiagWin()
-{
+void epi_clr2ndTxt4RsDiagWin() {
     sndTxt4diagWindow.clear();
 }
 
 // ///////////////////////////////////////////////////////////////////////////////////
 //          Memory for Slave responses, common data
 // ///////////////////////////////////////////////////////////////////////////////////
-
-
-static bool Sdata_serialTestResult;
-
-void gpi_storeResult_serialTestOK(bool wasOk)
-{
-    Sdata_serialTestResult=wasOk;
+void gpi_storeResult_serialTestOK(bool wasOk) {
+    SharedMemBuffer::getData()->Sdata.serialTestResult = wasOk;
 }
 
-bool epi_getResult_serialTestOK()
-{
+bool epi_getResult_serialTestOK() {
     // retval: true: test was successful, got right response
-    return Sdata_serialTestResult;
+    return SharedMemBuffer::getDataConst()->Sdata.serialTestResult;
 }
 
-
-
 // ///////////////////////////////////////////////////////////////////////////////////
 //          Store received data for hwapi
 // ///////////////////////////////////////////////////////////////////////////////////
-
-
-
-static uint8_t Sdata_pProtResultOk;
-
-void gpi_startNewRequest()
-{
-    Sdata_pProtResultOk=0;
+void gpi_startNewRequest() {
+    SharedMemBuffer::getData()->Sdata.pProtResultOk = 0;
 }
 
-void gpi_storeResultOfLastRequest(bool answisok)
-{
-    if (answisok)
-        Sdata_pProtResultOk=1;
-    else
-        Sdata_pProtResultOk=2;
+void gpi_storeResultOfLastRequest(bool answisok) {
+    SharedMemBuffer::getData()->Sdata.pProtResultOk = answisok ? 1 : 2;
 }
 
-uint8_t epi_getResultOfLastRequest()
-{
+uint8_t epi_getResultOfLastRequest() {
     // retval: 0: in progress  1: OK  2: error
-    return Sdata_pProtResultOk;
+    return SharedMemBuffer::getDataConst()->Sdata.pProtResultOk;
 }
 
-
-
-
-static uint16_t Sdata_receivedDataLength;
-static uint8_t Sdata_receivedDataBlock[64];
-
-void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t *receivedData)
-{
-    Sdata_receivedDataLength=uint16_t(RdDlen);
-    if (Sdata_receivedDataLength>64)
-        Sdata_receivedDataLength=64;
-    tslib_strclr(Sdata_receivedDataBlock,0,64);
-    tslib_strcpy(receivedData, Sdata_receivedDataBlock, Sdata_receivedDataLength);
-
+void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t const *receivedData) {
+    SharedMemBuffer::getData()->Sdata.receivedDataLength
+        = std::min(RdDlen, (uint8_t)(64));
+    memset((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
+           0x00, sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock));
+    strncpy((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
+            (char const *)receivedData,
+            sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock)-1);
 }
 
-uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad)
-{
+uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad) {
     // get data back in *pl, max 64 byte
     // retval = nr of bytes received. If host buffer too small then
     // only plBufSíz bytes are copied to pl
     // plBufSíz=size of host buffer
 
-    uint16_t ml=plBufSiz;
-    if (ml>64) ml=64;
-    if (Sdata_receivedDataLength<ml)
-        ml=Sdata_receivedDataLength;
-    tslib_strcpy(Sdata_receivedDataBlock, payLoad, ml);
-    return Sdata_receivedDataLength;
+    uint16_t ml = std::min(plBufSiz, (uint16_t)(64));
+    if (SharedMemBuffer::getDataConst()->Sdata.receivedDataLength < ml) {
+        ml = SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
+    }
+    strncpy((char *)payLoad,
+            (char const *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
+            ml);
+
+    return SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
 }
-
-
-
-
-

DCPlugin/src/datIf.cpp

@@ -17,6 +17,8 @@ static uint16_t datif_OutCmdpara5;
 static uint32_t datif_OutCmdpara6;
 static uint8_t cycl_running;
 
+//static bool     datif_DCdataValid;
+
 T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
 {
 
@@ -46,6 +48,8 @@ T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
     dif_scanStep=0;
     selectedSlaveAddr=FIX_SLAVE_ADDR;
     cycl_running=0;
+    //datif_DCdataValid=0;
+    gpi_storeDcDataValid(0);
 }
 
 void T_datif::resetChain(void)
@@ -863,6 +867,11 @@ char T_datif::loadRecDataFromFrame()
     //int portNr;
     bool ret;
     uint8_t uctmp;      // maxai
+    char ctmp;
+    static uint8_t lastResult;
+    uint8_t prnResult;
+    static uint32_t lastInsertedAmount;
+    uint32_t newInsertedAmount;
 
     ret=myDCIF->getReceivedInData(&SlaveAdr, &readSource, &readAddress,  &RdDleng, receivedData);
         // retval: data valid, only one time true, true if CommandState OK and readState OK
@@ -902,7 +911,8 @@ char T_datif::loadRecDataFromFrame()
 
     for (int ii=0; ii<RdDleng; ii++)
     {
-        localStr.append(receivedData[ii]);
+        ctmp=receivedData[ii];
+        localStr.append(ctmp);
     }
 
     //qDebug() << "got HW version: " << localStr;
@@ -936,7 +946,7 @@ char T_datif::loadRecDataFromFrame()
 
         case CMD2DC_RdBkDCstate:                            //101
             //qDebug() << "got DC state " << localStr;
-            localStr[8]=0;
+            //localStr[8]=0;
             gpi_storeGenerals(2, localStr);
                 // 0=HW   1=SW  2=State
             break;
@@ -1112,7 +1122,9 @@ char T_datif::loadRecDataFromFrame()
     case CMD2DC_RdBk_MifState:          //109
         // get reader status and card type
 
-        gpi_storeMifReaderStateAndCardType(receivedData);
+        //gpi_storeMifReaderStateAndCardType(receivedData);
+        gpi_storeNewMifareCard(receivedData[0], &receivedData[1]);
+
         break;
 
     case CMD2DC_RdBk_MifData:           //24
@@ -1216,7 +1228,7 @@ char T_datif::loadRecDataFromFrame()
 
 
 
-// ab hier neu:    XXX
+// ab hier neu:    12.4.23
 
     case CMD2DC_RDBK_DEV_PARA:      //14
 /*
@@ -1350,10 +1362,16 @@ char T_datif::loadRecDataFromFrame()
 
     case 112:       // get inserted amount in cent in sum
         // byte 0..3: amount just paid   4,5:last coin type  6,7: last coin value
-        ultmp=uchar2ulong(receivedData[3],receivedData[2],receivedData[1],receivedData[0]);
+        newInsertedAmount=uchar2ulong(receivedData[3],receivedData[2],receivedData[1],receivedData[0]);
         uitmp=uchar2uint(receivedData[5],receivedData[4]);
         uit2=uchar2uint(receivedData[7],receivedData[6]);
-        gpi_storeCurrentPayment(ultmp, uitmp, uit2);
+        gpi_storeCurrentPayment(newInsertedAmount, uitmp, uit2);
+        if (newInsertedAmount != lastInsertedAmount)
+        {
+            emit datif_gotNewCoin();
+            lastInsertedAmount=newInsertedAmount;
+        }
+
         break;
 
     case 113:       // get wake source, 8byte
@@ -1464,18 +1482,40 @@ char T_datif::loadRecDataFromFrame()
 
 */
 
+        if (RdDleng>40)
+            //datif_DCdataValid=1;    // das hier sind die wichtigsten Daten, deshalb hierrein!
+            gpi_storeDcDataValid(1);
+
         gpi_storeDynMachineConditions(RdDleng, receivedData);
+
+        prnResult=receivedData[52];
+        if (prnResult != lastResult)
+        {
+            // new result
+            if (prnResult==1)
+            {
+                emit datif_templatePrintFinished_OK();
+            } else
+            if (prnResult==2)
+            {
+                emit datif_templatePrintFinished_Err();
+            }
+
+            lastResult=prnResult;
+        }
+
         break;
 
     case 32:        // Get current cash level (in vault)
                     // bytes 0..3: amount   bytes 4,5=Nr.ofCoins in vault
-
+        ultmp=uchar2ulong(receivedData[3],receivedData[2],receivedData[1],receivedData[0]);
+        uitmp=uchar2uint(receivedData[5],receivedData[4]);
+        gpi_storeCBlevel(ultmp, uitmp);
         break;
 
     case 33:        // Get all backuped acc. Numbers
                     // 8 UINTs with acc-nr
-
-
+        gpi_storeDCbackupAccNr(RdDleng, receivedData);
         break;
 
     case 38:        // Get stored account record backup
@@ -1541,7 +1581,8 @@ struct T_vaultRecord
     UCHAR endofblock[4];	// end>
 // 316 byte Block im Speicher
 */
-
+        // readAddress,  &RdDleng, receivedData
+        gpi_storeVaultRecord(readAddress, receivedData );   // always 64byte
         break;
 
     }
@@ -1644,11 +1685,15 @@ bool T_datif::verifyLineTestresponse(uint8_t RdDlen, uint8_t *receivedData)
     if (RdDlen < 16)
         return false;
     QString myStr;
+    char ctmp;
+
     myStr.clear();
     myStr.append("< Slave Response");
 
     for (int nn=0; nn<16; nn++)
-        if (myStr[nn] !=receivedData[nn])
+    {
+        ctmp=receivedData[nn];
+        if (myStr[nn] != ctmp)
         {
             //qDebug() << " datif cmd 10: got wrong string ";
             //qDebug() << myStr;
@@ -1656,6 +1701,7 @@ bool T_datif::verifyLineTestresponse(uint8_t RdDlen, uint8_t *receivedData)
             //qDebug() << nn;
             return false;
         }
+    }
     return true;
 }
 

DCPlugin/src/hwChk.cpp

@@ -0,0 +1,25 @@
+
+#include <stdint.h>
+#include "hwChk.h"
+
+
+hwChk::hwChk(QWidget *parent) : QObject(parent)
+{
+
+//    myDCIF = new T_prot();
+// h: T_prot *myDCIF;
+
+    //myDatif = new T_datif();
+    HWaccess = new hwinf();
+
+    struct T_moduleCondition dcModCond;
+    sys_getDeviceConditions(dcModCond);
+
+
+}
+
+hwChk::~hwChk()
+{
+
+}
+

DCPlugin/src/hwapi.cpp

@@ -21,29 +21,64 @@
 #include "controlBus.h"
 #include "storeINdata.h"
 #include "dcBL.h"
+#include "shared_mem_buffer.h"
 #include <QDebug>
-#include <../plugins/interfaces.h>
+#include <QSharedMemory>
+#include "interfaces.h"
 
+static uint32_t hwapi_lastStartAmount;
 
 static const QMap<QString, int> baudrateMap = {
   {"1200"   ,   0}, {"9600"   ,   1}, {"19200"  ,   2}, {"38400"  ,   3},
   {"57600"  ,   4}, {"115200" ,   5}
 };
 
-hwapi::hwapi(QWidget *parent) : QObject(parent)
-{
-    // constructor
-    //epi_resetAllDOs();
-    //PI_INI();
+hwapi::hwapi(QObject *parent) : QObject(parent) {
+    // create or attach shared memory segment
+    // !!! The compoment creating the shared memory MUST be ATBQT !!!
+    m_sharedMem = SharedMemBuffer::getShm(sizeof(SharedMemBuffer));
+    if (m_sharedMem) {
+        if (m_sharedMem->isAttached()) {
+            qInfo() << "Shared memory ("
+                    << sizeof(SharedMemBuffer) << "bytes) created and attached";
+        }
+    } else {
+        qCritical() << "Creating/attaching shared memory failed";
+    }
     sendWRcmd_INI();
-
     myDatif = new T_datif();
+
+    connect(myDatif, SIGNAL(datif_templatePrintFinished_OK()), this, SLOT(hwapi_slotPrintFinished_OK()));
+    connect(myDatif, SIGNAL(datif_templatePrintFinished_Err()), this, SLOT(hwapi_slotPrintFinished_Err()));
+    connect(myDatif, SIGNAL(datif_gotNewCoin()), this, SLOT(hwapi_slotGotCoin()));
 }
 
+hwapi::~hwapi() {
+    if (m_sharedMem && m_sharedMem->isAttached()) {
+        m_sharedMem->detach();
+    }
+}
 
+void hwapi::hwapi_slotPrintFinished_OK(void) {
+    emit hwapi_templatePrintFinished_OK();
+}
 
-void hwapi::sub_storeSendingText(QByteArray *buf) const
-{
+void hwapi::hwapi_slotPrintFinished_Err(void) {
+    emit hwapi_templatePrintFinished_Err();
+}
+
+void hwapi::hwapi_slotGotCoin(void) {
+    // new coin was inserted while transaction and new amount reported:
+    emit hwapi_gotNewCoin();
+
+    uint32_t newSum=epi_CurrentPaymentGetAmount();
+
+    if (newSum>=hwapi_lastStartAmount)
+        emit hwapi_vendStopByMax();
+
+}
+
+void hwapi::sub_storeSendingText(QByteArray *buf) const {
 
     char local[70], copie[1350];    // 64byte more then max buffer size!
     int LL, nn, len, maxruns=20;
@@ -133,6 +168,22 @@ bool hwapi::dc_openSerial(int BaudNr, QString BaudStr,
     return false;
 }
 
+QStringList hwapi::dc_getStatus() const {
+    QStringList status;
+
+    if (m_sharedMem) {
+        SharedMemBuffer const *shMem = SharedMemBuffer::getDataConst();
+        status += QString("comport  : %1").arg(shMem->rs.comportName);
+        status += QString("baudrate : %1").arg(shMem->rs.baudNr);
+        status += QString("baudNr   : %1").arg(shMem->rs.baudStr);
+        status += QString("connect  : %1").arg(shMem->rs.connect);
+        status += QString("port open: %1").arg(shMem->rs.portIsOpen);
+        // to be continued
+    }
+
+    return status;
+}
+
 bool hwapi::dc_closeSerial(void) const {
     epi_closeSerial();
     for (int i = 0; i < 10; ++i) {
@@ -438,16 +489,20 @@ bool hwapi::dc_updatePrinterTemplate(enum FileTypeJson type,
 
     qDebug() << "updating: " << fnames << br << serial << "...";
 
+    if (!serial.isNull()) {
         if (!openSerial(baudrateMap.value(br), br, serial)) {
             return false;
         }
+    }
 
     int nTry = 50;
     while (!sys_ready4sending()) { // wait max. 5 seconds
         std::this_thread::sleep_for(std::chrono::milliseconds(100));
         if (--nTry <= 0) {
             qCritical() << "sys not ready for sending";
+            if (!serial.isNull()) {
                 closeSerial(serial);
+            }
             return false;
         }
     }
@@ -471,7 +526,9 @@ bool hwapi::dc_updatePrinterTemplate(enum FileTypeJson type,
             continue;
         }
     }
+    if (!serial.isNull()) {
         closeSerial(serial);
+    }
     return ret;
 }
 
@@ -496,31 +553,52 @@ bool hwapi::dc_printTemplate(enum FileTypeJson type,
 
     qDebug() << "printing: " << templateIdx << br << serial << "...";
 
+    if (!serial.isNull()) {
         if (!openSerial(baudrateMap.value(br), br, serial)) {
             return false;
         }
+    }
 
     int nTry = 50;
     while (!sys_ready4sending()) { // wait max. 5 seconds
         std::this_thread::sleep_for(std::chrono::milliseconds(100));
         if (--nTry <= 0) {
             qCritical() << "sys not ready for sending";
+            if (!serial.isNull()) {
                 closeSerial(serial);
+            }
             return false;
         }
     }
 
     bool ret = true;
+    struct T_dynDat dynTicketData;
+    memset (&dynTicketData, 0x00, sizeof(dynTicketData));
+
+    // lassen sich auch veraendern
+    memcpy(&dynTicketData.licensePlate[0], "WEN1230", 8);
+    memcpy(&dynTicketData.vendingPrice[0], "1234", 8);
+    memcpy(&dynTicketData.parkingEnd[0], "12:00:00", 8);
+    memcpy(&dynTicketData.currentTime[0], "14:15:00", 8);
+    memcpy(&dynTicketData.currentDate[0], "01.01.2023", 8);
+
     for (int i = 0; i < templateIdx.size(); ++i) {
+        // dynamische Daten werden gespeichert
+        if (prn_sendDynamicPrnValues(&dynTicketData.licensePlate[0])) {
+            // angabe welches template beim drucken benutzt werden soll
+            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
             if (prn_printTemplate(templateIdx[i])) {
                 qDebug() << "printing template" << templateIdx[i];
                 std::this_thread::sleep_for(std::chrono::seconds(3));
+            }
         } else {
             ret = false;
             continue;
         }
     }
+    if (!serial.isNull()) {
         closeSerial(serial);
+    }
     return ret;
 
 }
@@ -727,13 +805,16 @@ QString hwapi::rtc_getTimStr() const
 {
     uint8_t hh,  mm,  ss, buf[20], nn;
     QString qbuf;
-
+    char ctmp;
     qbuf.clear();
     for (nn=0; nn<20; nn++) buf[nn]=0;
     epi_getTime(&hh, &mm, &ss);
     GetTimeString(hh, mm, ss, HourSys24h, MITSEK, buf); // about 12byte long
-    for (nn=0; nn<20; nn++) qbuf[nn]=buf[nn];
-
+    for (nn=0; nn<20; nn++)
+    {
+        ctmp=buf[nn];
+        qbuf[nn]=ctmp;
+    }
     return qbuf;
 }
 
@@ -741,14 +822,17 @@ QString hwapi::rtc_getDatStr() const
 {
     uint8_t day,  month,  year, buf[20], nn;
     QString qbuf;
+    char ctmp;
 
     qbuf.clear();
     for (nn=0; nn<20; nn++) buf[nn]=0;
     epi_getDate(&year, &month, &day);
     GetDateString(day, month, 0x20, year, DateFormatDeutsch, 0, buf);
     for (nn=0; nn<20; nn++)
-        qbuf[nn]=buf[nn];
-
+    {
+        ctmp=  buf[nn];
+        qbuf[nn]=ctmp;
+    }
     return qbuf;
 }
 
@@ -1567,20 +1651,6 @@ uint8_t hwapi::coin_escrowFlapOpened(void) const
 
 
 
-
-
-
-
-
-// ------------------------------------------------------------------------------
-// Level4   devices are operated by DC
-//          processes with more then one devices
-//          timer controlled or long term processes
-// ------------------------------------------------------------------------------
-
-
-
-
 void hwapi::sendDeviceSettings(uint8_t kindOfPrinter, uint8_t kindOfCoinChecker,
                                uint8_t kindOfMifareReader, uint8_t suppressSleep,
                                uint8_t kindOfModem, uint8_t kindOfCredit) const
@@ -2209,7 +2279,8 @@ bool hwapi::pri_TD_addText(QByteArray text) const
 
 bool hwapi::pri_TD_addValue(int val) const
 {
-    QString  tmpStr;
+//    QString  tmpStr;
+    QByteArray  tmpStr;
     tmpStr.setNum(val,10);      // up to 12 chars
     if (ticketTemplate.length()>1266)
         return false;
@@ -3059,7 +3130,7 @@ bool hwapi::bl_isUp(void) const
 }
 
 
-void hwapi::bl_sendAddress(u_int16_t blockNumber) const
+void hwapi::bl_sendAddress(uint16_t blockNumber) const
 {
     // send start address, nr of 64byte-block, start with 0
     // will be sent only for folling block-numbers:
@@ -3094,7 +3165,7 @@ void hwapi::bl_openBinary(void) const
     dcBL_loadBinary(0);
 }
 
-void hwapi::bl_sendDataBlock(uint8_t length, u_int8_t *buffer) const
+void hwapi::bl_sendDataBlock(uint8_t length, uint8_t *buffer) const
 {
     // send 64 byte from bin file
     uint8_t LL=length, sendBuf[80], sendLen;
@@ -3125,6 +3196,7 @@ void hwapi::bl_sendLastBlock(void) const
 
     len=dcBL_writeLastPage(buf);
     sendWRcmd_setSendBlock160(len, buf);
+
 }
 
 uint8_t hwapi::bl_wasSendingDataOK(void) const
@@ -3297,6 +3369,60 @@ bool hwapi::rtc_getExtendedTime(uint8_t *leng, uint8_t *data) const
 
 }
 
+bool hwapi::rtc_getExtendedTime(struct T_extTime *exTime) const
+{
+    uint8_t len;
+    uint16_t LL, nn;
+    uint8_t *start;
+    uint8_t  buf[66];
+
+    epi_restoreExtendedTime(&len, buf);
+        // Puffer in struct eintragen:
+    LL=sizeof(struct T_extTime);
+    start = &(exTime->Hours);
+    nn=0;
+    do
+    {
+        *start = buf[nn];
+        start++;
+    } while(++nn<LL);
+
+    return true;
+
+
+/*
+struct T_extTime
+{
+    uint8_t     Hours;
+    uint8_t     Min;
+    uint8_t     Sec;
+    uint8_t     Year;
+    uint8_t     Month;
+    uint8_t     Day;
+    uint8_t     DOW;
+    uint8_t     res1;
+    uint16_t    MinOfDay;
+    uint16_t    res2;
+    uint32_t    SecOfDay;
+    uint8_t     isLeapYear;
+    uint8_t     nxtLeapYear;
+    uint8_t     lastLeapYear;
+    uint8_t     hoursOfThisWeek;
+    uint16_t    minutesOfThisWeek;
+    uint16_t    hoursOfThisMonth;
+    uint16_t    daysOfThisYear;
+    uint16_t    GetHoursOfYear;
+    uint16_t    res3;
+    uint32_t    GetMinutesOfYear;
+    uint8_t     getWakeIntvSec;
+    uint8_t     res4;
+    uint16_t    res5;
+    uint32_t    MinutesOfMillenium;
+};
+*/
+
+}
+
 bool hwapi::sys_runCompleteTest(void) const
 {
     // warning: lasts 20s in one pace
@@ -3308,9 +3434,8 @@ bool hwapi::sys_ready4sending(void) const
     // return true if a Json-file can be sent
 
     // check free memory
-    uint8_t frei=FDLONG_STACKDEPTH - check4FDlongCmd();
+    uint8_t frei=check4freeFDlongCmd();
         // Command-Stack sollte 16 Commands fassen, je 64byte Nutzdaten = 1024byte
-        // in check4FDlongCmd() steht wieviele Plaetze bereits belegt sind
         // frei gibt also die Anzahl freier 64byte Bloecke zurueck
         // das Json-File hat max 800 byte = 13 bloecke
     if (frei<16)        // Puffer muss ganz leer sein! nicht dass was durcheinander kommt
@@ -3345,9 +3470,8 @@ bool hwapi::sys_sendJsonFileToDc(uint8_t kindOfFile, uint8_t nrOfTemplate, uint8
     dateiLang<<=6;  // auf volle 64byte aufgerundet
 
     // check free memory
-    frei=FDLONG_STACKDEPTH - check4FDlongCmd();
+    frei=check4freeFDlongCmd();
         // Command-Stack sollte 16 Commands fassen, je 64byte Nutzdaten = 1024byte
-        // in check4FDlongCmd() steht wieviele Plaetze bereits belegt sind
         // frei gibt also die Anzahl freier 64byte Bloecke zurueck
         // das Json-File hat max 800 byte = 13 bloecke
     if (frei<16)        // Puffer muss ganz leer sein! nicht dass was durcheinander kommt
@@ -3368,8 +3492,8 @@ bool hwapi::sys_sendJsonFileToDc(uint8_t kindOfFile, uint8_t nrOfTemplate, uint8
     {
         biox_CopyBlock(inhaltOfJson, uitmp, temp, 0, 64);
         longFDcmd_set(31,0, bn++, 64, temp);
-        uitmp += 64;
-        // uitmp<<=6;
+        //uitmp<<=6;  // falsch
+        uitmp+=64;
     } while(uitmp < dateiLang);
 
     longFDcmd_set(32, 0,0, 0,temp);       // Abschluss
@@ -3392,19 +3516,25 @@ bool hwapi::prn_sendDynamicPrnValues(uint8_t *dynPrnVal ) const
 
 }
 
+
 bool hwapi::prn_printTemplate(uint8_t nrOftemplate) const
     // print one of the templates loaded by Json prior
     // nr = 1..32
 {
     // return true if sending, false if cmd-stack is full
-    return sendFDcmd_set(152, 0,0, nrOftemplate,0,0,0);
+
+    // 3.5.23: die dynVals und alle templates sollen am stück gesendet
+    uint8_t data[64];
+    data[0]=nrOftemplate;
+    return longFDcmd_set(152, 0,0, 1, data);
 }
 
-void hwapi::log_getHoldAccountNumbers(uint32_t *accNr ) const
-    // returns all acc nrs of the backuped vault records
-    // use: uint32_t backupedAccNumbers[8]
+void hwapi::log_getHoldAccountNumbers(uint8_t *nrOfVals, uint16_t *accNr ) const
 {
-    Q_UNUSED(accNr);
+    // returns all acc nrs of the backuped vault records
+    // use: uint16_t backupedAccNumbers[8]
+
+    epi_restoreDCbackupAccNr(nrOfVals, accNr);
 }
 
 
@@ -3412,21 +3542,62 @@ void hwapi::log_getHoldAccountNumbers(uint32_t *accNr ) const
 bool hwapi::log_selectVaultRecord(uint16_t accountNr ) const
 {
     // return true if sending, false if cmd-stack is full
-    uint8_t dat1, dat2;
+    // and trigger transfer
 
+    uint8_t dat1, dat2;
+    bool ret;
+
+    uint8_t frei=check4freeFDshortCmd();
+    if (frei<8)
+        return false;
+
+    epi_iniVRstorage();
     dat1=uint2uchar(accountNr, LOWBYTE);
     dat2=uint2uchar(accountNr, HIGHBYTE);
-    return sendFDcmd_set(153, 0,0, dat1,dat2,0,0);
+    ret=sendFDcmd_set(153, 0,0, dat1,dat2,0,0); // select this record
+        // true means "will be sent"
+    sendFDcmd_set(0,38,0, 0,0,0,0);    // return VaultRecord block-Nr.0
+    sendFDcmd_set(0,38,1, 0,0,0,0);    // return VaultRecord block-Nr.1
+    sendFDcmd_set(0,38,2, 0,0,0,0);    // return VaultRecord block-Nr.2
+    sendFDcmd_set(0,38,3, 0,0,0,0);    // return VaultRecord block-Nr.3
+    sendFDcmd_set(0,38,4, 0,0,0,0);    // return VaultRecord block-Nr.4
+    sendFDcmd_set(0,38,5, 0,0,0,0);    // return VaultRecord block-Nr.4
+        // 38: <100 to get long 64byte response
 
+    return ret;
 }
 
+bool hwapi::log_chkIfVaultRecordAvailable(void) const
+{
+    // return true if completly received
+    return epi_checkIfVaultRecordAvailable();
+        return false;
+}
 
-//request, isAvailable
-void hwapi::log_getVaultRecord(struct T_vaultRecord *retVR) const
+bool hwapi::log_getVaultRecord(struct T_vaultRecord *retVR) const
     // which was selected by: log_selectVaultRecord()
     // to be forwarded to Ismas
+    // return true if completly received
 {
-    Q_UNUSED(retVR);
+
+    uint16_t LL, nn, len;
+    char   *start;
+    uint8_t  buf[400];
+    bool ret;
+
+    ret=epi_restoreVaultRecord(&len, buf);   // true if completly received
+    if (ret==false)
+        return false;
+        // Puffer in struct eintragen:
+    LL=sizeof(struct T_vaultRecord);		// =320
+    start = &retVR->startbuffer[0];
+    nn=0;
+    do
+    {
+        *start = buf[nn];
+        start++;
+    } while(++nn<LL);
+    return true;
 }
 
 bool hwapi::prn_printAccountReceipt(void) const
@@ -3441,14 +3612,19 @@ bool hwapi::prn_printTestTicket(void) const
 
 }
 
-bool hwapi::cash_startPayment(uint16_t amount) const
+bool hwapi::cash_startPayment(uint32_t amount) const
 {
-    uint8_t dat1, dat2;
+    // 17.4.23TS: extended to 32bit
+    uint8_t dat1, dat2, dat3, dat4;
 
+    hwapi_lastStartAmount=amount;
     epi_clearCurrentPayment();
-    dat1=uint2uchar(amount, LOWBYTE);
-    dat2=uint2uchar(amount, HIGHBYTE);
-    return sendFDcmd_set(155, 0,0, dat1,dat2,0,0);
+    dat1=ulong2uchar(amount, 0);
+    dat2=ulong2uchar(amount, 1);
+    dat3=ulong2uchar(amount, 2);
+    dat4=ulong2uchar(amount, 3);
+
+    return sendFDcmd_set(155, 0,0, dat1,dat2,dat3,dat4);
 
 }
 
@@ -3482,6 +3658,7 @@ bool hwapi::cash_stopPayment(void) const
 {
     // DB1: 1=encash    2=cancel & return coins
     //      3=stop and keep coins in escrow
+    emit hwapi_vendStopByPushbutton();
     return sendFDcmd_set(156, 0,0, 3,0,0,0);
 
 }
@@ -3504,17 +3681,24 @@ bool hwapi::vend_failed(void) const
 
 }
 
-
-
-
-
-
-uint8_t hwapi::mif_getCardType(QString cardholder) const
+uint8_t hwapi::mif_getCardType(QString *cardholder) const
     // return 1,2,3,4 = upper, lower access card, printer test, coin test
     // cardholder: 7byte Name-String
 {
-    Q_UNUSED(cardholder);
-    return 0; // to satisfy compiler
+    uint8_t type, buf[8], nn;
+    char ctmp;
+
+    memset(buf, 0x00, sizeof(buf));
+
+    type=epi_mifGetCardType(&buf[0]);
+        //holder[8] = name of card holder
+        // retval Type of MifareCard, 1=upper door, 2=lower door 3=test printer 4=test coins
+    for (nn=0;nn<8; nn++) {
+        ctmp=buf[nn];
+        cardholder[nn]=ctmp;
+
+    }
+    return type;
 }
 
 uint64_t hwapi::sys_getWakeSource(void) const
@@ -3523,17 +3707,358 @@ uint64_t hwapi::sys_getWakeSource(void) const
      return epi_getWakeSources();
 }
 
-//void hwapi::sys_getDeviceConditions(struct T_moduleCondition *devCond) const
+uint8_t hwapi::sys_getWakeReason(void) const
+{
+     // Master was woken by following reason:
+     // 1: MDB Event
+     // 2: Coin Event
+     // ( 3: Master Event) - will not set the wake line
+     // ( 4: 32s pulse) - will not set the wake line
+     // 5: Door Event
+     // ( 6: Diag Event) - will not set the wake line
+     // 7: 30min-Pulse for HB
+
+     return epi_getWakeReason();
+}
+
+
 void hwapi::sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const
 {
     //uint8_t leng, data[66];
     epi_restoreDeviceConditions(leng, data);
 }
 
-//void hwapi::sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const
-void hwapi::sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const
+void hwapi::sys_getDeviceConditions(struct T_moduleCondition *devCond) const
 {
-    epi_restoreDeviceConditions(leng, data);
+    uint16_t LL, nn;
+    uint8_t *start;
+    uint8_t  buf[70], leng;
+
+    epi_restoreDeviceConditions(&leng, buf);
+
+        // Puffer in struct eintragen:
+    LL=sizeof(struct T_moduleCondition);
+    start = &devCond->ram;
+    nn=0;
+    do
+    {
+        *start = buf[nn];
+        start++;
+    } while(++nn<LL);
+
+}
+
+
+
+
+void hwapi::sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const
+{
+    epi_restoreDynMachineConditions(leng, data);
+}
+
+void hwapi::sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const
+{
+
+    uint16_t LL, nn;
+    char *start;
+    uint8_t  buf[70], leng;
+
+    epi_restoreDynMachineConditions(&leng, buf);
+        // Puffer in struct eintragen:
+    LL=sizeof(struct T_dynamicCondition);
+    start = &dynMachCond->allDoorsDebounced;
+    nn=0;
+    do
+    {
+        *start = buf[nn];
+        start++;
+    } while(++nn<LL);
+
+}
+
+
+uint32_t hwapi::cash_getAmountInVault(void) const
+{
+    return epi_getCashBoxContent();
+}
+
+uint16_t hwapi::cash_getNrCoinsInVault(void) const
+{
+    return epi_getNrOfCoinsInCashBox();
+}
+
+
+
+uint8_t hwapi::prn_getPrintResult() const
+{
+    // return:  0: unknown
+    //          1: OK - last template was printed succesful
+    //          2: error - last template was not printed
+
+    struct T_dynamicCondition dynMachCon;
+    //uint8_t  buf[70], leng,
+    uint8_t res;
+    static  uint8_t lastState;
+    //uint32_t  aa;
+
+   // aa=&dynMachCon;
+    sys_getDynMachineConditions(&dynMachCon);
+    res= dynMachCon.resultOfLastTemplPrint;
+        // 0: unknown or printing in progress
+        // 1: OK, doc was printed   2: error, doc was not printed
+
+    if (res==0)
+    {
+        if (lastState>0)
+        {
+            // print was started
+            lastState=res;
+        }
+    } else
+    {
+        if (lastState==0)
+        {
+            // result hat sich auf 1 oder 2 geändert, d.h. Druck ist fertig
+            if (res==1)
+            {
+
+                //emit    hwapi_templatePrintFinished_OK();
+            } else
+            if (res==2)
+            {
+
+                //emit    hwapi_templatePrintFinished_Err();
+            }
+                lastState=res;
+        }
+    }
+    return res;
+}
+
+uint8_t hwapi::prn_getCurrentPrinterState() const
+{
+        //        0: printer OK
+        //          bit0: near paper end          bit1: no paper
+        //          bit2: temperature error       bit3: error head open
+        //          bit4: paper jam in cutter
+        //          bit6: no response             bit7: serial rec. error
+        //			bit5: printer not ready
+
+
+    uint8_t     lastPrinterStatus;
+    uint8_t  buf[70], leng;
+
+    // 2nd way to get dyn.conditions:
+    epi_restoreDynMachineConditions(&leng, buf);
+    lastPrinterStatus=buf[53];
+
+    return lastPrinterStatus;
+}
+
+
+// 21.4.23TS: change function "sendDeviceSettings()" to use this struct: "struct T_devices"
+void hwapi::sys_sendDeviceParameter(struct T_devices *deviceSettings) const
+{
+    // same as "sendDeviceSettings()" but with much more data
+    uint8_t buf[64];
+    uint16_t LL, nn;
+    tslib_strclr(buf,0,64);
+    uint8_t *start;
+
+    // den gesamten struct in einen Puffer kopieren
+    LL=sizeof(struct T_devices);
+    start = &deviceSettings->kindOfPrinter;
+    nn=0;
+    do
+    {
+        buf[nn] = *start;
+        start++;
+    } while(++nn<LL);
+
+    epi_store64BdevParameter(LL,buf);   // this buffer holds the device settings to be used here in hwapi
+    epi_store64ByteSendData(LL, buf);   // this buffer holds sending data temporarely
+    sendWRcmd_setSendCommand0(SENDDIRCMD_DEVICE_PARA);
+
+}
+
+void hwapi::sys_restoreDeviceParameter(struct T_devices *deviceSettings) const
+{
+    uint8_t buf[64];
+    uint8_t LL, nn;
+    tslib_strclr(buf,0,64);
+    uint8_t *start;
+
+    epi_restore64BdevParameter(&LL, buf);
+
+    // Puffer in struct eintragen:
+    start = &deviceSettings->kindOfPrinter;
+    nn=0;
+    do
+    {
+        *start = buf[nn];
+        start++;
+    } while(++nn<LL);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------------------
+// ------------   supervise  all hardware components
+// ------------    assess the machine state
+
+1. check if DC startup test is through, retrigger if not
+2. get results and find errors
+3. in case of error check if component is used (e.g. billreader is seldom used)
+4: check doors
+5. return value: 0: no response from DC
+                 1: no Test results and Test not running. need retrigger!
+                 2: state not clear by now, test ongoing, wait
+                 3: Service or battery door is open, goto INTRUSION MODE
+                        from here: after valid ID-card goto SERVICE MODE
+                 4: vault door is open, goto INTRUSION MODE
+                        from here: after valid ID-card and vault door closed goto TEST MODE
+                        in TEST MODE: complete system check decides if vending mode allowed
+                 5: All doors are closed but errors found,
+                        goto OOO MODE (out-of-order)
+                        from here: run system test until problem is fixed
+                 6: All doors are closed, no error, maybe warnings,
+                        goto VENDING MODE (normal operation)
+                (priority sinks from 0 to 6)
+
+ --------------------------------------------------------------------------------------------- */
+
+uint8_t hwapi::sys_componentAssessment(void) const
+{
+    // this function decides if vending mode is possible, independant from door
+    // return >0 in case of error
+    // is inncluded in sys_superviseSystem
+
+    struct T_moduleCondition *modCond=0;
+    sys_getDeviceConditions(modCond);
+
+    struct T_dynamicCondition *dynMaCond=0;
+    sys_getDynMachineConditions(dynMaCond);
+
+    struct T_devices *devPara=0;
+    sys_restoreDeviceParameter(devPara);
+
+    if (modCond->rtc>=200)
+        return 1;
+    if (modCond->printer==200 || modCond->printer==201)   // 200: not connected  201: printer-HW-error  202: no paper
+        return 2;
+    if (modCond->printer==202)
+        return 3;
+
+    if (modCond->coinBlocker>=200)
+        return 4;
+    if (modCond->mdbBus>=200)
+        return 5;
+    if (modCond->intEe>=200)
+        return 6;
+
+    if (devPara->kindOfCoinChecker==1 || devPara->kindOfCoinChecker==2)  // 0: without  1=EMP820   2=EMP900    3=currenza c²	(MW)
+    {
+        if (modCond->coinChecker>=200 || modCond->coinEscrow>=200)
+        {
+            // Fehler Münzver.
+            return 7;
+        }
+        if (modCond->coinSafe>200)           // 200: kasse fehlt 201: voll  100:fast voll  1:ok
+        {
+            return 8;
+        }
+    } else
+    if (devPara->kindOfCoinChecker==3)
+    {
+        if (modCond->changer>=200)
+        {
+            // Fehler Münzver.
+            return 7;
+        }
+        if (modCond->coinSafe>200)           // 200: kasse fehlt 201: voll  100:fast voll  1:ok
+        {
+            return 8;
+        }
+    }
+
+    if ( modCond->billReader>=200 && devPara->BillAcceptor>0)
+    {
+        // Fehler BNA
+        return 9;
+    }
+
+    if (dynMaCond->onAlarm>0)
+        return 10;
+
+    if (dynMaCond->modeAbrech>0)
+        return 11;
+
+    if (dynMaCond->nowCardTest>0)
+        return 12;
+
+    if (dynMaCond->startupTestIsRunning>0)
+        return 13;
+
+    if (modCond->voltage>=200)
+        return 14;
+    if (modCond->temper>=200)
+        return 15;
+
+    return 0;
+}
+
+
+// retrigger System-Check with:
+// bool hwapi::sys_runCompleteTest(void) const
+
+
+uint8_t hwapi::sys_superviseSystem(void) const
+{
+    // this function proofs if vending is possible depending of doors state
+
+    struct T_dynamicCondition *dynMaCond=0;
+    struct T_moduleCondition *modCond=0;
+
+    if (!gpi_areDcDataValid())
+    {
+        // es gibt keinerlei gültige Daten vom DC
+        return 0;
+    }
+
+    // jetzt sind die DC-Daten aktuell, also reinholen:
+    sys_getDynMachineConditions(dynMaCond);
+    sys_getDeviceConditions(modCond);
+
+    if (!modCond->allModulesChecked)
+    {
+        // noch keine Testergebnisse
+        if (dynMaCond->startupTestIsRunning)
+            return 2;    // Starttest läuft gerade
+        else
+            return 1;    // Starttest ist noch nicht gelaufen
+    }
+
+    // all doors: 99: undefined  0:closed  1:open
+    if (dynMaCond->lowerDoor || dynMaCond->upperDoor)
+        return 3;
+    if (dynMaCond->middleDoor)
+        return 4;
+
+    if (sys_componentAssessment() >0)
+        return 5;       // errors found
+
+    return 6;   // everything fine
+}
+
+
+
+uint8_t hwapi::sys_getSystemErrors(void) const
+{
+
+    return sys_componentAssessment();
+
+
 }
 
 

DCPlugin/src/sendWRcmd.cpp

@@ -563,11 +563,17 @@ bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, ui
 
 uint8_t check4FDshortCmd(void)
 {
-    // returns number of waiting command
+    // returns number of waiting command, max FDCMD_STACKDEPTH
     return p_nextFDcmdsInQueue;
 }
 
 
+uint8_t check4freeFDshortCmd(void)
+{
+    // returns number of free places in short-command stack
+    return FDCMD_STACKDEPTH - p_nextFDcmdsInQueue;
+}
+
 
 // long command, 64 data bytes
 static uint8_t longFDwrCmd[FDLONG_STACKDEPTH];
@@ -602,7 +608,7 @@ bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8
     uint8_t nn;
     if (p_longFDcmdsInQueue>=FDLONG_STACKDEPTH)
     {
-        qCritical() << "cannot save cmd because stack is full";
+        qDebug() << "cannot save cmd because stack is full";
         return false;           // not possible
     }
     longFDwrCmd[p_longFDcmdsInQueue]=nextWrCmd;
@@ -613,7 +619,6 @@ bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8
         longFDpara[p_longFDcmdsInQueue][nn]=data[nn];
 
     p_longFDcmdsInQueue++;
-
     return true;                // ok, will be sent
 }
 
@@ -659,5 +664,41 @@ uint8_t check4FDlongCmd(void)
     return p_longFDcmdsInQueue;
 }
 
+uint8_t check4freeFDlongCmd(void)
+{
+    // returns number of free places in command stack
+    return FDLONG_STACKDEPTH - p_longFDcmdsInQueue;
+}
+
+
+
+
+static uint8_t Sdata_DeviceParameter[64];
+static uint8_t Sdata_DevParaLen;
+
+uint8_t epi_store64BdevParameter(uint8_t length, uint8_t *buf)
+{
+    // HWapi writes data to be stored
+    uint8_t nn;
+    for (nn=0; nn<length; nn++)
+        Sdata_DeviceParameter[nn]=buf[nn];
+    for (nn=length; nn<64; nn++)
+        Sdata_DeviceParameter[nn]=0;
+
+    Sdata_DevParaLen=length;
+    return 0;
+}
+
+uint8_t epi_restore64BdevParameter(uint8_t *length, uint8_t *buf)
+{
+
+    for (uint8_t nn=0; nn<Sdata_DevParaLen; nn++)
+        buf[nn]=Sdata_DeviceParameter[nn];
+    *length=Sdata_DevParaLen;
+
+    return 0;
+}
+
+
 
 

DCPlugin/src/shared_mem_buffer.cpp

@@ -0,0 +1,39 @@
+#include "shared_mem_buffer.h"
+
+#include <QDebug>
+#include <atomic>
+
+#ifdef QT_POSIX_IPC
+    // The POSIX backend can be explicitly selected using the -feature-ipc_posix
+    // option to the Qt configure script. If it is enabled, the QT_POSIX_IPC
+    // macro will be defined. -> we use SystemV shared memory
+#error "QT_POSIX_IPC defined"
+#else
+#include <sys/ipc.h>    // ftok
+#endif
+
+// std::atomic_bool SharedMemBuffer::__sharedMemLocked{false};
+
+QSharedMemory *SharedMemBuffer::getShm(std::size_t size) {
+    static QSharedMemory shMem;
+    if (size > 0) {
+        static const long nativeKey = ftok("/etc/os-release", 'H');
+        static const QString fkey = std::to_string(nativeKey).c_str();
+        shMem.setKey(fkey);
+        if (!shMem.isAttached()) {
+            if (shMem.create(size)) {
+                return &shMem;
+            } else {
+                if (shMem.error() == QSharedMemory::AlreadyExists) {
+                    if (shMem.attach()) {
+                        return &shMem;
+                    }
+                }
+            }
+            qCritical() << shMem.nativeKey() << shMem.key() << shMem.data()
+                        << shMem.error() << shMem.errorString();
+            return nullptr;
+        }
+    }
+    return &shMem;
+}

DCPlugin/src/tslib.cpp

@@ -76,6 +76,23 @@ uint8_t uint2uchar(uint16_t uival, bool getHighB)
 }
 
 
+uint8_t ulong2uchar(uint32_t ulval, uint8_t getBytNr)
+{
+    // getBytNr: 0=LSB  3=MSB
+    uint32_t ultmp=ulval;
+    if (getBytNr==0)
+        return uint8_t(ultmp);
+    ultmp>>=8;
+    if (getBytNr==1)
+        return uint8_t(ultmp);
+    ultmp>>=8;
+    if (getBytNr==2)
+        return uint8_t(ultmp);
+    ultmp>>=8;
+    return uint8_t(ultmp);
+
+}
+
 void delay(uint16_t MilliSec)
 {
     QThread::msleep(uint32_t(MilliSec));

OnDemandUpdatePTU.pro

@@ -0,0 +1,129 @@
+QT += core gui
+QT += widgets serialport network
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+TARGET = ATBUpdateTool
+
+# 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
+VERSION=1.3.2
+
+INCLUDEPATH += plugins
+
+CONFIG += c++17 console
+# CONFIG -= app_bundle
+
+DEFINES+=APP_VERSION=\\\"$$VERSION\\\"
+
+QMAKE_CXXFLAGS += -g
+QMAKE_CXXFLAGS += -Wno-deprecated-copy
+
+# custom target for 'git subtree'
+# subtree.target = subtree
+# subtree.commands = git subtree add --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash
+# subtree.depends =
+# QMAKE_EXTRA_UNIX_TARGETS += subtree
+
+# ! exists(DCPlugin) {
+#     $$system("git subtree add --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash")
+# } else {
+    # $$system("git subtree pull --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash")
+# }
+
+# You can make your code fail to compile if it uses deprecated APIs.
+# In order to do so, uncomment the following line.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+contains( CONFIG, PTU5 ) {
+    greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
+    CONFIG += link_pkgconfig
+    lessThan(QT_MAJOR_VERSION, 5):   PKGCONFIG += qextserialport
+    QMAKE_CXXFLAGS += -std=c++17   # for GCC >= 4.7
+    QMAKE_CXXFLAGS += -Wno-deprecated-copy
+    ARCH = PTU5
+    DEFINES+=PTU5
+}
+contains( CONFIG, PTU5_YOCTO ) {
+    greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
+    QMAKE_CXXFLAGS += -std=c++17   # for GCC >= 4.7
+    QMAKE_CXXFLAGS += -Wno-deprecated-copy
+    PTU5BASEPATH = /opt/devel/ptu5
+    ARCH = PTU5
+    DEFINES+=PTU5
+
+    # add qmqtt lib
+    #LIBS += -lQt5Qmqtt
+}
+contains( CONFIG, DesktopLinux ) {
+    greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
+    lessThan(QT_MAJOR_VERSION, 5):    CONFIG += extserialport
+    # QMAKE_CC = ccache $$QMAKE_CC
+    # QMAKE_CXX = ccache $$QMAKE_CXX
+    QMAKE_CXXFLAGS += -std=c++17
+    QMAKE_CXXFLAGS += -Wno-deprecated-copy
+    linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
+    ARCH = DesktopLinux
+    DEFINES+=DesktopLinux
+}
+
+SOURCES += \
+        main.cpp \
+        progress_event.cpp \
+        update_dc_event.cpp \
+        mainwindow.cpp \
+        utils.cpp \
+        update.cpp \
+        git/git_client.cpp \
+        ismas/ismas_client.cpp \
+        process/command.cpp \
+        message_handler.cpp \
+        worker.cpp \
+        worker_thread.cpp
+
+HEADERS += \
+        update.h \
+        progress_event.h \
+        update_dc_event.h \
+        utils.h \
+        mainwindow.h \
+        git/git_client.h \
+        apism/ismas_data.h \
+        ismas/ismas_client.h \
+        process/command.h \
+        message_handler.h \
+        worker.h \
+        worker_thread.h \
+        plugins/interfaces.h
+
+FORMS += \
+    mainwindow.ui
+
+OTHER_FILES += \
+    /opt/app/tools/atbupdate/update_log.csv \
+    main.cpp.bck \
+    main.cpp.bck2 \
+    main.cpp.bck3
+
+# https://blog.developer.atlassian.com/the-power-of-git-subtree/?_ga=2-71978451-1385799339-1568044055-1068396449-1567112770
+# git subtree add --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash
+# git subtree pull --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash
+# include(./DCPlugin/DCPlugin.pri)
+
+
+
+##########################################################################################
+# for running program on target through QtCreator
+contains( CONFIG, PTU5 ) {
+   qnx: target.path = /tmp/$${TARGET}/bin
+   else: unix:!android: target.path = /opt/app/tools/atbupdate/
+   !isEmpty(target.path): INSTALLS += target
+}

UpdatePTUDevCtrl.pro

@@ -1,56 +0,0 @@
-# QT -= gui
-QT += core
-QT += widgets serialport
-QT += network
-
-TARGET = up_dev_ctrl
-
-CONFIG += c++11
-# CONFIG -= app_bundle
-
-# DEFINES+=LinuxDesktop
-
-QMAKE_CXXFLAGS += -Wno-deprecated-copy
-
-# You can make your code fail to compile if it uses deprecated APIs.
-# In order to do so, uncomment the following line.
-#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
-
-contains( CONFIG, PTU5 ) {
-    greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
-    CONFIG += link_pkgconfig
-    lessThan(QT_MAJOR_VERSION, 5):   PKGCONFIG += qextserialport
-    QMAKE_CXXFLAGS += -std=c++11   # for GCC >= 4.7
-    QMAKE_CXXFLAGS += -Wno-deprecated-copy
-    ARCH = PTU5
-    DEFINES+=PTU5
-}
-contains( CONFIG, DesktopLinux ) {
-    greaterThan(QT_MAJOR_VERSION, 4): QT += serialport
-    lessThan(QT_MAJOR_VERSION, 5):    CONFIG += extserialport
-    # QMAKE_CC = ccache $$QMAKE_CC
-    # QMAKE_CXX = ccache $$QMAKE_CXX
-    QMAKE_CXXFLAGS += -std=c++11
-    QMAKE_CXXFLAGS += -Wno-deprecated-copy
-    linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
-    ARCH = DesktopLinux
-    DEFINES+=DesktopLinux
-}
-
-SOURCES += \
-        main.cpp \
-        message_handler.cpp
-
-HEADERS += \
-        message_handler.h \
-        DCPlugin/include/interfaces.h
-
-# https://blog.developer.atlassian.com/the-power-of-git-subtree/?_ga=2-71978451-1385799339-1568044055-1068396449-1567112770
-# git subtree add --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash
-# git subtree pull --prefix DCPlugin https://git.mimbach49.de/GerhardHoffmann/DCPlugin.git master --squash
-include(./DCPlugin/DCPlugin.pri)
-
-# Default rules for deployment.
-qnx: target.path = /tmp/$${TARGET}/bin
-else: unix:!android: target.path = /opt/$${TARGET}/bin
-!isEmpty(target.path): INSTALLS += target

allgemein.txt

@@ -0,0 +1,126 @@
+0:
+    Zunaechst wir immer nachgesehen, ob das Repository bereits geklont wurde.
+    Wenn nein, dann wird geklont. Im Master-Branch befinden sich Dateinen, die
+    in allen anderen Branches gemeinsam genutzt werden. Das sollte wohl auf
+    jeden Fall fuer den DeviceController gelten.
+1:
+    Anfrage bei ISMAS ob neue Daten da sind. Hier faengt die ganze Sache an.
+    Da man nicht weiss, on ISMAS ueberhaupt antworten wird braucht es einen
+    Timer. Man kann die Sache dann auch gleich mehrfach versuchen.
+
+    Die Anfrage geht also per Signal an den Apism-Client. Im Signal wird der
+    Zustand mitgegeben:
+
+        ISMAS_UPDATE_REQUEST_PENDING
+
+    und im Slot dann entsprechend uebernommen. Der Timer sollte nicht im Worker
+    stehen, sondern im Apism-Client. Der Worker sollte damit nicht belastet
+    sein. Der wird dann vom Apism-Client entsprechend benachrichtigt.
+
+        ISMAS_UPDATE_REQUEST_FAILURE
+            ISMAS_UPDATE_REQUEST_TIMEOUT
+        ISMAS_UPDATE_REQUEST_SUCCESS
+
+    Im 1./2.Fall wird dann ein Fehlerhandling durchgefuehrt. Insbesondere
+    wird Apism ueber den DB-Kanal darueber informiert (U0003). Am Ende wie
+    dann wie immer SendCmdVersion und beenden der Applikation.
+
+    Im Erfolgsfall muss in der Antwort der Branch enthalten sein, fuer den das
+    Update durchgefuhrt werden soll. Das ist auch bereits so (Location).
+
+    Ein Sonderfall waere der -m-Modus, da hier niemand auf der ISMAS-Seite
+    aktiv eingreift. Hier braucht es dann einen Ubergabeparameter an 
+    ATBUpdateTool: --branch-name
+
+    Normalfall ist aber die Aktivierung via ISMAS. Dann muss der in der Antwort
+    enthaltene Branch zunaechst ausgecheckt werden.
+2: 
+    Dazu wird ein entsprechendes Signal an den GitClient gesandet.
+        
+        GIT_CHECKOUT_BRANCH_REQUEST
+
+    Der GitClient sieht jetzt erstmal nach, ob es diesen Branch ueberhaupt
+    gibt.
+
+        Falls nein:    
+
+        GIT_CHECKOUT_BRANCH_REQUEST_FAILURE
+            BRANCH_NOT_EXIST
+ 
+        Falls ja:
+            der GitClient versucht nun den Branch auszuchecken. 
+            Geht das gut?
+            Falls nein:
+
+                GIT_CHECKOUT_BRANCH_REQUEST_FAILURE
+                    BRANCH_CHECKOUT_ERROR
+
+            Falls ja:
+                GIT_CHECKOUT_BRANCH_REQUEST_SUCCESS
+                    -> eventl. koennte man den Namen des Branches mitgeben
+
+
+        Signal an den Worker. Im entsprechenden Slot wird jetzt der eigentliche
+        UpdateProzess angeworfen.
+ 3:
+    Mittels git fetch werden jetzt die Aenderungen ermittelt.
+
+        GIT_FETCH_UPDATES_REQUEST
+        
+        GIT_FETCH_UPDATES_REQUEST_FAILURE
+            -> Worker informieren damit Fehlerbehandlung aktiviert wird
+        GIT_FETCH_UPDATES_REQUEST_SUCCESS
+
+        GIT_DIFF_UPDATES
+
+        Die Liste der geaenderten Dateien geht an den Worker. Der kann jetzt
+        noch Test machen, ob das Sinn macht. Evtl. eine Statusmeldung ausgeben
+        drueber was gleich passieren wird.
+4:
+    Mittels git merge/pull werden nun die Dateien tatsaechlich im Branch 
+    aktualisiert.
+
+        GIT_PULL_UPDATES_REQUEST
+        GIT_PULL_UPDATES_REQUEST_FAILURE
+            -> Worker informieren damit Fehlerbehandlung aktiviert wird
+        GIT_PULL_UPDATES_REQUEST_SUCCESS
+            -> Worker informieren
+
+    Sind die Daten vorhanden, dann werden sie mittels rsync ins Dateisystem
+    kopiert.
+
+        RSYNC_UPDATES 
+        RSYNC_UPDATES_FAILURE
+        RSYNC_UPDATES_SUCCESS
+
+    Fuer jede kopierte Datei geht eine Nachricht raus ans ISMAS.
+5:
+    Sind die Daten dann kopiert, so werden sie auf den DC kopiert (falls
+    notwendig): hier gehen dann wieder Nachrichten an ISMAS raus:
+
+        DC_UPDATE 
+        DC_UPDATE_FAILURE
+        DC_UPDATE_SUCCESS
+
+        JSON_UPDATE
+        JSON_UPDATE_FAILURE
+        JSON_UPDATE_SUCCESS
+        
+        Hier fuer jedes Json-File.
+
+    Schliesslich noch eine Zusammenfasung an ISMAS:
+
+        ISMAS_UPDATE_INFO_CONFIRM
+        ISMAS_UPDATE_INFO_CONFIRM_FAILURE
+            -> Worker informieren damit Fehlerbehandlung aktiviert wird
+        ISMAS_UPDATE_INFO_CONFIRM_SUCCESS
+
+    und schliesslich der abschliessende Status an ISMAS zurueckgemeldet:
+
+        ISMAS_CURRENT_PSA_STATUS_CONFIRM
+        ISMAS_CURRENT_PSA_STATUS_CONFIRM_FAILURE
+        ISMAS_CURRENT_PSA_STATUS_CONFIRM_SUCCESS
+
+    
+
+

apism/ismas_data.h

@@ -0,0 +1,137 @@
+#ifndef ISMASDATA_H
+#define ISMASDATA_H
+
+#include <QJsonObject>
+#include <QJsonArray>
+
+
+
+
+namespace ISMAS {
+
+    struct TransferData : public QJsonObject {
+        struct : public QJsonObject {
+            QJsonValue tariffId;
+            QJsonValue group;
+            QJsonValue zone;
+        } device;
+
+        struct : public QJsonObject {
+            QJsonValue state;
+            QJsonValue uid;
+            QJsonValue seq_tick_number;
+            QJsonValue timestamp;
+            QJsonValue userText;
+            QJsonValue userTextType;
+        } transaction;
+
+        struct : public QJsonObject {
+            // TODO: check what is really used at the moment
+            QJsonValue id;          // unique article id
+            QJsonValue name;        // name
+            QJsonValue price;       // price in cent
+            QJsonValue currency;    //
+            QJsonValue startTime;   // start time
+            QJsonValue endTime;     // end time
+            QJsonValue userText;    // additional info
+            QJsonValue parkingTime;
+            QJsonValue printText;
+            // QJsonValue discount;
+        } item;
+
+        struct : public QJsonObject {
+            struct : public QJsonObject {
+                QJsonValue coins;     // total amount of coins value
+                // QJsonValue notes;     // total amount of notes value
+                QJsonValue overpaid;  // in cent
+                QJsonValue currency;
+                QJsonValue change;
+            } cash;
+
+            struct : public QJsonObject {
+                QJsonValue cardNumber;
+                QJsonValue value;           // buchungsbetrag
+                QJsonValue cardType;
+                QJsonValue currency;
+                QJsonValue tid;
+                QJsonValue tresult;
+            } card;
+
+            struct : public QJsonObject {
+                QJsonValue cardNumber;
+                QJsonValue cardType;
+                QJsonValue value;
+                QJsonValue valueOld;
+                QJsonValue valueNew;
+                QJsonValue time;
+                QJsonValue timeOld;
+                QJsonValue timeNew;
+            } prePaidCard;
+        } payment;
+
+        struct : public QJsonObject {
+            QJsonValue delivery;    // PRINT, OnlineTicket
+            QJsonValue result;      // SUCCESS, ERROR
+            QJsonValue errorCode;   // 0=OK, 1=...
+            QJsonValue errorMsg;
+        } result;
+    };
+
+
+    struct AccountData : public QJsonObject {
+        struct : public QJsonObject {
+            QJsonValue UID;
+            QJsonValue ChangeNumber;
+            QJsonValue Process;         // Vorgang
+            QJsonValue startDateTime;
+            QJsonValue endDateTime;
+            QJsonValue startHash;
+            QJsonValue endHash;
+
+            struct : public QJsonObject {
+                QJsonValue value;          // coin value
+                QJsonValue numberOfCoins;  // number of coins
+                QJsonValue currency;
+            } coin;
+
+        } coinBox;                  // Münzkasse
+    };
+
+
+    struct EventData : public QJsonObject {
+        struct : public QJsonObject {
+            QJsonValue eventID;
+            QJsonValue deviceName;
+            QJsonValue reason;
+            QJsonValue event;
+            QJsonValue eventState;
+            QJsonValue timeStamp;
+            QJsonValue parameter;
+            QJsonValue secondLevelInfo;
+        } machineEvent;                  //
+    };
+
+    struct StateData : public QJsonObject {
+        QJsonValue Timestamp;
+        QJsonArray HW_States;
+        struct : public QJsonObject {
+            QJsonValue name;
+            QJsonValue value;
+            QJsonValue unit;
+        } machineState;                  //
+    };
+
+
+    enum class REQUEST : quint8 {
+        NO_REQUEST,
+        START,
+        STOP,
+        PING,
+        SELF,
+        ISMAS_PARAMETER
+    };
+}
+
+
+
+#endif // ISMASDATA_H

doc/update_ptu.tex

@@ -0,0 +1,172 @@
+\documentclass[12pt]{article}
+\usepackage{euler}
+\usepackage[english]{babel}
+\usepackage{lipsum}
+\usepackage{multirow}
+\usepackage[colorlinks=true, urlcolor=blue, linkcolor=red]{hyperref}
+\newcounter{Chapcounter}
+\newcommand\showmycounter{\addtocounter{Chapcounter}{1}\themycounter}
+\newcommand{\chapter}[1] 
+{{\centering          
+  \addtocounter{Chapcounter}{1} \Large \underline{\textbf{ \color{blue} Chapter \theChapcounter: ~#1}} }   
+  \addcontentsline{toc}{section}{ \color{blue} Chapter:~\theChapcounter~~ #1}    
+}
+\hypersetup{colorlinks=true}
+\hypersetup{linkcolor=black}
+
+\title{Update PTU}
+\author{Gerhard Hoffmann}
+\date{\today}
+
+\begin{document}
+\maketitle
+% \chapter{Introduction}
+\section{Motivation}
+
+The two main components of a PSA are
+\begin{itemize}
+    \item PTU software.
+    \item Device controller (DC) firmware.
+\end{itemize}
+
+While the DC firmware is basically the same for each PSA (even for different
+customers), the PTU software is highly dependent on customer requirements.\par
+Hence, each customer is assigned an own git-repository, which will be loaded
+("cloned") on the PSA when configuring the machine for the first time.\par
+Two special tools, the {\bf UpdateController} (a \href{https://doc.qt.io/qt-5/}{Qt}
+binary [{\bf \nameref{UpdateTool}}]) and the {\bf UpdateScript}
+(a \href{https://www.gnu.org/software/bash/manual/bash.html}{bash}
+script [{\bf \nameref{UpdateScript}}]), work together to finish a PSA installation.\par 
+    
+\section{PSA: Initial configuration}
+
+For the initial configuration, a PSA loads a customer-specific git-repository,
+which structure is detailed below [{\bf \nameref{repostructure}}].\par
+The "git clone" for the repository is done by the UpdateScript [{\bf \nameref{UpdateScript}}].
+It updates the file
+\begin{center}
+    \fbox{
+        /opt/app/tools/atbupdate/update\_log.csv
+    }
+\end{center}
+which will be interpreted by the UpdateController [{\bf \nameref{UpdateTool}}].
+The structure of [{\bf \nameref{updatelogcsv}}] is detailed below.\par
+Each line of update\_log.csv represents a command for the UpdateController,
+which will either download certain files to the DC or execute some
+\href{https://openwrt.org/docs/guide-user/additional-software/opkg}{opkg}
+commands [{\bf \nameref{opkg}}].
+        
+\section{PSA: Update}
+   
+The update of a PSA is basically managed by \href{https://git-scm.com/}{git}, a
+free and open source distributed version control system. Like many other Version
+Control Systems, git has a way to fire off custom scripts when certain important
+actions occur, so-called \href{https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks}{hooks}.
+The hooks used for a PSA update are called {\bf post-checkout} and {\bf post-merge}.\par
+The post-checkout hook is called when checking out some branch of the customer-repository
+(for instance when cloning the customer repository for the first time). In contrast,
+the post-merge hook is called when a \href{https://www.git-scm.com/docs/git-pull}{git pull}
+operation has been issued (more precisely, a \href {https://www.git-scm.com/docs/git-fetch}{git-fetch}
+followed by a \href{https://www.git-scm.com/docs/git-merge}{git-merge}).\par
+Both hooks update the file [{\bf \nameref{updatelogcsv}}], which is interpreted
+by the UpdateController in a second step.
+    
+% \chapter{Update-Tool "up\_dev\_ctrl"}
+    \section{up\_dev\_ctrl}
+    \label{UpdateTool}
+
+        The update-tool is a Qt binary ("up\_dev\_ctrl") and called by the
+        system-controller application. It is installed under
+        \begin{center}
+            \fbox{
+                /opt/app/tools/atbupdate/up\_dev\_ctrl
+            }
+        \end{center}
+
+        and has two responsibilities:
+        \begin{itemize}
+            \item Call update-script "update\_psa".
+            \item Update the device controller firmware.
+        \end{itemize}
+    \subsection{Calling the update-script "update\_psa"}
+        The update-script "update\_psa" is about executing all git-commands
+        necessary to clone and pull a customer repository.
+
+    \newpage
+
+% \chapter{Update-Script "update\_psa"}
+    \section{update\_psa}
+    \label{UpdateScript}
+
+    Inside of such a
+        repository, there are at least the following directories:
+        \begin{itemize}
+           \item {\bf etc} 
+           \item {\bf etc/dc}\newline 
+                Contains the device controller firmware as binary file.
+           \item {\bf etc/psa\_config}\newline
+                Contains the printer template files (JSON).
+           \item {\bf etc/psa\_tariff}\newline
+                Contains the tariff files (JSON).
+           \item {\bf etc/psa\_update}\newline
+                Contains a single file for opkg-commands.
+        \end{itemize}
+    \newpage
+
+%\chapter{Annex}
+    \section{Structure of a customer git-repository}
+    \label{repostructure}
+    \subsection{The post-checkout hook}
+TODO: checkout\_history
+    \subsection{The post-merge hook}
+They are both located under the {\bf .githooks}-directory
+    
+\section{update\_log.csv}
+\label{updatelogcsv}
+    \begin{table}[h!]
+        \begin{center}
+        \caption{Initial state of update\_log.csv}
+        \label{tab:initial_state}
+        \begin{tabular}{llll}
+            \textbf{Request} & \textbf{Name} & \textbf{Date} & \textbf{Status}\\
+            \hline
+            \multicolumn{4}{c}{}\\
+            DOWNLOAD & /etc/dc/dc2c4.21.bin                & 2023-05-01T12:00:00 & N/A\\
+            DOWNLOAD & /etc/psa\_config/DC2C\_print01.json & 2023-05-01T12:00:00 & N/A\\
+            DOWNLOAD & /etc/psa\_config/DC2C\_print02.json & 2023-05-01T12:00:00 & N/A\\
+            DOWNLOAD & /etc/psa\_config/DC2C\_print03.json & 2023-05-01T12:00:00 & N/A\\
+            DOWNLOAD & /etc/psa\_config/DC2C\_print04.json & 2023-05-01T12:00:00 & N/A\\
+            DOWNLOAD & /etc/psa\_config/DC2C\_print29.json & 2023-05-01T12:00:00 & N/A\\
+            DOWNLOAD & /etc/psa\_config/DC2C\_print32.json & 2023-05-01T12:00:00 & N/A\\
+            EXECUTE  & opkg update                         & 2023-05-01T12:00:00 & N/A\\
+        \end{tabular}
+        \end{center}
+    \end{table}    
+
+    \begin{table}[h!]
+        \begin{center}
+        \caption{State of update\_log.csv after updating}
+        \label{tab:initial_state}
+        \begin{tabular}{llll}
+            \textbf{Request} & \textbf{Name} & \textbf{Date} & \textbf{Status}\\
+            \hline
+            \multicolumn{4}{c}{}\\
+            DONE & /etc/dc/dc2c4.21.bin                & 2023-05-01T12:00:00 & N/A\\
+            DONE & /etc/psa\_config/DC2C\_print01.json & 2023-05-01T12:00:00 & N/A\\
+            DONE & /etc/psa\_config/DC2C\_print02.json & 2023-05-01T12:00:00 & N/A\\
+            DONE & /etc/psa\_config/DC2C\_print03.json & 2023-05-01T12:00:00 & N/A\\
+            DONE & /etc/psa\_config/DC2C\_print04.json & 2023-05-01T12:00:00 & N/A\\
+            DONE & /etc/psa\_config/DC2C\_print29.json & 2023-05-01T12:00:00 & N/A\\
+            DONE & /etc/psa\_config/DC2C\_print32.json & 2023-05-01T12:00:00 & N/A\\
+            DONE & opkg update                         & 2023-05-01T12:00:00 & N/A\\
+        \end{tabular}
+        \end{center}
+    \end{table}    
+
+    \newpage
+    
+    \section{The package manager "opkg"}
+    \label{opkg}
+
+    \section{Known problems}
+\end{document}

git/git_client.cpp

@@ -0,0 +1,376 @@
+#include "git_client.h"
+#include "update.h"
+#include "worker.h"
+#include "utils.h"
+
+#include <QRegularExpression>
+#include <QDebug>
+#include <QDir>
+
+
+GitClient::GitClient(QString const &customerNrStr,
+                     QString const &customerRepository,
+                     QString const &workingDirectory,
+                     QString const &branchName,
+                     QObject *parent)
+  : QObject(parent)
+  , m_worker(qobject_cast<Worker *>(parent))
+  , m_repositoryPath(QString("https://git.mimbach49.de/GerhardHoffmann/%1.git").arg(customerNrStr))
+  , m_customerNr(customerNrStr)
+  , m_workingDirectory(workingDirectory)
+  , m_branchName(branchName)
+  , m_customerRepository(customerRepository) {
+    if (!m_worker) {
+        qCritical() << "ERROR CASTING PARENT TO WORKER FAILED";
+    }
+}
+
+bool GitClient::gitCloneCustomerRepository() {
+    QString gitCommand("git clone ");
+    gitCommand += m_repositoryPath;
+    Command c(gitCommand);
+
+    qInfo() << "IN CURRENT WD" << m_workingDirectory
+            << "CLONE" << m_repositoryPath << "...";
+
+    if (c.execute(m_workingDirectory)) { // execute the command in wd
+        QString const result = c.getCommandResult();
+        if (!result.isEmpty()) {
+            // Cloning into 'customer_281'...\n
+            static QRegularExpression re("(^\\s*Cloning\\s+into\\s+[']\\s*)(.*)(\\s*['].*$)");
+            QRegularExpressionMatch match = re.match(result);
+            if (match.hasMatch()) {
+                if (re.captureCount() == 3) { // start with full match (0), then the other 3 matches
+                    if (match.captured(2).trimmed() == m_customerNr) {
+                        qInfo() << "CLONING" << m_repositoryPath << "OK";
+                        return true;
+                    }
+                }
+            }
+        }
+        Utils::printCriticalErrorMsg(QString("ERROR CLONE RESULT HAS WRONG FORMAT. CLONE_RESULT=") + result);
+    }
+    return false;
+}
+
+bool GitClient::copyGitConfigFromMaster() { // only allowed when called in
+                                            // master branch (???)
+    if (QDir(m_customerRepository).exists()) {
+        QString const cp = QString("cp .gitconfig .git/config");
+        Command c("bash");
+        if (c.execute(m_customerRepository, QStringList() << "-c" << cp)) {
+            qInfo() << "cp .gitconfig .git/config OK";
+            return true;
+        }
+        qCritical() << "ERROR cp .gitconfig .git/config";
+    }
+    return false;
+}
+
+QStringList GitClient::gitBranchNames() {
+    // git config --global pager.branch false
+    QStringList bNames;
+    if (QDir(m_customerRepository).exists()) {
+        QString gitCommand("git branch -a");
+        Command c(gitCommand);
+        if (c.execute(m_customerRepository)) {
+            QString const result = c.getCommandResult();
+            return result.split('\n');
+        }
+    }
+    return bNames;
+}
+
+bool GitClient::gitCheckoutBranch() {
+    // TODO: nachsehen, ob der Branch ueberhaupt existiert
+
+    if (QDir(m_customerRepository).exists()) {
+        int zoneNr = Utils::read1stLineOfFile("/mnt/system_data/zone_nr");
+        m_branchName = (zoneNr != 0)
+            ? QString("zg1/zone%1").arg(zoneNr) : "master";
+
+        QString gitCommand("git checkout ");
+        gitCommand += m_branchName;
+
+        Command c(gitCommand);
+        return c.execute(m_customerRepository); // execute command in customerRepo
+    }
+    Utils::printCriticalErrorMsg(QString("ERROR ") + m_customerRepository + " DOES NOT EXIST");
+    return false;
+}
+
+bool GitClient::gitCloneAndCheckoutBranch() {
+    qInfo() << "CLONE" << m_repositoryPath << "AND CHECKOUT" << m_branchName;
+    if (gitCloneCustomerRepository()) {
+        //if (copyGitConfigFromMaster()) {
+            if (gitCheckoutBranch()) {
+                return true;
+            } else {
+                // TODO
+            }
+        //}
+    }
+    Utils::printCriticalErrorMsg(QString("CLONE ") + m_repositoryPath + " AND CHECKOUT FAILED");
+    return false;
+}
+
+QStringList GitClient::gitShowReason() {
+    QStringList lst;
+    if (QDir(m_customerRepository).exists()) {
+        // %h: commit (short form)
+        // %s: commit message
+        // %cI: commit date, strict ISO 8601 format
+        // Note: use master branch. By convention, there is a ChangeLog file
+        // in the root of the repository, which has to be always the last file
+        // to be checked in when the customer repository somehow changed.
+        Command c("git show origin/master -s --format=\"c=%h m=%s d=%cI\"");
+        if (c.execute(m_customerRepository)) {
+            QString const s = c.getCommandResult().trimmed();
+            int const c = s.indexOf("c=");
+            int const m = s.indexOf("m=");
+            int const d = s.indexOf("d=");
+
+            QString msg = IsmasClient::getReasonForLastSendVersion();
+            QString commit{""}, date{""};
+
+            if (c != -1) {
+                int start = c + 2;
+                if (m >= start) {
+                    int length = m - start;
+                    commit = s.mid(start, length).trimmed();
+
+                    start = m + 2;
+                    if (d >= start) {
+                        length = d - start;
+                        msg += " (";
+                        msg = s.mid(start, length).trimmed();
+                        msg += ")";
+
+                        start = d + 2;
+                        date = s.mid(start);
+                    }
+                }
+
+                if (!commit.isEmpty() && !msg.isEmpty() && !date.isEmpty()) {
+                    lst << commit << msg << date;
+                }
+            }
+        }
+    } else {
+        qCritical() << "CUSTOMER_REPOSITORY" << m_customerRepository
+                    << "DOES NOT EXIST";
+    }
+    return lst;
+}
+
+/*
+ Zu beachten: wird eine datei neu hinzugefuegt (git add/commit) dann aber gleich
+ wieder geloscht, so wird sie im diff nicht angezeigt.
+ */
+std::optional<QStringList> GitClient::gitDiff(QString const &commits) {
+    if (QDir(m_customerRepository).exists()) {
+        // 409f198..6c22726
+        QString gitCommand("git diff --compact-summary ");
+        gitCommand += commits;
+
+        Command c(gitCommand);
+        if (c.execute(m_customerRepository)) { // execute command in local customerRepo
+            QString s = c.getCommandResult().trimmed();
+            Utils::printInfoMsg("GIT DIFF RESULT " + s);
+
+            QStringList lines = Update::split(s, '\n');
+            QStringList fileNames;
+            // each line has the format "etc/psa_config/DC2C_print01.json | 1 +
+            // or the format            "etc/psa_config/DC2C_print01.json (new) | 1 +
+            // the filenames are relativ to the repository
+            for (int i = 0; i < lines.size(); ++i) {
+                QString const &line = lines.at(i);
+                int newIndex = line.indexOf("(new");    // for new files
+                int goneIndex = line.indexOf("(gone");  // for removed files
+                int modeIndex = line.indexOf("(mode");
+                int pipeIndex = line.indexOf('|');
+                if (newIndex != -1) {
+                    QString file = line.left(newIndex).trimmed();
+                    qInfo() << "FILE (NEW)" << file;
+                    fileNames << file;
+                } else
+                if (modeIndex != -1) {
+                    QString const file = line.left(modeIndex).trimmed();
+                    qInfo() << "FILE (MODE)" << file;
+                    fileNames << file;
+                } else
+                if (goneIndex != -1) {
+                    QString const file = line.left(goneIndex).trimmed();
+                    qCritical() << "FILE (GONE)" << file;
+                } else
+                if (pipeIndex != -1) {
+                    QString const file = line.left(pipeIndex).trimmed();
+                    qInfo() << "FILE (PIPE)" << file;
+                    fileNames << file;
+                }
+            }
+            if (!fileNames.isEmpty()) {
+                return fileNames;
+            }
+        }
+    }
+    return std::nullopt;
+}
+
+/*
+ Hat sich nichts geaendert, so werden auch keine Commits <>..<> angezeigt
+ */
+std::optional<QString> GitClient::gitFetch() {
+    if (QDir(m_customerRepository).exists()) {
+        qInfo() << "BRANCH NAME" << m_branchName;
+
+        Command c("git fetch");
+        if (c.execute(m_customerRepository)) {
+            QString const s = c.getCommandResult().trimmed();
+            if (!s.isEmpty()) {
+                QStringList lines = Update::split(s, '\n');
+                if (!lines.empty()) {
+                    int zoneNr = Utils::read1stLineOfFile("/mnt/system_data/zone_nr");
+                    m_branchName = (zoneNr != 0) ? QString("zg1/zone%1").arg(zoneNr) : "master";
+                    // lines can look like this:
+                    // From https://git.mimbach49.de/GerhardHoffmann/customer_281
+                    //   41ec581..5d25ac3  master     -> origin/master
+                    //   ff10f57..43530a1  zg1/zone1  -> origin/zg1/zone1
+                    //   6ed893f..5d9882c  zg1/zone2  -> origin/zg1/zone2
+                    //   4384d17..77045d8  zg1/zone3  -> origin/zg1/zone3
+                    //   89d2812..36a0d74  zg1/zone5  -> origin/zg1/zone5
+                    bool found = false;
+                    for (int i=0; i < lines.size(); ++i) {
+                        if (lines.at(i).contains(m_branchName)) {
+                            found = true;
+                            // 409f198..6c22726  zg1/zone1  -> origin/zg1/zone1
+                            static QRegularExpression re("(^\\s*)([0-9A-Fa-f]+..[0-9A-Fa-f]+)(.*$)");
+                            QRegularExpressionMatch match = re.match(lines.at(i));
+                            if (match.hasMatch()) {
+                                if (re.captureCount() == 3) { // start with full match (0), then the other 3 matches
+                                    return match.captured(2);
+                                } else {
+                                    emit m_worker->showErrorMessage("git fetch",
+                                        QString("(wrong cap-count (%1)").arg(re.captureCount()));
+                                }
+                            } else {
+                                emit m_worker->showErrorMessage("git fetch",
+                                    "no regex-match for commits");
+                                Utils::printCriticalErrorMsg("NO REGEX MATCH FOR COMMITS");
+                            }
+                        }
+                    }
+                    if (!found) {
+                        emit m_worker->showErrorMessage("git fetch",
+                            QString("unkown branch name ") + m_branchName);
+                        Utils::printCriticalErrorMsg("UNKNOWN BRANCH NAME " + m_branchName);
+                    }
+                } else {
+                    emit m_worker->showErrorMessage("git fetch",
+                        QString("wrong format for result of 'git fetch' ") + s);
+                    Utils::printCriticalErrorMsg(QString("WRONG FORMAT FOR RESULT OF 'GIT FETCH' ") + s);
+                }
+            } else {
+                emit m_worker->showErrorMessage("git fetch", "empty result for 'git fetch'");
+                Utils::printCriticalErrorMsg("EMPTY RESULT FOR 'GIT FETCH'");
+            }
+        }
+    } else {
+        emit m_worker->showErrorMessage("git fetch", QString("repository ") + m_customerRepository + " does not exist");
+        Utils::printCriticalErrorMsg(QString("REPOSITORY ") + m_customerRepository + " DOES NOT EXIST");
+    }
+    return std::nullopt;
+}
+
+bool GitClient::gitFetchAndDiff() {
+    if (gitFetch()) {
+        QString gitCommand("git diff --compact-summary HEAD..FETCH_HEAD");
+        Command c(gitCommand);
+        return c.execute(m_workingDirectory);
+    }
+    return false;
+}
+
+bool GitClient::gitPull() {
+    if (QDir(m_customerRepository).exists()) {
+        Command c("git pull");
+        if (c.execute(m_customerRepository)) {
+            qInfo() << "PULLED INTO" << m_customerRepository;
+            return true;
+        }
+        Utils::printCriticalErrorMsg(QString("PULL INTO " + m_customerRepository + " FAILED"));
+    }
+    return false;
+}
+
+std::optional<QStringList> GitClient::gitMerge() {
+    Command c("git merge");
+    if (c.execute(m_workingDirectory)) {
+        QString s = c.getCommandResult();
+        QStringList lst = Update::split(s, '\n');
+        return lst;
+    }
+    return std::nullopt;
+}
+
+QString GitClient::gitLastCommit(QString fileName) {
+    if (QDir(m_customerRepository).exists()) {
+        QString const filePath
+            = QDir::cleanPath(m_customerRepository + QDir::separator() + fileName);
+        if (QFile(filePath).exists()) {
+            QString const gitCommand = QString("git log %1 | head -n 1").arg(fileName);
+            Command c("bash");
+            if (c.execute(m_customerRepository, QStringList() << "-c" << gitCommand)) {
+                QString const r = c.getCommandResult();
+                int const idx = r.indexOf("commit ");
+                if (idx != -1) {
+                    return r.mid(idx + 8).trimmed();
+                }
+            }
+        }
+    }
+    return "";
+}
+
+// fileName has to an absolute path
+QString GitClient::gitBlob(QString fileName) {
+    QFileInfo fi(fileName);
+    if (fi.exists()) {
+        QString const gitCommand = QString("git hash-object %1").arg(fileName);
+        Command c(gitCommand);
+        if (c.execute("/tmp")) {
+            return c.getCommandResult().trimmed();
+        }
+    }
+    return "N/A";
+}
+
+QString GitClient::gitCommitForBlob(QString blob) {
+    if (QDir(m_customerRepository).exists()) {
+        QString const gitCommand
+            = QString("git whatchanged --all --find-object=%1 | head -n 1").arg(blob);
+        Command c(gitCommand);
+        if (c.execute(m_customerRepository)) {
+            return c.getCommandResult();
+        }
+    }
+    return "";
+}
+
+bool GitClient::gitIsFileTracked(QString fName) {
+    if (QDir(m_customerRepository).exists()) {
+        QString const gitCommand
+            = QString("git ls-files --error-unmatch %1").arg(fName);
+        Command c(gitCommand);
+        return c.execute(m_customerRepository);
+    }
+    return false;
+}
+
+
+//get_commit_for_blob () {
+//    # search for the blob in all commits for the file(name) $1
+//    echo $(git log --all --pretty=format:%H -- $2   |
+//           xargs -I{} bash -c "git ls-tree {} -- $2 |
+//           grep -q $1 && echo -n {} && head -n 1")
+//}

git/git_client.h

@@ -0,0 +1,59 @@
+#ifndef GIT_CLIENT_H_INCLUDED
+#define GIT_CLIENT_H_INCLUDED
+
+#include <QObject>
+#include <QStringList>
+#include <optional>
+
+#include "process/command.h"
+#include "ismas/ismas_client.h"
+
+class Worker;
+class GitClient : public QObject {
+    Q_OBJECT
+
+    Worker *m_worker;
+    QString const m_repositoryPath;
+    QString const m_customerNr;
+    QString const m_workingDirectory;
+    QString m_branchName;
+    QString const m_customerRepository;
+
+    bool copyGitConfigFromMaster();
+
+  public:
+    explicit GitClient(QString const &customerNrStr,
+                       QString const &repositoryPath,
+                       QString const &workingDirectory = QCoreApplication::applicationDirPath(),
+                       QString const &branchName = "master",
+                       QObject *parent = 0);
+
+    bool gitCloneCustomerRepository();
+    bool gitCheckoutBranch();
+    QStringList gitBranchNames();
+
+    QString const workingDirectory() const { return m_workingDirectory; }
+    QString workingDirectory() { return m_workingDirectory; }
+
+    QString const branchName() const { return m_branchName; }
+    QString branchName() { return m_branchName; }
+
+    QString repositoryPath() { return m_repositoryPath; }
+    QString const repositoryPath() const { return m_repositoryPath; }
+
+    bool gitCloneAndCheckoutBranch();
+
+    std::optional<QString> gitFetch();
+    bool gitFetchAndDiff();
+    bool gitPull();
+    std::optional<QStringList> gitDiff(QString const &commit);
+    std::optional<QStringList> gitMerge();
+
+    QString gitLastCommit(QString fileName);
+    QStringList gitShowReason();
+    static QString gitBlob(QString fileName);
+    QString gitCommitForBlob(QString blob);
+    bool gitIsFileTracked(QString file2name);
+};
+
+#endif // GIT_CLIENT_H_INCLUDED

ismas/ismas_client.cpp

@@ -0,0 +1,904 @@
+#include "ismas/ismas_client.h"
+#include "utils.h"
+
+#include <cstring>
+#include <cstdio>
+
+#include <errno.h>
+#include <arpa/inet.h> // inet_addr()
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <string.h>
+#include <strings.h> // bzero()
+#include <sys/socket.h>
+#include <unistd.h> // read(), write(), close()
+#include <fcntl.h>
+
+
+#include <QThread>
+#include <QJsonDocument>
+#include <QJsonObject>
+
+#if 0
+# $1: EVENT: U0001 update finished: 100%
+#            U0002 reset TRG
+#            U0003 error
+#            U0010 for update process
+# $2: PERCENT : "only for ISMAS: 0-100%",
+# $3: RESULTCODE : "only for ISMAS",
+#   0: Success
+#   1: no Update nessesary
+#   2: Backup failed
+#   3: Package error/ Wrong package
+#   4: Install Error
+# $4: STEP : "running step (only for us): update_psa...",
+# $5: STEP_RESULT : "error and result text",
+# $6: VERSION : "opkg and conf info; what will be updated"
+#
+#endif
+
+#include <QDateTime>
+#include <QDebug>
+
+void IsmasClient::printDebugMessage(int port,
+                                    QString const &clientIP,
+                                    int clientPort,
+                                    QString const &message) {
+    qDebug().noquote()
+        << "\n"
+        << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+        << "hostname ........" << "127.0.0.1"  << "\n"
+        << "port ............" << port << "\n"
+        << "local address ..." << clientIP << "\n"
+        << "local port ......" << clientPort << "\n"
+        << message;
+}
+
+void IsmasClient::printInfoMessage(int port,
+                                   QString const &clientIP,
+                                   int clientPort,
+                                   QString const &message) {
+    qInfo().noquote()
+        << "\n"
+        << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+        << "hostname ........" << "127.0.0.1"  << "\n"
+        << "port ............" << port << "\n"
+        << "local address ..." << clientIP << "\n"
+        << "local port ......" << clientPort << "\n"
+        << message;
+}
+
+void IsmasClient::printErrorMessage(int port,
+                                    QString const &clientIP,
+                                    int clientPort,
+                                    QString const &message) {
+    qCritical().noquote()
+        << "\n"
+        << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+        << "hostname ........" << "127.0.0.1"  << "\n"
+        << "port ............" << port << "\n"
+        << "local address ..." << clientIP << "\n"
+        << "local port ......" << clientPort << "\n"
+        << message;
+}
+
+std::optional<QString>
+IsmasClient::sendRequestReceiveResponse(int port, QString const &request) {
+
+    qInfo() << "REQUEST" << request;
+
+    int sockfd;
+    int r;
+    errno = 0;
+    // socket create and verification
+    if ((sockfd = ::socket(AF_INET, SOCK_STREAM, 0)) == -1) {
+        qCritical().noquote()
+            << "\n"
+            << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+            << "SOCKET CREATION FAILED (" << strerror(errno) << ")";
+        return std::nullopt;
+    }
+
+    struct sockaddr_in servAddr;
+    bzero(&servAddr, sizeof(servAddr));
+    // assign IP, PORT
+    servAddr.sin_family = AF_INET;
+    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
+
+    servAddr.sin_port = htons(port);
+    // connect the client socket to server socket
+    if ((r = ::connect(sockfd, (struct sockaddr *)(&servAddr), sizeof(servAddr))) != 0) {
+        qCritical().noquote()
+            << "\n"
+            << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+            << "CONNECTION WITH SERVER FAILED (" << strerror(r) << ")";
+        ::close(sockfd);
+        return std::nullopt;
+    }
+
+    struct sockaddr_in clientAddr;
+    bzero(&clientAddr, sizeof(clientAddr));
+    socklen_t sockLen = sizeof(clientAddr);
+
+    char clientIP[16];
+    bzero(&clientIP, sizeof(clientIP));
+    getsockname(sockfd, (struct sockaddr *)(&clientAddr), &sockLen);
+    inet_ntop(AF_INET, &clientAddr.sin_addr, clientIP, sizeof(clientIP));
+    unsigned int clientPort = ntohs(clientAddr.sin_port);
+
+    printDebugMessage(port, clientIP, clientPort, QString("CONNECTED TO SERVER"));
+
+    struct timeval tv;
+    tv.tv_sec = 10;  /* 10 secs timeout for read and write */
+
+    struct linger so_linger;
+    so_linger.l_onoff = 1;
+    so_linger.l_linger = 0;
+
+    int maxfdp1;
+    fd_set rset;
+    fd_set wset;
+
+    setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger));
+    // no reliable, but does not harm, as we use select() as well
+    setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
+    setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+    int flag = 1;
+    setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int));
+
+    static char buf[1024*8];
+    bzero(buf, sizeof(buf));
+    int const bytesToWrite = strlen(request.toStdString().c_str());
+    strncpy(buf, request.toStdString().c_str(), sizeof(buf)-1);
+
+    int loop = 0;
+    int bytesWritten = 0;
+    while (bytesWritten < bytesToWrite) {
+        errno = 0;
+        FD_ZERO(&wset);
+        FD_SET(sockfd, &wset);
+        maxfdp1 = sockfd + 1;
+        tv.tv_sec = 60;  /* 60 secs timeout for read and write -> APISM cuts the connection after 30s */
+        tv.tv_usec = 0;
+
+        int const w = select(maxfdp1, NULL, &wset, NULL, &tv);
+        if (w < 0) { // error
+            if (errno == EINTR) {
+                printErrorMessage(port, clientIP, clientPort,
+                    QString("INTERRUPTED BY SIGNAL (1) (") + strerror(errno) + ")");
+                continue;
+            } else {
+                printErrorMessage(port, clientIP, clientPort,
+                        QString("SELECT-ERROR (WRITE) %1(").arg(loop) + strerror(errno) + ")");
+                ::close(sockfd);
+                return std::nullopt;
+            }
+        } else
+        if (w == 0) { // timeout
+            printErrorMessage(port, clientIP, clientPort,
+                    QString("SELECT-TIMEOUT (WRITE) %1(").arg(loop) + strerror(errno) + ")");
+            if (++loop < 10) {
+                QThread::msleep(500);
+                continue;
+            }
+            ::close(sockfd);
+            return std::nullopt;
+        } else
+        if (w > 0) {
+            int n = ::sendto(sockfd, buf+bytesWritten, bytesToWrite-bytesWritten, 0, NULL, 0);
+            if (n >= 0) {
+                bytesWritten += n;
+            } else {
+                if (errno == EWOULDBLOCK) {
+                    if (++loop < 10) {
+                        QThread::msleep(500);
+                        continue;
+                    }
+                    printErrorMessage(port, clientIP, clientPort,
+                        QString("WRITE TIMEOUT %1(").arg(loop) + strerror(errno) + ")");
+                    ::close(sockfd);
+                    return std::nullopt;
+                } else
+                if (errno == EINTR) {
+                    printErrorMessage(port, clientIP, clientPort,
+                        QString("WRITE INTERRUPTED BY SIGNAL (1) (") + strerror(errno) + ")");
+                    continue;
+                }
+            }
+        }
+    }
+
+    // DO NOT USE SHUTDOWN! APISM CAN NOT COPE WITH IT
+    // errno = 0;
+    // if (shutdown(sockfd, SHUT_WR) < 0) {
+    //     printErrorMessage(port, clientIP, clientPort,
+    //        QString("CANNOT CLOSE WRITING END (") + strerror(errno) + ")");
+    // }
+
+    printInfoMessage(port, clientIP, clientPort, QString("MESSAGE SENT <<<") + buf + ">>>");
+
+    loop = 0;
+    bzero(buf, sizeof(buf));
+    int bytesToRead = sizeof(buf)-1;
+    int bytesRead = 0;
+    while (bytesRead < bytesToRead) {
+        errno = 0;
+        FD_ZERO(&rset);
+        FD_SET(sockfd, &rset);
+        maxfdp1 = sockfd + 1;
+        tv.tv_sec = 60;  /* 60 secs timeout for read and write */
+        tv.tv_usec = 0;
+
+        QString const selectStart = QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+
+        int const r = select(maxfdp1, &rset, NULL, NULL, &tv);
+        if (r < 0) { // error
+            if (errno == EINTR) {
+                printErrorMessage(port, clientIP, clientPort,
+                    QString("INTERRUPTED BY SIGNAL (2) (") + strerror(errno) + ")");
+                continue;
+            } else {
+                printErrorMessage(port, clientIP, clientPort,
+                        QString("SELECT-ERROR (READ) %1(").arg(loop) + strerror(errno) + ")");
+                ::close(sockfd);
+                return std::nullopt;
+            }
+        } else
+        if (r == 0) { // timeout
+            printErrorMessage(port, clientIP, clientPort,
+                    QString("SELECT-TIMEOUT (READ) %1(").arg(loop) + strerror(errno) + ")");
+            if (++loop < 10) {
+                QThread::msleep(500);
+                continue;
+            }
+            ::close(sockfd);
+            return std::nullopt;
+        } else
+        if (r > 0) {
+            if (FD_ISSET(sockfd, &rset)) {
+                int n = ::recvfrom(sockfd, buf+bytesRead, bytesToRead-bytesRead,
+                                   0, NULL, NULL);
+                if (n > 0) { //
+                    bytesRead += n;
+                } else
+                if (n == 0) {
+                    // The return value will be 0 when the peer has performed an orderly shutdown.
+                    printErrorMessage(port, clientIP, clientPort,
+                        QString("PEER CLOSED CONNECTION (") + strerror(errno) + ") START AT" +
+                                selectStart + " NOW " + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
+                    ::close(sockfd);
+                    return std::nullopt;
+                } else
+                if (n < 0) {
+                    if (errno == EWOULDBLOCK) { // check just in case
+                        if (++loop < 10) {
+                            QThread::msleep(500);
+                            continue;
+                        }
+                        printErrorMessage(port, clientIP, clientPort,
+                                QString("READ TIMEOUT %1(").arg(loop) + strerror(errno) + ")");
+                        ::close(sockfd);
+                        return std::nullopt;
+                    }
+                    if (errno == EINTR) {
+                        printErrorMessage(port, clientIP, clientPort,
+                            QString("INTERRUPTED BY SIGNAL (2) (") + strerror(errno) + ")");
+                        continue;
+                    }
+                }
+            }
+        }
+
+        printInfoMessage(port, clientIP, clientPort, QString("MESSAGE RECEIVED ") + buf);
+        QString response(buf);
+
+        if (int idx = response.indexOf("{\"error\":\"ISMAS is offline\"}")) {
+            response = response.mid(0, idx);
+        } else
+        if (response.contains("RECORD")) { // RECORD SAVED or RECORD WRITE ABORTED
+            printInfoMessage(port, clientIP, clientPort, QString("IGNORED '") + response + "' RESPONSE");
+            ::close(sockfd);
+            return std::nullopt;
+        }
+
+        QJsonParseError parseError;
+        QJsonDocument document(QJsonDocument::fromJson(response.toUtf8(), &parseError));
+        if (parseError.error == QJsonParseError::NoError) {
+            if (document.isObject()) { // done: received valid APISM response
+                printInfoMessage(port, clientIP, clientPort,
+                   QString("VALID APISM RESPONSE .. \n") + response);
+                ::close(sockfd);
+                return response;
+            } else {
+                printInfoMessage(port, clientIP, clientPort,
+                   QString("CORRUPTED RESPONSE ") + response);
+                ::close(sockfd);
+                return std::nullopt;
+            }
+        } else {
+            printDebugMessage(port, clientIP, clientPort,
+                QString("PARSE ERROR ") + response + " " + parseError.errorString());
+            ::close(sockfd);
+            return std::nullopt;
+        }
+    }
+    return std::nullopt;
+}
+
+QString IsmasClient::updateNewsToIsmas(char const *event,
+                                       int percent,
+                                       int resultCode,
+                                       char const *step,
+                                       char const *step_result,
+                                       char const *version) {
+    char buf[1024];
+    memset(buf, 0, sizeof(buf));
+
+    QString const ts = QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+    snprintf(buf, sizeof(buf)-1,
+        "{"
+            "\"REASON\":\"SW_UP\","
+            "\"TIMESTAMP\":\"%s\","
+            "\"EVENT_ID\":\"0\","
+            "\"EVENT\":\"%s\","
+            "\"EVENTSTATE\":1,"
+            "\"PARAMETER\": {"
+                "\"PERCENT\" : %d,"
+                "\"RESULTCODE\" : %d,"
+                "\"STEP\" : \"%s\","
+                "\"STEP_RESULT\" : \"%s\","
+                "\"VERSION\" : \"%s\""
+            "}"
+        "}", ts.toStdString().c_str(), event, percent, resultCode,
+             step, step_result, version);
+    return buf;
+}
+
+QString IsmasClient::errorBackendNotConnected(QString const &info,
+                                              QString const &version) {
+    return updateNewsToIsmas("U0003",
+                             m_progressInPercent,
+                             RESULT_CODE::INSTALL_ERROR,
+                             "CHECK BACKEND CONNECTIVITY",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::errorGitClone(int percent, QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0003",
+                             percent,
+                             RESULT_CODE::INSTALL_ERROR,
+                             "CLONE CUSTOMER REPOSITORY FAILED",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::backendConnected(QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "CHECK BACKEND CONNECTIVITY",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::execOpkgCommand(QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "EXECUTE OPKG COMMAND",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::rsyncFile(QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "RSYNC FILE",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::updateTriggerSet(QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "CHECK UPDATE TRIGGER",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+
+}
+
+QString IsmasClient::errorUpdateTrigger(QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0003",
+                             m_progressInPercent,
+                             RESULT_CODE::INSTALL_ERROR,
+                             "CHECK UPDATE TRIGGER",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+
+}
+
+QString IsmasClient::updateOfPSASendVersion(PSAInstalled const &psa) {
+    //static int const constexpr SIZE = 4096*8;
+    static char buf[4096*2];
+    memset(buf, 0, sizeof(buf));
+
+    // local data="#M=APISM#C=CMD_SENDVERSION#J=
+    snprintf(buf, sizeof(buf)-1,
+        "{"
+            "\"VERSION_INFO\" : {"
+                "\"REASON\":\"%s\","
+                "\"CREATED\":\"%s\","
+                "\"HASH\":\"%s\""
+            "},"
+            "\"TARIFF\" : {"
+                "\"VERSION\" : \"%s\","
+                "\"PROJECT\" : \"%s\","
+                "\"ZONE\" : %d,"
+                "\"INFO\" : \"%s\","
+                "\"BLOB\" : \"%s\","
+                "\"LAST-COMMIT\" : \"%s\","
+                "\"SIZE\" : %d,"
+                "\"LOADED\" : \"%s\""
+            "},"
+            "\"OPKG_COMMANDS\" : {"
+                "\"BLOB\" : \"%s\","
+                "\"LAST-COMMIT\" : \"%s\","
+                "\"SIZE\" : %d,"
+                "\"LOADED\" : \"%s\""
+            "},"
+            "\"JSON\" : {"
+                "\"DC2C_CASH\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_CONF\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_DEVICE\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_01\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_02\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_03\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_04\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_05\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_06\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_07\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_08\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_09\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_10\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_11\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_12\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_13\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_14\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_15\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_16\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_17\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_18\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_19\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_20\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_21\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_22\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_23\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_24\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_25\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_26\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_27\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_28\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_29\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_30\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_31\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "},"
+                "\"DC2C_PRINT_32\" : {"
+                    "\"BLOB\" : \"%s\","
+                    "\"SIZE\" : %d"
+                "}"
+            "},"
+            "\"HARDWARE\" : {"
+                "\"DEVICES\" : [\"PTU5\", \"DC\", \"PRINTER\", \"BNA\"]"
+            "},"
+            "\"OS\" : {"
+                "\"Linux\": \"%s\""
+            "},"
+            "\"CONFIG\" : {"
+                "\"PTU5\" : {"
+                    "\"CPU_SERIAL\" : \"%s\""
+                "},"
+                "\"DC\" : {"
+                    "\"HW-VERSION\" : \"%s\","
+                    "\"SW-VERSION\" : \"%s\","
+                    "\"SIZE\" : %d,"
+                    "\"GITBLOB\" : \"%s\","
+                    "\"GITLASTCOMMIT\" : \"%s\""
+                "},"
+                "\"PRINTER\" : {"
+                "},"
+                "\"BNA\" : {"
+                "}"
+            "},"
+            "\"SOFTWARE\": {"
+                "\"APISM\" : {"
+                    "\"VERSION\" : \"%s\""
+                "},"
+                "\"ATBQT\" : {"
+                    "\"VERSION\" : \"%s\""
+                "}"
+            "},"
+            "\"PLUGINS\" : {"
+                "\"libATBDeviceControllerPlugin.so\" : {"
+                    "\"VERSION\" : \"%s\""
+                "},"
+                "\"libIngenicoISelf_CCPlugin.so\" : {"
+                    "\"VERSION\" : \"%s\""
+                "},"
+                "\"libMOBILISIS_CalculatePricePlugin.so\" : {"
+                    "\"VERSION\" : \"%s\""
+                "},"
+                "\"libMOBILISIS_CalculatePricePlugin_ConfigUi.so\" : {"
+                    "\"VERSION\" : \"%s\""
+                "},"
+                "\"libPRM_CalculatePricePlugin.so\" : {"
+                    "\"VERSION\" : \"%s\""
+                "},"
+                "\"libPRM_CalculatePricePlugin_ConfigUi.so\" : {"
+                    "\"VERSION\" : \"%s\""
+                "},"
+                "\"libTCP_ZVT_CCPlugin.so\" : {"
+                    "\"VERSION\" : \"%s\""
+                "}"
+            "}"
+        "}",
+        psa.versionInfo.reason.toStdString().c_str(),
+        psa.versionInfo.created.toStdString().c_str(),
+        psa.versionInfo.lastCommit.toStdString().c_str(),
+
+        psa.tariff.version.toStdString().c_str(),
+        psa.tariff.project.toStdString().c_str(),
+        psa.tariff.zone,
+        psa.tariff.info.toStdString().c_str(),
+        psa.tariff.blob.toStdString().c_str(),
+        psa.tariff.lastCommit.toStdString().c_str(),
+        psa.tariff.size,
+        psa.tariff.loadTime.toStdString().c_str(),
+
+        psa.opkg.blob.toStdString().c_str(),
+        psa.opkg.lastCommit.toStdString().c_str(),
+        psa.opkg.size,
+        psa.opkg.loadTime.toStdString().c_str(),
+
+        psa.cash.blob.toStdString().c_str(),
+        psa.cash.size,
+        psa.conf.blob.toStdString().c_str(),
+        psa.conf.size,
+        psa.device.blob.toStdString().c_str(),
+        psa.device.size,
+
+        psa.print[0].blob.toStdString().c_str(),
+        psa.print[0].size,
+        psa.print[1].blob.toStdString().c_str(),
+        psa.print[1].size,
+        psa.print[2].blob.toStdString().c_str(),
+        psa.print[2].size,
+        psa.print[3].blob.toStdString().c_str(),
+        psa.print[3].size,
+        psa.print[4].blob.toStdString().c_str(),
+        psa.print[4].size,
+        psa.print[5].blob.toStdString().c_str(),
+        psa.print[5].size,
+        psa.print[6].blob.toStdString().c_str(),
+        psa.print[6].size,
+        psa.print[7].blob.toStdString().c_str(),
+        psa.print[7].size,
+        psa.print[8].blob.toStdString().c_str(),
+        psa.print[8].size,
+        psa.print[9].blob.toStdString().c_str(),
+        psa.print[9].size,
+        psa.print[10].blob.toStdString().c_str(),
+        psa.print[10].size,
+        psa.print[11].blob.toStdString().c_str(),
+        psa.print[11].size,
+        psa.print[12].blob.toStdString().c_str(),
+        psa.print[12].size,
+        psa.print[13].blob.toStdString().c_str(),
+        psa.print[13].size,
+        psa.print[14].blob.toStdString().c_str(),
+        psa.print[14].size,
+        psa.print[15].blob.toStdString().c_str(),
+        psa.print[15].size,
+        psa.print[16].blob.toStdString().c_str(),
+        psa.print[16].size,
+        psa.print[17].blob.toStdString().c_str(),
+        psa.print[17].size,
+        psa.print[18].blob.toStdString().c_str(),
+        psa.print[18].size,
+        psa.print[19].blob.toStdString().c_str(),
+        psa.print[19].size,
+        psa.print[20].blob.toStdString().c_str(),
+        psa.print[20].size,
+        psa.print[21].blob.toStdString().c_str(),
+        psa.print[21].size,
+        psa.print[22].blob.toStdString().c_str(),
+        psa.print[22].size,
+        psa.print[23].blob.toStdString().c_str(),
+        psa.print[23].size,
+        psa.print[24].blob.toStdString().c_str(),
+        psa.print[24].size,
+        psa.print[25].blob.toStdString().c_str(),
+        psa.print[25].size,
+        psa.print[26].blob.toStdString().c_str(),
+        psa.print[26].size,
+        psa.print[27].blob.toStdString().c_str(),
+        psa.print[27].size,
+        psa.print[28].blob.toStdString().c_str(),
+        psa.print[28].size,
+        psa.print[29].blob.toStdString().c_str(),
+        psa.print[29].size,
+        psa.print[30].blob.toStdString().c_str(),
+        psa.print[30].size,
+        psa.print[31].blob.toStdString().c_str(),
+        psa.print[31].size,
+
+        psa.hw.linuxVersion.toStdString().c_str(),
+        psa.hw.cpuSerial.toStdString().c_str(),
+
+        psa.dc.versionHW.toStdString().c_str(),
+        psa.dc.versionSW.toStdString().c_str(),
+        psa.dc.size,
+        psa.dc.gitBlob.toStdString().c_str(),
+        psa.dc.gitLastCommit.toStdString().c_str(),
+
+        psa.sw.apismVersion.toStdString().c_str(),
+        psa.sw.atbQTVersion.toStdString().c_str(),
+
+        psa.pluginVersion.deviceController.toStdString().c_str(),
+        psa.pluginVersion.ingenicoISelfCC.toStdString().c_str(),
+        psa.pluginVersion.mobilisisCalculatePrice.toStdString().c_str(),
+        psa.pluginVersion.mobilisisCalculatePriceConfigUi.toStdString().c_str(),
+        psa.pluginVersion.prmCalculatePrice.toStdString().c_str(),
+        psa.pluginVersion.prmCalculatePriceConfigUi.toStdString().c_str(),
+        psa.pluginVersion.tcpZVT.toStdString().c_str());
+
+    qInfo() << buf;
+
+    return buf;
+}
+
+QString IsmasClient::updateOfPSAContinues(QString currentStage,
+                                          QString currentStageInfo,
+                                          QString const &version) {
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             currentStage.toStdString().c_str(),
+                             currentStageInfo.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::updateOfPSAStarted(QString const &version) {
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "START",
+                             "detected WAIT state: start update process",
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::checkoutBranch(QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "BRANCH-CHECKOUT",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::cloneAndCheckoutCustomerRepository(QString const &info, QString const &version) { // clone and checkout customer repository
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "CLONE-CHECKOUT",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::gitFetch(QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0010",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "GIT-FETCH",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::errorGitFetch(int resultCode, QString const &info, QString const &version) {
+    return updateNewsToIsmas("U0003",
+                             m_progressInPercent,
+                             resultCode,
+                             "GIT-FETCH-FAILED",
+                             info.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::updateOfPSAActivated(QString const &version) {   // sent even after success
+    m_progressInPercent = 0;
+    return updateNewsToIsmas("U0002",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "UPDATE ACTIVATED",
+                             "reset WAIT state",
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::updateOfPSASucceeded(QString const &version) {
+    m_progressInPercent = 100;
+    return updateNewsToIsmas("U0001",
+                             m_progressInPercent,
+                             RESULT_CODE::SUCCESS,
+                             "UPDATE SUCCESS",
+                             "update process succeeded",
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::sanityCheckFailed(int resultCode, QString reason, QString const &version) {
+    return updateNewsToIsmas("U0003",
+                             m_progressInPercent,
+                             resultCode,
+                             "SANITY-CHECK-FAILED",
+                             reason.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+QString IsmasClient::jsonParseFailed(int resultCode, QString reason, QString const &version) {
+    return updateNewsToIsmas("U0003",
+                             m_progressInPercent,
+                             resultCode,
+                             "JSON-PARSE-ERROR",
+                             reason.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+std::optional<QString> IsmasClient::finalResult(int resultCode, QString reason, QString const &version) {
+    m_progressInPercent = 100;
+    if (resultCode == RESULT_CODE::SUCCESS) {
+        return updateNewsToIsmas("U0002",
+                                 m_progressInPercent,
+                                 resultCode,
+                                 "FINAL-UPDATE-RESULT",
+                                 reason.toStdString().c_str(),
+                                 version.toStdString().c_str());
+    }
+    if (resultCode == RESULT_CODE::INSTALL_ERROR) {
+        return updateNewsToIsmas("U0003",
+                                 m_progressInPercent,
+                                 resultCode,
+                                 "FINAL-UPDATE-RESULT",
+                                 reason.toStdString().c_str(),
+                                 version.toStdString().c_str());
+    }
+    return std::nullopt;
+}
+
+QString IsmasClient::updateOfPSAFailed(int resultCode, QString step,
+                                       QString reason, QString const &version) {
+    return updateNewsToIsmas("U0003",
+                             m_progressInPercent,
+                             resultCode,
+                             step.toStdString().c_str(),
+                             reason.toStdString().c_str(),
+                             version.toStdString().c_str());
+}
+
+char const *IsmasClient::reason[REASON::ENTRIES] = {
+    "TIME-TRIGGERED", "SERVICE", "DEV-TEST"
+};
+
+QString IsmasClient::getReasonForLastSendVersion() {
+    QString const &parentName = Utils::getParentName();
+    if (parentName == "ATBQT") {
+        return reason[REASON::SERVICE];
+    }
+    if (parentName == "systemd") {
+        return reason[REASON::TIME_TRIGGERED];
+    }
+    return reason[REASON::DEV_TEST];
+}

ismas/ismas_client.h

@@ -0,0 +1,206 @@
+#ifndef ISMAS_CLIENT_H_INCLUDED
+#define ISMAS_CLIENT_H_INCLUDED
+
+#include <QObject>
+#include <QString>
+
+#include <optional>
+
+struct PSAInstalled {
+    struct VersionInfo {
+        QString created;
+        QString reason;
+        QString lastCommit;
+    } versionInfo;
+
+    struct Tariff {
+        QString name;
+        QString version;
+        QString project;
+        int zone;
+        int size;
+        QString blob;
+        QString lastCommit;
+        QString info;
+        QString loadTime;
+    } tariff;
+
+    struct HardWare {
+        QString linuxVersion;
+        QString cpuSerial;
+    } hw;
+
+    struct Opkg {
+        int size;
+        QString blob;
+        QString lastCommit;
+        QString loadTime;
+    } opkg;
+
+    struct DC {
+        QString versionHW;
+        QString versionSW;
+        QString gitBlob;
+        QString gitLastCommit;
+        int size;
+    } dc;
+
+    struct SoftWare {
+        QString apismVersion;
+        QString atbQTVersion;
+    } sw;
+
+    struct PluginVersion {
+        QString deviceController;
+        QString ingenicoISelfCC;
+        QString mobilisisCalculatePrice;
+        QString mobilisisCalculatePriceConfigUi;
+        QString prmCalculatePrice;
+        QString prmCalculatePriceConfigUi;
+        QString tcpZVT;
+    } pluginVersion;
+
+    struct DC2C {
+        QString name;
+        QString blob;
+        int size;
+    };
+
+    DC2C cash;
+    DC2C conf;
+    DC2C device;
+
+    DC2C print[32];
+
+    explicit PSAInstalled() {
+        tariff.name = "N/A";
+        tariff.version = "N/A";
+        tariff.project = "N/A";
+        tariff.zone = -1;
+        tariff.size = -1;
+        tariff.blob = "N/A";
+        tariff.info = "N/A";
+        tariff.loadTime = "N/A";
+
+        hw.linuxVersion = "N/A";
+        hw.cpuSerial = "N/A";
+
+        opkg.size = -1;
+        opkg.blob = "N/A";
+        opkg.lastCommit = "N/A";
+        opkg.loadTime = "N/A";
+
+        dc.versionHW = "N/A";
+        dc.versionSW = "N/A";
+        dc.gitBlob = "N/A";
+        dc.gitLastCommit = "N/A";
+        dc.size = -1;
+
+        sw.apismVersion = "N/A";
+        sw.atbQTVersion = "N/A";
+
+        pluginVersion.deviceController = "N/A";
+        pluginVersion.ingenicoISelfCC = "N/A";
+        pluginVersion.mobilisisCalculatePrice = "N/A";
+        pluginVersion.mobilisisCalculatePriceConfigUi = "N/A";
+        pluginVersion.prmCalculatePrice = "N/A";
+        pluginVersion.prmCalculatePriceConfigUi = "N/A";
+        pluginVersion.tcpZVT = "N/A";
+
+        cash.name = "N/A";
+        cash.blob = "N/A";
+        cash.size = -1;
+
+        conf.name = "N/A";
+        conf.blob = "N/A";
+        conf.size = -1;
+
+        device.size = -1;
+        device.blob = "N/A";
+        device.size = -1;
+
+        for (int i=0; i < 32; ++i) {
+            print[i].size = -1;
+            print[i].blob = "N/A";
+            print[i].size = -1;
+        }
+    }
+};
+
+class IsmasClient : public QObject {
+    Q_OBJECT
+
+    int m_progressInPercent;
+public:
+    explicit IsmasClient() : m_progressInPercent(1) {}
+
+    enum APISM {
+        DB_PORT = 7777,
+        DIRECT_PORT = 7778
+    };
+
+
+    enum RESULT_CODE {
+        SUCCESS=0,
+        NO_UPDATE_NECESSARY=1,
+        BACKUP_FAILED=2,
+        WRONG_PACKAGE=3,
+        INSTALL_ERROR=4};
+
+    enum REASON {
+        TIME_TRIGGERED = 0,
+        SERVICE,
+        DEV_TEST,
+        ENTRIES
+    };
+
+    static char const *reason[REASON::ENTRIES];
+
+    static std::optional<QString>
+        sendRequestReceiveResponse(int port, QString const &request);
+
+    static QString getReasonForLastSendVersion();
+
+    int getProgressInPercent() const {return m_progressInPercent; }
+    void setProgressInPercent(int procent) { m_progressInPercent = procent; }
+
+    QString updateNewsToIsmas(char const *event,
+                              int percent,
+                              int resultCode,
+                              char const *step,
+                              char const *step_result,
+                              char const *version);
+
+    QString updateOfPSAStarted(QString const &version = QString());   // start of update process
+    QString cloneAndCheckoutCustomerRepository(QString const &info, QString const &version = QString());   // clone and checkout customer repository
+    QString checkoutBranch(QString const &info, QString const &version = QString());   // checkout branch
+    QString errorBackendNotConnected(QString const &info, QString const &version = QString());   // checkout branch
+    QString errorGitClone(int percent, QString const &info, QString const &version = QString());
+    QString backendConnected(QString const &info, QString const &version = QString());
+    QString updateTriggerSet(QString const &info, QString const &version = QString());
+    QString errorUpdateTrigger(QString const &info, QString const &version = QString());
+    QString gitFetch(QString const &info, QString const &version = QString());
+    QString execOpkgCommand(QString const &info, QString const &version = QString());
+    QString rsyncFile(QString const &info, QString const &version = QString());
+    QString errorGitFetch(int resultCode, QString const &info, QString const &version = QString());
+    QString updateOfPSAActivated(QString const &version = QString());
+                                    // and update accepted
+    QString updateOfPSASucceeded(QString const &version = QString()); // update process succeeded
+    QString updateOfPSAContinues(QString currentStage, QString currentStageInfo, QString const &version = QString());
+    QString updateOfPSAFailed(int resultCode, QString step, QString reason, QString const &version = QString());
+    QString sanityCheckFailed(int resultCode, QString reason, QString const &version = QString());
+    QString jsonParseFailed(int resultCode, QString reason, QString const &version = QString());
+    std::optional<QString> finalResult(int resultCode, QString reason, QString const &version = QString());
+
+    QString updateOfPSASendVersion(PSAInstalled const &psa);
+
+  private:
+    static void printDebugMessage(int port, QString const &clientIP, int clientPort,
+                                  QString const &message);
+    static void printInfoMessage(int port, QString const &clientIP, int clientPort,
+                                 QString const &message);
+    static void printErrorMessage(int port, QString const &clientIP, int clientPort,
+                                  QString const &message);
+};
+
+#endif // ISMAS_CLIENT_H_INCLUDED

main.cpp

@@ -4,14 +4,40 @@
 #include <QTimer>
 #include <QFileInfo>
 
-#include "message_handler.h"
-#include "interfaces.h"
+#ifdef __linux__
+#include <stdlib.h> // system()
+#endif
 
-#include "DCPlugin/include/hwapi.h"
+#include "message_handler.h"
+#include "plugins/interfaces.h"
 
 #include <unistd.h>
-#include <thread>
 #include <memory>
+#include <QSharedMemory>
+#include <QRunnable>
+#include <QThreadPool>
+#include <QDir>
+#include <QProcess>
+#include <QCommandLineParser>
+#include <QStandardPaths>
+#include <QMainWindow>
+
+#include "update.h"
+#include "git/git_client.h"
+#include "ismas/ismas_client.h"
+#include "worker_thread.h"
+#include "worker.h"
+#include "mainwindow.h"
+#include "utils.h"
+
+#include <QThread>
+#include <QtWidgets>
+#include <QScopedPointer>
+
+#if defined (Q_OS_UNIX) || defined (Q_OS_LINUX)
+#include <unistd.h>
+#include <errno.h>
+#endif
 
 #ifdef PTU5
 #define SERIAL_PORT "ttymxc2"
@@ -19,70 +45,143 @@
 #define SERIAL_PORT "ttyUSB0"
 #endif
 
-static void updateBinary(std::unique_ptr<hwinf> hw,     // update d2dc*.bin
-                         char const *fileToSendToDC,
-                         char const *baudrate,
-                         char const *serialInterface) {
-    for (int i=0; i < 1;++i) {
-        hw->dc_updateDC(fileToSendToDC, baudrate, serialInterface);
-        std::this_thread::sleep_for(std::chrono::milliseconds(3000));
-    }
-    QCoreApplication::quit();
-}
-
-static void updatePrinterConf(std::unique_ptr<hwinf> hw, // update printer-file
-                              QVector<int> nrOfTemplate,
-                              QVector<QString> fileToSendToDC,
-                              QString br, QString serial) {
-    for (int i=0; i < 1;++i) {
-        hw->dc_updatePrinterTemplate(hwapi::FileTypeJson::PRINTER,
-                                     nrOfTemplate, fileToSendToDC,
-                                     br, serial);
-
-        hw->dc_printTemplate(hwapi::FileTypeJson::PRINTER,
-                             nrOfTemplate, br, serial);
-    }
-    QCoreApplication::quit();
-}
-
 // argv[1]: file to send to dc
 int main(int argc, char *argv[]) {
+    QByteArray const value = qgetenv("LC_ALL");
+    if (value != "C") {
+        qputenv("LC_ALL", "C");
+    }
+    // qputenv("XDG_RUNTIME_DIR", "/run/user/0");
+
+    openlog("ATB-UPDATE", LOG_PERROR | LOG_PID | LOG_CONS, LOG_USER);
+
     QApplication a(argc, argv);
+    QApplication::setApplicationName("ATBUpdateTool");
+    QApplication::setApplicationVersion(APP_VERSION);
 
     if (!messageHandlerInstalled()) { // change internal qt-QDebug-handling
         atbInstallMessageHandler(atbDebugOutput);
-        setDebugLevel(QtMsgType::QtDebugMsg);
-        //setDebugLevel(QtMsgType::QtDebugMsg);
+        setDebugLevel(LOG_NOTICE);
     }
 
-    if (argc > 2) {
-        qCritical() << "Usage: " << argv[0] << "<file to send to dc>";
-        return -1;
+//#if defined (Q_OS_UNIX) || defined (Q_OS_LINUX)
+//#ifdef _POSIX_THREAD_PROCESS_SHARED
+//    errno = 0;
+//    int res = 0;
+//    if ((res = sysconf(_SC_THREAD_PROCESS_SHARED)) < 0) {
+//        if (errno != 0) {
+//            qCritical() << "_POSIX_THREAD_PROCESS_SHARED NOT SUPPORTED"
+//                        << strerror(errno);
+//            exit(-1);
+//        }
+//    } else {
+//        if (res == _POSIX_THREAD_PROCESS_SHARED) {
+//            Utils::printInfoMsg("_POSIX_THREAD_PROCESS_SHARED SUPPORTED");
+//        }
+//    }
+//#endif
+//#endif
+
+    QCommandLineParser parser;
+    parser.setApplicationDescription("Download tool for downloading device controller firmware, printer json-files and executing opkg-commands.");
+    parser.addHelpOption();
+    parser.addVersionOption();
+
+    QCommandLineOption pluginDirectoryOption(QStringList() << "plugin-directory" << "plugin-directory",
+        QCoreApplication::translate("main", "Where to find dc-plugin."),
+        QCoreApplication::translate("main", "directory"));
+    QString const pluginDefault = "/usr/lib";
+    pluginDirectoryOption.setDefaultValue(pluginDefault);
+    parser.addOption(pluginDirectoryOption);
+
+    QCommandLineOption pluginNameOption(QStringList() << "plugin-name" << "plugin-name",
+        QCoreApplication::translate("main", "Name of dc-plugin."),
+        QCoreApplication::translate("main", "directory"));
+    QString const pluginNameDefault = "libCAmaster.so";
+    pluginNameOption.setDefaultValue(pluginNameDefault);
+    parser.addOption(pluginNameOption);
+
+    QCommandLineOption workingDirectoryOption(QStringList() << "working-directory" << "working-directory",
+        QCoreApplication::translate("main", "working directory of update-script."),
+        QCoreApplication::translate("main", "directory"));
+    QString const workingDirectoryDefault = "/opt/app/tools/atbupdate";
+    workingDirectoryOption.setDefaultValue(workingDirectoryDefault);
+    parser.addOption(workingDirectoryOption);
+
+    QCommandLineOption dryRunOption(QStringList() << "d" << "dry-run",
+        QCoreApplication::translate("main", "Start ATBUpdateTool in dry-run-mode. No actual actions."));
+    parser.addOption(dryRunOption);
+
+    // Process the actual command line arguments given by the user
+    parser.process(a);
+    QString plugInDir = parser.value(pluginDirectoryOption);
+    QString plugInName = parser.value(pluginNameOption);
+    QString workingDir = parser.value(workingDirectoryOption);
+    bool dryRun = parser.isSet(dryRunOption);
+    QString const rtPath = QCoreApplication::applicationDirPath();
+
+    if (!QDir(plugInDir).exists()) {
+        qCritical() << plugInDir
+                    << "does not exists, but has to contain dc-library";
+        exit(-1);
     }
 
-    std::unique_ptr<hwinf> hw(new hwapi());
-    QFileInfo fileInfo(argv[1]);
-    QString fname(fileInfo.fileName());
-    int ret = 0;
+    qInfo() << "pwd ..............." << rtPath;
+    qInfo() << "plugInDir ........." << plugInDir;
+    qInfo() << "plugInName ........" << plugInName;
+    qInfo() << "workingDir ........" << workingDir;
+    qInfo() << "dryRun ............" << dryRun;
 
-    if (fname.startsWith("dc") && fname.endsWith(".bin")) {
-        std::thread t(updateBinary, std::move(hw),
-                      fname.toStdString().c_str(), "115200", SERIAL_PORT);
-        ret = a.exec();
-        t.join();
-    } else {
-        QVector<QString> fnames{"DC2C_print01.json",
-                                "DC2C_print02.json",
-                                "DC2C_print03.json"};
-        QVector<int> templateIdx{1,2,3};
-        //if (fname.startsWith("DC2C_print") && fname.endsWith(".json")) {
-        //int const nrOfTemplate = fname.midRef(10, 2).toInt();
-        std::thread t(updatePrinterConf, std::move(hw), templateIdx, fnames,
-                     "115200", SERIAL_PORT);
-        ret = a.exec();
-        t.join();
-        //}
-    }
+    // before loading the library, delete all possible shared memory segments
+#if defined Q_OS_LINUX || defined Q_OS_UNIX
+    // system("rm -rf /tmp/qipc*");
+#else
+#error "Only tested under UNIX/LINUX"
+#endif
 
-    return ret;
+    hwinf *hw = Update::loadDCPlugin(QDir(plugInDir), plugInName);
+    hw->dc_autoRequest(true);
+    // hw->dc_openSerial(5, "115200", "ttymxc2", 1);
+
+    int machineNr = Utils::read1stLineOfFile("/etc/machine_nr");
+    int customerNr = Utils::read1stLineOfFile("/etc/cust_nr");
+    int zoneNr = Utils::read1stLineOfFile("/etc/zone_nr");
+    QString const branchName = (zoneNr != 0)
+            ? QString("zg1/zone%1").arg(zoneNr) : "master";
+
+    QThread::currentThread()->setObjectName("main thread");
+    qInfo() << "Main thread" << QThread::currentThreadId();
+
+    Worker worker(customerNr,
+                  machineNr,
+                  zoneNr,
+                  branchName,
+                  plugInName,
+                  workingDir,
+                  dryRun);
+
+    QString const customerNrStr(
+        QString("customer_") + QString::number(customerNr).rightJustified(3, '0'));
+
+    QScopedPointer<Update> update(
+        new Update(hw,
+                   &worker,
+                   QDir::cleanPath(workingDir + QDir::separator() + customerNrStr),
+                   customerNrStr,
+                   branchName,
+                   plugInName,
+                   workingDir,
+                   dryRun,
+                   nullptr,
+                   SERIAL_PORT,
+                   "115200"));
+
+    MainWindow mw(hw, &worker, update.get());
+    worker.setMainWindow(&mw);
+
+    mw.setWindowFlags(Qt::Window | Qt::FramelessWindowHint);
+    mw.setWindowState(Qt::WindowFullScreen);
+    mw.show();
+
+    return a.exec();
 }

main.cpp.bck

@@ -0,0 +1,81 @@
+#include <QCoreApplication>
+#include <QApplication>
+#include <QDebug>
+#include <QTimer>
+#include <QFileInfo>
+
+#include "message_handler.h"
+#include "plugins/interfaces.h"
+
+#include "DCPlugin/include/hwapi.h"
+
+#include <unistd.h>
+#include <thread>
+#include <memory>
+
+static void updateBinary(std::unique_ptr<hwinf> hw,     // update d2dc*.bin
+                         char const *fileToSendToDC,
+                         char const *baudrate,
+                         char const *serialInterface) {
+    for (int i=0; i < 1;++i) {
+        hw->dc_updateDC(fileToSendToDC, baudrate, serialInterface);
+        std::this_thread::sleep_for(std::chrono::milliseconds(3000));
+    }
+    QCoreApplication::quit();
+}
+
+static void updatePrinterConf(std::unique_ptr<hwinf> hw, // update printer-file
+                              char const *fileToSendToDC,
+                              char const *baudrate,
+                              char const *serialInterface) {
+    for (int i=0; i < 1;++i) {
+        hw->dc_updateDC(fileToSendToDC, baudrate, serialInterface);
+        std::this_thread::sleep_for(std::chrono::milliseconds(3000));
+    }
+    QCoreApplication::quit();
+}
+
+int main(int argc, char *argv[]) {
+    QApplication a(argc, argv);
+
+    if (!messageHandlerInstalled()) { // change internal qt-QDebug-handling
+        atbInstallMessageHandler(atbDebugOutput);
+        setDebugLevel(QtMsgType::QtDebugMsg);
+        //setDebugLevel(QtMsgType::QtDebugMsg);
+    }
+
+    if (argc > 2) {
+        qCritical() << "Usage: " << argv[0] << "<file to send to dc>";
+        return -1;
+    }
+
+    std::unique_ptr<hwinf> hw(new hwapi());
+    QFileInfo fileInfo(argv[1]);
+    QString fname(fileInfo.fileName());
+    int ret = 0;
+
+    if (fname.startsWith("dc") && fname.endsWith(".bin")) {
+#ifdef PTU5
+        std::thread t(updateBinary, std::move(hw),
+                      fname.toStdString().c_str(), "115200", "ttymxc2");
+#else
+        std::thread t(updateBinary, std::move(hw),
+                      fname.toStdString().c_str(), "115200", "ttyUSB0");
+#endif
+        ret = a.exec();
+        t.join();
+    } else
+    if (fname.startsWith("DC") && fname.endsWith(".json")) {
+#ifdef PTU5
+        std::thread t(updatePrinterConf, std::move(hw),
+                      fname.toStdString().c_str(), "115200", "ttymxc2");
+#else
+        std::thread t(updatePrinterConf, std::move(hw),
+                      fname.toStdString().c_str(), "115200", "ttyUSB0");
+#endif
+        ret = a.exec();
+        t.join();
+    }
+
+    return ret;
+}

main.cpp.bck2

@@ -0,0 +1,54 @@
+#include <QCoreApplication>
+#include <QApplication>
+#include <QDebug>
+#include <QTimer>
+#include <QFileInfo>
+
+#include "message_handler.h"
+#include "interfaces.h"
+#include "DCPlugin/include/hwapi.h"
+
+#include <unistd.h>
+#include <thread>
+#include <memory>
+#include <QSharedMemory>
+#include <QRunnable>
+#include <QThreadPool>
+#include <QDir>
+
+#include "update.h"
+#include "worker_thread.h"
+#include "worker.h"
+
+#ifdef PTU5
+#define SERIAL_PORT "ttymxc2"
+#else
+#define SERIAL_PORT "ttyUSB0"
+#endif
+
+// argv[1]: file to send to dc
+int main(int argc, char *argv[]) {
+    QApplication a(argc, argv);
+
+    if (!messageHandlerInstalled()) { // change internal qt-QDebug-handling
+        atbInstallMessageHandler(atbDebugOutput);
+        setDebugLevel(QtMsgType::QtDebugMsg);
+        //setDebugLevel(QtMsgType::QtDebugMsg);
+    }
+
+    QByteArray const value = qgetenv("XDG_RUNTIME_DIR");
+    if (value.size() == 0) {
+        qputenv("XDG_RUNTIME_DIR", "/run/user/0");
+    }
+
+    QString const update_ctrl_file = "/opt/app/tools/atbupdate/update_log.csv";
+    QString const workingDir = (argc == 2) ? argv[1] : ".";
+
+    Worker worker(update_ctrl_file, workingDir);
+
+    qCritical() << "starting main event loop";
+    int ret = a.exec();
+    qCritical() << "stopping main event loop" << ret;
+
+    return ret;
+}

main.cpp.bck3

@@ -0,0 +1,62 @@
+#include <QCoreApplication>
+#include <QApplication>
+#include <QDebug>
+#include <QTimer>
+#include <QFileInfo>
+
+#include "message_handler.h"
+#include "plugins/interfaces.h"
+
+#include <unistd.h>
+#include <thread>
+#include <memory>
+#include <QSharedMemory>
+#include <QRunnable>
+#include <QThreadPool>
+#include <QDir>
+
+#include "update.h"
+#include "worker_thread.h"
+#include "worker.h"
+
+#include <thread>
+
+#ifdef PTU5
+#define SERIAL_PORT "ttymxc2"
+#else
+#define SERIAL_PORT "ttyUSB0"
+#endif
+
+static void doWork(QString update_ctrl_file, QString workingDir) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+    Update update(update_ctrl_file, workingDir);
+    update.doUpdate();
+    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+    QCoreApplication::quit();
+}
+
+// argv[1]: file to send to dc
+int main(int argc, char *argv[]) {
+    QApplication a(argc, argv);
+
+    if (!messageHandlerInstalled()) { // change internal qt-QDebug-handling
+        atbInstallMessageHandler(atbDebugOutput);
+        setDebugLevel(QtMsgType::QtDebugMsg);
+        //setDebugLevel(QtMsgType::QtDebugMsg);
+    }
+
+    QByteArray const value = qgetenv("XDG_RUNTIME_DIR");
+    if (value.size() == 0) {
+        qputenv("XDG_RUNTIME_DIR", "/run/user/0");
+    }
+
+    // QString const update_ctrl_file = "/opt/app/tools/atbupdate/update_log.csv";
+    // QString const workingDir = (argc == 2) ? argv[1] : ".";
+
+    // std::thread t(doWork, update_ctrl_file, workingDir);
+
+    int ret = a.exec();
+    // t.join();
+
+    return ret;
+}

mainwindow.cpp

@@ -0,0 +1,427 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+#include "worker.h"
+#include "utils.h"
+#include "progress_event.h"
+#include "update_dc_event.h"
+#include "plugins/interfaces.h"
+
+#include <QDateTime>
+#include <QMessageBox>
+#include <QDebug>
+#include <QScrollBar>
+
+
+
+#if EMERGENCY_LEAVE_BL==1
+static int step = 0;
+
+void MainWindow::emergencyLeaveBL() {
+    //
+    qCritical() << __func__ << step;
+    switch(step) {
+    case 0:
+        if (m_hw->dc_openSerial(5, "115200", "ttymxc2", 1)) {
+            qCritical() << __func__ << "open ok";
+            step++;
+            QThread::msleep(2000);
+            m_hw->dc_autoRequest(false);
+            emit leaveBL();
+        }
+        break;
+    case 1:
+        m_hw->bl_rebootDC();
+        QThread::msleep(1000);
+        qCritical() << __func__ << "reboot ok" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        step++;
+        emit leaveBL();
+        break;
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+        m_hw->bl_startBL();
+        QThread::msleep(1000);
+        qCritical() << __func__ << "start" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        step++;
+        emit leaveBL();
+        break;
+    case 7:
+    case 9:
+    case 11:
+    case 13:
+    case 15:
+        m_hw->bl_checkBL();
+        qCritical() << __func__ << "check" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        QThread::msleep(1500);
+        ++step;
+        emit leaveBL();
+        break;
+    case 8:
+    case 10:
+    case 12:
+    case 14:
+    case 16:
+        qCritical() << __func__ << "is Up..." << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        if (m_hw->bl_isUp()) {
+            qCritical() << __func__ << "is Up...OK" << step << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+            QThread::msleep(5000);
+            step = 16;
+        } else {
+            qCritical() << __func__ << "is Up...NO" << step << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        }
+        ++step;
+        emit leaveBL();
+        break;
+    case 17:
+    case 18:
+    case 19:
+        qCritical() << __func__ << "stop" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+        m_hw->bl_stopBL();
+        QThread::msleep(1000);
+        //m_hw->dc_closeSerial();
+        ++step;
+        emit leaveBL();
+        break;
+    }
+}
+#endif
+
+MainWindow::MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *parent)
+    : QMainWindow(parent)
+    , ui(new Ui::MainWindow)
+    , m_hw(hw)
+    , m_worker(worker)
+    , m_width(70)
+    , m_progressRunning(false)
+    , m_progressValue(0)
+    , m_update(update)
+    , m_updateStep(UpdateDcEvent::UpdateStep::NONE) {
+
+#if EMERGENCY_LEAVE_BL==1
+    QTimer *t = new QTimer(this);
+    connect(t, SIGNAL(timeout()), this, SLOT(emergencyLeaveBL()));
+    connect(this, SIGNAL(leaveBL()), this, SLOT(emergencyLeaveBL()), Qt::QueuedConnection);
+    t->setSingleShot(true);
+    t->start(1000);
+    return;
+#endif
+
+    this->setStatusBar(new QStatusBar(this));
+    QFont f;
+    f.setStyleHint(QFont::Monospace);
+    f.setWeight(QFont::Bold);
+    f.setFamily("Misc Fixed");
+    f.setPixelSize(12);
+    this->statusBar()->setFont(f);
+
+    ui->setupUi(this);
+
+    ui->updateProgress->setRange(0, 100);
+    ui->updateProgress->reset();
+
+    QStringList lst;
+    QString start = QDateTime::currentDateTime().toString(Qt::ISODate);
+    lst << QString("Start: ") + start.leftJustified(m_width-10);
+    lst << QString("").leftJustified(m_width-3, '=');
+    lst << QString("Machine number  : %1 ").arg(m_worker->machineNr()).leftJustified(m_width-3);
+    lst << QString("Customer number : %1 ").arg(m_worker->customerNr()).leftJustified(m_width-3);
+    lst << QString("Zone number     : %1 (%2)").arg(m_worker->zoneNr()).arg(Utils::zoneName(m_worker->zoneNr())).leftJustified(m_width-3);
+    lst << QString("APISM version   : %1").arg(m_worker->apismVersion()).leftJustified(m_width-3);
+    lst << QString("").leftJustified(m_width-3, '=');
+
+
+    ui->updateStatus->setText(lst.join('\n'));
+    ui->updateStatus->setEnabled(true);
+
+    m_startTimer = new QTimer(this);
+    connect(m_startTimer, SIGNAL(timeout()), m_worker, SLOT(update()));
+    m_startTimer->setSingleShot(true);
+    m_startTimer->start(1000);
+
+    m_exitTimer = new QTimer(this);
+    connect(m_exitTimer, SIGNAL(timeout()), ui->exit, SLOT(click()));
+    m_exitTimer->setSingleShot(true);
+    m_exitTimer->start(1800 * 1000);
+
+    connect(ui->exit, SIGNAL(clicked()),this,SLOT(onQuit()));
+    connect(m_worker, SIGNAL(disableExit()),this,SLOT(onDisableExit()));
+    connect(m_worker, SIGNAL(enableExit()),this,SLOT(onEnableExit()));
+    connect(m_worker, SIGNAL(stopStartTimer()),this,SLOT(onStopStartTimer()));
+    connect(m_worker, SIGNAL(restartExitTimer()),this,SLOT(onRestartExitTimer()));
+    connect(m_worker, SIGNAL(appendText(QString,QString)),this,SLOT(onAppendText(QString,QString)));
+    connect(m_worker, SIGNAL(showErrorMessage(QString,QString)),this, SLOT(onShowErrorMessage(QString,QString)));
+    connect(m_worker, SIGNAL(showStatusMessage(QString,QString)),this, SLOT(onShowStatusMessage(QString,QString)));
+    connect(m_worker, SIGNAL(replaceLast(QString,QString)),this,SLOT(onReplaceLast(QString,QString)));
+    connect(m_worker, SIGNAL(replaceLast(QStringList,QString)),this, SLOT(onReplaceLast(QStringList,QString)));
+}
+
+MainWindow::~MainWindow() {
+    delete m_startTimer;
+    delete m_exitTimer;
+    delete ui;
+}
+
+void MainWindow::customEvent(QEvent *event) {
+    if (event->type() == ProgressEvent::type()) {
+        ProgressEvent *pevent = (ProgressEvent *)event;
+        int const progress = pevent->progressPercent();
+        QObject const *sender = pevent->sender();
+        if (sender == this) {
+            switch(progress) {
+            case 0: {
+                ui->updateProgress->reset();
+            } break;
+            case START_PROGRESS_LOOP: {
+                m_progressRunning = true;
+                ui->updateProgress->reset();
+                m_progressValue = 10;
+                QApplication::postEvent(this, new ProgressEvent(this, m_progressValue));
+            } break;
+            case STOP_PROGRESS_LOOP: {
+                m_progressRunning = false;
+                m_progressValue -= 10;
+                m_worker->setProgress(m_progressValue/10);
+            } break;
+            default: {
+                    if (m_progressRunning) {
+                        m_progressValue = progress;
+                        ui->updateProgress->setValue(progress/10);
+                        QApplication::postEvent(this, new ProgressEvent(this, progress+10));
+                        QThread::msleep(500);
+                    }
+                }
+            }
+        } else
+        if (sender == m_worker) {
+            switch(progress) {
+            case 0: {
+                ui->updateProgress->reset();
+            } break;
+            case START_PROGRESS_LOOP: {
+                QApplication::postEvent(this, new ProgressEvent(this, START_PROGRESS_LOOP));
+            } break;
+            case STOP_PROGRESS_LOOP: {
+                QApplication::postEvent(this, new ProgressEvent(this, STOP_PROGRESS_LOOP));
+            } break;
+            default:{
+                ui->updateProgress->setValue(progress);
+            }}
+        } else {
+            qCritical() << "!!! UNKNOWN SENDER !!!";
+        }
+    } else
+    if (event->type() == UpdateDcEvent::type()) {
+        UpdateDcEvent *pevent = (UpdateDcEvent *)event;
+        UpdateDcEvent::UpdateStep const updateStep = pevent->updateStep();
+        QObject const *sender = pevent->sender();
+        if (sender == m_worker) {
+            QDateTime const &recv = QDateTime::currentDateTime();
+            QDateTime const &send = pevent->sendDateTime();
+            qint64 const delay = recv.toMSecsSinceEpoch() - send.toMSecsSinceEpoch();
+            switch(updateStep) {
+            case UpdateDcEvent::UpdateStep::NONE:
+                break;
+            case UpdateDcEvent::UpdateStep::DC_REBOOT: {
+                m_hw->bl_rebootDC();
+                QString msg = QDateTime::currentDateTime().toString(Qt::ISODateWithMs)
+                          + QString(": reset device controller (delay=%1ms").arg(delay);
+                emit m_worker->showStatusMessage("dc update", msg);
+                Utils::printInfoMsg(msg.toUpper());
+                m_updateStep = UpdateDcEvent::UpdateStep::DC_REBOOT;
+            } break;
+            case UpdateDcEvent::UpdateStep::BL_START: {
+                QString const &msg = recv.toString(Qt::ISODateWithMs)
+                    + QString(": start bootloader (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                emit m_worker->showStatusMessage("dc update", msg);
+                Utils::printInfoMsg(msg.toUpper());
+                m_hw->bl_startBL();
+                if (pevent->count() == BL_START_COUNT) {
+                    m_updateStep = UpdateDcEvent::UpdateStep::BL_START;
+                }
+            } break;
+            case UpdateDcEvent::UpdateStep::BL_CHECK: {
+                if (m_updateStep != UpdateDcEvent::UpdateStep::BL_IS_UP) {
+                    QString const &msg = recv.toString(Qt::ISODateWithMs)
+                        + QString(": request bootloader version (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                    emit m_worker->showStatusMessage("dc update", msg);
+                    Utils::printInfoMsg(msg.toUpper());
+                    m_hw->bl_checkBL();
+                    //m_updateStep = UpdateDcEvent::UpdateStep::BL_CHECK;
+                }
+            } break;
+            case UpdateDcEvent::UpdateStep::BL_IS_UP: {
+                QString msg = recv.toString(Qt::ISODateWithMs)
+                    + QString(": check running bootloader (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                emit m_worker->showStatusMessage("dc update", msg);
+                Utils::printInfoMsg(msg.toUpper());
+                if (m_updateStep != UpdateDcEvent::UpdateStep::BL_IS_UP) {
+                    if (m_hw->bl_isUp()) {
+                        msg = recv.toString(Qt::ISODateWithMs)
+                            + QString(": bootloader running (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                        emit m_worker->showStatusMessage("dc update", msg);
+                        Utils::printInfoMsg(msg.toUpper());
+                        m_updateStep = UpdateDcEvent::UpdateStep::BL_IS_UP;
+                    } else {
+                        msg = recv.toString(Qt::ISODateWithMs)
+                            + QString(": bootloader stop requested (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                        emit m_worker->showStatusMessage("dc update", msg);
+                        Utils::printInfoMsg(msg.toUpper());
+                        if (m_updateStep == UpdateDcEvent::UpdateStep::BL_STOP) {
+                            msg = QDateTime::currentDateTime().toString(Qt::ISODateWithMs)
+                                    + QString(": bootloader down (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                            emit m_worker->showStatusMessage("dc update", msg);
+                            Utils::printInfoMsg(msg.toUpper());
+                            m_updateStep = UpdateDcEvent::UpdateStep::BL_IS_DOWN;
+                        }
+                    }
+                }
+            } break;
+            case UpdateDcEvent::UpdateStep::BL_STOP: {
+                QString const &msg = QDateTime::currentDateTime().toString(Qt::ISODateWithMs)
+                    + QString(": stop bootloader (%1, delay=%2ms)").arg(pevent->count()).arg(delay);
+                emit m_worker->showStatusMessage("dc update", msg);
+                Utils::printInfoMsg(msg.toUpper());
+                //if (m_bootLoaderIsUp) {
+                m_hw->bl_stopBL();
+                m_updateStep = UpdateDcEvent::UpdateStep::BL_STOP;
+                //}
+            } break;
+            default: ;
+            }
+        }
+    }
+
+    QThread::yieldCurrentThread();
+}
+
+void MainWindow::onStopStartTimer() {
+    m_startTimer->stop();
+}
+
+void MainWindow::onDisableExit() {
+   ui->exit->setEnabled(false);
+}
+
+void MainWindow::onEnableExit() {
+   ui->exit->setEnabled(true);
+}
+
+void MainWindow::onRestartExitTimer() {
+    m_exitTimer->stop();
+    m_exitTimer->start(60 * 1000);
+}
+
+void MainWindow::onQuit() {
+    m_exitTimer->stop();
+    qCritical() << QString("ON QUIT: EXIT CODE %1").arg(m_worker->returnCode());
+    qApp->exit(m_worker->returnCode());
+}
+
+void MainWindow::scrollDownTextEdit() {
+    qCritical() << "ON REPLACE LAST CALLED AT" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+
+    ui->updateStatus->setEnabled(true);
+
+    QTextCursor tmpCursor = ui->updateStatus->textCursor();
+    tmpCursor.movePosition(QTextCursor::End);
+    ui->updateStatus->setTextCursor(tmpCursor);
+    ui->updateStatus->ensureCursorVisible();
+}
+
+void MainWindow::onAppendText(QString text, QString suffix) {
+    qCritical() << "ON APPEND CALLED AT" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+
+    QString editText = ui->updateStatus->toPlainText();
+    if (!suffix.isNull() && suffix.size() > 0) {
+        //qInfo() << "TEXT" << text << "SUFFIX" << suffix;
+        if (suffix == Worker::UPDATE_STEP_SUCCESS || suffix == Worker::UPDATE_STEP_FAIL) {
+            editText += QString("\n").leftJustified(m_width-3, '=');
+            editText += " ";
+        }
+        QString const &add = (QString("\n") + text).leftJustified(m_width - (2 + suffix.size())) + suffix;
+        editText += add;
+    } else {
+        QString const &add = text.leftJustified(m_width-9);
+        editText += add;
+    }
+
+    Utils::printLineEditInfo(editText.split('\n', QString::SplitBehavior::SkipEmptyParts));
+    ui->updateStatus->setText(editText.trimmed());
+
+    scrollDownTextEdit();
+}
+
+void MainWindow::onReplaceLast(QStringList newTextLines, QString suffix) {
+    qCritical() << "ON REPLACE LAST CALLED AT" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+
+    int const s = newTextLines.size();
+    if (s > 0) {
+        QString editText = ui->updateStatus->toPlainText();
+        QStringList lines = editText.split('\n', QString::SplitBehavior::SkipEmptyParts);
+        QString newText;
+        if (lines.size() >= s) {
+            for (int i = 0; i < s; ++i) {
+                lines.removeLast();
+            }
+            if (lines.size() > 0) {
+                newText = lines.join('\n');
+                newText += '\n';
+            }
+            QStringList newLines;
+            for (int i = 0; i < s; ++i) {
+                if (i == 0 && !suffix.isNull() && suffix.size() > 0 && suffix != "\n") {
+                    newLines += Utils::rstrip(newTextLines.at(i).leftJustified(m_width-10) + suffix);
+                } else {
+                    newLines += Utils::rstrip(newTextLines.at(i).leftJustified(m_width-10));
+                }
+            }
+            lines += newLines;
+            newText += newLines.join(' ');
+        }
+
+        ui->updateStatus->setText(newText);
+        Utils::printLineEditInfo(lines);
+        scrollDownTextEdit();
+    }
+}
+
+void MainWindow::onReplaceLast(QString text, QString suffix) {
+    qCritical() << "ON REPLACE LAST CALLED AT" << QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+
+    QString editText = ui->updateStatus->toPlainText();
+    QStringList lines = editText.split('\n', QString::SplitBehavior::SkipEmptyParts);
+    if (lines.size() > 0) {
+        lines.removeLast();
+        if (!suffix.isNull() && suffix.size() > 0 && suffix != "\n") {
+            QString const add = text.leftJustified(m_width-10) + suffix;
+            if (!add.isEmpty()) {
+                lines += text.leftJustified(m_width-10) + suffix;
+            }
+        } else {
+            QString const add = text.leftJustified(m_width-10);
+            if (!add.isEmpty()) {
+                lines += text.leftJustified(m_width-10);
+            }
+        }
+    }
+
+    Utils::printLineEditInfo(lines);
+    ui->updateStatus->setText(lines.join('\n').trimmed());
+    scrollDownTextEdit();
+}
+
+void MainWindow::onShowMessage(QString title, QString text) {
+    this->statusBar()->clearMessage();
+    this->statusBar()->showMessage( // timeout: 10000
+        QString(title + " " + text).leftJustified(80, ' '), 10000);
+}
+
+void MainWindow::onShowErrorMessage(QString title, QString text) {
+    onShowMessage(title, text);
+}
+
+void MainWindow::onShowStatusMessage(QString title, QString text) {
+    onShowMessage(title, text);
+}

mainwindow.h

@@ -0,0 +1,82 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QTimer>
+#include <QStatusBar>
+
+QT_BEGIN_NAMESPACE
+namespace Ui { class MainWindow; }
+QT_END_NAMESPACE
+
+#include "worker.h"
+#include "update.h"
+#include "update_dc_event.h"
+
+#define EMERGENCY_LEAVE_BL 0
+
+class hwinf;
+class MainWindow : public QMainWindow {
+    Q_OBJECT
+
+protected:
+    void customEvent(QEvent *event) override;
+
+public:
+    MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *parent = nullptr);
+    ~MainWindow();
+
+    static const int START_PROGRESS_LOOP = -1;
+    static const int STOP_PROGRESS_LOOP = -2;
+    static const int BL_START_COUNT = 5;
+    static const int BL_CHECK_COUNT = 5;
+    static const int BL_IS_UP_COUNT = 5;
+    static const int BL_STOP_COUNT = 5;
+
+    int progressValue() const { return m_progressValue; }
+    hwinf *getPlugin() { return m_hw; }
+    hwinf const *getPlugin() const { return m_hw; }
+    Update *getUpdate() { return m_update; }
+    Update const *getUpdate() const { return m_update; }
+    UpdateDcEvent::UpdateStep updateStep() const { return m_updateStep; }
+    void setUpdateStep(UpdateDcEvent::UpdateStep updateStep) { m_updateStep = updateStep; }
+
+public slots:
+    void onAppendText(QString, QString suffix = "");
+    void onReplaceLast(QStringList, QString suffix = "");
+    void onReplaceLast(QString, QString suffix = "");
+    void onShowErrorMessage(QString, QString);
+    void onShowStatusMessage(QString, QString);
+    void onStopStartTimer();
+    void onRestartExitTimer();
+    void onEnableExit();
+    void onDisableExit();
+#if EMERGENCY_LEAVE_BL==1
+    void emergencyLeaveBL();
+#endif
+
+signals:
+
+#if EMERGENCY_LEAVE_BL==1
+    void leaveBL();
+#endif
+
+private slots:
+    void onQuit();
+
+private:
+    void scrollDownTextEdit();
+    void onShowMessage(QString, QString);
+
+    Ui::MainWindow *ui;
+    hwinf *m_hw;
+    Worker *m_worker;
+    int const m_width;
+    QTimer *m_startTimer;
+    QTimer *m_exitTimer;
+    bool m_progressRunning;
+    int m_progressValue;
+    Update *m_update;
+    UpdateDcEvent::UpdateStep m_updateStep;
+};
+#endif // MAINWINDOW_H

mainwindow.ui

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>480</height>
+   </rect>
+  </property>
+  <property name="font">
+   <font>
+    <family>Source Code Pro</family>
+   </font>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QWidget" name="layoutWidget">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>10</y>
+      <width>781</width>
+      <height>441</height>
+     </rect>
+    </property>
+    <layout class="QGridLayout" name="gridLayout">
+     <item row="3" column="2">
+      <widget class="QPushButton" name="exit">
+       <property name="text">
+        <string>Exit</string>
+       </property>
+      </widget>
+     </item>
+     <item row="3" column="1">
+      <widget class="QProgressBar" name="updateProgress">
+       <property name="value">
+        <number>1</number>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="0" rowspan="3" colspan="3">
+      <widget class="QTextEdit" name="updateStatus">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
+       <property name="font">
+        <font>
+         <family>Misc Fixed</family>
+         <pointsize>11</pointsize>
+         <bold>true</bold>
+        </font>
+       </property>
+       <property name="verticalScrollBarPolicy">
+        <enum>Qt::ScrollBarAsNeeded</enum>
+       </property>
+       <property name="horizontalScrollBarPolicy">
+        <enum>Qt::ScrollBarAsNeeded</enum>
+       </property>
+       <property name="sizeAdjustPolicy">
+        <enum>QAbstractScrollArea::AdjustToContents</enum>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </widget>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

message_handler.cpp

@@ -2,15 +2,17 @@
 
 #include <QDateTime>
 #include <cstring>
-
-#define OUTPUT_LEN (20)
+#include <QString>
+#include <QFileInfo>
+#include <QMessageLogContext>
 
 
+static char const *DBG_NAME[] = { "DBG  ", "WARN ", "CRIT ", "FATAL", "INFO " };
 static bool installedMsgHandler = false;
-static QtMsgType debugLevel = QtInfoMsg;
+static int debugLevel = LOG_NOTICE;
 
-QtMsgType getDebugLevel() { return debugLevel; }
-void setDebugLevel(QtMsgType newDebugLevel) {
+int getDebugLevel() { return debugLevel; }
+void setDebugLevel(int newDebugLevel) {
     debugLevel = newDebugLevel;
 }
 
@@ -41,108 +43,53 @@ QtMessageHandler atbInstallMessageHandler(QtMessageHandler handler) {
 ///     return app.exec();
 ///  }
 ///
-#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
-void atbDebugOutput(QtMsgType type, const char *msg) {
-    switch (type) {
-        case QtDebugMsg: {
-            if (debugLevel <= QtDebugMsg) {
-                fprintf(stderr, "%*.*s Debug: %s\n", OUTPUT_LEN, OUTPUT_LEN,
-                    QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg);
-            }
-        } break;
-        case QtInfoMsg: {
-            if (debugLevel <= QtInfoMsg) {
-                fprintf(stderr, "%*.*s Info: %s\n", OUTPUT_LEN, OUTPUT_LEN,
-                    QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg);
-            }
-        } break;
-        case QtWarningMsg: {
-            if (debugLevel <= QtWarningMsg) {
-                fprintf(stderr, "%*.*s Warning: %s\n", OUTPUT_LEN, OUTPUT_LEN,
-                    QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg);
-            }
-        } break;
-        case QtCriticalMsg: {
-            if (debugLevel <= QtCriticalMsg) {
-                fprintf(stderr, "%*.*s Critical: %s\n", OUTPUT_LEN, OUTPUT_LEN,
-                    QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg);
-            }
-        } break;
-        case QtFatalMsg: {
-            if (debugLevel <= QtFatalMsg) {
-                fprintf(stderr, "%*.*s Fatal: %s\n", OUTPUT_LEN, OUTPUT_LEN,
-                    QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg);
-            }
-            // abort();
-        } break;
-        default: {
-            fprintf(stderr, "%*.*s No ErrorLevel defined! %s\n", OUTPUT_LEN, OUTPUT_LEN,
-                QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg);
-        }
-    }
-}
-#elif QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+#if (QT_VERSION > QT_VERSION_CHECK(5, 0, 0) && QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 void atbDebugOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg) {
-    static constexpr const char *format = "dd.MM.yyyy hh:mm:ss";
-    QByteArray localMsg = msg.toLocal8Bit();
-    const char *file = context.file ? context.file : "";
-    const char *function = context.function ? context.function : "";
-    const char *p = std::strstr(function, "::");
-    if (p) {
-        function = p + 2;
-    }
-    char const* output = std::strrchr(file, '/');
-    if (output) {
-        file = output + 1;
-    }
-    qint64 const currentMSecsSinceEpoch = QDateTime::currentMSecsSinceEpoch();
-    int const fractional_part = currentMSecsSinceEpoch % 1000;
-    QDateTime const datetime = QDateTime::fromMSecsSinceEpoch(currentMSecsSinceEpoch);
-    switch (type) {
-        case QtDebugMsg: {
-            if (debugLevel <= QtDebugMsg) {
-                // fprintf(stderr, "%*.*s          CTX %s (%s:%u) ->\n", OUTPUT_LEN, OUTPUT_LEN,
-                //        "", function, file, context.line);
-                //fprintf(stderr, "%*.*s.%03d DEBG %s\n", OUTPUT_LEN, OUTPUT_LEN,
-                //        datetime.toString(format).toStdString().c_str(), fractional_part,
-                //        localMsg.constData());
-                fprintf(stderr, "%*.*s.%03d DEBUG %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN,
-                        datetime.toString(format).toStdString().c_str(), fractional_part,
-                        localMsg.constData(), file, context.line);
+    Q_UNUSED(context);
+    QString const localMsg = QString(DBG_NAME[type]) + msg.toLocal8Bit();
+
+    switch (debugLevel) {
+        case LOG_DEBUG: { // debug-level message
+            syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+        } break;
+        case LOG_INFO: { // informational message
+            if (type != QtDebugMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
             }
         } break;
-        case QtInfoMsg: {
-            if (debugLevel <= QtInfoMsg) {
-                fprintf(stderr, "%*.*s.%03d INFO %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN,
-                        datetime.toString(format).toStdString().c_str(), fractional_part,
-                        localMsg.constData(), file, context.line);
+        case LOG_NOTICE: { // normal, but significant, condition
+            if (type != QtDebugMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
             }
         } break;
-        case QtWarningMsg: {
-            if (debugLevel <= QtWarningMsg) {
-                fprintf(stderr, "%*.*s.%03d WARN %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN,
-                        datetime.toString(format).toStdString().c_str(), fractional_part,
-                        localMsg.constData(), file, context.line);
+        case LOG_WARNING: { // warning conditions
+            if (type != QtInfoMsg && type != QtDebugMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
             }
         } break;
-        case QtCriticalMsg: {
-            if (debugLevel <= QtCriticalMsg) {
-                fprintf(stderr, "%*.*s.%03d CRIT %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN,
-                        datetime.toString(format).toStdString().c_str(), fractional_part,
-                        localMsg.constData(), file, context.line);
+        case LOG_ERR: { // error conditions
+            if (type != QtInfoMsg && type != QtDebugMsg && type != QtWarningMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
             }
         } break;
-        case QtFatalMsg: {
-            if (debugLevel <= QtFatalMsg) {
-                fprintf(stderr, "%*.*s.%03d FATAL %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN,
-                        datetime.toString(format).toStdString().c_str(), fractional_part,
-                        localMsg.constData(), file, context.line);
+        case LOG_CRIT: { // critical conditions
+            if (type != QtInfoMsg && type != QtDebugMsg && type != QtWarningMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+            }
+        } break;
+        case LOG_ALERT: { // action must be taken immediately
+            if (type != QtInfoMsg && type != QtDebugMsg && type != QtWarningMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+            }
+        } break;
+        case LOG_EMERG: { // system is unusable
+            if (type != QtInfoMsg && type != QtDebugMsg && type != QtWarningMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
             }
         } break;
         default: {
-            fprintf(stderr, "%*.*s.%03d No ErrorLevel defined! %s\n", OUTPUT_LEN, OUTPUT_LEN,
-                datetime.toString(format).toStdString().c_str(), fractional_part,
-                msg.toStdString().c_str());
+            //fprintf(stderr, "%s No ErrorLevel defined! %s\n",
+            //    datetime.toStdString().c_str(), msg.toStdString().c_str());
         }
     }
 }

message_handler.h

@@ -2,9 +2,12 @@
 #define MESSAGE_HANDLER_H_INCLUDED
 
 #include <QtGlobal>
+#ifdef __linux__
+#include <syslog.h>
+#endif
 
-QtMsgType getDebugLevel();
-void setDebugLevel(QtMsgType newDebugLevel);
+int getDebugLevel();
+void setDebugLevel(int newDebugLevel);
 
 bool messageHandlerInstalled();
 QtMessageHandler atbInstallMessageHandler(QtMessageHandler handler);

process/command.cpp

@@ -0,0 +1,104 @@
+#include "command.h"
+
+#include <QProcess>
+#include <QDebug>
+#include <QDir>
+#include <QRegularExpression>
+
+Command::Command(QString const &command, int start_timeout, int finish_timeout)
+    : m_command(command.trimmed())
+    , m_commandResult("")
+    , m_waitForStartTimeout(start_timeout)
+    , m_waitForFinishTimeout(finish_timeout)
+    , m_exitCode(-1) {
+}
+
+QString Command::getCommandResult() const {
+    return m_commandResult;
+}
+
+void Command::readyReadStandardOutput() {
+    QProcess *p = (QProcess *)sender();
+    m_commandResult += p->readAllStandardOutput();
+    // qCritical() << m_commandResult;
+}
+
+void Command::readyReadStandardError() {
+    QProcess *p = (QProcess *)sender();
+    QByteArray buf = p->readAllStandardError();
+    qCritical() << buf;
+}
+
+void Command::finished(int /*exitCode*/, QProcess::ExitStatus /*exitStatus*/) {
+    QProcess *p = (QProcess *)sender();
+    // read all remaining data sent to the process, just in case
+    QString d = p->readAllStandardOutput();
+    if (!d.isEmpty()) {
+        m_commandResult += d;
+    }
+    disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardOutput()));
+    disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardError()));
+}
+
+bool Command::execute(QString workingDirectory, QStringList args) {
+
+    if (!QDir::setCurrent(workingDirectory)) {
+        qCritical() << "SET WORKING_DIRECTORY" << workingDirectory
+                    << "FAILED FOR" << m_command;
+        return false;
+    }
+
+    QScopedPointer<QProcess> p(new QProcess(this));
+    p->setWorkingDirectory(workingDirectory);
+    p->setProcessChannelMode(QProcess::MergedChannels);
+
+    connect(&(*p), SIGNAL(readyReadStandardOutput()), this, SLOT(readyReadStandardOutput()));
+    connect(&(*p), SIGNAL(readyReadStandardError()), this, SLOT(readyReadStandardError()));
+
+    if (!args.isEmpty()) {
+        qDebug() << "START COMMAND" << m_command << "WITH ARGS" << args
+                 << "IN" << p->workingDirectory();
+        p->start(m_command, args);
+    } else {
+        qDebug() << "START COMMAND" << m_command
+                 << "IN" << p->workingDirectory();
+        p->start(m_command);
+    }
+
+    if (p->waitForStarted(m_waitForStartTimeout)) {
+        qDebug() << "PROCESS" << m_command << "STARTED IN" << p->workingDirectory();
+        if (p->state() == QProcess::ProcessState::Running) {
+            qDebug() << "PROCESS" << m_command << "RUNNING IN" << p->workingDirectory();
+            if (p->waitForFinished(m_waitForFinishTimeout)) {
+                qDebug() << "PROCESS" << m_command << "FINISHED IN" << p->workingDirectory();
+                if (p->exitStatus() == QProcess::NormalExit) {
+                    if ((m_exitCode = p->exitCode()) == 0) {
+                        qDebug() << "EXECUTED" << m_command
+                                 << "with code" << m_exitCode
+                                 << "IN" << p->workingDirectory();
+                        return true;
+                    } else {
+                        qCritical() << "EXECUTED" << m_command
+                                    << "with code" << m_exitCode
+                                    << "IN" << p->workingDirectory();
+                    }
+                } else {
+                    qCritical() << "PROCESS" << m_command << "CRASHED with code"
+                                << p->exitCode()
+                                << "IN" << p->workingDirectory();
+                }
+            } else {
+                qCritical() << "PROCESS" << m_command
+                            << "DID NOT FINISH"
+                            << "IN" << p->workingDirectory();
+            }
+        } else {
+            qCritical() << "WRONG PROCESS STATE" << p->state()
+                        << "IN" << p->workingDirectory();
+        }
+    } else {
+        qCritical() << "PROCESS" << m_command << "TIMEOUT AT START"
+                    << "IN" << p->workingDirectory();
+    }
+    return false;
+}

process/command.h

@@ -0,0 +1,35 @@
+#ifndef COMMAND_H_INCLUDED
+#define COMMAND_H_INCLUDED
+#endif // COMMAND_H_INCLUDED
+
+#include <QObject>
+#include <QCoreApplication>
+#include <QString>
+#include <QStringList>
+#include <QProcess>
+
+
+class Command : public QObject {
+    Q_OBJECT
+
+    QString m_command;
+    QString m_commandResult;
+    int m_waitForStartTimeout;
+    int m_waitForFinishTimeout;
+    int m_exitCode;
+public:
+    explicit Command(QString const &command,
+                     int start_timeout = 100000,
+                     int finish_timeout = 100000);
+
+    QString getCommandResult() const;
+    QString command() const { return m_command; }
+
+    bool execute(QString workingDirectory, QStringList args = QStringList());
+    int exitCode() const { return m_exitCode; }
+
+private slots:
+    void readyReadStandardOutput();
+    void readyReadStandardError();
+    void finished(int exitCode, QProcess::ExitStatus exitStatus);
+};

progress_event.cpp

@@ -0,0 +1,20 @@
+#include "progress_event.h"
+
+QEvent::Type ProgressEvent::customEventType = QEvent::None;
+
+ProgressEvent::ProgressEvent(QObject const *sender, int progressPercent)
+    : QEvent(ProgressEvent::type())
+    , m_sender(sender)
+    , m_progressPercent(progressPercent) {
+}
+
+ProgressEvent::~ProgressEvent() {
+}
+
+QEvent::Type ProgressEvent::type() {
+    if (customEventType == QEvent::None) {
+        int generatedType = QEvent::registerEventType();
+        customEventType = static_cast<QEvent::Type>(generatedType);
+    }
+    return customEventType;
+}

progress_event.h

@@ -0,0 +1,26 @@
+#ifndef PROGRESS_EVENT_H_INCLUDED
+#define PROGRESS_EVENT_H_INCLUDED
+
+#include <QEvent>
+
+class ProgressEvent : public QEvent {
+
+    QObject const *m_sender;
+    int m_progressPercent;
+public:
+    explicit ProgressEvent(QObject const *sender, int progressPercent);
+    virtual ~ProgressEvent();
+    static QEvent::Type type();
+
+    QObject const *sender() { return m_sender; }
+    QObject const *sender() const { return m_sender; }
+
+    void setProgress(int progressPercent) { m_progressPercent = progressPercent; }
+    int progressPercent() { return m_progressPercent; }
+    int progressPercent() const { return m_progressPercent; }
+private:
+    static QEvent::Type customEventType;
+};
+
+
+#endif // PROGRESS_EVENT_H_INCLUDED

update.cpp

@@ -0,0 +1,892 @@
+#include "update.h"
+#include "worker.h"
+#include "utils.h"
+#include "update_dc_event.h"
+#include "mainwindow.h"
+
+#include <QCoreApplication>
+#include <QApplication>
+#include <QFile>
+#include <QTemporaryFile>
+#include <QDebug>
+#include <QTextStream>
+#include <QRegularExpression>
+#include <QRegExp>
+#include <QApplication>
+
+//#include <iostream>
+//#include <fstream>
+//#include <ctime>
+
+#include "plugins/interfaces.h"
+
+#include <QSharedMemory>
+#include <QScopedPointer>
+#include <QDir>
+#include <QThread>
+#include <QDateTime>
+#include <QPluginLoader>
+#include <QMap>
+
+#define UPDATE_OPKG                 (1)
+#define UPDATE_DC                   (1)
+#define UPDATE_PRINTER_TEMPLATES    (1)
+#define UPDATE_CASH_TEMPLATE        (1)
+#define UPDATE_CONF_TEMPLATE        (1)
+#define UPDATE_DEVICE_TEMPLATE      (1)
+
+static const QMap<QString, int> baudrateMap = {
+  {"1200"   ,   0}, {"9600"   ,   1}, {"19200"  ,   2}, {"38400"  ,   3},
+  {"57600"  ,   4}, {"115200" ,   5}
+};
+
+hwinf *Update::loadDCPlugin(QDir const &plugInDir, QString const &fname) {
+    hwinf *hw = nullptr;
+    if (plugInDir.exists()) {
+        QString pluginLibName(fname);
+        pluginLibName = plugInDir.absoluteFilePath(pluginLibName);
+        QFileInfo info(pluginLibName);
+        if (info.exists()) {
+            pluginLibName = plugInDir.absoluteFilePath(pluginLibName);
+            static QPluginLoader pluginLoader(pluginLibName);
+            if (!pluginLoader.load()) {
+                qCritical() << "in directory" << plugInDir.absolutePath();
+                qCritical() << "cannot load plugin" << pluginLoader.fileName();
+                qCritical() << pluginLoader.errorString();
+                exit(-1);
+            }
+            if (!pluginLoader.isLoaded()) {
+                qCritical() << pluginLoader.errorString();
+                exit(-2);
+            }
+            QObject *plugin = pluginLoader.instance();
+            if (!plugin) {
+                qCritical() << "cannot start instance";
+                exit(-3);
+            }
+            if (! (hw = qobject_cast<hwinf *>(plugin))) {
+                qCritical() << "cannot cast plugin" << plugin << "to hwinf";
+                exit(-4);
+            }
+        } else {
+            qCritical() << pluginLibName << "does not exist";
+            exit(-5);
+        }
+    } else {
+        qCritical() << "plugins directory" << plugInDir.absolutePath()
+                    << "does not exist";
+        exit(-6);
+    }
+    return hw;
+}
+
+Update::Update(hwinf *hw,
+               Worker *worker,
+               QString customerRepository,
+               QString customerNrStr,
+               QString branchName,
+               QString pluginName,
+               QString workingDir,
+               bool dryRun,
+               QObject *parent,
+               char const *serialInterface,
+               char const *baudrate)
+    : QObject(parent)
+    , m_hw(hw)
+    , m_worker(worker)
+    , m_serialInterface(serialInterface)
+    , m_baudrate(baudrate)
+    , m_customerRepository(customerRepository)
+    , m_customerNrStr(customerNrStr)
+    , m_branchName(branchName)
+    , m_pluginName(pluginName)
+    , m_workingDir(workingDir)
+    , m_dryRun(dryRun) {
+
+    qInfo() << "UPDATE: m_serialInterface    ..." << m_serialInterface;
+    qInfo() << "UPDATE: m_baudrate           ..." << m_baudrate;
+    qInfo() << "UPDATE: m_customerRepository ..." << m_customerRepository;
+    qInfo() << "UPDATE: m_customerNr ..........." << m_customerNrStr;
+    qInfo() << "UPDATE: m_branchName ..........." << m_branchName;
+    qInfo() << "UPDATE: m_pluginName ..........." << m_pluginName;
+    qInfo() << "UPDATE: m_workingDirectory ....." << m_workingDir;
+}
+
+Update::~Update() {
+}
+
+Update::DownloadResult Update::sendStatus(int ret) const {
+    switch (ret) {                      // return values of dc are:
+    case 0:                             // 0: no answer by now
+        return DownloadResult::NOP;     // 1: error
+    case 10:                            // 10: success
+        return DownloadResult::OK;
+    default:;
+    }
+    return DownloadResult::ERROR;
+}
+
+Update::DownloadResult Update::sendNextAddress(int bNum) const {
+    // sends address only if blockNumber is one of 0, 1024, 2048, 3072, 4096
+    int noAnswerCount = 0;
+    int errorCount = 0;
+    if ( bNum==0 || bNum==1024 || bNum==2048 || bNum==3072 || bNum==4096 ) {
+        // qDebug() << "addr-block" << bNum << "...";
+        while (noAnswerCount <= 250) {
+            m_hw->bl_sendAddress(bNum);
+            QThread::msleep(100);
+            DownloadResult const res = sendStatus(m_hw->bl_wasSendingAddOK());
+            if (res != DownloadResult::NOP) {
+                if (res == DownloadResult::ERROR) {
+                    if (++errorCount >= 10) {
+                        qCritical() << "addr-block" << bNum << "...FAILED";
+                        return res;
+                    }
+                } else { // res == DownloadResult::OK
+                    // qInfo() << "addr-block" << bNum << "...OK";
+                    return res;
+                }
+            } else {
+                noAnswerCount += 1; // no answer by now
+            }
+        }
+        // wait max. about 3 seconds
+        return DownloadResult::TIMEOUT;
+    }
+    // blockNumber is not one of 0, 1024, 2048, 3072, 4096 -> do nothing
+    return DownloadResult::NOP;
+}
+
+Update::DownloadResult Update::sendNextDataBlock(QByteArray const &binary,
+                                                 int bNum) const {
+    uint8_t local[66];
+    int const bAddr = bNum * 64;
+    int noAnswerCount = 0;
+    int errorCount = 0;
+
+    memcpy(local, binary.constData() + bAddr, 64);
+    local[64] = local[65] = 0x00;
+
+    // QByteArray b((const char *)(&local[0]), 64);
+    // qCritical() << "SNDB" << bNum << b.size() << b.toHex();
+
+    while (noAnswerCount <= 250) {
+        m_hw->bl_sendDataBlock(64, local);
+        QThread::msleep(10);
+        DownloadResult const res = sendStatus(m_hw->bl_wasSendingDataOK());
+        if (res != DownloadResult::NOP) {
+            if (res == DownloadResult::ERROR) {
+                if (++errorCount >= 10) {
+                    qCritical() << "data for block" << bNum << "...FAILED";
+                    return res;
+                }
+            } else {
+                // qInfo() << "data for block" << bNum << "OK";
+                return res;
+            }
+        } else {
+            noAnswerCount += 1; // no answer by now
+        }
+    }
+    // wait max. about 3 seconds
+    return DownloadResult::TIMEOUT;
+}
+
+Update::DownloadResult Update::dc_downloadBinary(QByteArray const &b) const {
+    int const nBlocks = (((b.size())%64)==0) ? (b.size()/64) : (b.size()/64)+1;
+
+    // fill lst block of data to be sent with 0xFF
+    QByteArray ba = b.leftJustified(nBlocks*64, (char)(0xFF));
+
+    qInfo() << "total number of bytes to send to dc" << ba.size();
+    qInfo() << "total number of blocks to send to dc" << nBlocks;
+
+    int bNum = 0;
+    DownloadResult res = DownloadResult::OK;
+    fprintf(stderr, "\n64-byte block %04d ", bNum);
+    while (res != DownloadResult::ERROR &&  bNum < nBlocks) {
+        if ((res = sendNextAddress(bNum)) != DownloadResult::ERROR) {
+            if ((res = sendNextDataBlock(ba, bNum)) != DownloadResult::ERROR) {
+                bNum += 1;
+                fprintf(stderr, ".");
+                if ((bNum % 80) == 0) {
+                    fprintf(stderr, "\n64-byte block %04d ", bNum);
+                }
+            }
+        }
+    }
+    fprintf(stderr, "\nlast 64-byte block %04d\n", bNum);
+
+    int const rest = ba.size() % 64;
+    int const offset = ba.size() - rest;
+    char const *startAddress = ba.constData() + offset;
+
+    if (rest > 0) {
+        // SHOULD NEVER HAPPEN !!!
+        uint8_t local[66];
+        memset(local, 0xFF, sizeof(local));
+        memcpy(local, startAddress, rest);
+        qCritical() << "ERROR SEND REMAINING" << rest << "BYTES";
+        m_hw->bl_sendDataBlock(64, local);
+    }
+
+    m_hw->bl_sendLastBlock();
+    qInfo() << "last result" << (int)sendStatus(m_hw->bl_wasSendingDataOK());
+    return res;
+}
+
+bool Update::startBootloader() const { // deprecated
+    return false;
+#if 0
+    int nStartTry = 5;
+    while (--nStartTry >= 0) {
+        m_hw->bl_startBL();
+        QThread::msleep(500);
+        int nCheckTry = 10;
+        while (--nCheckTry >= 0) {
+            m_hw->bl_checkBL();
+            QThread::msleep(500);
+            if (m_hw->bl_isUp()) {
+                qInfo() << "starting bootloader...OK";
+                return true;
+            } else {
+                qCritical() << "bootloader not up ("
+                            << nStartTry << "," << nCheckTry << ")" << QThread::currentThread();
+            }
+        }
+    }
+    qCritical() << "starting bootloader...FAILED" << QThread::currentThread();
+    return false;
+#endif
+}
+
+bool Update::stopBootloader() const {
+    // stop bootloader: this MUST work -> otherwise the PSA has to be restarted
+    // manually
+    emit m_worker->showErrorMessage("dc update", "stopping bootloader...");
+
+    int nTryFinalize = 1; // could do this in an endless loop
+
+    do {
+        // in principle, any value except BL_STOP will do, as we want to detect
+        // change to BL_STOP
+        m_worker->mainWindow()->setUpdateStep(UpdateDcEvent::UpdateStep::BL_CHECK);
+
+        QApplication::postEvent(
+            m_worker->mainWindow(),
+            new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_STOP, nTryFinalize));
+
+        QThread::sleep(1);
+
+        int const cntLimit = 20;
+        int cnt = 0;
+        while (++cnt < cntLimit &&
+            m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_STOP) {
+            // wait until bl_stopBL() has been sent
+            QThread::msleep(500);
+        }
+
+        QApplication::postEvent(
+            m_worker->mainWindow(),
+            new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_CHECK, nTryFinalize));
+        QThread::sleep(1);
+
+        QApplication::postEvent(
+            m_worker->mainWindow(),
+            new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_IS_UP, nTryFinalize));
+        QThread::sleep(1);
+
+        cnt = 0;
+        while (++cnt < cntLimit &&
+            m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_IS_DOWN) {
+            // wait until  done
+            QThread::msleep(200);
+        }
+
+    } while (++nTryFinalize <= MainWindow::BL_STOP_COUNT &&
+             m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_IS_DOWN);
+
+    return (m_worker->mainWindow()->updateStep() == UpdateDcEvent::UpdateStep::BL_IS_DOWN);
+}
+
+// br is a index into a table, used for historical reasons.
+bool Update::openSerial(int br, QString baudrate, QString comPort) const {
+    qDebug() << "opening serial" << br << baudrate << comPort << "...";
+    if (m_hw->dc_openSerial(br, baudrate, comPort, 1) == true) { // 1 for connect
+        Utils::printInfoMsg(
+            QString("OPENING SERIAL %1").arg(br)
+                  + " " + baudrate + " " + comPort + "...OK");
+
+        // m_hw->dc_autoRequest(true);
+        m_hw->dc_autoRequest(false);
+        QThread::sleep(1);
+
+        Utils::printInfoMsg(QString("IS PORT OPEN %1").arg(m_hw->dc_isPortOpen()));
+        return true;
+    }
+
+    Utils::printCriticalErrorMsg(
+        QString("OPENING SERIAL %1").arg(br)
+              + " " + baudrate + " " + comPort + "...FAILED");
+    return false;
+}
+
+void Update::closeSerial() const {
+    qInfo() << "CLOSED SERIAL" << m_baudrate << m_serialInterface;
+    m_hw->dc_closeSerial();
+}
+
+bool Update::isSerialOpen() const {
+    return m_hw->dc_isPortOpen();
+}
+
+bool Update::resetDeviceController() const { // deprecated
+    return false;
+#if 0
+    qDebug() << "resetting device controller...";
+    m_hw->bl_rebootDC();
+    // wait maximally 3 seconds, before starting bootloader
+    qInfo() << "resetting device controller...OK";
+    return true;
+#endif
+}
+
+QByteArray Update::loadBinaryDCFile(QString filename) const {
+    qDebug() << "loading dc binary" << filename << "...";
+
+    QFile file(filename); // closed in destructor call
+    if (!file.exists()) {
+        qCritical() << file.fileName() << "does not exist";
+        return QByteArray();
+    }
+    if (!file.open(QIODevice::ReadOnly)) {
+        qCritical() << "cannot open file" << file.fileName();
+        return QByteArray();
+    }
+    qInfo() << "loading dc binary" << filename << "...OK";
+    return file.readAll();
+}
+
+bool Update::downloadBinaryToDC(QString const &bFile) const {
+    qDebug() << "sending" << bFile << "to dc...";
+    QByteArray const dcBinary = loadBinaryDCFile(bFile);
+    if (dcBinary.size() > 0) {
+        if (dc_downloadBinary(dcBinary) != DownloadResult::OK) {
+            qCritical() << "sending" << bFile << "to dc...FAILED";
+            return false;
+        } else {
+            qInfo() << "sending" << bFile << "to dc...OK";
+        }
+    } else {
+        qCritical() << "sending" << bFile << "to dc...FAILED";
+        qCritical() << "loading binary" << bFile << "FAILED";
+        return false;
+    }
+    return true;
+}
+
+/*
+
+ ///////////////////////////////////////////////////////////////////////////////
+ //
+ //                        USING THE DC BOOTLOADER
+ //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ 1  :   bl_reboot()     // send to application, want DC2 to reset (in order to
+                        // start the bootloader)
+                        //
+                        // NOTE: this function is NOT reliable !!! Sometimes it
+                        // simply does not work, in which case bl_startBL,
+                        // bl_checkBL and bl_isUp do not work as well.
+                        // Alas, there is no feedback if bl_reboot worked!
+                        //
+                        // NOTE: this function can be called only once per
+                        // minute, because once called again, the controller
+                        // performs some self-checks consuming some time.
+                        //
+                        // NOTE: after a successful bl_reboot(), the device is
+                        // waiting about 4 seconds in the bootloader. To stay in
+                        // the bootloader, we have to send the command
+                        // bl_startBL(), which is kind of a misnomer, as it
+                        // should be bl_doNotLeaveBL().
+                        //
+ 2  :   bl_startBL():   // send within 4s after DC power-on, otherwise
+                        // bootloader is left.
+                        //
+                        // NOTE: a running bootloader is a MUST for the download
+                        // process of a device controller firmware as it does
+                        // the actual writing of the memory (the bl_reboot()
+                        // from above erases the available memory).
+                        //
+ 3  :   bl_check():     // send command to verify if bl is up
+                        //
+                        // NOTE: this command is kind of a request that we want
+                        // to check if the bootloader is up. The device
+                        // (actually the bootloader) responds with its version.
+                        //
+ 4  :   bl_isUp():      // returns true if bl is up and running
+                        //
+                        // NOTE: we know what the bootloader version actually is
+                        // as the bootloader does not change. By comparing the
+                        // string received in the previous step with this known
+                        // version string we know if the bootloader is up.
+                        //
+                        // NOTE FOR ALL PREVIOUS STEPS: execute them in their
+                        // own slots each to be sure to receive any possible
+                        // responds from the device.
+                        //
+ 5  :   bl_sendAddress(blockNumber)
+                        // send start address, nr of 64-byte block, start with 0
+                        // will be sent only for following block-numbers:
+                        // 0, 1024, 2048, 3072 and 4096, so basically every
+                        // 64kByte.
+                        // for other addresses nothing happens
+
+ 6  :   bl_wasSendingAddOK()
+                        // return val:  0: no response by now
+                        //              1: error
+                        //             10: OK
+
+ 7  :   bl_sendDataBlock()
+                        // send 64 byte from bin file
+
+ 8  :   bl_sendLastBlock()
+                        // send this command after all data are transferred
+
+ 9  :   bl_wasSendingDataOK()
+                        // return val:  0: no response by now
+                        //              1: error
+                        //             10: OK
+
+ 10 :   bl_stopBL()     // leave bl and start (the new) application
+                        //
+                        // NOTE: this function MUST work under all conditions.
+                        // Alas, there is no direct result for this command, so
+                        // the only way of knowing it was successful is to ask
+                        // the device if the bootloader is still running.
+                        // There is no problem to repeat this command until the
+                        // bootloader is really not running anymore.
+ */
+bool Update::updateBinary(char const *fileToSendToDC) {
+    qInfo() << "UPDATING DEVICE CONTROLLER FIRMWARE BINARY" << fileToSendToDC;
+    QFile fn(fileToSendToDC);
+    bool r;
+    if ((r = fn.exists()) == true) {
+        QFileInfo fi(fn);
+        if ((r = updateDC(fileToSendToDC)) == true) {
+            Utils::printInfoMsg(
+                QString("      UPDATING BINARY ") + fi.fileName()
+                      + QString(" (size=%1").arg(fi.size()) + ") DONE");
+        } else {
+            Utils::printCriticalErrorMsg(
+                QString("      UPDATING BINARY ") + fi.fileName()
+                      + QString(" (size=%1").arg(fi.size()) + ") FAILED");
+        }
+    } else {
+        Utils::printCriticalErrorMsg(
+            QString(fileToSendToDC) + " DOES NOT EXIST -> NO UPDATE OF DC FIRMWARE");
+    }
+    return r;
+}
+
+bool Update::updateDC(QString bFile) const {
+    qDebug() << "IN UPDATEDC: UPDATING DC: FILE TO SEND" << bFile;
+
+    m_worker->mainWindow()->setUpdateStep(UpdateDcEvent::UpdateStep::NONE);
+
+    QApplication::postEvent(            // step 1: reset device controller
+        m_worker->mainWindow(),
+        new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::DC_REBOOT, 1));
+    QThread::sleep(1);
+
+    for (int i=1; i <= MainWindow::BL_START_COUNT; ++i) {
+        QApplication::postEvent(        // step 2: start bootloader (5x)
+            m_worker->mainWindow(),
+            new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_START, i));
+        QThread::sleep(1);
+    }
+
+    int const cntLimit = 100;       // wait until its for sure that bl_startBL()
+    int cnt = 0;                    // has been excuted
+    while (++cnt < cntLimit &&
+        m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_START) {
+        // wait until all bl_startBL() are done
+        QThread::msleep(200);
+    }
+
+    if (cnt == cntLimit) {
+        // start events not received ???
+        Utils::printCriticalErrorMsg("BL_START EVENT NOT RECEIVED AFTER 20 SECS");
+        return false;
+    }
+
+    m_worker->mainWindow()->setUpdateStep(UpdateDcEvent::UpdateStep::BL_CHECK);
+
+    for (int i=1; i <= MainWindow::BL_IS_UP_COUNT; ++i) {
+        QApplication::postEvent(m_worker->mainWindow(), new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_CHECK, i));
+        QThread::sleep(1);
+        QApplication::postEvent(m_worker->mainWindow(), new UpdateDcEvent(m_worker, UpdateDcEvent::UpdateStep::BL_IS_UP, i));
+        if (m_worker->mainWindow()->updateStep() == UpdateDcEvent::UpdateStep::BL_IS_UP) {
+            break;
+        }
+        QThread::sleep(1);
+    }
+
+    cnt = 0;
+    while (++cnt < cntLimit &&
+        m_worker->mainWindow()->updateStep() != UpdateDcEvent::UpdateStep::BL_IS_UP) {
+        // wait until all bl_startBL() are done
+        QThread::msleep(200);
+    }
+
+    if (cnt == cntLimit) {
+        // really not up
+        Utils::printCriticalErrorMsg("BL_IS_UP EVENT NOT RECEIVED AFTER 20 SECS");
+        stopBootloader(); // try to stop bootloader whichhas been already started
+        return false;
+    }
+
+    if (m_worker->mainWindow()->updateStep() == UpdateDcEvent::UpdateStep::BL_IS_UP) {
+        // bootloader MUST be running to download device-controller
+#if 0
+        if (!downloadBinaryToDC(bFile)) {
+            Utils::printCriticalErrorMsg(
+                QString("UPDATING DC: ") + bFile + " ...DOWNLOAD FAILED");
+        }
+#endif
+
+    } else {
+        Utils::printCriticalErrorMsg(
+            QString("UPDATING DC: ") + bFile + " BOOT LOADER NOT RUNNING -> NO DOWNLOAD ("
+                  + QThread::currentThread()->objectName() + ")");
+        return false;
+    }
+
+    // do this unconditionally, even if bootloader is not running at all ->
+    // the controller possibly tells us nonsense.
+    if (!stopBootloader()) {
+        Utils::printCriticalErrorMsg(
+            QString("UPDATING DC: ") + bFile + " BOOT LOADER STILL RUNNING ("
+                  + QThread::currentThread()->objectName() + ")");
+        return false;
+    }
+
+    Utils::printInfoMsg(QString("UPDATING DC: ") + bFile + " ...OK");
+    return true;
+}
+
+QString Update::jsonType(enum FileTypeJson type) {
+    switch (type) {
+    case FileTypeJson::CASH: return "CASH";
+    case FileTypeJson::CONFIG: return "CONFIG";
+    case FileTypeJson::PRINTER: return "PRINTER";
+    case FileTypeJson::SERIAL: return "SERIAL";
+    case FileTypeJson::DEVICE: return "DEVICE";
+    case FileTypeJson::TIME: return "TIME";
+    }
+    return "N/A";
+}
+
+bool Update::downloadJson(enum FileTypeJson type,
+                          int templateIdx,
+                          QString jsFileToSendToDC) const {
+
+    qDebug() << "updating json-file:" << jsFileToSendToDC << "...";
+    qDebug() << "    template-index:" << templateIdx;
+    qDebug() << "         json-type:" << jsonType(type);
+
+    m_hw->dc_autoRequest(true); // downloading Json needs the AutoEmission flag
+    qDebug() << "SET AUTO-REQUEST=TRUE";
+    QThread::sleep(1);  // make sure the auto-request flag is acknowledged
+
+    bool ready = false;
+    int nTry = 25;
+    while ((ready = m_hw->sys_ready4sending()) == false) {
+        QThread::msleep(200);
+        if (--nTry <= 0) {
+            qCritical() << "SYS NOT READY FOR SENDING AFTER 5 SECONDS";
+            break;
+        }
+    }
+
+    bool ret = false;
+    if (ready) {
+        QFile file(jsFileToSendToDC);
+        QFileInfo fi(jsFileToSendToDC); // max. size of template file is 800 bytes
+        if (file.exists()) {
+            if (file.open(QIODevice::ReadOnly)) {
+                if (fi.size() <= 800) {
+                    QByteArray ba = file.readAll();
+                    if (m_hw->sys_sendJsonFileToDc((uint8_t)(type),
+                                                   templateIdx,
+                                                   (uint8_t *)ba.data())) {
+                        QThread::sleep(1);
+                        qDebug() << "SENT" << jsFileToSendToDC;
+                        ret = true;
+                    }
+                } else {
+                    qCritical() << "SIZE OF" << jsFileToSendToDC
+                                << "TOO BIG (" << fi.size() << "BYTES)";
+                }
+            } else {
+                qCritical() << "CANNOT OPEN" << jsFileToSendToDC << "FOR READING";
+            }
+        } else {
+            qCritical() << jsFileToSendToDC << "DOES NOT EXIST";
+        }
+    }
+
+    m_hw->dc_autoRequest(false);
+    qDebug() << "SET AUTO-REQUEST=FALSE";
+    QThread::sleep(1);  // make sure the auto-request flag is acknowledged
+
+    return ret;
+}
+
+bool Update::updatePrinterTemplate(int templateIdx, QString jsFile) const {
+    return downloadJson(FileTypeJson::PRINTER, templateIdx, jsFile);
+}
+
+bool Update::updateConfig(QString jsFile) {
+    return downloadJson(FileTypeJson::CONFIG, 0, jsFile);
+}
+
+bool Update::updateCashConf(QString jsFile) {
+    return downloadJson(FileTypeJson::CASH, 0, jsFile);
+}
+
+bool Update::updateDeviceConf(QString jsFile) {
+    return downloadJson(FileTypeJson::DEVICE, 0, jsFile);
+}
+
+QStringList Update::split(QString line, QChar sep) {
+    QStringList lst;
+    QString next;
+    int start = 0, end;
+
+    while ((end = line.indexOf(sep, start)) != -1) {
+        next = line.mid(start, end - start).trimmed();
+        lst << next;
+        start = end + 1;
+    }
+    next = line.mid(start, end - start).trimmed();
+    lst << next;
+
+    return lst;
+}
+
+void Update::readyReadStandardOutput() {
+    QProcess *p = (QProcess *)sender();
+    QByteArray buf = p->readAllStandardOutput();
+    qCritical() << buf;
+}
+
+void Update::readyReadStandardError() {
+    QProcess *p = (QProcess *)sender();
+    QByteArray buf = p->readAllStandardError();
+    qCritical() << buf;
+}
+
+void Update::finished(int /*exitCode*/, QProcess::ExitStatus /*exitStatus*/) {
+    QProcess *p = (QProcess *)sender();
+    disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardOutput()));
+    disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardError()));
+}
+
+QStringList Update::getDcSoftAndHardWareVersion() {
+    m_hw->dc_autoRequest(true);
+    QThread::sleep(1); // make sure the timer-slots are active
+
+    for (int i=0; i < 3; ++i) { // send explicit reuests to get
+                                // current SW/HW-versions
+        m_hw->request_DC2_SWversion();
+        m_hw->request_DC2_HWversion();
+        QThread::sleep(1);
+    }
+
+    QString const &hwVersion = m_hw->dc_getHWversion().toLower().trimmed();
+    QString const &swVersion = m_hw->dc_getSWversion().toLower().trimmed();
+
+    m_hw->dc_autoRequest(false);
+    QThread::sleep(1); // make sure the timer-slots are inactive
+
+    if (!hwVersion.isEmpty() && !swVersion.isEmpty()) {
+        return QStringList() << hwVersion << swVersion;
+    }
+
+    return QStringList() << "DC HW-version not available"
+                         << "DC SW-version not available";
+}
+
+bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {
+    bool serialOpened = false;
+
+    QString const &parentName = Utils::getParentName();
+
+    if (parentName == "ATBQT" || parentName == "systemd") {
+        // the tool was not called during 'service' ot during an automatic
+        // update procedure. and it was called explicitly with libCAmaster.so
+        if (m_pluginName.contains("master", Qt::CaseInsensitive)) {
+            Utils::printCriticalErrorMsg(parentName
+                + " IS MASTER, BUT ATB-UPDATE-TOOL CALLED WITH libCAmaster.so");
+            return false;
+        }
+    } else
+    if (Utils::isATBQTRunning()) {  // manual testing
+        if (m_pluginName.contains("master", Qt::CaseInsensitive)) {
+            Utils::printCriticalErrorMsg(
+                "ATBQT IS MASTER, BUT ATB-UPDATE-TOOL CALLED WITH libCAmaster.so");
+            return false;
+        }
+    } else {
+        if (m_pluginName.contains("slave", Qt::CaseInsensitive)) {
+            Utils::printCriticalErrorMsg(
+                "ATB-UPDATE-TOOL CALLED WITH libCAslave.so ALTHOUGH MASTER");
+            return false;
+        }
+
+        if ((serialOpened = openSerial(baudrateMap.value(m_baudrate),
+                                       m_baudrate,
+                                       m_serialInterface)) == false) {
+                Utils::printCriticalErrorMsg(
+                    QString("CANNOT OPEN ")
+                          + m_serialInterface
+                          + "( BAUDRATE=" + m_baudrate + ")");
+                return false;
+        }
+
+        m_hw->dc_autoRequest(false);
+
+        Utils::printInfoMsg(
+            QString("SERIAL OPEN ") + m_serialInterface
+                + " (BAUDRATE=" + m_baudrate + ")");
+    }
+
+    bool res = false;
+    QList<QString>::const_iterator it;
+    for (it = filesToWorkOn.cbegin(); it != filesToWorkOn.cend(); ++it) {
+        m_worker->startProgressLoop();
+        QString fToWorkOn = (*it).trimmed();
+        fToWorkOn = QDir::cleanPath(m_customerRepository + QDir::separator() + fToWorkOn);
+
+        static const QRegularExpression version("^.*dc2c[.][0-9]{1,2}[.][0-9]{1,2}[.]bin.*$");
+        if (fToWorkOn.contains(version)) {
+            Utils::printInfoMsg("DO-UPDATE FILE-TO-WORK-ON " + fToWorkOn);
+
+            QFile fn(fToWorkOn);
+            QFileInfo finfo(fn);
+            if (!fn.exists()) { // check for broken link
+                Utils::printCriticalErrorMsg("DO-UPDATE FILE-TO-WORK-ON "
+                    + fToWorkOn + " DOES NOT EXIST");
+                res = false;
+            } else {
+                bool updateBinaryRes = true;
+
+                qInfo() << "DOWNLOADING" << finfo.completeBaseName() << "TO DC";
+#if UPDATE_DC == 1
+                m_hw->dc_autoRequest(false);// default: turn auto-request setting off
+                QThread::sleep(1);          // wait to be sure that there are no more
+                                            // commands sent to dc-hardware
+                qInfo() << "SET AUTO-REQUEST=FALSE";
+
+                if ((updateBinaryRes = updateBinary(fToWorkOn.toStdString().c_str())) == true) {
+                    qCritical() << "downloaded binary" << fToWorkOn;
+                    ++displayIndex;
+                    emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+                        + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
+                        Worker::UPDATE_STEP_DONE);
+                }
+
+                m_hw->dc_autoRequest(true); // turn auto-request setting on
+                qInfo() << "SET AUTO-REQUEST=TRUE";
+
+                QStringList const &versions = Update::getDcSoftAndHardWareVersion();
+                if (versions.size() >= 2) {
+                    if (updateBinaryRes == true) {
+                        qInfo() << "dc-hardware-version (UPDATED)" << versions[0];
+                        qInfo() << "dc-firmware-version (UPDATED)" << versions[1];
+                    } else {
+                        qInfo() << "dc-hardware-version (NOT UPDATED)" << versions[0];
+                        qInfo() << "dc-firmware-version (NOT UPDATED)" << versions[1];
+                    }
+                }
+#endif
+                res = updateBinaryRes;
+            }
+        } else if (fToWorkOn.contains("DC2C_print", Qt::CaseInsensitive)
+                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
+            res = true;
+#if UPDATE_PRINTER_TEMPLATES == 1
+            int i = fToWorkOn.indexOf("DC2C_print", Qt::CaseInsensitive);
+            int const templateIdx = fToWorkOn.mid(i).midRef(10, 2).toInt();
+            if ((templateIdx < 1) || (templateIdx > 32)) {
+                qCritical() << "WRONG TEMPLATE INDEX" << templateIdx;
+                res = false;
+            } else {
+                if ((res = updatePrinterTemplate(templateIdx, fToWorkOn))) {
+                    qInfo() << "downloaded printer template"<< fToWorkOn;
+                    ++displayIndex;
+                    emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+                          + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
+                            Worker::UPDATE_STEP_DONE);
+                }
+            }
+#endif
+        } else if (fToWorkOn.contains("DC2C_cash", Qt::CaseInsensitive)
+                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
+            res = true;
+#if UPDATE_CASH_TEMPLATE == 1
+            if ((res = updateCashConf(fToWorkOn))) {
+                qInfo() << "downloaded cash template"<< fToWorkOn;
+                ++displayIndex;
+                emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+                      + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
+                        Worker::UPDATE_STEP_DONE);
+            }
+#endif
+        } else if (fToWorkOn.contains("DC2C_conf", Qt::CaseInsensitive)
+                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
+            res = true;
+#if UPDATE_CONF_TEMPLATE == 1
+            if ((res= updateConfig(fToWorkOn))) {
+                qInfo() << "downloaded config template"<< fToWorkOn;
+                ++displayIndex;
+                emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+                      + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
+                        Worker::UPDATE_STEP_DONE);
+            }
+#endif
+        } else if (fToWorkOn.contains("DC2C_device", Qt::CaseInsensitive)
+                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
+            res = true;
+#if UPDATE_DEVICE_TEMPLATE == 1
+            if ((res = updateDeviceConf(fToWorkOn))) {
+                qInfo() << "downloaded device template"<< fToWorkOn;
+                ++displayIndex;
+                emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")")
+                      + QString(" Update ") + QFileInfo(fToWorkOn).fileName(),
+                        Worker::UPDATE_STEP_DONE);
+            }
+#endif
+        } else {
+            qCritical() << "UNKNOWN JSON FILE NAME" << fToWorkOn;
+            res = false;
+        }
+        m_worker->stopProgressLoop();
+        m_worker->setProgress(100);
+
+        if (res == false) {
+            break;
+        }
+    } // for (it = openLines.cbegin(); it != openLines.end(); ++it) {
+
+    //m_hw->dc_autoRequest(true);  // ALWAYS turn autoRequest ON
+    //qDebug() << "SET AUTO-REQUEST=TRUE";
+
+    if (serialOpened) {
+        m_hw->dc_closeSerial();
+    }
+
+    return res;
+}

update.h

@@ -0,0 +1,98 @@
+#ifndef UPDATE_H_INCLUDED
+#define UPDATE_H_INCLUDED
+
+#include <QObject>
+#include <QString>
+#include <QFile>
+#include <QDir>
+#include <QByteArray>
+#include <QProcess>
+
+#include "plugins/interfaces.h"
+
+#ifdef PTU5
+#define SERIAL_PORT "ttymxc2"
+#else
+#define SERIAL_PORT "ttyUSB0"
+#endif
+
+class Worker;
+class Update : public QObject {
+    Q_OBJECT
+
+    hwinf *m_hw;
+    Worker *m_worker;
+    char const *m_serialInterface;
+    char const *m_baudrate;
+    QString m_customerRepository;
+    QString m_customerNrStr;
+    QString m_branchName;
+    QString m_pluginName;
+    QString m_workingDir;
+    bool m_maintenanceMode;
+    bool m_dryRun;
+
+public:
+    enum class DownloadResult {OK, ERROR, TIMEOUT, NOP};
+    enum class FileTypeJson {CONFIG=1, DEVICE=2, CASH=3, SERIAL=4, TIME=5, PRINTER=6};
+
+    static hwinf *loadDCPlugin(QDir const &plugInDir, QString const &fn);
+    static QStringList split(QString line, QChar sep = ',');
+
+
+    explicit Update(hwinf *hw,
+                    Worker *worker,
+                    QString customerRepository,
+                    QString customerNrStr,
+                    QString branchName,
+                    QString pluginName,
+                    QString workingDir,
+                    bool dryRun = false,
+                    QObject *parent = nullptr,
+                    char const *serialInterface = SERIAL_PORT,
+                    char const *baudrate = "115200");
+    virtual ~Update() override;
+    bool doUpdate(int &displayIndex, QStringList const &linesToWorkOn);
+
+    //QString customerId() { return m_customerId; }
+    //QString const customerId() const { return m_customerId; }
+
+    QString branchName() { return m_branchName; }
+    QString const branchName() const { return m_branchName; }
+
+    //QString repositoryPath() { return m_repositoryPath; }
+    //QString const repositoryPath() const { return m_repositoryPath; }
+
+private:
+    static QString jsonType(enum FileTypeJson type);
+
+    DownloadResult sendStatus(int ret) const;
+    DownloadResult sendNextAddress(int bNum) const;
+    DownloadResult sendNextDataBlock(QByteArray const &b, int bNum) const;
+    DownloadResult dc_downloadBinary(QByteArray const &binary) const;
+
+    bool startBootloader() const;
+    bool stopBootloader() const;
+    bool openSerial(int br, QString baudrate, QString comPort) const;
+    void closeSerial() const;
+    bool isSerialOpen() const;
+    bool resetDeviceController() const;
+    QByteArray loadBinaryDCFile(QString filename) const;
+    bool downloadBinaryToDC(QString const &bFile) const;
+    bool updateDC(QString bFile) const;
+    bool updatePrinterTemplate(int templateIdx, QString fname) const;
+    bool updateBinary(char const *fileToSendToDC);
+    bool updateConfig(QString jsFileToSendToDC);
+    bool updateCashConf(QString jsFileToSendToDC);
+    bool updateDeviceConf(QString jsFileToSendToDC);
+    bool downloadJson(enum FileTypeJson type, int templateIdx,
+                      QString jsFileToSendToDC) const;
+    QStringList getDcSoftAndHardWareVersion();
+
+private slots:
+    void readyReadStandardOutput();
+    void readyReadStandardError();
+    void finished(int exitCode, QProcess::ExitStatus exitStatus);
+
+};
+#endif // UPDATE_H_INCLUDED

update_dc_event.cpp

@@ -0,0 +1,25 @@
+#include "update_dc_event.h"
+
+QEvent::Type UpdateDcEvent::customEventType = QEvent::None;
+
+UpdateDcEvent::UpdateDcEvent(QObject const *sender,
+                             UpdateStep updateStep,
+                             int count,
+                             QDateTime const &sendDateTime)
+    : QEvent(UpdateDcEvent::type())
+    , m_sender(sender)
+    , m_updateStep(updateStep)
+    , m_count(count)
+    , m_sendDateTime(sendDateTime) {
+}
+
+UpdateDcEvent::~UpdateDcEvent() {
+}
+
+QEvent::Type UpdateDcEvent::type() {
+    if (customEventType == QEvent::None) {
+        int generatedType = QEvent::registerEventType();
+        customEventType = static_cast<QEvent::Type>(generatedType);
+    }
+    return customEventType;
+}

update_dc_event.h

@@ -0,0 +1,40 @@
+#ifndef UPDATE_DC_EVENT_H_INCLUDED
+#define UPDATE_DC_EVENT_H_INCLUDED
+
+#include <QEvent>
+#include <QDateTime>
+
+class UpdateDcEvent : public QEvent {
+public:
+    enum UpdateStep { NONE, DC_REBOOT, BL_START, BL_CHECK, BL_CHECK_AFTER_STOP, BL_IS_UP, BL_IS_DOWN, BL_STOP};
+
+private:
+    QObject const *m_sender;
+    UpdateStep m_updateStep;
+    int m_count;
+    QDateTime m_sendDateTime;
+
+public:
+    explicit UpdateDcEvent(QObject const *sender, UpdateStep updateStep,
+                           int count,
+                           QDateTime const &sendDateTime = QDateTime::currentDateTime());
+    virtual ~UpdateDcEvent();
+    static QEvent::Type type();
+
+    QObject const *sender() { return m_sender; }
+    QObject const *sender() const { return m_sender; }
+
+    void setUpdateStep(UpdateStep updateStep) { m_updateStep = updateStep; }
+    UpdateStep updateStep() { return m_updateStep; }
+    UpdateStep updateStep() const { return m_updateStep; }
+    int count() const { return m_count; }
+    void setCount(int count) { m_count = count; }
+    QDateTime &sendDateTime() { return m_sendDateTime; }
+    QDateTime const &sendDateTime() const { return m_sendDateTime; }
+
+private:
+    static QEvent::Type customEventType;
+};
+
+
+#endif // PROGRESS_EVENT_H_INCLUDED

utils.cpp

@@ -0,0 +1,226 @@
+#include "utils.h"
+#include "message_handler.h"
+#include "git/git_client.h"
+
+#include "unistd.h"
+
+#include <QFile>
+#include <QTextStream>
+#include <QDebug>
+#include <QDir>
+#include <QDirIterator>
+
+int Utils::read1stLineOfFile(QString fileName) {
+    QFile f(fileName);
+    if (f.exists()) {
+        if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            QTextStream in(&f);
+            in.setCodec("UTF-8");
+            while(!in.atEnd()) {
+                return in.readLine().toInt();
+            }
+        }
+    }
+    return -1;
+}
+
+QString Utils::zoneName(quint8 i) {
+    static constexpr char const *zName[] = {
+        "",
+        "purple",
+        "blue",
+        "yellow",
+        "green",
+        "yellow (mars)",
+        "green (mars)"
+    };
+    if (i < (sizeof(zName)/sizeof(char const *))) {
+        return zName[i];
+    }
+    return "N/A";
+}
+
+void Utils::printCriticalErrorMsg(QString const &errorMsg) {
+    qCritical() << QString(80, '!');
+    qCritical() << errorMsg;
+    qCritical() << QString(80, '!');
+}
+
+void Utils::printInfoMsg(QString const &infoMsg) {
+    qCritical() << QString(80, '=');
+    qCritical() << infoMsg;
+    qCritical() << QString(80, '=');
+
+}
+
+void Utils::printLineEditInfo(QStringList const &lines) {
+    if (getDebugLevel() == LOG_DEBUG) {
+        for (int i=0; i<lines.size(); ++i) {
+            qInfo() << lines.at(i);
+        } qInfo() << ""; qInfo() << "";
+    }
+}
+
+QString Utils::getTariffLoadTime(QString fileName) {
+    QFileInfo fInfo(fileName);
+    if (fInfo.exists()) {
+        QDateTime lastModifiedTime = fInfo.lastModified();
+        if (lastModifiedTime.isValid()) {
+            return lastModifiedTime.toString(Qt::ISODateWithMs);
+        } else {
+            printCriticalErrorMsg(fileName + " HAS INVALID MODIFIED-TIME");
+            QDateTime birthTime = fInfo.birthTime();
+            if (birthTime.isValid()) {
+                return birthTime.toString(Qt::ISODateWithMs);
+            } else {
+                printCriticalErrorMsg(fileName + " HAS INVALID BIRTH-TIME");
+            }
+        }
+    } else {
+        printCriticalErrorMsg(fileName + " DOES NOT EXIST");
+    }
+    return "N/A";
+}
+
+QString Utils::rstrip(QString const &str) {
+    int n = str.size() - 1;
+    for (; n >= 0; --n) {
+        if (!str.at(n).isSpace()) {
+            return str.left(n + 1);
+        }
+    }
+    return "";
+}
+
+bool Utils::sameFilesInDirs(QDir const &dir1, QDir const &dir2,
+                            QStringList const &nameFilters) {
+    if (!dir1.exists()) {
+        printCriticalErrorMsg(dir1.dirName() + " DOES NOT EXIST");
+        return false;
+    }
+    if (!dir2.exists()) {
+        printCriticalErrorMsg(dir2.dirName() + " DOES NOT EXIST");
+        return false;
+    }
+    if (dir1.absolutePath() == dir2.absolutePath()) {
+        printCriticalErrorMsg(dir1.dirName() + " AND "+ dir2.dirName() + " HAVE SAME PATH");
+        return false;
+    }
+
+    // files, sorted by name
+    QFileInfoList const &lst1 = dir1.entryInfoList(nameFilters, QDir::Files, QDir::Name);
+    QFileInfoList const &lst2 = dir2.entryInfoList(nameFilters, QDir::Files, QDir::Name);
+
+    QStringList fileNameLst1{};
+    QStringList fileNameLst2{};
+    QListIterator<QFileInfo> i1(lst1);
+    while (i1.hasNext()) {
+        fileNameLst1 << i1.next().fileName();
+    }
+    QListIterator<QFileInfo> i2(lst2);
+    while (i2.hasNext()) {
+        fileNameLst2 << i2.next().fileName();
+    }
+
+    if (fileNameLst1.isEmpty()) {
+        qCritical() << "DIR1" << dir1.dirName() << " DOES NOT CONTAIN EXPECTED FILES";
+        return false;
+    }
+    if (fileNameLst2.isEmpty())  {
+        qCritical() << "DIR1" << dir2.dirName() << " DOES NOT CONTAIN EXPECTED FILES";
+        return false;
+    }
+    if (fileNameLst1 != fileNameLst2) {
+        printCriticalErrorMsg(dir1.dirName() + " AND " + dir2.dirName()
+                            + " DIFFER: [" + fileNameLst1.join(',') + "],["
+                            + fileNameLst2.join(',') + "]");
+        return false;
+    } else {
+        printInfoMsg(dir1.dirName() + " AND " + dir2.dirName()
+                    + " ARE EQUAL: [" + fileNameLst1.join(',') + "]");
+    }
+
+    QStringList gitBlobLst1{};
+    QStringList gitBlobLst2{};
+    QListIterator<QFileInfo> i3(lst1);
+    while (i3.hasNext()) {
+        gitBlobLst1 << GitClient::gitBlob(i3.next().fileName());
+    }
+    QListIterator<QFileInfo> i4(lst2);
+    while (i4.hasNext()) {
+        gitBlobLst2 << GitClient::gitBlob(i4.next().fileName());
+    }
+
+    if (gitBlobLst1.isEmpty()) {
+        qCritical() << "DIR1" << dir1.dirName() << " DOES NOT CONTAIN EXPECTED FILES";
+        return false;
+    }
+    if (gitBlobLst2.isEmpty())  {
+        qCritical() << "DIR1" << dir2.dirName() << " DOES NOT CONTAIN EXPECTED FILES";
+        return false;
+    }
+
+    if (gitBlobLst1 != gitBlobLst2) {
+        printCriticalErrorMsg(dir1.dirName() + " AND " + dir2.dirName()
+                            + " DIFFER: [" + gitBlobLst1.join(',') + "],["
+                            + gitBlobLst2.join(',') + "]");
+        return false;
+    } else {
+        printInfoMsg(dir1.dirName() + " AND " + dir2.dirName()
+                    + " CONTAIN SAME GIT-BLOBS FOR FILES: [" + fileNameLst1.join(',') + "]");
+
+    }
+
+    return true;
+}
+
+
+QString Utils::getParentName() { // get name of parent process
+    QString ppid = QString("/proc/%1/status").arg(getppid());
+    QFile f(ppid);
+    if (f.exists()) {
+        if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            QTextStream in(&f);
+            in.setCodec("UTF-8");
+            while(!in.atEnd()) {
+                // Name:   ATBQT
+                QStringList line = in.readLine().split(':');
+                if (line.size() == 2) {
+                    if (line[0].trimmed() == "Name") {
+                        return line[1].trimmed();
+                    }
+                }
+            }
+        }
+    }
+    return "";
+}
+
+bool Utils::isATBQTRunning() {
+    QDirIterator it("/proc",
+                    QStringList() << "status",
+                    QDir::Files,
+                    QDirIterator::Subdirectories);
+    while (it.hasNext()) {
+        QString const &nextStatusFile = it.next();
+        QFile f(nextStatusFile);
+        if (f.exists()) {
+            if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
+                QTextStream in(&f);
+                in.setCodec("UTF-8");
+                while(!in.atEnd()) {
+                    // Name:   ATBQT
+                    QStringList line = in.readLine().split(':');
+                    if (line.size() == 2) {
+                        if (line[0].trimmed() == "Name") {
+                            if (line[1].trimmed() == "ATBQT") {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}

utils.h

@@ -0,0 +1,28 @@
+#ifndef UTILS_H_INCLUDED
+#define UTILS_H_INCLUDED
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QFile>
+#include <QFileInfo>
+#include <QDateTime>
+#include <QDir>
+
+namespace Utils {
+    int read1stLineOfFile(QString fileName);
+    QString zoneName(quint8 i);
+    void printCriticalErrorMsg(QString const &errorMsg);
+    void printInfoMsg(QString const &infoMsg);
+    void printLineEditInfo(QStringList const &lines);
+    QString getTariffLoadTime(QString fileName);
+    QString rstrip(QString const &str);
+    bool sameFilesInDirs(QDir const &dir1, QDir const &dir2,
+                         QStringList const &nameFilters = {"*.json"});
+
+
+    QString getParentName();
+    bool isATBQTRunning();
+}
+
+#endif // UTILS_H_INCLUDED

worker.h

@@ -0,0 +1,207 @@
+#ifndef WORKER_H_INCLUDED
+#define WORKER_H_INCLUDED
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QTimer>
+#include <QFile>
+#include <QJsonObject>
+#include <QHash>
+
+#include <optional>
+
+#include "worker_thread.h"
+#include "update.h"
+#include "git/git_client.h"
+#include "ismas/ismas_client.h"
+
+#ifdef PTU5
+#define SERIAL_PORT "ttymxc2"
+#else
+#define SERIAL_PORT "ttyUSB0"
+#endif
+
+
+enum class UPDATE_STATUS : quint8 {
+    NOT_DEFINED,
+    ISMAS_WAIT_STATE_CHECK_PENDING,
+    ISMAS_WAIT_STATE_CHECK_FAILURE,
+    ISMAS_RESPONSE_RECEIVED,
+    BACKEND_CHECK,
+    BACKEND_CHECK_FAILURE,
+    BACKEND_NOT_CONNECTED,
+    ISMAS_UPDATE_TRIGGER_SET,
+    ISMAS_UPDATE_TRIGGER_NOT_SET_OR_WRONG,
+    GIT_CLONE_AND_CHECKOUT_SUCCESS,
+    GIT_CLONE_AND_CHECKOUT_FAILURE,
+    GIT_CHECKOUT_BRANCH,
+    GIT_CHECKOUT_BRANCH_FAILURE,
+    GIT_FETCH_UPDATES,
+    GIT_FETCH_UPDATES_REQUEST_FAILURE,
+    EXEC_OPKG_COMMAND,
+    EXEC_OPKG_COMMANDS,
+    RSYNC_UPDATES_FAILURE,
+    RSYNC_UPDATES_SUCCESS,
+    RSYNC_FILE_SUCCESS,
+    JSON_PARSE_FAILURE,
+    UPDATE_PROCESS_SUCCESS,
+    UPDATE_PROCESS_FAILURE,
+    ISMAS_SANITY_CHECK_OK,
+    ISMAS_UPDATE_TRIGGER_SET_FAILURE,
+    PSA_UPDATE_FILES_FAILED,
+    GIT_CHECK_FILES_TO_UPDATE_SUCCESS,
+    ISMAS_SEND_LAST_VERSION_FAILED,
+    SAVE_LOG_FILES_FAILED
+};
+
+struct UpdateStatus {
+    UPDATE_STATUS m_updateStatus;
+    QString m_statusDescription;
+
+    explicit UpdateStatus(UPDATE_STATUS s = UPDATE_STATUS::NOT_DEFINED,
+                          QString const &d = QString(""))
+        : m_updateStatus(s), m_statusDescription(d) {}
+};
+
+QDebug operator<<(QDebug debug, UpdateStatus status);
+QString& operator<<(QString &str, UpdateStatus status);
+
+#define ISMAS_UPDATE_REQUESTS   (10)
+
+class MainWindow;
+class hwinf;
+class Worker : public QObject {
+    Q_OBJECT
+
+    WorkerThread m_workerThread;
+    int const m_customerNr;
+    QString const m_customerNrStr;
+    int const m_machineNr;
+    int const m_zoneNr;
+    QString const m_pluginName;
+    QString const m_workingDirectory;
+    QString const m_branchName;
+    QString const m_customerRepositoryPath;
+    QString const m_customerRepository;
+    bool const m_dryRun;
+    QObject *m_parent;
+    QString const m_serialInterface;
+    QString const m_baudrate;
+    IsmasClient m_ismasClient;
+    GitClient m_gc;
+    QString const m_osVersion;
+    QString const m_atbqtVersion;
+    QString const m_cpuSerial;
+    QString const m_pluginVersionATBDeciceController;
+    QString const m_pluginVersionIngenicoISelf;
+    QString const m_pluginVersionMobilisisCalc;
+    QString const m_pluginVersionMobilisisCalcConfig;
+    QString const m_pluginVersionPrmCalc;
+    QString const m_pluginVersionPrmCalcConfig;
+    QString const m_pluginVersionTcpZvt;
+
+    int m_ismasUpdateRequests;
+    QTimer m_waitForNewUpdates;
+
+    UpdateStatus m_updateStatus;
+
+    QStringList m_filesToUpdate;
+    bool m_updateProcessRunning;
+    int m_displayIndex;
+    int m_returnCode;
+
+    MainWindow *m_mainWindow;
+    int m_progressValue;
+    bool m_withoutIsmasDirectPort;
+    QString m_apismVersion;
+
+    bool executeOpkgCommand(QString opkgCommand);
+    QString getOsVersion() const;
+    QString getATBQTVersion() const;
+    QString getCPUSerial() const;
+    QString getRaucVersion() const;
+    QString getOpkgVersion() const;
+    QString getPluginVersion(QString const &pluginFileName) const;
+    QStringList getDCVersion() const;
+
+    qint64 getFileSize(QString const &fileName) const;
+
+public:
+    static const QString UPDATE_STEP_OK;
+    static const QString UPDATE_STEP_DONE;
+    static const QString UPDATE_STEP_FAIL;
+    static const QString UPDATE_STEP_SUCCESS;
+
+    explicit Worker(int customerNr, // 281
+                    int machineNr,
+                    int zoneNr,
+                    QString branchName,
+                    QString pluginName,
+                    QString workingDir = ".",
+                    bool dryRun = false,
+                    QObject *parent = nullptr,
+                    char const *serialInterface = SERIAL_PORT,
+                    char const *baudrate = "115200");
+    ~Worker();
+
+    void setMainWindow(MainWindow *mainWindow) { m_mainWindow = mainWindow; }
+    hwinf *getPlugin();
+    hwinf const *getPlugin() const;
+    void setProgress(int progress);
+    void startProgressLoop();
+    void stopProgressLoop();
+
+    IsmasClient &getIsmasClient() { return m_ismasClient; }
+    IsmasClient const &getIsmasClient() const { return m_ismasClient; }
+
+    bool updateProcessRunning() const { return m_updateProcessRunning; }
+    int returnCode() const { return m_returnCode; }
+
+    int machineNr() const { return m_machineNr; }
+    int customerNr() const { return m_customerNr; }
+    int zoneNr() const { return m_zoneNr; }
+    QString apismVersion() const { return m_apismVersion; }
+
+    MainWindow *mainWindow() { return m_mainWindow; }
+    MainWindow const *mainWindow() const { return m_mainWindow; }
+
+    //friend QDebug operator<<(QDebug debug, Worker const &w) {
+    //    Q_UNUSED(w);
+    //    return debug;
+    //}
+    //friend QString& operator<<(QString &str, Worker const &w) {
+    //    Q_UNUSED(w);
+    //    return str;
+    //}
+
+signals:
+    void appendText(QString, QString suffix = "");
+    void replaceLast(QString, QString);
+    void replaceLast(QStringList, QString);
+    void showErrorMessage(QString title, QString description);
+    void showStatusMessage(QString title, QString description);
+    void stopStartTimer();
+    void restartExitTimer();
+    void enableExit();
+    void disableExit();
+
+public slots:
+    void update();
+
+private slots:
+    bool updateTriggerSet();
+    bool customerEnvironment();
+    bool filesToUpdate();
+    bool updateFiles(quint8 percent);
+    bool syncCustomerRepositoryAndFS();
+    bool sendIsmasLastVersionNotification();
+    bool saveLogFile();
+
+private:
+    PSAInstalled getPSAInstalled();
+    void privateUpdate();
+    std::optional<QString> getApismVersion();
+};
+
+#endif // WORKER_H_INCLUDED

worker_thread.cpp

@@ -0,0 +1,13 @@
+#include "worker_thread.h"
+
+WorkerThread::WorkerThread(QString const &name,
+                           QObject *parent) : QThread(parent) {
+    this->setObjectName(name);
+}
+
+WorkerThread::~WorkerThread() {
+}
+
+//void WorkerThread::run() {
+//
+//}

worker_thread.h

@@ -0,0 +1,17 @@
+#ifndef WORKER_THREAD_H_INCLUDED
+#define WORKER_THREAD_H_INCLUDED
+
+#include <QThread>
+#include <QString>
+
+class WorkerThread : public QThread {
+    Q_OBJECT
+public:
+    WorkerThread(QString const &name, QObject *parent = nullptr);
+    virtual ~WorkerThread();
+
+protected:
+    // virtual void run();
+};
+
+#endif // WORKER_THREAD_H_INCLUDED