WebSVN - Projects - Diff - Rev 442 and 449 - /QMK-Groundstation/branches/libMK/libMK/Handler.cpp


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

Subversion Repositories Projects

(root)/QMK-Groundstation/branches/libMK/libMK/Handler.cpp @ 462 - Rev 442 → 449