Merge branch 'pu/integration' into pu/accountRequest

... but this is currently useless because we can not detect overpayment
here.

.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

@@ -1,25 +0,0 @@
-INCLUDEPATH += $${PWD}/include
-DEPENDPATH += $${PWD}
-
-HEADERS += $${PWD}/include/com.h \
-    $${PWD}/include/controlBus.h \
-    $${PWD}/include/datIf.h \
-    $${PWD}/include/dcBL.h \
-    $${PWD}/include/hwapi.h \
-    $${PWD}/include/interfaces.h \
-    $${PWD}/include/prot.h \
-    $${PWD}/include/sendWRcmd.h \
-    $${PWD}/include/storeINdata.h \
-    $${PWD}/include/tslib.h \
-    $${PWD}/include/shared_mem_buffer.h
-
-SOURCES += $${PWD}/src/com.cpp \
-    $${PWD}/src/controlBus.cpp \
-    $${PWD}/src/datIf.cpp \
-    $${PWD}/src/dcBL.cpp \
-    $${PWD}/src/hwapi.cpp \
-    $${PWD}/src/prot.cpp \
-    $${PWD}/src/sendWRcmd.cpp \
-    $${PWD}/src/storeINdata.cpp \
-    $${PWD}/src/tslib.cpp \
-    $${PWD}/src/shared_mem_buffer.cpp

DCPlugin.pro

@@ -4,7 +4,7 @@ CONFIG += plugin
 #CONFIG -= app_bundle
 #QT += widgets
 QT -= gui
-QT += widgets serialport
+QT += serialport
 
 INCLUDEPATH += $${PWD}/plugins
 INCLUDEPATH += $${PWD}/include
@@ -14,6 +14,7 @@ QMAKE_CXXFLAGS += -Wno-deprecated-copy
 # default
 ARCH = PTU5
 
+
 contains( CONFIG, DesktopLinux ) {
     QMAKE_CC = ccache $$QMAKE_CC
     QMAKE_CXX = ccache $$QMAKE_CXX
@@ -21,7 +22,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 +31,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 +67,30 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #else: unix:!android: target.path = /opt/$${TARGET}/bin
 #!isEmpty(target.path): INSTALLS += target
 
+# ATBAPP interface
+HEADERS += \
+    include/interfaces.h \
+    src/ATBAPP/ATBAPPplugin.h \
+    src/ATBAPP/DeviceControllerInterface.h \
+    src/ATBAPP/ATBHealthEvent.h \
+    src/ATBAPP/ATBDeviceControllerPlugin.h \
+    src/ATBAPP/Utils.h
+
+SOURCES += \
+    src/ATBAPP/ATBHealthEvent.cpp \
+    src/ATBAPP/ATBDeviceControllerPlugin.cpp \
+    src/ATBAPP/Utils.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/com.h

@@ -1,105 +0,0 @@
-//CAT is always master, no receive before request
-
-#ifndef SER_H
-#define SER_H
-#include <stdint.h>
-#include <QMainWindow>
-#include <QString>
-#include <QTimer>
-#include <QSerialPort>
-#include "tslib.h"
-#include "controlBus.h"
-
-#define MAXTELEGRAMLEN          90
-
-// display all inputs and outputs in output window:
-//#define PRINTALLDEBUGS          1
-
-class T_com : public QMainWindow        //,  public QPlainTextEdit
-{
-    Q_OBJECT
-
-    // complete send message (protocol frame)
-    QByteArray  sendBuffer;         //[MAXTELEGRAMLEN];
-    uint16_t     sendLen;            // >0: Daten Sendebereit, nach senden wieder auf 0 setzen
-
-    // right after reception:
-    QByteArray  rawInput;           //[MAXTELEGRAMLEN];
-    uint16_t     rawInLen;           // 0: keine neuen Daten erhalten
-
-//    QSerialPort *CatSerial = nullptr;
-    QSerialPort *CatSerial;
-
-    //char oeffneSerialPort();
-    char open_Serial_Port();
-    void closeSerialPort();
-    void receiveByLength(void);
-
-private slots:
-    void readSomeBytes(void);
-    void serialSendComplete(void);
-    //void incomingWake(void);    //bool LevelOfTheBit);
-    void receiveTO(void);
-    void ser_ISR100ms();
-
-
-
-public:
-    T_com(QWidget *parent = nullptr);
-    ~T_com();
-
-    QTimer *serRecTime;
-
-    bool isPortOpen(void);
-
-    void writeToSerial(const QByteArray &data, uint16_t sendLength);
-
-    void receiveFixLen(int64_t nrOfbytesToReceive);
-
-    bool readFromSerial(QByteArray &data, uint16_t &sendLength);
-        // retval: true: data available
-
-/*
-    uint8_t getAllPortPins(void);
-        // rs232pins: all signals bitwise coded in one byte:
-        // readback output:  bit 0=TxD(=output)      bit2=DTR (=output)    bit 6=RTS (=output)
-        // unused inputs:       bit1=RxD    bit 3=DCD    bit 5 = RING
-        // handshake inputs:           bit 4=DSR (0x10)     bit 7=CTS (0x80)
-
-    bool getHSin_CTS(void);
-        // return the CTS Handshake input): true= high level (+8V)
-
-    bool getHSin_DSR(void);
-        // return the DSR Handshake input): true= high level (+8V)
-
-    bool setHSout_RTS(bool hsout);
-        // hsout true=positiv voltage +12V  false= -12V
-        // retval: true=setting OK
-
-    bool setHSout_DTR(bool hsout);
-        // hsout true=positiv voltage +12V  false= -12V
-        // retval: true=setting OK
-*/
-
-signals:
-    void receivingFinished();
-    void sendingFinished();
-    //void wasWokenBySerialHandshake();
-
-};
-
-
-
-#endif // SER_H
-
-
-
-
-
-
-
-
-
-
-
-

include/controlBus.h

@@ -1,194 +0,0 @@
-#ifndef CONTROLBUS_H
-#define CONTROLBUS_H
-
-
-#include <stdint.h>
-#include "tslib.h"
-#include <QString>
-
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          control serial interface   gui <--> serial
-// ///////////////////////////////////////////////////////////////////////////////////
-
-
-void epi_setSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect);
-    // Actions: open serial port with parameters
-
-void epi_closeSerial(void);
-// Actions: close serial port
-
-// Actions, GUI Buttons -> API, start cyclic transmission
-void epi_startEmmision(char start);   // 1: start sending activated
-
-//void epi_setPeriodicSendTimeVal(uint16_t val);
-
-
-//  Port -> API
-void gpi_serialChanged(void);
-    // serial confirms that port was closed or opened
-
-// Actions, API -> serialPort
-uint8_t gpi_getSerialConn(void);      // connect if 1, disconnect if 0
-
-int gpi_getBaudNr(void);
-
-QString gpi_getComPortName(void);
-
-
-void gpi_serialIsOpen(bool offen);
-
-bool epi_isSerialPortOpen();
-    // true: port is open   false: port is closed
-
-
-
-
-
-// Meldung von TabCom an Datif: starte zyklische Sendung:
-bool gpi_isEmmisionOn(void);
-
-//uint16_t gpi_getPeriodicSendTimeVal();
-
-//bool gpi_PeriodicSendTimeHasChanged();
-
-//void epi_setCurrSlavAddr(int slavAd);
-
-//int gpi_getCurrSlavAddr(void);
-
-
-
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          Status Display    gui <--> serial
-// ///////////////////////////////////////////////////////////////////////////////////
-
-//---------------------
-    // Statuszeile COM Port  (serial Port) (open, closed)
-// Display in tab_com
-QString epi_getTxt4comStateLine(void);
-void epi_clrTxt4comStateLine();
-    // GUI: get Text for serial Comport-State Line
-
-//---------------------
-// Statuszeile Handshakes (serial Control)   flow.cpp
-// geht überhaupt was raus? kommt überhaupt was zurück?
-// I
-QString epi_getTxt4HsStateLine(void);
-void epi_clrTxt4HsStateLine();
-    // GUI: get Text
-
-// II Master receive state (empfangenes Telgramm OK? crc? length?  )
-// Statuszeile Auswertung der SlaveResponse (serial Frame, CRC usw)  (prot.cpp)
-QString epi_getTxt4masterStateLine(void);
-void epi_clrTxt4masterStateLine();
-
-// III Slave receive (from Master) OK? if then show results, if not then show errors
-// entweder Empfangsfehler anzeigen (crc? length?) oder result OUT-OK, OUT_ERR, IN_OK, IN_ERR
-// Hintergrund: wenn der Slave Fehler im Master-Telegramm gefunden hat, dann kann er es auch
-// nicht verwenden und nichts ausgeben oder einlesen
-QString epi_getTxt4resultStateLine(void);
-void epi_clrTxt4resultStateLine();
-
-// IV  Statuszeile Sende- und Empfangsdaten (Datif)
-// Display in tab_com
-QString epi_getTxt4dataStateLine(void);
-void epi_clrTxt4dataStateLine();
-// GUI: get Text for serial Comport-State Line
-
-// V, unten, Datif
-QString epi_getTxt4datifLine(void);
-void epi_clrTxt4datifLine();
-
-//---------------------
-
-        // sende-empfangs-Rohdaten-Fenster
-// Display in tab_com
-QString epi_getTxt4RsDiagWin(void);
-void epi_clrTxt4RsDiagWin();
-
-QString epi_get2ndTxt4RsDiagWin(void);
-void epi_clr2ndTxt4RsDiagWin();
-
-
-// Statuszeile COM Port  (serial Port) (open, closed)
-// Display in tab_com
-void gpi_setTxt4comStateLine(QString txtline);
-    // serial: write Text to be displayed in serial Comport-State line (like "connected")
-    // used in vcp.cpp, links in tabCom
-
-
-// Statuszeile Handshakes (serial Control)
-// I obere Zeile
-void gpi_setTxt4HsStateLine(QString txtline);
-    // used in flow.cc
-
-// II
-void gpi_setTxt4masterStateLine(QString txtline);
-
-// III
-void gpi_setTxt4resultStateLine(QString txtline);
-
-// IV
-void gpi_setTxt4dataStateLine(QString txtline);
-    // serial: write Text to be displayed in serial Comport-State line (like "connected")
-    // used in prot.cpp
-
-// V  unten:
-void gpi_setTxt4datifLine(QString txtline);
-
-
-// sende-empfangs-Rohdaten-Fenster
-// Display in tab_com
-void gpi_setTxt4RsDiagWin(QString txtline);
-void gpi_set2ndTxt4RsDiagWin(QString txtline);
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          Memory for Slave responses, common data
-// ///////////////////////////////////////////////////////////////////////////////////
-
-bool epi_getResult_serialTestOK();
-// retval: true: test was successful, got right response
-
-
-// result of serial line test, slave sent fixed string
-void gpi_storeResult_serialTestOK(bool wasOn);
-
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          restore just received data
-// ///////////////////////////////////////////////////////////////////////////////////
-
-
-uint8_t gpi_startNewRequest();
-    // called by Datif
-
-uint8_t gpi_storeResultOfLastRequest(bool answisok);
-    // written by Datif
-
-uint8_t epi_getResultOfLastRequest();
-    // retval: 0: in progress  1: OK  2: error
-
-
-void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t const *receivedData);
-    // stored by Datif
-
-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
-
-
-
-#endif
-
-
-
-
-
-
-
-
-
-

include/datIf.h

@@ -1,340 +0,0 @@
-// Data Interface between slave (DC) and pi buffer
-// determines sending and receiving order of data
-// cares for storing input data and restoring output data
-
-
-
-#ifndef DIF_H
-#define DIF_H
-#include <stdint.h>
-#include "tslib.h"
-#include "prot.h"
-#include "dcBL.h"
-
-
-#include <QMainWindow>
-#include <QString>
-#include <QTimer>
-#include <QDebug>
-#include <QDateTime>
-#include <QDate>
-#include <QTime>
-
-
-
-#define CMD2DC_sendTime             20
-#define CMD2DC_setWakeFrequ         112
-#define CMD2DC_MOV_UPLOCK           113
-#define CMD2DC_MOV_DNLOCK           114
-#define CMD2DC_UPPER_DOOR           115
-#define CMD2DC_LOWER_DOOR           116
-#define CMD2DC_VAULT_DOOR           117
-#define CMD2DC_REJMOT_ON            118
-#define CMD2DC_REJMOT_RUN           119
-#define CMD2DC_LED_COIN             100
-#define CMD2DC_LED_ILLU             101
-#define CMD2DC_LED_TICKET           102
-#define CMD2DC_LED_START            104
-#define CMD2DC_LED_PIN              103
-#define CMD2DC_LED_IN               105
-#define CMD2DC_FAN                  106
-#define CMD2DC_SIREN                107
-#define CMD2DC_BARRIER              108
-#define CMD2DC_WAKEPTU              109
-#define CMD2DC_SWITCHAUXPWR         110
-#define CMD2DC_SWITCHAUXDDR         18
-#define CMD2DC_SWITCHAUXOUT         19
-#define CMD2DC_UCONTACTON           111
-#define CMD2DC_DEVICE_PARAM         23
-#define CMD2DC_SEND_MACH_ID         11
-#define CMD2DC_RDBK_DEV_PARA        14
-
-#define CMD2DC_RDBK_MACH_ID         15
-
-#define CMD2DC_MDB_ON               120
-#define CMD2DC_MDB_GET_STATE        107  // REQ
-#define CMD2DC_MDB_DORESET          121
-#define CMD2DC_MDB_SETWAK           122
-//#define CMD2DC_MDB_GETWAK           0x2812  // REQ not nec.
-#define CMD2DC_MDB_SENDCMD          123
-#define CMD2DC_MDB_SENDMSG          12
-#define CMD2DC_MDB_GETRESP          22  // REQ
-
-#define CMD2DC_EMP_SET              24
-#define CMD2DC_EMP_GET_ALL          23  // REQ
-#define CMD2DC_EMP_STARTPOLL        124
-#define CMD2DC_EMP_STARTPAY         125
-#define CMD2DC_EMP_STOPPAY          126
-#define CMD2DC_EMP_GOTCOIN          108  // REQ
-#define CMD2DC_SHUTTER_OPEN         129
-#define CMD2DC_ESCR_OPEN            132
-#define CMD2DC_ESCR_TAKE            133
-#define CMD2DC_ESCR_RETURN          134
-#define CMD2DC_MOD_ON               135
-#define CMD2DC_MOD_WAK              136
-#define CMD2DC_CRED_ON              137
-#define CMD2DC_CRED_WAK             138
-
-// READ Commands ((e.g. get input)
-#define CMD2DC_TestSerial           10
-#define CMD2DC_GetSerialConfig      105
-#define CMD2DC_RdBkHWversion        11
-#define CMD2DC_RdBkSWversion        12
-#define CMD2DC_RdBkDCstate          101
-#define CMD2DC_RdBkUID              18
-#define CMD2DC_RdBkTime             104
-#define CMD2DC_RdBkAnalog           106
-#define CMD2DC_GetAllInputs         102
-#define CMD2DC_RdBkAllOutputs       103
-#define CMD2DC_MIFREADERON          127
-#define CMD2DC_ATB_CREATE           128
-
-
-
-
-// Mif read data:
-#define CMD2DC_RdBk_MifState        109
-#define CMD2DC_RdBk_MifData         24
-
-
-
-
-#define CMD2DC_RdBk_AtbCardType     25
-#define CMD2DC_SHUTTER_COIN         131
-#define CMD2DC_SHUTTER_OPEN3S       130
-#define CMD2DC_SEND_SHUT_TIME       0x2915
-#define CMD2DC_ESCR_TAKE            133
-#define CMD2DC_ESCR_RETURN          134
-#define CMD2DC_PRINTERON            139
-#define CMD2DC_RdBk_PrnState        110
-#define CMD2DC_RdBk_PrnFonts        26
-#define CMD2DC_RdBk_AllPrnData      27
-                                           // nr of params:
-#define CMD2DC_PRI_SYS_CMD          25  // 3
-#define CMD2DC_PRI_ESC_CMD          26  // 4
-#define CMD2DC_PRI_SETUP            27  // 5
-#define CMD2DC_PRI_MOVE             140  // 2
-#define CMD2DC_PRI_SETFONT          141  // 4
-#define CMD2DC_PRI_SETLETTER        142  // 3
-#define CMD2DC_PRI_CUT              143  // 1
-#define CMD2DC_PRI_PRINT_TXT        13  // 64
-#define CMD2DC_PRI_LF               144  // 1
-#define CMD2DC_PRI_PRIFONTTABLE     145
-#define CMD2DC_PRI_BARCODE          14  // ca 15...25
-#define CMD2DC_STOR_QR_DATA         15  // 150
-#define CMD2DC_PRI_QR_CODE          146  // 0
-#define CMD2DC_PRI_LOGOFROMFLASH    147  // 2
-#define CMD2DC_PRI_STORE_DOC        16  // 1
-#define CMD2DC_PRI_DOCUMENT_NR      17  // 1 + 64
-#define CMD2DC_PRI_CLEAR_DOC        148  // 1
-
-
-/*
-// WRITE Commands (e.g. switch relay)
-#define CMD2DC_sendTime             0x1310
-#define CMD2DC_setWakeFrequ         0x1320
-
-#define CMD2DC_MOV_UPLOCK           0x1801
-#define CMD2DC_MOV_DNLOCK           0x1802
-#define CMD2DC_UPPER_DOOR           0x1810
-#define CMD2DC_LOWER_DOOR           0x1811
-#define CMD2DC_VAULT_DOOR           0x1812
-
-// neu 7.10.21:
-#define CMD2DC_REJMOT_ON            0x1813
-#define CMD2DC_REJMOT_RUN           0x1814
-
-
-#define CMD2DC_LED_COIN             0x1204
-#define CMD2DC_LED_ILLU             0x1205
-#define CMD2DC_LED_TICKET           0x1206
-#define CMD2DC_LED_START            0x1208
-#define CMD2DC_LED_PIN              0x1207
-#define CMD2DC_LED_IN               0x1209
-#define CMD2DC_FAN                  0x1210
-#define CMD2DC_SIREN                0x1211
-#define CMD2DC_BARRIER              0x1212
-#define CMD2DC_WAKEPTU              0x1218
-#define CMD2DC_SWITCHAUXPWR         0x1220
-#define CMD2DC_SWITCHAUXDDR         0x1222
-#define CMD2DC_SWITCHAUXOUT         0x1224
-#define CMD2DC_UCONTACTON           0x1226
-
-#define CMD2DC_DEVICE_PARAM         0x2000
-#define CMD2DC_SEND_MACH_ID         0x2002
-#define CMD2DC_RDBK_DEV_PARA        0x2001
-#define CMD2DC_RDBK_MACH_ID         0x2003
-
-
-
-// --------------------------- MDB --------------
-#define CMD2DC_MDB_ON               0x2800
-#define CMD2DC_MDB_GET_STATE        0x2801  // REQ
-#define CMD2DC_MDB_DORESET          0x2802
-#define CMD2DC_MDB_SETWAK           0x2811
-//#define CMD2DC_MDB_GETWAK           0x2812  // REQ not nec.
-#define CMD2DC_MDB_SENDCMD          0x2820
-#define CMD2DC_MDB_SENDMSG          0x2821
-#define CMD2DC_MDB_GETRESP          0x2822  // REQ
-
-// --------------------------- EMP --------------
-#define CMD2DC_EMP_SET              0x2830
-#define CMD2DC_EMP_GET_ALL          0x2831  // REQ
-#define CMD2DC_EMP_STARTPOLL        0x2832
-#define CMD2DC_EMP_STARTPAY         0x2834
-#define CMD2DC_EMP_STOPPAY          0x2836
-#define CMD2DC_EMP_GOTCOIN          0x2837  // REQ
-
-
-
-
-
-
-
-
-#define CMD2DC_SHUTTER_OPEN         0x2911
-#define CMD2DC_ESCR_OPEN            0x2920
-#define CMD2DC_ESCR_TAKE            0x2921
-#define CMD2DC_ESCR_RETURN          0x2922
-#define CMD2DC_MOD_ON               0x2940
-#define CMD2DC_MOD_WAK              0x2941
-#define CMD2DC_CRED_ON              0x2960
-#define CMD2DC_CRED_WAK             0x2961
-
-
-// READ Commands ((e.g. get input)
-#define CMD2DC_TestSerial           0x1101
-#define CMD2DC_GetSerialConfig      0x1107
-#define CMD2DC_RdBkHWversion        0x110A
-#define CMD2DC_RdBkSWversion        0x110B
-#define CMD2DC_RdBkDCstate          0x110C
-
-#define CMD2DC_RdBkUID              0x1305
-#define CMD2DC_RdBkTime             0x1313
-#define CMD2DC_RdBkAnalog           0x1550
-#define CMD2DC_GetAllInputs         0x1201
-#define CMD2DC_RdBkAllOutputs       0x1202
-
-
-#define CMD2DC_MIFREADERON          0x2900
-#define CMD2DC_ATB_CREATE           0x2907
-// Mif read data:
-#define CMD2DC_RdBk_MifState       0x2902
-#define CMD2DC_RdBk_MifData         0x2903
-#define CMD2DC_RdBk_AtbCardType     0x2905
-//#define CMD2DC_RdBk_CardData        0x2906
-
-
-
-
-// higher Level operation commands
-//#define CMD2DC_SHUTTER_ONE          0x2912
-#define CMD2DC_SHUTTER_COIN         0x2913
-#define CMD2DC_SHUTTER_OPEN3S       0x2912
-#define CMD2DC_SEND_SHUT_TIME       0x2915
-
-#define CMD2DC_ESCR_TAKE            0x2921
-#define CMD2DC_ESCR_RETURN          0x2922
-
-
-#define CMD2DC_PRINTERON            0x2A01
-#define CMD2DC_RdBk_PrnState        0x2A02
-#define CMD2DC_RdBk_PrnFonts        0x2A12
-#define CMD2DC_RdBk_AllPrnData      0x2A40
-
-                                            // nr of params:
-#define CMD2DC_PRI_SYS_CMD          0x2A03  // 3
-#define CMD2DC_PRI_ESC_CMD          0x2A04  // 4
-#define CMD2DC_PRI_SETUP            0x2A05  // 5
-#define CMD2DC_PRI_MOVE             0x2A06  // 2
-#define CMD2DC_PRI_SETFONT          0x2A10  // 4
-#define CMD2DC_PRI_SETLETTER        0x2A11  // 3
-#define CMD2DC_PRI_CUT              0x2A13  // 1
-
-#define CMD2DC_PRI_PRINT_TXT        0x2A14  // 64
-
-#define CMD2DC_PRI_LF               0x2A15  // 1
-#define CMD2DC_PRI_PRIFONTTABLE     0x2A16
-#define CMD2DC_PRI_BARCODE          0x2A17  // ca 15...25
-
-#define CMD2DC_STOR_QR_DATA         0x2A18  // 150
-#define CMD2DC_PRI_QR_CODE          0x2A19  // 0
-
-#define CMD2DC_PRI_LOGOFROMFLASH    0x2A1A  // 2
-
-#define CMD2DC_PRI_STORE_DOC        0x2A41  // 1
-#define CMD2DC_PRI_DOCUMENT_NR      0x2A42  // 1 + 64
-#define CMD2DC_PRI_CLEAR_DOC        0x2A43  // 1
-
-*/
-
-
-
-
-#define FIX_SLAVE_ADDR          0
-#define SEND_ATONCE             1
-#define SENDCOMBINED            0
-
-
-
-
-class T_datif : public QMainWindow
-{
-    Q_OBJECT    
-
-    char sendINrequestsAutomatic(void);
-        // sende alle Befehle um die Eingangsdaten abzufragen der Reihe nach
-    char loadRecDataFromFrame();
-    void datif_startSending(void);
-    void datif_sendIOrequest(uint16_t WRcmd, uint16_t RDcmd, uint8_t nrOfWrData);
-
-    void datif_send8byteOutCmd(uint16_t WRcmd, uint16_t RDcmd);
-
-    bool verifyLineTestresponse(uint8_t RdDlen, uint8_t *receivedData);
-    void datif_OUT_setTime(void);
-    uint8_t datif_OUT_SendRandomData(uint8_t *buf, uint8_t Length);
-
-    void datif_send64byteOutCmd(uint16_t WRcmd, uint16_t addr, uint16_t RDcmd);
-
-    void datif_sendToMemory(uint16_t WRcmd, uint16_t docNr, uint16_t blockNr, uint8_t *data64);
-        // send printer documents to DC2 memory
-        // docNr: 0...15(31)    with 1280 byte each (20 blocks a 64byte)
-        // blockNr=0...19   with 64byte each
-        // docNr =transmitted in WRITEADDRESS high byte
-        // blockNr=transmitted in WRITEADDRESS low byte
-
-
-    T_prot *myDCIF;
-    QTimer *datif_trigger;
-    uint8_t selectedSlaveAddr;
-
-private slots:
-    char datif_cycleSend();
-    void StoredRecData();
-
-public:
-    T_datif(QWidget *parent = nullptr);
-
-    T_prot *getProt() { return myDCIF; }
-    T_prot const *getProt() const { return myDCIF; }
-
-    void resetChain(void);
-    char isPortOpen(void);
-    void sendWRcommand(uint16_t nxtAsCmd);
-        // Sende Schreibbefehle die bereits vorher asynchron gespeichert wurden
-    void send_requests(uint16_t nextWrCmd);
-    void sendHighLevel(uint16_t nxtHLCmd);
-
-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/dcBL.h

@@ -1,102 +0,0 @@
-#ifndef DCBL_H
-#define DCBL_H
-#include <stdint.h>
-#include "qbytearray.h"
-#include "qstring.h"
-#include <QFile>
-
-uint8_t dcBL_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf);
-// make BL protocol, retval = outbuf length (5...133)
-// bring data in correct form: start always with 0x02   finish with 0x03 and append checksum
-// 0x02 Cmd < ...sendData ..>  CRC  CRC 0x03
-// Data length = 0...64
-// special conversion: if data contain 2 or 3 (STX, ETX) then write two bytes:  0x1B (=ESC) and data|0x80
-// so maxlength = 5 + 2 x 64 (if all data are 2 or 3)  without 2,3: maxlength = 5 + 64
-
-uint8_t dcBL_readBLversion(uint8_t *sendData);
-    // minimum size of sendData-buffer: 5byte  retval: length
-
-uint8_t dcBL_readFWversion(uint8_t *sendData);
-    // minimum size of sendData-buffer: 5byte  retval: length
-
-uint8_t dcBL_exitBL(uint8_t *sendData);
-    // minimum size of sendData-buffer: 5byte  retval: length
-
-uint8_t dcBL_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *sendData);
-    // minimum size of sendData-buffer: 13byte    retval: length (9...13)
-
-uint8_t dcBL_writeLastPage(uint8_t *sendData);
-    // minimum size of sendData-buffer: 5byte  retval: length
-
-uint8_t dcBL_restartDC(uint8_t *sendData);
-    // minimum size of sendData-buffer: 20 byte  retval: length
-
-uint8_t dcBL_activatBootloader(uint8_t *sendData);
-    // minimum size of sendData-buffer: 20 byte  retval: length
-
-uint8_t dcBL_getResponse(uint8_t *respBuff);
-    // retval: nr of received bytes
-
-bool dcBL_responseOK();
-    // retval: 0: response OK (cmd |0x80)    1: response error (cmd or "0xe0")
-
-bool dcBL_importBinFile(QByteArray readBinFile, uint32_t fileSize, char withDispl);
-
-
-
-bool dcBL_isTextMemFree(void);
-
-void dcBL_writeText(QString newTxt);
-
-bool dcBL_checkForText(void);
-    // if pointer at 0 then no more content
-
-QString dcBL_readText(void);
-    // read from 0...9 (oldest first)
-
-
-
-void dcBL_iniChain(void);
-
-uint8_t dcBL_startChain(void);
-
-uint8_t dcBL_runChain(void);
-
-void dcBL_iniLoading(void);
-
-void dcBL_startLoading(void);
-
-uint8_t dcBL_sendHexfile(void);
-
-
-uint8_t dcBL_getResult(void);
-// call after every step to what's going on....
-//  1: connected to BL
-//  2: transmission started
-//  3: transmission successful
-
-
-
-#define RAW_BL_DATALEN      150
-void gpi_storeRawReceivedData(uint8_t  RdDlen, uint8_t *receivedData);
-
-uint8_t epi_getRawReceivedData(uint8_t *receivedData);
-    // retval=length, will be zeroed after first reading
-
-uint8_t epi_getRawRecLength(void);
-    // retval=length
-
-QString epi_getRawReceivedString();
-
-void epi_clrRawReceivedString();
-
-
-uint8_t dcBL_sendSuccess(uint8_t lastCommand);
-    // return val: 0: no response by now  1:error  10: OK
-    // lastCommand=0x21 for sendAddr or 0x22 for send data
-
-char dcBL_loadBinary(char withDisplay);
-
-
-
-#endif // DCBL_H

include/prot.h

@@ -1,129 +0,0 @@
-
-#ifndef SERIAL_FRAME_H
-#define SERIAL_FRAME_H
-
-#include <stdint.h>
-#include <QMainWindow>
-#include <QString>
-#include <QTimer>
-#include "tslib.h"
-#include "com.h"
-
-/*
- get's OUT-data from datif,
- get's IN-data from datif
- get's send command from datif
-    makes frame and calls: isSerialFree(), setSendData(),
-    if not free retrigger datif sending period (normally 500ms or 50ms for direct cmds)
-
-    with control-signal: gotReceiveData():
-        getRecData();
-        send results to diag window/line
-        send IN-data to datif
-*/
-
-#define     FRAME_DATALEN       64
-#define     FRAME_MAXLEN        FRAME_DATALEN+20
-#define     BL_DATA_LEN         150
-
-#define     DATALEN_SEND_FAST            4
-#define     DATALEN_SEND_LONG            64
-#define     HEADERLEN_SEND               4
-#define     TELEGRAMLEN_SEND_FAST        12
-#define     TELEGRAMLEN_SEND_LONG        70
-#define     STARTSIGN_SEND_FAST          0x3F
-#define     STARTSIGN_SEND_LONG          0x3D
-
-#define     DATALEN_RECEIVE_FAST            8
-#define     DATALEN_RECEIVE_LONG            64
-#define     HEADERLEN_RECEIVE               2
-#define     TELEGRAMLEN_RECEIVE_FAST        12
-#define     TELEGRAMLEN_RECEIVE_LONG        68
-#define     STARTSIGN_RECEIVE_FAST          0x5F
-#define     STARTSIGN_RECEIVE_LONG          0x5D
-
-
-class T_prot : public QMainWindow
-{
-    Q_OBJECT
-
-    // Dateneingang von Datif:
-    uint8_t  SendDataValid;     // bit1: WR OK  bit 2: RD OK
-    uint16_t slaveAddr;
-
-    uint16_t WriteCommand;
-    uint16_t WriteAddr;
-    uint8_t  WrDataLength;
-    uint8_t  ui8OutputData[FRAME_DATALEN];
-    char     chOut_Data[FRAME_DATALEN];
-    uint8_t  kindOfData;    // 0: binaries, 1:text
-
-    uint16_t ReadCommand;
-    uint16_t ReadAddr;
-    uint16_t reserve;
-
-    // Ausgangs-Daten, werden vom Datif geholt:
-    // nur wenn CommandState und readState OK
-    uint8_t  RecSlaveAddr;
-    bool    INdataValid;        // nur true wenn CommandState OK und readState OK
-    uint16_t readSource;        // diese (Eingangs-)Daten stehen im Puffer
-    uint16_t readAddress;       // von dieser Adr wurden die Daten gelesen
-    //uint8_t  lastWakeSrc;       // falls der Slave den Master geweckt hat
-    uint8_t  RdDataLength;
-    uint8_t  InputData[FRAME_DATALEN];
-
-    // 11.11.2020:
-    uint8_t  BLsendDataLength;
-    uint8_t  ui8BLsendData[BL_DATA_LEN];
-
-    T_com *mySerialPort;
-
-    void startPacking(void);
-    void startFastPacking(void);
-    uint8_t FramecheckInData(uint8_t *Inbuf, uint16_t LL);
-    uint8_t FastCheckInData(uint8_t *Inbuf, uint16_t LL);
-
-    uint8_t CheckInResult(uint8_t *Inbuf);
-
-    uint8_t ShowFastInData(uint8_t *recBuffer);
-    uint8_t ShowInData(uint8_t *recBuffer); // was CheckInData
-    void setRecLen(uint16_t WriteCmd);
-
-private slots:
-    void analyseRecData(void);
-
-public:
-    T_com *getSerialPort() { return mySerialPort; }
-    T_com const *getSerialPort() const { return mySerialPort; }
-
-    T_prot();
-    bool isPortOpen(void);
-    bool isSerialFree(void);
-    void setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t  WrDatLen, uint8_t *data);
-    void setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr);
-    void setUserWriteData(uint16_t WriteCmd);
-    void setUserWriteText(uint16_t WriteCmd, uint16_t WrAddr, uint8_t  WrDatLen, char *data);
-
-    void setUserWrite1DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val);
-    void setUserWrite2DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, uint8_t val1);
-
-    void setUserReadData( uint16_t ReadCmd,  uint16_t RdAddr, uint16_t reserv);
-    void setUserReadData( uint16_t ReadCmd,  uint16_t RdAddr);
-    void setUserReadData( uint16_t ReadCmd);
-
-    void setBLsendData( uint8_t len, uint8_t *buf);
-
-    void receiveFixLen(int64_t nrOfbytesToReceive);
-
-    void sendUserData(uint16_t slaveAdr);
-    bool ifDataReceived();
-    bool getReceivedInData(uint8_t  *SlavAddr, uint16_t *readSrc, uint16_t *readAddr,
-                           uint8_t  *RdDlen, uint8_t *receivedData);
-        // retval: data valid, only one time true
-signals:
-    void framerecieved();   //bool gotINdata);
-    void rawDataRecieved();
-
-};
-
-#endif // T_prot_H

include/sendWRcmd.h

@@ -1,242 +0,0 @@
-
-#ifndef SENDWRCMDS_DEFS_H
-#define SENDWRCMDS_DEFS_H
-
-#include <stdint.h>
-#include "tslib.h"
-#include <QString>
-
-// asynch. Commands
-// store OUTPUT commands until time to send
-// problem: OUT commands are set if a button is pressed or a transaction event happens
-// so it's never synchron with sending grid
-// but sending must apply the 100ms time grid as we have to wait for the response before sending the next command!!!
-
-// Level 0 (DC direct)
-#define SENDDIRCMD_TestSerial           1
-#define SENDDIRCMD_MakeReset            2
-#define SENDDIRCMD_setTime              3
-#define SENDDIRCMD_setWakeFrequ         4
-
-// Level 1 (DC DO's switching connected parts)
-#define SENDDIRCMD_MOVEUP_LOCK            5
-#define SENDDIRCMD_MOVEDN_LOCK            6
-#define SENDDIRCMD_OPENUP_DOOR            7
-#define SENDDIRCMD_OPENDN_DOOR            8
-#define SENDDIRCMD_LEDILLU              9
-#define SENDDIRCMD_LEDCOIN              10
-#define SENDDIRCMD_LEDTICKET            11
-#define SENDDIRCMD_LEDPAD               12
-#define SENDDIRCMD_LEDSTART             13
-#define SENDDIRCMD_LEDINSIDE            14
-//#define SENDDIRCMD_LED_ALL              15
-#define SENDDIRCMD_FAN                  16
-#define SENDDIRCMD_LAERM                17
-#define SENDDIRCMD_REL1                 18
-#define SENDDIRCMD_WAKEPTU              20
-#define SENDDIRCMD_AUXPWR               21
-#define SENDDIRCMD_AUXDDR               22
-#define SENDDIRCMD_AUXOUT               23
-
-#define SENDDIRCMD_UCONTACT_ON          30
-#define SENDDIRCMD_PRN2_SWONOFF         31
-
-#define SENDDIRCMD_MIF_SWONOFF          32      // 0x2900
-#define SENDDIRCMD_MIF_ATBCREATE        33      // 0x2907
-
-#define SENDDIRCMD_MOD_SWONOFF          40
-#define SENDDIRCMD_MOD_WAKE             41
-#define SENDDIRCMD_MDB_POWER            42
-#define SENDDIRCMD_MDB_WAKE             43
-#define SENDDIRCMD_CRED_ON              44
-#define SENDDIRCMD_CRED_WAKE            45
-
-#define SENDDIRCMD_SHUT_MOV             50
-#define SENDDIRCMD_ESCRO_MOV            51
-#define SENDDIR_OPENVAULT               52
-#define SENDDIR_REJMOT_ON               53
-#define SENDDIR_REJMOT_RUN              54
-
-// Level 2 (serial from DC to devices)
-#define SEND_REQU_SERCONF               100
-#define SEND_REQU_HWversion             101
-#define SEND_REQU_SWversion             102
-#define SEND_REQU_CONDITION             103
-#define SEND_REQU_UID                   104
-#define SEND_REQU_TIME                  105
-    // includes wake frequency
-#define SEND_REQU_ANALOGS               110
-#define SEND_REQU_DIG_INPUTS            111
-#define SEND_REQU_DIG_OUTPUTS           112
-
-#define SEND_REQU_PRN_STATE             120
-#define SEND_REQU_PRN_FONTS             121
-#define SEND_REQU_PRN_ALL               122
-
-#define SEND_REQU_MIFSTATE             123
-    // Type and state of reader
-
-#define SEND_REQU_MIFDATA               124
-    // Type, UID, Header of card
-    // read one card sector
-    // sectors must be addressed by RD_ADD
-
-#define SEND_REQU_MIF_ATB_TYPE          125
-
-#define SEND_REQU_MDB_GETSTAT           126
-//#define SEND_REQU_MDB_GETWAK            127
-#define SEND_REQU_MDB_GETRESP           128
-#define SEND_REQU_EMP_GETALL            129
-#define SEND_REQU_EMP_GETCOIN           130
-
-
-#define SENDDIRCMD_DEVICE_PARA          131
-#define SENDDIRCMD_MACHINE_ID           132
-#define SEND_REQU_DEVICE_PARA           133
-#define SEND_REQU_MACINE_ID             134
-
-
-// further: mdb state, coinchecker state, bill state, modem state, credit_state....
-
-#define SENDDIRCMD_SHUTOPENBYTIME       60
-#define SENDDIRCMD_SHUTOPENBYCOIN       61
-//#define SENDDIRCMD_SHUT_SENDTIME        62
-
-#define SENDDIRCMD_ESCRO_TAKE           63
-#define SENDDIRCMD_ESCRO_GIVE           64
-
-#define SENDDIRCMD_PRN_SYS_CMD          70
-#define SENDDIRCMD_PRN_ESC_CMD          71
-#define SENDDIRCMD_PRN_SETUP            72
-#define SENDDIRCMD_PRN_MOVE             73
-#define SENDDIRCMD_PRN_SETFONT          74
-#define SENDDIRCMD_PRN_SETLETT          75
-#define SENDDIRCMD_PRN_CUT              76
-//#define SENDDIRCMD_PRN_TXT              // not needed
-#define SENDDIRCMD_PRN_LF               78
-#define SENDDIRCMD_PRN_FONTTAB          79
-#define SENDDIRCMD_PRN_BC               80
-#define SENDDIRCMD_PRN_QR               81
-#define SENDDIRCMD_PRN_STOREDQR         82
-#define SENDDIRCMD_PRN_LOGO_FL          83
-//#define SENDDIRCMD_PRN_LOGO_GRAF        84
-//#define SENDDIRCMD_PRN_LOGODAT          85
-//#define SENDDIRCMD_PRN_STORBC           86
-#define SENDDIRCMD_PRN_STORQR           87
-#define SENDDIRCMD_PRN_DOC              88
-#define SENDDIRCMD_PRN_CLEARDOC         89
-
-//#define SENDDIRCMD_MDB_POWER            42
-//#define SENDDIRCMD_MDB_WAKE             43
-#define SENDDIRCMD_MDB_RES              90
-#define SENDDIRCMD_MDB_SENDCMD          91
-#define SENDDIRCMD_MDB_SNDMSG           92
-#define SENDDIRCMD_EMP_SETT             93
-#define SENDDIRCMD_EMP_POLL             94
-#define SENDDIRCMD_EMP_STARPPAY         95
-#define SENDDIRCMD_EMP_STOPPAY          96
-
-
-
-
-// obsolete:
-#define SENDDIRCMD_PRN1_SENDTEXT        54
-#define SENDDIRCMD_PRN1_SENDCMD         55
-#define SENDDIRCMD_PRN1_SERPAR          56
-#define SENDDIRCMD_PRN_LEVEL2_4B        58
-#define SENDDIRCMD_PRN_LEVEL2_64        59
-
-
-// highest priority
-#define CMDSTACKDEPTH   16
-// means: up to 16 cmd can be stored. They are issued one by one every 100ms
-void sendWRcmd_clrCmdStack(void);
-bool sendWRcmd_setSendCommand0(uint16_t nextCmd);
-    // GUI or app sends a command to DC transfered by serial
-
-uint16_t sendWRcmd_getSendCommand0(void);
-
-// lower priority
-#define CMD4STACKDEPTH   8
-void sendWRcmd_clrCmd4Stack(void);
-bool sendWRcmd_setSendCommand4(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4);
-uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4);
-
-#define CMD8STACKDEPTH   4
-void sendWRcmd_clrCmd8Stack(void);
-bool sendWRcmd_setSendCommand8(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint16_t dat3, uint32_t dat4);
-uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3, uint32_t *dat4);
-
-
-
-// lowest priority
-// wait for resonse before send next!
-bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t *buf);
-uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf);
-    // retval = *leng
-
-void sendWRcmd_INI(void);
-
-
-
-uint8_t epi_store64ByteSendData(uint8_t length, uint8_t *buf);
-    // HWapi writes data to be forwarded to DC and further to mdb-device
-    // not batched! don't use twice within 100ms
-
-uint8_t gpi_restore64ByteSendData(uint8_t *length, uint8_t *buf);
-    // datif reads data to forward to dc
-
-
-
-// ONE printer doc consists of 20 x 64 byte
-#define MAXNROF_PRNBYTES   64
-#define MAXNROF_PRNBLOCKS  20
-
-void epi_resetPrinterStack(void);
-
-uint8_t epi_storePrnText(char *buf, uint8_t leng);
-    // store text and binary data from Gui in next higher free memory 0....9
-
-uint8_t gpi_restorePrnText(uint8_t *retbuf);
-    // read printer text and send to slave, size of retbuf== 64
-
-uint8_t gpi_chk4remainingText(void);
-    // retval: 0: no more textline left (to send)  >0: nr of lines
-
-void epi_storeUserOfSendingTextBuffer(uint8_t user, uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4 );
-    // user=1: Text-Print is using this buffer
-    //      2: QR-code-Printer is using this buffer
-
-uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *para3, uint8_t *para4);
-    // user=1: Text-Print is using this buffer
-    //      2: QR-code-Printer is using this buffer
-
-#define     FDCMD_STACKDEPTH    16
-void sendFDcmd_clrStack(void);
-bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4);
-    // write Command to memory, wait for transport
-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, maxFDCMD_STACKDEPTH
-
-uint8_t check4freeFDshortCmd(void);
-    // returns number of free places in short-command stack
-
-#define     FDLONG_STACKDEPTH    16
-void longFDcmd_clrStack(void);
-bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data);
-    // write Command to memory, wait for transport
-    // data buffer size always 64! data[64], padded with 0
-bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data);
-
-uint8_t check4FDlongCmd(void);
-    // returns number of waiting command
-
-uint8_t check4freeFDlongCmd(void);
-    // returns number of free places in long-command stack
-
-
-#endif
-
-

include/shared_mem_buffer.h

@@ -1,293 +0,0 @@
-#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;
-    } 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

@@ -1,421 +0,0 @@
-
-#ifndef STOREINDATA_H
-#define STOREINDATA_H
-
-#include <stdint.h>
-#include "tslib.h"
-#include <QString>
-
-
-#define MAXNROF_AO              3
-//#define MAXNROF_GENSTR          16
-#define MAXNROF_CONTR_PORTS     11
-#define MAXNROF_DIports         2
-#define MAXNROF_DOports         2
-#define MAXNROF_CTR             2
-#define MEASCHAN_TEMPERATURE    0
-#define MEASCHAN_VOLTAGE        1
-
-
-// gpi: DC-driver stores data for graphic peripheral interface
-// epi: gui reads values from external peripheral interface
-
-
-// store power on/off condition of the devices to control the data request
-
-void indat_storePrinterPower(bool isOn);
-bool indat_isPrinterOn();
-
-void indat_storeMifarePower(bool isOn);
-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);
-
-void epi_getSlaveSerParams(uint8_t *slaveBaudRate, uint8_t *NrDataBits,
-                             uint8_t *parity, uint8_t *NrStopBits);
-
-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 const *buf8byteUid);
-// buffer size: 8 byte
-void epi_getUIDdec(uint8_t *buf8byteUid);
-// buffer size: 8 byte
-QString epi_getUIDstr();
-
-
-
-
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          Time and Date
-// ///////////////////////////////////////////////////////////////////////////////////
-
-uint8_t epi_getSquareMode();
-void gpi_backupSquareMode(uint8_t squMode);
-
-void gpi_backupTime(uint8_t *timeBuffer, uint8_t Leng);     // 104, <=8byte
-void epi_getTime(uint8_t *hh, uint8_t *mm, uint8_t *ss);
-void epi_getDate(uint8_t *yy, uint8_t *mm, uint8_t *dd);
-void epi_getToday(uint8_t *dow, uint16_t *minOfToday, uint32_t *secOfToday);
-bool epi_isLeapYear(uint8_t *lastLeapYear, uint8_t *NextLeapYear);
-bool epi_isLeapYear();
-void epi_getSpecialWeekTimeDate(uint8_t *DayOfWeek, uint8_t *HoursOfWeek, uint16_t *MinutesOfWeek);
-void epi_getSpecialMonthTimeDate(uint8_t *DayOfMonth, uint16_t *HoursOfMonth, uint16_t *MinutesOfMonth);
-void epi_getSpecialYearTimeDate(uint16_t *DayOfYear, uint16_t *HoursOfYear, uint32_t *MinutesOfYear);
-
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          Analog values
-// ///////////////////////////////////////////////////////////////////////////////////
-
-
-// #define MAXNROF_AI              4
-
-void gpi_storeAIs(uint8_t aiNr, uint16_t val);   // rs -> Sdata
-
-uint8_t gpi_getMaxNrAIs();
-
-uint16_t epi_loadAIs(uint8_t aiNr);              //       Sdata -> gui
-    // return value of one ADC with channel nr: aiNr 0...15
-
-uint32_t epi_loadMeasureValue(uint8_t ValueNr);
-    // ValueNr 0=ADC0, 1=ADC1 aso...
-
-void gpi_storeMeasureValue(uint8_t ValueNr, uint32_t val);
-    // in mV, also bis 65,535V
-
-QString epi_getSlaveTemperatureStr();
-
-QString epi_getSlaveVoltageStr();
-    // value in "meas_volt" in mV, also bis 65,535V. Value range [6000...16000] (6V...16V)
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          digital inputs
-// ///////////////////////////////////////////////////////////////////////////////////
-
-void gpi_storeDI_doorSwitches(uint8_t upperDoor, uint8_t lowerDoor, uint8_t vaultDoor);
-
-uint8_t epi_getDI_doorSwitches(void);
-    // bit0: upper door  1: low door  2:vault door
-
-void gpi_storeDI_vaultSwitches(uint8_t CashBoxIn, uint8_t BillBoxIn);
-
-uint8_t epi_getDI_vaultSwitches(void);
-    // bit0: cash box    1: bill box in
-
-void gpi_storeDI_lockSwitches(uint8_t indatUL, uint8_t indatLL);
-    // D5: bit 0: upper lockbar up   bit1:down
-    // D6: bit 0: lower lockbar up   bit1:down
-
-uint8_t epi_getDI_lockSwitches(void);
-    // retval: bit 0: upper lockbar up   bit1: upper lockbar is down
-    //         bit 2: lower lockbar up   bit1: lower lockbar is down
-
-
-void gpi_storeDI_optos(uint8_t indatOpto);
-    // OptoIn bit 0,1: optoin 1,2
-
-uint8_t epi_getDI_optos(void);
-    // bit0: opto in 1    1: opto in 2
-
-uint8_t gpi_storeDI_auxIn(uint8_t indatAuxIn); // Aux0...5
-uint8_t epi_getDI_auxIn(void);                 // bit0: auxin 1  ...  5: auxin 6
-
-bool gpi_storeDI_ptuWake(bool w);
-bool epi_getDI_ptuWake(void);
-
-bool gpi_storeDI_mbdWake(bool w);
-bool epi_getDI_mdbWake(void);
-
-bool gpi_storeDI_prnReady(bool ready);
-bool epi_getDI_prnReady(void);
-
-bool gpi_storeDI_CoinAttach(bool attach);
-bool epi_getDI_CoinAttach(void);
-
-bool gpi_storeDI_CoinEscrow(bool ce);
-bool epi_getDI_CoinEscrow(void);
-
-bool gpi_storeDI_mifareCardTapped(bool tapped);
-bool epi_getDI_mifareCardTapped(void);
-
-bool gpi_storeDI_modemWake(bool w);
-bool epi_getDI_modemWake(void);
-
-bool gpi_storeDI_contactPowerIsOn(bool on);
-bool epi_getDI_contactPwr(void);
-
-bool gpi_storeDI_MifarePowerIsOn(bool on);
-bool epi_getDI_mifarePwr(void);
-
-bool gpi_storeDI_readbackMdbTxD(bool rdbkMdbTxd);
-bool epi_getDI_mdbTxd(void);
-
-bool gpi_storeDI_AuxPowerIsOn(bool on);
-bool epi_getDI_auxPwr(void);
-
-bool gpi_storeDI_GsmPowerIsOn(bool on);
-bool epi_getDI_gsmPwr(void);
-
-bool gpi_storeDI_CreditPowerIsOn(bool on);
-bool epi_getDI_creditPwr(void);
-
-bool gpi_storeDI_PrinterPowerIsOn(bool on);
-bool epi_getDI_printerPwr(void);
-
-bool gpi_storeDI_MdbPowerIsOn(bool on);
-bool epi_getDI_mdbPwr(void);
-
-bool gpi_storeDI_rejMot_home(bool reject);
-bool epi_getDI_rejectMotor_homepos(void);
-
-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
-// ///////////////////////////////////////////////////////////////////////////////////
-
-uint8_t gpi_storeDO_mdbRxTst(uint8_t do_mbdRxTst);
-bool epi_getDO_mdbRxTestOut(void);
-
-uint8_t gpi_storeDO_motorOutputs(uint8_t Pwr);
-uint8_t epi_getDO_motorOuts(void);
-    // bit0: upper lock forward    bit 1 backward
-    // bit2: lower lock forward    bit 3 backward
-
-uint8_t gpi_storeDO_serialSwitch(uint8_t state);
-    // serial drv on/off, Serial mux1, Serial mux2
-uint8_t epi_getDO_serialSwitch(void);
-    // serial drv on/off, Serial mux1, Serial mux2
-
-bool epi_getDO_serialDriverIsOn(void);
-bool epi_getDO_serialMux1isSetToPrinter(void);
-    // mux1 off: serial is switched to printer
-
-bool epi_getDO_serialMux1isSetToModem(void);
-    // mux1 on: serial is switched to modem
-bool epi_getDO_serialMux2isSetToCredit(void);
-    // mux2 off: serial is switched to credit card terminal
-bool epi_getDO_serialMux2isSetToMifare(void);
-    // mux2 on: serial is switched to mifare reader
-
-uint8_t gpi_storeDO_ledsAndFan(uint8_t ledState);
-bool epi_getDO_led_coin(void);
-bool epi_getDO_led_front(void);
-bool epi_getDO_led_ticket(void);
-bool epi_getDO_led_pin(void);
-bool epi_getDO_led_start(void);
-bool epi_getDO_led_inside(void);
-bool epi_getDO_fan(void);
-
-uint8_t gpi_storeDO_sirenAndRelay(uint8_t sirenRelay);
-bool epi_getDO_sirene(void);
-bool epi_getDO_relay(void);
-
-uint8_t gpi_storeDO_ptuWake(uint8_t state);
-bool epi_getDO_ptuWake(void);
-
-uint8_t gpi_storeDO_auxPower(uint8_t pwr);
-bool epi_getDO_auxPower(void);
-
-uint8_t gpi_storeDO_coinShutter(uint8_t state);
-bool epi_getDO_coinShutterOpen(void);
-bool epi_getDO_coinShutterTest(void);
-
-uint8_t gpi_storeDO_coinEscrow(uint8_t state);
-uint8_t epi_getDO_coinEscrow(void);
-    // retval: 1:return flap is open   2:take flap is open    0:closed
-
-uint8_t gpi_storeDO_printerPwrOn(uint8_t state);
-uint8_t epi_getDO_printerPwr(void);
-
-// ---------------------------------------------------------------------------------------------
-// counterchecks, make sure that DC-outputs are correct
-
-/*
-bool epi_cntchk_wakePtu(void);
-bool epi_cntchk_enabDrv01(void);        // no communication possible if 0 !!!!!
-bool epi_cntchk_swRs1toModem(void);
-bool epi_cntchk_modemWake(void);
-bool epi_cntchk_enabDrv2(void);
-bool epi_cntchk_swRs2toMIF(void);
-
-bool epi_cntchk_shutterIsOpen(void);
-    // counter check if shutter is really open,  PJ4 must be OUT and HIGH, PB5 must be OUT and HIGH
-    // retval TRUE: shutter is open   FALSE: shutter is closed
-
-bool epi_cntchk_escrowReturnIsOpen(void);
-bool epi_cntchk_escrowTakeIsOpen(void);
-bool epi_cntchk_aux1DirOut(uint8_t auxNr);
-bool epi_cntchk_aux1OutHigh(uint8_t auxNr);
-
-bool epi_cntchk_ledPaperOn(void);
-bool epi_cntchk_ledPinpadOn(void);
-bool epi_cntchk_ledStartOn(void);
-bool epi_cntchk_ledServiceOn(void);
-bool epi_cntchk_ledCoinOn(void);
-bool epi_cntchk_ledIllumOn(void);
-bool epi_cntchk_FanOn(void);
-bool epi_cntchk_RelaisOn(void);
-bool epi_cntchk_LaermOn(void);
-bool epi_cntchk_Mot1Ron(void);
-bool epi_cntchk_Mot1Fon(void);
-bool epi_cntchk_Mot2Ron(void);
-bool epi_cntchk_Mot2Fon(void);
-*/
-
-
-// ------------------------------------------------------------------------------------
-// MDB Sendind Data  are store here for next transport to DC (Device Controller)
-// Transport to Slave runs every 100ms, answer from mdb-slave (e.g. coin changer) comes right
-// with next slave answer
-
-// start with: SENDDIRCMD_EXCHGMDB,
-    // send crude data from here to DC, DC to mdb slaves, mdb answer, return here within 50ms
-
-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);
-
-/* data description:
-byte 0: current read state: 0=power off  1=reader-fault 2=ready
-                            3=just reading 4=read complete
-                            5=read partial, removed too early
-                            6=state unknown
-byte 1,2: read data length from card
-3: 1=reader is OK (reported serial nr is OK)  0=wrong or no reader
-4...15: reader version, expected "SL025-1.8"
-byte16: 1=card is present   0:not
-17: 0
-18: card type reported from reader
-19: 1=allowed card type 0=not
-20: card size: 1 or 4 (dec) = card size
-21: LengthOfUID: 4 or 7 (dec) (byte)
-22: UID 8 byte in hex
-byte 30: sector logged: 0
-byte 31: current sector: 0
-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);
-    // 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
-
-void epi_restorePrinterState(uint8_t *buf);
-void gpi_storePrinterState(uint8_t const *buf);
-
-void epi_restorePrinterFonts(uint8_t *buf);
-void gpi_storePrinterFonts(uint8_t const *buf);
-
-bool gpi_storeMdbState(bool busReady, bool V12on, bool V5on);
-bool epi_restoreMdbBusReady(void);
-bool epi_restoreMdbV12Ready(void);
-bool epi_restoreMdbV5Ready(void);
-
-void gpi_storeMdbResponse(uint8_t leng, uint8_t const *data);
-void epi_restoreMdbResponse(uint8_t *leng, uint8_t *data);
-    // last received mdb answer (from mdb device)
-    // only needed if a special command was sent directly
-    // DB0: mdb Device-Nr
-    // DB1: last sent mdb command
-    // 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 epi_restoreEmpSettings(uint8_t *leng, uint8_t *data);
-
-/*
-void gpi_storeEmpCoinSignal(uint8_t leng, uint8_t *data);
-
-void epi_restoreEmpCoinSignal(uint8_t *leng, uint8_t *data);
-    // return 5 byte:
-    //      data[0]=got coin 0xFF=emp reported an error  0=got nothing
-    //      data[1]=emp-signal of last inserted coin
-    //      data[2,3]=emp-value of last inserted coin
-    //      data[4] = emp-error or warning
-
-void epi_clearEmpCoinSignal();
-*/
-
-
-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 epi_restoreRbDeviceSettings(uint8_t *leng, uint8_t *data);
-
-void gpi_storeMachineIDsettings(uint8_t leng, uint8_t const *data);
-void epi_restoreMachineIDsettings(uint8_t *leng, uint8_t *data);
-
-void epi_clearCurrentPayment(void);
-void gpi_storeCurrentPayment(uint32_t insertedAmount, uint16_t lastCoinType, uint16_t lastCoinValue);
-
-uint32_t epi_CurrentPaymentGetAmount(void);
-uint16_t epi_CurrentPaymentGetLastCoin(void);
-
-bool epi_CurrentPaymentGetAllCoins(uint16_t *types, uint16_t *values);
-    // alle bei diesem Verkauf eingeworfenen Münzen sind gespeichert falls die jmd. braucht
-
-void gpi_storeWakeSources(uint8_t const *receivedData);
-uint64_t epi_getWakeSources(void);
-
-void gpi_storeExtendedTime(uint8_t leng, uint8_t const *data);
-void epi_restoreExtendedTime(uint8_t *leng, uint8_t *data);
-
-void gpi_storeDeviceConditions(uint8_t leng, uint8_t const *data);
-void epi_restoreDeviceConditions(uint8_t *leng, uint8_t *data);
-
-void gpi_storeDynMachineConditions(uint8_t leng, uint8_t const *data);
-void epi_restoreDynMachineConditions(uint8_t *leng, uint8_t *data);
-
-void gpi_storeDCbackupAccNr(uint8_t leng, uint8_t const *data);
-void epi_restoreDCbackupAccNr(uint8_t *leng, uint16_t *accNrs);
-    // return accNrs[0..7]
-
-void epi_iniVRstorage(void);
-void gpi_storeVaultRecord(uint8_t blkNr, uint8_t const *data);
-bool epi_checkIfVaultRecordAvailable(void);
-bool epi_restoreVaultRecord(uint16_t *length, uint8_t *buf);
-    // true if completly received
-
-void gpi_storeCBlevel(uint32_t amount, uint16_t nrOfCoins);
-
-uint32_t epi_getCashBoxContent(void);
-uint16_t epi_getNrOfCoinsInCashBox(void);
-
-void gpi_storeNewMifareCard(uint8_t typ, uint8_t const *holder);
-
-uint8_t epi_mifGetCardType(uint8_t const *holder);
-    //holder[8] = name of card holder
-    // retval Type of MifareCard, 1=upper door, 2=lower door 3=test printer 4=test coins
-
-#endif
-
-
-

include/tslib.h

@@ -1,90 +0,0 @@
-#ifndef TSLIB_H
-#define TSLIB_H
-#include <stdint.h>
-#include <QByteArray>
-
-
-#define LOWBYTE     false
-#define HIGHBYTE    true
-
-uint16_t uchar2uint(char Highbyte, char Lowbyte);
-uint16_t uchar2uint(uint8_t Highbyte, uint8_t Lowbyte);
-uint32_t uchar2ulong(uint8_t Highbyte, uint8_t MHbyte, uint8_t MLbyte, uint8_t Lowbyte);
-
-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);
-
-#define     MITSEK          1
-#define     OHNESEK         0
-#define     HourSys12h          1
-#define     HourSys24h          0
-
-void GetTimeString(uint8_t hours, uint8_t minutes, uint8_t seconds, uint8_t System12h, uint8_t ShowSec, uint8_t *buf);
-    // generate time as ascii string from integers hours/minutes/seconds
-    // System12h=0:  24h system    =1: 12h System
-    // ShowSec=0:     String has 5 digits (hh:mm)   =1: String has 8 digits (hh:mm:ss)
-    // return String in *buf      // 12 byte für buf!
-
-#define     DateFormatDeutsch       0
-#define     DateFormatAmerica       1
-#define     UsePointSeperator       0
-#define     UseSlashSeperator       1
-
-
-void GetDateString(uint8_t day, uint8_t month, uint8_t yearhigh, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf);
-    // generate date as ascii string from integers day/month/year
-    // yearhigh in europe always 20 (not in arabia)
-    // format=  0: dd.mm.yyyy   (deutsch)
-    //          1: mm.dd.yyyy   (amerika)
-    //          2: yyyy.mm.dd   (Iran, Dubai)
-    //          3: dd.yyyy.mm
-    //          4: mm.yyyy.dd
-    //          5: yyyy.dd.mm
-        // sep: 0: use . as seperator   1: use / as seperator
-    // return String in *buf      // 11 byte für buf!
-
-
-void GetShortDateString(uint8_t day, uint8_t month, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf);
-    // generate date as ascii string from integers day/month/year
-    // format=  0: dd.mm.yy   (deutsch)
-    //          1: mm.dd.yy   (amerika)
-    //          2: yy.mm.dd   (Iran, Dubai)
-    //          3: dd.yy.mm
-    //          4: mm.yy.dd
-    //          5: yy.dd.mm
-        // sep: 0: use . as seperator   1: use / as seperator
-    // return String in *buf      // 11byte für buf!
-
-
-uint16_t tslib_strlen(char *buf);
-uint16_t tslib_strlen(uint8_t *buf);
-
-void tslib_strclr(char *buf, char clrsign, uint16_t len);
-void tslib_strclr(uint8_t *buf, char clrsign, uint16_t len);
-
-void tslib_strcpy(char *srcbuf, char *destbuf, uint16_t len);
-void tslib_strcpy(char *srcbuf, uint8_t *destbuf, uint16_t len);
-void tslib_strcpy(uint8_t *srcbuf, uint8_t *destbuf, uint16_t len);
-
-
-uint16_t tslib_calcCrcCcitt(uint16_t BufLength, uint8_t *buf);
-
-bool tslib_isDecAsciiNumber(char sign);
-bool tslib_isHexAsciiNumber(char sign);
-
-
-int tslib_getMinimum(int val1, int val2);
-
-void tslib_text2array(QByteArray text, char *aray, uint16_t maxArayLen);
-    // usage:  tslib_text2array("my text", ctmp, 50);
-
-void biox_CopyBlock(uint8_t *src, uint16_t srcPos, uint8_t *dest, uint16_t destPos, uint16_t len);
-    // both buffers starting from pos 0
-
-
-#endif // TSLIB_H

src/ATBAPP/ATBAPPplugin.h

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

src/ATBAPP/ATBDeviceControllerPlugin.cpp

@@ -0,0 +1,684 @@
+#include "src/ATBAPP/ATBDeviceControllerPlugin.h"
+#include "src/ATBAPP/ATBHealthEvent.h"
+#include "src/ATBAPP/Utils.h"
+
+#include <QTimer>
+#include <QTextCodec>
+#include <QDebug>
+
+#include <QPluginLoader>
+#include <QDateTime>
+#include <QFileInfo>
+
+#include <cstdlib>
+
+
+
+ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent) : QObject(parent),
+    pluginState(PLUGIN_STATE::NOT_INITIALIZED)
+{
+    this->pluginInfo = QString::fromUtf8(pluginInfoString.c_str());
+
+    if (!this->private_loadCashAgentLib("")) {
+        return;
+    }
+
+
+
+
+    //connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_OK()),  this, SLOT(onPrintFinishedOK()),  Qt::QueuedConnection);
+    //connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_Err()), this, SLOT(onPrintFinishedERR()), Qt::QueuedConnection);
+
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_gotNewCoin()),       this, SLOT(onCashGotCoin()),                Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByMax()),     this, SLOT(onCashPayStopByMax()),           Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByEscrow()),  this, SLOT(onCashPayStopByEscrow()),        Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByError()),   this, SLOT(onCashPayStopByError()),         Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByTimeout()), this, SLOT(onCashPayStopByTimeout()),       Qt::QueuedConnection);
+
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorServiceDoorOpened()),     this, SLOT(onServiceDoorOpened()), Qt::QueuedConnection);  // switch to ModeSERVICE
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorVaultDoorOpened()),       this, SLOT(onVaultDoorOpened()),   Qt::QueuedConnection);    // Screen?? with message
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCoinBoxRemoved()),        this, SLOT(onCoinBoxRemoved()),    Qt::QueuedConnection);     // Create/Send Account
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCoinBoxInserted()),       this, SLOT(onCoinBoxInserted()),   Qt::QueuedConnection);
+    //connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCBinAndAllDoorsClosed()), this, SLOT( ??? )), Qt::QueuedConnection);
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorAllDoorsClosed()),        this, SLOT(onAllDoorsClosed()),    Qt::QueuedConnection);     // check for errors, switch to mode IDLE
+
+
+    this->currentSelectedTicketType = 0;
+    this->currentCashState = CASH_STATE::CACHE_EMPTY;
+}
+
+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);
+
+    hw->dc_autoRequest(true);
+
+    hw->rtc_setDateTime();
+
+    // this is necessary to init the CashAgentLib (!)
+    hw->vend_failed();
+
+
+    // text encoding for printer
+    this->codec = QTextCodec::codecForName(printerEncoding);
+
+
+
+    this->pluginState = PLUGIN_STATE::INITIALIZED;
+
+    return pluginState;
+}
+
+
+// Handle Mode-Changes --------------------------------------------------------
+
+void ATBDeviceControllerPlugin::onChangedProgramModeToSELL()
+{
+    //hw->dc_autoRequest(true);
+}
+
+void ATBDeviceControllerPlugin::onChangedProgramModeToSERVICE()
+{
+    //hw->dc_autoRequest(true);
+}
+
+void ATBDeviceControllerPlugin::onChangedProgramModeToIDLE()
+{
+    //hw->dc_autoRequest(false);  // <-- TODO: ???
+}
+
+void ATBDeviceControllerPlugin::onChangedProgramModeToOOO()
+{
+
+}
+
+
+// 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());
+
+    if (amountInt == 0) amountInt = UINT_MAX;
+
+    hw->cash_startPayment(amountInt);
+}
+
+void ATBDeviceControllerPlugin::requestStopCashInput()
+{
+    hw->cash_stopPayment();
+
+    // we need new cash value in application...
+    QTimer::singleShot(500, this, SLOT(onCashPayStopedSuccess()));
+}
+
+void ATBDeviceControllerPlugin::cashCollect()
+{
+    hw->vend_success();
+    this->currentCashState = CASH_STATE::CACHE_EMPTY;
+}
+
+void ATBDeviceControllerPlugin::cashAbort()
+{
+    hw->vend_failed();
+    this->currentCashState = CASH_STATE::CACHE_EMPTY;
+}
+
+// TASKS: Account -------------------------------------------------------------
+
+// for an external account request, e.g. by an ui-button:
+void ATBDeviceControllerPlugin::requestAccount()
+{
+    qCritical() << "ATBDeviceControllerPlugin::requestAccount()";
+
+    this->private_startAccount();
+}
+
+void ATBDeviceControllerPlugin::private_startAccount()
+{
+    uint16_t backupedAccNumbers[8];    // array of account numbers
+    uint8_t nrOfVals;                  // number of saved accounts
+
+    // it is not defined which one is the latest account
+    hw->log_getHoldAccountNumbers(&nrOfVals, backupedAccNumbers);
+
+    // DEBUG
+    qCritical() << "Start account: ";
+    qCritical() << "                  nrOfVals = " << nrOfVals;
+    for (int i=0; i<nrOfVals; ++i) {
+        qCritical() << "      backupedAccNumbers[" << i << "] = " << backupedAccNumbers[0];
+    }
+
+    qsort( backupedAccNumbers, nrOfVals, sizeof (uint16_t), Utils::compare );
+
+    uint16_t latestAccountNumber = backupedAccNumbers[nrOfVals-1];
+
+
+    // DEBUG
+    qCritical() << "       latestAccountNumber = " << latestAccountNumber;
+
+    hw->log_selectVaultRecord(latestAccountNumber);
+
+    this->accountCheckCounter = 0;
+    QTimer::singleShot(500, this, SLOT(private_checkAccountData()));
+}
+
+void ATBDeviceControllerPlugin::private_checkAccountData()
+{
+    // DEBUG
+    qCritical() << "      --> private_checkAccountData()";
+
+    if (hw->log_chkIfVaultRecordAvailable()) {
+        this->private_getAccountData();
+    }
+    else {
+        if (this->accountCheckCounter < 10) {
+            this->accountCheckCounter++;
+            QTimer::singleShot(500, this, SLOT(private_checkAccountData()));
+        }
+        else {
+            // cannot get accountData within ~10*500ms
+            qCritical() << "checkAccountData() failed";
+
+            // TODO: create and send an HealthEvent...
+        }
+    }
+}
+
+
+void ATBDeviceControllerPlugin::private_getAccountData()
+{
+    // DEBUG
+    qCritical() << "      --> private_getAccountData()";
+
+    struct T_vaultRecord retVR;
+
+    hw->log_getVaultRecord(&retVR);
+
+    QHash<QString, QVariant> accountData;
+
+    accountData.insert("AccountingNumber", QString::number(retVR.AccountingNumber));
+
+    for (uint i = 0; i < sizeof(retVR.coinsInVault); ++i) {
+        accountData.insert("COIN_" + QString::number(i) + "_Quantity",  retVR.coinsInVault[i]);
+        accountData.insert("COIN_" + QString::number(i) + "_Value",     retVR.coinDenomination[i]);
+
+        // DEBUG
+        qCritical() << "COIN_" + QString::number(i) + "_Quantity = " << accountData["COIN_" + QString::number(i) + "_Quantity"];
+        qCritical() << "COIN_" + QString::number(i) + "_Value    = " << accountData["COIN_" + QString::number(i) + "_Value"];
+    }
+
+    emit requestAccountResponse(accountData);
+}
+
+
+// Door Events / Hardware contacts --------------------------------------------
+void ATBDeviceControllerPlugin::onServiceDoorOpened()
+{
+    qCritical() << "ATBDeviceControllerPlugin::onServiceDoorOpened()";
+
+    // switch to mode service
+    emit this->requestModeSERVICE();
+
+    // TODO:
+    // - create an HealthEvent (-> ISMAS-Event)
+}
+
+void ATBDeviceControllerPlugin::onVaultDoorOpened()
+{
+    // TODO:
+    // - show special screen / message on screen
+    // - create an HealthEvent (-> ISMAS-Event)
+    qCritical() << "ATBDeviceControllerPlugin::onVaultDoorOpened()";
+}
+
+void ATBDeviceControllerPlugin::onCoinBoxRemoved()
+{
+    qCritical() << "ATBDeviceControllerPlugin::onCoinBoxRemoved()";
+
+    this->private_startAccount();
+}
+
+void ATBDeviceControllerPlugin::onCoinBoxInserted()
+{
+    qCritical() << "ATBDeviceControllerPlugin::onCoinBoxInserted()";
+}
+
+void ATBDeviceControllerPlugin::onAllDoorsClosed()
+{
+    // TODO:
+    // - check for errors, switch to mode IDLE
+
+    qCritical() << "ATBDeviceControllerPlugin::onAllDoorsClosed()";
+
+    emit this->requestModeIDLE();
+}
+
+
+// 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->parkingEnd,  ba_parkingEndTime.data(), std::min(ba_parkingEndTime.size(),8));
+
+    QByteArray ba_parkingEndDate = codec->fromUnicode(parkingEndDateTime.toString("dd.MM.yy"));
+    memcpy((char*)dynTicketData->currentTime,  ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
+    // ! and yes... 'ParkingEndDate' is 'currentTime'
+
+    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;
+    }
+
+    // set ticket type:
+    //      00281 - Szeged:
+    //          1 - Cash / ShortTimeParking
+    //          2 - Card / ShortTimeParking
+    //          3 - Cash / DayTicket
+    //          4 - Card / DayTicket
+    QString paymentType = printingData["paymentType"].toString(); // must be "CASH" | "CARD"
+    QString productName = printingData["product"].toString();     // must be "ShortTimeParking" | "DayTicket"
+
+    if ( (paymentType == "CASH") && (productName == "ShortTimeParking") ) {
+        this->currentSelectedTicketType = 1;
+    }
+    else
+    if ( (paymentType == "CARD") && (productName == "ShortTimeParking") ) {
+        this->currentSelectedTicketType = 2;
+    }
+    else
+    if ( (paymentType == "CASH") && (productName == "DayTicket") ) {
+        this->currentSelectedTicketType = 3;
+    }
+    else
+    if ( (paymentType == "CARD") && (productName == "DayTicket") ) {
+        this->currentSelectedTicketType = 4;
+    }
+    else {
+        qCritical() << "ERROR: requestPrintTicket(): invalid payment data:";
+        qCritical() << "       paymentType = " << paymentType   << endl
+                    << "       productName = " << productName   << endl;
+        this->onPrintFinishedERR();
+        return;
+    }
+
+    QTimer::singleShot(1000, this, SLOT(onPrinterDataPrepared()));
+}
+
+
+
+void ATBDeviceControllerPlugin::onPrinterDataPrepared()
+{
+    this->hw->prn_printKombiticket(this->currentSelectedTicketType);
+
+    // FAKE SIGNAL:
+    QTimer::singleShot(4000, this, SLOT(onPrintFinishedOK()));
+
+
+    // old: use printer templates:
+    // 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(2000, this, SLOT(onPrinterPrintNextTemplate()));
+    }
+
+}
+
+
+/************************************************************************************************
+ * private slots, interface to low level hwapi
+ *
+ */
+void ATBDeviceControllerPlugin::onPrintFinishedOK()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedOK()";
+
+    emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
+                                   // TODO: TicketNumber
+                                   "",
+                                   "");
+}
+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()";
+
+    this->currentCashState = CASH_STATE::CACHE_INPUT;
+
+    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::onCashPayStopByMax()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashVendStopByMax()";
+
+    // we need new cash value in application...
+    QTimer::singleShot(500, this, SLOT(onCashPayStopedSuccess()));
+
+}
+
+void ATBDeviceControllerPlugin::onCashPayStopByEscrow()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByEscrow()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
+                              amountString,
+                              "",
+                              "");
+}
+
+void ATBDeviceControllerPlugin::onCashPayStopByError()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByError()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
+                              amountString,
+                              "",
+                              "");
+}
+
+void ATBDeviceControllerPlugin::onCashPayStopByTimeout()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByTimeout()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
+                              amountString,
+                              "",
+                              "");
+}
+
+void ATBDeviceControllerPlugin::onCashPayStopedSuccess()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStoped()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+    qCritical() << "      insertedAmount (int) = " << amountInt;
+    qCritical() << "            insertedAmount = " << amountString;
+
+    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
+                              amountString,
+                              "",
+                              "");
+}
+
+
+
+/**
+ * Load CashAgentLib
+ * @brief ATBDeviceControllerPlugin::private_loadCashAgentLib
+ * @param pluginName
+ * @return
+ */
+bool ATBDeviceControllerPlugin::private_loadCashAgentLib(QString pluginName)
+{
+    if (pluginName == "") {
+
+        // search list for plugin (.so) file:
+        QStringList pluginNameList;
+        pluginNameList << "/usr/lib/libCAmaster.so"
+                       << "/usr/lib/libCashAgentLib.so";
+        // using C++11 range based loop:
+        for (const auto& filename : pluginNameList) {
+            if (QFileInfo(filename).isReadable()) {
+                pluginName = filename;
+                break;
+            }
+        }
+
+        if (pluginName == "") {
+            qCritical() << "ATBDeviceControllerPlugin: CashAgentLib not installed!";
+            this->errorCode = "CashAgentLib::NOT_FOUND";
+            this->errorDescription = "ERROR: no CashAgentLib: ";
+            return false;
+        }
+
+    }
+
+    if (!QLibrary::isLibrary(pluginName)) {
+        qCritical() << "ATBDeviceControllerPlugin: can not load CashAgentLib: " << pluginName;
+        this->errorCode = "CashAgentLib::NO_LIBRARY";
+        this->errorDescription = "ERROR: can not load CashAgentLib: " + pluginName;
+        return false;
+    }
+
+    QPluginLoader* pluginLoader = new QPluginLoader();
+    pluginLoader->setFileName(pluginName);
+
+    QObject* plugin = pluginLoader->instance();
+    if (!pluginLoader->isLoaded()) {
+        qCritical() << "ATBDeviceControllerPlugin: can not instantiate CashAgentLib: " << pluginName;
+        qCritical() << "               error: " << pluginLoader->errorString();
+        this->errorCode = "CashAgentLib::NO_INSTANCE";
+        this->errorDescription = "ERROR: can not instantiate CashAgentLib: " + pluginName;
+        return false;
+    }
+
+    if (plugin == nullptr) {
+        qCritical() << "ATBDeviceControllerPlugin: plugin is NULL";
+        this->errorCode = "CashAgentLib::INSTANCE_IS_NULL";
+        this->errorDescription = "ERROR: CashAgentLib instance is NULL: " + pluginName;
+    }
+
+    qCritical() << "ATBDeviceControllerPlugin: instantiate CashAgentLib: " << pluginName;
+
+    this->hw = qobject_cast<hwinf*>(plugin);
+
+    if (this->hw == nullptr) {
+        qCritical() << "ATBDeviceControllerPlugin: hw is NULL";
+        this->errorCode = "CashAgentLib::HW_IS_NULL";
+        this->errorDescription = "ERROR: CashAgentLib object_cast is NULL: " + pluginName;
+        return false;
+    }
+
+    qCritical() << "ATBDeviceControllerPlugin: loaded CashAgentLib";
+
+    return true;
+}
+
+
+
+/************************************************************************************************
+ * 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,166 @@
+#ifndef ATBDEVICECONTROLLERPLUGIN_H
+#define ATBDEVICECONTROLLERPLUGIN_H
+
+#include <QObject>
+
+#include "src/ATBAPP/DeviceControllerInterface.h"
+#include "src/ATBAPP/ATBAPPplugin.h"
+#include "version.h"
+
+
+
+#include "interfaces.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);
+
+    // TASKS: Account -------------------------------------------------------------
+    void requestAccount();
+
+    // mandantory ATBAPP plugin methods: ------------------------------------------
+    nsDeviceControllerInterface::PLUGIN_STATE getState();
+    QString & getLastError();
+    const QString & getLastErrorDescription();
+
+    const QString & getPluginInfo();
+
+    // helpers e.g. for debug / log
+    const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState);;
+
+public slots:
+    void onChangedProgramModeToSELL();
+    void onChangedProgramModeToSERVICE();
+    void onChangedProgramModeToIDLE();
+    void onChangedProgramModeToOOO();
+
+
+
+
+
+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 requestModeSERVICE();
+    void requestModeIDLE();
+    void requestModeOOO();
+
+    void requestAccountResponse(const QHash<QString, QVariant> & accountData);
+
+
+
+    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;
+
+   bool private_loadCashAgentLib(QString pluginName);
+
+   quint8 currentSelectedTicketType;
+
+   nsDeviceControllerInterface::CASH_STATE currentCashState;
+
+   // counts failed hw->log_chkIfVaultRecordAvailable()
+   int accountCheckCounter;
+
+
+private slots:
+   // printer
+
+   void onPrinterDataPrepared();
+   void onPrinterPrintNextTemplate();
+
+   void onPrintFinishedOK();
+   void onPrintFinishedERR();
+
+   // cash payment
+   void onCashGotCoin();
+   void onCashPayStopedSuccess();
+   void onCashPayStopByMax();
+   void onCashPayStopByEscrow();
+   void onCashPayStopByError();
+   void onCashPayStopByTimeout();
+
+   // doors and hardware contacts
+   void onServiceDoorOpened();
+   void onVaultDoorOpened();
+   void onCoinBoxRemoved();
+   void onCoinBoxInserted();
+   void onAllDoorsClosed();
+
+   // account handling
+   void private_startAccount();
+   void private_checkAccountData();
+   void private_getAccountData();
+};
+
+#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,165 @@
+#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: Account -------------------------------------------------------------
+
+    virtual void requestAccount() = 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;
+
+public slots:
+    virtual void onChangedProgramModeToSELL() = 0;
+    virtual void onChangedProgramModeToSERVICE() = 0;
+    virtual void onChangedProgramModeToIDLE() = 0;
+    virtual void onChangedProgramModeToOOO() = 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 requestModeSERVICE() = 0;
+
+    /**
+     * emitted e.g. if doors are closed
+     */
+    virtual void requestModeIDLE() = 0;
+
+    /**
+     * emitted e.g. on severe errors
+     */
+    virtual void requestModeOOO() = 0;
+
+    /**
+     * emitted e.g. if service door is opened
+     */
+    virtual void requestAccountResponse(const QHash<QString, QVariant> & accountData) = 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/ATBAPP/Utils.cpp

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

src/ATBAPP/Utils.h

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

src/com.cpp

@@ -1,449 +0,0 @@
-#include "com.h"
-#include <QDebug>
-//#include "controlBus.h"
-
-//////////////////////////////////////////////////////////////////////////////////
-///
-///      serial hardware layer
-///
-//////////////////////////////////////////////////////////////////////////////////
-
-static int64_t com_want2read;
-// -------------------------------------------------------------------------------------------------------------
-// --------- PUBLIC --------------------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------------------------------------
-
-void T_com::writeToSerial(const QByteArray &data, uint16_t sendLength)
-{
-    sendBuffer=data;
-    sendLen=sendLength;
-    if (CatSerial->isOpen())
-    {
-        //qDebug() << "sending..." << sendBuffer;
-        CatSerial->write(sendBuffer);
-    } else
-        qDebug() << "error sending, port is not open";
-
-}
-
-
-bool T_com::readFromSerial(QByteArray &data, uint16_t &sendLength)
-{
-    // return one time true if new data (completly) read.
-    // return new data in &data and &sendLength  to other objects
-    uint16_t ll=rawInLen;
-    if (!CatSerial->isOpen())
-        return false;
-    data.clear();
-    data.append(rawInput);
-    sendLength=ll;
-    rawInLen=0;         // beim 2. Aufruf 0 zurück weil nichts neues da
-    if (ll>0)
-        return true;
-    return false;
-}
-
-
-// -------------------------------------------------------------------------------------------------------------
-// ---------   PRIVATES  --------------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------------------------------------
-
-
-T_com::T_com(QWidget *parent) : QMainWindow(parent)
-{
-    // port settings come from tabCom->Sdata->serial
-
-    gpi_serialChanged();
-    CatSerial = new QSerialPort();  // PortHW object for Control&Analyse Tool
-    //CatSerial->clear();
-    //CatSerial->clearError();
-
-    connect(CatSerial, &QSerialPort::readyRead, this, &T_com::readSomeBytes);
-        // still reading, not sure if complete, undefined number of calls while reading
-
-    connect(CatSerial, &QSerialPort::bytesWritten, this, &T_com::serialSendComplete);
-        // system confirms sending complete
-
-    //connect(CatSerial, &QSerialPort::dataTerminalReadyChanged, this, &T_com::incomingWake);
-    //connect(CatSerial, &QSerialPort::requestToSendChanged, this, &T_com::incomingWake);
-
-    // timer detects time gap in input flow
-    serRecTime = new QTimer();
-    connect(serRecTime, SIGNAL(timeout()), this, SLOT(receiveTO()));
-    serRecTime->setSingleShot(true);        // single shot! only one impulse if receive complete
-    serRecTime->stop();                     // on hold
-
-    // check COM-TAB periodic if user wants to connect or disconnect
-    QTimer *ChkConnectTimer = new QTimer();
-    connect(ChkConnectTimer, SIGNAL(timeout()), this, SLOT(ser_ISR100ms()));
-    ChkConnectTimer->setSingleShot(false);
-    ChkConnectTimer->start(100);     // in ms
-    com_want2read=0;
-}
-
-
-
-
-T_com::~T_com()
-{
-    if (CatSerial->isOpen())
-        CatSerial->close();
-}
-
-
-void T_com::ser_ISR100ms()
-{
-    //qDebug() << "~~>LIB" << "ENTER...";
-    // call every 100ms to check if user(HMI) wants to connect or disconnect
-    uint8_t chkConn = gpi_getSerialConn();    // from global GUI buffer (Sdata)
-
-    //qDebug() << "~~>LIB" << "checking connect button... " << chkConn;
-
-    switch (chkConn)
-    {
-        case 0: // 0 button "connect" was just released
-                //qDebug() << "close serial port" << chkConn;
-                closeSerialPort();
-                gpi_serialChanged();    // set chkConn to 2, thus getting edge
-                break;
-        case 1: // 1 button "connect" was just pressed
-                //qDebug() << "open serial port" << chkConn;
-                open_Serial_Port();
-                gpi_serialChanged();    // set chkConn to 2, thus getting edge
-                break;
-    }
-
-
-    if (CatSerial->isOpen()) {
-        gpi_serialIsOpen(true);
-    } else {
-        gpi_serialIsOpen(false);
-    }
-
-    //qDebug() << "LEAVE " << chkConn;
-}
-
-// -------------------------------------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------------------------------------
-
-char T_com::open_Serial_Port()
-{
-    //qDebug() << "ENTER";
-
-    bool ret;
-    QString myString=nullptr, myPortName=nullptr, myBaudStr=nullptr;
-    int myBaudNr;
-
-    if (CatSerial->isOpen()) {
-        qDebug() << "!!!IS OPEN!!!";
-        return 0;                   // opening twice is not allowed
-    }
-
-    //qDebug() << "connecting..." << myPortName;
-    myPortName=gpi_getComPortName();                // was selected and stored from GUI
-    CatSerial->setPortName(myPortName);
-    myBaudNr=gpi_getBaudNr();                       // was selected and stored from GUI
-
-    //qDebug() << "myPortName" << myPortName << ", myBaudNr" << myBaudNr;
-
-    switch (myBaudNr)
-    {
-        // 0:1200   1:9600   2:19200   3:38400   4:57600   5:115200
-        case 0: CatSerial->setBaudRate(QSerialPort::Baud1200); myBaudStr="1200"; break;
-        case 1: CatSerial->setBaudRate(QSerialPort::Baud9600); myBaudStr="9600"; break;
-        case 2: CatSerial->setBaudRate(QSerialPort::Baud19200); myBaudStr="19200"; break;
-        case 3: CatSerial->setBaudRate(QSerialPort::Baud38400); myBaudStr="38400"; break;
-        case 4: CatSerial->setBaudRate(QSerialPort::Baud57600); myBaudStr="57600"; break;
-        case 5: CatSerial->setBaudRate(QSerialPort::Baud115200); myBaudStr="115200"; break;
-    }
-
-    CatSerial->setDataBits(QSerialPort::Data8);
-        // alt: QSerialPort::Data5,6,7,8
-
-    CatSerial->setParity(QSerialPort::NoParity);
-        // alt: EvenParity, OddParity, NoParity
-
-    CatSerial->setStopBits(QSerialPort::OneStop);
-        // alternative: OneStop, TwoStop, OneAndHalfStop
-
-    CatSerial->setFlowControl(QSerialPort::NoFlowControl);
-        // alt: HardwareControl, SoftwareControl, NoFlowControl
-
-    ret=CatSerial->open(QIODevice::ReadWrite);
-        // alt: QIODevice::ReadWrite  QIODevice::ReadOnly  QIODevice::WriteOnly
-    if (!ret)
-    {
-        myString.clear();
-        myString = "error ";
-        myString.append(CatSerial->errorString());
-        qDebug() << myString;
-        gpi_setTxt4comStateLine(myString);
-
-        //qDebug() << "LEAVE";
-
-        return 0;
-    } else
-    {
-        myString.clear();
-        myString.append(myPortName);
-        //lang=myString.size();
-        myString.append(" opened with ");
-        myString.append(myBaudStr);
-        myString.append(" 8N1");
-        qDebug() << myString;
-        gpi_setTxt4comStateLine(myString);
-        gpi_setTxt4RsDiagWin(myString+"\n");
-
-    }
-
-    //qDebug() << "LEAVE";
-    return 0;
-}
-
-void T_com::closeSerialPort()
-{
-    //qDebug() << "ENTER";
-
-    if (CatSerial->isOpen())
-    {
-        qDebug() << "closing connection";
-        CatSerial->close();
-        gpi_setTxt4comStateLine("closed");
-        gpi_setTxt4RsDiagWin("closed");
-
-    }
-
-    //qDebug() << "LEAVE";
-}
-
-
-void T_com::readSomeBytes(void)
-{
-    // called by serial-read-detection
-    // restart off-time as input flow is ongoing
-
-    // timer for slow receive
-    // and serves as timeout for fast receive is msg is shorter as expected
-        serRecTime->stop();
-        serRecTime->start(20);     // in ms
-
-        //qDebug()<< "com-rec read some bytes";
-
-    this->receiveByLength();    // since 14.12.21: fast receive
-}
-
-void T_com::receiveFixLen(int64_t nrOfbytesToReceive)
-{
-    // call this before sending a request to slave
-    // then we know exactly when reception is complete -> much faster
-    com_want2read=nrOfbytesToReceive;
-        // since 14.12.21: FastDevice Protocol has two lengthen:
-        // fast: 12byte reception  long: 68byte
-}
-
-void T_com::receiveByLength(void)
-{
-
-    if (CatSerial->isOpen())
-    {
-        QString myString=nullptr, tmpStr=nullptr;
-        int64_t nrOfBytesreceived = CatSerial->bytesAvailable();        // nr of received bytes
-
-        //qDebug()<< "com-rec current Len: "<< nrOfBytesreceived;
-
-        if (nrOfBytesreceived >= com_want2read)
-        {
-            QByteArray data = CatSerial->readAll();     // erst auslesen wenn alles da! löscht den Empfangspuffer
-            serRecTime->stop();     // stop timeout to avoid 2nd emit
-            rawInLen=uint16_t (nrOfBytesreceived);
-            rawInput.clear();
-            rawInput.append(data);
-            // report "new data received" to other objects
-            //qDebug()<< "com-recFinished by Len "<< rawInLen;
-            emit receivingFinished();
-        }
-    }
-}
-
-void T_com::receiveTO(void)
-{
-    // no new input data for 20ms, --> assuming frame complete
-    // save data in private "rawInput"-buffer
-
-    if (CatSerial->isOpen())
-    {
-
-        QString myString=nullptr, tmpStr=nullptr;
-        int64_t nrOfBytesreceived = CatSerial->bytesAvailable();        // nr of received bytes
-        QByteArray data = CatSerial->readAll();
-
-        rawInLen=uint16_t (nrOfBytesreceived);
-        rawInput.clear();
-        rawInput.append(data);
-        //rawInput[rawInLen]=0;       // Zwangsterminierung bei QByteArray nicht nötig
-
-        // diag display in serial in/out window and debug window
-        myString.clear();
-        myString.setNum(rawInLen);
-        myString.append(" in: ");
-        //myString.append(rawInput);
-        for (int ii=0; ii<rawInLen; ii++)
-        {
-            tmpStr.clear();
-            tmpStr.setNum(rawInput[ii],16);   // problem: wenn >0x80 dann wird EIN Byte 16 stellig angezeigt
-            int ll=tmpStr.length();
-            if (ll>2)
-            {
-                myString.append(tmpStr[ll-2]);
-                myString.append(tmpStr[ll-1]);
-            } else
-            {
-                myString.append(tmpStr);
-            }
-                myString.append(" ");
-        }
-        myString.append("\n");
-    #ifdef PRINTALLDEBUGS
-        qDebug() << "VCP:" << myString;   // display all inputs and outputs in output window
-    #endif
-        gpi_setTxt4RsDiagWin(myString);
-        //gpi_set2ndTxt4RsDiagWin(myString);
-
-        // report "new data received" to other objects
-        //qDebug()<< "com-recFinished by TO";
-        emit receivingFinished();
-    }
-}
-
-void T_com::serialSendComplete(void)
-{
-    // system confirms sending complete, diag display
-    QString myString=nullptr, tmpStr=nullptr;
-
-    myString.clear();
-    myString.setNum(sendLen);
-    myString.append(" out: ");
-
-    for (int ii=0; ii<sendLen; ii++)
-    {
-        tmpStr.clear();
-        tmpStr.setNum(sendBuffer[ii],16);   // problem: wenn >0x80 dann 16stellig
-        int ll=tmpStr.length();
-        if (ll>2)
-        {
-            //qDebug() << "long_string" << ll << "\n";
-            myString.append(tmpStr[ll-2]);
-            myString.append(tmpStr[ll-1]);
-
-        } else
-        {
-            myString.append(tmpStr);
-        }
-            myString.append(" ");
-    }
-
-#ifdef PRINTALLDEBUGS
-    myString.append("\n");
-    qDebug() << myString; // display all output data in out-window
-#endif
-
-    gpi_setTxt4RsDiagWin(myString);
-
-    emit sendingFinished();     // for whom it may interest
-}
-
-
-bool T_com::isPortOpen(void)
-{
-    if (CatSerial->isOpen())
-        return true;
-    return false;
-}
-
-
-
-// -------------------------------------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------------------------------------
-
-/*
-uint8_t T_com::getAllPortPins(void)
-{
-    uint8_t rs232pins=0;
-    rs232pins= uint8_t(CatSerial->pinoutSignals());
-        // rs232pins: all signals bitwise coded in one byte:
-        // readback output:  bit 0=TxD(=output)      bit2=DTR (=output)    bit 6=RTS (=output)
-        // unused inputs:       bit1=RxD    bit 3=DCD    bit 5 = RING
-        // handshake inputs:           bit 4=DSR (0x10)     bit 7=CTS (0x80)
-    //qDebug()<<"serial port pins: " << rs232pins;
-    return rs232pins;
-}
-
-bool T_com::getHSin_CTS(void)
-{
-    // return the used Handshake IN (CTS, alt. DSR): true= high level (+8V)
-
-    uint8_t rs232pins=0;
-
-    rs232pins= uint8_t(CatSerial->pinoutSignals());
-        // rs232pins: all signals bitwise coded in one byte:
-        // readback output:  bit 0=TxD(=output)      bit2=DTR (=output)    bit 6=RTS (=output)
-        // unused inputs:       bit1=RxD    bit 3=DCD    bit 5 = RING
-        // handshake inputs:           bit 4=DSR (0x10)     bit 7=CTS (0x80)
-
-    if (rs232pins & 0x80)   // CTS
-        return true;
-
-    return false;
-}
-
-
-bool T_com::getHSin_DSR(void)
-{
-    uint8_t rs232pins=0;
-    rs232pins= uint8_t(CatSerial->pinoutSignals());
-    if (rs232pins & 0x10)   // DSR
-        return true;
-    return false;
-}
-
-void T_com::incomingWake(void)       //(bool LevelOfTheBit)
-{
-    emit wasWokenBySerialHandshake();
-}
-
-bool T_com::setHSout_RTS(bool hsout)
-{
-    // hsout true=positiv voltage +12V  false= -12V
-    // retval: true=setting OK
-
-    bool cc;
-    // 10.5.19, am Windows-PC nachgemessen, funktioniert gut
-    // false ergibt -12V    true ergibt +12V
-
-    cc=CatSerial->setRequestToSend(hsout);  // RTS out
-            // retval true means "setting was successful"
-
-    // alternative: use DTR as Handshake:
-    //cc=CatSerial->setDataTerminalReady(false);     // DTR out
-        // retval true means "setting was successful"
-    //qDebug()<<"RTS " <<cc;
-    return cc;
-}
-
-bool T_com::setHSout_DTR(bool hsout)
-{
-    // hsout true=positiv voltage +12V  false= -12V
-    // retval: true=setting OK
-
-    bool cc;
-    // 10.5.19, am Windows-PC nachgemessen, funktioniert gut
-    // false ergibt -12V    true ergibt +12V
-
-    cc=CatSerial->setDataTerminalReady(hsout);     // DTR out
-        // retval true means "setting was successful"
-    //qDebug()<<"DTR " <<cc;
-    return cc;
-}
-*/

src/controlBus.cpp

@@ -1,326 +0,0 @@
-#include <stdint.h>
-#include <algorithm>
-
-#include <QString>
-#include <QDebug>
-#include "tslib.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);
-
-    memset(&SharedMemBuffer::getData()->rs.baudStr[0], 0x00,
-           sizeof(SharedMemBuffer::getData()->rs.baudStr));
-    strncpy(SharedMemBuffer::getData()->rs.baudStr,
-            BaudStr.toStdString().c_str(),
-            sizeof(SharedMemBuffer::getData()->rs.baudStr)-1);
-
-    SharedMemBuffer::getData()->rs.baudNr = BaudNr;
-    SharedMemBuffer::getData()->rs.connect = connect;
-}
-
-void epi_closeSerial(void) {
-    SharedMemBuffer::getData()->rs.connect = 0;
-}
-
-void gpi_serialChanged(void) {
-    // serial confirms that port was closed or opened
-    // rs_connect=2;   // Flanke, nur 1x öffnen/schließen
-    SharedMemBuffer::getData()->rs.connect = 2;
-}
-
-uint8_t gpi_getSerialConn(void) {
-    return SharedMemBuffer::getDataConst()->rs.connect;
-}
-
-int gpi_getBaudNr(void) {
-    return SharedMemBuffer::getDataConst()->rs.baudNr;
-}
-
-QString gpi_getComPortName(void) {
-    return SharedMemBuffer::getDataConst()->rs.comportName;
-}
-
-void gpi_serialIsOpen(bool offen) {
-    SharedMemBuffer::getData()->rs.portIsOpen = offen;
-}
-
-bool epi_isSerialPortOpen() {
-    // true: port is open   false: port is closed
-    return SharedMemBuffer::getDataConst()->rs.portIsOpen;
-}
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          Control transfer   gui <--> serial
-// ///////////////////////////////////////////////////////////////////////////////////
-
-void epi_startEmmision(char start) {
-    SharedMemBuffer::getData()->AutoEmissionOn = start;
-}
-
-bool gpi_isEmmisionOn(void) {
-    return SharedMemBuffer::getDataConst()->AutoEmissionOn;
-}
-
-uint16_t gpi_getPeriodicSendTimeVal() {
-    SharedMemBuffer::getData()->datif.sendingPer_changed = 0;
-    if ((SharedMemBuffer::getDataConst()->datif.sendingPeriod < 3) ||
-        (SharedMemBuffer::getDataConst()->datif.sendingPeriod > 10000)) {
-        return 130;         // ms, default
-    }
-    return SharedMemBuffer::getDataConst()->datif.sendingPeriod;
-}
-
-void epi_setPeriodicSendTimeVal(uint16_t val) {
-    if (val>=3 && val<10000) {
-        SharedMemBuffer::getData()->datif.sendingPer_changed = 1;
-        SharedMemBuffer::getData()->datif.sendingPeriod = val;
-    }
-}
-
-bool gpi_PeriodicSendTimeHasChanged() {
-    return SharedMemBuffer::getDataConst()->datif.sendingPer_changed;
-}
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          Status Display    gui <--> serial
-// ///////////////////////////////////////////////////////////////////////////////////
-
-//              linke Spalte, über Connect Button
-static QString txt4comStateLine;
-
-QString epi_getTxt4comStateLine(void) {
-    // GUI: get Text for serial Comport-State Line
-    return txt4comStateLine;
-}
-
-void gpi_setTxt4comStateLine(QString txtline) {
-    // serial: write Text to be displayed in serial Comport-State line (like "connected")
-    txt4comStateLine.clear();
-    if (txtline=="")
-        txt4comStateLine.clear();
-    else
-        txt4comStateLine=txtline;
-}
-
-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) {
-    return txt4HsStateLine;
-}
-
-void gpi_setTxt4HsStateLine(QString txtline) {
-    txt4HsStateLine.clear();
-    if (txtline=="")
-        txt4HsStateLine.clear();
-    else
-        txt4HsStateLine=txtline;
-}
-
-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) {
-    return txt4masterStateLine;
-}
-
-void gpi_setTxt4masterStateLine(QString txtline) {
-    txt4masterStateLine.clear();
-    if (txtline=="")
-        txt4masterStateLine.clear();
-    else
-        txt4masterStateLine=txtline;
-}
-
-void epi_clrTxt4masterStateLine() {
-    txt4masterStateLine.clear();
-}
-
-//---------------------------------------------------------------------------------------------
-
-// III   Slave receive (from Master) OK? if then show results, if not then show errors
-// entweder Empfangsfehler anzeigen (crc? length?) oder result OUT-OK, OUT_ERR, IN_OK, IN_ERR
-// Hintergrund: wenn der Slave Fehler im Master-Telegramm gefunden hat, dann kann er es auch
-// nicht verwenden und nichts ausgeben oder einlesen
-
-static QString txt4resultStateLine;
-
-QString epi_getTxt4resultStateLine(void) {
-    return txt4resultStateLine;
-}
-
-void gpi_setTxt4resultStateLine(QString txtline) {
-    txt4resultStateLine.clear();
-    if (txtline=="")
-        txt4resultStateLine.clear();
-    else
-        txt4resultStateLine=txtline;
-}
-
-void epi_clrTxt4resultStateLine() {
-    txt4resultStateLine.clear();
-}
-
-//---------------------------------------------------------------------------------------------
-
-// IV  Statuszeile Empfangsdaten
-static QString txt4dataLine;
-
-QString epi_getTxt4dataStateLine(void) {
-    // GUI: get Text for serial Comport-State Line
-    return txt4dataLine;
-
-}
-
-void gpi_setTxt4dataStateLine(QString txtline) {
-    // serial: write Text to be displayed in serial Comport-State line (like "connected")
-    txt4dataLine.clear();
-    if (txtline=="")
-        txt4dataLine.clear();
-    else
-        txt4dataLine=txtline;
-}
-
-void epi_clrTxt4dataStateLine() {
-    txt4dataLine.clear();
-}
-
-//---------------------------------------------------------------------------------------------
-
-// 5. Zeile: Datif Ergebnis, Daten brauchbar?
-
-static QString txt4datifReceive;
-
-QString epi_getTxt4datifLine(void) {
-    return txt4datifReceive;
-}
-
-void gpi_setTxt4datifLine(QString txtline) {
-    txt4datifReceive.clear();
-    if (txtline=="")
-        txt4datifReceive.clear();
-    else
-        txt4datifReceive=txtline;
-}
-
-void epi_clrTxt4datifLine() {
-    txt4datifReceive.clear();
-}
-
-//---------------------------------------------------------------------------------------------
-//---------------------------------------------------------------------------------------------
-
-static QString txt4diagWindow;
-
-QString epi_getTxt4RsDiagWin(void) {
-    return txt4diagWindow;
-}
-
-void gpi_setTxt4RsDiagWin(QString txtline) {
-    txt4diagWindow.clear();
-    if (txtline=="")
-        txt4diagWindow.clear();
-    else
-        txt4diagWindow=txtline;
-}
-
-void epi_clrTxt4RsDiagWin() {
-    txt4diagWindow.clear();
-}
-
-//---------------------------------------------------------------------------------------------
-
-static QString sndTxt4diagWindow;
-
-QString epi_get2ndTxt4RsDiagWin(void) {
-    return sndTxt4diagWindow;
-}
-
-void gpi_set2ndTxt4RsDiagWin(QString txtline) {
-    sndTxt4diagWindow.clear();
-    if (txtline=="")
-        sndTxt4diagWindow.clear();
-    else
-        sndTxt4diagWindow=txtline;
-}
-
-void epi_clr2ndTxt4RsDiagWin() {
-    sndTxt4diagWindow.clear();
-}
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          Memory for Slave responses, common data
-// ///////////////////////////////////////////////////////////////////////////////////
-void gpi_storeResult_serialTestOK(bool wasOk) {
-    SharedMemBuffer::getData()->Sdata.serialTestResult = wasOk;
-}
-
-bool epi_getResult_serialTestOK() {
-    // retval: true: test was successful, got right response
-    return SharedMemBuffer::getDataConst()->Sdata.serialTestResult;
-}
-
-// ///////////////////////////////////////////////////////////////////////////////////
-//          Store received data for hwapi
-// ///////////////////////////////////////////////////////////////////////////////////
-void gpi_startNewRequest() {
-    SharedMemBuffer::getData()->Sdata.pProtResultOk = 0;
-}
-
-void gpi_storeResultOfLastRequest(bool answisok) {
-    SharedMemBuffer::getData()->Sdata.pProtResultOk = answisok ? 1 : 2;
-}
-
-uint8_t epi_getResultOfLastRequest() {
-    // retval: 0: in progress  1: OK  2: error
-    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));
-    memset((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
-           0x00, sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock));
-    strncpy((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
-            (char const *)receivedData,
-            sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock)-1);
-}
-
-uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad) {
-    // 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 = std::min(plBufSiz, (uint16_t)(64));
-    if (SharedMemBuffer::getDataConst()->Sdata.receivedDataLength < ml) {
-        ml = SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
-    }
-    strncpy((char *)payLoad,
-            (char const *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
-            ml);
-
-    return SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
-}

src/prot.cpp

@@ -1,764 +0,0 @@
-#include "prot.h"
-#include <QDebug>
-#include "controlBus.h"
-#include "dcBL.h"
-
-
-T_prot::T_prot()
-{
-
-    mySerialPort = new T_com();
-    connect(mySerialPort, SIGNAL(receivingFinished()), this, SLOT( analyseRecData() ));
-    //connect(mySerialPort, SIGNAL(sendingFinished()), this, SLOT(sendeFin()));
-
-    for (int nn=0; nn<FRAME_DATALEN; nn++)
-    {
-        chOut_Data[nn]=0;
-        ui8OutputData[nn]=0;
-        InputData[nn]=0;
-    }
-    for (int nn=0; nn<BL_DATA_LEN; nn++)
-    {
-        ui8BLsendData[nn]=0;
-    }
-    WriteCommand=0;
-    WriteAddr=0;
-    WrDataLength=0;
-    SendDataValid=0;
-    kindOfData=0;
-    slaveAddr=0;
-    ReadCommand=0;
-    ReadAddr=0;
-    reserve =0;
-    RecSlaveAddr =0;
-    INdataValid=0;
-    readSource =0;
-    readAddress=0;
-    RdDataLength=0;
-    BLsendDataLength=0;
-
-}
-
-
-// ---------------------------------------------------------------------------------------------------------
-// sending.....
-// ---------------------------------------------------------------------------------------------------------
-
-bool T_prot::isPortOpen(void)
-{
-    return mySerialPort->isPortOpen();
-}
-
-bool T_prot::isSerialFree(void)
-{
-    return true;           // ohne HS's kann er nicht blockiert sein
-}
-
-void T_prot::setRecLen(uint16_t WriteCmd)
-{
-    if (WriteCmd<100)
-    {
-        RdDataLength=DATALEN_RECEIVE_LONG;      // store here already because it's no longer
-                                                // returned from slave
-        mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_LONG);
-    } else
-    {
-        RdDataLength=DATALEN_RECEIVE_FAST;
-        mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_FAST);
-    }
-}
-
-void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t  WrDatLen, uint8_t *data)
-{
-    WriteCommand=WriteCmd;
-    WriteAddr=WrAddr;
-    WrDataLength=WrDatLen;
-    if (WrDataLength>FRAME_DATALEN)
-        WrDataLength=FRAME_DATALEN;
-
-    for (int nn=0; nn<WrDataLength; nn++)
-        ui8OutputData[nn]=data[nn];
-    SendDataValid=1;    // always set WR first
-    kindOfData=0;    // 0: binaries, 1:text
-    this->setRecLen(WriteCmd);
-
-}
-
-void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr)
-{
-    WriteCommand=WriteCmd;
-    WriteAddr=WrAddr;
-    WrDataLength=0;
-    for (int nn=0; nn<FRAME_DATALEN; nn++)
-        ui8OutputData[nn]=0;
-    SendDataValid=1;    // always set WR first
-    kindOfData=0;    // 0: binaries, 1:text
-    this->setRecLen(WriteCmd);
-
-}
-
-void T_prot::setUserWriteData(uint16_t WriteCmd)
-{
-    WriteCommand=WriteCmd;
-    WriteAddr=0;
-    WrDataLength=0;
-    for (int nn=0; nn<FRAME_DATALEN; nn++)
-        ui8OutputData[nn]=0;
-    SendDataValid=1;    // always set WR first
-    kindOfData=0;    // 0: binaries, 1:text
-    this->setRecLen(WriteCmd);
-
-}
-
-void T_prot::setUserWrite1DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val)
-{
-    // wie oben, jedoch einfachere Datenübergabe
-    WriteCommand=WriteCmd;
-    WriteAddr=WrAddr;
-    WrDataLength=1;
-    ui8OutputData[0]=val;
-    SendDataValid=1;    // always set WR first
-    kindOfData=0;    // 0: binaries, 1:text
-    this->setRecLen(WriteCmd);
-
-}
-
-void T_prot::setUserWrite2DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, uint8_t val1)
-{
-    WriteCommand=WriteCmd;
-    WriteAddr=WrAddr;
-    WrDataLength=2;
-    ui8OutputData[0]=val0;
-    ui8OutputData[1]=val1;
-    SendDataValid=1;    // always set WR first
-    kindOfData=0;    // 0: binaries, 1:text
-    this->setRecLen(WriteCmd);
-
-}
-
-void T_prot::setUserWriteText(uint16_t WriteCmd, uint16_t WrAddr, uint8_t  WrDatLen, char *data)
-{
-    WriteCommand=WriteCmd;
-    WriteAddr=WrAddr;
-    WrDataLength=WrDatLen;
-    if (WrDataLength>FRAME_DATALEN)
-        WrDataLength=FRAME_DATALEN;
-
-    for (int nn=0; nn<WrDataLength; nn++)
-        chOut_Data[nn]=data[nn];
-    SendDataValid=1;    // always set WR first
-    kindOfData=1;    // 0: binaries, 1:text
-    this->setRecLen(WriteCmd);
-
-}
-
-void T_prot::setUserReadData( uint16_t ReadCmd,  uint16_t RdAddr, uint16_t reserv)
-{
-    ReadCommand=ReadCmd;
-    ReadAddr=RdAddr;
-    reserve=reserv;  
-    SendDataValid |=2;
-    readAddress=RdAddr;    // store here already because it's no longer returned from slave
-    readSource=ReadCmd;
-}
-
-void T_prot::setUserReadData( uint16_t ReadCmd,  uint16_t RdAddr)
-{
-    ReadCommand=ReadCmd;
-    ReadAddr=RdAddr;
-    reserve=0;
-    SendDataValid |=2;
-    readAddress=RdAddr;    // store here already because it's no longer returned from slave
-    readSource=ReadCmd;
-}
-
-void T_prot::setUserReadData( uint16_t ReadCmd)
-{
-    ReadCommand=ReadCmd;
-    ReadAddr=0;
-    reserve=0;
-    SendDataValid |=2;
-    readAddress=0;    // store here already because it's no longer returned from slave
-    readSource=ReadCmd;
-}
-
-void T_prot::setBLsendData( uint8_t len, uint8_t *buf)
-{
-    for (int nn=0; nn<BL_DATA_LEN; nn++)
-        ui8BLsendData[nn]=0;
-
-    BLsendDataLength=len;
-    if ( BLsendDataLength>BL_DATA_LEN) BLsendDataLength=BL_DATA_LEN;
-    for (int nn=0; nn<BLsendDataLength; nn++)
-        ui8BLsendData[nn]=buf[nn];
-    WriteCommand=0xFFFF;
-    this->setRecLen(100);   // how many??
-    //readAddress=          // needed??
-
-    //qDebug()<<"prot: got BL data " << len << "bytes, ";
-    //for (int i=0; i<len; ++i) {
-    //    printf("%02x ", (unsigned char)buf[i]);
-    //} printf("\n");
-
-    /*
-qDebug()<<buf[0] <<buf[1] <<buf[2] <<buf[3] <<buf[4] <<buf[5] <<buf[6] <<buf[7];
-qDebug() <<buf[8] <<buf[9] <<buf[10] <<buf[11] <<buf[12] <<buf[13]<<buf[14]<<buf[15];
-qDebug() <<buf[16] <<buf[17] <<buf[18] <<buf[19] <<buf[20] <<buf[21]<<buf[22]<<buf[23];
-qDebug() <<buf[24] <<buf[25] <<buf[26] <<buf[27] <<buf[28] <<buf[29]<<buf[30]<<buf[31];
-qDebug() <<buf[32] <<buf[33] <<buf[34] <<buf[35] <<buf[36] <<buf[37]<<buf[38]<<buf[39];
-qDebug() <<buf[40] <<buf[41] <<buf[42] <<buf[43] <<buf[44] <<buf[45]<<buf[46]<<buf[47];
-qDebug() <<buf[48] <<buf[49] <<buf[50] <<buf[51] <<buf[52] <<buf[53] <<buf[54]<<buf[55];
-qDebug() <<buf[56] <<buf[57] <<buf[58] <<buf[59] <<buf[60] <<buf[61] <<buf[62]<<buf[63];
-qDebug() <<buf[64] <<buf[65] <<buf[66] <<buf[67] <<buf[68] <<buf[69] <<buf[70]<<buf[71];
-qDebug() <<buf[72] <<buf[73] <<buf[74] <<buf[75] <<buf[76] <<buf[77] <<buf[78]<<buf[79];
-*/
-}
-
-void T_prot::receiveFixLen(int64_t nrOfbytesToReceive)
-{
-    mySerialPort->receiveFixLen(nrOfbytesToReceive);
-}
-
-void T_prot::sendUserData(uint16_t slaveAdr)
-{
-    // man könnte hier noch "SendDataValid" abfragen,
-    // muss immer 3 sein, muss man aber nicht
-
-    //qDebug()  << "prot send user data "<<slaveAdr;
-    QByteArray  packBuf_2;
-    slaveAddr=slaveAdr;
-
-    if (WriteCommand==0xFFFF)
-    {
-        // Bypass for bootloader, no protocol frame but send as is...
-        packBuf_2.clear();
-        for (int nn=0; nn<BLsendDataLength; nn++)
-            packBuf_2[nn]=char(ui8BLsendData[nn]);        
-        mySerialPort->writeToSerial(packBuf_2, BLsendDataLength);
-
-
-    } else
-        startFastPacking();     // quicker since 15.12.21TS
-        //startPacking();
-}
-
-void T_prot::startFastPacking(void)
-{
-    uint16_t  mycrc;
-    uint16_t  sendLen;
-    uint8_t   uctmp, nn, pp, CrcLp;
-    char      sendBuffer[FRAME_MAXLEN], ctmp;
-
-    //qDebug()  << "prot start fast packing "<<slaveAddr;
-
-    for (int nn=0; nn<FRAME_MAXLEN; nn++)
-        sendBuffer[nn]=0;
-
-    if (WriteCommand>9 && WriteCommand<100)
-    {
-        // long command 10...99
-        // WriteCommand==0 if only read request, then use short sending
-        sendBuffer[0]=STARTSIGN_SEND_LONG;
-        WrDataLength=DATALEN_SEND_LONG;    // immer
-        //qDebug()  << "send long cmd, len: " << WrDataLength;
-    } else
-    {
-        // fast command
-        sendBuffer[0]=STARTSIGN_SEND_FAST;
-        WrDataLength=DATALEN_SEND_FAST;    // immer
-        //qDebug()  << "send fast cmd, len: " << WrDataLength;
-    }
-    sendBuffer[1]= uint8_t(WriteCommand);
-    sendBuffer[2]= uint8_t(ReadCommand);
-    if (WriteAddr>0)
-        sendBuffer[3]= char(WriteAddr);  // bei fast nur EINE adresse, wr hat Vorrang
-    else
-        sendBuffer[3]= char(ReadAddr);
-    // beim Fast prot. ist das reserve dann ists egal was drin steht
-
-    if (kindOfData)   // 0: binaries, 1:text
-    {
-        for (nn=0; nn<WrDataLength; nn++)
-        {
-            pp=HEADERLEN_SEND+nn;
-            ctmp=(chOut_Data[nn]);      // text
-            sendBuffer[pp]= char(ctmp);
-        }
-
-    } else
-    {
-        for (nn=0; nn<WrDataLength; nn++)
-        {
-            pp=HEADERLEN_SEND+nn;
-            uctmp=(ui8OutputData[nn]);      // bin
-            sendBuffer[pp]= char(uctmp);
-        }
-    }
-
-    CrcLp= HEADERLEN_SEND + WrDataLength;
-    mycrc=0;
-    for (nn=0; nn<CrcLp; nn++)
-    {
-        uctmp=sendBuffer[nn];
-        mycrc+=uint16_t(uctmp);
-        //qDebug() << mycrc;
-    }
-    sendBuffer[CrcLp]=char(mycrc);
-    mycrc>>=8;
-    sendBuffer[CrcLp+1]=char(mycrc);
-    sendLen=CrcLp+2;
-
-    // send to VCP:
-    QByteArray  packBuff;
-    packBuff.clear();
-    packBuff.append(sendBuffer, sendLen);  // ohne sendLen wird beim ersten \0 abgeschnitten!!!
-    mySerialPort->writeToSerial(packBuff, sendLen);
-
-}
-
-/*
-void T_prot::startPacking(void)
-{
-    uint16_t  mycrc;
-    uint16_t  uitmp, sendLen;
-    uint8_t   uctmp, nn, pp, CrcLp;
-    char     sendBuffer[FRAME_MAXLEN], ctmp;
-    
-    //qDebug()  << "prot start packing "<<slaveAddr;
-
-    for (int nn=0; nn<FRAME_MAXLEN; nn++)
-        sendBuffer[nn]=0;
-
-    sendBuffer[0]='>';
-    uitmp=slaveAddr;
-    sendBuffer[1]= char(uitmp);
-    uitmp>>=8;
-    sendBuffer[2]= char(uitmp);
-
-    uitmp=WriteCommand;
-    sendBuffer[3]= char(uitmp);
-    uitmp>>=8;
-    sendBuffer[4]= char(uitmp);
-
-    uitmp=WriteAddr;
-    sendBuffer[5]= char(uitmp);
-    uitmp>>=8;
-    sendBuffer[6]= char(uitmp);
-
-    uitmp=ReadCommand;
-    sendBuffer[7]= char(uitmp);
-    uitmp>>=8;
-    sendBuffer[8]= char(uitmp);
-
-    uitmp=ReadAddr;
-    sendBuffer[9]= char(uitmp);
-    uitmp>>=8;
-    sendBuffer[10]= char(uitmp);
-
-    uitmp=reserve;
-    sendBuffer[11]= '-';    //char(uitmp);
-    uitmp>>=8;
-    sendBuffer[12]= '-';    //char(uitmp);
-
-    sendBuffer[13]= char(WrDataLength);
-    CrcLp= 14 + WrDataLength;
-
-    if (kindOfData)   // 0: binaries, 1:text
-    {
-        for (nn=0; nn<WrDataLength; nn++)
-        {
-            pp=14+nn;
-            ctmp=(chOut_Data[nn]);
-            sendBuffer[pp]= ctmp;
-        }
-
-    } else
-    {
-        for (nn=0; nn<WrDataLength; nn++)
-        {
-            pp=14+nn;
-            uctmp=(ui8OutputData[nn]);
-            sendBuffer[pp]= char(uctmp);
-        }
-    }
-
-    mycrc=0;
-    for (nn=0; nn<CrcLp; nn++)
-    {
-        uctmp=sendBuffer[nn];
-        mycrc+=uint16_t(uctmp);
-        //qDebug() << mycrc;
-    }
-    sendBuffer[CrcLp]=char(mycrc);
-    mycrc>>=8;
-    sendBuffer[CrcLp+1]=char(mycrc);
-    sendLen=CrcLp+2;
-
-    sendBuffer[CrcLp+2]=13;
-    sendBuffer[CrcLp+3]=10;
-    sendLen+=2;
-
-    // send to VCP:
-    QByteArray  packBuff;
-    packBuff.clear();
-    packBuff.append(sendBuffer, sendLen);  // ohne sendLen wird beim ersten \0 abgeschnitten!!!
-    mySerialPort->writeToSerial(packBuff, sendLen);
-    // void T_com::writeToSerial(const QByteArray &data, uint16_t sendLength)
-}
-*/
-
-// ---------------------------------------------------------------------------------------------------------
-// receiving.....
-// ---------------------------------------------------------------------------------------------------------
-
-
-void T_prot::analyseRecData(void)
-{
-    // Aufruf per connect aus serialcontrol wenn Daten empfangen wurden
-    // getRecData(QByteArray &data, uint16_t &sendLength);
-
-    QByteArray Indata;
-    QString myString, tempStr;
-//char recBuffer[FRAME_MAXLEN];
-uint8_t recBuffer[FRAME_MAXLEN];
-
-    uint16_t recLength;
-
-    INdataValid=false;
-    gpi_setTxt4HsStateLine("");
-    gpi_setTxt4masterStateLine("");
-    gpi_setTxt4resultStateLine("");
-    gpi_setTxt4dataStateLine("");
-    gpi_setTxt4datifLine("");
-
-    // read from "VCP":
-    mySerialPort->readFromSerial(Indata, recLength);
-//qDebug()<<"prot: got data " << recLength;
-    if (recLength>FRAME_MAXLEN)
-        recLength=FRAME_MAXLEN;
-    for (int nn=0; nn<recLength; nn++)
-        recBuffer[nn]=uint8_t(Indata[nn]);
-
-    myString.clear();
-    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)
-    if (result>0)
-    {
-        // dann anzeige
-        switch (result)
-        {
-          case 1: gpi_setTxt4masterStateLine("wrong length received"); break;
-          case 2: gpi_setTxt4masterStateLine("wrong start sign received"); break;
-          case 3: gpi_setTxt4masterStateLine("received datalen too big"); break;
-          case 4: gpi_setTxt4masterStateLine("wrong data len received"); break;
-          case 5: gpi_setTxt4masterStateLine("wrong crc received"); break;
-
-        }
-        myString.setNum(result);
-
-        // Daten abspeichern, könnten vom BL sein:
-        gpi_storeRawReceivedData(uint8_t(recLength), recBuffer);
-        emit rawDataRecieved();
-
-    } else
-    {
-        //& result ==0
-        gpi_setTxt4masterStateLine("slave response OK");
-        // Daten OK, also prüfe Inhalt.
-        // Konnte der Slave das Master-Command verwenden oder hatte es Fehler?
-        // konnte der Slave die geforderten Daten ausgeben (DOs, AOs)?
-        // konnte der Slave die geforderten Daten einlesen (AIs, DIs)?
-
-        //CheckInResult(recBuffer);    // Ergebnisse des Slaves anzeigen
-            // stimmt nicht mehr bei FastProt
-
-        ShowFastInData(recBuffer);    // Eingangs-Daten des Slaves anzeigen
-     }
-    emit framerecieved();
-    //qDebug() << "framereceived emitted";
-}
-
-
-uint8_t T_prot::FastCheckInData(uint8_t *Inbuf, uint16_t LL)
-{
-
-    uint16_t rawInLen=LL, crcL_Addr, recCrc, myCrc, nn, datalen, nxt;
-
-    if (Inbuf[0]!=STARTSIGN_RECEIVE_FAST && Inbuf[0]!=STARTSIGN_RECEIVE_LONG)
-    {
-        //qDebug() << "prot: got wrong start sign: " << Inbuf[0];
-        return 2;       // wrong start sign
-    }
-    if ( (rawInLen<TELEGRAMLEN_RECEIVE_FAST && Inbuf[0]==STARTSIGN_RECEIVE_FAST) ||
-         (rawInLen<TELEGRAMLEN_RECEIVE_LONG && Inbuf[0]==STARTSIGN_RECEIVE_LONG)   )
-    {
-        //qDebug("prot: got %d bytes only", rawInLen);
-        return 1;       // wrong length
-    }
-    if (Inbuf[0]==0x5F)
-        datalen=DATALEN_RECEIVE_FAST;
-    else
-        datalen=DATALEN_RECEIVE_LONG;
-
-    crcL_Addr=datalen+HEADERLEN_RECEIVE;  // weil im definierten protocol 2 bytes vor den Daten stehen
-    recCrc=0;
-    recCrc=uchar2uint(uint8_t(Inbuf[crcL_Addr+1]), uint8_t(Inbuf[crcL_Addr]));
-    myCrc=0;
-    for (nn=0; nn<crcL_Addr; nn++)
-    {
-        nxt=uint16_t (Inbuf[nn]);
-        nxt &=0x00FF;   // the casting makes 0xFFFF out of 0xFF !!!!!!!!!
-        myCrc+=nxt;
-        //qDebug("CRC: nxt: %d  sum: %d", nxt, myCrc);
-    }
-
-    if (myCrc != recCrc)
-    {
-        //qDebug() << "crc does not match:   mycrc=" << myCrc<< "   receivedCRC=" << recCrc;
-        //qDebug("calculated over %d bytes", crcL_Addr);
-        return 5;       // crc wrong
-    }
-    return 0;
-}
-
-/*
-uint8_t T_prot::FramecheckInData(uint8_t *Inbuf, uint16_t LL)
-{
-
-    uint16_t rawInLen=LL, crcL_Addr, recCrc, myCrc, nn, datalen, nxt;
-
-    if (rawInLen<12)
-    {
-        qDebug("prot: got %d bytes only", rawInLen);
-        return 1;       // wrong length
-    }
-
-    if ( Inbuf[0] != '<')
-        return 2;       // wrong start sign
-
-    datalen=uint16_t(Inbuf[9]);
-    if ( datalen > FRAME_DATALEN)  //[9]=reported data lenght
-        return 3;       // reported datalen too big
-
-    if ((datalen !=(rawInLen-12)) && (datalen !=(rawInLen-13)) && (datalen !=(rawInLen-14)) )
-    {
-        // angehängtes CR und/oder LF tolerieren
-        qDebug() << "wrong data length, " << datalen << " " << rawInLen;
-        return 4;       // data len does not match to complete length
-
-    }
-    crcL_Addr=datalen+10;  // weil im definierten protocol 10 bytes vor den Daten stehen
-    recCrc=0;
-
-    recCrc=uchar2uint(uint8_t(Inbuf[crcL_Addr+1]), uint8_t(Inbuf[crcL_Addr]));
-    myCrc=0;
-    for (nn=0; nn<crcL_Addr; nn++)
-    {
-        nxt=uint16_t (Inbuf[nn]);
-        nxt &=0x00FF;   // the casting makes 0xFFFF out of 0xFF !!!!!!!!!
-        myCrc+=nxt;
-        //qDebug("CRC: nxt: %d  sum: %d", nxt, myCrc);
-
-    }
-
-    if (myCrc != recCrc)
-    {
-        qDebug() << "crc does not match:   mycrc=" << myCrc<< "   receivedCRC=" << recCrc;
-        qDebug("calculated over %d bytes", crcL_Addr);
-        return 5;       // crc wrong
-    }
-    return 0;
-}
-*/
-
-uint8_t T_prot::CheckInResult(uint8_t *Inbuf)
-{
-    char slaveresult;
-    QString myString=nullptr, tempStr=nullptr;
-
-    // slave results anzeigen
-
-    slaveresult=Inbuf[2];    // hier steht das "Command Result" des slaves,
-                            // d.h das Ergebnis der Protokol-Prüfung (Master->Slave)
-    switch (slaveresult)
-    {
-//        received message (from master) analysis:
-//        0: got valid request
-// this errors can only come back from a single device (not bus)
-// or from a bus slave in local mode
-//        1: wrong start     2: wrong length
-//        3: wrong crc       4: wrong addr
-
-        case 1: gpi_setTxt4resultStateLine("slave got wrong start sign"); break;
-        case 2: gpi_setTxt4resultStateLine("slave got wrong length"); break;
-        case 3: gpi_setTxt4resultStateLine("slave got wrong crc"); break;
-        case 4: gpi_setTxt4resultStateLine("slave got wrong addr"); break;
-
-        case 10: gpi_setTxt4resultStateLine("slave is in local mode"); break;
-        case 13: gpi_setTxt4resultStateLine("local mode with wrong crc"); break;
-        case 14: gpi_setTxt4resultStateLine("local mode with wrong addr"); break;
-           // wenn 1..4 dann konnte der Slave das Mastertelegramm gar nicht verwenden, also hier Stoppen
-    }
-    if (slaveresult>0 && slaveresult<10)
-        return 1;
-
-    // Slave hat gültiges Kommando empfangen:
-    // 2.result auswerten:
-    // recBuffer[3];   // Write result, d.h. Ergebnis des Schreibvorganges (z.B. DOs) des Slaves
-    // recBuffer[4];   // Read result, d.h. Ergebnis des Lesevorganges (z.B. DIs) des Slaves
-    // bisher nicht bekannt welche Fehlercodes es gibt, also den code direkt ausgeben.
-    // bisher bekannt: 0=OK
-
-    myString.clear();
-    myString = "Slave OUT and IN Result: ";
-    tempStr.setNum(Inbuf[3],16);
-    myString.append(tempStr);
-    myString.append(" ");
-    tempStr.setNum(Inbuf[4],16);
-    myString.append(tempStr);
-    gpi_setTxt4resultStateLine(myString);
-    return 0;
-}
-
-
-
-uint8_t T_prot::ShowFastInData(uint8_t *recBuffer)
-{
-    QString myString=nullptr, tempStr=nullptr;
-    uint8_t result;
-
-    RecSlaveAddr=0;
-    result=recBuffer[1];    // total result
-    result &=0x60;          // only read result (bit 5,6)
-
-    if (result==0)     // read result =OK,
-                       // dann sind die Eingangsdaten gültig
-    {
-        myString.append("valid INdata: ");
-        INdataValid=true;
-        //readSource   already set with sending
-        readAddress=0;
-        // RdDataLength already set with sending
-        if (RdDataLength>FRAME_DATALEN)
-            RdDataLength=FRAME_DATALEN;
-        for (int ii=0; ii<RdDataLength; ii++)
-            InputData[ii]=uint8_t(recBuffer[ii+HEADERLEN_RECEIVE]);
-
-        tempStr.setNum(readSource,16);
-        myString.append(tempStr);
-        myString.append(" add:");
-
-        tempStr.setNum(readAddress);
-        myString.append(tempStr);
-        //myString.append(" wakeSrc:");
-        //tempStr.setNum(lastWakeSrc);
-        //myString.append(tempStr);
-        myString.append(" Dlen:");
-        tempStr.setNum(RdDataLength);
-        myString.append(tempStr);        
-
-    } else
-    {
-        myString=" ";   // Eingangsdaten nicht gültig, sieht man aber weiter oben schon
-
-    }
-
-    gpi_setTxt4dataStateLine(myString);
-    //qDebug() << myString;
-    //qDebug("prot_checkInData_bindata: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
-    //        InputData[0], InputData[1], InputData[2], InputData[3],
-    //        InputData[4], InputData[5], InputData[6], InputData[7],
-    //        InputData[8], InputData[9], InputData[10], InputData[11],
-    //        InputData[12], InputData[13], InputData[14], InputData[15]);
-    return 0;
-}
-
-/*
-
-uint8_t T_prot::ShowInData(uint8_t *recBuffer)
-{
-    QString myString=nullptr, tempStr=nullptr;
-
-    RecSlaveAddr=recBuffer[1];
-    if (recBuffer[2]==0 && recBuffer[4]==0)     // comand result=OK und read result =OK,
-                                                // dann sind die Eingangsdaten gültig
-    {
-        myString.append("valid INdata: ");
-        INdataValid=true;
-        readSource=uchar2uint(recBuffer[6],recBuffer[5]);
-        readAddress=uchar2uint(recBuffer[8],recBuffer[7]);
-        //lastWakeSrc=uint8_t(recBuffer[4]);
-        RdDataLength=uint8_t(recBuffer[9]);
-        if (RdDataLength>FRAME_DATALEN)
-            RdDataLength=FRAME_DATALEN;
-        for (int ii=0; ii<RdDataLength; ii++)
-            InputData[ii]=uint8_t(recBuffer[ii+10]);
-
-        tempStr.setNum(readSource,16);
-        myString.append(tempStr);
-        myString.append(" add:");
-
-        tempStr.setNum(readAddress);
-        myString.append(tempStr);
-        //myString.append(" wakeSrc:");
-        //tempStr.setNum(lastWakeSrc);
-        //myString.append(tempStr);
-        myString.append(" Dlen:");
-        tempStr.setNum(RdDataLength);
-        myString.append(tempStr);
-
-    } else
-    {
-        myString=" ";   // Eingangsdaten nicht gültig, sieht man aber weiter oben schon
-
-    }
-
-    gpi_setTxt4dataStateLine(myString);
-    //qDebug() << myString;
-    //qDebug("prot_checkInData_bindata: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
-    //        InputData[0], InputData[1], InputData[2], InputData[3],
-    //        InputData[4], InputData[5], InputData[6], InputData[7],
-    //        InputData[8], InputData[9], InputData[10], InputData[11],
-    //        InputData[12], InputData[13], InputData[14], InputData[15]);
-    return 0;
-}
-
-*/
-
-bool T_prot::ifDataReceived()
-{
-    return  INdataValid;
-}
-
-bool T_prot::getReceivedInData(uint8_t  *SlavAddr, uint16_t *readSrc, uint16_t *readAddr,
-                                    uint8_t  *RdDlen, uint8_t *receivedData)
-{
-    uint8_t nn;
-    *SlavAddr=RecSlaveAddr;
-    *readSrc=readSource;        // diese (Eingangs-)Daten stehen im Puffer
-    *readAddr=readAddress;       // von dieser Adr wurden die Daten gelesen
-    //*lastWakSourc=lastWakeSrc;       // falls der Slave den Master geweckt hat
-    *RdDlen=RdDataLength;
-    for (nn=0; nn<FRAME_DATALEN; nn++)
-        receivedData[nn]=0;
-    for (nn=0; nn<RdDataLength; nn++)
-        receivedData[nn]=InputData[nn];
-    return INdataValid;           // nur true wenn CommandState OK und readState OK
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

src/sendWRcmd.cpp

@@ -1,673 +0,0 @@
-#include <stdint.h>
-#include <QString>
-#include <QDebug>
-#include "tslib.h"
-#include "sendWRcmd.h"
-
-
-void indat_PrnPwr(void);
-
-
-void sendWRcmd_INI(void)
-{
-
-    sendWRcmd_clrCmdStack();
-    sendWRcmd_clrCmd4Stack();
-    sendFDcmd_clrStack();
-    longFDcmd_clrStack();
-}
-
-// Command Stack for commands without parameters
-
-
-static uint16_t nextAsynchsendCmd0[CMDSTACKDEPTH];
-static uint8_t  nrOfCmdsInQueue;
-/* convention: use simple (not rotating) FIFO Stack:
-Example: nrOfCmdsInQueue=4 then
-    nextAsynchsendCmd0[0]=cmd1      // was stored as first
-    nextAsynchsendCmd0[1]=cmd2
-    nextAsynchsendCmd0[2]=cmd3
-    nextAsynchsendCmd0[3]=cmd4      // came in as last
-
-    Send: [0] first, then move buffer 1 down:
-    nextAsynchsendCmd0[0]=cmd2
-    nextAsynchsendCmd0[1]=cmd3
-    nextAsynchsendCmd0[2]=cmd4
-    nextAsynchsendCmd0[3]=0;
-    nrOfCmdsInQueue=3 now
-*/
-
-void sendWRcmd_clrCmdStack(void)
-{
-    uint8_t nn;
-    for (nn=0; nn<CMDSTACKDEPTH; nn++)
-        nextAsynchsendCmd0[nn]=0;
-    nrOfCmdsInQueue=0;
-}
-
-bool sendWRcmd_setSendCommand0(uint16_t nextCmd)
-{
-    // write Command to memory, wait for transport
-    if (nrOfCmdsInQueue>=CMDSTACKDEPTH)
-    {
-        qDebug() << "cannot save cmd because stack is full";
-        return false;           // not possible
-    }
-    nextAsynchsendCmd0[nrOfCmdsInQueue++]=nextCmd;
-    //qDebug() << "PI cmd queued:"<< nextCmd << ", saved, pp=" << nrOfCmdsInQueue;
-    return true;                // ok, will be sent
-}
-
-uint16_t sendWRcmd_getSendCommand0(void)
-{
-    uint16_t nxtAsynchCmd;
-    uint8_t nn, ll;
-    if (nrOfCmdsInQueue==0 || nrOfCmdsInQueue>CMDSTACKDEPTH)
-        return 0;   // error
-    nxtAsynchCmd=nextAsynchsendCmd0[0];
-
-    // move Puffer down by one element
-    if (CMDSTACKDEPTH>0)
-        ll=CMDSTACKDEPTH-1;
-    else
-        ll=0;
-    for (nn=0; nn<ll; nn++)
-        nextAsynchsendCmd0[nn]=nextAsynchsendCmd0[nn+1];
-
-    if (nrOfCmdsInQueue>0)
-        nrOfCmdsInQueue--;
-    //qDebug() << "PI cmd queued:"<< nxtAsynchCmd << ", restored, pp now =" << nrOfCmdsInQueue;
-    return nxtAsynchCmd;
-}
-
-//---------------------------------------------------------------------------------------------------------------------
-//---------------------------------------------------------------------------------------------------------------------
-// Command Stack for commands with 4 parameters
-
-
-
-static uint16_t nextAsynchsendCmd4[CMD4STACKDEPTH];
-static uint8_t  nextCmd4para1[CMD4STACKDEPTH];
-static uint8_t  nextCmd4para2[CMD4STACKDEPTH];
-static uint8_t  nextCmd4para3[CMD4STACKDEPTH];
-static uint8_t  nextCmd4para4[CMD4STACKDEPTH];
-static uint8_t  nrOfCmds4InQueue;
-/* convention: use simple (not rotating) FIFO Stack:
-Example: nrOfCmdsInQueue=4 then
-    nextAsynchsendCmd0[0]=cmd1      // was stored as first
-    nextAsynchsendCmd0[1]=cmd2
-    nextAsynchsendCmd0[2]=cmd3
-    nextAsynchsendCmd0[3]=cmd4      // came in as last
-
-    Send: [0] first, then move buffer 1 down:
-    nextAsynchsendCmd0[0]=cmd2
-    nextAsynchsendCmd0[1]=cmd3
-    nextAsynchsendCmd0[2]=cmd4
-    nextAsynchsendCmd0[3]=0;
-    nrOfCmdsInQueue=3 now
-*/
-
-
-void sendWRcmd_clrCmd4Stack(void)
-{
-    uint8_t nn;
-    for (nn=0; nn<CMD4STACKDEPTH; nn++)
-    {
-        nextAsynchsendCmd4[nn]=0;
-        nextCmd4para1[nn]=0;
-        nextCmd4para2[nn]=0;
-        nextCmd4para3[nn]=0;
-        nextCmd4para4[nn]=0;
-    }
-    nrOfCmds4InQueue=0;
-}
-
-bool sendWRcmd_setSendCommand4(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
-{
-    // write Command to memory, wait for transport
-    if (nrOfCmds4InQueue>=CMD4STACKDEPTH)
-    {
-        qDebug() << "cannot save cmd because stack is full";
-        return false;           // not possible
-    }
-    nextAsynchsendCmd4[nrOfCmds4InQueue]=nextCmd;
-    nextCmd4para1[nrOfCmds4InQueue]=dat1;
-    nextCmd4para2[nrOfCmds4InQueue]=dat2;
-    nextCmd4para3[nrOfCmds4InQueue]=dat3;
-    nextCmd4para4[nrOfCmds4InQueue]=dat4;
-    //qDebug() << "data with 4 data byte saved, pp=" << nrOfCmds4InQueue;
-    //qDebug() << " dat1=" << nextCmd4para1[nrOfCmds4InQueue] << " dat2=" << nextCmd4para2[nrOfCmds4InQueue]
-    //             << " dat3=" << nextCmd4para3[nrOfCmds4InQueue]  << " dat4=" << nextCmd4para4[nrOfCmds4InQueue];
-    nrOfCmds4InQueue++;
-    return true;                // ok, will be sent
-}
-
-uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
-{
-    uint16_t nxtAsynchCmd;
-    uint8_t nn, ll;
-
-    if (nrOfCmds4InQueue==0 || nrOfCmds4InQueue>CMD4STACKDEPTH)
-        return 0;   // error
-    nxtAsynchCmd=nextAsynchsendCmd4[0];
-    *dat1=nextCmd4para1[0];
-    *dat2=nextCmd4para2[0];
-    *dat3=nextCmd4para3[0];
-    *dat4=nextCmd4para4[0];
-    //qDebug() << "cmd4  restored to send from [0];  pp=" << nrOfCmds4InQueue;
-    //qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
-    //            " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
-
-    // move Puffer down by one element
-        if (CMD4STACKDEPTH>0)
-        ll=CMD4STACKDEPTH-1;
-    else
-        ll=0;
-    for (nn=0; nn<ll; nn++)
-    {
-        nextAsynchsendCmd4[nn]=nextAsynchsendCmd4[nn+1];
-        nextCmd4para1[nn]=nextCmd4para1[nn+1];
-        nextCmd4para2[nn]=nextCmd4para2[nn+1];
-        nextCmd4para3[nn]=nextCmd4para3[nn+1];
-        nextCmd4para4[nn]=nextCmd4para4[nn+1];
-    }
-    if (nrOfCmds4InQueue>0)
-        nrOfCmds4InQueue--;
-    //qDebug() << "cmd4  after push down: pp=" << nrOfCmds4InQueue;
-    return nxtAsynchCmd;
-}
-
-
-
-
-
-static uint16_t  nextAsynchsendCmd8[CMD8STACKDEPTH];
-static uint8_t   nextCmd8para1[CMD8STACKDEPTH];
-static uint8_t   nextCmd8para2[CMD8STACKDEPTH];
-static uint16_t  nextCmd8para3[CMD8STACKDEPTH];
-static uint32_t  nextCmd8para4[CMD8STACKDEPTH];
-static uint8_t   nrOfCmds8InQueue;
-
-void sendWRcmd_clrCmd8Stack(void)
-{
-    uint8_t nn;
-    for (nn=0; nn<CMD8STACKDEPTH; nn++)
-    {
-        nextAsynchsendCmd8[nn]=0;
-        nextCmd8para1[nn]=0;
-        nextCmd8para2[nn]=0;
-        nextCmd8para3[nn]=0;
-        nextCmd8para4[nn]=0;
-    }
-    nrOfCmds8InQueue=0;
-}
-
-bool sendWRcmd_setSendCommand8(uint16_t nextCmd, uint8_t dat1, uint8_t dat2, uint16_t dat3, uint32_t dat4)
-{
-    // write Command to memory, wait for transport
-    if (nrOfCmds8InQueue>=CMD8STACKDEPTH)
-    {
-        qDebug() << "cannot save cmd because stack is full";
-        return false;           // not possible
-    }
-    nextAsynchsendCmd8[nrOfCmds8InQueue]=nextCmd;
-    nextCmd8para1[nrOfCmds8InQueue]=dat1;
-    nextCmd8para2[nrOfCmds8InQueue]=dat2;
-    nextCmd8para3[nrOfCmds8InQueue]=dat3;
-    nextCmd8para4[nrOfCmds8InQueue]=dat4;
-    nrOfCmds8InQueue++;
-    return true;                // ok, will be sent
-}
-
-uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3, uint32_t *dat4)
-{
-    uint16_t nxtAsynchCmd;
-    uint8_t nn, ll;
-
-    if (nrOfCmds8InQueue==0 || nrOfCmds8InQueue>CMD8STACKDEPTH)
-        return 0;   // error
-    nxtAsynchCmd=nextAsynchsendCmd8[0];
-    *dat1=nextCmd8para1[0];
-    *dat2=nextCmd8para2[0];
-    *dat3=nextCmd8para3[0];
-    *dat4=nextCmd8para4[0];
-
-    // move buffer down by one element
-    if (CMD8STACKDEPTH>0)
-        ll=CMD8STACKDEPTH-1;
-    else
-        ll=0;
-    for (nn=0; nn<ll; nn++)
-    {
-        nextAsynchsendCmd8[nn]=nextAsynchsendCmd8[nn+1];
-        nextCmd8para1[nn]=nextCmd8para1[nn+1];
-        nextCmd8para2[nn]=nextCmd8para2[nn+1];
-        nextCmd8para3[nn]=nextCmd8para3[nn+1];
-        nextCmd8para4[nn]=nextCmd8para4[nn+1];
-    }
-    if (nrOfCmds8InQueue>0)
-        nrOfCmds8InQueue--;
-    return nxtAsynchCmd;
-}
-
-
-
-
-
-
-
-static uint8_t sendAsynchDataBuf[160]; // no stack, only ONE buffer
-static uint8_t sendAsyDatLen;
-
-bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t *buf)
-{
-    //qDebug()  << "pi epi: storing send data";
-    if (leng>160) leng=160;
-    sendAsyDatLen=leng;
-    tslib_strclr(sendAsynchDataBuf, 0, 160);
-    for (uint8_t nn=0; nn<leng; nn++)
-        sendAsynchDataBuf[nn]=buf[nn];
-    return true;                // ok, will be sent
-}
-
-uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf)
-{
-    //qDebug()  << "pi gpi: restoring send data";
-    *leng=sendAsyDatLen;
-    for (uint8_t nn=0; nn<sendAsyDatLen; nn++)
-        buf[nn]=sendAsynchDataBuf[nn];
-    sendAsyDatLen=0;
-    //tslib_strclr(sendAsynchDataBuf, 0, 64);
-    return *leng;
-}
-
-
-// ------------------------------------------------------------------------------------
-// MDB Sendind Data  are store here for next transport to DC (Device Controller)
-// Transport to Slave runs every 100ms, answer from mdb-slave (e.g. coin changer) comes rigth
-// with next slave answer
-
-// start with: SENDDIRCMD_EXCHGMDB,
-    // send crude data from here to DC, DC to mdb slaves, mdb answer, return here within 50ms
-
-
-static uint8_t Sdata_mdbSendBuffer[64];
-static uint8_t Sdata_mdbSendLen;
-
-uint8_t epi_store64ByteSendData(uint8_t length, uint8_t *buf)
-{
-    // HWapi writes data to be forwarded to DC and further to mdb-device
-    for (uint8_t nn=0; nn<length; nn++)
-        Sdata_mdbSendBuffer[nn]=buf[nn];
-    Sdata_mdbSendLen=length;
-    return 0;
-}
-
-uint8_t gpi_restore64ByteSendData(uint8_t *length, uint8_t *buf)
-{
-    // datif reads data to forward to dc
-    for (uint8_t nn=0; nn<Sdata_mdbSendLen; nn++)
-        buf[nn]=Sdata_mdbSendBuffer[nn];
-    *length=Sdata_mdbSendLen;
-    Sdata_mdbSendLen=0;
-    return 0;
-}
-
-
-
-
-
-
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//---------------------------------------- Printer Text Fifo -------------------------
-static uint8_t prnDataParameters[4];
-static uint8_t prnDataBufferUser;
-
-void epi_storeUserOfSendingTextBuffer(uint8_t user, uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4 )
-{
-    // user=1: Text-Print is using this buffer
-    //      2: QR-code-Printer is using this buffer
-    prnDataBufferUser=user;
-    prnDataParameters[0]=para1;
-    prnDataParameters[1]=para2;
-    prnDataParameters[2]=para3;
-    prnDataParameters[3]=para4;
-
-//    qDebug() << "new user stored: " << user;
-
-}
-
-uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *para3, uint8_t *para4)
-{
-    // user=1: Text-Print is using this buffer
-    //      2: QR-code-Printer is using this buffer
-    //qDebug() << "returning user "<< prnDataBufferUser;
-
-    *para1=prnDataParameters[0];
-    *para2=prnDataParameters[1];
-    *para3=prnDataParameters[2];
-    *para4=prnDataParameters[3];
-    return prnDataBufferUser;
-
-}
-
-
-    // Sending Text Fifo
-// ONE printer doc consists of 20 x 64 byte
-// #define MAXNROF_PRNBYTES   64
-// #define MAXNROF_PRNBLOCKS  20
-static char Sdata_PRN_TEXT[MAXNROF_PRNBLOCKS][MAXNROF_PRNBYTES];
-static uint8_t pPrnDataBuff;        // points to next PRINTER_BLOCK
-
-
-//static uint8_t pPrnDataBuff;        // points to next waiting printer text
-//  defined above, needed if more then one text is stored (before sent)
-// every block will be sent after 100ms, if 8 blocks are stored within this 100ms
-// then pointer goes up to 8. Important: FIFO!!!!!!!!
-
-void epi_resetPrinterStack(void)
-{
-    pPrnDataBuff=0;
-}
-
-uint8_t epi_storePrnText(char *buf, uint8_t leng)
-{
-    // store text from Gui in next higher free memory 0....9
-
-    uint16_t len;
-    uint8_t  pp, nn;
-
-    pp=pPrnDataBuff;    // next free memory block with 64byte each
-    if (pp>=MAXNROF_PRNBLOCKS)
-        return 1;   // not possible, no free mem
-
-    //len=tslib_strlen(buf);    // kennt keine Binärzeichen!!!!!!
-    len=leng;
-    if (len>MAXNROF_PRNBYTES)
-        len=MAXNROF_PRNBYTES;
-
-    tslib_strclr(Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
-
-    for (nn=0; nn<len; nn++)
-        Sdata_PRN_TEXT[pp][nn]=buf[nn];     // copy new text into buffer
-
-    if (pPrnDataBuff<MAXNROF_PRNBLOCKS)
-        pPrnDataBuff++;                     // inc pointer if end not yet reached
-    return 0;       // OK
-}
-
-
-
-uint8_t gpi_restorePrnText(uint8_t *retbuf)
-{
-    // read printer text and send to slave, size of retbuf == 64
-
-    // always read from [0] because this is the oldest (Fifo)
-    // then move all text lines down by one and dec pointer
-
-    uint8_t  nn, pp=pPrnDataBuff;
-
-    if (pp==0)    // next free memory block with 64byte each
-        return 1;           // no text in buffer
-
-    // example: pp=5: then buffers [0...4] are occupied
-
-    for (nn=0; nn<MAXNROF_PRNBYTES; nn++)
-        retbuf[nn] = uint8_t (Sdata_PRN_TEXT[0][nn]);     // restore oldest text
-
-    // now copy textline [1] to [0], then
-    // copy textline [2] to [1], then
-    // copy textline [3] to [2] .... upto [pp-1] to [pp-2]
-    // hint: copying from 9....0 would delete all strings!!!!!!
-
-    for (nn=0; nn<(pp-1); nn++)
-        tslib_strcpy(Sdata_PRN_TEXT[nn+1], Sdata_PRN_TEXT[nn], MAXNROF_PRNBYTES);
-    if (pPrnDataBuff>0)
-        pPrnDataBuff--;
-    pp=pPrnDataBuff;
-    // example: pp=4: then buffers [0...3] are still occupied, pp=0: all buffers empty
-
-    // now clear highest copyed line (which got free now)
-    tslib_strclr(Sdata_PRN_TEXT[pp], 0, MAXNROF_PRNBYTES);
-
-    // optionally: clear all remaining higher lines:
-    for (nn=(pp+1); nn<MAXNROF_PRNBLOCKS; nn++)
-         tslib_strclr(Sdata_PRN_TEXT[nn], 0, MAXNROF_PRNBYTES);
-
-    return 0;
-}
-
-uint8_t gpi_chk4remainingText(void)
-{
-    // retval: 0: no more textline left (to send)  >0: nr of 64byte-blocks
-    return (pPrnDataBuff);
-}
-
-
-
-
-
-
-
-
-
-
-// ---------------------------------------------------------------------------------
-//   11.4.23 neu, Kommando direkt an "FastDevice"-protokoll senden, nicht mehr umsetzen
-// ---------------------------------------------------------------------------------
-
-
-// short command, 4 data bytes
-static uint8_t nextFDwrCmd[FDCMD_STACKDEPTH];
-static uint8_t nextFDrdCmd[FDCMD_STACKDEPTH];
-static uint8_t nextFDblkNr[FDCMD_STACKDEPTH];
-
-static uint8_t  nextFDpara1[FDCMD_STACKDEPTH];
-static uint8_t  nextFDpara2[FDCMD_STACKDEPTH];
-static uint8_t  nextFDpara3[FDCMD_STACKDEPTH];
-static uint8_t  nextFDpara4[FDCMD_STACKDEPTH];
-static uint8_t  p_nextFDcmdsInQueue;
-/* convention: use simple (not rotating) FIFO Stack:
-Example: nrOfCmdsInQueue=4 then
-    nextAsynchsendCmd0[0]=cmd1      // was stored as first
-    nextAsynchsendCmd0[1]=cmd2
-    nextAsynchsendCmd0[2]=cmd3
-    nextAsynchsendCmd0[3]=cmd4      // came in as last
-
-    Send: [0] first, then move buffer 1 down:
-    nextAsynchsendCmd0[0]=cmd2
-    nextAsynchsendCmd0[1]=cmd3
-    nextAsynchsendCmd0[2]=cmd4
-    nextAsynchsendCmd0[3]=0;
-    nrOfCmdsInQueue=3 now
-*/
-
-
-void sendFDcmd_clrStack(void)
-{
-    uint8_t nn;
-    for (nn=0; nn<FDCMD_STACKDEPTH; nn++)
-    {
-        nextFDwrCmd[nn]=0;
-        nextFDrdCmd[nn]=0;
-        nextFDblkNr[nn]=0;
-        nextFDpara1[nn]=0;
-        nextFDpara2[nn]=0;
-        nextFDpara3[nn]=0;
-        nextFDpara4[nn]=0;
-    }
-    p_nextFDcmdsInQueue=0;
-}
-
-bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4)
-{
-    // write Command to memory, wait for transport
-    if (p_nextFDcmdsInQueue>=FDCMD_STACKDEPTH)
-    {
-        qDebug() << "cannot save cmd because stack is full";
-        return false;           // not possible
-    }
-    nextFDwrCmd[p_nextFDcmdsInQueue]=nextWrCmd;
-    nextFDrdCmd[p_nextFDcmdsInQueue]=nextRdCmd;
-    nextFDblkNr[p_nextFDcmdsInQueue]=blockNum;
-    nextFDpara1[p_nextFDcmdsInQueue]=dat1;
-    nextFDpara2[p_nextFDcmdsInQueue]=dat2;
-    nextFDpara3[p_nextFDcmdsInQueue]=dat3;
-    nextFDpara4[p_nextFDcmdsInQueue]=dat4;
-    //qDebug() << "data with 4 data byte saved, pp=" << nrOfCmds4InQueue;
-    //qDebug() << " dat1=" << nextCmd4para1[nrOfCmds4InQueue] << " dat2=" << nextCmd4para2[nrOfCmds4InQueue]
-    //             << " dat3=" << nextCmd4para3[nrOfCmds4InQueue]  << " dat4=" << nextCmd4para4[nrOfCmds4InQueue];
-    p_nextFDcmdsInQueue++;
-    return true;                // ok, will be sent
-}
-
-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 nn, ll;
-
-    if (p_nextFDcmdsInQueue==0 || p_nextFDcmdsInQueue>FDCMD_STACKDEPTH)
-        return false;           // not possible
-
-    *nextWrCmd=nextFDwrCmd[0];
-    *nextRdCmd=nextFDrdCmd[0];
-    *blockNum=nextFDblkNr[0];
-    *dat1=nextFDpara1[0];
-    *dat2=nextFDpara2[0];
-    *dat3=nextFDpara3[0];
-    *dat4=nextFDpara4[0];
-    //qDebug() << "cmd4  restored to send from [0];  pp=" << nrOfCmds4InQueue;
-    //qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
-    //            " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
-
-    // move Puffer down by one element
-    if (FDCMD_STACKDEPTH>0)
-        ll=FDCMD_STACKDEPTH-1;
-    else
-        ll=0;
-    for (nn=0; nn<ll; nn++)
-    {
-        nextFDwrCmd[nn]=nextFDwrCmd[nn+1];
-        nextFDrdCmd[nn]=nextFDrdCmd[nn+1];
-        nextFDblkNr[nn]=nextFDblkNr[nn+1];
-        nextFDpara1[nn]=nextFDpara1[nn+1];
-        nextFDpara2[nn]=nextFDpara2[nn+1];
-        nextFDpara3[nn]=nextFDpara3[nn+1];
-        nextFDpara4[nn]=nextFDpara4[nn+1];
-    }
-    if (p_nextFDcmdsInQueue>0)
-        p_nextFDcmdsInQueue--;
-    //qDebug() << "cmd4  after push down: pp=" << nrOfCmds4InQueue;
-    return true;                // ok, will be sent
-}
-
-uint8_t check4FDshortCmd(void)
-{
-    // 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];
-static uint8_t longFDrdCmd[FDLONG_STACKDEPTH];
-static uint8_t longFDblkNr[FDLONG_STACKDEPTH];
-static uint8_t longFDlength[FDLONG_STACKDEPTH];
-
-static uint8_t  longFDpara[FDLONG_STACKDEPTH][64];
-static uint8_t  p_longFDcmdsInQueue;
-
-
-void longFDcmd_clrStack(void)
-{
-    uint8_t nn, mm;
-    for (nn=0; nn<FDLONG_STACKDEPTH; nn++)
-    {
-        longFDwrCmd[nn]=0;
-        longFDrdCmd[nn]=0;
-        longFDblkNr[nn]=0;
-        longFDlength[nn]=0;
-        for (mm=0; mm<64; mm++)
-            longFDpara[nn][mm]=0;
-    }
-    p_longFDcmdsInQueue=0;
-}
-
-
-bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t length, uint8_t *data)
-{
-    // write Command to memory, wait for transport
-    // data buffer size always 64! data[64], padded with 0
-    uint8_t nn;
-    if (p_longFDcmdsInQueue>=FDLONG_STACKDEPTH)
-    {
-        qDebug() << "cannot save cmd because stack is full";
-        return false;           // not possible
-    }
-    longFDwrCmd[p_longFDcmdsInQueue]=nextWrCmd;
-    longFDrdCmd[p_longFDcmdsInQueue]=nextRdCmd;
-    longFDblkNr[p_longFDcmdsInQueue]=blockNum;
-    longFDlength[p_longFDcmdsInQueue]=length;
-    for (nn=0; nn<64; nn++)
-        longFDpara[p_longFDcmdsInQueue][nn]=data[nn];
-
-    p_longFDcmdsInQueue++;
-    return true;                // ok, will be sent
-}
-
-bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data)
-{
-    uint8_t nn, mm, ll;
-
-    if (p_longFDcmdsInQueue==0 || p_longFDcmdsInQueue>FDLONG_STACKDEPTH)
-        return false;           // not possible
-
-    *nextWrCmd= longFDwrCmd[0];
-    *nextRdCmd= longFDrdCmd[0];
-    *blockNum = longFDblkNr[0];
-    *length   = longFDlength[0];
-    for (mm=0; mm<64; mm++)
-        data[mm] = longFDpara[0][mm];
-
-    // move Puffer down by one element
-    if (FDLONG_STACKDEPTH>0)
-        ll=FDLONG_STACKDEPTH-1;
-    else
-        ll=0;
-    for (nn=0; nn<ll; nn++)
-    {
-        longFDwrCmd[nn]  = longFDwrCmd[nn+1];
-        longFDrdCmd[nn]  = longFDrdCmd[nn+1];
-        longFDblkNr[nn]  = longFDblkNr[nn+1];
-        longFDlength[nn] = longFDlength[nn+1];
-
-        for (mm=0; mm<64; mm++)
-            longFDpara[nn][mm] = longFDpara[nn+1][mm];
-
-    }
-    if (p_longFDcmdsInQueue>0)
-        p_longFDcmdsInQueue--;
-
-    return true;                // ok, will be sent
-}
-
-uint8_t check4FDlongCmd(void)
-{
-    // returns number of waiting command
-    return p_longFDcmdsInQueue;
-}
-
-uint8_t check4freeFDlongCmd(void)
-{
-    // returns number of free places in command stack
-    return FDLONG_STACKDEPTH - p_longFDcmdsInQueue;
-}
-
-

src/shared_mem_buffer.cpp

@@ -1,39 +0,0 @@
-#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

@@ -1,598 +0,0 @@
-#include "tslib.h"
-#include <QThread>
-
-//tslib::tslib()
-//{
-
-
-//}
-
-
-/*
-uint16_t tslib::uchar2uint(uint8_t Highbyte, uint8_t Lowbyte)
-{
-    uint16_t uitmp;
-    uitmp=0;
-    uitmp |= uint8_t(Highbyte);
-    uitmp<<=8;
-    uitmp |= uint8_t(Lowbyte);
-    return uitmp;
-}
-
-uint8_t tslib::uint2uchar(uint16_t uival, bool getHighB)
-{
-    // getHighB: low=GetLowByte
-    uint16_t uitmp=uival;
-    if (getHighB==0)
-        return uint8_t(uitmp);
-    uitmp>>=8;
-    return uint8_t(uitmp);
-
-}*/
-
-uint16_t uchar2uint(char Highbyte, char Lowbyte)
-{
-    uint16_t uitmp;
-    uitmp=0;
-    uitmp |= uint8_t(Highbyte);
-    uitmp<<=8;
-    uitmp |= uint8_t(Lowbyte);
-    return uitmp;
-}
-
-uint16_t uchar2uint(uint8_t Highbyte, uint8_t Lowbyte)
-{
-    uint16_t uitmp;
-    uitmp=0;
-    uitmp |= uint8_t(Highbyte);
-    uitmp<<=8;
-    uitmp |= uint8_t(Lowbyte);
-    return uitmp;
-}
-
-uint32_t uchar2ulong(uint8_t Highbyte, uint8_t MHbyte, uint8_t MLbyte, uint8_t Lowbyte)
-{
-    uint32_t ultmp=0;
-
-    ultmp |= uint8_t(Highbyte);
-    ultmp<<=8;
-    ultmp |= uint8_t(MHbyte);
-    ultmp<<=8;
-    ultmp |= uint8_t(MLbyte);
-    ultmp<<=8;
-    ultmp |= uint8_t(Lowbyte);
-    return ultmp;
-}
-
-uint8_t uint2uchar(uint16_t uival, bool getHighB)
-{
-    // getHighB: low=GetLowByte
-    uint16_t uitmp=uival;
-    if (getHighB==0)
-        return uint8_t(uitmp);
-    uitmp>>=8;
-    return uint8_t(uitmp);
-
-}
-
-
-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));
-}
-
-
-void GetTimeString(uint8_t hours, uint8_t minutes, uint8_t seconds, uint8_t System12h, uint8_t ShowSec, uint8_t *buf)
-{
-	// Zahlenwerte in String wandeln, 12/24h-Format     // 12byte für buf!
-	uint8_t usa;
-	uint16_t  jj;
-	uint8_t hh, mm, ss, with_sec;
-
-        // buf[0]= ganz linkes Zeichen
-    hh=hours;
-    mm=minutes;
-    ss=seconds;
-
-    // 15.10.12, Plausibilitätsprüfung --------------------------------------------------
-    if (hh>23) hh=0;
-    if (mm>59) mm=0;
-    if (ss>59) ss=0;
-
-    with_sec=ShowSec;
-        for (jj=0; jj<12; jj++) buf[jj]=0;
-        usa = System12h; 		// 1:12h   0:24h
-
-    // Stunden:
-        if (usa)
-    {
-        // 12h System
-        if (hh==0 || hh==12)
-        {
-            // 12AM (Mitternacht) oder 12PM (Mittag)
-                buf[0]=0x31;
-                buf[1]=0x32;
-        } else
-        if (hh<12)
-        {
-            // 1..11AM
-                buf[0]=hh/10+0x30;
-                buf[1]=hh%10+0x30;
-        } else
-        {
-            //13:00 bis 23Uhr
-                buf[0]=(hh-12)/10+0x30;
-                buf[1]=(hh-12)%10+0x30;
-        }
-    } else
-    {
-        // 24h System
-        buf[0]=hh/10+0x30;
-        buf[1]=hh%10+0x30;
-    }
-
-    // Minuten:
-    buf[2]=':';
-    buf[3]=mm/10+0x30;
-    buf[4]=mm%10+0x30;
-
-    jj=5;
-    if (with_sec)
-    {
-        buf[jj++]=':';
-        buf[jj++]=ss/10+0x30;
-        buf[jj++]=ss%10+0x30;
-    }
-    if (usa)
-    {
-        buf[jj++]=' ';
-        if (hh<12)
-            buf[jj++]='A';
-        else
-            buf[jj++]='P';
-        buf[jj++]='M';
-    }
-
-}
-
-// -------------------    ********************************************************************************
-
-void GetDateString(uint8_t day, uint8_t month, uint8_t yearhigh, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf)
-{
-	// generate date as ascii string from integers day/month/year
-	// yearhigh: 10..29, in europe always 20 (not in arabia!) comes as hex number, e.g. 0x20
-	// format=  0: dd.mm.yyyy   (deutsch)
-	//          1: mm.dd.yyyy   (amerika)
-    //          2: yyyy.mm.dd   (Iran, Dubai)
-    //          3: dd.yyyy.mm
-    //          4: mm.yyyy.dd
-    //          5: yyyy.dd.mm
-        // sep: 0: use . as seperator   1: use / as seperator
-    // return String in *buf      // 11byte für buf!
-
-
-	uint8_t tag, mon, jahr, d10, d1, m10, m1, y1000, y100, y10, y1;
-	uint8_t slash;
-
-
-    y100= (yearhigh & 0x0F)+0x30;
-    y1000=((yearhigh & 0xF0)>>4)+0x30;
-//    if (yearhigh>=20)
-//    {
-//    	y1000='2';
-//        y100=28+yearhigh;   // '0' + (yearhigh-20)
-//    } else
-//    if (yearhigh<20)
-//    {
-//        y1000='1';
-//        y100=38-yearhigh;   // '9' - (19-yearhigh)
-//    }
-
-    tag=day;
-    mon=month;
-    jahr=yearlow;
-
-    if (mon>12 || mon==0) mon=1;           // 23.10.12
-    if (tag>31 || tag==0) tag=1;
-    if (jahr>50 || jahr<11) jahr=1;
-
-    if (sep==0)
-        slash='.';          // slash==0
-    else if (sep==1)
-        slash='/';
-    else
-    if  (sep>=0x20)
-        slash=sep;
-    else
-        slash='.';
-
-    d10 =tag/10;
-    d1  =tag%10;
-    m10 =mon/10;
-    m1  =mon%10;
-    y10 =jahr/10;
-    y1  =jahr%10;
-
-	d10 +=0x30;    // in Asccii wandeln
-	d1  +=0x30;
-	m10 +=0x30;
-	m1  +=0x30;
-	y10 +=0x30;
-    y1  +=0x30;
-
-	switch (format)
-	{
-		    // 0: dd.mm.yyyy
-	    case 0: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=m10; buf[4]=m1; buf[5]=slash;
-		    buf[6]=y1000; buf[7]=y100; buf[8]=y10; buf[9]=y1; break;
-
-		    // 1: mm.dd.yyyy
-	    case 1: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=d10; buf[4]=d1; buf[5]=slash;
-		    buf[6]=y1000; buf[7]=y100; buf[8]=y10; buf[9]=y1; break;
-
-		// 2: yyyy.mm.dd
-	    case 2: buf[0]=y1000; buf[1]=y100; buf[2]=y10; buf[3]=y1; buf[4]=slash; buf[5]=m10;
-		    buf[6]=m1; buf[7]=slash; buf[8]=d10; buf[9]=d1; break;
-
-		// 3: dd.yyyy.mm
-	    case 3: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=y1000; buf[4]=y100;
-		    buf[5]=y10; buf[6]=y1; buf[7]=slash; buf[8]=m10; buf[9]=m1; break;
-
-		// 4: mm.yyyy.dd
-	    case 4: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=y1000; buf[4]=y100;
-		    buf[5]=y10; buf[6]=y1; buf[7]=slash; buf[8]=d10; buf[9]=d1; break;
-
-		// 5: yyyy.dd.mm
-	    case 5: buf[0]=y1000; buf[1]=y100; buf[2]=y10; buf[3]=y1; buf[4]=slash; buf[5]=d10;
-		    buf[6]=d1; buf[7]=slash; buf[8]=m10; buf[9]=m1; break;
-
-	}
-	buf[10]=0;
-
-
-}
-
-// -------------------    ********************************************************************************
-
-void GetShortDateString(uint8_t day, uint8_t month, uint8_t yearlow, uint8_t format, uint8_t sep, uint8_t *buf)
-{
-	// generate date as ascii string from integers day/month/year
-	// format=  0: dd.mm.yy   (deutsch)
-	//          1: mm.dd.yy   (amerika)
-    //          2: yy.mm.dd   (Iran, Dubai)
-    //          3: dd.yy.mm
-    //          4: mm.yy.dd
-    //          5: yy.dd.mm
-        // sep: 0: use . as seperator   1: use / as seperator
-    // return String in *buf      // 11byte für buf!
-
-
-	uint8_t tag, mon, jahr, d10, d1, m10, m1, y10, y1;
-	uint8_t slash;
-
-
-    tag=day;
-    mon=month;
-    jahr=yearlow;
-
-    if (mon>12 || mon==0) mon=1;           // 23.10.12
-    if (tag>31 || tag==0) tag=1;
-    if (jahr>50 || jahr<11) jahr=1;
-
-    if (sep==0)
-        slash='.';          // slash==0
-    else if (sep==1)
-        slash='/';
-    else if  (sep>=0x20)
-        slash=sep;
-    else
-        slash='.';
-
-    d10 =tag/10;
-    d1  =tag%10;
-    m10 =mon/10;
-    m1  =mon%10;
-    y10 =jahr/10;
-    y1  =jahr%10;
-
-	d10 +=0x30;    // in Asccii wandeln
-	d1  +=0x30;
-	m10 +=0x30;
-	m1  +=0x30;
-	y10 +=0x30;
-    y1  +=0x30;
-
-	switch (format)
-	{
-		    // 0: dd.mm.yyyy
-	    case 0: buf[0]=d10; buf[1]=d1; buf[2]=slash; buf[3]=m10; buf[4]=m1; buf[5]=slash;
-		    buf[6]=y10; buf[7]=y1; break;
-
-		    // 1: mm.dd.yyyy
-	    case 1: buf[0]=m10; buf[1]=m1; buf[2]=slash; buf[3]=d10; buf[4]=d1; buf[5]=slash;
-		    buf[6]=y10; buf[7]=y1; break;
-
-		// 2: yyyy.mm.dd
-	    case 2: buf[0]=y10; buf[1]=y1; buf[2]=slash; buf[3]=m10;
-		    buf[4]=m1; buf[5]=slash; buf[6]=d10; buf[7]=d1; break;
-
-		// 3: dd.yyyy.mm
-	    case 3: buf[0]=d10; buf[1]=d1; buf[2]=slash;
-		    buf[3]=y10; buf[4]=y1; buf[5]=slash; buf[6]=m10; buf[7]=m1; break;
-
-		// 4: mm.yyyy.dd
-	    case 4: buf[0]=m10; buf[1]=m1; buf[2]=slash;
-		    buf[3]=y10; buf[4]=y1; buf[5]=slash; buf[6]=d10; buf[7]=d1; break;
-
-		// 5: yyyy.dd.mm
-	    case 5: buf[0]=y10; buf[1]=y1; buf[2]=slash; buf[3]=d10;
-		    buf[4]=d1; buf[5]=slash; buf[6]=m10; buf[7]=m1; break;
-
-	}
-	buf[8]=0;
-
-
-}
-
-uint16_t tslib_strlen(char *buf)
-{
-    uint16_t nn;
-
-    for (nn=0; nn<0xFFF0; nn++)
-        if (buf[nn]==0)
-            return nn;
-    return 0;
-}
-
-uint16_t tslib_strlen(uint8_t *buf)
-{
-    uint16_t nn;
-
-    for (nn=0; nn<0xFFF0; nn++)
-        if (buf[nn]==0)
-            return nn;
-    return 0;
-}
-
-void tslib_strclr(char *buf, char clrsign, uint16_t len)
-{
-    uint16_t nn;
-
-    for (nn=0; nn<len; nn++)
-        buf[nn]=clrsign;
-
-}
-
-void tslib_strclr(uint8_t *buf, char clrsign, uint16_t len)
-{
-    uint16_t nn;
-
-    for (nn=0; nn<len; nn++)
-        buf[nn]=uint8_t (clrsign);
-
-}
-
-
-void tslib_strcpy(char *srcbuf, char *destbuf, uint16_t len)
-{
-    uint16_t nn;
-
-    for (nn=0; nn<len; nn++)
-        destbuf[nn]=srcbuf[nn];
-
-}
-
-void tslib_strcpy(char *srcbuf, uint8_t *destbuf, uint16_t len)
-{
-    uint16_t nn;
-
-    for (nn=0; nn<len; nn++)
-        destbuf[nn]=uint8_t(srcbuf[nn]);
-
-}
-
-void tslib_strcpy(uint8_t *srcbuf, uint8_t *destbuf, uint16_t len)
-{
-    uint16_t nn;
-
-    for (nn=0; nn<len; nn++)
-        destbuf[nn]=srcbuf[nn];
-
-}
-
-bool tslib_isDecAsciiNumber(char sign)
-{
-    if (sign>=0x30 && sign<=0x39)
-        return true;
-    return false;
-}
-
-bool tslib_isHexAsciiNumber(char sign)
-{
-    if (sign>=0x30 && sign<=0x39)
-        return true;
-    if (sign>=0x61 && sign<=0x66)   // a...f
-        return true;
-    if (sign>=0x41 && sign<=0x46)   // A...F
-        return true;
-    return false;
-}
-
-int tslib_getMinimum(int val1, int val2)
-{
-    if (val1<val2)
-        return val1;
-    return val2;
-}
-
-
-
-void tslib_text2array(QByteArray text, char *aray, uint16_t maxArayLen)
-{
-    QByteArray  sloc;
-    int ii, LL=text.length();
-
-    if (LL>maxArayLen) LL=maxArayLen;
-    for (ii=0; ii<LL; ii++)
-    {
-        aray[ii]=text.at(ii);
-    }
-    if (LL==maxArayLen)
-        aray[LL-1]=0;
-    else
-        aray[LL]=0;
-}
-
-
-// -----------------------------------------------------------------------------------------------
-// functions for DeviceController's Bootloader ---------------------------------------------------
-// -----------------------------------------------------------------------------------------------
-/*
-uint16_t tslib_calcCrcCcitt(uint16_t BufLength, uint8_t *buf)
-{
-    uint8_t  nn, B15H, element;
-    uint16_t crc = 0x84cf;
-
-    while (BufLength--)
-    {
-        element = *buf++;
-        for (nn = 0; nn < 8; nn++)
-        {
-            B15H = 0;
-            if(crc & 0x8000)
-                B15H = 1;
-            crc = (crc << 1) | ((element >> (7 - nn)) & 0x01);
-            if (B15H)
-            {
-                crc ^= 0x1021;
-            }
-        }
-    }
-
-    for (nn = 0; nn < 16; nn++)
-    {
-        B15H = 0;
-        if(crc & 0x8000)
-        B15H = 1;
-        crc = (crc << 1) | 0x00;
-        if (B15H)
-        {
-            crc ^= 0x1021;
-        }
-    }
-    return crc;
-
-}
-
-static uint8_t LastBLcmd;   // stored the last sent cmd in order to analys response
-                            // cmd echo'ed: error       cmd or'ed with 0x80: OK
-
-uint8_t tslib_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf)
-{
-    // make BL protocol, retval = outbuf length (5...133)
-    // bring data in correct form: start always with 0x02   finish with 0x03 and append checksum
-    // 0x02 Cmd < ...sendData ..>  CRC  CRC 0x03
-    // Data length = 0...64
-    // special conversion: if data contain 2 or 3 (STX, ETX) then write two bytes:  0x1B (=ESC) and data|0x80
-    // so maxlength = 5 + 2 x 64 (if all data are 2 or 3)  without 2,3: maxlength = 5 + 64
-
-    uint8_t  myBuf[140], pp=0, nn, uctmp, currLen=0;
-    uint16_t calcCrc;
-
-    tslib_strclr(myBuf, 0, 140);
-
-    myBuf[pp++]=2;    // STX
-    myBuf[pp++]=Cmd;
-    LastBLcmd=Cmd;
-
-    // append data:
-    for (nn=0; nn<SendDataLength; nn++)
-    {
-        uctmp=sendData[nn];
-        if (uctmp==2 || uctmp==3)       // STX or ETX in normal data!
-        {
-            myBuf[pp++]=0x1B;       // ESC
-            myBuf[pp++]=uctmp | 0x80;
-        } else
-            myBuf[pp++]=uctmp;
-    }
-    currLen=pp;
-
-    // calc crc: (over cmd and data, without STX)
-    calcCrc=tslib_calcCrcCcitt(uint16_t(currLen), myBuf);
-    myBuf[pp++]=uint8_t(calcCrc & 0x00FF);
-    myBuf[pp++]=uint8_t((calcCrc>>8) & 0x00FF);
-    myBuf[pp++]=3;
-    currLen=pp;
-
-    return currLen;
-}
-
-// some special commands (right out of bootloader manual)
-uint8_t tslib_readBLversion(uint8_t *sendData)
-{
-    // minimum size of sendData-buffer: 5byte  retval: length
-    uint8_t myBuf[2];
-    tslib_strclr(myBuf, 0, 2);
-    return tslib_prepareDC_BLcmd(0x11, 0, myBuf, sendData);
-}
-
-uint8_t tslib_readFWversion(uint8_t *sendData)
-{
-    // minimum size of sendData-buffer: 5byte  retval: length
-    uint8_t myBuf[2];
-    tslib_strclr(myBuf, 0, 2);
-    return tslib_prepareDC_BLcmd(0x12, 0, myBuf, sendData);
-}
-
-uint8_t tslib_exitBL(uint8_t *sendData)
-{
-    // minimum size of sendData-buffer: 5byte  retval: length
-    uint8_t myBuf[2];
-    tslib_strclr(myBuf, 0, 2);
-    return tslib_prepareDC_BLcmd(0x18, 0, myBuf, sendData);
-}
-
-uint8_t tslib_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *sendData)
-{
-    // minimum size of sendData-buffer: 13byte    retval: length (9...13)
-    uint8_t myBuf[2];
-    tslib_strclr(myBuf, 0, 2);
-    return tslib_prepareDC_BLcmd(0x11, 0, myBuf, sendData);
-}
-*/
-
-// -----------------------------------------------------------------------------------------------
-
-
-void biox_CopyBlock(uint8_t *src, uint16_t srcPos, uint8_t *dest, uint16_t destPos, uint16_t len)
-{
-    // both buffers starting from pos 0
-    uint16_t xx,yy,zz,ii;
-
-    xx = srcPos;
-    yy = destPos;
-    zz = len;
-
-    for (ii = 0; ii < zz; ++ii)
-    {
-        dest[yy + ii] = src[xx + ii];
-    }
-}