WebSVN - Projects - Diff - Rev 462 and 500 - /QMK-Groundstation/branches/libMK/libMK/Handler.cpp


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

Subversion Repositories Projects

(root)/QMK-Groundstation/branches/libMK/libMK/Handler.cpp - Rev 462 → 500