软件模拟I2C从机

2018-09-12

1. I2C总线介绍
2. I2C硬件接口
3. I2C协议介绍
4. I2C从机软件实现思路
5. I2C从机代码

工作的第一个项目，就是关于i2c协议的，之前在学校的时候，用过软件模拟i2c，但是都是模拟i2c主机的，没有接触过模拟从机的。想着应该不会太难吧，不就是操作2根线吗？但是在实际的操作中却让我大吃苦头。下面介绍一下具体的过程吧！

1. I2C总线介绍#

在消费者电子电讯和工业电子中看上去不相关的设计里经常有很多相似的地方例如几乎每个系统都包括：

一些智能控制，通常是一个单片的微控制器
通用电路，例如LCD驱动、远程I/O口、RAM、EEPROM或数据转换器
面向应用的电路，比如音频拨号电话的DTMF发生器等

为了使这些相似之处对系统设计者和器件厂商都得益，而且使硬件效益最大，电路最简单，Philips公司开发了一个简单的双向两线总线，实现有效的IC之间控制。这个总线就成为Inter IC或I2C总线。
下面是I2C总线的一些特征：

只要求两条总线线路；一条串行数据线SDA，一条串行时钟线SCL
每个连接到总线的器件都可以通过唯一的地址和一直存在的简单的主机/从机关系软件设定地址，主机可以作为主机发送器或主机接收器
它是一个真正的多主机总线，如果两个或更多主机同时初始化数据传输可以通过冲突检测和仲裁防止数据被破坏
串行的8位双向数据传输位速率在标准模式下可达100kbit/s，快速模式下可达400kbit/s，高速模式下可达3.4Mbit/s
片上的滤波器可以滤去总线数据线上的毛刺波，保证数据完整
连接到相同总线的IC数量只受到总线的最大电容400pF限制

2. I2C硬件接口#

I2C一共有2根线：SCL时钟线、SDA数据线。
其标准的与从机设备连接的图片如图所示：

i2c硬件连接图

从图中可以看到，i2c的SCL和SDA都通过上拉电阻连接到+VDD，而连接在总线上的器件采用开漏输出的方式，该方式只能输出低电平，浮空状态为高阻态，必须通过外部的上拉电阻把总线电平拉高，所以i2c总线空闲时，总线电平为高电平。

3. I2C协议介绍#

I2C的协议，说白了就是规定数据如何传输的，其时序图如下图所示。

i2c时序图
从上图中可以看到I2C通讯中关键的几点：

在SCL高电平时，SDA出现下降沿，即为I2C的start信号。可以理解为跳入坑中，开始通信。
在数据传输中，SDA线上的数据在SCL为高电平时必须保持稳定，只有在SCL为低电平时，SDA线上的数据才允许改变。
发送到SDA线上的每个字节必须为8位，首先传输的是数据的最高位（MSB）。
在主机向从机发送地址时，若是该地址和从机地址相同，则从机应拉低SDA总线，发送ACK信号。
在SCL为高电平时，SDA出现上升沿，即为I2C的STOP信号。可以理解为跳出坑外，停止通信。
SCL信号是有主机控制的，SDA的控制权由主机和从机分时控制。

理解了以上几点，那么I2C的通讯协议基本是掌握了。下面这两幅图是I2C主机写从机和读从机的总线控制的示意图。
第一幅图为主机向从机写数据的总线控制示意图，写数据时，传输方向未发生变化。
i2c_3
第二幅图为主机读从机数据的总线控制示意图，在读数据时，主机先向从机发送地址，然后从机向主机发送数据，传输方向发生变化。
i2c_4

4. I2C从机软件实现思路#

在使用STM32模拟I2C从机时，查阅了很多关于模拟从机的资料，很多人说使用中断的方式可能无法采集高速I2C通信时的SCL信号，但是我在TI的一个文档中找到了使用软件模拟I2C从机即是使用中断实现的，TI使用两块MSP430单片机，一块作为I2C的主机，另一块作为从机。TI在设计文档中这么写道：

In the software slave I2C example code, MCLK frequency is set at 8 MHz. With 8-MHz MCLK, software slave I2C can achieve 100-kHz SCL clock frequency using assembly code and 43-kHz SCL clock frequency using C code. Higher SCL clock frequency can be achieved with higher frequency MCLK. The FRAM memory size for the C code and the assembly code is different.

即以8MHZ的主时钟，以汇编写得到代码，从机可以实现100kHZ的SCL时钟频率，以C语言写的代码，可以实现43KHZ的SCL时钟频率。

所以，对于72MHZ时钟频率的STM32单片机来说，使用中断应该可以实现快速的I2C通讯。下面就介绍一下TI使用中断实现软件模拟I2C从机的思路。
首先，TI使用了SDA和SCL两个中断，在中断中又使用状态机的方法，实现对I2C通信状态的分解。

SDA中断	判断START状态和STOP状态
SCL中断	根据SCL上升沿和下降沿中断，进入I2C_State下，处理不同的任务

其分为14个不同的状态，下图为其14个状态及每种状态的描述。
i2c_state

这14个状态把I2C通讯的发送、接收等各种情况全部包括，构成了一个状态机。
i2c_state_machine

这样的实现比较复杂，代码逻辑也比较繁琐，但是它包含了i2c通信的各种情况，相对其他的实现方式，相对较好。

5. I2C从机代码#

//iicslave.c

#include "iicslave.h"

#define I2COA 0x0A               // Slave address
//define variable
unsigned char ram_data[16];
static unsigned char i2c_data = 0;
unsigned int I2C_state = 0;
unsigned char cnt_2to6 = 0;
unsigned char cnt_2to8 = 0;
unsigned int RW_flag = 0;
volatile unsigned char ram_cnt = 0;
unsigned char cnt = 0;


void InitBuffer(void)
{
    unsigned char i;
    for (i = 0; i < 16; i++)
    {
        ram_data[i] = 16-i;
    }
}

// Set SCL and SDA to inputs
// SDA interrupts on high-to-low transition
// SCL interrupts on low-to-high transition
// initially, just SDA interrupt is set
void INIT_PORT(void)
{
//    GPIO_InitTypeDef GPIO_InitStructure;//定义结构体

    NVIC_InitTypeDef NVIC_InitStructure;

    EXTI_InitTypeDef EXTI_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);//打开复用时钟

    RCC_APB2PeriphClockCmd(RCC_IIC_PORT, ENABLE); //使能时钟
    // Set SCL and SDA to inputs
    I2C_SCLModeIn();
    I2C_SDAModeIn();
// 	GPIO_InitStructure.GPIO_Pin  = IIC_SCL;//选择IO口   PD4/PD5

// 　	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//设置成浮空输入

// 　	GPIO_Init(IIC_PORT, &GPIO_InitStructure);//使用结构体信息进行初始化IO口

//	GPIO_InitStructure.GPIO_Pin = IIC_SDA;

// 	GPIO_Init(IIC_PORT, &GPIO_InitStructure);

// 	SDA interrupts on high-to-low transition
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOD,GPIO_PinSource3);
	
	EXTI_InitStructure.EXTI_Line = EXTI_Line3;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_Init(&EXTI_InitStructure);
    // SCL interrupts on low-to-high transition
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOD,GPIO_PinSource4);
	
	EXTI_InitStructure.EXTI_Line = EXTI_Line4;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    EXTI_InitStructure.EXTI_LineCmd = DISABLE;
    EXTI_Init(&EXTI_InitStructure);
    //NVIC初始化
    //SDA NVIC
    NVIC_InitStructure.NVIC_IRQChannel = EXTI3_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

    //SCL NVIC
    NVIC_InitStructure.NVIC_IRQChannel = EXTI4_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);
}



//static void I2C_SCLModeOut(void)
//{
//	/*定义I2C_SCL的方向为输出*/
//	GPIO_InitTypeDef GPIO_InitStructure;

//	GPIO_InitStructure.GPIO_Pin = IIC_SCL;
//	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
//	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD; //开漏输出
//	GPIO_Init(IIC_PORT, &GPIO_InitStructure);
//}
static void I2C_SCLModeIn(void)
{
    /*定义I2C_SCL的方向为输入*/
    GPIO_InitTypeDef GPIO_InitStructure;

    GPIO_InitStructure.GPIO_Pin = IIC_SCL;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
    GPIO_Init(IIC_PORT, &GPIO_InitStructure);
}

static void I2C_SDAModeOut(void)
{
    /*定义I2C_SDA的方向为输出*/
    GPIO_InitTypeDef GPIO_InitStructure;

    GPIO_InitStructure.GPIO_Pin = IIC_SDA;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;//开漏输出
    GPIO_Init(IIC_PORT,&GPIO_InitStructure);
}
static void I2C_SDAModeIn(void)
{
    /*定义I2C_SDA的方向为输入*/
    GPIO_InitTypeDef GPIO_InitStructure;

    GPIO_InitStructure.GPIO_Pin = IIC_SDA;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_Init(IIC_PORT,&GPIO_InitStructure);
}


//PD5 interrupt service function
void SDA_IRQHandler(void)
{
    if (EXTI_GetITStatus(EXTI_Line3) != RESET)
    {
        //if((GPIO_ReadInputDataBit(IIC_PORT,IIC_SCL) == 1) && (((EXTI->FTSR&0x10)>>5) == 1))//如果SDA下降沿中断(无法判断是否是下降沿？)
		if((GPIO_ReadInputDataBit(IIC_PORT,IIC_SCL) == 1) && (GPIO_ReadInputDataBit(IIC_PORT,IIC_SDA) == 0))
        {   //即通过SDA的状态来判断，如果此时SCL为高电平
            I2C_state = I2C_START;//开始状态
        }
        else
        {
            I2C_state = I2C_STOP;//停止状态
        }
    }
	EXTI_ClearITPendingBit(EXTI_Line3);//清除中断标志
    switch(I2C_state)
    {
    //fixme:感觉此处有问题，对于开始和结束状态判断不对。
    case I2C_START:
        EXTI_ClearITPendingBit(EXTI_Line4);//清除SCL的中断标志位
	
		Set_SCL_RTIR;
        Enable_SCL_INT;//使能SCL上升沿中断
	
        Set_SDA_RTIR;//设置SDA上升沿触发
        Disable_SDA_INT;//关闭SDA中断
        I2C_state = SCL_W1LH;
        EXTI_ClearITPendingBit(EXTI_Line3);//清除中断标志
        break;
    case I2C_STOP:
        INIT_PORT();
        i2c_data = 0;
        RW_flag = 0;
        ram_cnt = 0;
        break;
    default:
        break;
    }
}


//PD4 interrupt service function
void SCL_IRQHandler(void)
{
    if(EXTI_GetITStatus(EXTI_Line4) != RESET)//go into SCL interrupt
    {
        switch(I2C_state)
        {
        case SCL_W1LH:
            Set_SCL_FTIR;//set falling edge for SCL
            if(GPIO_ReadInputDataBit(IIC_PORT,IIC_SDA) == 1)//read SDA status
                i2c_data = 1;
            else
                i2c_data = 0;

            EXTI_ClearITPendingBit(EXTI_Line3);//clear SDA interrupt flag
			Set_SDA_RTIR;
            Enable_SDA_INT;//enable SDA interrupt

            I2C_state = SCL_W1HL;

            EXTI_ClearITPendingBit(EXTI_Line4);//clear SCL interrupt flag
            break;
        case SCL_W1HL:
            Set_SCL_RTIR;//set rising edge for SCL
            Disable_SDA_INT;//1st FALLING SCL TO disable SDA INT
            I2C_state = SCL_W2to6LH;
            EXTI_ClearITPendingBit(EXTI_Line4);//clear SCL interrupt flag
            break;
        case SCL_W2to6LH:
            i2c_data <<= 1;
            if(GPIO_ReadInputDataBit(IIC_PORT,IIC_SDA) == 1)
                i2c_data ++;
            if(cnt_2to6 < 4)
                cnt_2to6++;
            else
            {
                cnt_2to6 = 0;
                I2C_state = SCL_W7LH;
            }
            EXTI_ClearITPendingBit(EXTI_Line4);//clear SCL interrupt flag
            break;
        case SCL_W7LH:
            i2c_data <<= 1;

            if(GPIO_ReadInputDataBit(IIC_PORT,IIC_SDA) == 1)
                i2c_data++;

            if((RW_flag == 0) && (i2c_data != I2COA))//slave address is not right
                I2C_state = I2C_STOP;
            else 								//slave address is right
                I2C_state = SCL_W8LH;

            EXTI_ClearITPendingBit(EXTI_Line4);//clear SCL interrupt flag
            break;
        case SCL_W8LH:
            Set_SCL_FTIR;//set falling edge for SCL

            if(RW_flag == 0)
            {
                if(GPIO_ReadInputDataBit(IIC_PORT,IIC_SDA) == 1)
                    RW_flag = 1;			//read CMD
                else
                    RW_flag = 2;			//write CMD
            }
            else//Note:don't understand
            {
                i2c_data <<= 1;
                if(GPIO_ReadInputDataBit(IIC_PORT,IIC_SDA) == 1)
                    i2c_data++;
            }
            I2C_state = SCL_W8HL;
            EXTI_ClearITPendingBit(EXTI_Line4);//clear SCL interrupt flag
            break;
        case SCL_W8HL:
            I2C_SDAModeOut();//set SDA as output mode
            Reset_SDA;//set low for SDA
            if(RW_flag == 1)
            {
                i2c_data = ram_data[ram_cnt];
                ram_cnt++;
                ram_cnt &= 0x0f;
                I2C_state = SCL_R1HL;//go to read state
            }
            else if(RW_flag == 2)
            {
                RW_flag = 3;
                I2C_state = SCL_W9HL;//go to write state
            }
            else if(RW_flag == 3)
            {
                ram_data[ram_cnt] = i2c_data;
                ram_cnt++;
                ram_cnt &= 0x0f;
				I2C_state = SCL_W9HL;
            }
			else
				I2C_state = I2C_STOP;
            EXTI_ClearITPendingBit(EXTI_Line4);//clear SCL interrupt flag
            break;
        case SCL_W9HL:
            I2C_SDAModeIn();//release SDA
			
			EXTI->RTSR &= ~0x0010;  
			EXTI->FTSR &= ~0x0010;  
			EXTI->RTSR = EXTI_RTSR_TR4;	
		
            I2C_state = SCL_W1LH;
		
            EXTI_ClearITPendingBit(EXTI_Line4);//clear SCL interrupt flag
            break;
        case SCL_R1HL:
            Set_SCL_RTIR;//set rising edge SCL for SCL_R1LH
			I2C_SDAModeOut();
            if(i2c_data & 0x80)//get MSB
                Set_SDA;
            else
                Reset_SDA;
            i2c_data <<= 1;
            //NOTE:why disable SDA interrupt??????
            Disable_SDA_INT;//Disable SDA INT
            I2C_state = SCL_R1LH;
            EXTI_ClearITPendingBit(EXTI_Line4);//clear SCL interrupt flag
            break;
        case SCL_R1LH:
            Set_SCL_FTIR;//set falling edge for SCL
            EXTI_ClearITPendingBit(EXTI_Line3);//clear SDA interrupt flag
			
			Set_SDA_RTIR;
            Enable_SDA_INT;
            I2C_state = SCL_R2to8HL;
            EXTI_ClearITPendingBit(EXTI_Line4);
            break;
        case SCL_R2to8HL:
			EXTI_ClearITPendingBit(EXTI_Line3);
			Disable_SDA_INT;
		
            if(i2c_data & 0x80)
                Set_SDA;
            else
                Reset_SDA;
            i2c_data <<= 1;
            
            if(cnt_2to8 < 6)
            {
                cnt_2to8++;
            }
            else
            {
                cnt_2to8 = 0;
                I2C_state = SCL_R9HL;
            }
            EXTI_ClearITPendingBit(EXTI_Line4);
            break;
        case SCL_R9HL:
			//Set_SDA;
            I2C_SDAModeIn();//release SDA
            Set_SCL_RTIR;//Set rising edge for SCL
            I2C_state = SCL_R9LH;
            EXTI_ClearITPendingBit(EXTI_Line4);
            break;
        case SCL_R9LH:
            if(GPIO_ReadInputDataBit(IIC_PORT,IIC_SDA))//NACK
            {
                Set_SCL_RTIR;
				//i2c_data = 0x0E;
                I2C_state = SCL_W1LH;
            }
            else 								//ACK
            {
				EXTI->RTSR &= (~0x00000010);  
				EXTI->FTSR &= (~0x00000010);  
				EXTI->FTSR |= 0x00000010;	
				
				i2c_data = 0;
				i2c_data = ram_data[ram_cnt++];
                //ram_cnt++;				
                //ram_cnt &= 0x0f;
				
                I2C_state = SCL_R1HL;
            }
            EXTI_ClearITPendingBit(EXTI_Line4);
            break;
        case I2C_STOP:
            INIT_PORT();
            i2c_data = 0;
            RW_flag = 0;
            ram_cnt = 0;
            break;
        default:
            break;
        }
    }
}

iicslave.h

#ifndef _IICSLAVE_H_
#define _IICSLAVE_H_

#include "stm32f10x.h"

//PD4 SCL
//PD5 SDA

#define  GPIO_A 	0
#define  GPIO_B     1
#define  GPIO_C		2
#define  GPIO_D		4
#define  GPIO_E 	5
#define  GPIO_F 	6

//#define  FTIR		1
//#define  RTIR		2

//define port and pin
#define RCC_IIC_PORT	RCC_APB2Periph_GPIOD
#define IIC_PORT		GPIOD
#define IIC_SCL			GPIO_Pin_4
#define IIC_SDA  		GPIO_Pin_3

//
#define Enable_SCL_INT	do{ \
							EXTI->IMR &= ~(EXTI_Line4); \
							EXTI->IMR |= EXTI_Line4; \
							}while(0)
#define Disable_SCL_INT	do{ \
							EXTI->IMR &= ~(EXTI_Line4); \
							}while(0)
#define Enable_SDA_INT	do{ \
							EXTI->IMR &= ~(EXTI_Line3); \
							EXTI->IMR |= EXTI_Line3; \
							}while(0)
#define Disable_SDA_INT	do{ \
							EXTI->IMR &= ~(EXTI_Line3); \
							}while(0)

//set edge trigger for SCL/SDA
//set register to '0' then write the register
#define Set_SCL_RTIR	do{ \
							EXTI->RTSR &= (~0x00000010);  \
							EXTI->FTSR &= (~0x00000010);	\
							EXTI->RTSR |= 0x00000010;	\
							}while(0)

#define Set_SCL_FTIR	do{ \
							EXTI->RTSR &= (~0x00000010);  \
							EXTI->FTSR &= (~0x00000010);  \
							EXTI->FTSR |= 0x00000010;	\
							}while(0)
							
#define Set_SDA_RTIR	do{ \
							EXTI->RTSR &= (~0x00000008);  \
							EXTI->FTSR &= (~0x00000008);	\
							EXTI->RTSR |= 0x00000008;	\
							}while(0)
#define Set_SDA_FTIR	do{ \
							EXTI->RTSR &= (~0x00000008);  \
							EXTI->FTSR &= (~0x00000008);	\
							EXTI->FTSR |= 0x00000008;	\
							}while(0)


/**********************use stm32 lib****************************/

//set SCL/SDA
#define Set_SCL		GPIO_SetBits(IIC_PORT,IIC_SCL)
#define Reset_SCL 	GPIO_ResetBits(IIC_PORT,IIC_SCL)
#define Set_SDA		GPIO_SetBits(IIC_PORT,IIC_SDA)
#define Reset_SDA	GPIO_ResetBits(IIC_PORT,IIC_SDA)


//set interrupt trigger mode
//#define NVIC_SCL_Falling_Mode	Ex_NVIC_Config()


/******************use stm32 registers****************************/
// #define Set_SCL		
// #define Reset_SCL 	GPIO_ResetBits(IIC_PORT,IIC_SCL)
// #define Set_SDA		GPIO_SetBits(IIC_PORT,IIC_SDA)
// #define Reset_SDA	GPIO_ResetBits(IIC_PORT,IIC_SDA)

#define I2C_START 1     //start condition
#define I2C_STOP  2     //stop condition
#define SCL_W1LH  3     //Bit1(first clk rising edge)
#define SCL_W1HL  4     //Bit1(first clk falling edge)
#define SCL_W2to6LH 5   //Bit2-6(2nd-6th clk rising edge)
#define SCL_W7LH  6     //Bit7(7th clk rising edge)
#define SCL_W8LH  7     //Bit8(8th clk rising edge)
#define SCL_W8HL  8     //Set ACK(8th clk falling edge)
#define SCL_W9HL  9     //Re_init R4(9th clk falling edge)
#define SCL_R1HL  10    //Bit1(first clk falling edge)
#define SCL_R1LH  11    //Bit1(first clk rising edge)
#define SCL_R2to8HL  12    //Bit2-8(2nd-8th clk falling edge)
#define SCL_R9HL  13    //Free SDA(9th clk falling edge)
#define SCL_R9LH  14    //Check ACK(9th clk rising edge)


extern void  Ex_NVIC_Config(u8 GPIOx, u8 BITx, u8 TRIM);

extern void  MY_NVIC_Init(u8 NVIC_PreemptionPriority, u8 NVIC_SubPriority, u8 NVIC_Channel, u8 NVIC_Group);

extern void INIT_PORT(void);

extern void InitBuffer(void);

static void I2C_SCLModeOut(void);

static void I2C_SCLModeIn(void);

static void I2C_SDAModeOut(void);

static void I2C_SDAModeIn(void);

void SDA_IRQHandler(void);

void SCL_IRQHandler(void);

#endif

参考内容：

STM32-IIC从模式

森.烂笔头的博客

TI公司:slaa703a.pdf

周立功：I2C总线规范