//#include <stdint.h>
#include "dcBL.h"
#include <QDebug>
//#include "tabFw.h"
#include "sendWRcmd.h"


// File sits "behind" the HWapi and in front of "PI", so all necessary Bootloader functions can be called from HWapi



uint16_t ucharTOuint(uint8_t Highbyte, uint8_t Lowbyte)
{
    uint16_t uitmp;
    uitmp=0;
    uitmp |= uint8_t(Highbyte);
    uitmp<<=8;
    uitmp |= uint8_t(Lowbyte);
    return uitmp;
}

#define GETLOWBYTE      0
#define GETHIGHBYTE     1

uint8_t uintTOuchar(uint16_t uival, uint8_t getHighB)
{
    // getHighB: low=GetLowByte
    uint16_t uitmp=uival;
    if (getHighB==0)
        return uint8_t(uitmp);
    uitmp>>=8;
    return uint8_t(uitmp);

}

//#define GETLOWBYTE      0
//#define GETHIGHBYTE     1
#define GETMIDLOWBYTE      2
#define GETMIDHIGHBYTE     3

uint8_t ulongTOuchar(uint32_t ulval, uint8_t whichByte)
{

    uint32_t ultmp=ulval;
    if (whichByte==GETLOWBYTE)
        return uint8_t(ultmp);
    ultmp>>=8;
    if (whichByte==GETMIDLOWBYTE)
        return uint8_t(ultmp);
    ultmp>>=8;
    if (whichByte==GETMIDHIGHBYTE)
        return uint8_t(ultmp);
    ultmp>>=8;
    if (whichByte==GETHIGHBYTE)
        return uint8_t(ultmp);
    return 0;
}

void strclr(uint8_t *buf, uint8_t clrsign, uint8_t len)
{
    uint16_t nn;

    for (nn=0; nn<len; nn++)
        buf[nn]=clrsign;

}

// -----------------------------------------------------------------------------------------------
// communication with this particular DeviceController's Bootloader ---------------------------------
// -----------------------------------------------------------------------------------------------

uint16_t dcBL_calcCrcCcitt(uint32_t BufLength, uint8_t *buf)
{
    // CRC16 / CCITT-FALSE
    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;

}


#define     SEND_STX    2
#define     SEND_ETX    3
#define     SEND_ESC    0x1B

static uint8_t dcBL_LastBLcmd;   // stored the last sent cmd in order to analys response
                            // cmd echo'ed: error       cmd or'ed with 0x80: OK

uint8_t dcBL_prepareDC_BLcmd(uint8_t Cmd, uint8_t SendDataLength, uint8_t *sendData, uint8_t *outBuf)
{
    // make BL protocol, retval = outbuf length (5...133)
    // bring data in correct form: start always with 0x02   finish with 0x03 and append checksum
    // 0x02 Cmd < ...sendData ..>  CRC  CRC 0x03
    // Data length = 0...64
    // special conversion: if data contain 2 or 3 (STX, ETX) then write two bytes:  0x1B (=ESC) and data|0x80
    // so maxlength = 5 + 2 x 64 (if all data are 2 or 3)  without 2,3: maxlength = 5 + 64

    // 26.01.2021: noch einen Fehler gefunden: die "special conversion" fehlt bei der angehaengten Checksumme!!!

    uint8_t  myBuf[140], pp=0, HB, LB;
    uint8_t  crcBuf[140], mm=0;
    uint8_t  nn, uctmp, currLen=0;
    uint16_t calcCrc;

    strclr(myBuf, 0, 140);
    strclr(crcBuf, 0, 140); // extra Puffer because STX must not be caculated

    myBuf[pp++]=SEND_STX;
    myBuf[pp++]=Cmd;
    crcBuf[mm++]=Cmd;
    dcBL_LastBLcmd=Cmd;

    // append data:
    for (nn=0; nn<SendDataLength; nn++)
    {
        uctmp=sendData[nn];
        if (uctmp==SEND_STX || uctmp==SEND_ETX || uctmp==SEND_ESC)       // ESC, STX or ETX in payload
        {
            myBuf[pp++]=SEND_ESC;
            //crcBuf[mm++]=SEND_ESC;        // so wäre die Berechnung NACH der Umwandlung, ist aber falsch
            myBuf[pp++]=uctmp | 0x80;
            //crcBuf[mm++]=uctmp | 0x80;    // so wäre die Berechnung NACH der Umwandlung, ist aber falsch
            crcBuf[mm++]=uctmp;         // crc VOR umwandlung berechnen!
        } else
        {
            myBuf[pp++]=uctmp;
            crcBuf[mm++]=uctmp;
        }
    }
    currLen=mm;

    // calc crc: (over cmd and data, without STX)
    //qDebug() << "calc crc: anzahl  " <<mm;
    //qDebug() << crcBuf;
    calcCrc=dcBL_calcCrcCcitt(uint32_t(currLen), crcBuf);
    //qDebug() << calcCrc;

//    myBuf[pp++]=uintTOuchar(calcCrc, GETHIGHBYTE);
//    myBuf[pp++]=uintTOuchar(calcCrc, GETLOWBYTE);
//    myBuf[pp++]=SEND_ETX;

    // 26.01.2021: die "special conversion" auch für die angehaengte Checksumme:
    HB=uintTOuchar(calcCrc, GETHIGHBYTE);
    LB=uintTOuchar(calcCrc, GETLOWBYTE);
    uctmp=HB;
    if (uctmp==SEND_STX || uctmp==SEND_ETX || uctmp==SEND_ESC)       // ESC, STX or ETX in payload
    {
        myBuf[pp++]=SEND_ESC;
        myBuf[pp++]=uctmp | 0x80;
        crcBuf[mm++]=uctmp;
    } else
    {
        myBuf[pp++]=uctmp;
        crcBuf[mm++]=uctmp;
    }
    uctmp=LB;
    if (uctmp==SEND_STX || uctmp==SEND_ETX || uctmp==SEND_ESC)       // ESC, STX or ETX in payload
    {
        myBuf[pp++]=SEND_ESC;
        myBuf[pp++]=uctmp | 0x80;
        crcBuf[mm++]=uctmp;
    } else
    {
        myBuf[pp++]=uctmp;
        crcBuf[mm++]=uctmp;
    }
    myBuf[pp++]=SEND_ETX;

    currLen=pp;

    for (nn=0; nn<currLen; nn++)
        outBuf[nn]=myBuf[nn];

    if (outBuf[currLen-1] !=3)
    {
        qDebug()<<"protocol error no ETX, len="<< currLen << " data: " << myBuf;
    }
    return currLen;
}

// some special commands (right out of bootloader manual)
uint8_t dcBL_readBLversion(uint8_t *sendData)
{
    // minimum size of sendData-buffer: 5byte  retval: length
    uint8_t myBuf[2];
    strclr(myBuf, 0, 2);
    return dcBL_prepareDC_BLcmd(0x11, 0, myBuf, sendData);
}

uint8_t dcBL_readFWversion(uint8_t *sendData)
{
    // minimum size of sendData-buffer: 5byte  retval: length
    uint8_t myBuf[2];
    strclr(myBuf, 0, 2);
    return dcBL_prepareDC_BLcmd(0x12, 0, myBuf, sendData);
}

uint8_t dcBL_exitBL(uint8_t *sendData)
{
    // minimum size of sendData-buffer: 5byte  retval: length
    uint8_t myBuf[2];
    strclr(myBuf, 0, 2);
    return dcBL_prepareDC_BLcmd(0x18, 0, myBuf, sendData);
}

uint8_t dcBL_sendFlashStartAddr2BL(uint32_t startAddr, uint8_t *sendData)
{
    // minimum size of sendData-buffer: 13byte    retval: length (9...13)
    uint8_t myBuf[5];

    myBuf[0]=ulongTOuchar(startAddr, GETHIGHBYTE);
    myBuf[1]=ulongTOuchar(startAddr, GETMIDHIGHBYTE);
    myBuf[2]=ulongTOuchar(startAddr, GETMIDLOWBYTE);
    myBuf[3]=ulongTOuchar(startAddr, GETLOWBYTE);
    myBuf[4]=0;


qDebug()<<"dcBL_sendFlashStartAddr2BL "<<myBuf[0]<<" "<<myBuf[1]<<" "<<myBuf[2]<<" "<<myBuf[3];


    return dcBL_prepareDC_BLcmd(0x21, 4, myBuf, sendData);
}

uint8_t dcBL_writeLastPage(uint8_t *sendData)
{
    // return the necessary command to tell the BL "finish writing" =write last page even if not full
    // minimum size of sendData-buffer: 5byte  retval: length
    uint8_t myBuf[2],ret;
    strclr(myBuf, 0, 2);
    ret=dcBL_prepareDC_BLcmd(0x22, 0, myBuf, sendData);

qDebug()<<"dcBL just sending last block command, ret: "<<ret<<" "<<sendData[0]
    <<" "<<sendData[1]<<" "<<sendData[2]<<" "<<sendData[3]<<" "<<sendData[4]
    <<" "<<sendData[5]<<" "<<sendData[6]<<" "<<sendData[7];

        return ret;
}

uint8_t dcBL_restartDC(uint8_t *sendData)
{
    // minimum size of sendData-buffer: 20 byte  retval: length

    // send this data block in decimal:  2 81 67 34 85 91 45 52 66 77 88 210 211 3
    uint8_t nn=0;
    sendData[nn++]=2;
    sendData[nn++]=81;
    sendData[nn++]=67;
    sendData[nn++]=34;
    sendData[nn++]=85;
    sendData[nn++]=91;
    sendData[nn++]=45;
    sendData[nn++]=52;
    sendData[nn++]=66;
    sendData[nn++]=77;
    sendData[nn++]=88;
    sendData[nn++]=210;
    sendData[nn++]=211;
    sendData[nn++]=3;
    sendData[nn++]=0;
    sendData[nn++]=0;
    return nn;
}

uint8_t dcBL_activatBootloader(uint8_t *sendData)
{
    // minimum size of sendData-buffer: 20 byte  retval: length
    uint8_t nn=0;

    //sendData[nn++]='U';  nötig??
    sendData[nn++]='U';
    sendData[nn++]='U';
    sendData[nn++]='U';
    sendData[nn++]='U';
    sendData[nn++]='U';

    sendData[nn++]=2;
    sendData[nn++]='c';
    sendData[nn++]='4';
    sendData[nn++]='5';
    sendData[nn++]='b';
    sendData[nn++]='3';
    sendData[nn++]=3;

    sendData[nn++]='U';
    sendData[nn++]='U';
    sendData[nn++]='U';
    sendData[nn++]='U';
    sendData[nn++]='U';
    sendData[nn++]=0;
    return nn;
}

// -----------------------------------------------------------------------------------------------

uint8_t dcBL_getResponse(uint8_t *respBuff)
{
    // retval: nr of received bytes
    uint8_t recLen=epi_getRawRecLength();
    if (recLen>0 && recLen<150)
    {
        epi_getRawReceivedData(respBuff);
        epi_clrRawReceivedString();
        //dcBL_writeText("dcBL gotResponse");

    }

    return recLen;
}

#define noReceive       0
#define ISWRONG         1
#define ISOK            10

uint8_t dcBL_ChkResponse()
{
    // retval: 0: no response (by now)
    // 1...5: Error, repeat
    // 10: OK, next...
    uint8_t buf[152], recLen;

    memset(buf,0,152);
    recLen=dcBL_getResponse(buf);
    if (recLen==0)
        return 0;    // no response by now

    if ((buf[0]==2) && (buf[1]==(dcBL_LastBLcmd | 0x80) ) )
        return 10;    //  OK

    // 27.01.21: Problem aufgetaucht: Fehler nur bei CRC melden
    // -> block wiederholen. In den anderen Fällen NICHT wiederholen
    // sonst ist der block doppelt im Flash!!!!!!!!
    if (recLen>0 && recLen<5)
    {
        //dcBL_writeText("error wrong length");
        //exactError=1;
qDebug()<<" DCBL_chkResp wrong length ";
        return 10;    //  OK
    }
    if (buf[0] !=2)
    {
        //dcBL_writeText("error wrong start");
        //exactError=2;
qDebug()<<" DCBL_chkResp wrong start ";
        return 10;    //  OK
    }
    if (buf[0]==2 && buf[1]=='e' && buf[2]=='0' )
    {
        //dcBL_writeText("error wrong crc");
        //exactError=3;   // DC reports wrong crc
qDebug()<<" DCBL_chkResp wrong crc";
        return 1;   // error
    }
    if (buf[0]==2 && buf[1]==dcBL_LastBLcmd )
    {
        //dcBL_writeText("error wrong cmd");
        //exactError=4;    // wrong cmd
qDebug()<<" DCBL_chkResp wrong cmd";
        return 10;    //  OK
    }
    return 1;   // error
}



uint8_t dcBL_sendSuccess(uint8_t lastCommand)
{
    // return val: 0: no response by now  1:error  10: OK

    uint8_t Indata[152], recLen;

    memset(Indata,0,152);
    recLen=dcBL_getResponse(Indata);
    if (recLen==0)
        return 0;    // no response by now

//    qDebug()<<"dcBL_sendSuccess: got BL data"<< recLen <<
//        Indata[0]<< Indata[1]<<  Indata[2]<<  Indata[3] << Indata[4]<< Indata[5]<< Indata[6]<< Indata[7];

    if (Indata[0]==2 && Indata[1]==(lastCommand | 0x80) )
        return 10;    //  OK
    return 1;
}

// -----------------------------------------------------------------------------------------------
// --- ATB Bin-File Handling ---------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------

/* example read file from HDD:
    uint8_t uit8tmp;
    QString stemp=" ";

    QFile file("/own/H2B/dc2.bin");
    //QFile file("/own/H2B/dc2.hex");   // laesst sich genauso oeffnen

    // TODO: use File-Open-Dialog-Box

    if (!file.exists())
    {
        qDebug()<<"file not exists";
    } else
    {
        if (!file.open(QIODevice::ReadOnly)  )
        {
            qDebug()<<"cannot open";
        } else
        {
            qDebug()<<"loading....";
            qDebug()<<"size: " << file.size() <<"\n";
            QByteArray myBin = file.readAll();

            // Kontrolle:
            int ii=0;
            do
            {
                uit8tmp=(uint8_t)myBin[ii++];
                //qDebug() << uit8tmp << " "; // Anzeige in dez
                stemp.setNum(uit8tmp,16);
                qDebug() << stemp << " ";   // Anzeige in hex

            } while (ii<100);
        }
    }

  */


// -------------------------------------------------------------------------

static QByteArray   dcBL_AtbBinFile;
static uint32_t     dcBL_fileSize;
static uint16_t     dcBL_nrOfBlocks;    // incl. last block
static uint16_t     dcBL_fileCrc;
static uint8_t      dcBL_myBuf[265000]; // same content like "dcBL_AtbBinFile" but bytewise
static uint8_t      dcBL_sizeLastBlk;


bool dcBL_importBinFile(QByteArray readBinFile, uint32_t fileSize, char withDispl)
{
    // copy file from QByteArray into local buffer for sending to DC
    // calculate size, nr_of_blocks and crc
    uint16_t uitmp;
    uint32_t ultmp;
    uint32_t LL;

    dcBL_AtbBinFile=readBinFile;
    dcBL_fileSize=fileSize;

    if (dcBL_fileSize>=265000)  // max bin file size for atmega
        return false;       // keep last file
    ultmp=dcBL_fileSize;
    ultmp %=64;
    uitmp=uint16_t(ultmp);
    ultmp=dcBL_fileSize;
    ultmp /=64;
    dcBL_nrOfBlocks=uint16_t(ultmp);
    if (uitmp>0)
        dcBL_nrOfBlocks++;    // letzter Block hat !=64 byte

    // type conversion for crc calc
    for (LL=0; LL<dcBL_fileSize; LL++)
        dcBL_myBuf[LL]=uint8_t(dcBL_AtbBinFile[LL]);
    dcBL_fileCrc=dcBL_calcCrcCcitt(LL, dcBL_myBuf);

    ultmp=dcBL_fileSize % 64;
    dcBL_sizeLastBlk = uint8_t(ultmp);
    qDebug()<<" got file with "<<dcBL_nrOfBlocks<<" blocks (64byte) and crc: "<<dcBL_fileCrc;

    return true;

    if (withDispl)
    {

    }

// hier nicht wie bisher bei der VMC um 14 Bytes nach oben schieben und Laenge/crc anhaengen,
//    weil man sonst den BL und das Win-tool auch aendern muesste

}

char dcBL_loadBinary(QString fileName)
{
    uint32_t fileLen;

    QFile file(fileName);
    if (!file.exists())
    {
        qDebug()<<"file dc2c4.bin does not exist";
        return 1;
    }
    if (!file.open(QIODevice::ReadOnly)  )
    {
        qDebug()<<"cannot open";
        return 1;
    }

    QByteArray myBin;

    myBin.clear();
    myBin = file.readAll();
    fileLen=uint32_t(file.size());
    qDebug()<<"loading dc2c4.bin binary with " << fileLen <<"bytes \n";

    dcBL_importBinFile(myBin, fileLen, 0);  //withDisplay);
    return 0;

}

char dcBL_loadBinSafe(QString fileName)
{
    // retval: true: file = OK
    // Problem: nach der BL Programmierung ist das flash sehr oft defekt (ganze Bereiche sind falsch)
    // die Übertragung ist CRC geschüzt, also bleibt die Vermutung das es am Einlesen des binfiles liegt.
    // --->also sicherstellen dass das Laden des Binfiles 100%ig in Ordnung ist.
    QByteArray BINFILECOPY1, BINFILECOPY2;
    uint32_t   BinFileCpyLen1, BinFileCpyLen2, LL;
    uint8_t    repeat=0, nn=0, stopp=0;

    do
    {
        //dcBL_writeText("loading 1st time:");
        //qDebug() <<"loading 1st time:";
        dcBL_loadBinary(fileName);
        // file jetzt in: "QByteArray dcBL_AtbBinFile" mit Laenge "uint32_t dcBL_fileSize"
        BINFILECOPY1=dcBL_AtbBinFile;
        BinFileCpyLen1=dcBL_fileSize;

        //dcBL_writeText("loading 2nd time:");
        //qDebug() <<"loading 2. time:";
        dcBL_loadBinary(fileName);
        // file jetzt in: "QByteArray dcBL_AtbBinFile" mit Laenge "uint32_t dcBL_fileSize"
        BINFILECOPY2=dcBL_AtbBinFile;
        BinFileCpyLen2=dcBL_fileSize;

        //dcBL_writeText("loading 3rd time:");
        //qDebug() <<"loading 3. time:";
        dcBL_loadBinary(fileName);
        // file jetzt in: "QByteArray dcBL_AtbBinFile" mit Laenge "uint32_t dcBL_fileSize"

        repeat=0;
        if (dcBL_fileSize !=BinFileCpyLen1 || dcBL_fileSize !=BinFileCpyLen2)
        {
            //dcBL_writeText("file length wrong");
            qDebug() <<"length error";

            repeat=1;       // load both again....
        }
        if (repeat==0)
        {
            LL=0; stopp=0;
            do
            {
                if (dcBL_AtbBinFile.at(LL) != BINFILECOPY1.at(LL))
                    stopp=1;
            } while((++LL < dcBL_fileSize) && !stopp);

            if (stopp)
            {
                repeat=1;       // load both again....
            }
        }

        if (repeat==0)
        {
            LL=0; stopp=0;
            //qDebug() <<"2. loop";
            do
            {
                if (dcBL_AtbBinFile[LL] != BINFILECOPY2[LL])
                    stopp=1;
            } while((++LL < dcBL_fileSize) && !stopp);

            if (stopp)
            {
                repeat=1;       // load both again....
            }
        }

    } while (++nn<3 && repeat);     // 3 trials


    if (repeat==0)
    {
        qDebug() << "read file successful after " << nn << " loops";
        return true;    // file OK
    }
    qDebug() << "read file with errors after " << nn << " loops";
    return false;       // error, could not load correctly

}

// -----------------------------------------------------------------------------------------------
// --- Send Bin-File to DC ---------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------
//static uint32_t     dcBL_fileSize;
//static uint16_t     dcBL_nrOfBlocks;
//static uint16_t     dcBL_fileCrc;

uint16_t dcBL_getNrOfBlocks(void)
{
    // size of the loaded bin file in 64byte blocks
    return dcBL_nrOfBlocks;
}

uint16_t dcBL_getFileCrc(void)
{
    // checksum of the loaded bin file
    return dcBL_fileCrc;
}

uint32_t dcBL_getFileSize(void)
{
    // length of the loaded bin file in byte
    return dcBL_fileSize;
}

uint8_t dcBL_getSizeOfLastBlock(void)
{
    uint32_t ultmp;
    ultmp=dcBL_fileSize % 64;
    return uint8_t(ultmp);
}

void dcBL_sendAddress(uint16_t blockNumber)
{
    // send start address, nr of 64byte-block, start with 0
    // will be sent only for folling block-numbers:
    // 0, 1024, 2048, 3072 and 4096, so basically every 64kByte
    uint32_t dcBL_BlkCtr=(uint32_t)blockNumber;
    uint8_t  len, buf[20];

    tslib_strclr(buf, 0, 20);
    if (blockNumber==0 || blockNumber==1024 || blockNumber==2048 || blockNumber==3072 || blockNumber==4096)
    {
        dcBL_BlkCtr*=64;
        len=dcBL_sendFlashStartAddr2BL(dcBL_BlkCtr, buf);   // make command string

//qDebug()<<"dcBL_bl_sendAddress "<<buf[0]<<" "<<buf[1]<<" "<<buf[2]<<" "<<buf[3]<<" "
//         <<buf[4]<<" "<<buf[5]<<" "<<buf[6]<<" ";

        sendWRcmd_setSendBlock160(len, buf);        // send command to BL
    }
}


uint8_t dcBL_getFileBlock(uint16_t blockPointer, uint8_t *buf)
{
    // blockPointer=0....4095
    uint32_t addr, LL, lang;  //, BL;
    uint8_t  val;

    addr=uint32_t(blockPointer);    
    addr<<=6;   // *64  =Start address
    lang=dcBL_AtbBinFile.length();

    for (LL=0; LL<64; LL++)
    {
        if (addr<lang)
            val=uint8_t(dcBL_AtbBinFile.at(addr));
        else
            val=0xFF;
        addr++;
        buf[LL]=val;
    }

    return 64;
}

static uint16_t block2beSentNow, blTimeOutCounter;
static uint8_t  blChainStep, blChainResult, blRepeatCounter;

bool dcBL_sendOneBlockCpl(uint16_t blockNumber)
{
    // call in loop from block number 0 upto < "dcBL_getNrOfBlocks()"
    // but after every call WAIT (!) for response "dcBL_getBlockResult()" !!!!

    // data will be sent to DC, if neccesary addr will be sent additionally
    // if neccesary sending will automatically repeat up to 3times

    if (blockNumber>4095)
        return false;
    block2beSentNow=blockNumber;
    blChainStep=1;
    blChainResult=0;
    blTimeOutCounter=0;
    blRepeatCounter=0;
    return true;
}

int8_t dcBL_getBlockResult(void)
{
    // after every "dcBL_sendOneBlock()" call this until response
    // retval  0: wait   1: OK, blk was sent    2: OK, transfer complete
    //         3: error despite repeating, cancel. probably bin file corrupted
    //      Max duration: 3x no response (BL not OK) = 900ms
    return blChainResult;

}


char dcBL_cycle(void)
{
    // to be called cyclic every 100ms
    uint8_t buf[70], sendBuf[160], ret, sendLen;

    if (blChainStep==1)
    {
        // start, check if addr necessary
        if (block2beSentNow==0 || block2beSentNow==1024 || block2beSentNow==2048
                               || block2beSentNow==3072 || block2beSentNow==4096 )
        {

            dcBL_sendAddress(block2beSentNow);
            blChainStep++;
            //qDebug()<<"dcBL_cycle sending address and wait for response";
            return 0;   // continue in 100ms
        } else
            blChainStep=10;  // continue immed. with sending data
    }

    if (blChainStep==2)
    {
        // address was send, wait for response
        ret= dcBL_sendSuccess(0x21);
            // return val: 0: no response by now  1:error  10: OK
        if (ret==10)
        {
            //qDebug()<<"dcBL_cycle got resp OK";

            blChainStep=10;     // OK, continue with data
            blTimeOutCounter=0;
            return 0;   // continue in 100ms
        }
        if (ret==1)
        {
            //qDebug()<<"dcBL_cycle got resp error";

            // we got response but BL reports an error
            blTimeOutCounter=0;
            blRepeatCounter++;
            if (blRepeatCounter<3)
                blChainStep=1;      // repeat
            else
            {
                blChainResult=3;    // error timeout, no response from DC-BL
                blChainStep=99;
                return 0;
            }
            return 0;   // continue in 100ms
        }
        blTimeOutCounter++;
        if (blTimeOutCounter>=3)    // wait 3 cycles (3x100ms) for response
        {
            //qDebug()<<"dcBL_cycle TO";

            blChainResult=3;    // error timeout, no response from DC-BL
            blChainStep=99;
            return 0;
        } else
        {
            // ein oder zweimal keine Antwort
            blChainStep=1;      // repeat

            //qDebug()<<"dcBL_cycle no response";

            return 0;   // continue in 100ms
        }
    }

    // kein else!
    if (blChainStep==10)
    {
        // send data block or conclusion
        if (block2beSentNow == dcBL_nrOfBlocks)
        {
            // very last blocknumber, send conclusion
            sendLen=dcBL_writeLastPage(sendBuf);
            sendWRcmd_setSendBlock160(sendLen, sendBuf);
        } else
        {
            // send data...
            dcBL_getFileBlock(block2beSentNow, buf);

            //qDebug()<<"dcBL sending data block"<<block2beSentNow;

            sendLen=dcBL_prepareDC_BLcmd(0x22, 64, buf, sendBuf);   // pack into protocol frame
            sendWRcmd_setSendBlock160(sendLen, sendBuf);            // send up to 140 bytes
        }

        blChainStep++;
    } else

    if (blChainStep==11)
    {
        // data or conclusion was send, wait for response
        ret=dcBL_sendSuccess(0x22);
        // return val: 0: no response by now  1:error  10: OK
        if (ret==10)
        {
            blChainStep=99;     // OK, done
            blChainResult=1;        // block sent succesful
            if (block2beSentNow == dcBL_nrOfBlocks)
                blChainResult=2;    // transfer complete

            blTimeOutCounter=0;
            return 0;   // continue in 100ms
        }
        if (ret==1)
        {
            // we got response but BL reports an error
            blTimeOutCounter=0;
            blRepeatCounter++;
            if (blRepeatCounter<3)
                blChainStep=10;      // repeat
            else
            {
                blChainResult=3;    // error timeout, no response from DC-BL
                blChainStep=99;
                return 0;
            }
            return 0;   // continue in 100ms
        }
        blTimeOutCounter++;
        if (blTimeOutCounter>=3)    // wait 3 cycles (3x100ms) for response
        {
            blChainResult=3;    // error timeout, no response from DC-BL
            blChainStep=99;
            return 0;
        } else
        {
            // ein oder zweimal keine Antwort
            blChainStep=10;      // repeat
            return 0;   // continue in 100ms
        }
    }

    return 0;
}











// -----------------------------------------------------------------------------------------------
// --   fully automatic programmimg chain  ------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------

// use modules above and this functions from PI:
// sendWRcmd_setSendBlock160(len, buf);
// epi_getRawRecLength();
// epi_getRawReceivedData(receivedData);


/*
// this lines shall be displayed in tabFW / FW_responseWindow
// they are read every 100ms. Make batch for 10 lines
#define SIZEBLRESP      50
static QString BlResp[SIZEBLRESP];
static int     pBlResp;

bool dcBL_isTextMemFree(void)
{
    if (pBlResp<0) pBlResp=0;       // just for security
    if (pBlResp<(SIZEBLRESP-1))
        return true;
    return false;
}

void dcBL_writeText(QString newTxt)
{
    // write text here in this file from memory 1....9, mem 0 is always free
    if (dcBL_isTextMemFree())
        BlResp[++pBlResp]=newTxt;
}

bool dcBL_checkForText(void)
{
    // if pointer at 0 then no more content
    if (pBlResp>0)
        return true;
    return false;
}

QString dcBL_readText(void)
{
    // read from 0...9 (oldest first)
    if (pBlResp<=0)     // should never be <0
        return "";
    QString locStr=BlResp[1];       // store memory[1]

    // move memories down by one: 2->1 3->2 4>3....9->8. Place 1 is free now
    // example: if pBlResp==3 then we have still text 2 and 3 to display. 1 will be transfered now with  this call
    int nn;
    for (nn=1; nn<pBlResp; nn++)
        BlResp[nn]=BlResp[nn+1];
    if (pBlResp>0) pBlResp--;
    return locStr;
}

*/

// -------------------------------------------------------------------------

/*
static uint8_t dcBL_step, dcBL_state;
static uint16_t dcBL_BlkCtr, dcBL_cyclCtr, repeatCtr;

void dcBL_iniChain(void)
{
    int nn;
    dcBL_step=0;
    dcBL_cyclCtr=0;
    dcBL_state=0;
    dcBL_BlkCtr=0;
    repeatCtr=0;

    // delete output window:
    pBlResp=0;
    for (nn=0;nn<SIZEBLRESP; nn++)
        BlResp[nn]="";
    //dcBL_writeText("**CLEAR**");
    dcBL_writeText("bl chain ini");
}

uint8_t dcBL_startChain(void)
{
    if (dcBL_step==0 || dcBL_step>17)
    {
        dcBL_iniChain();
        dcBL_step=1;
        //epi_clrRawReceivedString();
        qDebug()<<"starting chain...";
        //qDebug()<<pBlResp;
        dcBL_writeText("bl chain start");
    }
    return 0;
}


uint8_t dcBL_runChain(void)
{
    // starting BL
    // request BL-version (to be sure it's working)
    // send start address
    // send bin-file
    // check all responses
    // display result
    // close BL

    // sequencer, triggered by 100ms timer from mainwindow over TabFw::updateGui

    QString tmpStr="";

    uint8_t buf[70], sendBuf[160], len, sendLen, gotResp, ii, uit8tmp;
    //static uint8_t lastBlkLength;
    QString stemp=" ";
    uint32_t ultmp;
    bool ret;
    //uint8_t recLen, recBuff[160], ;

   gotResp=dcBL_ChkResponse();  //zum test hier raus, unten gehts nicht, darf nur 1x

    switch (dcBL_step)
    {
        case 1: // tell DC-app to restart
            dcBL_writeText("loading binary..");
            ret=dcBL_loadBinSafe();
            if (ret)
                dcBL_step++;
            else
            {
                dcBL_writeText("cancel, cannot load binary!");
                dcBL_step=0;
            }
            break;

        case 2:
            dcBL_writeText("sending restart...");
            len=dcBL_restartDC(buf);
            sendWRcmd_setSendBlock160(len, buf);
            dcBL_step++;
            break;

        case 3: // wait 100ms more
            dcBL_step++;
            break;

        case 4: // start BL
            dcBL_writeText("sending BL start...");
            len=dcBL_activatBootloader(buf);
            sendWRcmd_setSendBlock160(5, buf);
            dcBL_step++;
            dcBL_cyclCtr=0;
            break;

        case 5: // wait for answer: 2 99 52 53 98 51 3
        // Problem: kommt von app, nicht vom BL. Also wenn BL schon aktiv ist dann gehts nicht


            dcBL_step++;
            repeatCtr=0;
            break;

        case 6: // request Version number
            len=dcBL_readFWversion(buf);
            sendWRcmd_setSendBlock160(len, buf);
            dcBL_writeText("request version nr...");
            dcBL_cyclCtr=0;
            dcBL_step++;
            break;

        case 7: // wait for answer  2 146 45 45 95 176 3

            if (gotResp==ISOK)
            {
                dcBL_state=1;   // BL started
                dcBL_step++;
                repeatCtr=0;
                return 0;
            } else
            if (gotResp==ISWRONG)
            {
                if (++repeatCtr<3)
                {
                    dcBL_step--;
                }else
                {
                    dcBL_step=0;    // stop chain
                }
            }

            if (++dcBL_cyclCtr>10)
            {
                dcBL_writeText("cancel");
                dcBL_step=0;    // stop chain
            }
            break;

        case 8: // send start address
            if (dcBL_BlkCtr==0 || dcBL_BlkCtr==1024 || dcBL_BlkCtr==2048 || dcBL_BlkCtr==3072 || dcBL_BlkCtr==4096)
            {
                ultmp=uint32_t(dcBL_BlkCtr);
                ultmp*=64;
                len=dcBL_sendFlashStartAddr2BL(ultmp, buf);
                sendWRcmd_setSendBlock160(len, buf);
                dcBL_writeText("sending start address");
                dcBL_cyclCtr=0;
                dcBL_step++;
                return 0;
            } else
                dcBL_step=12;
            break;

        case 9: // wait for answer 2 161 68 59 3
            if (gotResp==ISOK)
            {
                dcBL_step=12;   // Header nicht senden, unnötig
                dcBL_BlkCtr=0;        //  0
                repeatCtr=0;
                return 0;
            } else
            if (gotResp==ISWRONG)
            {
                if (++repeatCtr<3)
                {
                    dcBL_step--;
                } else
                {
                    dcBL_step=0;    // stop chain
                }
            }
            if (++dcBL_cyclCtr>10)
            {
                dcBL_writeText("cancel");
                dcBL_step=0;    // stop chain
            }
            break;


        case 12: // send binary 64 byte wise

            len=dcBL_getFileBlock(dcBL_BlkCtr, buf);      // read from file, len = 0...64
            //lastBlkLength=len;                          // recognize last block or end
            sendLen=dcBL_prepareDC_BLcmd(0x22, len, buf, sendBuf);   // pack into protocol frame


            // Kontrolle:
            qDebug()<<"dcBL sending: ";
            ii=0;
            do
            {
                uit8tmp=(uint8_t)sendBuf[ii++];
                //qDebug() << uit8tmp << " "; // Anzeige in dez
                stemp.setNum(uit8tmp,16);
                qDebug() << stemp << " ";   // Anzeige in hex

            } while (ii<100);


            sendWRcmd_setSendBlock160(sendLen, sendBuf);                  // send 140 bytes
            delay(100);
            //dcBL_writeText("blk nr: ");
            tmpStr.setNum(dcBL_BlkCtr);
            dcBL_writeText(tmpStr);
            delay(100);
            //qDebug()<<"sending: " << buf;
            dcBL_cyclCtr=0;
            dcBL_BlkCtr++;
            dcBL_step++;
            break;

        case 13: // wait for answer  2 162 116 88 3

            if (gotResp==ISOK)
            {
                // check if next address is needed (every 1024Blocks = 65536bytes)
                if (dcBL_BlkCtr==1024 || dcBL_BlkCtr==2048 || dcBL_BlkCtr==3072 || dcBL_BlkCtr==4096)
                {
                    dcBL_step=8;
                    return 0;
                }

                // check for EOF:
                if (dcBL_BlkCtr >= dcBL_nrOfBlocks)
                {
                    dcBL_writeText("last block successful sent...");
                    dcBL_step++;    // stop chain
                    dcBL_state=3;   // transmission SUCCESSFUL
                    return 0;
                }
                dcBL_state=2;   // transmission started
                dcBL_step--;    // send next data block
                repeatCtr=0;
                return 0;
            }
            if (gotResp==ISWRONG)
            {
                if (++repeatCtr<3)
                {
                    dcBL_writeText("error");
                    dcBL_BlkCtr--;
                    dcBL_step--;    // send same block again
                } else
                {
                    dcBL_step=0;    // stop chain
                }
            }
            if (++dcBL_cyclCtr>30)  // longer TO due to flashing
            {
                dcBL_writeText("cancel");
                dcBL_step=0;    // stop chain
            }
            break;

        case 14: //
            dcBL_writeText("finish writing flash");
            len=dcBL_writeLastPage(buf);        // nur zur Sicherheit
            sendWRcmd_setSendBlock160(len, buf);
            dcBL_step++;
            break;

        case 15: // wait for answer
            if (gotResp==ISOK)
            {
                dcBL_step++;
                repeatCtr=0;
                return 0;
            } else
            if (gotResp==ISWRONG)
            {
                if (++repeatCtr>3)
                {
                    dcBL_step--;
                }
            }
            if (++dcBL_cyclCtr>10)
            {
                dcBL_writeText("cancel");
                dcBL_step=0;    // stop chain
            }
            break;


        case 16: //
            dcBL_writeText("exit BL, bye");
            len=dcBL_exitBL(buf);
            sendWRcmd_setSendBlock160(len, buf);
            dcBL_step++;

            break;

        case 17: // wait for answer, not sure if it comes!
            if (gotResp==ISOK)
            {
                dcBL_step++;
                repeatCtr=0;
                return 0;
            } else
            if (gotResp==ISWRONG)
            {
                if (++repeatCtr>10)
                {
                    dcBL_step--;
                }
            }
            if (++dcBL_cyclCtr>30)
            {
                dcBL_writeText("cancel");
                dcBL_step=0;    // stop chain
            }
            break;

        case 18:
            dcBL_step=0;
            break;
    }

    return 0;
}



void dcBL_iniLoading(void)
{
    dcBL_iniChain();
}


// nicht verwendet
void dcBL_startLoading(void)
{
    if (dcBL_step==0 || dcBL_step>17)
    {
        //dcBL_iniChain();
        dcBL_step=1;
        //epi_clrRawReceivedString();
        qDebug()<<"DCBL start sending hexfile...";
        dcBL_writeText("DCBL start sending hexfile...");
        dcBL_BlkCtr=0;
        dcBL_cyclCtr=0;
    }

}
*/

/*
// nicht verwendet
uint8_t dcBL_sendHexfile(void)
{
    QString tmpStr="";
    uint8_t buf[70], sendBuf[160], len, sendLen, gotResp;   //, recLen; recBuff[160], ii,
    QString stemp=" ";
    uint32_t ultmp;
    //uint8_t uit8tmp, ii;


    gotResp=dcBL_ChkResponse();

    switch (dcBL_step)
    {
        case 1: // send start address
            if (dcBL_BlkCtr==0 || dcBL_BlkCtr==1024 || dcBL_BlkCtr==2048 || dcBL_BlkCtr==3072 || dcBL_BlkCtr==4096)
            {
                ultmp=uint32_t(dcBL_BlkCtr);
                ultmp*=64;
                len=dcBL_sendFlashStartAddr2BL(ultmp, buf);
                sendWRcmd_setSendBlock160(len, buf);
                qDebug()<<" DCBL_CYCL_sending HexFile address ";
                dcBL_writeText("sending addr");
                dcBL_step++;
                return 0;
            } else
                dcBL_step=12;
            break;

        case 2: // wait for answer 2 161 68 59 3
            if (gotResp==ISOK)
            {
                dcBL_step=12;   // Header nicht senden, unnötig
                dcBL_BlkCtr=0;        //  0
                repeatCtr=0;
                return 0;
            } else
            if (gotResp==ISWRONG)
            {
                if (++repeatCtr<3)
                {
                    dcBL_step--;
                } else
                {
                    dcBL_step=0;    // stop chain
                    qDebug()<<" DCBL_CYCL_got wrong resp to addr";
                    dcBL_writeText("wrong resp");
                }
            }
            if (++dcBL_cyclCtr>100)
            {
                dcBL_writeText("cancel");
                 qDebug()<<" DCBL_CYCL_step 2  got NO resp to addr";
                dcBL_step=0;    // stop chain
            }
            break;

        case 12: // send binary 64 byte wise

            len=dcBL_getFileBlock(dcBL_BlkCtr, buf);      // read from file, len = 0...64
            //lastBlkLength=len;                          // recognize last block or end
            sendLen=dcBL_prepareDC_BLcmd(0x22, len, buf, sendBuf);   // pack into protocol frame

            sendWRcmd_setSendBlock160(sendLen, sendBuf);                  // send 140 bytes
            delay(100);
            dcBL_writeText("blk nr: ");
            tmpStr.setNum(dcBL_BlkCtr);
            dcBL_writeText(tmpStr);
            delay(100);
            qDebug()<<"DCBL sending blk nr: " << dcBL_BlkCtr;
            dcBL_cyclCtr=0;
            dcBL_BlkCtr++;
            dcBL_step++;
            break;

        case 13: // wait for answer  2 162 116 88 3

            if (gotResp==ISOK)
            {
                // check if next address is needed (every 1024Blocks = 65536bytes)
                if (dcBL_BlkCtr==1024 || dcBL_BlkCtr==2048 || dcBL_BlkCtr==3072 || dcBL_BlkCtr==4096)
                {
                    dcBL_step=8;
                    return 0;
                }

                // check for EOF:
                if (dcBL_BlkCtr >= dcBL_nrOfBlocks)
                {
                    dcBL_writeText("last block successful sent...");
                    dcBL_step++;    // stop chain
                    dcBL_state=3;   // transmission SUCCESSFUL
                    return 0;
                }
                dcBL_state=2;   // transmission started
                dcBL_step--;    // send next data block
                repeatCtr=0;
                return 0;
            }
            if (gotResp==ISWRONG)
            {
                if (++repeatCtr<3)
                {
                    dcBL_writeText("error");
                    dcBL_BlkCtr--;
                    dcBL_step--;    // send same block again
                } else
                {
                    dcBL_step=0;    // stop chain
                }
            }
            if (++dcBL_cyclCtr>30)  // longer TO due to flashing
            {
                dcBL_writeText("cancel");
                dcBL_step=0;    // stop chain
            }
            break;

        case 14: //
            dcBL_writeText("finish writing flash");
            len=dcBL_writeLastPage(buf);        // nur zur Sicherheit
            sendWRcmd_setSendBlock160(len, buf);
            dcBL_step++;
            break;

        case 15: // wait for answer
            if (gotResp==ISOK)
            {
                dcBL_step++;
                repeatCtr=0;
                return 0;
            } else
            if (gotResp==ISWRONG)
            {
                if (++repeatCtr>3)
                {
                    dcBL_step--;
                }
            }
            if (++dcBL_cyclCtr>10)
            {
                dcBL_writeText("cancel");
                dcBL_step=0;    // stop chain
            }
            break;

    }
    return 0;
}

*/


/*
uint8_t dcBL_getResult(void)
{
    // call after every step to what's going on....
    //  1: connected to BL
    //  2: transmission started
    //  3: transmission successful

    return dcBL_state;
}
*/
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------

// move to storeINdata and use shared mem as ptu-updater uses CAslave Lib 6.9.23TS
/*
static uint8_t Sdata_rawData[RAW_BL_DATALEN];

static uint8_t Sdata_LengthRawData;

void gpi_storeRawReceivedData(uint8_t  RdDlen, uint8_t *receivedData)
{
    uint8_t nn;
    Sdata_LengthRawData=RdDlen;
    if (Sdata_LengthRawData>RAW_BL_DATALEN)
        Sdata_LengthRawData=RAW_BL_DATALEN;
    for (nn=0; nn<Sdata_LengthRawData; nn++)
        Sdata_rawData[nn]=receivedData[nn];
    //qDebug()<<"dcBL got data"<<  Sdata_LengthRawData << "bytes :)";

}

uint8_t epi_getRawReceivedData(uint8_t *receivedData)
{
    // retval=length, will be zeroed after first reading
    uint8_t nn, ret;

    for (nn=0; nn<Sdata_LengthRawData; nn++)
        receivedData[nn]=Sdata_rawData[nn];
    ret=Sdata_LengthRawData;
    //Sdata_LengthRawData=0;
    return ret;
}

uint8_t epi_getRawRecLength(void)
{
    // retval=length
    return Sdata_LengthRawData;
}
*/
/*
QString epi_getRawReceivedString()
{
    uint8_t nn;     //, ret;
    QString myString=nullptr, tmpStr=nullptr;

    myString.clear();
    if (Sdata_LengthRawData==0)
        return myString;

    for (nn=0; nn<Sdata_LengthRawData; nn++)
    {
        tmpStr.clear();
        tmpStr.setNum(Sdata_rawData[nn],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(" ");

    }
    //ret=Sdata_LengthRawData;
    //Sdata_LengthRawData=0;
    return myString;
}*/
/*
void epi_clrRawReceivedString()
{
    Sdata_LengthRawData=0;
}
*/