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;
1 ingob 7 
unsigned char motor = 0;
1210 hbuss 8 
unsigned char motorread = 0,MissingMotor = 0;
1479 killagreg 9 
 
10 
MotorData_t Motor[MAX_MOTORS];
11 
 
1322 hbuss 12 
unsigned int I2CError = 0;
1 ingob 13 
 
14 
//############################################################################
15 
//Initzialisieren der I2C (TWI) Schnittstelle
16 
void i2c_init(void)
17 
//############################################################################
18 
{
19 
  TWSR = 0;
1479 killagreg 20 
  TWBR = ((SYSCLK/SCL_CLOCK)-16)/2;
1 ingob 21 
}
22 
 
23 
//############################################################################
24 
//Start I2C
1479 killagreg 25 
void i2c_start(void)
1 ingob 26 
//############################################################################
27 
{
28 
    TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT) | (1<<TWIE);
29 
}
30 
 
31 
//############################################################################
32 
void i2c_stop(void)
33 
//############################################################################
34 
{
35 
    TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT);
36 
}
37 
 
173 holgerb 38 
void i2c_reset(void)
1 ingob 39 
//############################################################################
173 holgerb 40 
{
1479 killagreg 41 
                 i2c_stop();
173 holgerb 42 
                 twi_state = 0;
43 
                 motor = TWDR;
44 
                 motor = 0;
45 
                 TWCR = 0x80;
46 
                 TWAMR = 0;
47 
                 TWAR = 0;
48 
                 TWDR = 0;
49 
                 TWSR = 0;
50 
                 TWBR = 0;
51 
                 i2c_init();
52 
                 i2c_start();
53 
                 i2c_write_byte(0);
54 
}
55 
 
56 
//############################################################################
1209 hbuss 57 
void i2c_write_byte(char byte)
1 ingob 58 
//############################################################################
1479 killagreg 59 
{
1 ingob 60 
    TWSR = 0x00;
61 
    TWDR = byte;
62 
    TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
63 
}
64 
 
1209 hbuss 65 
/****************************************/
66 
/*    Write to I2C                      */
67 
/****************************************/
68 
void I2C_WriteByte(int8_t byte)
69 
{
70 
    // move byte to send into TWI Data Register
71 
    TWDR = byte;
72 
    // clear interrupt flag (TWINT = 1)
73 
    // enable i2c bus (TWEN = 1)
74 
    // enable interrupt (TWIE = 1)
75 
    TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
76 
}
77 
 
78 
/****************************************/
79 
/*    Receive byte and send ACK         */
80 
/****************************************/
81 
void I2C_ReceiveByte(void)
82 
{
83 
   TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWEA);
84 
}
85 
 
86 
/****************************************/
87 
/* I2C receive last byte and send no ACK*/
88 
/****************************************/
89 
void I2C_ReceiveLastByte(void)
90 
{
91 
   TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
92 
}
93 
 
94 
 
95 
 
1 ingob 96 
//############################################################################
97 
SIGNAL (TWI_vect)
98 
//############################################################################
99 
{
1211 hbuss 100 
 static unsigned char missing_motor;
1210 hbuss 101 
     switch(twi_state++)
1 ingob 102 
        {
1210 hbuss 103 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
104 
// Writing the Data
105 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 ingob 106 
        case 0:
1210 hbuss 107 
                        while(Mixer.Motor[motor][0] <= 0 && motor < MAX_MOTORS) motor++;  // skip if not used
1479 killagreg 108 
                                if(motor == MAX_MOTORS)  // writing finished -> now read
109 
                                {
110 
                                 motor = 0;
111 
                                 twi_state = 3;
1210 hbuss 112 
                                 i2c_write_byte(0x53+(motorread*2));
1479 killagreg 113 
                                 }
1209 hbuss 114 
                                else i2c_write_byte(0x52+(motor*2));
1 ingob 115 
                break;
116 
        case 1:
1479 killagreg 117 
                i2c_write_byte(Motor[motor++].SetPoint);
1111 hbuss 118 
                break;
119 
        case 2:
1479 killagreg 120 
                if(TWSR == 0x30)
121 
                                 {
122 
                                  if(!missing_motor) missing_motor = motor;
123 
                                  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 124 
                                 }
1111 hbuss 125 
                i2c_stop();
1210 hbuss 126 
                I2CTimeout = 10;
1209 hbuss 127 
                twi_state = 0;
1479 killagreg 128 
                i2c_start();
129 
                break;
1210 hbuss 130 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
131 
// Reading Data
132 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1111 hbuss 133 
        case 3:
1211 hbuss 134 
               //Transmit 1st byte for reading
1210 hbuss 135 
                if(TWSR != 0x40)  // Error?
1479 killagreg 136 
                 {
137 
                  Motor[motorread].State &= ~MOTOR_STATE_PRESENT_MASK; // clear present bit
138 
                  motorread++;
1211 hbuss 139 
                  if(motorread >= MAX_MOTORS) motorread = 0;
140 
                  i2c_stop();
1210 hbuss 141 
                  twi_state = 0;
142 
                 }
1479 killagreg 143 
                 else
1211 hbuss 144 
                 {
1479 killagreg 145 
                  Motor[motorread].State |= MOTOR_STATE_PRESENT_MASK; // set present bit
1211 hbuss 146 
                  I2C_ReceiveByte();
147 
                 }
1210 hbuss 148 
                MissingMotor = missing_motor;
1211 hbuss 149 
                missing_motor = 0;
1111 hbuss 150 
                break;
1210 hbuss 151 
        case 4: //Read 1st byte and transmit 2nd Byte
1479 killagreg 152 
                Motor[motorread].Current = TWDR;
1209 hbuss 153 
                I2C_ReceiveLastByte(); //nack
154 
                break;
1210 hbuss 155 
        case 5:
1209 hbuss 156 
                //Read 2nd byte
1479 killagreg 157 
                Motor[motorread].MaxPWM = TWDR;
158 
                                motorread++; // next motor
1211 hbuss 159 
                if(motorread >= MAX_MOTORS) motorread = 0;
1111 hbuss 160 
                i2c_stop();
1209 hbuss 161 
                twi_state = 0;
1111 hbuss 162 
                break;
1479 killagreg 163 
 
1210 hbuss 164 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
165 
// writing Gyro-Offset
166 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1479 killagreg 167 
        case 8:
1111 hbuss 168 
                i2c_write_byte(0x98); // Address of the DAC
169 
                break;
1479 killagreg 170 
        case 9:
1111 hbuss 171 
                i2c_write_byte(0x10); // Update Channel A
172 
                break;
1479 killagreg 173 
        case 10:
1111 hbuss 174 
                i2c_write_byte(AnalogOffsetNick); // Value
175 
                break;
1479 killagreg 176 
        case 11:
1111 hbuss 177 
                i2c_write_byte(0x80); // Value
178 
                break;
1479 killagreg 179 
        case 12:
180 
                i2c_stop();
1111 hbuss 181 
                I2CTimeout = 10;
1479 killagreg 182 
                i2c_start();
1111 hbuss 183 
                break;
1479 killagreg 184 
        case 13:
1111 hbuss 185 
                i2c_write_byte(0x98); // Address of the DAC
186 
                break;
1479 killagreg 187 
        case 14:
1111 hbuss 188 
                i2c_write_byte(0x12); // Update Channel B
189 
                break;
1479 killagreg 190 
        case 15:
1111 hbuss 191 
                i2c_write_byte(AnalogOffsetRoll); // Value
192 
                break;
1479 killagreg 193 
        case 16:
1111 hbuss 194 
                i2c_write_byte(0x80); // Value
195 
                break;
1479 killagreg 196 
        case 17:
197 
                i2c_stop();
1111 hbuss 198 
                I2CTimeout = 10;
1479 killagreg 199 
                i2c_start();
1111 hbuss 200 
                break;
1479 killagreg 201 
        case 18:
1111 hbuss 202 
                i2c_write_byte(0x98); // Address of the DAC
203 
                break;
1479 killagreg 204 
        case 19:
1111 hbuss 205 
                i2c_write_byte(0x14); // Update Channel C
206 
                break;
1479 killagreg 207 
        case 20:
1111 hbuss 208 
                i2c_write_byte(AnalogOffsetGier); // Value
209 
                break;
1479 killagreg 210 
        case 21:
1111 hbuss 211 
                i2c_write_byte(0x80); // Value
212 
                break;
1479 killagreg 213 
        case 22:
214 
                i2c_stop();
1111 hbuss 215 
                I2CTimeout = 10;
216 
                twi_state = 0;
217 
                break;
1209 hbuss 218 
        default: twi_state = 0;
1479 killagreg 219 
                break;
1209 hbuss 220 
                }
1111 hbuss 221 
 TWCR |= 0x80;
222 
}