STM32温湿度采集与OLED显示

最新推荐文章于 2025-04-22 14:28:05 发布
最新推荐文章于 2025-04-22 14:28:05 发布
阅读量1.8k 收藏 29
点赞数 37
CC 4.0 BY-SA版权
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yehoy/article/details/144472151

本片文章学习https://blog.youkuaiyun.com/jynyyhd/article/details/127834397

https://blog.youkuaiyun.com/qq_53088119/article/details/127886368

https://blog.youkuaiyun.com/m0_74327085/article/details/139563525

https://blog.youkuaiyun.com/m0_74327085/article/details/139770136

一.stm32通过I2C接口实现温湿度（AHT20）的采集

学习I2C总线通信协议，使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集，并将采集的温度-湿度值通过串口输出。

(1).什么是“软件I2C”和“硬件I2C”？

1. 软件 I2C（Bit-banged I2C）

软件 I2C 是指通过 软件控制 I2C 总线的时钟信号（SCL）和数据线（SDA），模拟实现 I2C 通信的过程。这通常被称为 bit-banging，即通过控制GPIO（通用输入输出）引脚的电平变化来模拟 I2C 协议中的时序。

  • 工作原理：在软件 I2C 中，开发者通过编写程序，使用微控制器的普通 GPIO 引脚（而不是专用的硬件 I2C 引脚）来生成 SCL 和 SDA 信号。每当需要一个 I2C 时钟周期时，软件通过切换 GPIO 的电平来模拟时钟信号的生成；同样，数据传输也通过软件控制在 SDA 线上设置相应的电平。
  • 优点：
    • 灵活性：软件 I2C 可以在任何 GPIO 引脚上实现，不受硬件限制。
    • 低成本：如果微控制器没有硬件 I2C 支持，可以通过软件实现 I2C 通信。
    • 可调性：开发者可以控制时序，因此可以在一定范围内调整通信速率。
  • 缺点：
    • 速度较慢：因为 I2C 通信时钟是由软件控制的，所以速度通常比硬件 I2C 慢，尤其在高速通信时会受到限制。
    • CPU 占用高：软件实现的 I2C 需要大量的 CPU 时间来控制 GPIO 引脚，可能会影响其他任务的执行。
    • 可靠性差：由于是软件模拟，时序的精确性和稳定性较差，可能容易受到外部干扰或微控制器负载变化的影响。

2. 硬件 I2C

硬件 I2C 是指通过微控制器内部的专用硬件模块来实现 I2C 通信。这些硬件模块是专门设计用来处理 I2C 协议的，可以直接控制 SCL 和 SDA 信号，而无需使用 CPU 软件来模拟时序。

  • 工作原理：在硬件 I2C 中，微控制器会通过内建的 I2C 外设来生成和管理 SCL 和 SDA 信号。硬件 I2C 控制器自动生成时序，并负责数据的传输和接收。开发者通常只需要通过简单的 API 来发送或接收数据。
  • 优点：
    • 速度快：硬件 I2C 通信的速度通常较快，因为硬件模块处理时序和数据传输，比软件模拟更高效。
    • CPU 占用低：硬件 I2C 会自动处理数据的发送和接收，CPU 只需要进行简单的控制和配置，因此能腾出更多的处理时间来执行其他任务。
    • 稳定性高：由于由专门的硬件控制时序，硬件 I2C 更加稳定，通信可靠性高，不容易受到外部干扰。
  • 缺点：
    • 灵活性差：硬件 I2C 限制于微控制器的硬件资源，通常每个微控制器上只有几个 I2C 接口，并且硬件模块对引脚的要求更严格。
    • 需要支持硬件的芯片：只有具备 I2C 硬件模块的微控制器才能使用硬件 I2C。如果你的设备不支持硬件 I2C，则只能使用软件 I2C。

3. 何时选择软件 I2C 或硬件 I2C？

  • 使用软件 I2C：当你使用的微控制器没有硬件 I2C 模块，或者需要灵活地选择通信引脚时，可以选择软件 I2C。对于一些低速设备或开发阶段，软件 I2C 也能满足基本需求。

  • 使用硬件 I2C：如果你的应用对通信速度、稳定性和 CPU 占用有较高要求，或者设备支持硬件 I2C，则应优先选择硬件 I2C。

总的来说，硬件 I2C 在性能和稳定性上更具优势，而 软件 I2C 提供了更大的灵活性，但在高性能要求下不如硬件实现。

(2).实现：每隔2秒钟采集一次温湿度数据，并通过串口发送到上位机（win10）（基于HAL库，芯片TM32F103C8T6)

配置cubemx项目文件

RCC

SYS

USART1

 GPIO

I2C1

NVIC

设置时钟

项目配置

然后打开keil项目。

配置keil文件

事先准备AHT20芯片代码，将其放在创建的keil文件同目录下。

在keil项目中打开添加文件设置，

添加对应文件。

完成后找到魔术棒点击

选择你刚刚添加进去的AHT文件，然后开始修改代码。

 修改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

修改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);
}

 修改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 */

然后编译烧录，在连接上传感芯片，SCL连接PB6，SDA连接PB7，GND接地，VDD接电源，

结果

打开串口助手后不断传输测量数据，手指捂住传感器温湿度有明显变化。

二.OLED屏显

(1).简单显示和滚动显示

配置cubemx项目文件

这个选择的话可以避开前面的温湿度传感器配备PB6和PB7引脚的使用，这里使用0.96OLED显示屏用的是PB10和PB11

配置keil文件

u8g2库的移植使用，字模的使用，直接去看本文开头第三个链接，这里直接展示在那个基础上修改的主函数代码部分，其他部分均未修改，

#include "i2c.h"
#include "tim.h"
#include "gpio.h"

#include "stm32_u8g2.h"
#include "test.h"

static const unsigned char mao[] = {
0x00,0x88,0x44,0x88,0x2B,0xFE,0x10,0x88,0x28,0x88,0x48,0x00,0x89,0xFC,0x09,0x24,0x19,0x24,0x29,0x24,0x49,0xFC,0x89,0x24,0x09,0x24,0x09,0x24,0x51,0xFC,0x21,0x04
};
static const unsigned char feng[] = {
0x10,0x40,0x10,0x40,0x10,0xFC,0x7C,0x88,0x55,0x50,0x54,0x20,0x54,0xD8,0x57,0x26,0x7C,0xF8,0x50,0x20,0x10,0xF8,0x14,0x20,0x1F,0xFE,0xE4,0x20,0x40,0x20,0x00,0x20
};

void SystemClock_Config(void);

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_I2C2_Init();
    MX_TIM1_Init();
    u8g2_t u8g2;
    u8g2Init(&u8g2);
    u8g2_SetFont(&u8g2, u8g2_font_ncenB12_tf);
    unsigned int x = 0;
    while (1)
    {
       if (x <= 128)
       {
           x++; 
       }
       else if (x > 128)
       {
           x = 0; 
       }
       u8g2_DrawXBMP(&u8g2, x + 16, 0, 16, 16, mao);
       u8g2_DrawXBMP(&u8g2, x + 32, 0, 16, 16, feng);
       u8g2_SetFont(&u8g2, u8g2_font_ncenB10_tf);
       u8g2_DrawStr(&u8g2, 16, 50, "632207030318");
       u8g2_SendBuffer(&u8g2);
       HAL_Delay(100);
    }
}

结果

在上述代码中x变量可以省略，那个是为了让我的字滚动显示的粗略设置，编译无误后烧录进去就行，因为有那个x变量所以看起来不美观（SDA接PB11，SCL接PB10）

OLED显示

(2).显示AHT20的温度和湿度

具体去看第四个链接

配置cubemx项目文件

跟上一个一样，不过需要多加上一个I2C1的设置去使用温湿度传感器

配置keil文件

也是主要展示main.c的部分

#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±¶£©
		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****/

结果

手捂住有明显变化

温湿度OLED

CatBee.
关注
STM32-温湿度采集与OLED显示
gqiaos524的博客
12-13 1289
STM32的I2C外设可用作通讯的主机及从机，支持标准速度模式（高达100Kbit/s）、快速模式（高达400Kbit/s）、超快速模式（高达1Mbit/s），支持7位、10位设备地址，支持DMA数据传输，并具有数据校验功能。它的I2C外设还支持SMBus2.0协议，SMBus协议与I2C类似，主要应用于笔记本电脑的电池管理中，本教程不展开，感兴趣的读者可参考《SMBus2.0》文档了解。OLED（Organic Light - Emitting Diode）即有机发光二极管。
stm32采集显示温湿度&通过IIC实现OLED屏显示
HuaijinD的博客
12-15 2275
详细介绍了 I2C 协议中软件 I2C 和硬件 I2C 的区别。软件 I2C 通过单片机的 I/O 端口模拟，灵活性高；硬件 I2C 使用芯片上的 I2C 外设，通信更快更稳定，但引脚固定。通过 stm32cubemx 配置相关引脚和外设，在 keil 中编写 AHT20 驱动程序，实现了每隔 2 秒采集温湿度数据并通过串口发送到上位机。采用 U8g2 图形库进行 OLED 显示。
基于stm32手机端蓝牙控制采集温湿度
Wangxiangang9527的博客
07-06 4111
基于stm32手机端蓝牙控制采集温湿度 使用串口一与PC端通信，使用串口二与通过蓝牙模块与手机端通信 使用手机控制阈值上下限，并通过比较采集到的值，超过阈值则报警。 串口初始化 #if SYSTEM_SUPPORT_OS #include "includes.h" //ucos 使用 #endif #if 1 #pragma import(__use_no_semihosting) //标准库需要的支持函数 stru
STM32学习笔记（一）微项目 使用STM32F103实现温湿度的采集
qq_64813512的博客
06-15 2404
总结就是理解DHT11采集温湿度的原理，就很好做出来。是挺抽象的，我的文章。
【STM32】温湿度采集与OLED显示
normog的博客
06-23 1051
I2C 通讯协议 (Inter － Integrated Circuit) 是由 Phiilps 公司开发的，由于它引脚少，硬件实现简单， 可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路 (IC) 间的通讯。通过本次实验，详细了解到了I2C总线协议，以及AHT20温湿度传感器的使用。以上为此次学习成果，如有问题，烦请指正。
【stm32】——温湿度采集与OLED显示
2201_75518371的博客
06-23 1252
I2C总线是一种主从结构（Master/Slave）总线，I2C总线上每一个设备都可以作为主设备或从设备，但一个总线上一般只有一个主设备，可以带多个从设备。其中主设备用来产生允许传输的时钟信号，并初始化总线的数据传输，所以主设备通常是CPU；而从设备只能被动响应主设备发起的通信请求，所以各种I2C接口芯片将作为从设备使用。I2C具有以下特点：I2C总线由两根线组成，即SDA（串行数据线）和SCL（串行时钟线）。SDA线用于数据传输，SCL线用于同步数据传输。
基于STM32的温湿度采集——OLED显示
qq_45874317的博客
11-26 1321
一、实现温湿度通过串口显示 具体参考STM32通过I2C接口实现温湿度（AHT20）的采集_暮雪千的博客-优快云博客 二、实现将温湿度采集数据显示到OLED 本过程是基于上面实现串口显示的工程上，进行添加相关OLED的代码 将文件添加进去之后 开始编译显示部分的代码 显示温度的代码 void read_AHT20(void) { uint8_t i; for(i=0; i<6; i++) { readByte[i]=0; } //-------------..
内置 I2C模块的 STM32F030
05-08
STM32F030内部外设I2C模块介绍
（开源|含代码）STM32RCT6读取SHT30温湿度数据I2C通讯协议
Shuger_Money的博客
01-14 265
I2C 温湿度传感器 SHT30
STM32F030硬件i2c驱动
03-08
实测可用。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
基于Java的温室花卉温湿度监控系统
毕业设计大牛哥
01-04 573
基于Java的温室花卉温湿度监控系统，能够实现温室环境的实时监控、数据存储、报警和控制功能。通过该系统，用户可以方便地了解温室内的温湿度情况，及时调整环境设备，确保花卉生长的环境质量。此外，系统界面简洁明了，用户体验良好。通过不断完善和优化，该系统有望在现代农业中发挥更大的作用。
java代码获取温度传感器数据
weixin_41085013的博客
07-26 410
Java代码获取温度传感器数据 在物联网(IoT)领域，温度传感器是最常见的传感器之一，用于监测环境温度。本文将介绍如何使用Java代码获取温度传感器的数据，并展示数据的可视化。 温度传感器简介 温度传感器是一种将温度变化转换为电信号的设备。常见的温度传感器有热电偶、热敏电阻、数字温度传感器等。本文以数字温度传感器DS18...
【STM32F103笔记】9、I2C通信——玩转OLED（OLED命令详解）
热门推荐
TTZZWWW
03-15 1万+
I2C通信——玩转OLED（OLED命令详解）I2C介绍I2C主机模式通信格式I2C寄存器1、Control register 1 (I2C_CR1)2、Control register 2 (I2C_CR2)3、Own address register 1 (I2C_OAR1)4、Own address register 2 (I2C_OAR2)5、Data register (I2C_DR)6...
STM32F103，OLED（模拟I2C/IIC），中文/图片显示详细新手入门教程
Wsy445257918的博客
11-27 1804
温馨提示，本篇文章较长，请通过左边的目录选择。本次教程不讲废话，只讲硬菜，请按需进食（点击左边目录，选择自己想要了解的部分）。本次实验使用的是0.96寸，4针脚的oled显示屏，接下来我将讲解如何让oled显示单个字符，字符串，数字，汉字，图片。
SHT30温湿度传感器程序
最新发布
gitblog_06730的博客
04-22 235
SHT30温湿度传感器程序 去发现同类优质开源项目:https://gitcode.com/ 简介 本程序是基于STM32F103C8T6微控制器，通过I2C总线驱动SHT30温湿度传感器的代码。该程序能够实现从SHT30传感器采集温度和湿度数据，并通过串口实时打印输出，方便用户进行二次开发。 功能特点 驱动I2C总线的SHT30温湿度传感器 实时采集温度和湿度数据 通过串口打印输出数据 支持二...
ESP8266作为客户端上传DHT11温湿度给私人java服务器
niruxi0401的博客
07-03 952
系列文章目录 第一章ESP8266的java软件仿真测试 第二章ESP8266硬件与软件测试 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、这次要做的是什么？二、使用步骤1.下载源码2.读入数据总结 前言 daodanjishui物联网核心原创技术之ESP8266客户端与Java服务器通信实战 提示：以下是本篇文章正文内容，下面案例可供参考 一、这次要做的是什么？ 在上期分享的 “ESP8266作为客户端连上网络调试助手服务器”的资料中，也就是第二章的
【STM32】温湿度传感器的使用
m0_53887937的博客
01-10 2204
简单的学习记录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值