WebSVN - Projects - Diff - Rev 513 and 524 - /QMK-Groundstation/branches/libMK/libMK/Handler.cpp


#include "Handler.h"
#include "FlightLog.h"
#include <sstream>
#include <string>
 
/**
 * Constructor that gets a communication instance
 */
Handler::Handler(Communication * com, KopterData * data) {
    this->com = com;
    this->data = data;
}
 
//-------------FlightCtrl commands--------------------
/**
 * read settings from FlightCtrl (settings index 0x00-0x05)
 */
void Handler::get_flightctrl_settings(int index) {
    FlightLog::info_FC("getting FlightCtrl settings");
    char tx_data[2] = {index, 0};
    com->send_cmd('q', ADDRESS_FC, tx_data, 1, true);
}
 
/**
 * write settings to FlightCtrl
 */
void Handler::set_flightctrl_settings(char * tx_data) {
    FlightLog::info_FC("setting FlightCtrl settings");
    com->send_cmd('s', ADDRESS_FC, tx_data, MaxParameter+2, true);
}
 
/**
 * test one or more motors
 */
void Handler::motor_test(sMotorData motor) {
    char tx_data[MAX_MOTORS];
    for (int z = 0; z<MAX_MOTORS; z++)
    {
        tx_data[z] = motor.desired_speed[z];
    }
    FlightLog::info_FC("testing motor");
    com->send_cmd('t', ADDRESS_FC, tx_data, MAX_MOTORS, false);
}
 
void Handler::reset_motor() {
    for (int z = 0; z<MAX_MOTORS; z++)
    {
        data->motor.desired_speed[z] = 0;
    }
 
    motor_test(data->motor);
}
 
/**
 * read mixer values from FlightCtrl
 */
void Handler::read_motor_mixer() {
    FlightLog::info_FC("reading motor mixer values");
    char tx_data[1] = {0};
    //com->log("read motor mixer");
    com->send_cmd('n', ADDRESS_FC, tx_data, 1, true);
}
 
/**
 * write motor mixer values to FlightCtrl
 */
void Handler::write_motor_mixer(char * tx_data, int length) {
    FlightLog::info_FC("setting motor mixer values");
    com->send_cmd('m', ADDRESS_FC, tx_data, length, true);
}
 
//FIXME: implement me!
int Handler::get_motor_config(char * tx_data) {
    FlightLog::error("get motor config not implemented");
    return -1;
}
 
//-------------NaviCtrl commands--------------------
/**
 * set debug values for NaviCtrl
 */
void Handler::set_navictrl_debug(int speed) {
    FlightLog::info_NC("setting NaviCtrl debug speed");
    char tx_data[1] = { speed };
    com->send_cmd('o', ADDRESS_NC, tx_data, 1, false);
}
 
/**
 * stop debug for NaviCtrl
 */
void Handler::stop_navictrl_debug() {
    set_navictrl_debug(0);
}
 
/**
 * send a waypoint to the NaviCtrl (the MikroKopter will fly to the position emidiately)
 */
void Handler::send_waypoint(Waypoint_t desired_pos) {
    FlightLog::info_GPS("sending Waypoint");
    com->send_cmd('s', ADDRESS_NC, (char *)&desired_pos, sizeof(desired_pos), false);
}
 
/**
 * add waypoint to waypoint list
 */
void Handler::add_waypoint(Waypoint_t wp) {
    FlightLog::info_GPS("adding Waypoint");
    com->send_cmd('w', ADDRESS_NC, (char *)&wp, sizeof(wp), false);
}
 
/**
 * clear waypoint list on MK
 */
void Handler::delete_waypoints() {
    Waypoint_t wp;
    wp.Position.Status = INVALID;
    send_waypoint(wp);
}
//-------------switch between Hardware--------------------
void Handler::switch_navictrl() {
    FlightLog::info("switching to NaviCtrl");
    char tx_data[6] = { 0x1B, 0x1B, 0x55, 0xAA, 0x00, '\r'};
    com->send_cmd('#', ADDRESS_NC, tx_data, 6, false);
}
 
void Handler::switch_flightctrl() {
    FlightLog::info("switching to FlightCtrl");
    char tx_data[1] = { 0 };
    com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);
}
 
void Handler::switch_mk3mag() {
    FlightLog::info("switching to MK3MAG");
    char tx_data[1] = { 1 };
    com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);
}
 
//-------------commands for MK3MAG-----------------
 
 
//-------------commands for all--------------------
 
/**
 * set debug values for all components
 */
void Handler::set_all_debug(int speed) {
    FlightLog::info("setting debug speed");
    char tx_data[1] = { speed };
    com->send_cmd('d', ADDRESS_ALL, tx_data, 1, false);
}
 
/**
 * stop debug for all components
 */
void Handler::stop_all_debug() {
    set_all_debug(0);
}
 
/**
 * get all analog labels
 */
void Handler::get_analog() {
    FlightLog::info("get analog values");
    char tx_data[1] = { 0 };
    com->send_cmd('a', ADDRESS_ALL, tx_data, 1, true);
}
 
/**
 * get values from LCD / show LCD
 */
void Handler::show_lcd() {
    FlightLog::info("show LCD");
    char tx_data[1] = {0};
    com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
}
 
/**
 * got to next LCD Page
 */
void Handler::lcd_up() {
    FlightLog::info("going up one LCD page");
    char tx_data[2] = { 0, 0 };
    if (data->lcd_cur != data->lcd_max)
        tx_data[0] = data->lcd_cur+1;
    com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
}
 
/**
 * got to previous LCD Page
 */
void Handler::lcd_down() {
    FlightLog::info("going down one LCD page");
    char tx_data[2] = { 0, 0 };
    if (data->lcd_cur != 0)
        tx_data[0] = data->lcd_cur-1;
    com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
}
 
void Handler::get_version() {
    FlightLog::info("get version");
    //TODO: Check if is this correct or do we need data from switch_...
    char tx_data[1] = { 0 };
    com->send_cmd('v', ADDRESS_ALL, tx_data, 0, true);
}
 
void Handler::get_ppm_channels() {
     FlightLog::info("get PPM channels");
    char tx_data[1] = { 0 };
    com->send_cmd('p', ADDRESS_ALL, tx_data, 0, false);
}
 
void Handler::new_navi_data(char * data) {
    std::string mode;
    switch(data[N_NC_FLAGS])
    {
        case 0x01 : mode = "Free"; break;
        case 0x02 : mode = "Position Hold"; break;
        case 0x04 : mode = "Coming Home"; break;
        case 0x08 : mode = "Range Limit"; break;
        case 0x10 : mode = "Serial Error"; break;
        case 0x20 : mode = "Target reached"; break;
        case 0x40 : mode = "Manual Control"; break;
    }
   
}
 
/**
 * receive data
 */
void Handler::receive_data(char * incomming, int length) {
    if (incomming[0] != '#') {
        FlightLog::error("this frame is not correct");
        FlightLog::info(incomming);
        return;
    }
    int hardwareID = incomming[1] - 'a';
 
    //The cmd is also known as ID-Byte (or ID for short) in the wiki-dokumentation
    char cmd = incomming[2];
    //decoded data
    unsigned char data[MAX_DATA_SIZE];
 
    Parser::decode64(incomming, length, data, 3);
 
    switch(hardwareID)
    {
        case ADDRESS_FC :
            switch(cmd)
            {
                // Motor-Mixer
                case 'N' :
                    com->stop_resend();
                    //decoded data
                    FlightLog::info_FC("received motortest values from FlightCtrl");
                    if (data[0] == VERSION_MIXER)
                    {
                        //TODO: Handler::receivedMotorConfig(incomming)
                        //f_MotorMixer->set_MotorConfig(RX);
                    }
                    break;
                // Motor-Mixer Schreib-Bestätigung
                case 'M' :
                    com->stop_resend();
 
                    if (data[0] == 1)
                    {
                        FlightLog::info_FC("motor values written to FlightCtrl.");
                        //lb_Status->setText(tr("MotorMixer-Daten in FC geschrieben."));
                    } else {
                        FlightLog::warning("could not write motor values to FlightCtrl!");
                    }
                    break;
 
                // Stick-Belegung der Fernsteuerung
                case 'P' : // DONE 0.71g
                    FlightLog::info_FC("received stick-settings:");
                    for (int i = 1; i <= 8; i++) {
                        std::stringstream d;
                        d << "Stickvalue for Stick nr. " << i << ": " << Parser::dataToInt((char *)data, i*2, true);;
                        std::string val;
                        d >> val;
                        FlightLog::info_FC((char *)val.c_str());
                    }
                    /*f_Settings->pb_K1->setValue(Parser::dataToInt(RX.decode,  2,true));
                    f_Settings->pb_K2->setValue(Parser::dataToInt(RX.decode,  4,true));
                    f_Settings->pb_K3->setValue(Parser::dataToInt(RX.decode,  6,true));
                    f_Settings->pb_K4->setValue(Parser::dataToInt(RX.decode,  8,true));
                    f_Settings->pb_K5->setValue(Parser::dataToInt(RX.decode, 10 ,true));
                    f_Settings->pb_K6->setValue(Parser::dataToInt(RX.decode, 12,true));
                    f_Settings->pb_K7->setValue(Parser::dataToInt(RX.decode, 14,true));
                    f_Settings->pb_K8->setValue(Parser::dataToInt(RX.decode, 16,true));*/
                    break;
                // Settings lesen
                case 'Q' : // DONE 0.71g
                    com->stop_resend();
                    FlightLog::info_FC("received settings");
                    if (data[1] == VERSION_SETTINGS)
                    {
                        int settings_id = data[0];
                        std::stringstream d;
                        d << "Settings-ID: " << settings_id;
                        std::string val;
                        d >> val;
                        FlightLog::info_FC((char *)val.c_str());
                        for (int i = 0; i < MaxParameter; i++) {
                            d.flush();
                            d << "Value for Parameter nr. " << i << ": " << (int)data[i+2];
                            d >> val;
                            FlightLog::info_FC((char *)val.c_str());
                        }
                       
                        /*for (int a = 0; a < MaxParameter; a++)
                        {
                            FCSettings[a] = RX.decode[a + 2];
                        }
                        f_Settings->show_FCSettings(Settings_ID, FCSettings);
                        f_Settings->pb_Read->setEnabled(true);
                        f_Settings->pb_Write->setEnabled(true);*/
                    }
                    else
                    {
                        FlightLog::error("wrong FlightCtrl version");
                        /*f_Settings->pb_Read->setDisabled(true);
                        f_Settings->pb_Write->setDisabled(true);
 
                        QString name = QString("Versionen inkompatibel.\n") +
                                    QString("Version von GroundStation benoetigt: ") +
                                    QString(VERSION_SETTINGS) +
                                    QString("\nVersion auf der FlightCtrl: ") +
                                    QString(RX.decode[1]) +
                                    QString("\nParameterbearbeitung nicht moeglich.");
                        QMessageBox::warning(this, QA_NAME,
                                name, QMessageBox::Ok);*/
                    }
                    break;
                // Settings written
                case 'S' : // DONE 0.71g
                    com->stop_resend();
                    FlightLog::info_FC("settings written successfully");
                    //TODO: QMessagebox("settings written successful") ?
                    break;
            }
 
        case ADDRESS_NC :
            switch(cmd)
            {
                // Navigationsdaten
                case 'O' : // NOT DONE 0.12h
                    //new_NaviData(RX);
                    FlightLog::info_NC("received navigation data");
                    break;
            }
//        case ADDRESS_MK3MAG :
 
        default :
            switch(cmd)
            {
                // LCD-Anzeige
                case 'L' : // DONE 0.71g
                    com->stop_resend();
                    FlightLog::info("received LCD page.");
                    /*int LCD[MAX_DATA_SIZE];
                    memcpy(LCD,RX.decode, sizeof(RX.decode));
 
                    f_LCD->show_Data(LCD);
 
                    LCD_Page     = RX.decode[0];
                    LCD_MAX_Page = RX.decode[1];
                    */
                    break;
                // Analoglabels
                case 'A' : // DONE 0.71g
                    com->stop_resend();
                    FlightLog::info("received analog labels");
                    //check position
                    if (data[0] != 31) {
                        /*
                        Settings->Analog1.Label[Position] = ToolBox::dataToQString(RX.decode,1,17).trimmed();
                        if (Settings->Analog1.Label[Position] == "")
                        {
                            Settings->Analog1.Label[Position] = "A-" + QString("%1").arg(Position);
                        }
                        Position ++;
                        TX_Data[0] = Position;
                        o_Connection->send_Cmd('a', ADDRESS_ALL, TX_Data, 1, true);*/
                    } else {
                        /*
                        for (int a = 0; a < MaxAnalog; a++)
                        {
                            lb_Analog[a]->setText(Settings->Analog1.Label[a]);
                        }
                        Settings->Analog1.Version = QString(Mode.Version);
                        Settings->write_Settings_AnalogLabels(HardwareID);
                        config_Plot();*/
                    }
                    break;
                // Debug-Daten
                case 'D' : // DONE 0.71g
                    FlightLog::info("received debug data:");
                    for (int i = 0; i < MaxAnalog; i++) {
                        /*
                        Parser::dataToInt((char *)data, (i * 2) + 2, false);
                        */
                    }
                    //show_DebugData();
                    break;
                // Version
                case 'V' : // DONE 0.71h
                    com->stop_resend();
                    FlightLog::info("received version");
                    /*
                    Mode.ID            = HardwareID;
                    Mode.VERSION_MAJOR = RX.decode[0];
                    Mode.VERSION_MINOR = RX.decode[1];
                    Mode.VERSION_PATCH = RX.decode[4];
                    Mode.VERSION_SERIAL_MAJOR = RX.decode[2];
                    Mode.VERSION_SERIAL_MINOR = RX.decode[3];
 
                    Mode.Hardware   = HardwareType[Mode.ID];
                    //TODO: Funktion im Handler get_version() oder sowas
                    QString version = QString("%1").arg(RX.decode[0]) + "." +
                                        QString("%1").arg(RX.decode[1]) +
                                        QString(RX.decode[4] + 'a');
                    Mode.Version = version.toLatin1().data;
                    setWindowTitle(QA_NAME + " v" + QA_VERSION + " - " +
                                Mode.Hardware + " " +
                                Mode.Version);
 
                    if (Mode.VERSION_SERIAL_MAJOR != VERSION_SERIAL_MAJOR)
                    {
//                                AllowSend = false;
                            QMessageBox::warning(this, QA_NAME,
                            tr("Serielles Protokoll Inkompatibel. \nBitte neue Programmversion installieren,"), QMessageBox::Ok);
                    }
 
                    if (ac_NoDebug->isChecked())
                    {
                        TX_Data[0] = 0;
                    }
                    else
                    if (ac_FastDebug->isChecked())
                    {
                        TX_Data[0] = Settings->Data.Debug_Fast / 10;
                    }
                    else
                    {
                        TX_Data[0] = Settings->Data.Debug_Slow / 10;
                    }
 
                    o_Connection->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
 
                    // Wenn MK3MAG dann andauernd Daten neu anfragen.
                    if (Mode.ID == ADDRESS_MK3MAG)
                    {
                        TickerEvent[3] = true;
                        rb_SelMag->setChecked(true);
                    }
 
                    // Wenn NaviCtrl dann hier.
                    if (Mode.ID == ADDRESS_NC)
                    {
                        rb_SelNC->setChecked(true);
 
                        if (ac_NoNavi->isChecked())
                        {
                            TX_Data[0] = 0;
                        }
                        else
                        if (ac_FastNavi->isChecked())
                        {
                            TX_Data[0] = Settings->Data.Navi_Fast / 10;
                        }
                        else
                        {
                            TX_Data[0] = Settings->Data.Navi_Slow / 10;
                        }
 
                        o_Connection->send_Cmd('o', ADDRESS_NC, TX_Data, 1, false);
                    }
 
 
                    // Wenn FlightCtrl dann Settings abfragen.
                    if (Mode.ID == ADDRESS_FC)
                    {
                        rb_SelFC->setChecked(true);
                        {
                            TX_Data[0] = 0xff;
                            TX_Data[1] = 0;
 
                            // DEP: Raus wenn Resend implementiert.
//                                ToolBox::Wait(SLEEP);
                            o_Connection->send_Cmd('q', ADDRESS_FC, TX_Data, 1, true);
                            qDebug("FC - Get Settings");
                        }
                    }
                    // Wenn nicht Lesen und Schreiben der Settings deaktivieren.
                    else
                    {
                            f_Settings->pb_Read->setDisabled(true);
                            f_Settings->pb_Write->setDisabled(true);
                    }
 
                    Settings->read_Settings_Analog(HardwareID);
                    Settings->read_Settings_AnalogLabels(HardwareID);
 
                    if (Settings->Analog1.Version != QString(Mode.Version))
                    {
                        lb_Status->setText(tr("Analoglabel-Version unterschiedlich. Lese Analoglabels neu aus."));
                        slot_ac_GetLabels();
                    }
                    else
                    for (int a = 0; a < MaxAnalog; a++)
                    {
                        lb_Analog[a]->setText(Settings->Analog1.Label[a]);
                    }
                    config_Plot();*/
                    break;
            }
    }
}

Rev 513	Rev 524
1	#include "Handler.h"	1	#include "Handler.h"
2	#include "FlightLog.h"	2	#include "FlightLog.h"
3	#include <sstream>	3	#include <sstream>
4	#include <string>	4	#include <string>
5		5
6	/**	6	/**
7	* Constructor that gets a communication instance	7	* Constructor that gets a communication instance
8	*/	8	*/
9	Handler::Handler(Communication * com, KopterData * data) {	9	Handler::Handler(Communication * com, KopterData * data) {
10	this->com = com;	10	this->com = com;
11	this->data = data;	11	this->data = data;
12	}	12	}
13		13
14	//-------------FlightCtrl commands--------------------	14	//-------------FlightCtrl commands--------------------
15	/**	15	/**
16	* read settings from FlightCtrl (settings index 0x00-0x05)	16	* read settings from FlightCtrl (settings index 0x00-0x05)
17	*/	17	*/
18	void Handler::get_flightctrl_settings(int index) {	18	void Handler::get_flightctrl_settings(int index) {
19	FlightLog::info_FC("getting FlightCtrl settings");	19	FlightLog::info_FC("getting FlightCtrl settings");
20	char tx_data[2] = {index, 0};	20	char tx_data[2] = {index, 0};
21	com->send_cmd('q', ADDRESS_FC, tx_data, 1, true);	21	com->send_cmd('q', ADDRESS_FC, tx_data, 1, true);
22	}	22	}
23		23
24	/**	24	/**
25	* write settings to FlightCtrl	25	* write settings to FlightCtrl
26	*/	26	*/
27	void Handler::set_flightctrl_settings(char * tx_data) {	27	void Handler::set_flightctrl_settings(char * tx_data) {
28	FlightLog::info_FC("setting FlightCtrl settings");	28	FlightLog::info_FC("setting FlightCtrl settings");
29	com->send_cmd('s', ADDRESS_FC, tx_data, MaxParameter+2, true);	29	com->send_cmd('s', ADDRESS_FC, tx_data, MaxParameter+2, true);
30	}	30	}
31		31
32	/**	32	/**
33	* test one or more motors	33	* test one or more motors
34	*/	34	*/
35	void Handler::motor_test(sMotorData motor) {	35	void Handler::motor_test(sMotorData motor) {
36	char tx_data[MAX_MOTORS];	36	char tx_data[MAX_MOTORS];
37	for (int z = 0; z<MAX_MOTORS; z++)	37	for (int z = 0; z<MAX_MOTORS; z++)
38	{	38	{
39	tx_data[z] = motor.desired_speed[z];	39	tx_data[z] = motor.desired_speed[z];
40	}	40	}
41	FlightLog::info_FC("testing motor");	41	FlightLog::info_FC("testing motor");
42	com->send_cmd('t', ADDRESS_FC, tx_data, MAX_MOTORS, false);	42	com->send_cmd('t', ADDRESS_FC, tx_data, MAX_MOTORS, false);
43	}	43	}
44		44
45	void Handler::reset_motor() {	45	void Handler::reset_motor() {
46	for (int z = 0; z<MAX_MOTORS; z++)	46	for (int z = 0; z<MAX_MOTORS; z++)
47	{	47	{
48	data->motor.desired_speed[z] = 0;	48	data->motor.desired_speed[z] = 0;
49	}	49	}
50		50
51	motor_test(data->motor);	51	motor_test(data->motor);
52	}	52	}
53		53
54	/**	54	/**
55	* read mixer values from FlightCtrl	55	* read mixer values from FlightCtrl
56	*/	56	*/
57	void Handler::read_motor_mixer() {	57	void Handler::read_motor_mixer() {
58	FlightLog::info_FC("reading motor mixer values");	58	FlightLog::info_FC("reading motor mixer values");
59	char tx_data[1] = {0};	59	char tx_data[1] = {0};
60	//com->log("read motor mixer");	60	//com->log("read motor mixer");
61	com->send_cmd('n', ADDRESS_FC, tx_data, 1, true);	61	com->send_cmd('n', ADDRESS_FC, tx_data, 1, true);
62	}	62	}
63		63
64	/**	64	/**
65	* write motor mixer values to FlightCtrl	65	* write motor mixer values to FlightCtrl
66	*/	66	*/
67	void Handler::write_motor_mixer(char * tx_data, int length) {	67	void Handler::write_motor_mixer(char * tx_data, int length) {
68	FlightLog::info_FC("setting motor mixer values");	68	FlightLog::info_FC("setting motor mixer values");
69	com->send_cmd('m', ADDRESS_FC, tx_data, length, true);	69	com->send_cmd('m', ADDRESS_FC, tx_data, length, true);
70	}	70	}
-		71
71		72	//FIXME: implement me!
-		73	int Handler::get_motor_config(char * tx_data) {
72	int Handler::get_motor_config(char * tx_data) {	74	FlightLog::error("get motor config not implemented");
73	return -1;	75	return -1;
74	}	76	}
75		77
76	//-------------NaviCtrl commands--------------------	78	//-------------NaviCtrl commands--------------------
77	/**	79	/**
78	* set debug values for NaviCtrl	80	* set debug values for NaviCtrl
79	*/	81	*/
80	void Handler::set_navictrl_debug(int speed) {	82	void Handler::set_navictrl_debug(int speed) {
81	FlightLog::info_NC("setting NaviCtrl debug speed");	83	FlightLog::info_NC("setting NaviCtrl debug speed");
82	char tx_data[1] = { speed };	84	char tx_data[1] = { speed };
83	com->send_cmd('o', ADDRESS_NC, tx_data, 1, false);	85	com->send_cmd('o', ADDRESS_NC, tx_data, 1, false);
84	}	86	}
85		87
86	/**	88	/**
87	* stop debug for NaviCtrl	89	* stop debug for NaviCtrl
88	*/	90	*/
89	void Handler::stop_navictrl_debug() {	91	void Handler::stop_navictrl_debug() {
90	set_navictrl_debug(0);	92	set_navictrl_debug(0);
91	}	93	}
92		94
93	/**	95	/**
94	* send a waypoint to the NaviCtrl (the MikroKopter will fly to the position emidiately)	96	* send a waypoint to the NaviCtrl (the MikroKopter will fly to the position emidiately)
95	*/	97	*/
96	void Handler::send_waypoint(Waypoint_t desired_pos) {	98	void Handler::send_waypoint(Waypoint_t desired_pos) {
97	FlightLog::info_GPS("sending Waypoint");	99	FlightLog::info_GPS("sending Waypoint");
98	com->send_cmd('s', ADDRESS_NC, (char *)&desired_pos, sizeof(desired_pos), false);	100	com->send_cmd('s', ADDRESS_NC, (char *)&desired_pos, sizeof(desired_pos), false);
99	}	101	}
100		102
101	/**	103	/**
102	* add waypoint to waypoint list	104	* add waypoint to waypoint list
103	*/	105	*/
104	void Handler::add_waypoint(Waypoint_t wp) {	106	void Handler::add_waypoint(Waypoint_t wp) {
105	FlightLog::info_GPS("adding Waypoint");	107	FlightLog::info_GPS("adding Waypoint");
106	com->send_cmd('w', ADDRESS_NC, (char *)&wp, sizeof(wp), false);	108	com->send_cmd('w', ADDRESS_NC, (char *)&wp, sizeof(wp), false);
107	}	109	}
108		110
109	/**	111	/**
110	* clear waypoint list on MK	112	* clear waypoint list on MK
111	*/	113	*/
112	void Handler::delete_waypoints() {	114	void Handler::delete_waypoints() {
113	Waypoint_t wp;	115	Waypoint_t wp;
114	wp.Position.Status = INVALID;	116	wp.Position.Status = INVALID;
115	send_waypoint(wp);	117	send_waypoint(wp);
116	}	118	}
117	//-------------switch between Hardware--------------------	119	//-------------switch between Hardware--------------------
118	void Handler::switch_navictrl() {	120	void Handler::switch_navictrl() {
119	FlightLog::info("switching to NaviCtrl");	121	FlightLog::info("switching to NaviCtrl");
120	char tx_data[6] = { 0x1B, 0x1B, 0x55, 0xAA, 0x00, '\r'};	122	char tx_data[6] = { 0x1B, 0x1B, 0x55, 0xAA, 0x00, '\r'};
121	com->send_cmd('#', ADDRESS_NC, tx_data, 6, false);	123	com->send_cmd('#', ADDRESS_NC, tx_data, 6, false);
122	}	124	}
123		125
124	void Handler::switch_flightctrl() {	126	void Handler::switch_flightctrl() {
125	FlightLog::info("switching to FlightCtrl");	127	FlightLog::info("switching to FlightCtrl");
126	char tx_data[1] = { 0 };	128	char tx_data[1] = { 0 };
127	com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);	129	com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);
128	}	130	}
129		131
130	void Handler::switch_mk3mag() {	132	void Handler::switch_mk3mag() {
131	FlightLog::info("switching to MK3MAG");	133	FlightLog::info("switching to MK3MAG");
132	char tx_data[1] = { 1 };	134	char tx_data[1] = { 1 };
133	com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);	135	com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);
134	}	136	}
135		137
136	//-------------commands for MK3MAG-----------------	138	//-------------commands for MK3MAG-----------------
137		139
138		140
139	//-------------commands for all--------------------	141	//-------------commands for all--------------------
140		142
141	/**	143	/**
142	* set debug values for all components	144	* set debug values for all components
143	*/	145	*/
144	void Handler::set_all_debug(int speed) {	146	void Handler::set_all_debug(int speed) {
145	FlightLog::info("setting debug speed");	147	FlightLog::info("setting debug speed");
146	char tx_data[1] = { speed };	148	char tx_data[1] = { speed };
147	com->send_cmd('d', ADDRESS_ALL, tx_data, 1, false);	149	com->send_cmd('d', ADDRESS_ALL, tx_data, 1, false);
148	}	150	}
149		151
150	/**	152	/**
151	* stop debug for all components	153	* stop debug for all components
152	*/	154	*/
153	void Handler::stop_all_debug() {	155	void Handler::stop_all_debug() {
154	set_all_debug(0);	156	set_all_debug(0);
155	}	157	}
156		158
157	/**	159	/**
158	* get all analog labels	160	* get all analog labels
159	*/	161	*/
160	void Handler::get_analog() {	162	void Handler::get_analog() {
161	FlightLog::info("get analog values");	163	FlightLog::info("get analog values");
162	char tx_data[1] = { 0 };	164	char tx_data[1] = { 0 };
163	com->send_cmd('a', ADDRESS_ALL, tx_data, 1, true);	165	com->send_cmd('a', ADDRESS_ALL, tx_data, 1, true);
164	}	166	}
165		167
166	/**	168	/**
167	* get values from LCD / show LCD	169	* get values from LCD / show LCD
168	*/	170	*/
169	void Handler::show_lcd() {	171	void Handler::show_lcd() {
170	FlightLog::info("show LCD");	172	FlightLog::info("show LCD");
171	char tx_data[1] = {0};	173	char tx_data[1] = {0};
172	com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);	174	com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
173	}	175	}
174		176
175	/**	177	/**
176	* got to next LCD Page	178	* got to next LCD Page
177	*/	179	*/
178	void Handler::lcd_up() {	180	void Handler::lcd_up() {
179	FlightLog::info("going up one LCD page");	181	FlightLog::info("going up one LCD page");
180	char tx_data[2] = { 0, 0 };	182	char tx_data[2] = { 0, 0 };
181	if (data->lcd_cur != data->lcd_max)	183	if (data->lcd_cur != data->lcd_max)
182	tx_data[0] = data->lcd_cur+1;	184	tx_data[0] = data->lcd_cur+1;
183	com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);	185	com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
184	}	186	}
185		187
186	/**	188	/**
187	* got to previous LCD Page	189	* got to previous LCD Page
188	*/	190	*/
189	void Handler::lcd_down() {	191	void Handler::lcd_down() {
190	FlightLog::info("going down one LCD page");	192	FlightLog::info("going down one LCD page");
191	char tx_data[2] = { 0, 0 };	193	char tx_data[2] = { 0, 0 };
192	if (data->lcd_cur != 0)	194	if (data->lcd_cur != 0)
193	tx_data[0] = data->lcd_cur-1;	195	tx_data[0] = data->lcd_cur-1;
194	com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);	196	com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
195	}	197	}
196		198
197	void Handler::get_version() {	199	void Handler::get_version() {
198	FlightLog::info("get version");	200	FlightLog::info("get version");
199	//TODO: Check if is this correct or do we need data from switch_...	201	//TODO: Check if is this correct or do we need data from switch_...
200	char tx_data[1] = { 0 };	202	char tx_data[1] = { 0 };
201	com->send_cmd('v', ADDRESS_ALL, tx_data, 0, true);	203	com->send_cmd('v', ADDRESS_ALL, tx_data, 0, true);
202	}	204	}
203		205
204	void Handler::get_ppm_channels() {	206	void Handler::get_ppm_channels() {
205	FlightLog::info("get PPM channels");	207	FlightLog::info("get PPM channels");
206	char tx_data[1] = { 0 };	208	char tx_data[1] = { 0 };
207	com->send_cmd('p', ADDRESS_ALL, tx_data, 0, false);	209	com->send_cmd('p', ADDRESS_ALL, tx_data, 0, false);
208	}	210	}
209		211
210	void Handler::new_navi_data(char * data) {	212	void Handler::new_navi_data(char * data) {
211	std::string mode;	213	std::string mode;
212	switch(data[N_NC_FLAGS])	214	switch(data[N_NC_FLAGS])
213	{	215	{
214	case 0x01 : mode = "Free"; break;	216	case 0x01 : mode = "Free"; break;
215	case 0x02 : mode = "Position Hold"; break;	217	case 0x02 : mode = "Position Hold"; break;
216	case 0x04 : mode = "Coming Home"; break;	218	case 0x04 : mode = "Coming Home"; break;
217	case 0x08 : mode = "Range Limit"; break;	219	case 0x08 : mode = "Range Limit"; break;
218	case 0x10 : mode = "Serial Error"; break;	220	case 0x10 : mode = "Serial Error"; break;
219	case 0x20 : mode = "Target reached"; break;	221	case 0x20 : mode = "Target reached"; break;
220	case 0x40 : mode = "Manual Control"; break;	222	case 0x40 : mode = "Manual Control"; break;
221	}	223	}
222		224
223	}	225	}
224		226
225	/**	227	/**
226	* receive data	228	* receive data
227	*/	229	*/
228	void Handler::receive_data(char * incomming, int length) {	230	void Handler::receive_data(char * incomming, int length) {
229	if (incomming[0] != '#') {	231	if (incomming[0] != '#') {
230	FlightLog::error("this frame is not correct");	232	FlightLog::error("this frame is not correct");
231	FlightLog::info(incomming);	233	FlightLog::info(incomming);
232	return;	234	return;
233	}	235	}
234	int hardwareID = incomming[1] - 'a';	236	int hardwareID = incomming[1] - 'a';
235		237
236	//The cmd is also known as ID-Byte (or ID for short) in the wiki-dokumentation	238	//The cmd is also known as ID-Byte (or ID for short) in the wiki-dokumentation
237	char cmd = incomming[2];	239	char cmd = incomming[2];
238	//decoded data	240	//decoded data
239	unsigned char data[MAX_DATA_SIZE];	241	unsigned char data[MAX_DATA_SIZE];
240		242
241	Parser::decode64(incomming, length, data, 3);	243	Parser::decode64(incomming, length, data, 3);
242		244
243	switch(hardwareID)	245	switch(hardwareID)
244	{	246	{
245	case ADDRESS_FC :	247	case ADDRESS_FC :
246	switch(cmd)	248	switch(cmd)
247	{	249	{
248	// Motor-Mixer	250	// Motor-Mixer
249	case 'N' :	251	case 'N' :
250	com->stop_resend();	252	com->stop_resend();
251	//decoded data	253	//decoded data
252	FlightLog::info_FC("received motortest values from FlightCtrl");	254	FlightLog::info_FC("received motortest values from FlightCtrl");
253	if (data[0] == VERSION_MIXER)	255	if (data[0] == VERSION_MIXER)
254	{	256	{
255	//TODO: Handler::receivedMotorConfig(incomming)	257	//TODO: Handler::receivedMotorConfig(incomming)
256	//f_MotorMixer->set_MotorConfig(RX);	258	//f_MotorMixer->set_MotorConfig(RX);
257	}	259	}
258	break;	260	break;
259	// Motor-Mixer Schreib-Bestätigung	261	// Motor-Mixer Schreib-Bestätigung
260	case 'M' :	262	case 'M' :
261	com->stop_resend();	263	com->stop_resend();
262		264
263	if (data[0] == 1)	265	if (data[0] == 1)
264	{	266	{
265	FlightLog::info_FC("motor values written to FlightCtrl.");	267	FlightLog::info_FC("motor values written to FlightCtrl.");
266	//lb_Status->setText(tr("MotorMixer-Daten in FC geschrieben."));	268	//lb_Status->setText(tr("MotorMixer-Daten in FC geschrieben."));
267	} else {	269	} else {
268	FlightLog::warning("could not write motor values to FlightCtrl!");	270	FlightLog::warning("could not write motor values to FlightCtrl!");
269	}	271	}
270	break;	272	break;
271		273
272	// Stick-Belegung der Fernsteuerung	274	// Stick-Belegung der Fernsteuerung
273	case 'P' : // DONE 0.71g	275	case 'P' : // DONE 0.71g
274	FlightLog::info_FC("received stick-settings:");	276	FlightLog::info_FC("received stick-settings:");
275	for (int i = 1; i <= 8; i++) {	277	for (int i = 1; i <= 8; i++) {
276	std::stringstream d;	278	std::stringstream d;
277	d << "Stickvalue for Stick nr. " << i << ": " << Parser::dataToInt((char )data, i2, true);;	279	d << "Stickvalue for Stick nr. " << i << ": " << Parser::dataToInt((char )data, i2, true);;
278	std::string val;	280	std::string val;
279	d >> val;	281	d >> val;
280	FlightLog::info_FC((char *)val.c_str());	282	FlightLog::info_FC((char *)val.c_str());
281	}	283	}
282	/*f_Settings->pb_K1->setValue(Parser::dataToInt(RX.decode, 2,true));	284	/*f_Settings->pb_K1->setValue(Parser::dataToInt(RX.decode, 2,true));
283	f_Settings->pb_K2->setValue(Parser::dataToInt(RX.decode, 4,true));	285	f_Settings->pb_K2->setValue(Parser::dataToInt(RX.decode, 4,true));
284	f_Settings->pb_K3->setValue(Parser::dataToInt(RX.decode, 6,true));	286	f_Settings->pb_K3->setValue(Parser::dataToInt(RX.decode, 6,true));
285	f_Settings->pb_K4->setValue(Parser::dataToInt(RX.decode, 8,true));	287	f_Settings->pb_K4->setValue(Parser::dataToInt(RX.decode, 8,true));
286	f_Settings->pb_K5->setValue(Parser::dataToInt(RX.decode, 10 ,true));	288	f_Settings->pb_K5->setValue(Parser::dataToInt(RX.decode, 10 ,true));
287	f_Settings->pb_K6->setValue(Parser::dataToInt(RX.decode, 12,true));	289	f_Settings->pb_K6->setValue(Parser::dataToInt(RX.decode, 12,true));
288	f_Settings->pb_K7->setValue(Parser::dataToInt(RX.decode, 14,true));	290	f_Settings->pb_K7->setValue(Parser::dataToInt(RX.decode, 14,true));
289	f_Settings->pb_K8->setValue(Parser::dataToInt(RX.decode, 16,true));*/	291	f_Settings->pb_K8->setValue(Parser::dataToInt(RX.decode, 16,true));*/
290	break;	292	break;
291	// Settings lesen	293	// Settings lesen
292	case 'Q' : // DONE 0.71g	294	case 'Q' : // DONE 0.71g
293	com->stop_resend();	295	com->stop_resend();
294	FlightLog::info_FC("received settings");	296	FlightLog::info_FC("received settings");
295	if (data[1] == VERSION_SETTINGS)	297	if (data[1] == VERSION_SETTINGS)
296	{	298	{
297	int settings_id = data[0];	299	int settings_id = data[0];
298	std::stringstream d;	300	std::stringstream d;
299	d << "Settings-ID: " << settings_id;	301	d << "Settings-ID: " << settings_id;
300	std::string val;	302	std::string val;
301	d >> val;	303	d >> val;
302	FlightLog::info_FC((char *)val.c_str());	304	FlightLog::info_FC((char *)val.c_str());
303	for (int i = 0; i < MaxParameter; i++) {	305	for (int i = 0; i < MaxParameter; i++) {
304	d.flush();	306	d.flush();
305	d << "Value for Parameter nr. " << i << ": " << (int)data[i+2];	307	d << "Value for Parameter nr. " << i << ": " << (int)data[i+2];
306	d >> val;	308	d >> val;
307	FlightLog::info_FC((char *)val.c_str());	309	FlightLog::info_FC((char *)val.c_str());
308	}	310	}
309		311
310	/*for (int a = 0; a < MaxParameter; a++)	312	/*for (int a = 0; a < MaxParameter; a++)
311	{	313	{
312	FCSettings[a] = RX.decode[a + 2];	314	FCSettings[a] = RX.decode[a + 2];
313	}	315	}
314	f_Settings->show_FCSettings(Settings_ID, FCSettings);	316	f_Settings->show_FCSettings(Settings_ID, FCSettings);
315	f_Settings->pb_Read->setEnabled(true);	317	f_Settings->pb_Read->setEnabled(true);
316	f_Settings->pb_Write->setEnabled(true);*/	318	f_Settings->pb_Write->setEnabled(true);*/
317	}	319	}
318	else	320	else
319	{	321	{
320	FlightLog::error("wrong FlightCtrl version");	322	FlightLog::error("wrong FlightCtrl version");
321	/*f_Settings->pb_Read->setDisabled(true);	323	/*f_Settings->pb_Read->setDisabled(true);
322	f_Settings->pb_Write->setDisabled(true);	324	f_Settings->pb_Write->setDisabled(true);
323		325
324	QString name = QString("Versionen inkompatibel.\n") +	326	QString name = QString("Versionen inkompatibel.\n") +
325	QString("Version von GroundStation benoetigt: ") +	327	QString("Version von GroundStation benoetigt: ") +
326	QString(VERSION_SETTINGS) +	328	QString(VERSION_SETTINGS) +
327	QString("\nVersion auf der FlightCtrl: ") +	329	QString("\nVersion auf der FlightCtrl: ") +
328	QString(RX.decode[1]) +	330	QString(RX.decode[1]) +
329	QString("\nParameterbearbeitung nicht moeglich.");	331	QString("\nParameterbearbeitung nicht moeglich.");
330	QMessageBox::warning(this, QA_NAME,	332	QMessageBox::warning(this, QA_NAME,
331	name, QMessageBox::Ok);*/	333	name, QMessageBox::Ok);*/
332	}	334	}
333	break;	335	break;
334	// Settings written	336	// Settings written
335	case 'S' : // DONE 0.71g	337	case 'S' : // DONE 0.71g
336	com->stop_resend();	338	com->stop_resend();
337	FlightLog::info_FC("settings written successfully");	339	FlightLog::info_FC("settings written successfully");
338	//TODO: QMessagebox("settings written successful") ?	340	//TODO: QMessagebox("settings written successful") ?
339	break;	341	break;
340	}	342	}
341		343
342	case ADDRESS_NC :	344	case ADDRESS_NC :
343	switch(cmd)	345	switch(cmd)
344	{	346	{
345	// Navigationsdaten	347	// Navigationsdaten
346	case 'O' : // NOT DONE 0.12h	348	case 'O' : // NOT DONE 0.12h
347	//new_NaviData(RX);	349	//new_NaviData(RX);
348	FlightLog::info_NC("received navigation data");	350	FlightLog::info_NC("received navigation data");
349	break;	351	break;
350	}	352	}
351	// case ADDRESS_MK3MAG :	353	// case ADDRESS_MK3MAG :
352		354
353	default :	355	default :
354	switch(cmd)	356	switch(cmd)
355	{	357	{
356	// LCD-Anzeige	358	// LCD-Anzeige
357	case 'L' : // DONE 0.71g	359	case 'L' : // DONE 0.71g
358	com->stop_resend();	360	com->stop_resend();
359	FlightLog::info("received LCD page.");	361	FlightLog::info("received LCD page.");
360	/*int LCD[MAX_DATA_SIZE];	362	/*int LCD[MAX_DATA_SIZE];
361	memcpy(LCD,RX.decode, sizeof(RX.decode));	363	memcpy(LCD,RX.decode, sizeof(RX.decode));
362		364
363	f_LCD->show_Data(LCD);	365	f_LCD->show_Data(LCD);
364		366
365	LCD_Page = RX.decode[0];	367	LCD_Page = RX.decode[0];
366	LCD_MAX_Page = RX.decode[1];	368	LCD_MAX_Page = RX.decode[1];
367	*/	369	*/
368	break;	370	break;
369	// Analoglabels	371	// Analoglabels
370	case 'A' : // DONE 0.71g	372	case 'A' : // DONE 0.71g
371	com->stop_resend();	373	com->stop_resend();
372	FlightLog::info("received analog labels");	374	FlightLog::info("received analog labels");
373	//check position	375	//check position
374	if (data[0] != 31) {	376	if (data[0] != 31) {
375	/*	377	/*
376	Settings->Analog1.Label[Position] = ToolBox::dataToQString(RX.decode,1,17).trimmed();	378	Settings->Analog1.Label[Position] = ToolBox::dataToQString(RX.decode,1,17).trimmed();
377	if (Settings->Analog1.Label[Position] == "")	379	if (Settings->Analog1.Label[Position] == "")
378	{	380	{
379	Settings->Analog1.Label[Position] = "A-" + QString("%1").arg(Position);	381	Settings->Analog1.Label[Position] = "A-" + QString("%1").arg(Position);
380	}	382	}
381	Position ++;	383	Position ++;
382	TX_Data[0] = Position;	384	TX_Data[0] = Position;
383	o_Connection->send_Cmd('a', ADDRESS_ALL, TX_Data, 1, true);*/	385	o_Connection->send_Cmd('a', ADDRESS_ALL, TX_Data, 1, true);*/
384	} else {	386	} else {
385	/*	387	/*
386	for (int a = 0; a < MaxAnalog; a++)	388	for (int a = 0; a < MaxAnalog; a++)
387	{	389	{
388	lb_Analog[a]->setText(Settings->Analog1.Label[a]);	390	lb_Analog[a]->setText(Settings->Analog1.Label[a]);
389	}	391	}
390	Settings->Analog1.Version = QString(Mode.Version);	392	Settings->Analog1.Version = QString(Mode.Version);
391	Settings->write_Settings_AnalogLabels(HardwareID);	393	Settings->write_Settings_AnalogLabels(HardwareID);
392	config_Plot();*/	394	config_Plot();*/
393	}	395	}
394	break;	396	break;
395	// Debug-Daten	397	// Debug-Daten
396	case 'D' : // DONE 0.71g	398	case 'D' : // DONE 0.71g
397	FlightLog::info("received debug data:");	399	FlightLog::info("received debug data:");
398	for (int i = 0; i < MaxAnalog; i++) {	400	for (int i = 0; i < MaxAnalog; i++) {
399	/*	401	/*
400	Parser::dataToInt((char )data, (i 2) + 2, false);	402	Parser::dataToInt((char )data, (i 2) + 2, false);
401	*/	403	*/
402	}	404	}
403	//show_DebugData();	405	//show_DebugData();
404	break;	406	break;
405	// Version	407	// Version
406	case 'V' : // DONE 0.71h	408	case 'V' : // DONE 0.71h
407	com->stop_resend();	409	com->stop_resend();
408	FlightLog::info("received version");	410	FlightLog::info("received version");
409	/*	411	/*
410	Mode.ID = HardwareID;	412	Mode.ID = HardwareID;
411	Mode.VERSION_MAJOR = RX.decode[0];	413	Mode.VERSION_MAJOR = RX.decode[0];
412	Mode.VERSION_MINOR = RX.decode[1];	414	Mode.VERSION_MINOR = RX.decode[1];
413	Mode.VERSION_PATCH = RX.decode[4];	415	Mode.VERSION_PATCH = RX.decode[4];
414	Mode.VERSION_SERIAL_MAJOR = RX.decode[2];	416	Mode.VERSION_SERIAL_MAJOR = RX.decode[2];
415	Mode.VERSION_SERIAL_MINOR = RX.decode[3];	417	Mode.VERSION_SERIAL_MINOR = RX.decode[3];
416		418
417	Mode.Hardware = HardwareType[Mode.ID];	419	Mode.Hardware = HardwareType[Mode.ID];
418	//TODO: Funktion im Handler get_version() oder sowas	420	//TODO: Funktion im Handler get_version() oder sowas
419	QString version = QString("%1").arg(RX.decode[0]) + "." +	421	QString version = QString("%1").arg(RX.decode[0]) + "." +
420	QString("%1").arg(RX.decode[1]) +	422	QString("%1").arg(RX.decode[1]) +
421	QString(RX.decode[4] + 'a');	423	QString(RX.decode[4] + 'a');
422	Mode.Version = version.toLatin1().data;	424	Mode.Version = version.toLatin1().data;
423	setWindowTitle(QA_NAME + " v" + QA_VERSION + " - " +	425	setWindowTitle(QA_NAME + " v" + QA_VERSION + " - " +
424	Mode.Hardware + " " +	426	Mode.Hardware + " " +
425	Mode.Version);	427	Mode.Version);
426		428
427	if (Mode.VERSION_SERIAL_MAJOR != VERSION_SERIAL_MAJOR)	429	if (Mode.VERSION_SERIAL_MAJOR != VERSION_SERIAL_MAJOR)
428	{	430	{
429	// AllowSend = false;	431	// AllowSend = false;
430	QMessageBox::warning(this, QA_NAME,	432	QMessageBox::warning(this, QA_NAME,
431	tr("Serielles Protokoll Inkompatibel. \nBitte neue Programmversion installieren,"), QMessageBox::Ok);	433	tr("Serielles Protokoll Inkompatibel. \nBitte neue Programmversion installieren,"), QMessageBox::Ok);
432	}	434	}
433		435
434	if (ac_NoDebug->isChecked())	436	if (ac_NoDebug->isChecked())
435	{	437	{
436	TX_Data[0] = 0;	438	TX_Data[0] = 0;
437	}	439	}
438	else	440	else
439	if (ac_FastDebug->isChecked())	441	if (ac_FastDebug->isChecked())
440	{	442	{
441	TX_Data[0] = Settings->Data.Debug_Fast / 10;	443	TX_Data[0] = Settings->Data.Debug_Fast / 10;
442	}	444	}
443	else	445	else
444	{	446	{
445	TX_Data[0] = Settings->Data.Debug_Slow / 10;	447	TX_Data[0] = Settings->Data.Debug_Slow / 10;
446	}	448	}
447		449
448	o_Connection->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);	450	o_Connection->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
449		451
450	// Wenn MK3MAG dann andauernd Daten neu anfragen.	452	// Wenn MK3MAG dann andauernd Daten neu anfragen.
451	if (Mode.ID == ADDRESS_MK3MAG)	453	if (Mode.ID == ADDRESS_MK3MAG)
452	{	454	{
453	TickerEvent[3] = true;	455	TickerEvent[3] = true;
454	rb_SelMag->setChecked(true);	456	rb_SelMag->setChecked(true);
455	}	457	}
456		458
457	// Wenn NaviCtrl dann hier.	459	// Wenn NaviCtrl dann hier.
458	if (Mode.ID == ADDRESS_NC)	460	if (Mode.ID == ADDRESS_NC)
459	{	461	{
460	rb_SelNC->setChecked(true);	462	rb_SelNC->setChecked(true);
461		463
462	if (ac_NoNavi->isChecked())	464	if (ac_NoNavi->isChecked())
463	{	465	{
464	TX_Data[0] = 0;	466	TX_Data[0] = 0;
465	}	467	}
466	else	468	else
467	if (ac_FastNavi->isChecked())	469	if (ac_FastNavi->isChecked())
468	{	470	{
469	TX_Data[0] = Settings->Data.Navi_Fast / 10;	471	TX_Data[0] = Settings->Data.Navi_Fast / 10;
470	}	472	}
471	else	473	else
472	{	474	{
473	TX_Data[0] = Settings->Data.Navi_Slow / 10;	475	TX_Data[0] = Settings->Data.Navi_Slow / 10;
474	}	476	}
475		477
476	o_Connection->send_Cmd('o', ADDRESS_NC, TX_Data, 1, false);	478	o_Connection->send_Cmd('o', ADDRESS_NC, TX_Data, 1, false);
477	}	479	}
478		480
479		481
480	// Wenn FlightCtrl dann Settings abfragen.	482	// Wenn FlightCtrl dann Settings abfragen.
481	if (Mode.ID == ADDRESS_FC)	483	if (Mode.ID == ADDRESS_FC)
482	{	484	{
483	rb_SelFC->setChecked(true);	485	rb_SelFC->setChecked(true);
484	{	486	{
485	TX_Data[0] = 0xff;	487	TX_Data[0] = 0xff;
486	TX_Data[1] = 0;	488	TX_Data[1] = 0;
487		489
488	// DEP: Raus wenn Resend implementiert.	490	// DEP: Raus wenn Resend implementiert.
489	// ToolBox::Wait(SLEEP);	491	// ToolBox::Wait(SLEEP);
490	o_Connection->send_Cmd('q', ADDRESS_FC, TX_Data, 1, true);	492	o_Connection->send_Cmd('q', ADDRESS_FC, TX_Data, 1, true);
491	qDebug("FC - Get Settings");	493	qDebug("FC - Get Settings");
492	}	494	}
493	}	495	}
494	// Wenn nicht Lesen und Schreiben der Settings deaktivieren.	496	// Wenn nicht Lesen und Schreiben der Settings deaktivieren.
495	else	497	else
496	{	498	{
497	f_Settings->pb_Read->setDisabled(true);	499	f_Settings->pb_Read->setDisabled(true);
498	f_Settings->pb_Write->setDisabled(true);	500	f_Settings->pb_Write->setDisabled(true);

Subversion Repositories Projects

(root)/QMK-Groundstation/branches/libMK/libMK/Handler.cpp - Rev 513 → 524