Checking to test compilation

Cleaned source.

.gitignore

@@ -0,0 +1 @@
+*.user

DCPlugin.pri

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

DCPlugin.pro

@@ -0,0 +1,68 @@
+TEMPLATE = lib
+CONFIG += plugin
+#CONFIG += c++11 console
+#CONFIG -= app_bundle
+#QT += widgets
+QT -= gui
+QT += widgets serialport
+
+INCLUDEPATH += $${PWD}/plugins
+INCLUDEPATH += $${PWD}/include
+
+QMAKE_CXXFLAGS += -Wno-deprecated-copy
+
+# default
+ARCH = PTU5
+
+contains( CONFIG, DesktopLinux ) {
+    QMAKE_CC = ccache $$QMAKE_CC
+    QMAKE_CXX = ccache $$QMAKE_CXX
+    QMAKE_CXXFLAGS += -std=c++11
+    # QMAKE_CXXFLAGS += -Wno-deprecated-ctor
+    linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
+    ARCH = DesktopLinux
+    include(DCPlugin.pri)
+}
+
+contains( CONFIG, PTU5 ) {
+    # QMAKE_CC = ccache $$QMAKE_CC
+    # QMAKE_CXX = ccache $$QMAKE_CXX
+    QMAKE_CXXFLAGS += -std=c++11
+    linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
+    CONFIG += link_pkgconfig
+    ARCH = PTU5
+
+    # NOTE: include contents of DCPlugin.pri. Also used by ATBQT.
+    # Add new files in DCPlugin.pri.
+    include(DCPlugin.pri)
+}
+
+contains( CONFIG, PTU5_YOCTO ) {
+    ARCH = PTU5
+
+    # add qmqtt lib
+    #LIBS += -lQt5Qmqtt
+}
+
+TARGET   = CashAgentLib
+DESTDIR  = ../plugins
+
+
+# The following define makes your compiler emit warnings if you use
+# any Qt feature that has been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if it uses deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+
+
+# Default rules for deployment.
+#qnx: target.path = /tmp/$${TARGET}/bin
+#else: unix:!android: target.path = /opt/$${TARGET}/bin
+#!isEmpty(target.path): INSTALLS += target
+

include/com.h

@@ -33,7 +33,7 @@ class T_com : public QMainWindow        //,  public QPlainTextEdit
     //char oeffneSerialPort();
     char open_Serial_Port();
     void closeSerialPort();
-
+    void receiveByLength(void);
 
 private slots:
     void readSomeBytes(void);
@@ -54,6 +54,8 @@ public:
 
     void writeToSerial(const QByteArray &data, uint16_t sendLength);
 
+    void receiveFixLen(int64_t nrOfbytesToReceive);
+
     bool readFromSerial(QByteArray &data, uint16_t &sendLength);
         // retval: true: data available
 

include/controlBus.h

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

include/datIf.h

@@ -21,6 +21,115 @@
 #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
@@ -110,8 +219,8 @@
 #define CMD2DC_MIFREADERON          0x2900
 #define CMD2DC_ATB_CREATE           0x2907
 // Mif read data:
-#define CMD2DC_RdBk_MifReader       0x2902
-#define CMD2DC_RdBk_Mifcard         0x2903
+#define CMD2DC_RdBk_MifState       0x2902
+#define CMD2DC_RdBk_MifData         0x2903
 #define CMD2DC_RdBk_AtbCardType     0x2905
 //#define CMD2DC_RdBk_CardData        0x2906
 
@@ -157,7 +266,7 @@
 #define CMD2DC_PRI_DOCUMENT_NR      0x2A42  // 1 + 64
 #define CMD2DC_PRI_CLEAR_DOC        0x2A43  // 1
 
-
+*/
 
 
 
@@ -206,6 +315,9 @@ private slots:
 public:
     T_datif(QWidget *parent = nullptr);
 
+    T_prot *getProt() { return myDCIF; }
+    T_prot const *getProt() const { return myDCIF; }
+
     void resetChain(void);
     char isPortOpen(void);
     void sendWRcommand(uint16_t nxtAsCmd);
@@ -218,6 +330,11 @@ signals:
         //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

@@ -62,6 +62,12 @@ 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....
@@ -72,7 +78,7 @@ uint8_t dcBL_getResult(void);
 
 
 #define RAW_BL_DATALEN      150
-void gpi_storeRawReceivedData(uint8_t  RdDlen, uint8_t *receivedData);
+void gpi_storeRawReceivedData(uint8_t  RdDlen, uint8_t const *receivedData);
 
 uint8_t epi_getRawReceivedData(uint8_t *receivedData);
     // retval=length, will be zeroed after first reading
@@ -85,8 +91,11 @@ 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);
 
 
 

include/prot.h

@@ -26,6 +26,23 @@
 #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
@@ -62,14 +79,23 @@ class T_prot : public QMainWindow
     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 CheckInData(uint8_t *recBuffer);
+
+    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);
@@ -87,6 +113,8 @@ public:
 
     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,

include/sendWRcmd.h

@@ -73,10 +73,10 @@
 #define SEND_REQU_PRN_FONTS             121
 #define SEND_REQU_PRN_ALL               122
 
-#define SEND_REQU_MIFREADER             123
+#define SEND_REQU_MIFSTATE             123
     // Type and state of reader
 
-#define SEND_REQU_MIFCARD               124
+#define SEND_REQU_MIFDATA               124
     // Type, UID, Header of card
     // read one card sector
     // sectors must be addressed by RD_ADD
@@ -148,21 +148,23 @@
 
 
 // highest priority
-#define CMDSTACKDEPTH   16
+// #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);
+bool sendWRcmd_setSendCommand0(uint16_t nextCmd, uint8_t dat1=0, uint8_t dat2=0,
+                               uint8_t dat3=0, uint8_t dat4=0);
     // GUI or app sends a command to DC transfered by serial
 
-uint16_t sendWRcmd_getSendCommand0(void);
+uint16_t sendWRcmd_getSendCommand0(uint8_t *dat1=0, uint8_t *dat2=0,
+                                   uint8_t *dat3=0, uint8_t *dat4=0);
 
 // lower priority
-#define CMD4STACKDEPTH   8
+// #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
+// #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);
@@ -171,7 +173,7 @@ uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2, uint16_t *dat3,
 
 // lowest priority
 // wait for resonse before send next!
-bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t *buf);
+bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t const *buf);
 uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf);
     // retval = *leng
 
@@ -179,7 +181,7 @@ void sendWRcmd_INI(void);
 
 
 
-uint8_t epi_store64ByteSendData(uint8_t length, uint8_t *buf);
+uint8_t epi_store64ByteSendData(uint8_t length, uint8_t const *buf);
     // HWapi writes data to be forwarded to DC and further to mdb-device
     // not batched! don't use twice within 100ms
 
@@ -211,6 +213,31 @@ uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *
     // user=1: Text-Print is using this buffer
     //      2: QR-code-Printer is using this buffer
 
+//#define     FDCMD_STACKDEPTH    16
+void sendFDcmd_clrStack(void);
+bool sendFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum, uint8_t dat1, uint8_t dat2, uint8_t dat3, uint8_t dat4);
+    // write Command to memory, wait for transport
+bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4);
+
+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 const *data);
+    // write Command to memory, wait for transport
+    // data buffer size always 64! data[64], padded with 0
+bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum, uint8_t *length, uint8_t *data);
+
+uint8_t check4FDlongCmd(void);
+    // returns number of waiting command
+
+uint8_t check4freeFDlongCmd(void);
+    // returns number of free places in long-command stack
+
 
 #endif
 

include/serial_port_thread.h

@@ -0,0 +1,22 @@
+#ifndef SERIAL_PORT_THREAD_H_INCLUDED
+#define SERIAL_PORT_THREAD_H_INCLUDED
+
+#include <QThread>
+#include <QString>
+#include <QEventLoop>
+
+class SerialPortThread : public QThread {
+    Q_OBJECT
+
+    QEventLoop m_loop;
+public:
+    SerialPortThread(QObject *parent = nullptr);
+    virtual ~SerialPortThread();
+
+    virtual void run() override;
+
+    QEventLoop &getEventLoop() { return m_loop; }
+};
+
+
+#endif // SERIAL_PORT_THREAD_H_INCLUDED

include/serial_port_worker.h

@@ -0,0 +1,121 @@
+#ifndef SERIAL_PORT_WORKER_H_INCLUDED
+#define SERIAL_PORT_WORKER_H_INCLUDED
+
+#include <QObject>
+#include <QString>
+#include <QTimer>
+#include <QSerialPort>
+#include <QSerialPortInfo>
+#include <QThread>
+
+#include <assert.h>
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <deque>
+#include <iostream>
+#include <atomic>
+
+
+struct Command {
+    enum : uint16_t {PRIORITY_1, PRIORITY_2, PRIORITY_3, PRIORITY_4, END_MARK};
+    enum : uint16_t {QUIT_SENTINEL = 0x1000, SEND_BLOCK_SIZE = 160};
+    uint32_t m_priority;
+    uint16_t m_priorityClass;
+    uint16_t m_cmdId;
+    char    *m_sendBuffer;
+    char    *m_recvBuffer;
+    uint8_t m_sendBufferLength;
+    uint8_t m_recvBufferLength; // expected result length
+
+    static std::atomic<uint8_t> m_nextSendBufferIndex;
+    static std::atomic<uint8_t> m_nextRecvBufferIndex;
+    static char m_sendBuffers[256][SEND_BLOCK_SIZE];
+    static char m_recvBuffers[256][SEND_BLOCK_SIZE];
+
+    static uint32_t getNextCommandPriority(uint8_t cmdType);
+    static char *getNextSendBuffer();
+    static char *getNextRecvBuffer();
+
+ public:
+    Command(uint16_t cmdId, uint8_t sendBufferLength, uint8_t recvBufferLength, uint8_t priorityClass);
+    Command();
+
+    friend bool operator< (Command const& lhs, Command const& rhs) {
+        return lhs.m_priority < rhs.m_priority;
+    }
+
+    friend std::ostream& operator<< (std::ostream& os, Command const& cmd) {
+        return os << "{ " << cmd.m_priority << ", '" << cmd.m_priority << "' } ";
+    }
+};
+
+/// \brief SerialPortWorker
+///
+/// SerialPortWorker sends and receives data from serial port
+///
+class SerialPortWorker : public QThread {
+    Q_OBJECT
+
+    /// \brief Internal serial port.
+    QSerialPort m_serialPort;
+
+    /// \brief Internal serial port info.
+    QSerialPortInfo m_serialPortInfo;
+
+    /// \brief Flag indicating if serial port is opened.
+    bool m_serialPortOpened;
+
+    /// \brief Port name of serial port.
+    QString     m_portName;
+
+    /// \brief Baudrate of internal serial port.
+    enum QSerialPort::BaudRate m_baudRate;
+
+    std::priority_queue<Command, std::deque<Command>> m_sendQueue;
+    std::deque<Command> m_recvQueue;
+    std::mutex m_sendQueueMutex;
+    std::mutex m_recvQueueMutex;
+    std::condition_variable m_sendQueueCondVar;
+    std::condition_variable m_recvQueueCondVar;
+
+    std::atomic<uint32_t> m_bytesWritten;
+    std::atomic<uint32_t> m_bytesAvailable;
+
+    SerialPortWorker(QString portName, QSerialPort::BaudRate baudRate, QObject *parent = nullptr);
+
+    Command getNextCommand();
+    void insertResult(Command const &result);
+
+    enum : uint16_t {TIMEOUT = 100, WAIT_TIME_MAX = 1000};
+
+  public:
+    ~SerialPortWorker();
+
+    SerialPortWorker(SerialPortWorker const &) = delete;
+    void operator=(SerialPortWorker const &) = delete;
+
+    // serial port im plugin anlegen. erst dann kann getInstance() benutzt werden
+    static SerialPortWorker &getInstance(QString portName, QSerialPort::BaudRate baudRate, QObject *parent = nullptr) {
+        static SerialPortWorker serialPortWorker(portName, baudRate, parent);
+        return serialPortWorker;
+    }
+
+    bool openSerialPort();
+    void closeSerialPort();
+
+    bool isPortOpen() const { return m_serialPortOpened; }
+
+    void insertCommand(Command const &cmd);
+    bool getNextResult(Command &result, int timeout = 1000);
+
+    virtual void run() override;
+
+    void quit();
+
+private slots:
+    void getBytesAvailable();
+    bool getNumberOfBytesWritten(qint64);
+};
+
+#endif // SERIAL_PORT_WORKER_H_INCLUDED

include/shared_mem_buffer.h

@@ -0,0 +1,347 @@
+#ifndef SHARED_MEM_BUFFER_INCLUDED_H
+#define SHARED_MEM_BUFFER_INCLUDED_H
+
+#include <cinttypes>
+#include <atomic>
+
+#include <QSharedMemory>
+
+// TODO: pid eintragen und convars/mutexe eintragen
+
+#ifdef __linux__
+
+
+#include <pthread.h>
+
+// PTHREAD_PROCESS_SHARED
+
+#else
+// WIN32
+#endif
+
+struct SharedMemBuffer {
+    int init;
+    char appName[32];
+    pid_t pid;
+    pthread_condattr_t sndCndA;
+    pthread_cond_t sndCndV;
+    pthread_mutexattr_t sndMtxA;
+    pthread_mutex_t sndMtx;
+
+    pthread_condattr_t rcvCndA;
+    pthread_cond_t rcvCndV;
+    pthread_mutexattr_t rcvMtxA;
+    pthread_mutex_t rcvMtx;
+
+    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 {
+#define DATIF_MAXCMDS 16
+        uint16_t sendingPeriod;
+        bool     sendingPer_changed;
+        uint8_t  OutCmdpara1;
+        uint8_t  OutCmdpara2;
+        uint8_t  OutCmdpara3;
+        uint8_t  OutCmdpara4;
+        uint16_t OutCmdpara5;
+        uint32_t OutCmdpara6;
+        uint8_t  dataStep;
+        uint8_t  scanStep;
+        uint8_t  RDBLKNR;
+        uint8_t  cycl_running;
+    } datif;
+
+    struct txt4 {
+        char comStateLine[32];
+        char HsStateLine[32];
+        char masterStateLine[32];
+        char resultStateLine[32];
+        char dataLine[32];
+        char datifReceive[32];
+        char diagWindow[32];
+        char sndDiagWindow[32];
+    } txt4;
+
+    struct dcBL {
+#define SIZEBLRESP      50
+#define RAW_BL_DATALEN 150
+        uint8_t  LastBLcmd;   // stored the last sent cmd in order to analys response
+        uint8_t  AtbBinFile[300000];
+        uint32_t fileSize;
+        uint16_t nrOfBlocks;
+        uint16_t fileCrc;
+        uint8_t  myBuf[300000]; // same content like "dcBL_AtbBinFile" but bytewise
+        char     Resp[SIZEBLRESP][32];
+        int      pResp;
+        uint8_t  step;
+        uint8_t  state;
+        uint16_t BlkCtr;
+        uint16_t cyclCtr;
+        uint16_t repeatCtr;
+    } dcBL;
+
+    struct {
+        uint16_t shutterTime;
+        char ticketTemplate[1024];
+    } hwapi;
+
+    struct {
+        uint8_t  sendAsynchDataBuf[160]; // no stack, only ONE buffer
+        uint8_t  sendAsyDatLen;
+    } next;
+
+    struct { // highest priority
+#define CMDSTACKDEPTH  16
+        // up to 16 cmd can be stored. They are issued one by one every 100ms
+        uint16_t AsynchSend[CMDSTACKDEPTH];
+        uint8_t  para1[CMDSTACKDEPTH];  /* used to streamline source */
+        uint8_t  para2[CMDSTACKDEPTH];  /* used to streamline source */
+        uint8_t  para3[CMDSTACKDEPTH];  /* used to streamline source */
+        uint8_t  para4[CMDSTACKDEPTH];  /* used to streamline source */
+        uint8_t  nrOfCmdsInQueue;
+    } Cmd0;
+
+    struct { // lower priority
+             // Command Stack for commands with 4 parameters
+#define CMD4STACKDEPTH   8
+        uint16_t AsynchSend[CMD4STACKDEPTH];
+        uint8_t  para1[CMD4STACKDEPTH];
+        uint8_t  para2[CMD4STACKDEPTH];
+        uint8_t  para3[CMD4STACKDEPTH];
+        uint8_t  para4[CMD4STACKDEPTH];
+        uint8_t  nrOfCmdsInQueue;
+    } Cmd4;
+
+    struct {
+#define CMD8STACKDEPTH   4
+        uint16_t AsynchSend[CMD8STACKDEPTH];
+        uint8_t  para1[CMD8STACKDEPTH];
+        uint8_t  para2[CMD8STACKDEPTH];
+        uint16_t para3[CMD8STACKDEPTH];
+        uint32_t para4[CMD8STACKDEPTH];
+        uint8_t  nrOfCmdsInQueue;
+    } Cmd8;
+
+    struct { // short command, 4 data bytes
+#define FDCMD_STACKDEPTH 16
+        uint8_t  wrCmd[FDCMD_STACKDEPTH];
+        uint8_t  rdCmd[FDCMD_STACKDEPTH];
+        uint8_t  blkNr[FDCMD_STACKDEPTH];
+        uint8_t  para1[FDCMD_STACKDEPTH];
+        uint8_t  para2[FDCMD_STACKDEPTH];
+        uint8_t  para3[FDCMD_STACKDEPTH];
+        uint8_t  para4[FDCMD_STACKDEPTH];
+        uint8_t  cmdsInQueue;
+    } FDShort;
+
+    struct { // long command, 64 data bytes
+#define FDLONG_STACKDEPTH 16
+        uint8_t wrCmd[FDLONG_STACKDEPTH];
+        uint8_t rdCmd[FDLONG_STACKDEPTH];
+        uint8_t blkNr[FDLONG_STACKDEPTH];
+        uint8_t length[FDLONG_STACKDEPTH];
+        uint8_t para[FDLONG_STACKDEPTH][64];
+        uint8_t cmdsInQueue;
+    } FDLong;
+
+    struct {
+        uint8_t DataParameters[4];
+        uint8_t DataBufferUser;
+        uint8_t pDataBuff;        // points to next PRINTER_BLOCK
+    } prn;
+
+    struct {
+        bool savePrnPwr;
+        bool saveMifPwr;
+        bool MdbIsOn;
+    } indat;
+
+    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
+#define MAXNROF_PRNBYTES   64
+#define MAXNROF_PRNBLOCKS  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];
+        char PRN_TEXT[MAXNROF_PRNBLOCKS][MAXNROF_PRNBYTES];
+        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];
+        uint8_t rawData[150];
+        uint8_t LengthRawData;
+        uint8_t mdbSendBuffer[64];
+        uint8_t mdbSendLen;
+    } Sdata;
+
+    uint8_t mif_cardType;
+    uint8_t mif_cardHolder[8];
+
+#define MEMDEPTH_GOTCOINS (16)
+    struct T_coin {
+        uint8_t valid;
+        uint8_t signal;
+        uint8_t error;
+        uint8_t pad;
+        uint16_t value;
+    } gotCoin[MEMDEPTH_GOTCOINS];
+    uint8_t ctr_gotCoin;
+
+    struct store {
+        uint32_t insertedAmount;
+        uint16_t lastCoinType[64];
+        uint16_t lastCoinValue[64];
+        uint64_t wakeSrc;
+        uint8_t rbDevParamLen;
+        uint8_t rbDevParams[66];
+        uint8_t deviceCondLen;
+        uint8_t deviceCond[66];
+        uint8_t machCondLen;
+        uint8_t machCond[66];
+        uint8_t DcBackupNrOfAccNr;
+        uint16_t DcBackupAccNr[16];    // z.Z. nur 8
+        uint8_t gotNrBlocksOfVaultRec;
+        uint8_t vaultrecord[360];
+        uint32_t amount;
+        uint16_t nrOfCoins;
+    } store;
+
+    struct T_globTime {
+        // Reihenfolge nicht vertauschen!!!!!
+        uint8_t     hour;
+        uint8_t     minute;
+        uint8_t     second;
+        uint8_t     Year;
+        uint8_t     Month;
+        uint8_t     DayOfMonth;
+        uint8_t     DayOfWeek;          // 1=monday...7
+        uint8_t     reserve1;
+
+        uint16_t     MinutesOfToday;
+        uint16_t     reserve2;
+
+        uint32_t     SecondsOfToday;
+
+        uint8_t      IsLeapyear;
+        uint8_t      nextLeap;
+        uint8_t      lastLeap;
+        uint8_t      hoursOfWeek;
+
+        uint16_t     minOfWeek;
+        uint16_t     hoursOfMonth;
+        uint16_t     minOfMonth;
+        uint16_t     dayOfYear;
+        uint16_t     hoursOfYear;
+        uint16_t     reserve3;
+
+        uint32_t     minOfYear;
+
+        uint8_t      squareOutMode;
+        uint8_t      free1;
+        uint16_t     reserve4;
+        uint32_t     minOfMillenium;
+        // bis hierher 44byts
+        uint32_t    free2;
+        uint32_t    free3;
+        uint32_t    free4;
+    } getGlobalTime;
+
+    static QSharedMemory *getShm(std::size_t s = 0);
+    static SharedMemBuffer *getData() {
+        return (SharedMemBuffer *)getShm()->data();
+    }
+    static SharedMemBuffer const *getDataConst() {
+        return (SharedMemBuffer const *)getShm()->data();
+    }
+
+#if 0
+    static std::atomic<bool> __sharedMemLocked;
+
+    static bool sharedMemLocked() {
+        return __sharedMemLocked;
+    }
+    static void setSharedMemLocked() {
+        __sharedMemLocked = true;
+    }
+    static void setSharedMemUnlocked() {
+        __sharedMemLocked = false;
+    }
+#endif
+};
+
+#endif // SHARED_MEM_BUFFER_INCLUDED_H

include/storeINdata.h

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

include/tslib.h

@@ -13,6 +13,9 @@ uint32_t uchar2ulong(uint8_t Highbyte, uint8_t MHbyte, uint8_t MLbyte, uint8_t L
 
 uint8_t  uint2uchar(uint16_t uival, bool getHighB);
 
+uint8_t ulong2uchar(uint32_t ulval, uint8_t getBytNr);
+    // getBytNr: 0=LSB  3=MSB
+
 
 void delay(uint16_t MilliSec);
 
@@ -59,6 +62,7 @@ void GetShortDateString(uint8_t day, uint8_t month, uint8_t yearlow, uint8_t for
 
 
 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);
@@ -79,6 +83,8 @@ 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/com.cpp

@@ -8,7 +8,7 @@
 ///
 //////////////////////////////////////////////////////////////////////////////////
 
-
+static int64_t com_want2read;
 // -------------------------------------------------------------------------------------------------------------
 // --------- PUBLIC --------------------------------------------------------------------------------------------
 // -------------------------------------------------------------------------------------------------------------
@@ -78,7 +78,7 @@ T_com::T_com(QWidget *parent) : QMainWindow(parent)
     connect(ChkConnectTimer, SIGNAL(timeout()), this, SLOT(ser_ISR100ms()));
     ChkConnectTimer->setSingleShot(false);
     ChkConnectTimer->start(100);     // in ms
-
+    com_want2read=0;
 }
 
 
@@ -93,29 +93,34 @@ T_com::~T_com()
 
 void T_com::ser_ISR100ms()
 {
+    //qDebug() << "~~>LIB" << "ENTER...";
     // call every 100ms to check if user(HMI) wants to connect or disconnect
-
-    //qDebug() << "~~>LIB" << "checking connect button... " ;
-
     uint8_t chkConn = gpi_getSerialConn();    // from global GUI buffer (Sdata)
+
+    //qDebug() << "~~>LIB" << "checking connect button... " << chkConn;
+
     switch (chkConn)
     {
         case 0: // 0 button "connect" was just released
+                //qDebug() << "close serial port" << chkConn;
                 closeSerialPort();
                 gpi_serialChanged();    // set chkConn to 2, thus getting edge
                 break;
         case 1: // 1 button "connect" was just pressed
+                //qDebug() << "open serial port" << chkConn;
                 open_Serial_Port();
                 gpi_serialChanged();    // set chkConn to 2, thus getting edge
                 break;
     }
 
 
-    if (CatSerial->isOpen())
+    if (CatSerial->isOpen()) {
         gpi_serialIsOpen(true);
-    else
+    } else {
         gpi_serialIsOpen(false);
+    }
 
+    //qDebug() << "LEAVE " << chkConn;
 }
 
 // -------------------------------------------------------------------------------------------------------------
@@ -124,17 +129,24 @@ void T_com::ser_ISR100ms()
 
 char T_com::open_Serial_Port()
 {
+    //qDebug() << "ENTER";
+
     bool ret;
     QString myString=nullptr, myPortName=nullptr, myBaudStr=nullptr;
     int myBaudNr;
 
-    if (CatSerial->isOpen())
+    if (CatSerial->isOpen()) {
+        qDebug() << "!!!IS OPEN!!!";
         return 0;                   // opening twice is not allowed
+    }
 
     //qDebug() << "connecting..." << myPortName;
     myPortName=gpi_getComPortName();                // was selected and stored from GUI
     CatSerial->setPortName(myPortName);
     myBaudNr=gpi_getBaudNr();                       // was selected and stored from GUI
+
+    //qDebug() << "myPortName" << myPortName << ", myBaudNr" << myBaudNr;
+
     switch (myBaudNr)
     {
         // 0:1200   1:9600   2:19200   3:38400   4:57600   5:115200
@@ -167,6 +179,9 @@ char T_com::open_Serial_Port()
         myString.append(CatSerial->errorString());
         qDebug() << myString;
         gpi_setTxt4comStateLine(myString);
+
+        //qDebug() << "LEAVE";
+
         return 0;
     } else
     {
@@ -182,11 +197,14 @@ char T_com::open_Serial_Port()
 
     }
 
-     return 0;
+    //qDebug() << "LEAVE";
+    return 0;
 }
 
 void T_com::closeSerialPort()
 {
+    //qDebug() << "ENTER";
+
     if (CatSerial->isOpen())
     {
         qDebug() << "closing connection";
@@ -195,6 +213,8 @@ void T_com::closeSerialPort()
         gpi_setTxt4RsDiagWin("closed");
 
     }
+
+    //qDebug() << "LEAVE";
 }
 
 
@@ -202,9 +222,48 @@ void T_com::readSomeBytes(void)
 {
     // called by serial-read-detection
     // restart off-time as input flow is ongoing
-    serRecTime->stop();
-    serRecTime->start(20);     // in ms
 
+    // 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)
@@ -252,6 +311,7 @@ void T_com::receiveTO(void)
         //gpi_set2ndTxt4RsDiagWin(myString);
 
         // report "new data received" to other objects
+        //qDebug()<< "com-recFinished by TO";
         emit receivingFinished();
     }
 }

src/controlBus.cpp

@@ -1,415 +1,310 @@
 #include <stdint.h>
+#include <algorithm>
+
 #include <QString>
 #include <QDebug>
 #include "tslib.h"
-//#include "controlBus.h"
+#include "shared_mem_buffer.h"
 
 // ///////////////////////////////////////////////////////////////////////////////////
 //          control serial interface   gui <--> serial
 // ///////////////////////////////////////////////////////////////////////////////////
+void epi_setSerial(int BaudNr,
+                   QString BaudStr,
+                   QString ComName,
+                   uint8_t connect) {
+    memset(&SharedMemBuffer::getData()->rs.comportName[0], 0x00,
+           sizeof(SharedMemBuffer::getData()->rs.comportName));
+    strncpy(SharedMemBuffer::getData()->rs.comportName,
+            ComName.toStdString().c_str(),
+            sizeof(SharedMemBuffer::getData()->rs.comportName)-1);
 
-static QString    rs_comportName;   // z.B. "COM48"
-static QString    rs_baudStr;       // z.B. "19200"
-static int        rs_baudNr;        //0...5 oder -1
-static uint8_t    rs_connect;       // 0,1
-
-void epi_setSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect)
-{
-    rs_comportName = ComName;
-    rs_baudStr     = BaudStr;
-    rs_baudNr      = BaudNr;    // 0=1200  1=9600  2=19200  3=38400  4=57600  5=115200  oder -1
-    rs_connect     = connect;     // 0/1
+    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)
-{
-    rs_connect=0;
+void epi_closeSerial(void) {
+    SharedMemBuffer::getData()->rs.connect = 0;
 }
 
-
-void gpi_serialChanged(void)
-{
+void gpi_serialChanged(void) {
     // serial confirms that port was closed or opened
-    rs_connect=2;   // Flanke, nur 1x öffnen/schließen
+    // rs_connect=2;   // Flanke, nur 1x öffnen/schließen
+    SharedMemBuffer::getData()->rs.connect = 2;
 }
 
-uint8_t gpi_getSerialConn(void)
-{
-    return rs_connect;
+uint8_t gpi_getSerialConn(void) {
+    return SharedMemBuffer::getDataConst()->rs.connect;
 }
 
-
-int gpi_getBaudNr(void)
-{
-    return rs_baudNr;
+int gpi_getBaudNr(void) {
+    return SharedMemBuffer::getDataConst()->rs.baudNr;
 }
 
-QString gpi_getComPortName(void)
-{
-    return rs_comportName;
+QString gpi_getComPortName(void) {
+    return SharedMemBuffer::getDataConst()->rs.comportName;
 }
 
-static bool rs_portIsOpen;
-
-void gpi_serialIsOpen(bool offen)
-{
-    rs_portIsOpen=offen;
+void gpi_serialIsOpen(bool offen) {
+    SharedMemBuffer::getData()->rs.portIsOpen = offen;
 }
 
-bool epi_isSerialPortOpen()
-{
+bool epi_isSerialPortOpen() {
     // true: port is open   false: port is closed
-    return rs_portIsOpen;
+    return SharedMemBuffer::getDataConst()->rs.portIsOpen;
 }
 
 // ///////////////////////////////////////////////////////////////////////////////////
 //          Control transfer   gui <--> serial
 // ///////////////////////////////////////////////////////////////////////////////////
 
-
-static char       AutoEmissionOn;     // 1: zyklisch Anfragen zum Slave senden
-
-void epi_startEmmision(char start)
-{
-    AutoEmissionOn=start;
+void epi_startEmmision(char start) {
+    SharedMemBuffer::getData()->AutoEmissionOn = start;
 }
 
-bool gpi_isEmmisionOn(void)
-{
-    return AutoEmissionOn;
+bool gpi_isEmmisionOn(void) {
+    return SharedMemBuffer::getDataConst()->AutoEmissionOn;
 }
 
-//-----------------------------------------------------
-
-static uint16_t datif_sendingPeriod;
-static bool     datif_sendingPer_changed;
-
-uint16_t gpi_getPeriodicSendTimeVal()
-{
-    datif_sendingPer_changed=0;
-    if (datif_sendingPeriod<3 || datif_sendingPeriod>10000)
+uint16_t gpi_getPeriodicSendTimeVal() {
+    SharedMemBuffer::getData()->datif.sendingPer_changed = 0;
+    if ((SharedMemBuffer::getDataConst()->datif.sendingPeriod < 3) ||
+        (SharedMemBuffer::getDataConst()->datif.sendingPeriod > 10000)) {
         return 130;         // ms, default
-    else
-        return datif_sendingPeriod;
+    }
+    return SharedMemBuffer::getDataConst()->datif.sendingPeriod;
 }
 
-void epi_setPeriodicSendTimeVal(uint16_t val)
-{
-    if (val>=3 && val<10000)
-    {
-        datif_sendingPer_changed=1;
-        datif_sendingPeriod=val;
+void epi_setPeriodicSendTimeVal(uint16_t val) {
+    if (val>=3 && val<10000) {
+        SharedMemBuffer::getData()->datif.sendingPer_changed = 1;
+        SharedMemBuffer::getData()->datif.sendingPeriod = val;
     }
 }
 
-bool gpi_PeriodicSendTimeHasChanged()
-{
-    return datif_sendingPer_changed;
+bool gpi_PeriodicSendTimeHasChanged() {
+    return SharedMemBuffer::getDataConst()->datif.sendingPer_changed;
 }
 
-//-----------------------------------------------------
-
-
-//-----------------------------------------------------
-
 // ///////////////////////////////////////////////////////////////////////////////////
 //          Status Display    gui <--> serial
 // ///////////////////////////////////////////////////////////////////////////////////
 
-
-//              linke Spalte, über Connect Button
-static QString txt4comStateLine;
-
-QString epi_getTxt4comStateLine(void)
-{
+// linke Spalte, über Connect Button
+QString epi_getTxt4comStateLine(void) {
     // GUI: get Text for serial Comport-State Line
-    return txt4comStateLine;
+    return SharedMemBuffer::getDataConst()->txt4.comStateLine;
 }
 
-void gpi_setTxt4comStateLine(QString txtline)     // gpi
-{
+void gpi_setTxt4comStateLine(QString txtline) {
     // serial: write Text to be displayed in serial Comport-State line (like "connected")
-    txt4comStateLine.clear();
-    if (txtline=="")
-        txt4comStateLine.clear();
-    else
-        txt4comStateLine=txtline;
+    memset(SharedMemBuffer::getData()->txt4.comStateLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.comStateLine));
+    memcpy(SharedMemBuffer::getData()->txt4.comStateLine,
+           txtline.toStdString().c_str(),
+           sizeof(SharedMemBuffer::getData()->txt4.comStateLine)-1);
 }
 
-void epi_clrTxt4comStateLine()
-{
-    txt4comStateLine.clear();
+void epi_clrTxt4comStateLine() {
+    memset(SharedMemBuffer::getData()->txt4.comStateLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.comStateLine));
 }
 
-
-//---------------------------------------------------------------------------------------------
-
 // 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;
+QString epi_getTxt4HsStateLine(void) {
+    return SharedMemBuffer::getDataConst()->txt4.HsStateLine;
 }
 
-void gpi_setTxt4HsStateLine(QString txtline)
-{
-    txt4HsStateLine.clear();
-    if (txtline=="")
-        txt4HsStateLine.clear();
-    else
-        txt4HsStateLine=txtline;
+void gpi_setTxt4HsStateLine(QString txtline) {
+    // serial: write Text to be displayed in serial Comport-State line (like "connected")
+    memset(SharedMemBuffer::getData()->txt4.HsStateLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.HsStateLine));
+    memcpy(SharedMemBuffer::getData()->txt4.HsStateLine,
+           txtline.toStdString().c_str(),
+           sizeof(SharedMemBuffer::getData()->txt4.HsStateLine)-1);
 }
 
-void epi_clrTxt4HsStateLine()
-{
-    txt4HsStateLine.clear();
+void epi_clrTxt4HsStateLine() {
+    memset(SharedMemBuffer::getData()->txt4.HsStateLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.HsStateLine));
 }
 
-
-
-//---------------------------------------------------------------------------------------------
-
 // 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;
+QString epi_getTxt4masterStateLine(void) {
+    return SharedMemBuffer::getDataConst()->txt4.masterStateLine;
 }
 
-void gpi_setTxt4masterStateLine(QString txtline)
-{
-    txt4masterStateLine.clear();
-    if (txtline=="")
-        txt4masterStateLine.clear();
-    else
-        txt4masterStateLine=txtline;
+void gpi_setTxt4masterStateLine(QString txtline) {
+    memset(SharedMemBuffer::getData()->txt4.masterStateLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.masterStateLine));
+    memcpy(SharedMemBuffer::getData()->txt4.masterStateLine,
+           txtline.toStdString().c_str(),
+           sizeof(SharedMemBuffer::getData()->txt4.masterStateLine)-1);
 }
 
-void epi_clrTxt4masterStateLine()
-{
-    txt4masterStateLine.clear();
+void epi_clrTxt4masterStateLine() {
+    memset(SharedMemBuffer::getData()->txt4.masterStateLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.masterStateLine));
 }
 
-
-
 //---------------------------------------------------------------------------------------------
 
 // 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;
+QString epi_getTxt4resultStateLine(void) {
+    return SharedMemBuffer::getDataConst()->txt4.resultStateLine;
 }
 
-void gpi_setTxt4resultStateLine(QString txtline)
-{
-    txt4resultStateLine.clear();
-    if (txtline=="")
-        txt4resultStateLine.clear();
-    else
-        txt4resultStateLine=txtline;
+void gpi_setTxt4resultStateLine(QString txtline) {
+    memset(SharedMemBuffer::getData()->txt4.resultStateLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.resultStateLine));
+    memcpy(SharedMemBuffer::getData()->txt4.resultStateLine,
+           txtline.toStdString().c_str(),
+           sizeof(SharedMemBuffer::getData()->txt4.resultStateLine)-1);
 }
 
-void epi_clrTxt4resultStateLine()
-{
-    txt4resultStateLine.clear();
+void epi_clrTxt4resultStateLine() {
+    memset(SharedMemBuffer::getData()->txt4.resultStateLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.resultStateLine));
 }
 
-
 //---------------------------------------------------------------------------------------------
-
 // IV  Statuszeile Empfangsdaten
-static QString txt4dataLine;
-
-QString epi_getTxt4dataStateLine(void)
-{
+QString epi_getTxt4dataStateLine(void) {
     // GUI: get Text for serial Comport-State Line
-    return txt4dataLine;
-
+    return SharedMemBuffer::getDataConst()->txt4.dataLine;
 }
 
-void gpi_setTxt4dataStateLine(QString txtline)
-{
+void gpi_setTxt4dataStateLine(QString txtline) {
     // serial: write Text to be displayed in serial Comport-State line (like "connected")
-    txt4dataLine.clear();
-    if (txtline=="")
-        txt4dataLine.clear();
-    else
-        txt4dataLine=txtline;
+    memset(SharedMemBuffer::getData()->txt4.dataLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.dataLine));
+    memcpy(SharedMemBuffer::getData()->txt4.dataLine,
+           txtline.toStdString().c_str(),
+           sizeof(SharedMemBuffer::getData()->txt4.dataLine)-1);
 }
 
-void epi_clrTxt4dataStateLine()
-{
-    txt4dataLine.clear();
+void epi_clrTxt4dataStateLine() {
+    memset(SharedMemBuffer::getData()->txt4.dataLine,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.dataLine));
 }
 
 //---------------------------------------------------------------------------------------------
 
 // 5. Zeile: Datif Ergebnis, Daten brauchbar?
-
-static QString txt4datifReceive;
-
-QString epi_getTxt4datifLine(void)
-{
-
-    return txt4datifReceive;
-
+QString epi_getTxt4datifLine(void) {
+    return SharedMemBuffer::getDataConst()->txt4.datifReceive;
 }
 
-void gpi_setTxt4datifLine(QString txtline)
-{
-
-    txt4datifReceive.clear();
-    if (txtline=="")
-        txt4datifReceive.clear();
-    else
-        txt4datifReceive=txtline;
+void gpi_setTxt4datifLine(QString txtline) {
+    memset(SharedMemBuffer::getData()->txt4.datifReceive,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.datifReceive));
+    memcpy(SharedMemBuffer::getData()->txt4.datifReceive,
+           txtline.toStdString().c_str(),
+           sizeof(SharedMemBuffer::getData()->txt4.datifReceive)-1);
 }
 
-void epi_clrTxt4datifLine()
-{
-    txt4datifReceive.clear();
+void epi_clrTxt4datifLine() {
+    memset(SharedMemBuffer::getData()->txt4.datifReceive,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.datifReceive));
 }
 
-//---------------------------------------------------------------------------------------------
-//---------------------------------------------------------------------------------------------
-
-static QString txt4diagWindow;
-
-QString epi_getTxt4RsDiagWin(void)
-{
-    return txt4diagWindow;
-
+QString epi_getTxt4RsDiagWin(void) {
+    return SharedMemBuffer::getDataConst()->txt4.diagWindow;
 }
 
-void gpi_setTxt4RsDiagWin(QString txtline)
-{
-    txt4diagWindow.clear();
-    if (txtline=="")
-        txt4diagWindow.clear();
-    else
-        txt4diagWindow=txtline;
+void gpi_setTxt4RsDiagWin(QString txtline) {
+    memset(SharedMemBuffer::getData()->txt4.diagWindow,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.diagWindow));
+    memcpy(SharedMemBuffer::getData()->txt4.diagWindow,
+           txtline.toStdString().c_str(),
+           sizeof(SharedMemBuffer::getData()->txt4.diagWindow)-1);
 }
 
-void epi_clrTxt4RsDiagWin()
-{
-    txt4diagWindow.clear();
+void epi_clrTxt4RsDiagWin() {
+    memset(SharedMemBuffer::getData()->txt4.diagWindow,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.diagWindow));
 }
 
-//---------------------------------------------------------------------------------------------
-
-static QString sndTxt4diagWindow;
-
-QString epi_get2ndTxt4RsDiagWin(void)
-{
-    return sndTxt4diagWindow;
-
+QString epi_get2ndTxt4RsDiagWin(void) {
+    return SharedMemBuffer::getDataConst()->txt4.sndDiagWindow;
 }
 
-void gpi_set2ndTxt4RsDiagWin(QString txtline)
-{
-    sndTxt4diagWindow.clear();
-    if (txtline=="")
-        sndTxt4diagWindow.clear();
-    else
-        sndTxt4diagWindow=txtline;
+void gpi_set2ndTxt4RsDiagWin(QString txtline) {
+    memset(SharedMemBuffer::getData()->txt4.sndDiagWindow,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.sndDiagWindow));
+    memcpy(SharedMemBuffer::getData()->txt4.sndDiagWindow,
+           txtline.toStdString().c_str(),
+           sizeof(SharedMemBuffer::getData()->txt4.sndDiagWindow)-1);
 }
 
-void epi_clr2ndTxt4RsDiagWin()
-{
-    sndTxt4diagWindow.clear();
+void epi_clr2ndTxt4RsDiagWin() {
+    memset(SharedMemBuffer::getData()->txt4.sndDiagWindow,
+           0x00, sizeof(SharedMemBuffer::getData()->txt4.sndDiagWindow));
 }
 
 // ///////////////////////////////////////////////////////////////////////////////////
 //          Memory for Slave responses, common data
 // ///////////////////////////////////////////////////////////////////////////////////
-
-
-static bool Sdata_serialTestResult;
-
-void gpi_storeResult_serialTestOK(bool wasOk)
-{
-    Sdata_serialTestResult=wasOk;
+void gpi_storeResult_serialTestOK(bool wasOk) {
+    SharedMemBuffer::getData()->Sdata.serialTestResult = wasOk;
 }
 
-bool epi_getResult_serialTestOK()
-{
+bool epi_getResult_serialTestOK() {
     // retval: true: test was successful, got right response
-    return Sdata_serialTestResult;
+    return SharedMemBuffer::getDataConst()->Sdata.serialTestResult;
 }
 
-
-
 // ///////////////////////////////////////////////////////////////////////////////////
 //          Store received data for hwapi
 // ///////////////////////////////////////////////////////////////////////////////////
-
-
-
-static uint8_t Sdata_pProtResultOk;
-
-void gpi_startNewRequest()
-{
-    Sdata_pProtResultOk=0;
+void gpi_startNewRequest() {
+    SharedMemBuffer::getData()->Sdata.pProtResultOk = 0;
 }
 
-void gpi_storeResultOfLastRequest(bool answisok)
-{
-    if (answisok)
-        Sdata_pProtResultOk=1;
-    else
-        Sdata_pProtResultOk=2;
+void gpi_storeResultOfLastRequest(bool answisok) {
+    SharedMemBuffer::getData()->Sdata.pProtResultOk = answisok ? 1 : 2;
 }
 
-uint8_t epi_getResultOfLastRequest()
-{
+uint8_t epi_getResultOfLastRequest() {
     // retval: 0: in progress  1: OK  2: error
-    return Sdata_pProtResultOk;
+    return SharedMemBuffer::getDataConst()->Sdata.pProtResultOk;
 }
 
-
-
-
-static uint16_t Sdata_receivedDataLength;
-static uint8_t Sdata_receivedDataBlock[64];
-
-void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t *receivedData)
-{
-    Sdata_receivedDataLength=uint16_t(RdDlen);
-    if (Sdata_receivedDataLength>64)
-        Sdata_receivedDataLength=64;
-    tslib_strclr(Sdata_receivedDataBlock,0,64);
-    tslib_strcpy(receivedData, Sdata_receivedDataBlock, Sdata_receivedDataLength);
-
+void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t const *receivedData) {
+    SharedMemBuffer::getData()->Sdata.receivedDataLength
+        = std::min(RdDlen, (uint8_t)(64));
+    memset((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
+           0x00, sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock));
+    strncpy((char *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
+            (char const *)receivedData,
+            sizeof(SharedMemBuffer::getData()->Sdata.receivedDataBlock)-1);
 }
 
-uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad)
-{
+uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad) {
     // get data back in *pl, max 64 byte
     // retval = nr of bytes received. If host buffer too small then
     // only plBufSíz bytes are copied to pl
     // plBufSíz=size of host buffer
 
-    uint16_t ml=plBufSiz;
-    if (ml>64) ml=64;
-    if (Sdata_receivedDataLength<ml)
-        ml=Sdata_receivedDataLength;
-    tslib_strcpy(Sdata_receivedDataBlock, payLoad, ml);
-    return Sdata_receivedDataLength;
+    uint16_t ml = std::min(plBufSiz, (uint16_t)(64));
+    if (SharedMemBuffer::getDataConst()->Sdata.receivedDataLength < ml) {
+        ml = SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
+    }
+    strncpy((char *)payLoad,
+            (char const *)(&SharedMemBuffer::getData()->Sdata.receivedDataBlock[0]),
+            ml);
+
+    return SharedMemBuffer::getDataConst()->Sdata.receivedDataLength;
 }
-
-
-
-
-

src/main.cpp

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

src/prot.cpp

@@ -9,9 +9,33 @@ T_prot::T_prot()
 
     mySerialPort = new T_com();
     connect(mySerialPort, SIGNAL(receivingFinished()), this, SLOT( analyseRecData() ));
-    //connect(mySerialPort, SIGNAL(receivingFinished()), this, SLOT( receivFin() ));
     //connect(mySerialPort, SIGNAL(sendingFinished()), this, SLOT(sendeFin()));
-    kindOfData=0;    // 0: binaries, 1:text
+
+    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;
 
 }
 
@@ -30,6 +54,19 @@ 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)
 {
@@ -43,6 +80,8 @@ void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t  WrDat
         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)
@@ -54,6 +93,8 @@ void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr)
         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)
@@ -65,6 +106,8 @@ void T_prot::setUserWriteData(uint16_t WriteCmd)
         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)
@@ -76,6 +119,8 @@ void T_prot::setUserWrite1DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val)
     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)
@@ -87,6 +132,8 @@ void T_prot::setUserWrite2DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, u
     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)
@@ -101,6 +148,8 @@ void T_prot::setUserWriteText(uint16_t WriteCmd, uint16_t WrAddr, uint8_t  WrDat
         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)
@@ -109,6 +158,8 @@ void T_prot::setUserReadData( uint16_t ReadCmd,  uint16_t RdAddr, uint16_t reser
     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)
@@ -117,6 +168,8 @@ void T_prot::setUserReadData( uint16_t ReadCmd,  uint16_t RdAddr)
     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)
@@ -125,6 +178,8 @@ void T_prot::setUserReadData( uint16_t 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)
@@ -137,8 +192,14 @@ void T_prot::setBLsendData( uint8_t len, uint8_t *buf)
     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()<<"prot: got BL data " << len << "bytes, ";
     /*
 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];
@@ -153,6 +214,11 @@ qDebug() <<buf[72] <<buf[73] <<buf[74] <<buf[75] <<buf[76] <<buf[77] <<buf[78]<<
 */
 }
 
+void T_prot::receiveFixLen(int64_t nrOfbytesToReceive)
+{
+    mySerialPort->receiveFixLen(nrOfbytesToReceive);
+}
+
 void T_prot::sendUserData(uint16_t slaveAdr)
 {
     // man könnte hier noch "SendDataValid" abfragen,
@@ -167,14 +233,90 @@ void T_prot::sendUserData(uint16_t slaveAdr)
         // 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]);
+            packBuf_2[nn]=char(ui8BLsendData[nn]);        
         mySerialPort->writeToSerial(packBuf_2, BLsendDataLength);
 
 
     } else
-        startPacking();
+        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;
@@ -262,10 +404,8 @@ void T_prot::startPacking(void)
     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.....
@@ -293,7 +433,7 @@ uint8_t recBuffer[FRAME_MAXLEN];
 
     // read from "VCP":
     mySerialPort->readFromSerial(Indata, recLength);
-
+//qDebug()<<"prot: got data " << recLength;
     if (recLength>FRAME_MAXLEN)
         recLength=FRAME_MAXLEN;
     for (int nn=0; nn<recLength; nn++)
@@ -301,10 +441,11 @@ uint8_t recBuffer[FRAME_MAXLEN];
 
     myString.clear();
     tempStr.clear();
-    uint8_t result=FramecheckInData(recBuffer, recLength);  // check input data (response from slave)
+    //uint8_t result=FramecheckInData(recBuffer, recLength);  // check input data (response from slave)
+    uint8_t result=FastCheckInData(recBuffer, recLength);  // check input data (response from slave)
     if (result>0)
     {
-        // dann anzeigen und ende
+        // dann anzeige
         switch (result)
         {
           case 1: gpi_setTxt4masterStateLine("wrong length received"); break;
@@ -316,6 +457,7 @@ uint8_t recBuffer[FRAME_MAXLEN];
         }
         myString.setNum(result);
 
+        // Daten abspeichern, könnten vom BL sein:
         gpi_storeRawReceivedData(uint8_t(recLength), recBuffer);
         emit rawDataRecieved();
 
@@ -328,16 +470,59 @@ uint8_t recBuffer[FRAME_MAXLEN];
         // konnte der Slave die geforderten Daten ausgeben (DOs, AOs)?
         // konnte der Slave die geforderten Daten einlesen (AIs, DIs)?
 
-        CheckInResult(recBuffer);    // Ergebnisse des Slaves anzeigen
+        //CheckInResult(recBuffer);    // Ergebnisse des Slaves anzeigen
+            // stimmt nicht mehr bei FastProt
 
-        CheckInData(recBuffer);    // Eingangs-Daten des Slaves anzeigen
+        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)
 {
 
@@ -385,7 +570,7 @@ uint8_t T_prot::FramecheckInData(uint8_t *Inbuf, uint16_t LL)
     }
     return 0;
 }
-
+*/
 
 uint8_t T_prot::CheckInResult(uint8_t *Inbuf)
 {
@@ -438,24 +623,27 @@ uint8_t T_prot::CheckInResult(uint8_t *Inbuf)
 
 
 
-uint8_t T_prot::CheckInData(uint8_t *recBuffer)
+uint8_t T_prot::ShowFastInData(uint8_t *recBuffer)
 {
     QString myString=nullptr, tempStr=nullptr;
+    uint8_t result;
 
-    RecSlaveAddr=recBuffer[1];
-    if (recBuffer[2]==0 && recBuffer[4]==0)     // comand result=OK und read result =OK,
-                                                // dann sind die Eingangsdaten gültig
+    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=uchar2uint(recBuffer[6],recBuffer[5]);
-        readAddress=uchar2uint(recBuffer[8],recBuffer[7]);
-        //lastWakeSrc=uint8_t(recBuffer[4]);
-        RdDataLength=uint8_t(recBuffer[9]);
+        //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+10]);
+            InputData[ii]=uint8_t(recBuffer[ii+HEADERLEN_RECEIVE]);
 
         tempStr.setNum(readSource,16);
         myString.append(tempStr);
@@ -486,6 +674,57 @@ uint8_t T_prot::CheckInData(uint8_t *recBuffer)
     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()
 {

src/sendWRcmd.cpp

@@ -1,268 +1,157 @@
-#include <stdint.h>
+#include <cstdint>
+#include <algorithm>
+
 #include <QString>
 #include <QDebug>
+
 #include "tslib.h"
 #include "sendWRcmd.h"
-
+#include "shared_mem_buffer.h"
 
 void indat_PrnPwr(void);
 
+/* 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
 
-void sendWRcmd_INI(void)
-{
+    Send: [0] first, then move buffer 1 down:
+    nextAsynchsendCmd0[0]=cmd2
+    nextAsynchsendCmd0[1]=cmd3
+    nextAsynchsendCmd0[2]=cmd4
+    nextAsynchsendCmd0[3]=0;
+    nrOfCmdsInQueue=3 now
+*/
+template <typename T, std::size_t N>
+static void *move_buffer_down_by_one(T (&buffer)[N]) {
+    return memmove(buffer, &buffer[1], sizeof(buffer)-sizeof(buffer[0]));
+}
+template <typename T, std::size_t N>
+static void clear(T (&buffer)[N]) {
+    memset((char *)(&buffer[0]), 0x00, sizeof(buffer));
+}
+template <typename T, std::size_t M, std::size_t N>
+static void clear(T (&buffer)[M][N]) {
+    memset((char *)(&buffer[0][0]), 0x00, sizeof(buffer));
+}
+template <typename T>
+static void sendWRcmd_clearCmdStack(T &cmdStack) {
+    clear(cmdStack.AsynchSend);
+    clear(cmdStack.para1);
+    clear(cmdStack.para2);
+    clear(cmdStack.para3);
+    clear(cmdStack.para4);
+    cmdStack.nrOfCmdsInQueue = 0;
+}
+template <typename T, typename T1, typename T2, typename T3, typename T4>
+static bool sendWRcmd_setSendCmd(T &cmdStack, uint16_t nextCmd, T1 dat1,
+                                 T2 dat2, T3 dat3, T4 dat4) {
+    uint8_t const &n = cmdStack.nrOfCmdsInQueue;
+    int const STACKDEPTH = sizeof(cmdStack.para1);
+    if (n < STACKDEPTH) {
+        cmdStack.AsynchSend[n] = nextCmd;
+        cmdStack.para1[n] = dat1;
+        cmdStack.para2[n] = dat2;
+        cmdStack.para3[n] = dat3;
+        cmdStack.para4[n] = dat4;
+        cmdStack.nrOfCmdsInQueue += 1;
+        return true;                // ok, will be sent
+    }
+    qCritical() << "cannot save cmd because stack is full";
+    return false;           // not possible
+}
+template <typename T, typename T1, typename T2, typename T3, typename T4>
+static bool sendWRcmd_getSendCmd(T &cmdStack, T1 *dat1, T2 *dat2,
+                                 T3 *dat3, T4 *dat4) {
+    if (dat1 && dat2 && dat3 && dat4) {
+        uint8_t const &n = cmdStack.nrOfCmdsInQueue;
+        int const STACKDEPTH = sizeof(cmdStack.para1);
+        if ((n > 0) && (n <= STACKDEPTH)) {
+            uint16_t const nxt = cmdStack.AsynchSend[0];
+            move_buffer_down_by_one(cmdStack.AsynchSend);
+            *dat1 = cmdStack.para1[n];
+            *dat2 = cmdStack.para2[n];
+            *dat3 = cmdStack.para3[n];
+            *dat4 = cmdStack.para4[n];
+            cmdStack.nrOfCmdsInQueue = n - 1;
+            return nxt;
+        }
+    }
+    qCritical() << "cannot fetch cmd";
+    return 0;   // error
+}
 
+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;
+void sendWRcmd_clrCmdStack(void) {
+    sendWRcmd_clearCmdStack(SharedMemBuffer::getData()->Cmd0);
+}
+void sendWRcmd_clrCmd4Stack(void) {
+    sendWRcmd_clearCmdStack(SharedMemBuffer::getData()->Cmd4);
+}
+void sendWRcmd_clrCmd8Stack(void) {
+    sendWRcmd_clearCmdStack(SharedMemBuffer::getData()->Cmd8);
 }
 
-bool sendWRcmd_setSendCommand0(uint16_t nextCmd)
-{
+bool sendWRcmd_setSendCommand0(uint16_t nextCmd, uint8_t dat1, uint8_t dat2,
+                               uint8_t dat3, uint8_t dat4) {
     // 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
+    return sendWRcmd_setSendCmd(SharedMemBuffer::getData()->Cmd0,
+                                nextCmd, dat1, dat2, dat3, dat4);
 }
-
-uint16_t sendWRcmd_getSendCommand0(void)
-{
-    uint16_t nxtAsynchCmd;
-    uint8_t nn;
-    if (nrOfCmdsInQueue==0 || nrOfCmdsInQueue>CMDSTACKDEPTH)
-        return 0;   // error
-    nxtAsynchCmd=nextAsynchsendCmd0[0];
-    // move Puffer down by one element
-    for (nn=0; nn<CMDSTACKDEPTH; 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)
-{
+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
+    return sendWRcmd_setSendCmd(SharedMemBuffer::getData()->Cmd4, nextCmd, dat1,
+                                dat2, dat3, dat4);
 }
-
-uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4)
-{
-    uint16_t nxtAsynchCmd;
-    uint8_t nn;
-
-    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
-    for (nn=0; nn<CMD4STACKDEPTH; 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)
-{
+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 sendWRcmd_setSendCmd(SharedMemBuffer::getData()->Cmd8, nextCmd, dat1,
+                                dat2, dat3, dat4);
+}
+
+uint16_t sendWRcmd_getSendCommand0(uint8_t *dat1, uint8_t *dat2,
+                                   uint8_t *dat3, uint8_t *dat4) {
+    return sendWRcmd_getSendCmd(SharedMemBuffer::getData()->Cmd0, dat1, dat2,
+                                dat3, dat4);
+}
+uint16_t sendWRcmd_getSendCommand4(uint8_t *dat1, uint8_t *dat2,
+                                   uint8_t *dat3, uint8_t *dat4) {
+    return sendWRcmd_getSendCmd(SharedMemBuffer::getData()->Cmd4, dat1, dat2,
+                                dat3, dat4);
+}
+uint16_t sendWRcmd_getSendCommand8(uint8_t *dat1, uint8_t *dat2,
+                                   uint16_t *dat3, uint32_t *dat4) {
+    return sendWRcmd_getSendCmd(SharedMemBuffer::getData()->Cmd8, dat1, dat2,
+                                dat3, dat4);
+}
+
+bool sendWRcmd_setSendBlock160(uint8_t leng, uint8_t const *buf) {
+    SharedMemBuffer::getData()->next.sendAsyDatLen = std::min(leng, (uint8_t)160);
+    clear(SharedMemBuffer::getData()->next.sendAsynchDataBuf);
+    memcpy((char *)(&SharedMemBuffer::getData()->next.sendAsynchDataBuf),
+           (char const *)(buf),
+           SharedMemBuffer::getDataConst()->next.sendAsyDatLen);
     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;
-
-    if (nrOfCmds8InQueue==0 || nrOfCmds8InQueue>CMD4STACKDEPTH)
-        return 0;   // error
-    nxtAsynchCmd=nextAsynchsendCmd8[0];
-    *dat1=nextCmd8para1[0];
-    *dat2=nextCmd8para2[0];
-    *dat3=nextCmd8para3[0];
-    *dat4=nextCmd8para4[0];
-
-    // move buffer down by one element
-    for (nn=0; nn<CMD8STACKDEPTH; 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)
-{
+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);
+    *leng = SharedMemBuffer::getDataConst()->next.sendAsyDatLen;
+    memcpy((char *)buf,
+           (char const *)(SharedMemBuffer::getData()->next.sendAsynchDataBuf),
+           *leng);
+    SharedMemBuffer::getData()->next.sendAsyDatLen = 0;
     return *leng;
 }
 
@@ -275,161 +164,294 @@ uint8_t sendWRcmd_getSendBlock160(uint8_t *leng, uint8_t *buf)
 // 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)
-{
+uint8_t epi_store64ByteSendData(uint8_t length, uint8_t const *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;
+    memcpy((char *)(&SharedMemBuffer::getData()->Sdata.mdbSendBuffer[0]),
+           (char const *)buf, length);
+    SharedMemBuffer::getData()->Sdata.mdbSendLen = length;
     return 0;
 }
 
-uint8_t gpi_restore64ByteSendData(uint8_t *length, uint8_t *buf)
-{
+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;
+    memcpy((char *)(buf),
+           (char const *)(&SharedMemBuffer::getDataConst()->Sdata.mdbSendBuffer[0]),
+            SharedMemBuffer::getDataConst()->Sdata.mdbSendLen);
+    *length = SharedMemBuffer::getDataConst()->Sdata.mdbSendLen;
+    SharedMemBuffer::getData()->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 )
-{
+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;
-
+    SharedMemBuffer::getData()->prn.DataBufferUser = user;
+    SharedMemBuffer::getData()->prn.DataParameters[0] = para1;
+    SharedMemBuffer::getData()->prn.DataParameters[1] = para2;
+    SharedMemBuffer::getData()->prn.DataParameters[2] = para3;
+    SharedMemBuffer::getData()->prn.DataParameters[3] = para4;
 }
 
-uint8_t gpi_getUserOfSendingTextBuffer(uint8_t *para1, uint8_t *para2, uint8_t *para3, uint8_t *para4)
-{
+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;
-
+    *para1 = SharedMemBuffer::getDataConst()->prn.DataParameters[0];
+    *para2 = SharedMemBuffer::getDataConst()->prn.DataParameters[1];
+    *para3 = SharedMemBuffer::getDataConst()->prn.DataParameters[2];
+    *para4 = SharedMemBuffer::getDataConst()->prn.DataParameters[3];
+    return SharedMemBuffer::getDataConst()->prn.DataBufferUser;
 }
 
-
-    // Sending Text Fifo
+// 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 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;
+void epi_resetPrinterStack(void) {
+    SharedMemBuffer::getData()->prn.pDataBuff = 0;
 }
 
-uint8_t epi_storePrnText(char *buf, uint8_t leng)
-{
+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;
+    uint16_t const len = std::min(leng, (uint8_t)MAXNROF_PRNBYTES);
+    int const pp = SharedMemBuffer::getDataConst()->prn.pDataBuff;
 
-    pp=pPrnDataBuff;    // next free memory block with 64byte each
-    if (pp>=MAXNROF_PRNBLOCKS)
-        return 1;   // not possible, no free mem
+    // next free memory block with 64byte each
+    if (pp < MAXNROF_PRNBLOCKS) {
+        clear(SharedMemBuffer::getData()->Sdata.PRN_TEXT[pp]);
+        // copy new text into buffer
+        memcpy((char *)(&SharedMemBuffer::getData()->Sdata.PRN_TEXT[pp][0]),
+               (char const *)(buf), len);
+        // inc pointer if end not yet reached
+        SharedMemBuffer::getData()->prn.pDataBuff++;
+        return 0;       // OK
+    }
 
-    //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
+    return 1;   // not possible, no free mem
 }
 
-
-
-uint8_t gpi_restorePrnText(uint8_t *retbuf)
-{
+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
+    int pp = SharedMemBuffer::getDataConst()->prn.pDataBuff;
 
-    uint8_t  nn, pp=pPrnDataBuff;
+    if (pp > 0) { // next free memory block with 64byte each
+        // example: pp=5: then buffers [0...4] are occupied
 
-    if (pp==0)    // next free memory block with 64byte each
-        return 1;           // no text in buffer
+        memcpy((char *)retbuf, // restore oldest text
+               (char const *)(&SharedMemBuffer::getData()->Sdata.PRN_TEXT[0][0]),
+               sizeof(SharedMemBuffer::getDataConst()->Sdata.PRN_TEXT[0]));
 
-    // example: pp=5: then buffers [0...4] are occupied
+        // 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<MAXNROF_PRNBYTES; nn++)
-        retbuf[nn] = uint8_t (Sdata_PRN_TEXT[0][nn]);     // restore oldest text
+        for (int nn=0; nn < (pp-1); nn++) {
+            memmove((char *)(&SharedMemBuffer::getData()->Sdata.PRN_TEXT[nn+1][0]),
+                    (char const *)(&SharedMemBuffer::getDataConst()->Sdata.PRN_TEXT[nn][0]),
+                    sizeof(SharedMemBuffer::getDataConst()->Sdata.PRN_TEXT[0]));
+        }
 
-    // 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!!!!!!
+        if (SharedMemBuffer::getDataConst()->prn.pDataBuff > 0) {
+            SharedMemBuffer::getData()->prn.pDataBuff--;
+        }
 
-    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
+        pp = SharedMemBuffer::getDataConst()->prn.pDataBuff;
+        // 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);
+        // now clear highest copyed line (which got free now)
+        clear(SharedMemBuffer::getData()->Sdata.PRN_TEXT[pp]);
 
-    // optionally: clear all remaining higher lines:
-    for (nn=(pp+1); nn<MAXNROF_PRNBLOCKS; nn++)
-         tslib_strclr(Sdata_PRN_TEXT[nn], 0, MAXNROF_PRNBYTES);
+        // optionally: clear all remaining higher lines:
+        for (int nn = (pp+1); nn < MAXNROF_PRNBLOCKS; nn++) {
+            clear(SharedMemBuffer::getData()->Sdata.PRN_TEXT[nn]);
+        }
+        return 0;
+    }
 
-    return 0;
+    return 1; // no text in buffer
 }
 
-uint8_t gpi_chk4remainingText(void)
-{
+uint8_t gpi_chk4remainingText(void) {
     // retval: 0: no more textline left (to send)  >0: nr of 64byte-blocks
-    return (pPrnDataBuff);
+    return SharedMemBuffer::getDataConst()->prn.pDataBuff;
+}
+
+// ---------------------------------------------------------------------------------
+//   11.4.23 neu, Kommando direkt an "FastDevice"-protokoll senden, nicht mehr umsetzen
+// ---------------------------------------------------------------------------------
+
+/* 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) {
+    clear(SharedMemBuffer::getData()->FDShort.wrCmd);
+    clear(SharedMemBuffer::getData()->FDShort.rdCmd);
+    clear(SharedMemBuffer::getData()->FDShort.blkNr);
+    clear(SharedMemBuffer::getData()->FDShort.para1);
+    clear(SharedMemBuffer::getData()->FDShort.para2);
+    clear(SharedMemBuffer::getData()->FDShort.para3);
+    clear(SharedMemBuffer::getData()->FDShort.para4);
+    SharedMemBuffer::getData()->FDShort.cmdsInQueue = 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
+    int const c = SharedMemBuffer::getDataConst()->FDShort.cmdsInQueue;
+    if (c < FDCMD_STACKDEPTH) {
+        SharedMemBuffer::getData()->FDShort.wrCmd[c] = nextWrCmd;
+        SharedMemBuffer::getData()->FDShort.rdCmd[c] = nextRdCmd;
+        SharedMemBuffer::getData()->FDShort.blkNr[c] = blockNum;
+        SharedMemBuffer::getData()->FDShort.para1[c] = dat1;
+        SharedMemBuffer::getData()->FDShort.para2[c] = dat2;
+        SharedMemBuffer::getData()->FDShort.para3[c] = dat3;
+        SharedMemBuffer::getData()->FDShort.para4[c] = dat4;
+        SharedMemBuffer::getData()->FDShort.cmdsInQueue = (c + 1);
+        return true;                // ok, will be sent
+    }
+    qCritical() << "cannot save cmd because stack is full";
+    return false; // not possible
+}
+
+bool sendFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum,
+                   uint8_t *dat1, uint8_t *dat2, uint8_t *dat3, uint8_t *dat4) {
+
+    int const c = SharedMemBuffer::getDataConst()->FDShort.cmdsInQueue;
+
+    if ((c > 0)  && (c <= FDCMD_STACKDEPTH)) {
+        *nextWrCmd = SharedMemBuffer::getDataConst()->FDShort.wrCmd[c];
+        *nextRdCmd = SharedMemBuffer::getDataConst()->FDShort.rdCmd[c];
+        *blockNum = SharedMemBuffer::getDataConst()->FDShort.blkNr[c];
+        *dat1 = SharedMemBuffer::getDataConst()->FDShort.para1[c];
+        *dat2 = SharedMemBuffer::getDataConst()->FDShort.para2[c];
+        *dat3 = SharedMemBuffer::getDataConst()->FDShort.para3[c];
+        *dat4 = SharedMemBuffer::getDataConst()->FDShort.para4[c];
+
+        // move Puffer down by one element
+        for (int m = 0; m < c-1; ++m) {
+            int const n = m + 1;
+            SharedMemBuffer::getData()->FDShort.wrCmd[m] = SharedMemBuffer::getDataConst()->FDShort.wrCmd[n];
+            SharedMemBuffer::getData()->FDShort.rdCmd[m] = SharedMemBuffer::getDataConst()->FDShort.rdCmd[n];
+            SharedMemBuffer::getData()->FDShort.blkNr[m] = SharedMemBuffer::getDataConst()->FDShort.blkNr[n];
+            SharedMemBuffer::getData()->FDShort.para1[m] = SharedMemBuffer::getDataConst()->FDShort.para1[n];
+            SharedMemBuffer::getData()->FDShort.para2[m] = SharedMemBuffer::getDataConst()->FDShort.para2[n];
+            SharedMemBuffer::getData()->FDShort.para3[m] = SharedMemBuffer::getDataConst()->FDShort.para3[n];
+            SharedMemBuffer::getData()->FDShort.para4[m] = SharedMemBuffer::getDataConst()->FDShort.para4[n];
+        }
+        SharedMemBuffer::getData()->FDShort.cmdsInQueue = c - 1;
+        return true;                // ok, will be sent
+    }
+    return false;           // not possible
+}
+
+uint8_t check4FDshortCmd(void) { // returns number of waiting command, max FDCMD_STACKDEPTH
+    return SharedMemBuffer::getDataConst()->FDShort.cmdsInQueue;
 }
 
 
+uint8_t check4freeFDshortCmd(void) { // returns number of free places in short-command stack
+    return FDCMD_STACKDEPTH - SharedMemBuffer::getDataConst()->FDShort.cmdsInQueue;
+}
 
+void longFDcmd_clrStack(void) {
+    clear(SharedMemBuffer::getData()->FDLong.wrCmd);
+    clear(SharedMemBuffer::getData()->FDLong.rdCmd);
+    clear(SharedMemBuffer::getData()->FDLong.blkNr);
+    clear(SharedMemBuffer::getData()->FDLong.length);
+    clear(SharedMemBuffer::getData()->FDLong.para);
+    SharedMemBuffer::getData()->FDLong.cmdsInQueue = 0;
+}
 
+bool longFDcmd_set(uint8_t nextWrCmd, uint8_t nextRdCmd, uint8_t blockNum,
+                   uint8_t length, uint8_t const *data) {
+    // write Command to memory, wait for transport
+    // data buffer size always 64! data[64], padded with 0
+    int const c = SharedMemBuffer::getDataConst()->FDLong.cmdsInQueue;
 
+    if (c > 0 && c <= FDLONG_STACKDEPTH) {
+        SharedMemBuffer::getData()->FDLong.wrCmd[c] = nextWrCmd;
+        SharedMemBuffer::getData()->FDLong.rdCmd[c] = nextRdCmd;
+        SharedMemBuffer::getData()->FDLong.blkNr[c] = blockNum;
+        SharedMemBuffer::getData()->FDLong.length[c] = length;
+        memcpy((char *)SharedMemBuffer::getData()->FDLong.para[c],
+               (char const *)data,
+                sizeof(SharedMemBuffer::getDataConst()->FDLong.para[0]));
+
+        SharedMemBuffer::getData()->FDLong.cmdsInQueue = c + 1;
+        return true;                // ok, will be sent
+    }
+    qCritical() << "cannot save cmd because stack is full";
+    return false;           // not possible
+}
+
+bool longFDcmd_get(uint8_t *nextWrCmd, uint8_t *nextRdCmd, uint8_t *blockNum,
+                   uint8_t *length, uint8_t *data) {
+
+    int const c = SharedMemBuffer::getDataConst()->FDLong.cmdsInQueue;
+
+    if (c > 0 && c <= FDLONG_STACKDEPTH) {
+        *nextWrCmd = SharedMemBuffer::getDataConst()->FDLong.wrCmd[c];
+        *nextRdCmd = SharedMemBuffer::getDataConst()->FDLong.rdCmd[c];
+        *blockNum  = SharedMemBuffer::getDataConst()->FDLong.blkNr[c];
+        *length    = SharedMemBuffer::getDataConst()->FDLong.length[c];
+        memcpy((char *)data,
+               (char const *)SharedMemBuffer::getDataConst()->FDLong.para[c],
+                sizeof(SharedMemBuffer::getDataConst()->FDLong.para[0]));
+
+        // move Puffer down by one element
+        for (int m = 0; m < c-1; ++m) {
+            int const n = m + 1;
+            SharedMemBuffer::getData()->FDLong.wrCmd[m] = SharedMemBuffer::getDataConst()->FDLong.wrCmd[n];
+            SharedMemBuffer::getData()->FDLong.rdCmd[m] = SharedMemBuffer::getDataConst()->FDLong.rdCmd[n];
+            SharedMemBuffer::getData()->FDLong.blkNr[m] = SharedMemBuffer::getDataConst()->FDLong.blkNr[n];
+            SharedMemBuffer::getData()->FDLong.length[m] = SharedMemBuffer::getData()->FDLong.length[n];
+            memcpy((char *)SharedMemBuffer::getData()->FDLong.para[m],
+                   (char const *)SharedMemBuffer::getData()->FDLong.para[n],
+                   sizeof(SharedMemBuffer::getDataConst()->FDLong.para[0]));
+        }
+        SharedMemBuffer::getData()->FDLong.cmdsInQueue = c - 1;
+        return true;                // ok, will be sent
+    }
+
+    qCritical() << "cannot save cmd because stack is full";
+    return false;           // not possible
+}
+
+uint8_t check4FDlongCmd(void) { // returns number of waiting command
+    return SharedMemBuffer::getDataConst()->FDLong.cmdsInQueue;
+}
+
+uint8_t check4freeFDlongCmd(void) { // returns number of free places in command stack
+    return FDLONG_STACKDEPTH - SharedMemBuffer::getDataConst()->FDLong.cmdsInQueue;
+}

src/serial_port_thread.cpp

@@ -0,0 +1,15 @@
+#include "serial_port_thread.h"
+
+
+SerialPortThread::SerialPortThread(QObject *parent)
+    : QThread(parent) {
+    this->setObjectName("SerialPortThread");
+}
+
+SerialPortThread::~SerialPortThread() {
+    m_loop.quit();
+}
+
+void SerialPortThread::run() {
+    m_loop.exec();
+}

src/serial_port_worker.cpp

@@ -0,0 +1,244 @@
+#include "serial_port_worker.h"
+#include "serial_port_thread.h"
+
+#include <QDebug>
+#include <QCoreApplication>
+
+std::atomic<uint8_t> Command::m_nextSendBufferIndex{0};
+std::atomic<uint8_t> Command::m_nextRecvBufferIndex{0};
+char Command::m_sendBuffers[256][SEND_BLOCK_SIZE]{{0}};
+char Command::m_recvBuffers[256][SEND_BLOCK_SIZE]{{0}};
+
+uint32_t Command::getNextCommandPriority(uint8_t priorityClass) {
+    static std::atomic<std::uint32_t> priority_1{0};
+    static std::atomic<std::uint32_t> priority_2{1000000000};
+    static std::atomic<std::uint32_t> priority_3{2000000000};
+    static std::atomic<std::uint32_t> priority_4{3000000000};
+    switch (priorityClass) {
+    case PRIORITY_1:
+        return priority_1.fetch_add(1);
+    case PRIORITY_2:
+        return priority_2.fetch_add(1);
+    case PRIORITY_3:
+        return priority_3.fetch_add(1);
+    case PRIORITY_4:
+        return priority_4.fetch_add(1);
+    }
+    return -1;
+}
+
+char *Command::getNextSendBuffer() {
+    uint8_t const nextIndex = m_nextSendBufferIndex.fetch_add(1);
+    return &m_sendBuffers[nextIndex][0];
+}
+
+char *Command::getNextRecvBuffer() {
+    uint8_t const nextIndex = m_nextRecvBufferIndex.fetch_add(1);
+    return &m_recvBuffers[nextIndex][0];
+}
+
+Command::Command(uint16_t cmdId, uint8_t sendBufferLength,
+                 uint8_t recvBufferLength, uint8_t priorityClass)
+    : m_priority(getNextCommandPriority(priorityClass))
+    , m_priorityClass(priorityClass)
+    , m_cmdId(cmdId)
+    , m_sendBuffer(Command::getNextSendBuffer())
+    , m_recvBuffer(Command::getNextRecvBuffer())
+    , m_sendBufferLength(sendBufferLength)
+    , m_recvBufferLength(recvBufferLength) {
+    memset(m_sendBuffer, 0x00, sizeof(m_sendBuffers[0]));
+}
+
+Command::Command()
+    : m_priority(0)
+    , m_priorityClass(0)
+    , m_cmdId(0)
+    , m_sendBuffer(0)
+    , m_recvBuffer(0)
+    , m_sendBufferLength(0)
+    , m_recvBufferLength(0) {
+}
+
+/**
+* \brief Constructor for SerialPort
+*
+* @date 08.11.2022 – first draft.
+*
+*/
+SerialPortWorker::SerialPortWorker(QString portName, enum QSerialPort::BaudRate baudRate, QObject *parent)
+    : QThread(parent)
+    , m_serialPort()
+    , m_serialPortOpened(false)
+    , m_portName(portName)
+    , m_baudRate(baudRate)
+    , m_bytesWritten(0) {
+    this->setObjectName("SerialPortWorker");
+
+    foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts()) {
+        if (!info.isNull()) {
+            qDebug() << "Name .......... " << info.portName();
+            qDebug() << "Description ... " << info.description();
+            qDebug() << "Manufacturer .. " << info.manufacturer();
+            qDebug() << "SerialNumber .. " << info.serialNumber();
+            if (info.hasProductIdentifier()) {
+                qDebug() << "Product-ID .... " << info.productIdentifier();
+            }
+            if (info.hasVendorIdentifier()) {
+                qDebug() << "Vendor-ID ..... " << info.vendorIdentifier();
+            }
+            qDebug() << "Location ...... " << info.systemLocation();
+
+            if (info.portName() == m_portName) {
+                m_serialPortInfo = info;
+            }
+        }
+    }
+
+    if (m_serialPortInfo.portName() == m_portName) {
+        m_serialPort.setPort(m_serialPortInfo);
+        m_serialPort.setPortName(m_portName);
+        m_serialPort.setDataBits(QSerialPort::Data8);
+        m_serialPort.setParity(QSerialPort::NoParity);
+        m_serialPort.setStopBits(QSerialPort::OneStop);
+        m_serialPort.setFlowControl(QSerialPort::NoFlowControl);
+        m_serialPortOpened = m_serialPort.open(QIODevice::ReadWrite);
+    }
+}
+
+SerialPortWorker::~SerialPortWorker() {
+    closeSerialPort();
+}
+
+void SerialPortWorker::run() {
+    SerialPortThread serialPortThread;
+    this->moveToThread(&serialPortThread); // not really necessary
+
+    // Note: because this thread is moved to serialPortThread, the event loop
+    // used will be the one of serialPortThread (this-thread does not even have one).
+    // This is the only purpose of serialPortThread.
+    serialPortThread.start();
+
+    connect(&m_serialPort, SIGNAL(readyRead()), this, SLOT(getBytesAvailable()));
+    connect(&m_serialPort, SIGNAL(bytesWritten(qint64)), this, SLOT(getNumberOfBytesWritten(qint64)));
+
+    while (m_serialPortOpened) {
+        Command nextCmd = getNextCommand();
+        if (nextCmd.m_cmdId == Command::QUIT_SENTINEL) {
+            break;
+        }
+        QByteArray data(nextCmd.getNextSendBuffer(), nextCmd.m_sendBufferLength);
+        m_bytesWritten = 0;
+        m_serialPort.write(data);
+        // process events in event loop of associated thread
+        serialPortThread.getEventLoop().processEvents(QEventLoop::ExcludeUserInputEvents, TIMEOUT);
+        int maxWaitTime = WAIT_TIME_MAX;
+
+        while (maxWaitTime > 0 && m_bytesWritten < (uint32_t)data.size()) {
+            if (!m_serialPort.waitForBytesWritten(100)) { // wait timeout-ms for the bytes to be written
+                // process events in event loop of associated thread
+                serialPortThread.getEventLoop().processEvents(QEventLoop::ExcludeUserInputEvents, TIMEOUT);
+                maxWaitTime -= TIMEOUT;
+            }
+        }
+        if (m_bytesWritten == (uint32_t)data.size()) { // data written, wait for result
+            if (nextCmd.m_recvBufferLength > 0) {
+                // process events in event loop of associated thread
+                serialPortThread.getEventLoop().processEvents(QEventLoop::ExcludeUserInputEvents, TIMEOUT);
+                maxWaitTime = WAIT_TIME_MAX;
+                while (maxWaitTime > 0 && m_bytesAvailable < nextCmd.m_recvBufferLength) {
+                    if (!m_serialPort.waitForReadyRead(100)) {
+                        // process events in event loop of associated thread
+                        serialPortThread.getEventLoop().processEvents(QEventLoop::ExcludeUserInputEvents, TIMEOUT);
+                        maxWaitTime -= TIMEOUT;
+                    }
+                }
+                uint32_t const bytesAvailable = m_bytesAvailable;
+                if (bytesAvailable == nextCmd.m_recvBufferLength) {
+                    QByteArray result = m_serialPort.read(bytesAvailable);
+                    if (!result.isEmpty() && ((uint32_t)result.size() == bytesAvailable)) {
+                        memcpy(nextCmd.m_recvBuffer, result.data(), bytesAvailable);
+                        insertResult(nextCmd);
+                    }
+                } else {
+                    // error
+                }
+            }
+        } else {
+            // error
+        }
+    } // while (m_serialPortOpened)
+
+    serialPortThread.quit();
+    serialPortThread.wait();
+}
+
+bool SerialPortWorker::openSerialPort() {
+    if (!m_serialPortOpened) {
+        return m_serialPort.open(QIODevice::ReadWrite);
+    }
+    return false; // opening twice is not allowed
+}
+
+void SerialPortWorker::closeSerialPort() {
+    if (m_serialPortOpened) {
+        m_serialPort.close();
+        m_serialPortOpened = false;
+    }
+}
+
+void SerialPortWorker::quit() {
+    Command cmd(Command::QUIT_SENTINEL, 0, 0, Command::PRIORITY_1);
+    insertCommand(cmd);
+}
+
+void SerialPortWorker::insertCommand(Command const &cmd) {
+    {   std::lock_guard<std::mutex> lock(m_sendQueueMutex);
+        m_sendQueue.push(cmd);
+    } // release lock
+    m_sendQueueCondVar.notify_one();
+}
+
+Command SerialPortWorker::getNextCommand() {
+    Command nextCmd;
+    {   std::unique_lock<std::mutex> lock(m_sendQueueMutex);
+        m_sendQueueCondVar.wait(lock, [this]{ return !this->m_sendQueue.empty(); });
+        nextCmd = m_sendQueue.top();
+        m_sendQueue.pop();
+    } // release lock
+    return nextCmd;
+}
+
+void SerialPortWorker::insertResult(Command const &result) {
+    {   std::lock_guard<std::mutex> lock(m_recvQueueMutex);
+        m_recvQueue.push_back(result);
+    } // release lock
+    m_recvQueueCondVar.notify_one();
+}
+
+bool SerialPortWorker::getNextResult(Command &nextResult, int timeout) {
+    bool timed_out = false;
+    {   std::unique_lock<std::mutex> lock(m_recvQueueMutex);
+        if (m_recvQueueCondVar.wait_for(lock, std::chrono::milliseconds(timeout),
+                                    [this]{ return !this->m_recvQueue.empty(); })) {
+            nextResult = m_recvQueue.front();
+            m_recvQueue.pop_front();
+            return true;
+        } else {
+            timed_out = true;
+        }
+    } // release lock
+    return (timed_out == false);
+}
+
+void SerialPortWorker::getBytesAvailable() {
+    m_bytesAvailable += m_serialPort.bytesAvailable();
+}
+
+bool SerialPortWorker::getNumberOfBytesWritten(qint64 bytesWritten) {
+    if (bytesWritten > 0) {
+        m_bytesWritten += (uint32_t)bytesWritten;
+        return true;
+    }
+    return false;
+}
+

src/shared_mem_buffer.cpp

@@ -0,0 +1,123 @@
+#include "shared_mem_buffer.h"
+
+#include <QDebug>
+#include <QCoreApplication>
+#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
+
+#ifdef __linux__
+#include <unistd.h>
+#endif
+
+#define PROCESS_SHARED (PTHREAD_PROCESS_SHARED)
+
+// 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)) {
+                // the creator is the owner of the shared-memory segment
+                SharedMemBuffer *shm = (SharedMemBuffer *)(shMem.data());
+                if (shm) {
+                    shm->init = 0;
+                    // mark the shm
+                    memset(shm->appName, 0x00, sizeof(shm->appName));
+                    strncpy(shm->appName,
+                            QCoreApplication::applicationName().toLocal8Bit().constData(),
+                            sizeof(shm->appName)-1);
+                    shm->pid = getpid();
+
+                    // create condition variables plus associated mutexes for
+                    // sending/receiving commands to dc
+                    int r = 0;
+                    if ((r = pthread_mutexattr_init(&shm->sndMtxA)) != 0) {
+                        qCritical() << "init mutex attribute"
+                                    << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_mutexattr_setpshared(
+                                &shm->sndMtxA, PTHREAD_PROCESS_SHARED) != 0)) {
+                        qCritical() << "set s-mutex attribute to process shared"
+                                    << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_mutex_init(&shm->sndMtx,
+                                                &shm->sndMtxA) != 0)) {
+                        qCritical() << "init s-mutex" << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_condattr_init(&shm->sndCndA) != 0)) {
+                        qCritical() << "init s-mutex" << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_condattr_setpshared(
+                                &shm->sndCndA, PTHREAD_PROCESS_SHARED) != 0)) {
+                        qCritical() << "init s-cond attribute to process shared"
+                                    << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_cond_init(&shm->sndCndV,
+                                               &shm->sndCndA) != 0)) {
+                        qCritical() << "init s-condvar" << strerror(errno) << r;
+                    }
+
+                    if ((r = pthread_mutexattr_init(&shm->rcvMtxA)) != 0) {
+                        qCritical() << "init r-mutex attribute"
+                                    << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_mutexattr_setpshared(
+                                &shm->rcvMtxA, PTHREAD_PROCESS_SHARED) != 0)) {
+                        qCritical() << "set r-mutex attribute to process shared"
+                                    << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_mutex_init(&shm->rcvMtx,
+                                                &shm->rcvMtxA) != 0)) {
+                        qCritical() << "init r-mutex" << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_condattr_init(&shm->rcvCndA) != 0)) {
+                        qCritical() << "init r-mutex" << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_condattr_setpshared(
+                                &shm->rcvCndA, PTHREAD_PROCESS_SHARED) != 0)) {
+                        qCritical() << "init r-cond attribute to process shared"
+                                    << strerror(errno) << r;
+                    }
+                    if ((r == 0) &&
+                        (r = pthread_cond_init(&shm->rcvCndV,
+                                               &shm->rcvCndA) != 0)) {
+                        qCritical() << "init s-condvar" << strerror(errno) << r;
+                    }
+                    shm->init = 1;
+                }
+                return &shMem;
+            } else {
+                if (shMem.error() == QSharedMemory::AlreadyExists) {
+                    if (shMem.attach()) {
+                        return &shMem;
+                    }
+                }
+            }
+            qCritical() << shMem.nativeKey() << shMem.key() << shMem.data()
+                        << shMem.error() << shMem.errorString();
+            return nullptr;
+        }
+    }
+    return &shMem;
+}

src/tslib.cpp

@@ -76,6 +76,23 @@ uint8_t uint2uchar(uint16_t uival, bool getHighB)
 }
 
 
+uint8_t ulong2uchar(uint32_t ulval, uint8_t getBytNr)
+{
+    // getBytNr: 0=LSB  3=MSB
+    uint32_t ultmp=ulval;
+    if (getBytNr==0)
+        return uint8_t(ultmp);
+    ultmp>>=8;
+    if (getBytNr==1)
+        return uint8_t(ultmp);
+    ultmp>>=8;
+    if (getBytNr==2)
+        return uint8_t(ultmp);
+    ultmp>>=8;
+    return uint8_t(ultmp);
+
+}
+
 void delay(uint16_t MilliSec)
 {
     QThread::msleep(uint32_t(MilliSec));
@@ -344,6 +361,15 @@ uint16_t tslib_strlen(char *buf)
     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)
 {
@@ -555,3 +581,18 @@ uint8_t tslib_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *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];
+    }
+}