Add comment

This not GUI library!

DCPlugin.pri

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

DCPlugin.pro

@@ -4,7 +4,7 @@ CONFIG += plugin
 #CONFIG -= app_bundle
 #QT += widgets
 QT -= gui
-QT += widgets serialport
+QT += serialport
 
 INCLUDEPATH += $${PWD}/plugins
 INCLUDEPATH += $${PWD}/include
@@ -14,7 +14,6 @@ QMAKE_CXXFLAGS += -Wno-deprecated-copy
 # default
 ARCH = PTU5
 
-include(DCPlugin.pri)
 
 contains( CONFIG, DesktopLinux ) {
     QMAKE_CC = ccache $$QMAKE_CC
@@ -70,6 +69,7 @@ DEFINES += QT_DEPRECATED_WARNINGS
 
 # ATBAPP interface
 HEADERS += \
+    include/interfaces.h \
     src/ATBAPP/ATBAPPplugin.h \
     src/ATBAPP/DeviceControllerInterface.h \
     src/ATBAPP/ATBHealthEvent.h \

include/com.h

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

include/controlBus.h

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

include/datIf.h

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

include/dcBL.h

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

include/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/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,18 +88,23 @@ 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
         uint16_t AccountingNumber;
@@ -111,23 +131,26 @@ struct T_vaultRecord {
 //16
         char label3buffer[4];	// mw >
 
-    // Verkauf, Tür zu:
+        // Verkauf, T<EFBFBD>r zu:
-    uint32_t VKcoinsInserted[16];		// nur für Wechsler, soviel wurde eingeworfen
+        uint32_t VKcoinsInserted[16];		// nur f<EFBFBD>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<EFBFBD>r Wechsler, Anzahl M<EFBFBD>nzen pro Typ, soviel wurde zur<EFBFBD>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<EFBFBD>r Wechsler, soviel wurde eingeworfen
+        uint16_t ServCoinsReturned[6];		// nur f<>r Wechsler, Anzahl M<>nzen pro Typ, soviel wurde zur<75>ckgegeben
         uint16_t resint3;
         uint16_t resint4;
-    uint16_t currentTubeContent[6];		//  nur für Wechsler, aktueller Füllstand
+        uint16_t currentTubeContent[6];		//  nur f<EFBFBD>r Wechsler, aktueller F<EFBFBD>llstand
         uint16_t resint5;
         uint16_t resint6;
 // 56
+
         char label4buffer[4];	// box>
         uint16_t coinsInVault[16];
         uint16_t billsInStacker[8];
 // 48
+
         char label5buffer[4];	// val>
         // actually constant unless exchange rate is changed
         uint16_t coinDenomination[16];	// 5..50000 (z.B. 2? sind in Ungarn 760Ft)
@@ -135,12 +158,17 @@ struct T_vaultRecord {
         uint16_t tubeDenom[6];
         uint16_t exchangeRate;
         uint16_t resint9;
+
 // 64
+
         char endofblock[4];	// end>
+
 // 316 byte Block im Speicher
+
 };
 
-struct T_moduleCondition {
+struct T_moduleCondition
+{
         // store conditon of all system components, hold in RAM
         // 0 means unknown, not yet tested/used
         // 1 means OK
@@ -182,26 +210,41 @@ struct T_moduleCondition {
         uint8_t   ResetReason;
         uint8_t	allModulesChecked;
 
+        uint8_t   alarmState;
+        uint8_t   res11;
+        uint8_t   res12;
+        uint8_t   res13;
+
 };
 
-struct T_dynamicCondition {
+struct T_dynamicCondition
-    char allDoorsDebounced;     // 99: undefined, 0=all closed, bit1=upper door open  2=midlle door open 3=lower door open
+{
+        char allDoorsDebounced;
         char openedAuthorized;
-    uint8_t CBinDebounced;
+        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;       // not used, always 0
+        char reserve;
         char billBox;
         char modeAbrech;
         char onAlarm;           // 0:alarm aus  1:alarm  2:alarm mit Sirene   3: Sirenentest
         char nowCardTest;
-    char nowPayment;
+        char nowPayment;        // not used, always 0
         char lastMifCardType;
         uint8_t lastSDoorState;
         uint8_t lastVDoorState;
-    uint8_t lastCBstate;        // 99: undefined  0:not there   1:insered
+        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;
@@ -229,10 +272,12 @@ struct T_dynamicCondition {
                     //          bit6: no response             bit7: serial rec. error
                     //			bit5: printer not ready
         uint8_t     startupTestIsRunning;
+
         //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<EFBFBD>	(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
@@ -317,7 +364,7 @@ public:
         // 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
         
@@ -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<EFBFBD>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<EFBFBD>C    100=0,0<EFBFBD>C    141=20,5<EFBFBD>C    400=150,0<EFBFBD>C)
     
     virtual QString  dc_getTemperaturStr(void)  const =0;
-        // as string like "-12,5°C"
+        // as string like "-12,5<EFBFBD>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<EFBFBD>_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
@@ -1279,7 +1322,7 @@ public:
     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<EFBFBD>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<EFBFBD>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;
 
@@ -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,61 +1670,27 @@ 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:
-    // bool hwapi::sys_runCompleteTest(void) const
-
-
-
-
-
-
-
-
-    // ---------------------------------------------------------------------------------------------
-    // ---------------------------------------------------------------------------------------------
-    // ---------------------------------------------------------------------------------------------
 
 signals:
     virtual void hwapi_templatePrintFinished_OK(void) const=0;
@@ -1707,12 +1729,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"
 
 
 

include/prot.h

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

include/sendWRcmd.h

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

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

include/storeINdata.h

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

include/tslib.h

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

src/ATBAPP/ATBDeviceControllerPlugin.cpp

@@ -3,6 +3,10 @@
 
 #include <QTimer>
 #include <QTextCodec>
+#include <QDebug>
+
+#include <QPluginLoader>
+#include <QDateTime>
 
 
 ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent) : QObject(parent),
@@ -10,12 +14,21 @@ ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent) : QObject(
 {
     this->pluginInfo = QString::fromUtf8(pluginInfoString.c_str());
 
-    this->hw = new hwapi();
+    if (!this->private_loadCashAgentLib("")) {
+        return;
+    }
+
+
+
+
+    //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_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()));
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByMax()),     this, SLOT(onCashPayStopByMax()));
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByEscrow()),  this, SLOT(onCashPayStopByEscrow()));
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByError()),   this, SLOT(onCashPayStopByError()));
+    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByTimeout()), this, SLOT(onCashPayStopByTimeout()));
 }
 
 ATBDeviceControllerPlugin::~ATBDeviceControllerPlugin() {}
@@ -29,6 +42,7 @@ PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *healthEventReceive
     QByteArray printerEncoding = settings.value("DEVICE_CONTROLLER/printerEnconding", "ISO 8859-2").toString().toLatin1();
 
 
+    hw->dc_autoRequest(true);
 
     // open serial port
     hw->dc_openSerial(5, "115200", serialPort, 1);
@@ -52,12 +66,17 @@ void ATBDeviceControllerPlugin::requestStartCashInput(const QString & amount)
 
     uint32_t amountInt = static_cast<uint32_t>(amount.toUInt());
 
+    if (amountInt == 0) amountInt = UINT_MAX;
+
     hw->cash_startPayment(amountInt);
 }
 
 void ATBDeviceControllerPlugin::requestStopCashInput()
 {
     hw->cash_stopPayment();
+
+    // we need new cash value in application...
+    QTimer::singleShot(500, this, SLOT(onCashPayStoped()));
 }
 
 void ATBDeviceControllerPlugin::cashCollect()
@@ -70,6 +89,12 @@ void ATBDeviceControllerPlugin::cashAbort()
     hw->vend_failed();
 }
 
+// TASKS: Account -------------------------------------------------------------
+void ATBDeviceControllerPlugin::requestAccount()
+{
+    qCritical() << "TODO: implement ATBDeviceControllerPlugin::requestAccount()";
+}
+
 
 // TASKS: printing ------------------------------------------------------------
 void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant> & printingData)
@@ -99,10 +124,11 @@ void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant
     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));
+    memcpy((char*)dynTicketData->parkingEnd,  ba_parkingEndTime.data(), std::min(ba_parkingEndTime.size(),8));
 
     QByteArray ba_parkingEndDate = codec->fromUnicode(parkingEndDateTime.toString("dd.MM.yy"));
-    memcpy((char*)dynTicketData->parkingEndDate,  ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
+    memcpy((char*)dynTicketData->currentTime,  ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
+    // ! and yes... 'ParkingEndDate' is 'currentTime'
 
     QByteArray ba_currentDate = codec->fromUnicode(currentDateTime.toString("dd.MM.yy"));
     memcpy((char*)dynTicketData->currentDate,  ba_currentDate.data(), std::min(ba_currentDate.size(),8));
@@ -128,6 +154,8 @@ void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant
     }
 
 
+
+
     // TODO: wird hier nur 'licensePlate' gedruckt?
     if (!this->hw->prn_sendDynamicPrnValues(dynTicketData->licensePlate)) {
         this->errorCode = "hwapi::prn_sendDynamicPrnValues";
@@ -146,7 +174,7 @@ void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant
         return;
     }
 
-    QTimer::singleShot(500, this, SLOT(onPrinterDataPrepared()));
+    QTimer::singleShot(1000, this, SLOT(onPrinterDataPrepared()));
 }
 
 
@@ -179,7 +207,7 @@ void ATBDeviceControllerPlugin::onPrinterPrintNextTemplate()
     else {
         // print next template
         this->currentTemplate++;
-        QTimer::singleShot(1000, this, SLOT(onPrinterPrintNextTemplate()));
+        QTimer::singleShot(2000, this, SLOT(onPrinterPrintNextTemplate()));
     }
 
 }
@@ -235,7 +263,7 @@ void ATBDeviceControllerPlugin::onCashGotCoin()
 }
 
 
-void ATBDeviceControllerPlugin::onCashVendStopByMax()
+void ATBDeviceControllerPlugin::onCashPayStopByMax()
 {
     // DEBUG
     qCritical() << "ATBDeviceControllerPlugin::onCashVendStopByMax()";
@@ -251,6 +279,115 @@ void ATBDeviceControllerPlugin::onCashVendStopByMax()
 
 }
 
+void ATBDeviceControllerPlugin::onCashPayStopByEscrow()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByEscrow()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
+                              amountString,
+                              "",
+                              "");
+}
+
+void ATBDeviceControllerPlugin::onCashPayStopByError()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByError()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
+                              amountString,
+                              "",
+                              "");
+}
+
+void ATBDeviceControllerPlugin::onCashPayStopByTimeout()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByTimeout()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
+                              amountString,
+                              "",
+                              "");
+}
+
+void ATBDeviceControllerPlugin::onCashPayStoped()
+{
+    // DEBUG
+    qCritical() << "ATBDeviceControllerPlugin::onCashPayStoped()";
+
+    uint32_t amountInt = this->hw->getInsertedAmount();
+
+    QString amountString = QString::number(amountInt);
+
+    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
+                              amountString,
+                              "",
+                              "");
+}
+
+
+
+/**
+ * Load CashAgentLib
+ * @brief ATBDeviceControllerPlugin::private_loadCashAgentLib
+ * @param pluginName
+ * @return
+ */
+bool ATBDeviceControllerPlugin::private_loadCashAgentLib(QString pluginName)
+{
+    if (pluginName == "") {
+        pluginName = "/usr/lib/libCashAgentLib.so";
+    }
+
+    if (!QLibrary::isLibrary(pluginName)) {
+        qCritical() << "ATBDeviceControllerPlugin: can not load CashAgentLib: " << pluginName;
+        this->errorCode = 5;
+        this->errorDescription = "ERROR: can not load CashAgentLib: " + pluginName;
+        return false;
+    }
+
+    QPluginLoader* pluginLoader = new QPluginLoader();
+    pluginLoader->setFileName(pluginName);
+
+    QObject* plugin = pluginLoader->instance();
+    if (!pluginLoader->isLoaded()) {
+        qCritical() << "ATBDeviceControllerPlugin: can not instantiate CashAgentLib: " << pluginName;
+        this->errorCode = 6;
+        this->errorDescription = "ERROR: can not instantiate CashAgentLib: " + pluginName;
+        return false;
+    }
+
+    if (plugin == nullptr) {
+        qCritical() << "ATBDeviceControllerPlugin: plugin is NULL";
+    }
+
+    qCritical() << "ATBDeviceControllerPlugin: instantiate CashAgentLib: " << pluginName;
+
+    this->hw = qobject_cast<hwinf*>(plugin);
+
+    if (this->hw == nullptr) {
+        qCritical() << "ATBDeviceControllerPlugin: hw is NULL";
+    }
+
+    return true;
+}
+
+
+
 /************************************************************************************************
  * Mandatory plugin methods
  *

src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -9,7 +9,7 @@
 
 
 
-#include "hwapi.h"
+#include "interfaces.h"
 
 #include <unistd.h>
 #include <thread>
@@ -51,6 +51,9 @@ public:
     // TASKS: printing ------------------------------------------------------------
     void requestPrintTicket(const QHash<QString, QVariant> & printingData);
 
+    // TASKS: Account -------------------------------------------------------------
+    void requestAccount();
+
     // mandantory ATBAPP plugin methods: ------------------------------------------
     nsDeviceControllerInterface::PLUGIN_STATE getState();
     QString & getLastError();
@@ -83,6 +86,9 @@ signals:
 
     void requestServiceMode();
 
+    void requestAccountResponse(const QHash<QString, QVariant> & accountData);
+
+
     void Error(
             const QString & errorCode,
             const QString & errorDescription);
@@ -108,6 +114,8 @@ private:
 
    QTextCodec *codec;
 
+   bool private_loadCashAgentLib(QString pluginName);
+
 private slots:
    // printer
 
@@ -119,7 +127,11 @@ private slots:
 
    // cash payment
    void onCashGotCoin();
-   void onCashVendStopByMax();
+   void onCashPayStoped();
+   void onCashPayStopByMax();
+   void onCashPayStopByEscrow();
+   void onCashPayStopByError();
+   void onCashPayStopByTimeout();
 };
 
 #endif // ATBDEVICECONTROLLERPLUGIN_H

src/ATBAPP/DeviceControllerInterface.h

@@ -44,6 +44,9 @@ public:
     virtual void cashCollect() = 0;
     virtual void cashAbort() = 0;
 
+    // TASKS: Account -------------------------------------------------------------
+
+    virtual void requestAccount() = 0;
 
 
     // TASKS: printing ------------------------------------------------------------
@@ -95,6 +98,11 @@ signals:
      */
     virtual void requestServiceMode() = 0;
 
+    /**
+     * emitted e.g. if service door is opened
+     */
+    virtual void requestAccountResponse(const QHash<QString, QVariant> & accountData) = 0;
+
     /**
      * emitted on error
      * depending on errorCode:

src/com.cpp

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

src/controlBus.cpp

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

src/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/prot.cpp

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

src/sendWRcmd.cpp

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

src/shared_mem_buffer.cpp

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

src/tslib.cpp

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