Adding src files (sax)

src/com.cpp

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

src/controlBus.cpp

@@ -0,0 +1,415 @@
+#include <stdint.h>
+#include <QString>
+#include <QDebug>
+#include "tslib.h"
+//#include "controlBus.h"
+
+// ///////////////////////////////////////////////////////////////////////////////////
+//          control serial interface   gui <--> serial
+// ///////////////////////////////////////////////////////////////////////////////////
+
+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
+
+}
+
+void epi_closeSerial(void)
+{
+    rs_connect=0;
+}
+
+
+void gpi_serialChanged(void)
+{
+    // serial confirms that port was closed or opened
+    rs_connect=2;   // Flanke, nur 1x öffnen/schließen
+}
+
+uint8_t gpi_getSerialConn(void)
+{
+    return rs_connect;
+}
+
+
+int gpi_getBaudNr(void)
+{
+    return rs_baudNr;
+}
+
+QString gpi_getComPortName(void)
+{
+    return rs_comportName;
+}
+
+static bool rs_portIsOpen;
+
+void gpi_serialIsOpen(bool offen)
+{
+    rs_portIsOpen=offen;
+}
+
+bool epi_isSerialPortOpen()
+{
+    // true: port is open   false: port is closed
+    return rs_portIsOpen;
+}
+
+// ///////////////////////////////////////////////////////////////////////////////////
+//          Control transfer   gui <--> serial
+// ///////////////////////////////////////////////////////////////////////////////////
+
+
+static char       AutoEmissionOn;     // 1: zyklisch Anfragen zum Slave senden
+
+void epi_startEmmision(char start)
+{
+    AutoEmissionOn=start;
+}
+
+bool gpi_isEmmisionOn(void)
+{
+    return 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)
+        return 130;         // ms, default
+    else
+        return datif_sendingPeriod;
+}
+
+void epi_setPeriodicSendTimeVal(uint16_t val)
+{
+    if (val>=3 && val<10000)
+    {
+        datif_sendingPer_changed=1;
+        datif_sendingPeriod=val;
+    }
+}
+
+bool gpi_PeriodicSendTimeHasChanged()
+{
+    return datif_sendingPer_changed;
+}
+
+//-----------------------------------------------------
+
+
+//-----------------------------------------------------
+
+// ///////////////////////////////////////////////////////////////////////////////////
+//          Status Display    gui <--> serial
+// ///////////////////////////////////////////////////////////////////////////////////
+
+
+//              linke Spalte, über Connect Button
+static QString txt4comStateLine;
+
+QString epi_getTxt4comStateLine(void)
+{
+    // GUI: get Text for serial Comport-State Line
+    return txt4comStateLine;
+}
+
+void gpi_setTxt4comStateLine(QString txtline)     // gpi
+{
+    // serial: write Text to be displayed in serial Comport-State line (like "connected")
+    txt4comStateLine.clear();
+    if (txtline=="")
+        txt4comStateLine.clear();
+    else
+        txt4comStateLine=txtline;
+}
+
+void epi_clrTxt4comStateLine()
+{
+    txt4comStateLine.clear();
+}
+
+
+//---------------------------------------------------------------------------------------------
+
+// rechte Spalte, oberste Statuszeile
+// I) "Handshakes" (serial Control)   flow.cpp
+// geht überhaupt was raus? kommt überhaupt was zurück?
+static QString txt4HsStateLine;
+
+QString epi_getTxt4HsStateLine(void)
+{
+    return txt4HsStateLine;
+}
+
+void gpi_setTxt4HsStateLine(QString txtline)
+{
+    txt4HsStateLine.clear();
+    if (txtline=="")
+        txt4HsStateLine.clear();
+    else
+        txt4HsStateLine=txtline;
+}
+
+void epi_clrTxt4HsStateLine()
+{
+    txt4HsStateLine.clear();
+}
+
+
+
+//---------------------------------------------------------------------------------------------
+
+// II) Master receive state (empfangenes Telgramm OK? crc? length?  )
+// Statuszeile Auswertung der SlaveResponse (serial Frame, CRC usw)  (prot.cpp)
+static QString txt4masterStateLine;
+
+QString epi_getTxt4masterStateLine(void)
+{
+    return txt4masterStateLine;
+}
+
+void gpi_setTxt4masterStateLine(QString txtline)
+{
+    txt4masterStateLine.clear();
+    if (txtline=="")
+        txt4masterStateLine.clear();
+    else
+        txt4masterStateLine=txtline;
+}
+
+void epi_clrTxt4masterStateLine()
+{
+    txt4masterStateLine.clear();
+}
+
+
+
+//---------------------------------------------------------------------------------------------
+
+// III   Slave receive (from Master) OK? if then show results, if not then show errors
+// entweder Empfangsfehler anzeigen (crc? length?) oder result OUT-OK, OUT_ERR, IN_OK, IN_ERR
+// Hintergrund: wenn der Slave Fehler im Master-Telegramm gefunden hat, dann kann er es auch
+// nicht verwenden und nichts ausgeben oder einlesen
+
+static QString txt4resultStateLine;
+
+QString epi_getTxt4resultStateLine(void)
+{
+    return txt4resultStateLine;
+}
+
+void gpi_setTxt4resultStateLine(QString txtline)
+{
+    txt4resultStateLine.clear();
+    if (txtline=="")
+        txt4resultStateLine.clear();
+    else
+        txt4resultStateLine=txtline;
+}
+
+void epi_clrTxt4resultStateLine()
+{
+    txt4resultStateLine.clear();
+}
+
+
+//---------------------------------------------------------------------------------------------
+
+// IV  Statuszeile Empfangsdaten
+static QString txt4dataLine;
+
+QString epi_getTxt4dataStateLine(void)
+{
+    // GUI: get Text for serial Comport-State Line
+    return txt4dataLine;
+
+}
+
+void gpi_setTxt4dataStateLine(QString txtline)
+{
+    // serial: write Text to be displayed in serial Comport-State line (like "connected")
+    txt4dataLine.clear();
+    if (txtline=="")
+        txt4dataLine.clear();
+    else
+        txt4dataLine=txtline;
+}
+
+void epi_clrTxt4dataStateLine()
+{
+    txt4dataLine.clear();
+}
+
+//---------------------------------------------------------------------------------------------
+
+// 5. Zeile: Datif Ergebnis, Daten brauchbar?
+
+static QString txt4datifReceive;
+
+QString epi_getTxt4datifLine(void)
+{
+
+    return txt4datifReceive;
+
+}
+
+void gpi_setTxt4datifLine(QString txtline)
+{
+
+    txt4datifReceive.clear();
+    if (txtline=="")
+        txt4datifReceive.clear();
+    else
+        txt4datifReceive=txtline;
+}
+
+void epi_clrTxt4datifLine()
+{
+    txt4datifReceive.clear();
+}
+
+//---------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------
+
+static QString txt4diagWindow;
+
+QString epi_getTxt4RsDiagWin(void)
+{
+    return txt4diagWindow;
+
+}
+
+void gpi_setTxt4RsDiagWin(QString txtline)
+{
+    txt4diagWindow.clear();
+    if (txtline=="")
+        txt4diagWindow.clear();
+    else
+        txt4diagWindow=txtline;
+}
+
+void epi_clrTxt4RsDiagWin()
+{
+    txt4diagWindow.clear();
+}
+
+//---------------------------------------------------------------------------------------------
+
+static QString sndTxt4diagWindow;
+
+QString epi_get2ndTxt4RsDiagWin(void)
+{
+    return sndTxt4diagWindow;
+
+}
+
+void gpi_set2ndTxt4RsDiagWin(QString txtline)
+{
+    sndTxt4diagWindow.clear();
+    if (txtline=="")
+        sndTxt4diagWindow.clear();
+    else
+        sndTxt4diagWindow=txtline;
+}
+
+void epi_clr2ndTxt4RsDiagWin()
+{
+    sndTxt4diagWindow.clear();
+}
+
+// ///////////////////////////////////////////////////////////////////////////////////
+//          Memory for Slave responses, common data
+// ///////////////////////////////////////////////////////////////////////////////////
+
+
+static bool Sdata_serialTestResult;
+
+void gpi_storeResult_serialTestOK(bool wasOk)
+{
+    Sdata_serialTestResult=wasOk;
+}
+
+bool epi_getResult_serialTestOK()
+{
+    // retval: true: test was successful, got right response
+    return Sdata_serialTestResult;
+}
+
+
+
+// ///////////////////////////////////////////////////////////////////////////////////
+//          Store received data for hwapi
+// ///////////////////////////////////////////////////////////////////////////////////
+
+
+
+static uint8_t Sdata_pProtResultOk;
+
+void gpi_startNewRequest()
+{
+    Sdata_pProtResultOk=0;
+}
+
+void gpi_storeResultOfLastRequest(bool answisok)
+{
+    if (answisok)
+        Sdata_pProtResultOk=1;
+    else
+        Sdata_pProtResultOk=2;
+}
+
+uint8_t epi_getResultOfLastRequest()
+{
+    // retval: 0: in progress  1: OK  2: error
+    return 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);
+
+}
+
+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;
+}
+
+
+
+
+

src/prot.cpp

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

src/sendWRcmd.cpp

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

src/tslib.cpp

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