基于SPI的OLED字幕显示

一、本次实验目标

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

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

2. 显示AHT20的温度和湿度；

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

二、SPI协议介绍

2.1 什么是SPI

SPI，全称为Serial Peripheral Interface，是由Motorola公司开发的一种通用数据总线。它使用四根通信线进行数据传输：SCK（Serial Clock，串行时钟线）、MOSI（Master Output Slave Input，主设备输出从设备输入线）、MISO（Master Input Slave Output，主设备输入从设备输出线）以及SS（Slave Select，从设备选择线）。这些线的作用分别是：

SCK：这是主设备发送的时钟信号，用于同步所有设备的数据传输。
MOSI：这是主设备向从设备发送数据的线路。主设备在每个时钟脉冲的上升沿或下降沿将一个位发送到从设备。
MISO：这是从设备向主设备发送数据的线路。从设备在每个时钟脉冲的上升沿或下降沿读取一位数据并将其发送回主设备。
SS：这是主设备控制从设备的选择线路。主设备可以通过将SS线拉低来选择与它通信的从设备。
SPI是一种同步、全双工的通信接口，它支持一主多从的结构，即一个主设备可以与多个从设备进行通信。在SPI通信中，主设备和从设备必须先进行初始化，然后主设备开始发送数据，同时从设备也在接收数据。因此，SPI是一种非常有效的通信方式，适用于高速、高可靠性的数据传输。

此外，SPI总线可以挂载多个设备，实现多设备同时通信。在这种多设备通信中，主设备通过选择不同的从设备来与其进行通信，从而实现了一主多从的通信模式。这种模式在嵌入式系统、微控制器、传感器等领域中得到了广泛应用。

SPI的基本结构如下

2.2 SPI相关架构与特征

硬件电路
在SPI的硬件电路中，所有的SPI设备都通过SCK（Serial Clock）、MOSI（Master Output Slave Input）和MISO（Master Input Slave Output）三个信号线相互连接。这些信号线将所有的设备同步到一个共享的主时钟，并且主要用于在主机和从机之间发送和接收数据。

每个从机设备都被单独分配了一条SS（Slave Select）控制线。这条控制线是主机用来选择与哪个从机进行通信的线路。当某条SS线被激活时，相应的从机就会被选中，然后主机就可以与其进行数据交换。

在输出引脚配置方面，它们被设置为推挽输出模式。这意味着当引脚被设置为输出模式时，可以向外部电路提供电力，驱动电流，从而控制外部设备。这种配置允许SPI设备有效地扩展主机与多个SPI设备之间的通信能力，同时保证了数据传输的稳定性和可靠性。

对于输入引脚，它们被配置为浮空或上拉输入模式。在浮空输入模式下，引脚不连接到任何特定的电平，因此其状态是由外部电路决定的。而在上拉输入模式下，引脚默认状态为高电平，只有当外部电路将其拉低时，它才会显示外部的电平状态。

这些输入引脚配置提供了SPI设备对外部电路的适应性和灵活性，使得SPI设备可以与各种不同的外部设备进行通信和交互。同时，这种配置也增强了SPI通信的可靠性和稳定性，从而保证了数据传输的安全和准确。

SPI外设
STM32微控制器内置了硬件SPI收发电路，这意味着SPI通信的所有硬件层面，包括时钟生成、数据收发等，都可以由硬件自动处理，大大减轻了CPU的负担。

SPI接口可以配置为使用8位或16位数据帧，同时可以配置数据的顺序，可以选择高位先行或低位先行。这样的灵活性使得SPI接口可以适应不同的通信协议和数据格式。

SPI接口的时钟频率可以配置为fPCLK/(2, 4, 8, 16, 32, 64, 128, 256)，这意味着接口可以在不同的频率下运行，以适应不同的通信速度需求。

SPI接口支持多主机模型和主/从操作模式，这使得多个主机可以同时与多个从机进行通信，或者一个主机可以与多个从机进行通信。

SPI接口可以简化为半双工或单工通信模式，这意味着接口可以根据需要进行更灵活的配置。

最后，STM32的SPI接口还支持DMA（直接内存访问），这意味着数据可以在不需要CPU介入的情况下，直接在内存和SPI设备之间传输，大大提高了数据传输的效率。

除此之外，STM32的SPI接口还兼容I2S协议，I2S是一种用于音频信号传输的协议，这使得STM32可以方便地与音频设备进行通信。
SPI内部框图如下

2.3 SPI基本时序单元

起始条件与终止条件

• 起始条件：SS从高电平切换到低电平
• 终止条件：SS从低电平切换到i高电平

交换一个字节（模式0）

在SPI（Serial Peripheral Interface）通信中，当使用模式0时，可以通过合理设置CPOL（Clock Polarity）和CPHA（Clock Phase）的值来实现数据的交换。

首先，当CPOL设置为0时，这表示在空闲状态下，SCK（Serial Clock）信号线将保持低电平。这个设置意味着在通信过程中，SCK信号线在低电平期间保持稳定，而高电平期间则用于数据的传输。

接下来，当CPHA设置为0时，数据在SCK信号的第一个边沿被写入到移位寄存器中，并在第二个边沿被从移位寄存器中读取。这意味着在每个时钟周期内，数据仅在SCK信号的上升沿处被采样和传输，而在下降沿处数据保持稳定。

通过这种配置，SPI接口可以确保每个时钟周期内能够有效地传输一个字节的数据。这种配置适用于高速、全双工的通信应用，因为它能够确保数据的准确传输。同时，由于这种配置可以使主机和从机之间的通信同步进行，因此它非常适合于需要精确控制数据传输的应用场景。

交换一个字节（模式1）

在SPI通信模式1下，通过CPOL（Clock Polarity）设置为0和CPHA（Clock Phase）设置为1的组合，可以实现交换一个字节的数据。

在这种模式下，空闲状态时，SCK（Serial Clock）信号线同样保持低电平。在通信过程中，SCK信号在低电平期间保持稳定，而在高电平期间进行数据传输。

然而，当CPHA设置为1时，数据在SCK信号的第一个边沿被移出（或读取）到移位寄存器中，并在第二个边沿被移入（或写入）到移位寄存器中。这意味着在每个时钟周期内，数据仅在SCK信号的下降沿处被采样和传输，而在上升沿处保持稳定。

通过这种配置，SPI接口可以在每个时钟周期内同样有效地传输一个字节的数据。但请注意，这种配置与模式0下的传输顺序相反。在模式1下，从机在每个时钟周期的开始时刻发送数据，而主机在第二个边沿接收数据。这种配置适用于高速、全双工的通信应用，其中需要实现反向传输或特定的数据采样顺序。

交换一个字节（模式2）

在SPI通信模式2下，通过设置CPOL（时钟极性）为1和CPHA（时钟相位）为0，可以实现一个字节的数据交换。在这种配置下，SCK（串行时钟）信号线在空闲状态下保持高电平。这意味着在通信过程中，SCK信号在高电平期间保持稳定，而在低电平期间进行数据传输。

当CPHA设置为0时，数据在SCK信号的第一个边沿被移入（或写入）到移位寄存器中，并在第二个边沿被移出（或读取）到移位寄存器中。这意味着在每个时钟周期内，数据仅在SCK信号的下降沿处被采样和传输，而在上升沿处保持稳定。这种配置使得SPI接口可以在每个时钟周期内有效地传输一个字节的数据。

在这种模式下，主机和从机之间的通信可以同步进行，确保数据的准确传输。这种配置适用于高速、全双工的通信应用，其中数据需要在每个时钟周期内被精确传输。在这种配置下，数据的传输速度非常快，因为每个时钟周期都用于传输一个完整的数据字节。此外，由于这种配置支持全双工通信，因此主机和从机可以在同一时刻进行数据传输，从而提高了通信效率。

交换一个字节（模式3）

在SPI通信模式3下，通过CPOL（Clock Polarity）设置为1和CPHA（Clock Phase）设置为1的组合，可以实现交换一个字节的数据。

在这种模式下，空闲状态时，SCK（Serial Clock）信号线同样保持高电平。在通信过程中，SCK信号在每个时钟周期内都保持高电平，只有在数据传输时才发生电平变化。

当CPHA设置为1时，数据在SCK信号的第一个边沿被移出（或读取）到移位寄存器中，并在第二个边沿被移入（或写入）到移位寄存器中。这意味着在每个时钟周期内，数据仅在SCK信号的上升沿处被采样和传输，而在下降沿处保持稳定。

通过这种配置，SPI接口也可以在每个时钟周期内传输一个字节的数据。但请注意，在这种模式下，数据传输的方向与前两种模式相反。在模式3下，从机在每个时钟周期的开始时刻发送数据，而主机在第二个边沿接收数据。这种配置适用于特定的通信应用，其中需要实现反向传输或特定的数据采样顺序。

三、 OLED介绍与汉字取模软件

3.1 OLED介绍

OLED有机发光二极管是一种性能优异的新型显示屏技术。它的特点在于功耗低、相应速度快、宽视角以及轻薄柔韧。其中，0.96寸OLED模块是一种非常小巧玲珑的显示屏模块，占用接口少，简单易用，因此在电子设计中非常常见。它可以通过I2C或SPI通信协议进行控制，供电范围为3~5.5V，分辨率为128*64。使用OLED显示屏可以为您的产品带来更加出色的显示效果和更加高效的能源利用。

4针与7针OLED硬件电路如下：

OLED的点阵编码与显示原理可以归纳为以下两点：

点阵编码：OLED的汉字显示采用点阵编码方式。在汉字的点阵字库中，每个字节的每个位都代表一个汉字的一个点。当某一位为0时，表示该点不存在；而当某一位为1时，则表示该点存在。通过这种方式，将0和1分别用不同的颜色绘制出来，就形成了我们所看到的汉字。根据点阵规模的不同，常用的点阵字库有12×12、14×14和16×16三种。这些字库根据字节所表示点的不同，又分为横向矩阵和纵向矩阵两种存储方式，其中横向矩阵的方式更为常见。
点阵显示：OLED的像素按照128列×64行的组织形式排列。每一行的所有像素单元共享一个阴极（COM），而每一列的所有像素单元共享一个阳极（SEG）。这些电极在交叉处连接在一起，形成一个个显示单元，也就是我们看到的像素。要激活一个像素，只需要在该像素所在的列电极上施加正电压，同时将行电极接地即可。如果要驱动一整行图像，就需要同时将128个列信号加载到列电极上，并将该行行电极接地。当该行显示时，其他63行均不能显示，其行电极应为高电平或悬空。因此，整屏的显示需要分时进行，一行一行地显示，每次只显示一行。完成一次全屏扫描称为一帧。一般来说，帧频要大于60才能保证人眼观察不到逐行显示。每行扫描显示所需的时间称为占空比，占空比越小，要达到相同的显示亮度，驱动电流就越大。例如，SSD1306的最大驱动电流为100uA，当整行128个像素全部点亮时，行电极就需要流过12.8mA的电流。

3.2 汉字取模软件及取模过程

本次使用的OLED显示的汉字均是通过汉字取模软件生成的。通过将汉字在16x16的像素区域内进行识别并排列，形成对应的C51代码，我们将C51代码粘贴到编程文件中就可以使用它了。

这里我就再给一个取模软件的链接
链接：https://pan.baidu.com/s/1ZSrDvhP-mwLQB9F0X_uLlQ
提取码：1234
以下是一个简单的取模过程
我们解压完成后，打开第一个文件夹

在进入主界面后，点击设置，并设置为以下选项

点击确定好后，在主界面就可以输入你想要的汉字了。点击生成字模即可。文字下方是每个文字对应的C51字模代码，我们将其复制粘贴到代码中

四、显示姓名及学号

4.1 获取并修改工程

首先我们需要在网上获取相关OLED的代码。这些都是现成封装好的，我们直接使用就可以了。
链接： http://www.lcdwiki.com/res/Program/OLED/0.96inch/SPI_SSD1306_MSP096X_V1.0/0.96inch_SPI_OLED_Module_SSD1306_MSP096X_V1.0.zip

随后我们打开我们的OLED工程，注意路径

将使用芯片改为C8T6，执行以下步骤：
打开魔术棒，选择“Device”，将芯片改为STM32F103C8

然后转到C++，将字符串改为以下格式

4.2 代码撰写

点击“gui”这个文件，在头文件声明中找到“oledfont.h”，右边跳转定义

找到GB16数组，并将你想输入的文字字模复制并加入到数组中，同时去除原有的大括号，最后输入点阵的内容（符号要用英文输入模式）：

随后打开test.c文件，在TEST_MainPage函数下进行修改

最后，打开主函数，改为如下：

4.3 烧录结果

OLED与STM32开发板连接如下：

连接好后上电，显示结果如下：

五、滑动字幕窗口显示

5.1 获取字模

生成的过程与上类似，这里给出要显示的文字

{0x11,0x08,0x15,0x48,0x25,0x48,0x45,0x50,0x97,0xDE,0x10,0x24,0x20,0x14,0x6F,0xD4},
{0xA0,0x14,0x27,0x94,0x24,0x94,0x24,0xA8,0x24,0xC8,0x24,0x94,0x28,0x14,0x30,0x22},/*"微",0*/
{0x20,0x50,0x20,0x48,0x2F,0xFE,0x20,0x40,0x27,0xFC,0xFC,0x44,0x27,0xFC,0x24,0x44},
{0x27,0xFC,0x24,0x44,0x20,0x08,0x2F,0xFE,0x22,0x08,0x21,0x08,0x21,0x28,0x20,0x10},/*"博",1*/
{0x10,0x40,0x10,0x40,0x20,0xA0,0x21,0x10,0x4A,0x08,0xF4,0x06,0x13,0xF8,0x20,0x00},
{0x40,0x00,0xFB,0xF8,0x42,0x08,0x02,0x08,0x1A,0x08,0xE2,0x08,0x43,0xF8,0x02,0x08},/*"给",2*/
{0x04,0x40,0x08,0x20,0x18,0x50,0x24,0x88,0x03,0x00,0x0C,0xC0,0x30,0x30,0xC0,0x0E},
{0x1F,0xF0,0x02,0x10,0x02,0x10,0x02,0x10,0x02,0x50,0x02,0x20,0x02,0x00,0x02,0x00},/*"爷",3*/
{0x00,0x40,0x40,0x40,0x20,0x40,0x20,0x40,0x07,0xFC,0x04,0x44,0x14,0x44,0x14,0x44},
{0x24,0x44,0xE4,0x44,0x27,0xFC,0x24,0x44,0x20,0x40,0x20,0x40,0x20,0x40,0x00,0x40},/*"冲",4*/

5.2 修改代码

复制一个上一个实验的工程，并对GB16数组进行修改，加入新建立的字模

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

编译烧录

5.3 烧录结果

硬件连接跟上个实验相同，烧录结果如下：

六、显示AHT20的温湿度

AHT20我在前面的博客中已经介绍过有关的知识点和代码
https://blog.csdn.net/Constellation_zZ/article/details/134292144

将取模后的汉字加入到GB16数组中

const typFNT_GB16 cfont16[] = 
{
"请",0x00,0x40,0x40,0x40,0x27,0xFC,0x20,0x40,0x03,0xF8,0x00,0x40,0xE7,0xFE,0x20,0x00,
0x23,0xF8,0x22,0x08,0x23,0xF8,0x22,0x08,0x2B,0xF8,0x32,0x08,0x22,0x28,0x02,0x10,/*"请",0*/
	
"稍",0x08,0x20,0x1D,0x24,0xF0,0xA4,0x10,0xA8,0x10,0x20,0xFD,0xFC,0x11,0x04,0x31,0x04,
0x39,0xFC,0x55,0x04,0x55,0x04,0x91,0xFC,0x11,0x04,0x11,0x04,0x11,0x14,0x11,0x08,/*"稍",1*/
	
"后",0x00,0x10,0x00,0xF8,0x1F,0x00,0x10,0x00,0x10,0x00,0x1F,0xFE,0x10,0x00,0x10,0x00,
0x10,0x00,0x17,0xF8,0x14,0x08,0x24,0x08,0x24,0x08,0x44,0x08,0x87,0xF8,0x04,0x08,/*2*/
	
"开",0x00,0x00,0x7F,0xFC,0x08,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0xFF,0xFE,
0x08,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x10,0x20,0x10,0x20,0x20,0x20,0x40,0x20,/*"开",0*/
	
"启",0x01,0x00,0x00,0x80,0x1F,0xFC,0x10,0x04,0x10,0x04,0x10,0x04,0x1F,0xFC,0x10,0x00,
0x10,0x00,0x10,0x00,0x17,0xFC,0x24,0x04,0x24,0x04,0x44,0x04,0x87,0xFC,0x04,0x04,/*"启",1*/
	
"中",0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x3F,0xF8,0x21,0x08,0x21,0x08,0x21,0x08,
0x21,0x08,0x21,0x08,0x3F,0xF8,0x21,0x08,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,/*"中",2*/
	
"正",0x00,0x00,0x7F,0xFC,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x11,0x00,0x11,0xF8,
0x11,0x00,0x11,0x00,0x11,0x00,0x11,0x00,0x11,0x00,0x11,0x00,0xFF,0xFE,0x00,0x00,/*"正",0*/

"在",0x02,0x00,0x02,0x00,0x04,0x00,0xFF,0xFE,0x08,0x00,0x08,0x40,0x10,0x40,0x30,0x40,
0x57,0xFC,0x90,0x40,0x10,0x40,0x10,0x40,0x10,0x40,0x10,0x40,0x1F,0xFE,0x10,0x00,/*"在",1*/

"检",0x10,0x40,0x10,0x40,0x10,0xA0,0x10,0xA0,0xFD,0x10,0x12,0x08,0x35,0xF6,0x38,0x00,
0x54,0x88,0x50,0x48,0x92,0x48,0x11,0x50,0x11,0x10,0x10,0x20,0x17,0xFE,0x10,0x00,/*"检",2*/

"测",0x00,0x04,0x27,0xC4,0x14,0x44,0x14,0x54,0x85,0x54,0x45,0x54,0x45,0x54,0x15,0x54,
0x15,0x54,0x25,0x54,0xE5,0x54,0x21,0x04,0x22,0x84,0x22,0x44,0x24,0x14,0x08,0x08,/*"测",3*/
	
"温",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的封装配置函数文件。AHT20配置函数链接：

链接：https://pan.baidu.com/s/1846AHdi3J96m_txVhv1ahw?pwd=0231
提取码：0231

解压后，将两个函数导入到项目工程的HARDWARE文件中，并设置头文件路径。
先把本地文件复制粘贴到HARDWARE文件夹里

在keil中添加

记得添加头文件路径

打开工程，修改AHT20的.c文件如下：

#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倍）
//	下一步客户处理显示数据，
//	 }
 
// }

头文件修改为如下：

#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

再将主函数修改为如下：

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

}

AHT20硬件连接如下：

烧录结果如下：

六、总结

这次实验对我来说是一次非常宝贵的学习机会，让我深入了解了SPI协议、OLED的使用以及字模的生成。通过实际操作，我更加熟练地掌握了STM32与OLED的交互操作。

在实现三个要求的过程中，我不仅熟悉了相关的理论知识，还积累了实际的编程经验。这次实验让我意识到，理论知识与实践操作相结合是非常重要的。只有真正亲手去操作、去编写代码，才能更好地理解并掌握这些知识。

在操作OLED时，我特别注意了显示字长的设置问题。如果设置不正确，可能会导致显示不全或者出现其他问题。这让我意识到细节决定成败，对于这些细致的操作步骤，必须认真对待。

同时，在进行字模取模时，我也深刻体会到了横向取模、纵向取模以及倒序取模的区别和重要性。选择不当的话，可能会得到模糊不清的显示效果，而不是正常清晰的汉字。这让我认识到在编写代码时，必须认真思考并选择正确的取模方式，以确保得到最佳的显示效果。

OLED作为一种外设模块，在硬件项目中具有广泛的应用价值。这次实验让我意识到OLED的重要性，它不仅可以用于显示文字和图像，还可以用于调试和排查问题。在未来的项目中，我会充分利用OLED进行调试显示，相信这将会给我带来很大的帮助。

通过这次实验，我不仅掌握了相关的知识和技能，还对硬件编程有了更深入的了解。我相信，这些经验和知识将对我未来的学习和工作产生积极的影响。我会继续深入学习和练习OLED的使用，不断提高自己的技能水平。

七、参考

https://blog.csdn.net/m0_63323712/article/details/134410644