Subversion Repositories FlightCtrl

Rev

Rev 1126 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1126 Rev 1133
Line 49... Line 49...
49
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
49
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
50
// +  POSSIBILITY OF SUCH DAMAGE.
50
// +  POSSIBILITY OF SUCH DAMAGE.
51
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
51
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
52
#include "main.h"
52
#include "main.h"
Line 53... Line 53...
53
 
53
 
54
unsigned char EEPromArray[E2END + 1] EEMEM;
54
unsigned char EEPromArray[E2END+1] EEMEM;
55
unsigned char PlatinenVersion = 10;
55
unsigned char PlatinenVersion = 10;
56
unsigned char SendVersionToNavi = 1;
56
unsigned char SendVersionToNavi = 1;
57
// -- Parametersatz aus EEPROM lesen ---
57
// -- Parametersatz aus EEPROM lesen ---
58
// number [1..5]
-
 
59
 
58
// number [1..5]
-
 
59
void ReadParameterSet(unsigned char number, unsigned char *buffer, unsigned char length)
60
void ReadParameterSet(unsigned char number, unsigned char *buffer, unsigned char length) {
60
{
61
    if ((number > 5) || (number < 1)) number = 3;
61
   if((number > 5)||(number < 1)) number = 3;
62
    eeprom_read_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * (number - 1)], length);
62
   eeprom_read_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * (number - 1)], length);
63
    LED_Init();
63
   LED_Init();
Line 64... Line 64...
64
}
64
}
65
 
65
 
-
 
66
// -- Parametersatz ins EEPROM schreiben ---
-
 
67
// number [1..5]
-
 
68
void WriteParameterSet(unsigned char number, unsigned char *buffer, unsigned char length)
-
 
69
{
-
 
70
   if(number > 5) number = 5;
-
 
71
   if(number < 1) return;
-
 
72
   eeprom_write_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * (number - 1)], length);
-
 
73
   SetActiveParamSetNumber(number);
Line 66... Line -...
66
// -- Parametersatz ins EEPROM schreiben ---
-
 
67
// number [1..5]
74
   LED_Init();
-
 
75
}
68
 
76
 
69
void WriteParameterSet(unsigned char number, unsigned char *buffer, unsigned char length) {
77
unsigned char GetActiveParamSetNumber(void)
-
 
78
{
-
 
79
        unsigned char set;
-
 
80
        set = eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET]);
70
    if (number > 5) number = 5;
81
        if((set > 5) || (set < 1))
-
 
82
        {
71
    if (number < 1) return;
83
                set = 3;
72
    eeprom_write_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * (number - 1)], length);
84
                SetActiveParamSetNumber(set);                           // diesen Parametersatz als aktuell merken
Line -... Line 85...
-
 
85
        }
73
    SetActiveParamSetNumber(number);
86
        return(set);
74
    LED_Init();
-
 
75
}
-
 
-
 
87
}
76
 
88
 
77
unsigned char GetActiveParamSetNumber(void) {
89
 
78
    unsigned char set;
90
void SetActiveParamSetNumber(unsigned char number)
79
    set = eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET]);
-
 
80
    if ((set > 5) || (set < 1)) {
-
 
81
        set = 3;
91
{
Line 82... Line -...
82
        SetActiveParamSetNumber(set); // diesen Parametersatz als aktuell merken
-
 
83
    }
-
 
84
    return (set);
-
 
85
}
-
 
86
 
-
 
87
void SetActiveParamSetNumber(unsigned char number) {
92
        if(number > 5) number = 5;
88
    if (number > 5) number = 5;
93
        if(number < 1) return;
-
 
94
        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], number);                                 // diesen Parametersatz als aktuell merken
89
    if (number < 1) return;
95
}
90
    eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], number); // diesen Parametersatz als aktuell merken
96
 
91
}
97
 
92
 
98
void CalMk3Mag(void)
-
 
99
{
93
void CalMk3Mag(void) {
100
 static unsigned char stick = 1;
94
    static unsigned char stick = 1;
101
 
95
 
102
 if(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -20) stick = 0;
-
 
103
 if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -70) && !stick)
96
    if (PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -20) stick = 0;
104
  {
97
    if ((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -70) && !stick) {
105
   stick = 1;
98
        stick = 1;
-
 
99
        WinkelOut.CalcState++;
106
   WinkelOut.CalcState++;
-
 
107
   if(WinkelOut.CalcState > 4)
-
 
108
    {
100
        if (WinkelOut.CalcState > 4) {
109
//     WinkelOut.CalcState = 0; // in Uart.c
101
            //     WinkelOut.CalcState = 0; // in Uart.c
110
     beeptime = 1000;
Line 102... Line 111...
102
            beeptime = 1000;
111
    }
103
        } else Piep(WinkelOut.CalcState);
112
   else Piep(WinkelOut.CalcState);
104
    }
-
 
105
    DebugOut.Analog[19] = WinkelOut.CalcState;
113
  }
106
}
114
  DebugOut.Analog[19] = WinkelOut.CalcState;
107
 
115
}
108
//############################################################################
116
 
Line 109... Line 117...
109
//Hauptprogramm
117
//############################################################################
110
 
118
//Hauptprogramm
111
int main(void)
119
int main (void)
112
//############################################################################
120
//############################################################################
113
{
121
{
-
 
122
        unsigned int timer;
114
    unsigned int timer;
123
 
115
 
124
        //unsigned int timer2 = 0;
-
 
125
    DDRB  = 0x00;
116
    //unsigned int timer2 = 0;
126
    PORTB = 0x00;
-
 
127
    for(timer = 0; timer < 1000; timer++); // verzögern
117
    DDRB = 0x00;
128
    if(PINB & 0x01)
118
    PORTB = 0x00;
129
     {
119
    for (timer = 0; timer < 1000; timer++); // verzögern
130
      if(PINB & 0x02) PlatinenVersion = 13;
Line 120... Line 131...
120
    if (PINB & 0x01) {
131
       else           PlatinenVersion = 11;
121
        if (PINB & 0x02) PlatinenVersion = 13;
132
     }
122
        else PlatinenVersion = 11;
133
    else
123
    } else {
134
     {
124
        if (PINB & 0x02) PlatinenVersion = 20;
135
      if(PINB & 0x02) PlatinenVersion = 20;
125
        else PlatinenVersion = 10;
136
       else           PlatinenVersion = 10;
126
    }
137
     }
127
 
138
 
Line 128... Line 139...
128
    DDRC = 0x81; // SCL
139
    DDRC  = 0x81; // SCL
129
    DDRC |= 0x40; // HEF4017 Reset
140
    DDRC  |=0x40; // HEF4017 Reset
130
    PORTC = 0xff; // Pullup SDA
141
    PORTC = 0xff; // Pullup SDA
Line 131... Line 142...
131
    DDRB = 0x1B; // LEDs und Druckoffset
142
    DDRB  = 0x1B; // LEDs und Druckoffset
Line 132... Line -...
132
    PORTB = 0x01; // LED_Rot
-
 
133
    DDRD = 0x3E; // Speaker & TXD & J3 J4 J5
143
    PORTB = 0x01; // LED_Rot
134
    DDRD |= 0x80; // J7 -> Servo signal
-
 
135
    PORTD = 0x77; // LED
-
 
Line 136... Line 144...
136
 
144
    DDRD  = 0x3E; // Speaker & TXD & J3 J4 J5
Line 137... Line 145...
137
 
145
    DDRD  |=0x80; // J7 -> Servo signal
138
    MCUSR &= ~(1 << WDRF);
146
        PORTD = 0x77; // LED
139
    WDTCSR |= (1 << WDCE) | (1 << WDE);
147
 
140
    WDTCSR = 0;
148
 
141
 
149
    MCUSR &=~(1<<WDRF);
142
    beeptime = 2000;
150
    WDTCSR |= (1<<WDCE)|(1<<WDE);
Line 143... Line 151...
143
 
151
    WDTCSR = 0;
Line 144... Line 152...
144
    StickGier = 0;
152
 
145
    PPM_in[K_GAS] = 0;
153
    beeptime = 2000;
Line 146... Line 154...
146
    StickRoll = 0;
154
 
Line 147... Line 155...
147
    StickNick = 0;
155
        StickGier = 0; PPM_in[K_GAS] = 0;StickRoll = 0; StickNick = 0;
148
 
156
 
149
    ROT_OFF;
157
    ROT_OFF;
150
 
158
 
-
 
159
    Timer_Init();
151
    Timer_Init();
160
        UART_Init();
152
    UART_Init();
161
    rc_sum_init();
-
 
162
        ADC_Init();
153
    rc_sum_init();
163
        i2c_init();
Line 154... Line 164...
154
    ADC_Init();
164
        SPI_MasterInit();
-
 
165
 
155
    i2c_init();
166
        sei();
156
    SPI_MasterInit();
167
 
-
 
168
        printf("\n\rFlightControl\n\rHardware:%d.%d\n\rSoftware:V%d.%d%c ",PlatinenVersion/10,PlatinenVersion%10, VERSION_MAJOR, VERSION_MINOR,VERSION_PATCH + 'a');
157
 
169
        printf("\n\r==============================");
158
    sei();
170
 
159
 
171
        GRN_ON;
160
    printf("\n\rFlightControl\n\rHardware:%d.%d\n\rSoftware:V%d.%d%c ", PlatinenVersion / 10, PlatinenVersion % 10, VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH + 'a');
172
 
161
    printf("\n\r==============================");
173
 
162
 
174
        ReadParameterSet(3, (unsigned char *) &EE_Parameter.Kanalbelegung[0], 9); // read only the first bytes
163
    GRN_ON;
175
    // valid Stick-Settings?
164
 
176
    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) == 255 || eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) < EE_DATENREVISION ||
165
 
177
        EE_Parameter.Kanalbelegung[0] > 9 || EE_Parameter.Kanalbelegung[1] > 9 || EE_Parameter.Kanalbelegung[2] > 9 || EE_Parameter.Kanalbelegung[3] > 9)
166
    ReadParameterSet(3, (unsigned char *) & EE_Parameter.Kanalbelegung[0], 9); // read only the first bytes
178
           {
-
 
179
            printf("\n\rInit. EEPROM: Generating Default-Parameter and Stick-Settings...");
167
    // valid Stick-Settings?
180
        DefaultStickMapping();
168
    if (eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) == 255 || eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) < EE_DATENREVISION ||
181
       }
Line 169... Line 182...
169
            EE_Parameter.Kanalbelegung[0] > 9 || EE_Parameter.Kanalbelegung[1] > 9 || EE_Parameter.Kanalbelegung[2] > 9 || EE_Parameter.Kanalbelegung[3] > 9) {
182
    else if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != EE_DATENREVISION) printf("\n\rInit. EEPROM: Generating Default-Parameter using old Stick Settings");
170
        printf("\n\rInit. EEPROM: Generating Default-Parameter and Stick-Settings...");
183
 
Line 171... Line 184...
171
        DefaultStickMapping();
184
    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != EE_DATENREVISION)
-
 
185
        {
172
    } else if (eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != EE_DATENREVISION) printf("\n\rInit. EEPROM: Generating Default-Parameter using old Stick Settings");
186
          DefaultKonstanten1();
173
 
187
          for (unsigned char i=1;i<6;i++)
174
    if (eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != EE_DATENREVISION) {
188
      {
175
        DefaultKonstanten1();
189
       if(i==2) DefaultKonstanten2(); // Kamera
176
        for (unsigned char i = 1; i < 6; i++) {
190
       if(i==3) DefaultKonstanten3(); // Beginner
177
            if (i == 2) DefaultKonstanten2(); // Kamera
191
       if(i>3)  DefaultKonstanten2(); // Kamera
Line 178... Line 192...
178
            if (i == 3) DefaultKonstanten3(); // Beginner
192
       WriteParameterSet(i, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
Line 179... Line 193...
179
            if (i > 3) DefaultKonstanten2(); // Kamera
193
      }
Line 180... Line 194...
180
            WriteParameterSet(i, (unsigned char *) & EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
194
          SetActiveParamSetNumber(3); // default-Setting
181
        }
195
          eeprom_write_byte(&EEPromArray[EEPROM_ADR_VALID], EE_DATENREVISION);
Line 182... Line 196...
182
        SetActiveParamSetNumber(3); // default-Setting
196
        }
183
        eeprom_write_byte(&EEPromArray[EEPROM_ADR_VALID], EE_DATENREVISION);
197
 
184
    }
198
    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4)
Line 185... Line 199...
185
 
199
     {
Line 186... Line 200...
186
    if (eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4) {
200
       printf("\n\rACC nicht abgeglichen!");
187
        printf("\n\rACC nicht abgeglichen!");
201
     }
188
    }
202
 
189
 
203
        ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
-
 
204
    printf("\n\rBenutze Parametersatz %d", GetActiveParamSetNumber());
Line 190... Line 205...
190
    ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) & EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
205
 
191
    printf("\n\rBenutze Parametersatz %d", GetActiveParamSetNumber());
206
 
192
 
207
        if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)
193
 
208
         {
194
    if (EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) {
209
           printf("\n\rAbgleich Luftdrucksensor..");
195
        printf("\n\rAbgleich Luftdrucksensor..");
210
           timer = SetDelay(1000);
196
        timer = SetDelay(1000);
211
       SucheLuftruckOffset();
197
        SucheLuftruckOffset();
212
           while (!CheckDelay(timer));
198
        while (!CheckDelay(timer));
213
       printf("OK\n\r");
199
        printf("OK\n\r");
214
        }
200
    }
215
 
-
 
216
        SetNeutral();
201
 
217
 
202
    SetNeutral();
218
        ROT_OFF;
203
 
219
 
204
    ROT_OFF;
220
    beeptime = 2000;
205
 
221
    ExternControl.Digital[0] = 0x55;
206
    beeptime = 2000;
222
 
207
    ExternControl.Digital[0] = 0x55;
223
 
-
 
224
        printf("\n\rSteuerung: ");
208
 
225
        if (EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) printf("HeadingHold");
209
 
226
        else printf("Neutral");
210
    printf("\n\rSteuerung: ");
227
 
-
 
228
        printf("\n\n\r");
211
    if (EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) printf("HeadingHold");
229
 
212
    else printf("Neutral");
230
    LcdClear();
-
 
231
    I2CTimeout = 5000;
213
 
232
    WinkelOut.Orientation = 1;
214
    printf("\n\n\r");
233
        while (1)
-
 
234
        {
215
 
235
 
216
    LcdClear();
236
                if(UpdateMotor)      // ReglerIntervall
217
    I2CTimeout = 5000;
237
            {
218
    WinkelOut.Orientation = 1;
238
                    UpdateMotor=0;
-
 
239
//PORTD |= 0x08;
219
    while (1) {
240
            if(WinkelOut.CalcState) CalMk3Mag();
220
 
241
            else MotorRegler();
-
 
242
//PORTD &= ~0x08;
221
        if (UpdateMotor) // ReglerIntervall
243
            SendMotorData();
222
        {
244
            ROT_OFF;
-
 
245
            if(PcZugriff) PcZugriff--;
223
            UpdateMotor = 0;
246
             else
-
 
247
              {
224
            //PORTD |= 0x08;
248
                           ExternControl.Config = 0;
-
 
249
               ExternStickNick = 0;
225
            if (WinkelOut.CalcState) CalMk3Mag();
250
               ExternStickRoll = 0;
226
            else MotorRegler();
251
               ExternStickGier = 0;
227
            //PORTD &= ~0x08;
252
              }
228
            SendMotorData();
253
            if(SenderOkay)  SenderOkay--;
229
            ROT_OFF;
254
            if(!I2CTimeout)
230
            if (PcZugriff) PcZugriff--;
255
                {
231
            else {
256
                 I2CTimeout = 5;
232
                ExternControl.Config = 0;
257
                 i2c_reset();
233
                ExternStickNick = 0;
258
                  if((BeepMuster == 0xffff) && MotorenEin)
234
                ExternStickRoll = 0;
259
                   {
235
                ExternStickGier = 0;
260
                    beeptime = 10000;
236
            }
261
                    BeepMuster = 0x0080;
Line 237... Line 262...
237
            if (SenderOkay) SenderOkay--;
262
                   }
238
            if (!I2CTimeout) {
263
                }
239
                I2CTimeout = 5;
264
            else
240
                i2c_reset();
265
                {
241
                if ((BeepMuster == 0xffff) && MotorenEin) {
266
                 I2CTimeout--;
242
                    beeptime = 10000;
267
                 ROT_OFF;
243
                    BeepMuster = 0x0080;
-
 
244
                }
268
                }
245
            } else {
-
 
246
                I2CTimeout--;
269
            if(SIO_DEBUG && (!UpdateMotor || !MotorenEin))
247
                ROT_OFF;
270
              {
248
            }
271
               DatenUebertragung();