STM32进阶-OLED显示时间+温度和湿度

最新推荐文章于 2023-12-29 10:16:09 发布
最新推荐文章于 2023-12-29 10:16:09 发布
阅读量668 收藏 9
点赞数 7
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72338354/article/details/134621081
版权

功能的实现
设计目标
本设计旨在利用STM32微控制器和OLED显示屏实现实时显示时间、温度和湿度的功能。通过集成这些功能于单一设备中，用户可以方便地获取环境信息并进行实时监测和调整。
硬件设计
在硬件方面，我们将使用STM32F103C8T6微控制器作为主控制器，AHT20温湿度传感器用于测量环境温度和湿度，以及SSD1306 OLED显示屏用于显示时间、温度和湿度。这些硬件组件相互配合，实现了整体功能的实现。
软件设计
在软件方面，我们将使用STM32CubeIDE进行开发。通过编写相应的代码，我们将实现以下功能：
初始化：初始化STM32微控制器、AHT20传感器和SSD1306 OLED显示屏，建立各个组件之间的通信连接。
读取数据：通过STM32微控制器读取AHT20传感器的温度和湿度数据。
时间获取：通过STM32内部时钟或外部时钟模块，获取当前的时间。
数据处理：对读取到的温度、湿度和时间数据进行处理，确保其准确性和可用性。
数据显示：将处理后的数据通过SSD1306 OLED显示屏进行显示，实现实时的时间、温度和湿度信息展示。
循环更新：通过循环结构，不断更新和刷新显示的数据，以保证数据的实时性。
通过以上硬件和软件设计，我们可以实现STM32-OLED显示时间+温度和湿度的功能。这个设计可以帮助用户方便地获取环境信息，并进行实时监测和调整。同时，这个设计也展示了STM32微控制器和OLED显示屏的强大功能和灵活性，为用户提供了一个实用且易于使用的解决方案。
代码的实现
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);
}

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);

实验效果：
编译
在这里插入图片描述

烧录
在这里插入图片描述

总结：
本实验成功实现了STM32 OLED显示时间、温度和湿度的功能。但在实验过程中发现以下问题：当环境温湿度变化较快时，检测数据的更新速度稍显缓慢。为了提高检测速度和准确率，建议采用更高级别的温湿度传感器，并优化程序的读取和解析过程。此外，还可以考虑加入更多的功能，如设置闹钟、温湿度报警等，以满足更复杂的应用需求。

m0_72338354
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于STM32的温湿度传感器（DHT11）+OLED屏显示(超详细)
D102428的博客
02-17 1万+
本文主要说明温湿度传感器（DHT11）在STM32下如何使用，并且结合OLED屏来达到显示的效果。以下内容均为查询相关资料撰写而成，如有侵权，请联系作者。本文章主要讲的是通过使用STM32实现了对DHT11温湿度传感器的数据采集和显示。通过对GPIO的配置和延时函数的使用，我们成功地与DHT11传感器进行了通信，并读取了温度和湿度数据。在软件开发方面，我们编写了针对DHT11传感器的初始化、数据读取和校验的函数，并成功地将获取到的数据显示在OLED屏幕上，使用户能够直观地了解当前环境的温度和湿度情况。
STM32实现OLED屏显示
apple_52030329的博客
11-19 5660
软件版本Keil 531硬件题目要求理解OLED屏显和汉字点阵编码原理，使用STM32F103的SPI或IIC接口实现以下功能：显示自己的学号和姓名；显示AHT20的温度和湿度；上下或左右的滑动显示长字符，如一段歌词或诗词(最好使用硬件刷屏模式)。SPI（Serial Peripheral interface）是串行外围设备接口，SPI 接口主要应用在 EEPROM，FLASH，实时时钟，AD 转换器，还有数字信号处理器和数字信号解码器之间。
STM32—项目三（温湿度在oled屏显示）
Ai1101224的博客
06-08 3038
只有一根数据线DAT，发送序列指令给DHT11模块，模块就会传输一次完整的数据为40bit（8bit湿度整数数据+8bit湿度小数数据+8bi温度整数数据+8bit温度小数数据+8bit校验）,高位先出。4.GPIO（全部设置为输出且输出高电平）A57既作为输入，也作为输出，则不能直接在CubeMX里配置，需要自己写代码。上面链接为硬件IIC，下面代码是软件IIC。工程添加.c和.h文件。
stm32+OLED+AHT20-显示温度时间日期
weixin_66084944的博客
11-21 752
AHT20是一款由法国Hall传感器公司生产的数字温湿度传感器，它具有高精度、低功耗、数字输出等特点，广泛应用于温湿度监测、空气质量检测、智能家居等领域。下面将详细介绍AHT20的原理、配置步骤、注意事项等。OLED，即有机发光显示器（Organic Light-Emitting Display），是一种新型的显示技术，具有自发光、视角广、色彩鲜艳、响应速度快等特点，被广泛应用于智能手机、电视、电脑、平板电脑、智能手表等领域。下面将详细介绍OLED的原理、配置步骤和注意事项。
OLED屏显示自己的姓名和学号及温湿度
m0_74454099的博客
11-20 387
理解OLED屏显和汉字点阵编码原理，使用STM32F103的SPI或IIC接口实现以下功能：显示自己的学号和姓名；显示AHT20的温度和湿度；OLED（Organic Light-Emitting Diode），又称为有机电激光显示、有机发光半导体（Organic Electroluminescence Display，OLED）。OLED属于一种电流型的有机发光器件，是通过载流子的注入和复合而致发光的现象，发光强度与注入的电流成正比。
OLED时钟
qq1074237849的博客
06-03 4825
OLED显示年、月、日、时、分、秒、星期以及背景图片。
(毕业设计)基于STM32F103C8T6单片机+OLED显示屏实现的远程机房控制系统 采集温湿度数据,烟雾数据+源代码+原理图
最新发布
01-30
远程机房控制系统 采集温湿度数据 烟雾数据到机智云平台（控制舵机模拟开关机），并显示在OLED屏幕上，可以在APP设置烟雾阈值，若超过则报警 所需硬件 烟雾传感器 DHT11 SG90舵机 STM32F103C8T6单片机 OLED显示屏 ...
智能家居系统，使用Proteus 8.12 仿真 STM32，温湿度传感器、OLED屏幕等软件，毕业设计可以参考
11-06
2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。...
基于STM32和微信小程序的室内空气监控系统+源代码+文档说明
12-02
本系统可持续监测室内的温湿度、可燃气体、PM2.5等空气参数，并将采集数据通过OLED显示屏展示。同时，所采集数据通过MQTT协议上传OneNET云平台下的MQTT服务器。用户可通过微信小程序查看设备端空气参数数据和设备...
基于Stm32实现的采集各项气体和温湿度数据并上传机智云平台，可以在手机APP设置报警阈值+源代码+文档说明+原理图+实验报告
01-30
基于Stm32实现的采集各项气体和温湿度数据并上传机智云平台，可以在手机APP设置报警阈值+源代码+文档说明+原理图+实验报告 功能简介 采集各项气体和温湿度数据并上传机智云平台，可以在手机APP设置报警阈值 所需...
基于stm32的OLED 屏幕显示温湿度历程
08-10
基于stm32f103芯片的oled显示dht11传感器采集的温湿度传感器的参考历程，内置丰富·的oled屏幕显示函数，方便初学者使用，下载方可运行。
【项目】环境监测 | 可燃气体传感器+温湿度传感器+雨滴传感器+OLED屏幕
09-02
备赛广东省电赛的时候，队长给我布置了这个小项目，说有可能会用在比赛的作品中，但实际就不知道了，所以在这里分享一下代码。...项目还涉及了对FreeRTOS系统的基本移植和使用，对于想进阶STM32的小伙伴是非常好的。
OLED显示实验
q1594的博客
12-29 1554
OLED即有机发光二极管，本次介绍的是正点原子的OLED显示模块。（1）模块有单色和双色两种可选，单色为纯蓝色，双色为黄蓝双色（分区域的双色，前16行为黄色，后48行为蓝色，黄蓝之间有一行不显示的间隔区）（2）尺寸小，显示尺寸为0.96寸，模块大小为27mm26mm大小（3）高分辨率，模块分辨率为12864（4）多种接口模式，该模块提供了4种接口，包括：6800、8080两种并行接口方式4线SPI接口方式和IIC接口方式。（5）不需要高压，直接3.3V就可以工作了。
基于I2C/SPI的温湿度采集与OLED显示
weixin_48302823的博客
11-26 3084
一：SPI协议： SPI，是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，正是出于这种简单易用的特性，现在越来越多的芯片集成了这种通信协议。二、汉字点阵
STM32F103+DHT11显示温湿度（0.96寸oled）
热门推荐
weixin_45631738的博客
05-26 1万+
文章目录STM32一.前言二.DHT11驱动原理三.代码 STM32 一.前言 在实际的项目开发过程中我们会使用到很多模块，今天我们说一下DHT11温湿度模块 这里是将测量的数据显示在0.96寸oled显示屏上面，如果不会oled屏幕驱动的可以看一下之前的文章 二.DHT11驱动原理 步骤一 DHT11上电后（DHT11上电后要等待 1S 以越过不稳定状态在此期间不能发送任何指令），测试环境 温湿度数据，并记录数据，同时 DHT11的 DATA 数据线由上拉电阻拉高一直保持高电平；此时 DHT11的 DAT
基于stm32的OLED温湿度显示
IT23131的博客
11-27 7118
一.SPI 1.简介 SPI（Serial Peripheral Interface，串行外设接口）是Motorola公司提出的一种同步串行数据传输标准，是一种高速的，全双工，同步的通信总线，在很多器件中被广泛应用。 2.SPI接口 SPI接口经常被称为4线串行总线，以主/从方式工作，数据传输过程由主机初始化。 如图1所示，其使用的4条信号线分别为： 1) SCLK：串行时钟，用来同步数据传输，由主机输出； 2) MOSI：主机输出从机输入（Master Output Slaver Input
基于SPI的0.96OLED数据显示温湿度
eininbebop的博客
01-02 1016
关于SPI SPI 接口是 Motorola 首先提出的全双工三线同步串行外围接口，采用主从模式（Master Slave）架构；支持多 slave 模式应用，一 般仅支持单 Master。 时钟由 Master 控制，在时钟移位脉冲下，数据按位传输，高位在前，低位在后（MSB first）；SPI 接口有 2 根单向数据线，为全双工通信，目前应用中的数据速率可达几 Mbps 的水平。 提示：以下是本篇文章正文内容，下面案例可供参考 0.96OLED屏幕 相关资料：0.96inch SPI OLED Mo
STM32之基于I2C/SPI总线的温湿度采集与OLED显示
weixin_48268385的博客
11-20 3769
文章目录一. 一. 使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集，并将采集的温度-湿度值通过串口输出。 解释什么是“软件I2C”和“硬件I2C”？ 显示温湿度
环境监测＋oled显示+STM32F103C8T6
weixin_54411122的博客
05-08 7498
因为本人也是新手，所以代码难免会有漏洞，还望见谅。这次的代码是依照我上一篇温湿度计改编过来的。面对新手，我尽可能的在注释中列出需要注意的东西，我不讲传感器的原理，因为我也不会，这工程完全是给萌新应急用的，我也总结了所有外设iO口的接线，方便新手快速接线。 实现的效果 oled实时显示温度，湿度，光照强度，烟雾浓度，一氧化碳浓度和空气质量。（从黑夜到白天）当光照强度大于50且上一次光照强度低于50时，步进电机启动，顺时钟转动360度（模拟关闭窗帘）；（从白天到黑夜）当光照强度小于50且...
stm32 oled显示温度和时间
05-15
STM32是一款十分强大的微控制器，可以用于各种应用场景。其中，使用STM32来控制OLED显示温度和时间也是一种十分实用的应用。当我们在将温度和时间显示在OLED屏幕上时，需要首先连接OLED屏幕和STM32，然后通过程序控制OLED屏幕显示的方式实现。 具体过程如下： 1. 确定使用的OLED屏幕的型号，然后将其连接到STM32开发板上。通常情况下，我们需要连接GND、VCC、SCL和SDA这四个引脚。其中，SCL针脚连接到STM32的SCL引脚，SDA针脚连接到STM32的SDA引脚，VCC针脚连接到系统的正电源，GND针脚连接到系统的地。 2. 在STM32的开发环境中，编写程序，通过读取STM32内部温度传感器的数据，获取当前的温度。然后将温度信息转化为字符串，使用OLED屏幕提供的API将其显示到屏幕上。 3. 同样地，在STM32的开发环境中，编写程序，获取当前的时间。根据需要，可以选择使用RTC模块或者其他的时钟模块。然后将时间信息转化为字符串，使用OLED屏幕提供的API将其显示到屏幕上。 通过以上步骤，我们就可以使用STM32控制OLED显示温度和时间了。需要注意的是，在实现过程中需要对STM32进行适当的设置，以确保其能够正确地读取温度和时间信息，并将其显示到OLED屏幕上。此外，为了增强代码的鲁棒性和可拓展性，我们可以为温度和时间信息的显示编写单独的函数，以方便在其他应用中重复使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值