Merged new function to DCPlugin (01.06.2023).

Added c++17.

DCPlugin.pri

@@ -2,6 +2,7 @@ INCLUDEPATH += $${PWD}/include
 DEPENDPATH += $${PWD}
 
 HEADERS += $${PWD}/include/com.h \
+    $$PWD/include/datei.h \
     $${PWD}/include/controlBus.h \
     $${PWD}/include/datIf.h \
     $${PWD}/include/dcBL.h \
@@ -14,6 +15,8 @@ HEADERS += $${PWD}/include/com.h \
     $${PWD}/include/shared_mem_buffer.h
 
 SOURCES += $${PWD}/src/com.cpp \
+    $$PWD/src/datei.cpp \
+    $$PWD/src/main.cpp \
     $${PWD}/src/controlBus.cpp \
     $${PWD}/src/datIf.cpp \
     $${PWD}/src/dcBL.cpp \

DCPlugin.pro

@@ -14,24 +14,27 @@ QMAKE_CXXFLAGS += -Wno-deprecated-copy
 # default
 ARCH = PTU5
 
-include(DCPlugin.pri)
-
 contains( CONFIG, DesktopLinux ) {
-    QMAKE_CC = ccache $$QMAKE_CC
+    # QMAKE_CC = ccache $$QMAKE_CC
-    QMAKE_CXX = ccache $$QMAKE_CXX
+    # QMAKE_CXX = ccache $$QMAKE_CXX
-    QMAKE_CXXFLAGS += -std=c++11
+    QMAKE_CXXFLAGS += -std=c++17
     # QMAKE_CXXFLAGS += -Wno-deprecated-ctor
     linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
     ARCH = DesktopLinux
+    include(DCPlugin.pri)
 }
 
 contains( CONFIG, PTU5 ) {
     # QMAKE_CC = ccache $$QMAKE_CC
     # QMAKE_CXX = ccache $$QMAKE_CXX
-    QMAKE_CXXFLAGS += -std=c++11
+    QMAKE_CXXFLAGS += -std=c++17
     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 ) {
@@ -43,12 +46,11 @@ contains( CONFIG, PTU5_YOCTO ) {
     #LIBS += -lQt5Qmqtt
 }
 
-TARGET   = ATBDeviceControllerPlugin
+TARGET   = CashAgentLib
 #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
@@ -68,16 +70,8 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #else: unix:!android: target.path = /opt/$${TARGET}/bin
 #!isEmpty(target.path): INSTALLS += target
 
-# ATBAPP interface
-HEADERS += \
-    src/ATBAPP/ATBAPPplugin.h \
-    src/ATBAPP/DeviceControllerInterface.h \
-    src/ATBAPP/ATBHealthEvent.h \
-    src/ATBAPP/ATBDeviceControllerPlugin.h
 
-SOURCES += \
+
-    src/ATBAPP/ATBHealthEvent.cpp \
-    src/ATBAPP/ATBDeviceControllerPlugin.cpp
 
 DISTFILES += \
     generate-version.sh
@@ -92,3 +86,5 @@ version.input = VERSION_H
 version.variable_out = HEADERS
 QMAKE_EXTRA_COMPILERS += version
 QMAKE_CLEAN += $${PWD}/include/version.h
+
+HEADERS +=

include/controlBus.h

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

include/datIf.h

@@ -303,13 +303,12 @@ class T_datif : public QMainWindow
         // docNr =transmitted in WRITEADDRESS high byte
         // blockNr=transmitted in WRITEADDRESS low byte
 
+    int     datif_noResponseCtr;
 
     T_prot *myDCIF;
     QTimer *datif_trigger;
     uint8_t selectedSlaveAddr;
 
-    int datif_noResponseCtr;
-
 private slots:
     char datif_cycleSend();
     void StoredRecData();
@@ -317,16 +316,12 @@ private slots:
 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);
-    bool areDataValid(void);
 
 signals:
     void ResponseRecieved();

include/datei.h

@@ -0,0 +1,202 @@
+#ifndef DATEI_H
+#define DATEI_H
+
+#include <stdint.h>
+#include <QFile>
+#include <QFileInfo>
+#include <QDebug>
+#include "tslib.h"
+#include <QString>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonParseError>
+
+    // create csv file with:
+#define FILESEPERATOR       ','
+
+    // pasre csv with:
+#define FILESEP1       ','
+#define FILESEP2       ';'
+
+#define NEWLINEINFILE       '\n'
+#define MAXNUMBEROFSEQUENCES      200
+    // only for csv files
+
+
+// all generated files located in sudirectory "dynamic machine data - dmd"
+
+#define FILENAME_SHAREDDATA            "../dmd/DCshare.csv"
+#define FILENAME_SHARED_UID            "../dmd/DC_UID.csv"
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ create csv file -------------------------------
+// -------------------------------------------------------------------------------------------------
+
+
+// create array with strings and values (to be written to file)
+void csv_startCreatingFile(void);
+void csv_addTextToFile(QString myText);
+void csv_addIntToFile(int myValue);
+void csv_addUintToFile(uint myValue);
+void csv_addLongvalToFile(qlonglong myValue);
+void csv_addUlongvalToFile(qulonglong myValue);
+//void csv_addCurrentTimeToFile(void);
+//void csv_addCurrentDateToFile(void);
+void csv_addNewlineToFile(void);
+QByteArray csv_readbackArray(void);
+
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ parse csv file -------------------------------
+// -------------------------------------------------------------------------------------------------
+
+
+// return number of entries in the just read file (entries are seperated by
+// comma or line-feed)
+uint32_t csv_nrOfEntriesInFile(QByteArray readFromFile);
+
+// before: QByteArray sourceFile=datei_readFromFile(filename);
+
+QByteArray csv_getOneFileSequence(QByteArray sourceFile, uint32_t sequNr);
+// not needed, just for test       // sequNr: 0....(size-1)
+
+// get single entries of of the just read file:
+int csv_getEntryAsInt(QByteArray sourceFile, uint32_t sequNr);
+    // sequNr: 0....(size-1)
+
+int32_t csv_getEntryAsLong(QByteArray sourceFile, uint32_t sequNr);
+    // sequNr: 0....(size-1)
+
+uint8_t csv_getEntryAsUshort(QByteArray sourceFile, uint32_t sequNr);
+    // sequNr: 0....(size-1)
+
+uint16_t csv_getEntryAsUint(QByteArray sourceFile, uint32_t sequNr);
+    // sequNr: 0....(size-1)
+
+uint32_t csv_getEntryAsUlong(QByteArray sourceFile, uint32_t sequNr);
+    // sequNr: 0....(size-1)
+
+uint64_t csv_getEntryAs2Ulong(QByteArray sourceFile, uint32_t sequNr);
+    // sequNr: 0....(size-1)
+
+QString csv_getEntryAsString(QByteArray sourceFile, uint32_t sequNr);
+    // sequNr: 0....(size-1)
+
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ create Json Record -------------------------------
+// -------------------------------------------------------------------------------------------------
+
+void json_startRecord(void);
+    // clear buffer and write opening curly bracket {
+
+void json_enterIntToRecord(QString attribute, ulong i_value);
+    // example: "parameter":1234567890
+
+void json_enterTextToRecord(QString attribute, QString txt_value);
+    // example: "parameter":"slow"
+
+//void json_addCurrentTimeToRecord(QString attribute);
+    // example: if attribute=myTime:  "myTime":"hh_mm_ss"
+
+//void json_addCurrentDateToRecord(QString attribute);
+    // example: if attribute=myDate:  "myDate":"dd.mm.yyyy"
+    // also / possible as seperator
+    // further possible forms:
+    // 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
+
+void json_enterArrayToRecord(QString attribute, uint8_t *buf, ulong nrofVals);
+    // add array of numbers with "nrofVals" elements
+
+void json_enterStructToRecord(QString attribute);
+    // every call must be concluded with an extra "json_finishFile()"
+    // example: "sname":{
+
+void json_finishStruct(void);
+
+void json_finishRecord(void);
+    // close curly bracket
+
+
+QString json_readbackRecordStr(void);
+
+QByteArray json_readbackRecordBa(void);
+
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ parse Json file -------------------------------
+// -------------------------------------------------------------------------------------------------
+
+// first: QByteArray datei_readFromFile(QString filename);
+
+//void datei_json_readTestFile(QString filename);
+
+int json_nrOfPairsInFile(QByteArray filename);
+
+bool json_exists(QByteArray filename, QString searchForKey);
+    // look for "searchForKey" =name of the pair (left of : )
+    // retval true if exists
+
+bool json_remove(QByteArray filename, QString searchFor);
+    // look for "searchFor" =name of the pair (left of : ) and remove the record from file
+    // retval true if removed
+
+QString json_searchForStringInFile(QByteArray filename, QString searchFor);
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+
+int json_searchForIntInFile(QByteArray filename, QString searchFor);
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+
+//.......................
+
+QJsonObject json_searchForObjectInFile(QByteArray filename, QString searchFor);
+    // return an object from the json file
+
+int json_nrOfPairsInObject(QJsonObject objname);
+
+QString json_searchForStringInObject(QJsonObject objname, QString searchFor);
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+
+int json_searchForIntInObject(QJsonObject objname, QString searchFor);
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+
+//.......................
+
+QJsonArray json_searchForArrayInFile(QByteArray filename, QString searchFor);
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+
+int json_nrOfValuesInArray(QJsonArray arrayname);
+
+bool json_getValuesOfArray(QJsonArray arrayname, int *buf, int MaxBufferSize);
+    // assuming that the array consists of integers
+
+
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ read, write, copy files -------------------
+// -------------------------------------------------------------------------------------------------
+
+void datei_closeFile(QString filename);
+
+// read content of an exiting file:
+QByteArray datei_readFromFile(QString filename);
+
+bool datei_ifFileExists(QString filename);
+
+char datei_writeToFile(QString filename, QByteArray content);
+    // retval=0 if successful     1: no write access allowed
+    //      2:cannot open to append     3:cannot create new file
+
+bool datei_copyFile(QString currentFileName, QString newFileName);
+    // retval=true if successful
+
+bool datei_clearFile(QString filename);
+    // retval=true if successful
+
+#endif // DATEI_H

include/hwChk.h

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

include/hwapi.h

@@ -24,46 +24,33 @@ matching interfaces.h:
 #define hwapi_H
 
 #include <stdint.h>
+#include <QTabWidget>
+#include <QtPlugin>
 #include <QTimer>
 #include <QObject>
-#include "interfaces.h"
+#include <../plugins/interfaces.h>
 #include "datIf.h"
 
-class QSharedMemory;
+
+
 class hwapi :   public QObject,
                 public hwinf
 {
     Q_OBJECT
+    Q_PLUGIN_METADATA(IID "Atb.Psa2020.software.HWapi/1.0" )   //FILE "HWapi.json")
     Q_INTERFACES(hwinf)
 private:
     void sub_storeSendingText(QByteArray *buf) const;
     QTimer *hwapi_TimerPayment;
 
-    DownloadResult sendNextAddress(int bNum) const;
-    DownloadResult sendNextDataBlock(QByteArray const &b, int bNum) const;
-    DownloadResult sendStatus(int ret) const;
-    DownloadResult dc_downloadBinary(QByteArray const &binary) const;
-
-    bool startBootloader() const;
-    bool stopBootloader() const;
-    bool openSerial(int br, QString baudrate, QString comPort) const;
-    bool closeSerial(QString comport) const;
-    bool resetDeviceController() const;
-    QByteArray loadBinaryDCFile(QString filename) const;
-    bool downloadBinaryToDC(QString const &bFile) const;
-
-    QSharedMemory *m_sharedMem;
 public:
-    explicit hwapi(QObject *parent = nullptr);
+    explicit hwapi(QWidget *parent = nullptr);
-    virtual ~hwapi();
 
     T_datif *myDatif;
 
 
-    virtual QStringList dc_getStatus() const override;
-
     // ------------------------------------------------------------------------------
-    // Level 0 commands, interface
+    // commands, interface
     // open, close, change serial interface
     // actually not neccessary as it is opened automatically on program start
     // start automatic READ requests
@@ -75,7 +62,7 @@ public:
         // ComName: for example "COM48"
         // connect: 0, 1
 
-    bool dc_closeSerial(void) const override;
+    void dc_closeSerial(void) const override;
 
     bool dc_isPortOpen(void) const override ;
 
@@ -83,21 +70,10 @@ public:
         // select if READ-Requests are sent manually one by one or automatically
         // automatically request ALL digital and analog sensors, get time/date, get status information
 
-    bool dc_updateDC(QString binFileName, QString baudrate,
-                     QString comPort) const override;
 
-    bool dc_updatePrinterTemplate(enum FileTypeJson type,
-                                  QVector<int> templateIdx,
-                                  QVector<QString> fnames,
-                                  QString br,
-                                  QString serial = QString()) const override;
 
-    bool dc_printTemplate(enum FileTypeJson type,
-                          QVector<int> templateIdx,
-                          QString br,
-                          QString serial = QString()) const override;
     // ------------------------------------------------------------------------------
-    // Level 1, control device-controller (functions of µC)
+    // control device-controller (functions of µC)
     // check serial connection to deviceController
     // read response from DC2 (input data)
     // some test function for serial communication
@@ -192,7 +168,7 @@ public:
 
 
     // ------------------------------------------------------------------------------
-    // Level 2  DC2-onboard devices
+    // DC2-onboard devices
     //          WR: set time
     //          RD. get time, get measure, get test results
     // ------------------------------------------------------------------------------
@@ -266,7 +242,7 @@ public:
     bool dc_mainFuseIsOk(void) const override;
 
     // ------------------------------------------------------------------------------
-    // Level 3: digital outputs and simple switching of connected devices
+    // igital outputs and simple switching of connected devices
     //          simple processes like flashing a led or open flap for 1s
     // ------------------------------------------------------------------------------
 
@@ -322,7 +298,7 @@ public:
 
 
     // ------------------------------------------------------------------------------
-    // Level 3: digital inputs of connected devices
+    //  digital inputs of connected devices
     // ------------------------------------------------------------------------------
 
     bool door_isContactPowerOn(void) const override;
@@ -684,29 +660,29 @@ public:
     // up to 8 dynamic values can be defined in the template ("print val3 here") and will be sent with printing command
     // example: print current time at this point (the time of printing not the storage time!!)
 
-    void pri_startTicketDesign(void) const override;
+    //void pri_startTicketDesign(void) const override;
         // start for every new printer document, reseting collecting buffer
 
     // all further functions write/append text, numbers and command to the ticket-buffer, up to 1278 bytes allowed
     // return val of the appending functions: true=ok false=too long, buffer full
 
-    int pri_TD_getCurrentSize(void) const override;
+    //int pri_TD_getCurrentSize(void) const override;
         // retval: 0...1278
 
-    bool pri_TD_addText(QByteArray text) const override;
+    //bool pri_TD_addText(QByteArray text) const override;
         // example: pri_TD_addText("Hello") const override;
         // example: pri_TD_addText(tempStr) const override;
         // retval: true=ok false=too long, buffer full
 
-    bool pri_TD_addValue(int val) const override;
+    //bool pri_TD_addValue(int val) const override;
         // +/- 0...2^(31)
 
-    bool pri_TD_addNewLine(void) const override;
+    //bool pri_TD_addNewLine(void) const override;
 
-    bool pri_TD_addSign(char sign) const override;
+    //bool pri_TD_addSign(char sign) const override;
         // example: '.'   ' '   0x20 'W' '$'
 
-    bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const override;
+    //bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const override;
         // always add 8 byte to the ticket layout:  ESC & group & attribute & parameter1...5
         /* complete list of possible commands:
             group 50 : paper
@@ -747,11 +723,11 @@ public:
 
     */
 
-    char prn_clearDocument(uint8_t documentNumber) const override;
+    //char prn_clearDocument(uint8_t documentNumber) const override;
         // clear memory buffer for ONE document
         // function takes a second! don't send right before "store doc"
 
-    bool prn_store_Document(uint8_t documentNumber ) const override;
+    //bool prn_store_Document(uint8_t documentNumber ) const override;
 
         // send the predefined Layout (generated with above TD functions) to DeviceController to save
         // documentNumber=0...15
@@ -763,7 +739,7 @@ public:
     // the place in the ticket layout is predefined (already in DC memory)
     // the dynamics are first calculated at printing time
 
-    bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const override;
+    //bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const override;
 
 
 
@@ -867,7 +843,7 @@ public:
     void bl_rebootDC(void) const override;
 
     void bl_startBL(void) const override;
-    bool bl_checkBL(void) const override;
+    void bl_checkBL(void) const override;
     bool bl_isUp(void) const override;
         // return true is bl is up and running
         // also initializes "sendFile"
@@ -944,6 +920,7 @@ public:
         // return true if successful. could fail if more the 8 commands are waiting
 
     bool rtc_getExtendedTime(uint8_t *leng, uint8_t *data) const override;
+
     bool rtc_getExtendedTime(struct T_extTime *exTime) const override;
 
     bool sys_runCompleteTest(void) const override;
@@ -990,6 +967,9 @@ public:
     bool prn_printTestTicket(void) const override;
         // return true if sending to DC OK, false if cmd-stack is full
 
+
+
+
     bool cash_startPayment(uint32_t amount) const override;
         // 17.4.23TS: extended to 32bit
 
@@ -1038,20 +1018,21 @@ public:
         // retval: 6 bytes, bit coded, 1=event keeps DC awake
 
     uint8_t sys_getWakeReason(void) const override;
-         // Master was woken by following reason:
+        // Master was woken by following reason:
-         // 1: MDB Event
+        // 1: MDB Event
-         // 2: Coin Event
+        // 2: Coin Event
-         // ( 3: Master Event) - will not set the wake line
+        // ( 3: Master Event) - will not set the wake line
-         // ( 4: 32s pulse) - will not set the wake line
+        // ( 4: 32s pulse) - will not set the wake line
-         // 5: Door Event
+        // 5: Door Event
-         // ( 6: Diag Event) - will not set the wake line
+        // ( 6: Diag Event) - will not set the wake line
-         // 7: 30min-Pulse for HB
+        // 7: 30min-Pulse for HB
 
     void sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const override;
 
     void sys_getDeviceConditions(struct T_moduleCondition *devCond) const override;
 
     void sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const override;
+
     void sys_getDynMachineConditions(struct T_dynamicCondition *dynMachCond) const override;
 
 
@@ -1069,51 +1050,30 @@ public:
         //          bit6: no response             bit7: serial rec. error
         //			bit5: printer not ready
 
+
     void sys_sendDeviceParameter(struct T_devices *deviceSettings) const override;
 
     void sys_restoreDeviceParameter(struct T_devices *deviceSettings) const override;
 
     bool sys_areDCdataValid(void) const override;
 
-    /* ---------------------------------------------------------------------------------------------
+    bool sys_sendingTest(void) const override;
-    // ------------   supervise  all hardware components
-    // ------------    assess the machine state
 
-    1. check if DC startup test is through, retrigger if not
+    void prn_requestCurrentDynData(void) const override;
-    2. get results and find errors
-    3. in case of error check if component is used (e.g. billreader is seldom used)
-    4: check doors
-    5. return value: 0: no response from DC
-                     1: no Test results and Test not running. need retrigger!
-                     2: state not clear by now, test ongoing, wait
-                     3: Service or battery door is open, goto INTRUSION MODE
-                            from here: after valid ID-card goto SERVICE MODE
-                     4: vault door is open, goto INTRUSION MODE
-                            from here: after valid ID-card and vault door closed goto TEST MODE
-                            in TEST MODE: complete system check decides if vending mode allowed
-                     5: All doors are closed but errors found,
-                            goto OOO MODE (out-of-order)
-                            from here: run system test until problem is fixed
-                     6: All doors are closed, no error, maybe warnings,
-                            goto VENDING MODE (normal operation)
-                    (priority sinks from 0 to 6)
 
-     --------------------------------------------------------------------------------------------- */
+    bool prn_getCurrentDynamicPrnValuesFromDC(uint8_t *dynPrnVal ) const override;
+    // which was sent with: bool prn_sendDynamicPrnValues(uint8_t *dynPrnVal ) const override;
 
-    uint8_t sys_componentAssessment(void) const override;
+    bool prn_dynDataAreEqual(uint8_t *buf) const override;
-    // this function decides if vending mode is possible, independant from door
-    // return >0 in case of error
-    // is inncluded in sys_superviseSystem
 
-    uint8_t sys_superviseSystem(void) const override;
+    bool prn_printKombiticket(uint8_t nrOfKombi) const override;
-    // this function proofs if vending is possible depending of doors state
+        // print four of the templates loaded by Json prior
+        // nr = 1..8
 
+    void lock_triggerUpperSolenoid(void) const override;
 
-    uint8_t sys_getSystemErrors(void) const override;
+    void lock_triggerLowerSolenoid(void) const override;
 
-    // ---------------------------------------------------------------------------------------------
-    // ---------------------------------------------------------------------------------------------
-    // ---------------------------------------------------------------------------------------------
 
 signals:
     void hwapi_templatePrintFinished_OK(void) const override;

include/prot.h

@@ -93,9 +93,6 @@ 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);

include/sendWRcmd.h

@@ -211,8 +211,15 @@ uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *
     // 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);
@@ -220,31 +227,35 @@ bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, ui
 uint8_t check4FDshortCmd(void);
     // returns number of waiting command, maxFDCMD_STACKDEPTH
 
+uint8_t checkNextFDcmd(void);
+    // return 0: no command waiting
+//          1: short cmd
+//          2: long cmd
+
 uint8_t check4freeFDshortCmd(void);
     // returns number of free places in short-command stack
 
-#define     FDLONG_STACKDEPTH    16
+//#define     FDLONG_STACKDEPTH    16
-void longFDcmd_clrStack(void);
+//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);
 bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data);
 
-uint8_t check4FDlongCmd(void);
+//uint8_t check4FDlongCmd(void);
     // returns number of waiting command
 
-uint8_t check4freeFDlongCmd(void);
+//uint8_t check4freeFDlongCmd(void);
     // returns number of free places in long-command stack
 
 
-
 uint8_t epi_store64BdevParameter(uint8_t length, uint8_t *buf);
     // HWapi writes data to be stored
 
 uint8_t epi_restore64BdevParameter(uint8_t *length, uint8_t *buf);
 
 
-
 #endif
 
 

include/shared_mem_buffer.h

@@ -7,6 +7,12 @@
 #include <QSharedMemory>
 
 struct SharedMemBuffer {
+
+
+
+
+
+
     struct rs {
         char comportName[16]; // z.B. "COM48"
         char baudStr[16];     // z.B. "19200"
@@ -198,6 +204,7 @@ struct SharedMemBuffer {
     uint8_t mif_cardType;
     uint8_t mif_cardHolder[8];
 
+#if 0
 #define MEMDEPTH_GOTCOINS (16)
     struct T_coin {
         uint8_t valid;
@@ -207,6 +214,7 @@ struct SharedMemBuffer {
         uint16_t value;
     } gotCoin[MEMDEPTH_GOTCOINS];
     uint8_t ctr_gotCoin;
+#endif
 
     struct store {
         uint32_t insertedAmount;
@@ -225,9 +233,6 @@ struct SharedMemBuffer {
         uint8_t vaultrecord[360];
         uint32_t amount;
         uint16_t nrOfCoins;
-        bool    dcDataValid;
-        uint8_t wakeReason;
-        char    curPayNewCoin;
     } store;
 
     struct T_globTime {

include/storeINdata.h

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

plugins/interfaces.h

@@ -2,9 +2,12 @@
 #define INTERFACE_H
 
 #include <QtPlugin>
-#include <QStringList>
 
-struct T_emp {
+
+
+struct T_emp
+{
+
    // Fixdata from EMP:
    uint8_t shaft;      // = changer level
    uint16_t countryCode;
@@ -21,19 +24,29 @@ struct T_emp {
 
    // dynamic:
    uint8_t state;      // step counter of EMP (electronic coin checker) FSM (finite state machine):
-                       // 0=Emp & Bus power off,  1=powered, poll off    2=polling on
+       // 0=start command
-                       // 3=device responded, requesting status
+       // 1=powered, do emp ini, send reset
-                       // 4=waiting for status     5=have status,
+       // 2=delay
-                       // 6: IDLE,  have paramters from master, polling running, ready for payment
+       // 3=wait for response, requesting status after response
-                       //          Master can stop/start polling and acceptance
+       // 4,5 through, startup
-                       // 7: end of transaction,  polling on, accept off, reporting coins, (wait for last coin)
+       // 6: wait for status
-                       // 8: transaction running, polling on, acceptance on, reporting coins,
+       // 7: through, startup
+       // 8: IDLE state.   EMP is up and ready, polling is running
+       // 9: polling on, payment not yet on
+       // 10: payment, check coins
+       // 11: through
+       // 12: wait 1s for last coin
+       // 90: stop all, 1s delay
+       // 99: off, all stopped
+
 
    uint8_t pollingRunning;
    uint8_t paymentRunning;
+
 };
 
-struct Trtc_DateTime {
+struct Trtc_DateTime
+{
    uint8_t rtc_hour;
    uint8_t rtc_min;
    uint8_t rtc_sec;
@@ -43,7 +56,8 @@ struct Trtc_DateTime {
    uint8_t rtc_dayOfWeek;
 };
 
-struct Tprn_hw_state {
+struct Tprn_hw_state
+{
     // hardware (IO's)
     bool powerRdBk;     // prn pwr is on
     bool rsSwOk;        // serial switch (printer or modem) is set to printer
@@ -60,7 +74,8 @@ struct Tprn_hw_state {
     bool badResponse;
 };
 
-struct Tprn_currentSettings {
+ struct Tprn_currentSettings
+{
     uint8_t currFont;
     uint8_t currSize;
     uint8_t currHeigth;
@@ -73,166 +88,196 @@ struct Tprn_currentSettings {
     bool    nowAligned;
 };
 
-struct T_dynDat {
+// obsolete
+ struct T_dynDat
+{
     uint8_t licensePlate[8];
     uint8_t vendingPrice[8];
-    uint8_t parkingEndTime[8];
+    uint8_t parkingEnd[8];
-    uint8_t parkingEndDate[8];
+    uint8_t currentTime[8];
     uint8_t currentDate[8];
     uint8_t dynDat5[8];
     uint8_t dynDat6[8];
     uint8_t dynDat7[8];
 };
 
-struct T_vaultRecord {
+
+struct T_vaultRecord
+{
+
     // Kassenbeleg (Abrechnungsdatensatz = Kassenwechsel-Datensatz)
-    char startbuffer[4];		// Psa>  // never move or change this 1st entry
+        char startbuffer[4];		// Psa>  // never move or change this 1st entry
-    uint16_t AccountingNumber;
+        uint16_t AccountingNumber;
-    uint16_t CUNU;
+        uint16_t CUNU;
-    uint16_t MANU;
+        uint16_t MANU;
-    uint16_t resint1;
+        uint16_t resint1;
-    //uint16_t resint2;
+        //uint16_t resint2;
 
-    char label1buffer[4];	 // tim>
+        char label1buffer[4];	 // tim>
-    uint8_t year;
+        uint8_t year;
-    uint8_t month;
+        uint8_t month;
-    uint8_t dom;
+        uint8_t dom;
-    uint8_t hour;
+        uint8_t hour;
-    uint8_t min;
+        uint8_t min;
-    uint8_t sec;
+        uint8_t sec;
-    uint8_t DoW;
+        uint8_t DoW;
-    uint8_t reschar3;
+        uint8_t reschar3;
 
-    char label2buffer[4];	// abs>
+        char label2buffer[4];	// abs>
-    uint32_t AbsIncome1;
+        uint32_t AbsIncome1;
-    uint32_t AbsReserve;
+        uint32_t AbsReserve;
-    uint32_t AbsNrOfCuts;
+        uint32_t AbsNrOfCuts;
 
 //16
-    char label3buffer[4];	// mw >
+        char label3buffer[4];	// mw >
 
-    // Verkauf, Tür zu:
+        // Verkauf, Tür zu:
-    uint32_t VKcoinsInserted[16];		// nur für Wechsler, soviel wurde eingeworfen
+        uint32_t VKcoinsInserted[16];		// nur für Wechsler, soviel wurde eingeworfen
-    uint32_t VKcoinsReturned[6];		// nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
+        uint32_t VKcoinsReturned[6];		// nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
 //88
-    // Service, Tür offen:
+
-    uint16_t ServCoinsInserted[16];		// nur für Wechsler, soviel wurde eingeworfen
+        // Service, Tür offen:
-    uint16_t ServCoinsReturned[6];		// nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
+        uint16_t ServCoinsInserted[16];		// nur für Wechsler, soviel wurde eingeworfen
-    uint16_t resint3;
+        uint16_t ServCoinsReturned[6];		// nur für Wechsler, Anzahl Münzen pro Typ, soviel wurde zurückgegeben
-    uint16_t resint4;
+        uint16_t resint3;
-    uint16_t currentTubeContent[6];		//  nur für Wechsler, aktueller Füllstand
+        uint16_t resint4;
-    uint16_t resint5;
+        uint16_t currentTubeContent[6];		//  nur für Wechsler, aktueller Füllstand
-    uint16_t resint6;
+        uint16_t resint5;
+        uint16_t resint6;
 // 56
-    char label4buffer[4];	// box>
+
-    uint16_t coinsInVault[16];
+        char label4buffer[4];	// box>
-    uint16_t billsInStacker[8];
+        uint16_t coinsInVault[16];
+        uint16_t billsInStacker[8];
 // 48
-    char label5buffer[4];	// val>
+
-    // actually constant unless exchange rate is changed
+        char label5buffer[4];	// val>
-    uint16_t coinDenomination[16];	// 5..50000 (z.B. 2? sind in Ungarn 760Ft)
+        // actually constant unless exchange rate is changed
-    uint16_t billDenom[8];
+        uint16_t coinDenomination[16];	// 5..50000 (z.B. 2? sind in Ungarn 760Ft)
-    uint16_t tubeDenom[6];
+        uint16_t billDenom[8];
-    uint16_t exchangeRate;
+        uint16_t tubeDenom[6];
-    uint16_t resint9;
+        uint16_t exchangeRate;
+        uint16_t resint9;
+
 // 64
-    char endofblock[4];	// end>
+
+        char endofblock[4];	// end>
+
 // 316 byte Block im Speicher
-};
-
-struct T_moduleCondition {
-    // store conditon of all system components, hold in RAM
-    // 0 means unknown, not yet tested/used
-    // 1 means OK
-    // 50..99	= HINT / Notification
-    // 100..150	= WARNING
-    // 200..250	= ERROR
-
-    uint8_t	ram;
-    uint8_t	intEe;
-    uint8_t	extEe;
-
-    uint8_t	rtc;				// 1: time/date OK   100: time not plausible  200: hardware error
-    uint8_t	boardHw;
-    uint8_t	printer;
-    uint8_t	modem;
-
-    uint8_t	signal;				//		1...99
-    uint8_t	regist;				// 100:not  1:reg  2:ping OK   3:gotTime
-    uint8_t	mdbBus;
-    uint8_t	coinChecker;		// EMP, OMP or mei-cashflow
-
-    uint8_t	coinEscrow;
-    uint8_t	mifareReader;
-    uint8_t	creditTerm;
-    uint8_t	coinReject;
-
-    uint8_t	coinSafe;
-    uint8_t   billSafe;
-    uint8_t	voltage;			// 1:11..14V
-    uint8_t   temper;
-
-    uint8_t	poweronTest;
-    uint8_t   doorState;			// 1: alles zu  200: t?r offen + bit1(S) +bit2(CB) + bit3(CB)
-    uint8_t	doorWasOpened;		// 1: all doors are closed   200: any door was just opened
-    uint8_t	changer;			// can only be tested by usage
-
-    uint8_t   coinBlocker;		// can only be tested by usage
-    uint8_t   billReader;			// can only be tested by usage
-    uint8_t   ResetReason;
-    uint8_t	allModulesChecked;
 
 };
 
-struct T_dynamicCondition {
+struct T_moduleCondition
-    char allDoorsDebounced;     // 99: undefined, 0=all closed, bit1=upper door open  2=midlle door open 3=lower door open
+{
-    char openedAuthorized;
+        // store conditon of all system components, hold in RAM
-    uint8_t CBinDebounced;
+        // 0 means unknown, not yet tested/used
-    char upperDoor;		// 99: undefined  0:closed  1:open
+        // 1 means OK
-    char middleDoor;    // 99: undefined  0:closed  1:open
+        // 50..99	= HINT / Notification
-    char lowerDoor;     // 99: undefined  0:closed  1:open
+        // 100..150	= WARNING
-    char reserve;       // not used, always 0
+        // 200..250	= ERROR
-    char billBox;
+
-    char modeAbrech;
+        uint8_t	ram;
-    char onAlarm;       // 0:alarm aus  1:alarm  2:alarm mit Sirene   3: Sirenentest
+        uint8_t	intEe;
-    char nowCardTest;
+        uint8_t	extEe;
-    char nowPayment;
+
-    char lastMifCardType;
+        uint8_t	rtc;				// 1: time/date OK   100: time not plausible  200: hardware error
-    uint8_t lastSDoorState;
+        uint8_t	boardHw;
-    uint8_t lastVDoorState;
+        uint8_t	printer;
-    uint8_t lastCBstate;        // 99: undefined  0:not there   1:insered
+        uint8_t	modem;
-    char        paymentInProgress;
+
-    char        res1;
+        uint8_t	signal;				//		1...99
-    uint16_t    U_Batt;
+        uint8_t	regist;				// 100:not  1:reg  2:ping OK   3:gotTime
-    uint16_t	Temperatur;
+        uint8_t	mdbBus;
-    uint16_t	nrCoinsInBox;
+        uint8_t	coinChecker;		// EMP, OMP or mei-cashflow
-    uint32_t	amountInBox;
+
-    uint32_t	totalTransVolume;
+        uint8_t	coinEscrow;
-    uint32_t	totalNrOfVends;
+        uint8_t	mifareReader;
-    char        jsonValid_config;
+        uint8_t	creditTerm;
-    char        jsonValid_device;
+        uint8_t	coinReject;
-    char        jsonValid_cash;
+
-    char        jsonValid_print;
+        uint8_t	coinSafe;
-    char        jsonValid_serial;
+        uint8_t   billSafe;
-    char        jsonValid_time;
+        uint8_t	voltage;			// 1:11..14V
-    char        lastFileType;
+        uint8_t   temper;
+
+        uint8_t	poweronTest;
+        uint8_t   doorState;			// 1: alles zu  200: t?r offen + bit1(S) +bit2(CB) + bit3(CB)
+        uint8_t	doorWasOpened;		// 1: all doors are closed   200: any door was just opened
+        uint8_t	changer;			// can only be tested by usage
+
+        uint8_t   coinBlocker;		// can only be tested by usage
+        uint8_t   billReader;			// can only be tested by usage
+        uint8_t   ResetReason;
+        uint8_t	allModulesChecked;
+
+        uint8_t   alarmState;
+        uint8_t   res11;
+        uint8_t   res12;
+        uint8_t   res13;
+
+};
+
+struct T_dynamicCondition
+{
+        char allDoorsDebounced;
+        char openedAuthorized;
+        uint8_t CBinDebounced;  // 0:fehlt  1:drin
+        char upperDoor;         // 99: undefined  0:closed  1:open
+        char middleDoor;		// 99: undefined  0:closed  1:open
+        char lowerDoor;         // 99: undefined  0:closed  1:open
+        char reserve;
+        char billBox;
+        char modeAbrech;
+        char onAlarm;           // 0:alarm aus  1:alarm  2:alarm mit Sirene   3: Sirenentest
+        char nowCardTest;
+        char nowPayment;        // not used, always 0
+        char lastMifCardType;
+        uint8_t lastSDoorState;
+        uint8_t lastVDoorState;
+        uint8_t lastCBstate;
+        char        paymentInProgress;
+        //	0: stopped by timeout
+        //  1: running  2: wait4lastCoin
+        //				3: payment stopped manually, coins in Escrow
+        //			    4: payment stopped autom, amount collected, coins in Escrow
+        //			    5: payment stopped, escrow full, coins in Escrow
+        //			    6: coins encashed   7:coins returned
+        //				8: CoinChecker or MDB on Error
+
+
+        char        res1;
+        uint16_t    U_Batt;
+        uint16_t	Temperatur;
+        uint16_t	nrCoinsInBox;
+        uint32_t	amountInBox;
+        uint32_t	totalTransVolume;
+        uint32_t	totalNrOfVends;
+        char        jsonValid_config;
+        char        jsonValid_device;
+        char        jsonValid_cash;
+        char        jsonValid_print;
+        char        jsonValid_serial;
+        char        jsonValid_time;
+        char        lastFileType;
 // 44
-    uint8_t     MifCardHolder[8];
+        uint8_t     MifCardHolder[8];
-    uint8_t     resultOfLastTemplPrint;
+        uint8_t     resultOfLastTemplPrint;
-                // 0: unknown or printing in progress
+                    // 0: unknown or printing in progress
-                // 1: OK, doc was printed   2: error, doc was not printed
+                    // 1: OK, doc was printed   2: error, doc was not printed
-    uint8_t     lastPrinterStatus;
+        uint8_t     lastPrinterStatus;
-                //        0: printer OK
+                    //        0: printer OK
-                //          bit0: near paper end          bit1: no paper
+                    //          bit0: near paper end          bit1: no paper
-                //          bit2: temperature error       bit3: error head open
+                    //          bit2: temperature error       bit3: error head open
-                //          bit4: paper jam in cutter
+                    //          bit4: paper jam in cutter
-                //          bit6: no response             bit7: serial rec. error
+                    //          bit6: no response             bit7: serial rec. error
-                //			bit5: printer not ready
+                    //			bit5: printer not ready
-    uint8_t     startupTestIsRunning;
+        uint8_t     startupTestIsRunning;
-    //54
+
+        //54
 };
 
-struct T_extTime {
+struct T_extTime
+{
     uint8_t     Hours;
     uint8_t     Min;
     uint8_t     Sec;
@@ -258,8 +303,10 @@ struct T_extTime {
     uint8_t     res4;
     uint16_t    res5;
     uint32_t    MinutesOfMillenium;
+
 };
 
+
 typedef uint8_t UCHAR;
 typedef uint16_t UINT;
 
@@ -268,7 +315,7 @@ struct T_devices
     // set by master, used(1) or notused (0) or type 2....20
 
     UCHAR   kindOfPrinter;			// 0:off   1:Gebe
-    UCHAR	kindOfCoinChecker;		// 0: without  1=EMP820   2=EMP900    3=currenza c²	(MW)
+    UCHAR	kindOfCoinChecker;		// 0: without  1=EMP820   2=EMP900    3=currenza c²	(MW)
     UCHAR	kindOfMifareReader;		// by now only stronglink SL025 =1
     UCHAR   suppressSleepMode;		// 0:sleep allowed   1: no sleep
 
@@ -293,14 +340,14 @@ struct T_devices
 };
 
 
-class hwinf {
-public:
-    enum class DownloadResult {OK, ERROR, TIMEOUT, NOP};
-    enum class FileTypeJson {CONFIG=1, DEVICE, CASH, SERIAL, TIME, PRINTER};
 
+class hwinf
+{
+
+public:
     virtual ~hwinf() {}
                
-    virtual QStringList dc_getStatus() const = 0;
+    
                                            
     // $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$    
     //       Use serial interface and protocol stack in Cashagent-Library
@@ -310,18 +357,18 @@ public:
     //      Furthermore the Cashagent-Library answers with status strings about sending and reading result
     // $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
 
-    virtual bool dc_openSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect) const = 0;
+    virtual bool dc_openSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect)  const =0;
         // Command: open serial interface
         // BaudNr:  0:1200   1:9600   2:19200   3:38400   4:57600   5:115200
         // BaudStr: for exapmle "19200"
         // ComName: for example "COM48"
         // connect: 0, 1
 
-    virtual bool dc_closeSerial(void) const = 0;
+    virtual void dc_closeSerial(void)  const =0;
         // Command: close serial interface in order to save power while power down
         // or if another port must be used
         
-    virtual bool dc_isPortOpen(void) const =0;
+    virtual bool dc_isPortOpen(void)  const =0;
         // returns true if port open (don't send unless open. Sending to closed port will crash program)
                    
         
@@ -332,21 +379,7 @@ public:
     
     virtual bool test_serialIsOn(void) const =0;      
         
-    virtual bool dc_updateDC(QString binFileName,
-                             QString baudrate,
-                             QString comPort) const = 0;
-        // download binary file down into device controller
         
-    virtual bool dc_updatePrinterTemplate(enum FileTypeJson type,
-                                          QVector<int> templateIdx,
-                                          QVector<QString> fnames,
-                                          QString br,
-                                          QString serial = QString()) const = 0;
-
-    virtual bool dc_printTemplate(enum FileTypeJson type,
-                                  QVector<int> templateIdx,
-                                  QString br,
-                                  QString serial = QString()) const = 0;
                        
     virtual void dc_autoRequest(bool on)  const =0;
         // on = true:  select that all READ-Requests are sent automatically 
@@ -363,7 +396,7 @@ public:
         // get data back in "payLoad", max 64 byte, can be used for diagnosis
         // retval = nr of bytes received. If host buffer too small then
         // only plBufSiz bytes are copied to "payLoad"
-        // plBufSiz­z=size of host buffer
+        // plBufSiz­z=size of host buffer
                             
     virtual void dc_requTestResponse()  const =0;
         // tell DC2 to send a test-string, useful to see if cable and baudrate is OK
@@ -484,10 +517,10 @@ public:
 
     // Analog values:
     virtual uint32_t dc_getTemperature(void)  const =0;       
-        // in Sax-Format 0...400 (0=-50,0°C    100=0,0°C    141=20,5°C    400=150,0°C)
+        // in Sax-Format 0...400 (0=-50,0°C    100=0,0°C    141=20,5°C    400=150,0°C)
     
     virtual QString  dc_getTemperaturStr(void)  const =0;
-        // as string like "-12,5°C"
+        // as string like "-12,5°C"
         
     virtual uint32_t dc_getVoltage(void)  const =0;           
         // as value in mV,  0...65,535V
@@ -642,7 +675,7 @@ public:
                             uint8_t kindOfModem,        uint8_t kindOfCredit        ) const =0;
         // enable hardware in device controller:
         // kindOfPrinter:       0:off 1: GPT4672 (only this one implemented)
-        // kindOfCoinChecker:   0:off 1:EMP820 2:EMP900 3: C²_changer
+        // kindOfCoinChecker:   0:off 1:EMP820 2:EMP900 3: C²_changer
         // kindOfMifareReader:  0:off 1: SL025   (only this one implemented)
         // suppressSleep:       0:sleep allowed 1: sleep surpressed for special reason
         // kindOfModem:         0:off 1: ATB_Sunlink_LTE        (not yet implemented)
@@ -748,7 +781,7 @@ public:
         // send 5 byte: byte 0,1: speed  5...250 mm/s
         //              byte2: density   0....(25)....50
         //              byte3: alignment    'l', 'c', 'r' = left, center, right
-        //              byte4: orientation  0, 90, 180    = 0°, 90°, 180° rotation (by now not supported!)
+        //              byte4: orientation  0, 90, 180    = 0°, 90°, 180° rotation (by now not supported!)
         // not batched! don't use twice within 100ms
 
     virtual void prn_movePaper(uint8_t wayInMm, uint8_t direction) const =0;
@@ -806,29 +839,36 @@ public:
     // up to 8 dynamic values can be defined in the template ("print val3 here") and will be sent with printing command
     // example: print current time at this point (the time of printing not the storage time!!)
 
-    virtual void pri_startTicketDesign(void) const =0;
+    // obsolete
+    //virtual void pri_startTicketDesign(void) const =0;
         // start for every new printer document, reseting collecting buffer
 
     // all further functions write/append text, numbers and command to the ticket-buffer, up to 1278 bytes allowed
     // return val of the appending functions: true=ok false=too long, buffer full
 
-    virtual int pri_TD_getCurrentSize(void) const =0;
+    // obsolete
+    //virtual int pri_TD_getCurrentSize(void) const =0;
         // retval: 0...1278
 
-    virtual bool pri_TD_addText(QByteArray text) const =0;
+    // obsolete
+    //virtual bool pri_TD_addText(QByteArray text) const =0;
         // example: pri_TD_addText("Hello") const =0;
         // example: pri_TD_addText(tempStr) const =0;
         // retval: true=ok false=too long, buffer full
 
-    virtual bool pri_TD_addValue(int val) const =0;
+    // obsolete
+    //virtual bool pri_TD_addValue(int val) const =0;
         // +/- 0...2^(31)
 
-    virtual bool pri_TD_addNewLine(void) const =0;
+    // obsolete
+    //virtual bool pri_TD_addNewLine(void) const =0;
 
-    virtual bool pri_TD_addSign(char sign) const =0;
+    // obsolete
+    //virtual bool pri_TD_addSign(char sign) const =0;
         // example: '.'   ' '   0x20 'W' '$'
 
-    virtual bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const =0;
+    // obsolete
+    //virtual bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const =0;
         // always add 8 byte to the ticket layout:  ESC & group & attribute & parameter1...5
         /* complete list of possible commands:
             group 50 : paper
@@ -869,11 +909,13 @@ public:
 
     */
 
-    virtual char prn_clearDocument(uint8_t documentNumber) const =0;
+    // obsolete
+    //virtual char prn_clearDocument(uint8_t documentNumber) const =0;
         // clear memory buffer for ONE document
         // function takes a second! don't send right before "store doc"
 
-    virtual bool prn_store_Document(uint8_t documentNumber ) const =0;
+    // obsolete
+    //virtual bool prn_store_Document(uint8_t documentNumber ) const =0;
         // send the predefined Layout (generated with above TD functions) to DeviceController to save
         // documentNumber=0...15
         // maximal 1280 bytes each
@@ -884,7 +926,8 @@ public:
     // the place in the ticket layout is predefined (already in DC memory)
     // the dynamics are first calculated at printing time
 
-    virtual bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const =0;
+// obsolete
+    //virtual bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const =0;
 
 
 // 36
@@ -1276,10 +1319,10 @@ public:
 
     virtual void bl_rebootDC(void) const =0;
 
-    virtual void bl_startBL(void) const = 0;
+    virtual void bl_startBL(void) const =0;
         // send command within 4s after DC power-on, otherwise bl is left
 
-    virtual bool bl_checkBL(void) const = 0;
+    virtual void bl_checkBL(void) const =0;
         // send command to verify if bl is up
 
     virtual bool bl_isUp(void) const =0;
@@ -1316,7 +1359,7 @@ public:
 
 
     // Komplett-schreib Funktion, noch nicht getestet
-    // Nachteil: keine Rückmeldung wie lang's noch dauert
+    // Nachteil: keine Rückmeldung wie lang's noch dauert
     //virtual void bl_startSending(void) const=0;
         // call once after BL is working and file is loaded
     //virtual void bl_sendFile(void) const=0;
@@ -1342,7 +1385,7 @@ public:
     buf[4]=GlobTime.Month;
     buf[5]=GlobTime.Day;
     buf[6]=GlobTime.DOW;
-    buf[7]=' ';                   // immer auf 32bit auffüllen sonst Speicherproblem beim Master!
+    buf[7]=' ';                   // immer auf 32bit auffüllen sonst Speicherproblem beim Master!
     uitmp=GlobTime.MinOfDay;
     buf[8]=swl_getOneByteFromUint(uitmp, 0);
     buf[9]=swl_getOneByteFromUint(uitmp, 1);
@@ -1453,6 +1496,15 @@ public:
         // 17.4.23TS: extended to 32bit
 
     virtual uint8_t cash_paymentProcessing(void) const=0;
+        // run this function periodically while coin payment process to generate necessary signals
+        // return value:
+        // 0: stopped   1: starting up   2: coin collection
+        // 3: finished by User (Push button)  4: finished, Max-Value collected
+        // 5: finished by escrow
+        // 10,11: error cannot start
+        // 12: timeout while payment, coins returned
+        // 13: stopped by unexpected error
+
 
     virtual uint32_t getInsertedAmount(void) const=0;
 
@@ -1484,14 +1536,14 @@ public:
         // retval: 6 bytes, bit coded, 1=event keeps DC awake
 
     virtual uint8_t sys_getWakeReason(void) const=0;
-         // Master was woken by following reason:
+        // Master was woken by following reason:
-         // 1: MDB Event
+        // 1: MDB Event
-         // 2: Coin Event
+        // 2: Coin Event
-         // ( 3: Master Event) - will not set the wake line
+        // ( 3: Master Event) - will not set the wake line
-         // ( 4: 32s pulse) - will not set the wake line
+        // ( 4: 32s pulse) - will not set the wake line
-         // 5: Door Event
+        // 5: Door Event
-         // ( 6: Diag Event) - will not set the wake line
+        // ( 6: Diag Event) - will not set the wake line
-         // 7: 30min-Pulse for HB
+        // 7: 30min-Pulse for HB
 
     virtual void sys_getDeviceConditions(uint8_t *leng, uint8_t *data) const=0;
     /*
@@ -1530,6 +1582,8 @@ public:
      */
 
     virtual void sys_getDeviceConditions(struct T_moduleCondition *devCond) const=0;
+
+
     virtual void sys_getDynMachineConditions(uint8_t *leng, uint8_t *data) const=0;
 /*
 
@@ -1602,8 +1656,10 @@ public:
 
     virtual uint16_t cash_getNrCoinsInVault(void) const=0;
 
-
     virtual uint8_t prn_getPrintResult() const=0;
+        // return:  0: unknown
+        //          1: OK - last template was printed succesful
+        //          2: error - last template was not printed
 
     // in case of print-error get detailed error:
     virtual uint8_t prn_getCurrentPrinterState() const=0;
@@ -1614,62 +1670,32 @@ public:
         //          bit6: no response             bit7: serial rec. error
         //			bit5: printer not ready
 
+
     virtual void sys_sendDeviceParameter(struct T_devices *deviceSettings) const=0;
 
     virtual void sys_restoreDeviceParameter(struct T_devices *deviceSettings) const=0;
 
     virtual bool sys_areDCdataValid(void) const=0;
 
-    /* ---------------------------------------------------------------------------------------------
+    virtual bool sys_sendingTest(void) const =0;
-    // ------------   supervise  all hardware components
-    // ------------    assess the machine state
 
-    1. check if DC startup test is through, retrigger if not
+    virtual void prn_requestCurrentDynData(void) const =0;
-    2. get results and find errors
-    3. in case of error check if component is used (e.g. billreader is seldom used)
-    4: check doors
-    5. return value: 0: no response from DC
-                     1: no Test results and Test not running. need retrigger!
-                     2: state not clear by now, test ongoing, wait
-                     3: Service or battery door is open, goto INTRUSION MODE
-                            from here: after valid ID-card goto SERVICE MODE
-                     4: vault door is open, goto INTRUSION MODE
-                            from here: after valid ID-card and vault door closed goto TEST MODE
-                            in TEST MODE: complete system check decides if vending mode allowed
-                     5: All doors are closed but errors found,
-                            goto OOO MODE (out-of-order)
-                            from here: run system test until problem is fixed
-                     6: All doors are closed, no error, maybe warnings,
-                            goto VENDING MODE (normal operation)
-                    (priority sinks from 0 to 6)
 
-     --------------------------------------------------------------------------------------------- */
+    virtual bool prn_getCurrentDynamicPrnValuesFromDC(uint8_t *dynPrnVal ) const =0;
+        // which was sent with: bool prn_sendDynamicPrnValues(uint8_t *dynPrnVal ) const override;
 
-    virtual uint8_t sys_componentAssessment(void) const=0;
+    virtual bool prn_dynDataAreEqual(uint8_t *buf) const =0;
-    // this function decides if vending mode is possible, independant from door
-    // return >0 in case of error
-    // is inncluded in sys_superviseSystem
 
-    virtual uint8_t sys_superviseSystem(void) const=0;
+    virtual bool prn_printKombiticket(uint8_t nrOfKombi) const=0;
-    // this function proofs if vending is possible depending of doors state
+        // print four of the templates loaded by Json prior
-
+        // nr = 1..8
-    virtual uint8_t sys_getSystemErrors(void) const=0;
 
 
-    // retrigger System-Check with:
+    virtual void lock_triggerUpperSolenoid(void) const =0;
-    // bool hwapi::sys_runCompleteTest(void) const
 
+    virtual void lock_triggerLowerSolenoid(void) const =0;
 
 
-
-
-
-
-
-    // ---------------------------------------------------------------------------------------------
-    // ---------------------------------------------------------------------------------------------
-    // ---------------------------------------------------------------------------------------------
-
 signals:
     virtual void hwapi_templatePrintFinished_OK(void) const=0;
     virtual void hwapi_templatePrintFinished_Err(void) const=0;
@@ -1707,12 +1733,19 @@ signals:
 // 14.04.2023: V3.4 new features extended: sys_getDynMachineConditions, sys_getDeviceConditions and
 //                    rtc_getExtendedTime return struct in addition. New function to select and get VaultRecord
 //
+// 19.04.2023: V3.5 new function: sys_getWakeReason();
+// 17.05.2023: V3.6 new function: cash_isCollectionActive(), cash_isPayProcessActive()
+//                  new signals:  hwapi_coinCollectionJustStopped, hwapi_coinCollectionJustStarted
+//                  getAllInsertedCoins() fixed, also in datif and storeINdata
+
+
 
 //#define HWINF_iid "Atb.Psa2020.software.HWapi/3.1"
 //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.1"
 //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.3"
 //#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.4"
-#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.5"
+//#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.5"
+#define HWINF_iid "Atb.Psa1256ptu5.software.HWapi/3.6"
 
 
 

src/ATBAPP/ATBAPPplugin.h

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

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

src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -1,125 +0,0 @@
-#ifndef ATBDEVICECONTROLLERPLUGIN_H
-#define ATBDEVICECONTROLLERPLUGIN_H
-
-#include <QObject>
-
-#include "src/ATBAPP/DeviceControllerInterface.h"
-#include "src/ATBAPP/ATBAPPplugin.h"
-#include "version.h"
-
-
-
-#include "hwapi.h"
-
-#include <unistd.h>
-#include <thread>
-#include <memory>
-#include <QSharedMemory>
-
-
-class QTextCodec;
-
-
-using namespace nsDeviceControllerInterface;
-
-class QSettings;
-
-class ATBDeviceControllerPlugin : public QObject,
-        public DeviceControllerInterface
-{
-    Q_OBJECT
-    Q_INTERFACES(ATBAPPplugin)
-    Q_INTERFACES(DeviceControllerInterface)
-    #if QT_VERSION >= 0x050000
-    Q_PLUGIN_METADATA( IID "ATBDeviceControllerPlugin" )
-    #endif
-
-public:
-    explicit ATBDeviceControllerPlugin(QObject *parent = nullptr);
-    ~ATBDeviceControllerPlugin();
-
-    // ----------------------------------------------------------------------------
-    // interface:
-    PLUGIN_STATE initDCPlugin(QObject *healthEventReceiver, const QSettings & settings);
-
-    // TASKS: Cash handling -------------------------------------------------------
-    void requestStartCashInput(const QString & amount);
-    void requestStopCashInput();
-    void cashCollect();
-    void cashAbort();
-
-    // TASKS: printing ------------------------------------------------------------
-    void requestPrintTicket(const QHash<QString, QVariant> & printingData);
-
-    // mandantory ATBAPP plugin methods: ------------------------------------------
-    nsDeviceControllerInterface::PLUGIN_STATE getState();
-    QString & getLastError();
-    const QString & getLastErrorDescription();
-
-    const QString & getPluginInfo();
-
-    // helpers e.g. for debug / log
-    const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState);
-
-
-
-
-
-signals:
-    void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
-                                     const QString & errorCode,
-                                     const QString & errorDescription);
-
-    void cashInputEvent(nsDeviceControllerInterface::RESULT_STATE resultState,
-                        nsDeviceControllerInterface::CASH_STATE cashState,
-                        const QString & newCashValue,
-                        const QString & errorCode,
-                        const QString & errorDescription);
-
-    void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
-                                     const QString & newCashValue,
-                                     const QString & errorCode,
-                                     const QString & errorDescription);
-
-    void requestServiceMode();
-
-    void Error(
-            const QString & errorCode,
-            const QString & errorDescription);
-
-
-
-
-private:
-   QString errorCode;
-   QString errorDescription;
-   QString pluginInfo;
-
-   int currentTemplate;
-
-
-   bool useDebug;
-
-   PLUGIN_STATE pluginState;
-
-   QObject* healthEventReceiver;
-
-   hwinf* hw;
-
-   QTextCodec *codec;
-
-private slots:
-   // printer
-
-   void onPrinterDataPrepared();
-   void onPrinterPrintNextTemplate();
-
-   void onPrintFinishedOK();
-   void onPrintFinishedERR();
-
-   // cash payment
-   void onCashGotCoin();
-   void onCashVendStopByMax();
-};
-
-#endif // ATBDEVICECONTROLLERPLUGIN_H

src/ATBAPP/ATBHealthEvent.cpp

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

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

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

src/com.cpp

@@ -19,7 +19,7 @@ void T_com::writeToSerial(const QByteArray &data, uint16_t sendLength)
     sendLen=sendLength;
     if (CatSerial->isOpen())
     {
-        qCritical() << "sending..." << sendBuffer;
+        //qDebug() << "sending..." << sendBuffer;
         CatSerial->write(sendBuffer);
     } else
         qDebug() << "error sending, port is not open";
@@ -93,34 +93,29 @@ T_com::~T_com()
 
 void T_com::ser_ISR100ms()
 {
-    //qDebug() << "~~>LIB" << "ENTER...";
     // call every 100ms to check if user(HMI) wants to connect or disconnect
+
+    //qDebug() << "~~>LIB" << "checking connect button... " ;
+
     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()) {
+    if (CatSerial->isOpen())
         gpi_serialIsOpen(true);
-    } else {
+    else
         gpi_serialIsOpen(false);
-    }
 
-    //qDebug() << "LEAVE " << chkConn;
 }
 
 // -------------------------------------------------------------------------------------------------------------
@@ -129,24 +124,17 @@ void T_com::ser_ISR100ms()
 
 char T_com::open_Serial_Port()
 {
-    //qDebug() << "ENTER";
-
     bool ret;
     QString myString=nullptr, myPortName=nullptr, myBaudStr=nullptr;
     int myBaudNr;
 
-    if (CatSerial->isOpen()) {
+    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
@@ -179,9 +167,6 @@ char T_com::open_Serial_Port()
         myString.append(CatSerial->errorString());
         qDebug() << myString;
         gpi_setTxt4comStateLine(myString);
-
-        //qDebug() << "LEAVE";
-
         return 0;
     } else
     {
@@ -197,14 +182,11 @@ char T_com::open_Serial_Port()
 
     }
 
-    //qDebug() << "LEAVE";
+     return 0;
-    return 0;
 }
 
 void T_com::closeSerialPort()
 {
-    //qDebug() << "ENTER";
-
     if (CatSerial->isOpen())
     {
         qDebug() << "closing connection";
@@ -213,8 +195,6 @@ void T_com::closeSerialPort()
         gpi_setTxt4RsDiagWin("closed");
 
     }
-
-    //qDebug() << "LEAVE";
 }
 
 

src/controlBus.cpp

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

src/datIf.cpp

@@ -3,13 +3,16 @@
 #include "controlBus.h"
 #include "storeINdata.h"
 #include <QDebug>
+#include <datei.h>
+#include <QDir>
+
 
 // called from MainWindow()
 
 
 #define     DATIF_MAXCMDS        16
 static uint8_t dif_dataStep;
-static uint8_t dif_scanStep, RDBLKNR;
+static uint8_t dif_scanStep;    //, RDBLKNR;
 
 
 static uint8_t datif_OutCmdpara1, datif_OutCmdpara2, datif_OutCmdpara3, datif_OutCmdpara4;
@@ -17,10 +20,13 @@ static uint16_t datif_OutCmdpara5;
 static uint32_t datif_OutCmdpara6;
 static uint8_t cycl_running;
 
-//static bool     datif_DCdataValid;
-
 T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
 {
+    QByteArray myBA;
+    QDir myDir("../dmd");
+
+    if (!myDir.exists())
+        myDir.mkdir("../dmd");
 
     myDCIF = new T_prot();
 
@@ -34,7 +40,7 @@ T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
     datif_trigger = new QTimer();
     connect(datif_trigger, SIGNAL(timeout()), this, SLOT(datif_cycleSend()));
     datif_trigger->setSingleShot(false);
-    datif_trigger->start(10);     // in ms, 80 gut, default 100   50....200
+    datif_trigger->start(10);     // in ms,
 
     // passing Signal through
     //connect(myDCIF, SIGNAL(framerecieved()), this, SLOT( ResponseRecieved() ));
@@ -48,9 +54,30 @@ T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
     dif_scanStep=0;
     selectedSlaveAddr=FIX_SLAVE_ADDR;
     cycl_running=0;
-    //datif_DCdataValid=0;
     gpi_storeDcDataValid(0);
     datif_noResponseCtr=0;
+
+
+    // neu, 24.5.23: Alle Daten zusätzlich in Datei speichern
+//    if (datei_ifFileExists(FILENAME_SHAREDDATA))
+//    {
+//        myBA.clear();
+//        myBA=datei_readFromFile(FILENAME_SHAREDDATA);
+//    }
+
+    // Testfile ereugen:
+    csv_startCreatingFile();
+    csv_addUintToFile(0);
+    csv_addUintToFile(1);
+    csv_addUintToFile(2);
+    csv_addUintToFile(3);
+    csv_addUintToFile(4);
+    csv_addUintToFile(5);
+    myBA=csv_readbackArray();
+    datei_clearFile(FILENAME_SHAREDDATA);
+    datei_writeToFile(FILENAME_SHAREDDATA, myBA);
+
+
 }
 
 void T_datif::resetChain(void)
@@ -72,7 +99,7 @@ char T_datif::datif_cycleSend()
 
     datif_noResponseCtr++;         // inc every 10ms    fehlt noch in SysCont
     if (datif_noResponseCtr>500)    // seit 5s kein Lebenszeichen von DC2
-        gpi_storeDcDataValid(0);    // fehlt in SysCont
+        gpi_storeDcDataValid(0);
 
 
     if (cycl_running)
@@ -105,7 +132,23 @@ char T_datif::datif_cycleSend()
 
                 //void myDCIF->sendUserData(uint16_t slaveAdr);
 
-            if (check4FDshortCmd())
+            if (checkNextFDcmd()==2)
+            {
+                b_ret=longFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &length, data);
+                if (b_ret)
+                {
+                    myDCIF->setUserWriteData(nextWrCmd, blockNum, length, data);
+                    myDCIF->setUserReadData(nextRdCmd);
+                    myDCIF->sendUserData(selectedSlaveAddr);
+                    //qDebug()<<"Datif send long cmd "<<nextWrCmd<< " " <<nextRdCmd<< " " <<length << " " << data[0]<< " " << data[1]
+                    //         << " " << data[2]<< " " << data[3]<< " " << data[4]<< " " << data[5]<< " " << data[6]<< " " << data[7]
+                    //         << " " << data[8]<< " " << data[9]<< " " << data[10]<< " " << data[11]<< " " << data[12];
+                }
+                cycl_running=1;
+                return 0;
+            } else
+
+            if (checkNextFDcmd()==1)
             {
                 b_ret=sendFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &dat1, &dat2, &dat3, &dat4);
                 if (b_ret)
@@ -114,19 +157,18 @@ char T_datif::datif_cycleSend()
                     myDCIF->setUserWriteData(nextWrCmd, blockNum, 4, data);
                     myDCIF->setUserReadData(nextRdCmd);
                     myDCIF->sendUserData(selectedSlaveAddr);
+                    //qDebug()<<"Datif send short cmd "<<nextWrCmd<< " " <<nextRdCmd;
                 }
+                cycl_running=1;
+                return 0;
             }
 
-            if (check4FDlongCmd())
+
-            {
+
-                b_ret=longFDcmd_get(&nextWrCmd, &nextRdCmd, &blockNum, &length, data);
+
-                if (b_ret)
+
-                {
+
-                    myDCIF->setUserWriteData(nextWrCmd, blockNum, length, data);
+
-                    myDCIF->setUserReadData(nextRdCmd);
-                    myDCIF->sendUserData(selectedSlaveAddr);
-                }
-            }
 
             // direct commands have highest prio (setting OUTPUTS)
             nxtAsCmd=sendWRcmd_getSendCommand0();       // command was stored by Gui
@@ -320,6 +362,7 @@ void T_datif::sendWRcommand(uint16_t nextWrCmd)
             datif_sendIOrequest(CMD2DC_FAN, CMD2DC_RdBkAllOutputs, 1);
             break;
         case SENDDIRCMD_LAERM:
+//qDebug()<<"datif switch siren";
             datif_sendIOrequest(CMD2DC_SIREN, CMD2DC_RdBkAllOutputs, 1);
             break;
         case SENDDIRCMD_REL1:           
@@ -742,7 +785,7 @@ char T_datif::sendINrequestsAutomatic(void)
             break;
 
         case 12:
-            if (indat_isPrinterOn())
+            //if (indat_isPrinterOn())
                 datif_sendIOrequest(0, CMD2DC_RdBk_AllPrnData, 0);      // 27
             //  datif_sendIOrequest(0, CMD2DC_RdBk_PrnState, 0);
             break;
@@ -752,7 +795,7 @@ char T_datif::sendINrequestsAutomatic(void)
             break;
 
         case 14:
-            if (indat_isMifareOn())
+            //if (indat_isMifareOn())
             {
                 datif_sendIOrequest(0, CMD2DC_RdBk_MifState, 0);    // 109
                 //qDebug()<<"requesting MIF reader state";
@@ -765,6 +808,7 @@ char T_datif::sendINrequestsAutomatic(void)
             break;
 
         case 16:
+            /*
             if (indat_isMifareOn())
             {
                 datif_OutCmdpara1=0;    // data block number 0 contains the Mifare-ID
@@ -774,7 +818,8 @@ char T_datif::sendINrequestsAutomatic(void)
                     RDBLKNR=0;
                 datif_OutCmdpara1=RDBLKNR;
 
-            } break;
+            }*/
+            break;
 
         case 17:
             //datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
@@ -782,7 +827,7 @@ char T_datif::sendINrequestsAutomatic(void)
             break;
 
         case 18:
-            if (indat_isMdbOn())
+            //if (indat_isMdbOn())
                 datif_sendIOrequest(0, CMD2DC_MDB_GET_STATE, 0);        // 107
             //else
             //    dif_scanStep=24;  unsinn
@@ -829,7 +874,7 @@ char T_datif::sendINrequestsAutomatic(void)
 
     dif_scanStep++;
     if (dif_scanStep>26)
-        dif_scanStep=5;
+        dif_scanStep=0;   // dif_scanStep=5;
 
 return 0;
 
@@ -862,7 +907,10 @@ void T_datif::StoredRecData()
         // "neu" is the same as "INdataValid"
         loadRecDataFromFrame();
     }
-    cycl_running=0;
+    //cycl_running=0;   // send next cmd immediately
+    cycl_running=9;     // send next cmd after 10ms
+                        // wichtig! bei 0 werden Telegramme verschluckt!   24.5.2023
+                        // 9 ergibt 16ms   Formel: gap = 110ms (Zeile 80) - cycl_running*10ms
 }
 
 char T_datif::loadRecDataFromFrame()
@@ -887,20 +935,14 @@ char T_datif::loadRecDataFromFrame()
     ret=myDCIF->getReceivedInData(&SlaveAdr, &readSource, &readAddress,  &RdDleng, receivedData);
         // retval: data valid, only one time true, true if CommandState OK and readState OK
     gpi_storeResultOfLastRequest(ret);
-
-
-    qCritical() << "loadRecDataFromFrame() readSource = " << readSource;
-
     if (ret==false)
     {
-        qCritical() << "datif: rec data not valid";
+     //   qDebug() << "datif: rec data not valid";
         return 0;
     }
 
     gpi_storeRecPayLoad(RdDleng, receivedData); //  save for host (user of hwapi)
 
-
-    qCritical() << "loadRecDataFromFrame() readSource = " << readSource;
     //qDebug() << "\n datif: got valid data, rdsrc:" << readSource << "  rdadd:" << readAddress
      //        << "  rdlen:" << RdDleng;
 //    qDebug("datif_recData: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
@@ -1042,7 +1084,7 @@ char T_datif::loadRecDataFromFrame()
         //<< receivedData[3] << " " << receivedData[4] << " " << receivedData[5];
 
             uctmp=receivedData[0];
-           // qDebug()<<"datif single bits: "<< (uctmp&1) << (uctmp&2) << (uctmp&4);
+      //qDebug()<<"datif DOOR bits: "<< (uctmp&1) << (uctmp&2) << (uctmp&4);
             gpi_storeDI_doorSwitches(uctmp&1, uctmp&2, uctmp&4);
 
             gpi_storeDI_vaultSwitches(uctmp&8, uctmp&16);
@@ -1071,8 +1113,6 @@ char T_datif::loadRecDataFromFrame()
             gpi_storeDI_GsmPowerIsOn(uctmp&16);
             gpi_storeDI_CreditPowerIsOn(uctmp&32);
             gpi_storeDI_PrinterPowerIsOn(uctmp&64);
-
-            //gpi_storeMdbState(uctmp&4, uctmp&128, uctmp&4);   // hat ein eigenes Cmd weiter unten!
             gpi_storeDI_MdbPowerIsOn(uctmp&128);
 
              gpi_storeDI_paperLow(receivedData[5]);
@@ -1200,10 +1240,11 @@ char T_datif::loadRecDataFromFrame()
     case CMD2DC_MDB_GET_STATE:      //107
         // DB0: mdb_bus_ready (switched on)
         // DB1: rdBackV12devicePower
-        // DB2: rdBackV5busPwr
+        // DB2: rdBackV5busPwr          kommt immer mit 1
 
         //qDebug() << "got MDB state " << receivedData[0] << " " << receivedData[1] << " " << receivedData[2];
         gpi_storeMdbState(receivedData[0],receivedData[1],receivedData[2]);
+
         break;
 
     case CMD2DC_MDB_GETRESP:        //22
@@ -1218,7 +1259,7 @@ char T_datif::loadRecDataFromFrame()
         break;
 
     case CMD2DC_EMP_GET_ALL:        //23
-        qCritical() << "got emp parameters "<< receivedData[1];
+        //qDebug() << "got emp parameters "<< receivedData[1];
         gpi_storeEmpSettings(64, receivedData);
         break;
 
@@ -1404,7 +1445,6 @@ char T_datif::loadRecDataFromFrame()
             }
 qDebug()<<"   store new coin"<<newInsertedAmount<<" "<<uitmp<<" "<<uit2;
         }
-
         break;
 
     case 113:       // get wake source, 8byte
@@ -1514,7 +1554,6 @@ qDebug()<<"   store new coin"<<newInsertedAmount<<" "<<uitmp<<" "<<uit2;
     outBuf[pBuf++]=0;
 
 */
-
         if (RdDleng>40)
             //datif_DCdataValid=1;    // das hier sind die wichtigsten Daten, deshalb hierrein!
             gpi_storeDcDataValid(1);
@@ -1618,6 +1657,11 @@ struct T_vaultRecord
         gpi_storeVaultRecord(readAddress, receivedData );   // always 64byte
         break;
 
+    case 39:
+        gpi_storeDynData(receivedData);
+        break;
+
+
     }
     readSource=0;   // 17.05.2023: to avoid multiple recording
 

src/datei.cpp

@@ -0,0 +1,943 @@
+// written by Thomas Sax, Jan.2022
+#include "datei.h"
+
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ create csv file -------------------------------
+// -------------------------------------------------------------------------------------------------
+
+QByteArray datei_writeArray, datei_tempArray;
+
+void csv_startCreatingFile(void)
+{
+    datei_writeArray.clear();
+    datei_tempArray.clear();
+}
+
+void csv_addTextToFile(QString myText)
+{
+    datei_writeArray.append(myText.toLatin1());
+    datei_writeArray.append(FILESEPERATOR);
+}
+
+void csv_addIntToFile(int myValue)
+{
+    //qulonglong ullt=12345678901234567890;   // max 1,844 x10^19
+    datei_tempArray.setNum(myValue,10);  // accepted types: short, ushort, int, uint,
+                            // qlonglong, qulonglong, float, double
+                            // numerbase can be 2...36(!),10=dec
+
+    datei_writeArray.append(datei_tempArray);
+    datei_writeArray.append(FILESEPERATOR);
+}
+
+void csv_addUintToFile(uint myValue)
+{
+    datei_tempArray.setNum(myValue,10);
+    datei_writeArray.append(datei_tempArray);
+    datei_writeArray.append(FILESEPERATOR);
+}
+
+
+void csv_addLongvalToFile(qlonglong myValue)
+{
+    datei_tempArray.setNum(myValue,10);
+    datei_writeArray.append(datei_tempArray);
+    datei_writeArray.append(FILESEPERATOR);
+}
+
+void csv_addUlongvalToFile(qulonglong myValue)
+{
+    datei_tempArray.setNum(myValue,10);
+    datei_writeArray.append(datei_tempArray);
+    datei_writeArray.append(FILESEPERATOR);
+}
+
+/*
+void csv_addCurrentTimeToFile(void)
+{
+    uint8_t hour, minute, sec, ui8buf[20];
+    char buf[20];
+
+    config_getSysTime(&hour, &minute, &sec);
+    GetTimeString(hour, minute, sec, 0, 1, ui8buf);
+    for (uint8_t nn=0; nn<20; nn++)
+        buf[nn]=char(ui8buf[nn]);
+    datei_writeArray.append(buf,8);             // time string
+    datei_writeArray.append(FILESEPERATOR);
+
+}
+
+void csv_addCurrentDateToFile(void)
+{
+    uint16_t year;
+    uint8_t month, day, ui8buf[20];
+    char buf[20];
+
+    config_getSystemDate(&year, &month, &day);
+    //qDebug()<<"date year: "<<year;
+    GetDateString(day, month, 0x20, uint8_t(year%100), 0, 0, ui8buf);
+    for (uint8_t nn=0; nn<20; nn++)
+        buf[nn]=char(ui8buf[nn]);
+    datei_writeArray.append(buf, 10);            // date string
+    datei_writeArray.append(NEWLINEINFILE);
+
+}
+*/
+
+void csv_addNewlineToFile(void)
+{
+    datei_writeArray.chop(1);      // Komma weg
+    datei_writeArray.append(NEWLINEINFILE);
+}
+
+QByteArray csv_readbackArray(void)
+{
+    return datei_writeArray;
+}
+
+
+/*
+QByteArray csv_writeContent_testValues(void)
+{
+    QByteArray myBA, tmpBA;
+    uint8_t modCount=5, modAddr=23;
+    uint8_t hour, minute, sec, month, day, ui8buf[20];
+    uint16_t year, modType=45678;
+    char buf[20];
+    uint32_t modNrDIs=1234567890;
+    uint8_t  modNrAIs=4, modNrCtr=2, modNrDOs=8;
+    int       modNrAOs=-2;
+       
+    myBA.clear();
+    tmpBA.clear();
+    myBA.append("scan time");
+    myBA.append(FILESEPERATOR);
+    
+    datei_getSysTime(&hour, &minute, &sec);
+    GetTimeString(hour, minute, sec, 0, 1, ui8buf);        
+    for (uint8_t nn=0; nn<20; nn++)
+        buf[nn]=char(ui8buf[nn]);
+    myBA.append(buf,8);             // time string
+    myBA.append(FILESEPERATOR);
+    
+    datei_getSystemDate(&year, &month, &day);
+    //qDebug()<<"date year: "<<year;
+    GetDateString(day, month, 0x20, uint8_t(year%100), 0, 0, ui8buf);        
+    for (uint8_t nn=0; nn<20; nn++)
+        buf[nn]=char(ui8buf[nn]);          
+    myBA.append(buf, 10);            // date string
+    myBA.append(NEWLINEINFILE);
+    
+    myBA.append("number of modules");
+    myBA.append(FILESEPERATOR);
+    tmpBA.setNum(modCount,10);   //2nd para = number base 2, 8, 10 or 16 (bin, oct, dec, hex)
+    myBA.append(tmpBA);
+    myBA.append(NEWLINEINFILE);
+
+    myBA.append("busaddr");
+    myBA.append(FILESEPERATOR);
+    myBA.append("type");
+    myBA.append(FILESEPERATOR);
+    myBA.append("NrOfDI");
+    myBA.append(FILESEPERATOR);
+    myBA.append("NrOfAI");
+    myBA.append(FILESEPERATOR);
+    myBA.append("NrOfCtrIn");
+    myBA.append(FILESEPERATOR);
+    myBA.append("NrOfDO");
+    myBA.append(FILESEPERATOR);
+    myBA.append("NrOfAO");
+    myBA.append(NEWLINEINFILE);
+
+    tmpBA.setNum(modAddr,10);
+    myBA.append(tmpBA);
+    myBA.append(FILESEPERATOR);
+    tmpBA.setNum(modType,10);
+    myBA.append(tmpBA);
+    myBA.append(FILESEPERATOR);
+    tmpBA.setNum(modNrDIs,10);
+    myBA.append(tmpBA);
+    myBA.append(FILESEPERATOR);
+    tmpBA.setNum(modNrAIs,10);
+    myBA.append(tmpBA);
+    myBA.append(FILESEPERATOR);
+    tmpBA.setNum(modNrCtr,10);
+    myBA.append(tmpBA);
+    myBA.append(FILESEPERATOR);
+    tmpBA.setNum(modNrDOs,10);
+    myBA.append(tmpBA);
+    myBA.append(FILESEPERATOR);
+    tmpBA.setNum(modNrAOs,10);
+    myBA.append(tmpBA);
+    myBA.append(NEWLINEINFILE);
+    return myBA;
+}
+*/
+
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ parse csv file -------------------------------
+// -------------------------------------------------------------------------------------------------
+
+// first: QByteArray datei_readFromFile(QString filename);
+
+
+uint32_t csv_nrOfEntriesInFile(QByteArray readFromFile)
+{
+    // count sequences between FILESEPERATOR and NEWLINEINFILE    
+    uint32_t   filSize=0, pp=0;
+    char       oneByt=0;
+    
+    int  filLen=readFromFile.size();
+    if(filLen>1)
+        filSize=uint32_t(filLen);
+    else
+        return 0;
+        
+    // 1) find position of seperators
+    for (uint32_t ii=0; ii<filSize; ii++)
+    {
+        oneByt=readFromFile[ii];
+        if (oneByt==FILESEP1 || oneByt==FILESEP2 || oneByt==NEWLINEINFILE)
+            pp++;
+    }
+    // now: pp = number of seperators
+    // oneByt = last byte in file. If it's not a seperator then 
+    // there's one more entry (last entry without termination)
+    if (oneByt !=FILESEP1 && oneByt !=FILESEP2 && oneByt !=NEWLINEINFILE)
+        pp++;
+    //qDebug()<<"csv: nr of sequences="<< pp;
+    return pp;
+}
+
+QByteArray csv_getOneFileSequence(QByteArray sourceFile, uint32_t sequNr)
+{
+    // seperate file content in single sequences between FILESEPERATOR and NEWLINEINFILE
+    // and return "entryNr" - entry 
+    // for this first step leave data type QByteArray
+    // 2nd step can change in numbers and strings
+    QByteArray sequence;
+    uint32_t   sepPos[MAXNUMBEROFSEQUENCES];
+    uint32_t   filSize=0, pp=0, ii, start=0, ende=0;
+    char       oneByt;
+    int        filLen, mm; 
+    
+    filLen=sourceFile.size();
+    //qDebug()<<"fillen="<< filLen;
+    if(filLen<10)
+        return "";
+    filSize=uint32_t(filLen);
+
+    if (sequNr>MAXNUMBEROFSEQUENCES)
+        return "";    
+
+    // 1) find position of seperators
+    for (ii=0; ii<filSize; ii++)
+    {
+        oneByt=sourceFile[ii];
+        if (oneByt==FILESEP1 || oneByt==FILESEP2 || oneByt==NEWLINEINFILE)
+        {
+            sepPos[pp++]=ii;
+        }
+    }
+    // now: pp = number of entries
+    //qDebug()<<"nr of seperators="<< pp;
+
+    if (sequNr>=pp)
+        return "";
+
+    // 2) get sequence
+    if (sequNr==0)
+    {
+        start=0;
+        ende=sepPos[sequNr];        
+    } else
+    if (sequNr>0)
+    {
+        start=sepPos[sequNr-1]+1;
+        ende=sepPos[sequNr];    
+    }    
+
+    //qDebug()<<"datei getOneFileSequence start/ende: "<<start << " " << ende;
+    if (start>=ende)
+        return "";
+        //return "-err3-";
+    sequence.clear();
+    //batmp.clear();
+    pp=0;
+    for (ii=start; ii<ende; ii++)
+    {
+        mm=int(ii);
+        if (mm>=int(filSize))
+            mm=0;
+        oneByt=sourceFile.at(mm);
+        sequence.append(oneByt);
+    }    
+    return sequence;    
+}
+
+int csv_getEntryAsInt(QByteArray sourceFile, uint32_t sequNr)
+{
+    QByteArray myBA, myVA;
+    int        entry=0;
+    bool ok;
+
+    myVA.clear();
+    myBA = csv_getOneFileSequence(sourceFile, sequNr);
+    //qDebug()<<"datei getEntryAsInt, sequence: " << myBA;
+
+    entry=myBA.toInt(&ok,16);
+    if (ok)
+    {
+        //qDebug()<<"datei getEntryAsInt, number: " << entry;
+        return entry;
+    }
+    //qDebug()<<"datei getEntryAsInt, error " << myBA;
+    return 0;
+}
+
+int32_t csv_getEntryAsLong(QByteArray sourceFile, uint32_t sequNr)
+{
+    QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
+    long        entry=0;
+    bool ok;
+    
+    entry=myBA.toLong(&ok,10);
+    if (ok)
+        return entry;
+    return 0;
+}
+
+uint8_t csv_getEntryAsUshort(QByteArray sourceFile, uint32_t sequNr)
+{
+    QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
+    uint8_t        entry=0;
+    bool ok;
+    
+    entry=uint8_t(myBA.toUShort(&ok,10));
+    if (ok)
+        return entry;
+    return 0;
+}
+
+uint16_t csv_getEntryAsUint(QByteArray sourceFile, uint32_t sequNr)
+{
+    QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
+    uint16_t        entry=0;
+    bool ok;
+    
+    entry=uint16_t(myBA.toUInt(&ok,10));
+    if (ok)
+        return entry;
+    return 0;
+}
+
+uint32_t csv_getEntryAsUlong(QByteArray sourceFile, uint32_t sequNr)
+{
+    QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
+    uint32_t        entry=0;
+    bool ok;
+    
+    entry=myBA.toULong(&ok,10);
+    if (ok)
+        return entry;
+    return 0;
+}
+
+uint64_t csv_getEntryAs2Ulong(QByteArray sourceFile, uint32_t sequNr)
+{
+    QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
+    uint64_t        entry=0;
+    bool ok;
+    
+    entry=myBA.toULongLong(&ok,10);
+    if (ok)
+        return entry;
+    return 0;
+}
+
+
+
+QString csv_getEntryAsString(QByteArray sourceFile, uint32_t sequNr)
+{
+    QByteArray myBA = csv_getOneFileSequence(sourceFile, sequNr);
+    QString     entry;
+
+    //qDebug()<<"datei getEntryAsString, sequence: " << myBA;
+    entry=myBA.toStdString().c_str();
+    return entry;
+}
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ create Json file -------------------------------
+// -------------------------------------------------------------------------------------------------
+
+/*
+ example
+QString str = "{"
+                  "  \"Herausgeber\": \"Xema\","
+                  "  \"Nummer\": \"1234-5678-9012-3456\","
+                  "  \"Deckung\": 2e+6,"
+                  "  \"Währung\": \"EURO\","
+                  "  \"Inhaber\": {"
+                  "    \"Name\": \"Mustermann\","
+                  "    \"Vorname\": \"Max\","
+                  "    \"männlich\": true,"
+                  "    \"Hobbys\": [ \"Reiten\", \"Golfen\", \"Lesen\" ],"
+                  "    \"Alter\": 42,"
+                  "    \"Kinder\": [],"
+                  "    \"Partner\": null"
+                  "  }"
+                  "}";
+
+*/
+
+QString myJsonCon;
+QString tmpStr;
+
+void json_startRecord(void)
+{
+    myJsonCon.clear();
+    tmpStr.clear();
+    myJsonCon.append('{');
+}
+
+void json_enterIntToRecord(QString attribute, ulong i_value)
+{
+    tmpStr.clear();
+    myJsonCon.append('"');
+    myJsonCon.append(attribute);
+    myJsonCon.append('"');
+    myJsonCon.append(':');
+    tmpStr.setNum(i_value);
+    myJsonCon.append(tmpStr);
+    myJsonCon.append(',');
+    myJsonCon.append(NEWLINEINFILE);
+}
+
+void json_enterTextToRecord(QString attribute, QString txt_value)
+{
+    myJsonCon.append('"');
+    myJsonCon.append(attribute);
+    myJsonCon.append('"');
+    myJsonCon.append(':');
+    myJsonCon.append('"');
+    myJsonCon.append(txt_value);
+    myJsonCon.append('"');
+    myJsonCon.append(',');
+    myJsonCon.append(NEWLINEINFILE);
+}
+/*
+void json_addCurrentTimeToRecord(QString attribute)
+{
+    uint8_t hour, minute, sec, ui8buf[20];
+    //char buf[20];
+
+    myJsonCon.append('"');
+    myJsonCon.append(attribute);
+    myJsonCon.append('"');
+    myJsonCon.append(':');
+    myJsonCon.append('"');
+
+    datei_getSysTime(&hour, &minute, &sec);
+    GetTimeString(hour, minute, sec, 0, 1, ui8buf);
+    for (uint8_t nn=0; nn<8; nn++)
+        myJsonCon.append(ui8buf[nn]);
+
+    myJsonCon.append('"');
+    myJsonCon.append(',');
+    myJsonCon.append(NEWLINEINFILE);
+
+}
+
+void json_addCurrentDateToRecord(QString attribute)
+{
+    uint16_t year;
+    uint8_t month, day, ui8buf[20];
+    //char buf[20];
+
+    myJsonCon.append('"');
+    myJsonCon.append(attribute);
+    myJsonCon.append('"');
+    myJsonCon.append(':');
+    myJsonCon.append('"');
+
+    datei_getSystemDate(&year, &month, &day);
+    GetDateString(day, month, 0x20, uint8_t(year%100), 0, 0, ui8buf);
+    for (uint8_t nn=0; nn<10; nn++)
+        myJsonCon.append(ui8buf[nn]);
+
+    myJsonCon.append('"');
+    myJsonCon.append(',');
+    myJsonCon.append(NEWLINEINFILE);
+
+}
+*/
+
+void json_enterArrayToRecord(QString attribute, uint8_t *buf, ulong nrofVals)
+{
+    // add array of numbers with "nrofVals" elements
+
+    myJsonCon.append('"');
+    myJsonCon.append(attribute);
+    myJsonCon.append('"');
+    myJsonCon.append(':');
+    myJsonCon.append('[');  // eckig!!!
+    for (ulong ul=0; ul<nrofVals; ul++)
+    {
+        tmpStr.setNum(buf[ul]);
+        myJsonCon.append(tmpStr);
+        myJsonCon.append(',');
+    }
+    myJsonCon.chop(1);      // Komma weg
+    myJsonCon.append(']');  // eckig!!!
+    myJsonCon.append(',');
+    myJsonCon.append(NEWLINEINFILE);
+}
+
+void json_enterStructToRecord(QString attribute)
+{
+    // every call must be concluded with "json_finishFile()"
+    myJsonCon.append('"');
+    myJsonCon.append(attribute);
+    myJsonCon.append('"');
+    myJsonCon.append(':');
+    myJsonCon.append('{');  // geschweift!!
+    myJsonCon.append(NEWLINEINFILE);
+}
+
+void json_finishStruct(void)
+{
+    myJsonCon.chop(2);  // remove , and \r from the end
+    myJsonCon.append('}');
+    myJsonCon.append(',');
+    myJsonCon.append(NEWLINEINFILE);
+
+}
+
+void json_finishRecord(void)
+{
+    myJsonCon.chop(2);  // remove , and \r from the end
+    myJsonCon.append(NEWLINEINFILE);
+    myJsonCon.append('}');
+    myJsonCon.append(NEWLINEINFILE);
+
+}
+
+
+QString json_readbackRecordStr(void)
+{
+    return myJsonCon;
+}
+
+QByteArray json_readbackRecordBa(void)
+{            
+    return myJsonCon.toLatin1();
+}
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ parse Json file -------------------------------
+// -------------------------------------------------------------------------------------------------
+
+/*
+example Json File:
+{"temperature":28,
+"snow":"no",
+"Zeit":"16_21_45",
+"sunny":"12h",
+"humidity":75,
+"wann ":"24.01.2022",
+"unterstruktur":{
+"day of week":"tuesday",
+"year":22,
+"month":1,
+"day":24},
+"fast am":"Ende",
+"Puffer":[8,3,9,2,10]
+}
+ */
+// first: QByteArray datei_readFromFile(QString filename);
+
+
+int json_nrOfPairsInFile(QByteArray filename)
+{
+    QJsonDocument jdoc = QJsonDocument::fromJson(filename);
+    QJsonObject jobj = jdoc.object();
+
+    // key value pair consisting of key (unique string) and value (QJsonValue)
+    int nrOfPairs=jobj.size();
+
+    qDebug() << "my Json file has got: " << nrOfPairs<< "pairs";
+    return nrOfPairs;
+}
+
+bool json_exists(QByteArray filename, QString searchForKey)
+{
+    // look for "searchForKey" =name of the pair (left of : )
+    QJsonDocument jdoc = QJsonDocument::fromJson(filename);
+    QJsonObject jobj = jdoc.object();
+
+    if (jobj.contains(searchForKey))
+        return true;
+    return false;
+}
+
+bool json_remove(QByteArray filename, QString searchFor)
+{
+    // look for "searchFor" =name of the pair (left of : ) and remove the record from file
+    QJsonDocument jdoc = QJsonDocument::fromJson(filename);
+    QJsonObject jobj = jdoc.object();
+
+    if (jobj.contains(searchFor))
+    {
+        jobj.remove(searchFor);
+        return true;
+    }
+    return false;
+}
+
+QString json_searchForStringInFile(QByteArray filename, QString searchFor)
+{
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+    QJsonDocument jdoc = QJsonDocument::fromJson(filename);
+    QJsonObject jobj = jdoc.object();
+
+    if (jobj.contains(searchFor))
+    {
+        return jobj[searchFor].toString();    // toObject(); toArray();
+    } else
+    {
+        //qDebug() << "pairname not found in Json file";
+        return "";
+    }
+}
+
+int json_searchForIntInFile(QByteArray filename, QString searchFor)
+{
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+    QJsonDocument jdoc = QJsonDocument::fromJson(filename);
+    QJsonObject jobj = jdoc.object();
+
+    if (jobj.contains(searchFor))
+    {
+        return jobj[searchFor].toInt();    // toObject(); toArray();
+    } else
+    {
+        //qDebug() << "number not found in Json file";
+        return 0;
+    }
+}
+
+bool json_searchForObjectInFile(QByteArray filename, QString searchFor, QJsonObject *oneObject)
+{
+    // return an object from the json file
+    QJsonDocument jdoc = QJsonDocument::fromJson(filename);
+    QJsonObject jobj = jdoc.object();
+
+    if (jobj.contains(searchFor))
+    {
+        *oneObject = jobj[searchFor].toObject();
+        return true;
+    } else
+    {
+        //qDebug() << "Object not found in Json file";
+        return false;
+    }
+}
+
+int json_nrOfPairsInObject(QJsonObject objname)
+{
+    int nrOfPairs=objname.size();
+    qDebug() << "my Json Object has got: " << nrOfPairs<< "pairs";
+    return nrOfPairs;
+}
+
+QString json_searchForStringInObject(QJsonObject objname, QString searchFor)
+{
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+
+    if (objname.contains(searchFor))
+    {
+        return objname[searchFor].toString();
+    } else
+    {
+        //qDebug() << "string not found in Json object";
+        return "";
+    }
+}
+
+int json_searchForIntInObject(QJsonObject objname, QString searchFor)
+{
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+
+    if (objname.contains(searchFor))
+    {
+        return objname[searchFor].toInt();
+    } else
+    {
+        //qDebug() << "number not found in Json file";
+        return 0;
+    }
+}
+
+bool json_searchForArrayInFile(QByteArray filename, QString searchFor, QJsonArray *oneArray)
+{
+    // look for "searchFor" =name of the pair (left of : ) and return value of this pair (right of : ) as String
+    QJsonDocument jdoc = QJsonDocument::fromJson(filename);
+    QJsonObject jobj = jdoc.object();
+
+    if (jobj.contains(searchFor))
+    {
+        *oneArray = jobj[searchFor].toArray();
+        return true;
+    } else
+    {
+        //qDebug() << "Array not found in Json file";
+        return false;
+    }
+}
+
+int json_nrOfValuesInArray(QJsonArray arrayname)
+{
+    int nrOfPairs=arrayname.size();
+    qDebug() << "my Json Array has got: " << nrOfPairs<< "values";
+    return nrOfPairs;
+}
+
+
+
+bool json_getValuesOfArray(QJsonArray arrayname, int *buf, int MaxBufferSize)
+{
+    // assuming that the array consists of integers
+
+    /* copy to local buffer:
+    #define MAXNROFARRAYVALUES      100
+    int buf[MAXNROFARRAYVALUES], ii;
+    int nrOfPairs=arrayname.size();
+
+    if (nrOfPairs>MAXNROFARRAYVALUES)
+        nrOfPairs=MAXNROFARRAYVALUES;
+
+    for (ii=0; ii<nrOfPairs; ii++)
+        buf[ii]=arrayname[ii].toInt();
+    */
+    // copy to host buffer:
+    bool ok=true;
+    int nrOfPairs=arrayname.size();
+
+    if (nrOfPairs>MaxBufferSize)
+    {
+        ok=false;       // got not all
+        nrOfPairs=MaxBufferSize;
+    }
+    for (int ii=0; ii<nrOfPairs; ii++)
+        buf[ii]=arrayname[ii].toInt();
+
+    return ok;
+}
+
+/*
+void datei_json_readTestFile(QString filename)
+{
+    QByteArray my2Ba;
+    QString    my2Str;
+
+    my2Str.clear();
+    my2Ba=datei_readFromFile(filename);
+
+    QJsonDocument jdoc = QJsonDocument::fromJson(my2Ba);
+    QJsonObject jobj = jdoc.object();
+    //QJsonParseError jerror;
+    QJsonObject myObj;
+    QJsonArray myArray;
+
+        // key value pair consisting of key (unique string) and value (QJsonValue)
+    int nrOfPairs=jobj.size();
+    qDebug() << "my Json file has got: " << nrOfPairs<< "pairs";
+
+    if (jobj.contains("Zeit"))
+        qDebug() << "my Json file: " << jobj["Zeit"].toString();    // toObject(); toArray();
+    else
+        qDebug() << "my Json file contains no Zeit";
+
+    if (jobj.contains("Humidity"))
+        qDebug() << "my Json file: " << jobj["humidity"].toInt();
+    else
+        qDebug() << "my Json file contains no Humidity";
+
+    if (jobj.contains("month"))
+        qDebug() << "my Json file: " << jobj["month"].toObject();   // anzeige QJsonObject()
+    else
+        qDebug() << "my Json file contains no month";
+
+
+    myObj=jobj["unterstruktur"].toObject();
+    qDebug() << "my unterstruktur: " << myObj["month"].toInt();
+    qDebug() << "my unterstruktur: " << myObj["day of week"].toString();
+    //if (jerror.error == QJsonParseError::NoError)
+    //    qDebug() << "no error";
+
+    qDebug() << "my Month: " << myObj["Month"].toInt();
+    //if (myObj["Month"] == QJsonValue::Undefined)
+    //    qDebug() << "no found";     geht nicht
+
+    //if (jerror.error != QJsonParseError::NoError)
+      //  qDebug() << "no found";
+
+    myArray=jobj["Puffer"].toArray();
+    qDebug() << "my array " <<myArray[2].toInt();
+    //if (jerror.error != QJsonParseError::NoError)
+     //   qDebug() << "no found";
+
+    if ( !jobj.contains("Puffer"))
+        qDebug() << "no Puffer found";
+
+    if ( !myArray.contains(20))
+        qDebug() << "no entry found";
+} */
+
+
+
+// -------------------------------------------------------------------------------------------------
+// ------------------------------------------------------ read, write, copy files -------------------
+// -------------------------------------------------------------------------------------------------
+
+void datei_closeFile(QString filename)
+{
+    QFile file(filename);
+    file.close();
+}
+
+QByteArray datei_readFromFile(QString filename)
+{
+    //QFile file("/own/H2B/dc2.hex");
+    //QFile file(FILENAME_STRUCTURE);
+    QFile file;
+    file.setFileName(filename);
+    QByteArray myBA;
+
+    myBA.clear();
+    if (!file.exists())
+    {
+        qDebug()<<"file not exists";
+        return myBA;
+    } else
+    {
+        if (!file.open(QIODevice::ReadOnly)  )
+        {
+            qDebug()<<"cannot open";
+
+        } else
+        {
+            //qDebug()<<"loading file with " << file.size() <<"byte";
+            myBA = file.readAll();
+            //qDebug()<<"datei read: " << myBA;
+            file.close();
+        }
+    }
+    return myBA;
+}
+
+bool datei_ifFileExists(QString filename)
+{
+
+    QFile file;
+    file.setFileName(filename);
+
+    if (file.exists())
+        return true;
+    return false;
+}
+
+char datei_writeToFile(QString filename, QByteArray content)
+{
+    // retval=0 if successful  1: no write access allowed 2:cannot open to append 3:cannot create new file
+    QFile file(filename);
+    QFileInfo myFI(filename);
+
+    //if (!myFI.isWritable())   //geht nur bei NTFS, weg.
+    //{
+        //file.setPermissions(filename, QFile::WriteOther); geht nicht :(
+    //    qDebug()<<"datei_writeToFile: writing not allowed. set attributes first!";
+    //    return 1;
+    //}
+
+    if (file.exists())
+    {
+        if (!file.open(QIODevice::Append))
+        {
+            qDebug()<<"datei_writeToFile cannot open to append";
+            return 2;
+        } else
+        {
+            // add new object to the end of the file
+            file.write(content);
+            file.close();
+            return 0;   // OK
+        }
+    } else
+    {
+        if (!file.open(QIODevice::WriteOnly))
+        {
+            qDebug()<<"datei_writeToFile cannot open new";
+            return 3;
+        } else
+        {
+            qDebug()<<"create new file";
+            // write first lines into file
+            file.write(content);
+            file.close();
+            return 0;   // OK
+        }
+    }
+    return 0;
+}
+
+bool datei_copyFile(QString currentFileName, QString newFileName)
+{
+    // retval=true if successful
+    QFile file;
+    file.setFileName(currentFileName);
+    return file.copy(newFileName);
+}
+
+bool datei_clearFile(QString filename)
+{
+    // retval=true if successful
+    QFile file;
+    file.setFileName(filename);
+
+    file.remove();  // 3.2.22 erst ganz löschen wegen Schreibrechten
+    if (!file.open(QIODevice::WriteOnly))
+    {
+        qDebug()<<"datei_clearFile  cannot open file to delete";
+        return false;
+    } else
+    {
+        file.write(0);
+        file.close();
+        return true;
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/hwChk.cpp

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

src/main.cpp

@@ -0,0 +1,9 @@
+#include <QCoreApplication>
+#include "tslib.h"
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication a(argc, argv);
+
+    return a.exec();
+}

src/prot.cpp

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

src/sendWRcmd.cpp

@@ -14,7 +14,7 @@ void sendWRcmd_INI(void)
     sendWRcmd_clrCmdStack();
     sendWRcmd_clrCmd4Stack();
     sendFDcmd_clrStack();
-    longFDcmd_clrStack();
+
 }
 
 // Command Stack for commands without parameters
@@ -456,18 +456,23 @@ uint8_t gpi_chk4remainingText(void)
 // ---------------------------------------------------------------------------------
 //   11.4.23 neu, Kommando direkt an "FastDevice"-protokoll senden, nicht mehr umsetzen
 // ---------------------------------------------------------------------------------
-
+// header
-
-// 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 nextFDshort[FDCMD_STACKDEPTH];
 
+// short data
 static uint8_t  nextFDpara1[FDCMD_STACKDEPTH];
 static uint8_t  nextFDpara2[FDCMD_STACKDEPTH];
 static uint8_t  nextFDpara3[FDCMD_STACKDEPTH];
 static uint8_t  nextFDpara4[FDCMD_STACKDEPTH];
+// lon data:
+static uint8_t longFDlength[FDCMD_STACKDEPTH];
+static uint8_t longFDpara[FDCMD_STACKDEPTH][64];
+
 static uint8_t  p_nextFDcmdsInQueue;
+
 /* convention: use simple (not rotating) FIFO Stack:
 Example: nrOfCmdsInQueue=4 then
     nextAsynchsendCmd0[0]=cmd1      // was stored as first
@@ -492,16 +497,21 @@ void sendFDcmd_clrStack(void)
         nextFDwrCmd[nn]=0;
         nextFDrdCmd[nn]=0;
         nextFDblkNr[nn]=0;
+        nextFDshort[nn]=0;
         nextFDpara1[nn]=0;
         nextFDpara2[nn]=0;
         nextFDpara3[nn]=0;
         nextFDpara4[nn]=0;
+        longFDlength[nn]=0;
+        memset(&longFDpara[nn][0],0,64);
     }
+
     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)
     {
@@ -518,13 +528,68 @@ bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8
     //qDebug() << "data with 4 data byte saved, pp=" << nrOfCmds4InQueue;
     //qDebug() << " dat1=" << nextCmd4para1[nrOfCmds4InQueue] << " dat2=" << nextCmd4para2[nrOfCmds4InQueue]
     //             << " dat3=" << nextCmd4para3[nrOfCmds4InQueue]  << " dat4=" << nextCmd4para4[nrOfCmds4InQueue];
+    nextFDshort[p_nextFDcmdsInQueue]=1; // 1=short
+    p_nextFDcmdsInQueue++;
+/*
+    int nn;
+    if (p_nextFDcmdsInQueue==2)
+    {
+        qDebug() << "sendFDcmd_set, stack has 2 elements: " << p_nextFDcmdsInQueue;
+        for (nn=0; nn<16; nn++)
+        {
+            qDebug() << "header: " << nextFDwrCmd[nn] << " / " << nextFDrdCmd[nn] << " / "<< nextFDblkNr[nn] << " / " << nextFDshort[nn];
+        }
+    }
+*/
+/*
+    if (p_nextFDcmdsInQueue>15)
+    {
+        qDebug() << "sendFDcmd_set, stack is full now: " << p_nextFDcmdsInQueue;
+        for (nn=0; nn<16; nn++)
+        {
+            qDebug() << "header: " << nextFDwrCmd[nn] << " / " << nextFDrdCmd[nn] << " / "<< nextFDblkNr[nn] << " / " << nextFDpara1[nn] << " / " << nextFDpara2[nn] << " / " << nextFDpara3[nn] << " / " << nextFDpara4[nn];
+
+            qDebug() << "    long data: " << nextFDshort[nn] << " / "<< longFDlength[nn] << " / "<< longFDpara[nn][0] << " / "<< longFDpara[nn][1]
+                     << " / "<< longFDpara[nn][2] << " / "<< longFDpara[nn][3] << " / "<< longFDpara[nn][4];
+
+        }
+
+    }
+*/
+
+    return true;                // ok, will be sent
+}
+
+
+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_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;
+
+    longFDlength[p_nextFDcmdsInQueue]=length;
+
+    for (nn=0; nn<64; nn++)
+        longFDpara[p_nextFDcmdsInQueue][nn]=data[nn];
+
+    nextFDshort[p_nextFDcmdsInQueue]=2;
+
     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;
+    uint8_t nn, ll, mm;
 
     if (p_nextFDcmdsInQueue==0 || p_nextFDcmdsInQueue>FDCMD_STACKDEPTH)
         return false;           // not possible
@@ -536,7 +601,7 @@ bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, ui
     *dat2=nextFDpara2[0];
     *dat3=nextFDpara3[0];
     *dat4=nextFDpara4[0];
-    //qDebug() << "cmd4  restored to send from [0];  pp=" << nrOfCmds4InQueue;
+    //qDebug() << "sendFDcmd_get [0];  pp=" << p_nextFDcmdsInQueue;
     //qDebug() << " data1: " << nextCmd4para1[0] << " data2: " << nextCmd4para2[0] <<
     //            " data3: " << nextCmd4para3[0] << " data4: " << nextCmd4para4[0];
 
@@ -550,17 +615,74 @@ bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, ui
         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];
+
+        nextFDshort[nn] = nextFDshort[nn+1];
+
+        longFDlength[nn] = longFDlength[nn+1];
+
+        for (mm=0; mm<64; mm++)
+            longFDpara[nn][mm] = longFDpara[nn+1][mm];
     }
+
     if (p_nextFDcmdsInQueue>0)
         p_nextFDcmdsInQueue--;
     //qDebug() << "cmd4  after push down: pp=" << nrOfCmds4InQueue;
+
+    // clear released buffer:
+    for (nn=p_nextFDcmdsInQueue; 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;
+
+        nextFDshort[nn]=0;
+
+        longFDlength[nn]=0;
+
+        for (mm=0; mm<64; mm++)
+            longFDpara[nn][mm] = 0;
+
+    }
+
+
+/*
+    qDebug() << "sendFDcmd_set, stack now: " << p_nextFDcmdsInQueue;
+    for (nn=0; nn<16; nn++)
+    {
+        qDebug() << "header: " << nextFDwrCmd[nn] << " / " << nextFDrdCmd[nn] << " / "<< nextFDblkNr[nn] << " / " << nextFDshort[nn];
+
+        qDebug() << "    short data: " << nextFDpara1[nn] << " / "<< nextFDpara2[nn] << " / "<< nextFDpara3[nn]<< " / "<< nextFDpara4[nn];
+
+        qDebug() << "    long data: " << longFDlength[nn] << " / "<< longFDpara[nn][0] << " / "<< longFDpara[nn][1]
+                 << " / "<< longFDpara[nn][2] << " / "<< longFDpara[nn][3] << " / "<< longFDpara[nn][4];
+    }
+*/
     return true;                // ok, will be sent
 }
 
+uint8_t checkNextFDcmd(void)
+{
+    // return 0: no command waiting
+//          1: short cmd
+//          2: long cmd
+    //qDebug() << "chk nxt fd cmd: "<<p_nextFDcmdsInQueue<<" "<<nextFDshort[0]<<" "<<nextFDshort[1]<<" "<<nextFDshort[2]<<" "<<nextFDshort[3];
+    if (p_nextFDcmdsInQueue==0)
+        return 0;
+    if (nextFDshort[0]==1)
+        return 1;
+    return 2;
+}
+
 uint8_t check4FDshortCmd(void)
 {
     // returns number of waiting command, max FDCMD_STACKDEPTH
@@ -576,15 +698,15 @@ uint8_t check4freeFDshortCmd(void)
 
 
 // long command, 64 data bytes
-static uint8_t longFDwrCmd[FDLONG_STACKDEPTH];
+//static uint8_t longFDwrCmd[FDLONG_STACKDEPTH];
-static uint8_t longFDrdCmd[FDLONG_STACKDEPTH];
+//static uint8_t longFDrdCmd[FDLONG_STACKDEPTH];
-static uint8_t longFDblkNr[FDLONG_STACKDEPTH];
+//static uint8_t longFDblkNr[FDLONG_STACKDEPTH];
-static uint8_t longFDlength[FDLONG_STACKDEPTH];
+//static uint8_t longFDlength[FDLONG_STACKDEPTH];
-
-static uint8_t  longFDpara[FDLONG_STACKDEPTH][64];
-static uint8_t  p_longFDcmdsInQueue;
 
+//static uint8_t  longFDpara[FDLONG_STACKDEPTH][64];
+//static uint8_t  p_longFDcmdsInQueue;
 
+/*
 void longFDcmd_clrStack(void)
 {
     uint8_t nn, mm;
@@ -598,66 +720,74 @@ void longFDcmd_clrStack(void)
             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;
-
+//p_nextFDcmdsInQueue; nn<FDCMD_STACKDEPTH
-    if (p_longFDcmdsInQueue==0 || p_longFDcmdsInQueue>FDLONG_STACKDEPTH)
+    if (p_nextFDcmdsInQueue==0 || p_nextFDcmdsInQueue>FDCMD_STACKDEPTH)
         return false;           // not possible
 
-    *nextWrCmd= longFDwrCmd[0];
+    *nextWrCmd=nextFDwrCmd[0];
-    *nextRdCmd= longFDrdCmd[0];
+    *nextRdCmd=nextFDrdCmd[0];
-    *blockNum = longFDblkNr[0];
+    *blockNum=nextFDblkNr[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)
+    if (FDCMD_STACKDEPTH>0)
-        ll=FDLONG_STACKDEPTH-1;
+        ll=FDCMD_STACKDEPTH-1;
     else
         ll=0;
     for (nn=0; nn<ll; nn++)
     {
-        longFDwrCmd[nn]  = longFDwrCmd[nn+1];
+        nextFDwrCmd[nn]=nextFDwrCmd[nn+1];
-        longFDrdCmd[nn]  = longFDrdCmd[nn+1];
+        nextFDrdCmd[nn]=nextFDrdCmd[nn+1];
-        longFDblkNr[nn]  = longFDblkNr[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];
+
+        nextFDshort[nn] = nextFDshort[nn+1];
+
         longFDlength[nn] = longFDlength[nn+1];
 
         for (mm=0; mm<64; mm++)
             longFDpara[nn][mm] = longFDpara[nn+1][mm];
 
     }
-    if (p_longFDcmdsInQueue>0)
+    if (p_nextFDcmdsInQueue>0)
-        p_longFDcmdsInQueue--;
+        p_nextFDcmdsInQueue--;
+
+    // clear released buffer:
+    for (nn=p_nextFDcmdsInQueue; 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;
+
+        nextFDshort[nn]=0;
+
+        longFDlength[nn]=0;
+        for (mm=0; mm<64; mm++)
+            longFDpara[nn][mm] = 0;
+    }
+
 
     return true;                // ok, will be sent
 }
-
+/*
 uint8_t check4FDlongCmd(void)
 {
     // returns number of waiting command
@@ -669,7 +799,7 @@ uint8_t check4freeFDlongCmd(void)
     // returns number of free places in command stack
     return FDLONG_STACKDEPTH - p_longFDcmdsInQueue;
 }
-
+*/
 
 
 
@@ -699,6 +829,3 @@ uint8_t epi_restore64BdevParameter(uint8_t *length, uint8_t *buf)
     return 0;
 }
 
-
-
-

src/shared_mem_buffer.cpp

@@ -9,16 +9,23 @@
     // macro will be defined. -> we use SystemV shared memory
 #error "QT_POSIX_IPC defined"
 #else
+#ifdef __linux__
 #include <sys/ipc.h>    // ftok
 #endif
+#endif
 
 // std::atomic_bool SharedMemBuffer::__sharedMemLocked{false};
 
 QSharedMemory *SharedMemBuffer::getShm(std::size_t size) {
     static QSharedMemory shMem;
     if (size > 0) {
+#ifdef __linux__
         static const long nativeKey = ftok("/etc/os-release", 'H');
         static const QString fkey = std::to_string(nativeKey).c_str();
+#else
+        static const QString fkey = "0123456?000=9";
+#endif
+
         shMem.setKey(fkey);
         if (!shMem.isAttached()) {
             if (shMem.create(size)) {