当前位置：物联沃-IOTWORD物联网 > 技术教程 > 【嵌入式】STM32进阶：OLED显示时间、温度和湿度
代码收藏家代码收藏家 技术教程

【嵌入式】STM32进阶：OLED显示时间、温度和湿度

【嵌入式】STM32进阶-OLED显示时间+温度和湿度

  • 0.前言
  • 1.温度传感器—AHT20
  • 2.OLED显示屏—SSD1306
  • 3.系统板—STM32F103C8T6
  • 4.功能的实现
  • 4.1设计目标
  • 4.2硬件设计
  • 4.3软件设计
  • 5.代码的实现
  • 5.1 AHT20的代码
  • 5.2 OLED的代码
  • 6.实验效果
  • 6.1编译
  • 6.2烧录
  • 7.总结

    • 0.前言

    在本次实验中，我们将学习如何使用STM32微控制器和OLED显示屏，实现显示时间、温度和湿度的功能。这个应用场景在很多项目中都非常常见，例如室内温湿度监测、气象站等。
    在现代生活中，对时间、温度和湿度的监测和显示具有重要的意义。无论是在家庭、办公室还是工业环境中，了解当前的时间和环境条件都是必要的。通过将这些信息实时显示在OLED屏幕上，我们可以方便地获取这些数据，从而更好地管理和调整我们的生活和工作。
    在过去，通常需要使用多个独立的设备来获取这些信息，例如时钟、温度计和湿度计等。但是，通过本次实验，我们可以利用STM32微控制器的强大功能和OLED显示屏的高度可定制性，将这些功能集成到一个设备中。这样一来，我们不仅可以减少设备的数量和复杂度，还可以提高信息的集成度和可视性。
    本次实验的应用背景和价值在于：

    1. 实时显示：通过使用STM32微控制器和OLED显示屏，我们可以实时显示当前的时间、温度和湿度，无需额外的设备或操作。
    2. 一体化设计：将时间、温度和湿度的功能集成到一个设备中，可以减少设备数量和占用空间，提高设备的整体美观性和易用性。
    3. 数据记录和分析：通过将温湿度数据记录到STM32的存储器中，我们可以进行后续的数据分析和处理，例如绘制温湿度曲线图或进行数据比较。
    4. 应用扩展：在基础的时间、温度和湿度显示功能上，我们还可以扩展其他功能，例如报警功能、历史数据查询等，以满足不同应用场景的需求。

    总之，本次实验将带领我们实现一个功能强大且实用的应用，通过STM32微控制器和OLED显示屏，实时显示时间、温度和湿度。这个实验不仅有实际应用的价值，还可以帮助我们更深入地理解和掌握STM32的开发和应用。

    1.温度传感器—AHT20

    温度传感器类型 AHT20
    工作原理 AHT20是一种数字温湿度传感器，采用电容式测量原理。它通过测量气体的电容变化来确定温度和湿度。
    优点 AHT20具有以下优点：高精度测量、低功耗、快速响应时间、数字输出、宽温度和湿度测量范围、抗干扰性能好。
    接口 AHT20采用I2C接口进行通信，可以与微控制器等设备进行直接连接。
    温度测量范围 -40℃至+85℃
    温度测量精度 ±0.3℃
    湿度测量范围 0%RH至100%RH
    湿度测量精度 ±2%RH
    供电电压 2.1V至3.6V
    应用领域 AHT20广泛应用于温湿度监测和控制领域，例如室内环境监测、气象站、温湿度记录仪等。

    以上表格为对AHT20温度传感器的介绍，AHT20是一种数字温湿度传感器，具有高精度测量、低功耗、快速响应时间等优点。它采用I2C接口进行通信，可直接连接到微控制器等设备。AHT20的温度测量范围为-40℃至+85℃，温度测量精度为±0.3℃。湿度测量范围为0%RH至100%RH，湿度测量精度为±2%RH。它的供电电压范围为2.1V至3.6V。AHT20广泛应用于温湿度监测和控制领域，例如室内环境监测、气象站、温湿度记录仪等。

    2.OLED显示屏—SSD1306

    OLED简介 SSD1306
    OLED全称 有机发光二极管显示器（Organic Light Emitting Diode）
    工作原理 OLED是一种自发光显示技术，具有非常高的对比度、快速响应、广视角和低功耗等特点。它通过有机发光材料的电流通过产生光来显示图像。
    优点 OLED具有以下优点：高对比度、鲜艳的颜色、快速响应时间、广视角、低功耗、薄型轻巧、可弯曲和透明等。
    控制芯片 SSD1306
    接口 SSD1306控制芯片通过I2C或SPI接口与主控器连接。
    分辨率 SSD1306支持多种分辨率配置，常见的有128×64和128×32。
    显示颜色 SSD1306支持单色和多色显示，常见的有单色（白色或蓝色）和多色（16位色、256位色等）。
    特殊功能 SSD1306具有一些特殊功能，例如显示缓冲区、显示翻转、屏幕亮度调节等。
    应用领域 OLED广泛应用于便携式设备、智能穿戴设备、电子产品、工业控制、车载显示等领域。

    以上表格为对SSD1306 OLED控制芯片的介绍。OLED是一种自发光显示技术，具有高对比度、快速响应、低功耗等优点。SSD1306是常用的OLED控制芯片，通过I2C或SPI接口与主控器连接。SSD1306支持多种分辨率配置和显示颜色，具有一些特殊功能如显示缓冲区、显示翻转、屏幕亮度调节等。OLED广泛应用于便携式设备、智能穿戴设备、电子产品、工业控制、车载显示等领域。

    3.系统板—STM32F103C8T6

    STM32F103C8T6简介
    芯片系列 STM32F1系列
    芯片型号 STM32F103C8T6
    芯片封装 LQFP48
    主要特点 – ARM Cortex-M3内核
    – 最高工作频率72MHz
    – 64KB闪存和20KB SRAM
    – 通用定时器、PWM输出
    – 多种通信接口（USART、I2C、SPI等）
    – 多个GPIO引脚
    供电电压 2.0V至3.6V
    工作温度范围 -40℃至+85℃
    价格 相对较低
    应用领域 嵌入式系统、物联网、工业控制、自动化等

    以上表格为对STM32F103C8T6微控制器的介绍。STM32F103C8T6属于STM32F1系列，它采用了ARM Cortex-M3内核，具有最高72MHz的工作频率。该芯片具有64KB的闪存和20KB的SRAM，并提供了丰富的外设资源，如通用定时器、PWM输出、多种通信接口等。它还拥有较多的GPIO引脚，提供了灵活的连接能力。STM32F103C8T6的供电电压范围为2.0V至3.6V，工作温度范围为-40℃至+85℃。由于其性能和价格的平衡，它被广泛应用于嵌入式系统、物联网、工业控制、自动化等领域。

    4.功能的实现

    4.1设计目标

    本设计旨在利用STM32微控制器和OLED显示屏实现实时显示时间、温度和湿度的功能。通过集成这些功能于单一设备中，用户可以方便地获取环境信息并进行实时监测和调整。

    4.2硬件设计

    在硬件方面，我们将使用STM32F103C8T6微控制器作为主控制器，AHT20温湿度传感器用于测量环境温度和湿度，以及SSD1306 OLED显示屏用于显示时间、温度和湿度。这些硬件组件相互配合，实现了整体功能的实现。

    4.3软件设计

    在软件方面，我们将使用STM32CubeIDE进行开发。通过编写相应的代码，我们将实现以下功能：

    1. 初始化：初始化STM32微控制器、AHT20传感器和SSD1306 OLED显示屏，建立各个组件之间的通信连接。
    2. 读取数据：通过STM32微控制器读取AHT20传感器的温度和湿度数据。
    3. 时间获取：通过STM32内部时钟或外部时钟模块，获取当前的时间。
    4. 数据处理：对读取到的温度、湿度和时间数据进行处理，确保其准确性和可用性。
    5. 数据显示：将处理后的数据通过SSD1306 OLED显示屏进行显示，实现实时的时间、温度和湿度信息展示。
    6. 循环更新：通过循环结构，不断更新和刷新显示的数据，以保证数据的实时性。

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

    5.代码的实现

    5.1 AHT20的代码

    参考
    链接: https://blog.csdn.net/weixin_63019977/article/details/134266104

    /*******************************************/
/*@????:??????????          */
/*@??:?????????                */
/*@??: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);
}

    5.2 OLED的代码

    参考链接: https://blog.csdn.net/weixin_63019977/article/details/134346345
    通过汉字取模软件，将所需要的汉字取模出来：

            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);//Ãë
		
		//OLED_ShowString(2,17,"Mon");
		DHT11_REC_Data(); //½ÓÊÕdht11Êý¾Ý
	    OLED_ShowNum(3,10,rec_data[2]-5,2);
		OLED_ShowNum(4,10,rec_data[0]-13,2);
		s+=1;
		if(s>=60)
		{
			s=0;
			min++;
		}
		if(min>=60)
		{
			min=0;
			hour++;
		}
		if(hour>=24)
		{
			hour=0;
			day++;
		}
		if(day>=31)
		{
			month++;
			day=1;
		}
		if(month>12)
		{
			year++;
			month=1;
		}
		
		Delay_s(1);

    6.实验效果

    6.1编译

    6.2烧录

    7.总结

    在本次实验中，我成功地利用STM32微控制器和OLED显示屏实现了实时显示时间、温度和湿度的功能。通过这个实验，我收获了以下几点心得和总结：
    首先，这个实验让我更加深入地了解了STM32微控制器的使用和编程。通过使用Keil进行开发，我学会了如何初始化微控制器、配置外设和编写驱动程序。这为我今后在嵌入式领域的学习和开发奠定了坚实的基础。
    其次，我对OLED显示屏的原理和操作也有了更深入的了解。通过与STM32微控制器的连接和编程，我成功地实现了数据的显示和刷新。这个实验让我意识到OLED显示屏在嵌入式系统中的广泛应用，以及其显示效果和灵活性的优势。
    此外，通过与AHT20温湿度传感器的结合，我成功地获取到了环境温度和湿度的数据，并通过OLED显示屏进行了实时显示。这个实验让我认识到传感器在嵌入式系统中的重要性，以及如何通过读取传感器数据并进行处理和显示。
    总的来说，这个实验不仅让我对STM32微控制器、OLED显示屏和温湿度传感器有了更深入的了解，还提升了我的嵌入式系统开发能力和编程技巧。我相信这些知识和经验将对我今后的学习和工作产生积极的影响。
    通过这个实验，我也明确了自己在嵌入式领域的兴趣和发展方向。我将继续深入学习和探索STM32微控制器和相关技术，不断提升自己的能力，为嵌入式系统的开发和应用做出更多的贡献。

    您可能感兴趣的内容:

    物联沃分享整理
    物联沃-IOTWORD物联网 » 【嵌入式】STM32进阶：OLED显示时间、温度和湿度

    代码收藏家 普通

    分享到：

    相关推荐

    发表评论