STM32模拟IIC通信方式参考源码

利用STM32的硬件平台实现的IIC模拟通信，这里实现了两路IIC接口，可以选择。

bsp_iic.c

#include "bsp_iic.h"


static void IIC_Init(E_I2cChn e_i2cChn)
{
    uint16_t u16SDAPin, u16SCLPin;
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(    RCC_APB2Periph_GPIOB, ENABLE );

    if( e_i2cChn_RhTemp == e_i2cChn)
    {
        u16SDAPin = GPIO_Pin_7;
        u16SCLPin = GPIO_Pin_6;
    }

    else
    {
        u16SDAPin = GPIO_Pin_11;
        u16SCLPin = GPIO_Pin_10;
    }

    GPIO_InitStructure.GPIO_Pin = u16SDAPin | u16SCLPin;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    IIC_SCL(e_i2cChn, 1);
    IIC_SDA(e_i2cChn, 1);
}


static void IIC_Start(E_I2cChn e_i2cChn)
{
    SDA_OUT(e_i2cChn);
    IIC_SDA(e_i2cChn, 1);
    IIC_SCL(e_i2cChn, 1);

    delay_us(4);
     IIC_SDA(e_i2cChn, 0); //START:when CLK is high,DATA change form high to low

    delay_us(4);
    IIC_SCL(e_i2cChn, 0);
}


static void IIC_Stop(E_I2cChn e_i2cChn)
{
    SDA_OUT(e_i2cChn);
    IIC_SCL(e_i2cChn, 0);
    IIC_SDA(e_i2cChn, 0);//STOP:when CLK is high DATA change form low to high

     delay_us(4);
    IIC_SCL(e_i2cChn, 1);
    IIC_SDA(e_i2cChn, 1);

    delay_us(4);
}


// 等待应答信号到来 等待应答信号到来
// 返回值： 0，接收应答失败
// 1，接受应答成功
static etError IIC_receivedAck(E_I2cChn e_i2cChn)
{
    uint8_t ucErrTime = 0;
    SDA_IN(e_i2cChn);
    IIC_SDA(e_i2cChn, 1);
    delay_us(1);

    IIC_SCL(e_i2cChn, 1);
    delay_us(1);

    while(READ_SDA(e_i2cChn))
    {
        ucErrTime++;
        if(ucErrTime > 250)
        {
            IIC_Stop(e_i2cChn);
            return ACK_ERROR;
        }
    }
    IIC_SCL(e_i2cChn, 0);
    return NO_ERROR;
}

/* ACK: SDA low level */
static void IIC_sendAck(E_I2cChn e_i2cChn)
{
    IIC_SCL(e_i2cChn, 0);
    SDA_OUT(e_i2cChn);

    IIC_SDA(e_i2cChn, 0);
    delay_us(2);

    IIC_SCL(e_i2cChn, 1);
    delay_us(2);

    IIC_SCL(e_i2cChn, 0);
}

/* no ack: SDA high level */
static void IIC_sendNAck(E_I2cChn e_i2cChn)
{
    IIC_SCL(e_i2cChn, 0);
    SDA_OUT(e_i2cChn);

    IIC_SDA(e_i2cChn, 1);
    delay_us(2);

    IIC_SCL(e_i2cChn, 1);
    delay_us(2);

    IIC_SCL(e_i2cChn, 0);
}


static etError IIC_Send_Byte(E_I2cChn e_i2cChn, uint8_t u8SendByte)
{
    etError error;
    uint8_t i;
    SDA_OUT(e_i2cChn);
    IIC_SCL(e_i2cChn, 0); // scl = low level, to enable data transimit in IIC bus.

    for(i = 0; i < 8; i ++)
    {
        /* send bits via IIC bus */
        IIC_SDA(e_i2cChn, ((u8SendByte & 0x80) >> 7));
        u8SendByte <<= 1;
        delay_us(2);

        IIC_SCL(e_i2cChn, 1);
        delay_us(2);

        IIC_SCL(e_i2cChn, 0);
        delay_us(2);
    }


    /**
     * check whether received ACK from slave device after sending command to slave device.
     * if received ACK, indicate NO_ERROR; else indicate error.
     **/
    if(IIC_receivedAck(e_i2cChn) == NO_ERROR)
    {
        error = NO_ERROR;
    }
    else
        error = ACK_ERROR;

    return error;
}



/**
* etAck: ack signal.
*/
static uint8_t IIC_Read_Byte(E_I2cChn e_i2cChn, etI2cAck etAck)
{
    uint8_t i = 0, receive = 0;

    SDA_IN(e_i2cChn);
    for(i = 0; i < 8; i++)
    {
        IIC_SCL(e_i2cChn, 0);
        delay_us(2);

        IIC_SCL(e_i2cChn, 1);
        receive <<= 1;

        if(READ_SDA(e_i2cChn))
            receive++;
        delay_us(2);
    }

    /**
     * master read one byte from slave device, then send ACK/nACK signal to slave device
     * to enable continously sending command to slave(sending ACK) or stop commuincation(sending nACK).
     */
    if (etAck == ACK)
        IIC_sendAck(e_i2cChn);
    else
        IIC_sendNAck(e_i2cChn);
    return receive;
}


const T_IICOpera g_tIICOpera = {

    IIC_Init,

    IIC_Start,
    IIC_Stop,

    /* master send/read byte to/from slave */
    IIC_Send_Byte,
    IIC_Read_Byte,
};

bsp_iic.h

#ifndef _BSP_IIC_H
#define _BSP_IIC_H

#include "bsp_SysConfig.h"


typedef enum E_I2cChn{

    e_i2cChn_RhTemp = 0,
    e_i2cChn_Pressure = 1,
}E_I2cChn;


// I2C acknowledge
typedef enum{
    ACK = 0,
    NACK = 1,
}etI2cAck;


#if 1
static __INLINE void SDA_IN(E_I2cChn eIICChn)
{
    if(eIICChn == e_i2cChn_RhTemp)
    {
        GPIOB->CRL &=~ (((uint32_t)0x0f) << 28);
        GPIOB->CRL |= ((uint32_t)8) << 28;
    }
    else
    {
        GPIOB->CRH &=~ (((uint32_t)0x0f) << 12);
        GPIOB->CRH |= ((uint32_t)8) << 12;
    }
}


static  __INLINE  void SDA_OUT(E_I2cChn eIICChn)
{
    if(eIICChn == e_i2cChn_RhTemp){
        GPIOB->CRL &=~ (((uint32_t)0x0f) << 28);
        GPIOB->CRL |= ((uint32_t)3) << 28;
    }
    else
    {
        GPIOB->CRH &=~ (((uint32_t)0x0f) << 12);
        GPIOB->CRH |= ((uint32_t)3) << 12;
    }
}


static  __INLINE  void IIC_SCL(E_I2cChn eIICChn, uint8_t value)
{
    if(eIICChn == e_i2cChn_RhTemp)
    {
        PBout(6) = value;
    }
    else
    {
        PBout(10) = value;
    }
}


static  __INLINE void IIC_SDA(E_I2cChn eIICChn, uint8_t value)
{
    if(eIICChn == e_i2cChn_RhTemp)
    {
        PBout(7)= value;
    }
    else
    {
        PBout(11) = value;
    }
}

static  __INLINE  uint8_t READ_SDA(E_I2cChn e_i2cChn)
{
    volatile uint8_t u8SDAbit;
    if(e_i2cChn == e_i2cChn_RhTemp)
    {
        u8SDAbit = PBin(7);
    }
    else
    {
        u8SDAbit = PBin(11);
    }
    return u8SDAbit;
}

#else
// IO方向设置
//
#define SDA_IN() {GPIOC->CRH&=0XFFFF0FFF;GPIOC->CRH|=8<<12;}
#define SDA_OUT() {GPIOC->CRH&=0XFFFF0FFF;GPIOC->CRH|=3<<12;}

//IO操作函数
#define IIC_SCL    PCout(12) //SCL
#define IIC_SDA    PCout(11) //SDA
#define READ_SDA   PCin(11) //输入SDA

#endif


static __INLINE void delay_us(uint16_t t)
{
    uint16_t x, y;
    for(x = t; x >0; x --)
        for(y = 650; y >0 ; y--);
}



typedef struct T_IICOpera{

    void (*init)(E_I2cChn e_i2cChn);

    void (*start)(E_I2cChn e_i2cChn);
    void (*stop)(E_I2cChn e_i2cChn);

    etError (*sendByte)(E_I2cChn e_i2cChn, uint8_t u8Byte);
    uint8_t (*readByte)(E_I2cChn e_i2cChn, etI2cAck etAck);

}T_IICOpera;



extern const T_IICOpera g_tIICOpera;



#endif /* _BSP_IIC_H */