WebSVN - Projects - Diff - Rev 307 and 314 - /QMK-Groundstation/trunk/Classes/ToolBox.cpp


/***************************************************************************
 *   Copyright (C) 2008 by Manuel Schrape                                  *
 *   manuel.schrape@gmx.de                                                 *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License.        *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#include "ToolBox.h"
 
ToolBox::ToolBox()
{
}
 
void ToolBox::Wait(int Time)
{
#ifndef _WIN32_
    usleep(Time);
#else
//    sleep(Time);
#endif
}
 
QString ToolBox::get_Float(long Wert, int Count)
{
    QString Temp, s_Wert;
 
    s_Wert = QString("%1").arg(Wert);
 
    Temp = s_Wert.left(s_Wert.length() - Count) + QString(".") + s_Wert.right(Count);
 
/*
    if (Wert > 0)
        Temp = "";
    else
        Temp = "-";
 
    Temp = Temp + QString("%1").arg(Wert / Count) + "." + QString("%1").arg(Wert % Count);
*/
    return Temp;
}
 
 
// Base64 Decoder
bool ToolBox::Decode64(sRxData &RX, bool Long)
{
    unsigned char a,b,c,d;
    unsigned char ptr = 0;
    unsigned char x,y,z;
    int ptrOut[150];
 
    int ptrIn = 3;
    int max = RX.String.length();
    int len = RX.String.length();
    int DecLen = 0;
 
    if (RX.Input[ptrIn] == 0)
    {
        qDebug("QString to Char ERROR...!!!!");
        return false;
    }
 
    while(len != 0)
    {
        a = RX.Input[ptrIn++] - '=';
        b = RX.Input[ptrIn++] - '=';
        c = RX.Input[ptrIn++] - '=';
        d = RX.Input[ptrIn++] - '=';
 
        if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden
 
        x = (a << 2) | (b >> 4);
        y = ((b & 0x0f) << 4) | (c >> 2);
        z = ((c & 0x03) << 6) | d;
 
        if(len--) ptrOut[ptr++] = x; else break;
        if(len--) ptrOut[ptr++] = y; else break;
        if(len--) ptrOut[ptr++] = z; else break;
    }
 
    for (int a=0; a<ptr; a++)
    {
        if (Long == false)
        {
            int b1, b2, b3;
 
            b1 = ptrOut[a++];
            b2 = ptrOut[a];
 
            b3 = (b2 << 8) | b1;
 
            if (b3 > 32767)
                b3 = b3 - 65536;
 
            RX.Decode[DecLen] = b3;
            DecLen++;
        }
        else
        {
            RX.Decode[DecLen] = ptrOut[a];
            DecLen++;
        }
 
        RX.DecLen = DecLen;
    }
    return true;
}
 
// Base64 Encoder
QString ToolBox::Encode64(char Data[150],unsigned int Length)
{
    unsigned int pt = 0;
    unsigned char a,b,c;
    unsigned char ptr = 0;
 
    char TX_Buff[150];
 
    while(Length > 0)
    {
        if(Length) { a = Data[ptr++]; Length--;} else a = 0;
        if(Length) { b = Data[ptr++]; Length--;} else b = 0;
        if(Length) { c = Data[ptr++]; Length--;} else c = 0;
 
        TX_Buff[pt++] = '=' + (a >> 2);
        TX_Buff[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
        TX_Buff[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
        TX_Buff[pt++] = '=' + ( c & 0x3f);
    }
    TX_Buff[pt] = 0;
 
    return QString(TX_Buff);
}
 
// Datensatz nach 8bit Integer
int ToolBox::Data2Char(int *Data , int Start, bool is_signed)
{
    int Out = (Data[Start]);
 
    if ((Out > 128) && (is_signed))
      Out = Out - 256;
 
    return Out;
 
}
 
// Datensatz nach 8bit Integer
int ToolBox::Char2Data(int Data)
{
    if (Data < 0)
    {
        return Data + 256;
    }
    return Data;
}
 
 
// Datensatz nach 16bit Integer
int ToolBox::Data2Int(int *Data , int Start, bool is_signed)
{
    int Out = (Data[Start+1]<<8) | (Data[Start+0]);
 
    if ((Out > 32767) && (is_signed))
      Out = Out - 65536;
 
    return Out;
 
}
 
// Datensatz nach 32bit Long
long ToolBox::Data2Long(int *Data , int Start, bool is_signed)
{
    long Out = (Data[Start+3]<<24) | (Data[Start+2]<<16) | (Data[Start+1]<<8) | (Data[Start+0]);
 
    if ((Out > 32767) && (is_signed))
      Out = Out;
 
    return Out;
}
 
// Datensatz nach QString
QString ToolBox::Data2QString(int Data[150], int Start, int End)
{
    char String[150];
    for (int a = Start; a < End; a++)
    {
        String[a - Start] = Data[a];
    }
    String[End - Start] = '\0';
 
    return QString(String);
}
 
// Datensatz-CRC prüfen
bool ToolBox::check_CRC(QString RXString)
{
    int CRC = 0;
    char *RX;
 
    int Length = RXString.length();
 
    RX = RXString.toLatin1().data();
 
    if (RX[1] == 127)
    {
        RX[1] = 0;
    }
 
    for(int i=0; i < Length-2; i++)
    {
            CRC+=RX[i];
    }
 
    CRC = CRC % 4096;
 
    if(RX[Length - 2] != ('=' + (CRC / 64)))
    {
        return false;
    }
 
    if(RX[Length - 1] != ('=' + CRC % 64))
    {
        return false;
    }
 
    return true;
}
 
// Datensatz-CRC hinzufügen
QString ToolBox::add_CRC(QString TXString)
{
    unsigned int tmpCRC = 0;
 
    char *TXBuff;
    char CRC[2];
 
    TXBuff = TXString.toLatin1().data();
 
    for(int i = 0; i < TXString.length(); i++)
    {
        tmpCRC += TXBuff[i];
    }
 
    tmpCRC %= 4096;
 
    CRC[0] = '=' + tmpCRC / 64;
    CRC[1] = '=' + tmpCRC % 64;
    CRC[2] = '\0';
 
    QString Return = TXString + QString(CRC);
 
    return Return;
}
 
// Alle Icons
QIcon ToolBox::Icon(int ID)
{
    QIcon Icons[5] ;
    Icons[0].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledred.png")), QIcon::Normal, QIcon::Off);
    Icons[1].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledyellow.png")), QIcon::Normal, QIcon::Off);
    Icons[3].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledyellow.png")), QIcon::Normal, QIcon::Off);
    Icons[4].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledoff.png")), QIcon::Normal, QIcon::Off);
    return Icons[ID];
}
 

Rev 307	Rev 314
1	/***************************************************************************	1	/***************************************************************************
2	* Copyright (C) 2008 by Manuel Schrape *	2	* Copyright (C) 2008 by Manuel Schrape *
3	* manuel.schrape@gmx.de *	3	* manuel.schrape@gmx.de *
4	* *	4	* *
5	* This program is free software; you can redistribute it and/or modify *	5	* This program is free software; you can redistribute it and/or modify *
6	* it under the terms of the GNU General Public License as published by *	6	* it under the terms of the GNU General Public License as published by *
7	* the Free Software Foundation; either version 2 of the License. *	7	* the Free Software Foundation; either version 2 of the License. *
8	* *	8	* *
9	* This program is distributed in the hope that it will be useful, *	9	* This program is distributed in the hope that it will be useful, *
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of *	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12	* GNU General Public License for more details. *	12	* GNU General Public License for more details. *
13	* *	13	* *
14	* You should have received a copy of the GNU General Public License *	14	* You should have received a copy of the GNU General Public License *
15	* along with this program; if not, write to the *	15	* along with this program; if not, write to the *
16	* Free Software Foundation, Inc., *	16	* Free Software Foundation, Inc., *
17	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *	17	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
18	***************************************************************************/	18	***************************************************************************/
19		19
20	#include "ToolBox.h"	20	#include "ToolBox.h"
21		21
22	ToolBox::ToolBox()	22	ToolBox::ToolBox()
23	{	23	{
24	}	24	}
25		25
26	void ToolBox::Wait(int Time)	26	void ToolBox::Wait(int Time)
27	{	27	{
28	#ifndef _WIN32_	28	#ifndef _WIN32_
29	usleep(Time);	29	usleep(Time);
30	#else	30	#else
31	// sleep(Time);	31	// sleep(Time);
32	#endif	32	#endif
33	}	33	}
34		34
35	QString ToolBox::get_Float(long Wert, long Count)	35	QString ToolBox::get_Float(long Wert, int Count)
36	{	36	{
-		37	QString Temp, s_Wert;
-		38
-		39	s_Wert = QString("%1").arg(Wert);
-		40
-		41	Temp = s_Wert.left(s_Wert.length() - Count) + QString(".") + s_Wert.right(Count);
37	QString Temp;	42
38		43	/*
39	if (Wert > 0)	44	if (Wert > 0)
40	Temp = "";	45	Temp = "";
41	else	46	else
42	Temp = "-";	47	Temp = "-";
43		48
44	Temp = Temp + QString("%1").arg(Wert / Count) + "." + QString("%1").arg(Wert % Count);	49	Temp = Temp + QString("%1").arg(Wert / Count) + "." + QString("%1").arg(Wert % Count);
45		50	*/
46	return Temp;	51	return Temp;
47	}	52	}
48		53
49		54
50	// Base64 Decoder	55	// Base64 Decoder
51	bool ToolBox::Decode64(sRxData &RX, bool Long)	56	bool ToolBox::Decode64(sRxData &RX, bool Long)
52	{	57	{
53	unsigned char a,b,c,d;	58	unsigned char a,b,c,d;
54	unsigned char ptr = 0;	59	unsigned char ptr = 0;
55	unsigned char x,y,z;	60	unsigned char x,y,z;
56	int ptrOut[150];	61	int ptrOut[150];
57		62
58	int ptrIn = 3;	63	int ptrIn = 3;
59	int max = RX.String.length();	64	int max = RX.String.length();
60	int len = RX.String.length();	65	int len = RX.String.length();
61	int DecLen = 0;	66	int DecLen = 0;
62		67
63	if (RX.Input[ptrIn] == 0)	68	if (RX.Input[ptrIn] == 0)
64	{	69	{
65	qDebug("QString to Char ERROR...!!!!");	70	qDebug("QString to Char ERROR...!!!!");
66	return false;	71	return false;
67	}	72	}
68		73
69	while(len != 0)	74	while(len != 0)
70	{	75	{
71	a = RX.Input[ptrIn++] - '=';	76	a = RX.Input[ptrIn++] - '=';
72	b = RX.Input[ptrIn++] - '=';	77	b = RX.Input[ptrIn++] - '=';
73	c = RX.Input[ptrIn++] - '=';	78	c = RX.Input[ptrIn++] - '=';
74	d = RX.Input[ptrIn++] - '=';	79	d = RX.Input[ptrIn++] - '=';
75		80
76	if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden	81	if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden
77		82
78	x = (a << 2) \| (b >> 4);	83	x = (a << 2) \| (b >> 4);
79	y = ((b & 0x0f) << 4) \| (c >> 2);	84	y = ((b & 0x0f) << 4) \| (c >> 2);
80	z = ((c & 0x03) << 6) \| d;	85	z = ((c & 0x03) << 6) \| d;
81		86
82	if(len--) ptrOut[ptr++] = x; else break;	87	if(len--) ptrOut[ptr++] = x; else break;
83	if(len--) ptrOut[ptr++] = y; else break;	88	if(len--) ptrOut[ptr++] = y; else break;
84	if(len--) ptrOut[ptr++] = z; else break;	89	if(len--) ptrOut[ptr++] = z; else break;
85	}	90	}
86		91
87	for (int a=0; a<ptr; a++)	92	for (int a=0; a<ptr; a++)
88	{	93	{
89	if (Long == false)	94	if (Long == false)
90	{	95	{
91	int b1, b2, b3;	96	int b1, b2, b3;
92		97
93	b1 = ptrOut[a++];	98	b1 = ptrOut[a++];
94	b2 = ptrOut[a];	99	b2 = ptrOut[a];
95		100
96	b3 = (b2 << 8) \| b1;	101	b3 = (b2 << 8) \| b1;
97		102
98	if (b3 > 32767)	103	if (b3 > 32767)
99	b3 = b3 - 65536;	104	b3 = b3 - 65536;
100		105
101	RX.Decode[DecLen] = b3;	106	RX.Decode[DecLen] = b3;
102	DecLen++;	107	DecLen++;
103	}	108	}
104	else	109	else
105	{	110	{
106	RX.Decode[DecLen] = ptrOut[a];	111	RX.Decode[DecLen] = ptrOut[a];
107	DecLen++;	112	DecLen++;
108	}	113	}
109		114
110	RX.DecLen = DecLen;	115	RX.DecLen = DecLen;
111	}	116	}
112	return true;	117	return true;
113	}	118	}
114		119
115	// Base64 Encoder	120	// Base64 Encoder
116	QString ToolBox::Encode64(char Data[150],unsigned int Length)	121	QString ToolBox::Encode64(char Data[150],unsigned int Length)
117	{	122	{
118	unsigned int pt = 0;	123	unsigned int pt = 0;
119	unsigned char a,b,c;	124	unsigned char a,b,c;
120	unsigned char ptr = 0;	125	unsigned char ptr = 0;
121		126
122	char TX_Buff[150];	127	char TX_Buff[150];
123		128
124	while(Length > 0)	129	while(Length > 0)
125	{	130	{
126	if(Length) { a = Data[ptr++]; Length--;} else a = 0;	131	if(Length) { a = Data[ptr++]; Length--;} else a = 0;
127	if(Length) { b = Data[ptr++]; Length--;} else b = 0;	132	if(Length) { b = Data[ptr++]; Length--;} else b = 0;
128	if(Length) { c = Data[ptr++]; Length--;} else c = 0;	133	if(Length) { c = Data[ptr++]; Length--;} else c = 0;
129		134
130	TX_Buff[pt++] = '=' + (a >> 2);	135	TX_Buff[pt++] = '=' + (a >> 2);
131	TX_Buff[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));	136	TX_Buff[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));
132	TX_Buff[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));	137	TX_Buff[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));
133	TX_Buff[pt++] = '=' + ( c & 0x3f);	138	TX_Buff[pt++] = '=' + ( c & 0x3f);
134	}	139	}
135	TX_Buff[pt] = 0;	140	TX_Buff[pt] = 0;
136		141
137	return QString(TX_Buff);	142	return QString(TX_Buff);
138	}	143	}
139		144
140	// Datensatz nach 8bit Integer	145	// Datensatz nach 8bit Integer
141	int ToolBox::Data2Char(int *Data , int Start, bool is_signed)	146	int ToolBox::Data2Char(int *Data , int Start, bool is_signed)
142	{	147	{
143	int Out = (Data[Start]);	148	int Out = (Data[Start]);
144		149
145	if ((Out > 128) && (is_signed))	150	if ((Out > 128) && (is_signed))
146	Out = Out - 256;	151	Out = Out - 256;
147		152
148	return Out;	153	return Out;
149		154
150	}	155	}
151		156
152	// Datensatz nach 8bit Integer	157	// Datensatz nach 8bit Integer
153	int ToolBox::Char2Data(int Data)	158	int ToolBox::Char2Data(int Data)
154	{	159	{
155	if (Data < 0)	160	if (Data < 0)
156	{	161	{
157	return Data + 256;	162	return Data + 256;
158	}	163	}
159	return Data;	164	return Data;
160	}	165	}
161		166
162		167
163	// Datensatz nach 16bit Integer	168	// Datensatz nach 16bit Integer
164	int ToolBox::Data2Int(int *Data , int Start, bool is_signed)	169	int ToolBox::Data2Int(int *Data , int Start, bool is_signed)
165	{	170	{
166	int Out = (Data[Start+1]<<8) \| (Data[Start+0]);	171	int Out = (Data[Start+1]<<8) \| (Data[Start+0]);
167		172
168	if ((Out > 32767) && (is_signed))	173	if ((Out > 32767) && (is_signed))
169	Out = Out - 65536;	174	Out = Out - 65536;
170		175
171	return Out;	176	return Out;
172		177
173	}	178	}
174		179
175	// Datensatz nach 32bit Long	180	// Datensatz nach 32bit Long
176	long ToolBox::Data2Long(int *Data , int Start, bool is_signed)	181	long ToolBox::Data2Long(int *Data , int Start, bool is_signed)
177	{	182	{
178	long Out = (Data[Start+3]<<24) \| (Data[Start+2]<<16) \| (Data[Start+1]<<8) \| (Data[Start+0]);	183	long Out = (Data[Start+3]<<24) \| (Data[Start+2]<<16) \| (Data[Start+1]<<8) \| (Data[Start+0]);
179		184
180	if ((Out > 32767) && (is_signed))	185	if ((Out > 32767) && (is_signed))
181	Out = Out;	186	Out = Out;
182		187
183	return Out;	188	return Out;
184	}	189	}
185		190
186	// Datensatz nach QString	191	// Datensatz nach QString
187	QString ToolBox::Data2QString(int Data[150], int Start, int End)	192	QString ToolBox::Data2QString(int Data[150], int Start, int End)
188	{	193	{
189	char String[150];	194	char String[150];
190	for (int a = Start; a < End; a++)	195	for (int a = Start; a < End; a++)
191	{	196	{
192	String[a - Start] = Data[a];	197	String[a - Start] = Data[a];
193	}	198	}
194	String[End - Start] = '\0';	199	String[End - Start] = '\0';
195		200
196	return QString(String);	201	return QString(String);
197	}	202	}
198		203
199	// Datensatz-CRC prüfen	204	// Datensatz-CRC prüfen
200	bool ToolBox::check_CRC(QString RXString)	205	bool ToolBox::check_CRC(QString RXString)
201	{	206	{
202	int CRC = 0;	207	int CRC = 0;
203	char *RX;	208	char *RX;
204		209
205	int Length = RXString.length();	210	int Length = RXString.length();
206		211
207	RX = RXString.toLatin1().data();	212	RX = RXString.toLatin1().data();
208		213
209	if (RX[1] == 127)	214	if (RX[1] == 127)
210	{	215	{
211	RX[1] = 0;	216	RX[1] = 0;
212	}	217	}
213		218
214	for(int i=0; i < Length-2; i++)	219	for(int i=0; i < Length-2; i++)
215	{	220	{
216	CRC+=RX[i];	221	CRC+=RX[i];
217	}	222	}
218		223
219	CRC = CRC % 4096;	224	CRC = CRC % 4096;
220		225
221	if(RX[Length - 2] != ('=' + (CRC / 64)))	226	if(RX[Length - 2] != ('=' + (CRC / 64)))
222	{	227	{
223	return false;	228	return false;
224	}	229	}
225		230
226	if(RX[Length - 1] != ('=' + CRC % 64))	231	if(RX[Length - 1] != ('=' + CRC % 64))
227	{	232	{
228	return false;	233	return false;
229	}	234	}
230		235
231	return true;	236	return true;
232	}	237	}
233		238
234	// Datensatz-CRC hinzufügen	239	// Datensatz-CRC hinzufügen
235	QString ToolBox::add_CRC(QString TXString)	240	QString ToolBox::add_CRC(QString TXString)
236	{	241	{
237	unsigned int tmpCRC = 0;	242	unsigned int tmpCRC = 0;
238		243
239	char *TXBuff;	244	char *TXBuff;
240	char CRC[2];	245	char CRC[2];
241		246
242	TXBuff = TXString.toLatin1().data();	247	TXBuff = TXString.toLatin1().data();
243		248
244	for(int i = 0; i < TXString.length(); i++)	249	for(int i = 0; i < TXString.length(); i++)
245	{	250	{
246	tmpCRC += TXBuff[i];	251	tmpCRC += TXBuff[i];
247	}	252	}
248		253
249	tmpCRC %= 4096;	254	tmpCRC %= 4096;
250		255
251	CRC[0] = '=' + tmpCRC / 64;	256	CRC[0] = '=' + tmpCRC / 64;
252	CRC[1] = '=' + tmpCRC % 64;	257	CRC[1] = '=' + tmpCRC % 64;
253	CRC[2] = '\0';	258	CRC[2] = '\0';
254		259
255	QString Return = TXString + QString(CRC);	260	QString Return = TXString + QString(CRC);
256		261
257	return Return;	262	return Return;
258	}	263	}
259		264
260	// Alle Icons	265	// Alle Icons
261	QIcon ToolBox::Icon(int ID)	266	QIcon ToolBox::Icon(int ID)
262	{	267	{
263	QIcon Icons[5] ;	268	QIcon Icons[5] ;
264	Icons[0].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledred.png")), QIcon::Normal, QIcon::Off);	269	Icons[0].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledred.png")), QIcon::Normal, QIcon::Off);
265	Icons[1].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledyellow.png")), QIcon::Normal, QIcon::Off);	270	Icons[1].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledyellow.png")), QIcon::Normal, QIcon::Off);
266	Icons[3].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledyellow.png")), QIcon::Normal, QIcon::Off);	271	Icons[3].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledyellow.png")), QIcon::Normal, QIcon::Off);
267	Icons[4].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledoff.png")), QIcon::Normal, QIcon::Off);	272	Icons[4].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledoff.png")), QIcon::Normal, QIcon::Off);
268	return Icons[ID];	273	return Icons[ID];
269	}	274	}
270		275

Subversion Repositories Projects

(root)/QMK-Groundstation/trunk/Classes/ToolBox.cpp @ 481 - Rev 307 → 314