i2c.c

Go to the documentation of this file.

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/*----- Header-Files -------------------------------------------------------*/
#include <stm32f4xx.h>              /* Processor STM32F407IG                */
#include <carme.h>                  /* CARME Module                         */
#include <i2c.h>

/*----- Macros -------------------------------------------------------------*/
#define TIMEOUT_MAX         0x3000      
/*----- Data types ---------------------------------------------------------*/

/*----- Function prototypes ------------------------------------------------*/
static void CARME_I2C_Settings(I2C_TypeDef *I2Cx);
static ERROR_CODES CARME_I2C_Timeout(I2C_TypeDef* I2Cx);

/*----- Data ---------------------------------------------------------------*/
static CARME_Port_Pin_t CARME_I2C_Port_Pin[] = {
    /* CARME I2C Board */
    { GPIOH, GPIO_Pin_4, GPIO_Mode_AF, GPIO_AF_I2C2 },  
    { GPIOH, GPIO_Pin_5, GPIO_Mode_AF, GPIO_AF_I2C2 },   
    /* CARME I2C Audio Codec */
    { GPIOH, GPIO_Pin_7, GPIO_Mode_AF, GPIO_AF_I2C3 },  
    { GPIOH, GPIO_Pin_8, GPIO_Mode_AF, GPIO_AF_I2C3 }   
};

static I2C_InitTypeDef I2C_InitStruct[2];

/*----- Implementation -----------------------------------------------------*/
void CARME_I2C_Init(I2C_TypeDef *I2Cx) {

    GPIO_InitTypeDef GPIO_InitStruct;

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C3, ENABLE);

    /* Configure the GPIO */
    GPIO_StructInit(&GPIO_InitStruct);
    GPIO_InitStruct.GPIO_Speed = GPIO_Fast_Speed;
    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_OD;
    CARME_GPIO_Init(CARME_I2C_Port_Pin, &GPIO_InitStruct,
            sizeof(CARME_I2C_Port_Pin) / sizeof(CARME_Port_Pin_t));

    /* Configure the I2C */
    if (I2Cx == CARME_I2C_BOARD ) {

        I2C_StructInit(&I2C_InitStruct[0]);
        I2C_InitStruct[0].I2C_ClockSpeed = CARME_I2C_SPEED;
        I2C_InitStruct[0].I2C_OwnAddress1 = CARME_I2C_ADDR_BOARD;
        I2C_InitStruct[0].I2C_Ack = I2C_Ack_Enable;
    } else if (I2Cx == CARME_I2C_AUDIO ) {

        I2C_StructInit(&I2C_InitStruct[1]);
        I2C_InitStruct[1].I2C_ClockSpeed = CARME_I2C_SPEED;
        I2C_InitStruct[1].I2C_OwnAddress1 = CARME_I2C_ADDR_AUDIO;
        I2C_InitStruct[1].I2C_Ack = I2C_Ack_Enable;
    }
    CARME_I2C_Settings(I2Cx);
}

static void CARME_I2C_Settings(I2C_TypeDef *I2Cx) {

    uint8_t i;

    if (I2Cx == CARME_I2C_BOARD ) {
        I2C_Cmd(CARME_I2C_BOARD, DISABLE);
        I2C_DeInit(CARME_I2C_BOARD );
        I2C_Init(I2Cx, &I2C_InitStruct[0]);
        I2C_Cmd(I2Cx, ENABLE);
    } else if (I2Cx == CARME_I2C_AUDIO ) {
        I2C_Cmd(CARME_I2C_AUDIO, DISABLE);
        I2C_DeInit(CARME_I2C_AUDIO );
        I2C_Init(I2Cx, &I2C_InitStruct[1]);
        I2C_Cmd(I2Cx, ENABLE);
    }

    i = 0xFF;
    while (i--)
        /* Wait until hardware is running */
        ;
}

static ERROR_CODES CARME_I2C_Timeout(I2C_TypeDef* I2Cx) {

    I2C_GenerateSTOP(I2Cx, ENABLE);
    I2C_SoftwareResetCmd(I2Cx, ENABLE);
    I2C_SoftwareResetCmd(I2Cx, DISABLE);
    CARME_I2C_Settings(I2Cx);

    return CARME_ERROR_I2C_TIMEOUT;
}

ERROR_CODES CARME_I2C_Write(I2C_TypeDef *I2Cx, uint8_t addr, uint16_t reg,
        uint8_t twoByte, uint8_t *pdata, uint16_t count) {

    uint32_t timeout = TIMEOUT_MAX;
    uint16_t i;

    while (I2C_GetFlagStatus(I2Cx, I2C_FLAG_BUSY )) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    I2C_GenerateSTART(I2Cx, ENABLE);
    timeout = TIMEOUT_MAX;
    while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT )) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    I2C_Send7bitAddress(I2Cx, addr, I2C_Direction_Transmitter );
    timeout = TIMEOUT_MAX;
    while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED )) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    if (twoByte == 1) {
        I2C_SendData(I2Cx, (uint8_t) (reg >> 8));
        timeout = TIMEOUT_MAX;
        while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTING )) {
            if (--timeout == 0) {
                return CARME_I2C_Timeout(I2Cx);
            }
        }

        I2C_SendData(I2Cx, (uint8_t) reg);
        timeout = TIMEOUT_MAX;
        while (!I2C_GetFlagStatus(I2Cx, I2C_FLAG_BTF )) {
            if (--timeout == 0) {
                CARME_I2C_Timeout(I2Cx);
            }
        }
    } else {
        I2C_SendData(I2Cx, (uint8_t) reg);
        timeout = TIMEOUT_MAX;
        while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTING )) {
            if (--timeout == 0) {
                return CARME_I2C_Timeout(I2Cx);
            }
        }
    }

    for (i = 0; i < count; i++) {
        I2C_SendData(I2Cx, pdata[i]);
        timeout = TIMEOUT_MAX;
        while (!I2C_GetFlagStatus(I2Cx, I2C_FLAG_BTF )) {
            if (--timeout == 0) {
                CARME_I2C_Timeout(I2Cx);
            }
        }
    }

    I2C_GenerateSTOP(I2Cx, ENABLE);
    return CARME_NO_ERROR;
}

ERROR_CODES CARME_I2C_Read(I2C_TypeDef *I2Cx, uint8_t addr, uint16_t reg,
        uint8_t twoByte, uint8_t *pdata, uint16_t count) {

    uint32_t timeout = TIMEOUT_MAX;
    uint16_t i;

    while (I2C_GetFlagStatus(I2Cx, I2C_FLAG_BUSY )) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    I2C_GenerateSTART(I2Cx, ENABLE);
    timeout = TIMEOUT_MAX;
    while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT )) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    I2C_Send7bitAddress(I2Cx, addr, I2C_Direction_Transmitter );
    timeout = TIMEOUT_MAX;
    while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED )) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    if (twoByte == 1) {
        I2C_SendData(I2Cx, (uint8_t) (reg >> 8));
        timeout = TIMEOUT_MAX;
        while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTING )) {
            if (--timeout == 0) {
                return CARME_I2C_Timeout(I2Cx);
            }
        }

        I2C_SendData(I2Cx, (uint8_t) reg);
        timeout = TIMEOUT_MAX;
        while (!I2C_GetFlagStatus(I2Cx, I2C_FLAG_BTF )) {
            if (--timeout == 0) {
                CARME_I2C_Timeout(I2Cx);
            }
        }
    } else {
        I2C_SendData(I2Cx, (uint8_t) reg);
        timeout = TIMEOUT_MAX;
        while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTING )) {
            if (--timeout == 0) {
                return CARME_I2C_Timeout(I2Cx);
            }
        }
    }

    I2C_GenerateSTART(I2Cx, ENABLE);
    timeout = TIMEOUT_MAX;
    while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT )) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    I2C_Send7bitAddress(I2Cx, addr, I2C_Direction_Receiver );
    timeout = TIMEOUT_MAX;
    while (I2C_GetFlagStatus(I2Cx, I2C_FLAG_ADDR ) == RESET) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    for (i = 0; i < count - 1; i++) {
        timeout = TIMEOUT_MAX;
        while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_RECEIVED )) {
            if (--timeout == 0) {
                return CARME_I2C_Timeout(I2Cx);
            }
        }
        pdata[i] = I2C_ReceiveData(I2Cx);
    }

    I2C_AcknowledgeConfig(I2Cx, DISABLE);
    (void) I2Cx->SR2;

    I2C_GenerateSTOP(I2Cx, ENABLE);
    timeout = TIMEOUT_MAX;
    while (I2C_GetFlagStatus(I2Cx, I2C_FLAG_RXNE ) == RESET) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    pdata[count - 1] = I2C_ReceiveData(I2Cx);
    timeout = TIMEOUT_MAX;
    while (I2Cx->CR1 & I2C_CR1_STOP ) {
        if (--timeout == 0) {
            return CARME_I2C_Timeout(I2Cx);
        }
    }

    I2C_AcknowledgeConfig(I2Cx, ENABLE);
    I2C_ClearFlag(I2Cx, I2C_FLAG_AF );

    return CARME_NO_ERROR;
}

#ifdef __cplusplus
}
#endif /* __cplusplus */