Rev 37 | Rev 61 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 37 | Rev 41 | ||
---|---|---|---|
Line 52... | Line 52... | ||
52 | // + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
52 | // + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
53 | // + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
53 | // + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
54 | // + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
54 | // + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
55 | // + POSSIBILITY OF SUCH DAMAGE. |
55 | // + POSSIBILITY OF SUCH DAMAGE. |
56 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
56 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
- | 57 | #include <stdlib.h> |
|
- | 58 | #include <string.h> |
|
- | 59 | #include "91x_lib.h" |
|
- | 60 | #include "i2c.h" |
|
- | 61 | #include "uart1.h" |
|
- | 62 | #include "timer.h" |
|
57 | #include "main.h" |
63 | #include "main.h" |
- | 64 | #include "led.h" |
|
- | 65 | #include "spi_slave.h" |
|
- | 66 | ||
- | 67 | ||
- | 68 | volatile I2C_State_t I2C_State = I2C_OFF; |
|
- | 69 | ||
- | 70 | // rxbuffer |
|
- | 71 | volatile u8 I2C_RxBufferSize; |
|
- | 72 | volatile u8 *I2C_RxBuffer; |
|
- | 73 | volatile u8 Rx_Idx = 0; |
|
- | 74 | // txbuffer |
|
- | 75 | volatile u8 I2C_TxBufferSize; |
|
- | 76 | volatile u8 *I2C_TxBuffer; |
|
- | 77 | volatile u8 Tx_Idx = 0; |
|
- | 78 | ||
- | 79 | volatile u8 I2C_Direction; |
|
- | 80 | volatile u8 I2C_Command; |
|
- | 81 | ||
- | 82 | volatile I2C_Heading_t I2C_Heading; |
|
- | 83 | volatile I2C_WriteAttitude_t I2C_WriteAttitude; |
|
- | 84 | volatile I2C_Mag_t I2C_Mag; |
|
- | 85 | volatile I2C_Version_t MK3MAG_Version; |
|
- | 86 | volatile I2C_Cal_t I2C_WriteCal; |
|
- | 87 | volatile I2C_Cal_t I2C_ReadCal; |
|
Line 58... | Line -... | ||
58 | - | ||
59 | u8 I2C_RxBufferSize, I2C_TxBufferSize; |
- | |
60 | u8 *I2C_TxBuffer, *I2C_RxBuffer; |
- | |
61 | u8 Tx_Idx=0, Rx_Idx=0, I2C_Direction; |
- | |
62 | u8 I2C_Command; |
- | |
63 | - | ||
64 | struct str_I2C_Heading I2C_Heading; |
- | |
65 | struct str_I2C_WriteNickRoll I2C_WriteNickRoll; |
- | |
66 | struct str_I2C_Mag I2C_Mag; |
- | |
67 | struct str_I2C_EEPROM I2C_ReadEEPROM, I2C_WriteEEPROM; |
- | |
68 | struct str_I2C_Version I2C_Version; |
- | |
69 | struct str_I2C_WriteCal I2C_WriteCal; |
- | |
70 | u8 CompassUpdateActiv = 0; |
- | |
71 | u8 CompassCalState = 0; |
88 | |
- | 89 | volatile u8 I2C_ReadRequest = 0; |
|
- | 90 | volatile u32 I2C1_Timeout = 0; |
|
- | 91 | volatile u32 CheckI2COkay = 0; |
|
- | 92 | volatile u8 I2C_PrimRxBuffer[10]; // must be larger than any of the secondary rx buffers |
|
Line 72... | Line 93... | ||
72 | volatile u8 I2C_ReadRequest = 0; |
93 | |
73 | 94 | ||
74 | //-------------------------------------------------------------- |
95 | //-------------------------------------------------------------- |
75 | void I2C1_Init(void) |
96 | void I2C1_Init(void) |
76 | { |
97 | { |
Line 77... | Line 98... | ||
77 | I2C_InitTypeDef I2C_Struct; |
98 | I2C_InitTypeDef I2C_Struct; |
- | 99 | GPIO_InitTypeDef GPIO_InitStructure; |
|
78 | GPIO_InitTypeDef GPIO_Struct; |
100 | |
- | 101 | SerialPutString("\r\n I2C init..."); |
|
- | 102 | // enable Port 2 peripherie |
|
- | 103 | SCU_APBPeriphClockConfig(__GPIO2, ENABLE); |
|
79 | 104 | // disable a reset state |
|
- | 105 | SCU_APBPeriphReset(__GPIO2, DISABLE); |
|
- | 106 | ||
- | 107 | // free a busy bus |
|
- | 108 | ||
- | 109 | // At switch on I2C devices can get in a state where they |
|
- | 110 | // are still waiting for a command due to all the bus lines bouncing |
|
- | 111 | // around at startup have started clocking data into the device(s). |
|
80 | SerialPutString("I2C init..."); |
112 | // Enable the ports as open collector port outputs |
- | 113 | // and clock out at least 9 SCL pulses, then generate a stop |
|
- | 114 | // condition and then leave the clock line high. |
|
- | 115 | ||
81 | SCU_APBPeriphClockConfig(__I2C1,ENABLE); |
116 | // configure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT to normal port operation |
82 | I2C_DeInit(I2C1); |
117 | GPIO_StructInit(&GPIO_InitStructure); |
83 | 118 | GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput; |
|
84 | GPIO_Struct.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3; |
119 | GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3; |
- | 120 | GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector; |
|
- | 121 | GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Disable; |
|
- | 122 | GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt1; |
|
- | 123 | GPIO_Init(GPIO2, &GPIO_InitStructure); |
|
- | 124 | ||
- | 125 | u8 i; |
|
- | 126 | u32 delay; |
|
- | 127 | // set SCL high and then SDA to low (start condition) |
|
- | 128 | GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET); |
|
- | 129 | delay = SetDelay(1); |
|
- | 130 | while (!CheckDelay(delay)); |
|
- | 131 | GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_RESET); |
|
- | 132 | // toggle SCL at least 10 times from high to low to high |
|
- | 133 | for(i = 0; i < 10; i++) |
|
- | 134 | { |
|
- | 135 | delay = SetDelay(1); |
|
- | 136 | while (!CheckDelay(delay)); |
|
- | 137 | ||
- | 138 | GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_RESET); |
|
- | 139 | delay = SetDelay(1); |
|
- | 140 | while (!CheckDelay(delay)); |
|
- | 141 | GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET); |
|
- | 142 | } |
|
- | 143 | delay = SetDelay(1); |
|
- | 144 | while (!CheckDelay(delay)); |
|
- | 145 | // create stop condition setting SDA HIGH when SCL is HIGH |
|
- | 146 | GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_SET); |
|
- | 147 | ||
- | 148 | ||
- | 149 | // reconfigure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT |
|
- | 150 | GPIO_StructInit(&GPIO_InitStructure); |
|
- | 151 | GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput; |
|
- | 152 | GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3; |
|
85 | GPIO_Struct.GPIO_Type = GPIO_Type_OpenCollector; |
153 | GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector; |
- | 154 | GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable; |
|
- | 155 | GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; //I2C1_CLKOUT, I2C1_DOUT |
|
- | 156 | GPIO_Init(GPIO2, &GPIO_InitStructure); |
|
- | 157 | ||
- | 158 | // enable I2C peripherie |
|
- | 159 | SCU_APBPeriphClockConfig(__I2C1,ENABLE); |
|
86 | GPIO_Struct.GPIO_IPConnected = GPIO_IPConnected_Enable; |
160 | // reset I2C peripherie |
- | 161 | SCU_APBPeriphReset(__I2C1,ENABLE); |
|
- | 162 | SCU_APBPeriphReset(__I2C1,DISABLE); |
|
87 | GPIO_Struct.GPIO_Alternate=GPIO_OutputAlt2; |
163 | |
88 | GPIO_Init(GPIO2, &GPIO_Struct); |
164 | I2C_DeInit(I2C1); |
89 | 165 | I2C_StructInit(&I2C_Struct); |
|
90 | I2C_Struct.I2C_GeneralCall = I2C_GeneralCall_Disable; |
166 | I2C_Struct.I2C_GeneralCall = I2C_GeneralCall_Disable; |
91 | I2C_Struct.I2C_Ack = I2C_Ack_Enable; |
167 | I2C_Struct.I2C_Ack = I2C_Ack_Enable; |
- | 168 | I2C_Struct.I2C_CLKSpeed = 20000; |
|
- | 169 | I2C_Struct.I2C_OwnAddress = 0x00; |
|
- | 170 | I2C_Init(I2C1, &I2C_Struct); |
|
- | 171 | ||
- | 172 | I2C_TxBuffer = NULL; |
|
- | 173 | Tx_Idx = 0; |
|
- | 174 | I2C_TxBufferSize = 0; |
|
- | 175 | ||
- | 176 | I2C_RxBuffer = NULL; |
|
- | 177 | Rx_Idx = 0; |
|
- | 178 | I2C_RxBufferSize = 0; |
|
- | 179 | ||
- | 180 | I2C_Cmd(I2C1, ENABLE); |
|
- | 181 | I2C_ITConfig(I2C1, ENABLE); |
|
- | 182 | ||
- | 183 | VIC_Config(I2C1_ITLine, VIC_IRQ , 0); |
|
- | 184 | VIC_ITCmd(I2C1_ITLine, ENABLE); |
|
- | 185 | ||
- | 186 | I2C1_Timeout = SetDelay(1000); |
|
Line 92... | Line 187... | ||
92 | I2C_Struct.I2C_CLKSpeed = 20000; |
187 | I2C_Heading.Heading = -1; |
- | 188 | I2C_GenerateSTOP(I2C1, ENABLE); |
|
- | 189 | I2C_State = I2C_IDLE; |
|
- | 190 | ||
- | 191 | SerialPutString("ok"); |
|
93 | I2C_Struct.I2C_OwnAddress = I2C_SLAVE_ADDRESS; |
192 | } |
- | 193 | ||
- | 194 | ||
Line -... | Line 195... | ||
- | 195 | //-------------------------------------------------------------- |
|
94 | I2C_Init(I2C1, &I2C_Struct); |
196 | void I2C1_Deinit(void) |
- | 197 | { |
|
95 | 198 | GPIO_InitTypeDef GPIO_InitStructure; |
|
- | 199 | ||
- | 200 | SerialPutString("\r\n I2C deinit..."); |
|
- | 201 | I2C_GenerateStart(I2C1, DISABLE); |
|
- | 202 | I2C_GenerateSTOP(I2C1, ENABLE); |
|
- | 203 | VIC_ITCmd(I2C1_ITLine, DISABLE); |
|
- | 204 | I2C_ITConfig(I2C1, DISABLE); |
|
- | 205 | I2C_Cmd(I2C1, DISABLE); |
|
- | 206 | I2C_DeInit(I2C1); |
|
- | 207 | SCU_APBPeriphClockConfig(__I2C1, DISABLE); |
|
- | 208 | ||
- | 209 | // set ports to input |
|
- | 210 | SCU_APBPeriphClockConfig(__GPIO2, ENABLE); |
|
- | 211 | GPIO_StructInit(&GPIO_InitStructure); |
|
- | 212 | GPIO_InitStructure.GPIO_Direction = GPIO_PinInput; |
|
- | 213 | GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3; |
|
- | 214 | GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull; |
|
- | 215 | GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Disable; |
|
- | 216 | GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; |
|
- | 217 | GPIO_Init(GPIO2, &GPIO_InitStructure); |
|
- | 218 | ||
- | 219 | I2C_TxBuffer = NULL; |
|
- | 220 | Tx_Idx = 0; |
|
Line 96... | Line 221... | ||
96 | I2C_Cmd(I2C1, ENABLE); |
221 | I2C_TxBufferSize = 0; |
97 | I2C_ITConfig(I2C1, ENABLE); |
- | |
Line -... | Line 222... | ||
- | 222 | ||
- | 223 | I2C_RxBuffer = NULL; |
|
Line -... | Line 224... | ||
- | 224 | Rx_Idx = 0; |
|
98 | 225 | I2C_RxBufferSize = 0; |
|
Line -... | Line 226... | ||
- | 226 | ||
99 | VIC_Config(I2C1_ITLine,VIC_IRQ , 8); |
227 | I2C_State = I2C_OFF; |
100 | VIC_ITCmd(I2C1_ITLine, ENABLE); |
228 | |
101 | 229 | I2C1_Timeout = 0; |
|
102 | I2C_Heading.Heading = 0; |
- | |
103 | SerialPutString("ok\n\r"); |
- | |
104 | - | ||
105 | - | ||
106 | } |
230 | I2C_Heading.Heading = -1; |
107 | 231 | ||
108 | //-------------------------------------------------------------- |
- | |
109 | void I2C1_IRQHandler(void) |
232 | SerialPutString("ok"); |
110 | { |
233 | } |
111 | 234 | ||
112 | switch (I2C_GetLastEvent(I2C1)) |
235 | |
113 | { |
236 | //-------------------------------------------------------------- |
114 | case I2C_EVENT_MASTER_MODE_SELECT: // EV5 |
- | |
115 | Tx_Idx = 0; |
237 | void I2C1_IRQHandler(void) |
116 | Rx_Idx = 0; |
238 | { |
- | 239 | u16 status; |
|
117 | I2C_Send7bitAddress(I2C1, I2C_SLAVE_ADDRESS, I2C_Direction); |
240 | static u8 crc; |
118 | // DebugOut.Analog[16]++; |
241 | // detemine I2C State |
- | 242 | status = I2C_GetLastEvent(I2C1); |
|
119 | break; |
243 | |
120 | 244 | if(status & (I2C_FLAG_AF|I2C_FLAG_BERR)) // if an acknowledge failure or bus error occured |
|
121 | case I2C_EVENT_MASTER_MODE_SELECTED: // EV6 |
- | |
122 | // Clear EV6 by set again the PE bit |
- | |
123 | I2C1->CR |= 0x20; |
- | |
124 | if (I2C_Direction == I2C_MODE_TRANSMITTER) |
245 | { // Set and subsequently clear the STOP bit while BTF is set. |
125 | { |
246 | while(I2C_GetFlagStatus (I2C1, I2C_FLAG_BTF) != RESET) |
126 | I2C_SendData(I2C1, I2C_Command);//EV8 just after EV6 |
247 | { |
127 | } |
- | |
128 | break; |
248 | I2C_GenerateSTOP (I2C1, ENABLE); // free the bus |
- | 249 | I2C_GenerateSTOP (I2C1, DISABLE); // free the bus |
|
- | 250 | } |
|
- | 251 | I2C_State = I2C_IDLE; |
|
- | 252 | LED_GRN_OFF; |
|
- | 253 | } |
|
- | 254 | else |
|
- | 255 | { // depending on current i2c state |
|
- | 256 | switch (status) |
|
- | 257 | { |
|
- | 258 | // the start condition was initiated on the bus |
|
- | 259 | case I2C_EVENT_MASTER_MODE_SELECT: |
|
- | 260 | LED_GRN_ON; |
|
- | 261 | // update current bus state variable |
|
- | 262 | switch(I2C_Direction) |
|
- | 263 | { |
|
- | 264 | case I2C_MODE_TRANSMITTER: |
|
- | 265 | I2C_State = I2C_TX_PROGRESS; |
|
- | 266 | break; |
|
- | 267 | ||
- | 268 | case I2C_MODE_RECEIVER: |
|
- | 269 | if ((I2C_RxBuffer == NULL) || (I2C_RxBufferSize == 0)) |
|
- | 270 | { |
|
- | 271 | I2C_GenerateSTOP (I2C1, ENABLE); |
|
- | 272 | I2C_State = I2C_IDLE; |
|
- | 273 | return; |
|
- | 274 | } |
|
- | 275 | else |
|
- | 276 | { |
|
- | 277 | I2C_State = I2C_RX_PROGRESS; |
|
- | 278 | } |
|
- | 279 | break; |
|
- | 280 | ||
- | 281 | default: // invalid direction |
|
- | 282 | I2C_GenerateSTOP (I2C1, ENABLE); |
|
- | 283 | I2C_State = I2C_IDLE; |
|
- | 284 | LED_GRN_OFF; |
|
- | 285 | return; |
|
- | 286 | } |
|
- | 287 | // enable acknowledge |
|
- | 288 | I2C_AcknowledgeConfig (I2C1, ENABLE); |
|
- | 289 | // send address/direction byte on the bus |
|
- | 290 | I2C_Send7bitAddress(I2C1, I2C_SLAVE_ADDRESS, I2C_Direction); |
|
- | 291 | break; |
|
- | 292 | ||
- | 293 | // the address byte was send |
|
- | 294 | case I2C_EVENT_MASTER_MODE_SELECTED: |
|
- | 295 | // Clear EV6 by set again the PE bit |
|
- | 296 | I2C_Cmd(I2C1, ENABLE); |
|
- | 297 | // reset checksum |
|
- | 298 | crc = 0; |
|
- | 299 | switch(I2C_State) |
|
- | 300 | { |
|
- | 301 | case I2C_TX_PROGRESS: |
|
- | 302 | // send command 1st data byte (allways the command id) |
|
- | 303 | I2C_SendData(I2C1, I2C_Command); |
|
- | 304 | crc += I2C_Command; |
|
- | 305 | Tx_Idx = 0; |
|
- | 306 | // reset timeout |
|
- | 307 | I2C1_Timeout = SetDelay(500); // after 500 ms of inactivity the I2C1 bus will be reset |
|
129 | 308 | break; |
|
- | 309 | ||
- | 310 | case I2C_RX_PROGRESS: |
|
- | 311 | Rx_Idx = 0; |
|
- | 312 | break; |
|
- | 313 | ||
- | 314 | default: // unknown I2C state |
|
- | 315 | // should never happen |
|
- | 316 | I2C_GenerateSTOP (I2C1, ENABLE); |
|
- | 317 | I2C_State = I2C_IDLE; |
|
- | 318 | break; |
|
- | 319 | } |
|
- | 320 | break; |
|
- | 321 | ||
- | 322 | // the master has transmitted a byte and slave has been acknowledged |
|
- | 323 | case I2C_EVENT_MASTER_BYTE_TRANSMITTED: |
|
- | 324 | ||
- | 325 | // some bytes have to be transmitted |
|
130 | case I2C_EVENT_MASTER_BYTE_TRANSMITTED: // EV8 |
326 | if(Tx_Idx < I2C_TxBufferSize) |
- | 327 | { |
|
- | 328 | if(I2C_TxBuffer != NULL) |
|
- | 329 | { |
|
- | 330 | I2C_SendData(I2C1, I2C_TxBuffer[Tx_Idx]); |
|
- | 331 | crc += I2C_TxBuffer[Tx_Idx]; |
|
- | 332 | } |
|
- | 333 | else |
|
- | 334 | { |
|
- | 335 | I2C_SendData(I2C1, 0x00); |
|
- | 336 | } |
|
- | 337 | } |
|
- | 338 | else // the last tx buffer byte was send |
|
- | 339 | { |
|
- | 340 | // send crc byte at the end |
|
- | 341 | I2C_SendData(I2C1, crc); |
|
- | 342 | // generate stop or repeated start condition |
|
- | 343 | if ((I2C_RxBuffer != NULL) && (I2C_RxBufferSize > 0)) // is any answer byte expected? |
|
- | 344 | { |
|
- | 345 | I2C_Direction = I2C_MODE_RECEIVER; // switch to master receiver after repeated start condition |
|
- | 346 | I2C_GenerateStart(I2C1, ENABLE); // initiate repeated start condition on the bus |
|
- | 347 | } |
|
- | 348 | else |
|
- | 349 | { // stop communication |
|
- | 350 | I2C_GenerateSTOP(I2C1, ENABLE); // generate stop condition to free the bus |
|
- | 351 | I2C_State = I2C_IDLE; // ready for new actions |
|
- | 352 | LED_GRN_OFF; |
|
- | 353 | DebugOut.Analog[15]++; |
|
- | 354 | } |
|
- | 355 | } |
|
- | 356 | Tx_Idx++; |
|
- | 357 | break; |
|
- | 358 | ||
- | 359 | // the master has received a byte from the slave |
|
- | 360 | case I2C_EVENT_MASTER_BYTE_RECEIVED: |
|
- | 361 | // some bytes have to be received |
|
- | 362 | if (Rx_Idx < I2C_RxBufferSize) |
|
- | 363 | { // copy received byte from the data register to the rx-buffer |
|
- | 364 | I2C_PrimRxBuffer[Rx_Idx] = I2C_ReceiveData(I2C1); |
|
- | 365 | // update checksum |
|
- | 366 | crc += I2C_PrimRxBuffer[Rx_Idx]; |
|
- | 367 | } |
|
- | 368 | // if the last byte (crc) was received |
|
- | 369 | else if ( Rx_Idx == I2C_RxBufferSize) |
|
- | 370 | { |
|
- | 371 | // generate a STOP condition on the bus before reading data register |
|
- | 372 | I2C_GenerateSTOP(I2C1, ENABLE); |
|
- | 373 | // compare last byte with checksum |
|
- | 374 | if(crc == I2C_ReceiveData(I2C1)) |
|
- | 375 | { // copy primary rx buffer content to rx buffer if exist |
|
- | 376 | if(I2C_RxBuffer != NULL) |
|
- | 377 | { |
|
- | 378 | memcpy((u8 *)I2C_RxBuffer, (u8 *)I2C_PrimRxBuffer, I2C_RxBufferSize); |
|
- | 379 | } |
|
- | 380 | DebugOut.Analog[15]++; |
|
- | 381 | CheckI2COkay++; |
|
- | 382 | } |
|
- | 383 | else // checksum error detected |
|
- | 384 | { |
|
- | 385 | DebugOut.Analog[14]++; |
|
- | 386 | } |
|
- | 387 | I2C_State = I2C_IDLE; |
|
- | 388 | LED_GRN_OFF; |
|
- | 389 | } |
|
- | 390 | Rx_Idx++; |
|
131 | // DebugOut.Analog[17]++; |
391 | // if the 2nd last byte was received disable acknowledge for the last one |
132 | if ( Tx_Idx >= I2C_TxBufferSize ) |
- | |
133 | { |
- | |
134 | I2C_GenerateSTOP (I2C1, ENABLE); |
- | |
135 | Tx_Idx = 0; |
- | |
136 | if (I2C_RxBufferSize > 0) // wird Antwort erwartet ? |
- | |
137 | { |
- | |
138 | I2C_ReadRequest = 1; |
- | |
139 | TimerI2CReadDelay = SetDelay(10); |
- | |
140 | } |
- | |
141 | } |
- | |
142 | else |
- | |
143 | { |
- | |
144 | I2C_SendData(I2C1, I2C_TxBuffer[Tx_Idx]); |
- | |
145 | Tx_Idx++; |
- | |
146 | } |
- | |
147 | break; |
- | |
148 | - | ||
149 | case I2C_EVENT_MASTER_BYTE_RECEIVED: // EV7 |
- | |
150 | DebugOut.Analog[16]++; |
- | |
151 | //if (Rx_Idx == 1) DebugOut.Analog[19] = I2C_RxBuffer[0]; |
- | |
152 | if (Rx_Idx < I2C_RxBufferSize) |
- | |
153 | { I2C_RxBuffer[Rx_Idx] = I2C_ReceiveData(I2C1); |
- | |
154 | - | ||
155 | } else I2C_ReceiveData(I2C1); |
- | |
156 | - | ||
157 | Rx_Idx++; |
- | |
158 | if ( Rx_Idx == I2C_RxBufferSize+1 ) |
- | |
159 | { |
- | |
160 | I2C_AcknowledgeConfig (I2C1, DISABLE); |
- | |
161 | } |
- | |
162 | if ( Rx_Idx == I2C_RxBufferSize+2 ) |
392 | if ( Rx_Idx == I2C_RxBufferSize ) |
163 | { |
393 | { |
164 | I2C_GenerateSTOP(I2C1, ENABLE); |
394 | I2C_AcknowledgeConfig (I2C1, DISABLE); |
165 | if (I2C_Command == I2C_CMD_READ_HEADING) CompassUpdateActiv = 0; |
395 | } |
166 | } |
396 | break; |
- | 397 | ||
- | 398 | default: |
|
- | 399 | break; |
|
- | 400 | } |
|
- | 401 | } |
|
- | 402 | } |
|
167 | break; |
403 | //---------------------------------------------------------------- |
- | 404 | void I2C1_SendCommand(u8 command) |
|
- | 405 | { |
|
- | 406 | // If I2C transmission is in progress |
|
- | 407 | while (I2C_State != I2C_IDLE) return; // return imediatly if a transfer is still in progress |
|
- | 408 | // disable I2C IRQ to avoid read/write access to the tx/rx buffer pointers during |
|
- | 409 | // update of that buffer pointers and length |
|
- | 410 | I2C_ITConfig(I2C1, DISABLE); |
|
- | 411 | // update current command id |
|
- | 412 | I2C_Command = command; |
|
- | 413 | // set pointers to data area with respect to the command id |
|
- | 414 | switch (command) |
|
- | 415 | { |
|
- | 416 | case I2C_CMD_VERSION: |
|
- | 417 | I2C_RxBuffer = (u8 *)&MK3MAG_Version; |
|
- | 418 | I2C_RxBufferSize = sizeof(MK3MAG_Version); |
|
- | 419 | I2C_TxBuffer = NULL; |
|
- | 420 | I2C_TxBufferSize = 0; |
|
- | 421 | break; |
|
- | 422 | case I2C_CMD_WRITE_CAL: |
|
- | 423 | I2C_RxBuffer = (u8 *)&I2C_ReadCal; |
|
- | 424 | I2C_RxBufferSize = sizeof(I2C_ReadCal); |
|
- | 425 | I2C_TxBuffer = (u8 *)&I2C_WriteCal; |
|
- | 426 | I2C_TxBufferSize = sizeof(I2C_WriteCal); |
|
- | 427 | break; |
|
- | 428 | case I2C_CMD_READ_MAG: |
|
- | 429 | I2C_RxBuffer = (u8 *)&I2C_Mag; |
|
- | 430 | I2C_RxBufferSize = sizeof(I2C_Mag); |
|
- | 431 | I2C_TxBuffer = NULL; |
|
- | 432 | I2C_TxBufferSize = 0; |
|
- | 433 | break; |
|
- | 434 | case I2C_CMD_READ_HEADING: |
|
- | 435 | DebugOut.Analog[26] = I2C_Heading.Heading; |
|
- | 436 | I2C_RxBuffer = (u8 *)&I2C_Heading; |
|
- | 437 | I2C_RxBufferSize = sizeof(I2C_Heading); |
|
- | 438 | // updat atitude from spi rx buffer |
|
- | 439 | I2C_WriteAttitude.Roll = FromFlightCtrl.IntegralRoll; |
|
- | 440 | I2C_WriteAttitude.Nick = FromFlightCtrl.IntegralNick; |
|
- | 441 | I2C_TxBuffer = (u8 *)&I2C_WriteAttitude; |
|
- | 442 | I2C_TxBufferSize = sizeof(I2C_WriteAttitude); |
|
- | 443 | break; |
|
- | 444 | default: // unknown command id |
|
- | 445 | I2C_RxBuffer = NULL; |
|
- | 446 | I2C_RxBufferSize = 0; |
|
- | 447 | I2C_TxBuffer = NULL; |
|
- | 448 | I2C_TxBufferSize = 0; |
|
168 | 449 | break; |
|
- | 450 | } |
|
Line 169... | Line -... | ||
169 | default: |
- | |
170 | break; |
451 | // enable I2C IRQ again |
171 | } |
- | |
172 | } |
- | |
173 | //---------------------------------------------------------------- |
- | |
174 | void SendI2C_Command(u8 command) |
- | |
175 | { |
- | |
176 | I2C_Command = command; |
- | |
177 | //I2C_GenerateSTOP(I2C1, ENABLE); |
- | |
178 | - | ||
179 | switch (command) |
- | |
180 | { |
- | |
181 | case I2C_CMD_VERSION: |
- | |
182 | I2C_RxBuffer = (u8 *)&I2C_Version; |
- | |
183 | I2C_RxBufferSize = sizeof(I2C_Version); |
- | |
184 | I2C_TxBufferSize = 0; |
- | |
185 | break; |
- | |
186 | case I2C_CMD_WRITE_EEPROM: |
- | |
187 | I2C_RxBufferSize = 0; |
- | |
188 | I2C_TxBuffer = (u8 *)&I2C_WriteEEPROM; |
- | |
189 | I2C_TxBufferSize = sizeof(I2C_WriteEEPROM); |
- | |
190 | break; |
- | |
191 | case I2C_CMD_WRITE_CAL: |
- | |
192 | I2C_RxBufferSize = 0; |
- | |
193 | I2C_WriteCal.CalByte = CompassCalState; |
- | |
194 | I2C_TxBuffer = (u8 *)&I2C_WriteCal; |
- | |
195 | I2C_TxBufferSize = sizeof(I2C_WriteCal); |
- | |
196 | break; |
- | |
197 | case I2C_CMD_READ_EEPROM: |
- | |
198 | I2C_RxBuffer = (u8 *)&I2C_ReadEEPROM.Inhalt; |
- | |
199 | I2C_RxBufferSize = 2; |
- | |
200 | I2C_TxBuffer = (u8 *)&I2C_ReadEEPROM; |
- | |
201 | I2C_TxBufferSize = 1; |
- | |
202 | break; |
- | |
203 | case I2C_CMD_READ_MAG: |
- | |
204 | I2C_RxBuffer = (u8 *)&I2C_Mag; |
- | |
205 | I2C_RxBufferSize = sizeof(I2C_Mag); |
452 | I2C_ITConfig(I2C1, ENABLE); |
206 | I2C_TxBufferSize = 0; |
453 | // set direction to master transmitter |
207 | break; |
- | |
208 | case I2C_CMD_READ_HEADING: |
- | |
209 | CompassUpdateActiv = 1; |
- | |
210 | I2C_RxBuffer = (u8 *)&I2C_Heading; |
- | |
211 | I2C_RxBufferSize = sizeof(I2C_Heading); |
- | |
212 | I2C_TxBuffer = (u8 *)&I2C_WriteNickRoll; |
- | |
Line -... | Line 454... | ||
- | 454 | I2C_Direction = I2C_MODE_TRANSMITTER; |
|
213 | I2C_TxBufferSize = sizeof(I2C_WriteNickRoll); |
455 | // test on busy flag and clear it |
- | 456 | I2C_CheckEvent( I2C1, I2C_FLAG_BUSY ); |
|
- | 457 | // initiale start condition on the bus |
|
214 | break; |
458 | I2C_GenerateStart(I2C1, ENABLE); |
Line -... | Line 459... | ||
- | 459 | // to be continued in the I2C1_IRQHandler() above |
|
- | 460 | ||
- | 461 | ||
- | 462 | ||
- | 463 | } |
|
- | 464 | ||
- | 465 | //---------------------------------------------------------------- |
|
215 | 466 | void I2C1_GetMK3MagVersion(void) |
|
- | 467 | { |
|
- | 468 | u8 msg[20]; |
|
- | 469 | u8 repeat = 10; |
|
- | 470 | ||
- | 471 | MK3MAG_Version.Major = 0xFF; |
|
- | 472 | MK3MAG_Version.Minor = 0xFF; |
|
- | 473 | MK3MAG_Version.Patch = 0xFF; |
|
- | 474 | MK3MAG_Version.Compatible = 0xFF; |
|
- | 475 | ||
- | 476 | while ((MK3MAG_Version.Major == 0xFF) && (repeat != 0)) |
|
- | 477 | { |
|
- | 478 | I2C1_SendCommand(I2C_CMD_VERSION); |
|
- | 479 | I2C1_Timeout = SetDelay(500); |
|
Line 216... | Line 480... | ||
216 | } |
480 | while (!CheckDelay(I2C1_Timeout)) if (MK3MAG_Version.Major != 0xFF) break; |