WebSVN - FlightCtrl - Blame - Rev 190 - /branches/salvo

Rev	Author	Line No.	Line
143	salvo	1	/*
		2	This program (files gps.c and gps.h) is free software; you can redistribute it and/or modify
		3	it under the terms of the GNU General Public License as published by the Free Software Foundation;
		4	either version 3 of the License, or (at your option) any later version.
		5	This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
		6	without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		7	GNU General Public License for more details. You should have received a copy of the GNU General Public License
		8	along with this program. If not, see <http://www.gnu.org/licenses/>.
		9
149	salvo	10	Please note: All the other files for the project "Mikrokopter" by H.Buss are under the license (license_buss.txt) published by www.mikrokopter.de
143	salvo	11	*/
		12	/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		13	Peter Muehlenbrock
		14	Auswertung der Daten vom GPS im ublox Format
182	salvo	15	Hold Modus mit PID Regler
184	salvo	16	Stand 29.9.2007
143	salvo	17	++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		18	*/
1	ingob	19	#include "main.h"
156	salvo	20	//#include "gps.h"
1	ingob	21
143	salvo	22	// Defines fuer ublox Messageformat um Auswertung zu steuern
183	salvo	23	#define UBLOX_IDLE 0
		24	#define UBLOX_SYNC1 1
		25	#define UBLOX_SYNC2 2
		26	#define UBLOX_CLASS 3
		27	#define UBLOX_ID 4
		28	#define UBLOX_LEN1 5
		29	#define UBLOX_LEN2 6
		30	#define UBLOX_CKA 7
		31	#define UBLOX_CKB 8
143	salvo	32	#define UBLOX_PAYLOAD 9
		33
		34	// ublox Protokoll Identifier
		35	#define UBLOX_NAV_POSUTM 0x08
		36	#define UBLOX_NAV_STATUS 0x03
		37	#define UBLOX_NAV_VELED 0x12
		38	#define UBLOX_NAV_CLASS 0x01
		39	#define UBLOX_SYNCH1_CHAR 0xB5
		40	#define UBLOX_SYNCH2_CHAR 0x62
		41
1	ingob	42	signed int GPS_Nick = 0;
		43	signed int GPS_Roll = 0;
158	salvo	44	short int ublox_msg_state = UBLOX_IDLE;
143	salvo	45	static uint8_t chk_a =0; //Checksum
		46	static uint8_t chk_b =0;
158	salvo	47	short int gps_state;
		48	short int gps_updte_flag;
		49	signed int GPS_hdng_abs_2trgt; //Winkel zum Ziel bezogen auf Nordpol
		50	signed int GPS_hdng_rel_2trgt; //Winkel zum Ziel bezogen auf Nordachse des Kopters
		51	signed int GPS_dist_2trgt; //vorzeichenlose Distanz zum Ziel
159	salvo	52	signed int gps_int_x,gps_int_y,gps_reg_x,gps_reg_y;
		53	signed int ;
143	salvo	54	static unsigned int rx_len;
		55	unsigned int cnt0,cnt1,cnt2; //******Provisorisch
		56	static unsigned int ptr_payload_data_end;
190	salvo	57	unsigned int gps_alive_cnt; // Wird bei jedem gueltigen GPS Telegramm hochgezaehlt
143	salvo	58
		59	static uint8_t *ptr_payload_data;
		60	static uint8_t *ptr_pac_status;
		61
156	salvo	62	short int Get_GPS_data(void);
143	salvo	63
		64	NAV_POSUTM_t actual_pos; // Aktuelle Nav Daten werden hier im ublox Format abgelegt
		65	NAV_STATUS_t actual_status; // Aktueller Nav Status
		66	NAV_VELNED_t actual_speed; // Aktueller Geschwindigkeits und Richtungsdaten
		67
156	salvo	68	GPS_ABS_POSITION_t gps_act_position; // Alle wichtigen Daten zusammengefasst
		69	GPS_ABS_POSITION_t gps_home_position; // Die Startposition, beim Kalibrieren ermittelt
		70	GPS_REL_POSITION_t gps_rel_act_position; // Die aktuelle relative Position bezogen auf Home Position
158	salvo	71	GPS_REL_POSITION_t gps_rel_hold_position; // Die gespeicherte Sollposition fuer GPS_ Hold Mode
143	salvo	72
156	salvo	73	// Initialisierung
		74	void GPS_Neutral(void)
1	ingob	75	{
158	salvo	76	ublox_msg_state = UBLOX_IDLE;
		77	gps_state = GPS_CRTL_IDLE;
		78	actual_pos.status = 0;
		79	actual_speed.status = 0;
		80	actual_status.status = 0;
		81	gps_home_position.status = 0; // Noch keine gueltige Home Position
		82	gps_act_position.status = 0;
		83	gps_rel_act_position.status = 0;
		84	GPS_Nick = 0;
		85	GPS_Roll = 0;
		86	gps_updte_flag = 0;
159	salvo	87	gps_int_x = 0;
		88	gps_int_y = 0;
190	salvo	89	gps_alive_cnt = 0;
159	salvo	90
1	ingob	91	}
		92
156	salvo	93	// Home Position sichern falls Daten verfuegbar sind.
		94	void GPS_Save_Home(void)
1	ingob	95	{
156	salvo	96	short int n;
		97	n = Get_GPS_data();
		98	if (n == 0) // Gueltige und aktuelle Daten ?
		99	{
		100	// Neue GPS Daten liegen vor
157	salvo	101	gps_home_position.utm_east = gps_act_position.utm_east;
		102	gps_home_position.utm_north = gps_act_position.utm_north;
		103	gps_home_position.utm_alt = gps_act_position.utm_alt;
		104	gps_home_position.status = 1; // Home Position gueltig
156	salvo	105	}
		106	}
		107
		108	// Relative Position zur Home Position bestimmen
		109	// Rueckgabewert 0= Daten sind aktuell und gueltig. 1= Keine Aenderung. 2= Daten ungueltig
		110	short int Get_Rel_Position(void)
		111	{
		112	short int n = 0;
		113	n = Get_GPS_data();
		114	if (n >=1) return (n); // nix zu tun, weil keine neue Daten da sind
190	salvo	115	if (gps_alive_cnt < 400) gps_alive_cnt += 300; // Timeoutzaehler. Wird in MotorreglerRoutine ueberwacht und dekrementiert
156	salvo	116	if (gps_home_position.status > 0) //Nur wenn Home Position vorliegt
		117	{
		118	gps_rel_act_position.utm_east = (int) (gps_act_position.utm_east - gps_home_position.utm_east);
		119	gps_rel_act_position.utm_north = (int) (gps_act_position.utm_north - gps_home_position.utm_north);
		120	gps_rel_act_position.status = 1; // gueltige Positionsdaten
		121	n = 0;
158	salvo	122	gps_updte_flag = 1; // zeigt an, dass neue Daten vorliegen.
156	salvo	123	}
		124	else
		125	{
		126	n = 2; //keine gueltigen Daten vorhanden
		127	gps_rel_act_position.status = 0; //keine gueltige Position weil keine home Position da ist.
		128	}
		129	return (n);
		130	}
		131
		132	// Daten aus aktuellen ublox Messages extrahieren
		133	// Rueckgabewert 0= Daten sind aktuell und gueltig. 1= Keine Aenderung. 2= Daten ungueltig
		134	short int Get_GPS_data(void)
		135	{
		136	short int n = 1;
		137
		138	if (actual_pos.status == 0) return (1); //damit es schnell geht, wenn nix zu tun ist
143	salvo	139	if ((actual_pos.status > 0) && (actual_status.status > 0) && (actual_speed.status > 0))
		140	{
		141	cnt1++; //**** noch Rausschmeissen
149	salvo	142	if (((actual_status.gpsfix_type & 0x03) >=2) && ((actual_status.nav_status_flag & 0x01) >=1)) // nur wenn Daten aktuell und gueltig sind
143	salvo	143	{
		144	gps_act_position.utm_east = actual_pos.utm_east/10;
		145	gps_act_position.utm_north = actual_pos.utm_north/10;
		146	gps_act_position.utm_alt = actual_pos.utm_alt/10;
		147	gps_act_position.speed_gnd = actual_speed.speed_gnd/10;
		148	gps_act_position.speed_gnd = actual_speed.speed_gnd/10;
		149	gps_act_position.heading = actual_speed.heading/100000;
		150	gps_act_position.status = 1;
156	salvo	151	n = 0; //Daten gueltig
143	salvo	152	}
156	salvo	153	else
		154	{
		155	gps_act_position.status = 0; //Keine gueltigen Daten
		156	n = 2;
		157	}
		158	actual_pos.status = 0; //neue ublox Messages anfordern
		159	actual_status.status = 0;
		160	actual_speed.status = 0;
		161	}
		162	return (n);
1	ingob	163	}
		164
		165
143	salvo	166	/*
		167	Daten vom GPS im ublox MSG Format auswerten
156	salvo	168	Die Routine wird bei jedem Empfang eines Zeichens vom GPS Modul durch den UART IRQ aufgerufen
143	salvo	169	// Die UBX Messages NAV_POSUTM, NAV_STATUS und NAV_VALED muessen aktiviert sein
		170	*/
		171	void Get_Ublox_Msg(uint8_t rx)
		172	{
1	ingob	173
143	salvo	174	switch (ublox_msg_state)
		175	{
1	ingob	176
143	salvo	177	case UBLOX_IDLE: // Zuerst Synchcharacters pruefen
		178	if ( rx == UBLOX_SYNCH1_CHAR ) ublox_msg_state = UBLOX_SYNC1;
		179	else ublox_msg_state = UBLOX_IDLE;
		180	break;
		181
		182	case UBLOX_SYNC1:
		183
		184	if (rx == UBLOX_SYNCH2_CHAR) ublox_msg_state = UBLOX_SYNC2;
		185	else ublox_msg_state = UBLOX_IDLE;
		186	chk_a = 0,chk_b = 0;
		187	break;
		188
		189	case UBLOX_SYNC2:
		190	if (rx == UBLOX_NAV_CLASS) ublox_msg_state = UBLOX_CLASS;
		191	else ublox_msg_state = UBLOX_IDLE;
		192	break;
		193
		194	case UBLOX_CLASS: // Nur NAV Meldungen auswerten
		195	switch (rx)
		196	{
		197	case UBLOX_NAV_POSUTM:
		198	ptr_pac_status = &actual_pos.status;
		199	if (*ptr_pac_status > 0) ublox_msg_state = UBLOX_IDLE; //Abbruch weil Daten noch nicht verwendet wurden
		200	else
		201	{
		202	ptr_payload_data = &actual_pos;
		203	ptr_payload_data_end = &actual_pos.status;
		204	ublox_msg_state = UBLOX_LEN1;
		205	}
		206	break;
		207
		208	case UBLOX_NAV_STATUS:
		209	ptr_pac_status = &actual_status.status;
		210	if (*ptr_pac_status > 0) ublox_msg_state = UBLOX_IDLE;
		211	else
		212	{
		213	ptr_payload_data = &actual_status;
		214	ptr_payload_data_end = &actual_status.status;
		215	ublox_msg_state = UBLOX_LEN1;
		216	}
		217	break;
		218
		219	case UBLOX_NAV_VELED:
156	salvo	220	ptr_pac_status = &actual_speed.status;
143	salvo	221	if (*ptr_pac_status > 0) ublox_msg_state = UBLOX_IDLE;
		222	else
		223	{
		224	ptr_payload_data = &actual_speed;
		225	ptr_payload_data_end = &actual_speed.status;
		226	ublox_msg_state = UBLOX_LEN1;
		227	}
		228	break;
		229
		230	default:
		231	ublox_msg_state = UBLOX_IDLE;
		232	break;
		233	}
		234	chk_a = UBLOX_NAV_CLASS + rx;
		235	chk_b = UBLOX_NAV_CLASS + chk_a;
		236	break;
		237
		238	case UBLOX_LEN1: // Laenge auswerten
		239	rx_len = rx;
		240	chk_a += rx;
		241	chk_b += chk_a;
		242	ublox_msg_state = UBLOX_LEN2;
		243	break;
		244
		245
		246	case UBLOX_LEN2: // Laenge auswerten
		247	rx_len = rx_len + (rx *256); // Laenge ermitteln
		248	chk_a += rx;
		249	chk_b += chk_a;
		250	ublox_msg_state = UBLOX_PAYLOAD;
		251	break;
		252
		253	case UBLOX_PAYLOAD: // jetzt Nutzdaten einlesen
		254	if (rx_len > 0)
		255	{
		256	*ptr_payload_data = rx;
		257	chk_a += rx;
		258	chk_b += chk_a;
		259	--rx_len;
		260	if ((rx_len > 0) && (ptr_payload_data <= ptr_payload_data_end))
		261	{
		262	ptr_payload_data++;
156	salvo	263	ublox_msg_state = UBLOX_PAYLOAD;
143	salvo	264	}
		265	else ublox_msg_state = UBLOX_CKA;
		266	}
		267	else ublox_msg_state = UBLOX_IDLE; // Abbruch wegen Fehler
		268	break;
		269
		270	case UBLOX_CKA: // Checksum pruefen
		271	if (rx == chk_a) ublox_msg_state = UBLOX_CKB;
		272	else ublox_msg_state = UBLOX_IDLE; // Abbruch wegen Fehler
		273	break;
		274
		275	case UBLOX_CKB: // Checksum pruefen
		276	if (rx == chk_b) *ptr_pac_status = 1; // Paket ok
		277	ublox_msg_state = UBLOX_IDLE;
		278	break;
		279
		280	default:
		281	ublox_msg_state = UBLOX_IDLE;
		282	break;
158	salvo	283	}
143	salvo	284	}
158	salvo	285
		286	//Zentrale Statemachine fuer alle GPS relevanten Regelungsablauefe
		287	short int GPS_CRTL(short int cmd)
		288	{
184	salvo	289	static unsigned int cnt; //Zaehler fuer diverse Verzoegerungen
		290	static signed int int_east,int_north; //Integrierer
		291	static signed int dist_north,dist_east;
186	salvo	292	static signed int diff_east,diff_north; // Differenzierer (Differenz zum vorhergehenden x bzw. y Wert)
		293	static signed int diff_east_f,diff_north_f; // Differenzierer, gefiltert
		294	signed int n;
		295	long signed int dist,d,n_l;
158	salvo	296	switch (cmd)
		297	{
162	salvo	298
		299	case GPS_CMD_REQ_HOME: // Es soll zum Startpunkt zurueckgeflogen werden.
		300	// Noch einiges zu ueberlegen und zu tun
		301	return(GPS_STST_PEND); // noch warten
		302	break;
		303	// ******************************
		304
158	salvo	305	case GPS_CMD_REQ_HOLD: // Die Lageregelung soll aktiviert werden.
		306	if (gps_state != GPS_CRTL_HOLD_ACTIVE)
		307	{
		308	cnt++;
160	salvo	309	if (cnt > 500) // erst nach Verzoegerung
158	salvo	310	{
		311	cnt = 0;
		312	// aktuelle positionsdaten abespeichern
		313	if (gps_rel_act_position.status > 0)
		314	{
186	salvo	315	int_east = 0;
		316	int_north = 0;
		317	gps_reg_x = 0;
		318	gps_reg_y = 0;
		319	dist_east = 0;
		320	dist_north = 0;
		321	diff_east_f = 0;
		322	diff_north_f = 0;
190	salvo	323	diff_east = 0;
186	salvo	324	diff_north = 0;
158	salvo	325	gps_rel_hold_position.utm_east = gps_rel_act_position.utm_east;
		326	gps_rel_hold_position.utm_north = gps_rel_act_position.utm_north;
		327	gps_rel_hold_position.status = 1; // gueltige Positionsdaten
		328	gps_state = GPS_CRTL_HOLD_ACTIVE;
		329	return (GPS_STST_OK);
		330	}
		331	else
		332	{
		333	gps_rel_hold_position.status = 0; //Keine Daten verfuegbar
		334	gps_state = GPS_CRTL_IDLE;
		335	return(GPS_STST_ERR); // Keine Daten da
		336	}
		337	}
		338	else return(GPS_STST_PEND); // noch warten
		339	}
		340	break;
		341
162	salvo	342	case GPS_CMD_STOP: // Lageregelung beenden
190	salvo	343	cnt = 0;
		344	GPS_Nick = 0;
		345	GPS_Roll = 0;
		346	gps_int_x = 0;
		347	gps_int_y = 0;
162	salvo	348	gps_state = GPS_CRTL_IDLE;
158	salvo	349	return (GPS_STST_OK);
		350	break;
		351
		352	default:
		353	return (GPS_STST_ERR);
		354	break;
		355	}
		356
		357	switch (gps_state)
		358	{
		359	case GPS_CRTL_IDLE:
		360	cnt = 0;
		361	return (GPS_STST_OK);
		362	break;
		363
186	salvo	364	case GPS_CRTL_HOLD_ACTIVE: // Hier werden die Daten fuer Nick und Roll errechnet
159	salvo	365	if (gps_updte_flag == 1) //nur wenn neue GPS Daten vorliegen
158	salvo	366	{
		367	gps_updte_flag = 0;
		368	// ab hier wird geregelt
186	salvo	369	diff_east = -dist_east; //Alten Wert fuer Differenzier schon mal abziehen
		370	diff_north = -dist_north;
190	salvo	371	dist_east = gps_rel_hold_position.utm_east - gps_rel_act_position.utm_east;
184	salvo	372	dist_north = gps_rel_hold_position.utm_north - gps_rel_act_position.utm_north;
162	salvo	373	int_east += dist_east;
		374	int_north += dist_north;
167	salvo	375	diff_east += dist_east; // Differenz zur vorhergehenden East Position
		376	diff_north += dist_north; // Differenz zur vorhergehenden North Position
161	salvo	377
186	salvo	378	diff_east_f = ((diff_east_f )/2) + (diff_east /2); //Differenzierer filtern
		379	diff_north_f = ((diff_north_f)/2) + (diff_north/2); //Differenzierer filtern
		380
167	salvo	381	#define GPSINT_MAX 2048 //neuer Wert ab 25.9.2007 Begrenzung
162	salvo	382	if ((abs(int_east) > GPSINT_MAX) \|\| (abs(int_north)> GPSINT_MAX)) //Bei zu hohem Wert Integrator auf Wert halten
		383	{
		384	int_east -= dist_east;
		385	int_north -= dist_north;
		386	}
186	salvo	387	// P-Anteil Kleine Werte verstaerken, grosse abschwaechen
		388	#define GPS_DIST_P_MAX 200 //maximal 20m
		389	int dist_east_p,dist_north_p;
		390	dist_east_p = dist_east;
		391	dist_north_p = dist_north;
		392	if (dist_east > GPS_DIST_P_MAX) dist_east_p = GPS_DIST_P_MAX; // P-Anteil begrenzen
		393	else if (dist_east < - GPS_DIST_P_MAX) dist_east_p = -GPS_DIST_P_MAX;
		394	if (dist_north > GPS_DIST_P_MAX) dist_north_p = GPS_DIST_P_MAX; // P-Anteil begrenzen
		395	else if (dist_north < - GPS_DIST_P_MAX) dist_north_p = -GPS_DIST_P_MAX;
		396
		397	n = sin_i((dist_east_p*90)/(GPS_DIST_P_MAX));
		398	d = (GPS_DIST_P_MAX * (long)n) /1000;
		399	dist_east_p = (int) d;
		400	n = sin_i((dist_north_p*90)/(GPS_DIST_P_MAX));
		401	d = (GPS_DIST_P_MAX * (long)n) /1000;
		402	dist_north_p = (int) d;
161	salvo	403
186	salvo	404	//PID Regler Werte aufsummieren
190	salvo	405	gps_reg_x = ((int_east * Parameter_UserParam2)/32) + ((dist_east_p * Parameter_UserParam1)/4)+ ((diff_east_f * Parameter_UserParam3)/2); // I + P +D Anteil X Achse
		406	gps_reg_y = ((int_north * Parameter_UserParam2)/32) + ((dist_north_p * Parameter_UserParam1)/4)+ ((diff_north_f * Parameter_UserParam3)/2); // I + P +D Anteil Y Achse
159	salvo	407
186	salvo	408	//Ziel-Richtung bezogen auf Nordpol bestimmen
159	salvo	409	GPS_hdng_abs_2trgt = arctan_i((long)gps_reg_x,(long)gps_reg_y);
		410
186	salvo	411	// in Winkel 0...360 Grad umrechnen
161	salvo	412	if ((gps_reg_x >= 0)) GPS_hdng_abs_2trgt = ( 90-GPS_hdng_abs_2trgt);
162	salvo	413	else GPS_hdng_abs_2trgt = (270 - GPS_hdng_abs_2trgt);
161	salvo	414
159	salvo	415	// Relative Richtung in bezug auf Nordachse des Kopters errechen
		416	n= GyroKomp_Int/GYROKOMP_INC_GRAD_DEFAULT;
		417	GPS_hdng_rel_2trgt = GPS_hdng_abs_2trgt - n;
167	salvo	418	if ((GPS_hdng_rel_2trgt >180) && (GPS_hdng_abs_2trgt >=180)) GPS_hdng_rel_2trgt = GPS_hdng_rel_2trgt-360;
159	salvo	419	else if (GPS_hdng_rel_2trgt >180) GPS_hdng_rel_2trgt = 360 - GPS_hdng_rel_2trgt;
		420	else if (GPS_hdng_rel_2trgt <-180) GPS_hdng_rel_2trgt = 360 + GPS_hdng_rel_2trgt;
		421
184	salvo	422	// Regelabweichung aus x,y zu Ziel in Distanz umrechnen
160	salvo	423	if (abs(gps_reg_x) > abs(gps_reg_y) )
		424	{
182	salvo	425	dist = (long)gps_reg_x; //Groesseren Wert wegen besserer Genauigkeit nehmen
190	salvo	426	dist = abs((dist *1000) / (long) sin_i(GPS_hdng_abs_2trgt));
160	salvo	427	}
		428	else
		429	{
182	salvo	430	dist = (long)gps_reg_y;
190	salvo	431	dist = abs((dist *1000) / (long) cos_i(GPS_hdng_abs_2trgt));
160	salvo	432	}
190	salvo	433	GPS_dist_2trgt = (int) dist;
185	salvo	434	// Winkel und Distanz in Nick und Rollgroessen umrechnen
184	salvo	435	GPS_Roll = (int) +( (dist * (long) sin_i(GPS_hdng_rel_2trgt))/1000);
185	salvo	436	GPS_Nick = (int) -( (dist * (long) cos_i(GPS_hdng_rel_2trgt))/1000);
190	salvo	437
186	salvo	438	#define GPS_V 8
184	salvo	439	if (GPS_Roll > (GPS_NICKROLL_MAX * GPS_V)) GPS_Roll = (GPS_NICKROLL_MAX * GPS_V);
		440	else if (GPS_Roll < -(GPS_NICKROLL_MAX * GPS_V)) GPS_Roll = -(GPS_NICKROLL_MAX * GPS_V);
		441	if (GPS_Nick > (GPS_NICKROLL_MAX * GPS_V)) GPS_Nick = (GPS_NICKROLL_MAX * GPS_V);
		442	else if (GPS_Nick < -(GPS_NICKROLL_MAX * GPS_V)) GPS_Nick = -(GPS_NICKROLL_MAX * GPS_V);
		443
		444	//Kleine Werte verstaerken, Grosse abschwaechen
186	salvo	445	n = sin_i((GPS_Roll90)/(GPS_NICKROLL_MAX GPS_V));
		446	n_l = ((long) GPS_NICKROLL_MAX * (long) n)/1000;
		447	GPS_Roll = (int) n_l;
185	salvo	448	n = sin_i((GPS_Nick90)/(GPS_NICKROLL_MAX GPS_V));
186	salvo	449	n_l = ((long) GPS_NICKROLL_MAX * (long) n)/1000;
		450	GPS_Nick = (int) n_l;
184	salvo	451
		452	if ((abs(dist_east) > GPS_DIST_MAX) \|\| (abs(dist_north) > GPS_DIST_MAX)) // bei zu grossem Abstand abbrechen
		453	{
		454	GPS_Roll = 0;
		455	GPS_Nick = 0;
		456	gps_state = GPS_CRTL_IDLE;
186	salvo	457	return (GPS_STST_ERR);
		458	break;
184	salvo	459	}
158	salvo	460	}
		461	else return (GPS_STST_OK);
		462	break;
		463
		464	default:
		465	gps_state = GPS_CRTL_IDLE;
		466	return (GPS_STST_ERR);
		467	break;
		468	}
		469	return (GPS_STST_ERR);
		470
		471	}
		472

Subversion Repositories FlightCtrl

(root)/branches/salvo_gps/GPS.c @ 266 - Rev 190