stm32+OLED+AHT20-显示温度时间日期

最新推荐文章于 2024-07-09 10:20:43 发布

要换系统啦

最新推荐文章于 2024-07-09 10:20:43 发布

阅读量872

点赞数 5

文章标签： stm32 嵌入式硬件单片机

本文链接：https://blog.csdn.net/weixin_66084944/article/details/134521951

版权

本文任务

读取AHT20的温度和湿度，通过OLED，把年月份时分秒、日历和实时温度、湿度显示出来，2秒周期。

AHT20介绍

在这里插入图片描述
AHT20是一款由法国Hall传感器公司生产的数字温湿度传感器，它具有高精度、低功耗、数字输出等特点，广泛应用于温湿度监测、空气质量检测、智能家居等领域。下面将详细介绍AHT20的原理、配置步骤、注意事项等。

原理

AHT20传感器基于热敏电阻和电容式湿度传感器的原理，能够同时测量温度和湿度。热敏电阻能够感应温度的变化，而电容式湿度传感器则能够感应空气中的湿度。

在AHT20中，热敏电阻和湿度传感器被放置在一个封装中，通过内部的电路进行信号处理和数字化输出。当温度变化时，热敏电阻的阻值会发生变化，从而引起电压的变化；而当湿度变化时，电容式湿度传感器的电容值也会发生变化，从而引起频率的变化。这两个信号经过内部处理后，通过I2C接口输出数字信号，可以方便地进行读取和传输。

配置步骤

硬件连接

将AHT20传感器与微控制器或单片机的I2C接口相连。需要注意的是，AHT20的I2C地址是固定的，不能修改。具体连接方式如下：

（1）VCC：连接到电源；
（2）GND：连接到地线；
（3）SDA：连接到I2C总线的SDA接口；
（4）SCL：连接到I2C总线的SCL接口。

软件配置

在软件方面，需要编写程序来读取AHT20传感器的数据。下面以Arduino平台为例，介绍如何读取AHT20的数据：

（1）包含所需的头文件：在Arduino代码中添加“#include <Wire.h>”；（2）定义I2C地址：根据AHT20的I2C地址，定义一个byte类型的变量存储地址，例如byte addr = 0x5c；（3）初始化I2C接口：使用Wire.begin()函数初始化I2C接口；（4）发送读取命令：使用Wire.beginTransmission(addr)函数发送AHT20的读取命令；（5）读取传感器数据：使用Wire.read()`函数读取传感器数据；
（6）解析数据：将读取的数据解析成温度和湿度值。

数据解析

AHT20传感器输出的是原始数据，需要经过解析才能得到温度和湿度值。AHT20的数据格式如下：

前8位是温度数据的原始值；
中间8位是温度数据的符号位，正数时为0，负数时为1；
后8位是湿度数据的原始值；
最后一位是湿度数据的符号位，正数时为0，负数时为1。
根据这个数据格式，可以编写程序进行解析。需要注意的是，AHT20的数据是经过校准和补偿的，所以解析出来的值应该是比较准确的结果。

注意事项

AHT20传感器需要避免长时间暴露在高温高湿的环境中，以免影响其测量精度和使用寿命。
在进行硬件连接时，需要确认电源电压是否符合AHT20的额定电压要求，以免损坏传感器或影响测量精度。
在进行软件配置时，需要正确设置I2C地址和其他参数，以免出现通信错误或测量错误。

OLED介绍

在这里插入图片描述

OLED，即有机发光显示器（Organic Light-Emitting Display），是一种新型的显示技术，具有自发光、视角广、色彩鲜艳、响应速度快等特点，被广泛应用于智能手机、电视、电脑、平板电脑、智能手表等领域。下面将详细介绍OLED的原理、配置步骤和注意事项。

原理

OLED显示器的原理是基于有机发光材料的特性。当在有机材料上施加电压时，电子和空穴会向基态跃迁，并在基态上形成激子。激子会进一步分解为低能态的电子和空穴，同时释放出能量，激发有机材料发光。这种自发式的发光方式使得OLED显示器具有自发光的特性，可以独立控制每个像素的亮度。

OLED显示器按照驱动方式可以分为被动式和主动式两种。被动式OLED显示器采用薄膜晶体管（TFT）作为背板，每个像素由薄膜晶体管控制，具有结构简单、制造工艺成熟等优点。而主动式OLED显示器则采用有源驱动方式，每个像素配备一个薄膜晶体管和存储电容，可以独立控制每个像素的亮度和灰度。

配置步骤

硬件连接

将OLED显示器与微控制器或单片机的I2C接口相连。需要注意的是，OLED显示器的I2C地址是固定的，不能修改。具体连接方式如下：

（1）VCC：连接到电源；
（2）GND：连接到地线；
（3）SDA：连接到I2C总线的SDA接口；
（4）SCL：连接到I2C总线的SCL接口。

软件配置

在软件方面，需要编写程序来控制OLED显示器显示文本或图像。下面以Arduino平台为例，介绍如何配置OLED显示器：

（1）包含所需的头文件：在Arduino代码中添加“#include <Adafruit_GFX.h>”；（2）定义OLED显示器对象：在代码中定义一个Adafruit_SSD1306类型的对象，例如Adafruit_SSD1306 display(128, 64, &Wire, -1);；（3）初始化I2C接口：使用Wire.begin()函数初始化I2C接口；（4）设置OLED显示器对象：使用display.begin()函数设置OLED显示器对象，例如display.begin(SSD1306_SWITCHCAPVCC, 0x3C);；（5）显示文本或图像：使用display.drawString()或display.drawBitmap()`函数显示文本或图像。

图像转换

由于OLED显示器是自发光器件，每个像素的颜色可以独立控制，因此需要将待显示的图像转换为像素数据才能显示。图像转换可以使用图形库或自定义代码实现。需要注意的是，图像转换需要考虑到OLED显示器的分辨率和颜色空间等因素。

注意事项

OLED显示器需要避免长时间连续工作在高亮度状态下，以免影响其使用寿命。
在进行硬件连接时，需要确认电源电压是否符合OLED显示器的额定电压要求，以免损坏显示器或影响显示效果。
在进行软件配置时，需要正确设置I2C地址和其他参数，以免出现通信错误或显示错误。

功能实现设计

硬件设计

在硬件方面，我们选择了STM32F103C8T6微控制器作为主控制器，它具有高性能、低功耗和丰富的外设接口，非常适合用于嵌入式系统的开发。AHT20温湿度传感器则被用来监测环境中的温度和湿度，这款传感器具有高精度、低功耗、数字输出等优点，数据传输速度快，方便我们进行实时监测。此外，我们还使用了SSD1306 OLED显示屏，它具有高对比度、宽视角、低功耗等优点，同时支持中文字符集显示，可以很好地满足我们的需求。

在硬件设计中，我们首先搭建了电源系统，为各个硬件组件提供稳定的电源。接着，我们通过I2C接口连接STM32微控制器、AHT20传感器和SSD1306 OLED显示屏，确保它们之间的通信畅通。此外，我们还连接了STM32的内置时钟或外部时钟模块，获取当前的时间信息。

软件设计

在软件方面，我们使用STM32CubeIDE进行开发，这是一个基于Eclipse的集成开发环境，提供了丰富的开发工具和函数库，方便我们进行程序的编写和调试。

首先，我们编写了初始化代码，初始化STM32微控制器、AHT20传感器和SSD1306 OLED显示屏，并建立通信连接。接着，我们通过STM32微控制器读取AHT20传感器的温度和湿度数据，并使用内置时钟或外部时钟模块获取当前的时间信息。然后，我们对读取到的数据进行处理，去除无效数据，确保数据的准确性和可用性。最后，我们将处理后的数据显示在SSD1306 OLED显示屏上，实现实时的时间、温度和湿度信息展示。

为了实现实时更新和刷新显示的数据，我们使用了循环结构，不断循环读取数据、处理数据、显示数据，保证数据的实时性。此外，我们还编写了相应的延时函数和异常处理函数，确保程序的稳定性和可靠性。

通过以上硬件和软件设计，我们成功实现了STM32-OLED显示时间+温度和湿度的功能。这个设计可以帮助用户方便地获取环境信息，并进行实时监测和调整。同时，这个设计也展示了STM32微控制器和OLED显示屏的强大功能和灵活性，为用户提供了一个实用且易于使用的解决方案。

工程配置

AHT20的代码

/*******************************************/
/*@????:??????????          */
/*@??:?????????                */
/*@??:V1.2                              */
/*******************************************/
//#include "main.h" 
#include "AHT20.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);
}

OLED代码

见链接：https://blog.csdn.net/weixin_66084944/article/details/134466278
再将需要显示的汉字用取模软件取出来，例如：
在这里插入图片描述

0x00,0x20,0x18,0xC7,0x44,0x44,0x44,0x44,0xFC,0x44,0x44,0x44,0x44,0x04,0x00,0x00,
0x04,0x04,0x04,0x07,0x04,0x04,0x04,0x04,0xFF,0x04,0x04,0x04,0x04,0x04,0x04,0x00,/*"年",0*/
0x00,0x00,0x00,0xFE,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0xFE,0x00,0x00,0x00,
0x80,0x40,0x30,0x0F,0x02,0x02,0x02,0x02,0x02,0x02,0x42,0x82,0x7F,0x00,0x00,0x00,/*"月",1*/
0x00,0x00,0x00,0xFE,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0xFE,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xFF,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xFF,0x00,0x00,0x00,0x00,/*"日",2*/

OLED_ShowHZ(1,2,18);//日期
OLED_ShowHZ(1,4,20);//
		
OLED_ShowNum(1,7,year,4);//2023
OLED_ShowHZ(1,11,22);//年
		
OLED_ShowNum(1,13,month,2);//11
OLED_ShowHZ(1,15,24);//月
		
OLED_ShowNum(2,1,day,2);//20
OLED_ShowHZ(2,3,26);//日
		
OLED_ShowNum(2,5,hour,2);//15
OLED_ShowHZ(2,7,30);//时
		
OLED_ShowNum(2,9,min,2);//40
OLED_ShowHZ(2,11,32);//分
		
OLED_ShowNum(2,13,s,2);//s
OLED_ShowHZ(2,15,28);//秒

结果呈现

在这里插入图片描述

总结

在这次实验中，我成功地利用STM32微控制器和OLED显示屏实现了实时显示时间、温度和湿度的功能。这个过程让我对嵌入式系统的开发有了更深入的体验和理解，也让我收获了一些宝贵的经验和教训。

首先，通过这个实验，我对STM32微控制器有了更深入的了解。我学会了如何初始化和配置微控制器，以及如何编写和调试驱动程序。我认识到STM32微控制器在嵌入式系统中的重要作用，它不仅具有高性能和低功耗的优点，还具有丰富的外设接口，方便我们进行各种应用开发。

其次，我对OLED显示屏的操作和原理也有了更深入的了解。通过与STM32微控制器的连接和编程，我成功地实现了数据的显示和刷新。这个过程中，我了解到OLED显示屏的优点，如高对比度、宽视角、低功耗等，并且意识到它在嵌入式系统中的广泛应用。

此外，我还成功地与AHT20温湿度传感器进行了结合，获取到了环境温度和湿度的数据，并通过OLED显示屏进行了实时显示。这个过程中，我了解到传感器在嵌入式系统中的重要性，以及如何通过读取传感器数据并进行处理和显示。

除了硬件方面的收获，这个实验也让我在软件编程方面得到了锻炼。我学会了如何使用Keil编写和调试程序，如何处理和显示从传感器获取的数据。这些技能不仅对我在嵌入式系统开发方面有很大的帮助，也提升了我的编程能力和问题解决能力。

总的来说，这次实验让我对STM32微控制器、OLED显示屏和温湿度传感器有了更深入的了解，并且提升了我的嵌入式系统开发能力和编程技巧。这些经验和知识将对我今后的学习和工作产生积极的影响。

通过这个实验，我也明确了自己在嵌入式领域的兴趣和发展方向。我将继续深入学习和探索STM32微控制器和相关技术，不断提升自己的能力，为嵌入式系统的开发和应用做出更多的贡献。同时，我也意识到嵌入式系统开发需要综合运用多学科知识的能力，包括电子、计算机硬件、软件以及物理等多个领域的知识。因此，我将继续拓宽自己的知识面，不断提高自己的综合素质，以更好地适应嵌入式系统开发的需求。

此外，我也认识到嵌入式系统开发需要耐心和细心。在实验过程中，我遇到了许多问题和挑战，如通信故障、数据不稳定等。我通过反复调试和测试才解决了这些问题。这个过程让我认识到开发嵌入式系统需要具备耐心和细心，不能急于求成，要认真对待每一个细节问题。

最后，我认为这个实验对我未来的学习和工作有很大的启示作用。它让我认识到嵌入式系统开发的重要性和实用性，也让我明确了自己的兴趣和发展方向。我将以此为契机，继续深入学习和探索嵌入式系统的开发和应用，为未来的学习和工作做好充分的准备。