WebSVN - FlightCtrl - Blame - Rev 501 - /branches/Flight-Ctrl_V0_64_3_GPS_work

Rev	Author	Line No.	Line
202	joko	1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		2	// + Copyright (c) 04.2007 Holger Buss
		3	// + only for non-profit use
		4	// + www.MikroKopter.com
		5	// + see the File "License.txt" for further Informations
		6	// +
		7	// + GPS read out:
		8	// + modified Version of the Pitschu Brushless Ufo - (c) Peter Schulten, M�lheim, Germany
		9	// + only for non-profit use
		10	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		11
		12	#include "main.h"
		13	#include "uart.h"
		14
		15	unsigned char DebugGetAnforderung = 0,DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0;
		16	unsigned volatile char SioTmp = 0;
		17	unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];
		18	unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
		19	unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF];
		20	unsigned volatile char NeuerDatensatzEmpfangen = 0;
		21	unsigned volatile char NeueKoordinateEmpfangen = 0;
		22	unsigned volatile char UebertragungAbgeschlossen = 1;
		23	unsigned volatile char CntCrcError = 0;
		24	unsigned volatile char AnzahlEmpfangsBytes = 0;
		25	unsigned volatile char PC_DebugTimeout = 0;
		26	unsigned char PcZugriff = 100;
		27	unsigned char MotorTest[4] = {0,0,0,0};
		28	unsigned char MeineSlaveAdresse;
		29	struct str_DebugOut DebugOut;
		30	struct str_Debug DebugIn;
		31	struct str_VersionInfo VersionInfo;
		32	int Debug_Timer;
		33
459	joko	34	char newData_navPosUtm = 0; // Flag, wenn neue PosUtm-Daten vorliegen (211007Kr)
		35
202	joko	36	static uint8_t gpsState;
		37	#define GPS_EMPTY 0
		38	#define GPS_SYNC1 1
		39	#define GPS_SYNC2 2
		40	#define GPS_CLASS 3
		41	#define GPS_LEN1 4
		42	#define GPS_LEN2 5
		43	#define GPS_FILLING 6
		44	#define GPS_CKA 7
		45	#define GPS_CKB 8
459	joko	46
202	joko	47	gpsInfo_t actualPos; // measured position (last gps record)
		48
		49	#define SYNC_CHAR1 0xb5
		50	#define SYNC_CHAR2 0x62
		51
		52	#define CLASS_NAV 0x01
		53	#define MSGID_STATUS 0x03
501	joko	54	//#define MSGID_POSLLH 0x02 //(231107Kr)
202	joko	55	#define MSGID_POSUTM 0x08
		56	#define MSGID_VELNED 0x12
		57
		58
		59
		60	typedef struct {
		61	unsigned long ITOW; // time of week
		62	uint8_t GPSfix; // GPSfix Type, range 0..6
		63	uint8_t Flags; // Navigation Status Flags
		64	uint8_t DiffS; // Differential Status
		65	uint8_t res; // reserved
		66	unsigned long TTFF; // Time to first fix (millisecond time tag)
		67	unsigned long MSSS; // Milliseconds since Startup / Reset
		68	uint8_t packetStatus;
		69	} NAV_STATUS_t;
		70
501	joko	71	/*
		72	typedef struct { //(231107Kr)
		73	unsigned long ITOW; // time of week
		74	long LON; // longitude in 1e-07 deg
		75	long LAT; // lattitude
		76	long HEIGHT; // height in mm
		77	long HMSL; // height above mean sea level im mm
		78	unsigned long Hacc; // horizontal accuracy in mm
		79	unsigned long Vacc; // vertical accuracy in mm
		80	uint8_t packetStatus;
		81	} NAV_POSLLH_t;
		82	*/
202	joko	83
		84	typedef struct {
		85	unsigned long ITOW; // time of week
		86	long EAST; // cm UTM Easting
		87	long NORTH; // cm UTM Nording
		88	long ALT; // cm altitude
		89	uint8_t ZONE; // UTM zone number
		90	uint8_t HEM; // Hemisphere Indicator (0=North, 1=South)
		91	uint8_t packetStatus;
		92	} NAV_POSUTM_t;
		93
		94
		95	typedef struct {
		96	unsigned long ITOW; // ms GPS Millisecond Time of Week
		97	long VEL_N; // cm/s NED north velocity
		98	long VEL_E; // cm/s NED east velocity
		99	long VEL_D; // cm/s NED down velocity
		100	unsigned long Speed; // cm/s Speed (3-D)
		101	unsigned long GSpeed; // cm/s Ground Speed (2-D)
		102	long Heading; // deg (1e-05) Heading 2-D
		103	unsigned long SAcc; // cm/s Speed Accuracy Estimate
		104	unsigned long CAcc; // deg Course / Heading Accuracy Estimate
		105	uint8_t packetStatus;
		106	} NAV_VELNED_t;
		107
		108
		109
		110	NAV_STATUS_t navStatus;
501	joko	111	//NAV_POSLLH_t navPosLlh; //(231107Kr)
202	joko	112	NAV_POSUTM_t navPosUtm;
		113	NAV_VELNED_t navVelNed;
		114
		115	volatile char ubxP, ubxEp, *ubxSp; // pointers to packet currently transfered
		116	volatile uint8_t CK_A, CK_B; // UBX checksum bytes
		117	volatile unsigned short msgLen;
		118	volatile uint8_t msgID;
		119	volatile uint8_t ignorePacket; // true when previous packet was not processed
		120
		121
		122	#ifdef GPS_DEBUG // if set then the GPS data is transfered to display
		123	extern volatile uint8_t v24state;
		124	char buf[200];
		125	char *bp;
		126	char *ep;
		127	#endif
		128
		129	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		130	//++ Sende-Part der Daten�bertragung
		131	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		132	SIGNAL(INT_VEC_TX)
		133	{
		134	static unsigned int ptr = 0;
		135	unsigned char tmp_tx;
		136	if(!UebertragungAbgeschlossen)
		137	{
		138	ptr++; // die [0] wurde schon gesendet
		139	tmp_tx = SendeBuffer[ptr];
		140	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))
		141	{
		142	ptr = 0;
		143	UebertragungAbgeschlossen = 1;
		144	}
		145	UDR = tmp_tx;
		146	}
		147	else ptr = 0;
		148	}
		149
		150	void GPSscanData (void)
		151	{
		152
		153
		154
		155
		156	if (navStatus.packetStatus == 1) // valid packet
		157	{
		158	actualPos.GPSFix = navStatus.GPSfix;
		159	actualPos.newData = navStatus.packetStatus;
		160	navStatus.packetStatus = 0;
		161	}
		162
501	joko	163	/*
		164	if (navPosLlh.packetStatus == 1) // valid packet
202	joko	165	{
501	joko	166	actualPos.longi = navPosLlh.LON; //(231107Kr)
		167	actualPos.lati = navPosLlh.LAT; //(231107Kr)
		168	actualPos.height = navPosLlh.HEIGHT; //(231107Kr)
		169	navPosLlh.packetStatus = 0;
202	joko	170	}
501	joko	171	*/
202	joko	172
		173	if (navPosUtm.packetStatus == 1) // valid packet
		174	{
		175	actualPos.northing = navPosUtm.NORTH;
		176	actualPos.easting = navPosUtm.EAST;
		177	actualPos.altitude = navPosUtm.ALT;
		178	navPosUtm.packetStatus = 0;
459	joko	179	newData_navPosUtm = 1; // (211007Kr)
501	joko	180	ROT_ON; // Rot blinkt in der Frequenz mit der neue UTM-Daten des GPS Empf�nger ankommen und brauchbar sind //(211107Kr)
202	joko	181	}
		182
501	joko	183
		184	if (navVelNed.packetStatus == 1) // valid packet
202	joko	185	{
		186	actualPos.velNorth = navVelNed.VEL_N;
		187	actualPos.velEast = navVelNed.VEL_E;
501	joko	188	actualPos.velDown = navVelNed.VEL_D;
393	joko	189	actualPos.GSpeed = navVelNed.GSpeed; //Geschwindigkeit [cm/s] �ber Grund (151007Kr)
202	joko	190	navVelNed.packetStatus = 0;
		191	}
		192
		193	}
		194
		195	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		196	//++ Empfangs-Part der Daten�bertragung, incl. CRC-Auswertung
		197	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		198	SIGNAL(INT_VEC_RX)
		199	{
		200	static unsigned int crc;
		201	static unsigned char crc1,crc2,buf_ptr;
		202	static unsigned char UartState = 0;
		203	unsigned char CrcOkay = 0;
		204
		205	SioTmp = UDR;
		206
		207	uint8_t c;
		208	uint8_t re;
		209
		210	re = (UCSR0A & (_B1(FE0) \| _B1(DOR0))); // any error occured ?
		211	c = SioTmp;
		212
		213	#ifdef GPS_DEBUG
		214	*bp++ = c;
		215	if (bp >= (buf+200)) bp = buf;
		216	if (v24state == 0)
		217	{
		218	v24state = 1;
		219	UDR0 = *ep++;
		220	if (ep >= buf+200)
		221	ep = buf;
		222	UCSR0B \|= _B1(UDRIE0); //enable further irqs
		223	}
		224	#endif
		225
		226	if (re == 0)
		227	{
		228	switch (gpsState)
		229	{
		230	case GPS_EMPTY:
		231	if (c == SYNC_CHAR1)
		232	gpsState = GPS_SYNC1;
		233	break;
		234	case GPS_SYNC1:
		235	if (c == SYNC_CHAR2)
		236	gpsState = GPS_SYNC2;
		237	else if (c != SYNC_CHAR1)
		238	gpsState = GPS_EMPTY;
		239	break;
		240	case GPS_SYNC2:
		241	if (c == CLASS_NAV)
		242	gpsState = GPS_CLASS;
		243	else
		244	gpsState = GPS_EMPTY;
		245	break;
		246	case GPS_CLASS: // msg ID seen: init packed receive
		247	msgID = c;
		248	CK_A = CLASS_NAV + c;
		249	CK_B = CLASS_NAV + CK_A;
		250	gpsState = GPS_LEN1;
		251
		252	switch (msgID)
		253	{
		254	case MSGID_STATUS:
		255	ubxP = (char*)&navStatus;
		256	ubxEp = (char*)(&navStatus + sizeof(NAV_STATUS_t));
		257	ubxSp = (char*)&navStatus.packetStatus;
		258	ignorePacket = navStatus.packetStatus;
		259	break;
501	joko	260	/*
		261	case MSGID_POSLLH: //(231107Kr)
		262	ubxP = (char*)&navPosLlh;
		263	ubxEp = (char*)(&navPosLlh + sizeof(NAV_POSLLH_t));
		264	ubxSp = (char*)&navPosLlh.packetStatus;
		265	ignorePacket = navPosLlh.packetStatus;
202	joko	266	break;
501	joko	267	*/
202	joko	268	case MSGID_POSUTM:
		269	ubxP = (char*)&navPosUtm;
		270	ubxEp = (char*)(&navPosUtm + sizeof(NAV_POSUTM_t));
		271	ubxSp = (char*)&navPosUtm.packetStatus;
		272	ignorePacket = navPosUtm.packetStatus;
		273	break;
		274	case MSGID_VELNED:
		275	ubxP = (char*)&navVelNed;
		276	ubxEp = (char*)(&navVelNed + sizeof(NAV_VELNED_t));
		277	ubxSp = (char*)&navVelNed.packetStatus;
		278	ignorePacket = navVelNed.packetStatus;
		279	break;
		280
		281
		282	default:
		283	ignorePacket = 1;
		284	ubxSp = (char*)0;
		285	}
		286	break;
		287	case GPS_LEN1: // first len byte
		288	msgLen = c;
		289	CK_A += c;
		290	CK_B += CK_A;
		291	gpsState = GPS_LEN2;
		292	break;
		293	case GPS_LEN2: // second len byte
		294	msgLen = msgLen + (c * 256);
		295	CK_A += c;
		296	CK_B += CK_A;
		297	gpsState = GPS_FILLING; // next data will be stored in packet struct
		298	break;
		299	case GPS_FILLING:
		300	CK_A += c;
		301	CK_B += CK_A;
		302
		303	if ( !ignorePacket && ubxP < ubxEp)
		304	*ubxP++ = c;
		305
		306	if (--msgLen == 0)
		307	gpsState = GPS_CKA;
		308
		309	break;
		310	case GPS_CKA:
		311	if (c == CK_A)
		312	gpsState = GPS_CKB;
		313	else
		314	gpsState = GPS_EMPTY;
		315	break;
		316	case GPS_CKB:
		317	if (c == CK_B && ubxSp) // No error -> packet received successfully
		318	*ubxSp = 1; // set packetStatus in struct
		319	gpsState = GPS_EMPTY; // ready for next packet
		320	break;
		321	default:
		322	gpsState = GPS_EMPTY; // ready for next packet
		323	}
		324	}
		325	else // discard any data if error occured
		326	{
		327	gpsState = GPS_EMPTY;
		328	}
		329	GPSscanData ();
		330
		331
		332
		333
		334
		335
		336
		337	if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0;
		338	if(SioTmp == '\r' && UartState == 2)
		339	{
		340	UartState = 0;
		341	crc -= RxdBuffer[buf_ptr-2];
		342	crc -= RxdBuffer[buf_ptr-1];
		343	crc %= 4096;
		344	crc1 = '=' + crc / 64;
		345	crc2 = '=' + crc % 64;
		346	CrcOkay = 0;
		347	if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};
		348	if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
		349	{
		350	NeuerDatensatzEmpfangen = 1;
		351	AnzahlEmpfangsBytes = buf_ptr;
		352	RxdBuffer[buf_ptr] = '\r';
		353	if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando
		354	}
		355	}
		356	else
		357	switch(UartState)
		358	{
		359	case 0:
		360	if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet
		361	buf_ptr = 0;
		362	RxdBuffer[buf_ptr++] = SioTmp;
		363	crc = SioTmp;
		364	break;
		365	case 1: // Adresse auswerten
		366	UartState++;
		367	RxdBuffer[buf_ptr++] = SioTmp;
		368	crc += SioTmp;
		369	break;
		370	case 2: // Eingangsdaten sammeln
		371	RxdBuffer[buf_ptr] = SioTmp;
		372	if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
		373	else UartState = 0;
		374	crc += SioTmp;
		375	break;
		376	default:
		377	UartState = 0;
		378	break;
		379	}
		380	}
		381
		382
		383	// --------------------------------------------------------------------------
		384	void AddCRC(unsigned int wieviele)
		385	{
		386	unsigned int tmpCRC = 0,i;
		387	for(i = 0; i < wieviele;i++)
		388	{
		389	tmpCRC += SendeBuffer[i];
		390	}
		391	tmpCRC %= 4096;
		392	SendeBuffer[i++] = '=' + tmpCRC / 64;
		393	SendeBuffer[i++] = '=' + tmpCRC % 64;
		394	SendeBuffer[i++] = '\r';
		395	UebertragungAbgeschlossen = 0;
		396	UDR = SendeBuffer[0];
		397	}
		398
		399
		400	// --------------------------------------------------------------------------
		401	void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)
		402	{
		403	unsigned int pt = 0;
		404	unsigned char a,b,c;
		405	unsigned char ptr = 0;
		406
		407	SendeBuffer[pt++] = '#'; // Startzeichen
		408	SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...)
		409	SendeBuffer[pt++] = cmd; // Commando
		410
		411	while(len)
		412	{
		413	if(len) { a = snd[ptr++]; len--;} else a = 0;
		414	if(len) { b = snd[ptr++]; len--;} else b = 0;
		415	if(len) { c = snd[ptr++]; len--;} else c = 0;
		416	SendeBuffer[pt++] = '=' + (a >> 2);
		417	SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));
		418	SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));
		419	SendeBuffer[pt++] = '=' + ( c & 0x3f);
		420	}
		421	AddCRC(pt);
		422	}
		423
		424
		425	// --------------------------------------------------------------------------
		426	void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer
		427	{
		428	unsigned char a,b,c,d;
		429	unsigned char ptr = 0;
		430	unsigned char x,y,z;
		431	while(len)
		432	{
		433	a = RxdBuffer[ptrIn++] - '=';
		434	b = RxdBuffer[ptrIn++] - '=';
		435	c = RxdBuffer[ptrIn++] - '=';
		436	d = RxdBuffer[ptrIn++] - '=';
		437	if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden
		438
		439	x = (a << 2) \| (b >> 4);
		440	y = ((b & 0x0f) << 4) \| (c >> 2);
		441	z = ((c & 0x03) << 6) \| d;
		442
		443	if(len--) ptrOut[ptr++] = x; else break;
		444	if(len--) ptrOut[ptr++] = y; else break;
		445	if(len--) ptrOut[ptr++] = z; else break;
		446	}
		447
		448	}
		449
		450	// --------------------------------------------------------------------------
		451	void BearbeiteRxDaten(void)
		452	{
		453	if(!NeuerDatensatzEmpfangen) return;
		454
		455	unsigned int tmp_int_arr1[1];
		456	unsigned int tmp_int_arr2[2];
		457	unsigned int tmp_int_arr3[3];
		458	unsigned char tmp_char_arr2[2];
		459	unsigned char tmp_char_arr3[3];
		460	unsigned char tmp_char_arr4[4];
		461	//if(!MotorenEin)
		462	PcZugriff = 255;
		463	switch(RxdBuffer[2])
		464	{
		465	case 'c':// Debugdaten incl. Externe IOs usw
		466	Decode64((unsigned char *) &DebugIn,sizeof(DebugIn),3,AnzahlEmpfangsBytes);
		467	/* for(unsigned char i=0; i<4;i++)
		468	{
		469	EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2], DebugIn.Analog[i]);
		470	EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2 + 1], DebugIn.Analog[i] >> 8);
		471	}*/
		472	//RemoteTasten \|= DebugIn.RemoteTasten;
		473	DebugDataAnforderung = 1;
		474	break;
		475
		476	case 'h':// x-1 Displayzeilen
		477	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
		478	RemoteTasten \|= tmp_char_arr2[0];
		479	DebugDisplayAnforderung = 1;
		480	break;
		481	case 't':// Motortest
		482	Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);
		483	break;
		484	case 'v': // Version-Anforderung und Ausbaustufe
		485	GetVersionAnforderung = 1;
		486	break;
		487	case 'g':// "Get"-Anforderung f�r Debug-Daten
		488	// Bei Get werden die vom PC einstellbaren Werte vom PC zur�ckgelesen
		489	DebugGetAnforderung = 1;
		490	break;
		491	case 'q':// "Get"-Anforderung f�r Settings
		492	// Bei Get werden die vom PC einstellbaren Werte vom PC zur�ckgelesen
		493	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
		494	if(tmp_char_arr2[0] != 0xff)
		495	{
		496	if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
		497	ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
		498	SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
		499	}
		500	else
		501	SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
		502
		503	break;
		504
		505	case 'l':
		506	case 'm':
		507	case 'n':
		508	case 'o':
		509	case 'p': // Parametersatz speichern
		510	Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
		511	WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
		512	eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken
		513	Piep(GetActiveParamSetNumber());
		514	break;
		515
		516
		517	}
		518	// DebugOut.AnzahlZyklen = Debug_Timer_Intervall;
		519	NeuerDatensatzEmpfangen = 0;
		520	}
		521
		522	//############################################################################
		523	//Routine f�r die Serielle Ausgabe
		524	int uart_putchar (char c)
		525	//############################################################################
		526	{
		527	if (c == '\n')
		528	uart_putchar('\r');
		529	//Warten solange bis Zeichen gesendet wurde
		530	loop_until_bit_is_set(USR, UDRE);
		531	//Ausgabe des Zeichens
		532	UDR = c;
		533
		534	return (0);
		535	}
		536
		537	// --------------------------------------------------------------------------
		538	void WriteProgramData(unsigned int pos, unsigned char wert)
		539	{
		540	//if (ProgramLocation == IN_RAM) Buffer[pos] = wert;
		541	// else eeprom_write_byte(&EE_Buffer[pos], wert);
		542	// Buffer[pos] = wert;
		543	}
		544
		545	//############################################################################
		546	//INstallation der Seriellen Schnittstelle
		547	void UART_Init (void)
		548	//############################################################################
		549	{
		550	//Enable TXEN im Register UCR TX-Data Enable & RX Enable
		551
		552	UCR=(1 << TXEN) \| (1 << RXEN);
		553	// UART Double Speed (U2X)
		554	USR \|= (1<<U2X);
		555	// RX-Interrupt Freigabe
		556	UCSRB \|= (1<<RXCIE);
		557	// TX-Interrupt Freigabe
		558	UCSRB \|= (1<<TXCIE);
		559
		560	//Teiler wird gesetzt
		561	UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
		562	//UBRR = 33;
		563	//�ffnet einen Kanal f�r printf (STDOUT)
		564	//fdevopen (uart_putchar, 0);
		565	//sbi(PORTD,4);
		566	Debug_Timer = SetDelay(200);
		567
		568	gpsState = GPS_EMPTY;
		569	}
		570
		571	//---------------------------------------------------------------------------------------------
		572	void DatenUebertragung(void)
		573	{
		574	static char dis_zeile = 0;
		575	if(!UebertragungAbgeschlossen) return;
		576
		577	if(DebugGetAnforderung && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zur�ckgelesen
		578	{
		579	SendOutData('G',MeineSlaveAdresse,(unsigned char *) &DebugIn,sizeof(DebugIn));
		580	DebugGetAnforderung = 0;
		581	}
		582
		583	if((CheckDelay(Debug_Timer) \|\| DebugDataAnforderung) && UebertragungAbgeschlossen)
		584	{
		585	SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
		586	DebugDataAnforderung = 0;
		587	Debug_Timer = SetDelay(MIN_DEBUG_INTERVALL);
		588	}
		589
		590	if(DebugDisplayAnforderung && UebertragungAbgeschlossen)
		591	{
		592	Menu();
		593	DebugDisplayAnforderung = 0;
		594	if(++dis_zeile == 4)
		595	{
		596	SendOutData('4',0,&PPM_in,sizeof(PPM_in)); // DisplayZeile �bertragen
		597	dis_zeile = -1;
		598	}
		599	else SendOutData('0' + dis_zeile,0,&DisplayBuff[20 * dis_zeile],20); // DisplayZeile �bertragen
		600	}
		601	if(GetVersionAnforderung && UebertragungAbgeschlossen)
		602	{
		603	SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
		604	GetVersionAnforderung = 0;
		605	}
		606
		607	}
		608

Subversion Repositories FlightCtrl

(root)/branches/Flight-Ctrl_V0_64_3_GPS_work_Jochen/uart.c - Rev 501