Subversion Repositories FlightCtrl

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 ingob 1 
/*############################################################################
2 
############################################################################*/
3 
 
4 
#include "main.h"
5 
 
918 hbuss 6 
volatile unsigned char twi_state = 0;
1643 holgerb 7 
unsigned char motor = 0,TransmitBlConfig = 1;
1210 hbuss 8 
unsigned char motorread = 0,MissingMotor = 0;
1643 holgerb 9 
unsigned char ReadTemperature = 0;
1479 killagreg 10 
 
11 
MotorData_t Motor[MAX_MOTORS];
12 
 
1322 hbuss 13 
unsigned int I2CError = 0;
1 ingob 14 
 
15 
//############################################################################
16 
//Initzialisieren der I2C (TWI) Schnittstelle
17 
void i2c_init(void)
18 
//############################################################################
19 
{
20 
  TWSR = 0;
1479 killagreg 21 
  TWBR = ((SYSCLK/SCL_CLOCK)-16)/2;
1 ingob 22 
}
23 
 
173 holgerb 24 
void i2c_reset(void)
1 ingob 25 
//############################################################################
173 holgerb 26 
{
1639 holgerb 27 
                 I2C_Stop();
173 holgerb 28 
                 twi_state = 0;
29 
                 motor = TWDR;
30 
                 motor = 0;
31 
                 TWCR = 0x80;
32 
                 TWAMR = 0;
33 
                 TWAR = 0;
34 
                 TWDR = 0;
35 
                 TWSR = 0;
36 
                 TWBR = 0;
37 
                 i2c_init();
1639 holgerb 38 
                 I2C_Start();
173 holgerb 39 
                 i2c_write_byte(0);
40 
}
1 ingob 41 
 
1639 holgerb 42 
/*
1 ingob 43 
//############################################################################
44 
SIGNAL (TWI_vect)
45 
//############################################################################
46 
{
1211 hbuss 47 
 static unsigned char missing_motor;
1210 hbuss 48 
     switch(twi_state++)
1 ingob 49 
        {
1210 hbuss 50 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
51 
// Writing the Data
52 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 ingob 53 
        case 0:
1210 hbuss 54 
                        while(Mixer.Motor[motor][0] <= 0 && motor < MAX_MOTORS) motor++;  // skip if not used
1479 killagreg 55 
                                if(motor == MAX_MOTORS)  // writing finished -> now read
56 
                                {
57 
                                 motor = 0;
58 
                                 twi_state = 3;
1210 hbuss 59 
                                 i2c_write_byte(0x53+(motorread*2));
1479 killagreg 60 
                                 }
1209 hbuss 61 
                                else i2c_write_byte(0x52+(motor*2));
1 ingob 62 
                break;
63 
        case 1:
1479 killagreg 64 
                i2c_write_byte(Motor[motor++].SetPoint);
1111 hbuss 65 
                break;
66 
        case 2:
1479 killagreg 67 
                if(TWSR == 0x30)
68 
                                 {
69 
                                  if(!missing_motor) missing_motor = motor;
70 
                                  if((Motor[motor-1].State & MOTOR_STATE_ERROR_MASK) < MOTOR_STATE_ERROR_MASK) Motor[motor-1].State++; // increment error counter and handle overflow
1322 hbuss 71 
                                 }
1639 holgerb 72 
                I2C_Stop();
1210 hbuss 73 
                I2CTimeout = 10;
1209 hbuss 74 
                twi_state = 0;
1639 holgerb 75 
                I2C_Start();
1479 killagreg 76 
                break;
1210 hbuss 77 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
78 
// Reading Data
79 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1111 hbuss 80 
        case 3:
1211 hbuss 81 
               //Transmit 1st byte for reading
1210 hbuss 82 
                if(TWSR != 0x40)  // Error?
1479 killagreg 83 
                 {
84 
                  Motor[motorread].State &= ~MOTOR_STATE_PRESENT_MASK; // clear present bit
85 
                  motorread++;
1211 hbuss 86 
                  if(motorread >= MAX_MOTORS) motorread = 0;
1639 holgerb 87 
                  I2C_Stop();
1210 hbuss 88 
                  twi_state = 0;
89 
                 }
1479 killagreg 90 
                 else
1211 hbuss 91 
                 {
1479 killagreg 92 
                  Motor[motorread].State |= MOTOR_STATE_PRESENT_MASK; // set present bit
1211 hbuss 93 
                  I2C_ReceiveByte();
94 
                 }
1210 hbuss 95 
                MissingMotor = missing_motor;
1211 hbuss 96 
                missing_motor = 0;
1111 hbuss 97 
                break;
1210 hbuss 98 
        case 4: //Read 1st byte and transmit 2nd Byte
1479 killagreg 99 
                Motor[motorread].Current = TWDR;
1209 hbuss 100 
                I2C_ReceiveLastByte(); //nack
101 
                break;
1210 hbuss 102 
        case 5:
1209 hbuss 103 
                //Read 2nd byte
1479 killagreg 104 
                Motor[motorread].MaxPWM = TWDR;
105 
                                motorread++; // next motor
1211 hbuss 106 
                if(motorread >= MAX_MOTORS) motorread = 0;
1639 holgerb 107 
                I2C_Stop();
1209 hbuss 108 
                twi_state = 0;
1111 hbuss 109 
                break;
1479 killagreg 110 
 
1210 hbuss 111 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
112 
// writing Gyro-Offset
113 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1479 killagreg 114 
        case 8:
1111 hbuss 115 
                i2c_write_byte(0x98); // Address of the DAC
116 
                break;
1479 killagreg 117 
        case 9:
1111 hbuss 118 
                i2c_write_byte(0x10); // Update Channel A
119 
                break;
1479 killagreg 120 
        case 10:
1111 hbuss 121 
                i2c_write_byte(AnalogOffsetNick); // Value
122 
                break;
1479 killagreg 123 
        case 11:
1111 hbuss 124 
                i2c_write_byte(0x80); // Value
125 
                break;
1479 killagreg 126 
        case 12:
1639 holgerb 127 
                I2C_Stop();
1111 hbuss 128 
                I2CTimeout = 10;
1639 holgerb 129 
                I2C_Start();
1111 hbuss 130 
                break;
1479 killagreg 131 
        case 13:
1111 hbuss 132 
                i2c_write_byte(0x98); // Address of the DAC
133 
                break;
1479 killagreg 134 
        case 14:
1111 hbuss 135 
                i2c_write_byte(0x12); // Update Channel B
136 
                break;
1479 killagreg 137 
        case 15:
1111 hbuss 138 
                i2c_write_byte(AnalogOffsetRoll); // Value
139 
                break;
1479 killagreg 140 
        case 16:
1111 hbuss 141 
                i2c_write_byte(0x80); // Value
142 
                break;
1479 killagreg 143 
        case 17:
1639 holgerb 144 
                I2C_Stop();
1111 hbuss 145 
                I2CTimeout = 10;
1639 holgerb 146 
                I2C_Start();
1111 hbuss 147 
                break;
1479 killagreg 148 
        case 18:
1111 hbuss 149 
                i2c_write_byte(0x98); // Address of the DAC
150 
                break;
1479 killagreg 151 
        case 19:
1111 hbuss 152 
                i2c_write_byte(0x14); // Update Channel C
153 
                break;
1479 killagreg 154 
        case 20:
1111 hbuss 155 
                i2c_write_byte(AnalogOffsetGier); // Value
156 
                break;
1479 killagreg 157 
        case 21:
1111 hbuss 158 
                i2c_write_byte(0x80); // Value
159 
                break;
1479 killagreg 160 
        case 22:
1639 holgerb 161 
                I2C_Stop();
1111 hbuss 162 
                I2CTimeout = 10;
163 
                twi_state = 0;
164 
                break;
1209 hbuss 165 
        default: twi_state = 0;
1479 killagreg 166 
                break;
1209 hbuss 167 
                }
1111 hbuss 168 
 TWCR |= 0x80;
169 
}
1638 holgerb 170 
*/
171 
 
172 
/*
173 
                if(DataArray[3] & 0x01) Parameter.PwmScaling            = DataArray[4];
174 
                if(DataArray[3] & 0x02) Parameter.MaxStrom                      = DataArray[5];
175 
                if(DataArray[3] & 0x04) Parameter.TemperaturLimiter = DataArray[6];
176 
                if(DataArray[3] & 0x08) Parameter.SkaliereStrom         = DataArray[7];
177 
                if(DataArray[3] & 0x10) Parameter.Bitconfig                     = DataArray[8];
178 
*/
179 
 
180 
//############################################################################
181 
SIGNAL (TWI_vect)
182 
//############################################################################
183 
{                           // 2    3   4   5   6   7   8  9
1644 holgerb 184 
 unsigned char test[] = {0,0,'#',0x1F,255,30,99,64,0x00,7,8,9,10};
1643 holgerb 185 
 static unsigned char missing_motor,send = 0,crc = 0,read_more = 0;
1644 holgerb 186 
J4High;
1638 holgerb 187 
     switch(twi_state++)
188 
        {
189 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
190 
// Writing the Data
191 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
192 
        case 0:
193 
                        while(Mixer.Motor[motor][0] <= 0 && motor < MAX_MOTORS) motor++;  // skip if not used
194 
                                if(motor == MAX_MOTORS)  // writing finished -> now read
195 
                                {
196 
                                 motor = 0;
197 
                                 twi_state = 4;
198 
                                 i2c_write_byte(0x53+(motorread*2));
199 
                                 }
200 
                                else i2c_write_byte(0x52+(motor*2));
201 
                                send = 0;
202 
                break;
203 
        case 1:
204 
                i2c_write_byte(Motor[motor].SetPoint);
1643 holgerb 205 
//              if(!(Motor[motor].Version & MOTOR_STATE_NEW_PROTOCOL_MASK) /*|| !Motor[motor].SetPointLowerBits*/)
1644 holgerb 206 
                if((!(Motor[motor].Version & MOTOR_STATE_NEW_PROTOCOL_MASK) || !Motor[motor].SetPointLowerBits) && !TransmitBlConfig)
1643 holgerb 207 
                                  twi_state++; // skip
1638 holgerb 208 
                break;
209 
        case 2:
1642 killagreg 210 
                if(!send++)
1638 holgerb 211 
                                 {
1643 holgerb 212 
                                  i2c_write_byte((Motor[motor].SetPointLowerBits << 1) & 0x07);
1638 holgerb 213 
                                  crc = 0xAA;
214 
                                 }
215 
                                else
1639 holgerb 216 
                if(send == 9) i2c_write_byte(crc)
1642 killagreg 217 
                                else
1638 holgerb 218 
                                 {
219 
                                  crc += test[send];
220 
                                  i2c_write_byte(test[send]);
1642 killagreg 221 
                                }
222 
                if(TransmitBlConfig && !MotorenEin && motor == motorread && (Motor[motorread].Version & MOTOR_STATE_NEW_PROTOCOL_MASK))
1639 holgerb 223 
                                 {
224 
                                  if(send <= 10) twi_state--;
1642 killagreg 225 
                                 }
1638 holgerb 226 
                break;
227 
        case 3:
1642 killagreg 228 
                        motor++;
1638 holgerb 229 
                if(TWSR == 0x30)
230 
                                 {
231 
                                  if(!missing_motor) missing_motor = motor;
232 
                                  if((Motor[motor-1].State & MOTOR_STATE_ERROR_MASK) < MOTOR_STATE_ERROR_MASK) Motor[motor-1].State++; // increment error counter and handle overflow
233 
                                 }
1639 holgerb 234 
                I2C_Stop();
1638 holgerb 235 
                I2CTimeout = 10;
236 
                twi_state = 0;
1639 holgerb 237 
                I2C_Start();
1638 holgerb 238 
                break;
239 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
240 
// Reading Data
241 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
242 
        case 4:
243 
               //Transmit 1st byte for reading
244 
                if(TWSR != 0x40)  // Error?
245 
                 {
246 
                  Motor[motorread].State &= ~MOTOR_STATE_PRESENT_MASK; // clear present bit
247 
                  motorread++;
1643 holgerb 248 
                  if(motorread >= MAX_MOTORS) { TransmitBlConfig = 0; motorread = 0; ReadTemperature = ++ReadTemperature & 0x0f;}
1639 holgerb 249 
                  I2C_Stop();
1638 holgerb 250 
                  twi_state = 0;
251 
                 }
252 
                 else
253 
                 {
254 
                  Motor[motorread].State |= MOTOR_STATE_PRESENT_MASK; // set present bit
1643 holgerb 255 
                  if(motorread == ReadTemperature || TransmitBlConfig)                         
256 
                                  {
257 
                   read_more = 1;
258 
                   I2C_ReceiveByte();
259 
                                  }
260 
                                  else
261 
                                   {
262 
                                    I2C_ReceiveLastByte();                               
263 
                                        read_more = 0;
264 
                                   }   
1638 holgerb 265 
                 }
266 
                MissingMotor = missing_motor;
267 
                missing_motor = 0;
268 
                break;
269 
        case 5: //Read 1st byte and transmit 2nd Byte
270 
                Motor[motorread].Current = TWDR;
1643 holgerb 271 
                if(read_more) I2C_ReceiveByte() //nack
272 
                                else
273 
                                 {
274 
                                        motorread++; // next motor
275 
                                        if(motorread >= MAX_MOTORS) { TransmitBlConfig = 0; motorread = 0; ReadTemperature = ++ReadTemperature & 0x0f;}
276 
                                        I2C_Stop();
277 
                                        twi_state = 0;
278 
                                 }
1638 holgerb 279 
                break;
1642 killagreg 280 
        case 6:
1638 holgerb 281 
                       //Read 2nd byte and transmit 3rd Byte
282 
                Motor[motorread].MaxPWM = TWDR;
1642 killagreg 283 
                                if(TWDR == 250)
1638 holgerb 284 
                                 {
1643 holgerb 285 
                                  if(!MotorenEin) Motor[motorread].Version |= MOTOR_STATE_NEW_PROTOCOL_MASK;
1642 killagreg 286 
                                 }
287 
                                 else if(TransmitBlConfig) Motor[motorread].Version = 0;
1638 holgerb 288 
                                I2C_ReceiveLastByte(); //nack
289 
                break;
1642 killagreg 290 
        case 7: // read next
1638 holgerb 291 
                                Motor[motorread].Temperature = TWDR;
292 
                                motorread++; // next motor
1639 holgerb 293 
                if(motorread >= MAX_MOTORS) { TransmitBlConfig = 0; motorread = 0; }
294 
                I2C_Stop();
1638 holgerb 295 
                twi_state = 0;
1643 holgerb 296 
                                break;
1638 holgerb 297 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
298 
// writing Gyro-Offset
299 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
300 
        case 18:
301 
                i2c_write_byte(0x98); // Address of the DAC
302 
                break;
303 
        case 19:
304 
                i2c_write_byte(0x10); // Update Channel A
305 
                break;
306 
        case 20:
307 
                i2c_write_byte(AnalogOffsetNick); // Value
308 
                break;
309 
        case 21:
310 
                i2c_write_byte(0x80); // Value
311 
                break;
312 
        case 22:
1639 holgerb 313 
                I2C_Stop();
1638 holgerb 314 
                I2CTimeout = 10;
1639 holgerb 315 
                I2C_Start();
1638 holgerb 316 
                break;
317 
        case 23:
318 
                i2c_write_byte(0x98); // Address of the DAC
319 
                break;
320 
        case 24:
321 
                i2c_write_byte(0x12); // Update Channel B
322 
                break;
323 
        case 25:
324 
                i2c_write_byte(AnalogOffsetRoll); // Value
325 
                break;
326 
        case 26:
327 
                i2c_write_byte(0x80); // Value
328 
                break;
329 
        case 27:
1639 holgerb 330 
                I2C_Stop();
1638 holgerb 331 
                I2CTimeout = 10;
1639 holgerb 332 
                I2C_Start();
1638 holgerb 333 
                break;
334 
        case 28:
335 
                i2c_write_byte(0x98); // Address of the DAC
336 
                break;
337 
        case 29:
338 
                i2c_write_byte(0x14); // Update Channel C
339 
                break;
340 
        case 30:
341 
                i2c_write_byte(AnalogOffsetGier); // Value
342 
                break;
343 
        case 31:
344 
                i2c_write_byte(0x80); // Value
345 
                break;
346 
        case 32:
1639 holgerb 347 
                I2C_Stop();
1638 holgerb 348 
                I2CTimeout = 10;
349 
                twi_state = 0;
350 
                break;
351 
        default: twi_state = 0;
352 
                break;
353 
                }
354 
 TWCR |= 0x80;
1644 holgerb 355 
J4Low;
1638 holgerb 356 
}
1639 holgerb 357