Subversion Repositories NaviCtrl

#include <stdlib.h>

#include <string.h>

#include "91x_lib.h"

#include "i2c.h"

#include "uart1.h"

#include "timer.h"

#include "led.h"

#include "spi_slave.h"

volatile I2C_State_t I2C_State = I2C_OFF;

// rxbuffer

volatile u8 I2C_RxBufferSize;

volatile u8 *I2C_RxBuffer;

volatile u8 Rx_Idx = 0;

// txbuffer

volatile u8 I2C_TxBufferSize;

volatile u8 *I2C_TxBuffer;

volatile u8 Tx_Idx = 0;

volatile u8 I2C_Direction;

volatile u8 I2C_Command;

volatile I2C_Heading_t                  I2C_Heading;

volatile I2C_WriteAttitude_t    I2C_WriteAttitude;

volatile I2C_Mag_t                              I2C_Mag;

volatile I2C_Version_t                  MK3MAG_Version;

volatile I2C_Cal_t                              I2C_WriteCal;

volatile I2C_Cal_t                              I2C_ReadCal;

volatile u8 I2C_ReadRequest = 0;

volatile u32 I2C1_Timeout = 0;

volatile u32 CheckI2COkay = 0;

volatile u8 I2C_PrimRxBuffer[10]; // must be larger than any of the secondary rx buffers

        GPIO_InitTypeDef  GPIO_InitStructure;

        SerialPutString("\r\n I2C init...");

        // enable Port 2 peripherie

        SCU_APBPeriphClockConfig(__GPIO2, ENABLE);

        // disable a reset state

        SCU_APBPeriphReset(__GPIO2, DISABLE);

        // free a busy bus

        // At switch on I2C devices can get in a state where they

        // are still waiting for a command due to all the bus lines bouncing

        // around at startup have started clocking data into the device(s).

        // Enable the ports as open collector port outputs

        // and clock out at least 9 SCL pulses, then generate a stop

        // condition and then leave the clock line high.

        // configure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT to normal port operation

        GPIO_StructInit(&GPIO_InitStructure);

        GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;

        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;

        GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;

        GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Disable;

        GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt1;

        GPIO_Init(GPIO2, &GPIO_InitStructure);

        u8 i;

        u32 delay;

        // set SCL high and then SDA to low (start condition)

        GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);

        delay = SetDelay(1);

        while (!CheckDelay(delay));

        GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_RESET);

        // toggle SCL at least 10 times from high to low to high

        for(i = 0; i < 10; i++)

        {

                delay = SetDelay(1);

                while (!CheckDelay(delay));

                GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_RESET);

                delay = SetDelay(1);

                GPIO_WriteBit(GPIO2, GPIO_Pin_2, Bit_SET);

        }

        delay = SetDelay(1);

        while (!CheckDelay(delay));

        // create stop condition setting SDA HIGH when SCL is HIGH

        GPIO_WriteBit(GPIO2, GPIO_Pin_3, Bit_SET);

        // reconfigure P2.2->I2C1_CLKOUT and P2.3->I2C1_DOUT

        GPIO_StructInit(&GPIO_InitStructure);

        GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;

        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;

        GPIO_InitStructure.GPIO_Type = GPIO_Type_OpenCollector;

        SCU_APBPeriphClockConfig(__I2C1,ENABLE);

        // reset I2C peripherie

        I2C_Struct.I2C_GeneralCall = I2C_GeneralCall_Disable;

        I2C_Struct.I2C_Ack = I2C_Ack_Enable;

        I2C_Struct.I2C_CLKSpeed = 20000;

        I2C_Struct.I2C_OwnAddress = 0x00;

        I2C_Init(I2C1, &I2C_Struct);

        I2C_TxBuffer = NULL;

        Tx_Idx = 0;

        I2C_RxBufferSize = 0;

        I2C_Cmd(I2C1, ENABLE);

        I2C_ITConfig(I2C1, ENABLE);

        VIC_ITCmd(I2C1_ITLine, ENABLE);

        I2C1_Timeout = SetDelay(1000);

        I2C_Heading.Heading = -1;

        I2C_GenerateSTOP(I2C1, ENABLE);

        I2C_State = I2C_IDLE;

        SerialPutString("ok");

}

//--------------------------------------------------------------

void I2C1_Deinit(void)

{

        GPIO_InitTypeDef  GPIO_InitStructure;  

        SerialPutString("\r\n I2C deinit...");

        I2C_GenerateStart(I2C1, DISABLE);

        I2C_GenerateSTOP(I2C1, ENABLE);

        VIC_ITCmd(I2C1_ITLine, DISABLE);

        I2C_ITConfig(I2C1, DISABLE);

        I2C_Cmd(I2C1, DISABLE);

        I2C_DeInit(I2C1);

        SCU_APBPeriphClockConfig(__I2C1, DISABLE);

        // set ports to input

        SCU_APBPeriphClockConfig(__GPIO2, ENABLE);

        GPIO_StructInit(&GPIO_InitStructure);

        GPIO_InitStructure.GPIO_Direction =     GPIO_PinInput;

    GPIO_InitStructure.GPIO_Pin =                       GPIO_Pin_2 | GPIO_Pin_3;

    GPIO_InitStructure.GPIO_Type =                      GPIO_Type_PushPull;

        GPIO_InitStructure.GPIO_IPConnected =   GPIO_IPConnected_Disable;

    GPIO_InitStructure.GPIO_Alternate =         GPIO_InputAlt1;

    GPIO_Init(GPIO2, &GPIO_InitStructure);

        I2C_TxBuffer = NULL;

        Tx_Idx = 0;

        I2C_TxBufferSize = 0;

        Rx_Idx = 0;

        I2C1_Timeout = 0;

        I2C_Heading.Heading = -1;

        SerialPutString("ok");

}

//--------------------------------------------------------------

void I2C1_IRQHandler(void)

{

        u16 status;

        static u8 crc;

        // detemine I2C State

        status = I2C_GetLastEvent(I2C1);

        if(status & (I2C_FLAG_AF|I2C_FLAG_BERR))  // if an acknowledge failure or bus error occured

        {   // Set and subsequently clear the STOP bit while BTF is set.

                while(I2C_GetFlagStatus (I2C1, I2C_FLAG_BTF) != RESET)

                {

                        I2C_GenerateSTOP (I2C1, ENABLE); // free the bus

                        I2C_GenerateSTOP (I2C1, DISABLE); // free the bus

                }

                I2C_State = I2C_IDLE;

                LED_GRN_OFF;

        }

        else

        {       // depending on current i2c state

                {

                                LED_GRN_ON;

                                // update current bus state variable

                                switch(I2C_Direction)

                                {

                                        case I2C_MODE_TRANSMITTER:

                                                I2C_State = I2C_TX_PROGRESS;

                                                break;

                                        case I2C_MODE_RECEIVER:

                                                if ((I2C_RxBuffer == NULL) || (I2C_RxBufferSize == 0))

                                                {

                                                        I2C_GenerateSTOP (I2C1, ENABLE);

                                                }

                                                else

                                                {

                                                        I2C_State = I2C_RX_PROGRESS;

                                                LED_GRN_OFF;

                                                return;

                                I2C_AcknowledgeConfig (I2C1, ENABLE);

                                // send address/direction byte on the bus

                                break;

                        // the address byte was send

                        case I2C_EVENT_MASTER_MODE_SELECTED:

                                // Clear EV6 by set again the PE bit

                                I2C_Cmd(I2C1, ENABLE);

                                // reset checksum

                                crc = 0;

                                switch(I2C_State)

                                {

                                        case I2C_TX_PROGRESS:

                                        // send command 1st data byte (allways the command id) 

                                        I2C_SendData(I2C1, I2C_Command);

                                        crc += I2C_Command;

                                        Tx_Idx = 0;

                                        break;

                                        case I2C_RX_PROGRESS:

                        // the master has transmitted a byte and slave has been acknowledged

                        case I2C_EVENT_MASTER_BYTE_TRANSMITTED:

                                // some bytes have to be transmitted

                                {

                                        if(I2C_TxBuffer != NULL)

                                        {

                                                I2C_SendData(I2C1, I2C_TxBuffer[Tx_Idx]);

                                                crc += I2C_TxBuffer[Tx_Idx];

                                        }

                                        {

                                                I2C_SendData(I2C1, 0x00);

                                        }

                                }

                                else // the last tx buffer byte was send

                                {

                                        // send crc byte at the end

                                        I2C_SendData(I2C1, crc);

                                        // generate stop or repeated start condition

                                        {

                                                DebugOut.Analog[15]++;

                                Tx_Idx++;      

                        // the master has received a byte from the slave

                                // some bytes have to be received

                                if (Rx_Idx < I2C_RxBufferSize)

                                {       // copy received byte  from the data register to the rx-buffer

                                        I2C_PrimRxBuffer[Rx_Idx] = I2C_ReceiveData(I2C1);

                                        // update checksum

                                        crc += I2C_PrimRxBuffer[Rx_Idx];

                                }

                                // if the last byte (crc) was received

                                else if ( Rx_Idx == I2C_RxBufferSize)

                                {

                                        // generate a STOP condition on the bus before reading data register

                                        I2C_GenerateSTOP(I2C1, ENABLE);

                                        // compare last byte with checksum

                                        if(crc == I2C_ReceiveData(I2C1))

                                        {       // copy primary rx buffer content to rx buffer if exist

                                                if(I2C_RxBuffer != NULL)

                                                {

                                                        memcpy((u8 *)I2C_RxBuffer, (u8 *)I2C_PrimRxBuffer, I2C_RxBufferSize);

                                                }

                                        }

                                Rx_Idx++;

                                // if the 2nd last byte was received disable acknowledge for the last one

                                if ( Rx_Idx == I2C_RxBufferSize )

                                {

                                        I2C_AcknowledgeConfig (I2C1, DISABLE);

                                }

//----------------------------------------------------------------

        {

                case I2C_CMD_WRITE_CAL:

                        I2C_RxBuffer = (u8 *)&I2C_ReadCal;

                        I2C_RxBufferSize = sizeof(I2C_ReadCal);

            case I2C_CMD_READ_MAG:

                        I2C_RxBuffer = (u8 *)&I2C_Mag;

                        I2C_RxBufferSize = sizeof(I2C_Mag);

                        I2C_TxBuffer = NULL;

                        I2C_TxBufferSize = 0;

                        break;

            case I2C_CMD_READ_HEADING:

                        DebugOut.Analog[26] = I2C_Heading.Heading;

                        I2C_RxBuffer = (u8 *)&I2C_Heading;

                        I2C_RxBufferSize = sizeof(I2C_Heading);

                        // updat atitude from spi rx buffer

                        I2C_WriteAttitude.Roll = FromFlightCtrl.IntegralRoll;

                        I2C_WriteAttitude.Nick = FromFlightCtrl.IntegralNick;

                        I2C_TxBuffer =  (u8 *)&I2C_WriteAttitude;

                        I2C_TxBufferSize = sizeof(I2C_WriteAttitude);

                        break;

                default: // unknown command id

                        I2C_RxBuffer = NULL;

                        I2C_TxBufferSize = 0;

        // set direction to master transmitter

        I2C_Direction = I2C_MODE_TRANSMITTER;

        // initiale start condition on the bus 

        I2C_GenerateStart(I2C1, ENABLE);

}

//----------------------------------------------------------------

void I2C1_GetMK3MagVersion(void)

{

        u8 msg[20];

    u8 repeat = 10;

        MK3MAG_Version.Major = 0xFF;

        MK3MAG_Version.Minor = 0xFF;