WebSVN - FlightCtrl - Diff - Rev 1320 and 1322 - /branches/V0.84a-test1/analog.c


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 04.2007 Holger Buss
// + only for non-profit use
// + www.MikroKopter.com
// + see the File "License.txt" for further Informations
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
#include "main.h"
volatile int  Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_ax, Aktuell_ay,Aktuell_az, UBat = 100;
volatile int  AdWertNickFilter = 0, AdWertRollFilter = 0, AdWertGierFilter = 0;
volatile int  HiResNick = 2500, HiResRoll = 2500;
volatile int  AdWertNick = 0, AdWertRoll = 0, AdWertGier = 0;
volatile int  AdWertAccRoll = 0,AdWertAccNick = 0,AdWertAccHoch = 0;
volatile char messanzahl_AccHoch = 0;
volatile long Luftdruck = 32000;
volatile long SummenHoehe = 0;
volatile int  StartLuftdruck;
volatile unsigned int  MessLuftdruck = 1023;
unsigned char DruckOffsetSetting;
signed char ExpandBaro = 0;
volatile int VarioMeter = 0;
volatile unsigned int ZaehlMessungen = 0;
unsigned char AnalogOffsetNick = 115,AnalogOffsetRoll = 115,AnalogOffsetGier = 115;
unsigned char GyroDefektN = 0,GyroDefektR = 0,GyroDefektG = 0;
volatile unsigned char AdReady = 1;
//#######################################################################################
//
void ADC_Init(void)
//#######################################################################################
{
    ADMUX = 0;//Referenz ist extern
    ANALOG_ON;
}
 
#define DESIRED_H_ADC 850
 
void SucheLuftruckOffset(void)
{
 unsigned int off;
 off = eeprom_read_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET]);
 if(off > 20) off -= 10;
 OCR0A = off;
 ExpandBaro = 0;
 Delay_ms_Mess(100);
 if(MessLuftdruck < DESIRED_H_ADC) off = 0;
 for(; off < 250;off++)
  {
  OCR0A = off;
  Delay_ms_Mess(50);
  printf(".");
  if(MessLuftdruck < DESIRED_H_ADC) break;
  }
 eeprom_write_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET], off);
 DruckOffsetSetting = off;
 Delay_ms_Mess(300);
}
 
void SucheGyroOffset(void)
{
 unsigned char i, ready = 0;
 int timeout;
 GyroDefektN = 0; GyroDefektR = 0; GyroDefektG = 0;
 timeout = SetDelay(2000);
 for(i=140; i != 0; i--)
  {
   if(ready == 3 && i > 10) i = 9;
   ready = 0;
   if(AdWertNick < 1020) AnalogOffsetNick--; else if(AdWertNick > 1030) AnalogOffsetNick++; else ready++;
   if(AdWertRoll < 1020) AnalogOffsetRoll--; else if(AdWertRoll > 1030) AnalogOffsetRoll++; else ready++;
   if(AdWertGier < 1020) AnalogOffsetGier--; else if(AdWertGier > 1030) AnalogOffsetGier++; else ready++;
   twi_state = 8;
   i2c_start();
   if(AnalogOffsetNick < 10)  { GyroDefektN = 1; AnalogOffsetNick = 10;}; if(AnalogOffsetNick > 245) { GyroDefektN = 1; AnalogOffsetNick = 245;};
   if(AnalogOffsetRoll < 10)  { GyroDefektR = 1; AnalogOffsetRoll = 10;}; if(AnalogOffsetRoll > 245) { GyroDefektR = 1; AnalogOffsetRoll = 245;};
   if(AnalogOffsetGier < 10)  { GyroDefektG = 1; AnalogOffsetGier = 10;}; if(AnalogOffsetGier > 245) { GyroDefektG = 1; AnalogOffsetGier = 245;};
   while(twi_state) if(CheckDelay(timeout)) {printf("\n\r DAC or I2C ERROR! Check I2C, 3Vref, DAC and BL-Ctrl"); break;}
   AdReady = 0;
   ANALOG_ON;
   while(!AdReady);
   if(i<10) Delay_ms_Mess(10);
  }
   Delay_ms_Mess(70);
}
 
/*
0  n
1  r
2     g
3     y
4     x
5  n
6  r
7     u
8     z
9     L
10 n
11 r
12    g
13    y
14    x
15 n
16 r
17    L
*/
 
//#######################################################################################
//
SIGNAL(SIG_ADC)
//#######################################################################################
{
    static unsigned char kanal=0,state = 0;
    static signed int gier1, roll1, nick1, nick_filter, roll_filter;
        static signed int accy, accx;
 
        static long tmpLuftdruck = 0;
        static char messanzahl_Druck = 0;
 
    switch(state++)
        {
        case 0:
            nick1 = ADC;
            kanal = AD_ROLL;
            break;
        case 1:
            roll1 = ADC;
                    kanal = AD_GIER;
            break;
        case 2:
            gier1 = ADC;
            kanal = AD_ACC_Y;
            break;
        case 3:
            Aktuell_ay = NeutralAccY - ADC;
            accy = Aktuell_ay;
                    kanal = AD_ACC_X;
            break;
        case 4:
            Aktuell_ax = ADC - NeutralAccX;
            accx =  Aktuell_ax;
            kanal = AD_NICK;
            break;
        case 5:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 6:
            roll1 += ADC;
            kanal = AD_UBAT;
            break;
        case 7:
            UBat = (3 * UBat + ADC / 3) / 4;
                    kanal = AD_ACC_Z;
            break;
       case 8:
            AdWertAccHoch =  (signed int) ADC - NeutralAccZ;
            if(AdWertAccHoch > 1)
             {
              if(NeutralAccZ < 750)
               {
                NeutralAccZ += 0.02;
                if(modell_fliegt < 500) NeutralAccZ += 0.1;
               }
             }
             else if(AdWertAccHoch < -1)
             {
              if(NeutralAccZ > 550)
                {
                 NeutralAccZ-= 0.02;
                 if(modell_fliegt < 500) NeutralAccZ -= 0.1;
                }
             }
            messanzahl_AccHoch = 1;
            Aktuell_az = ADC;
            Mess_Integral_Hoch += AdWertAccHoch;      // Integrieren
            Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
                kanal = AD_DRUCK;
            break;
   // "case 8:" fehlt hier absichtlich
        case 10:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 11:
            roll1 += ADC;
                    kanal = AD_GIER;
            break;
        case 12:
            if(PlatinenVersion == 10)  AdWertGier = (ADC + gier1 + 1) / 2;
            else
            if(PlatinenVersion == 20)  AdWertGier = 2047 - (ADC + gier1);
                        else                                       AdWertGier = (ADC + gier1);
            kanal = AD_ACC_Y;
            break;
        case 13:
            Aktuell_ay = NeutralAccY - ADC;
            AdWertAccRoll = (Aktuell_ay + accy);
            kanal = AD_ACC_X;
            break;
        case 14:
            Aktuell_ax = ADC - NeutralAccX;
            AdWertAccNick =  (Aktuell_ax + accx);
            kanal = AD_NICK;
            break;
        case 15:
            nick1 += ADC;
            if(PlatinenVersion == 10) nick1 *= 2; else nick1 *= 4;
            AdWertNick = nick1 / 8;
            nick_filter = (nick_filter + nick1) / 2;
            HiResNick = nick_filter - AdNeutralNick;
            AdWertNickFilter = (AdWertNickFilter + HiResNick) / 2;
            kanal = AD_ROLL;
            break;
        case 16:
            roll1 += ADC;
            if(PlatinenVersion == 10) roll1 *= 2; else roll1 *= 4;
            AdWertRoll = roll1 / 8;
            roll_filter = (roll_filter + roll1) / 2;
            HiResRoll = roll_filter - AdNeutralRoll;
            AdWertRollFilter = (AdWertRollFilter + HiResRoll) / 2;
                kanal = AD_DRUCK;
            break;
        case 17:
            state = 0;
                        AdReady = 1;
            ZaehlMessungen++;
            // "break" fehlt hier absichtlich
        case 9:
                MessLuftdruck = ADC;
            tmpLuftdruck += MessLuftdruck;
 
            if(++messanzahl_Druck >= 18)
            {
                                Luftdruck = (7 * Luftdruck + tmpLuftdruck - (18 * 523) * (long)ExpandBaro + 4) / 8;  // -523.19 counts per 10 counts offset step
                                HoehenWert = StartLuftdruck - Luftdruck;
                                SummenHoehe -= SummenHoehe/SM_FILTER;
                                SummenHoehe += HoehenWert;
                                VarioMeter = (15 * VarioMeter + 8 * (int)(HoehenWert - SummenHoehe/SM_FILTER))/16;
                tmpLuftdruck /= 2;
                messanzahl_Druck = 18/2;
            }
            kanal = AD_NICK;
            break;
        default:
            kanal = 0; state = 0; kanal = AD_NICK;
            break;
        }
    ADMUX = kanal;
    if(state != 0) ANALOG_ON;
 
}
 
 
 
/*
//#######################################################################################
//
SIGNAL(SIG_ADC)
//#######################################################################################
{
    static unsigned char kanal=0,state = 0;
    static signed int gier1, roll1, nick1;
        static signed long nick_filter, roll_filter;
        static signed int accy, accx;
    switch(state++)
        {
        case 0:
            nick1 = ADC;
            kanal = AD_ROLL;
            break;
        case 1:
            roll1 = ADC;
                    kanal = AD_GIER;
            break;
        case 2:
            gier1 = ADC;
            kanal = AD_ACC_Y;
            break;
        case 3:
            Aktuell_ay = NeutralAccY - ADC;
            accy = Aktuell_ay;
            kanal = AD_NICK;
            break;
        case 4:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 5:
            roll1 += ADC;
                    kanal = AD_ACC_Z;
            break;
       case 6:
            AdWertAccHoch =  (signed int) ADC - NeutralAccZ;
            if(AdWertAccHoch > 1)
             {
              if(NeutralAccZ < 750)
               {
                NeutralAccZ += 0.02;
                if(modell_fliegt < 500) NeutralAccZ += 0.1;
               }
             }
             else if(AdWertAccHoch < -1)
             {
              if(NeutralAccZ > 550)
                {
                 NeutralAccZ-= 0.02;
                 if(modell_fliegt < 500) NeutralAccZ -= 0.1;
                }
             }
            messanzahl_AccHoch = 1;
            Aktuell_az = ADC;
            Mess_Integral_Hoch += AdWertAccHoch;      // Integrieren
            Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
            kanal = AD_NICK;
            break;
        case 7:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 8:
            roll1 += ADC;
                    kanal = AD_ACC_X;
            break;
        case 9:
            Aktuell_ax = ADC - NeutralAccX;
            accx =  Aktuell_ax;
                    kanal = AD_GIER;
            break;
        case 10:
            gier1 += ADC;
            kanal = AD_NICK;
            break;
        case 11:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 12:
            roll1 += ADC;
            kanal = AD_UBAT;
            break;
        case 13:
            UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19)  / 2;
            kanal = AD_ACC_Y;
            break;
        case 14:
            Aktuell_ay = NeutralAccY - ADC;
            accy += Aktuell_ay;
            kanal = AD_NICK;
            break;
        case 15:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 16:
            roll1 += ADC;
            kanal = AD_ACC_X;
            break;
        case 17:
            Aktuell_ax = ADC - NeutralAccX;
            accx += Aktuell_ax;
                    kanal = AD_NICK;
            break;
        case 18:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 19:
            roll1 += ADC;
                    kanal = AD_GIER;
            break;
        case 20:
            gier1 += ADC;
            kanal = AD_ACC_Y;
            break;
        case 21:
            Aktuell_ay = NeutralAccY - ADC;
            accy += Aktuell_ay;
            kanal = AD_NICK;
            break;
        case 22:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 23:
            roll1 += ADC;
                kanal = AD_DRUCK;
            break;
        case 24:
            tmpLuftdruck += ADC;
            if(++messanzahl_Druck >= 5)
                {
                MessLuftdruck = ADC;
                messanzahl_Druck = 0;
                                HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert)) / 8;  // D-Anteil = neuerWert - AlterWert
                Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;
                HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck;
                tmpLuftdruck = 0;
                }
            kanal = AD_NICK;
            break;
        case 25:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 26:
            roll1 += ADC;
                    kanal = AD_ACC_X;
            break;
        case 27:
            Aktuell_ax = ADC - NeutralAccX;
            accx +=  Aktuell_ax;
                    kanal = AD_GIER;
            break;
        case 28:
            if(PlatinenVersion == 10)  AdWertGier = (ADC + gier1 + 2) / 4;
            else
            if(PlatinenVersion == 20)  AdWertGier = 2047 - (ADC + gier1 + 1) / 2;
                        else                                       AdWertGier = (ADC + gier1 + 1) / 2;
            kanal = AD_NICK;
            break;
        case 29:
            nick1 += ADC;
            kanal = AD_ROLL;
            break;
        case 30:
            roll1 += ADC;
            kanal = AD_ACC_Y;
            break;
        case 31:
            Aktuell_ay = NeutralAccY - ADC;
            AdWertAccRoll = (Aktuell_ay + accy);
            kanal = AD_NICK;
            break;
        case 32:
            AdWertNick = (ADC + nick1 + 3) / 5;
            nick_filter = (long) (1 * (long) nick_filter + 4 * (long)(ADC + nick1) + 1) / 2;
            if(PlatinenVersion == 10) { AdWertNick /= 2;nick_filter /=2;}
            HiResNick = nick_filter - 20 * AdNeutralNick;
            AdWertNickFilter = (long)(3L * (long)AdWertNickFilter + HiResNick + 2) / 4;
            DebugOut.Analog[21] = AdWertNickFilter / 4;
            kanal = AD_ROLL;
            break;
        case 33:
            AdWertRoll = (ADC + roll1 + 3) / 5;
            roll_filter = (long)(1 * (long)roll_filter + 4 * (long)(ADC + roll1) + 1) / 2;
            if(PlatinenVersion == 10) { AdWertRoll /= 2;roll_filter /=2;}
            HiResRoll = roll_filter - 20 * AdNeutralRoll;
            AdWertRollFilter = (long)(3L * (long)AdWertRollFilter + HiResRoll + 2) / 4;
            DebugOut.Analog[22] = AdWertRollFilter / 4;
            kanal = AD_ACC_X;
            break;
        case 34:
            Aktuell_ax = ADC - NeutralAccX;
            AdWertAccNick =  (Aktuell_ax + accx);
                    kanal = AD_NICK;
            state = 0;
                        AdReady = 1;
            ZaehlMessungen++;
            break;
        default:
            kanal = 0;
            state = 0;
            break;
        }
    ADMUX = kanal;
    if(state != 0) ANALOG_ON;
}
*/
 

Rev 1320	Rev 1322
1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2	// + Copyright (c) 04.2007 Holger Buss	2	// + Copyright (c) 04.2007 Holger Buss
3	// + only for non-profit use	3	// + only for non-profit use
4	// + www.MikroKopter.com	4	// + www.MikroKopter.com
5	// + see the File "License.txt" for further Informations	5	// + see the File "License.txt" for further Informations
6	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	6	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
7		7
8	#include "main.h"	8	#include "main.h"
9	volatile int Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_ax, Aktuell_ay,Aktuell_az, UBat = 100;	9	volatile int Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_ax, Aktuell_ay,Aktuell_az, UBat = 100;
10	volatile int AdWertNickFilter = 0, AdWertRollFilter = 0, AdWertGierFilter = 0;	10	volatile int AdWertNickFilter = 0, AdWertRollFilter = 0, AdWertGierFilter = 0;
11	volatile int HiResNick = 2500, HiResRoll = 2500;	11	volatile int HiResNick = 2500, HiResRoll = 2500;
12	volatile int AdWertNick = 0, AdWertRoll = 0, AdWertGier = 0;	12	volatile int AdWertNick = 0, AdWertRoll = 0, AdWertGier = 0;
13	volatile int AdWertAccRoll = 0,AdWertAccNick = 0,AdWertAccHoch = 0;	13	volatile int AdWertAccRoll = 0,AdWertAccNick = 0,AdWertAccHoch = 0;
14	volatile char messanzahl_AccHoch = 0;	14	volatile char messanzahl_AccHoch = 0;
15	volatile long Luftdruck = 32000;	15	volatile long Luftdruck = 32000;
-		16	volatile long SummenHoehe = 0;
16	volatile int StartLuftdruck;	17	volatile int StartLuftdruck;
17	volatile unsigned int MessLuftdruck = 1023;	18	volatile unsigned int MessLuftdruck = 1023;
18	unsigned char DruckOffsetSetting;	19	unsigned char DruckOffsetSetting;
19	signed char ExpandBaro = 0;	20	signed char ExpandBaro = 0;
20	volatile int VarioMeter = 0;	21	volatile int VarioMeter = 0;
21	volatile unsigned int ZaehlMessungen = 0;	22	volatile unsigned int ZaehlMessungen = 0;
22	unsigned char AnalogOffsetNick = 115,AnalogOffsetRoll = 115,AnalogOffsetGier = 115;	23	unsigned char AnalogOffsetNick = 115,AnalogOffsetRoll = 115,AnalogOffsetGier = 115;
23	unsigned char GyroDefektN = 0,GyroDefektR = 0,GyroDefektG = 0;	24	unsigned char GyroDefektN = 0,GyroDefektR = 0,GyroDefektG = 0;
24	volatile unsigned char AdReady = 1;	25	volatile unsigned char AdReady = 1;
25	//#######################################################################################	26	//#######################################################################################
26	//	27	//
27	void ADC_Init(void)	28	void ADC_Init(void)
28	//#######################################################################################	29	//#######################################################################################
29	{	30	{
30	ADMUX = 0;//Referenz ist extern	31	ADMUX = 0;//Referenz ist extern
31	ANALOG_ON;	32	ANALOG_ON;
32	}	33	}
-		34
-		35	#define DESIRED_H_ADC 850
33		36
34	void SucheLuftruckOffset(void)	37	void SucheLuftruckOffset(void)
35	{	38	{
36	unsigned int off;	39	unsigned int off;
37	off = eeprom_read_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET]);	40	off = eeprom_read_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET]);
38	if(off > 20) off -= 10;	41	if(off > 20) off -= 10;
39	OCR0A = off;	42	OCR0A = off;
40	ExpandBaro = 0;	43	ExpandBaro = 0;
41	Delay_ms_Mess(100);	44	Delay_ms_Mess(100);
42	if(MessLuftdruck < 850) off = 0;	45	if(MessLuftdruck < DESIRED_H_ADC) off = 0;
43	for(; off < 250;off++)	46	for(; off < 250;off++)
44	{	47	{
45	OCR0A = off;	48	OCR0A = off;
46	Delay_ms_Mess(50);	49	Delay_ms_Mess(50);
47	printf(".");	50	printf(".");
48	if(MessLuftdruck < 850) break;	51	if(MessLuftdruck < DESIRED_H_ADC) break;
49	}	52	}
50	eeprom_write_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET], off);	53	eeprom_write_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET], off);
51	DruckOffsetSetting = off;	54	DruckOffsetSetting = off;
52	Delay_ms_Mess(300);	55	Delay_ms_Mess(300);
53	}	56	}
54		57
55	void SucheGyroOffset(void)	58	void SucheGyroOffset(void)
56	{	59	{
57	unsigned char i, ready = 0;	60	unsigned char i, ready = 0;
58	int timeout;	61	int timeout;
59	GyroDefektN = 0; GyroDefektR = 0; GyroDefektG = 0;	62	GyroDefektN = 0; GyroDefektR = 0; GyroDefektG = 0;
60	timeout = SetDelay(2000);	63	timeout = SetDelay(2000);
61	for(i=140; i != 0; i--)	64	for(i=140; i != 0; i--)
62	{	65	{
63	if(ready == 3 && i > 10) i = 9;	66	if(ready == 3 && i > 10) i = 9;
64	ready = 0;	67	ready = 0;
65	if(AdWertNick < 1020) AnalogOffsetNick--; else if(AdWertNick > 1030) AnalogOffsetNick++; else ready++;	68	if(AdWertNick < 1020) AnalogOffsetNick--; else if(AdWertNick > 1030) AnalogOffsetNick++; else ready++;
66	if(AdWertRoll < 1020) AnalogOffsetRoll--; else if(AdWertRoll > 1030) AnalogOffsetRoll++; else ready++;	69	if(AdWertRoll < 1020) AnalogOffsetRoll--; else if(AdWertRoll > 1030) AnalogOffsetRoll++; else ready++;
67	if(AdWertGier < 1020) AnalogOffsetGier--; else if(AdWertGier > 1030) AnalogOffsetGier++; else ready++;	70	if(AdWertGier < 1020) AnalogOffsetGier--; else if(AdWertGier > 1030) AnalogOffsetGier++; else ready++;
68	twi_state = 8;	71	twi_state = 8;
69	i2c_start();	72	i2c_start();
70	if(AnalogOffsetNick < 10) { GyroDefektN = 1; AnalogOffsetNick = 10;}; if(AnalogOffsetNick > 245) { GyroDefektN = 1; AnalogOffsetNick = 245;};	73	if(AnalogOffsetNick < 10) { GyroDefektN = 1; AnalogOffsetNick = 10;}; if(AnalogOffsetNick > 245) { GyroDefektN = 1; AnalogOffsetNick = 245;};
71	if(AnalogOffsetRoll < 10) { GyroDefektR = 1; AnalogOffsetRoll = 10;}; if(AnalogOffsetRoll > 245) { GyroDefektR = 1; AnalogOffsetRoll = 245;};	74	if(AnalogOffsetRoll < 10) { GyroDefektR = 1; AnalogOffsetRoll = 10;}; if(AnalogOffsetRoll > 245) { GyroDefektR = 1; AnalogOffsetRoll = 245;};
72	if(AnalogOffsetGier < 10) { GyroDefektG = 1; AnalogOffsetGier = 10;}; if(AnalogOffsetGier > 245) { GyroDefektG = 1; AnalogOffsetGier = 245;};	75	if(AnalogOffsetGier < 10) { GyroDefektG = 1; AnalogOffsetGier = 10;}; if(AnalogOffsetGier > 245) { GyroDefektG = 1; AnalogOffsetGier = 245;};
73	while(twi_state) if(CheckDelay(timeout)) {printf("\n\r DAC or I2C ERROR! Check I2C, 3Vref, DAC and BL-Ctrl"); break;}	76	while(twi_state) if(CheckDelay(timeout)) {printf("\n\r DAC or I2C ERROR! Check I2C, 3Vref, DAC and BL-Ctrl"); break;}
74	AdReady = 0;	77	AdReady = 0;
75	ANALOG_ON;	78	ANALOG_ON;
76	while(!AdReady);	79	while(!AdReady);
77	if(i<10) Delay_ms_Mess(10);	80	if(i<10) Delay_ms_Mess(10);
78	}	81	}
79	Delay_ms_Mess(70);	82	Delay_ms_Mess(70);
80	}	83	}
81		84
82	/*	85	/*
83	0 n	86	0 n
84	1 r	87	1 r
85	2 g	88	2 g
86	3 y	89	3 y
87	4 x	90	4 x
88	5 n	91	5 n
89	6 r	92	6 r
90	7 u	93	7 u
91	8 z	94	8 z
92	9 L	95	9 L
93	10 n	96	10 n
94	11 r	97	11 r
95	12 g	98	12 g
96	13 y	99	13 y
97	14 x	100	14 x
98	15 n	101	15 n
99	16 r	102	16 r
100	17 L	103	17 L
101	*/	104	*/
102		105
103	//#######################################################################################	106	//#######################################################################################
104	//	107	//
105	SIGNAL(SIG_ADC)	108	SIGNAL(SIG_ADC)
106	//#######################################################################################	109	//#######################################################################################
107	{	110	{
108	static unsigned char kanal=0,state = 0;	111	static unsigned char kanal=0,state = 0;
109	static signed int gier1, roll1, nick1, nick_filter, roll_filter;	112	static signed int gier1, roll1, nick1, nick_filter, roll_filter;
110	static signed int accy, accx;	113	static signed int accy, accx;
111		114
112	static long tmpLuftdruck = 0;	115	static long tmpLuftdruck = 0;
113	static char messanzahl_Druck = 0;	116	static char messanzahl_Druck = 0;
114	static long SummenHoehe = 0;	-
115	switch(state++)	117	switch(state++)
116	{	118	{
117	case 0:	119	case 0:
118	nick1 = ADC;	120	nick1 = ADC;
119	kanal = AD_ROLL;	121	kanal = AD_ROLL;
120	break;	122	break;
121	case 1:	123	case 1:
122	roll1 = ADC;	124	roll1 = ADC;
123	kanal = AD_GIER;	125	kanal = AD_GIER;
124	break;	126	break;
125	case 2:	127	case 2:
126	gier1 = ADC;	128	gier1 = ADC;
127	kanal = AD_ACC_Y;	129	kanal = AD_ACC_Y;
128	break;	130	break;
129	case 3:	131	case 3:
130	Aktuell_ay = NeutralAccY - ADC;	132	Aktuell_ay = NeutralAccY - ADC;
131	accy = Aktuell_ay;	133	accy = Aktuell_ay;
132	kanal = AD_ACC_X;	134	kanal = AD_ACC_X;
133	break;	135	break;
134	case 4:	136	case 4:
135	Aktuell_ax = ADC - NeutralAccX;	137	Aktuell_ax = ADC - NeutralAccX;
136	accx = Aktuell_ax;	138	accx = Aktuell_ax;
137	kanal = AD_NICK;	139	kanal = AD_NICK;
138	break;	140	break;
139	case 5:	141	case 5:
140	nick1 += ADC;	142	nick1 += ADC;
141	kanal = AD_ROLL;	143	kanal = AD_ROLL;
142	break;	144	break;
143	case 6:	145	case 6:
144	roll1 += ADC;	146	roll1 += ADC;
145	kanal = AD_UBAT;	147	kanal = AD_UBAT;
146	break;	148	break;
147	case 7:	149	case 7:
148	UBat = (3 * UBat + ADC / 3) / 4;	150	UBat = (3 * UBat + ADC / 3) / 4;
149	kanal = AD_ACC_Z;	151	kanal = AD_ACC_Z;
150	break;	152	break;
151	case 8:	153	case 8:
152	AdWertAccHoch = (signed int) ADC - NeutralAccZ;	154	AdWertAccHoch = (signed int) ADC - NeutralAccZ;
153	if(AdWertAccHoch > 1)	155	if(AdWertAccHoch > 1)
154	{	156	{
155	if(NeutralAccZ < 750)	157	if(NeutralAccZ < 750)
156	{	158	{
157	NeutralAccZ += 0.02;	159	NeutralAccZ += 0.02;
158	if(modell_fliegt < 500) NeutralAccZ += 0.1;	160	if(modell_fliegt < 500) NeutralAccZ += 0.1;
159	}	161	}
160	}	162	}
161	else if(AdWertAccHoch < -1)	163	else if(AdWertAccHoch < -1)
162	{	164	{
163	if(NeutralAccZ > 550)	165	if(NeutralAccZ > 550)
164	{	166	{
165	NeutralAccZ-= 0.02;	167	NeutralAccZ-= 0.02;
166	if(modell_fliegt < 500) NeutralAccZ -= 0.1;	168	if(modell_fliegt < 500) NeutralAccZ -= 0.1;
167	}	169	}
168	}	170	}
169	messanzahl_AccHoch = 1;	171	messanzahl_AccHoch = 1;
170	Aktuell_az = ADC;	172	Aktuell_az = ADC;
171	Mess_Integral_Hoch += AdWertAccHoch; // Integrieren	173	Mess_Integral_Hoch += AdWertAccHoch; // Integrieren
172	Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen	174	Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
173	kanal = AD_DRUCK;	175	kanal = AD_DRUCK;
174	break;	176	break;
175	// "case 8:" fehlt hier absichtlich	177	// "case 8:" fehlt hier absichtlich
176	case 10:	178	case 10:
177	nick1 += ADC;	179	nick1 += ADC;
178	kanal = AD_ROLL;	180	kanal = AD_ROLL;
179	break;	181	break;
180	case 11:	182	case 11:
181	roll1 += ADC;	183	roll1 += ADC;
182	kanal = AD_GIER;	184	kanal = AD_GIER;
183	break;	185	break;
184	case 12:	186	case 12:
185	if(PlatinenVersion == 10) AdWertGier = (ADC + gier1 + 1) / 2;	187	if(PlatinenVersion == 10) AdWertGier = (ADC + gier1 + 1) / 2;
186	else	188	else
187	if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1);	189	if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1);
188	else AdWertGier = (ADC + gier1);	190	else AdWertGier = (ADC + gier1);
189	kanal = AD_ACC_Y;	191	kanal = AD_ACC_Y;
190	break;	192	break;
191	case 13:	193	case 13:
192	Aktuell_ay = NeutralAccY - ADC;	194	Aktuell_ay = NeutralAccY - ADC;
193	AdWertAccRoll = (Aktuell_ay + accy);	195	AdWertAccRoll = (Aktuell_ay + accy);
194	kanal = AD_ACC_X;	196	kanal = AD_ACC_X;
195	break;	197	break;
196	case 14:	198	case 14:
197	Aktuell_ax = ADC - NeutralAccX;	199	Aktuell_ax = ADC - NeutralAccX;
198	AdWertAccNick = (Aktuell_ax + accx);	200	AdWertAccNick = (Aktuell_ax + accx);
199	kanal = AD_NICK;	201	kanal = AD_NICK;
200	break;	202	break;
201	case 15:	203	case 15:
202	nick1 += ADC;	204	nick1 += ADC;
203	if(PlatinenVersion == 10) nick1 = 2; else nick1 = 4;	205	if(PlatinenVersion == 10) nick1 = 2; else nick1 = 4;
204	AdWertNick = nick1 / 8;	206	AdWertNick = nick1 / 8;
205	nick_filter = (nick_filter + nick1) / 2;	207	nick_filter = (nick_filter + nick1) / 2;
206	HiResNick = nick_filter - AdNeutralNick;	208	HiResNick = nick_filter - AdNeutralNick;
207	AdWertNickFilter = (AdWertNickFilter + HiResNick) / 2;	209	AdWertNickFilter = (AdWertNickFilter + HiResNick) / 2;
208	kanal = AD_ROLL;	210	kanal = AD_ROLL;
209	break;	211	break;
210	case 16:	212	case 16:
211	roll1 += ADC;	213	roll1 += ADC;
212	if(PlatinenVersion == 10) roll1 = 2; else roll1 = 4;	214	if(PlatinenVersion == 10) roll1 = 2; else roll1 = 4;
213	AdWertRoll = roll1 / 8;	215	AdWertRoll = roll1 / 8;
214	roll_filter = (roll_filter + roll1) / 2;	216	roll_filter = (roll_filter + roll1) / 2;
215	HiResRoll = roll_filter - AdNeutralRoll;	217	HiResRoll = roll_filter - AdNeutralRoll;
216	AdWertRollFilter = (AdWertRollFilter + HiResRoll) / 2;	218	AdWertRollFilter = (AdWertRollFilter + HiResRoll) / 2;
217	kanal = AD_DRUCK;	219	kanal = AD_DRUCK;
218	break;	220	break;
219	case 17:	221	case 17:
220	state = 0;	222	state = 0;
221	AdReady = 1;	223	AdReady = 1;
222	ZaehlMessungen++;	224	ZaehlMessungen++;
223	// "break" fehlt hier absichtlich	225	// "break" fehlt hier absichtlich
224	case 9:	226	case 9:
225	MessLuftdruck = ADC;	227	MessLuftdruck = ADC;
226	tmpLuftdruck += MessLuftdruck;	228	tmpLuftdruck += MessLuftdruck;
227	#define SM_FILTER 16	-
228	if(++messanzahl_Druck >= 18)	229	if(++messanzahl_Druck >= 18)
229	{	230	{
230	Luftdruck = (7 * Luftdruck + tmpLuftdruck - (18 * 523) * (long)ExpandBaro + 4) / 8; // -523.19 counts per 10 counts offset step	231	Luftdruck = (7 * Luftdruck + tmpLuftdruck - (18 * 523) * (long)ExpandBaro + 4) / 8; // -523.19 counts per 10 counts offset step
231	HoehenWert = StartLuftdruck - Luftdruck;	232	HoehenWert = StartLuftdruck - Luftdruck;
232	SummenHoehe -= SummenHoehe/SM_FILTER;	233	SummenHoehe -= SummenHoehe/SM_FILTER;
233	SummenHoehe += HoehenWert;	234	SummenHoehe += HoehenWert;
234	VarioMeter = (15 * VarioMeter + 8 * (int)(HoehenWert - SummenHoehe/SM_FILTER))/16;	235	VarioMeter = (15 * VarioMeter + 8 * (int)(HoehenWert - SummenHoehe/SM_FILTER))/16;
235	tmpLuftdruck /= 2;	236	tmpLuftdruck /= 2;
236	messanzahl_Druck = 18/2;	237	messanzahl_Druck = 18/2;
237	}	238	}
238	kanal = AD_NICK;	239	kanal = AD_NICK;
239	break;	240	break;
240	default:	241	default:
241	kanal = 0; state = 0; kanal = AD_NICK;	242	kanal = 0; state = 0; kanal = AD_NICK;
242	break;	243	break;
243	}	244	}
244	ADMUX = kanal;	245	ADMUX = kanal;
245	if(state != 0) ANALOG_ON;	246	if(state != 0) ANALOG_ON;
246		247
247	}	248	}
248		249
249		250
250		251
251	/*	252	/*
252	//#######################################################################################	253	//#######################################################################################
253	//	254	//
254	SIGNAL(SIG_ADC)	255	SIGNAL(SIG_ADC)
255	//#######################################################################################	256	//#######################################################################################
256	{	257	{
257	static unsigned char kanal=0,state = 0;	258	static unsigned char kanal=0,state = 0;
258	static signed int gier1, roll1, nick1;	259	static signed int gier1, roll1, nick1;
259	static signed long nick_filter, roll_filter;	260	static signed long nick_filter, roll_filter;
260	static signed int accy, accx;	261	static signed int accy, accx;
261	switch(state++)	262	switch(state++)
262	{	263	{
263	case 0:	264	case 0:
264	nick1 = ADC;	265	nick1 = ADC;
265	kanal = AD_ROLL;	266	kanal = AD_ROLL;
266	break;	267	break;
267	case 1:	268	case 1:
268	roll1 = ADC;	269	roll1 = ADC;
269	kanal = AD_GIER;	270	kanal = AD_GIER;
270	break;	271	break;
271	case 2:	272	case 2:
272	gier1 = ADC;	273	gier1 = ADC;
273	kanal = AD_ACC_Y;	274	kanal = AD_ACC_Y;
274	break;	275	break;
275	case 3:	276	case 3:
276	Aktuell_ay = NeutralAccY - ADC;	277	Aktuell_ay = NeutralAccY - ADC;
277	accy = Aktuell_ay;	278	accy = Aktuell_ay;
278	kanal = AD_NICK;	279	kanal = AD_NICK;
279	break;	280	break;
280	case 4:	281	case 4:
281	nick1 += ADC;	282	nick1 += ADC;
282	kanal = AD_ROLL;	283	kanal = AD_ROLL;
283	break;	284	break;
284	case 5:	285	case 5:
285	roll1 += ADC;	286	roll1 += ADC;
286	kanal = AD_ACC_Z;	287	kanal = AD_ACC_Z;
287	break;	288	break;
288	case 6:	289	case 6:
289	AdWertAccHoch = (signed int) ADC - NeutralAccZ;	290	AdWertAccHoch = (signed int) ADC - NeutralAccZ;
290	if(AdWertAccHoch > 1)	291	if(AdWertAccHoch > 1)
291	{	292	{
292	if(NeutralAccZ < 750)	293	if(NeutralAccZ < 750)
293	{	294	{
294	NeutralAccZ += 0.02;	295	NeutralAccZ += 0.02;
295	if(modell_fliegt < 500) NeutralAccZ += 0.1;	296	if(modell_fliegt < 500) NeutralAccZ += 0.1;
296	}	297	}
297	}	298	}
298	else if(AdWertAccHoch < -1)	299	else if(AdWertAccHoch < -1)
299	{	300	{
300	if(NeutralAccZ > 550)	301	if(NeutralAccZ > 550)
301	{	302	{
302	NeutralAccZ-= 0.02;	303	NeutralAccZ-= 0.02;
303	if(modell_fliegt < 500) NeutralAccZ -= 0.1;	304	if(modell_fliegt < 500) NeutralAccZ -= 0.1;
304	}	305	}
305	}	306	}
306	messanzahl_AccHoch = 1;	307	messanzahl_AccHoch = 1;
307	Aktuell_az = ADC;	308	Aktuell_az = ADC;
308	Mess_Integral_Hoch += AdWertAccHoch; // Integrieren	309	Mess_Integral_Hoch += AdWertAccHoch; // Integrieren
309	Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen	310	Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
310	kanal = AD_NICK;	311	kanal = AD_NICK;
311	break;	312	break;
312	case 7:	313	case 7:
313	nick1 += ADC;	314	nick1 += ADC;
314	kanal = AD_ROLL;	315	kanal = AD_ROLL;
315	break;	316	break;
316	case 8:	317	case 8:
317	roll1 += ADC;	318	roll1 += ADC;
318	kanal = AD_ACC_X;	319	kanal = AD_ACC_X;
319	break;	320	break;
320	case 9:	321	case 9:
321	Aktuell_ax = ADC - NeutralAccX;	322	Aktuell_ax = ADC - NeutralAccX;
322	accx = Aktuell_ax;	323	accx = Aktuell_ax;
323	kanal = AD_GIER;	324	kanal = AD_GIER;
324	break;	325	break;
325	case 10:	326	case 10:
326	gier1 += ADC;	327	gier1 += ADC;
327	kanal = AD_NICK;	328	kanal = AD_NICK;
328	break;	329	break;
329	case 11:	330	case 11:
330	nick1 += ADC;	331	nick1 += ADC;
331	kanal = AD_ROLL;	332	kanal = AD_ROLL;
332	break;	333	break;
333	case 12:	334	case 12:
334	roll1 += ADC;	335	roll1 += ADC;
335	kanal = AD_UBAT;	336	kanal = AD_UBAT;
336	break;	337	break;
337	case 13:	338	case 13:
338	UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2;	339	UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2;
339	kanal = AD_ACC_Y;	340	kanal = AD_ACC_Y;
340	break;	341	break;
341	case 14:	342	case 14:
342	Aktuell_ay = NeutralAccY - ADC;	343	Aktuell_ay = NeutralAccY - ADC;
343	accy += Aktuell_ay;	344	accy += Aktuell_ay;
344	kanal = AD_NICK;	345	kanal = AD_NICK;
345	break;	346	break;
346	case 15:	347	case 15:
347	nick1 += ADC;	348	nick1 += ADC;
348	kanal = AD_ROLL;	349	kanal = AD_ROLL;
349	break;	350	break;
350	case 16:	351	case 16:
351	roll1 += ADC;	352	roll1 += ADC;
352	kanal = AD_ACC_X;	353	kanal = AD_ACC_X;
353	break;	354	break;
354	case 17:	355	case 17:
355	Aktuell_ax = ADC - NeutralAccX;	356	Aktuell_ax = ADC - NeutralAccX;
356	accx += Aktuell_ax;	357	accx += Aktuell_ax;
357	kanal = AD_NICK;	358	kanal = AD_NICK;
358	break;	359	break;
359	case 18:	360	case 18:
360	nick1 += ADC;	361	nick1 += ADC;
361	kanal = AD_ROLL;	362	kanal = AD_ROLL;
362	break;	363	break;
363	case 19:	364	case 19:
364	roll1 += ADC;	365	roll1 += ADC;
365	kanal = AD_GIER;	366	kanal = AD_GIER;
366	break;	367	break;
367	case 20:	368	case 20:
368	gier1 += ADC;	369	gier1 += ADC;
369	kanal = AD_ACC_Y;	370	kanal = AD_ACC_Y;
370	break;	371	break;
371	case 21:	372	case 21:
372	Aktuell_ay = NeutralAccY - ADC;	373	Aktuell_ay = NeutralAccY - ADC;
373	accy += Aktuell_ay;	374	accy += Aktuell_ay;
374	kanal = AD_NICK;	375	kanal = AD_NICK;
375	break;	376	break;
376	case 22:	377	case 22:
377	nick1 += ADC;	378	nick1 += ADC;
378	kanal = AD_ROLL;	379	kanal = AD_ROLL;
379	break;	380	break;
380	case 23:	381	case 23:
381	roll1 += ADC;	382	roll1 += ADC;
382	kanal = AD_DRUCK;	383	kanal = AD_DRUCK;
383	break;	384	break;
384	case 24:	385	case 24:
385	tmpLuftdruck += ADC;	386	tmpLuftdruck += ADC;
386	if(++messanzahl_Druck >= 5)	387	if(++messanzahl_Druck >= 5)
387	{	388	{
388	MessLuftdruck = ADC;	389	MessLuftdruck = ADC;
389	messanzahl_Druck = 0;	390	messanzahl_Druck = 0;
390	HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert)) / 8; // D-Anteil = neuerWert - AlterWert	391	HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert)) / 8; // D-Anteil = neuerWert - AlterWert
391	Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;	392	Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;
392	HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck;	393	HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck;
393	tmpLuftdruck = 0;	394	tmpLuftdruck = 0;
394	}	395	}
395	kanal = AD_NICK;	396	kanal = AD_NICK;
396	break;	397	break;
397	case 25:	398	case 25:
398	nick1 += ADC;	399	nick1 += ADC;
399	kanal = AD_ROLL;	400	kanal = AD_ROLL;
400	break;	401	break;
401	case 26:	402	case 26:
402	roll1 += ADC;	403	roll1 += ADC;
403	kanal = AD_ACC_X;	404	kanal = AD_ACC_X;
404	break;	405	break;
405	case 27:	406	case 27:
406	Aktuell_ax = ADC - NeutralAccX;	407	Aktuell_ax = ADC - NeutralAccX;
407	accx += Aktuell_ax;	408	accx += Aktuell_ax;
408	kanal = AD_GIER;	409	kanal = AD_GIER;
409	break;	410	break;
410	case 28:	411	case 28:
411	if(PlatinenVersion == 10) AdWertGier = (ADC + gier1 + 2) / 4;	412	if(PlatinenVersion == 10) AdWertGier = (ADC + gier1 + 2) / 4;
412	else	413	else
413	if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1 + 1) / 2;	414	if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1 + 1) / 2;
414	else AdWertGier = (ADC + gier1 + 1) / 2;	415	else AdWertGier = (ADC + gier1 + 1) / 2;
415	kanal = AD_NICK;	416	kanal = AD_NICK;
416	break;	417	break;
417	case 29:	418	case 29:
418	nick1 += ADC;	419	nick1 += ADC;
419	kanal = AD_ROLL;	420	kanal = AD_ROLL;
420	break;	421	break;
421	case 30:	422	case 30:
422	roll1 += ADC;	423	roll1 += ADC;
423	kanal = AD_ACC_Y;	424	kanal = AD_ACC_Y;
424	break;	425	break;
425	case 31:	426	case 31:
426	Aktuell_ay = NeutralAccY - ADC;	427	Aktuell_ay = NeutralAccY - ADC;
427	AdWertAccRoll = (Aktuell_ay + accy);	428	AdWertAccRoll = (Aktuell_ay + accy);
428	kanal = AD_NICK;	429	kanal = AD_NICK;
429	break;	430	break;
430	case 32:	431	case 32:
431	AdWertNick = (ADC + nick1 + 3) / 5;	432	AdWertNick = (ADC + nick1 + 3) / 5;
432	nick_filter = (long) (1 * (long) nick_filter + 4 * (long)(ADC + nick1) + 1) / 2;	433	nick_filter = (long) (1 * (long) nick_filter + 4 * (long)(ADC + nick1) + 1) / 2;
433	if(PlatinenVersion == 10) { AdWertNick /= 2;nick_filter /=2;}	434	if(PlatinenVersion == 10) { AdWertNick /= 2;nick_filter /=2;}
434	HiResNick = nick_filter - 20 * AdNeutralNick;	435	HiResNick = nick_filter - 20 * AdNeutralNick;
435	AdWertNickFilter = (long)(3L * (long)AdWertNickFilter + HiResNick + 2) / 4;	436	AdWertNickFilter = (long)(3L * (long)AdWertNickFilter + HiResNick + 2) / 4;
436	DebugOut.Analog[21] = AdWertNickFilter / 4;	437	DebugOut.Analog[21] = AdWertNickFilter / 4;
437	kanal = AD_ROLL;	438	kanal = AD_ROLL;
438	break;	439	break;
439	case 33:	440	case 33:
440	AdWertRoll = (ADC + roll1 + 3) / 5;	441	AdWertRoll = (ADC + roll1 + 3) / 5;
441	roll_filter = (long)(1 * (long)roll_filter + 4 * (long)(ADC + roll1) + 1) / 2;	442	roll_filter = (long)(1 * (long)roll_filter + 4 * (long)(ADC + roll1) + 1) / 2;
442	if(PlatinenVersion == 10) { AdWertRoll /= 2;roll_filter /=2;}	443	if(PlatinenVersion == 10) { AdWertRoll /= 2;roll_filter /=2;}
443	HiResRoll = roll_filter - 20 * AdNeutralRoll;	444	HiResRoll = roll_filter - 20 * AdNeutralRoll;
444	AdWertRollFilter = (long)(3L * (long)AdWertRollFilter + HiResRoll + 2) / 4;	445	AdWertRollFilter = (long)(3L * (long)AdWertRollFilter + HiResRoll + 2) / 4;
445	DebugOut.Analog[22] = AdWertRollFilter / 4;	446	DebugOut.Analog[22] = AdWertRollFilter / 4;
446	kanal = AD_ACC_X;	447	kanal = AD_ACC_X;
447	break;	448	break;
448	case 34:	449	case 34:
449	Aktuell_ax = ADC - NeutralAccX;	450	Aktuell_ax = ADC - NeutralAccX;
450	AdWertAccNick = (Aktuell_ax + accx);	451	AdWertAccNick = (Aktuell_ax + accx);
451	kanal = AD_NICK;	452	kanal = AD_NICK;
452	state = 0;	453	state = 0;
453	AdReady = 1;	454	AdReady = 1;
454	ZaehlMessungen++;	455	ZaehlMessungen++;
455	break;	456	break;
456	default:	457	default:
457	kanal = 0;	458	kanal = 0;
458	state = 0;	459	state = 0;
459	break;	460	break;
460	}	461	}
461	ADMUX = kanal;	462	ADMUX = kanal;
462	if(state != 0) ANALOG_ON;	463	if(state != 0) ANALOG_ON;
463	}	464	}
464	*/	465	*/
465		466

Subversion Repositories FlightCtrl

(root)/branches/V0.84a-test1/analog.c @ 2030 - Rev 1320 → 1322