1462 lines
41 KiB
C++
1462 lines
41 KiB
C++
//#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;
|
|
|
|
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];
|
|
strclr(myBuf, 0, 2);
|
|
return dcBL_prepareDC_BLcmd(0x22, 0, myBuf, sendData);
|
|
}
|
|
|
|
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, bool display)
|
|
{
|
|
// retval: nr of received bytes
|
|
uint8_t recLen=epi_getRawRecLength();
|
|
if (recLen>0 && recLen<150)
|
|
{
|
|
epi_getRawReceivedData(respBuff);
|
|
epi_clrRawReceivedString();
|
|
dcBL_writeText("dcBL gotResponse");
|
|
|
|
if (display)
|
|
{
|
|
/*
|
|
// Antwort ins Fenster schreiben:
|
|
QString tmpStr="", myStr="~~> ";
|
|
|
|
tmpStr.setNum(recLen);
|
|
myStr.append(tmpStr);
|
|
myStr.append(" bytes received: ");
|
|
for (int nn=0; nn<recLen; nn++)
|
|
{
|
|
tmpStr.clear();
|
|
tmpStr.setNum(respBuff[nn]);
|
|
myStr.append(tmpStr);
|
|
myStr.append(" ");
|
|
}
|
|
dcBL_writeText(myStr);
|
|
*/
|
|
}
|
|
}
|
|
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;
|
|
//uint8_t exactError;
|
|
//QString tmpStr="";
|
|
|
|
//exactError=0;
|
|
recLen=dcBL_getResponse(buf,0);
|
|
if (recLen==0)
|
|
return 0; // no response by now
|
|
|
|
//qDebug()<<" DCBL_chkResp got answer " << recLen ;
|
|
//dcBL_writeText("DCBL_chkResp got answer");
|
|
|
|
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
|
|
}
|
|
//tmpStr.clear();
|
|
//tmpStr.setNum(exactError);
|
|
//dcBL_writeText(tmpStr);
|
|
return 1; // error
|
|
}
|
|
|
|
|
|
|
|
uint8_t dcBL_sendSuccess(uint8_t lastCommand)
|
|
{
|
|
// return val: 0: no response by now 1:error 10: OK
|
|
|
|
uint8_t buf[152], recLen;
|
|
|
|
recLen=dcBL_getResponse(buf,0);
|
|
if (recLen==0)
|
|
return 0; // no response by now
|
|
|
|
if (buf[0]==2 && buf[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);
|
|
}
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
char dcBL_loadBinary(char withDisplay)
|
|
{
|
|
// same function as in "tabFw"
|
|
//uint8_t uit8tmp;
|
|
uint32_t ultmp, fileLen;
|
|
QString tmpStr="", s2tmp="";
|
|
|
|
qDebug()<<"dcBL loading DC2c binary...";
|
|
QFile file("../dc2c4.bin");
|
|
if (!file.exists())
|
|
{
|
|
//qDebug()<<"file _own_H2B_dc2.bin does not exist";
|
|
dcBL_writeText("file _own_H2B_dc2.bin does not exist");
|
|
return 1;
|
|
}
|
|
if (!file.open(QIODevice::ReadOnly) )
|
|
{
|
|
//qDebug()<<"cannot open";
|
|
dcBL_writeText("cannot open");
|
|
return 1;
|
|
}
|
|
|
|
//qDebug()<<"loading....";
|
|
//qDebug()<<"size: " << file.size() <<"\n";
|
|
if (withDisplay)
|
|
{
|
|
s2tmp="loading file with ";
|
|
tmpStr.setNum(file.size());
|
|
s2tmp.append(tmpStr);
|
|
s2tmp.append(" bytes");
|
|
dcBL_writeText(s2tmp);
|
|
}
|
|
QByteArray myBin = file.readAll();
|
|
fileLen=uint32_t(file.size());
|
|
|
|
// Rest des Blockes mit 0xFF füllen
|
|
for (ultmp=fileLen; ultmp<(fileLen+70); ultmp++)
|
|
myBin[ultmp]=char(0xFF);
|
|
|
|
/* // Kontrolle:
|
|
qDebug()<<"dcBL_loadBinary: ";
|
|
int ii=59500;
|
|
do
|
|
{
|
|
uit8tmp=uint8_t(myBin[ii++]);
|
|
s2tmp.clear();
|
|
//qDebug() << uit8tmp << " "; // Anzeige in dez
|
|
s2tmp.setNum(uit8tmp,16);
|
|
qDebug() << s2tmp << " "; // Anzeige in hex
|
|
|
|
} while (ii<60100);
|
|
*/
|
|
|
|
dcBL_importBinFile(myBin, fileLen, withDisplay);
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
static QByteArray dcBL_AtbBinFile;
|
|
static uint32_t dcBL_fileSize;
|
|
static uint16_t dcBL_nrOfBlocks;
|
|
static uint16_t dcBL_fileCrc;
|
|
//static uint8_t dcBL_myBuf[2570000]; // same content like "dcBL_AtbBinFile" but bytewise
|
|
static uint8_t dcBL_myBuf[300000]; // same content like "dcBL_AtbBinFile" but bytewise
|
|
|
|
bool dcBL_importBinFile(QByteArray readBinFile, uint32_t fileSize, char withDispl)
|
|
{
|
|
uint16_t uitmp;
|
|
uint32_t ultmp;
|
|
uint32_t LL;
|
|
QString tmpStr="", s2tmp="";
|
|
|
|
dcBL_AtbBinFile=readBinFile;
|
|
dcBL_fileSize=fileSize;
|
|
|
|
//if (dcBL_fileSize>258048) // 27.3.23TS woher kommt die Zahl???
|
|
// das hex file hat 278kB
|
|
// hex file nicht erlaubt???
|
|
if (dcBL_fileSize>=300000)
|
|
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);
|
|
// dcBL_writeText("file crc calculated successful");
|
|
|
|
if (withDispl)
|
|
{
|
|
s2tmp="crc: ";
|
|
tmpStr.setNum(dcBL_fileCrc,16);
|
|
s2tmp.append(tmpStr);
|
|
dcBL_writeText(s2tmp);
|
|
|
|
tmpStr.clear();
|
|
s2tmp="blocks: ";
|
|
tmpStr.setNum(dcBL_nrOfBlocks,10);
|
|
s2tmp.append(tmpStr);
|
|
dcBL_writeText(s2tmp);
|
|
|
|
tmpStr.clear();
|
|
s2tmp="last block size: ";
|
|
tmpStr.setNum(uitmp,10);
|
|
s2tmp.append(tmpStr);
|
|
dcBL_writeText(s2tmp);
|
|
}
|
|
return true;
|
|
|
|
// erstmal nicht wie bisher um 14 Bytes nach oben schieben und Laenge/crc anhaengen,
|
|
// weil man sonst den BL und das Win-tool auch aendern muesste
|
|
|
|
}
|
|
|
|
char dcBL_loadBinSafe(void)
|
|
{
|
|
// 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, BINFILECOPY3;
|
|
uint32_t BinFileCpyLen1, BinFileCpyLen2, BinFileCpyLen3, LL;
|
|
uint8_t repeat=0, nn=0, stopp=0;
|
|
//char cc;
|
|
|
|
do
|
|
{
|
|
//dcBL_writeText("loading 1st time:");
|
|
//qDebug() <<"loading 1st time:";
|
|
dcBL_loadBinary(0);
|
|
// 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(0);
|
|
// 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(0);
|
|
// file jetzt in: "QByteArray dcBL_AtbBinFile" mit Laenge "uint32_t dcBL_fileSize"
|
|
BINFILECOPY3=dcBL_AtbBinFile;
|
|
BinFileCpyLen3=dcBL_fileSize;
|
|
|
|
//cc=BINFILECOPY2[100];
|
|
//if (cc>0)
|
|
// BINFILECOPY2[100]=0;
|
|
//else
|
|
// BINFILECOPY2[100]=1;
|
|
|
|
repeat=0;
|
|
if (BinFileCpyLen1 !=BinFileCpyLen2 || BinFileCpyLen1 !=BinFileCpyLen3)
|
|
{
|
|
dcBL_writeText("file length wrong");
|
|
qDebug() <<"length error";
|
|
|
|
repeat=1; // load both again....
|
|
}
|
|
if (repeat==0)
|
|
{
|
|
LL=0; stopp=0;
|
|
//qDebug() <<"1. loop";
|
|
|
|
do
|
|
{
|
|
if (dcBL_AtbBinFile[LL] != BINFILECOPY1[LL])
|
|
stopp=1;
|
|
} while((++LL < dcBL_fileSize) && !stopp);
|
|
|
|
if (stopp)
|
|
{
|
|
dcBL_writeText("file compare1 wrong ");
|
|
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)
|
|
{
|
|
dcBL_writeText("file compare2 wrong ");
|
|
repeat=1; // load both again....
|
|
} else
|
|
dcBL_writeText("file OK");
|
|
}
|
|
|
|
} while (++nn<3 && repeat); // 3 trials
|
|
|
|
qDebug() << "compare finito " << nn << " " << repeat;
|
|
|
|
if (repeat==0)
|
|
return true; // file OK
|
|
return false; // error, could not load correctly
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t dcBL_getAtbFileHeader(uint8_t *buf)
|
|
{
|
|
// this header is prepended by the pc-direct-loader-tool
|
|
// (so the uC-BL expects this!) here it is sent seperately:
|
|
uint8_t myBuf[30], pp=0, len;
|
|
|
|
myBuf[pp++]='A';
|
|
myBuf[pp++]='T';
|
|
myBuf[pp++]='B';
|
|
myBuf[pp++]='-';
|
|
myBuf[pp++]='D';
|
|
myBuf[pp++]='C';
|
|
myBuf[pp++]='2';
|
|
myBuf[pp++]='-';
|
|
myBuf[pp++]=ulongTOuchar(dcBL_fileSize, GETHIGHBYTE);
|
|
myBuf[pp++]=ulongTOuchar(dcBL_fileSize, GETMIDHIGHBYTE);
|
|
myBuf[pp++]=ulongTOuchar(dcBL_fileSize, GETMIDLOWBYTE);
|
|
myBuf[pp++]=ulongTOuchar(dcBL_fileSize, GETLOWBYTE);
|
|
myBuf[pp++]='-';
|
|
myBuf[pp++]=uintTOuchar(dcBL_fileCrc, GETHIGHBYTE);
|
|
myBuf[pp++]=uintTOuchar(dcBL_fileCrc, GETLOWBYTE);
|
|
myBuf[pp++]='-';
|
|
len=pp;
|
|
//tslib_strcpy(myBuf, buf, (len+3));
|
|
len=dcBL_prepareDC_BLcmd(0x32, len, myBuf, buf);
|
|
return len;
|
|
}
|
|
|
|
uint8_t dcBL_getFileBlock(uint16_t blockPointer, uint8_t *buf)
|
|
{
|
|
// blockPointer=0....4095
|
|
uint32_t addr, LL; //, BL;
|
|
//uint8_t uit8tmp;
|
|
//QString stemp=" ";
|
|
|
|
addr=uint32_t(blockPointer);
|
|
addr<<=6; // *64 =Start address
|
|
/*
|
|
if ( (addr+63)>dcBL_fileSize)
|
|
{
|
|
BL=dcBL_fileSize-addr+1; // Block Length
|
|
for (LL=0; LL<64; LL++)
|
|
buf[LL]=0;
|
|
if (BL>64) BL=64; // security limitation
|
|
// only BL bytes are left to give
|
|
for (LL=0; LL<BL; LL++)
|
|
{
|
|
buf[LL]=uint8_t(dcBL_AtbBinFile[LL+addr]);
|
|
// buf[LL]=dcBL_myBuf[LL+addr];
|
|
}
|
|
return uint8_t(BL);
|
|
} else
|
|
*/
|
|
{
|
|
// all 64bytes can be read:
|
|
for (LL=0; LL<64; LL++)
|
|
{
|
|
buf[LL]=uint8_t(dcBL_AtbBinFile[LL+addr]);
|
|
//buf[LL]=dcBL_myBuf[LL+addr];
|
|
}
|
|
|
|
/*
|
|
// Kontrolle:
|
|
qDebug()<<"dcBL getFileBlock myBuf: ";
|
|
int ii=0;
|
|
do
|
|
{
|
|
uit8tmp=(uint8_t)dcBL_myBuf[ii++];
|
|
//qDebug() << uit8tmp << " "; // Anzeige in dez
|
|
stemp.setNum(uit8tmp,16);
|
|
qDebug() << stemp << " "; // Anzeige in hex
|
|
|
|
} while (ii<64);
|
|
|
|
qDebug()<<"dcBL getFileBlock myBuf: ";
|
|
ii=0;
|
|
do
|
|
{
|
|
uit8tmp=(uint8_t)buf[ii++];
|
|
//qDebug() << uit8tmp << " "; // Anzeige in dez
|
|
stemp.setNum(uit8tmp,16);
|
|
qDebug() << stemp << " "; // Anzeige in hex
|
|
|
|
} while (ii<64);
|
|
*/
|
|
|
|
return 64;
|
|
}
|
|
//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 her 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_cyclCtr++;
|
|
if (recLen>6 && recBuff[0]==2 && recBuff[1]==99 && recBuff[2]==52)
|
|
// && recBuff[3]==53 && recBuff[4]==98 && recBuff[5]==51 && recBuff[6]==3 )
|
|
{
|
|
dcBL_writeText("BL started");
|
|
dcBL_cyclCtr=0;
|
|
dcBL_step++;
|
|
return 0;
|
|
}
|
|
//qDebug()<<dcBL_cyclCtr;
|
|
if (dcBL_cyclCtr>10) // 50 gibt 6,2s
|
|
{
|
|
// cancel, report error
|
|
dcBL_writeText("cannot start BL, cancel");
|
|
dcBL_state=3;
|
|
dcBL_step=0; // stop chain
|
|
return 0;
|
|
} */
|
|
|
|
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
|
|
/*
|
|
// 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()<<"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;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// -------------------------------------------------------------------------
|
|
// -------------------------------------------------------------------------
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|