SiegfriedSiegert/DCLibraries
1
0
Fork 0
forked from GerhardHoffmann/DCLibraries
Code Pull Requests Activity
Files
1.99.11-2
DCLibraries/dCArun/tslib.cpp
Gerhard Hoffmann a9041d417d Start repository
2023-11-08 13:02:26 +01:00

1017 lines
25 KiB
C++
Executable File
Raw Permalink Blame History

#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[2]='_'; // : not allowed in JsonFormat
buf[3]=mm/10+0x30;
buf[4]=mm%10+0x30;
jj=5;
if (with_sec)
{
buf[jj++]=':';
//buf[jj++]='_'; // : not allowed in JsonFormat
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;
}
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;
}
bool tslib_strComp(uint8_t *buf, char *compStr)
{
uint16_t strLen=tslib_strlen(compStr), pp;
for (pp=0; pp<strLen; pp++)
{
if (buf[pp] != compStr[pp])
return false;
}
return true;
}
// -----------------------------------------------------------------------------------------------
// 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);
}
*/
// -----------------------------------------------------------------------------------------------
bool tslib_plausiChkTime(uint8_t hour, uint8_t min, uint8_t sec )
{
// retval: true: time is OK
bool ret=true;
if (hour>23) ret=false;
if (min>59) ret=false;
if (sec>59) ret=false;
return ret;
}
// -----------------------------------------------------------------------------------------------
bool tslib_plausiChkDate(uint8_t year, uint8_t month, uint8_t dom )
{
// retval: true: time is OK
bool ret=true;
if (year<23) ret=false;
if (month<1 || month>12) ret=false;
if (dom<1 || dom>31) ret=false;
return ret;
}
// -----------------------------------------------------------------------------------------------
UCHAR swl_LengthCurrentMonth(UCHAR month, UCHAR year)
{
// return nr of days for this month, respecting leap years
if (month==2)
{
// Sonderfall Februar:
if (year%4)
return 28; // Rest wenn durch 4 geteilt wird
else
return 29; // durch 4 teilbar ohne Rest
} else
if (month==1 || month==3 || month==5 || month==7 ||
month==8 || month==10 || month==12)
{
return 31;
} else
return 30;
}
// -----------------------------------------------------------------------------------------------
UINT swl_GetDaysOfaCompleteYear(UCHAR year)
{
// year: 0=2000 4=2004 99=2099
// retval: 365 or 366 (leap year)
UCHAR jahr;
jahr=year;
if (jahr & 3) // wenn bits 0 und 1 low sind dann Vielfaches von 4
{
// dann kein Schaltjahr
return(365);
} else
{
// Schaltjahr
return(366);
}
}
// -----------------------------------------------------------------------------------------------
UINT swl_GetDaysOfYear(UCHAR year, UCHAR month, UCHAR day)
{
// number of days of momentary year from 1. Jan until
// (inclusive) given date with respect to leap years
// year: 0..99 month=1..12 day=1..31
int summe=0;
UCHAR mo, ta, yy, mm, uctmp;
yy=year;
mo=month;
ta=day;
if (mo==0 || mo>12 || ta==0 || ta>31 || yy>99)
return(0); // Fehler
// Beispiel: mo=5: summiere Tage des Jan, Feb, März und April
// der Mai ist noch nicht komplett abgelaufen!
mm=1; // start mit Januar
while (mo>1)
{
uctmp=swl_LengthCurrentMonth(mm,yy);
summe += (int)uctmp;
mo--; mm++;
}
summe+=ta;
return(summe);
}
// -----------------------------------------------------------------------------------------------
unsigned long swl_getNrOfDaysSince2000Jan1(UCHAR thisYear, UCHAR thisMonth, UCHAR thisDay)
{
// till today
ULONG ultmp=0;
UCHAR jj;
for (jj=0; jj<thisYear; jj++)
{
ultmp +=swl_GetDaysOfaCompleteYear(jj);
}
ultmp +=swl_GetDaysOfYear(thisYear, thisMonth, thisDay); // Tage des aktuellen Jahres
return ultmp;
}
// -----------------------------------------------------------------------------------------------
unsigned long swl_getNrOfHoursSince_Midnight2000Jan1(UCHAR thisYear, UCHAR thisMonth, UCHAR thisDay, UCHAR hoursNow)
{
ULONG ultmp=0;
ultmp=swl_getNrOfDaysSince2000Jan1(thisYear, thisMonth, thisDay);
ultmp-=1; // - today
ultmp *=24;
ultmp +=hoursNow;
return ultmp;
}
// -----------------------------------------------------------------------------------------------
unsigned long swl_getNrOfMinutesSince_Midnight2000Jan1(UCHAR thisYear, \
UCHAR thisMonth, UCHAR thisDay, UCHAR hoursNow, UCHAR minuteNow)
{
ULONG ultmp=0;
ultmp=swl_getNrOfHoursSince_Midnight2000Jan1(thisYear, thisMonth, thisDay, hoursNow);
ultmp *=60;
ultmp +=minuteNow;
return ultmp;
}
// -----------------------------------------------------------------------------------------------
unsigned long swl_getNrOfSecondsSince_Midnight2000Jan1(UCHAR thisYear, \
UCHAR thisMonth, UCHAR thisDay, UCHAR hoursNow, UCHAR minuteNow, UCHAR secondNow)
{
ULONG ultmp=0;
ultmp=swl_getNrOfMinutesSince_Midnight2000Jan1(thisYear, thisMonth, \
thisDay, hoursNow, minuteNow);
ultmp *=60;
ultmp +=secondNow;
return ultmp;
}
// -----------------------------------------------------------------------------------------------
char swl_isLeap(UCHAR year)
{
if ((year%4)==0)
return 1;
return 0;
}
// -----------------------------------------------------------------------------------------------
UCHAR swl_getNextLeapYear(UCHAR year)
{
UCHAR uctmp=year, nn;
for (nn=uctmp; nn<(uctmp+4); nn++)
if ((nn%4)==0) // dann ist es ein Schaltjahr
return nn;
return 0;
}
// -----------------------------------------------------------------------------------------------
UCHAR swl_getLastLeapYear(UCHAR year)
{
UCHAR uctmp=year, nn;
if (uctmp<4)
return 0; // das Jahr 2000 war das vorherige Schaltjahr
if ((uctmp%4)==0) // dann ist "thisyear" ein Schaltjahr
return uctmp;
uctmp-=4;
for (nn=uctmp; nn<(uctmp+4); nn++)
if ((nn%4)==0) // dann ist es ein Schaltjahr
return nn;
return 0;
}
// -----------------------------------------------------------------------------------------------
UCHAR swl_hoursOfThisWeek(UCHAR dow, UCHAR hoursNow)
{
// always calculate from monday 0 o'clock
// dow: 1=monday 7=sunday
UCHAR uctmp = dow-1;
uctmp*=24;
uctmp+=hoursNow;
return uctmp;
}
// -----------------------------------------------------------------------------------------------
UINT swl_minutesOfThisWeek(UCHAR dow, UCHAR hoursNow, UCHAR minutesNow)
{
// always calculate from monday 0 o'clock
// dow: 1=monday 7=sunday
UINT uitmp;
uitmp=(UINT)swl_hoursOfThisWeek(dow, hoursNow);
//uitmp--; // aktuelle Stunde weg, dafür die minutesNow addieren
// nicht weil bei 9:40 Uhr sowieso nur 9h
uitmp*=60;
uitmp+=(UINT)minutesNow;
return uitmp;
}
// -----------------------------------------------------------------------------------------------
UINT swl_hoursOfThisMonth(UCHAR thisDay, UCHAR hoursNow)
{
UINT daysofmon;
daysofmon=thisDay-1; // beispiel: heute 17. dann gibts 16Tage mit 24h
daysofmon*=24;
daysofmon+=(UINT)hoursNow; // + die Stunden heute
return daysofmon;
}
// -----------------------------------------------------------------------------------------------
UINT swl_minutesOfThisMonth(UCHAR thisDay, UCHAR hoursNow, UCHAR minutesNow)
{
UINT hoursofmon;
hoursofmon=swl_hoursOfThisMonth(thisDay, hoursNow);
hoursofmon*=60;
hoursofmon+=(UINT)minutesNow;
return hoursofmon;
}
// -----------------------------------------------------------------------------------------------
UINT swl_GetHoursOfYear(UCHAR year, UCHAR month, UCHAR day, UCHAR hourNow)
{
UINT daysofthisyear;
daysofthisyear=swl_GetDaysOfYear(year, month, day); // incl. heute
daysofthisyear--;
daysofthisyear*=24; // bis gestern
daysofthisyear+=(UINT)hourNow;
return daysofthisyear;
}
// -----------------------------------------------------------------------------------------------
ULONG swl_GetMinutesOfYear(UCHAR year, UCHAR month, UCHAR day, UCHAR hourNow, UCHAR minutesNow)
{
ULONG hoursofthisyear;
hoursofthisyear=(ULONG)swl_GetHoursOfYear(year, month, day, hourNow); // incl. heute
hoursofthisyear--;
hoursofthisyear*=60;
hoursofthisyear+=(ULONG)minutesNow;
return hoursofthisyear;
}
// -----------------------------------------------------------------------------------------------
UCHAR swl_weekday(UCHAR year, UCHAR month, UCHAR dayOfMonth)
{
// return 1...7 = monday...sunday, starting from 1.1.2000
UINT tage, uitmp;
tage=(UINT)swl_getNrOfDaysSince2000Jan1(year, month, dayOfMonth);
// days till today 1.1.2000 was a saturday
// calulate weekday out of unix time (sec seit 1.1.1970 00:00Uhr UTC, das war ein Donnerstag (4) )
//given unix time t, returns day of week Sun-Sat as an integer 0-6
//uint8_t dow(unsigned long t)
//{
// return ((t / 86400) + 4) % 7;
//}
uitmp=tage+5;
uitmp%=7;
if (uitmp==0) uitmp=7; // Sunday = 7 not 0
return (UCHAR)uitmp;
}
QString swl_int2str(int val)
{
QString myStr;
myStr.clear();
myStr.append(QString::number(val,10)); // decimal based number
// statt number auch setNum moeglich
return myStr;
}
QString swl_hex2str(ulong val)
{
QString myStr;
myStr.clear();
myStr.append(QString::number(val,16).toUpper() );
return myStr;
}
void swl_text2ui8buf(QString text, uint8_t *outbuf, uint16_t length)
{
// copy text byte-by-byte to outbuf
uint16_t nn;
char oneChar;
for (nn=0; nn<length; nn++)
{
oneChar=text[nn].toLatin1();
outbuf[nn]=oneChar;
}
}
QString swl_ulong2str(uint32_t val)
{
QString myStr;
myStr.clear();
myStr.append(QString::number(val,10)); // decimal based number
// statt number auch setNum moeglich
return myStr;
}
QString swl_long2str(long val)
{
QString myStr;
myStr.clear();
myStr.append(QString::number(val,10)); // decimal based number
// statt number auch setNum moeglich
return myStr;
}
uint16_t swl_str2uint(QString myIntStr)
{
bool ok=0;
uint16_t nxtAn;
nxtAn=myIntStr.toUInt(&ok,10);
if (ok)
{
return nxtAn;
}
return 0;
}
uint32_t swl_str2ulong(QString myIntStr)
{
bool ok=0;
uint32_t nxtAn;
nxtAn=myIntStr.toULong(&ok,10);
if (ok)
{
return nxtAn;
}
return 0;
}
QString swl_labelAndValToStr(QString label, uint32_t val)
{
QString myStr;
myStr.clear();
myStr.append(label);
myStr.append(QString::number(val));
return myStr;
}
QString swl_8valInaRowToStr(QString label, uint8_t val[8])
{
QString myStr;
myStr.clear();
myStr.append(label);
for (int ii=0; ii<8; ii++)
{
myStr.append(QString::number(val[ii]));
myStr.append(" ");
}
return myStr;
}
QString swl_8valInaRowToStr(QString label, uint16_t val[8])
{
QString myStr;
myStr.clear();
myStr.append(label);
for (int ii=0; ii<8; ii++)
{
myStr.append(QString::number(val[ii]));
myStr.append(" ");
}
return myStr;
}
QString swl_8intsInaRowToStr(QString label, int val[8])
{
QString myStr;
myStr.clear();
myStr.append(label);
for (int ii=0; ii<8; ii++)
{
myStr.append(QString::number(val[ii]));
myStr.append(" ");
}
return myStr;
}
QString swl_centToEuroString(uint32_t amount_in_cent)
{
QString tmpStr;
uint32_t euros, cents;
tmpStr.clear();
euros=amount_in_cent/100;
cents=amount_in_cent%100;
tmpStr.append(QString::number(euros,10));
tmpStr.append(",");
tmpStr.append(QString::number(cents,10));
tmpStr.append( " €");
return tmpStr;
}
View Git Blame Copy Permalink