Subversion Repositories FlightCtrl

Rev

Rev 1210 | Rev 1226 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1210 Rev 1211
Line 6... Line 6...
6
volatile unsigned char twi_state = 0;
6
volatile unsigned char twi_state = 0;
7
unsigned char motor = 0;
7
unsigned char motor = 0;
8
unsigned char motorread = 0,MissingMotor = 0;
8
unsigned char motorread = 0,MissingMotor = 0;
9
unsigned char motor_rx[16],motor_rx2[16];
9
unsigned char motor_rx[16],motor_rx2[16];
10
unsigned char MotorPresent[MAX_MOTORS];
10
unsigned char MotorPresent[MAX_MOTORS];
-
 
11
unsigned char MotorError[MAX_MOTORS];
Line 11... Line 12...
11
 
12
 
12
//############################################################################
13
//############################################################################
13
//Initzialisieren der I2C (TWI) Schnittstelle
14
//Initzialisieren der I2C (TWI) Schnittstelle
14
void i2c_init(void)
15
void i2c_init(void)
Line 93... Line 94...
93
 
94
 
94
//############################################################################
95
//############################################################################
95
SIGNAL (TWI_vect)
96
SIGNAL (TWI_vect)
96
//############################################################################
97
//############################################################################
97
{
98
{
98
 static unsigned char missing_motor,cnt_motor;
99
 static unsigned char missing_motor;
99
     switch(twi_state++)
100
     switch(twi_state++)
100
        {
101
        {
101
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
102
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
102
// Writing the Data
103
// Writing the Data
Line 113... Line 114...
113
                break;
114
                break;
114
        case 1:
115
        case 1:
115
                i2c_write_byte(Motor[motor++]);
116
                i2c_write_byte(Motor[motor++]);
116
                break;
117
                break;
117
        case 2:
118
        case 2:
118
                if(TWSR == 0x30) { if(!missing_motor) missing_motor = motor; }
119
                if(TWSR == 0x30) { if(!missing_motor) missing_motor = motor; if(++MotorError[motor-1] == 0) MotorError[motor-1] = 255;}
119
                i2c_stop();
120
                i2c_stop();
120
                I2CTimeout = 10;
121
                I2CTimeout = 10;
121
                twi_state = 0;
122
                twi_state = 0;
122
                i2c_start();  
123
                i2c_start();  
123
                break;
124
                break;
124
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
125
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
125
// Reading Data
126
// Reading Data
126
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
127
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
127
        case 3:
128
        case 3:
128
                //Transmit 1st byte for reading
129
               //Transmit 1st byte for reading
129
 
-
 
130
                if(TWSR != 0x40)  // Error?
130
                if(TWSR != 0x40)  // Error?
131
                                 {
131
                 {
132
                                  MotorPresent[motorread] = 0;
132
                  MotorPresent[motorread] = 0;
133
                                  motorread++;
133
                  motorread++;
134
                                  if(motorread >= MAX_MOTORS) motorread = 0;
134
                  if(motorread >= MAX_MOTORS) motorread = 0;
135
                                  i2c_stop();
135
                  i2c_stop();
136
                  twi_state = 0;
136
                  twi_state = 0;
137
                 }
137
                 }
138
                                 else
138
                 else
139
                                 {
139
                 {
140
                  MotorPresent[motorread] = ('1' - '-') + motorread;
140
                  MotorPresent[motorread] = ('1' - '-') + motorread;
-
 
141
                  I2C_ReceiveByte();
141
                                 }
142
                 }
142
                MissingMotor = missing_motor;
143
                MissingMotor = missing_motor;
143
                I2C_ReceiveByte();
144
                missing_motor = 0;
144
                break;
145
                break;
145
        case 4: //Read 1st byte and transmit 2nd Byte
146
        case 4: //Read 1st byte and transmit 2nd Byte
146
                motor_rx[motorread] = TWDR;
147
                motor_rx[motorread] = TWDR;
147
                I2C_ReceiveLastByte(); //nack
148
                I2C_ReceiveLastByte(); //nack
148
                break;
149
                break;
149
        case 5:
150
        case 5:
150
                //Read 2nd byte
151
                //Read 2nd byte
151
                motor_rx2[motorread++] = TWDR;
152
                motor_rx2[motorread++] = TWDR;
-
 
153
                if(motorread >= MAX_MOTORS) motorread = 0;
152
                i2c_stop();
154
                i2c_stop();
153
                twi_state = 0;
155
                twi_state = 0;
154
                                missing_motor = 0;
-
 
155
                break;
156
                break;
-
 
157
                       
156
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
158
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
157
// writing Gyro-Offset
159
// writing Gyro-Offset
158
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
160
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
159
        case 8:
161
        case 8:
160
                i2c_write_byte(0x98); // Address of the DAC
162
                i2c_write_byte(0x98); // Address of the DAC
Line 210... Line 212...
210
        default: twi_state = 0;
212
        default: twi_state = 0;
211
                break;        
213
                break;        
212
                }
214
                }
213
 TWCR |= 0x80;
215
 TWCR |= 0x80;
214
}
216
}
215
/*
-
 
216
//############################################################################
-
 
217
SIGNAL (TWI_vect)
-
 
218
//############################################################################
-
 
219
{
-
 
220
    switch (twi_state++)
-
 
221
        {
-
 
222
        case 0:
-
 
223
                i2c_write_byte(0x52+(motor*2));
-
 
224
                break;
-
 
225
        case 1:
-
 
226
                switch(motor++)
-
 
227
                    {
-
 
228
                    case 0:
-
 
229
                            i2c_write_byte(Motor_Vorne);
-
 
230
                            break;
-
 
231
                    case 1:      
-
 
232
                            i2c_write_byte(Motor_Hinten);
-
 
233
                            break;
-
 
234
                    case 2:
-
 
235
                            i2c_write_byte(Motor_Rechts);
-
 
236
                            break;
-
 
237
                    case 3:
-
 
238
                            i2c_write_byte(Motor_Links);
-
 
239
                            break;
-
 
240
                    }
-
 
241
                break;
-
 
242
        case 2:
-
 
243
                i2c_stop();
-
 
244
                if (motor<4) twi_state = 0;
-
 
245
                else motor = 0;
-
 
246
                i2c_start();  
-
 
247
                break;
-
 
248
                   
-
 
249
        //Liest Daten von Motor
-
 
250
        case 3:
-
 
251
                i2c_write_byte(0x53+(motorread*2));
-
 
252
                break;
-
 
253
        case 4:
-
 
254
                switch(motorread)
-
 
255
                    {
-
 
256
                    case 0:
-
 
257
                        i2c_write_byte(Motor_Vorne);
-
 
258
                        break;
-
 
259
                    case 1:
-
 
260
                        i2c_write_byte(Motor_Hinten);
-
 
261
                        break;
-
 
262
                    case 2:
-
 
263
                        i2c_write_byte(Motor_Rechts);
-
 
264
                        break;
-
 
265
                    case 3:
-
 
266
                        i2c_write_byte(Motor_Links);
-
 
267
                        break;
-
 
268
                    }
-
 
269
                break;
-
 
270
        case 5: //1 Byte vom Motor lesen      
-
 
271
                motor_rx[motorread] = TWDR;
-
 
272
 
-
 
273
        case 6:
-
 
274
                switch(motorread)
-
 
275
                    {
-
 
276
                    case 0:
-
 
277
                        i2c_write_byte(Motor_Vorne);
-
 
278
                        break;
-
 
279
                    case 1:
-
 
280
                        i2c_write_byte(Motor_Hinten);
-
 
281
                        break;
-
 
282
                    case 2:
-
 
283
                        i2c_write_byte(Motor_Rechts);
-
 
284
                        break;
-
 
285
                    case 3:
-
 
286
                        i2c_write_byte(Motor_Links);
-
 
287
                        break;
-
 
288
                    }
-
 
289
                break;  
-
 
290
        case 7: //2 Byte vom Motor lesen      
-
 
291
                motor_rx[motorread+4] = TWDR;
-
 
292
                motorread++;
-
 
293
                if (motorread>3) motorread=0;
-
 
294
                i2c_stop();
-
 
295
                I2CTimeout = 10;
-
 
296
                twi_state = 0;
-
 
297
                break;
-
 
298
        case 8: // Gyro-Offset
-
 
299
                i2c_write_byte(0x98); // Address of the DAC
-
 
300
                break;
-
 
301
        case 9:
-
 
302
                i2c_write_byte(0x10); // Update Channel A
-
 
303
                break;
-
 
304
        case 10:
-
 
305
                i2c_write_byte(AnalogOffsetNick); // Value
-
 
306
                break;
-
 
307
        case 11:
-
 
308
                i2c_write_byte(0x80); // Value
-
 
309
                break;
-
 
310
        case 12:
-
 
311
                i2c_stop();              
-
 
312
                I2CTimeout = 10;
-
 
313
                i2c_start();  
-
 
314
                break;
-
 
315
        case 13:
-
 
316
                i2c_write_byte(0x98); // Address of the DAC
-
 
317
                break;
-
 
318
        case 14:
-
 
319
                i2c_write_byte(0x12); // Update Channel B
-
 
320
                break;
-
 
321
        case 15:
-
 
322
                i2c_write_byte(AnalogOffsetRoll); // Value
-
 
323
                break;
-
 
324
        case 16:
-
 
325
                i2c_write_byte(0x80); // Value
-
 
326
                break;
-
 
327
        case 17:
-
 
328
                i2c_stop();              
-
 
329
                I2CTimeout = 10;
-
 
330
                i2c_start();  
-
 
331
                break;
-
 
332
        case 18:
-
 
333
                i2c_write_byte(0x98); // Address of the DAC
-
 
334
                break;
-
 
335
        case 19:
-
 
336
                i2c_write_byte(0x14); // Update Channel C
-
 
337
                break;
-
 
338
        case 20:
-
 
339
                i2c_write_byte(AnalogOffsetGier); // Value
-
 
340
                break;
-
 
341
        case 21:
-
 
342
                i2c_write_byte(0x80); // Value
-
 
343
                break;
-
 
344
        case 22:
-
 
345
                i2c_stop();              
-
 
346
                I2CTimeout = 10;
-
 
347
                twi_state = 0;
-
 
348
                break;
-
 
349
        }
-
 
350
 TWCR |= 0x80;
-
 
351
}
-
 
352
*/
-
 
353
217