用STM32F103达成基于I2C协议的AHT20温湿度传感器和OLED屏显示汉字

目录

一 I2C协议简介

   硬件I2C与软件I2C

 二 代码和ATH20芯片实现温湿度的串口显示

三 用stm32f103芯片的SPI和IIC接口接上OLED屏显示中文姓名温湿度

 1 先用文字字模生成器PCtolCD200生成需要的字模

 2 烧录程序

四 显示温湿度

五 滚动屏显示

 六 总结

七 参考文献

---

一 I2C协议简介

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

    I2c的物理层

 它的物理层有如下特点：

(1) 它是一个支持设备的总线。“总线”指多个设备共用的信号线。在一个 I2C 通讯总线中，可 连接多个 I2C 通讯设备，支持多个通讯主机及多个通讯从机。

(2) 一个 I2C 总线只使用两条总线线路，一条双向串行数据线 (SDA) ，一条串行时钟线 (SCL)。 数据线即用来表示数据，时钟线用于数据收发同步。

(3) 每个连接到总线的设备都有一个独立的地址，主机可以利用这个地址进行不同设备之间的 访问。

(4) 总线通过上拉电阻接到电源。当 I2C 设备空闲时，会输出高阻态，而当所有设备都空闲，都 输出高阻态时，由上拉电阻把总线拉成高电平。

(5) 多个主机同时使用总线时，为了防止数据冲突，会利用仲裁方式决定由哪个设备占用总线。

(6) 具有三种传输模式：标准模式传输速率为 100kbit/s ，快速模式为 400kbit/s ，高速模式下可 达 3.4Mbit/s，但目前大多 I 2C 设备尚不支持高速模式。

(7) 连接到相同总线的 IC 数量受到总线的最大电容 400pF 限制。

   硬件I2C与软件I2C

  硬件I2C

硬件I2C对应芯片上的I2C外设，有相应I2C驱动电路，其所使用的I2C管脚也是专用的，因而效率要远高于软件模拟的I2C；一般也较为稳定，但是程序较为繁琐。硬件（固件）I2C是直接调用内部寄存器进行配置；而软件I2C是没有寄存器这个概念的。这种方式减轻了cpu的负担。

  软件I2C
软件I2C一般是使用GPIO管脚，用软件控制SCL,SDA线输出高低电平，模拟i2c协议的时序。由于直接控制 GPIO 引脚电平产生通讯时序时，需要由 CPU 控制每个时刻的引脚状态，所以称之为“软件模拟协议”方式。

 二 代码和ATH20芯片实现温湿度的串口显示

在空白模板上新建一系列的c文件和h文件，然后将以下代码写上去

main.c

#include "delay.h"
#include "usart.h"
#include "bsp_i2c.h"


int main(void)
{	
	delay_init();     //?óê±oˉêy3?ê??ˉ	  
	uart_init(115200);	 //′??ú3?ê??ˉ?a115200
	IIC_Init();
		while(1)
	{
		printf("温度湿度显示");
		read_AHT20_once();
		delay_ms(1500);
  }
}

bsp_i2c.c

#include "bsp_i2c.h"
#include "delay.h"

uint8_t   ack_status=0;
uint8_t   readByte[6];
uint8_t   AHT20_status=0;

uint32_t  H1=0;  //Humility
uint32_t  T1=0;  //Temperature

uint8_t  AHT20_OutData[4];
uint8_t  AHT20sendOutData[10] = {0xFA, 0x06, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF};

void IIC_Init(void)
{					     
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
	   
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //í?íìê?3?
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
 
	IIC_SCL=1;
	IIC_SDA=1;
 
}
//2úéúIIC?eê?D?o?
void IIC_Start(void)
{
	SDA_OUT();     //sda??ê?3?
	IIC_SDA=1;	  	  
	IIC_SCL=1;
	delay_us(4);
 	IIC_SDA=0;//START:when CLK is high,DATA change form high to low 
	delay_us(4);
	IIC_SCL=0;//?ˉ×?I2C×ü??￡?×?±?·￠?í?ò?óê?êy?Y 
}	  
//2úéúIICí￡?1D?o?
void IIC_Stop(void)
{
	SDA_OUT();//sda??ê?3?
	IIC_SCL=0;
	IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
 	delay_us(4);
	IIC_SCL=1; 
	IIC_SDA=1;//·￠?íI2C×ü???áê?D?o?
	delay_us(4);							   	
}
//μè′yó|′eD?o?μ?à′
//·μ???μ￡o1￡??óê?ó|′e꧰ü
//        0￡??óê?ó|′e3é1|
u8 IIC_Wait_Ack(void)
{
	u8 ucErrTime=0;
	SDA_IN();      //SDAéè???aê?è?  
	IIC_SDA=1;delay_us(1);	   
	IIC_SCL=1;delay_us(1);	 
	while(READ_SDA)
	{
		ucErrTime++;
		if(ucErrTime>250)
		{
			IIC_Stop();
			return 1;
		}
	}
	IIC_SCL=0;//ê±?óê?3?0 	   
	return 0;  
} 
//2úéúACKó|′e
void IIC_Ack(void)
{
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=0;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}
//2?2úéúACKó|′e		    
void IIC_NAck(void)
{
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=1;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}					 				     
//IIC·￠?íò???×??ú
//·μ??′ó?úóD?Tó|′e
//1￡?óDó|′e
//0￡??Tó|′e			  
void IIC_Send_Byte(u8 txd)
{                        
    u8 t;   
		SDA_OUT(); 	    
    IIC_SCL=0;//à-μíê±?ó?aê?êy?Y′?ê?
    for(t=0;t<8;t++)
    {              
        IIC_SDA=(txd&0x80)>>7;
        txd<<=1; 	  
		delay_us(2);   //??TEA5767?aèy???óê±??ê?±?D?μ?
		IIC_SCL=1;
		delay_us(2); 
		IIC_SCL=0;	
		delay_us(2);
    }	 
} 	    
//?á1??×??ú￡?ack=1ê±￡?·￠?íACK￡?ack=0￡?·￠?ínACK   
u8 IIC_Read_Byte(unsigned char ack)
{
	unsigned char i,receive=0;
	SDA_IN();//SDAéè???aê?è?
  for(i=0;i<8;i++ )
	{
    IIC_SCL=0; 
    delay_us(2);
		IIC_SCL=1;
    receive<<=1;
    if(READ_SDA)receive++;   
		delay_us(1); 
  }					 
	if (!ack)
			IIC_NAck();//·￠?ínACK
	else
			IIC_Ack(); //·￠?íACK   
	return receive;
}
 
void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr)
{
	IIC_Start();  
	
	if(device_addr==0xA0) //eepromμ??·′óóú1×??ú
		IIC_Send_Byte(0xA0 + ((addr/256)<<1));//·￠?í??μ??·
	else
		IIC_Send_Byte(device_addr);	    //·￠?÷?tμ??·
	IIC_Wait_Ack(); 
	IIC_Send_Byte(addr&0xFF);   //·￠?íμíμ??·
	IIC_Wait_Ack(); 
	IIC_Send_Byte(data);     //·￠?í×??ú							   
	IIC_Wait_Ack();  		    	   
  IIC_Stop();//2úéúò???í￡?1ì??t 
	if(device_addr==0xA0) //
		delay_ms(10);
	else
		delay_us(2);
}
 
uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead)  //?á??′??÷?ò?áêy?Y
{	
		uint16_t data;
		IIC_Start();  
		if(device_addr==0xA0)
			IIC_Send_Byte(0xA0 + ((addr/256)<<1));
		else
			IIC_Send_Byte(device_addr);	
		IIC_Wait_Ack();
		IIC_Send_Byte(addr&0xFF);   //·￠?íμíμ??·
		IIC_Wait_Ack(); 
 
		IIC_Start();  	
		IIC_Send_Byte(device_addr+1);	    //·￠?÷?tμ??·
		IIC_Wait_Ack();
		if(ByteNumToRead == 1)//LM75???èêy?Y?a11bit
		{
			data=IIC_Read_Byte(0);
		}
		else
			{
				data=IIC_Read_Byte(1);
				data=(data<<8)+IIC_Read_Byte(0);
			}
		IIC_Stop();//2úéúò???í￡?1ì??t	    
		return data;
}


/**********
*é???2?·??aIO?ú?￡?éI2C????
*
*′ó?aò????aê??aAHT20μ?????I2C
*oˉêy??óDIICoíI2Cμ???±e￡???×￠òa￡?￡?￡?￡?￡?
*
*2020/2/23×?oóDT??è??ú
*
***********/
void  read_AHT20_once(void)
{
	delay_ms(10);

	reset_AHT20();
	delay_ms(10);

	init_AHT20();
	delay_ms(10);

	startMeasure_AHT20();
	delay_ms(80);

	read_AHT20();
	delay_ms(5);
}


void  reset_AHT20(void)
{

	I2C_Start();

	I2C_WriteByte(0x70);
	ack_status = Receive_ACK();
	if(ack_status) printf("1");
	else printf("1-n-");
	I2C_WriteByte(0xBA);
	ack_status = Receive_ACK();
		if(ack_status) printf("2");
	else printf("2-n-");
	I2C_Stop();

	/*
	AHT20_OutData[0] = 0;
	AHT20_OutData[1] = 0;
	AHT20_OutData[2] = 0;
	AHT20_OutData[3] = 0;
	*/
}



void  init_AHT20(void)
{
	I2C_Start();

	I2C_WriteByte(0x70);
	ack_status = Receive_ACK();
	if(ack_status) printf("3");
	else printf("3-n-");	
	I2C_WriteByte(0xE1);
	ack_status = Receive_ACK();
	if(ack_status) printf("4");
	else printf("4-n-");
	I2C_WriteByte(0x08);
	ack_status = Receive_ACK();
	if(ack_status) printf("5");
	else printf("5-n-");
	I2C_WriteByte(0x00);
	ack_status = Receive_ACK();
	if(ack_status) printf("6");
	else printf("6-n-");
	I2C_Stop();
}



void  startMeasure_AHT20(void)
{
	//------------
	I2C_Start();

	I2C_WriteByte(0x70);
	ack_status = Receive_ACK();
	if(ack_status) printf("7");
	else printf("7-n-");
	I2C_WriteByte(0xAC);
	ack_status = Receive_ACK();
	if(ack_status) printf("8");
	else printf("8-n-");
	I2C_WriteByte(0x33);
	ack_status = Receive_ACK();
	if(ack_status) printf("9");
	else printf("9-n-");
	I2C_WriteByte(0x00);
	ack_status = Receive_ACK();
	if(ack_status) printf("10");
	else printf("10-n-");
	I2C_Stop();
}



void read_AHT20(void)
{
	uint8_t   i;

	for(i=0; i<6; i++)
	{
		readByte[i]=0;
	}

	//-------------
	I2C_Start();

	I2C_WriteByte(0x71);
	ack_status = Receive_ACK();
	readByte[0]= I2C_ReadByte();
	Send_ACK();

	readByte[1]= I2C_ReadByte();
	Send_ACK();

	readByte[2]= I2C_ReadByte();
	Send_ACK();

	readByte[3]= I2C_ReadByte();
	Send_ACK();

	readByte[4]= I2C_ReadByte();
	Send_ACK();

	readByte[5]= I2C_ReadByte();
	SendNot_Ack();
	//Send_ACK();

	I2C_Stop();

	//--------------
	if( (readByte[0] & 0x68) == 0x08 )
	{
		H1 = readByte[1];
		H1 = (H1<<8) | readByte[2];
		H1 = (H1<<8) | readByte[3];
		H1 = H1>>4;

		H1 = (H1*1000)/1024/1024;

		T1 = readByte[3];
		T1 = T1 & 0x0000000F;
		T1 = (T1<<8) | readByte[4];
		T1 = (T1<<8) | readByte[5];

		T1 = (T1*2000)/1024/1024 - 500;

		AHT20_OutData[0] = (H1>>8) & 0x000000FF;
		AHT20_OutData[1] = H1 & 0x000000FF;

		AHT20_OutData[2] = (T1>>8) & 0x000000FF;
		AHT20_OutData[3] = T1 & 0x000000FF;
	}
	else
	{
		AHT20_OutData[0] = 0xFF;
		AHT20_OutData[1] = 0xFF;

		AHT20_OutData[2] = 0xFF;
		AHT20_OutData[3] = 0xFF;
		printf("lyy");

	}
	printf("\r\n");
	printf("温度:%d%d.%d",T1/100,(T1/10)%10,T1%10);
	printf("湿度:%d%d.%d",H1/100,(H1/10)%10,H1%10);
	printf("\r\n");
}




uint8_t  Receive_ACK(void)
{
	uint8_t result=0;
	uint8_t cnt=0;

	IIC_SCL = 0;
	SDA_IN(); 
	delay_us(4);

	IIC_SCL = 1;
	delay_us(4);

	while(READ_SDA && (cnt<100))
	{
		cnt++;
	}

	IIC_SCL = 0;
	delay_us(4);

	if(cnt<100)
	{
		result=1;
	}
	return result;
}



void  Send_ACK(void)
{
	SDA_OUT();
	IIC_SCL = 0;
	delay_us(4);

	IIC_SDA = 0;
	delay_us(4);

	IIC_SCL = 1;
	delay_us(4);
	IIC_SCL = 0;
	delay_us(4);

	SDA_IN();
}



void  SendNot_Ack(void)
{
	SDA_OUT();
	IIC_SCL = 0;
	delay_us(4);

	IIC_SDA = 1;
	delay_us(4);

	IIC_SCL = 1;
	delay_us(4);

	IIC_SCL = 0;
	delay_us(4);

	IIC_SDA = 0;
	delay_us(4);
}


void I2C_WriteByte(uint8_t  input)
{
	uint8_t  i;
	SDA_OUT();
	for(i=0; i<8; i++)
	{
		IIC_SCL = 0;
		delay_ms(5);

		if(input & 0x80)
		{
			IIC_SDA = 1;
			//delaymm(10);
		}
		else
		{
			IIC_SDA = 0;
			//delaymm(10);
		}

		IIC_SCL = 1;
		delay_ms(5);

		input = (input<<1);
	}

	IIC_SCL = 0;
	delay_us(4);

	SDA_IN();
	delay_us(4);
}	


uint8_t I2C_ReadByte(void)
{
	uint8_t  resultByte=0;
	uint8_t  i=0, a=0;

	IIC_SCL = 0;
	SDA_IN();
	delay_ms(4);

	for(i=0; i<8; i++)
	{
		IIC_SCL = 1;
		delay_ms(3);

		a=0;
		if(READ_SDA)
		{
			a=1;
		}
		else
		{
			a=0;
		}

		//resultByte = resultByte | a;
		resultByte = (resultByte << 1) | a;

		IIC_SCL = 0;
		delay_ms(3);
	}

	SDA_IN();
	delay_ms(10);

	return   resultByte;
}


void  set_AHT20sendOutData(void)
{
	/* --------------------------
	 * 0xFA 0x06 0x0A temperature(2 Bytes) humility(2Bytes) short Address(2 Bytes)
	 * And Check (1 byte)
	 * -------------------------*/
	AHT20sendOutData[3] = AHT20_OutData[0];
	AHT20sendOutData[4] = AHT20_OutData[1];
	AHT20sendOutData[5] = AHT20_OutData[2];
	AHT20sendOutData[6] = AHT20_OutData[3];

//	AHT20sendOutData[7] = (drf1609.shortAddress >> 8) & 0x00FF;
//	AHT20sendOutData[8] = drf1609.shortAddress  & 0x00FF;

//	AHT20sendOutData[9] = getXY(AHT20sendOutData,10);
}


void  I2C_Start(void)
{
	SDA_OUT();
	IIC_SCL = 1;
	delay_ms(4);

	IIC_SDA = 1;
	delay_ms(4);
	IIC_SDA = 0;
	delay_ms(4);

	IIC_SCL = 0;
	delay_ms(4);
}



void  I2C_Stop(void)
{
	SDA_OUT();
	IIC_SDA = 0;
	delay_ms(4);

	IIC_SCL = 1;
	delay_ms(4);

	IIC_SDA = 1;
	delay_ms(4);
}

bsp_i2c.h

#ifndef __BSP_I2C_H
#define __BSP_I2C_H

#include "sys.h"
#include "delay.h"
#include "usart.h"
//ê1ó?IIC1 1ò??M24C02,OLED,LM75AD,HT1382    PB6,PB7
 
#define SDA_IN()  {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}
#define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}
 
//IO2ù×÷oˉêy	 
#define IIC_SCL    PBout(6) //SCL
#define IIC_SDA    PBout(7) //SDA	 
#define READ_SDA   PBin(7)  //ê?è?SDA 


//IIC?ùóD2ù×÷oˉêy
void IIC_Init(void);                //3?ê??ˉIICμ?IO?ú				 
void IIC_Start(void);				//·￠?íIIC?aê?D?o?
void IIC_Stop(void);	  			//·￠?íIICí￡?1D?o?
void IIC_Send_Byte(u8 txd);			//IIC·￠?íò???×??ú
u8 IIC_Read_Byte(unsigned char ack);//IIC?áè?ò???×??ú
u8 IIC_Wait_Ack(void); 				//IICμè′yACKD?o?
void IIC_Ack(void);					//IIC·￠?íACKD?o?
void IIC_NAck(void);				//IIC2?·￠?íACKD?o?
 
void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr);
uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead);//??′??÷μ??·￡??÷?tμ??·￡?òa?áμ?×??úêy  


void  read_AHT20_once(void);
void  reset_AHT20(void);
void  init_AHT20(void);	
void  startMeasure_AHT20(void);
void  read_AHT20(void);
uint8_t  Receive_ACK(void);
void  Send_ACK(void);
void  SendNot_Ack(void);
void I2C_WriteByte(uint8_t  input);
uint8_t I2C_ReadByte(void);	
void  set_AHT20sendOutData(void);
void  I2C_Start(void);
void  I2C_Stop(void);
#endif

usart.c

#include "sys.h"
#include "usart.h"


//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/


// 	 
//è?1?ê1ó?ucos,?ò°üà¨????μ?í·???t?′?é.
#if SYSTEM_SUPPORT_UCOS
#include "includes.h"					//ucos ê1ó?	  
#endif
//	 
//STM32?a·￠°?
//′??ú13?ê??ˉ		   

// 	  
 

//
//?óè?ò???′ú??,?§3?printfoˉêy,??2?Dèòa????use MicroLIB	  
#if 1
#pragma import(__use_no_semihosting)             
//±ê×??aDèòaμ??§3?oˉêy                 
struct __FILE 
{ 
	int handle; 

}; 

FILE __stdout;       
//?¨ò?_sys_exit()ò?±ü?aê1ó?°??÷?ú?￡ê?    
void _sys_exit(int x) 
{ 
	x = x; 
} 
//???¨ò?fputcoˉêy 
int fputc(int ch, FILE *f)
{      
	while((USART1->SR&0X40)==0);//?-?··￠?í,?±μ?·￠?ííê±?   
    USART1->DR = (u8) ch;      
	return ch;
}
#endif 

/*ê1ó?microLibμ?·?·¨*/
 /* 
int fputc(int ch, FILE *f)
{
	USART_SendData(USART1, (uint8_t) ch);

	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {}	
   
    return ch;
}
int GetKey (void)  { 

    while (!(USART1->SR & USART_FLAG_RXNE));

    return ((int)(USART1->DR & 0x1FF));
}
*/
 
#if EN_USART1_RX   //è?1?ê1?üá??óê?
//′??ú1?D??·t??3ìDò
//×￠òa,?áè?USARTx->SR?ü±ü?a?a??????μ?′í?ó   	
u8 USART_RX_BUF[USART_REC_LEN];     //?óê??o3?,×?′óUSART_REC_LEN??×??ú.
//?óê?×′ì?
//bit15￡?	?óê?íê3é±ê??
//bit14￡?	?óê?μ?0x0d
//bit13~0￡?	?óê?μ?μ?óDD§×??úêy??
u16 USART_RX_STA=0;       //?óê?×′ì?±ê??	  
  
void uart_init(u32 bound){
    //GPIO???úéè??
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);	//ê1?üUSART1￡?GPIOAê±?ó
     //USART1_TX   PA.9
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//?′ó?í?íìê?3?
    GPIO_Init(GPIOA, &GPIO_InitStructure);
   
    //USART1_RX	  PA.10
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//????ê?è?
    GPIO_Init(GPIOA, &GPIO_InitStructure);  

   //Usart1 NVIC ????

    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//?à??ó??è??3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//×óó??è??3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQí¨μàê1?ü
	NVIC_Init(&NVIC_InitStructure);	//?ù?Y???¨μ?2?êy3?ê??ˉVIC??′??÷
  
   //USART 3?ê??ˉéè??

	USART_InitStructure.USART_BaudRate = bound;//ò?°?éè???a9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×?3¤?a8??êy?Y??ê?
	USART_InitStructure.USART_StopBits = USART_StopBits_1;//ò???í￡?1??
	USART_InitStructure.USART_Parity = USART_Parity_No;//?T????D￡?é??
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//?Tó2?têy?Yá÷????
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//ê?·￠?￡ê?

    USART_Init(USART1, &USART_InitStructure); //3?ê??ˉ′??ú
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//?a???D??
    USART_Cmd(USART1, ENABLE);                    //ê1?ü′??ú 

}



void USART1_IRQHandler(void)                	//′??ú1?D??·t??3ìDò
	{
	u8 Res;
#ifdef OS_TICKS_PER_SEC	 	//è?1?ê±?ó?ú??êy?¨ò?á?,?μ?÷òaê1ó?ucosIIá?.
	OSIntEnter();    
#endif
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //?óê??D??(?óê?μ?μ?êy?Y±?D?ê?0x0d 0x0a?á?2)
		{
		Res =USART_ReceiveData(USART1);//(USART1->DR);	//?áè??óê?μ?μ?êy?Y
		
		if((USART_RX_STA&0x8000)==0)//?óê??′íê3é
			{
			if(USART_RX_STA&0x4000)//?óê?μ?á?0x0d
				{
				if(Res!=0x0a)USART_RX_STA=0;//?óê?′í?ó,??D??aê?
				else USART_RX_STA|=0x8000;	//?óê?íê3éá? 
				}
			else //?1??ê?μ?0X0D
				{	
				if(Res==0x0d)USART_RX_STA|=0x4000;
				else
					{
					USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
					USART_RX_STA++;
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//?óê?êy?Y′í?ó,??D??aê??óê?	  
					}		 
				}
			}   		 
     } 
#ifdef OS_TICKS_PER_SEC	 	//è?1?ê±?ó?ú??êy?¨ò?á?,?μ?÷òaê1ó?ucosIIá?.
	OSIntExit();  											 
#endif
} 
#endif	

usart.h

#ifndef __USART_H
#define __USART_H
#include "stdio.h"	
#include "sys.h" 

//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/

//	 
//STM32?a·￠°?
//′??ú13?ê??ˉ		   

#define USART_REC_LEN  			200  	//?¨ò?×?′ó?óê?×??úêy 200
#define EN_USART1_RX 			1		    //ê1?ü￡¨1￡?/???1￡¨0￡?′??ú1?óê?
	  	
extern u8  USART_RX_BUF[USART_REC_LEN]; //?óê??o3?,×?′óUSART_REC_LEN??×??ú.??×??ú?a??DD·? 
extern u16 USART_RX_STA;         		//?óê?×′ì?±ê??	
//è?1???′??ú?D???óê?￡???2?òa×￠êíò???oê?¨ò?
void uart_init(u32 bound);
#endif

delay.c

include "delay.h"
#include "sys.h"

//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/


// 	 
//è?1?ê1ó?ucos,?ò°üà¨????μ?í·???t?′?é.
#if SYSTEM_SUPPORT_UCOS
#include "includes.h"					//ucos ê1ó?	  
#endif
//	 

//STM32?a·￠°?
//ê1ó?SysTickμ???í¨??êy?￡ê????ó3ù??DD1üàí
//°üà¨delay_us,delay_ms

// 	 
static u8  fac_us=0;//us?óê±±?3?êy
static u16 fac_ms=0;//ms?óê±±?3?êy
#ifdef OS_CRITICAL_METHOD 	//è?1?OS_CRITICAL_METHOD?¨ò?á?,?μ?÷ê1ó?ucosIIá?.
//systick?D??·t??oˉêy,ê1ó?ucosê±ó?μ?
void SysTick_Handler(void)
{				   
	OSIntEnter();		//??è??D??
    OSTimeTick();       //μ÷ó?ucosμ?ê±?ó·t??3ìDò               
    OSIntExit();        //′￥·￠è????D??èí?D??
}
#endif

//3?ê??ˉ?ó3ùoˉêy
//μ±ê1ó?ucosμ?ê±oò,′?oˉêy?á3?ê??ˉucosμ?ê±?ó?ú??
//SYSTICKμ?ê±?ó1ì?¨?aHCLKê±?óμ?1/8
//SYSCLK:?μí3ê±?ó
void delay_init()	 
{

#ifdef OS_CRITICAL_METHOD 	//è?1?OS_CRITICAL_METHOD?¨ò?á?,?μ?÷ê1ó?ucosIIá?.
	u32 reload;
#endif
	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);	//????ía2?ê±?ó  HCLK/8
	fac_us=SystemCoreClock/8000000;	//?a?μí3ê±?óμ?1/8  
	 
#ifdef OS_CRITICAL_METHOD 	//è?1?OS_CRITICAL_METHOD?¨ò?á?,?μ?÷ê1ó?ucosIIá?.
	reload=SystemCoreClock/8000000;		//?????óμ???êy′?êy μ￥???aK	   
	reload*=1000000/OS_TICKS_PER_SEC;//?ù?YOS_TICKS_PER_SECéè?¨ò?3?ê±??
							//reload?a24????′??÷,×?′ó?μ:16777216,?ú72M??,??o?1.86s×óóò	
	fac_ms=1000/OS_TICKS_PER_SEC;//′ú±íucos?éò??óê±μ?×?éùμ￥??	   
	SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;   	//?a??SYSTICK?D??
	SysTick->LOAD=reload; 	//??1/OS_TICKS_PER_SEC???D??ò?′?	
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;   	//?a??SYSTICK    
#else
	fac_ms=(u16)fac_us*1000;//·?ucos??,′ú±í????msDèòaμ?systickê±?óêy   
#endif
}								    

#ifdef OS_CRITICAL_METHOD	//ê1ó?á?ucos
//?óê±nus
//nus?aòa?óê±μ?usêy.		    								   
void delay_us(u32 nus)
{		
	u32 ticks;
	u32 told,tnow,tcnt=0;
	u32 reload=SysTick->LOAD;	//LOADμ??μ	    	 
	ticks=nus*fac_us; 			//Dèòaμ??ú??êy	  		 
	tcnt=0;
	told=SysTick->VAL;        	//????è?ê±μ???êy?÷?μ
	while(1)
	{
		tnow=SysTick->VAL;	
		if(tnow!=told)
		{	    
			if(tnow=ticks)break;//ê±??3?1y/μèóúòa?ó3ùμ?ê±??,?òí?3?.
		}  
	}; 									    
}
//?óê±nms
//nms:òa?óê±μ?msêy
void delay_ms(u16 nms)
{	
	if(OSRunning==TRUE)//è?1?osò??-?ú?üá?	    
	{		  
		if(nms>=fac_ms)//?óê±μ?ê±??′óóúucosμ?×?éùê±???ü?ú 
		{
   			OSTimeDly(nms/fac_ms);//ucos?óê±
		}
		nms%=fac_ms;				//ucosò??-?T·¨ìá1??a?′D?μ??óê±á?,2éó???í¨·?ê??óê±    
	}
	delay_us((u32)(nms*1000));	//??í¨·?ê??óê±,′?ê±ucos?T·¨???ˉμ÷?è.
}
#else//2?ó?ucosê±
//?óê±nus
//nus?aòa?óê±μ?usêy.		    								   
void delay_us(u32 nus)
{		
	u32 temp;	    	 
	SysTick->LOAD=nus*fac_us; //ê±???ó??	  		 
	SysTick->VAL=0x00;        //??????êy?÷
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //?aê?μ1êy	 
	do
	{
		temp=SysTick->CTRL;
	}
	while(temp&0x01&&!(temp&(1<<16)));//μè′yê±??μ?′?   
	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //1?±???êy?÷
	SysTick->VAL =0X00;       //??????êy?÷	 
}
//?óê±nms
//×￠òanmsμ?·??§
//SysTick->LOAD?a24????′??÷,?ùò?,×?′ó?óê±?a:
//nms<=0xffffff*8*1000/SYSCLK
//SYSCLKμ￥???aHz,nmsμ￥???ams
//??72Mì??t??,nms<=1864 
void delay_ms(u16 nms)
{	 		  	  
	u32 temp;		   
	SysTick->LOAD=(u32)nms*fac_ms;//ê±???ó??(SysTick->LOAD?a24bit)
	SysTick->VAL =0x00;           //??????êy?÷
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //?aê?μ1êy  
	do
	{
		temp=SysTick->CTRL;
	}
	while(temp&0x01&&!(temp&(1<<16)));//μè′yê±??μ?′?   
	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //1?±???êy?÷
	SysTick->VAL =0X00;       //??????êy?÷	  	    
} 
#endif

delay.h

#ifndef __DELAY_H
#define __DELAY_H 			   
#include "sys.h"
//	 

//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/


//ê1ó?SysTickμ???í¨??êy?￡ê????ó3ù??DD1üàí
//°üà¨delay_us,delay_ms

// 	 
void delay_init(void);
void delay_ms(u16 nms);
void delay_us(u32 nus);

#endif

sys.c

#include "sys.h"


//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/

//	 

//STM32?a·￠°?
//?μí3?D??·?×ééè???ˉ		   

//********************************************************************************  
void NVIC_Configuration(void)
{

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);	//éè??NVIC?D??·?×é2:2???à??ó??è??￡?2???ìó|ó??è??

}

sys.h

#ifndef __SYS_H
#define __SYS_H	
#include "stm32f10x.h"
//	 


//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/



// 	 

//0,2??§3?ucos
//1,?§3?ucos
#define SYSTEM_SUPPORT_UCOS		0		//?¨ò??μí3???t?Dê?·??§3?UCOS
																	    
	 
//??′?2ù×÷,êμ??51àà??μ?GPIO????1|?ü
//??ì?êμ??????,2???<>μú????(87ò3~92ò3).
//IO?ú2ù×÷oê?¨ò?
#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
#define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
#define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum)) 
//IO?úμ??·ó3é?
#define GPIOA_ODR_Addr    (GPIOA_BASE+12) //0x4001080C 
#define GPIOB_ODR_Addr    (GPIOB_BASE+12) //0x40010C0C 
#define GPIOC_ODR_Addr    (GPIOC_BASE+12) //0x4001100C 
#define GPIOD_ODR_Addr    (GPIOD_BASE+12) //0x4001140C 
#define GPIOE_ODR_Addr    (GPIOE_BASE+12) //0x4001180C 
#define GPIOF_ODR_Addr    (GPIOF_BASE+12) //0x40011A0C    
#define GPIOG_ODR_Addr    (GPIOG_BASE+12) //0x40011E0C    

#define GPIOA_IDR_Addr    (GPIOA_BASE+8) //0x40010808 
#define GPIOB_IDR_Addr    (GPIOB_BASE+8) //0x40010C08 
#define GPIOC_IDR_Addr    (GPIOC_BASE+8) //0x40011008 
#define GPIOD_IDR_Addr    (GPIOD_BASE+8) //0x40011408 
#define GPIOE_IDR_Addr    (GPIOE_BASE+8) //0x40011808 
#define GPIOF_IDR_Addr    (GPIOF_BASE+8) //0x40011A08 
#define GPIOG_IDR_Addr    (GPIOG_BASE+8) //0x40011E08 
 
//IO?ú2ù×÷,????μ￥ò?μ?IO?ú!
//è·±￡nμ??μD?óú16!
#define PAout(n)   BIT_ADDR(GPIOA_ODR_Addr,n)  //ê?3? 
#define PAin(n)    BIT_ADDR(GPIOA_IDR_Addr,n)  //ê?è? 

#define PBout(n)   BIT_ADDR(GPIOB_ODR_Addr,n)  //ê?3? 
#define PBin(n)    BIT_ADDR(GPIOB_IDR_Addr,n)  //ê?è? 

#define PCout(n)   BIT_ADDR(GPIOC_ODR_Addr,n)  //ê?3? 
#define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)  //ê?è? 

#define PDout(n)   BIT_ADDR(GPIOD_ODR_Addr,n)  //ê?3? 
#define PDin(n)    BIT_ADDR(GPIOD_IDR_Addr,n)  //ê?è? 

#define PEout(n)   BIT_ADDR(GPIOE_ODR_Addr,n)  //ê?3? 
#define PEin(n)    BIT_ADDR(GPIOE_IDR_Addr,n)  //ê?è?

#define PFout(n)   BIT_ADDR(GPIOF_ODR_Addr,n)  //ê?3? 
#define PFin(n)    BIT_ADDR(GPIOF_IDR_Addr,n)  //ê?è?

#define PGout(n)   BIT_ADDR(GPIOG_ODR_Addr,n)  //ê?3? 
#define PGin(n)    BIT_ADDR(GPIOG_IDR_Addr,n)  //ê?è?



void NVIC_Configuration(void);



#endif

然后将上述.c的源文件加入同一个工程文件里面构建。

 然后将上述构建出来的HEX文件烧入芯片，

然后将STM32F103芯片的PB6接口接到AHT20芯片的SCL口，PA7口接相应的SDA口，然后3.3V对接，接地对接后，用USB转TTL与芯片链接接到电脑上，并且打开电脑的串口助手，打开串口，然后每隔几秒得到一组温度和湿度的数据。

 在上述得到一系列的21.8摄氏度的情况下，用手指去捏着AHT20后可以得到明显温度和湿度都得到大幅度的上升，得出有效的温度传感器。

三 用stm32f103芯片的SPI和IIC接口接上OLED屏显示中文姓名温湿度

  首先用以下载的文件后打开其中的工程文件，可以得到其中的所有源代码文件，将其中代码中的一些内容进行更改就可以得到我们需要的内容。

 1 先用文字字模生成器PCtolCD200生成需要的字模

 由于OLED显示屏是竖屏幕显示所以需要横屏显示的时候就需要旋转90度这里特意将小字转换与其他字体方向相反试试

然后在将以上得到的字模复制到工程文件里面的gui.c里面的oledfond.h文件里面的相应字模模块

然后进入test.c中将修改显示函数void TEST_MainPage(void)中的原内容中的名字和学号更改为自己的就可以了

 在将main.c中的while循环语句中的第一项不更改其他的全部加上注释或者删除均可如下

 2 烧录程序

做完上述步骤后，构建完毕生成hex文件，将此Hex文件烧录到自己的芯片当中，然后以一定接法以oled屏和stm32芯片相接，具体如下

OLED      to       stm32

VCC                   3.3V

GND                   GND

D0                       PB13

D1                      PB15

DC                      PB10

CS                       PB11

RES                    PB12

然后给芯片供电，OLED屏亮起来得到以下内容

可以看到成功显示了名字和学号，小字也得到了相应的翻转。 

四 显示温湿度

 显示温湿度也需要有文字的显示，所以和以上一样，首先点开工程文件里面的test.c分支里面的oldefond.h头文件里面，将里面16*16的点阵中的内容改一下，改成当前温湿度的字模。当然 也是需要翻转的

 因为需要用到温湿度检测，所以需要用到最上面的温湿度检测代码，以及需要用到AHT20芯片，所以需要将温度湿度检测工程里面的bsp_i2c.c,bsp_i2c.h，sys.c,sys.h移植到本工程文件里面，当然sys可能会冲突，所以最好改名为AHT20_sys.c和AHT20_sys.h.然后在将bsp_i2c.c中的代码中的串口发送改为OLDE显示，需要更改一些代码如下void show_oled (void)

void shwo_oled(void)
{	
GUI_ShowCHinese(28,10,16,"当前温湿度",1);
  GUI_ShowCHinese(20,32,16,"温度：",1);
	GUI_ShowString(60,32,strTemp1,16,1);
	GUI_ShowString(68,32,strTemp2,16,1);
	GUI_ShowString(76,32,".",16,1);
	GUI_ShowString(84,32,strTemp3,16,1);
	GUI_ShowCHinese(92,32,16,"℃",1);
  GUI_ShowCHinese(20,48,16,"湿度：",1);
	GUI_ShowString(60,48,strHumi1,16,1);
	GUI_ShowString(68,48,strHumi2,16,1);
	GUI_ShowString(76,48,".",16,1);
	GUI_ShowString(84,48,strHumi3,16,1);
	GUI_ShowCHinese(92,48,16,"％",1);
}

然后在将main.c主函数中的不需要用到的滚动等函数注释掉或者删掉，然后加上以下代码

 

现在就大功告成可以开始构建了然后将生成的hex文件烧录到芯片里面，然后在芯片上同时接上oled显示屏和AHT20就可以了，在OLED屏幕上进行温湿度的显示

如上，显示了温湿度，并且用手指触碰AHT20温湿度感应上时其温湿度就会上升，得出所需要的结果。 

 

五 滚动屏显示

和以上相似，先将需要滚动显示的文字加载gui.c中的oledfond.h中的16*16的文字点阵中，

 然后将test.c中void TEST_MainPage(void)函数下的显示中文函数语句打上其他的可以删除可以加以注释

 然后将main.c中的主函数中的while循环删除或者注释掉，然后在其下面加入新的滚动函数

OLED_WR_Byte(0x2E,OLED_CMD);        //关闭滚动
    OLED_WR_Byte(0x27,OLED_CMD);        //水平向左或者右滚动 26/27
    OLED_WR_Byte(0x00,OLED_CMD);        //虚拟字节
	OLED_WR_Byte(0x00,OLED_CMD);        //起始页 0
	OLED_WR_Byte(0x07,OLED_CMD);        //滚动时间间隔
	OLED_WR_Byte(0x07,OLED_CMD);        //终止页 7
	OLED_WR_Byte(0x00,OLED_CMD);        //虚拟字节
	OLED_WR_Byte(0xFF,OLED_CMD);        //虚拟字节
	TEST_MainPage();
	OLED_WR_Byte(0x2F,OLED_CMD);        //开启滚动

然后构建生成HEX文件，将文件烧录到芯片中。

stm32f103芯片和OLED屏的接法如上就可以得到如下所示的滚动字幕

 得到以上滚动显示的“白日依山尽”

 六 总结

  本次使用了SPI和i2c分别显示温湿度和使用中文字模生成器生成字模OLDE屏幕上显示了文字，也将温湿度从串口上搬到了OLED屏幕上，得到了滚屏显示等的结果，但上面实现的就只有代码的修改，文字的修改，其实还需要学习的内容还有很多，加油吧。

七 参考文献

基于 SPI 协议用 0.96 寸 OLED 显示汉字及温湿度数据_L-GRAZY的博客-CSDN博客

https://doc.embedfire.com/mcu/stm32/f407batianhu/hal/pdf/[%E9%87%8E%E7%81%ABEmbedFire]%E3%80%8ASTM32%20HAL%E5%BA%93%E5%BC%80%E5%8F%91%E5%AE%9E%E6%88%98%E6%8C%87%E5%8D%97%E2%80%94%E2%80%94%E5%9F%BA%E4%BA%8E%E9%87%8E%E7%81%AB%E9%9C%B8%E5%A4%A9%E8%99%8E%E5%BC%80%E5%8F%91%E6%9D%BF%E3%80%8B.pdf