• 模拟IIC通讯协议（stm32）（硬件iic后面在补）

    一、IIC基础知识总结。

            1、IIC通讯需要两条线就可以，SCL、SDA。

            2、IIC的数据传输的速率，不同的ic是不同的，根据电平维持的延时函数的时间来确定IIC数据传输的速率.

            3、IIC的延时函数可以使用延时函数，延时函数一般使用系统滴答时钟产生延时，也是在Sysclk频率总线的基础上产生的延时。这个延时和“__NOP();”指令产生的延时是一样的，“__NOP();”也是依靠Sysclk频率产生延时。使用场景：“__NOP();”指令是一个汇编指令的运行产生延时，是占用cpu的，短时间且精确的延时是可以使用的；较长时间的精准的延时还是需要使用系统滴答时钟的定时器实现延时的。

            4、标准的IIC传输节拍信号是由7种的：起始信号、停止信号、产生ACK应答信号、产生NACK应答信号、等待ACK应答信号、接收1byte字节信号、发送1byte字节信号。

            5、在标准IIC信号中分为两种形式：边沿信号，上升沿或者下降沿（起始信号、停止信号）。电平信号，高电平或者低电平（产生ACK应答信号、产生NACK应答信号、等待ACK应答信号、接收1byte字节信号、发送1byte字节信号）。

            6、上面的两类信号，也就是7种信号中，SDA的信号必须在SCL为高电平的时候有效。

            7、在上面的7种基础信号的基础上，根据不同的芯片封装不同的数据发送和接收的函数，下面将简单介绍一般的数据发送和接收协议形式，大部分ic芯片都是相同的。

            ic数据的发送：

            （1）发送起始位。

            （2）发送写控制字节，写控制字节的最后一位表示“写”，其他的位表示IC的id。

            （3）等待IC的ACK回应。

            （4）发送地址字节。

            （5）等待IC的ACK回应。

            （6）发送写入的数据字节。

            （7）等待IC的ACK回应。

            （8）如果单字节写入，只能写入一次，Pag页的写入，5，6可以进行多次。

            （9）最后给IC发送停止位。

            ic数据的接收：

            （1）发送起始位。

            （2）发送写控制字节，写控制字节的最后一位表示“写”，其他的位表示IC的id。

            （3）等待IC的ACK回应。

            （4）写入地址高字节（如果是16位地址数据）。

            （5）等待IC的ACK回应。

            （6）写入地址低字节

            （7）等待IC的ACK回应。

            （8）发送起始位。

            （9）发送读控制字节，读控制字节的最后一位表示“读”，其他的位表示IC的id。

            （10）等待IC的ACK回应。

            （11）接收数据。

            （12）数据没有接收完毕，继续接收，发送ACK回应信号。

            （13）接收数据。

            （14）数据接收完毕，发送NACK回应信号。

            （15）发送停止位。

            8、停止信号，最后保持SCL为高电平；其他信号，函数结束的最后一定要保持SCL为低电平。

    二、IIC使用引脚的配置电平的配置。

    1、SDA的GPIO输入

    1. static void i2c_sda_in(void)
    2. {
    3.     GPIO_InitTypeDef  gpio_cfg;
    4.     __HAL_RCC_GPIOB_CLK_ENABLE();
    5.     gpio_cfg.Pin = bus_i2c->sda_pin;
    6.     gpio_cfg.Mode = GPIO_MODE_INPUT;
    7. //    gpio_cfg.Pull = GPIO_PULLUP;
    8.     HAL_GPIO_Init((GPIO_TypeDef*)bus_i2c->sda_port, &gpio_cfg);
    9. }

    2、SDA的GPIO输出

    1. static void i2c_sda_out(void)
    2. {
    3.     GPIO_InitTypeDef  gpio_cfg;
    4.     __HAL_RCC_GPIOB_CLK_ENABLE();
    5.     gpio_cfg.Pin = bus_i2c->sda_pin;
    6.     gpio_cfg.Mode = GPIO_MODE_OUTPUT_OD;
    7.     gpio_cfg.Pull = GPIO_PULLUP;
    8.     gpio_cfg.Speed = GPIO_SPEED_FREQ_HIGH;
    9.     HAL_GPIO_Init((GPIO_TypeDef*)bus_i2c->sda_port, &gpio_cfg);
    10. }

    3、SCL的GPIO输出

    1. static void i2c_scl_out(void)
    2. {
    3.     GPIO_InitTypeDef  gpio_cfg;
    4.     __HAL_RCC_GPIOB_CLK_ENABLE();
    5.     gpio_cfg.Pin = bus_i2c->scl_pin;
    6.     gpio_cfg.Mode = GPIO_MODE_OUTPUT_OD;
    7.     gpio_cfg.Pull = GPIO_PULLUP;
    8.     gpio_cfg.Speed = GPIO_SPEED_FREQ_HIGH;
    9.     HAL_GPIO_Init((GPIO_TypeDef*)bus_i2c->scl_port, &gpio_cfg);
    10. }

    4、SDA输出高低电平

    1. static void i2c_sda_write(unsigned char value)
    2. {
    3.     HAL_GPIO_WritePin((GPIO_TypeDef*)bus_i2c->sda_port, bus_i2c->sda_pin, value?GPIO_PIN_SET:GPIO_PIN_RESET);
    4. }

    5、SCL输出高低电平

    1. static void i2c_scl_write(unsigned char value)
    2. {
    3.     HAL_GPIO_WritePin((GPIO_TypeDef*)bus_i2c->scl_port, bus_i2c->scl_pin, value?GPIO_PIN_SET:GPIO_PIN_RESET);
    4. }

    6、SDA电平读取

    1. static unsigned int i2c_sda_read(void)
    2. {
    3.   return HAL_GPIO_ReadPin((GPIO_TypeDef*)bus_i2c->sda_port, bus_i2c->sda_pin);
    4. }

    三、IIC基础信号

    1、起始信号（边沿信号）

            刚开始的时候SDA和SCL引脚信号应该都是高电平(原因：iic的两条线在电路上是加了上拉电电阻的，并且对应GPIO初始化的时候，设置的是上拉模式，所以刚开始的时候SDA和SCL引脚都是高电平)，起始信号之后要保持SCL为低电平。

            在SCL高电平的时候，SDA产生下降沿。

    （1）SAD拉高+延时函数

    （2）SCL拉高+延时函数

    （3）SDA拉低+延时函数

    （4）SCL拉低+延时函数

    1. static void i2c_start(void)
    2. {
    3.     i2c_sda_out();
    4.     i2c_sda_write(1);
    5.     i2c_delay();
    6.     i2c_scl_write(1);
    7.     i2c_delay();
    8.     i2c_sda_write(0);
    9.     i2c_delay();
    10.     i2c_scl_write(0);
    11.     i2c_delay();
    12. }

    2、停止信号（边沿信号）

               结束的时候SCL的电平一定是低电平（原因：停止信号一般是在IIC发送或者读取数据之后进行发送的，数据发送或者接收的时候SDA在SCL为高电平的时候有效，发送结束之后，SCL必须为低电平，让SDA引脚的信号电平是无效的，所以发停止信号之前，SCL的电平一定是低电平），但是SDA的电平是不确定的，所以应该先把SDA电平拉低。

            在SCL为高电平的时候，SDA产生上升沿。

    （1）SDA拉低+延时函数

    （2）SCL拉高+延时函数

    （3）SDA拉高+延时函数

    1. static void i2c_stop(void)
    2. {
    3.     i2c_sda_out();
    4.     i2c_sda_write(0);
    5.     i2c_delay();
    6.     i2c_scl_write(1);
    7.     i2c_delay();
    8.     i2c_sda_write(1);
    9.     i2c_delay();
    10. }

    3、延时函数

            延时函数就使用汇编指令“__NOP()”。具体知识参考其他文章。

    1. static void i2c_delay(void)
    2. {
    3.     __NOP();
    4. }

    4、发送ACK应答信号（电平信号）

            SCL电平一定是低电平（原因：发送ACK是在IIC读取数据的时候，需要继续读取数据，给IC的回应信号，实在读取一个电平信号之后发送的，读取信号SDA是在SCL为低电平的时候有效，所以的读取之后，SCL必须为低电平。），SDA电平未知。SCL为高电平的时候，SDA为低电平，为ACK应答信号。但是这个信号必须在数据接受完之后发送才有效。

    （1）SDA拉低+延时函数

    （2）SCL拉高+延时函数

    （3）SCL拉低+延时函数

    1. static void i2c_write_ack(void)
    2. {
    3.     i2c_sda_out();
    4.     i2c_sda_write(0);
    5.     i2c_delay();
    6.     i2c_scl_write(1);
    7.     i2c_delay();
    8.     i2c_scl_write(0);
    9.     i2c_delay();
    10. }

    5、发送NACK应答信号（电平信号）

            SCL电平一定为低电平（原因：NACK信号是在IIC读取数据的时候，读取结束，告诉IC芯片读取结束，不用在发送数据的信号，所以也是在IIC数据读取完成之后，所以SCL的电平在数据位读取完之后一定低电平。），SDA的状态确定。在SCL为高电平的时候，SDA为高电平。这个信号也是只有在读取完数据之后发送才可以。

    （1）SDA拉高+延时函数

    （2）SCL拉高+延时函数

    （3）SCL拉低+延时函数

    1. static void i2c_write_nack(void)
    2. {
    3.     i2c_sda_out();
    4.     i2c_sda_write(1);
    5.     i2c_delay();
    6.     i2c_scl_write(1);
    7.     i2c_delay();
    8.     i2c_scl_write(0);
    9.     i2c_delay();
    10. }

    6、等待ACK应答信号（电平信号）

            SCL一定为高电平，SDA电平不确定。在SCL为高电平的时候，读取SDA电平，当读取到SDA为低电平的时候，就说明接收到了ACK信号。

    （1）SCL拉高+延时函数

    （2）读取SDA电平+延时函数

    （3）SCL拉低+延时函数

    1. static unsigned char i2c_read_ack(void)
    2. {
    3.     unsigned char level = 0;
    4.     i2c_sda_in();
    5.     i2c_scl_write(1);
    6.     i2c_delay();
    7.     if(i2c_sda_read())
    8.         level = 1;
    9.     i2c_scl_write(0);
    10.     i2c_delay();
    11.     return level;
    12. }

    7、发送数据（电平信号）

            只有在SCL为高电平的时候SDA电平才有效，在SCL为高电平的时候，必须保持SDA电平稳定，所以SCL电平变化之前，SDA应该先变化。

    （1）SDA电平变化+延时函数（根绝写入数据位设置电平）

    （2）SCL拉高+延时函数

    （3）SCL拉低+延时函数

    1. static void i2c_write_byte(unsigned short data)
    2. {
    3.     int i;
    4.     unsigned char temp = (unsigned char)(data & 0xFF);
    5.     i2c_sda_out();
    6.     for(i=0;i<8;i++)
    7.     {
    8.         if(temp & 0x80)
    9.         i2c_sda_write(1);
    10.         else
    11.         i2c_sda_write(0);
    12.         temp <<= 1;
    13.         i2c_delay();
    14.         i2c_scl_write(1);
    15.         i2c_delay();
    16.         i2c_scl_write(0);
    17.         i2c_delay();
    18.     }
    19. }

    8、接收数据（电平信号）

            数据接收和数据发送是一样的，SDA在SCL为高电平的时候有效，所以SCL为高电平的时候读取SDA引脚的电平状态。

    （1）SCL拉高+延时函数

    （2）读取SDA电平+延时函数

    （3）SCL拉低+延时函数

    1. static unsigned char i2c_read_byte(void)
    2. {
    3.     int i;
    4.     unsigned char temp = 0;
    5.     i2c_sda_in();
    6.     for(i=0;i<8;i++)
    7.     {
    8. 			  i2c_scl_write(1);
    9.         i2c_delay();
    10.         temp <<= 1;
    11.         if(i2c_sda_read())
    12.         temp |= 0x01;
    13.         i2c_scl_write(0);
    14.         i2c_delay();
    15.     }
    16.     return temp;
    17. }

    四、针对IC的写入数据指令和读书数据指令流程

          下面是针对IC的一般情况的数据写入和读出的操作流程。

            通过IIC对IC芯片进行操作的时候，不管是数据的读或者数据的写，都会先写入IC的控制字节，控制字节的8bit中，最低位为读、写控制标志位，剩余的高7个bit是IC的器件地址，是专属于这个IC的，对挂载在IC总线上的IC期间，就是通过这个器件地址进行读写区分的。

    1、IIC对IC的数据写入（单字节写入）

            下图所示的就是IIC对IC芯片的数据写入的基本逻辑。除了两个边沿信号(起始、停止信号)是不需要等待IC给ACK回应的。写入数据或者地址都是需等待IC的ACK回应，确认IC收到了数据。

    （1）写入启动。

    （2）写入“ic写控制字节”。

    （3）等待ACK响应。

    （4）写入寄存器地址。

    （5）等待ACK响应。（如果没等到就写入stop位并返回）。

    （6）写入要写入的数据（可以使用循环写入多个byte）。

    （7）每次写入数据都需要等待ACK响应。

    （8）写入stop位。

    1. uint8_t PCT2075DP_Write(uint8_t reg, void* data,uint8_t size)
    2. {
    3. 	int i;
    4. 	uint8_t* pData = (uint8_t*)data;
    5. 	i2c_scl_out();
    6. 	i2c_start();
    7. 	i2c_write_byte(0x90);
    8. 	if(i2c_read_ack)
    9. 	{
    10. 		i2c_stop();
    11. 		return -1;
    12. 	}
    13. 	i2c_write_byte(reg);
    14. 	if(i2c_read_ack)
    15. 	{
    16. 		i2c_stop();
    17. 		return -3;
    18. 	}
    19. 	for(i=0; i
    20. 	{
    21. 		i2c_write_byte(pData[i]);
    22. 		if(i2c_read_ack)
    23. 		{
    24. 			i2c_stop();
    25. 			return i;
    26. 		}
    27. 	}
    28. 	i2c_stop();
    29. 	return i;
    30. }

    2、IIC对IC的数据读出（单字节读出）

           IIC对IC的数据读取除了两个边沿信号(起始、停止信号)是不需要给IC一个ACK回应信号的。进行数据的读取的时候，每读取一个字节都是需要给IC发送一个ACK回应，代表已经接收到数据，还需要继续接收数据；如果接收到的是最后一个数据，并且不在接收数据，那么就回应NACK信号。

    （1）写起始信号位。

    （2）写入“ic写控制字节”。

    （3）等待IC的ACK回应。

    （4）写入地址高字节（如果地址16位就写高字节）。

    （5）等待IC的ACK回应。

    （6）写入地址低字节。

    （7）等待IC的ACK回应。

    （8）写入起始信号（本次是重启IIC总线）。

    （9）写入“ic读控制字节”。

    （10）等待IC的ACK回应。

    （11）读取数据字节。

    （12）写入ACK回应信号（表示继续读取）。

    （13）读取数据字节。

    （14）写入NACK回应信号（表示数据读取结束）。

    （15）写入停止位。

    1. uint8_t PCT2075DP_Read(uint8_t reg, void* data,uint8_t size, uint8_t poit)
    2. {
    3. 	int i;
    4. 	uint8_t* pData = (uint8_t*)data;
    5. 	i2c_scl_out();
    6. 	i2c_start();
    7. 	i2c_write_byte(0x90);
    8. 	if(i2c_read_ack())
    9. 	{
    10. 		i2c_stop();
    11. 		return -1;
    12. 	}
    13. 	i2c_write_byte(0x00);
    14. 	if(i2c_read_ack())
    15. 	{
    16. 		i2c_stop();
    17. 		return -3;
    18. 	}
    19. 	
    20. 	i2c_start();
    21. 	i2c_write_byte(0x91);
    22. 	if(i2c_read_ack())
    23. 	{
    24. 		i2c_stop();
    25. 		return -4;
    26. 	}
    27. 	for(i=0; i
    28. 	{
    29. 		pData[i] = i2c_read_byte();    //需要继续读的时候就回复i2c_write_ack()。
    30. 		if(i == size - 1)
    31. 		{
    32. 			i2c_write_nack();
    33. 		}else
    34. 		{
    35. 			i2c_write_ack();
    36. 		}
    37. 	}
    38. 	i2c_stop();
    39. 	return i;
    40. }

    下面是总体代码：

    1. #ifndef __MYIIC_H__
    2. #define __MYIIC_H__
    3.  
    4. #include "stm32l0xx_hal.h"
    5. #include "stdint.h"
    6. #include 
    7. #include "delay.h"
    8. #include "485.h"
    9.  
    10. typedef struct sIIC_IO {
    11.     unsigned int scl_port;
    12.     unsigned int scl_pin;
    13.     unsigned int sda_port;
    14.     unsigned int sda_pin;
    15. }g_tIIC_IO;
    16.  
    17.  
    18. extern void myTest(float *pvalue);
    19. extern int pct7075_read(float *pvalue);
    20. #endif
    1. #include "Myiic.h"
    2. #include 
    3. /* 模拟IIC，7个函数。
    4.  *（1）iic函数发送数据注意发送多少位的兼容。
    5.  *（2）iic函数发送两个字节的还是一个字节的地址。
    6.  *（3）SDA的数据电平只有在SCL为高电平的时候有效。
    7.  *（4）iic功能函数：起始信号、停止信号、产生ACK应答、产生NACK应答，等待ACK应答，接收数据，发送数据
    8.  *（5）利用面对对象思想，结构体封装模拟iic使用端口和与引脚
    9.  *（6）引脚的输出输出初始化，引脚电平变化的函数，结构体的封装管理。
    10.  */
    11.  
    12.  
    13.  
    14. g_tIIC_IO i2c1 = {
    15.     .scl_port = (unsigned int)GPIOB,
    16.     .scl_pin  = (unsigned int)GPIO_PIN_6,
    17.     .sda_port = (unsigned int)GPIOB,
    18.     .sda_pin  = (unsigned int)GPIO_PIN_7
    19. };
    20.  
    21. g_tIIC_IO *bus_i2c = &i2c1;
    22.  
    23. static void i2c_delay(void)
    24. {
    25.     __NOP();
    26. }
    27.  
    28. static void i2c_sda_out(void)
    29. {
    30.     GPIO_InitTypeDef  gpio_cfg;
    31.     __HAL_RCC_GPIOB_CLK_ENABLE();
    32.     gpio_cfg.Pin = bus_i2c->sda_pin;
    33.     gpio_cfg.Mode = GPIO_MODE_OUTPUT_OD;
    34.     gpio_cfg.Pull = GPIO_PULLUP;
    35.     gpio_cfg.Speed = GPIO_SPEED_FREQ_HIGH;
    36.     HAL_GPIO_Init((GPIO_TypeDef*)bus_i2c->sda_port, &gpio_cfg);
    37. }
    38.  
    39. static void i2c_sda_write(unsigned char value)
    40. {
    41.     HAL_GPIO_WritePin((GPIO_TypeDef*)bus_i2c->sda_port, bus_i2c->sda_pin, value?GPIO_PIN_SET:GPIO_PIN_RESET);
    42. }
    43.  
    44. static void i2c_sda_in(void)
    45. {
    46.     GPIO_InitTypeDef  gpio_cfg;
    47.     __HAL_RCC_GPIOB_CLK_ENABLE();
    48.     gpio_cfg.Pin = bus_i2c->sda_pin;
    49.     gpio_cfg.Mode = GPIO_MODE_INPUT;
    50. //    gpio_cfg.Pull = GPIO_PULLUP;
    51.     HAL_GPIO_Init((GPIO_TypeDef*)bus_i2c->sda_port, &gpio_cfg);
    52. }
    53.  
    54. static unsigned int i2c_sda_read(void)
    55. {
    56.   return HAL_GPIO_ReadPin((GPIO_TypeDef*)bus_i2c->sda_port, bus_i2c->sda_pin);
    57. }
    58.  
    59. static void i2c_scl_out(void)
    60. {
    61.     GPIO_InitTypeDef  gpio_cfg;
    62.     __HAL_RCC_GPIOB_CLK_ENABLE();
    63.     gpio_cfg.Pin = bus_i2c->scl_pin;
    64.     gpio_cfg.Mode = GPIO_MODE_OUTPUT_OD;
    65.     gpio_cfg.Pull = GPIO_PULLUP;
    66.     gpio_cfg.Speed = GPIO_SPEED_FREQ_HIGH;
    67.     HAL_GPIO_Init((GPIO_TypeDef*)bus_i2c->scl_port, &gpio_cfg);
    68. }
    69.  
    70. static void i2c_scl_write(unsigned char value)
    71. {
    72.     HAL_GPIO_WritePin((GPIO_TypeDef*)bus_i2c->scl_port, bus_i2c->scl_pin, value?GPIO_PIN_SET:GPIO_PIN_RESET);
    73. }
    74.  
    75. static void i2c_start(void)
    76. {
    77.     i2c_sda_out();
    78.     i2c_sda_write(1);
    79.     i2c_delay();
    80.     i2c_scl_write(1);
    81.     i2c_delay();
    82.     i2c_sda_write(0);
    83.     i2c_delay();
    84.     i2c_scl_write(0);
    85.     i2c_delay();
    86. }
    87.  
    88. static void i2c_stop(void)
    89. {
    90.     i2c_sda_out();
    91.     i2c_sda_write(0);
    92.     i2c_delay();
    93.     i2c_scl_write(1);
    94.     i2c_delay();
    95.     i2c_sda_write(1);
    96.     i2c_delay();
    97. }
    98.  
    99. static void i2c_write_nack(void)
    100. {
    101.     i2c_sda_out();
    102.     i2c_sda_write(1);
    103.     i2c_delay();
    104.     i2c_scl_write(1);
    105.     i2c_delay();
    106.     i2c_scl_write(0);
    107.     i2c_delay();
    108. }
    109.  
    110. static void i2c_write_ack(void)
    111. {
    112.     i2c_sda_out();
    113.     i2c_sda_write(0);
    114.     i2c_delay();
    115.     i2c_scl_write(1);
    116.     i2c_delay();
    117.     i2c_scl_write(0);
    118.     i2c_delay();
    119. }
    120.  
    121. static unsigned char i2c_read_ack(void)
    122. {
    123.     unsigned char level = 0;
    124.     i2c_sda_in();
    125.     i2c_scl_write(1);
    126.     i2c_delay();
    127.     if(i2c_sda_read())
    128.         level = 1;
    129.     i2c_scl_write(0);
    130.     i2c_delay();
    131.     return level;
    132. }
    133.  
    134. static void i2c_write_byte(unsigned short data)
    135. {
    136.     int i;
    137.     unsigned char temp = (unsigned char)(data & 0xFF);
    138.     i2c_sda_out();
    139.     for(i=0;i<8;i++)
    140.     {
    141.         if(temp & 0x80)
    142.         i2c_sda_write(1);
    143.         else
    144.         i2c_sda_write(0);
    145.         temp <<= 1;
    146.         i2c_delay();
    147.         i2c_scl_write(1);
    148.         i2c_delay();
    149.         i2c_scl_write(0);
    150.         i2c_delay();
    151.     }
    152. }
    153.  
    154. static unsigned char i2c_read_byte(void)
    155. {
    156.     int i;
    157.     unsigned char temp = 0;
    158.     i2c_sda_in();
    159.     for(i=0;i<8;i++)
    160.     {
    161. 			  i2c_scl_write(1);
    162.         i2c_delay();
    163.         temp <<= 1;
    164.         if(i2c_sda_read())
    165.         temp |= 0x01;
    166.         i2c_scl_write(0);
    167.         i2c_delay();
    168.     }
    169.     return temp;
    170. }
    171.  
    172. /* 上面就是iic的标准操作函数 */
    173. /*****************************************************************/
    174. /*
    175.  *address:地址
    176.  *reg：寄存器指针指令
    177.  *
    178.  */
    179.  
    180. uint8_t PCT2075DP_Write(uint8_t reg, void* data,uint8_t size)
    181. {
    182. 	int i;
    183. 	uint8_t* pData = (uint8_t*)data;
    184. 	i2c_scl_out();
    185. 	i2c_start();
    186. 	i2c_write_byte(0x90);
    187. 	if(i2c_read_ack)
    188. 	{
    189. 		i2c_stop();
    190. 		return -1;
    191. 	}
    192. 	i2c_write_byte(reg);
    193. 	if(i2c_read_ack)
    194. 	{
    195. 		i2c_stop();
    196. 		return -3;
    197. 	}
    198. 	for(i=0; i
    199. 	{
    200. 		i2c_write_byte(pData[i]);
    201. 		if(i2c_read_ack)
    202. 		{
    203. 			i2c_stop();
    204. 			return i;
    205. 		}
    206. 	}
    207. 	i2c_stop();
    208. 	return i;
    209. }
    210.  
    211.  
    212.  
    213. uint8_t PCT2075DP_Read(uint8_t reg, void* data,uint8_t size, uint8_t poit)
    214. {
    215. 	int i;
    216. 	uint8_t* pData = (uint8_t*)data;
    217. 	i2c_scl_out();
    218. 	i2c_start();
    219. 	i2c_write_byte(0x90);
    220. 	if(i2c_read_ack())
    221. 	{
    222. 		i2c_stop();
    223. 		return -1;
    224. 	}
    225. 	i2c_write_byte(0x00);
    226. 	if(i2c_read_ack())
    227. 	{
    228. 		i2c_stop();
    229. 		return -3;
    230. 	}
    231. 	
    232. 	i2c_start();
    233. 	i2c_write_byte(0x91);
    234. 	if(i2c_read_ack())
    235. 	{
    236. 		i2c_stop();
    237. 		return -4;
    238. 	}
    239. 	for(i=0; i
    240. 	{
    241. 		pData[i] = i2c_read_byte();    //需要继续读的时候就回复i2c_write_ack()。
    242. 		if(i == size - 1)
    243. 		{
    244. 			i2c_write_nack();
    245. 		}else
    246. 		{
    247. 			i2c_write_ack();
    248. 		}
    249. 	}
    250. 	i2c_stop();
    251. 	return i;
    252. }
    253.  
    254.  
    255.  
    256.  
    257.  
    258.  
    259. void myTest(float *pvalue)
    260. {
    261. 	uint16_t temp,data=0;
    262. 	int retry = 3;
    263. 	float value;
    264. 	/* run in normal mode */
    265. 	PCT2075DP_Write(0x01, &data, 1);
    266. 	while(retry --)
    267. 	{
    268. 			if (PCT2075DP_Read(0x00, &temp, 2, 0) == 2)
    269. 					break;
    270. 	}
    271. 	temp = ((temp&0xFF00)>>8)|((temp&0x00FF)<<8);   // 传感器读取数据高8位与低8位位置调转，返回值直接short型
    272. 	value = temp;
    273. 	temp=0;
    274. 	value = value / 256;
    275. 	*pvalue= value;
    276. }
    277.  
    278.  
    279.  
    280. int i2c_write(g_tIIC_IO* bus, unsigned char address, unsigned short reg, void* pbuf, int size, unsigned char reg_16bit)
    281. {
    282.     int i = 0;
    283.     unsigned char* buf_ptr;
    284.     if(pbuf == NULL) return i;
    285.     buf_ptr = (unsigned char*)pbuf;
    286.     bus_i2c = bus;
    287.     i2c_scl_out();
    288.     i2c_start();
    289.     i2c_write_byte(address | 0);
    290.     if(i2c_read_ack()) {
    291.         i2c_stop();
    292.         return -1;
    293.     }
    294.     if(reg_16bit) {
    295.         i2c_write_byte(reg >> 8);
    296.         if(i2c_read_ack()) {
    297.         i2c_stop();
    298.         return -2;
    299.         }
    300.     }
    301.     i2c_write_byte(reg);
    302.     if(i2c_read_ack()) {
    303.         i2c_stop();
    304.         return -3;
    305.     }
    306.     for(i=0;i
    307.         i2c_write_byte(buf_ptr[i]);
    308.         if(i2c_read_ack()) {
    309.         i2c_stop();
    310.         return i;
    311.         }
    312.     }
    313.     i2c_stop();
    314.     return i;
    315. }
    316.  
    317. int i2c_read(g_tIIC_IO* bus, unsigned char address, unsigned short reg, void* pbuf, int size, unsigned char reg_16bit)
    318. {
    319.     int i = 0;
    320.     unsigned char* buf_ptr;
    321.     if(pbuf == NULL) return i;
    322.     buf_ptr = (unsigned char*)pbuf;
    323.     bus_i2c = bus;
    324.     i2c_scl_out();
    325.     i2c_start();
    326.     i2c_write_byte(address | 0);
    327.     if(i2c_read_ack()) {
    328.         i2c_stop();
    329.         return -1;
    330.     }
    331.     if(reg_16bit) {
    332.         i2c_write_byte(reg >> 8);
    333.         if(i2c_read_ack()) {
    334.         i2c_stop();
    335.         return -2;
    336.         }
    337.     }
    338.     i2c_write_byte(reg);
    339.     if(i2c_read_ack()) {
    340.         i2c_stop();
    341.         return -3;
    342.     }
    343.     i2c_start();
    344.     i2c_write_byte(address | 1);
    345.     if(i2c_read_ack()) {
    346.         i2c_stop();
    347.         return -4;
    348.     }
    349.     for(i=0;i
    350.         buf_ptr[i] = i2c_read_byte();
    351.         if(i == size - 1)
    352.         i2c_write_nack();
    353.         else
    354.         i2c_write_ack();
    355.     }
    356.     i2c_stop();
    357.     return i;
    358. }
    359.  
    360. int pct7075_read(float *pvalue)
    361. {
    362.         int retry = 3; // 3次读取失败则传感器数据读取失效，回填0xFF
    363.     short temp;
    364.     float value;
    365. #ifdef PWR_CTRL
    366.     unsigned char cfg;
    367.  
    368.     /* run in normal mode */
    369.     cfg = 0x00;
    370.     i2c_write(&PTC2075_I2C_BUS, PTC2075_SLV_ADDR, 0x01, &cfg, 1, 0);
    371. #endif
    372.     /* 多次读取，方式有时候读取失败 */
    373.     while(retry --)
    374.     {
    375.         if (i2c_read(&i2c1, 0x90, 0x00, &temp, 2, 0) == 2)
    376.             break;
    377.     }
    378. #ifdef PWR_CTRL
    379.     /* run in shutdown mode */
    380.     cfg = 0x01;
    381.     i2c_write(&i2c1, 0x90, 0x01, &cfg, 1, 0);
    382. #endif
    383.     if(!retry)   //读取数据失败的情况。
    384.     {
    385.         memset(pvalue, 0xFF, 4);
    386.         return -1;
    387.     }
    388.  
    389.     temp = ((temp&0xFF00)>>8)|((temp&0x00FF)<<8);   // 传感器读取数据高8位与低8位位置调转，返回值直接short型
    390.     value = temp;
    391.     value = value / 256;
    392.     if(pvalue != 0) *pvalue = value;
    393.     return 0;
    394. }
    395.

    stm32的硬件iic的通讯信息的时序不好调整，所以这里就先不花时间研究了。

    五、模拟IIC封装函数

            上面模拟IIC的操作函数移植比较不方便，下面的代码使用的时候，只需要在结构体中修改对应得GPIO引脚就可以了。

    5.1、h头文件

    1. #ifndef __MY_IIC_H__
    2. #define __MY_IIC_H__
    3.  
    4.  
    5. #include "sys.h" 
    6. #include "stm32f4xx.h" 
    7. #include "usart.h"
    8. #include 
    9. #include "delay.h"
    10. #include "myiic.h"
    11. /* 软件iic实现的时序图 */
    12.  
    13. /* IIC的SDA、SCL引脚的GPIO初始化函数 */
    14. typedef struct IIC_IO {
    15.     GPIO_TypeDef * scl_port;
    16.     unsigned int scl_pin;
    17.     GPIO_TypeDef * sda_port;
    18.     unsigned int sda_pin;
    19. }g_tIIC_IO;
    20.  
    21. /* IIC的时序操作和初始化函数 */
    22. typedef struct IIC_OPERATION
    23. {
    24. 	void(*My_IIC_delay)(uint16_t count);
    25. 	void(*My_IIC_Init)(void);
    26. 	void(*My_IIC_start)(void);
    27. 	void(*My_IIC_stop)(void);
    28. 	void(*My_IIC_write_nack)(void);
    29. 	void(*My_IIC_write_ack)(void);
    30. 	uint8_t(*My_IIC_read_ack)(void);
    31. 	void(*My_IIC_write_byte)(uint8_t data);
    32. 	uint8_t(*My_IIC_read_byte)(void);
    33. }g_tIIC_OPERATION;
    34.  
    35.  
    36. void My_IIC_delay(uint16_t count);   //IIC使用的延时函数
    37. void My_IIC_Init(void);            //IIC的对应GPIO的初始化函数
    38. void My_IIC_start(void);    //IIC起始边沿信号函数
    39. void My_IIC_stop(void);    //IIC写入停止函数
    40. void My_IIC_write_nack(void);     //写入NACK函数
    41. void My_IIC_write_ack(void);     //写入ACK函数
    42. uint8_t My_IIC_read_ack(void);    //IIC的等待ack函数
    43. void My_IIC_write_byte(uint8_t data);    //IIC的数据写入函数
    44. uint8_t My_IIC_read_byte(void);     //IIC的数据读取函数
    45.  
    46. /* IIC操作的结构体函数 */
    47. extern g_tIIC_OPERATION iic_operation;
    48.  
    49.  
    50. #endif

    5.2、c源文件

    1. #include "my_iic.h"
    2.  
    3. /* 模拟IIC，7个函数。
    4.  *（1）iic函数发送数据注意发送多少位的兼容。
    5.  *（2）iic函数发送两个字节的还是一个字节的地址。
    6.  *（3）SDA的数据电平只有在SCL为高电平的时候有效。
    7.  *（4）iic功能函数：起始信号、停止信号、产生ACK应答、产生NACK应答，等待ACK应答，接收数据，发送数据
    8.  *（5）利用面对对象思想，结构体封装模拟iic使用端口和与引脚
    9.  *（6）引脚的输出输出初始化，引脚电平变化的函数，结构体的封装管理。
    10.  */
    11.  
    12.  
    13. /* 模拟IIC的时序操作函数 */
    14. g_tIIC_OPERATION iic_operation = 
    15. {
    16. 	.My_IIC_delay      =  My_IIC_delay     ,
    17. 	.My_IIC_Init       =  My_IIC_Init      ,
    18. 	.My_IIC_start      =  My_IIC_start     ,
    19. 	.My_IIC_stop       =  My_IIC_stop      ,
    20. 	.My_IIC_write_nack =  My_IIC_write_nack,
    21. 	.My_IIC_write_ack  =  My_IIC_write_ack ,
    22. 	.My_IIC_read_ack   =  My_IIC_read_ack  ,
    23. 	.My_IIC_write_byte =  My_IIC_write_byte,
    24. 	.My_IIC_read_byte  =  My_IIC_read_byte ,
    25. };
    26.  
    27.  
    28. /* 模拟IIC对应的GPIO的引脚，不同得代码使用移植得时候，只需要修改下面得结构体对应得GPIO口即可 */
    29. /*
    30. 	WM8978芯片的驱动IIC对应引脚：
    31. 	（1）SDA：i2c1.scl_port PIN9
    32. 	（2）SDL：i2c1.scl_port PIN8
    33.  */
    34. g_tIIC_IO i2c1 = {
    35.     .scl_port = GPIOB,
    36.     .scl_pin  = (unsigned int)8,
    37.     .sda_port = GPIOB,
    38.     .sda_pin  = (unsigned int)9,
    39. };
    40.  
    41.  
    42. /* IIC使用的延时函数,延时的函数系统时钟的倒数，1/AHB=1/168MHz=0.00059us*/
    43. void My_IIC_delay(uint16_t count)
    44. {
    45. 	uint16_t i;
    46. 	//__NOP()汇编指令实现延时，适合短暂延时
    47. 	for(i=0; i10; i++)
    48. 	{
    49. 		 __NOP();
    50. 	}
    51. 	//适合长延时
    52. 	//delay_ms(1);
    53. }
    54.  
    55. /* IIC的SDA、SCL对应GPIO的初始化函数 */
    56. void My_IIC_Init(void) 
    57. {
    58. 	RCC->AHB1ENR|=1<<1;    //使能PORTB时钟	   
    59.   /* SDA:GPIOB9 */	
    60. 	i2c1.sda_port->MODER &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清空寄存器对应位
    61. 	i2c1.sda_port->MODER |= (uint32_t)(1<<(i2c1.sda_pin*2));    //通用输出
    62. 	i2c1.sda_port->OTYPER &= ~(uint32_t)(1<//清除原来配置位
    63.   i2c1.sda_port->OTYPER |= (uint32_t)(1<//推挽输出
    64. 	i2c1.sda_port->OSPEEDR &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清除原来配置位
    65. 	i2c1.sda_port->OSPEEDR |= (uint32_t)(2<<(i2c1.sda_pin*2));   //设置速率位50M
    66. 	i2c1.sda_port->PUPDR &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清除原来配置位
    67. 	i2c1.sda_port->PUPDR |= (uint32_t)(1<<(i2c1.sda_pin*2));     //上拉输出
    68. 	
    69. 	/* SCL:GPIOB8 */
    70. 	i2c1.scl_port->MODER &= ~(uint32_t)(3<<(i2c1.scl_pin*2));   //清空寄存器对应位
    71. 	i2c1.scl_port->MODER |= (uint32_t)(1<<(i2c1.scl_pin*2));    //通用输出
    72. 	i2c1.scl_port->OTYPER &= ~(uint32_t)(1<//清除原来配置位
    73. 	i2c1.scl_port->OTYPER |= (uint32_t)(1<//推挽输出
    74. 	i2c1.scl_port->OSPEEDR &= ~(uint32_t)(3<<(i2c1.scl_pin*2));   //清除原来配置位
    75. 	i2c1.scl_port->OSPEEDR |= (uint32_t)(2<<(i2c1.scl_pin*2));   //设置速率位50M
    76. 	i2c1.scl_port->PUPDR &= ~(uint32_t)(3<<(i2c1.scl_pin*2));   //清除原来配置位
    77. 	i2c1.scl_port->PUPDR |= (uint32_t)(1<<(i2c1.scl_pin*2));     //上拉输出
    78. 	i2c1.sda_port->ODR = (uint32_t)(1<//SDA置1
    79. 	i2c1.scl_port->ODR = (uint32_t)(1<//SCL置1
    80. }
    81.  
    82.  
    83. /* IIC写入起始边沿信号函数 */
    84. void My_IIC_start(void)
    85. {
    86. 	  i2c1.scl_port->MODER &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清空寄存器对应位
    87. 	  i2c1.scl_port->MODER |= (uint32_t)(1<<(i2c1.sda_pin*2));    //通用输出
    88.     i2c1.sda_port->ODR |= (uint16_t)(1<//SDA置1
    89.     i2c1.scl_port->ODR |= (uint16_t)(1<//SCL置1
    90.     My_IIC_delay(4);
    91.     i2c1.sda_port->ODR &= ~(uint32_t)(1<//SDA置0
    92.     My_IIC_delay(4);
    93.     i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    94. }
    95.  
    96. /* IIC写入停止函数 */
    97. void My_IIC_stop(void)
    98. {
    99. 	  i2c1.sda_port->MODER &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清空寄存器对应位
    100. 	  i2c1.sda_port->MODER |= (uint32_t)(1<<(i2c1.sda_pin*2));    //通用输出
    101. 	  i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    102.     i2c1.sda_port->ODR &= ~(uint32_t)(1<//SDA置0
    103.     My_IIC_delay(4);
    104.     i2c1.scl_port->ODR |= (uint32_t)(1<//SCL置1
    105.     i2c1.sda_port->ODR |= (uint32_t)(1<//SDA置1
    106. 	  My_IIC_delay(4);
    107. }
    108. /* IIC写入NACK响应函数 */
    109. void My_IIC_write_nack(void)
    110. {
    111.     i2c1.sda_port->MODER &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清空寄存器对应位
    112. 	  i2c1.sda_port->MODER |= (uint32_t)(1<<(i2c1.sda_pin*2));    //通用输出
    113. 	  i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    114. 	  /* 下面SDA置1的设置是可有可无的，因为这时候不知道SDA的电平，
    115. 	     所以设置为1，等到ic芯片将其拉为零 */
    116.     i2c1.sda_port->ODR |= (uint32_t)(1<//SDA置1
    117.     My_IIC_delay(2);
    118.     i2c1.scl_port->ODR |= (uint32_t)(1<//SCL置1
    119.     My_IIC_delay(2);
    120.     i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    121. }
    122. /* IIC写入ACK响应函数 */
    123. void My_IIC_write_ack(void)
    124. {
    125. 	  i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    126.     i2c1.sda_port->MODER &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清空寄存器对应位
    127. 	  i2c1.sda_port->MODER |= (uint32_t)(1<<(i2c1.sda_pin*2));    //通用输出
    128.     i2c1.sda_port->ODR &= ~(uint32_t)(1<//SDA置0
    129.     My_IIC_delay(2);
    130.     i2c1.scl_port->ODR |= (uint32_t)(1<//SCL置1
    131.     My_IIC_delay(2);
    132.     i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    133. }
    134.  
    135. /* 返回0表示成功 */
    136. /* IIC等待读取ACK响应函数 */
    137. uint8_t My_IIC_read_ack(void)
    138. {
    139. 	  unsigned char ErrTime =0;
    140.     i2c1.sda_port->MODER &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清空寄存器对应位
    141. 	  i2c1.sda_port->ODR |= (uint32_t)(1<//SDA置1
    142. 	  i2c1.scl_port->ODR |= (uint32_t)(1<//SCL置1
    143.     while((i2c1.sda_port->IDR &= (uint32_t)(1<
    144. 		{
    145. 			if(ErrTime>250)
    146. 			{
    147. 				My_IIC_stop();
    148. 				return 1;
    149. 			}
    150. 			ErrTime++;
    151. 		}
    152.     i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    153.     return 0;
    154. }
    155. /* IIC数据写入函数 */
    156. void My_IIC_write_byte(uint8_t txd)
    157. {
    158.     int i;
    159.     i2c1.sda_port->MODER &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清空寄存器对应位
    160. 	  i2c1.sda_port->MODER |= (uint32_t)(1<<(i2c1.sda_pin*2));    //通用输出
    161. 	  i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    162.     for(i=0;i<8;i++)
    163.     {
    164. 			  if((txd & 0x80)>>7)
    165. 					 i2c1.sda_port->ODR |= (uint32_t)(1<//SDA置1
    166. 				else
    167. 					i2c1.sda_port->ODR &= ~(uint32_t)(1<//SDA置0
    168.         txd <<= 1;
    169.         My_IIC_delay(2);
    170.         i2c1.scl_port->ODR |= (uint32_t)(1<//SCL置1
    171.         My_IIC_delay(2);
    172.         i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    173.         My_IIC_delay(2);
    174.     }
    175. 		
    176. }
    177.  
    178. /* IIC数据读取函数 */
    179. uint8_t My_IIC_read_byte(void)
    180. {
    181.     int i;
    182.     unsigned char temp = 0;
    183.     i2c1.sda_port->MODER &= ~(uint32_t)(3<<(i2c1.sda_pin*2));   //清空寄存器对应位
    184.     for(i=0;i<8;i++)
    185.     {
    186. 			  i2c1.scl_port->ODR |= (uint32_t)(1<//SCL置1
    187.         My_IIC_delay(1);
    188.         temp <<= 1;
    189.         if(i2c1.sda_port->IDR &= (uint32_t)(1<//SDA置0
    190. 					temp |= 0x01;
    191.         i2c1.scl_port->ODR &= ~(uint32_t)(1<//SCL置0
    192.         My_IIC_delay(1);
    193.     }
    194.     return temp;
    195. }
    196.  
    197.  
    198.

  • 相关阅读:
    【2022蓝帽杯】file_session && 浅入opcode
    华为“仓颉”不是中文编程，中文编程早有所属，势如破竹
    4.4 C++ Boost 数据集序列化库
    Java程序设计-韩建平-读书笔记
    图形化思维：Graphviz和DOT语言的艺术与实践
    Java-Scanner用法
    044-WEB攻防-PHP应用&SQL盲注&布尔回显&延时判断&报错处理&增删改查方式
    MySQL备份与恢复
    VUE3中watch和watchEffect的用法
    CMakeLists.txt新手教程
  • 原文地址：https://blog.csdn.net/qq_50299271/article/details/133886324