21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数 ...
返回列表 发新帖我要提问

[其他ST产品] 使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集

[复制链接]
1378|20
 楼主| 个百zz分点个 发表于 2023-1-31 20:37 | 显示全部楼层 |阅读模式
I2c, ST, STM, STM32, STM32F
一、I2C协议
1、应用
I2C 通讯协议(Inter－Integrated Circuit)是由 Phiilps 公司开发的，由于它引脚少，硬件实现简单，可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备，现在被广泛地
使用在系统内多个集成电路(IC)间的通讯。

2、组成
最基本的是把它分为物理层和协议层。
物理层规定通讯系统中具有机械、电子功能部分的特性，确保原始数据在物理媒体的传输。
协议层主要规定通讯逻辑，统一收发双方的数据打包、解包标准。简单来说物理层规定我们用嘴巴还是用肢体来交流，协议层则规定我们用中文还是英文来交流。
- 物理层
I2C是一个支持设备的总线。可连接多个 I2C 通讯设备，支持多个通讯主机及多个通讯从机。对于I2C 总线，只使用两条总线线路，一条双向串行数据线(SDA) ，一条串行时钟线(SCL)。
- 协议层
I2C 的协议定义了通讯的起始和停止信号、数据有效性、响应、仲裁、时钟同步和地址广播等环节。
3、软件I2C和硬件I2C
3.1软件I2C
通过CPU 控制每个时刻的引脚状态来控制 GPIO 引脚电平产生通讯时序的方式称为软件I2C。

3.2硬件I2C
STM32 的 I2C 片上外设专门负责实现 I2C 通讯协议，只要配置好该外设，它就会自动根据协议要求产生通讯信号，收发数据并缓存起来，CPU只要检测该外设的状态和访问数据寄存器，就能完成数据收发。这种通过外设进行数据收发的方式称为硬件I2C。
————————————————
版权声明：本文为CSDN博主「m0_54384176」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_54384176/article/details/127923921

回复

收藏 举报

相关帖子
 楼主| 个百zz分点个 发表于 2023-1-31 20:37 | 显示全部楼层
差别
硬件 I2C 直接使用外设来控制引脚，可以减轻 CPU 的负担。不过使用硬件I2C 时必须使用某些固定的引脚作为 SCL 和 SDA，软件模拟 I2C 则可以使用任意 GPIO 引脚，相对比较灵活。对于硬件I2C用法比较复杂，软件I2C的流程更清楚一些。如果要详细了解I2C的协议，使用软件I2C可能更好的理解这个过程。在使用I2C过程，硬件I2C可能通信更加快，更加稳定。
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:38 | 显示全部楼层
二、通过硬件I2C协议采集AHT20的数据
1、配置项目
默认你已经创建了一个新项目

时钟RCC配置，将HSE选为外部晶振模式
131463d90bcea1213.png
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:38 | 显示全部楼层
SYS设置，选择Serial Wire模式。
d7f0cd4d28dd44708ce87ce697803890.png
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:39 | 显示全部楼层
设置USART
07cdf8b32535402b89e5d86989db6281.png
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:39 | 显示全部楼层
设置允许中断
9efc93e8222d4d0bbd06645d1185ef3d.png
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:39 | 显示全部楼层
I2C设置 814263d90c1035c9a.png
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:42 | 显示全部楼层
设置DMA模式
953bbc0f47624ac18bb5cd175b71601f.png
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:42 | 显示全部楼层
RCC时钟
1a67a55b3bb240c58ea4320b40f30ff1.png
设置工程路径、工程名,最后导出文件。使用keil打开并进行编写。
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:42 | 显示全部楼层

配置代码
新建一个文件夹，里面放置两个文件：
AHT20-21_DEMO_V1_3.c和AHT20-21_DEMO_V1_3.h

然后通过小方块创建一个工程文件夹,将刚刚的两个文件添加进来,后面需要进行修改.
0ad05798612841cfb6730fd1b646e3f3.png


回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:43 | 显示全部楼层
1843663d90ccec55e2.png 导入文件路径
复制前面新建的文件夹路径
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:43 | 显示全部楼层
设置文件路径
c110d9c597f645d8bb284fb39a4a58ab.png
2efb745075f14cd9947d1d1aa6bd29ac.png
将刚刚文件路径放在最后步骤2那里,然后一致点击ok返回。
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:43 | 显示全部楼层
因为后面重写了prntf函数,需要勾选允许微库。
197c628cbb504abe9ce288fa07b58e52.png
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:44 | 显示全部楼层
修改AHT20-21_DEMO_V1_3.h文件
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:44 | 显示全部楼层
复制
  1. #ifndef _AHT20_DEMO_
    

  2. #define _AHT20_DEMO_
    


  3. 

  4. #include "main.h"  
    


  5. 

  6. void Delay_N10us(uint32_t t);//延时函数
    

  7. void SensorDelay_us(uint32_t t);//延时函数
    

  8. void Delay_4us(void);                //延时函数
    

  9. void Delay_5us(void);                //延时函数
    

  10. void Delay_1ms(uint32_t t);        
    

  11. void AHT20_Clock_Init(void);                //延时函数
    

  12. void SDA_Pin_Output_High(void)  ; //将PB15配置为输出 ， 并设置为高电平， PB15作为I2C的SDA
    

  13. void SDA_Pin_Output_Low(void);  //将P15配置为输出  并设置为低电平
    

  14. void SDA_Pin_IN_FLOATING(void);  //SDA配置为浮空输入
    

  15. void SCL_Pin_Output_High(void); //SCL输出高电平，P14作为I2C的SCL
    

  16. void SCL_Pin_Output_Low(void); //SCL输出低电平
    

  17. void Init_I2C_Sensor_Port(void); //初始化I2C接口,输出为高电平
    

  18. void I2C_Start(void);                 //I2C主机发送START信号
    

  19. void AHT20_WR_Byte(uint8_t Byte); //往AHT20写一个字节
    

  20. uint8_t AHT20_RD_Byte(void);//从AHT20读取一个字节
    

  21. uint8_t Receive_ACK(void);   //看AHT20是否有回复ACK
    

  22. void Send_ACK(void)        ;          //主机回复ACK信号
    

  23. void Send_NOT_ACK(void);        //主机不回复ACK
    

  24. void Stop_I2C(void);          //一条协议结束
    

  25. uint8_t AHT20_Read_Status(void);//读取AHT20的状态寄存器
    

  26. uint8_t AHT20_Read_Cal_Enable(void);  //查询cal enable位有没有使能
    

  27. void AHT20_SendAC(void); //向AHT20发送AC命令
    

  28. uint8_t Calc_CRC8(uint8_t *message,uint8_t Num);
    

  29. void AHT20_Read_CTdata(uint32_t *ct); //没有CRC校验，直接读取AHT20的温度和湿度数据
    

  30. void AHT20_Read_CTdata_crc(uint32_t *ct); //CRC校验后，读取AHT20的温度和湿度数据
    

  31. void AHT20_Init(void);   //初始化AHT20
    

  32. void JH_Reset_REG(uint8_t addr);///重置寄存器
    

  33. void AHT20_Start_Init(void);///上电初始化进入正常测量状态
    

  34. #endif
    


  35.
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:44 | 显示全部楼层
修改AHT20-21_DEMO_V1_3.c文件
复制
  1. /*******************************************/
    

  2. /*@版权所有：广州奥松电子有限公司          */
    

  3. /*@作者：温湿度传感器事业部                */
    

  4. /*@版本：V1.2                              */
    

  5. /*******************************************/
    

  6. //#include "main.h" 
    

  7. #include "AHT20-21_DEMO_V1_3.h" 
    

  8. #include "gpio.h"
    

  9. #include "i2c.h"
    


  10. 


  11. 

  12. void Delay_N10us(uint32_t t)//延时函数
    

  13. {
    

  14.   uint32_t k;
    


  15. 

  16.    while(t--)
    

  17.   {
    

  18.     for (k = 0; k < 2; k++);//110
    

  19.   }
    

  20. }
    


  21. 

  22. void SensorDelay_us(uint32_t t)//延时函数
    

  23. {
    

  24.                 
    

  25.         for(t = t-2; t>0; t--)
    

  26.         {
    

  27.                 Delay_N10us(1);
    

  28.         }
    

  29. }
    


  30. 

  31. void Delay_4us(void)                //延时函数
    

  32. {        
    

  33.         Delay_N10us(1);
    

  34.         Delay_N10us(1);
    

  35.         Delay_N10us(1);
    

  36.         Delay_N10us(1);
    

  37. }
    

  38. void Delay_5us(void)                //延时函数
    

  39. {        
    

  40.         Delay_N10us(1);
    

  41.         Delay_N10us(1);
    

  42.         Delay_N10us(1);
    

  43.         Delay_N10us(1);
    

  44.         Delay_N10us(1);
    


  45. 

  46. }
    


  47. 

  48. void Delay_1ms(uint32_t t)                //延时函数
    

  49. {
    

  50.    while(t--)
    

  51.   {
    

  52.     SensorDelay_us(1000);//延时1ms
    

  53.   }
    

  54. }
    


  55. 


  56. 

  57. //void AHT20_Clock_Init(void)                //延时函数
    

  58. //{
    

  59. //        RCC_APB2PeriphClockCmd(CC_APB2Periph_GPIOB,ENABLE);
    

  60. //}
    


  61. 

  62. void SDA_Pin_Output_High(void)   //将PB7配置为输出 ， 并设置为高电平， PB7作为I2C的SDA
    

  63. {
    

  64.         GPIO_InitTypeDef  GPIO_InitStruct;
    

  65.         GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//推挽输出
    

  66.         GPIO_InitStruct.Pin = GPIO_PIN_7;
    

  67.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    

  68.         HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
    

  69.         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_SET);
    

  70. }
    


  71. 

  72. void SDA_Pin_Output_Low(void)  //将P7配置为输出  并设置为低电平
    

  73. {
    

  74.         GPIO_InitTypeDef  GPIO_InitStruct;
    

  75.         GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//推挽输出
    

  76.         GPIO_InitStruct.Pin = GPIO_PIN_7;
    

  77.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    

  78.         HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
    

  79.         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET);
    

  80. }
    


  81. 

  82. void SDA_Pin_IN_FLOATING(void)  //SDA配置为浮空输入
    

  83. {
    

  84.         GPIO_InitTypeDef  GPIO_InitStruct;
    

  85.         GPIO_InitStruct.Mode = GPIO_MODE_INPUT;//浮空
    

  86.         GPIO_InitStruct.Pin = GPIO_PIN_7;
    

  87.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    

  88.         HAL_GPIO_Init( GPIOB,&GPIO_InitStruct);
    

  89. }
    


  90. 


  91. 

  92. void SCL_Pin_Output_High(void) //SCL输出高电平，P14作为I2C的SCL
    

  93. {
    

  94.         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_SET);
    

  95. }
    


  96. 

  97. void SCL_Pin_Output_Low(void) //SCL输出低电平
    

  98. {
    

  99.         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_RESET);
    

  100. }
    


  101. 

  102. void Init_I2C_Sensor_Port(void) //初始化I2C接口,输出为高电平
    

  103. {        
    

  104.         GPIO_InitTypeDef  GPIO_InitStruct;
    

  105.         GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//推挽输出
    

  106.         GPIO_InitStruct.Pin = GPIO_PIN_7;
    

  107.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    

  108.         HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
    

  109.         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_SET);
    


  110. 

  111.         
    

  112.         GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//推挽输出
    

  113.         GPIO_InitStruct.Pin = GPIO_PIN_6;
    

  114.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    

  115.         HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
    

  116.         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_SET);
    

  117.         
    

  118. }
    

  119. void I2C_Start(void)                 //I2C主机发送START信号
    

  120. {
    

  121.         SDA_Pin_Output_High();
    

  122.         SensorDelay_us(8);
    

  123.         SCL_Pin_Output_High();
    

  124.         SensorDelay_us(8);
    

  125.         SDA_Pin_Output_Low();
    

  126.         SensorDelay_us(8);
    

  127.         SCL_Pin_Output_Low();
    

  128.         SensorDelay_us(8);   
    

  129. }
    


  130. 


  131. 

  132. void AHT20_WR_Byte(uint8_t Byte) //往AHT20写一个字节
    

  133. {
    

  134.         uint8_t Data,N,i;        
    

  135.         Data=Byte;
    

  136.         i = 0x80;
    

  137.         for(N=0;N<8;N++)
    

  138.         {
    

  139.                 SCL_Pin_Output_Low(); 
    

  140.                 Delay_4us();        
    

  141.                 if(i&Data)
    

  142.                 {
    

  143.                         SDA_Pin_Output_High();
    

  144.                 }
    

  145.                 else
    

  146.                 {
    

  147.                         SDA_Pin_Output_Low();
    

  148.                 }        
    

  149.                         
    

  150.     SCL_Pin_Output_High();
    

  151.                 Delay_4us();
    

  152.                 Data <<= 1;
    

  153.                  
    

  154.         }
    

  155.         SCL_Pin_Output_Low();
    

  156.         SensorDelay_us(8);   
    

  157.         SDA_Pin_IN_FLOATING();
    

  158.         SensorDelay_us(8);        
    

  159. }        
    


  160. 


  161. 

  162. uint8_t AHT20_RD_Byte(void)//从AHT20读取一个字节
    

  163. {
    

  164.                 uint8_t Byte,i,a;
    

  165.         Byte = 0;
    

  166.         SCL_Pin_Output_Low();
    

  167.         
    

  168.         SDA_Pin_IN_FLOATING();
    

  169.         SensorDelay_us(8);        
    

  170.         
    

  171.         for(i=0;i<8;i++)
    

  172.         {
    

  173.     SCL_Pin_Output_High();
    

  174.                 
    

  175.                 Delay_5us();
    

  176.                 a=0;
    

  177.                 
    

  178.                 //if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_15)) a=1;
    

  179.                 if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_7)) a=1;
    

  180.                 Byte = (Byte<<1)|a;
    

  181.                 
    

  182.                 //SCL_Pin_Output_Low();
    

  183.                 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_RESET);
    

  184.                 Delay_5us();
    

  185.         }
    

  186.   SDA_Pin_IN_FLOATING();
    

  187.         SensorDelay_us(8);        
    

  188.         return Byte;
    

  189. }
    


  190. 


  191. 

  192. uint8_t Receive_ACK(void)   //看AHT20是否有回复ACK
    

  193. {
    

  194.         uint16_t CNT;
    

  195.         CNT = 0;
    

  196.         SCL_Pin_Output_Low();        
    

  197.         SDA_Pin_IN_FLOATING();
    

  198.         SensorDelay_us(8);        
    

  199.         SCL_Pin_Output_High();        
    

  200.         SensorDelay_us(8);        
    

  201.         while((HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_7))  && CNT < 100) 
    

  202.         CNT++;
    

  203.         if(CNT == 100)
    

  204.         {
    

  205.                 return 0;
    

  206.         }
    

  207.          SCL_Pin_Output_Low();        
    

  208.         SensorDelay_us(8);        
    

  209.         return 1;
    

  210. }
    


  211. 

  212. void Send_ACK(void)                  //主机回复ACK信号
    

  213. {
    

  214.         SCL_Pin_Output_Low();        
    

  215.         SensorDelay_us(8);        
    

  216.         SDA_Pin_Output_Low();
    

  217.         SensorDelay_us(8);        
    

  218.         SCL_Pin_Output_High();        
    

  219.         SensorDelay_us(8);
    

  220.         SCL_Pin_Output_Low();        
    

  221.         SensorDelay_us(8);
    

  222.         SDA_Pin_IN_FLOATING();
    

  223.         SensorDelay_us(8);
    

  224. }
    


  225. 

  226. void Send_NOT_ACK(void)        //主机不回复ACK
    

  227. {
    

  228.         SCL_Pin_Output_Low();        
    

  229.         SensorDelay_us(8);
    

  230.         SDA_Pin_Output_High();
    

  231.         SensorDelay_us(8);
    

  232.         SCL_Pin_Output_High();        
    

  233.         SensorDelay_us(8);                
    

  234.         SCL_Pin_Output_Low();        
    

  235.         SensorDelay_us(8);
    

  236.     SDA_Pin_Output_Low();
    

  237.         SensorDelay_us(8);
    

  238. }
    


  239. 

  240. void Stop_I2C(void)          //一条协议结束
    

  241. {
    

  242.         SDA_Pin_Output_Low();
    

  243.         SensorDelay_us(8);
    

  244.         SCL_Pin_Output_High();        
    

  245.         SensorDelay_us(8);
    

  246.         SDA_Pin_Output_High();
    

  247.         SensorDelay_us(8);
    

  248. }
    


  249. 

  250. uint8_t AHT20_Read_Status(void)//读取AHT20的状态寄存器
    

  251. {
    


  252. 

  253.         uint8_t Byte_first;        
    

  254.         I2C_Start();
    

  255.         AHT20_WR_Byte(0x71);
    

  256.         Receive_ACK();
    

  257.         Byte_first = AHT20_RD_Byte();
    

  258.         Send_NOT_ACK();
    

  259.         Stop_I2C();
    

  260.         return Byte_first;
    

  261. }
    


  262. 

  263. uint8_t AHT20_Read_Cal_Enable(void)  //查询cal enable位有没有使能
    

  264. {
    

  265.         uint8_t val = 0;//ret = 0,
    

  266.   val = AHT20_Read_Status();
    

  267.          if((val & 0x68)==0x08)
    

  268.                  return 1;
    

  269.    else  return 0;
    

  270.  }
    


  271. 

  272. void AHT20_SendAC(void) //向AHT20发送AC命令
    

  273. {
    


  274. 

  275.         I2C_Start();
    

  276.         AHT20_WR_Byte(0x70);
    

  277.         Receive_ACK();
    

  278.         AHT20_WR_Byte(0xac);//0xAC采集命令
    

  279.         Receive_ACK();
    

  280.         AHT20_WR_Byte(0x33);
    

  281.         Receive_ACK();
    

  282.         AHT20_WR_Byte(0x00);
    

  283.         Receive_ACK();
    

  284.         Stop_I2C();
    


  285. 

  286. }
    


  287. 

  288. //CRC校验类型：CRC8/MAXIM
    

  289. //多项式：X8+X5+X4+1
    

  290. //Poly：0011 0001  0x31
    

  291. //高位放到后面就变成 1000 1100 0x8c
    

  292. //C现实代码：
    

  293. uint8_t Calc_CRC8(uint8_t *message,uint8_t Num)
    

  294. {
    

  295.         uint8_t i;
    

  296.         uint8_t byte;
    

  297.         uint8_t crc=0xFF;
    

  298.   for(byte=0; byte<Num; byte++)
    

  299.   {
    

  300.     crc^=(message[byte]);
    

  301.     for(i=8;i>0;--i)
    

  302.     {
    

  303.       if(crc&0x80) crc=(crc<<1)^0x31;
    

  304.       else crc=(crc<<1);
    

  305.     }
    

  306.   }
    

  307.         return crc;
    

  308. }
    


  309. 

  310. void AHT20_Read_CTdata(uint32_t *ct) //没有CRC校验，直接读取AHT20的温度和湿度数据
    

  311. {
    

  312.                 volatile uint8_t  Byte_1th=0;
    

  313.         volatile uint8_t  Byte_2th=0;
    

  314.         volatile uint8_t  Byte_3th=0;
    

  315.         volatile uint8_t  Byte_4th=0;
    

  316.         volatile uint8_t  Byte_5th=0;
    

  317.         volatile uint8_t  Byte_6th=0;
    

  318.          uint32_t RetuData = 0;
    

  319.         uint16_t cnt = 0;
    

  320.         AHT20_SendAC();//向AHT10发送AC命令
    

  321.         Delay_1ms(80);//延时80ms左右        
    

  322.     cnt = 0;
    

  323.         while(((AHT20_Read_Status()&0x80)==0x80))//直到状态bit[7]为0，表示为空闲状态，若为1，表示忙状态
    

  324.         {
    

  325.                 SensorDelay_us(1508);
    

  326.                 if(cnt++>=100)
    

  327.                 {
    

  328.                  break;
    

  329.                  }
    

  330.         }
    

  331.         I2C_Start();
    

  332.         AHT20_WR_Byte(0x71);
    

  333.         Receive_ACK();
    

  334.         Byte_1th = AHT20_RD_Byte();//状态字，查询到状态为0x98,表示为忙状态，bit[7]为1；状态为0x1C，或者0x0C，或者0x08表示为空闲状态，bit[7]为0
    

  335.         Send_ACK();
    

  336.         Byte_2th = AHT20_RD_Byte();//湿度
    

  337.         Send_ACK();
    

  338.         Byte_3th = AHT20_RD_Byte();//湿度
    

  339.         Send_ACK();
    

  340.         Byte_4th = AHT20_RD_Byte();//湿度/温度
    

  341.         Send_ACK();
    

  342.         Byte_5th = AHT20_RD_Byte();//温度
    

  343.         Send_ACK();
    

  344.         Byte_6th = AHT20_RD_Byte();//温度
    

  345.         Send_NOT_ACK();
    

  346.         Stop_I2C();
    


  347. 

  348.         RetuData = (RetuData|Byte_2th)<<8;
    

  349.         RetuData = (RetuData|Byte_3th)<<8;
    

  350.         RetuData = (RetuData|Byte_4th);
    

  351.         RetuData =RetuData >>4;
    

  352.         ct[0] = RetuData;//湿度
    

  353.         RetuData = 0;
    

  354.         RetuData = (RetuData|Byte_4th)<<8;
    

  355.         RetuData = (RetuData|Byte_5th)<<8;
    

  356.         RetuData = (RetuData|Byte_6th);
    

  357.         RetuData = RetuData&0xfffff;
    

  358.         ct[1] =RetuData; //温度
    


  359. 

  360. }
    


  361. 


  362. 

  363. void AHT20_Read_CTdata_crc(uint32_t *ct) //CRC校验后，读取AHT20的温度和湿度数据
    

  364. {
    

  365.                 volatile uint8_t  Byte_1th=0;
    

  366.         volatile uint8_t  Byte_2th=0;
    

  367.         volatile uint8_t  Byte_3th=0;
    

  368.         volatile uint8_t  Byte_4th=0;
    

  369.         volatile uint8_t  Byte_5th=0;
    

  370.         volatile uint8_t  Byte_6th=0;
    

  371.         volatile uint8_t  Byte_7th=0;
    

  372.          uint32_t RetuData = 0;
    

  373.          uint16_t cnt = 0;
    

  374.         // uint8_t  CRCDATA=0;
    

  375.          uint8_t  CTDATA[6]={0};//用于CRC传递数组
    

  376.         
    

  377.         AHT20_SendAC();//向AHT10发送AC命令
    

  378.         Delay_1ms(80);//延时80ms左右        
    

  379.     cnt = 0;
    

  380.         while(((AHT20_Read_Status()&0x80)==0x80))//直到状态bit[7]为0，表示为空闲状态，若为1，表示忙状态
    

  381.         {
    

  382.                 SensorDelay_us(1508);
    

  383.                 if(cnt++>=100)
    

  384.                 {
    

  385.                  break;
    

  386.                 }
    

  387.         }
    

  388.         
    

  389.         I2C_Start();
    


  390. 

  391.         AHT20_WR_Byte(0x71);
    

  392.         Receive_ACK();
    

  393.         CTDATA[0]=Byte_1th = AHT20_RD_Byte();//状态字，查询到状态为0x98,表示为忙状态，bit[7]为1；状态为0x1C，或者0x0C，或者0x08表示为空闲状态，bit[7]为0
    

  394.         Send_ACK();
    

  395.         CTDATA[1]=Byte_2th = AHT20_RD_Byte();//湿度
    

  396.         Send_ACK();
    

  397.         CTDATA[2]=Byte_3th = AHT20_RD_Byte();//湿度
    

  398.         Send_ACK();
    

  399.         CTDATA[3]=Byte_4th = AHT20_RD_Byte();//湿度/温度
    

  400.         Send_ACK();
    

  401.         CTDATA[4]=Byte_5th = AHT20_RD_Byte();//温度
    

  402.         Send_ACK();
    

  403.         CTDATA[5]=Byte_6th = AHT20_RD_Byte();//温度
    

  404.         Send_ACK();
    

  405.         Byte_7th = AHT20_RD_Byte();//CRC数据
    

  406.         Send_NOT_ACK();                           //注意: 最后是发送NAK
    

  407.         Stop_I2C();
    

  408.         
    

  409.         if(Calc_CRC8(CTDATA,6)==Byte_7th)
    

  410.         {
    

  411.         RetuData = (RetuData|Byte_2th)<<8;
    

  412.         RetuData = (RetuData|Byte_3th)<<8;
    

  413.         RetuData = (RetuData|Byte_4th);
    

  414.         RetuData =RetuData >>4;
    

  415.         ct[0] = RetuData;//湿度
    

  416.         RetuData = 0;
    

  417.         RetuData = (RetuData|Byte_4th)<<8;
    

  418.         RetuData = (RetuData|Byte_5th)<<8;
    

  419.         RetuData = (RetuData|Byte_6th);
    

  420.         RetuData = RetuData&0xfffff;
    

  421.         ct[1] =RetuData; //温度
    

  422.                 
    

  423.         }
    

  424.         else
    

  425.         {
    

  426.                 ct[0]=0x00;
    

  427.                 ct[1]=0x00;//校验错误返回值，客户可以根据自己需要更改
    

  428.         }//CRC数据
    

  429. }
    


  430. 


  431. 

  432. void AHT20_Init(void)   //初始化AHT20
    

  433. {        
    

  434.         Init_I2C_Sensor_Port();
    

  435.         I2C_Start();
    

  436.         AHT20_WR_Byte(0x70);
    

  437.         Receive_ACK();
    

  438.         AHT20_WR_Byte(0xa8);//0xA8进入NOR工作模式
    

  439.         Receive_ACK();
    

  440.         AHT20_WR_Byte(0x00);
    

  441.         Receive_ACK();
    

  442.         AHT20_WR_Byte(0x00);
    

  443.         Receive_ACK();
    

  444.         Stop_I2C();
    


  445. 

  446.         Delay_1ms(10);//延时10ms左右
    


  447. 

  448.         I2C_Start();
    

  449.         AHT20_WR_Byte(0x70);
    

  450.         Receive_ACK();
    

  451.         AHT20_WR_Byte(0xbe);//0xBE初始化命令，AHT20的初始化命令是0xBE,   AHT10的初始化命令是0xE1
    

  452.         Receive_ACK();
    

  453.         AHT20_WR_Byte(0x08);//相关寄存器bit[3]置1，为校准输出
    

  454.         Receive_ACK();
    

  455.         AHT20_WR_Byte(0x00);
    

  456.         Receive_ACK();
    

  457.         Stop_I2C();
    

  458.         Delay_1ms(10);//延时10ms左右
    

  459. }
    

  460. void JH_Reset_REG(uint8_t addr)
    

  461. {
    

  462.         
    

  463.         uint8_t Byte_first,Byte_second,Byte_third;
    

  464.         I2C_Start();
    

  465.         AHT20_WR_Byte(0x70);//原来是0x70
    

  466.         Receive_ACK();
    

  467.         AHT20_WR_Byte(addr);
    

  468.         Receive_ACK();
    

  469.         AHT20_WR_Byte(0x00);
    

  470.         Receive_ACK();
    

  471.         AHT20_WR_Byte(0x00);
    

  472.         Receive_ACK();
    

  473.         Stop_I2C();
    


  474. 

  475.         Delay_1ms(5);//延时5ms左右
    

  476.         I2C_Start();
    

  477.         AHT20_WR_Byte(0x71);//
    

  478.         Receive_ACK();
    

  479.         Byte_first = AHT20_RD_Byte();
    

  480.         Send_ACK();
    

  481.         Byte_second = AHT20_RD_Byte();
    

  482.         Send_ACK();
    

  483.         Byte_third = AHT20_RD_Byte();
    

  484.         Send_NOT_ACK();
    

  485.         Stop_I2C();
    

  486.         
    

  487.   Delay_1ms(10);//延时10ms左右
    

  488.         I2C_Start();
    

  489.         AHT20_WR_Byte(0x70);///
    

  490.         Receive_ACK();
    

  491.         AHT20_WR_Byte(0xB0|addr);寄存器命令
    

  492.         Receive_ACK();
    

  493.         AHT20_WR_Byte(Byte_second);
    

  494.         Receive_ACK();
    

  495.         AHT20_WR_Byte(Byte_third);
    

  496.         Receive_ACK();
    

  497.         Stop_I2C();
    

  498.         
    

  499.         Byte_second=0x00;
    

  500.         Byte_third =0x00;
    

  501. }
    


  502. 

  503. void AHT20_Start_Init(void)
    

  504. {
    

  505.         JH_Reset_REG(0x1b);
    

  506.         JH_Reset_REG(0x1c);
    

  507.         JH_Reset_REG(0x1e);
    

  508. }
    


  509.
回复

收藏 举报

评论

zxx00
请问下，JH_Reset_REG()寄存器初始化函数中AHT20_WR_Byte(0xB0|addr);寄存器命令，这样子初始化是在哪里规定了吗？不太懂AHT21B说明书中就寄存器初始化该怎么做  发表于 2024-7-23 11:33
 楼主| 个百zz分点个 发表于 2023-1-31 20:45 | 显示全部楼层
将main.c文件里main函数包括上面的头文件等信息删除,换成下面代码插入代码
复制
  1. #include "main.h"
    

  2. #include "dma.h"
    

  3. #include "i2c.h"
    

  4. #include "usart.h"
    

  5. #include "gpio.h"
    

  6. #include "AHT20-21_DEMO_V1_3.h" 
    

  7. #include <stdio.h>
    

  8. #include <string.h>
    

  9. int fputc(int ch,FILE *f)//重新printf
    

  10. {
    

  11.     HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,0xFFFF);    
    

  12.                 while(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_TC)!=SET){
    

  13.                 }                
    

  14.     return ch;
    

  15. }
    

  16. void SystemClock_Config(void);
    

  17. volatile int  c1,t1;
    

  18. uint32_t CT_data[2]={0,0};
    

  19. int main(void)
    

  20. {
    

  21.   HAL_Init();
    

  22.   SystemClock_Config();
    

  23.   MX_USART1_UART_Init();
    

  24.   MX_DMA_Init();
    

  25.   MX_I2C1_Init();        
    

  26.         AHT20_Init();//放在其它之后
    

  27.   if((AHT20_Read_Status()&0x18)!=0x18)
    

  28.         {
    

  29.                 AHT20_Start_Init(); //重新初始化寄存器
    

  30.                 Delay_1ms(10);
    

  31.         }
    


  32. 


  33. 

  34.   while (1)
    

  35.   {
    

  36.    
    

  37.                 AHT20_Read_CTdata(CT_data);       //不经过CRC校验，直接读取AHT20的温度和湿度数据    推荐每隔大于1S读一次
    

  38.     //AHT20_Read_CTdata_crc(CT_data);  //crc校验后，读取AHT20的温度和湿度数据 
    

  39.           c1 = CT_data[0]*100*10/1024/1024;  //计算得到湿度值c1（放大了10倍）
    

  40.           t1 = CT_data[1]*200*10/1024/1024-500;//计算得到温度值t1（放大了10倍）        
    

  41.                 printf("湿度：%d%s",c1/10,"%");
    

  42.           printf("温度：%d%s",t1/10,"℃");
    

  43.           printf("\r\n");
    

  44.                 HAL_Delay(3000);
    


  45. 

  46.   }
    

  47.  
    

  48. }
    


  49. 


  50.
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:46 | 显示全部楼层
最后编译效果 8429363d90d9e349b7.png
回复

收藏 举报

 楼主| 个百zz分点个 发表于 2023-1-31 20:46 | 显示全部楼层
吹起或用手捏住温度会明显变化。
四、总结
参考博客：https://blog.csdn.net/qq_52215423/article/details/127887672?app_version=5.8.1&code=app_1562916241&csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22127887672%22%2C%22source%22%3A%22qq_52215423%22%7D&uLinkId=usr1mkqgl919blen&utm_source=app
用厂商的代码实现了对温度的检测，第一次做此类实验，收获很多，对AHT20温湿度传感器的原理与应用有了更深的理解。
回复

收藏 举报

kqh11a 发表于 2024-7-29 14:27 | 显示全部楼层
软件I2C通过CPU控制每个时刻的引脚状态来控制GPIO引脚电平产生通讯时序的方式
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

个百zz分点个

53

主题

679

帖子

0

粉丝
快速回复 在线客服 返回列表 返回顶部