WebSVN - FlightCtrl - Diff - Rev 128 and 173 - /branches/V0.64


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + 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  AccumulateNick = 0, AccumulateRoll = 0, AccumulateGier = 0;
volatile int  accumulate_AccRoll = 0,accumulate_AccNick = 0,accumulate_AccHoch = 0;
volatile char MessanzahlNick = 0, MessanzahlRoll = 0, MessanzahlGier = 0;
volatile char messanzahl_AccNick = 0, messanzahl_AccRoll = 0, messanzahl_AccHoch = 0;
volatile long Luftdruck = 32000;
volatile int  StartLuftdruck;
volatile unsigned int  MessLuftdruck = 1023;
unsigned char DruckOffsetSetting;
volatile int HoeheD = 0;
volatile char messanzahl_Druck;
volatile int  tmpLuftdruck;
volatile unsigned int ZaehlMessungen = 0;
 
//#######################################################################################
//
void ADC_Init(void)
//#######################################################################################
{
    ADMUX = 0;//Referenz ist extern
    ADCSRA=(1<<ADEN)|(1<<ADSC)|(1<<ADATE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)|(1<<ADIE);
    //Free Running Mode, Division Factor 128, Interrupt on
}
 
void SucheLuftruckOffset(void)
{
 unsigned int off;
 off = eeprom_read_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET]);
 if(off > 20) off -= 10;
 OCR0A = off;
 Delay_ms(100);
 if(MessLuftdruck < 850) off = 0;
 for(; off < 250;off++)
  {
  OCR0A = off;
  Delay_ms(50);
  printf(".");  
  if(MessLuftdruck < 900) break;
  }
 eeprom_write_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET], off);
 DruckOffsetSetting = off;
 Delay_ms(300);
}
 
 
//#######################################################################################
//
SIGNAL(SIG_ADC)
//#######################################################################################
{
    static unsigned char kanal=0,state = 0;
    signed int wert;   
    ANALOG_OFF;
    switch(state++)
        {
        case 0:
            wert = (signed int) AdNeutralGier - ADC;
            if(PlatinenVersion != 10) wert *= 2;
            AccumulateGier += wert;     //
            MessanzahlGier++;
            Mess_Integral_Gier += wert;// / 16;
            Mess_Integral_Gier2 += wert;
            kanal = 1;
            ZaehlMessungen++;
            break;
        case 1:
            wert = (signed int) ADC - AdNeutralRoll;
            if(PlatinenVersion != 10) wert *= 2;
            Mess_IntegralRoll += wert;
            Mess_IntegralRoll2 += wert;
            if(Mess_IntegralRoll > 310000L) Mess_IntegralRoll = -290000L;
            if(Mess_IntegralRoll <-310000L) Mess_IntegralRoll = 290000L;
            if(ADC < 15)   wert = -1000;
            if(ADC <  7)   wert = -2000;
            if(ADC > 1010) wert = +1000;
            if(ADC > 1017) wert = +2000;
            AccumulateRoll += wert;
            MessanzahlRoll++;
            kanal = 2;
            break;
        case 2:
            wert = (signed int) ADC - AdNeutralNick;
            if(PlatinenVersion != 10) wert *= 2;
            Mess_IntegralNick += wert;
            Mess_IntegralNick2 += wert;
            if(Mess_IntegralNick > 310000L) Mess_IntegralNick = -290000L;
            if(Mess_IntegralNick <-310000L) Mess_IntegralNick = 290000L;
            if(ADC < 15)   wert = -1000;
            if(ADC <  7)   wert = -2000;
            if(ADC > 1010) wert = +1000;
            if(ADC > 1017) wert = +2000;
            AccumulateNick += wert;
            MessanzahlNick++;
            kanal = 4;
            break;
        case 3:
            UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19)  / 2;
            kanal = 6;
            break;
        case 4:
            Aktuell_ay = NeutralAccY - ADC;
            accumulate_AccRoll += Aktuell_ay;
            messanzahl_AccRoll++;
            kanal = 7;
            break;
        case 5:
            Aktuell_ax = ADC - NeutralAccX;
            accumulate_AccNick +=  Aktuell_ax;
            messanzahl_AccNick++;
                    kanal = 5;
                    state = 6;
            break;
        case 6:
            accumulate_AccHoch =  (signed int) ADC - NeutralAccZ;
            accumulate_AccHoch += abs(Aktuell_ay) / 4 + abs(Aktuell_ax) / 4;
            if(accumulate_AccHoch > 1)
             {
              if(NeutralAccZ < 800) NeutralAccZ+= 0.02;
             }  
             else if(accumulate_AccHoch < -1)
             {
              if(NeutralAccZ > 600) NeutralAccZ-= 0.02;
             }
            messanzahl_AccHoch = 1;
            Aktuell_az = ADC;
            Mess_Integral_Hoch += accumulate_AccHoch;      // Integrieren
            Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
//            Mess_Integral_Hoch -= Mess_Integral_Hoch / 512; // dämfen
 /*           if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)
             {
                      kanal = 3;
                      state = 7;
             }
            else  
             {
                      kanal = 0;
                      state = 0;
             }*/
                      kanal = 3;
                      state = 7;
            break;
        case 7:
            tmpLuftdruck += ADC;
            if(++messanzahl_Druck >= 5)
                {
                MessLuftdruck = ADC;
                messanzahl_Druck = 0;
                                HoeheD = (int)(StartLuftdruck - tmpLuftdruck - HoehenWert);  // D-Anteil = neuerWert - AlterWert
                Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;
                HoehenWert = StartLuftdruck - Luftdruck;
                tmpLuftdruck = 0;
                }
            kanal = 0;
            state = 0;
            break;
        default:
            kanal = 0;
            state = 0;
            break;
        }
    ADMUX = kanal;
    ANALOG_ON;
}
 

Rev 128	Rev 173
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		9
10	volatile int Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_ax, Aktuell_ay,Aktuell_az, UBat = 100;	10	volatile int Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_ax, Aktuell_ay,Aktuell_az, UBat = 100;
11	volatile int AccumulateNick = 0, AccumulateRoll = 0, AccumulateGier = 0;	11	volatile int AccumulateNick = 0, AccumulateRoll = 0, AccumulateGier = 0;
12	volatile int accumulate_AccRoll = 0,accumulate_AccNick = 0,accumulate_AccHoch = 0;	12	volatile int accumulate_AccRoll = 0,accumulate_AccNick = 0,accumulate_AccHoch = 0;
13	volatile char MessanzahlNick = 0, MessanzahlRoll = 0, MessanzahlGier = 0;	13	volatile char MessanzahlNick = 0, MessanzahlRoll = 0, MessanzahlGier = 0;
14	volatile char messanzahl_AccNick = 0, messanzahl_AccRoll = 0, messanzahl_AccHoch = 0;	14	volatile char messanzahl_AccNick = 0, messanzahl_AccRoll = 0, messanzahl_AccHoch = 0;
15	volatile long Luftdruck = 32000;	15	volatile long Luftdruck = 32000;
16	volatile int StartLuftdruck;	16	volatile int StartLuftdruck;
17	volatile unsigned int MessLuftdruck = 1023;	17	volatile unsigned int MessLuftdruck = 1023;
18	unsigned char DruckOffsetSetting;	18	unsigned char DruckOffsetSetting;
19	volatile int HoeheD = 0;	19	volatile int HoeheD = 0;
20	volatile char messanzahl_Druck;	20	volatile char messanzahl_Druck;
21	volatile int tmpLuftdruck;	21	volatile int tmpLuftdruck;
22	volatile unsigned int ZaehlMessungen = 0;	22	volatile unsigned int ZaehlMessungen = 0;
23		23
24	//#######################################################################################	24	//#######################################################################################
25	//	25	//
26	void ADC_Init(void)	26	void ADC_Init(void)
27	//#######################################################################################	27	//#######################################################################################
28	{	28	{
29	ADMUX = 0;//Referenz ist extern	29	ADMUX = 0;//Referenz ist extern
30	ADCSRA=(1<<ADEN)\|(1<<ADSC)\|(1<<ADATE)\|(1<<ADPS2)\|(1<<ADPS1)\|(1<<ADPS0)\|(1<<ADIE);	30	ADCSRA=(1<<ADEN)\|(1<<ADSC)\|(1<<ADATE)\|(1<<ADPS2)\|(1<<ADPS1)\|(1<<ADPS0)\|(1<<ADIE);
31	//Free Running Mode, Division Factor 128, Interrupt on	31	//Free Running Mode, Division Factor 128, Interrupt on
32	}	32	}
33		33
34	void SucheLuftruckOffset(void)	34	void SucheLuftruckOffset(void)
35	{	35	{
36	unsigned int off;	36	unsigned int off;
-		37	off = eeprom_read_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET]);
-		38	if(off > 20) off -= 10;
-		39	OCR0A = off;
-		40	Delay_ms(100);
-		41	if(MessLuftdruck < 850) off = 0;
37	for(off=0; off < 250;off++)	42	for(; off < 250;off++)
38	{	43	{
39	OCR0A = off;	44	OCR0A = off;
40	Delay_ms(50);	45	Delay_ms(50);
41	printf(".");	46	printf(".");
42	if(MessLuftdruck < 900) break;	47	if(MessLuftdruck < 900) break;
43	}	48	}
-		49	eeprom_write_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET], off);
44	DruckOffsetSetting = off;	50	DruckOffsetSetting = off;
45	Delay_ms(200);	51	Delay_ms(300);
46	}	52	}
47		53
48		54
49	//#######################################################################################	55	//#######################################################################################
50	//	56	//
51	SIGNAL(SIG_ADC)	57	SIGNAL(SIG_ADC)
52	//#######################################################################################	58	//#######################################################################################
53	{	59	{
54	static unsigned char kanal=0,state = 0;	60	static unsigned char kanal=0,state = 0;
55	signed int wert;	61	signed int wert;
56	ANALOG_OFF;	62	ANALOG_OFF;
57	switch(state++)	63	switch(state++)
58	{	64	{
59	case 0:	65	case 0:
60	wert = (signed int) AdNeutralGier - ADC;	66	wert = (signed int) AdNeutralGier - ADC;
-		67	if(PlatinenVersion != 10) wert *= 2;
61	AccumulateGier += wert; //	68	AccumulateGier += wert; //
62	MessanzahlGier++;	69	MessanzahlGier++;
63	Mess_Integral_Gier += wert;// / 16;	70	Mess_Integral_Gier += wert;// / 16;
64	Mess_Integral_Gier2 += wert;	71	Mess_Integral_Gier2 += wert;
65	kanal = 1;	72	kanal = 1;
66	ZaehlMessungen++;	73	ZaehlMessungen++;
67	break;	74	break;
68	case 1:	75	case 1:
69	wert = (signed int) ADC - AdNeutralRoll;	76	wert = (signed int) ADC - AdNeutralRoll;
-		77	if(PlatinenVersion != 10) wert *= 2;
70	Mess_IntegralRoll += wert;	78	Mess_IntegralRoll += wert;
71	Mess_IntegralRoll2 += wert;	79	Mess_IntegralRoll2 += wert;
-		80	if(Mess_IntegralRoll > 310000L) Mess_IntegralRoll = -290000L;
-		81	if(Mess_IntegralRoll <-310000L) Mess_IntegralRoll = 290000L;
72	if(ADC < 10) wert = -700;	82	if(ADC < 15) wert = -1000;
-		83	if(ADC < 7) wert = -2000;
73	if(ADC > 1000) wert = +700;	84	if(ADC > 1010) wert = +1000;
-		85	if(ADC > 1017) wert = +2000;
74	AccumulateRoll += wert;	86	AccumulateRoll += wert;
75	MessanzahlRoll++;	87	MessanzahlRoll++;
76	kanal = 2;	88	kanal = 2;
77	break;	89	break;
78	case 2:	90	case 2:
79	wert = (signed int) ADC - AdNeutralNick;	91	wert = (signed int) ADC - AdNeutralNick;
-		92	if(PlatinenVersion != 10) wert *= 2;
80	Mess_IntegralNick += wert;	93	Mess_IntegralNick += wert;
81	Mess_IntegralNick2 += wert;	94	Mess_IntegralNick2 += wert;
-		95	if(Mess_IntegralNick > 310000L) Mess_IntegralNick = -290000L;
-		96	if(Mess_IntegralNick <-310000L) Mess_IntegralNick = 290000L;
82	if(ADC < 10) wert = -700;	97	if(ADC < 15) wert = -1000;
-		98	if(ADC < 7) wert = -2000;
83	if(ADC > 1000) wert = +700;	99	if(ADC > 1010) wert = +1000;
-		100	if(ADC > 1017) wert = +2000;
84	AccumulateNick += wert;	101	AccumulateNick += wert;
85	MessanzahlNick++;	102	MessanzahlNick++;
86	kanal = 4;	103	kanal = 4;
87	break;	104	break;
88	case 3:	105	case 3:
89	UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2;	106	UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2;
90	kanal = 6;	107	kanal = 6;
91	break;	108	break;
92	case 4:	109	case 4:
93	Aktuell_ay = NeutralAccY - ADC;	110	Aktuell_ay = NeutralAccY - ADC;
94	accumulate_AccRoll += Aktuell_ay;	111	accumulate_AccRoll += Aktuell_ay;
95	messanzahl_AccRoll++;	112	messanzahl_AccRoll++;
96	kanal = 7;	113	kanal = 7;
97	break;	114	break;
98	case 5:	115	case 5:
99	Aktuell_ax = ADC - NeutralAccX;	116	Aktuell_ax = ADC - NeutralAccX;
100	accumulate_AccNick += Aktuell_ax;	117	accumulate_AccNick += Aktuell_ax;
101	messanzahl_AccNick++;	118	messanzahl_AccNick++;
102	kanal = 5;	119	kanal = 5;
103	state = 6;	120	state = 6;
104	break;	121	break;
105	case 6:	122	case 6:
106	accumulate_AccHoch = (signed int) ADC - NeutralAccZ;	123	accumulate_AccHoch = (signed int) ADC - NeutralAccZ;
107	accumulate_AccHoch += abs(Aktuell_ay) / 4 + abs(Aktuell_ax) / 4;	124	accumulate_AccHoch += abs(Aktuell_ay) / 4 + abs(Aktuell_ax) / 4;
108	if(accumulate_AccHoch > 1)	125	if(accumulate_AccHoch > 1)
109	{	126	{
110	if(NeutralAccZ < 800) NeutralAccZ+= 0.02;	127	if(NeutralAccZ < 800) NeutralAccZ+= 0.02;
111	}	128	}
112	else if(accumulate_AccHoch < -1)	129	else if(accumulate_AccHoch < -1)
113	{	130	{
114	if(NeutralAccZ > 600) NeutralAccZ-= 0.02;	131	if(NeutralAccZ > 600) NeutralAccZ-= 0.02;
115	}	132	}
116	messanzahl_AccHoch = 1;	133	messanzahl_AccHoch = 1;
117	Aktuell_az = ADC;	134	Aktuell_az = ADC;
118	Mess_Integral_Hoch += accumulate_AccHoch; // Integrieren	135	Mess_Integral_Hoch += accumulate_AccHoch; // Integrieren
119	Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen	136	Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
120	// Mess_Integral_Hoch -= Mess_Integral_Hoch / 512; // dämfen	137	// Mess_Integral_Hoch -= Mess_Integral_Hoch / 512; // dämfen
121	/* if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)	138	/* if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)
122	{	139	{
123	kanal = 3;	140	kanal = 3;
124	state = 7;	141	state = 7;
125	}	142	}
126	else	143	else
127	{	144	{
128	kanal = 0;	145	kanal = 0;
129	state = 0;	146	state = 0;
130	}*/	147	}*/
131	kanal = 3;	148	kanal = 3;
132	state = 7;	149	state = 7;
133	break;	150	break;
134	case 7:	151	case 7:
135	tmpLuftdruck += ADC;	152	tmpLuftdruck += ADC;
136	if(++messanzahl_Druck >= 5)	153	if(++messanzahl_Druck >= 5)
137	{	154	{
138	MessLuftdruck = ADC;	155	MessLuftdruck = ADC;
139	messanzahl_Druck = 0;	156	messanzahl_Druck = 0;
140	HoeheD = (int)(StartLuftdruck - tmpLuftdruck - HoehenWert); // D-Anteil = neuerWert - AlterWert	157	HoeheD = (int)(StartLuftdruck - tmpLuftdruck - HoehenWert); // D-Anteil = neuerWert - AlterWert
141	Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;	158	Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;
142	HoehenWert = StartLuftdruck - Luftdruck;	159	HoehenWert = StartLuftdruck - Luftdruck;
143	tmpLuftdruck = 0;	160	tmpLuftdruck = 0;
144	}	161	}
145	kanal = 0;	162	kanal = 0;
146	state = 0;	163	state = 0;
147	break;	164	break;
148	default:	165	default:
149	kanal = 0;	166	kanal = 0;
150	state = 0;	167	state = 0;
151	break;	168	break;
152	}	169	}
153	ADMUX = kanal;	170	ADMUX = kanal;
154	ANALOG_ON;	171	ANALOG_ON;
155	}	172	}
156		173

Subversion Repositories FlightCtrl

(root)/branches/V0.64_ZeroWarnings/analog.c @ 1272 - Rev 128 → 173