Adding header files (sax)

include/com.h

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

include/controlBus.h

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

include/datIf.h

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

include/dcBL.h

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

include/interfaces.h

@@ -0,0 +1,850 @@
+#ifndef INTERFACE_H
+#define INTERFACE_H
+
+//#include <QtPlugin>
+
+
+ struct Tprn_hw_state
+{
+    // hardware (IO's)
+    bool powerRdBk;     // prn pwr is on
+    bool rsSwOk;        // serial switch (printer or modem) is set to printer
+    bool rsDrvOk;       // RS232 converter for PTU, Printer and Modem in on
+
+    bool ReadyLine;     // HW signal from printer showing ready
+    bool inIdle;        // powered and free from errors
+    bool paperNearEnd;  // paper roll runs out
+    bool noPaper;
+    bool ErrorTemp;
+    bool HeadOpen;
+    bool cutterJam;
+    bool noResponse;    // printer is not connected, cable broken, wrong baudrate
+    bool badResponse;
+};
+
+ struct Tprn_currentSettings
+{
+    uint8_t currFont;
+    uint8_t currSize;
+    uint8_t currHeigth;
+    uint8_t currWidth;
+    bool    nowBold;
+    bool    nowInvers;
+    bool    nowUnderlined;
+    uint8_t currDensity;
+    uint8_t currSpeed;
+    bool    nowAligned;
+};
+
+ struct T_dynDat
+{
+    uint8_t licensePlate[8];
+    uint8_t vendingPrice[8];
+    uint8_t parkingEnd[8];
+    uint8_t currentTime[8];
+    uint8_t currentDate[8];
+    uint8_t dynDat5[8];
+    uint8_t dynDat6[8];
+    uint8_t dynDat7[8];
+};
+
+
+ struct T_emp
+{
+
+    // Fixdata from EMP:
+    uint8_t shaft;      // = changer level
+    uint16_t countryCode;
+    uint8_t scale;
+    uint8_t decimals;
+    uint8_t coinValues[16];
+    uint16_t routing;
+
+    // Master specs:
+    uint8_t gotSetup;       // 1: got specifications from master   0: no specs
+    uint16_t coinAccept;    //  bit 0 = coin1  bit H=accept
+    uint8_t tokenChannel;
+    uint16_t denomination[16];
+
+    // dynamic:
+    uint8_t state;      // step counter of EMP (electronic coin checker) FSM (finite state machine):
+                        // 0=Emp & Bus power off,  1=powered, poll off    2=polling on
+                        // 3=device responded, requesting status
+                        // 4=waiting for status     5=have status,
+                        // 6: IDLE,  have paramters from master, polling running, ready for payment
+                        //          Master can stop/start polling and acceptance
+                        // 7: end of transaction,  polling on, accept off, reporting coins, (wait for last coin)
+                        // 8: transaction running, polling on, acceptance on, reporting coins,
+
+    uint8_t pollingRunning;
+    uint8_t paymentRunning;
+
+};
+
+
+
+
+class hwinf
+{
+
+public:
+    virtual ~hwinf() {}
+
+    virtual void dc_openSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect)  const =0;
+
+    virtual void dc_closeSerial(void)  const =0;
+
+    virtual bool dc_isPortOpen(void)  const =0;
+
+    virtual void dc_autoRequest(bool on)  const =0;
+        // select if READ-Requests are sent manually one by one or automatically
+        // automatically request ALL digital and analog sensors, get time/date, get status information
+
+    virtual void dc_requTestResponse()  const =0;
+
+
+    virtual bool dc_readAnswTestResponse()  const =0;
+        // retval: true: test was successful, got right response
+
+    virtual uint8_t dc_isRequestDone(void)  const =0;
+        // retval:  0: request is still in progress
+        //          1: answer from DC2 was OK
+        //          2: wrong answer from DC2
+
+    virtual uint16_t dc_getCompletePayLoad(uint16_t plBufSiz, uint8_t *payLoad)  const =0;
+        // get data back in *pl, max 64 byte, can be used for diagnosis
+        // 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
+
+    virtual void dc_setWakeFrequency(uint8_t period)  const =0;
+        // RTC wakes DC2 (and PTU) by hardware signal every 32seconds
+        // change wake signal period to 1...64s
+
+    virtual void dc_OrderToReset(void)  const =0;
+        // want DC2 to reset (in order to start Bootloader)
+
+    virtual QString dc_getSerialState(void)  const =0;
+    virtual void dc_clrSerialStateText(void)  const =0;
+
+    virtual void bl_sendDataDirectly(uint8_t length, uint8_t *buf)  const =0;
+        // send without protocol frame, needed for the DC bootloader
+
+    virtual uint8_t getRawRecLength(void)  const =0;
+
+    virtual uint8_t getRawReceivedData(uint8_t *receivedData)  const =0;
+
+    virtual QString dc_getSerialParams(void)  const =0;
+
+    virtual QString dc_getHWversion(void)  const =0;
+
+    virtual QString dc_getSWversion(void)  const =0;
+
+    virtual QString dc_getState(void)  const =0;
+
+    virtual QString dc_getTxt4RsDiagWin(void)  const =0;
+    virtual void dc_clrTxt4RsDiagWin(void)  const =0;
+    virtual QString dc_get2ndTxt4RsDiagWin(void)  const =0;
+    virtual void dc_clr2ndTxt4RsDiagWin(void)  const =0;
+    virtual QString dc_getTxt4HsStateLine(void)  const =0;
+    virtual void dc_clrTxt4HsStateLine(void)  const =0;
+    virtual QString dc_getTxt4masterStateLine(void)  const =0;
+    virtual void dc_clrTxt4masterStateLine(void)  const =0;
+    virtual QString dc_getTxt4resultStateLine(void)  const =0;
+    virtual void dc_clrTxt4resultStateLine(void)  const =0;
+    virtual QString dc_getdataStateLine(void)  const =0;
+    virtual void dc_clrTxt4dataStateLine(void)  const =0;
+    virtual QString dc_getdatifLine(void)  const =0;
+    virtual void dc_clrTxt4datifLine(void)  const =0;
+
+    // using DC2 Bootloader
+    virtual void bl_iniChain(void)  const =0;
+    virtual bool bl_importBinFile(QByteArray readBinFile, uint32_t fileSize, char withDispl)  const =0;
+    virtual uint8_t bl_activatBootloader(uint8_t *sendData)  const =0;
+    virtual uint8_t bl_startChain(void)  const =0;
+    virtual uint8_t bl_readBLversion(uint8_t *sendData)  const =0;
+        // minimum size of sendData-buffer: 5byte  retval: length
+    virtual uint8_t bl_readFWversion(uint8_t *sendData)  const =0;
+        // minimum size of sendData-buffer: 5byte  retval: length
+
+    virtual uint8_t bl_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf)  const =0;
+        // make BL protocol, retval = outbuf length (5...133)
+        // bring data in correct form: start always with 0x02   finish with 0x03 and append checksum
+        // 0x02 Cmd < ...sendData ..>  CRC  CRC 0x03
+        // Data length = 0...64
+        // special conversion: if data contain 2 or 3 (STX, ETX) then write two bytes:  0x1B (=ESC) and data|0x80
+        // so maxlength = 5 + 2 x 64 (if all data are 2 or 3)  without 2,3: maxlength = 5 + 64
+
+    virtual uint8_t bl_exitBL(uint8_t *sendData)  const =0;
+        // minimum size of sendData-buffer: 5byte  retval: length
+
+
+
+
+
+
+
+
+    // ------------------------------------------------------------------------------
+    // Level 2  DC2-onboard devices
+    //          WR: set time
+    //          RD. get time, get measure, get test results
+    // ------------------------------------------------------------------------------
+
+    // get UID, get time/date   test results   memory,  RTC  analog values
+
+     struct Trtc_DateTime
+    {
+        uint8_t rtc_hour;
+        uint8_t rtc_min;
+        uint8_t rtc_sec;
+        uint8_t rtc_dayOfMonth;
+        uint8_t rtc_month;
+        uint8_t rtc_year;
+        uint8_t rtc_dayOfWeek;
+    };
+
+    virtual uint8_t rtc_getDateTime(struct Trtc_DateTime *rtc_DateTime)  const =0;
+
+    virtual uint8_t rtc_setDateTime(void)  const =0;
+        // synch DC2 with PC or PTU system time and date
+
+    virtual void rtc_getTime(uint8_t *hh, uint8_t *mm, uint8_t *ss)  const =0;
+        // get time directly
+
+    virtual void rtc_getDate(uint8_t *yy, uint8_t *mm, uint8_t *dd)  const =0;
+        // get date directly
+
+    virtual uint8_t rtc_getToday(uint8_t *dow, uint16_t *minOfToday, uint32_t *secOfToday)  const =0;
+        // dow=day of week, 1=monday...7
+        // minOfToday: 0=midnight...1439= 23:59
+        // secOfToday: 0=midnight...86399= 23:59:59
+
+    virtual bool rtc_isLeapYear(uint8_t *lastLeapYear, uint8_t *NextLeapYear)  const =0;
+        // retval true: this year is leap year
+
+    virtual bool rtc_isLeapYear()  const =0;
+
+    virtual void rtc_getWeek(uint8_t *DayOfWeek, uint8_t *HoursOfWeek, uint16_t *MinutesOfWeek)  const =0;
+        // DayOfWeek: 1=monday...7
+        // HoursOfWeek: 0=Monday 0:00 o'clock...167=Sunday 23:00
+        // MinutesOfWeek: 0=Monday 0:00 o'clock...10079=Sunday 23:59
+
+    virtual void rtc_getMonth(uint8_t *DayOfMonth, uint16_t *HoursOfMonth, uint16_t *MinutesOfMonth)  const =0;
+        // DayOfMonth: 1...31
+        // HoursOfMonth: 0 = 0:00o'clock of 1.day in month     up to 743
+        // MinutesOfMonth:0 = 0:00o'clock of 1.day in month     up to 44639
+
+    virtual void rtc_getYear(uint16_t *DayOfYear, uint16_t *HoursOfYear, uint32_t *MinutesOfYear)  const =0;
+        // DayOfYear: 1...366  1= 1.Jan of this current year
+        // HoursOfYear: 0=1.Jan 0:00o'clock ...8783=31.12 23 o'clock
+        // MinutesOfYear: 0=1.Jan 0:00o'clock ...527039=31.12 23:59 o'clock
+
+    virtual QString rtc_getTimStr(void)  const =0;
+    virtual QString rtc_getDatStr(void)  const =0;
+    virtual QString rtc_getTimDatStr(void)  const =0;
+
+    // UID
+    virtual void     dc_getUID8byte(uint8_t *buf8byteUid)  const =0;
+    virtual QString  dc_getUIDstr()  const =0;
+    virtual uint64_t dc_getUIDnumber(void)  const =0;
+
+
+    // Analog inputs:
+    virtual uint32_t dc_getTemperature(void)  const =0;       // in Sax-Format 0...400 (0=-50,0°C    100=0,0°C    141=20,5°C    400=150,0°C)
+    virtual QString  dc_getTemperaturStr(void)  const =0;
+
+    virtual uint32_t dc_getVoltage(void)  const =0;           // in mV,  0...65,535V
+    virtual QString  dc_getVoltagStr(void)  const =0;
+
+
+
+    // ------------------------------------------------------------------------------
+    // Level 3: digital outputs and simple switching of connected devices
+    //          simple processes like flashing a led or open flap for 1s
+    // ------------------------------------------------------------------------------
+
+    virtual void lock_switchContactPower(bool on)  const =0;
+
+    // Locks move until stop cmd (0)
+    virtual uint8_t lock_switchUpperLock(uint8_t dir)  const =0;
+        // dir 0=off 1=up 2=down
+    virtual uint8_t lock_switchLowerLock(uint8_t dir)  const =0;
+        // dir 0=off 1=up 2=down
+
+    // LEDs
+    virtual void led_switchLedIllumination(uint8_t on)  const =0;
+    virtual void led_switchLedService(uint8_t on)  const =0;
+    virtual void led_switchLedPaper(uint8_t on, uint8_t ton, uint8_t tof)  const =0;
+    virtual void led_switchLedPinPad(uint8_t on, uint8_t ton, uint8_t tof)  const =0;
+    virtual void led_switchLedStart(uint8_t on, uint8_t ton, uint8_t tof)  const =0;
+    virtual void led_switchLedCoinbassin(uint8_t on, uint8_t ton, uint8_t tof)  const =0;
+
+    virtual void fan_switchFan(bool on)  const =0;
+    virtual void laerm_switchSiren(bool on)  const =0;
+    virtual void bar_OpenBarrier(bool open)  const =0;
+    virtual void ptu_switchWake(bool WAKEACTIVE)  const =0;
+
+    virtual void prn_switchPower(bool on)  const =0;
+
+    virtual void mif_readerOn(bool on)  const =0;
+
+    virtual void shut_move(bool open)  const =0;
+    virtual void esc_moveFlaps(uint8_t flap )  const =0;
+        // 0: close both  1: open take-flap   2: open return
+
+    virtual void mdb_switchPower(bool on)  const =0;
+    virtual void mdb_switchWake(bool WAKEACTIVE)  const =0;
+
+    virtual void mod_switchPower(bool on)  const =0;
+    virtual void credit_switchPower(bool on)  const =0;
+
+    virtual void aux_power(bool on)  const =0;
+    virtual void aux_setUsage(uint8_t PinDirection)  const =0;
+    virtual void aux_setOutputs(uint8_t PinIsHigh)  const =0;
+
+
+    virtual void mod_switchWake(bool WAKEACTIVE)  const =0;
+
+    virtual void credit_switchWake(bool WAKEACTIVE)  const =0;
+
+
+
+
+    // ------------------------------------------------------------------------------
+    // Level 3: digital inputs of connected devices
+    // ------------------------------------------------------------------------------
+
+    virtual bool door_isContactPowerOn(void)  const =0;
+
+    virtual uint8_t door_getSwitches(void)  const =0;
+        // retval:  bit0: upper door  1: low door  2:vault door
+
+    virtual bool    door_isUpperDoorOpen(void)  const =0;
+
+    virtual bool    door_isLowerDoorOpen(void)  const =0;
+
+    virtual bool    vault_isVaultDoorOpen(void)  const =0;
+
+    virtual uint8_t vault_getSwitches(void)  const =0;
+        // retval bit0: cash box,  bit 1: bill box
+
+    virtual bool    vault_isCoinVaultIn(void)  const =0;
+
+    virtual bool    vault_isBillVaultIn(void)  const =0;
+
+    virtual uint8_t door_getLocks(void)  const =0;
+        // retval bit0: upper lever is up
+        //        bit1: upper lever is down
+        //        bit2: lower lever is up
+        //        bit3: lower lever is down
+
+    virtual bool door_upperDoorIsLocked(void)  const =0;
+
+    virtual bool door_upperDoorIsUnlocked(void)  const =0;
+
+    virtual bool door_lowerDoorIsLocked(void)  const =0;
+
+    virtual bool door_lowerDoorIsUnlocked(void)  const =0;
+
+    virtual bool bar_optoIn1isOn(void)  const =0;
+
+    virtual bool bar_optoIn2isOn(void)  const =0;
+
+    virtual bool ptu_WakeINisActive(void)  const =0;
+
+    virtual bool prn_isPrinterPowerOn(void)  const =0;
+    virtual bool prn_readyINisActive(void)  const =0;
+
+    virtual bool mif_cardIsAttached(void)  const =0;
+    virtual bool mif_isMifarePowerOn(void)  const =0;
+
+    virtual bool mdb_WakeINisActive(void)  const =0;
+    virtual bool mdb_testIsmdbTxDon(void)  const =0;
+    virtual bool mdb_isMdbPowerOn(void)  const =0;
+
+    virtual bool coid_isAttached(void)  const =0;
+    virtual bool coin_escrowIsOpen(void)  const =0;
+
+    virtual bool aux_isAuxPowerOn(void)  const =0;
+
+    virtual uint8_t aux_getAuxInputs(void)  const =0;
+
+    virtual bool mod_isGsmPowerOn(void)  const =0;
+
+    virtual bool cred_isCreditPowerOn(void)  const =0;
+
+
+
+
+
+    // ------------------------------------------------------------------------------
+    // Level1,2,3     RD request commands
+    // ------------------------------------------------------------------------------
+
+    // all read-requests can be sent manually by the following functions
+    //   or automatically in background by:   void hwapi::dc_autoRequest(bool on)
+    //   in other words:
+    //   if automatic-reading is on, then there's no need to send any of these commands,
+    //    but it's allowed to send them in order to speed up the refreshing of the inputs
+
+    virtual void request_DC2serialConfig()  const =0;
+    virtual void request_DC2_HWversion() const =0;
+    virtual void request_DC2_SWversion() const =0;
+    virtual void request_DC2_condition() const =0;
+    virtual void request_DC2_UID() const =0;
+    virtual void request_DC2_TimeAndDate() const =0;
+    virtual void request_DC2_analogues() const =0;
+    virtual void request_DC2_digitalInputs() const =0;
+    virtual void request_DC2_digitalOutputs() const =0;
+
+    // ------------------------------------------------------------------------------
+    // the folowing device state requests are deploed only if device is powered up:
+    virtual void request_PrinterHwState() const =0;
+    virtual void request_PrinterCurrentFonts() const =0;
+    virtual void request_PrinterStateComplete() const =0;
+
+    virtual void request_MifareReaderState() const =0;
+    virtual void request_MifareCardType() const =0;
+    virtual void request_MifareAtbType() const =0;
+    virtual void request_MifareData() const =0;
+
+    virtual void request_MDB_Status() const =0;
+    virtual void request_MDB_lastResponse() const =0;
+    virtual void request_EMP_allParameters() const =0;
+    virtual void request_EMP_lastCoin() const =0;
+
+
+
+    // ------------------------------------------------------------------------------
+    // Level 3: readback digital outputs of connected devices
+    //          these functions are not needed for normal operation
+    //          but can be used to test and verify conditions
+
+    //          There are two options:
+    //              1) the important things like power-outputs and wake lines are
+    //              measured at DC2-terminals (after transistors) and come as input to DC-board
+    //              2) others like Leds are read from µC-pins by DC-board
+    // ------------------------------------------------------------------------------
+
+    virtual bool test_getDO_mdbRXtst(void) const =0;
+
+    virtual uint8_t lock_getDO_motors(void) const =0;
+        // bit0: upper lock forward    bit 1 backward
+        // bit2: lower lock forward    bit 3 backward
+
+    virtual uint8_t test_serialState(void) const =0;
+        // test on-board signals for the serials
+        // serial drv on/off, Serial mux1, Serial mux2
+    virtual bool test_serialIsOn(void) const =0;
+    virtual bool test_serialMux1isSetToPrinter(void) const =0;
+    virtual bool test_serialMux1isSetToModem(void) const =0;
+    virtual bool test_serialMux2isSetToCredit(void) const =0;
+    virtual bool test_serialMux2isSetToMifare(void) const =0;
+
+    virtual bool led_coinIsOn(void) const =0;
+    virtual bool led_frontIsOn(void) const =0;
+    virtual bool led_ticketIsOn(void) const =0;
+    virtual bool led_pinIsOn(void) const =0;
+    virtual bool led_StartIsOn(void) const =0;
+    virtual bool led_insideIsOn(void) const =0;
+
+    virtual bool fan_isOn(void) const =0;
+    virtual bool siren_isOn(void) const =0;
+    virtual bool bar_relayIsOn(void) const =0;
+    virtual bool ptu_WakeOutIsOn(void) const =0;
+
+    virtual bool aux_powerIsOn(void) const =0;
+
+    virtual bool coin_shutterIsOpen(void) const =0;
+    virtual bool coin_shutterTestOutput(void) const =0;
+
+    virtual uint8_t coin_escrowFlapOpened(void) const =0;
+        // retval: 1:return flap is open   2:take flap is open    0:closed
+
+
+
+    // ------------------------------------------------------------------------------
+    // Level4 ( Timer processes, device supervision by DC, processes with more then one devices
+    // WRITE
+    // ------------------------------------------------------------------------------
+
+
+    virtual void sendDeviceSettings(uint8_t kindOfPrinter,      uint8_t kindOfCoinChecker,
+                            uint8_t kindOfMifareReader, uint8_t suppressSleep,
+                            uint8_t kindOfModem,        uint8_t kindOfCredit        ) const =0;
+
+    virtual void request_ReadbackDeviceSettings() const =0;
+
+    virtual void readback_DeviceSettings(uint8_t *length, uint8_t *data) const =0;
+        // refer to DC2 manual for exact content
+        // state 5.5.21: byte[0]=kindOfPrinter   byte[1]=kindOfCoinChecker
+    //               byte[2]=kindOfMifarereadr   byte[3]=suppress sleep mode
+    //               byte[4]=kindOfModem         byte[5]=kind of cc terminal
+
+    virtual uint8_t emp_returnLastCoin(uint16_t *value, uint8_t *signal) const =0;
+        // use for changer
+
+    virtual void sendMachineID(uint16_t customerNr, uint16_t machineNr,
+                              uint16_t borough, uint16_t zone,
+                              uint16_t alias,   char *location) const =0;
+
+    virtual void request_ReadbackMachineID() const =0;
+
+    virtual void readback_machineIDdata(uint8_t *length, uint8_t *data) const =0;
+    // state 5.5.21: byte[0,1]=customer number    byte[2,3]=machine number
+    //               byte[4,5]=borough   byte[6,7]=zone   byte[8,9]=alias name
+    //               byte[10...41]=location
+
+
+    // Locks stops automatically at end switch or by timeout
+    virtual uint8_t lock_openUpperDoor(void) const =0;
+    virtual uint8_t lock_closeUpperDoor(void) const =0;
+
+    virtual uint8_t lock_openLowerDoor(void) const =0;
+    virtual uint8_t lock_closeLowerDoor(void) const =0;
+
+
+    virtual void shut_openOnce(void) const =0;
+        // and close automatic after shutter time
+
+    virtual void shut_openForCoin(bool start) const =0;
+        // open flap if coin is attached
+        // once process is started it runs until stop command
+
+    virtual void shut_sendOpeningTime(uint16_t timeIn_ms ) const =0;
+        // after this time without retrigger the flap is closed
+
+    virtual void esc_takeMoney(void) const =0;
+        // and close automatically after escrow time (1s)
+
+    virtual void esc_returnMoney(void) const =0;
+        // and close automatically after escrow time (1s)
+
+    virtual void mif_creatAtbCard(uint8_t cardType) const =0;
+
+
+    // ------------------------------------------------------------------------------
+    // read response from DC2 (input data)
+    // ------------------------------------------------------------------------------
+
+
+
+    /* data description:
+    byte 0: current read state: 0=power off  1=reader-fault 2=ready
+                                3=just reading 4=read complete
+                                5=read partial, removed too early
+                                6=state unknown
+    byte 1,2: read data length from card
+    3: 1=reader is OK (reported serial nr is OK)  0=wrong or no reader
+    4...15: reader version, expected "ATB25-1.8"
+    byte16: 1=card is present   0:not
+    17: 0
+    18: card type reported from reader
+    19: 1=allowed card type 0=not
+    20: card size: 1 or 4 (dec) = card size
+    21: LengthOfUID: 4 or 7 (dec) (byte)
+    22: UID 8 byte in hex
+    byte 30: sector logged: 0
+    byte 31: current sector: 0
+    byte 32: result, always 0
+    */
+    virtual uint8_t mif_returnReaderStateAndCardType(uint8_t *buf, uint8_t maxBufferSize) const =0;
+        // retval 0=OK 1=error host buffer too small
+
+    virtual bool mif_readerIsOK(void) const =0;
+
+    virtual bool mif_cardAttached(void) const =0;
+
+    virtual uint8_t mif_readResult(void) const =0;
+        // result: 0: unknown or still in progress
+        //         1: card read successful
+        //         2: reading error
+
+    virtual QString mif_cardUID(void) const =0;
+
+    virtual uint8_t mif_getCardDataDec(uint8_t blkNr, uint8_t *buf, uint8_t maxBufferSize) const =0;
+
+    virtual QString mif_getCardDataStr(uint8_t blockNumber) const =0;
+        // with blockNumber=0...11
+
+
+
+
+    // ----------------------------------------------------------------------------------------------------------
+    // --------------------------------------------- PRINTER ----------------------------------------------------
+    // ----------------------------------------------------------------------------------------------------------
+
+    // read printer condition and settings
+
+    virtual uint8_t prn_getHwState(struct Tprn_hw_state *prn_hw_state) const =0;
+        // retval: status byte
+            // byte 0 = 0: prnter OK,  >0: error
+            // bit0: paper low  1: no paper    2: temperature error
+            // 3: head open     4: paper jam in cutter
+            // 6: no response   7: bad response from printer
+        // and return struct "Tprn_hw_state"
+
+    virtual bool prn_isUpAndReady(void) const =0;
+        // true: printer is powered, serial is ok, no error, printer is connected and resonding
+
+    virtual void prn_getCurrentFontSetting(struct Tprn_currentSettings *prn_fonts) const =0;
+
+
+    // send Commands to printer:
+
+    virtual void prn_sendText(QByteArray *buf) const =0;
+        // up to 1280 bytes
+
+    virtual void prn_sendPrnSysCmd(uint8_t para1, uint8_t para2, uint32_t para3) const =0;
+        // send three byte through to printer, see printers manual
+
+    virtual void prn_sendPrnEscCmd(uint8_t para1, uint8_t para2, uint8_t para3, uint8_t para4) const =0;
+        // send four byte through to printer, see printers manual
+
+
+    virtual void prn_sendPrnSetup(uint16_t paperSpeed, uint8_t density,  uint8_t alignment, uint8_t orientation) const =0;
+        // send 5 byte: byte 0,1: speed  5...250 mm/s
+        //              byte2: density   0....(25)....50
+        //              byte3: alignment    'l', 'c', 'r' = left, center, right
+        //              byte4: orientation  0, 90, 180    = 0°, 90°, 180° rotation (by now not supported!)
+        // not batched! don't use twice within 100ms
+
+    virtual void prn_movePaper(uint8_t wayInMm, uint8_t direction) const =0;
+        //direction: 1=forward 2=backward
+        //
+    virtual void prn_setFonts(uint8_t font, uint8_t size, uint8_t width, uint8_t height) const =0;
+        // font = kind of font 5...11 (0..22)
+        // size = 6...20, 9..9: too tiny 10: small ...12 = normal size ...20=huge
+        // width:  0...4   0=1x  1=2x   2=4x (huge!)  3=8x 4=16x (3,4 make no sense)
+        // heigth: 0...7 = 1x...8x  only 0,1,2,(3) make sense
+
+    virtual void prn_setLetters(uint8_t bold, uint8_t invers, uint8_t underlined) const =0;
+        // bold: 0/1
+        // invers: 0/1
+        // underlined: 0/1
+
+    virtual void prn_cut(uint8_t kindof) const =0;
+        // kindof: 1=full cut 2=partial cut 3=eject (5xLF + full cut)
+
+    virtual void prn_newLine(uint8_t nrOfLines) const =0;
+
+    virtual void prn_printCompleteFontTable(void) const =0;
+
+
+    virtual void prn_printBarcode(uint8_t kindOf, uint8_t withText,  uint8_t offset, uint8_t rotation, uint8_t dataLeng, uint8_t *data) const =0;
+        // kind of barcode: 0=Code39   1=Code128   2=EAN13    3= 2/5interleaved    4=UPC-A   5=EAN8
+        // withText:    print readable text below
+        // offset: move by pixel from left border
+        // rotation
+        // dataLeng in byte
+
+    virtual void prn_sendQRdata(QByteArray *buf) const =0;
+        // maximal 150 alphanummeric bytes
+
+    virtual void prn_printQRcode(void) const =0;
+        // QRcode may have 1...150 alphanummeric data, must be transfered in advance
+
+
+    virtual void prn_printLogo(uint8_t nrOfLogo, uint8_t offset ) const =0;
+        // nrOfLogo: 1..4 in flash  5...8 in Ram
+        // offset: in mm form left border
+
+
+
+    // .........................................................
+    // Parking Ticket (print-out document) designer TD
+    // .........................................................
+
+    // Predefine document Layout (e.g. parking ticket) in advance and stroe it for quick and easy use
+    // in opposite to the above "single" commands you need only one or a few commands at vending time.
+    // Stored text is just send to printer once the printing command is issued
+    // stored commands within the text are interpreted and executed right at the place (in ticket) they are
+    // example: start bold, <text in bold>, stop bold
+    // Predefinition of up to 16 ticket Layouts is possible, 0...1280 byte each
+    // Number 0..15, al keept non-volatile
+    // up to 8 dynamic values can be defined in the template ("print val3 here") and will be sent with printing command
+    // example: print current time at this point (the time of printing not the storage time!!)
+
+    virtual void pri_startTicketDesign(void) const =0;
+        // start for every new printer document, reseting collecting buffer
+
+    // all further functions write/append text, numbers and command to the ticket-buffer, up to 1278 bytes allowed
+    // return val of the appending functions: true=ok false=too long, buffer full
+
+    virtual int pri_TD_getCurrentSize(void) const =0;
+        // retval: 0...1278
+
+    virtual bool pri_TD_addText(QByteArray text) const =0;
+        // example: pri_TD_addText("Hello") const =0;
+        // example: pri_TD_addText(tempStr) const =0;
+        // retval: true=ok false=too long, buffer full
+
+    virtual bool pri_TD_addValue(int val) const =0;
+        // +/- 0...2^(31)
+
+    virtual bool pri_TD_addNewLine(void) const =0;
+
+    virtual bool pri_TD_addSign(char sign) const =0;
+        // example: '.'   ' '   0x20 'W' '$'
+
+    virtual bool pri_TD_addCommand(char group, char attribute, char p1, char p2, char p3, char p4, char p5) const =0;
+        // always add 8 byte to the ticket layout:  ESC & group & attribute & parameter1...5
+        /* complete list of possible commands:
+            group 50 : paper
+                attribute 10 :  move forward
+                      p1: wayInMm p2: direction
+                attribute 11 : cut
+                      p1: kind of, 1=full 2=partial, 3=eject
+                attribute 12 : new line(s)
+                      p1: nr of lines 1...100
+
+            group 51 : fonts
+                attribute 10 : kind of font     see description above
+                      p1: 0...8
+                attribute 11 : font size
+                      p1: 6...20
+                attribute 12 : font width
+                      p1: 0...4
+                attribute 13 : font heigth
+                      p1: 0...7
+                attribute 14 : switch bold print on/off
+                      p1: 0=off  1=on
+                attribute 15 : switch invers print on/off
+                      p1: 0=off  1=on
+                attribute 16 : switch underlined print on/off
+                      p1: 0=off  1=on
+
+            group 52 : print graphics
+                attribute 10 : print barcode with dynamic data 6 and 7
+                      p1...p5 = kindOf, withText, offset, rotation, dataLeng, see description above
+                attribute 11 : print QRcode with preset data
+
+                attribute 12 : print Logo
+                     p1=nrOfLogo, p2=offset
+
+            group 53 : print dynamics
+                attribute 10 :
+                        p1: 1...8 = print dynData 0..7 at this place
+
+    */
+
+    virtual char prn_clearDocument(uint8_t documentNumber) const =0;
+        // clear memory buffer for ONE document
+        // function takes a second! don't send right before "store doc"
+
+    virtual bool prn_store_Document(uint8_t documentNumber ) const =0;
+        // send the predefined Layout (generated with above TD functions) to DeviceController to save
+        // documentNumber=0...15
+        // maximal 1280 bytes each
+        // allowed: 0x20...0xFF, 0x0A, 0x0C, 0x1B (LF, CR, Esc)
+        // 0x1B=start of embedded command (next 7bytes = command)
+
+    // with a print command a set of 8 dynamic strings can be sent
+    // the place in the ticket layout is predefined (already in DC memory)
+    // the dynamics are first calculated at printing time
+
+    virtual bool prn_printDocument(uint8_t documentNumber, struct T_dynDat *dynTicketData) const =0;
+
+
+
+
+
+    // ----------------------------------------------------------------------------------------------------------
+    // --------------------------------------------- MDB Bus ----------------------------------------------------
+    // ----------------------------------------------------------------------------------------------------------
+
+    //void mdb_switchPower(bool on) const =0;            defined above
+    //void mdb_switchWake(bool WAKEACTIVE) const =0;     defined above
+//    bool mdb_WakeINisActive(void) const =0;
+//    bool mdb_testIsmdbTxDon(void) const =0;
+//    bool mdb_isMdbPowerOn(void) const =0;
+//    void request_MDB_Status() const =0;
+//    void request_MDB_lastResponse() const =0;
+
+
+    virtual void mdb_sendBusReset(void) const =0;
+
+    virtual void mdb_sendCommand(uint8_t toMdbDevice, uint8_t mdbCommand) const =0;
+        // send one bus command directly over mdb bus, refer to mdb manual for commands
+        // this command is not needed in normal operation, just for new or special things
+
+    virtual void mdb_sendMessage(uint8_t toMdbDevice, uint8_t mdbCommand, uint8_t nrOfData, uint8_t *dataBuffer) const =0;
+        // nrOfData = sizeOf(dataBuffer) maximal 34 byte according mdb specs
+        // same as mdb_sendCommand, just with data
+
+    virtual bool mdb_busIsReadyToWork() const =0;
+
+    virtual bool mdb_deviceVoltageOK() const =0;
+
+    virtual bool mdb_busVoltageOk() const =0;
+
+    virtual uint8_t mdb_getLastDeviceResponse(uint8_t *fromDevice, uint8_t *lastRequest,
+                                      uint8_t *responseLength, uint8_t *responseBuffer) const =0;
+        // fromDevice: device nr from which data was requested 0,1,2,3
+        // lastRequest: sent mdb command
+        // responseLength: nr of payload data (after mdb-ack) 0...34
+        // responseBuffer holds payload data (answer from mdb device)
+        // return val: mdb result of this request: 1=got ACK  2=got 3xNAK  3=no or bad response    4:got Data (after ACK)
+
+
+
+
+
+    // ----------------------------------------------------------------------------------------------------------
+    // ---------------------------------- Electronic Coin Validator EMP -----------------------------------------
+    // ----------------------------------------------------------------------------------------------------------
+
+
+    virtual void emp_sendSettings(uint16_t coinAcceptance, uint8_t tokenChannel, uint16_t *coinDenomination ) const =0;
+        // coinAcceptance: bit0=coin1 (lowest donomination)  bit15=coin16  bitH=accept  bit L = deny coin (no validation)
+        // tokenChannel 0...31: if this signal comes from emp then a token was inserted
+        // coinDenomination = array of 16 coin values (e.g. 5, 10, 20...)
+
+    virtual void emp_pollingOnOff(uint8_t on) const =0;
+
+    virtual void emp_startCoinAcceptance(void) const =0;
+
+    virtual void emp_stopCoinAcceptance(void) const =0;
+
+    virtual void emp_getAllParameters(struct T_emp *emp) const =0;
+        // see struct in hwapi.h
+        // usage example:
+        //      hwapi   *HWaccess const =0;
+        //      HWaccess = new hwapi() const =0;
+        //      struct T_emp   myEmp const =0;
+        //      HWaccess->emp_getAllParameters(&myEmp) const =0;
+        //          readval=myEmp.pollingRunning const =0;
+
+    virtual uint8_t emp_chkIfCoinInserted(void) const =0;
+        // retval: 0...16 coins left in FIFO
+
+    virtual void emp_getNewCoinRecord(uint8_t *valid, uint8_t *signal, uint8_t *error, uint16_t *value) const =0;
+        // with every call ONE coin is taken out of FIFO and pointer decremented
+        // valid: should be 1
+        // signal: comes right from coin checker, 0...15 (0=first programmed coin type) 0xFF=no signal
+        // error: was reported from EMP as dynamic signal right after coin insertion (instead of
+        //          coin signal), example: 3=unknown coin  4=coin is blocked by host.  0xFF=no error
+        // value: of the coin. Depends on parameter "coinDenomination" in function "emp_sendSettings"
+        //          if coinDenomination[coin 0..15] = 0 then the value programmed in coin checker is taken
+        //          if coinDenomination > 0 then this value is taken.
+        //          Useful in case of two currencies (adapt to local currency) or for token.
+
+    // function gives more details as "emp getLastCoin()" but "emp getLastCoin()" is easier to use
+
+    // alternativ to emp_getNewCoinRecord( ):
+    virtual uint8_t emp_giveLastCoin(uint16_t *value, uint8_t *signal) const =0;
+        // retval: 0: NO coin stored  1: valid coin  2: got wrong coin or coin denied
+        // value: if retval1: value of the coin if reval=2: error number
+        //          0xFF means NO error or NO signal  (as 0 is a valid error/signal)
+        // signal: channel nr reported from checker 0...15
+
+
+
+};
+
+
+#endif
+
+
+

include/prot.h

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

include/sendWRcmd.h

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

include/storeINdata.h

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

include/tslib.h

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