STM32 HAL库--IIC协议读取温湿度数据

已于 2023-11-12 23:19:20 修改
阅读量362 收藏 2
点赞数
文章标签： stm32 嵌入式硬件 单片机
于 2023-11-12 23:17:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dylan_hs/article/details/134364817
版权

目录

一、IIC协议

IIC简介

IIC 通讯协议(Inter－Integrated Circuit)是一个同步半双工串行总线协议。它由 Phiilps 公司开发的，由于它引脚少，硬件实现简单，可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路(IC)间的通讯。

下面通过两个层面来讲述：物理层、协议层

物理层（通信模型）

  1. 两线制
    对于IIC 总线，只使用两条总线线路，一条双向串行数据线(SDA) ，一条串行时钟线(SCL)。
    在这里插入图片描述
  2. 挂载在IIC总线上的设备有主从之分，可以同时挂载多个主机和多个从机。
    主机：通信的发起方。所有的通信皆由主机先来发起。
    从机：和主机进行通信。实现数据的交互。
  3. IIC通信中，每一个设备（不论是主机还是从机）都有唯一的ID。
    那么问题来了，在同一根信号线上有那么多的设备挂载，既有主机也有从机，假设主机1想和从机2进行通信，该怎么实现呢。主机1如何精准的找到我想通信的从机呢？这就和设备的唯一的ID有关，主机1可以去信号线上广播想要通信的从机ID，如果对应ID的从机收到了主机1发起的请求，则发送一个应答信号传送给主机1，表示本从机设备收到了主机的通信请求，然后选择是否应答该请求，如果应答则表示同意通信，如果返回给主机1的是一个非应答信号则表示不想与主机1通信。而其他从设备虽然也能接收到主机1的请求，但因为ID不一样，所以无法与主机1通信。
  4. 同一时刻只能有一个主机和一个从机进行通信
    假如在同一个时刻，多个主机同时发起总线请求，也就是说同一时刻多个主机想要占据总线的使用权。此时将会有一个总线仲裁机制来决定到底是哪一个主机能使用信号线进行通信，也就是最终会是谁占据总线的使用权。
    总线仲裁机制使用的是线与特性（总线空闲电平状态为高电平），也就是说谁能先拉低总线谁就能得到总线的控制权限，如果两者都能拉低总线，那就看谁的时间更长，总有一个时刻会有一个主机最终获得线权。那么其他主机就会主动的让出总线的控制权限。
    在这里插入图片描述
  5. 空闲电平状态为高电平。
    在时钟线和数据线上都接了一个上拉电阻。其作用就在于使得IIC总线的空闲电平信号为高电平。这两个上拉电阻的必须要的。
    所以我们在初始化配置GPIO的时候最好给其配置成开漏输出。因为开漏输出是无法自己输出一个高电平的（开漏输出只有低电平状态和高阻态），但是因为IIC设备是一定会接上拉电阻的，所以开漏输出模式下，空闲电平状态将会由上拉电阻来拉高。然而因为我们后面要使用GPIO口模拟的方式来实现IIC协议，所以在这里配置推挽也问题不大，因为在软件模拟的时候，总线的输出高输出低是由我们自己软件控制的。
  6. IIC通信是高位先发，是以字节形式发送的（一次发8位）。
  7. 具有三种传输模式：标准模式传输速率为 100kbit/s ，快速模式为 400kbit/s ，高速模式下可达 3.4Mbit/s。

协议层

协议层主要是定义了通讯的起始和停止信号、数据有效性、响应、仲裁、时钟同步和地址广播等。

1、起始信号

在这里插入图片描述
起始信号是表示通信开始的信号，其表现为：在SCL时钟线为高电平期间，数据线产生一个由高到低的下降沿电平切换。

2、停止信号

在这里插入图片描述
停止信号是表示通信结束的信号，其表现为：在SCL时钟线为高电平期间，数据线产生一个由低到高的下降沿电平切换。

3、数据有效性

在这里插入图片描述
因为我们通过数据线发送的信号有高有低，所以在电平信号进行高低切换的过程当中，需要一定的时间，那么这时可以让此时的数据切换这段时间使得数据无效。在IIC里面，只有当时钟线为高电平的期间，数据才有效。时钟线为低电平的期间，数据是无效的。如果在数据切换期间读取数据有效，那么很可能会将切换电平信号识别成开始信号或结束信号。

4、应答信号
  • 应答：
    在这里插入图片描述
    应答信号：表示一个肯定的回应。其表现为：在时钟线SCL高电平期间，数据线SDA维持一个稳定的低电平。
  • 非应答：
    在这里插入图片描述
    非应答信号：表示一个否定的回应。其表现为：在时钟线SCL高电平期间，数据线SDA维持一个稳定的高电平，当然，有的时候，数据的接收方确实没有收到来自数据的发送方的信号，导致数据的接收方就没有理会数据的发送方，此时也属于非应答信号。

硬件IIC与软件IIC

想要控制STM32产生IIC方式的通讯，可以采用软件模拟或硬件IIC 这两种方式。
硬件IIC直接使用外设来控制引脚，可以减轻 CPU 的负担。不过使用硬件IIC时必须使用某些固定的引脚作为 SCL 和 SDA，软件模拟IIC则可以使用任意GPIO引脚，相对比较灵活。
在本开发板中，由于 STM32RCT6 芯片引脚较少，资源比较紧张，在设计硬件时不方便使用硬件IIC指定的引脚连接外部设备（EEPROM 存储器芯片），所以在控制程序上只能使用软件模拟 IIC的方式。

硬件IIC

硬件IIC是指直接利用 STM32 芯片中的硬件IIC外设，该硬件IIC外设跟 USART串口外设类似，只要配置好对应的寄存器，外设就会产生标准串口协议的时序。使用它的IIC外设则可以方便地通过外设寄存器产生IIC协议方式的通讯，如初始化好IIC外设后，只需要把某寄存器位置 1，那么外设就会控制对应的 SCL 及 SDA 线自动产生IIC起始信号，而不需要内核直接控制引脚的电平。

软件IIC

即直接使用 CPU 内核按照 IIC协议的要求控制 GPIO 输出高低电平。如控制产生IIC的起始信号时，先控制作为 SCL 线的 GPIO 引脚输出高电平，然后控制作为 SDA 线的 GPIO 引脚在此期间完成由高电平至低电平的切换，最后再控制 SCL 线切换为低电平，这样就输出了一个标准的IIC起始信号。

二、温湿度采集

任务要求：

使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集
编程实现：每隔2秒钟采集一次温湿度数据，并通过串口发送到上位机

CubeMX配置

基础配置在之前博客已多次展示，这里就不过多阐述。

  1. GPIO
    在这里插入图片描述
    这里选择PC13口为out-put模式
  2. 开启串口USART1
    在这里插入图片描述
  3. IIC设置
    在这里插入图片描述
    I2C1设置：
    在这里插入图片描述
    开启中断：
    在这里插入图片描述
  4. 配置完工程生成代码
    在这里插入图片描述
    在这里插入图片描述

Keil代码编写

AHT20芯片代码官网下载

1. 将文件复制到CubeMX创建的项目文件夹下

在这里插入图片描述

2. 在Keil中添加文件，并添加头文件路径

在这里插入图片描述
在这里插入图片描述

3. 修改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)  ; //将PB15配置为输出 ， 并设置为高电平， PB15作为I2C的SDA
void SDA_Pin_Output_Low(void);  //将P15配置为输出  并设置为低电平
void SDA_Pin_IN_FLOATING(void);  //SDA配置为浮空输入
void SCL_Pin_Output_High(void); //SCL输出高电平，P14作为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

4. 修改AHT20-21_DEMO_V1_3.c

/*******************************************/
/*@版权所有：广州奥松电子有限公司          */
/*@作者：温湿度传感器事业部                */
/*@版本：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输出高电平，P14作为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_15,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_15,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);
}

5. 修改mian.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "dma.h"
#include "i2c.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include<stdio.h>
#include "AHT20-21_DEMO_V1_3.h" 
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
int fputc(int ch,FILE *f)
{
    HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,0xFFFF);    
		//等待发送结束	
		while(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_TC)!=SET){
		}		

    return ch;
}
/* 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
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
	uint32_t CT_data[2]={0,0};
	volatile int  c1,t1;
	Delay_1ms(500);
  /* USER CODE END 1 */

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

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  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_USART1_UART_Init();
  MX_DMA_Init();
  MX_I2C1_Init();	
  MX_USART1_UART_Init();
	
  /* USER CODE BEGIN 2 */
  AHT20_Init();
	Delay_1ms(500);

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* 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("正在检测");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		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("等待");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		HAL_Delay(100);
		printf(".");
		printf("\r\n");
		HAL_Delay(1000);
    /* USER CODE BEGIN 3 */
  }
  /* 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 */
  1. 在main.c和usart.c中添加头文件#include "stdio.h"之后，勾选Target中的use MicroLIB，在mian.c文件中，添加如下代码，进行重定义。
int fputc(int ch, FILE *f)
 
{
 
  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
 
  return ch;
 
}

编译烧录之

硬件连接

SCL连接PB6，SDA连接PB7

请添加图片描述

效果

请添加图片描述

在这里插入图片描述
成功。

Dylan_hs
关注
STM32用HAL库函数实现硬件IIC
qq_59757948的博客
04-26 2165
这篇笔记我主要介绍代码实现，想要了解原理的请自己看视频，我不过多赘述了。
STM32 I2C协议读取温湿度传感器
cjhz2333的博客
11-23 2827
I2C总线（Inter IC BUS）是由Philips公司开发的一种通用数据总线两根通信线：SCL（Serial Clock）、SDA（Serial Data）同步，半双工带数据应答支持总线挂载多设备（一主多从、多主多从）本次实验我完成了用AHT20传感器收集温度、湿度的数据并发送到电脑的实验。主要了解了一些I2C的知识，结合代码和手册让我对I2C通信的印象更深刻了。
【STM32 HAL库】IIC通信与CubeMX配置
最新发布
AbaAbaxxx_的博客
09-10 1540
本文为笔者学习 IIC 通信的总结，基于keysking的视频内容，如有错误，欢迎指正。
STM32 (基于HAL库) 硬件IIC读写任意AT24CXX芯片
weixin_56565733的博客
04-25 7556
HAL任意AT24Cxx芯片读写： 原理我就不讲了，直接实操： 一、配置 1、使用STM32CUBEMX进行引脚配置，IIC配置如下： 2、利用串口进行数据查看，串口配置如下： 3、时钟我们选择最高72MHZ，这里没有硬性要求都可以。 4、配置完成，生成keil工程代码即可。 到此配置完成。 二、代码 编写驱动文件： HAL_24CXX.c文件代码如下： /*********************************** 适用范围：仅HAL适用 ***********************
HAL库软件IIC读取AT24C02/AT24C32
qq_48211392的博客
02-28 1003
因为SDA线既要用作输出，也要用作输入（从机应答信号），使用开漏模式则可以解决这个问题。当然我们也可以使SDA为推挽输出模式，但是这样每次SDA输出和输入模式转变时都需要重新初始化SDA的GPIO口，比较麻烦。我们把程序分为三部分，第一部分是延时函数和软件IIC函数；main测试函数以及测试结果：（友情提醒，测试软件IIC时可以先从单字节写入读取开始，这样出问题了可以缩小查找范围）为了克服硬件IIC的缺点以及更好了了解IIC协议，下面让我来介绍一下HAL库环境下的软件IIC如何使用。
STM32通过IIC协议实现温湿度采集
m0_72364598的博客
11-20 74
学习到了IIC通信原理及深层知识，也学习到了如何通过AHT20读取采集到的温湿度在实验时要注意传感器的引脚的链接。
STM32HAL库--IIC实验(速记版)
荒野
06-26 870
IIC(Inter-Integrated Circuit)总线是一种由 PHILIPS 公司开发的两线式串行总线，用于连接微控制器以及其外围设备。IIC 是由数据线 SDA和时钟线 SCL构成的串行总线。IIC 总线有如下特点：① 数据线用来传输数据，时钟线用来同步数据收发。② 总线上每个器件都有唯一器件地址，只需知道器件地址，根据时序即可实现微控制器与器件之间的通信。③ 数据线 SDA 和时钟线 SCL都是双向线路空闲时都是 SDA 和 SCL 都是高电平。
STM32F1-HTU21D温湿度传感器软件或硬件IIC数据读取
03-24
综上所述，STM32F1与HTU21D的IIC通信涉及软件模拟和硬件驱动两种方式，理解I2C协议及传感器的操作指令，结合HAL库或标准库的使用，可以实现稳定的数据读取。在实际项目中，应充分测试和验证，确保系统的可靠运行。
0048基于STM32F103单片机IIC读取AHT10温湿度传感器值的程序代码.rar
12-27
1、STM32F103通过IIC接口与AHT10温湿度传感器进行通讯，读取传感器温湿度值。 2、代码使用KEIL开发，当前在STM32F103C8T6运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量即可。 ...
HDC1080驱动 温湿度 STM32 IIC I2C
12-05
标题中的“HDC1080驱动 温湿度 STM32 IIC I2C”指的是一个基于STM32微控制器的驱动程序，用于与HDC1080温湿度传感器进行通信。HDC1080是一款高精度的数字式温湿度传感器，广泛应用于智能家居、环境监测以及物联网...
STM32（HAL库）软件IIC驱动OLED
weixin_44597885的博客
07-17 7562
本文通过STM32F103C8T6单片机（HAL库）通过软件IIC方式对OLED进行驱动。
HAL库-iic.rar
05-19
基于HAL库的iic
stm32l051 温湿度传感器接入HAL库
08-08
在本项目中，我们将使用STM32L051与AM231X温湿度传感器进行通信，通过HAL库实现模拟IIC（Inter-Integrated Circuit）总线，从而读取并显示传感器数据。 首先，我们需要了解HAL库。HAL库是ST公司为STM32微控制器设计...
【第六章】STM32 / GD32 - 软件I2C读取温度传感器LM75AD
Xiaoxuexxxxx的博客
04-24 1606
最后详细叙述一下通讯过程：1.开始：主设备把SDA从高拉低再把SCL从高拉低，对总线上的从机说：我要开始和你们中的某个人通信了。2.主设备发送要与之通信的从机的7位地址（一般是7位），第八位是读写位（读1写0）3.总线上的从设备把主设备发送的地址与自己的地址比较，如果匹配：从设备将SDA拉低一位表示应答（此时从设备获得SDA的控制权，之前SDA都是主设备控制的）。如果不拉低，SDA为高就表示非应答。4.主设备发送（或接收）数据给从设备。
【STM32】STM32通过I2C实现温湿度采集与显示
2201_75516394的博客
06-23 1194
(2)主设备接着发送8bit数据，其中7位是从设备的地址，一位表示此次主设备是要读数据海思写数据；I2C通信时，分为主设备和从设备，其中主设备一个、从设备多个。主设备要主导整个通信过程，从设备根据I2C协议被动的响应主设备；在同一时间，只有主设备和其中一个从设备通信，其余的从设备处于等待状态，等待主设备与其通信；每个从设备在I2C总线上都有唯一的地址，主设备就是通过地址来区分不同的从设备，从而决定和哪一个从设备通信。SCL：时钟线，用于传输CLK信号，一般是I2C主设备向从设备提供时钟的通道。
Stm32F103 Hal库硬件iic 访问AM2320温湿度传感器
weixin_43932857的博客
11-24 1194
Stm32F103 Hal库硬件iic 访问AM2320温湿度传感器 管脚配置 PB6 PB7 之前用库函数，一直读不到，换hal库后正常了，因为要在android板上调试，但是板卡没来，只好用stm32 先调试下。 很简单，先初始化i2C1 i2c.c I2C_HandleTypeDef hi2c1; /* I2C2 init function */ void MX_I2C1_Init(void) { hi2c1.Instance = I2C1; hi2c1.Init.ClockSpeed = 10
STM32基于IIC协议读取温湿度数据
Yokuershi的博客
11-07 221
I2C"是一种常见的串行通信协议，用于在不同的集成电路（IC）之间传输数据。有两种主要的I2C实现方式，即"软件I2C"和"硬件I2C”，它们在通信方式和实现方式上有所不同。此次实验内容为通过STM32微控制器使用I2C协议读取与AHT20温湿度传感器连接的温度和湿度数据。在连接硬件时，务必小心，确保正确接线，防止损坏设备。在代码编写中，注意I2C通信的初始化和配置，以确保通信的顺利进行。根据AHT20传感器的数据手册，正确解析温湿度数据。
HAL库使用IIC
qq_44907649的博客
05-21 3046
HAL库使用IIC 选择主从模式和速度 直接调用IIC函数 函数原型： * @brief Write an amount of data in blocking mode to a specific memory address * @param hi2c Pointer to a I2C_HandleTypeDef structure that contains * the configuration information for the specified I2C. * @par
STM32--HAL库IIC
qq_42425882的博客
04-10 7598
HAL库IIC相关函数
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dylan_hs

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值