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