Subversion Repositories FlightCtrl

Rev

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

Rev 885 Rev 886
Line 1... Line 1...
1
/*############################################################################
1
/*############################################################################
2
############################################################################*/
2
############################################################################*/
Line -... Line 3...
-
 
3
 
-
 
4
#include <avr/io.h>
-
 
5
#include <avr/interrupt.h>
3
 
6
 
-
 
7
#include "main.h"
-
 
8
#include "twimaster.h"
-
 
9
#include "fc.h"
-
 
10
 
-
 
11
volatile uint8_t twi_state = 0;
-
 
12
volatile uint8_t motor = 0;
-
 
13
volatile uint8_t motor_rx[8];
-
 
14
 
-
 
15
/**************************************************/
-
 
16
/*   Initialize I2C (TWI)                         */
-
 
17
/**************************************************/
-
 
18
void I2C_Init(void)
-
 
19
{
-
 
20
        uint8_t sreg = SREG;
-
 
21
        cli();
-
 
22
 
-
 
23
        // SDA is INPUT
-
 
24
        DDRC  &= ~(1<<DDC1);
-
 
25
        // SCL is output
-
 
26
        DDRC |= (1<<DDC0);
-
 
27
        // pull up SDA
-
 
28
        PORTC |= (1<<PORTC0)|(1<<PORTC1);
-
 
29
 
-
 
30
        // TWI Status Register
-
 
31
        // prescaler 1 (TWPS1 = 0, TWPS0 = 0)
-
 
32
        TWSR &= ~((1<<TWPS1)|(1<<TWPS0));
-
 
33
 
-
 
34
        // set TWI Bit Rate Register
-
 
35
        TWBR = ((SYSCLK/SCL_CLOCK)-16)/2;
-
 
36
 
-
 
37
        SREG = sreg;
-
 
38
}
-
 
39
 
-
 
40
/****************************************/
-
 
41
/*   Start I2C                          */
-
 
42
/****************************************/
-
 
43
void I2C_Start(void)
-
 
44
{
-
 
45
        // TWI Control Register
-
 
46
        // clear TWI interrupt flag (TWINT=1)
-
 
47
        // disable TWI Acknowledge Bit (TWEA = 0)
-
 
48
        // enable TWI START Condition Bit (TWSTA = 1), MASTER
-
 
49
        // disable TWI STOP Condition Bit (TWSTO = 0)
-
 
50
        // disable TWI Write Collision Flag (TWWC = 0)
-
 
51
        // enable i2c (TWIE = 1)
-
 
52
        // enable TWI Interrupt (TWIE = 1)
-
 
53
    TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN) | (1<<TWIE);
Line 4... Line 54...
4
#include "main.h"
54
}
5
 
-
 
6
unsigned char twi_state = 0;
55
 
7
unsigned char motor = 0;
-
 
8
unsigned char motorread = 0;
-
 
9
unsigned char motor_rx[8];
-
 
10
 
56
/****************************************/
11
//############################################################################
57
/*    Stop I2C                          */
12
//Initzialisieren der I2C (TWI) Schnittstelle
-
 
13
void i2c_init(void)
58
/****************************************/
14
//############################################################################
59
void I2C_Stop(void)
15
{
60
{
16
  TWSR = 0;
-
 
17
  TWBR = ((SYSCLK/SCL_CLOCK)-16)/2;
-
 
18
}
-
 
19
 
-
 
20
//############################################################################
61
        // TWI Control Register
21
//Start I2C
62
        // clear TWI interrupt flag (TWINT=1)
22
char i2c_start(void)
-
 
23
//############################################################################
63
        // disable TWI Acknowledge Bit (TWEA = 0)
24
{
-
 
25
    TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT) | (1<<TWIE);
-
 
26
    return(0);
-
 
27
}
64
        // diable TWI START Condition Bit (TWSTA = 1), no MASTER
28
 
65
        // enable TWI STOP Condition Bit (TWSTO = 1)
29
//############################################################################
66
        // disable TWI Write Collision Flag (TWWC = 0)
30
//Start I2C
-
 
31
void i2c_stop(void)
-
 
32
//############################################################################
67
        // enable i2c (TWIE = 1)
33
{
68
        // disable TWI Interrupt (TWIE = 0)
34
    TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT);
69
    TWCR = (1<<TWINT) | (1<<TWSTO) | (1<<TWEN);
-
 
70
}
-
 
71
 
-
 
72
/****************************************/
35
}
73
/*    Reset I2C                         */
36
 
-
 
37
void i2c_reset(void)
74
/****************************************/
-
 
75
void I2C_Reset(void)
38
//############################################################################
76
{
39
{
77
        // stop i2c bus
40
                 i2c_stop();                
78
        I2C_Stop();
41
                 twi_state = 0;
79
        twi_state = 0;
42
                 motor = TWDR;
80
        motor = TWDR; // ??
43
                 motor = 0;
81
        motor = 0;
44
                 TWCR = 0x80;
82
        TWCR = (1<<TWINT); // reset to original state incl. interrupt flag reset
45
                 TWAMR = 0;
83
        TWAMR = 0;
46
                 TWAR = 0;
84
        TWAR = 0;
47
                 TWDR = 0;
85
        TWDR = 0;
48
                 TWSR = 0;
86
        TWSR = 0;
49
                 TWBR = 0;
87
        TWBR = 0;
50
                 i2c_init();
88
        I2C_Init();
51
                 i2c_start();
89
        I2C_Start();
52
                 i2c_write_byte(0);
90
        I2C_WriteByte(0);
53
}
91
}
54
 
92
 
-
 
93
/****************************************/
55
//############################################################################
94
/*    Write to I2C                      */
56
//Start I2C
-
 
57
char i2c_write_byte(char byte)
95
/****************************************/
58
//############################################################################
96
void I2C_WriteByte(int8_t byte)
59
{
97
{
-
 
98
    // move byte to send into TWI Data Register
-
 
99
    TWDR = byte;
-
 
100
    // clear interrupt flag (TWINT = 1)
60
    TWSR = 0x00;
101
    // enable i2c bus (TWEN = 1)
61
    TWDR = byte;
-
 
62
    TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
-
 
63
   
-
 
64
    return(0);
102
    // enable intterupt (TWIW = 1)
Line -... Line 103...
-
 
103
    TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
-
 
104
}
-
 
105
 
-
 
106
 
-
 
107
/****************************************/
-
 
108
/*    Receive byte and send ACK         */
65
   
109
/****************************************/
-
 
110
void I2C_ReceiveByte(void)
-
 
111
{
-
 
112
   TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWEA);
-
 
113
}
-
 
114
 
66
}
115
/****************************************/
-
 
116
/* I2C receive last byte and send no ACK*/
-
 
117
/****************************************/
-
 
118
void I2C_ReceiveLastByte(void)
-
 
119
{
-
 
120
   TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
-
 
121
}
-
 
122
 
-
 
123
 
67
 
124
/****************************************/
68
//############################################################################
-
 
-
 
125
/*        I2C ISR                       */
69
//Start I2C
126
/****************************************/
-
 
127
ISR (TWI_vect)
-
 
128
 
70
SIGNAL (TWI_vect)
129
{
71
//############################################################################
130
        static uint8_t motorread = 0;
-
 
131
 
72
{
132
    switch (twi_state++) // First i2s_start from SendMotorData()
73
    switch (twi_state++)
133
        {
74
        {
134
                // Master Transmit
75
        case 0:
135
        case 0: // Send SLA-W
76
                i2c_write_byte(0x52+(motor*2));
136
                I2C_WriteByte(0x52+(motor*2));
77
                break;
137
                break;
78
        case 1:
138
        case 1: // Send Data to Salve
79
                switch(motor++)
139
                switch(motor++)
80
                    {
140
                    {
81
                    case 0:
141
                    case 0:
82
                            i2c_write_byte(Motor_Vorne);
142
                            I2C_WriteByte(Motor_Front);
83
                            break;
143
                            break;
84
                    case 1:      
144
                    case 1:
85
                            i2c_write_byte(Motor_Hinten);
145
                            I2C_WriteByte(Motor_Rear);
86
                            break;
146
                            break;
87
                    case 2:
147
                    case 2:
88
                            i2c_write_byte(Motor_Rechts);
148
                            I2C_WriteByte(Motor_Right);
89
                            break;
149
                            break;
90
                    case 3:
150
                    case 3:
91
                            i2c_write_byte(Motor_Links);
151
                            I2C_WriteByte(Motor_Left);
92
                            break;
-
 
93
                    }
152
                            break;
94
                break;
153
                    }
95
        case 2:
154
                break;
96
                i2c_stop();
-
 
97
                if (motor<4) twi_state = 0;
155
        case 2: // repeat case 0+1 for all Slaves
98
                else motor = 0;
156
                if (motor<4) twi_state = 0;
99
                i2c_start();  
157
                I2C_Start(); // Repeated start -> switch salve or switch Master Transmit -> Master Receive
100
                break;
158
                break;
101
                   
159
 
102
        //Liest Daten von Motor
160
        // Master Receive
103
        case 3:
161
        case 3: // Send SLA-R
104
                i2c_write_byte(0x53+(motorread*2));
162
                I2C_WriteByte(0x53+(motorread*2));
105
                break;
163
                break;
106
        case 4:
-
 
107
                switch(motorread)
-
 
108
                    {
-
 
109
                    case 0:
-
 
110
                        i2c_write_byte(Motor_Vorne);
-
 
111
                        break;
-
 
112
                    case 1:
-
 
113
                        i2c_write_byte(Motor_Hinten);
-
 
114
                        break;
-
 
115
                    case 2:
-
 
116
                        i2c_write_byte(Motor_Rechts);
-
 
117
                        break;
-
 
118
                    case 3:
-
 
119
                        i2c_write_byte(Motor_Links);
164
        case 4:
120
                        break;
165
                //Transmit 1st byte
121
                    }
166
                                I2C_ReceiveByte();
-
 
167
                break;
122
                break;
168
        case 5: //Read 1st byte and transmit 2nd Byte
123
        case 5: //1 Byte vom Motor lesen       
169
                motor_rx[motorread] = TWDR;
124
                motor_rx[motorread] = TWDR;
-
 
125
 
-
 
126
        case 6:
-
 
127
                switch(motorread)
-
 
128
                    {
170
                                I2C_ReceiveLastByte();
129
                    case 0:
-
 
130
                        i2c_write_byte(Motor_Vorne);
-
 
131
                        break;
-
 
132
                    case 1:
-
 
133
                        i2c_write_byte(Motor_Hinten);
-
 
134
                        break;
-
 
135
                    case 2:
-
 
136
                        i2c_write_byte(Motor_Rechts);
-
 
137
                        break;
-
 
138
                    case 3:
-
 
139
                        i2c_write_byte(Motor_Links);
-
 
140
                        break;
-
 
141
                    }
171
                                break;
142
                break;  
172
        case 6:
143
        case 7: //2 Byte vom Motor lesen       
173
                //Read 2nd byte
-
 
174
                                motor_rx[motorread+4] = TWDR;
144
                motor_rx[motorread+4] = TWDR;
175
                                motorread++;
145
                motorread++;
176
                if (motorread > 3) motorread=0;
146
                if (motorread>3) motorread=0;
177
 
-
 
178
        default:
-
 
179
                I2C_Stop();
147
                i2c_stop();
180
                twi_state = 0;
148
                I2CTimeout = 10;
-
 
149
                twi_state = 0;
181
                I2CTimeout = 10;