GerhardHoffmann/ATBUpdateTool
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
e1a26ef966
ATBUpdateTool/DCPlugin/src/dcBL.cpp

1462 lines
41 KiB
C++
Raw Normal View History

Squashed 'DCPlugin/' content from commit debade9 git-subtree-dir: DCPlugin git-subtree-split: debade99427801efa46a708cd726648c7f83a257
2023-04-11 14:04:38 +02:00
//#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;
}
Reference in New Issue Copy Permalink