首先说一下，我做的是模拟的IIC进行数据的读取，所以相对比较简单，时钟按照芯片主频稍作修改即可，我们目前使用的是PB9作为SCL引脚，PB8作为SDA引脚，整个连接如下图

00-连接图.png
完成了引脚的连接，那么我们就来修改AHT11的代码，这里直接上代码
  1. #include "DRV_AHT10.h"

  3. float TempData=0,WetData=0;


  6. void Delay_N10us(uint32_t t)//延时函数
  7. {
  8.   uint32_t k;

  10.    while(t--)
  11.   {
  12.      for (k = 0; k < 719; k++)//110
  13.       ;
  14.   }
  15. }



  19. void SensorDelay_us(uint32_t t)//延时函数
  20. {
  21.         t = t-2;       
  22.         for(; t>0; t--)
  23.         {
  24.                 Delay_N10us(1);
  25.         }

  27. }

  29. void Delay_3us(void)                //延时函数
  30. {       
  31.         Delay_N10us(1);
  32.         Delay_N10us(1);
  33.         Delay_N10us(1);
  34.         Delay_N10us(1);
  35. }
  36. void Delay_1us(void)                //延时函数
  37. {       
  38.         Delay_N10us(1);
  39.         Delay_N10us(1);
  40.         Delay_N10us(1);
  41.         Delay_N10us(1);
  42.         Delay_N10us(1);

  44. }
  45. //--SCL_PA00---SDA-PA01---

  47. void SDA_Pin_Output_High(void)   //将P15配置为输出 ， 并设置为高电平， P15作为I2C的SDA
  48. {
  49.   GPIO_Pins_Set(GPIOB,GPIO_PIN_8);
  50. }

  52. void SDA_Pin_Output_Low(void)  //将P15配置为输出  并设置为低电平
  53. {
  54.   GPIO_Pins_Reset(GPIOB,GPIO_PIN_8);
  55. }



  59. void SDA_Pin_IN_FLOATING(void)  //SDA配置为悬浮输入
  60. {
  61.        
  62.        
  63.           GPIO_InitType GPIO_InitStructure;
  64.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
  65.           //PA1-PA7-PA9
  66.                 GPIO_InitStructure.Pin          = GPIO_PIN_8;
  67.                 GPIO_InitStructure.GPIO_Mode    = GPIO_MODE_INPUT;
  68.                 GPIO_InitStructure.GPIO_Current = GPIO_DS_4MA;
  69.                 GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
  70.        
  71.        
  72.        
  73. }

  75. void SDA_Pin_OUT_PP(void)  //SDA配置为悬浮输入
  76. {
  77.           GPIO_InitType GPIO_InitStructure;
  78.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
  79.           //PA1-PA7-PA9
  80.                 GPIO_InitStructure.Pin          = GPIO_PIN_8;
  81.                 GPIO_InitStructure.GPIO_Mode    = GPIO_MODE_OUT_PP;
  82.                 GPIO_InitStructure.GPIO_Current = GPIO_DS_4MA;
  83.                 GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
  84. }



  88. void SCL_Pin_Output_High(void) //SCL输出高电平，P14作为I2C的SCL
  89. {
  90.     GPIO_Pins_Set(GPIOB,GPIO_PIN_9);
  91. }

  93. void SCL_Pin_Output_Low(void) //SCL输出低电平
  94. {
  95. GPIO_Pins_Reset(GPIOB,GPIO_PIN_9);
  96. }

  98. void Init_I2C_Sensor_Port(void) //初始化I2C接口
  99. {       
  100.        
  101.                   GPIO_InitType GPIO_InitStructure;
  102.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
  103.           //--SDA_PB8
  104.                 GPIO_InitStructure.Pin          = GPIO_PIN_8;
  105.                 GPIO_InitStructure.GPIO_Mode    = GPIO_MODE_OUT_PP;
  106.                 GPIO_InitStructure.GPIO_Current = GPIO_DS_4MA;
  107.                 GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
  108.                
  109.                 RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
  110.           //SCL_PB9
  111.                 GPIO_InitStructure.Pin          = GPIO_PIN_9;
  112.                 GPIO_InitStructure.GPIO_Mode    = GPIO_MODE_OUT_PP;
  113.                 GPIO_InitStructure.GPIO_Current = GPIO_DS_4MA;
  114.                 GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
  115.                
  116.                
  117. }


  120. void I2C_Start(void)                 //I2C主机发送START信号
  121. {
  122. SDA_Pin_Output_High();
  123. SensorDelay_us(8);
  124. SCL_Pin_Output_High();
  125. SensorDelay_us(8);
  126. SDA_Pin_Output_Low();
  127. SensorDelay_us(8);
  128. SCL_Pin_Output_Low();
  129. SensorDelay_us(8);   
  130. }


  133. void ZSSC_I2C_WR_Byte(uint8_t Byte) //往AHT10写一个字节
  134. {
  135.         uint8_t Data,N,i;       
  136.         SDA_Pin_OUT_PP();
  137.         Data=Byte;
  138.         i = 0x80;
  139.         for(N=0;N<8;N++)
  140.         {
  141.                 SCL_Pin_Output_Low();
  142.           
  143.                 Delay_3us();       
  144.                
  145.                 if(i&Data)
  146.                 {
  147.                         SDA_Pin_Output_High();
  148.                 }
  149.                 else
  150.                 {
  151.                         SDA_Pin_Output_Low();
  152.                 }       
  153.                        
  154.         SCL_Pin_Output_High();
  155.                 Delay_3us();
  156.                
  157.                 Data <<= 1;
  158.                  
  159.         }
  160.         SCL_Pin_Output_Low();
  161.         SensorDelay_us(8);   
  162.         SDA_Pin_IN_FLOATING();
  163.         SensorDelay_us(8);       
  164. }       


  167. uint8_t ZSSC_I2C_RD_Byte(void)//从AHT10读取一个字节
  168. {
  169.         uint8_t Byte,i,a;
  170.         Byte = 0;
  171.         SCL_Pin_Output_Low();
  172.         SDA_Pin_IN_FLOATING();
  173.         SensorDelay_us(8);       
  174.         for(i=0;i<8;i++)
  175.         {
  176.     SCL_Pin_Output_High();               
  177.                 Delay_1us();
  178.                 a=0;
  179.                 if(GPIO_Input_Pin_Data_Get(GPIOB,GPIO_PIN_8)==PIN_SET)//--读取引脚状态
  180.                 {
  181.                         a=1;
  182.                 }

  184.                 Byte = (Byte<<1)|a;
  185.                 SCL_Pin_Output_Low();
  186.                 Delay_1us();
  187.         }
  188.     SDA_Pin_IN_FLOATING();
  189.         SensorDelay_us(8);       
  190.         return Byte;
  191. }


  194. uint8_t Receive_ACK(void)   //看AHT10是否有回复ACK
  195. {
  196.         uint16_t CNT;
  197.         CNT = 0;
  198.         SCL_Pin_Output_Low();       
  199.         SDA_Pin_IN_FLOATING();
  200.         SensorDelay_us(8);       
  201.         SCL_Pin_Output_High();       
  202.         SensorDelay_us(8);       
  203.         while((GPIO_Input_Pin_Data_Get(GPIOB,GPIO_PIN_8)==PIN_SET)        && CNT < 100)
  204.         {
  205.                 CNT++;
  206.         }               

  208.         if(CNT == 100)
  209.         {
  210.                 return 0;
  211.         }
  212.         SCL_Pin_Output_Low();       
  213.         SensorDelay_us(8);       
  214.         return 1;
  215. }

  217. void Send_ACK(void)                  //主机回复ACK信号
  218. {
  219.        
  220.         SDA_Pin_OUT_PP();
  221.         SCL_Pin_Output_Low();       
  222.         SensorDelay_us(8);       
  223.         SDA_Pin_Output_Low();
  224.         SensorDelay_us(8);       
  225.         SCL_Pin_Output_High();       
  226.         SensorDelay_us(8);
  227.         SCL_Pin_Output_Low();       
  228.         SensorDelay_us(8);
  229.         SDA_Pin_IN_FLOATING();
  230.         SensorDelay_us(8);
  231. }

  233. void Send_NOT_ACK(void)        //主机不回复ACK
  234. {
  235.         SDA_Pin_OUT_PP();
  236.         SCL_Pin_Output_Low();       
  237.         SensorDelay_us(8);
  238.         SDA_Pin_Output_High();
  239.         SensorDelay_us(8);
  240.         SCL_Pin_Output_High();       
  241.         SensorDelay_us(8);               
  242.         SCL_Pin_Output_Low();       
  243.         SensorDelay_us(8);
  244.     SDA_Pin_Output_Low();
  245.         SensorDelay_us(8);
  246. }

  248. void Stop_I2C(void)          //一条协议结束
  249. {
  250.         SDA_Pin_OUT_PP();
  251.         SDA_Pin_Output_Low();
  252.         SensorDelay_us(8);
  253.         SCL_Pin_Output_High();       
  254.         SensorDelay_us(8);
  255.         SDA_Pin_Output_High();
  256.         SensorDelay_us(8);
  257. }

  259. uint8_t JH_Read_Status(void)//读取AHT10的状态寄存器
  260. {

  262.         uint8_t Byte_first;       
  263.         I2C_Start();
  264.         ZSSC_I2C_WR_Byte(0x71);
  265.         Receive_ACK();
  266.         Byte_first = ZSSC_I2C_RD_Byte();
  267.                

  269.         Send_NOT_ACK();
  270.         Stop_I2C();


  273.         return Byte_first;
  274. }

  276. uint8_t JH_Read_Cal_Enable(void)  //查询cal enable位有没有使能？
  277. {
  278.         uint8_t val = 0;//ret = 0,

  280.   val = JH_Read_Status();
  281.   if((val & 0x68)==0x08)  //判断NOR模式和校准输出是否有效
  282.   return 1;
  283.   else  return 0;
  284. }



  288. void JH_SendAC(void) //向AHT10发送AC命令
  289. {

  291. I2C_Start();
  292. ZSSC_I2C_WR_Byte(0x70);
  293. Receive_ACK();
  294. ZSSC_I2C_WR_Byte(0xac);
  295. Receive_ACK();
  296. ZSSC_I2C_WR_Byte(0x33);
  297. Receive_ACK();
  298. ZSSC_I2C_WR_Byte(0x00);
  299. Receive_ACK();
  300. Stop_I2C();

  302. }

  304. void JH_Send_BA(void)//向AHT10发送BA命令
  305. {


  308. I2C_Start();
  309. ZSSC_I2C_WR_Byte(0x70);
  310. Receive_ACK();
  311. ZSSC_I2C_WR_Byte(0xba);
  312. Receive_ACK();
  313. Stop_I2C();


  316. }

  318. void JH_Read_CTdata(uint32_t *ct) //读取AHT10的温度和湿度数据
  319. {
  320.         volatile uint8_t  Byte_1th=0;
  321.         volatile uint8_t  Byte_2th=0;
  322.         volatile uint8_t  Byte_3th=0;
  323.         volatile uint8_t  Byte_4th=0;
  324.         volatile uint8_t  Byte_5th=0;
  325.         volatile uint8_t  Byte_6th=0;
  326.          uint32_t RetuData = 0;
  327.        
  328.         uint16_t cnt = 0;


  331.         JH_SendAC();//向AHT10发送AC命令

  333.          SysTick_Delay_Ms(75);//等待75ms
  334.     cnt = 0;
  335.         while(((JH_Read_Status()&0x80)==0x80))//等待忙状态结束
  336.         {
  337.          SensorDelay_us(1508);
  338.          if(cnt++>=100)
  339.          {
  340.           break;
  341.           }
  342.         }
  343.         I2C_Start();

  345.         ZSSC_I2C_WR_Byte(0x71);//0x70+1   0x70为设备地址 1为方向位
  346.         Receive_ACK();
  347.         Byte_1th = ZSSC_I2C_RD_Byte();//状态字
  348.         Send_ACK();
  349.         Byte_2th = ZSSC_I2C_RD_Byte();//湿度字节
  350.         Send_ACK();
  351.         Byte_3th = ZSSC_I2C_RD_Byte();//湿度字节
  352.         Send_ACK();
  353.         Byte_4th = ZSSC_I2C_RD_Byte();//高4位为湿度  低4位为温度
  354.         Send_ACK();
  355.         Byte_5th = ZSSC_I2C_RD_Byte();//温度字节
  356.         Send_ACK();
  357.         Byte_6th = ZSSC_I2C_RD_Byte();//温度字节
  358.         Send_NOT_ACK();
  359.         Stop_I2C();

  361.         RetuData = (RetuData|Byte_2th)<<8;
  362.         RetuData = (RetuData|Byte_3th)<<8;
  363.         RetuData = (RetuData|Byte_4th);
  364.         RetuData =RetuData >>4;
  365.         ct[0] = RetuData;
  366.         RetuData = 0;
  367.         RetuData = (RetuData|Byte_4th)<<8;
  368.         RetuData = (RetuData|Byte_5th)<<8;
  369.         RetuData = (RetuData|Byte_6th);
  370.         RetuData = RetuData&0xfffff;
  371.         ct[1] =RetuData;

  373. }


  376. unsigned  char  JH_Init(void)   //初始化AHT10
  377. {

  379.         unsigned int count=0;
  380.         Init_I2C_Sensor_Port();
  381.         SensorDelay_us(11038);

  383.         I2C_Start();
  384.         ZSSC_I2C_WR_Byte(0x70);
  385.         Receive_ACK();
  386.         ZSSC_I2C_WR_Byte(0xe1);//写系统配置寄存器
  387.         Receive_ACK();
  388.         ZSSC_I2C_WR_Byte(0x08);
  389.         Receive_ACK();
  390.         ZSSC_I2C_WR_Byte(0x00);
  391.         Receive_ACK();
  392.         Stop_I2C();

  394.         SysTick_Delay_Ms(500);//延时0.5S
  395.    while(JH_Read_Cal_Enable()==0)//需要等待状态字status的Bit[3]=1时才去读数据。如果Bit[3]不等于1 ，发软件复位0xBA给AHT10，再重新初始化AHT10，直至Bit[3]=1
  396.    {
  397.    
  398.                                 JH_Send_BA();  //复位
  399.                                 SysTick_Delay_Ms(100);
  400.                                 SensorDelay_us(11038);

  402.                                 I2C_Start();
  403.                                 ZSSC_I2C_WR_Byte(0x70);
  404.                                 Receive_ACK();
  405.                                 ZSSC_I2C_WR_Byte(0xe1);//写系统配置寄存器
  406.                                 Receive_ACK();
  407.                                 ZSSC_I2C_WR_Byte(0x08);
  408.                                 Receive_ACK();
  409.                                 ZSSC_I2C_WR_Byte(0x00);
  410.                                 Receive_ACK();
  411.                                 Stop_I2C();
  412.                                 count++;
  413.                                 if(count>=10)
  414.                                         return 0;
  415.                                 SysTick_Delay_Ms(500);
  416.     }
  417.    return 1;
  418. }



  422. void Get_Data(void)
  423. {
  424.     uint32_t CT_data[2];
  425.                 volatile int  c1,t1;

  427.          
  428.                 if(0)
  429.                 {


  432.                 }
  433.                 else
  434.                 {
  435.                        
  436.                                 while(JH_Read_Cal_Enable()==0)//等到校准输出使能位为1，才读取。
  437.                                 {
  438.                                         JH_Init();//如果为0再使能一次
  439.                                         SysTick_Delay_Ms(50);
  440.                                 }
  441.                                 JH_Read_CTdata(CT_data);  //读取温度和湿度 ， 可间隔1.5S读一次
  442.                                 c1 = CT_data[0]*1000/1024/1024;  //计算得到湿度值（放大了10倍,如果c1=523，表示现在湿度为52.3%）
  443.                                 t1 = CT_data[1] *200*10/1024/1024-500;//计算得到温度值（放大了10倍，如果t1=245，表示现在温度为24.5℃）
  444.                                 TempData=t1*0.1;//因为设置了两位小数--
  445.                                 WetData=c1*0.1;//--放大了两倍----
  446.                 }

  448. }



这里就只上传传感器的代码，然后是MAIN函数的代码，非常的简单

  2. #include "n32g401.h"
  3. #include "bsp_delay.h"
  4. #include "DRV_UART.h"
  5. #include "DRV_TIM.h"
  6. #include "DRV_AHT10.h"


  9. int main(void)
  10.                           {
  11.         LED_Init();
  12.         UART_Init();
  13.         TIM_Init();
  14.         JH_Init();   //初始化AHT10;
  15.         while(1)
  16.         {
  17.                 Get_Data();
  18.                 printf("TempData is %2f3 %\r\n",TempData);
  19.                 printf("WetData  is %2f3 %\r\n",WetData);
  20.                 SysTick_Delay_Ms(500);
  21.                
  22.         }
  23. }


好了，我们来看看实时的结果：
串口结果.png
测试结果还是比较准确的，我拍了视频，后面上传上来，主要是在办公室，不太好说话，所以大家感受一下结果就行了，感兴趣的话可以自己复制代码去测试。

视频链接：
https://www.bilibili.com/video/BV1AusjeuEL7/?buvid=XU268A1260BC1080F6C5DE9BB8885853A284E&is_story_h5=false&mid=ZPNijV8XOdBxHvi4hyDZnQ%3D%3D&plat_id=240&share_from=ugc&share_medium=android&share_plat=android&share_session_id=34ec3807-b268-440c-a310-66412bf9f865&share_source=WEIXIN&share_tag=s_i&spmid=dt.space-dt.0.0×tamp=1724649027&unique_k=HwCthPZ&up_id=474849000