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

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

        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

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

        GPIO_StructInit(&GPIO_InitStructure);

        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);

                while (!CheckDelay(delay));

                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;

        GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;

        GPIO_Init(GPIO2, &GPIO_InitStructure);

        // enable I2C peripherie

        SCU_APBPeriphClockConfig(__I2C1,ENABLE);

        // reset I2C peripherie

        SCU_APBPeriphReset(__I2C1,ENABLE);

        I2C_DeInit(I2C1);

        I2C_Init(I2C1, &I2C_Struct);

        I2C_TxBuffer = NULL;

        Tx_Idx = 0;

        I2C_TxBufferSize = 0;

        I2C_RxBuffer = NULL;

        Rx_Idx = 0;

        I2C_RxBufferSize = 0;

        I2C_Cmd(I2C1, ENABLE);

        I2C_ITConfig(I2C1, ENABLE);

        VIC_Config(I2C1_ITLine, VIC_IRQ , 0);

        VIC_ITCmd(I2C1_ITLine, ENABLE);

        I2C1_Timeout = SetDelay(1000);

        I2C_Heading.Heading = -1;

        I2C_GenerateSTOP(I2C1, ENABLE);

        SerialPutString("ok");

}

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

void I2C1_Deinit(void)

{

        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;

        I2C_RxBufferSize = 0;

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

                I2C_State = I2C_IDLE;

                        // the start condition was initiated on the bus

                        case I2C_EVENT_MASTER_MODE_SELECT:

                                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);

                                                        I2C_State = I2C_IDLE;

                                                        return;

                                                }

                                                else

                                                {

                                                        I2C_State = I2C_RX_PROGRESS;

                                                }

                                                break;

                                        default: // invalid direction

                                                I2C_GenerateSTOP (I2C1, ENABLE);

                                                I2C_State = I2C_IDLE;

                                                LED_GRN_OFF;

                                                return;

                                }

                                // enable acknowledge

                                I2C_AcknowledgeConfig (I2C1, ENABLE);

                                // send address/direction byte on the bus

                                I2C_Send7bitAddress(I2C1, I2C_SLAVE_ADDRESS, I2C_Direction);

                                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;

                                        // reset timeout

                                        I2C1_Timeout = SetDelay(500); // after 500 ms of inactivity the I2C1 bus will be reset

                                        break;

                                        case I2C_RX_PROGRESS:

                                        Rx_Idx = 0;

                                        break;

                                        default: // unknown I2C state

                                        // should never happen

                                        I2C_GenerateSTOP (I2C1, ENABLE);

                                        break;

                                }

                                break;

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

                        case I2C_EVENT_MASTER_BYTE_TRANSMITTED:

                                // some bytes have to be transmitted

                                if(Tx_Idx < I2C_TxBufferSize)

                                {

                                        if(I2C_TxBuffer != NULL)

                                        {

                                                I2C_SendData(I2C1, I2C_TxBuffer[Tx_Idx]);

                                                crc += I2C_TxBuffer[Tx_Idx];

                                        }

                                        else

                                        {

                                        }

                                }

                                else // the last tx buffer byte was send

                                {

                                        // send crc byte at the end

                                        I2C_SendData(I2C1, crc);

                                        // generate stop or repeated start condition

                                        if ((I2C_RxBuffer != NULL) && (I2C_RxBufferSize > 0)) // is any answer byte expected?

                                        {

                                                I2C_Direction = I2C_MODE_RECEIVER; // switch to master receiver after repeated start condition 

                                                I2C_GenerateStart(I2C1, ENABLE);   // initiate repeated start condition on the bus

                                        }

                                        else

                                        {   // stop communication

                                                I2C_GenerateSTOP(I2C1, ENABLE); // generate stop condition to free the bus

                                                I2C_State = I2C_IDLE;                   // ready for new actions

                                                LED_GRN_OFF;

                                                DebugOut.Analog[15]++;

                                        }

                                }

                                Tx_Idx++;      

                                break;

                        // the master has received a byte from the slave

                case I2C_EVENT_MASTER_BYTE_RECEIVED:

                                // 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);

                                                }

                                                DebugOut.Analog[15]++;

                                                CheckI2COkay++;

                                        }

                                        else // checksum error detected

                                        {

                                                DebugOut.Analog[14]++;

                                        }

                                        I2C_State = I2C_IDLE;

                                        LED_GRN_OFF;   

                                }

                                Rx_Idx++;

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

                                if ( Rx_Idx == I2C_RxBufferSize )

                                {

                                        I2C_AcknowledgeConfig (I2C1, DISABLE);

                                }

                                break;

                        default:

                                break;

        // If I2C transmission is in progress

        while (I2C_State != I2C_IDLE) return; // return imediatly if a transfer is still in progress

        // disable I2C IRQ to avoid read/write access to the tx/rx buffer pointers during

        // update of that buffer pointers and length

        I2C_ITConfig(I2C1, DISABLE);

        // update current command id

        // set pointers to data area with respect to the command id

        switch (command)

        {

            case I2C_CMD_VERSION:

                        I2C_RxBuffer = (u8 *)&MK3MAG_Version;

                        I2C_RxBufferSize = sizeof(MK3MAG_Version);

                        I2C_TxBuffer = NULL;

                        I2C_TxBufferSize = 0;

                        break;

                case I2C_CMD_WRITE_CAL:

                        I2C_RxBuffer = (u8 *)&I2C_ReadCal;

                        I2C_RxBufferSize = sizeof(I2C_ReadCal);

                        I2C_TxBuffer = (u8 *)&I2C_WriteCal;

                        I2C_TxBufferSize = sizeof(I2C_WriteCal);

                        break;

            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_RxBufferSize = 0;

                        I2C_TxBuffer =  NULL;

                        I2C_TxBufferSize = 0;

                        break;

        }

        // enable I2C IRQ again

        I2C_ITConfig(I2C1, ENABLE);

        // set direction to master transmitter

        I2C_Direction = I2C_MODE_TRANSMITTER;

        // test on busy flag and clear it 

        I2C_CheckEvent( I2C1, I2C_FLAG_BUSY );

        // initiale start condition on the bus 

        // to be continued in the I2C1_IRQHandler() above

}

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

void I2C1_GetMK3MagVersion(void)

        u8 msg[20];

    u8 repeat = 10;

        MK3MAG_Version.Major = 0xFF;

        MK3MAG_Version.Minor = 0xFF;

        MK3MAG_Version.Patch = 0xFF;

        MK3MAG_Version.Compatible = 0xFF;

        while ((MK3MAG_Version.Major == 0xFF)  && (repeat != 0))

        {

                I2C1_SendCommand(I2C_CMD_VERSION);     

                I2C1_Timeout = SetDelay(500);

                while (!CheckDelay(I2C1_Timeout)) if (MK3MAG_Version.Major != 0xFF) break;

                repeat--;

        }

        if (MK3MAG_Version.Major != 0xFF)

        {

                sprintf(msg, "\n\r MK3Mag V%d.%d%c", MK3MAG_Version.Major, MK3MAG_Version.Minor, 'a' + MK3MAG_Version.Patch);

                SerialPutString(msg);

                sprintf(msg, " Compatible: %d", MK3MAG_Version.Compatible);