Subversion Repositories Projects

Compare Revisions

Ignore whitespace Rev 225 → Rev 224

/QMK-Groundstation/trunk/ToolBox.cpp
0,0 → 1,263
/***************************************************************************
* 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()
{
}
 
QString ToolBox::get_Float(long Wert, long Count)
{
QString Temp;
 
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 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[30] ;
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);
 
Icons[5].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/application-exit.png")), QIcon::Normal, QIcon::Off);
Icons[6].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/media-playback-stop.png")), QIcon::Normal, QIcon::Off);
Icons[7].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/media-record.png")), QIcon::Normal, QIcon::Off);
Icons[8].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/network-connect.png")), QIcon::Normal, QIcon::Off);
Icons[9].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/network-disconnect.png")), QIcon::Normal, QIcon::Off);
Icons[10].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/utilities-system-monitor.png")), QIcon::Normal, QIcon::Off);
 
Icons[11].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/applications-system.png")), QIcon::Normal, QIcon::Off);
Icons[12].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/applications-internet.png")), QIcon::Normal, QIcon::Off);
Icons[13].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/preferences-other.png")), QIcon::Normal, QIcon::Off);
Icons[14].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/preferences-system.png")), QIcon::Normal, QIcon::Off);
Icons[15].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/folder.png")), QIcon::Normal, QIcon::Off);
Icons[16].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/folder-print.png")), QIcon::Normal, QIcon::Off);
Icons[17].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/clock.png")), QIcon::Normal, QIcon::Off);
Icons[18].addPixmap(QPixmap(QString::fromUtf8(":/Actions/Images/22X22/configure.png")), QIcon::Normal, QIcon::Off);
 
Icons[20].addPixmap(QPixmap(QString::fromUtf8(":/Arrows/Images/32X32/arrow-up-double.png")), QIcon::Normal, QIcon::Off);
Icons[21].addPixmap(QPixmap(QString::fromUtf8(":/Arrows/Images/32X32/arrow-up.png")), QIcon::Normal, QIcon::Off);
Icons[22].addPixmap(QPixmap(QString::fromUtf8(":/Arrows/Images/32X32/arrow-down-double.png")), QIcon::Normal, QIcon::Off);
Icons[23].addPixmap(QPixmap(QString::fromUtf8(":/Arrows/Images/32X32/arrow-down.png")), QIcon::Normal, QIcon::Off);
Icons[24].addPixmap(QPixmap(QString::fromUtf8(":/Arrows/Images/32X32/arrow-left-double.png")), QIcon::Normal, QIcon::Off);
Icons[25].addPixmap(QPixmap(QString::fromUtf8(":/Arrows/Images/32X32/arrow-left.png")), QIcon::Normal, QIcon::Off);
Icons[26].addPixmap(QPixmap(QString::fromUtf8(":/Arrows/Images/32X32/arrow-right-double.png")), QIcon::Normal, QIcon::Off);
Icons[27].addPixmap(QPixmap(QString::fromUtf8(":/Arrows/Images/32X32/arrow-right.png")), QIcon::Normal, QIcon::Off);
 
return Icons[ID];
}
/QMK-Groundstation/trunk/ToolBox.h
0,0 → 1,41
/***************************************************************************
* 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. *
***************************************************************************/
#ifndef TOOLBOX_H
#define TOOLBOX_H
 
#include <QString>
#include <QIcon>
#include "global.h"
 
class ToolBox
{
public :
ToolBox();
static bool Decode64(sRxData &RX, bool Long = true);
static QString Encode64(char Data[150],unsigned int Length);
static bool check_CRC(QString RXString);
static QString add_CRC(QString TXString);
static int Data2Int(int *Data , int Start, bool is_signed = true);
static long Data2Long(int *Data , int Start, bool is_signed = true);
static QString Data2QString(int Data[150], int Start = 0, int End = 150);
static QIcon Icon(int ID);
static QString get_Float(long Wert, long Count);
};
 
#endif // TOOLBOX_H
/QMK-Groundstation/trunk/cSettings.cpp
0,0 → 1,225
/***************************************************************************
* 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 <QCoreApplication>
#include <QSettings>
#include <QDir>
 
#include "cSettings.h"
 
cSettings::cSettings()
{
read_Settings();
 
Analog1.LogView.resize(MaxAnalog);
Analog1.PlotView.resize(MaxAnalog);
 
// Alte Settingsstruktur Löschen.
if (Settings_ID == 1)
{
qDebug("Konvertiere Einstellungen Version 1 -> 2");
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("AnalogWerte");
for (int a = 0; a < MaxAnalog; a++)
{
Analog1.LogView.setBit(a, Setting.value(("Analog_" + QString("%1").arg(a) + "_Log"), Def_Log[a]).toBool());
Analog1.PlotView.setBit(a, Setting.value(("Analog_" + QString("%1").arg(a) + "_Plot"), Def_Plot_Show[a]).toBool());
Analog1.Label[a] = Setting.value(("Analog_" + QString("%1").arg(a)), Def_AnalogNames[a]).toString();
}
Setting.endGroup();
 
Settings_ID = 2;
 
Setting.remove("AnalogWerte-FC");
Setting.remove("AnalogWerte");
 
write_Settings_Analog();
write_Settings_AnalogLabels();
}
else
{
read_Settings_Analog();
read_Settings_AnalogLabels();
}
}
 
// Config der Analogwert-Anzeige (Plotter / CVS)
void cSettings::write_Settings_Analog(int ID)
{
QString Hardware = HardwareType[ID];
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("Analog-Werte");
Setting.setValue(Hardware + "-LogView", QBitArray(Analog1.LogView));
Setting.setValue(Hardware + "-PlotView", QBitArray(Analog1.PlotView));
Setting.endGroup();
}
 
void cSettings::read_Settings_Analog(int ID)
{
QBitArray Def_View;
Def_View.fill(true,MaxAnalog);
 
QString Hardware = HardwareType[ID];
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("Analog-Werte");
Analog1.LogView = Setting.value(Hardware + "-LogView", QBitArray(Def_View)).value<QBitArray>();
Analog1.PlotView = Setting.value(Hardware + "-PlotView", QBitArray(Def_View)).value<QBitArray>();
Setting.endGroup();
}
 
// Labels der Analogwerte.
void cSettings::write_Settings_AnalogLabels(int ID)
{
QString Hardware = HardwareType[ID];
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation-Labels");
 
Setting.beginGroup("Analog-Labels-" + Hardware);
Setting.setValue("Version", Analog1.Version);
for (int a=0; a<MaxAnalog; a++)
{
Setting.setValue("Label_" + QString("%1").arg(a), Analog1.Label[a]);
}
Setting.endGroup();
}
 
void cSettings::read_Settings_AnalogLabels(int ID)
{
QString Hardware = HardwareType[ID];
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation-Labels");
 
Setting.beginGroup("Analog-Labels-" + Hardware);
Analog1.Version = Setting.value(("Version"), "0").toString();
for (int a=0; a<MaxAnalog; a++)
{
Analog1.Label[a] = Setting.value(("Label_" + QString("%1").arg(a)), Def_AnalogNames[a]).toString();
}
Setting.endGroup();
}
 
// Programmeinstellungen
void cSettings::read_Settings()
{
QBitArray Def_TabViews;
Def_TabViews.fill(true, 6);
 
QDir Dir;
 
QString HomeDir = (QString(Dir.homePath() + "/"));
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("Global");
Settings_ID = Setting.value("Settings ID", 1).toInt();
Setting.endGroup();
 
Setting.beginGroup("Port");
TTY.Port = Setting.value("TTY", QString("/dev/ttyUSB0")).toString();
Setting.endGroup();
 
Setting.beginGroup("GUI");
GUI.isMax = Setting.value("IsMax",false).toBool();
GUI.Size = Setting.value("Size", QSize(700, 300)).toSize();
GUI.Point = Setting.value("Point",QPoint(1,1)).toPoint();
GUI.TabViews = Setting.value("TabViews", QBitArray(Def_TabViews)).value<QBitArray>();
GUI.Term_Info = Setting.value("Terminal_Info",false).toBool();
GUI.Term_Data = Setting.value("Terminal_Data",true).toBool();
GUI.Term_Always = Setting.value("Terminal_Always",false).toBool();
GUI.Term_Send = Setting.value("Terminal_Send",true).toBool();
Setting.endGroup();
 
Setting.beginGroup("Dirs");
DIR.Logging = Setting.value("LogDir", HomeDir).toString();
DIR.Parameter = Setting.value("ParDir", HomeDir).toString();
Setting.endGroup();
 
Setting.beginGroup("MKData");
Data.Plotter_Count = Setting.value("Plotter_Count", 100).toInt();
Data.Debug_Fast = Setting.value("Debug_Fast", 100).toInt();
Data.Debug_Slow = Setting.value("Debug_Slow", 500).toInt();
Data.Debug_Off = Setting.value("Debug_Off", 1000).toInt();
Data.Navi_Fast = Setting.value("Navi_Fast", 100).toInt();
Data.Navi_Slow = Setting.value("Navi_Slow", 500).toInt();
Data.Navi_Off = Setting.value("Navi_Off", 1000).toInt();
Setting.endGroup();
 
Setting.beginGroup("GoogleEarth-Server");
Server.Port = Setting.value("Port", 10664).toString();
Server.StartServer = Setting.value("StartServer", false).toBool();
Server.ToGround = Setting.value("ToGround", false).toBool();
Setting.endGroup();
 
}
 
void cSettings::write_Settings()
{
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("Global");
Setting.setValue("Settings ID", Settings_ID);
Setting.endGroup();
 
Setting.beginGroup("Port");
Setting.setValue("TTY", TTY.Port);
Setting.endGroup();
 
Setting.beginGroup("Dirs");
Setting.setValue("LogDir", DIR.Logging);
Setting.setValue("ParDir", DIR.Parameter);
Setting.endGroup();
 
Setting.beginGroup("GUI");
Setting.setValue("IsMax", GUI.isMax);
Setting.setValue("Size", GUI.Size);
Setting.setValue("Point", GUI.Point);
Setting.setValue("TabViews", QBitArray(GUI.TabViews));
Setting.setValue("Terminal_Info", GUI.Term_Info);
Setting.setValue("Terminal_Data", GUI.Term_Data);
Setting.setValue("Terminal_Always", GUI.Term_Always);
Setting.setValue("Terminal_Send", GUI.Term_Send);
Setting.endGroup();
 
Setting.beginGroup("MKData");
Setting.setValue("Plotter_Count", Data.Plotter_Count);
Setting.setValue("Debug_Fast", Data.Debug_Fast);
Setting.setValue("Debug_Slow", Data.Debug_Slow);
Setting.setValue("Debug_Off", Data.Debug_Off);
Setting.setValue("Navi_Fast", Data.Navi_Fast);
Setting.setValue("Navi_Slow", Data.Navi_Slow);
Setting.setValue("Navi_Off", Data.Navi_Off);
Setting.endGroup();
 
Setting.beginGroup("GoogleEarth-Server");
Setting.setValue("Port", Server.Port);
Setting.setValue("StartServer", Server.StartServer);
Setting.setValue("ToGround", Server.ToGround);
Setting.endGroup();
 
}
 
cSettings::~cSettings()
{
}
 
 
/QMK-Groundstation/trunk/cSettings.h
0,0 → 1,97
/***************************************************************************
* 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. *
***************************************************************************/
#ifndef CSETTINGS_H
#define CSETTINGS_H
 
#include "global.h"
 
struct set_TTY
{
QString Port;
};
 
struct set_GUI
{
bool isMax;
QSize Size;
QPoint Point;
QBitArray TabViews;
bool Term_Info;
bool Term_Data;
bool Term_Always;
bool Term_Send;
};
 
struct set_Data
{
int Plotter_Count;
int Debug_Fast;
int Debug_Slow;
int Debug_Off;
int Navi_Fast;
int Navi_Slow;
int Navi_Off;
};
 
struct set_DIR
{
QString Logging;
QString Parameter;
};
 
struct set_Server
{
QString Port;
bool StartServer;
bool ToGround;
};
 
 
struct set_Analog
{
QString Version;
QString Label[MaxAnalog];
QBitArray PlotView;
QBitArray LogView;
};
 
class cSettings
{
public:
cSettings();
~cSettings();
 
int Settings_ID;
 
set_GUI GUI;
set_DIR DIR;
set_TTY TTY;
set_Analog Analog1;
set_Data Data;
set_Server Server;
 
void read_Settings();
void write_Settings();
void write_Settings_Analog(int ID = 0);
void read_Settings_Analog(int ID = 0);
void write_Settings_AnalogLabels(int ID = 0);
void read_Settings_AnalogLabels(int ID = 0);
};
 
#endif