WebSVN - FlightCtrl - Blame - Rev 1249 - /branches/FC_075b_ACC-HH

Rev	Author	Line No.	Line
1	ingob	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
		8	#include "main.h"
		9	volatile int Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_ax, Aktuell_ay,Aktuell_az, UBat = 100;
1166	hbuss	10	volatile int AdWertNickFilter = 0, AdWertRollFilter = 0, AdWertGierFilter = 0;
		11	volatile int HiResNick = 2500, HiResRoll = 2500;
380	hbuss	12	volatile int AdWertNick = 0, AdWertRoll = 0, AdWertGier = 0;
		13	volatile int AdWertAccRoll = 0,AdWertAccNick = 0,AdWertAccHoch = 0;
1166	hbuss	14	volatile char messanzahl_AccHoch = 0;
1	ingob	15	volatile long Luftdruck = 32000;
		16	volatile int StartLuftdruck;
		17	volatile unsigned int MessLuftdruck = 1023;
		18	unsigned char DruckOffsetSetting;
1036	hbuss	19	signed char ExpandBaro = 0;
1	ingob	20	volatile int HoeheD = 0;
		21	volatile char messanzahl_Druck;
		22	volatile int tmpLuftdruck;
		23	volatile unsigned int ZaehlMessungen = 0;
918	hbuss	24	unsigned char AnalogOffsetNick = 115,AnalogOffsetRoll = 115,AnalogOffsetGier = 115;
		25	unsigned char GyroDefektN = 0,GyroDefektR = 0,GyroDefektG = 0;
1168	hbuss	26	volatile unsigned char AdReady = 1;
1	ingob	27	//#######################################################################################
		28	//
		29	void ADC_Init(void)
		30	//#######################################################################################
		31	{
		32	ADMUX = 0;//Referenz ist extern
1155	hbuss	33	ANALOG_ON;
1	ingob	34	}
		35
		36	void SucheLuftruckOffset(void)
		37	{
		38	unsigned int off;
173	holgerb	39	off = eeprom_read_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET]);
		40	if(off > 20) off -= 10;
		41	OCR0A = off;
1036	hbuss	42	ExpandBaro = 0;
380	hbuss	43	Delay_ms_Mess(100);
173	holgerb	44	if(MessLuftdruck < 850) off = 0;
		45	for(; off < 250;off++)
1	ingob	46	{
		47	OCR0A = off;
380	hbuss	48	Delay_ms_Mess(50);
1	ingob	49	printf(".");
1036	hbuss	50	if(MessLuftdruck < 850) break;
1	ingob	51	}
173	holgerb	52	eeprom_write_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET], off);
		53	DruckOffsetSetting = off;
380	hbuss	54	Delay_ms_Mess(300);
1	ingob	55	}
		56
918	hbuss	57	void SucheGyroOffset(void)
		58	{
		59	unsigned char i, ready = 0;
1219	hbuss	60	int timeout;
918	hbuss	61	GyroDefektN = 0; GyroDefektR = 0; GyroDefektG = 0;
1219	hbuss	62	timeout = SetDelay(2000);
918	hbuss	63	for(i=140; i != 0; i--)
		64	{
921	hbuss	65	if(ready == 3 && i > 10) i = 9;
918	hbuss	66	ready = 0;
		67	if(AdWertNick < 1020) AnalogOffsetNick--; else if(AdWertNick > 1030) AnalogOffsetNick++; else ready++;
		68	if(AdWertRoll < 1020) AnalogOffsetRoll--; else if(AdWertRoll > 1030) AnalogOffsetRoll++; else ready++;
		69	if(AdWertGier < 1020) AnalogOffsetGier--; else if(AdWertGier > 1030) AnalogOffsetGier++; else ready++;
		70	twi_state = 8;
		71	i2c_start();
		72	if(AnalogOffsetNick < 10) { GyroDefektN = 1; AnalogOffsetNick = 10;}; if(AnalogOffsetNick > 245) { GyroDefektN = 1; AnalogOffsetNick = 245;};
		73	if(AnalogOffsetRoll < 10) { GyroDefektR = 1; AnalogOffsetRoll = 10;}; if(AnalogOffsetRoll > 245) { GyroDefektR = 1; AnalogOffsetRoll = 245;};
		74	if(AnalogOffsetGier < 10) { GyroDefektG = 1; AnalogOffsetGier = 10;}; if(AnalogOffsetGier > 245) { GyroDefektG = 1; AnalogOffsetGier = 245;};
1219	hbuss	75	while(twi_state) if(CheckDelay(timeout)) {printf("\n\r DAC or I2C ERROR! Check I2C, 3Vref, DAC and BL-Ctrl"); break;}
918	hbuss	76	messanzahl_Druck = 0;
		77	ANALOG_ON;
		78	while(messanzahl_Druck == 0);
		79	if(i<10) Delay_ms_Mess(10);
		80	}
921	hbuss	81	Delay_ms_Mess(70);
918	hbuss	82	}
1	ingob	83
1247	MartinR	84	/* // MartinR: so war es
1171	hbuss	85
		86	1 r
		87	2 g
		88	3 y
		89	4 x
		90	5 n
		91	6 r
		92	7 u
		93	8 z
		94	9 L
		95	10 n
		96	11 r
		97	12 g
		98	13 y
		99	14 x
		100	15 n
		101	16 r
		102	17 L
		103	*/
		104
1247	MartinR	105
		106	/* MartinR : ge�ndert
		107
		108	1 r
		109	2 g
		110	3 L
		111	4 n
		112	5 r
		113	6 y
		114	7 x
		115	8 n
		116	9 r
		117	10 g
		118	11 L
		119	12 n
		120	13 r
		121	14 u
		122	15 z
		123	*/
		124
1	ingob	125	//#######################################################################################
		126	//
		127	SIGNAL(SIG_ADC)
		128	//#######################################################################################
		129	{
		130	static unsigned char kanal=0,state = 0;
1171	hbuss	131	static signed int gier1, roll1, nick1, nick_filter, roll_filter;
1247	MartinR	132
		133	static signed int roll_alt1, roll_alt2, roll_alt3, nick_alt1, nick_alt2, nick_alt3; // MartinR: 4x Mittelung
		134	//static signed int roll_alt1, nick_alt1; // MartinR: 2x Mittelung
		135
1171	hbuss	136	static signed int accy, accx;
1247	MartinR	137
		138	/* // MartinR : so war es Anfang
1171	hbuss	139	switch(state++)
		140	{
		141	case 0:
		142	nick1 = ADC;
		143	kanal = AD_ROLL;
		144	break;
		145	case 1:
		146	roll1 = ADC;
		147	kanal = AD_GIER;
		148	break;
		149	case 2:
		150	gier1 = ADC;
		151	kanal = AD_ACC_Y;
		152	break;
		153	case 3:
		154	Aktuell_ay = NeutralAccY - ADC;
		155	accy = Aktuell_ay;
		156	kanal = AD_ACC_X;
		157	break;
		158	case 4:
		159	Aktuell_ax = ADC - NeutralAccX;
		160	accx = Aktuell_ax;
		161	kanal = AD_NICK;
		162	break;
		163	case 5:
		164	nick1 += ADC;
		165	kanal = AD_ROLL;
		166	break;
		167	case 6:
		168	roll1 += ADC;
		169	kanal = AD_UBAT;
		170	break;
		171	case 7:
		172	UBat = (3 * UBat + ADC / 3) / 4;
		173	kanal = AD_ACC_Z;
		174	break;
		175	case 8:
		176	AdWertAccHoch = (signed int) ADC - NeutralAccZ;
		177	if(AdWertAccHoch > 1)
		178	{
		179	if(NeutralAccZ < 750)
		180	{
		181	NeutralAccZ += 0.02;
		182	if(modell_fliegt < 500) NeutralAccZ += 0.1;
		183	}
		184	}
		185	else if(AdWertAccHoch < -1)
		186	{
		187	if(NeutralAccZ > 550)
		188	{
		189	NeutralAccZ-= 0.02;
		190	if(modell_fliegt < 500) NeutralAccZ -= 0.1;
		191	}
		192	}
		193	messanzahl_AccHoch = 1;
		194	Aktuell_az = ADC;
		195	Mess_Integral_Hoch += AdWertAccHoch; // Integrieren
		196	Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // d�mfen
		197	kanal = AD_DRUCK;
		198	break;
		199	// "case 8:" fehlt hier absichtlich
		200	case 10:
		201	nick1 += ADC;
		202	kanal = AD_ROLL;
		203	break;
		204	case 11:
		205	roll1 += ADC;
		206	kanal = AD_GIER;
		207	break;
		208	case 12:
		209	if(PlatinenVersion == 10) AdWertGier = (ADC + gier1 + 1) / 2;
		210	else
		211	if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1);
		212	else AdWertGier = (ADC + gier1);
		213	kanal = AD_ACC_Y;
		214	break;
		215	case 13:
		216	Aktuell_ay = NeutralAccY - ADC;
		217	AdWertAccRoll = (Aktuell_ay + accy);
		218	kanal = AD_ACC_X;
		219	break;
		220	case 14:
		221	Aktuell_ax = ADC - NeutralAccX;
		222	AdWertAccNick = (Aktuell_ax + accx);
		223	kanal = AD_NICK;
		224	break;
		225	case 15:
		226	nick1 += ADC;
1173	hbuss	227	if(PlatinenVersion == 10) nick1 = 2; else nick1 = 4;
		228	AdWertNick = nick1 / 8;
		229	nick_filter = (nick_filter + nick1) / 2;
		230	HiResNick = nick_filter - AdNeutralNick;
1171	hbuss	231	AdWertNickFilter = (AdWertNickFilter + HiResNick) / 2;
		232	kanal = AD_ROLL;
		233	break;
		234	case 16:
		235	roll1 += ADC;
1173	hbuss	236	if(PlatinenVersion == 10) roll1 = 2; else roll1 = 4;
		237	AdWertRoll = roll1 / 8;
		238	roll_filter = (roll_filter + roll1) / 2;
		239	HiResRoll = roll_filter - AdNeutralRoll;
1171	hbuss	240	AdWertRollFilter = (AdWertRollFilter + HiResRoll) / 2;
		241	kanal = AD_DRUCK;
		242	break;
		243	case 17:
		244	state = 0;
		245	AdReady = 1;
		246	ZaehlMessungen++;
		247	// "break" fehlt hier absichtlich
		248	case 9:
		249	tmpLuftdruck += ADC;
		250	if(++messanzahl_Druck >= 5)
		251	{
		252	tmpLuftdruck /= 2;
		253	MessLuftdruck = ADC;
		254	messanzahl_Druck = 0;
		255	HoeheD = (31 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert))/32; // D-Anteil = neuerWert - AlterWert
		256	Luftdruck = (tmpLuftdruck + 7 * Luftdruck + 4) / 8;
		257	HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck;
		258	tmpLuftdruck /= 2;
		259	}
		260	kanal = AD_NICK;
		261	break;
		262	default:
		263	kanal = 0; state = 0; kanal = AD_NICK;
		264	break;
		265	}
1247	MartinR	266
		267	*/ // MartinR : so war es Ende
		268
		269	// MartinR : ge�ndert Anfang
		270
		271	switch(state++)
		272	{
		273	case 0:
		274	nick1 = ADC;
		275	kanal = AD_ROLL;
		276	break;
		277	case 1:
		278	roll1 = ADC;
		279	kanal = AD_GIER;
		280	break;
		281
		282	case 2:
		283	gier1 = ADC;
		284	kanal = AD_DRUCK;
		285	break;
		286	case 3:
		287	tmpLuftdruck = ADC;
		288	kanal = AD_NICK;
		289	break;
		290
		291	case 4:
		292	nick1 += ADC;
		293	kanal = AD_ROLL;
		294	break;
		295	case 5:
		296	roll1 += ADC;
		297	kanal = AD_ACC_Y;
		298	break;
		299
		300	case 6:
		301	Aktuell_ay = NeutralAccY - ADC;
		302	AdWertAccRoll = (Aktuell_ay + accy);
		303	accy = Aktuell_ay;
		304	kanal = AD_ACC_X;
		305	break;
		306	case 7:
		307	Aktuell_ax = ADC - NeutralAccX;
		308	AdWertAccNick = (Aktuell_ax + accx);
		309	accx = Aktuell_ax;
		310	kanal = AD_NICK;
		311	break;
		312
		313	case 8:
		314	nick1 += ADC;
		315	kanal = AD_ROLL;
		316	break;
		317	case 9:
		318	roll1 += ADC;
		319	kanal = AD_GIER;
		320	break;
		321
		322	case 10:
		323	if(PlatinenVersion == 10) AdWertGier = (ADC + gier1 + 1) / 2;
		324	else
		325	if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1);
		326	else AdWertGier = (ADC + gier1);
		327	kanal = AD_DRUCK;
		328	break;
		329
1249	MartinR	330	case 11:
		331
1247	MartinR	332	/* MartinR: so war es Anfang
1249	MartinR	333	tmpLuftdruck += ADC;
		334	if(++messanzahl_Druck >= 5)
		335	{
		336	tmpLuftdruck /= 2;
		337	MessLuftdruck = ADC;
		338	messanzahl_Druck = 0;
		339	HoeheD = (31 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert))/32; // D-Anteil = neuerWert - AlterWert
		340	Luftdruck = (tmpLuftdruck + 7 * Luftdruck + 4) / 8;
		341	HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck;
		342	tmpLuftdruck /= 2;
		343	}
1247	MartinR	344	*/ //MartinR: so war es Ende
		345
1249	MartinR	346	// MartinR: �nderungen Anfang : // nach fc.c verschoben
1247	MartinR	347	/*
		348	HoehenWertSumme += HoehenWert ;
		349	if (++ iHoehe >= 40) // MartinR: Wartezeit um auch kleine �nderungsgeschwindigkeiten erkennen zu k�nnen
		350	{
		351	HoehenWertSumme = HoehenWertSumme / iHoehe ; // MartinR: Mittelwert w�hrend der Wartezeit
		352	HoeheD = (int) Parameter_Luftdruck_D * (HoehenWert - HoehenWertalt) ;
		353	if (HoeheD < 0) HoeheD += Parameter_Luftdruck_D ; // MartinR: Digitalisierungsrauschen abmindern
		354	if (HoeheD > 0) HoeheD -= Parameter_Luftdruck_D ; // MartinR: entspricht - 1 Bit vom H�henwert
		355
		356	iHoehe = 0 ;
		357	HoehenWertalt = HoehenWertSumme ;
		358	HoehenWertSumme = 0 ;
		359	}
		360	*/
		361
		362	// MartinR: neu
		363	tmpLuftdruck += ADC;
		364	MessLuftdruck = tmpLuftdruck / 2;
1249	MartinR	365	//Luftdruck = (MessLuftdruck + 7 * Luftdruck + 4) / 8;
		366	Luftdruck = (tmpLuftdruck + 7 * Luftdruck + 4) / 8;
1247	MartinR	367	// HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck; // MartinR: zu H�henregler
		368
		369	kanal = AD_NICK;
		370	break;
		371
		372	case 12:
		373	nick1 += ADC;
		374	//if(PlatinenVersion == 10) nick1 = 2; else nick1 = 4; // MartinR: so war es
		375	//if(PlatinenVersion == 10) ; else nick1 *= 2; // MartinR: 2x Mittelung
		376	if(PlatinenVersion == 10) nick1 /= 2; //else nick1 *= 1; // MartinR: 4x Mittelung
		377	//AdWertNick = nick1 / 8; // MartinR: so war es
		378	//AdWertNick = nick1 / 4; // MartinR: 2x Mittelung
		379	AdWertNick = nick1 / 2; // MartinR: 4x Mittelung
		380
		381	// nick_filter = (nick_filter + nick1) / 2; // MartinR: so war es
		382	//nick_filter = (nick_alt1 + nick1); // MartinR: anderer Nick-Filter: 2x Mittelung
		383	nick_filter = (nick_alt3 +nick_alt2 +nick_alt1 + nick1); // MartinR: anderer Nick-Filter: 4x Mittelung
		384	nick_alt3 = nick_alt2; // MartinR: anderer Nick-Filter
		385	nick_alt2 = nick_alt1; // MartinR: anderer Nick-Filter
		386	nick_alt1 = nick1; // MartinR: anderer Nick-Filter
		387
		388	HiResNick = nick_filter - AdNeutralNick;
		389	//AdWertNickFilter = (AdWertNickFilter + HiResNick) / 2; // MartinR: so war es
		390	AdWertNickFilter = HiResNick; // MartinR: Filter deaktiviert
		391	kanal = AD_ROLL;
		392
		393	break;
		394	case 13:
		395	roll1 += ADC;
		396	// if(PlatinenVersion == 10) roll1 = 2; else roll1 = 4; // MartinR: so war es
		397	//if(PlatinenVersion == 10) ; else roll1 *= 2; // MartinR: 2x Mittelung
		398	if(PlatinenVersion == 10) roll1 /= 2; //else roll1 *= 1; // MartinR: 4x Mittelung
		399	// AdWertRoll = roll1 / 8; // MartinR: so war es
		400	//AdWertRoll = roll1 / 4; // MartinR: 2x Mittelung
		401	AdWertRoll = roll1 / 2; // MartinR: 4x Mittelung
		402
		403	//roll_filter = (roll_filter + roll1) / 2; // MartinR: so war es
		404	//roll_filter = (roll_alt1 + roll1); // MartinR: anderer Nick-Filter: 2x Mittelung
		405	roll_filter = (roll_alt3 + roll_alt2 + roll_alt1 + roll1); // MartinR: anderer Nick-Filter: 4x Mittelung
		406	roll_alt3 = roll_alt2; // MartinR: anderer Nick-Filter
		407	roll_alt2 = roll_alt1; // MartinR: anderer Nick-Filter
		408	roll_alt1 = roll1; // MartinR: anderer Nick-Filter
		409
		410	HiResRoll = roll_filter - AdNeutralRoll;
		411	//AdWertRollFilter = (AdWertRollFilter + HiResRoll) / 2; // MartinR: so war es
		412	AdWertRollFilter = HiResRoll; // MartinR: Filter deaktiviert
		413
		414	kanal = AD_UBAT;
		415
		416	break;
		417
		418	case 14:
		419	UBat = (3 * UBat + ADC / 3) / 4;
		420	kanal = AD_ACC_Z;
		421	break;
		422
		423	case 15:
		424	// AdWertAccHoch = (signed int) ADC - NeutralAccZ; // MartinR : so war es
		425	//AdWertAccHoch = ADC - NeutralAccZ; // MartinR: modifiziert f�r Tests
		426	/* // MartinR: deaktiviert
		427
		428	if(AdWertAccHoch > 1)
		429	{
		430	if(NeutralAccZ < 750)
		431	{
		432	NeutralAccZ += 0.02;
		433	if(modell_fliegt < 500) NeutralAccZ += 0.1;
		434	}
		435	}
		436	else if(AdWertAccHoch < -1)
		437	{
		438	if(NeutralAccZ > 550)
		439	{
		440	NeutralAccZ -= 0.02;
		441	if(modell_fliegt < 500) NeutralAccZ -= 0.1;
		442	}
		443	}
		444	*/ // MartinR: deaktiviert Ende
		445
		446	// messanzahl_AccHoch = 1; MartinR: deaktiviert, da nicht verwendet
		447
		448	Aktuell_az = (Aktuell_az + ADC) / 2;
		449	AdWertAccHoch = Aktuell_az - NeutralAccZ; // MartinR: modifiziert f�r Tests
		450	//Mess_Integral_Hoch += AdWertAccHoch; // Integrieren // MartinR: zu H�henregler in fc.c verschoben
		451	//Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // d�mfen // MartinR: zu H�henregler in fc.c verschoben
		452
		453	AdReady = 1;
		454	state = 0;
		455	kanal = AD_NICK;
		456	break;
		457
		458	default:
		459	kanal = 0; state = 0; kanal = AD_NICK;
		460	break;
		461	}
		462
		463	// MartinR : ge�ndert Ende
		464
		465
1171	hbuss	466	ADMUX = kanal;
1247	MartinR	467	// if(state != 0) ANALOG_ON; // MartinR : so war es
		468	// if(state != 0) ANALOG_START; // MartinR verschoben zu timer0
		469
1171	hbuss	470	}
		471
		472
		473
		474	/*
		475	//#######################################################################################
		476	//
		477	SIGNAL(SIG_ADC)
		478	//#######################################################################################
		479	{
		480	static unsigned char kanal=0,state = 0;
1166	hbuss	481	static signed int gier1, roll1, nick1;
		482	static signed long nick_filter, roll_filter;
		483	static signed int accy, accx;
		484	switch(state++)
		485	{
		486	case 0:
		487	nick1 = ADC;
		488	kanal = AD_ROLL;
		489	break;
		490	case 1:
		491	roll1 = ADC;
		492	kanal = AD_GIER;
		493	break;
		494	case 2:
		495	gier1 = ADC;
		496	kanal = AD_ACC_Y;
		497	break;
		498	case 3:
		499	Aktuell_ay = NeutralAccY - ADC;
		500	accy = Aktuell_ay;
		501	kanal = AD_NICK;
		502	break;
		503	case 4:
		504	nick1 += ADC;
		505	kanal = AD_ROLL;
		506	break;
		507	case 5:
		508	roll1 += ADC;
		509	kanal = AD_ACC_Z;
		510	break;
		511	case 6:
		512	AdWertAccHoch = (signed int) ADC - NeutralAccZ;
		513	if(AdWertAccHoch > 1)
		514	{
		515	if(NeutralAccZ < 750)
		516	{
		517	NeutralAccZ += 0.02;
		518	if(modell_fliegt < 500) NeutralAccZ += 0.1;
		519	}
		520	}
		521	else if(AdWertAccHoch < -1)
		522	{
		523	if(NeutralAccZ > 550)
		524	{
		525	NeutralAccZ-= 0.02;
		526	if(modell_fliegt < 500) NeutralAccZ -= 0.1;
		527	}
		528	}
		529	messanzahl_AccHoch = 1;
		530	Aktuell_az = ADC;
		531	Mess_Integral_Hoch += AdWertAccHoch; // Integrieren
		532	Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // d�mfen
		533	kanal = AD_NICK;
		534	break;
		535	case 7:
		536	nick1 += ADC;
		537	kanal = AD_ROLL;
		538	break;
		539	case 8:
		540	roll1 += ADC;
		541	kanal = AD_ACC_X;
		542	break;
		543	case 9:
		544	Aktuell_ax = ADC - NeutralAccX;
		545	accx = Aktuell_ax;
		546	kanal = AD_GIER;
		547	break;
		548	case 10:
		549	gier1 += ADC;
		550	kanal = AD_NICK;
		551	break;
		552	case 11:
		553	nick1 += ADC;
		554	kanal = AD_ROLL;
		555	break;
		556	case 12:
		557	roll1 += ADC;
		558	kanal = AD_UBAT;
		559	break;
		560	case 13:
		561	UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2;
		562	kanal = AD_ACC_Y;
		563	break;
		564	case 14:
		565	Aktuell_ay = NeutralAccY - ADC;
		566	accy += Aktuell_ay;
		567	kanal = AD_NICK;
		568	break;
		569	case 15:
		570	nick1 += ADC;
		571	kanal = AD_ROLL;
		572	break;
		573	case 16:
		574	roll1 += ADC;
		575	kanal = AD_ACC_X;
		576	break;
		577	case 17:
		578	Aktuell_ax = ADC - NeutralAccX;
		579	accx += Aktuell_ax;
		580	kanal = AD_NICK;
		581	break;
		582	case 18:
		583	nick1 += ADC;
		584	kanal = AD_ROLL;
		585	break;
		586	case 19:
		587	roll1 += ADC;
		588	kanal = AD_GIER;
		589	break;
		590	case 20:
		591	gier1 += ADC;
		592	kanal = AD_ACC_Y;
		593	break;
		594	case 21:
		595	Aktuell_ay = NeutralAccY - ADC;
		596	accy += Aktuell_ay;
		597	kanal = AD_NICK;
		598	break;
		599	case 22:
		600	nick1 += ADC;
		601	kanal = AD_ROLL;
		602	break;
		603	case 23:
		604	roll1 += ADC;
		605	kanal = AD_DRUCK;
		606	break;
		607	case 24:
		608	tmpLuftdruck += ADC;
		609	if(++messanzahl_Druck >= 5)
		610	{
		611	MessLuftdruck = ADC;
		612	messanzahl_Druck = 0;
1167	hbuss	613	HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert)) / 8; // D-Anteil = neuerWert - AlterWert
1166	hbuss	614	Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;
		615	HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck;
		616	tmpLuftdruck = 0;
		617	}
		618	kanal = AD_NICK;
		619	break;
		620	case 25:
		621	nick1 += ADC;
		622	kanal = AD_ROLL;
		623	break;
		624	case 26:
		625	roll1 += ADC;
		626	kanal = AD_ACC_X;
		627	break;
		628	case 27:
		629	Aktuell_ax = ADC - NeutralAccX;
		630	accx += Aktuell_ax;
		631	kanal = AD_GIER;
		632	break;
		633	case 28:
		634	if(PlatinenVersion == 10) AdWertGier = (ADC + gier1 + 2) / 4;
		635	else
		636	if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1 + 1) / 2;
		637	else AdWertGier = (ADC + gier1 + 1) / 2;
		638	kanal = AD_NICK;
		639	break;
		640	case 29:
		641	nick1 += ADC;
		642	kanal = AD_ROLL;
		643	break;
		644	case 30:
		645	roll1 += ADC;
		646	kanal = AD_ACC_Y;
		647	break;
		648	case 31:
		649	Aktuell_ay = NeutralAccY - ADC;
		650	AdWertAccRoll = (Aktuell_ay + accy);
		651	kanal = AD_NICK;
		652	break;
		653	case 32:
		654	AdWertNick = (ADC + nick1 + 3) / 5;
		655	nick_filter = (long) (1 * (long) nick_filter + 4 * (long)(ADC + nick1) + 1) / 2;
		656	if(PlatinenVersion == 10) { AdWertNick /= 2;nick_filter /=2;}
		657	HiResNick = nick_filter - 20 * AdNeutralNick;
		658	AdWertNickFilter = (long)(3L * (long)AdWertNickFilter + HiResNick + 2) / 4;
		659	DebugOut.Analog[21] = AdWertNickFilter / 4;
		660	kanal = AD_ROLL;
		661	break;
		662	case 33:
		663	AdWertRoll = (ADC + roll1 + 3) / 5;
		664	roll_filter = (long)(1 * (long)roll_filter + 4 * (long)(ADC + roll1) + 1) / 2;
		665	if(PlatinenVersion == 10) { AdWertRoll /= 2;roll_filter /=2;}
		666	HiResRoll = roll_filter - 20 * AdNeutralRoll;
		667	AdWertRollFilter = (long)(3L * (long)AdWertRollFilter + HiResRoll + 2) / 4;
		668	DebugOut.Analog[22] = AdWertRollFilter / 4;
		669	kanal = AD_ACC_X;
		670	break;
		671	case 34:
		672	Aktuell_ax = ADC - NeutralAccX;
		673	AdWertAccNick = (Aktuell_ax + accx);
		674	kanal = AD_NICK;
		675	state = 0;
		676	AdReady = 1;
		677	ZaehlMessungen++;
		678	break;
		679	default:
		680	kanal = 0;
		681	state = 0;
		682	break;
		683	}
		684	ADMUX = kanal;
		685	if(state != 0) ANALOG_ON;
		686	}
1171	hbuss	687	*/

Subversion Repositories FlightCtrl

(root)/branches/FC_075b_ACC-HH_MartinR/analog.c - Rev 1249