Add debug output

Cleaned source.

.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.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.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
+TARGET   = ATBDeviceControllerPlugin
-DESTDIR  = ../plugins
+#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

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}
+
+
+
+
+

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);

include/datIf.h

@@ -308,6 +308,8 @@ class T_datif : public QMainWindow
     QTimer *datif_trigger;
     uint8_t selectedSlaveAddr;
 
+    int datif_noResponseCtr;
+
 private slots:
     char datif_cycleSend();
     void StoredRecData();
@@ -324,12 +326,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

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

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,196 +73,234 @@ struct Tprn_hw_state
     bool    nowAligned;
 };
 
- struct T_dynDat
+struct T_dynDat {
-{
     uint8_t licensePlate[8];
     uint8_t vendingPrice[8];
-    uint8_t parkingEnd[8];
+    uint8_t parkingEndTime[8];
-    uint8_t currentTime[8];
+    uint8_t parkingEndDate[8];
     uint8_t currentDate[8];
     uint8_t dynDat5[8];
     uint8_t dynDat6[8];
     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
+    char startbuffer[4];		// Psa>  // never move or change this 1st entry
-        uint16_t AccountingNumber;
+    uint16_t AccountingNumber;
-        uint16_t CUNU;
+    uint16_t CUNU;
-        uint16_t MANU;
+    uint16_t MANU;
-        uint16_t resint1;
+    uint16_t resint1;
-        //uint16_t resint2;
+    //uint16_t resint2;
 
-        char label1buffer[4];	 // tim>
+    char label1buffer[4];	 // tim>
-        uint8_t year;
+    uint8_t year;
-        uint8_t month;
+    uint8_t month;
-        uint8_t dom;
+    uint8_t dom;
-        uint8_t hour;
+    uint8_t hour;
-        uint8_t min;
+    uint8_t min;
-        uint8_t sec;
+    uint8_t sec;
-        uint8_t DoW;
+    uint8_t DoW;
-        uint8_t reschar3;
+    uint8_t reschar3;
 
-        char label2buffer[4];	// abs>
+    char label2buffer[4];	// abs>
-        uint32_t AbsIncome1;
+    uint32_t AbsIncome1;
-        uint32_t AbsReserve;
+    uint32_t AbsReserve;
-        uint32_t AbsNrOfCuts;
+    uint32_t AbsNrOfCuts;
 
 //16
-        char label3buffer[4];	// mw >
+    char label3buffer[4];	// mw >
 
-        // Verkauf, Tür zu:
+    // Verkauf, Tür zu:
-        uint32_t VKcoinsInserted[16];		// nur für Wechsler, soviel wurde eingeworfen
+    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
+    uint32_t VKcoinsReturned[6];		// nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
 //88
-
+    // Service, Tür offen:
-        // Service, Tür offen:
+    uint16_t ServCoinsInserted[16];		// nur für Wechsler, soviel wurde eingeworfen
-        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
-        uint16_t ServCoinsReturned[6];		// nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
+    uint16_t resint3;
-        uint16_t resint3;
+    uint16_t resint4;
-        uint16_t resint4;
+    uint16_t currentTubeContent[6];		//  nur für Wechsler, aktueller Füllstand
-        uint16_t currentTubeContent[6];		//  nur für Wechsler, aktueller Füllstand
+    uint16_t resint5;
-        uint16_t resint5;
+    uint16_t resint6;
-        uint16_t resint6;
 // 56
-
+    char label4buffer[4];	// box>
-        char label4buffer[4];	// box>
+    uint16_t coinsInVault[16];
-        uint16_t coinsInVault[16];
+    uint16_t billsInStacker[8];
-        uint16_t billsInStacker[8];
 // 48
-
+    char label5buffer[4];	// val>
-        char label5buffer[4];	// val>
+    // actually constant unless exchange rate is changed
-        // actually constant unless exchange rate is changed
+    uint16_t coinDenomination[16];	// 5..50000 (z.B. 2? sind in Ungarn 760Ft)
-        uint16_t coinDenomination[16];	// 5..50000 (z.B. 2? sind in Ungarn 760Ft)
+    uint16_t billDenom[8];
-        uint16_t billDenom[8];
+    uint16_t tubeDenom[6];
-        uint16_t tubeDenom[6];
+    uint16_t exchangeRate;
-        uint16_t exchangeRate;
+    uint16_t resint9;
-        uint16_t resint9;
-
 // 64
-
+    char endofblock[4];	// end>
-        char endofblock[4];	// end>
-
 // 316 byte Block im Speicher
+};
+
+struct T_moduleCondition {
+    // store conditon of all system components, hold in RAM
+    // 0 means unknown, not yet tested/used
+    // 1 means OK
+    // 50..99	= HINT / Notification
+    // 100..150	= WARNING
+    // 200..250	= ERROR
+
+    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;
+    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;
+    uint8_t	mifareReader;
+    uint8_t	creditTerm;
+    uint8_t	coinReject;
+
+    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)
+    uint8_t	doorWasOpened;		// 1: all doors are closed   200: any door was just opened
+    uint8_t	changer;			// can only be tested by usage
+
+    uint8_t   coinBlocker;		// can only be tested by usage
+    uint8_t   billReader;			// can only be tested by usage
+    uint8_t   ResetReason;
+    uint8_t	allModulesChecked;
 
 };
 
-struct T_moduleCondition
+struct T_dynamicCondition {
-{
+    char allDoorsDebounced;     // 99: undefined, 0=all closed, bit1=upper door open  2=midlle door open 3=lower door open
-        // store conditon of all system components, hold in RAM
+    char openedAuthorized;
-        // 0 means unknown, not yet tested/used
+    uint8_t CBinDebounced;
-        // 1 means OK
+    char upperDoor;		// 99: undefined  0:closed  1:open
-        // 50..99	= HINT / Notification
+    char middleDoor;    // 99: undefined  0:closed  1:open
-        // 100..150	= WARNING
+    char lowerDoor;     // 99: undefined  0:closed  1:open
-        // 200..250	= ERROR
+    char reserve;       // not used, always 0
-
+    char billBox;
-        uint8_t	structStart;		// always first!!!
+    char modeAbrech;
-        uint8_t	ram;				// v
+    char onAlarm;       // 0:alarm aus  1:alarm  2:alarm mit Sirene   3: Sirenentest
-        uint8_t	intEe;				// v
+    char nowCardTest;
-        uint8_t	extEe;				// v
+    char nowPayment;
-
+    char lastMifCardType;
-        uint8_t	rtc;				// 1: time/date OK   100: time not plausible  200: hardware error
+    uint8_t lastSDoorState;
-        uint8_t	boardHw;			// v
+    uint8_t lastVDoorState;
-        uint8_t	printer;			// v
+    uint8_t lastCBstate;        // 99: undefined  0:not there   1:insered
-        uint8_t	modem;				// v
+    char        paymentInProgress;
-
+    char        res1;
-        uint8_t	signal;				//		1...99
+    uint16_t    U_Batt;
-        uint8_t	regist;				// 100:not  1:reg  2:ping OK   3:gotTime
+    uint16_t	Temperatur;
-        uint8_t	mdbBus;
+    uint16_t	nrCoinsInBox;
-        uint8_t	coinChecker;		// EMP, OMP or mei-cashflow
+    uint32_t	amountInBox;
-
+    uint32_t	totalTransVolume;
-        uint8_t	coinEscrow;			// v
+    uint32_t	totalNrOfVends;
-        uint8_t	mifareReader;		// v
+    char        jsonValid_config;
-        uint8_t	creditTerm;			// not available
+    char        jsonValid_device;
-        uint8_t	coinReject;			// v
+    char        jsonValid_cash;
-
+    char        jsonValid_print;
-        uint8_t	coinSafe;			// v
+    char        jsonValid_serial;
-        uint8_t   billSafe;			// v
+    char        jsonValid_time;
-        uint8_t	voltage;			// v	// 1:11..14V
+    char        lastFileType;
-        uint8_t   temper;				// v
+// 44
-
+    uint8_t     MifCardHolder[8];
-        uint8_t	poweronTest;
+    uint8_t     resultOfLastTemplPrint;
-        uint8_t   doorState;			// 1: alles zu  200: t?r offen + bit1(S) +bit2(CB) + bit3(CB)
+                // 0: unknown or printing in progress
-        uint8_t	doorWasOpened;		// 1: all doors are closed   200: any door was just opened
+                // 1: OK, doc was printed   2: error, doc was not printed
-        uint8_t	changer;			// can only be tested by usage
+    uint8_t     lastPrinterStatus;
-
+                //        0: printer OK
-        uint8_t   coinBlocker;		// can only be tested by usage
+                //          bit0: near paper end          bit1: no paper
-        uint8_t   billReader;			// can only be tested by usage
+                //          bit2: temperature error       bit3: error head open
-        uint8_t   ResetReason;
+                //          bit4: paper jam in cutter
-        uint8_t	allModulesChecked;
+                //          bit6: no response             bit7: serial rec. error
-
+                //			bit5: printer not ready
-        uint8_t   alarmState;
+    uint8_t     startupTestIsRunning;
-        uint8_t   res11;
+    //54
-        uint8_t   res12;
-        uint8_t   res13;
-
 };
 
-struct T_dynamicCondition
+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
 {
-        // dynamic conditions, change rapidly and frequently
+    // set by master, used(1) or notused (0) or type 2....20
-        // these are values for the Heartbeat
 
-        // T?rschalter entprellt:
+    UCHAR   kindOfPrinter;			// 0:off   1:Gebe
-        char upperDoor;		// 0:fehlt  1:drin
+    UCHAR	kindOfCoinChecker;		// 0: without  1=EMP820   2=EMP900    3=currenza c²	(MW)
-        char middleDoor;
+    UCHAR	kindOfMifareReader;		// by now only stronglink SL025 =1
-        char lowerDoor;
+    UCHAR   suppressSleepMode;		// 0:sleep allowed   1: no sleep
-        char coinBox;
 
-        char billBox;
+    UCHAR	kindOfModem;			// 0:off    1:Sunlink
-        char modeAbrech;
+    UCHAR	kindOfCreditcard;		// 0:off    1:Feig NFC
-        char onAlarm;
+    UCHAR	CoinEscrow;
-        char nowCardTest;
+    UCHAR   CoinRejectUnit;
 
-        char nowPayment;
+    UCHAR	CoinShutter;
-        char lastMifCardType;
+    UCHAR	BillAcceptor;
-        char openedAuthorized;
+    UCHAR	usevaultLock;
-        char allDoorsDebounced;
+    UCHAR	autoAlarm;				// 1: switch on siren for 1min in doors opened unauthorized
 
-        uint8_t lastSDoorState;
+    UCHAR	autoOpen;				// 1: open door covers after valid ATBcard
-        uint8_t lastVDoorState;
+    UCHAR	printAccReceipt;		// 0/1
-        uint8_t CBinDebounced;
+    UCHAR   printDoorReceipt;
-        uint8_t lastCBstate;
+    UCHAR   printTokenTicket;
 
-        char  paymentInProgress;
+    UINT	VaultFullWarnLevel;
-        char res1;
+    UINT	VaultFullErrorLevel;
-        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;
 
 };
 
 
-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
@@ -307,9 +338,16 @@ public:
         // download binary file down into device controller
 
     virtual bool dc_updatePrinterTemplate(enum FileTypeJson type,
-                                          int templateNr,
+                                          QVector<int> templateIdx,
-                                          QString const &fname) const = 0;
+                                          QVector<QString> fnames,
-                       
+                                          QString br,
+                                          QString serial = QString()) const = 0;
+
+    virtual bool dc_printTemplate(enum FileTypeJson type,
+                                  QVector<int> templateIdx,
+                                  QString br,
+                                  QString serial = QString()) const = 0;
+
     virtual void dc_autoRequest(bool on)  const =0;
         // on = true:  select that all READ-Requests are sent automatically 
         // on = false: select that all READ-Requests are sent manually one by one
@@ -1364,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
@@ -1388,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 bool log_chkIfVaultRecordAvailable(void) const=0;
-virtual void log_getVaultRecord(struct T_vaultRecord *retVR) 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
 
@@ -1406,7 +1449,10 @@ 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 uint8_t cash_paymentProcessing(void) const=0;
 
     virtual uint32_t getInsertedAmount(void) const=0;
 
@@ -1430,18 +1476,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;
     /*
 
@@ -1478,8 +1529,7 @@ virtual void log_getVaultRecord(struct T_vaultRecord *retVR) const=0;
 
      */
 
-
+    virtual void sys_getDeviceConditions(struct T_moduleCondition *devCond) const=0;
-    //virtual void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const=0;
     virtual void sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const=0;
 /*
 
@@ -1545,6 +1595,98 @@ 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;
+
+    virtual bool sys_areDCdataValid(void) 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_coinCollectionJustStarted(void) const=0;
+    virtual void hwapi_coinCollectionAborted(void) const=0;
+
+    virtual void hwapi_gotNewCoin(void) const=0;
+    virtual void hwapi_payStopByMax(void) const=0;
+    virtual void hwapi_payStopByPushbutton(void) const=0;
+
+    virtual void hwapi_payStopByEscrow(void) const=0;
+    virtual void hwapi_payStopByError(void) const=0;
+    virtual void hwapi_payStopByTimeout(void) const=0;
+    virtual void hwapi_payCancelled(void) const=0;
+
+    virtual void hwapi_coinProcessJustStopped(void) const=0;
 
 };
 
@@ -1562,10 +1704,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"
 
 
 

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
 

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;
+        char    curPayNewCoin;
+    } 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

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);
+uint8_t gpi_storeDI_auxIn(uint8_t indatAuxIn); // Aux0...5
-    // Aux0...5
+uint8_t epi_getDI_auxIn(void);                 // bit0: auxin 1  ...  5: auxin 6
-
-uint8_t epi_getDI_auxIn(void);
-    // bit0: auxin 1  ...  5: auxin 6
-
-void gpi_storeDI_ptuWake(uint8_t indat);
 
+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);
 
-
+bool gpi_storeDI_contactPowerIsOn(bool on);
-void gpi_storeDI_contactPowerIsOn(bool di_contact_PwrOn);
-
 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);
 
-
+bool gpi_storeDI_rejMot_home(bool reject);
-void gpi_storeDI_rejMot_home(bool di);
-
 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);
 
-
+uint8_t gpi_storeDO_motorOutputs(uint8_t Pwr);
-void 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
 
-
+uint8_t gpi_storeDO_serialSwitch(uint8_t state);
-void 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
 
-
+uint8_t gpi_storeDO_ledsAndFan(uint8_t ledState);
-void 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);
 
-
+uint8_t gpi_storeDO_coinShutter(uint8_t state);
-void gpi_storeDO_coinShutter(uint8_t state);
-
 bool epi_getDO_coinShutterOpen(void);
-
 bool epi_getDO_coinShutterTest(void);
 
-
+uint8_t gpi_storeDO_coinEscrow(uint8_t state);
-void 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
 
-
+uint8_t gpi_storeDO_printerPwrOn(uint8_t state);
-void 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 const *buf);
-
-
-
-uint8_t gpi_storeMifReaderStateAndCardType(uint8_t *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
-
+bool gpi_storeMifCardData(uint8_t blkNr, uint8_t const *receivedData);
-void gpi_storeMifCardData(uint8_t blkNr, uint8_t *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 const *buf);
-void gpi_storePrinterState(uint8_t *buf);
 
 void epi_restorePrinterFonts(uint8_t *buf);
+void gpi_storePrinterFonts(uint8_t const *buf);
 
-void gpi_storePrinterFonts(uint8_t *buf);
+bool gpi_storeMdbState(bool busReady, bool V12on, bool V5on);
-
-
-
-
-void gpi_storeMdbState(uint8_t busReady, uint8_t V12on, uint8_t V5on );
-
 bool epi_restoreMdbBusReady(void);
-
 bool epi_restoreMdbV12Ready(void);
-
 bool epi_restoreMdbV5Ready(void);
 
-
+void gpi_storeMdbResponse(uint8_t leng, uint8_t const *data);
-void gpi_storeMdbResponse(uint8_t leng, uint8_t *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 const *data);
-void gpi_storeEmpSettings(uint8_t leng, uint8_t *data);
-
 void epi_restoreEmpSettings(uint8_t *leng, uint8_t *data);
 
-
 /*
 void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t *data);
 
@@ -463,65 +360,65 @@ 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 const *data);
-
-void gpi_storeRbDeviceSettings(uint8_t leng, uint8_t *data);
-
 void epi_restoreRbDeviceSettings(uint8_t *leng, uint8_t *data);
 
-
+void gpi_storeMachineIDsettings(uint8_t leng, uint8_t const *data);
-void gpi_storeMachineIDsettings(uint8_t leng, uint8_t *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 const *receivedData);
-void gpi_storeWakeSources(uint8_t *receivedData);
-
 uint64_t epi_getWakeSources(void);
+uint8_t epi_getWakeReason(void);
 
-
+void gpi_storeExtendedTime(uint8_t leng, uint8_t const *data);
-
-void gpi_storeExtendedTime(uint8_t leng, uint8_t *data);
-
 void epi_restoreExtendedTime(uint8_t *leng, uint8_t *data);
 
-
+void gpi_storeDeviceConditions(uint8_t leng, uint8_t const *data);
-
-void gpi_storeDeviceConditions(uint8_t leng, uint8_t *data);
-
 void epi_restoreDeviceConditions(uint8_t *leng, uint8_t *data);
 
-
+void gpi_storeDynMachineConditions(uint8_t leng, uint8_t const *data);
-void gpi_storeDynMachineConditions(uint8_t leng, uint8_t *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();
+bool epi_areDcDataValid();
 
 
 

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);
 

src/ATBAPP/ATBAPPplugin.h

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

src/ATBAPP/ATBDeviceControllerPlugin.cpp

@@ -0,0 +1,316 @@
+#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
+                << "  currentDateTime = " << printingData["currentDateTime"] << endl;
+
+    QDateTime parkingEndDateTime = QDateTime::fromString(printingData["parkingEnd"].toString(),  Qt::ISODate);
+    QDateTime currentDateTime    = QDateTime::fromString(printingData["currentDateTime"].toString(), Qt::ISODate);
+
+    /* -----------------------------------------------------------------------------------------
+     * note: the following highly depends on printer template files!
+     * -----------------------------------------------------------------------------------------
+     */
+
+    // set dynamic printer data:
+    QByteArray ba_licenseplate = codec->fromUnicode(printingData["licenseplate"].toString());
+    memcpy((char*)dynTicketData->licensePlate, ba_licenseplate.data(), std::min(ba_licenseplate.size(),8));
+
+    QByteArray ba_amount = codec->fromUnicode(printingData["amount"].toString());
+    memcpy((char*)dynTicketData->vendingPrice,  ba_amount.data(), std::min(ba_amount.size(),8));
+
+    QByteArray ba_parkingEndTime = codec->fromUnicode(parkingEndDateTime.toString("hh:mm"));
+    memcpy((char*)dynTicketData->parkingEndTime,  ba_parkingEndTime.data(), std::min(ba_parkingEndTime.size(),8));
+
+    QByteArray ba_parkingEndDate = codec->fromUnicode(parkingEndDateTime.toString("dd.MM.yy"));
+    memcpy((char*)dynTicketData->parkingEndDate,  ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
+
+    QByteArray ba_currentDate = codec->fromUnicode(currentDateTime.toString("dd.MM.yy"));
+    memcpy((char*)dynTicketData->currentDate,  ba_currentDate.data(), std::min(ba_currentDate.size(),8));
+
+
+    // DEBUG
+    /*
+    uint8_t* buf = dynTicketData->licensePlate;
+    int length = 64;
+    for (int i = 0; i < length; ++i) {
+            fprintf(stderr, "%d %02x %c\n", i, buf[i], buf[i]);
+    }
+    fprintf(stderr, "\n");
+    */
+
+    // 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(500, 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(500, this, SLOT(onPrintFinishedOK()));
+    }
+    else {
+        // print next template
+        this->currentTemplate++;
+        QTimer::singleShot(1000, 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

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

src/ATBAPP/ATBHealthEvent.cpp

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

src/ATBAPP/ATBHealthEvent.h

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

src/ATBAPP/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

src/com.cpp

@@ -19,7 +19,7 @@ void T_com::writeToSerial(const QByteArray &data, uint16_t sendLength)
     sendLen=sendLength;
     if (CatSerial->isOpen())
     {
-        //qDebug() << "sending..." << sendBuffer;
+        qCritical() << "sending..." << sendBuffer;
         CatSerial->write(sendBuffer);
     } else
         qDebug() << "error sending, port is not open";

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"
+    memset(&SharedMemBuffer::getData()->rs.baudStr[0], 0x00,
-static QString    rs_baudStr;       // z.B. "19200"
+           sizeof(SharedMemBuffer::getData()->rs.baudStr));
-static int        rs_baudNr;        //0...5 oder -1
+    strncpy(SharedMemBuffer::getData()->rs.baudStr,
-static uint8_t    rs_connect;       // 0,1
+            BaudStr.toStdString().c_str(),
+            sizeof(SharedMemBuffer::getData()->rs.baudStr)-1);
 
-void epi_setSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect)
+    SharedMemBuffer::getData()->rs.baudNr = BaudNr;
-{
+    SharedMemBuffer::getData()->rs.connect = 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;
 }
 
-void epi_closeSerial(void)
+void epi_closeSerial(void) {
-{
+    SharedMemBuffer::getData()->rs.connect = 0;
-    rs_connect=0;
-//    qDebug() << "ENTER/LEAVE rc_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
+    // rs_connect=2;   // Flanke, nur 1x öffnen/schließen
-    //qDebug() << "ENTER/LEAVE rc_connect=2";
+    SharedMemBuffer::getData()->rs.connect = 2;
 }
 
-uint8_t gpi_getSerialConn(void)
+uint8_t gpi_getSerialConn(void) {
-{
+    return SharedMemBuffer::getDataConst()->rs.connect;
-    return rs_connect;
 }
 
-
+int gpi_getBaudNr(void) {
-int gpi_getBaudNr(void)
+    return SharedMemBuffer::getDataConst()->rs.baudNr;
-{
-    return rs_baudNr;
 }
 
-QString gpi_getComPortName(void)
+QString gpi_getComPortName(void) {
-{
+    return SharedMemBuffer::getDataConst()->rs.comportName;
-    return rs_comportName;
 }
 
-static bool rs_portIsOpen;
+void gpi_serialIsOpen(bool offen) {
-
+    SharedMemBuffer::getData()->rs.portIsOpen = offen;
-void gpi_serialIsOpen(bool offen)
-{
-    //qDebug() << "ENTER/LEAVE offen=" << offen;
-    rs_portIsOpen=offen;
 }
 
-bool epi_isSerialPortOpen()
+bool epi_isSerialPortOpen() {
-{
     // true: port is open   false: port is closed
-    //qDebug() << "ENTER/LEAVE offen=" << rs_portIsOpen;
+    return SharedMemBuffer::getDataConst()->rs.portIsOpen;
-    return rs_portIsOpen;
 }
 
 // ///////////////////////////////////////////////////////////////////////////////////
 //          Control transfer   gui <--> serial
 // ///////////////////////////////////////////////////////////////////////////////////
 
-
+void epi_startEmmision(char start) {
-static char       AutoEmissionOn;     // 1: zyklisch Anfragen zum Slave senden
+    SharedMemBuffer::getData()->AutoEmissionOn = start;
-
-void epi_startEmmision(char start)
-{
-    AutoEmissionOn=start;
 }
 
-bool gpi_isEmmisionOn(void)
+bool gpi_isEmmisionOn(void) {
-{
+    return SharedMemBuffer::getDataConst()->AutoEmissionOn;
-    return AutoEmissionOn;
 }
 
-//-----------------------------------------------------
+uint16_t gpi_getPeriodicSendTimeVal() {
-
+    SharedMemBuffer::getData()->datif.sendingPer_changed = 0;
-static uint16_t datif_sendingPeriod;
+    if ((SharedMemBuffer::getDataConst()->datif.sendingPeriod < 3) ||
-static bool     datif_sendingPer_changed;
+        (SharedMemBuffer::getDataConst()->datif.sendingPeriod > 10000)) {
-
-uint16_t gpi_getPeriodicSendTimeVal()
-{
-    datif_sendingPer_changed=0;
-    if (datif_sendingPeriod<3 || datif_sendingPeriod>10000)
         return 130;         // ms, default
-    else
+    }
-        return datif_sendingPeriod;
+    return SharedMemBuffer::getDataConst()->datif.sendingPeriod;
 }
 
-void epi_setPeriodicSendTimeVal(uint16_t val)
+void epi_setPeriodicSendTimeVal(uint16_t val) {
-{
+    if (val>=3 && val<10000) {
-    if (val>=3 && val<10000)
+        SharedMemBuffer::getData()->datif.sendingPer_changed = 1;
-    {
+        SharedMemBuffer::getData()->datif.sendingPeriod = val;
-        datif_sendingPer_changed=1;
-        datif_sendingPeriod=val;
     }
 }
 
-bool gpi_PeriodicSendTimeHasChanged()
+bool gpi_PeriodicSendTimeHasChanged() {
-{
+    return SharedMemBuffer::getDataConst()->datif.sendingPer_changed;
-    return 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
 // ///////////////////////////////////////////////////////////////////////////////////
-
+void gpi_storeResult_serialTestOK(bool wasOk) {
-
+    SharedMemBuffer::getData()->Sdata.serialTestResult = wasOk;
-static bool Sdata_serialTestResult;
-
-void gpi_storeResult_serialTestOK(bool wasOk)
-{
-    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
 // ///////////////////////////////////////////////////////////////////////////////////
-
+void gpi_startNewRequest() {
-
+    SharedMemBuffer::getData()->Sdata.pProtResultOk = 0;
-
-static uint8_t Sdata_pProtResultOk;
-
-void gpi_startNewRequest()
-{
-    Sdata_pProtResultOk=0;
 }
 
-void gpi_storeResultOfLastRequest(bool answisok)
+void gpi_storeResultOfLastRequest(bool answisok) {
-{
+    SharedMemBuffer::getData()->Sdata.pProtResultOk = answisok ? 1 : 2;
-    if (answisok)
-        Sdata_pProtResultOk=1;
-    else
-        Sdata_pProtResultOk=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;
 }
 
-
+void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t const *receivedData) {
-
+    SharedMemBuffer::getData()->Sdata.receivedDataLength
-
+        = std::min(RdDlen, (uint8_t)(64));
-static uint16_t Sdata_receivedDataLength;
+    memset((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
-static uint8_t Sdata_receivedDataBlock[64];
+           0x00, sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock));
-
+    strncpy((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
-void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t *receivedData)
+            (char const *)receivedData,
-{
+            sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock)-1);
-    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);
-
 }
 
-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;
+    uint16_t ml = std::min(plBufSiz, (uint16_t)(64));
-    if (ml>64) ml=64;
+    if (SharedMemBuffer::getDataConst()->Sdata.receivedDataLength < ml) {
-    if (Sdata_receivedDataLength<ml)
+        ml = SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
-        ml=Sdata_receivedDataLength;
+    }
-    tslib_strcpy(Sdata_receivedDataBlock, payLoad, ml);
+    strncpy((char *)payLoad,
-    return Sdata_receivedDataLength;
+            (char const *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
+            ml);
+
+    return SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
 }
-
-
-
-
-

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,9 @@ T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
     dif_scanStep=0;
     selectedSlaveAddr=FIX_SLAVE_ADDR;
     cycl_running=0;
+    //datif_DCdataValid=0;
+    gpi_storeDcDataValid(0);
+    datif_noResponseCtr=0;
 }
 
 void T_datif::resetChain(void)
@@ -65,6 +70,11 @@ char T_datif::datif_cycleSend()
     uint8_t length, data[66];
     bool b_ret;
 
+    datif_noResponseCtr++;         // inc every 10ms    fehlt noch in SysCont
+    if (datif_noResponseCtr>500)    // seit 5s kein Lebenszeichen von DC2
+        gpi_storeDcDataValid(0);    // fehlt in SysCont
+
+
     if (cycl_running)
     {
         // request is still running, wait for response before next sending
@@ -210,7 +220,10 @@ char T_datif::datif_cycleSend()
                 sendINrequestsAutomatic();  // sendCyclicCmd();       // request all cyclic data sequential
             }
             else
+            {
                 dif_scanStep=0;         // always start from beginning
+                gpi_storeDcDataValid(0);    // fehlt in SysCont
+            }
         }
         #ifdef USEHANDSHAKES
         else
@@ -221,6 +234,7 @@ char T_datif::datif_cycleSend()
     } else
     {
         //qDebug()  << "com port not available";    // wird ununterbrochen ausgegeben
+        gpi_storeDcDataValid(0);    // fehlt in SysCont
     }
 
     return 0;
@@ -838,6 +852,7 @@ char T_datif::isPortOpen(void)
 
 void T_datif::StoredRecData()
 {
+    datif_noResponseCtr=0;
     //qDebug() << "StoreRecData called";
     // call automatically by T_prot
     //if (myDCIF->ifDataReceived())
@@ -863,18 +878,29 @@ 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
     gpi_storeResultOfLastRequest(ret);
+
+
+    qCritical() << "loadRecDataFromFrame() readSource = " << readSource;
+
     if (ret==false)
     {
-     //   qDebug() << "datif: rec data not valid";
+        qCritical() << "datif: rec data not valid";
         return 0;
     }
 
     gpi_storeRecPayLoad(RdDleng, receivedData); //  save for host (user of hwapi)
 
+
+    qCritical() << "loadRecDataFromFrame() readSource = " << readSource;
     //qDebug() << "\n datif: got valid data, rdsrc:" << readSource << "  rdadd:" << readAddress
      //        << "  rdlen:" << RdDleng;
 //    qDebug("datif_recData: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
@@ -902,7 +928,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 +963,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 +1139,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
@@ -1189,7 +1218,7 @@ char T_datif::loadRecDataFromFrame()
         break;
 
     case CMD2DC_EMP_GET_ALL:        //23
-        //qDebug() << "got emp parameters "<< receivedData[1];
+        qCritical() << "got emp parameters "<< receivedData[1];
         gpi_storeEmpSettings(64, receivedData);
         break;
 
@@ -1198,6 +1227,15 @@ char T_datif::loadRecDataFromFrame()
         // DB1: last coin signal (value / scale)
         // DB2,3: last coin value
         // DB4: lastError from Emp
+
+        // 0: nr of stored coins
+        // 1: got  2:type  3:err  4=valL  5=valH
+
+//        qDebug() << "got emp coin "<< " " << receivedData[0] <<" " << receivedData[1]
+//                 << " " << receivedData[2]<< " " << receivedData[3]
+//                 << " " << receivedData[4]<< " " << receivedData[5]
+//                 << " " << receivedData[6]<< " " << receivedData[7];
+
         gpi_storeEmpCoinSignal(receivedData[0], &receivedData[1]);
         break;
 
@@ -1216,7 +1254,7 @@ char T_datif::loadRecDataFromFrame()
 
 
 
-// ab hier neu:    XXX
+// ab hier neu:    12.4.23
 
     case CMD2DC_RDBK_DEV_PARA:      //14
 /*
@@ -1350,10 +1388,23 @@ 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);
+        if (uitmp>0) // nur 1x bei neuer Münze
+        {
+            gpi_storeCurrentPayment(newInsertedAmount, uitmp, uit2);
+            //void gpi_storeCurrentPayment(uint32_t insertedAmount, uint16_t lastCoinType, uint16_t lastCoinValue)
+            if (newInsertedAmount != lastInsertedAmount)
+            {
+                emit datif_gotNewCoin();
+//qDebug()<<"emit new coin";
+
+                lastInsertedAmount=newInsertedAmount;
+            }
+qDebug()<<"   store new coin"<<newInsertedAmount<<" "<<uitmp<<" "<<uit2;
+        }
+
         break;
 
     case 113:       // get wake source, 8byte
@@ -1464,18 +1515,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,10 +1614,12 @@ struct T_vaultRecord
     UCHAR endofblock[4];	// end>
 // 316 byte Block im Speicher
 */
-
+        // readAddress,  &RdDleng, receivedData
+        gpi_storeVaultRecord(readAddress, receivedData );   // always 64byte
         break;
 
     }
+    readSource=0;   // 17.05.2023: to avoid multiple recording
 
     return 0;
 }
@@ -1644,11 +1719,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 +1735,7 @@ bool T_datif::verifyLineTestresponse(uint8_t RdDlen, uint8_t *receivedData)
             //qDebug() << nn;
             return false;
         }
+    }
     return true;
 }
 

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()
+{
+
+}
+

src/prot.cpp

@@ -433,7 +433,8 @@ uint8_t recBuffer[FRAME_MAXLEN];
 
     // read from "VCP":
     mySerialPort->readFromSerial(Indata, recLength);
-//qDebug()<<"prot: got data " << recLength;
+    qCritical()<<"prot: got data "  << recLength;
+    qCritical()<<"        Indata: " << Indata;
     if (recLength>FRAME_MAXLEN)
         recLength=FRAME_MAXLEN;
     for (int nn=0; nn<recLength; nn++)
@@ -443,6 +444,9 @@ uint8_t recBuffer[FRAME_MAXLEN];
     tempStr.clear();
     //uint8_t result=FramecheckInData(recBuffer, recLength);  // check input data (response from slave)
     uint8_t result=FastCheckInData(recBuffer, recLength);  // check input data (response from slave)
+
+    qCritical()<<"    FastCheckInData() result = " << result;
+
     if (result>0)
     {
         // dann anzeige

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];
@@ -658,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;
+}
+
+
 
 

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

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));