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

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

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

        // condition and then leave the clock line high.

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

                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_IPConnected = GPIO_IPConnected_Enable;

        GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; //I2C1_CLKOUT, I2C1_DOUT

        GPIO_Init(GPIO2, &GPIO_InitStructure);

        // enable I2C peripherie

        SCU_APBPeriphClockConfig(__I2C1,ENABLE);

        SCU_APBPeriphReset(__I2C1,ENABLE);

        SCU_APBPeriphReset(__I2C1,DISABLE);

        I2C_Struct.I2C_CLKSpeed = 20000;

        I2C_Struct.I2C_OwnAddress = 0x00;

        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_GenerateSTOP(I2C1, ENABLE);

        I2C_State = I2C_IDLE;

        SerialPutString("ok");

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

{

        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_RxBuffer = NULL;

        Rx_Idx = 0;

        u16 status;

        status = I2C_GetLastEvent(I2C1);

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

                }

                I2C_State = I2C_IDLE;

                LED_GRN_OFF;

        }

        else

        {       // depending on current i2c state

                switch (status)

                {

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

                                        case I2C_RX_PROGRESS:

                                        Rx_Idx = 0;

                                        break;

                                        default: // unknown I2C state

                                        // should never happen

                                        I2C_GenerateSTOP (I2C1, ENABLE);

                                        I2C_State = I2C_IDLE;

                                        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(I2C_TxBuffer != NULL)

                                        {

                                                I2C_SendData(I2C1, I2C_TxBuffer[Tx_Idx]);

                                                crc += I2C_TxBuffer[Tx_Idx];

                                        }

                                        else

                                        {

                                                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

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

                        default:

                                break;

                }

        }

}

void I2C1_SendCommand(u8 command)

{

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

        I2C_Command = command;

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

        }

        I2C_Direction = I2C_MODE_TRANSMITTER;

        I2C_CheckEvent( I2C1, I2C_FLAG_BUSY );

        // initiale start condition on the bus 

        // to be continued in the I2C1_IRQHandler() above

}

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

{

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