#include "datIf.h"
#include "sendWRcmd.h"
#include "controlBus.h"
#include "storeINdata.h"
#include <QDebug>

// called from MainWindow()


#define     DATIF_MAXCMDS        16
static uint8_t dif_dataStep;
static uint8_t dif_scanStep, RDBLKNR;


static uint8_t datif_OutCmdpara1, datif_OutCmdpara2, datif_OutCmdpara3, datif_OutCmdpara4;
static uint16_t datif_OutCmdpara5;
static uint32_t datif_OutCmdpara6;


T_datif::T_datif(QWidget *parent) : QMainWindow(parent)
{

    myDCIF = new T_prot();

    // valid data was received, storing
    connect(myDCIF, SIGNAL(framerecieved()), this, SLOT(StoredRecData()));

    // new, 9.11.20 data for DC-bootloader received not matchind Pprot
    //connect(myDCIF, SIGNAL(rawDataRecieved()), this, SLOT(BLdataRecData()));

    // cyclic transmission of INPUT-Requests
    datif_trigger = new QTimer();
    connect(datif_trigger, SIGNAL(timeout()), this, SLOT(datif_cycleSend()));
    datif_trigger->setSingleShot(false);
    datif_trigger->start(100);     // in ms, 80 gut, default 100   50....200

    // passing Signal through
    //connect(myDCIF, SIGNAL(framerecieved()), this, SLOT( ResponseRecieved() ));

    datif_OutCmdpara1=0;
    datif_OutCmdpara2=0;
    datif_OutCmdpara3=0;
    datif_OutCmdpara4=0;
    dif_dataStep=1;

    dif_scanStep=0;
    selectedSlaveAddr=FIX_SLAVE_ADDR;

}

void T_datif::resetChain(void)
{
   dif_scanStep=0;
}

char T_datif::datif_cycleSend()
{
    // cyclic transmission of INPUT-Requests
    // call cyclic to send next request every 100ms, then wait for response before sending again!!!
    uint16_t nxtAsCmd;
    uint8_t  dataSendBuf[160], dataBufLen, dbl, who;
    static uint8_t BlockCounter;

    if (myDCIF->isPortOpen())
    {
        #ifdef USEHANDSHAKES
        if (myDCIF->isSerialFree())
        #endif
        {
            // direct commands have highest prio (setting OUTPUTS)
            nxtAsCmd=sendWRcmd_getSendCommand0();       // command was stored by Gui
            if (nxtAsCmd>0)
            {
            qDebug()  << "datif: send next cmd0";
                sendWRcommand(nxtAsCmd);
                send_requests(nxtAsCmd);
                sendHighLevel(nxtAsCmd);
                BlockCounter=0;
                return 0;
            }

            nxtAsCmd=sendWRcmd_getSendCommand4(&datif_OutCmdpara1, &datif_OutCmdpara2, &datif_OutCmdpara3, &datif_OutCmdpara4);
                // command was stored by Gui
            if (nxtAsCmd>0)
            {
            qDebug()  << "datif: send next cmd4";
                sendWRcommand(nxtAsCmd);
                send_requests(nxtAsCmd);
                sendHighLevel(nxtAsCmd);
                BlockCounter=0;
                return 0;
            }

            nxtAsCmd=sendWRcmd_getSendCommand8(&datif_OutCmdpara1, &datif_OutCmdpara2, &datif_OutCmdpara5, &datif_OutCmdpara6);
                // command was stored by Gui
            if (nxtAsCmd>0)
            {
            qDebug()  << "datif: send next cmd8";
                sendWRcommand(nxtAsCmd);
                send_requests(nxtAsCmd);
                sendHighLevel(nxtAsCmd);
                BlockCounter=0;
                return 0;
            }

            dbl=sendWRcmd_getSendBlock160(&dataBufLen, dataSendBuf);  // used for bootloader
            if (dbl>0)
            {
            qDebug()  << "datif: sending 160 byte block, len: " << dataBufLen;
                datif_OUT_SendRandomData(dataSendBuf, dataBufLen);
                BlockCounter=0;
                return 0;
            }

            dbl=gpi_chk4remainingText();
            if (dbl>0)
            {
                qDebug() << "datif: sending printer text ";
                gpi_restorePrnText(&dataSendBuf[0]);
                    // can hold 1280 byte, get next 64
                //for (uint8_t nn=0; nn<64; nn++)
                //    qDebug() << dataSendBuf[nn] << " ";


                who=gpi_getUserOfSendingTextBuffer(&datif_OutCmdpara1, &datif_OutCmdpara2, &datif_OutCmdpara3, &datif_OutCmdpara4);

                if (who==1)
                {
                    epi_store64ByteSendData(64, dataSendBuf);   // "dueway", copy this 64 back to pi, used by datif_ send64byteOutCmd
                    datif_send64byteOutCmd(CMD2DC_PRI_PRINT_TXT, 0, 0);
                } else
                if (who==2)
                {
                    epi_store64ByteSendData(64, dataSendBuf);   // "dueway", copy this 64 back to pi, used by datif_ send64byteOutCmd
                    datif_send64byteOutCmd(CMD2DC_STOR_QR_DATA, 0, 0);
                } else
                if (who==3)
                {
                    qDebug() << "datif: sending printer text, docnr: " <<datif_OutCmdpara1 << " blknr: " << BlockCounter;

                    datif_sendToMemory(CMD2DC_PRI_STORE_DOC, datif_OutCmdpara1, BlockCounter, dataSendBuf);
                        // "docNr" in datif_OutCmdpara1   blockNr in dbl
                    //for (uint8_t nn=0; nn<64; nn++)
                     //   qDebug() << dataSendBuf[nn] << " ";
                    BlockCounter++;
                }
                return 0;
            }


            if (gpi_isEmmisionOn())     // auto send button is pressed
                sendINrequestsAutomatic();  // sendCyclicCmd();        // request all cyclic data sequential
            else
                dif_scanStep=0;         // always start from beginning
        }
        #ifdef USEHANDSHAKES
        else
        {
            qDebug()  << "last request not yet finished";
        }
        #endif
    } else
    {
        //qDebug()  << "com port not available";    // wird ununterbrochen ausgegeben
    }

    return 0;
}




// ##############################################################################
// ##############################################################################
// ##############################################################################

    // Sende Schreibbefehle die bereits vorher asynchron gespeichert wurden:
void T_datif::sendWRcommand(uint16_t nextWrCmd)
{
    // Aufruf im normalen Sendezeitraster, sende gewünschtes Einzelkommando
    //  zwischen den zyklischen aber im richtigen Raster
    //uint8_t LL;
    //uint8_t restBuf66[66];

    switch (nextWrCmd)
    {
        // basically this is the junction between asynchronous cmd and synchron sending
//        case SENDDIRCMD_TestSerial:
//            datif_sendIOrequest(0, CMD2DC_TestSerial, 0);
//            break;

        case SENDDIRCMD_setTime:
            datif_OUT_setTime();    // 0x1310            
            break;

        case SENDDIRCMD_setWakeFrequ:
            datif_sendIOrequest(CMD2DC_setWakeFrequ, 0,0);
            break;

        case SENDDIRCMD_MOVEUP_LOCK:
            datif_sendIOrequest(CMD2DC_MOV_UPLOCK, 0, 1);
            break;

        case SENDDIRCMD_MOVEDN_LOCK:
            datif_sendIOrequest(CMD2DC_MOV_DNLOCK, 0, 1);
            break;

        case SENDDIRCMD_OPENUP_DOOR:
            // Riegelleisten auf/ab bis ES
            datif_sendIOrequest(CMD2DC_UPPER_DOOR, 0, 1);
            break;

        case SENDDIRCMD_OPENDN_DOOR:
            datif_sendIOrequest(CMD2DC_LOWER_DOOR, 0, 1);
            break;

        case SENDDIRCMD_LEDILLU:
            datif_sendIOrequest(CMD2DC_LED_ILLU, CMD2DC_RdBkAllOutputs, 1);
            //                  WRITE cmd           Read Request
            //  a random request can be sent with a WRcmd, is never a disadvantage
            // but always an advantage (data are quicker actual)
            // the request does not influence the WRiting, it's independant
            break;

        case SENDDIRCMD_LEDCOIN:
            datif_sendIOrequest(CMD2DC_LED_COIN, CMD2DC_RdBkAllOutputs, 3);
            //                                                          ^ nr of params
            break;

        case SENDDIRCMD_LEDTICKET:
            datif_sendIOrequest(CMD2DC_LED_TICKET, CMD2DC_RdBkAllOutputs, 3);
            break;

        case SENDDIRCMD_LEDPAD:
            datif_sendIOrequest(CMD2DC_LED_PIN, CMD2DC_RdBkAllOutputs, 3);
            break;

        case SENDDIRCMD_LEDSTART:
            datif_sendIOrequest(CMD2DC_LED_START, CMD2DC_RdBkAllOutputs, 3);
            break;

        case SENDDIRCMD_LEDINSIDE:
            datif_sendIOrequest(CMD2DC_LED_IN, CMD2DC_RdBkAllOutputs, 1);
            break;

        case SENDDIRCMD_FAN:
            datif_sendIOrequest(CMD2DC_FAN, CMD2DC_RdBkAllOutputs, 1);
            break;
        case SENDDIRCMD_LAERM:
            datif_sendIOrequest(CMD2DC_SIREN, CMD2DC_RdBkAllOutputs, 1);
            break;
        case SENDDIRCMD_REL1:           
            datif_sendIOrequest(CMD2DC_BARRIER, CMD2DC_RdBkAllOutputs, 1);
            break;

        case SENDDIRCMD_WAKEPTU:
            datif_sendIOrequest(CMD2DC_WAKEPTU, 0, 1);
            break;

        case SENDDIRCMD_AUXPWR:
            datif_sendIOrequest(CMD2DC_SWITCHAUXPWR, CMD2DC_RdBkAllOutputs, 1);
            break;

        case SENDDIRCMD_AUXDDR:
            datif_sendIOrequest(CMD2DC_SWITCHAUXDDR, CMD2DC_RdBkAllOutputs, 1);
            break;

        case SENDDIRCMD_AUXOUT:
            datif_sendIOrequest(CMD2DC_SWITCHAUXOUT, CMD2DC_RdBkAllOutputs, 1);
            break;

        case SENDDIRCMD_PRN2_SWONOFF:
            datif_sendIOrequest(CMD2DC_PRINTERON, 0, 1);
            break;

        case SENDDIRCMD_UCONTACT_ON:
            datif_sendIOrequest(CMD2DC_UCONTACTON, 0, 1);
            break;

        case SENDDIRCMD_MIF_SWONOFF:
            datif_sendIOrequest(CMD2DC_MIFREADERON, 0, 1);      // 0x2900
            indat_storeMifarePower(datif_OutCmdpara1);
            break;

        case SENDDIRCMD_MOD_SWONOFF:
            datif_sendIOrequest(CMD2DC_MOD_ON, 0, 1);
            break;
        case SENDDIRCMD_MOD_WAKE:
            datif_sendIOrequest(CMD2DC_MOD_WAK, 0, 1);
            break;


        case SENDDIRCMD_MDB_POWER:
            //qDebug()<<"switch MDB pwr" << datif_OutCmdpara1;
            datif_sendIOrequest(CMD2DC_MDB_ON, 0, 1);
            indat_storeMDBisOn(CMD2DC_MDB_ON);
            break;

        case SENDDIRCMD_MDB_RES:
            datif_sendIOrequest(CMD2DC_MDB_DORESET, 0, 1);
            break;

        case SENDDIRCMD_MDB_WAKE:
            datif_sendIOrequest(CMD2DC_MDB_SETWAK, 0, 1);
            break;

        case SENDDIRCMD_CRED_ON:
            datif_sendIOrequest(CMD2DC_CRED_ON, 0, 1);
            break;
        case SENDDIRCMD_CRED_WAKE:
            datif_sendIOrequest(CMD2DC_CRED_WAK, 0, 1);
            break;

        case SENDDIRCMD_SHUT_MOV:
            datif_sendIOrequest(CMD2DC_SHUTTER_OPEN, 0, 1);
            break;

        case SENDDIRCMD_ESCRO_MOV:
            datif_sendIOrequest(CMD2DC_ESCR_OPEN, 0, 1);
            break;

        case SENDDIR_OPENVAULT:
            datif_sendIOrequest(CMD2DC_VAULT_DOOR, 0, 0);
            qDebug() << "Datif: send cmd open vault";
            break;

        case SENDDIR_REJMOT_ON:
            datif_sendIOrequest(CMD2DC_REJMOT_ON, 0, 0);
            qDebug() << "Datif: send cmd open vault";
            break;

        case SENDDIR_REJMOT_RUN:
            datif_sendIOrequest(CMD2DC_REJMOT_RUN, 0, 0);
            qDebug() << "Datif: send cmd open vault";
            break;


    }

}


void T_datif::send_requests(uint16_t nextWrCmd)
{
    switch (nextWrCmd)
    {

        case SENDDIRCMD_TestSerial:
            datif_sendIOrequest(0, CMD2DC_TestSerial, 0);
            //                  ^ under no circumstances give a write cmd with the request!!!!
            break;

        case SEND_REQU_SERCONF:
            datif_sendIOrequest(0, CMD2DC_GetSerialConfig, 0);
            break;

        case SEND_REQU_HWversion:
            datif_sendIOrequest(0, CMD2DC_RdBkHWversion, 0);
            break;

        case SEND_REQU_SWversion:
            datif_sendIOrequest(0, CMD2DC_RdBkSWversion, 0);
            break;

        case SEND_REQU_CONDITION :
            datif_sendIOrequest(0, CMD2DC_RdBkDCstate, 0);
            break;

        case SEND_REQU_UID :
            datif_sendIOrequest(0, CMD2DC_RdBkUID, 0);
            break;

        case SEND_REQU_TIME :
            datif_sendIOrequest(0, CMD2DC_RdBkTime, 0);
            break;

            // includes wake frequency
        case SEND_REQU_ANALOGS :
            datif_sendIOrequest(0, CMD2DC_RdBkAnalog, 0);
            break;

        case SEND_REQU_DIG_INPUTS :
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case SEND_REQU_DIG_OUTPUTS:
            datif_sendIOrequest(0, CMD2DC_RdBkAllOutputs, 0);
            break;




        case SEND_REQU_PRN_STATE:
            datif_sendIOrequest(0, CMD2DC_RdBk_PrnState, 0);
            break;

        case SEND_REQU_PRN_FONTS :
            datif_sendIOrequest(0, CMD2DC_RdBk_PrnFonts, 0);
            break;

    case SEND_REQU_PRN_ALL :
        datif_sendIOrequest(0, CMD2DC_RdBk_AllPrnData, 0);
        break;




        case SEND_REQU_MIFREADER :
            // Type and state of reader
            datif_sendIOrequest(0, CMD2DC_RdBk_MifReader, 0);
            break;

        case SEND_REQU_MIFCARD :
            // Type, UID, Header of card
            datif_sendIOrequest(0, CMD2DC_RdBk_Mifcard, 0);
            break;

        case SEND_REQU_MIF_ATB_TYPE :
            // read one card sector
            // sectors must be addressed by RD_ADD
            datif_sendIOrequest(0, CMD2DC_RdBk_AtbCardType, 0);
            break;

        //case SEND_REQU_MIF_DATA :
            // read one card sector
            // sectors must be addressed by RD_ADD
            //datif_sendIOrequest(0, CMD2DC_RdBk_CardData, 0);
            //break;

    case SEND_REQU_MDB_GETSTAT :
        datif_sendIOrequest(0, CMD2DC_MDB_GET_STATE, 0);
        break;

    //case SEND_REQU_MDB_GETWAK : hamma eh schoo
    //    datif_sendIOrequest(0, CMD2DC_MDB_GETWAK, 0);
    //    break;

    case SEND_REQU_MDB_GETRESP :
        datif_sendIOrequest(0, CMD2DC_MDB_GETRESP, 0);
        break;

    case SEND_REQU_EMP_GETALL :
        datif_sendIOrequest(0, CMD2DC_EMP_GET_ALL, 0);
        break;

    case SEND_REQU_EMP_GETCOIN :
        datif_sendIOrequest(0, CMD2DC_EMP_GOTCOIN, 0);
        break;

    case SEND_REQU_DEVICE_PARA :
        datif_sendIOrequest(0, CMD2DC_RDBK_DEV_PARA, 0);
        break;

    case SEND_REQU_MACINE_ID :
        datif_sendIOrequest(0, CMD2DC_RDBK_MACH_ID, 0);
        break;


    }

}


void T_datif::sendHighLevel(uint16_t nxtHLCmd)
{
    switch (nxtHLCmd)
    {

    case SENDDIRCMD_SHUTOPENBYTIME:
        // void datif_sendIOrequest(uint16_t WRcmd, uint16_t RDcmd, uint8_t nrOfWrData);
        qDebug() << "open by time " << datif_OutCmdpara1 << " "<< datif_OutCmdpara2;
        datif_sendIOrequest(CMD2DC_SHUTTER_OPEN3S, 0, 1);
        break;

    case SENDDIRCMD_SHUTOPENBYCOIN:
        qDebug() << "open by coin " << datif_OutCmdpara1 << " "<< datif_OutCmdpara2;
        datif_sendIOrequest(CMD2DC_SHUTTER_COIN, 0, 2);
        break;

    case SENDDIRCMD_ESCRO_TAKE:
        datif_sendIOrequest(CMD2DC_ESCR_TAKE, 0, 0);
        break;

    case SENDDIRCMD_ESCRO_GIVE:
        datif_sendIOrequest(CMD2DC_ESCR_RETURN, 0, 0);
        break;

    case SENDDIRCMD_MIF_ATBCREATE:
        datif_sendIOrequest(CMD2DC_ATB_CREATE, 0, 1);       // 0x2907
        break;



// yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy


    case SENDDIRCMD_MDB_SENDCMD:
        datif_sendIOrequest(CMD2DC_MDB_SENDCMD, 0, 1);
        break;

    case SENDDIRCMD_MDB_SNDMSG:
        datif_sendIOrequest(CMD2DC_MDB_SENDMSG, 0, 1);
        break;

    case SENDDIRCMD_EMP_SETT:
        //datif_sendIOrequest(CMD2DC_EMP_SET, 0, 1);
        datif_send64byteOutCmd(CMD2DC_EMP_SET,0,0);
        break;

    case SENDDIRCMD_EMP_POLL:
        datif_sendIOrequest(CMD2DC_EMP_STARTPOLL, 0, 1);
        break;

    case SENDDIRCMD_EMP_STARPPAY:
        datif_sendIOrequest(CMD2DC_EMP_STARTPAY, 0, 1);
        break;

    case SENDDIRCMD_EMP_STOPPAY:
        datif_sendIOrequest(CMD2DC_EMP_STOPPAY, 0, 1);
        break;

// yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy





    case SENDDIRCMD_PRN_SYS_CMD:
        datif_send8byteOutCmd(CMD2DC_PRI_SYS_CMD, 0);
        break;

    case SENDDIRCMD_PRN_ESC_CMD:
        datif_sendIOrequest(CMD2DC_PRI_ESC_CMD, 0, 4);
        break;

    case SENDDIRCMD_PRN_SETUP:
        // byte 0,1: speed   byte2: density    byte3: alignment    byte4: orientation
        datif_send64byteOutCmd(CMD2DC_PRI_SETUP, 0, 0);
        break;

    case SENDDIRCMD_PRN_MOVE:
        datif_sendIOrequest(CMD2DC_PRI_MOVE, 0, 2);
        break;

    case SENDDIRCMD_PRN_SETFONT:
        datif_sendIOrequest(CMD2DC_PRI_SETFONT, 0, 4);
        break;

    case SENDDIRCMD_PRN_SETLETT:
        datif_sendIOrequest(CMD2DC_PRI_SETLETTER, 0, 3);
        break;

    case SENDDIRCMD_PRN_CUT:
        datif_sendIOrequest(CMD2DC_PRI_CUT, 0, 1);
        break;

    case SENDDIRCMD_PRN_LF:
        datif_sendIOrequest(CMD2DC_PRI_LF, 0, 1);
        break;

    case SENDDIRCMD_PRN_FONTTAB:
        datif_sendIOrequest(CMD2DC_PRI_PRIFONTTABLE, 0, 0);
        break;

    case SENDDIRCMD_PRN_BC:
        datif_send64byteOutCmd(CMD2DC_PRI_BARCODE, 0, 0);
        break;

    case SENDDIRCMD_PRN_LOGO_FL:
        datif_sendIOrequest(CMD2DC_PRI_LOGOFROMFLASH, 0, 1);
        break;

    case SENDDIRCMD_PRN_DOC:
        datif_send64byteOutCmd(CMD2DC_PRI_DOCUMENT_NR, datif_OutCmdpara1, 0);
        break;

    case SENDDIRCMD_PRN_QR:
        datif_sendIOrequest(CMD2DC_PRI_QR_CODE, 0, 0);
        break;


    case SENDDIRCMD_PRN_CLEARDOC:
        datif_sendIOrequest(CMD2DC_PRI_CLEAR_DOC, 0, 1);
        break;


    case SENDDIRCMD_DEVICE_PARA:
        datif_send64byteOutCmd(CMD2DC_DEVICE_PARAM, 0, 0);
        break;


    case SENDDIRCMD_MACHINE_ID:
        datif_send64byteOutCmd(CMD2DC_SEND_MACH_ID, 0, 0);
        break;

    }

}



// ##############################################################################
// ##############################################################################
// ##############################################################################


// sende alle Befehle um die Eingangsdaten abzufragen der Reihe nach:
char T_datif::sendINrequestsAutomatic(void)
{

    switch (dif_scanStep)
    {
        // first 5 items are performed only one time after startup as this data never change
        qDebug() << "send IN request " << dif_scanStep;

        case 0:
            datif_sendIOrequest(0, CMD2DC_GetSerialConfig, 0);
            break;

        case 1:
            datif_sendIOrequest(0, CMD2DC_RdBkHWversion, 0);
            break;

        case 2:
            datif_sendIOrequest(0, CMD2DC_RdBkSWversion, 0);
            break;

        case 3:
            datif_sendIOrequest(0, CMD2DC_RdBkDCstate, 0);
            break;

        case 4:
            datif_sendIOrequest(0, CMD2DC_RdBkUID, 0);
            break;

        // repeat cyclic from here:
        case 5:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 6:
            datif_sendIOrequest(0, CMD2DC_RdBkTime, 0);
            break;

        case 7:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 8:
            datif_sendIOrequest(0, CMD2DC_RdBkAnalog, 0);
            break;

        case 9:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 10:
            datif_sendIOrequest(0, CMD2DC_RdBkAllOutputs, 0);
            break;

        case 11:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 12:
            if (indat_isPrinterOn())
                datif_sendIOrequest(0, CMD2DC_RdBk_AllPrnData, 0);            
            //  datif_sendIOrequest(0, CMD2DC_RdBk_PrnState, 0);
            break;

        case 13:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 14:
            if (indat_isMifareOn())
            {
                datif_sendIOrequest(0, CMD2DC_RdBk_MifReader, 0);
                //qDebug()<<"requesting MIF reader state";
            }
                break;

        case 15:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 16:
            if (indat_isMifareOn())
            {

                datif_sendIOrequest(0, CMD2DC_RdBk_Mifcard, 1);
                //qDebug()<<"requesting mif card data";
                if (++RDBLKNR>11)
                    RDBLKNR=0;
                datif_OutCmdpara1=RDBLKNR;

            } break;

        case 17:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 18:
            if (indat_isMdbOn())
                datif_sendIOrequest(0, CMD2DC_MDB_GET_STATE, 0);
            else
                dif_scanStep=24;
            break;

        case 19:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 20:
            //if (indat_isMdbOn())
                datif_sendIOrequest(0, CMD2DC_MDB_GETRESP, 0);

            break;

        case 21:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 22:
            //if (indat_isMdbOn())    // kein eigener Schalter für EMP
                datif_sendIOrequest(0, CMD2DC_EMP_GET_ALL, 0);
            break;

        case 23:
            datif_sendIOrequest(0, CMD2DC_GetAllInputs, 0);
            break;

        case 24:
            //if (indat_isMdbOn())    // kein eigener Schalter für EMP
                datif_sendIOrequest(0, CMD2DC_EMP_GOTCOIN, 0);
            break;

    }

    dif_scanStep++;
    if (dif_scanStep>=25)
        dif_scanStep=5;

return 0;

}


char T_datif::isPortOpen(void)
{
    return (myDCIF->isPortOpen());
}


// ##############################################################################
// ##############################################################################
// ##############################################################################
//              Empfangsdaten einsortieren
// ----------------------------------------------------------------------------------------------



//void T_datif::StoredRecData(bool neu)
void T_datif::StoredRecData()
{
    //qDebug() << "StoreRecData called";
    // call automatically by T_prot
    //if (myDCIF->ifDataReceived())
        //if (neu)
    {
        // just a wrapper as we need a retval
        // "neu" is the same as "INdataValid"
        loadRecDataFromFrame();
    }
}

char T_datif::loadRecDataFromFrame()
{
    // necessary data in T_prot:
    uint16_t readSource, uitmp;
    uint16_t readAddress;
    uint8_t  pp;
    uint8_t  SlaveAdr, RdDleng;
    uint8_t  receivedData[FRAME_DATALEN];
    QString  localStr;
    uint32_t ultmp;
    int portNr;
    bool ret;
    uint8_t maxai;

    ret=myDCIF->getReceivedInData(&SlaveAdr, &readSource, &readAddress,  &RdDleng, receivedData);
        // retval: data valid, only one time true, true if CommandState OK and readState OK
    gpi_storeResultOfLastRequest(ret);
    if (ret==false)
    {
        qDebug() << "datif: rec data not valid";
        return 0;
    }

    gpi_storeRecPayLoad(RdDleng, receivedData); //  save for host (user of hwapi)

//    qDebug() << "\n +++datif: got valid data, rdsrc:" << readSource << "  rdadd:" << readAddress
//             << "  rdlen:" << RdDleng;
//    qDebug("datif_recData: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
//            receivedData[0], receivedData[1], receivedData[2], receivedData[3],
//            receivedData[4], receivedData[5], receivedData[6], receivedData[7],
//            receivedData[8], receivedData[9], receivedData[10], receivedData[11],
//            receivedData[12], receivedData[13], receivedData[14], receivedData[15]);

    // readSource: reflects the READ Command if possible
    // readAddress: reflects the requested read/write address if slave could perform
    // lastWakeSrc: if Slave wakes master, this ist the reason for it (e.g. button pressed)
    // RdDataLength: number of bytes in receivedData

    //firstDB=receivedData[0];        // just shorter, is used very often
    //scndDB=receivedData[1];
    //thrdDB=receivedData[2];

    localStr.clear();

//    receivedData[0]='a';
//    receivedData[1]='B';
//    receivedData[2]='1';
//    receivedData[3]='-';
//    for (int ii=0; ii<4; ii++)            haut hin   :)

    for (int ii=0; ii<RdDleng; ii++)
    {
        localStr.append(receivedData[ii]);
    }

    //qDebug() << "got HW version: " << localStr;
    switch (readSource) // = request command
    {
        case CMD2DC_TestSerial:    // serial line check
            ret=verifyLineTestresponse(RdDleng, receivedData);
            gpi_storeResult_serialTestOK(ret);
            if (ret==true)
                gpi_setTxt4datifLine("correct");
            else
                gpi_setTxt4datifLine("false");
            break;

        case CMD2DC_GetSerialConfig: // get slave's RS232 config
            gpi_storeSlaveSerParams(receivedData[0], receivedData[1], receivedData[2], receivedData[3]);
            //gpi_storeSlaveBusAddr(SlaveAdr);
            break;

        case CMD2DC_RdBkHWversion:
            qDebug() << "got HW version: " << localStr;
            gpi_storeGenerals(0, localStr);
                // 0=HW   1=SW  2=State
            //gpi_storeSlaveBusAddr(SlaveAdr);
            break;

        case CMD2DC_RdBkSWversion:
            qDebug() << "got SW version: " << localStr;
            gpi_storeGenerals(1, localStr);
            break;

        case CMD2DC_RdBkDCstate:
            gpi_storeGenerals(2, localStr);
                // 0=HW   1=SW  2=State
            break;

        case CMD2DC_RdBkUID: // getback UID in DB0....7
            gpi_storeUID(receivedData);
            break;

        case CMD2DC_RdBkTime: // slave returned RTC time and date
            gpi_backupTime(receivedData, RdDleng);   // function reads 20 bytes from the buffer
            break;

        case CMD2DC_RdBkAnalog: // get ALL AIs 0...3, 4byte + 2byte each

        //            DB0...3: Value0=Temperature
        //            DB4...7: Value1=Voltage
        //            ...DB31 for Value7
        //            DB32,33: ADC0 input value 0...1023
        //            DB34,35: ADC1 input value 0...1023
        //            DB36,37: ADC2 input value 0...1023
        //            …
        //            DB46,47: ADC7 input value 0...1023
            pp=0;
            ultmp=uchar2uint(receivedData[1], receivedData[0]);
            gpi_storeMeasureValue(0, ultmp);
            pp=1;
            ultmp=uchar2uint(receivedData[5], receivedData[4]);
            gpi_storeMeasureValue(1, ultmp);

            pp=32;
            maxai=gpi_getMaxNrAIs();
            for (portNr=0; portNr<maxai; portNr++)
            {
                uitmp=uchar2uint(receivedData[pp+1], receivedData[pp]);
                gpi_storeAIs(uint8_t(portNr), uitmp);


                pp+=2;
            }
            break;

        case CMD2DC_GetAllInputs:
        /*
            D0: upper door  D1: low door  D2:vault door
            D3: cash box    D4: bill box in
            D5: bit 0: upper lockbar up   bit1:down
            D6: bit 0: lower lockbar up   bit1:down

            D7: DI_contact Power Is On

            D8: OptoIn 1,2
            D9: Aux0...5
            D10:Wake from ptu
            D11: DI Wake From Mdb
            D12: Ready from printer
            D13: Coin Shutter Input
            D14: CoinEscrow switch
            D15: Mifare IN
            D16: Modem_Wake In

            D18: DI Mif Pwr is on
            D19: DI MDB_TxD_rdBack
            D20: DI Aux Pwr is on
            D21: DI GSM Pwr from PO2 is ON
            D22:  DI Credit Pwr from PO2 is on
                    =DI RdBack Credit Wake
            D23:  DI Printer Pwr from PO2 is on
            D24:  DI MDB Pwr from PO2 is on
            new since 7.10.21:
            D25: coin reject switch  1=home position
            D26: Paper-Low-Sensor Input (printer must be ON!)

         */
            gpi_storeDI_doorSwitches(receivedData[0], receivedData[1], receivedData[2]);
            gpi_storeDI_vaultSwitches(receivedData[3], receivedData[4]);
            gpi_storeDI_lockSwitches(receivedData[5], receivedData[6]);

            gpi_storeDI_contactPowerIsOn(receivedData[7]);
            gpi_storeDI_optos(receivedData[8]);
            gpi_storeDI_auxIn(receivedData[9]);
            gpi_storeDI_ptuWake(receivedData[10]);
            gpi_storeDI_readbackMdbTxD(receivedData[11]);
            gpi_storeDI_prnReady(receivedData[12]);
            gpi_storeDI_CoinAttach(receivedData[13]);
            gpi_storeDI_CoinEscrow(receivedData[14]);
            gpi_storeDI_mifareCardTapped(receivedData[15]);
            gpi_storeDI_modemWake(receivedData[16]);    // gibt's gar nicht!
            gpi_storeDI_mbdWake(receivedData[17]);
            gpi_storeDI_MifarePowerIsOn(receivedData[18]);
            gpi_storeDI_readbackMdbTxD(receivedData[19]);
            gpi_storeDI_AuxPowerIsOn(receivedData[20]);
            gpi_storeDI_GsmPowerIsOn(receivedData[21]);
            gpi_storeDI_CreditPowerIsOn(receivedData[22]);
            gpi_storeDI_PrinterPowerIsOn(receivedData[23]);
            gpi_storeDI_MdbPowerIsOn(receivedData[24]);

            gpi_storeDI_rejMot_home(receivedData[25]);
            gpi_storeDI_paperLow(receivedData[26]);

        break;

        case CMD2DC_RdBkAllOutputs:

            /*
            D0 = mdb Rx-test out

            D1: motor outputs bit0: upper lock forw bit 1 backw
                                          Bit2: lowLock forw  bit3: LL backw

            D5: serial drv on/off, Serial mux1, Serial mux2
            D6: Leds, Fan,
            D7: Siren and relay
            D8: PtuWakeOut
            D9: Power Aux/Barcode
            D12: Coin shutter output, input-test-output
            D13: CoinEscrow Outputs bit0=return  bit1=take
            D14: printer power is switched on/off
            */

            gpi_storeDO_mdbRxTst(receivedData[0]);
            gpi_storeDO_motorOutputs(receivedData[1]);
            gpi_storeDO_serialSwitch(receivedData[5]);
            gpi_storeDO_ledsAndFan(receivedData[6]);
            gpi_storeDO_sirenAndRelay(receivedData[7]);
            gpi_storeDO_ptuWake(receivedData[8]);
            gpi_storeDO_auxPower(receivedData[9]);
            gpi_storeDO_coinShutter(receivedData[12]);
            gpi_storeDO_coinEscrow(receivedData[13]);
            gpi_storeDO_printerPwrOn(receivedData[14]);
            break;


    case CMD2DC_RdBk_MifReader:
        // get reader status and card type

        gpi_storeMifReaderStateAndCardType(receivedData);
        break;

    case CMD2DC_RdBk_Mifcard:
        // one block of data (64byte) comes in
        // blkNr 0...11 in "Addr"
        gpi_storeMifCardData(readAddress, receivedData);

        break;

    case CMD2DC_RdBk_AtbCardType:
        // DC reports the type of mif-card (valid ATB card?)

        break;



    case CMD2DC_RdBk_PrnState:      // 0x2A02

        // byte 1...6 come right from printer, see printer manual
        // byte 0 = all important infos:
        // 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

        gpi_storePrinterState(receivedData);    // derzeit 10bytes      ( 0x2A02)
        break;

    case CMD2DC_RdBk_PrnFonts:      //  0x2A12
        //D0: font table/type
        //D1: size
        //D2: height
        //D3: width
        //D4: bold
        //D5: invers
        //D6: underlined
        //D7: density
        //D8: speed
        //D9: Alignment
        gpi_storePrinterFonts(receivedData);    // derzeit 10bytes
        break;

    case CMD2DC_RdBk_AllPrnData:      // 0x2A40
        gpi_storePrinterState(receivedData);    // derzeit 10bytes      ( 0x2A02)
        gpi_storePrinterFonts(&receivedData[10]);    // derzeit 10bytes
        /*
        qDebug()<<"printer fonts stored " <<receivedData[0]<<" "<<receivedData[1]<<" " \
               <<receivedData[2]<<" "<<receivedData[3]<<" " \
              <<receivedData[4]<<" "<<receivedData[5]<<" " \
             <<receivedData[6]<<" "<<receivedData[10]<<" " \
            <<receivedData[11]<<" "<<receivedData[18]<<" " \
           <<receivedData[19]<<" "<<receivedData[20]<<" ";
        */
        break;

    case CMD2DC_MDB_GET_STATE:
        // DB0: mdb_bus_ready (switched on)
        // DB1: rdBackV12devicePower
        // DB2: rdBackV5busPwr
        gpi_storeMdbState(receivedData[0],receivedData[1],receivedData[2]);
        break;

    case CMD2DC_MDB_GETRESP:
        // 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: lastResult   1=got ACK  2=got 3xNAK  3=no or bad response    4:got Data (after ACK)
        // DB3: nr of received (payload) data bytes (apart from ACK, can be 0....34)
        // DB4...DB39: rec.data (payload)
        gpi_storeMdbResponse(receivedData[2]+3, receivedData);
        break;

    case CMD2DC_EMP_GET_ALL:
        //qDebug() << "got emp parameters "<< receivedData[1];
        gpi_storeEmpSettings(64, receivedData);
        break;

    case CMD2DC_EMP_GOTCOIN:
        // DB0: 1=coin 0xFF=error 0=got nothing
        // DB1: last coin signal (value / scale)
        // DB2,3: last coin value
        // DB4: lastError from Emp
        gpi_storeEmpCoinSignal(receivedData[0], &receivedData[1]);
        break;

    case CMD2DC_RDBK_DEV_PARA:
        gpi_storeDeviceSettings(RdDleng, receivedData);
        break;

    case CMD2DC_RDBK_MACH_ID:
        gpi_storeMachineIDsettings(RdDleng, receivedData);
        break;
    }

    return 0;
}


// subs:

// ----------------------------------------------------------------------------------------------
//                         erstelle WRITE Datensätze
// ----------------------------------------------------------------------------------------------

// always use this three functions to send data:
//void myDCIF->setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t  WrDatLen, uint8_t *data);
//void myDCIF->setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr);
//void myDCIF->setUserWriteData(uint16_t WriteCmd);
//void myDCIF->setUserWrite1DB (uint16_t WriteCmd, uint16_t WrAddr, uint8_t val);
//void myDCIF->setUserWrite2DB (uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, uint8_t val1);

//void myDCIF->setUserReadData( uint16_t ReadCmd,  uint16_t RdAddr, uint16_t reserv);
//void myDCIF->setUserReadData( uint16_t ReadCmd,  uint16_t RdAddr);
//void myDCIF->setUserReadData( uint16_t ReadCmd);

//void myDCIF->sendUserData(uint16_t slaveAdr);

void T_datif::datif_startSending(void)
{
    // egal ob WR und RD Daten gesetzt wurden
    myDCIF->sendUserData(selectedSlaveAddr);   // starte Sendung
    gpi_startNewRequest();
}

// allgemeine Schreib/Lese-Funktion
void T_datif::datif_sendIOrequest(uint16_t WRcmd, uint16_t RDcmd, uint8_t nrOfWrData)
{
    uint8_t data[6];

    if (nrOfWrData>4) nrOfWrData=0;
    tslib_strclr(data,0,6);

    if (nrOfWrData>0)
        data[0]=datif_OutCmdpara1;
    if (nrOfWrData>1)
        data[1]=datif_OutCmdpara2;
    if (nrOfWrData>2)
        data[2]=datif_OutCmdpara3;
    if (nrOfWrData>3)
        data[3]=datif_OutCmdpara3;
    data[4]=0; data[5]=0;

    myDCIF->setUserWriteData(WRcmd, 0, nrOfWrData, data);
    myDCIF->setUserReadData(RDcmd);
    myDCIF->sendUserData(selectedSlaveAddr);
}

void T_datif::datif_send8byteOutCmd(uint16_t WRcmd, uint16_t RDcmd)
{
    uint8_t data[10];
    uint16_t uitmp;
    uint32_t ultmp;

    tslib_strclr(data,0,10);    // 8 used

    data[0]=datif_OutCmdpara1;
    data[1]=datif_OutCmdpara2;
    uitmp=datif_OutCmdpara5;
    ultmp=datif_OutCmdpara6;

    data[2]=uint8_t(uitmp);
    uitmp>>=8;
    data[3]=uint8_t(uitmp);

    data[4]=uint8_t(ultmp);
    ultmp>>=8;
    data[5]=uint8_t(ultmp);
    ultmp>>=8;
    data[6]=uint8_t(ultmp);
    ultmp>>=8;
    data[7]=uint8_t(ultmp);

    data[8]=0; data[9]=0;

    myDCIF->setUserWriteData(WRcmd, 0, 8, data);
    myDCIF->setUserReadData(RDcmd);
    myDCIF->sendUserData(selectedSlaveAddr);
}


bool T_datif::verifyLineTestresponse(uint8_t RdDlen, uint8_t *receivedData)
{
    if (RdDlen !=16)
        return false;
    QString myStr;
    myStr.clear();
    myStr.append("< Slave Response");

    for (int nn=0; nn<16; nn++)
        if (myStr[nn] !=receivedData[nn])
            return false;
    return true;
}


// RTC ----------------------------------------------------------------------

void T_datif::datif_OUT_setTime(void)
{
    // send PC time/date to slave
    //uint8_t hour,min, sec, year, month, day, dayOfWeek,
    //uint8_t dayOfYear, isLeap, weekOfYear;
    uint8_t buff[15];
    uint16_t uitmp;

    QTime *systTime = new QTime();
    //    qDebug()  << systTime->currentTime().hour()   <<":"
    //              << systTime->currentTime().minute() <<":"
    //              << systTime->currentTime().second();

    buff[0]=uint8_t(systTime->currentTime().hour());
    buff[1]=uint8_t(systTime->currentTime().minute());
    buff[2]=uint8_t(systTime->currentTime().second());


    QDate *systDate = new QDate();
    systDate->currentDate();

    uitmp= uint16_t(systDate->currentDate().year());
    buff[3]=uint8_t(uitmp);
    buff[4]=uint8_t(uitmp>>8);

    buff[5]=uint8_t(systDate->currentDate().month());
    buff[6]=uint8_t(systDate->currentDate().day());
    buff[7]=uint8_t(systDate->currentDate().dayOfWeek());

//    uitmp=systDate->currentDate().dayOfYear();
//    buff[8]=uint8_t(uitmp);
//    buff[9]=uint8_t(uitmp>>8);

//    buff[10]=uint8_t(systDate->currentDate().isLeapYear(systDate->currentDate().year()));
//    buff[11]=uint8_t(systDate->currentDate().weekNumber());   //weekOfYear
//    buff[12]=0;

    //myDCIF->setUserWriteData(0x1310,0,8, buff);
    myDCIF->setUserWriteData(CMD2DC_sendTime,0,8, buff);
    myDCIF->setUserReadData(0);
    myDCIF->sendUserData(selectedSlaveAddr);       // jetzt wegsckicken

}

// 0x2311: set time to RTC
// 0x2312: set date to RTC

uint8_t T_datif::datif_OUT_SendRandomData(uint8_t *buf, uint8_t Length)
{
    uint8_t    len=Length;

    myDCIF->setBLsendData(len, buf );
    myDCIF->setUserReadData(0);
    myDCIF->sendUserData(selectedSlaveAddr);
    return 0;

}




void T_datif::datif_send64byteOutCmd(uint16_t WRcmd, uint16_t addr, uint16_t RDcmd)
{
    // sending length is already defined by stored data
    // not batched! don't use twice within 100ms
    uint8_t LL;
    uint8_t data[66];

    tslib_strclr(data,0,66);    // up to 64 used
    gpi_restore64ByteSendData(&LL, data);   // LL bytes was stored to be sent
    myDCIF->setUserWriteData(WRcmd, addr, LL, data);
    myDCIF->setUserReadData(RDcmd);
    myDCIF->sendUserData(selectedSlaveAddr);

}

void T_datif::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

    uint16_t aa=0;

    aa=docNr;
    aa<<=8;
    aa |=blockNr;
    myDCIF->setUserWriteData(WRcmd, aa, 64, data64);
    myDCIF->setUserReadData(0);
    myDCIF->sendUserData(selectedSlaveAddr);

}