WebSVN - FlightCtrl - Blame - Rev 1250 - /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:
1250	MartinR	287	tmpLuftdruck += ADC;
		288	messanzahl_Druck ++;
1247	MartinR	289	kanal = AD_NICK;
		290	break;
		291
		292	case 4:
		293	nick1 += ADC;
		294	kanal = AD_ROLL;
		295	break;
		296	case 5:
		297	roll1 += ADC;
		298	kanal = AD_ACC_Y;
		299	break;
		300
		301	case 6:
		302	Aktuell_ay = NeutralAccY - ADC;
		303	AdWertAccRoll = (Aktuell_ay + accy);
		304	accy = Aktuell_ay;
		305	kanal = AD_ACC_X;
		306	break;
		307	case 7:
		308	Aktuell_ax = ADC - NeutralAccX;
		309	AdWertAccNick = (Aktuell_ax + accx);
		310	accx = Aktuell_ax;
		311	kanal = AD_NICK;
		312	break;
		313
		314	case 8:
		315	nick1 += ADC;
		316	kanal = AD_ROLL;
		317	break;
		318	case 9:
		319	roll1 += ADC;
		320	kanal = AD_GIER;
		321	break;
		322
		323	case 10:
		324	if(PlatinenVersion == 10) AdWertGier = (ADC + gier1 + 1) / 2;
		325	else
		326	if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1);
		327	else AdWertGier = (ADC + gier1);
		328	kanal = AD_DRUCK;
		329	break;
		330
1249	MartinR	331	case 11:
		332
1247	MartinR	333	/* MartinR: so war es Anfang
1249	MartinR	334	tmpLuftdruck += ADC;
		335	if(++messanzahl_Druck >= 5)
		336	{
		337	tmpLuftdruck /= 2;
		338	MessLuftdruck = ADC;
		339	messanzahl_Druck = 0;
		340	HoeheD = (31 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert))/32; // D-Anteil = neuerWert - AlterWert
		341	Luftdruck = (tmpLuftdruck + 7 * Luftdruck + 4) / 8;
		342	HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck;
		343	tmpLuftdruck /= 2;
		344	}
1247	MartinR	345	*/ //MartinR: so war es Ende
		346
1249	MartinR	347	// MartinR: �nderungen Anfang : // nach fc.c verschoben
1247	MartinR	348	/*
		349	HoehenWertSumme += HoehenWert ;
		350	if (++ iHoehe >= 40) // MartinR: Wartezeit um auch kleine �nderungsgeschwindigkeiten erkennen zu k�nnen
		351	{
		352	HoehenWertSumme = HoehenWertSumme / iHoehe ; // MartinR: Mittelwert w�hrend der Wartezeit
		353	HoeheD = (int) Parameter_Luftdruck_D * (HoehenWert - HoehenWertalt) ;
		354	if (HoeheD < 0) HoeheD += Parameter_Luftdruck_D ; // MartinR: Digitalisierungsrauschen abmindern
		355	if (HoeheD > 0) HoeheD -= Parameter_Luftdruck_D ; // MartinR: entspricht - 1 Bit vom H�henwert
		356
		357	iHoehe = 0 ;
		358	HoehenWertalt = HoehenWertSumme ;
		359	HoehenWertSumme = 0 ;
		360	}
		361	*/
		362
		363	// MartinR: neu
		364	tmpLuftdruck += ADC;
1250	MartinR	365	//MessLuftdruck = tmpLuftdruck / 2;
		366	MessLuftdruck = ADC;
		367
		368	if(++messanzahl_Druck >= 5)
		369	{
		370	tmpLuftdruck -= 2616L * ExpandBaro; // -523.19 counts per 10 counts offset step
		371	tmpLuftdruck /= 2;
		372	messanzahl_Druck = 0;
		373	//HoeheD = (31 * HoeheD + (int) Parameter_Luftdruck_D * (int)((int)(StartLuftdruck - tmpLuftdruck) - HoehenWert))/32; // D-Anteil = neuerWert - AlterWert
		374	Luftdruck = (tmpLuftdruck + 7 * Luftdruck + 4) / 8;
		375	HoehenWert = StartLuftdruck - Luftdruck;
		376	//tmpLuftdruck /= 2;
		377	tmpLuftdruck = 0;
		378	}
		379
		380	// Luftdruck = (tmpLuftdruck + 7 * Luftdruck + 4) / 8;
1247	MartinR	381	// HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck; // MartinR: zu H�henregler
		382
		383	kanal = AD_NICK;
		384	break;
		385
		386	case 12:
		387	nick1 += ADC;
		388	//if(PlatinenVersion == 10) nick1 = 2; else nick1 = 4; // MartinR: so war es
		389	//if(PlatinenVersion == 10) ; else nick1 *= 2; // MartinR: 2x Mittelung
		390	if(PlatinenVersion == 10) nick1 /= 2; //else nick1 *= 1; // MartinR: 4x Mittelung
		391	//AdWertNick = nick1 / 8; // MartinR: so war es
		392	//AdWertNick = nick1 / 4; // MartinR: 2x Mittelung
		393	AdWertNick = nick1 / 2; // MartinR: 4x Mittelung
		394
		395	// nick_filter = (nick_filter + nick1) / 2; // MartinR: so war es
		396	//nick_filter = (nick_alt1 + nick1); // MartinR: anderer Nick-Filter: 2x Mittelung
		397	nick_filter = (nick_alt3 +nick_alt2 +nick_alt1 + nick1); // MartinR: anderer Nick-Filter: 4x Mittelung
		398	nick_alt3 = nick_alt2; // MartinR: anderer Nick-Filter
		399	nick_alt2 = nick_alt1; // MartinR: anderer Nick-Filter
		400	nick_alt1 = nick1; // MartinR: anderer Nick-Filter
		401
		402	HiResNick = nick_filter - AdNeutralNick;
		403	//AdWertNickFilter = (AdWertNickFilter + HiResNick) / 2; // MartinR: so war es
		404	AdWertNickFilter = HiResNick; // MartinR: Filter deaktiviert
		405	kanal = AD_ROLL;
		406
		407	break;
		408	case 13:
		409	roll1 += ADC;
		410	// if(PlatinenVersion == 10) roll1 = 2; else roll1 = 4; // MartinR: so war es
		411	//if(PlatinenVersion == 10) ; else roll1 *= 2; // MartinR: 2x Mittelung
		412	if(PlatinenVersion == 10) roll1 /= 2; //else roll1 *= 1; // MartinR: 4x Mittelung
		413	// AdWertRoll = roll1 / 8; // MartinR: so war es
		414	//AdWertRoll = roll1 / 4; // MartinR: 2x Mittelung
		415	AdWertRoll = roll1 / 2; // MartinR: 4x Mittelung
		416
		417	//roll_filter = (roll_filter + roll1) / 2; // MartinR: so war es
		418	//roll_filter = (roll_alt1 + roll1); // MartinR: anderer Nick-Filter: 2x Mittelung
		419	roll_filter = (roll_alt3 + roll_alt2 + roll_alt1 + roll1); // MartinR: anderer Nick-Filter: 4x Mittelung
		420	roll_alt3 = roll_alt2; // MartinR: anderer Nick-Filter
		421	roll_alt2 = roll_alt1; // MartinR: anderer Nick-Filter
		422	roll_alt1 = roll1; // MartinR: anderer Nick-Filter
		423
		424	HiResRoll = roll_filter - AdNeutralRoll;
		425	//AdWertRollFilter = (AdWertRollFilter + HiResRoll) / 2; // MartinR: so war es
		426	AdWertRollFilter = HiResRoll; // MartinR: Filter deaktiviert
		427
		428	kanal = AD_UBAT;
		429
		430	break;
		431
		432	case 14:
		433	UBat = (3 * UBat + ADC / 3) / 4;
		434	kanal = AD_ACC_Z;
		435	break;
		436
		437	case 15:
		438	// AdWertAccHoch = (signed int) ADC - NeutralAccZ; // MartinR : so war es
		439	//AdWertAccHoch = ADC - NeutralAccZ; // MartinR: modifiziert f�r Tests
		440	/* // MartinR: deaktiviert
		441
		442	if(AdWertAccHoch > 1)
		443	{
		444	if(NeutralAccZ < 750)
		445	{
		446	NeutralAccZ += 0.02;
		447	if(modell_fliegt < 500) NeutralAccZ += 0.1;
		448	}
		449	}
		450	else if(AdWertAccHoch < -1)
		451	{
		452	if(NeutralAccZ > 550)
		453	{
		454	NeutralAccZ -= 0.02;
		455	if(modell_fliegt < 500) NeutralAccZ -= 0.1;
		456	}
		457	}
		458	*/ // MartinR: deaktiviert Ende
		459
		460	// messanzahl_AccHoch = 1; MartinR: deaktiviert, da nicht verwendet
		461
		462	Aktuell_az = (Aktuell_az + ADC) / 2;
		463	AdWertAccHoch = Aktuell_az - NeutralAccZ; // MartinR: modifiziert f�r Tests
		464	//Mess_Integral_Hoch += AdWertAccHoch; // Integrieren // MartinR: zu H�henregler in fc.c verschoben
		465	//Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // d�mfen // MartinR: zu H�henregler in fc.c verschoben
		466
		467	AdReady = 1;
		468	state = 0;
		469	kanal = AD_NICK;
		470	break;
		471
		472	default:
		473	kanal = 0; state = 0; kanal = AD_NICK;
		474	break;
		475	}
		476
		477	// MartinR : ge�ndert Ende
		478
		479
1171	hbuss	480	ADMUX = kanal;
1247	MartinR	481	// if(state != 0) ANALOG_ON; // MartinR : so war es
		482	// if(state != 0) ANALOG_START; // MartinR verschoben zu timer0
		483
1171	hbuss	484	}
		485
		486
		487
		488	/*
		489	//#######################################################################################
		490	//
		491	SIGNAL(SIG_ADC)
		492	//#######################################################################################
		493	{
		494	static unsigned char kanal=0,state = 0;
1166	hbuss	495	static signed int gier1, roll1, nick1;
		496	static signed long nick_filter, roll_filter;
		497	static signed int accy, accx;
		498	switch(state++)
		499	{
		500	case 0:
		501	nick1 = ADC;
		502	kanal = AD_ROLL;
		503	break;
		504	case 1:
		505	roll1 = ADC;
		506	kanal = AD_GIER;
		507	break;
		508	case 2:
		509	gier1 = ADC;
		510	kanal = AD_ACC_Y;
		511	break;
		512	case 3:
		513	Aktuell_ay = NeutralAccY - ADC;
		514	accy = Aktuell_ay;
		515	kanal = AD_NICK;
		516	break;
		517	case 4:
		518	nick1 += ADC;
		519	kanal = AD_ROLL;
		520	break;
		521	case 5:
		522	roll1 += ADC;
		523	kanal = AD_ACC_Z;
		524	break;
		525	case 6:
		526	AdWertAccHoch = (signed int) ADC - NeutralAccZ;
		527	if(AdWertAccHoch > 1)
		528	{
		529	if(NeutralAccZ < 750)
		530	{
		531	NeutralAccZ += 0.02;
		532	if(modell_fliegt < 500) NeutralAccZ += 0.1;
		533	}
		534	}
		535	else if(AdWertAccHoch < -1)
		536	{
		537	if(NeutralAccZ > 550)
		538	{
		539	NeutralAccZ-= 0.02;
		540	if(modell_fliegt < 500) NeutralAccZ -= 0.1;
		541	}
		542	}
		543	messanzahl_AccHoch = 1;
		544	Aktuell_az = ADC;
		545	Mess_Integral_Hoch += AdWertAccHoch; // Integrieren
		546	Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // d�mfen
		547	kanal = AD_NICK;
		548	break;
		549	case 7:
		550	nick1 += ADC;
		551	kanal = AD_ROLL;
		552	break;
		553	case 8:
		554	roll1 += ADC;
		555	kanal = AD_ACC_X;
		556	break;
		557	case 9:
		558	Aktuell_ax = ADC - NeutralAccX;
		559	accx = Aktuell_ax;
		560	kanal = AD_GIER;
		561	break;
		562	case 10:
		563	gier1 += ADC;
		564	kanal = AD_NICK;
		565	break;
		566	case 11:
		567	nick1 += ADC;
		568	kanal = AD_ROLL;
		569	break;
		570	case 12:
		571	roll1 += ADC;
		572	kanal = AD_UBAT;
		573	break;
		574	case 13:
		575	UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2;
		576	kanal = AD_ACC_Y;
		577	break;
		578	case 14:
		579	Aktuell_ay = NeutralAccY - ADC;
		580	accy += Aktuell_ay;
		581	kanal = AD_NICK;
		582	break;
		583	case 15:
		584	nick1 += ADC;
		585	kanal = AD_ROLL;
		586	break;
		587	case 16:
		588	roll1 += ADC;
		589	kanal = AD_ACC_X;
		590	break;
		591	case 17:
		592	Aktuell_ax = ADC - NeutralAccX;
		593	accx += Aktuell_ax;
		594	kanal = AD_NICK;
		595	break;
		596	case 18:
		597	nick1 += ADC;
		598	kanal = AD_ROLL;
		599	break;
		600	case 19:
		601	roll1 += ADC;
		602	kanal = AD_GIER;
		603	break;
		604	case 20:
		605	gier1 += ADC;
		606	kanal = AD_ACC_Y;
		607	break;
		608	case 21:
		609	Aktuell_ay = NeutralAccY - ADC;
		610	accy += Aktuell_ay;
		611	kanal = AD_NICK;
		612	break;
		613	case 22:
		614	nick1 += ADC;
		615	kanal = AD_ROLL;
		616	break;
		617	case 23:
		618	roll1 += ADC;
		619	kanal = AD_DRUCK;
		620	break;
		621	case 24:
		622	tmpLuftdruck += ADC;
		623	if(++messanzahl_Druck >= 5)
		624	{
		625	MessLuftdruck = ADC;
		626	messanzahl_Druck = 0;
1167	hbuss	627	HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert)) / 8; // D-Anteil = neuerWert - AlterWert
1166	hbuss	628	Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;
		629	HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck;
		630	tmpLuftdruck = 0;
		631	}
		632	kanal = AD_NICK;
		633	break;
		634	case 25:
		635	nick1 += ADC;
		636	kanal = AD_ROLL;
		637	break;
		638	case 26:
		639	roll1 += ADC;
		640	kanal = AD_ACC_X;
		641	break;
		642	case 27:
		643	Aktuell_ax = ADC - NeutralAccX;
		644	accx += Aktuell_ax;
		645	kanal = AD_GIER;
		646	break;
		647	case 28:
		648	if(PlatinenVersion == 10) AdWertGier = (ADC + gier1 + 2) / 4;
		649	else
		650	if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1 + 1) / 2;
		651	else AdWertGier = (ADC + gier1 + 1) / 2;
		652	kanal = AD_NICK;
		653	break;
		654	case 29:
		655	nick1 += ADC;
		656	kanal = AD_ROLL;
		657	break;
		658	case 30:
		659	roll1 += ADC;
		660	kanal = AD_ACC_Y;
		661	break;
		662	case 31:
		663	Aktuell_ay = NeutralAccY - ADC;
		664	AdWertAccRoll = (Aktuell_ay + accy);
		665	kanal = AD_NICK;
		666	break;
		667	case 32:
		668	AdWertNick = (ADC + nick1 + 3) / 5;
		669	nick_filter = (long) (1 * (long) nick_filter + 4 * (long)(ADC + nick1) + 1) / 2;
		670	if(PlatinenVersion == 10) { AdWertNick /= 2;nick_filter /=2;}
		671	HiResNick = nick_filter - 20 * AdNeutralNick;
		672	AdWertNickFilter = (long)(3L * (long)AdWertNickFilter + HiResNick + 2) / 4;
		673	DebugOut.Analog[21] = AdWertNickFilter / 4;
		674	kanal = AD_ROLL;
		675	break;
		676	case 33:
		677	AdWertRoll = (ADC + roll1 + 3) / 5;
		678	roll_filter = (long)(1 * (long)roll_filter + 4 * (long)(ADC + roll1) + 1) / 2;
		679	if(PlatinenVersion == 10) { AdWertRoll /= 2;roll_filter /=2;}
		680	HiResRoll = roll_filter - 20 * AdNeutralRoll;
		681	AdWertRollFilter = (long)(3L * (long)AdWertRollFilter + HiResRoll + 2) / 4;
		682	DebugOut.Analog[22] = AdWertRollFilter / 4;
		683	kanal = AD_ACC_X;
		684	break;
		685	case 34:
		686	Aktuell_ax = ADC - NeutralAccX;
		687	AdWertAccNick = (Aktuell_ax + accx);
		688	kanal = AD_NICK;
		689	state = 0;
		690	AdReady = 1;
		691	ZaehlMessungen++;
		692	break;
		693	default:
		694	kanal = 0;
		695	state = 0;
		696	break;
		697	}
		698	ADMUX = kanal;
		699	if(state != 0) ANALOG_ON;
		700	}
1171	hbuss	701	*/

Subversion Repositories FlightCtrl

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