基于HAL库STM32温湿度采集与OLED显示（利用u8g2库）

stm32HAL库温湿度采集与OLED显示（利用u8g2库）

一、I2C总线通信协议

关于I2C的协议原理已在上一篇博客里详细指出
地址https://blog.youkuaiyun.com/2301_82236705/article/details/144444200

二 、AHT20-21简介

1. 温湿度（AHT20）外观

2. AHT20功能

AHT20，新一代温湿度传感器在尺寸与智能方面建立了新的标准：它嵌入了适 于回流焊的双列扁平无引脚SMD封装，底面3 x 3mm ，高度1.0mm。传感器输出经过 标定的数字信号，标准 I 2 C 格式。AHT20 配有一个全新设计的 ASIC专用芯片、一 个经过改进的MEMS半导体电容式湿度传感元件和一个标准的片上温度传感元件，其 性能已经大大提升甚至超出了前一代传感器的可靠性水平，新一代温湿度传感器， 经过改进使其在恶劣环境下的性能更稳定。每一个传感器都经过校准和测试，在产 品表面印有产品批号。由于对传感器做了改良和微型化改进，因此它的性价比更高， 并且最终所有设备都将得益于尖端的节能运行模式
完全标定

数字输出，IIC 接口

优异的长期稳定性

响应迅速、抗干扰能力强

宽电压支持 2.2-5.5 VDC

3. 参数介绍

湿度特性：

温度：

4. 引脚定义及连接

总共四个引脚：

5. 数据读取流程及温湿度转换

1.上电后要等待40ms，读取温湿度值之前， 首 先要看状态字的校准使能位Bit[3]是否为 1(通 过发送0x71可以获取一个字节的状态字)，如果 不为1，要发送0xBE命令(初始化)，此命令参数 有两个字节， 第一个字节为0x08，第二个字节 为0x00,然后等待10ms。

2.直接发送 0xAC命令(触发测量)，此命令参数 有两个字节，第一个字节为 0x33，第二个字节 为0x00。

3.等待80ms待测量完成，如果读取状态字Bit[7] 为0，表示测量完成，然后可以连续读取六个字 节；否则继续等待。

4.当接收完六个字节后，紧接着下一个字节是 CRC校验数据，用户可以根据需要读出，如果接 收端需要CRC校验，则在接收完第六个字节后发 ACK应答，否则发NACK结束，CRC初始值为0XFF, CRC8校验多项式为：

G（x）=1+x^4+x^5+x^8

5.计算温湿度值。
主机向从机发送测量数据：

读取温湿度数据：


相对湿度转换
相对湿度 RH 都可以根据 SDA 输出的相对湿度 信号 SRH 通过如下公式计算获得 （结果以 %RH 表示）：

温度转换
温度 T 都可以通过将温度输出信号 ST 代入到 下面的公式计算得到 （结果以温度 ℃ 表示）：

三 、实验任务

使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集，并将采集的温度-湿度值通过串口串口，并使用STM32F103的SPI或IIC接口显示AHT20的温度和湿度。
本文使用IIC接口

四、工程创建

1.RCC

2.SYS

3.USART1

4.I2C1配置（接温度传感器模块）

5.I2C2配置（接oled屏）

6.TIM1配置

7.时钟树配置

8.工程配置

五、实现AHT20采集程序

1.usart.c函数

由于我们使用了printf函数，需要在usart.c文件中添加以下代码完成printf重定向

//添加头文件#include "stdio.h"
/* USER CODE BEGIN 1 */
int fputc(int ch,FILE *f){
	HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,0xffff);
	return ch;
}
/* USER CODE END 1 */

2.main函数

oled显示，我用了上次实验的u8g2库，关于u8g2的移植和使用可以参考：https://blog.youkuaiyun.com/2301_82236705/article/details/144444200

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "i2c.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"
#include "u8g2.h"
#include "AHT20-21_DEMO_V1_3.h"
//温
static const unsigned char  wen[] =
{0x00,0x00,0xC4,0x1F,0x48,0x10,0x48,0x10,0xC1,0x1F,0x42,0x10,0x42,0x10,0xC8,0x1F,0x08,0x00,0xE4,0x3F,0x27,0x25,0x24,0x25,0x24,0x25,0x24,0x25,0xF4,0x7F,0x00,0x00};

//湿
static const unsigned char  shi[] ={0x00,0x00,0xE4,0x1F,0x28,0x10,0x28,0x10,0xE1,0x1F,0x22,0x10,0x22,0x10,0xE8,0x1F,0x88,0x04,0x84,0x04,0x97,0x24,0xA4,0x14,0xC4,0x0C,0x84,0x04,0xF4,0x7F,0x00,0x00};

//度	
static const unsigned char  du[] ={0x80,0x00,0x00,0x01,0xFC,0x7F,0x44,0x04,0x44,0x04,0xFC,0x3F,0x44,0x04,0x44,0x04,0xC4,0x07,0x04,0x00,0xF4,0x0F,0x24,0x08,0x42,0x04,0x82,0x03,0x61,0x0C,0x1C,0x70};

//待	
static const unsigned char  dai[]={0x10,0x02,0x10,0x02,0x08,0x02,0xC4,0x3F,0x12,0x02,0x10,0x02,0xE8,0x7F,0x0C,0x08,0x0A,0x08,0xE9,0x7F,0x08,0x08,0x48,0x08,0x88,0x08,0x88,0x08,0x08,0x0A,0x08,0x04};

//检	
static const unsigned char  jian[]={0x08,0x02,0x08,0x02,0x08,0x05,0x08,0x05,0xBF,0x08,0x48,0x10,0xAC,0x6F,0x1C,0x00,0x2A,0x11,0x0A,0x12,0x49,0x12,0x88,0x0A,0x88,0x08,0x08,0x04,0xE8,0x7F,0x08,0x00};

//测	
static const unsigned char  che[]={0x00,0x20,0xE4,0x23,0x28,0x22,0x28,0x2A,0xA1,0x2A,0xA2,0x2A,0xA2,0x2A,0xA8,0x2A,0xA8,0x2A,0xA4,0x2A,0xA7,0x2A,0x84,0x20,0x44,0x21,0x44,0x22,0x24,0x28,0x10,0x10};

	
	/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
	
//write by luobitaihuangzhang
	
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
	
 void oled_write(int temperature,int humidity){

	char t[5]; // 创建一个足够大的字符数组来存储转换后的数字
	char h[5];
 double t1=( double)temperature;
	double h1=(double)humidity;
  sprintf(t, "%.2f",t1/10 ); // 使用sprintf将int变量转换为字符串
	sprintf(h, "%.2f",h1/10);
	
	 u8g2_t u8g2;
  u8g2Init(&u8g2);	
	u8g2_ClearBuffer(&u8g2); 
	u8g2_SetFont(&u8g2,u8g2_font_ncenB12_tf);//设置字体格式
	u8g2_DrawXBMP(&u8g2,16,0,16,16,wen);//（参数顺序依次是，结构体、x、y、字宽、字高、储存要显示的字点阵的数组）
	u8g2_DrawXBMP(&u8g2,32,0,16,16,du);
	u8g2_DrawStr(&u8g2,48,16,":");
	u8g2_DrawXBMP(&u8g2,16,32,16,16,shi);
	u8g2_DrawXBMP(&u8g2,32,32,16,16,du);
	u8g2_DrawStr(&u8g2,48,48,":");
	u8g2_DrawUTF8(&u8g2,55,16,t);
	u8g2_DrawUTF8(&u8g2,55,48,h);
	
	u8g2_SendBuffer(&u8g2);
 }
 void oled_write_init(){
	u8g2_t u8g2;
  u8g2Init(&u8g2);	
	u8g2_ClearBuffer(&u8g2); 
	u8g2_SetFont(&u8g2,u8g2_font_ncenB12_tf);//设置字体格式
	u8g2_DrawXBMP(&u8g2,16,0,16,16,wen);//（参数顺序依次是，结构体、x、y、字宽、字高、储存要显示的字点阵的数组）
	u8g2_DrawXBMP(&u8g2,32,0,16,16,du);
	u8g2_DrawStr(&u8g2,48,16,":");
	u8g2_DrawXBMP(&u8g2,16,32,16,16,shi);
	u8g2_DrawXBMP(&u8g2,32,32,16,16,du);
	u8g2_DrawStr(&u8g2,48,48,":");
	u8g2_DrawXBMP(&u8g2,58,0,16,16,dai);
	u8g2_DrawXBMP(&u8g2,74,0,16,16,jian);
	u8g2_DrawXBMP(&u8g2,90,0,16,16,che);
	u8g2_DrawXBMP(&u8g2,58,32,16,16,dai);
	u8g2_DrawXBMP(&u8g2,74,32,16,16,jian);
	u8g2_DrawXBMP(&u8g2,90,32,16,16,che);
	u8g2_SendBuffer(&u8g2);
 }
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
	uint32_t CT_data[2]={0,0};
	volatile int  c1,t1;
	Delay_1ms(500);
	
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_I2C2_Init();
  MX_USART1_UART_Init();
  MX_I2C1_Init();
  MX_TIM1_Init();
	
	//初始化AHT20
	AHT20_Init();
	Delay_1ms(500);
	u8g2_t u8g2;
  u8g2Init(&u8g2);
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
	oled_write_init();
  while (1)
  {
    /* USER CODE END WHILE */
/* USER CODE END WHILE */
		AHT20_Read_CTdata(CT_data);       //不经过CRC校验，直接读取AHT20的温度和湿度数据    推荐每隔大于1S读一次
		//AHT20_Read_CTdata_crc(CT_data);  //crc校验后，读取AHT20的温度和湿度数据 
	

		c1 = CT_data[0]*1000/1024/1024;  //计算得到湿度值c1（放大了10倍）
		t1 = CT_data[1]*2000/1024/1024-500;//计算得到温度值t1（放大了10倍）
		printf("正在检测");
		for(int i=0;i<10;i++)
		{
			HAL_Delay(100);
			printf(".");
		}
		printf("\r\n");
		HAL_Delay(1000);
		printf("温度:%d%d.%d",t1/100,(t1/10)%10,t1%10);
		printf("湿度:%d%d.%d",c1/100,(c1/10)%10,c1%10);
		printf("\r\n");
		printf("等待");
		for(int i=0;i<10;i++)
		{
			HAL_Delay(100);
			printf(".");
		}
		printf("\r\n");
		HAL_Delay(1000);
		oled_write(t1,c1);
  /* USER CODE END 3 */
  }
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

3.AHT20

在keil中添加AHT20.c和.h文件
可在官方地址中下载

https://files.cnblogs.com/files/blogs/746187/AHT20-21_DEMO_V1_3.rar?t=1669050285

下载后需将原本的PB14,PB15改为PB6和PB7
修改后AHT20-21_DEMO_V1_3.h

#ifndef _AHT20_DEMO_
#define _AHT20_DEMO_

#include "main.h"  

void Delay_N10us(uint32_t t);//ÑÓʱº¯Êý
void SensorDelay_us(uint32_t t);//ÑÓʱº¯Êý
void Delay_4us(void);		//ÑÓʱº¯Êý
void Delay_5us(void);		//ÑÓʱº¯Êý
void Delay_1ms(uint32_t t);	
void AHT20_Clock_Init(void);		//ÑÓʱº¯Êý
void SDA_Pin_Output_High(void)  ; //½«PB7ÅäÖÃΪÊä³ö £¬ ²¢ÉèÖÃΪ¸ßµçƽ£¬ PB7×÷ΪI2CµÄSDA
void SDA_Pin_Output_Low(void);  //½«P7ÅäÖÃΪÊä³ö  ²¢ÉèÖÃΪµÍµçƽ
void SDA_Pin_IN_FLOATING(void);  //SDAÅäÖÃΪ¸¡¿ÕÊäÈë
void SCL_Pin_Output_High(void); //SCLÊä³ö¸ßµçƽ£¬P6×÷ΪI2CµÄSCL
void SCL_Pin_Output_Low(void); //SCLÊä³öµÍµçƽ
void Init_I2C_Sensor_Port(void); //³õʼ»¯I2C½Ó¿Ú,Êä³öΪ¸ßµçƽ
void I2C_Start(void);		 //I2CÖ÷»ú·¢ËÍSTARTÐźÅ
void AHT20_WR_Byte(uint8_t Byte); //ÍùAHT20дһ¸ö×Ö½Ú
uint8_t AHT20_RD_Byte(void);//´ÓAHT20¶ÁÈ¡Ò»¸ö×Ö½Ú
uint8_t Receive_ACK(void);   //¿´AHT20ÊÇ·ñÓлظ´ACK
void Send_ACK(void)	;	  //Ö÷»ú»Ø¸´ACKÐźÅ
void Send_NOT_ACK(void);	//Ö÷»ú²»»Ø¸´ACK
void Stop_I2C(void);	  //Ò»ÌõЭÒé½áÊø
uint8_t AHT20_Read_Status(void);//¶ÁÈ¡AHT20µÄ״̬¼Ä´æÆ÷
uint8_t AHT20_Read_Cal_Enable(void);  //²éѯcal enableλÓÐûÓÐʹÄÜ
void AHT20_SendAC(void); //ÏòAHT20·¢ËÍACÃüÁî
uint8_t Calc_CRC8(uint8_t *message,uint8_t Num);
void AHT20_Read_CTdata(uint32_t *ct); //ûÓÐCRCУÑ飬ֱ½Ó¶ÁÈ¡AHT20µÄζȺÍʪ¶ÈÊý¾Ý
void AHT20_Read_CTdata_crc(uint32_t *ct); //CRCУÑéºó£¬¶ÁÈ¡AHT20µÄζȺÍʪ¶ÈÊý¾Ý
void AHT20_Init(void);   //³õʼ»¯AHT20
void JH_Reset_REG(uint8_t addr);///ÖØÖüĴæÆ÷
void AHT20_Start_Init(void);///Éϵç³õʼ»¯½øÈëÕý³£²âÁ¿×´Ì¬


#endif

修改后AHT20-21_DEMO_V1_3.v

/*******************************************/
/*@°æȨËùÓУº¹ãÖÝ°ÂËɵç×ÓÓÐÏÞ¹«Ë¾          */
/*@×÷ÕߣºÎÂʪ¶È´«¸ÐÆ÷ÊÂÒµ²¿                */
/*@°æ±¾£ºV1.2                              */
/*******************************************/
#include "main.h" 
#include "AHT20-21_DEMO_V1_3.h" 
#include "gpio.h"
#include "i2c.h"


void Delay_N10us(uint32_t t)//ÑÓʱº¯Êý
{
  uint32_t k;

   while(t--)
  {
    for (k = 0; k < 2; k++);//110
  }
}

void SensorDelay_us(uint32_t t)//ÑÓʱº¯Êý
{
		
	for(t = t-2; t>0; t--)
	{
		Delay_N10us(1);
	}
}

void Delay_4us(void)		//ÑÓʱº¯Êý
{	
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);
}
void Delay_5us(void)		//ÑÓʱº¯Êý
{	
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);
	Delay_N10us(1);

}

void Delay_1ms(uint32_t t)		//ÑÓʱº¯Êý
{
   while(t--)
  {
    SensorDelay_us(1000);//ÑÓʱ1ms
  }
}


//void AHT20_Clock_Init(void)		//ÑÓʱº¯Êý
//{
//	RCC_APB2PeriphClockCmd(CC_APB2Periph_GPIOB,ENABLE);
//}

void SDA_Pin_Output_High(void)   //½«PB7ÅäÖÃΪÊä³ö £¬ ²¢ÉèÖÃΪ¸ßµçƽ£¬ PB7×÷ΪI2CµÄSDA
{
	GPIO_InitTypeDef  GPIO_InitStruct;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//ÍÆÍìÊä³ö
	GPIO_InitStruct.Pin = GPIO_PIN_7;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
	HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_SET);
}

void SDA_Pin_Output_Low(void)  //½«P7ÅäÖÃΪÊä³ö  ²¢ÉèÖÃΪµÍµçƽ
{
	GPIO_InitTypeDef  GPIO_InitStruct;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//ÍÆÍìÊä³ö
	GPIO_InitStruct.Pin =  GPIO_PIN_7;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
	HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7,GPIO_PIN_RESET);
}

void SDA_Pin_IN_FLOATING(void)  //SDAÅäÖÃΪ¸¡¿ÕÊäÈë
{
	GPIO_InitTypeDef  GPIO_InitStruct;
	GPIO_InitStruct.Mode = GPIO_MODE_INPUT;//¸¡¿Õ
	GPIO_InitStruct.Pin =  GPIO_PIN_7;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
	HAL_GPIO_Init( GPIOB,&GPIO_InitStruct);
}


void SCL_Pin_Output_High(void) //SCLÊä³ö¸ßµçƽ£¬P6×÷ΪI2CµÄSCL
{
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_SET);
}

void SCL_Pin_Output_Low(void) //SCLÊä³öµÍµçƽ
{
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_RESET);
}

void Init_I2C_Sensor_Port(void) //³õʼ»¯I2C½Ó¿Ú,Êä³öΪ¸ßµçƽ
{	
	GPIO_InitTypeDef  GPIO_InitStruct;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//ÍÆÍìÊä³ö
	GPIO_InitStruct.Pin = GPIO_PIN_7;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
	HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_SET);

	
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//ÍÆÍìÊä³ö
	GPIO_InitStruct.Pin = GPIO_PIN_6;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
	HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_SET);
	
}
void I2C_Start(void)		 //I2CÖ÷»ú·¢ËÍSTARTÐźÅ
{
	SDA_Pin_Output_High();
	SensorDelay_us(8);
	SCL_Pin_Output_High();
	SensorDelay_us(8);
	SDA_Pin_Output_Low();
	SensorDelay_us(8);
	SCL_Pin_Output_Low();
	SensorDelay_us(8);   
}


void AHT20_WR_Byte(uint8_t Byte) //ÍùAHT20дһ¸ö×Ö½Ú
{
	uint8_t Data,N,i;	
	Data=Byte;
	i = 0x80;
	for(N=0;N<8;N++)
	{
		SCL_Pin_Output_Low(); 
		Delay_4us();	
		if(i&Data)
		{
			SDA_Pin_Output_High();
		}
		else
		{
			SDA_Pin_Output_Low();
		}	
			
    SCL_Pin_Output_High();
		Delay_4us();
		Data <<= 1;
		 
	}
	SCL_Pin_Output_Low();
	SensorDelay_us(8);   
	SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);	
}	


uint8_t AHT20_RD_Byte(void)//´ÓAHT20¶ÁÈ¡Ò»¸ö×Ö½Ú
{
		uint8_t Byte,i,a;
	Byte = 0;
	SCL_Pin_Output_Low();
	
	SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);	
	
	for(i=0;i<8;i++)
	{
    SCL_Pin_Output_High();
		
		Delay_5us();
		a=0;
		
		//if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_15)) a=1;
		if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_7)) a=1;
		Byte = (Byte<<1)|a;
		
		//SCL_Pin_Output_Low();
		HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_RESET);
		Delay_5us();
	}
  SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);	
	return Byte;
}


uint8_t Receive_ACK(void)   //¿´AHT20ÊÇ·ñÓлظ´ACK
{
	uint16_t CNT;
	CNT = 0;
	SCL_Pin_Output_Low();	
	SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);	
	SCL_Pin_Output_High();	
	SensorDelay_us(8);	
	while((HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_7))  && CNT < 100) 
	CNT++;
	if(CNT == 100)
	{
		return 0;
	}
 	SCL_Pin_Output_Low();	
	SensorDelay_us(8);	
	return 1;
}

void Send_ACK(void)		  //Ö÷»ú»Ø¸´ACKÐźÅ
{
	SCL_Pin_Output_Low();	
	SensorDelay_us(8);	
	SDA_Pin_Output_Low();
	SensorDelay_us(8);	
	SCL_Pin_Output_High();	
	SensorDelay_us(8);
	SCL_Pin_Output_Low();	
	SensorDelay_us(8);
	SDA_Pin_IN_FLOATING();
	SensorDelay_us(8);
}

void Send_NOT_ACK(void)	//Ö÷»ú²»»Ø¸´ACK
{
	SCL_Pin_Output_Low();	
	SensorDelay_us(8);
	SDA_Pin_Output_High();
	SensorDelay_us(8);
	SCL_Pin_Output_High();	
	SensorDelay_us(8);		
	SCL_Pin_Output_Low();	
	SensorDelay_us(8);
    SDA_Pin_Output_Low();
	SensorDelay_us(8);
}

void Stop_I2C(void)	  //Ò»ÌõЭÒé½áÊø
{
	SDA_Pin_Output_Low();
	SensorDelay_us(8);
	SCL_Pin_Output_High();	
	SensorDelay_us(8);
	SDA_Pin_Output_High();
	SensorDelay_us(8);
}

uint8_t AHT20_Read_Status(void)//¶ÁÈ¡AHT20µÄ״̬¼Ä´æÆ÷
{

	uint8_t Byte_first;	
	I2C_Start();
	AHT20_WR_Byte(0x71);
	Receive_ACK();
	Byte_first = AHT20_RD_Byte();
	Send_NOT_ACK();
	Stop_I2C();
	return Byte_first;
}

uint8_t AHT20_Read_Cal_Enable(void)  //²éѯcal enableλÓÐûÓÐʹÄÜ
{
	uint8_t val = 0;//ret = 0,
  val = AHT20_Read_Status();
	 if((val & 0x68)==0x08)
		 return 1;
   else  return 0;
 }

void AHT20_SendAC(void) //ÏòAHT20·¢ËÍACÃüÁî
{

	I2C_Start();
	AHT20_WR_Byte(0x70);
	Receive_ACK();
	AHT20_WR_Byte(0xac);//0xAC²É¼¯ÃüÁî
	Receive_ACK();
	AHT20_WR_Byte(0x33);
	Receive_ACK();
	AHT20_WR_Byte(0x00);
	Receive_ACK();
	Stop_I2C();

}

//CRCУÑéÀàÐÍ£ºCRC8/MAXIM
//¶àÏîʽ£ºX8+X5+X4+1
//Poly£º0011 0001  0x31
//¸ßλ·Åµ½ºóÃæ¾Í±ä³É 1000 1100 0x8c
//CÏÖʵ´úÂ룺
uint8_t Calc_CRC8(uint8_t *message,uint8_t Num)
{
	uint8_t i;
	uint8_t byte;
	uint8_t crc=0xFF;
  for(byte=0; byte<Num; byte++)
  {
    crc^=(message[byte]);
    for(i=8;i>0;--i)
    {
      if(crc&0x80) crc=(crc<<1)^0x31;
      else crc=(crc<<1);
    }
  }
        return crc;
}

void AHT20_Read_CTdata(uint32_t *ct) //ûÓÐCRCУÑ飬ֱ½Ó¶ÁÈ¡AHT20µÄζȺÍʪ¶ÈÊý¾Ý
{
		volatile uint8_t  Byte_1th=0;
	volatile uint8_t  Byte_2th=0;
	volatile uint8_t  Byte_3th=0;
	volatile uint8_t  Byte_4th=0;
	volatile uint8_t  Byte_5th=0;
	volatile uint8_t  Byte_6th=0;
	 uint32_t RetuData = 0;
	uint16_t cnt = 0;
	AHT20_SendAC();//ÏòAHT10·¢ËÍACÃüÁî
	Delay_1ms(80);//ÑÓʱ80ms×óÓÒ	
    cnt = 0;
	while(((AHT20_Read_Status()&0x80)==0x80))//Ö±µ½×´Ì¬bit[7]Ϊ0£¬±íʾΪ¿ÕÏÐ״̬£¬ÈôΪ1£¬±íʾæ״̬
	{
		SensorDelay_us(1508);
		if(cnt++>=100)
		{
		 break;
		 }
	}
	I2C_Start();
	AHT20_WR_Byte(0x71);
	Receive_ACK();
	Byte_1th = AHT20_RD_Byte();//״̬×Ö£¬²éѯµ½×´Ì¬Îª0x98,±íʾΪæ״̬£¬bit[7]Ϊ1£»×´Ì¬Îª0x1C£¬»òÕß0x0C£¬»òÕß0x08±íʾΪ¿ÕÏÐ״̬£¬bit[7]Ϊ0
	Send_ACK();
	Byte_2th = AHT20_RD_Byte();//ʪ¶È
	Send_ACK();
	Byte_3th = AHT20_RD_Byte();//ʪ¶È
	Send_ACK();
	Byte_4th = AHT20_RD_Byte();//ʪ¶È/ζÈ
	Send_ACK();
	Byte_5th = AHT20_RD_Byte();//ζÈ
	Send_ACK();
	Byte_6th = AHT20_RD_Byte();//ζÈ
	Send_NOT_ACK();
	Stop_I2C();

	RetuData = (RetuData|Byte_2th)<<8;
	RetuData = (RetuData|Byte_3th)<<8;
	RetuData = (RetuData|Byte_4th);
	RetuData =RetuData >>4;
	ct[0] = RetuData;//ʪ¶È
	RetuData = 0;
	RetuData = (RetuData|Byte_4th)<<8;
	RetuData = (RetuData|Byte_5th)<<8;
	RetuData = (RetuData|Byte_6th);
	RetuData = RetuData&0xfffff;
	ct[1] =RetuData; //ζÈ

}


void AHT20_Read_CTdata_crc(uint32_t *ct) //CRCУÑéºó£¬¶ÁÈ¡AHT20µÄζȺÍʪ¶ÈÊý¾Ý
{
		volatile uint8_t  Byte_1th=0;
	volatile uint8_t  Byte_2th=0;
	volatile uint8_t  Byte_3th=0;
	volatile uint8_t  Byte_4th=0;
	volatile uint8_t  Byte_5th=0;
	volatile uint8_t  Byte_6th=0;
	volatile uint8_t  Byte_7th=0;
	 uint32_t RetuData = 0;
	 uint16_t cnt = 0;
	// uint8_t  CRCDATA=0;
	 uint8_t  CTDATA[6]={0};//ÓÃÓÚCRC´«µÝÊý×é
	
	AHT20_SendAC();//ÏòAHT10·¢ËÍACÃüÁî
	Delay_1ms(80);//ÑÓʱ80ms×óÓÒ	
    cnt = 0;
	while(((AHT20_Read_Status()&0x80)==0x80))//Ö±µ½×´Ì¬bit[7]Ϊ0£¬±íʾΪ¿ÕÏÐ״̬£¬ÈôΪ1£¬±íʾæ״̬
	{
		SensorDelay_us(1508);
		if(cnt++>=100)
		{
		 break;
		}
	}
	
	I2C_Start();

	AHT20_WR_Byte(0x71);
	Receive_ACK();
	CTDATA[0]=Byte_1th = AHT20_RD_Byte();//״̬×Ö£¬²éѯµ½×´Ì¬Îª0x98,±íʾΪæ״̬£¬bit[7]Ϊ1£»×´Ì¬Îª0x1C£¬»òÕß0x0C£¬»òÕß0x08±íʾΪ¿ÕÏÐ״̬£¬bit[7]Ϊ0
	Send_ACK();
	CTDATA[1]=Byte_2th = AHT20_RD_Byte();//ʪ¶È
	Send_ACK();
	CTDATA[2]=Byte_3th = AHT20_RD_Byte();//ʪ¶È
	Send_ACK();
	CTDATA[3]=Byte_4th = AHT20_RD_Byte();//ʪ¶È/ζÈ
	Send_ACK();
	CTDATA[4]=Byte_5th = AHT20_RD_Byte();//ζÈ
	Send_ACK();
	CTDATA[5]=Byte_6th = AHT20_RD_Byte();//ζÈ
	Send_ACK();
	Byte_7th = AHT20_RD_Byte();//CRCÊý¾Ý
	Send_NOT_ACK();                           //×¢Òâ: ×îºóÊÇ·¢ËÍNAK
	Stop_I2C();
	
	if(Calc_CRC8(CTDATA,6)==Byte_7th)
	{
	RetuData = (RetuData|Byte_2th)<<8;
	RetuData = (RetuData|Byte_3th)<<8;
	RetuData = (RetuData|Byte_4th);
	RetuData =RetuData >>4;
	ct[0] = RetuData;//ʪ¶È
	RetuData = 0;
	RetuData = (RetuData|Byte_4th)<<8;
	RetuData = (RetuData|Byte_5th)<<8;
	RetuData = (RetuData|Byte_6th);
	RetuData = RetuData&0xfffff;
	ct[1] =RetuData; //ζÈ
		
	}
	else
	{
		ct[0]=0x00;
		ct[1]=0x00;//УÑé´íÎó·µ»ØÖµ£¬¿Í»§¿ÉÒÔ¸ù¾Ý×Ô¼ºÐèÒª¸ü¸Ä
	}//CRCÊý¾Ý
}


void AHT20_Init(void)   //³õʼ»¯AHT20
{	
	Init_I2C_Sensor_Port();
	I2C_Start();
	AHT20_WR_Byte(0x70);
	Receive_ACK();
	AHT20_WR_Byte(0xa8);//0xA8½øÈëNOR¹¤×÷ģʽ
	Receive_ACK();
	AHT20_WR_Byte(0x00);
	Receive_ACK();
	AHT20_WR_Byte(0x00);
	Receive_ACK();
	Stop_I2C();

	Delay_1ms(10);//ÑÓʱ10ms×óÓÒ

	I2C_Start();
	AHT20_WR_Byte(0x70);
	Receive_ACK();
	AHT20_WR_Byte(0xbe);//0xBE³õʼ»¯ÃüÁAHT20µÄ³õʼ»¯ÃüÁîÊÇ0xBE,   AHT10µÄ³õʼ»¯ÃüÁîÊÇ0xE1
	Receive_ACK();
	AHT20_WR_Byte(0x08);//Ïà¹Ø¼Ä´æÆ÷bit[3]ÖÃ1£¬ÎªÐ£×¼Êä³ö
	Receive_ACK();
	AHT20_WR_Byte(0x00);
	Receive_ACK();
	Stop_I2C();
	Delay_1ms(10);//ÑÓʱ10ms×óÓÒ
}
void JH_Reset_REG(uint8_t addr)
{
	
	uint8_t Byte_first,Byte_second,Byte_third;
	I2C_Start();
	AHT20_WR_Byte(0x70);//Ô­À´ÊÇ0x70
	Receive_ACK();
	AHT20_WR_Byte(addr);
	Receive_ACK();
	AHT20_WR_Byte(0x00);
	Receive_ACK();
	AHT20_WR_Byte(0x00);
	Receive_ACK();
	Stop_I2C();

	Delay_1ms(5);//ÑÓʱ5ms×óÓÒ
	I2C_Start();
	AHT20_WR_Byte(0x71);//
	Receive_ACK();
	Byte_first = AHT20_RD_Byte();
	Send_ACK();
	Byte_second = AHT20_RD_Byte();
	Send_ACK();
	Byte_third = AHT20_RD_Byte();
	Send_NOT_ACK();
	Stop_I2C();
	
  Delay_1ms(10);//ÑÓʱ10ms×óÓÒ
	I2C_Start();
	AHT20_WR_Byte(0x70);///
	Receive_ACK();
	AHT20_WR_Byte(0xB0|addr);¼Ä´æÆ÷ÃüÁî
	Receive_ACK();
	AHT20_WR_Byte(Byte_second);
	Receive_ACK();
	AHT20_WR_Byte(Byte_third);
	Receive_ACK();
	Stop_I2C();
	
	Byte_second=0x00;
	Byte_third =0x00;
}

void AHT20_Start_Init(void)
{
	JH_Reset_REG(0x1b);
	JH_Reset_REG(0x1c);
	JH_Reset_REG(0x1e);
}

4.效果演示

温度采集

五、总结

本次实验经历了很大的挑战，但是终于初步实现了对stm32更为实际的应用，在实验中，熟悉要使用的器件功能，熟悉串口对我们来说很重要，希望今后也能在嵌入式的路上继续前行。

参考：
https://blog.youkuaiyun.com/m0_74327085/article/details/139770136
https://blog.youkuaiyun.com/sjsnsnsnsi/article/details/134298128