第10周作业--汉字点阵与OLED屏显

已于 2023-11-19 12:11:11 修改
阅读量128 收藏
点赞数
文章标签： stm32
于 2023-11-19 12:01:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gasling2003/article/details/134488672
版权

第10周作业–汉字点阵与OLED屏显

  1. 串口传输文件的练习。将两台笔记本电脑，借助 usb转rs232 模块和杜邦线，建立起串口连接。然后用串口助手等工具软件（带文件传输功能）将一台笔记本上的一个大文件（图片、视频和压缩包软件）传输到另外一台电脑，预算文件大小、波特率和传输时间三者之间的关系，并对比实际传输时间。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

成功的进行了将两台笔记本电脑，借助 usb转rs232 模块和杜邦线，建立起串口连接，传输文件。尽管没有计算实际时间，但是通过大致的对比可以得知，波特率越大所需要的时间就越短，并且在一台电脑传输时，另一台电脑不可传输。

2.学习理解汉字的机内码、区位码编码规则和字形数据存储格式。在Ubuntu下用C/C++(或python) 调用opencv库编程显示一张图片，并打开一个名为"logo.txt"的文本文件（其中只有一行文本文件，包括你自己的名字和学号），按照名字和学号去读取汉字24*24点阵字形字库（压缩包中的文件HZKf2424.hz）中对应字符的字形数据，将名字和学号叠加显示在此图片右下位置。

汉字的机内码、区位码和字形数据存储格式是汉字编码中的三个重要概念。并配以简单的图示。

  1. 机内码（GB2312-80）

机内码是汉字在计算机内部存储和处理的编码方式。GB2312-80是中国制定的第一个汉字编码标准，包含6763个汉字，涵盖了大部分常用汉字。

编码规则：

* 机内码采用2字节（16位）的编码方式。  
* 第一字节（高位字节）采用区号和位号表示，区号范围从0x4E00到0x9FA5，共94个区；位号范围从0x00到0xFF，共256个位。  
* 第二字节（低位字节）采用区号和位号表示，但与第一字节的区号和位号紧密相连。例如，第一字节编码为0x4E00表示汉字"啊"，则第二字节编码为0x3F。

字形数据存储格式：

* 机内码的字形数据存储格式采用点阵形式，每个汉字点阵包含16×16=256个点，每个点用一位二进制表示。  
* 字形数据存储时，首先存储字形数据的长度（字节数），然后存储实际的字形点阵数据。

\2. 区位码（GB2312-80）

区位码是汉字在计算机外部存储和传输的编码方式。它将汉字分为94个区，每个区有94个位，共计8836个汉字。

编码规则：

* 区位码采用4个十进制数字表示，前两个数字表示区号，后两个数字表示位号。例如，"啊"字的区位码为49 28H（H表示十六进制）。  
* 区位码不包含重码字，即同一个汉字在同一个区位中只有一个编码。

字形数据存储格式：

* 区位码的字形数据存储格式通常采用轮廓矢量化格式，每个汉字的字形数据由一组矢量描述。这种格式可以节省存储空间，并可以通过软件进行字形缩放、旋转等操作。  
* 字形数据存储时，通常会附带一些其他信息，如字体类型、大小、颜色等。

\3. 字形数据存储格式示例图（轮廓矢量化格式）

下面是一个示例图，展示了轮廓矢量化格式的字形数据存储方式：

字形数据：轮廓矢量化格式示例图  
  
+----------------+----------------+----------------+----------------+  
| 字形数据1（矢量）| 字形数据2（矢量）| 字形数据3（矢量）| 字形数据4（矢量）|  
+----------------+----------------+----------------+----------------+

在轮廓矢量化格式中，每个汉字的字形数据由一组矢量描述。这些矢量定义了字形的轮廓和内部细节。存储时，每个字形数据的长度和具体矢量数据都会被记录下来。使用这种格式可以节省存储空间，并可以通过软件进行字形缩放、旋转等操作。

安装OPENCV依赖库：

sudo apt-get install build-essential libgtk2.0-dev libavcodec-dev libavformat-dev libjpeg-dev libswscale-dev libtiff5-dev sudo apt-get install libgtk2.0-dev sudo apt-get install pkg-config

下载源码sources

在这里插入图片描述
在这里插入图片描述

下载完成后提取文件
在这里插入图片描述

然后在里面创建build目录，并且进入

输入代码指令进行解压安装。

cmake ..

make -j4

sudo make install
在这里插入图片描述

然后来进行字符数据显示

创建一个open.cpp文件，在文件夹下打开终端，输入以下命令

vim open.cpp

然后在里面输入代码：

`#include
#include<opencv/cv.h>
#include"opencv2/opencv.hpp"
#include<opencv/cxcore.h>
#include<opencv/highgui.h>
#include<math.h>

using namespace cv;
using namespace std;

void paint_chinese(Mat& image,int x_offset,int y_offset,unsigned long offset);
void paint_ascii(Mat& image,int x_offset,int y_offset,unsigned long offset);
void put_text_to_image(int x_offset,int y_offset,String image_path,char* logo_path);

int main(){
String image_path=“X.jpg”;//图片的名字
char* logo_path=“peng.txt”;//汉字文件的名字
put_text_to_image(200,350,image_path,logo_path);//change txt place
return 0;
}

void paint_ascii(Mat& image,int x_offset,int y_offset,unsigned long offset){
//绘制的起点坐标
Point p;
p.x = x_offset;
p.y = y_offset;
//存放ascii字膜
char buff[16];
//打开ascii字库文件
FILE *ASCII;

if ((ASCII = fopen("Asci0816.zf", "rb")) == NULL){
	printf("Can't open ascii.zf,Please check the path!");
	//getch();
	exit(0);
}

fseek(ASCII, offset, SEEK_SET);
fread(buff, 16, 1, ASCII);

int i, j;
Point p1 = p;
for (i = 0; i<16; i++)                  //十六个char
{
	p.x = x_offset;
	for (j = 0; j < 8; j++)              //一个char八个bit
	{
		p1 = p;
		if (buff[i] & (0x80 >> j))    /*测试当前位是否为1*/
		{
			/*
				由于原本ascii字膜是8*16的，不够大，
				所以原本的一个像素点用4个像素点替换，
				替换后就有16*32个像素点
				ps：感觉这样写代码多余了，但目前暂时只想到了这种方法
			*/
			circle(image, p1, 0, Scalar(0, 0, 255), -1);
			p1.x++;
			circle(image, p1, 0, Scalar(0, 0, 255), -1);
			p1.y++;
			circle(image, p1, 0, Scalar(0, 0, 255), -1);
			p1.x--;
		   circle(image, p1, 0, Scalar(0, 0, 255), -1);
		}						
        p.x+=2;            //原来的一个像素点变为四个像素点，所以x和y都应该+2
	}
	p.y+=2;
}

}
void paint_chinese(Mat& image,int x_offset,int y_offset,unsigned long offset){//在图片上画汉字
Point p;
p.x=x_offset;
p.y=y_offset;
FILE *HZK;
char buff[72];//72个字节，用来存放汉字的

if((HZK=fopen("HZKf2424.hz","rb"))==NULL){
    printf("Can't open HZKf2424.hz,Please check the path!");
    exit(0);//退出
}
fseek(HZK, offset, SEEK_SET);/*将文件指针移动到偏移量的位置*/
fread(buff, 72, 1, HZK);/*从偏移量的位置读取72个字节，每个汉字占72个字节*/
bool mat[24][24];//定义一个新的矩阵存放转置后的文字字膜
int i,j,k;
for (i = 0; i<24; i++)                 /*24x24点阵汉字，一共有24行*/
{
    	for (j = 0; j<3; j++)                /*横向有3个字节，循环判断每个字节的*/
		for (k = 0; k<8; k++)              /*每个字节有8位，循环判断每位是否为1*/
			if (buff[i * 3 + j] & (0x80 >> k))    /*测试当前位是否为1*/
			{
				mat[j * 8 + k][i] = true;          /*为1的存入新的字膜中*/
			}
			else {
				mat[j * 8 + k][i] = false;
			}
}

for (i = 0; i < 24; i++)
{
	p.x = x_offset;
	for (j = 0; j < 24; j++)
	{		
		if (mat[i][j])
			circle(image, p, 1, Scalar(255, 0, 0), -1);		  //写(替换)像素点
		p.x++;                                                //右移一个像素点
	}
	p.y++;                                                    //下移一个像素点
}

}

void put_text_to_image(int x_offset,int y_offset,String image_path,char* logo_path){//将汉字弄上图片
//x和y就是第一个字在图片上的起始坐标
//通过图片路径获取图片
Mat image=imread(image_path);
int length=19;//要打印的字符长度（打印多少字节长度就为多少，根据自己的情况调整）
unsigned char qh,wh;//定义区号，位号
unsigned long offset;//偏移量
unsigned char hexcode[30];//用于存放记事本读取的十六进制,记得要用无符号
FILE* file_logo;

if ((file_logo = fopen(logo_path, "rb")) == NULL){
	printf("Can't open txtfile,Please check the path!");
	//getch();
	exit(0);
}

fseek(file_logo, 0, SEEK_SET);
fread(hexcode, length, 1, file_logo);
int x =x_offset,y = y_offset;//x,y:在图片上绘制文字的起始坐标

for(int m=0;m<length;){
    if(hexcode[m]==0x23){
        break;//读到#号时结束
    }
    else if(hexcode[m]>0xaf){
        qh=hexcode[m]-0xaf;//使用的字库里是以汉字啊开头，而不是以汉字符号开头
        wh=hexcode[m+1] - 0xa0;//计算位码
        offset=(94*(qh-1)+(wh-1))*72L;
        paint_chinese(image,x,y,offset);
        /*
        计算在汉字库中的偏移量
        对于每个汉字，使用24*24的点阵来表示的
        一行有三个字节，一共24行，所以需要72个字节来表示
        */

        m=m+2;//一个汉字的机内码占两个字节，
        x+=24;//一个汉字为24*24个像素点，由于是水平放置，所以是向右移动24个像素点
    }

    else{
    //当读取的字符为ASCII码时
    wh=hexcode[m];
    offset=wh*16l;//计算英文字符的偏移量
    paint_ascii(image,x,y,offset);
    m++;//英文字符在文件里表示只占一个字节，所以往后移一位就行了
    x+=16;
    }

}

cv::imshow("image", image);
cv::waitKey();

}`

在这里插入图片描述

然后保存。

编译指令

g++ open.cpp -o pengpkg-config --cflags --libs opencv`

生成open执行文件

在这里插入图片描述

使用。/peng

运行生成下图

在这里插入图片描述

3. 理解OLED屏显和汉字点阵编码原理，使用STM32F103的SPI或IIC接口实现以下功能：

（1) 显示自己的学号和姓名；

下载OLED配套资料：

解压完成后打开DEMO文件夹选择TM32
在这里插入图片描述

选择第四个使用KEIL打开
在这里插入图片描述

在gui.c中找到oledfont.h点击追踪，找到oledfont.h

在这里插入图片描述

找到

const typFNT_GB16 cfont16[] =

改为：

在这里插入图片描述

在这里插入//"电",0x00,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x3F,0xF8,0x21,0x08,0x21,0x08,0x3F,0xF8,
//0x21,0x08,0x21,0x08,0x3F,0xF8,0x3F,0xF8,0x21,0x00,0x01,0x02,0x01,0xFE,0x00,0x00,/*"电",0*/
	
//"光",0x00,0x00,0x01,0x80,0x01,0x80,0x11,0x8C,0x19,0x98,0x0D,0xB0,0x11,0x80,0x7F,0xFE,
//0x02,0x40,0x02,0x40,0x06,0x40,0x04,0x40,0x0C,0x42,0x18,0x46,0x70,0x7C,0x00,0x00,/*"光",1*/
	
//"超",0x00,0x00,0x08,0x00,0x08,0xFE,0x3E,0x26,0x08,0x24,0x08,0x44,0x7F,0xDC,0x0C,0x90,
//0x0C,0x7C,0x2F,0x44,0x2D,0x44,0x2C,0x44,0x7C,0x7C,0x4C,0x00,0x47,0xFE,0x00,0x00,/*"超",2*/
	
//"人",0x00,0x00,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,
//0x03,0xC0,0x02,0x40,0x06,0x60,0x04,0x30,0x08,0x18,0x30,0x0C,0x60,0x06,0x00,0x00,/*"人",3*/
	
//"古",0x00,0x00,0x01,0x80,0x01,0x80,0x01,0x80,0x7F,0xFE,0x01,0x80,0x01,0x80,0x01,0x80,
//0x1F,0xF8,0x10,0x08,0x10,0x08,0x10,0x08,0x10,0x08,0x1F,0xF8,0x10,0x08,0x00,0x00,/*"古",4*/
	
//"力",0x00,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x3F,0xFE,0x01,0x04,0x01,0x04,
//0x03,0x04,0x03,0x04,0x02,0x04,0x06,0x04,0x0C,0x04,0x18,0x0C,0x70,0x38,0x20,0x00,/*"力",5*/
	
//"特",0x00,0x00,0x08,0x20,0x08,0x20,0x69,0xFE,0x48,0x20,0x7E,0x20,0x49,0xFE,0x48,0x08,
//0x08,0x08,0x1F,0xFE,0x68,0x08,0x08,0x88,0x08,0xC8,0x08,0x08,0x08,0x38,0x08,0x10,/*"特",6*/代码片

然后到test.c文件，在TEST_MainPage函数下进行修改

在这里插入图片描述

最后打开main.c修改为

在这里插入图片描述

点击保存编译，烧录进入STM32得到：

在这里插入图片描述

连接方式如下：
在这里插入图片描述

\2) 显示AHT20的温度和湿度；

首先要下载AHT20相关的资料，在我IIC里面有写。地址为：

将文件复制到HARDWARE下面
在这里插入图片描述

然后添加到头文件下面

在这里插入图片描述

然后添加到路径里面

在这里插入图片描述

添加到include paths中

在这里插入图片描述

在const typFNT_GB16 cfont16[] = 下面：

"正",0x00,0x00,0x00,0x00,0x3F,0xFC,0x3F,0xFC,0x00,0x80,0x00,0x80,0x18,0x80,0x18,0xFC,`
`0x18,0xFC,0x18,0x80,0x18,0x80,0x18,0x80,0x18,0x80,0x18,0x80,0x7F,0xFE,0x00,0x00,/*"正",0*/`
`"在",0x00,0x00,0x01,0x00,0x03,0x00,0x3F,0xFE,0x3F,0xFE,0x06,0x60,0x04,0x60,0x18,0x60,`
`0x1B,0xFC,0x38,0x60,0x78,0x60,0x18,0x60,0x18,0x60,0x18,0x60,0x1F,0xFE,0x18,0x00,/*"在",1*/`
`"检",0x00,0x00,0x10,0x60,0x10,0x60,0x10,0xF0,0x7C,0x90,0x11,0x0C,0x13,0xF6,0x32,0x00,`
`0x3D,0x44,0x77,0x6C,0x51,0x28,0x51,0xA8,0x10,0x10,0x14,0x10,0x17,0xFE,0x10,0x00,/*"检",2*/`
`"测",0x00,0x00,0x00,0x06,0x77,0xC6,0x14,0x56,0x04,0x56,0x45,0x56,0x65,0x56,0x25,0x56,`
`0x05,0x56,0x15,0x56,0x15,0x56,0x23,0x96,0x22,0x86,0x46,0x46,0x4C,0x4E,0x00,0x00,/*"测",3*/`
`"中",0x00,0x00,0x01,0x80,0x01,0x80,0x01,0x80,0x3F,0xFC,0x21,0x84,0x21,0x84,0x21,0x84,`
`0x21,0x84,0x3F,0xFC,0x21,0x84,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,/*"中",4*/`
`"温",0x00,0x00,0x23,0xF8,0x12,0x08,0x12,0x08,0x83,0xF8,0x42,0x08,0x42,0x08,0x13,0xF8,`
`0x10,0x00,0x27,0xFC,0xE4,0xA4,0x24,0xA4,0x24,0xA4,0x24,0xA4,0x2F,0xFE,0x00,0x00,/*"温",0*/`

`"度",0x01,0x00,0x00,0x80,0x3F,0xFE,0x22,0x20,0x22,0x20,0x3F,0xFC,0x22,0x20,0x22,0x20,`
`0x23,0xE0,0x20,0x00,0x2F,0xF0,0x24,0x10,0x42,0x20,0x41,0xC0,0x86,0x30,0x38,0x0E,/*"度",1*/`

`"湿",0x00,0x00,0x27,0xF8,0x14,0x08,0x14,0x08,0x87,0xF8,0x44,0x08,0x44,0x08,0x17,0xF8,`
`0x11,0x20,0x21,0x20,0xE9,0x24,0x25,0x28,0x23,0x30,0x21,0x20,0x2F,0xFE,0x00,0x00,/*"湿",2*/`

`"度",0x01,0x00,0x00,0x80,0x3F,0xFE,0x22,0x20,0x22,0x20,0x3F,0xFC,0x22,0x20,0x22,0x20,`
`0x23,0xE0,0x20,0x00,0x2F,0xF0,0x24,0x10,0x42,0x20,0x41,0xC0,0x86,0x30,0x38,0x0E,/*"度",3*/

`
将AHT20-21_DEMO_V1_3.h改为：

``#ifndef _AHT20_DEMO_`
`#define _AHT20_DEMO_`

`#include "stm32f10x.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"

``

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.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB,& GPIO_InitStruct);
GPIO_SetBits(GPIOB,GPIO_Pin_7);
}

void SDA_Pin_Output_Low(void) //将P7配置为输出 并设置为低电平
{

GPIO_InitTypeDef  GPIO_InitStruct;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB,& GPIO_InitStruct);
GPIO_ResetBits(GPIOB,GPIO_Pin_7);

}

void SDA_Pin_IN_FLOATING(void) //SDA配置为浮空输入
{

GPIO_InitTypeDef  GPIO_InitStruct;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;//
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init( GPIOB,&GPIO_InitStruct);

}

void SCL_Pin_Output_High(void) //SCL输出高电平，PB6作为I2C的SCL
{
GPIO_SetBits(GPIOB,GPIO_Pin_6);
}

void SCL_Pin_Output_Low(void) //SCL输出低电平
{
GPIO_ResetBits(GPIOB,GPIO_Pin_6);
}

void Init_I2C_Sensor_Port(void) //初始化I2C接口,输出为高电平
{
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB,& GPIO_InitStruct);
GPIO_SetBits(GPIOB,GPIO_Pin_15);//输出高电平
``
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB,& GPIO_InitStruct);
GPIO_SetBits(GPIOB,GPIO_Pin_15);//输出高电平

}
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_7)) a=1;
Byte = (Byte<<1)|a;
SCL_Pin_Output_Low();
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((GPIO_ReadInputDataBit(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);
}

//int32_t main(void)
//{
// uint32_t CT_data[2];
// volatile int c1,t1;
// /***********************************************************************************/
// /**///①刚上电，产品芯片内部就绪需要时间，延时100~500ms,建议500ms // /***********************************************************************************/ // Delay_1ms(500); // /***********************************************************************************/ // /**///②上电第一次发0x71读取状态字，判断状态字是否为0x18,如果不是0x18,进行寄存器初始化
// /***********************************************************************************/
// if((AHT20_Read_Status()&0x18)!=0x18)
// {
// AHT20_Start_Init(); //重新初始化寄存器
// Delay_1ms(10);
// }
//
// /***********************************************************************************/
// /**///③根据客户自己需求发测量命令读取温湿度数据，当前while（1）循环发测量命令读取温湿度数据，仅供参考 // /***********************************************************************************/
// while(1)
// {
// AHT20_Read_CTdata(CT_data); //不经过CRC校验，直接读取AHT20的温度和湿度数据 推荐每隔大于1S读一次
// //AHT20_Read_CTdata_crc(CT_data); //crc校验后，读取AHT20的温度和湿度数据
//

// c1 = CT_data[0]*100*10/1024/1024; //计算得到湿度值c1（放大了10倍）
// t1 = CT_data[1]*200*10/1024/1024-500;//计算得到温度值t1（放大了10倍）
// 下一步客户处理显示数据，
// }

// }


将main.c改为：


```c
`#include "delay.h"`
`#include "sys.h"`
`#include "oled.h"`
`#include "gui.h"`
`#include "test.h"`
`#include "AHT20-21_DEMO_V1_3.h"` 


`//存放温度和湿度`
`uint32_t CT_data[2]={0,0};`
`//湿度和温度`
`volatile int  c1,t1;`

`//用于LED显示的温度和湿度`
`u8 temp[10];  
u8 hum[10];`

`//初始化PC13用于测试`
`void GPIOC13_Init(void){`
	`GPIO_InitTypeDef  GPIO_InitStructure;`
	`RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);`	
	`GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;`
	`GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;`
	`GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;`
	`GPIO_Init(GPIOC, &GPIO_InitStructure);`	
	`GPIO_ResetBits(GPIOC,GPIO_Pin_13);`

`}`
`//初始化以及前期准备`
`void Init(void);`

`//读取温湿度`
`void getData(void);`

`//显示温湿度`
`void showData(void);`

`int main(void)`
`{`	
	`//初始化`
	`Init();`
	`while(1){`

		//获取数据
		getData();
		//显示数据
		showData();
	 
		//开启滚动
		OLED_WR_Byte(0x2F,OLED_CMD);
		
		//延时
		Delay_1ms(3100);
		//OLED_Clear(0); 
	}

`}`

`//初始化以及前期准备`
`void Init(void){`
	`//初始化PC12`
	`GPIOC13_Init();`		
``	
	//延时函数初始化	  
	delay_init();	   
	
	//初始化OLED 
	OLED_Init();
	 
	//清屏（全黑）	
	OLED_Clear(0);    
	//开机显示信息	
`GUI_ShowCHinese(10,0,16,"开启中",1);`	
``	
	Delay_1ms(1000);
	
	AHT20_Init();
	
	Delay_1ms(1000);
	
	OLED_Clear(0); 
	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(0x02,OLED_CMD); //终止页 2
	 
	OLED_WR_Byte(0x00,OLED_CMD); //虚拟字节
	 
	OLED_WR_Byte(0xFF,OLED_CMD); //虚拟字节


``	
	GUI_ShowCHinese(10,0,16,"正在检测",1);	
`}`

`//读取温湿度`
`void getData(){`
	`//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倍）`

		//转为字符串易于显示
		temp[0]=t1/100+'0';
		temp[1]=(t1/10)%10+'0';
		temp[2]='.';
		temp[3]=t1%10+'0';
		temp[4]='\0';
		
		hum[0]=c1/100+'0';
		hum[1]=(c1/10)%10+'0';
		hum[2]='.';
		hum[3]=c1%10+'0';
		hum[4]=32;
		hum[5]='%';
		hum[6]='\0';
`}`


`//显示温湿度`
`void showData(){`
		`//显示温度`
		`GUI_ShowCHinese(16,24,16,"温度",1);`
		`GUI_ShowString(47,24,":",16,1);`
		`GUI_ShowString(62,24,temp,16,1);`
		`GUI_ShowCHinese(94,24,16,"度",1);`
``		

		//显示湿度
		GUI_ShowCHinese(16,42,16,"湿度",1);
		GUI_ShowString(47,42,":",16,1);
		GUI_ShowString(62,42,hum,16,1);

`}`

随后点击编译烧录进入STM32
在这里插入图片描述

成功运行：

在这里插入图片描述
在这里插入图片描述

\3) 上下或左右的滑动显示长字符，比如“Hello，欢迎来到重庆交通大学物联网205实训室！”或者一段歌词或诗词(最好使用硬件刷屏模式)。

字符：

`"诀",0x00,0x00,0x00,0x40,0x30,0x40,0x1B,0xFC,0x03,0xFC,0x00,0x4C,0x70,0x4C,0x10,0x4C,`
`0x17,0xFE,0x10,0x40,0x10,0xA0,0x1C,0xA0,0x19,0x90,0x33,0x1C,0x06,0x06,0x04,0x00,/*"诀",0*/`
`"别",0x00,0x00,0x00,0x04,0x3F,0x04,0x21,0x24,0x21,0x24,0x3F,0x24,0x3F,0x24,0x08,0x24,`
`0x08,0x24,0x7F,0xA4,0x08,0xA4,0x08,0xA4,0x18,0x84,0x30,0x84,0x63,0x9C,0x00,0x00,/*"别",1*/`
`"之",0x00,0x00,0x02,0x00,0x01,0x00,0x01,0x00,0x00,0x00,0x3F,0xF8,0x00,0x20,0x00,0xC0,`
`0x01,0x80,0x03,0x00,0x06,0x00,0x0C,0x00,0x3C,0x00,0x67,0x80,0x01,0xFE,0x00,0x00,/*"之",2*/`
`"时",0x00,0x00,0x00,0x08,0x00,0x08,0x7C,0x08,0x65,0xFE,0x65,0xFE,0x64,0x08,0x7C,0x88,`
`0x64,0xC8,0x64,0x48,0x64,0x08,0x7C,0x08,0x64,0x08,0x60,0x08,0x00,0x38,0x00,0x00,/*"时",3*/`
`"已",0x00,0x00,0x00,0x00,0x3F,0xF8,0x00,0x08,0x00,0x08,0x30,0x08,0x30,0x08,0x3F,0xF8,`
`0x30,0x08,0x30,0x00,0x30,0x00,0x30,0x00,0x30,0x06,0x30,0x06,0x1F,0xFC,0x00,0x00,/*"已",4*/`
`"至",0x00,0x00,0x00,0x00,0x3F,0xFC,0x02,0x00,0x03,0x00,0x06,0x20,0x0C,0x10,0x1F,0xF8,`
`0x01,0x80,0x01,0x80,0x1F,0xF8,0x01,0x80,0x01,0x80,0x01,0x80,0x7F,0xFE,0x00,0x00,/*"至",5*/`

`"跨",0x00,0x00,0x00,0x20,0x3C,0x20,0x25,0xFE,0x24,0x50,0x3C,0x88,0x09,0xFF,0x09,0x02,`
`0x28,0x00,0x2D,0xFE,0x28,0x40,0x28,0xFC,0x2C,0x04,0x78,0x04,0x40,0x1C,0x00,0x10,/*"跨",0*/`
`"过",0x00,0x00,0x00,0x18,0x30,0x18,0x10,0x18,0x1B,0xFE,0x00,0x18,0x01,0x18,0x71,0x18,`
`0x11,0x98,0x10,0x98,0x10,0x18,0x10,0x10,0x10,0x70,0x3C,0x00,0x67,0xFE,0x00,0x00,/*"过",1*/`
`"高",0x00,0x00,0x01,0x00,0x01,0x80,0x7F,0xFE,0x1F,0xF0,0x08,0x10,0x08,0x10,0x1F,0xF0,`
`0x7F,0xFE,0x20,0x06,0x27,0xE6,0x24,0x26,0x24,0x26,0x27,0xE6,0x20,0x0E,0x00,0x08,/*"高",2*/`
`"山",0x00,0x00,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x21,0x84,0x21,0x84,0x21,0x84,`
`0x21,0x84,0x21,0x84,0x21,0x84,0x21,0x84,0x21,0x84,0x3F,0xFC,0x00,0x04,0x00,0x00,/*"山",3*/`
`"飞",0x00,0x00,0x00,0x00,0x7F,0xC0,0x00,0x48,0x00,0x58,0x00,0x50,0x00,0x60,0x00,0x70,`
`0x00,0x58,0x00,0x4C,0x00,0x40,0x00,0x60,0x00,0x22,0x00,0x36,0x00,0x1C,0x00,0x00,/*"飞",5*/`
`"跃",0x00,0x00,0x3E,0x08,0x23,0xF8,0x22,0x20,0x22,0x20,0x3E,0x20,0x08,0x20,0x09,0xFE,`
`0x2E,0x20,0x28,0x30,0x28,0x50,0x28,0x58,0x2E,0xC8,0x71,0x84,0x03,0x06,0x00,0x00,/*"跃",6*/`
`"流",0x00,0x00,0x00,0xC0,0x30,0x40,0x1F,0xFE,0x00,0x80,0x41,0x10,0x63,0x08,0x37,0xFC,`
`0x00,0x04,0x13,0x58,0x13,0x58,0x13,0x58,0x22,0x58,0x62,0x5A,0x44,0x5E,0x00,0x00,/*"流",7*/`
`"水",0x00,0x00,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x84,0x7D,0x8C,0x05,0x90,0x05,0xE0,`
`0x09,0xE0,0x09,0xA0,0x11,0x90,0x31,0x98,0x61,0x8E,0x01,0x80,0x03,0x80,0x02,0x00,/*"水",8*/`
`"这",0x00,0x00,0x20,0x80,0x20,0x40,0x30,0x40,0x1F,0xFC,0x00,0x18,0x03,0x10,0x71,0x90,`
`0x10,0x60,0x10,0x70,0x10,0xD0,0x11,0x88,0x12,0x0C,0x3C,0x00,0x43,0xFE,0x00,0x00,/*"这",10*/`
`"永",0x00,0x00,0x03,0x00,0x01,0xC0,0x00,0x40,0x0F,0x80,0x00,0x80,0x00,0x84,0x7E,0xCC,`
`0x06,0xF0,0x04,0xA0,0x04,0xB0,0x0C,0x98,0x18,0x8C,0x30,0x86,0x23,0x80,0x02,0x00,/*"永",11*/`
`"不",0x00,0x00,0x00,0x00,0x7F,0xFE,0x00,0x80,0x01,0x00,0x03,0x00,0x07,0x60,0x05,0x30,`
`0x19,0x18,0x31,0x0C,0x61,0x04,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x00,0x00,/*"不",12*/`
`"坠",0x00,0x00,0x3F,0x20,0x3E,0x20,0x24,0x20,0x24,0x30,0x24,0x70,0x22,0x58,0x26,0xCC,`
`0x25,0x86,0x20,0x00,0x01,0x80,0x3F,0xF8,0x01,0x80,0x01,0x80,0x7F,0xFE,0x00,0x00,/*"坠",13*/`
`"落",0x00,0x00,0x04,0x60,0x7F,0xFE,0x04,0x60,0x25,0x80,0x31,0xFC,0x03,0x08,0x46,0x90,`
`0x70,0x60,0x21,0xFE,0x1E,0x02,0x33,0xF8,0x23,0x08,0x63,0x08,0x43,0xF8,0x03,0x00,/*"落",14*/`
`"的",0x00,0x00,0x08,0x20,0x08,0x60,0x18,0x40,0x3E,0x7E,0x22,0xC6,0x22,0x86,0x23,0x86,`
`0x3E,0x66,0x22,0x24,0x22,0x34,0x22,0x04,0x22,0x04,0x3E,0x04,0x22,0x3C,0x00,0x00,/*"的",15*/`
`"双",0x00,0x00,0x00,0x00,0x7E,0xFC,0x02,0x84,0x02,0xC4,0x22,0xCC,0x36,0x48,0x1C,0x48,`
`0x0C,0x48,0x0C,0x78,0x0A,0x30,0x1B,0x30,0x30,0x78,0x20,0xCC,0x03,0x06,0x02,0x00,/*"双",16*/`
`"翅",0x00,0x00,0x10,0x00,0x11,0xDE,0x7E,0x42,0x7E,0x52,0x11,0x5A,0x11,0xCA,0x7C,0x46,`
`0x04,0xCE,0x27,0x5A,0x28,0x52,0x38,0x46,0x18,0xCC,0x3C,0x00,0x63,0xFE,0x40,0x00,/*"翅",17*/`
`"鹤",0x00,0x00,0x0C,0x10,0x08,0x10,0x7F,0xFE,0x5D,0xC4,0x14,0x54,0x3F,0x5C,0x64,0x4C,`
`0x64,0x48,0x3F,0x7E,0x24,0x02,0x3F,0x02,0x24,0x7A,0x3F,0x02,0x20,0x0E,0x00,0x08,/*"鹤",19*/`
`"翼",0x00,0x00,0x00,0x00,0x7E,0x7C,0x12,0x24,0x7E,0xFC,0x40,0x00,0x3F,0xF8,0x3F,0xF8,`
`0x31,0x88,0x3F,0xF8,0x3F,0xFC,0x04,0x20,0x7F,0xFE,0x04,0x30,0x38,0x1E,0x20,0x00,/*"翼",20*/`
`"三",0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0xF8,`
`0x1F,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0xFE,0x00,0x00,0x00,0x00,/*"三",21*/`
`"连",0x00,0x00,0x00,0x40,0x60,0x80,0x37,0xFE,0x11,0x00,0x01,0x20,0x02,0x20,0x73,0xFC,`
`0x10,0x20,0x10,0x20,0x17,0xFE,0x10,0x20,0x10,0x20,0x38,0x20,0x47,0xFE,0x00,0x00,/*"连",22*/`

然后在main.c中去掉while函数

加入：

`d`elay_init();	    	       //延时函数初始化	  
	NVIC_Configuration(); 	   //设置NVIC中断分组2:2位抢占优先级，2位响应优先级` 	
	`OLED_Init();			         //初始化OLED  
	OLED_Clear(0);             //清屏（全黑）`
``	
`		

```c
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); //终止页 2
OLED_WR_Byte(0x00,OLED_CMD); //虚拟字节
OLED_WR_Byte(0xFF,OLED_CMD); //虚拟字节
TEST_MainPage();
OLED_WR_Byte(0x2F,OLED_CMD); //开启滚动

在
在这里插入图片描述

最后编译运行烧录

https://live.csdn.net/v/344691
参考https://blog.csdn.net/qq_43279579/article/details/111414037
总结：
串口传输文件的练习
通过这个练习，我了解了串口通信的基本原理和如何使用串口助手等工具软件进行文件传输。文件传输过程中，文件大小、波特率和传输时间之间存在一定的关系。一般来说，文件大小越大，传输时间越长。而波特率越高，传输速度越快，相应的传输时间也会减少。

在实验中，我们通过调整波特率来观察传输时间的变化。当波特率较低时，传输时间较长，而当波特率较高时，传输时间明显缩短。这是因为高波特率意味着更高的传输速率，从而减少了传输时间。

此外，我们还注意到不同操作系统和硬件设备之间可能存在差异，例如在Windows系统下的传输时间和在Linux系统下的传输时间可能会有所不同。这主要是因为不同的操作系统和硬件设备可能采用不同的串口通信协议或具有不同的传输速率。

学习理解汉字的机内码、区位码编码规则和字形数据存储格式
通过这个练习，我深入了解了汉字的机内码、区位码编码规则和字形数据存储格式。汉字的机内码是汉字在计算机内部的编码方式，而区位码则是汉字在字符集中的位置标识。字形数据存储格式则是将汉字的字形以点阵的形式存储在计算机中。

在实现汉字叠加显示的过程中，我使用了OpenCV库来读取汉字点阵字库中的字形数据，并将这些数据绘制在图片上。具体来说，我使用了OpenCV的imread函数来读取图片，然后使用相应的函数将汉字的字形数据绘制在图片上。

在叠加文本时，我使用了OpenCV的putText函数来将文本信息叠加在图片上。需要注意的是，叠加的文本需要以UTF-8编码方式存储在文本文件中，这样才能正确地显示中文字符。

理解OLED屏显和汉字点阵编码原理
通过这个练习，我深入了解了OLED屏幕的显示原理和汉字点阵编码原理。OLED屏幕是一种自发光屏幕，具有高对比度、广视角和低功耗等优点。而汉字点阵编码则是将汉字的字形以点阵的形式存储在计算机中，以便在屏幕上显示。

在使用STM32F103的SPI或IIC接口实现OLED屏幕显示时，需要注意以下几点：首先，需要选择合适的OLED屏幕型号和驱动芯片，并根据硬件连接方式配置好SPI或IIC接口。其次，需要编写相应的驱动程序来初始化OLED屏幕和读写汉字点阵数据。最后，需要将汉字点阵数据写入OLED屏幕的显存中，以便在屏幕上显示。

在实现上下或左右滑动显示长字符时，可以使用硬件刷屏模式来实现。硬件刷屏模式是指利用OLED屏幕的硬件特性，将屏幕分成多个区域，并在每个区域中分别显示不同的内容。这样可以大大减少刷屏次数，提高显示效率。同时，为了实现上下或左右滑动的效果，可以在每个区域中显示不同的字符或图片，并通过控制字符或图片的位置来实现滑动效果。

kuuga！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
OLED屏显和汉字点阵编码原理-附件资源
03-05
OLED屏显和汉字点阵编码原理-附件资源
OLED与LCD屏显的对比分析
01-19
本文将从三个方面来简要分析OLED与LCD的对比。 　一、OLED与LCD的概念 　OLED,即有机发光二极管或者有机电激光显示。OLED具有自发光的特性，采用非常薄的有机材料涂层和玻璃基板，当电流通过时，有机材料就会发光...
实验汉字点阵与OLED屏显
qq_68130187的博客
11-19 372
本次实操还是挺复杂的，姓名与学号的显示挺顺利的，滚动字幕的实现也不是太难，查阅资料与细心操作，也是一次实现，但对于显示AHT20的温度和湿度，这里首先是实现了显示，但是温度和湿度一直没有采集到，直到后面反复调试代码，才发现是电压需要给5V，同时接触不良导致了无法采集数据，最后反复测试与检查电路，成功实现了，还是成就满满的，嵌入式开发感觉就是这个过程很难，但最终成功的时候，哪一种喜悦真的是发自内心的。在实际应用中，通常会使用现成的字库和库函数来简化这个过程，例如，通过调用OpenCV等库来方便地显示汉字。
汉字点阵与OLED屏显
Hahhhnxsm_的博客
11-18 498
OLED(Organic Light Emitting Display，中文名有机发光显示器）是指有机半导体材料和发光材料在电场驱动下，通过载流子注入和复合导致发光的现象。其原理是用ITO透明电极和金属电极分别作为器件的阳极和阴极，在一定电压驱动下，电子和空穴分别从阴极和阳极注入到电子和空穴传输层，电子和空穴分别经过电子和空穴传输层迁移到发光层，并在发光层中相遇，形成激子并使发光分子激发，后者经过辐射弛豫而发出可见光。
行业资料-交通装置-一种屏显方舱车.zip
08-30
行业资料-交通装置-一种屏显方舱车.zip
显示/光电技术中的OLED与LCD屏显的对比分析
10-20
本文将从三个方面来简要分析OLED与LCD的对比。 　一、OLED与LCD的概念 　OLED,即有机发光二极管或者有机电激光显示。OLED具有自发光的特性，采用非常薄的有机材料涂层和玻璃基板，当电流通过时，有机材料就会发光...
基于与STM32的加湿器之温湿度驱动
weixin_44453694的博客
07-10 744
DHT11 数字温湿度传感器是一款含有已校准数字信号输出的温湿度复合传感器。它应用专用的数字模块采集技术和温湿度传感技术，确保产品具有枀高的可靠性与卓越的长期稳定性。传感器包括一个电容式感湿元件和一个 NTC 测温元件，并与一个高性能 8 位单片机相连接。
STM32（三）：STM32指南者新建工程常用配置
weixin_44264994的博客
07-10 214
这一步的配置也不是配置一次之后完事，常常会因为各种原因需要重新选择，当你下载的时候，提示说找不到Device的时候， 请确保该配置是否正确。如图在F1标准库工程组织中的CMSIS部分的core_cm3.c实际是不需要的，是否留在工程里面没有任何影响，所有例程中都没有使用到它，此文件为官方库保留，已被其他代替。2、在Output选项卡中把输出文件夹定位到我们工程目录下的“output”文件夹， 如果想在编译的过程中生成hex文件，那么那Create HEX File选项勾上。路径没配全，见1、（3）、（4）
STM32-TIM定时器
luckyme_的博客
07-06 855
TIM定时器可以对输入的时钟进行计数，并在计数值达到设定值时触发中断
stm32实现软件spi
m0_46145044的博客
07-10 91
【代码】stm32实现软件spi。
STM32要学到什么程度才算合格？
linlaoshi2009的博客
06-28 1188
不过呢，我觉得要是能把外设原理搞懂，还会用，已经很不错。在开始前刚好我有一些资料，是我根据网友给的问题精心整理了一份「嵌入式的资料从专业入门到高级教程」，2. 学会用 STM32 来做一些小项目，比如说控制个小机器人啦，或者做个智能家居系统啥的。给个小建议，可以去参加一些 STM32 的比赛或者项目，这样可以更快地提高自己的水平。点个关注在评论区回复“888”之后私信回复“888”，全部无偿共享给大家！3. 掌握一些编程技巧，比如说优化代码啦，提高程序的运行效率啦。
stm32使用硬件SPI
m0_46145044的博客
07-10 110
【代码】stm32使用硬件SPI。
STM32-EXTI
luckyme_的博客
07-06 1220
EXTI可以监测指定GPIO口的电平信号，当其指定的GPIO口产生电平变化时，EXTI将立即向NVIC发出中断申请，经过NVIC裁决后即可中断CPU主程序，使CPU执行EXTI对应的中断程序。支持的触发方式：上升沿/下降沿/双边沿/软件触发支持的GPIO口：所有GPIO口，但相同的Pin不能同时触发中断。（例如：PA0和PB0不能同时用）通道数：16个GPIO_Pin，外加PVD输出、RTC(实时时钟)闹钟、USB唤醒、以太网唤醒。
STM32-USART
luckyme_的博客
07-06 721
USART（Universal Synchronous/Asynchronous Receiver/Transmitter）通用同步/异步收发器USART是STM32内部集成的硬件外设，可根据数据寄存器的一个字节数据自动生成数据帧时序，从TX引脚发送出去，也可自动接收RX引脚的数据帧时序，拼接为一个字节数据，存放在数据寄存器里自带波特率发生器，最高达4.5Mbits/s。一般设置为9600或115200。可配置数据位长度（8/9）、停止位长度（0.5/1/1.5/2）
A63 STM32_HAL库函数 之 Uart通用驱动 -- B -- 所有函数的介绍及使用
最新发布
常驻客栈的博客--嵌入式EtherCAT
07-10 572
以上就是该博客驱动所有函数的介绍及使用的内容。有不明白的地方欢迎留言；有建议欢迎留言，我后面编写文档好改进。创作不容，如果文档对您有帮助，记得给个赞。
STM32点灯闪烁
eh的博客
07-07 449
配置GPIO端口步骤：开启时钟->使用结构体设置输出模式、引脚、速度->初始化GPIO。在stm32f10x_gpio.h文件中可以看到，读、写、初始GPIO函数有。GPIO端口的每个位可以由软件分别配置成 多种模式。这样就可以实现点灯闪烁操作了。stm32c8t6引脚图。
STM32 - PWR 笔记
上山的月的博客
07-10 700
此篇文章是笔记，关于江科大STM32中 PWR 部分，后续自己深入理解，该文整体层次按自己理解划分，结构十分清晰，主副明确。让我们更好理解PWR结构。
STM32快速复习(七)IIC通信
DianZeF的博客
07-04 839
IIC通信
stm32控制oled屏幕显示
07-27
在控制OLED屏幕显示时，需要使用SPI接口来与屏幕进行通信。可以使用`OLED_WR_Byte()`函数来向SSD1306写入一个字节的数据或命令。其中，`dat`参数表示要写入的数据，`cmd`参数表示数据或命令的标志，0表示命令，1表示...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值