OLED显示实验
本章我们来学习使用OLED液晶显示屏，在开发板上我们预留了OLED模块接口，需要准备一个OLED显示模块。下面我们一起来点亮OLED，并实现ASCII字符的显示。

23.1 OLED简介
OLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（Organic Electroluminesence Display，OELD）。OLED由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。
LCD都需要背光，而OLED不需要，因为它是自发光的。这样同样的显示，OLED效果要来得好一些。以目前的技术，OLED的尺寸还难以大型化，但是分辨率确可以做到很高。在本章中，我们使用的是ALINETEK的OLED显示模块，该模块有以下特点：
$ h% N& z/ R9 E- H1）模块有单色和双色两种可选，单色为纯蓝色，而双色则为黄蓝双色。
8 J0 l1 }; K  w0 ^+ y, ]5 W2）尺寸小，显示尺寸为0.96寸，而模块的尺寸仅为27mm26mm大小。
3）高分辨率，该模块的分辨率为12864。
4）多种接口方式，该模块提供了总共4种接口包括：6800、8080两种并行接口方式、4线SPI接口方式以及IIC接口方式（只需要2根线就可以控制OLED了！）。
- p5 l- [) r0 X" q$ n; r4 O9 ]2 b5）不需要高压，直接接3.3V就可以工作了。
8 E: ~) h% C. Y  ~7 \! Z% g4 k* p这里要提醒大家的是，该模块不和5.0V接口兼容，所以请大家在使用的时候一定要小心，别直接接到5V的系统上去，否则可能烧坏模块。以下4种模式通过模块的BS1和BS2设置，BS1和BS2的设置与模块接口模式的关系如表23.1.1所示：

5 Q1 o' T( i1 D. o" q( W1 a

                表23.1.1 OLED模块接口方式设置表
* M+ j% m% x& D2 g0 L
表23.1.1中：“1”代表接VCC，而“0”代表接GND。
; R# V8 w# s5 T, G该模块的外观图如图23.1.1所示：

& O3 f  |2 m2 S) M
* P+ F' e' J+ g# \7 D7 [+ y# N+ k
7 G# }' n' m/ X1 F2 R+ j& ?图23.1.1 ALIENTEK OLED模块外观图
' h  \5 ]. G7 MALIENTEK OLED模块默认设置是：BS1和BS2接VCC ，即使用8080并口方式，如果你想要设置为其他模式，则需要在OLED的背面，用烙铁修改BS1和BS2的设置。
8 h+ Y0 \$ E4 w& s! W4 D模块的原理图如图23.1.2所示：



图23.1.2 ALIENTEK OLED模块原理图
  ^9 k4 _; u) A1 f该模块采用8*2的2.54排针与外部连接，总共有16个管脚，在16条线中，我们只用了15条，有一个是悬空的。15条线中，电源和地线占了2条，还剩下13条信号线。在不同模式下，我们需要的信号线数量是不同的，在8080模式下，需要全部13条，而在IIC模式下，仅需要2条线就够了！这其中有一条是共同的，那就是复位线RST（RES），RST上的低电平，将导致OLED复位，在每次初始化之前，都应该复位一下OLED模块。
% h& {2 h9 ]: F  LALIENTEK OLED模块的控制器是SSD1306，本章，我们将学习如何通过STM32H750来控制该模块显示字符和数字，本章的实例代码将可以支持两种方式与OLED模块连接，一种是8080的并口方式，另外一种是4线SPI方式。实际使用过程我们也通常只选用其中的一种来实现硬件上的连接，我们会分别介绍这两种模式，读者可以选择性阅读。

23.1.1 硬件驱动接口模式
1.8080并口模式
7 t0 Y  D+ b# K6 r0 o首先我们介绍一下模块的8080并行接口，8080并行接口的发明者是INTEL，该总线也被广泛应用于各类液晶显示器，ALIENTEK OLED模块也提供了这种接口，使得MCU可以快速的访问OLED。ALIENTEK OLED模块的8080接口方式需要如下一些信号线：
CS：OLED片选信号。
4 I# [8 H5 ^/ J# nWR：向OLED写入数据。
, h0 v+ V  b0 r" r0 T: e# XRD：从OLED读取数据。
( C* L# S( L8 r! pD[7：0]：8位双向数据线。
RST(RES)：硬复位OLED。
DC：命令/数据标志（0，读写命令；1，读写数据）。
模块的8080并口写的过程为：先根据要写入的数据的类型，设置DC为高（数据）/低（命令），设置WR起始电平为高，然后拉低片选，选中SSD1306，接着我们在整个读时序上保持RD为高电平，然后：
拉低WR的电平准备写入数据，向数据线（D[7：0]）上输入要写的信息；
拉高WR，这样得到一个WR的上升沿，在这个上升沿，使数据写入到SSD1306里面；
SSD1306的8080并口写时序图如图23.1.1.1所示：

4 o6 b7 t$ h7 `; Y+ t: J
+ h1 P$ g9 ^: d: F2 v: [! F
7 M2 _& Y4 w% a9 w9 a图23.1.1.1 8080并口写时序图
: c# V- G( @4 s4 Z- w* W模块的8080并口读的过程为：先根据要写入的数据的类型，设置DC为高（数据）/低（命令），设置RD起始电平为高，然后拉低片选CS信号，选中SSD1306，接着我们在整个读时序上保持WR为高电平，然后类似写时序，同样的：
5 y1 G) i( z0 G' K7 k在RD的上升沿， 使数据锁存到数据线（D[7：0]）上；
( s4 w# L: ]+ {/ D4 I& e9 RSSD1306的8080并口读时序图如图23.1.1.2所示：



图23.1.1.2 8080并口读时序图
SSD1306的8080接口方式下，控制脚的信号状态所对应的功能如表23.1.1.1：
  V8 g: w5 h5 k3 w7 c, _9 w

$ i: z8 j4 r/ t
                         表23.1.1.1 控制脚信号状态功能表
, |7 E) r+ V+ [: x* T+ D+ G% E
在8080方式下读数据操作的时候，我们有时候（例如读显存的时候）需要一个假读命（Dummy Read），以使得微控制器的操作频率和显存的操作频率相匹配。在读取真正的数据之前，由一个的假读的过程。这里的假读，其实就是第一个读到的字节丢弃不要，从第二个开始，才是我们真正要读的数据。
7 _+ M8 l, V: P  N一个典型的读显存的时序图，如图23.1.1.3所示：


* E+ {4 Z3 r- N: c- p2 a" n$ I
/ x2 h! c  t# u$ |图23.1.1.3 读显存时序图
# \) G! M4 ]/ U* t可以看到，在发送了列地址之后，开始读数据，第一个是Dummy Read，也就是假读，我们从第二个开始，才算是真正有效的数据。并行接口模式就介绍到这里。
% J- x" Z$ t9 e' E6 d; L2. SPI模式
) E3 i! n" m) U  r) E我们的代码同时兼容SPI方式的驱动，如果你使用的是这种驱动方式，则应该把代码中的宏OLED_MODE设置为：
#define OLED_MODE 0 /* 0: 4线串行模式 */
我们接下来介绍一下4线串行（SPI）方式，4先串口模式使用的信号线有如下几条：
CS：OLED片选信号。
7 K$ b0 ^1 U8 m* xRST(RES)：硬复位OLED。
DC：命令/数据标志（0，读写命令；1，读写数据）。
# u! ~- {5 I5 Q+ U# @, o4 \: dSCLK：串行时钟线。在4线串行模式下，D0信号线作为串行时钟线SCLK。
3 F' i6 `3 I5 I( V7 u: e; oSDIN：串行数据线。在4线串行模式下，D1信号线作为串行数据线SDIN。
" M( x$ M: W" L& c- [8 w模块的D2需要悬空，其他引脚可以接到GND。在4线串行模式下，只能往模块写数据而不能读数据。
在4线SPI模式下，每个数据长度均为8位，在SCLK的上升沿，数据从SDIN移入到SSD1306，并且是高位在前的。DC线还是用作命令/数据的标志线。在4线SPI模式下，写操作的时序如图23.1.1.4所示：

8 l* N8 h. T  O

5 h6 r, K" [0 q/ M图23.1.1.4 4线SPI写操作时序图
6 B0 z9 S6 H+ L1 _4线串行模式就为大家介绍到这里。其他还有几种模式，在SSD1306的数据手册上都有详细的介绍，我们把资料放到“开发板资料A盘->7，硬件资料\3，液晶资料\OLED资料\SSD1306-Revision 1.1 (Charge Pump).pdf”，如果要使用这些方式，请大家参考该手册并自行实现相应的功能代码。
: j5 s& s  X/ y5 p$ W5 p6 J+ j- |& P
3 j, S! z7 j& X2 [& C* r23.1.2 OLED显存
. u) F4 a0 Z8 K, ?# }( h9 [& n接下来，我们介绍一下模块的显存，SSD1306的显存总共为128*64bit大小，SSD1306将这些显存分为了8页，不使用显存对应的行列的重映射，其对应关系如表23.1.2.1所示：

5 J" R* v' R0 V1 Q; g
- C' ^7 R' q  p1 u( x- t5 _
表23.1.2.1 SSD1306显存与屏幕对应关系表
4 u+ d; E8 S8 _  c5 F可以看出，SSD1306的每页包含了128个字节，总共8页，这样刚好是128*64的点阵大小。当GRAM的写入模式为页模式时，需要设置低字节起始的列地址（0x000x0F）和高字节的起始列地址（0x100x1F），芯片手册中给出了写入GRAM与显示的对应关系，写入列地址在写完一字节后自动按列增长，如图23.1.2.2所示：

$ {/ W5 d8 s" f( a. j) `$ L

图23.1.2.2 SSD1306页2显存写入字节与屏幕坐标的关系
$ A' @' L2 i' w* [  a3 }因为每次写入都是按字节写入的，这就存在一个问题，如果我们使用只写方式操作模块，那么，每次要写8个点，这样，我们在画点的时候，就必须把要设置的点所在的字节的每个位都搞清楚当前的状态（0/1？），否则写入的数据就会覆盖掉之前的状态，结果就是有些不需要显示的点，显示出来了，或者该显示的没有显示了。这个问题在能读的模式下，我们可以先读出来要写入的那个字节，得到当前状况，在修改了要改写的位之后再写进GRAM，这样就不会影响到之前的状况了。但是这样需要能读GRAM，对于4线SPI模式/IIC模式，模块是不支持读的，而且读改写的方式速度也比较慢。
* i/ |5 t0 Y5 `8 O! o所以我们采用的办法是在STM32H750的内部建立一个虚拟的OLED的GRAM（共128*8=1024个字节），在每次修改的时候，只是修改STM32H750上的GRAM（实际上就是SRAM），在修改完了之后，一次性把STM3F103上的GRAM写入到OLED的GRAM。当然这个方法也有坏处，一个是对于那些SRAM很小的单片机（比如51系列）不太友好，另一个是每次都写入全屏，屏幕刷新率会变低。
SSD1306的命令比较多，这里我们仅介绍几个比较常用的命令，这些命令如下表所示：

$ z+ T7 p( _' t
' n4 ^# ^3 q  p9 m* q
" {4 ?7 ~: i- f$ H/ i表23.1.2.3 SSD1306常用命令表
- V, L$ n- D& M0 M( }( g2 k3 I0 K第0个命令为0X81，用于设置对比度的，这个命令包含了两个字节，第一个0X81为命令，随后发送的一个字节为要设置的对比度的值。这个值设置得越大屏幕就越亮。
第1个命令为0XAE/0XAF。0XAE为关闭显示命令；0XAF为开启显示命令。
第2个命令为0X8D，该指令也包含2个字节，第一个为命令字，第二个为设置值，第二个字节的BIT2表示电荷泵的开关状态，该位为1，则开启电荷泵，为0则关闭。在模块初始化的时候，这个必须要开启，否则是看不到屏幕显示的。
% w9 y: y6 A4 k3 U8 H6 r2 z# `第3个命令为0XB0~B7，该命令用于设置页地址，其低三位的值对应着GRAM的页地址。
第4个指令为0X00~0X0F，该指令用于设置显示时的起始列地址低四位。
" R9 g' M. y4 f1 z0 S" i) R0 o1 G3 x" v第6个指令为0X10~0X1F，该指令用于设置显示时的起始列地址高四位。
( p, x5 \) m' V- x* ?6 x其他命令，我们就不在这里一一介绍了，大家可以参考SSD1306 datasheet的第28页。从这页开始，对SSD1306的指令有详细的介绍。
7 O8 l/ [5 b# @, ^3 o最后，我们再来介绍一下OLED模块的初始化过程，SSD1306的典型初始化框图如图23.1.2.4所示：

/ b% ~% h+ J. s# f. c& H4 u9 a8 M9 V

4 N2 `4 \6 V$ d- l$ N; A, j图23.1.2.4 SSD1306初始化框图
驱动IC的初始化代码，我们直接使用厂家推荐的设置就可以了，只要对细节部分进行一些修改，使其满足我们自己的要求即可，其他不需要变动。
6 N- ?$ E. e' m$ R* W3 wOLED的介绍就到此为止，我们重点向大家介绍了ALIENTEK OLED模块的相关知识，接下来我们将使用这个模块来显示字符和数字。通过以上介绍，我们可以得出OLED显示需要的相关设置步骤如下：
1）设置STM32F103与OLED模块相连接的IO。
这一步，先将我们与OLED模块相连的IO口设置为输出，具体使用哪些IO口，这里需要根据连接电路以及OLED模块所设置的通讯模式来确定。这些将在硬件设计部分向大家介绍。
! t+ I# t; `' ^% h  v$ \2）初始化OLED模块。
其实这里就是上面的初始化框图的内容，通过对OLED相关寄存器的初始化，来启动OLED的显示。为后续显示字符和数字做准备。
3）通过函数将字符和数字显示到OLED模块上。
( t! \' f7 }* N% m8 K4 i这里就是通过我们设计的程序，将要显示的字符送到OLED模块就可以了，这些函数将在软件设计部分向大家介绍。
; y! Z# L) b+ I, M1 X* R8 `* q/ Y通过以上三步，我们就可以使用ALIENTEK OLED模块来显示字符和数字了，在后面我们还将会给大家介绍显示汉字的方法。这一部分就先介绍到这里。
! {) E3 v$ ~9 F! P; U& X7 ]
23.2 硬件设计
1.例程功能
1 e. I& ~' a& x5 G% P5 X使用8080并口模式驱动或者使用4线SPI串口模式，驱动OLED模块，不停的显示ASCII码和码值。LED0闪烁，提示程序运行。
2.硬件资源
1）RGB灯
$ A* W8 x  g3 p: ?7 X5 wRED : LED0 - PB4
2）ALIENTEK 0.96寸OLED模块，在硬件上，OLED与开发板的IO口对应关系如下：
7 d' G. N- t) eOLED_CS对应DCMI_VSYNC，即：PB7；
OLED_RS对应DCMI_SCL，即：PB10；
5 Z2 I: T; y2 c- G8 ~; V# T) qOLED_WR对应DCMI_HREF，即：PA4；
5 ?5 ^4 [8 @3 fOLED_RD对应DCMI_SDA，即：PB11；
( P0 y9 D+ Q) N. wOLED_RST对应DCMI_RESET，即：PA7；
6 I9 G1 _8 P, k6 v6 b  Z, ^OLED_D[7:0]对应DCMI_D[7:0]，即：PB9/PB8/PD3/PC11/PC9/PC8/PC7/PC6；
3.原理图
OLED模块的原理图在前面已有详细说明了，这里我们介绍OLED模块与我们开发板的连接，开发板上有一个OLED/CAMERA的接口（P2接口）可以和ALIENTEK OLED模块直接对插（靠左插！），连接如图23.2.1所示：
1 z9 ~. b: c. @- A- i! U% o
8 X* ]; a+ I4 j, p
" e# l" v9 N% R3 M, U  y0 ^& C- w/ p: O2 r
图23.2.1 OLED模块与开发板连接示意图
这些线的连接，开发板的内部已经连接好了，我们只需要将OLED模块插上去就好了，注意，这里的OLED_D[7:0]因为不是接的连续的IO，所以得用拼凑的方式去组合一下，后续会介绍。
4 J0 r! a) K' R( B, `3 }5 k23.3 程序设计
OLED只是用到HAL库中GPIO外设的驱动代码，在前面跑马灯实验已经介绍了。
, ?1 ?2 `5 {, E- T$ U  r. b3 z3 _23.3.1 程序流程图

7 p6 e) I* U! `7 C: @

图23.3.1.1 OLED实验程序流程图
7 W% J. i6 z+ P/ T* U# m
23.3.2 程序解析
1.OLED驱动代码
4 J( |' _) `2 u# k! K这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。OLED驱动源码包括三个文件：oled.c、oled.h和oledfont.h。oledfont.h头文件存放的是ASCII字符集，oled.h存放的是引脚接口宏定义和函数声明等，oled.c则是驱动代码。
首先看oledfont.h头文件的ASCII字符集内容：
3 N* J4 Q  q9 p6 J$ J

1. /* 常用ASCII表
   # T' U% |0 u0 O: ~$ P; w) B
2. * 偏移量32
   
3. * ASCII字符集: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]
   & }% j# k7 F8 L( H) t: K
4. ^_`abcdefghijklmnopqrstuvwxyz{|}~
   $ p9 e+ f9 {0 p1 {+ r3 Y3 }; |
5. * PC2LCD2002取模方式设置：阴码+逐列式+顺向+C51格式
   
6. * 总共：3个字符集（12*12、16*16和24*24），用户可以自行新增其他分辨率的字符集。
   . H4 m2 C. [7 P! u& y) N/ K
7. * 每个字符所占用的字节数为:(size/8+((size%8)?1:0))*(size/2),
   
8. 其中size:是字库生成时的点阵大小(12/16/24...)
   
9. */
   
10. 
    
11. /* 12*12 ASCII字符集点阵 */
    " ?" S' k; R# ?! S8 u8 L8 S5 r
12. const unsigned char oled_asc2_1206[95][12]={ ...这里省略字符集库... };
    
13. 
    
14. /* 16*16 ASCII字符集点阵 */
    
15. const unsigned char oled_asc2_1608[95][16]={ ...这里省略字符集库... };
    + T& z4 h; }9 }* v
16. 
    & |9 S5 R! d2 e4 g/ c, t! u
17. /* 24*24 ASICII字符集点阵 */
    
18. const unsigned char oled_asc2_2412[95][36]={ ...这里省略字符集库... };

复制代码

该头文件中包含三个大小不同的ASCII字符集点阵，其中包括：1212 ASCII字符集点阵、1616 ASCII字符集点阵、2424 ASICII字符集点阵。每个字符集点阵都包含95个常用的ASCII字符集，从空格符开始，分别为： !"#$%&'()+,-0123456789:;<=>?@ABCDEFGHIJKLMNOPQR
, `3 s7 @$ n0 i- g+ XSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~。
上面的ASCII字符集，我们可以使用一个款很好的字符提取软件来制作获取。字符提取软件为：PCtoLCD2002完美版，该软件可以提供各种字符，包括汉字（字体和大小都可以自己设置）阵提取，且取模方式可以设置好几种，常用的取模方式，该软件都支持。该软件还支持图形模式，也就是用户可以自己定义图片的大小，然后画图，根据所画的图形再生成点阵数据，这功能在制作图标或图片的时候很有用。
' Q' [7 _3 p9 H该软件的界面如图23.3.2.1所示：
  d8 X5 K8 ~; E1 e3 a
' B4 h5 w3 |  i5 h
3 ]5 }% l% P, ^: ]: t2 t
图23.3.2.1 PCtoLCD2002软件界面
然后我们选择设置，在设置里面设置取模方式如图23.3.2.2所示：



图23.3.2.2 设置取模方式
; L# ~6 _8 z* w" ]: X上图设置的取模方式，在右上角的取模说明里面有，即：从第一列开始向下每取8个点作为一个字节，如果最后不足8个点就补满8位。取模顺序是从高到低，即第一个点作为最高位。如*-------取为10000000。其实就是按如图23.3.2.3所示的这种方式：
. S$ S0 T- I% T0 L3 D


- A+ ]: K7 U* g9 F0 S" I图23.3.2.3 取模方式图解
从上到下，从左到右，高位在前。我们按这样的取模方式，然后把ASCII字符集按126大小、168和2412大小取模出来（对应汉字大小为1212、1616和2424，字符的只有汉字的一半大！），每个126的字符占用12个字节，每个168的字符占用16个字节，每个24*12的字符占用36个字节。
! E' V6 m5 G. F6 t3 W$ O( Uoled.c和oled.h文件的代码可以帮助显示我们制作好的字符集。我们还是先看oled.h文件的宏定义，首先是OLED模式设置宏定义：
$ W" N/ @: u- m* J  c; R$ y2 Z
5 b9 a' y: f6 _

1. /* OLED模式设置
   
2. * 0: 4线串行模式          （模块的BS1，BS2均接GND）
   & C" H. I9 x% k/ ~
3. * 1: 并行8080模式         （模块的BS1，BS2均接VCC）
   
4. */
   
5. #define OLED_MODE       1   /* 默认使用8080并口模式 */
   - S5 r' H( y2 A" K% q" q% F' P- S
6. 通过宏定义OLED_MODE来决定使用4线串行模式（0）还是并行8080模式（1），默认使用8080并口模式。
   
7. 关于OLED 80并口模式和SPI模式的引脚定义就不列出来了，请看源码。
   + r6 y0 J9 Z: O6 q2 q: a9 g
8. 还有两个关于向OLED写入选择命令或者数据的宏定义，后面讲的oled_wr_byte函数用到。
   1 T+ |! x9 \' u
9. /* 命令/数据 定义 */
   
10. #define OLED_CMD        0       /* 写命令 */
    
11. #define OLED_DATA       1       /* 写数据 */
    # [* g% P. ]1 V- P5 Q! e" m
12. 最后就是oled.c文件的驱动源码介绍。先是OLED(SSD1306)的初始化函数，其定义如下：
    2 C, K: E7 f2 A+ l& `7 e; y9 C
13. /**
    0 g  J7 X+ Q7 ]. {2 U5 C. D
14. * @brief       初始化OLED(SSD1306)
      U8 n+ I6 g* x$ I4 N* C+ e
15. * @param       无
    
16. * @retval      无
    , g8 L6 t: d& d' g7 i
17. */
    
18. void oled_init(void)
    
19. {
    7 m% f7 W2 f5 }" ~' k  Z6 L4 g
20.     GPIO_InitTypeDef  gpio_init_struct;
    
21. 
    1 O# d# u( w* E: z/ B0 J# q
22.     __HAL_RCC_GPIOA_CLK_ENABLE();
    9 ~9 B1 x0 v# Y' }9 Q
23.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
24.     __HAL_RCC_GPIOC_CLK_ENABLE();
    6 Y# n2 h$ {3 y- f
25.     __HAL_RCC_GPIOD_CLK_ENABLE();
    " O- N% K+ E2 z) T0 I& V
26. 
    - S4 J" t0 e$ h2 @$ j( {
27. #if OLED_MODE==1         /* 使用8080并口模式 */
    / t( w1 L9 _# C  z5 _
28. /* PA4,6,7,8设置 */
    
29.     gpio_init_struct.Pin=GPIO_PIN_4|GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8;
    
30.     gpio_init_struct.Mode=GPIO_MODE_OUTPUT_PP;                   /* 推挽输出 */
    , ]. g: ]% P# g$ M  O7 p7 N5 y
31.     gpio_init_struct.Pull=GPIO_PULLUP;                             /* 上拉 */
    ! y  X: b6 G6 x1 q2 D2 @
32.     gpio_init_struct.Speed=GPIO_SPEED_FREQ_VERY_HIGH;           /* 高速 */
    
33.     HAL_GPIO_Init(GPIOA,&gpio_init_struct);
    
34. 
    
35.     gpio_init_struct.Pin=GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10
    - p2 q9 D% y; w3 M
36. |GPIO_PIN_11;       /* PB7,8,9,10,11设置 */
    
37.     HAL_GPIO_Init(GPIOB,&gpio_init_struct);
    
38. 
    
39.     gpio_init_struct.Pin=GPIO_PIN_4|GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8
    
40. |GPIO_PIN_9|GPIO_PIN_11; /* PC4,6~9,PC11设置 */
    + s% m9 ~" V5 m7 J0 ~
41.     HAL_GPIO_Init(GPIOC,&gpio_init_struct);
    
42. 
    
43.     gpio_init_struct.Pin=GPIO_PIN_3;                 /* PD3 设置 */
      U! V1 v; X$ M  F0 h' W
44.     HAL_GPIO_Init(GPIOD,&gpio_init_struct);
    / }+ I) Y5 s* n& k  y7 c' M
45. 
    8 V' Y1 d, {/ e4 b3 G' @, M
46.     OLED_WR(1);
    
47.     OLED_RD(1);
    2 j# K# I( A: H
48. 
    ; I' V" W8 D6 P
49. #else               /* 使用4线SPI 串口模式 */
    
50. 
    + c8 F* G* X6 Q1 l9 h2 i7 U  w' n
51.     gpio_init_struct.Pin=OLED_SPI_RST_PIN;
    ; k6 R5 z' R& T3 ~" F- k1 F+ d4 ^
52.     gpio_init_struct.Mode=GPIO_MODE_OUTPUT_PP;                       /* 推挽输出 */
    , I  M6 J0 k  I, n
53.     gpio_init_struct.Pull=GPIO_PULLUP;                                 /* 上拉 */
    . N& h; @$ a5 ]& e8 y, n2 H
54.     gpio_init_struct.Speed=GPIO_SPEED_FREQ_VERY_HIGH;              /* 高速 */
    
55.     HAL_GPIO_Init(OLED_SPI_RST_PORT,&gpio_init_struct);            /* RST引脚模式设置 */
    5 L) H4 H. a+ R! h
56. 
    
57.     gpio_init_struct.Pin=OLED_SPI_CS_PIN;
    . Y; [( Z9 Y+ ~" M" q' \$ Z
58.     HAL_GPIO_Init(OLED_SPI_CS_PORT,&gpio_init_struct);             /* CS引脚模式设置 */
      R6 P) K" M" _5 b3 y6 `
59. 
    
60.     gpio_init_struct.Pin=OLED_SPI_RS_PIN;
    
61.     HAL_GPIO_Init(OLED_SPI_RS_PORT,&gpio_init_struct);             /* RS引脚模式设置 */
    $ b6 F5 z9 X7 o: F2 j0 q3 ^+ d. }, `
62. 
    
63.     gpio_init_struct.Pin=OLED_SPI_SCLK_PIN;
    
64.     HAL_GPIO_Init(OLED_SPI_SCLK_PORT,&gpio_init_struct);           /* SCLK引脚模式设置 */
    : d' I; J' l# v- T2 T4 ^
65. 
    + X3 @/ b, R% C3 C: n3 Y9 R
66.     gpio_init_struct.Pin=OLED_SPI_SDIN_PIN;
    
67.     HAL_GPIO_Init(OLED_SPI_SDIN_PORT,&gpio_init_struct);           /* SDIN引脚模式设置 */
    
68. 
    
69.     OLED_SDIN(1);
    ) K2 Y3 O! r1 Z$ _: D, P- m* A
70.     OLED_SCLK(1);
      B5 u! B6 }% w, t1 g" t
71. #endif
    
72.     OLED_CS(1);
      r0 o# V( }, v$ x, F2 b
73.     OLED_RS(1);
    
74. 
    - d3 j4 i) O  r7 }# ?
75.     OLED_RST(0);
    + |- _# f' F6 ^. |  ]+ j
76.     delay_ms(100);
    6 j* U9 w. j; g2 S) U5 ^  {- ^7 H
77.     OLED_RST(1);
    
78. 
    , `4 N/ z6 s; k& o' k- V
79.     oled_wr_byte(0xAE, OLED_CMD);   /* 关闭显示 */
    
80.     oled_wr_byte(0xD5, OLED_CMD);   /* 设置时钟分频因子,震荡频率 */
    ! s+ B: ?% ?( Q* c. p
81.     oled_wr_byte(80, OLED_CMD);             /* [3:0],分频因子;[7:4],震荡频率 */
    6 w  ], Q' {8 m: m3 G4 Y) e
82.     oled_wr_byte(0xA8, OLED_CMD);   /* 设置驱动路数 */
    / m# q* t# ^# ~" o
83.     oled_wr_byte(0X3F, OLED_CMD);   /* 默认0X3F(1/64) */
    $ t: T: s+ \+ Q; v; ~' }
84.     oled_wr_byte(0xD3, OLED_CMD);   /* 设置显示偏移 */
    / y5 d& o6 d8 o
85.     oled_wr_byte(0X00, OLED_CMD);   /* 默认为0 */
    
86. 
    4 n+ T  S4 D9 O0 h4 l( T
87.     oled_wr_byte(0x40, OLED_CMD);   /* 设置显示开始行 [5:0],行数. */
    % G& g1 R; m1 G, X% N
88. 
    9 P+ G& W2 L" k2 W) S) b: v& Y$ x
89.     oled_wr_byte(0x8D, OLED_CMD);   /* 电荷泵设置 */
    8 e7 g/ t4 D4 ?# E' Y0 l! o
90.     oled_wr_byte(0x14, OLED_CMD);   /* bit2，开启/关闭 */
    
91. oled_wr_byte(0x20, OLED_CMD);   /* 设置内存地址模式 */
    6 T* Q( c1 i' [9 _0 U6 W# n% d
92. /* [1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10; */
    ) R1 v, y, ^1 F$ I  f
93.     oled_wr_byte(0x02, OLED_CMD);   
    ! ?+ `  l  c8 i
94.     oled_wr_byte(0xA1, OLED_CMD);   /* 段重定义设置,bit0:0,0->0;1,0->127; */
    
95. /* 设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数 */   
      q( y( v1 r  {* Q0 W6 w
96.     oled_wr_byte(0xC8, OLED_CMD);   
    5 s6 y, T, z; H6 n2 s
97.     oled_wr_byte(0xDA, OLED_CMD);   /* 设置COM硬件引脚配置 */
    6 V# V8 b6 {7 p
98.     oled_wr_byte(0x12, OLED_CMD);   /* [5:4]配置 */
    % y4 R+ n7 O& h5 b
99. 
    5 a' b% L4 ]5 x  Y0 ]
100.     oled_wr_byte(0x81, OLED_CMD);   /* 对比度设置 */
     
101.     oled_wr_byte(0xEF, OLED_CMD);   /* 1~255;默认0X7F (亮度设置,越大越亮) */
     
102.     oled_wr_byte(0xD9, OLED_CMD);   /* 设置预充电周期 */
     
103.     oled_wr_byte(0xf1, OLED_CMD);   /* [3:0],PHASE 1;[7:4],PHASE 2; */
     0 @3 w/ F' C$ _& k
104. oled_wr_byte(0xDB, OLED_CMD);   /* 设置VCOMH 电压倍率 */
     , u& Q8 r# U- m: P: {7 t
105. /* [6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc; */
     
106.     oled_wr_byte(0x30, OLED_CMD);   
     
107. 
     
108.     oled_wr_byte(0xA4, OLED_CMD);   /* 全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏) */
     ! o+ W* m3 H0 W  n6 S. B
109.     oled_wr_byte(0xA6, OLED_CMD);   /* 设置显示方式;bit0:1,反相显示;0,正常显示 */
     
110.     oled_wr_byte(0xAF, OLED_CMD);   /* 开启显示 */
     # `' [  t$ ~3 z# @2 D$ S
111.     oled_clear();
     : r/ B2 L- m- U( z" n, J( {
112. }

复制代码

该函数的结构比较简单，开始是对GPIO口的初始化，这里我们用了宏定义OLED_MODE来决定要设置的IO口，后面的就是一些初始化序列了，我们按照厂家提供的资料来做就可以。值得注意一点的是，因为OLED是无背光的，在初始化之后，我们把显存都清空了，所以我们在屏幕上是看不到任何内容的，就像没通电一样，不要以为这就是初始化失败，要写入数据模块才会显示的。
接着，要介绍的是oled_refresh_gram更新显存到OLED函数，该函数的作用是把我们在程序中定义的二维数组g_oled_gram的值一次性刷新到OLED的显存GRAM中。我们在oled.c文件开头定义了如下一个二维数组：
: |4 h2 R7 h# S
, X# x* X9 G" V7 m0 V$ n" s+ \0 ?

1. /*
   # V2 N# |7 d# R
2. * OLED的显存
   $ Q6 n7 |/ D: k5 c+ Z
3. * 每个字节表示8个像素, 128,表示有128列, 8表示有64行, 高位表示高行数.
   
4. * 比如:g_oled_gram[0][0],包含了第一列,第1~8行的数据. g_oled_gram[0][0].0,即表示坐标(0,0)
   
5. * 类似的: g_oled_gram[1][0].1,表示坐标(1,1), g_oled_gram[10][1].2,表示坐标(10,10),
   
6. *
   ! X* g" q( z+ V% X% Z
7. * 存放格式如下(高位表示高行数).
   7 i9 b6 G0 R" _1 F
8. * [0]0 1 2 3 ... 127
   
9. * [1]0 1 2 3 ... 127
   6 @) O% O5 g3 j, A+ R9 _' W
10. * [2]0 1 2 3 ... 127
    % H& Z9 z7 G8 ~. M3 N, i! @
11. * [3]0 1 2 3 ... 127
    
12. * [4]0 1 2 3 ... 127
    $ ?) y+ L7 C) r' k
13. * [5]0 1 2 3 ... 127
    
14. * [6]0 1 2 3 ... 127
    
15. * [7]0 1 2 3 ... 127
    
16. */
    ) D. a6 W- c( {8 m
17. static uint8_t g_oled_gram[128][8];

复制代码

5 o6 s( K9 ]& |- A该数组值与OLED显存GRAM值一一对应。在操作的时候我们只需要先修改该数组的值，然后再通过调用oled_refresh_gram函数把数组的值一次性刷新到OLED 的GRAM上即可。oled_refresh_gram函数定义如下：

% `9 x7 D4 W( E7 f4 W/ j$ b

1. /**
   0 W: _% b2 P1 B* I& Q8 ~( C
2. * @brief               更新显存到OLED
   
3. * @param               无
   
4. * @retval              无
   ; f, c9 _% k* a* z) p3 C: B
5. */
   ) F9 t4 c/ ^8 R4 `  N" Y7 y8 z* S
6. void oled_refresh_gram(void)
   
7. {
   , _1 r& z* F, J
8.     uint8_t i, n;
   ! `3 {# f0 B  r$ l) Y* X) q# R
9. 
   
10.     for (i = 0; i < 8; i++)
    # F( k) p: {& \7 o6 @
11.     {
    
12.         oled_wr_byte (0xb0 + i, OLED_CMD); /* 设置页地址（0~7） */
    % E2 T6 ~; L5 L! M" |4 X3 @0 g
13.         oled_wr_byte (0x00, OLED_CMD);      /* 设置显示位置—列低地址 */
    8 N1 G- G4 A( y) ?' }4 h" @& ~
14.         oled_wr_byte (0x10, OLED_CMD);      /* 设置显示位置—列高地址 */
    $ ]2 }% F. c8 I; e: n9 P' @. R' b/ M
15.         for (n = 0; n < 128; n++)
    
16.         {
    6 S* U. _; \9 l0 R! e( T
17.             oled_wr_byte(g_oled_gram[n]<i>, OLED_DATA);
    
18.         }
    
19.     }
    ' D; D7 U' F' b8 I8 E; i
20. }</i>

复制代码

  v- L. ^; }2 [2 P. Holed_refresh_gram函数先设置页地址，然后写入列地址（也就是纵坐标），然后从0开始写入128个字节，写满该页，最后循环把8页的内容都写入，就实现了整个从STM32显存到OLED显存的拷贝。
oled_refresh_gram函数还调用了oled_wr_byte这个函数，也就是我们接着要介绍的函数：该函数和硬件相关，8080并口模式下该函数定义如下：
$ B7 k3 b) l' i2 z3 {; y9 q

1. /**
   & L7 ?% \7 S& H3 o
2. * @brief               向OLED写入一个字节
   # v7 Y& L7 ]! H; K8 N
3. * @param               data: 要输出的数据
   
4. * @param               cmd: 数据/命令标志 0,表示命令;1,表示数据;
   * U. R: D& t8 b. S4 C
5. * @retval              无
   
6. */
   2 \; _% q, [" Q2 ^: E4 c
7. static void oled_wr_byte(uint8_t data, uint8_t cmd)
   
8. {
   ' R# L/ X! p  i" D1 E. Y& \
9.     oled_data_out(data);
   
10.     OLED_RS(cmd);
    $ h% @) q0 K$ y% v+ c# G8 C
11.     OLED_CS(0);
    9 I. J% K" B" Q8 F
12.     OLED_WR(0);
    
13.     OLED_WR(1);
    
14.     OLED_CS(1);
    . J6 j+ t8 M" z2 Q# L
15.     OLED_RS(1);
    
16. }
    
17. 8080并口模式下的oled_wr_byte函数还调用oled_data_out函数，其定义如下：
    
18. /**
    
19. * @brief               通过拼凑的方法向OLED输出一个8位数据
    3 N- h- ^3 R0 Y; N
20. * @param               data: 要输出的数据
    
21. * @retval              无
    * o$ {' e1 |/ Y$ k$ r
22. */
    ( B. [7 u$ ]8 D
23. static void oled_data_out(uint8_t data)
    
24. {
    ! D5 q6 c8 B9 x+ a+ u
25.     uint16_t dat = data & 0X0F;
    : w) v8 Q8 s* w, a6 J# D
26.     GPIOC->ODR &= ~(0XF << 6);              /* 清空6~9 */
    
27.     GPIOC->ODR |= dat << 6;                 /* D[3:0]-->PC[9:6] */
    
28. 
    
29.     GPIOC->ODR &= ~(0X1 << 11);             /* 清空11 */
    ; m7 A7 ~/ D, c( ]& S$ z
30.     GPIOC->ODR |= ((data >> 4) & 0x01) << 11;        /* D4 */
    & t. e, E" \0 d$ j
31. 
    2 o% y' d4 l+ T: J
32.     GPIOD->ODR &= ~(0X1 << 3);                          /* 清空3 */
    
33.     GPIOD->ODR |= ((data >> 5) & 0x01) << 3;         /* D5 */
    & M; U0 X6 K& q9 W; l/ Q
34. 
    + v3 j4 m. B0 X. n" n
35.     GPIOB->ODR &= ~(0X3<<8);                                   /* 清空8,9 */
    + k( i3 j+ M  r) ]$ q  A
36.     GPIOB->ODR |= ((data >> 6) & 0x01) << 8;         /* D6 */
    9 R8 [9 h: W  p" G
37.     GPIOB->ODR |= ((data >> 7) & 0x01) << 9;         /* D7 */
    9 P& Z4 P2 \. k; L$ y' d
38. }

复制代码

) f, F( m" ^( E* s: K4 S# z& E- Boled_data_out函数的处理方法，就是我们前面说的，因为OLED的D0~D7不是接的连续IO，所以必须将数据，拆分到各个IO，以实现一次完整的数据传输，该函数就是根据我们OLED_D[7:0]具体连接的IO，对数据进行拆分，然后输出给对应位的各个IO，实现并口数据输出。这种方式会降低并口速度，但是我们OLED模块，是单色的，数据量不是很大，所以这种方式也不会造成视觉上的影响，大家可以放心使用，但是如果是TFTLCD，就不推荐了。
# N" l7 I; n+ }0 c. H+ {5 ZSPI模式下该函数定义如下：
* J' U& |. a/ P; F' s; V
# g+ ^! e8 G" s& q7 D- B: m

1. /**
   
2. * @brief               向OLED写入一个字节
   & t' @7 @6 L7 x  S* q& r
3. * @param               data: 要输出的数据
   6 D  U3 J) d; j4 {( |
4. * @param               cmd: 数据/命令标志 0,表示命令;1,表示数据;
   
5. * @retval              无
   * U# a% Y$ z0 N. Z* A/ y- A
6. */
   3 `0 O. c) _% \3 v4 u2 d+ _# K4 n0 \; ^
7. static void oled_wr_byte(uint8_t data, uint8_t cmd)
   
8. {
   
9.     uint8_t i;
   
10.     OLED_RS(cmd);   /* 写命令 */
    4 ?# f% J+ d  t
11.     OLED_CS(0);
    
12. 
    ' O( c9 q2 R  J% P4 y1 `
13.     for (i = 0; i < 8; i++)
    3 J* ^3 M3 F' T8 ?3 r
14.     {
    
15.         OLED_SCLK(0);
    
16. 
    
17.         if (data & 0x80)
    ; w, w! u9 x* T" m; P% J, m
18.         {
    5 d" b, O3 y: ]: u
19.             OLED_SDIN(1);
    ( M- ^  `: b8 u9 L# y5 B  Z& Q
20.         }
    
21.         else
    
22.         {
    + G5 Q8 g3 c+ p& S6 |0 |! t
23.             OLED_SDIN(0);
    ) x6 j1 n" l$ C' u; O! E1 @: _* o
24.         }
    
25.         OLED_SCLK(1);
    
26.         data <<= 1;
    
27.     }
    9 }3 p4 x5 T; X7 i1 [0 S! t
28. 
    % h( O8 j$ d# m, r' J
29.     OLED_CS(1);
    2 p' `% D5 {# n$ w7 j! M1 A2 d8 U
30.     OLED_RS(1);
    * U* I+ ]. O$ {( ^. K
31. }
    ! E' m$ ~% O& |: u( s

复制代码

两种模式下的oled_wr_byte函数形参是一样的。第一个形参data就是要写的内容。第二个形参cmd是通过选用OLED_CMD和OLED_DATA两个宏定义的其中一个，控制选择写命令还是写数据。两种模式下的oled_wr_byte函数的时序操作就是根据上面我们对8080接口以及4线SPI接口的时序来编写的。
: B% V9 L6 v. S* q& Q# N+ k6 mg_oled_gram [128][8]二维数组中的128代表列数（x坐标），而8代表的是页，每页又包含8行，总共64行（y坐标），从高到低对应行数从小到大，如表23.3.2.1所示：

0 F, F+ T% l+ J4 U' O

4 o! `% b" m. h" i* v表23.3.2.1 OLED_GRAM和OLED屏坐标对应关系
上表中G代表OLED_GRAM，G[0][0]就表示OLED_GRAM[0][0]。比如，我们要在x=3，y=9这个点写入1，则可以用这个句子实现：
' {% |8 g& B% hOLED_GRAM[3][1]|=1<<1；
一个通用的在点（x，y）置1表达式为：
* W. c1 I5 G! VOLED_GRAM[x][y/8]|=1<<(y%8)；
3 ~, H$ q5 ?! O) q+ ^6 a- J$ T其中x的范围为：0127；y的范围为：063。
/ Q6 s: y7 r. v1 g1 J因此，我们可以得出接下来介绍的这个比较重要的函数：OLED画点函数，其定义如下：

2 ?2 d. N: @- e0 C! }( K/ I

1. /**
   , b  A6 w: g* c0 X! i5 a
2. * @brief       OLED画点
   ( g. h. @. D8 {; R' ]
3. * @param       x  : 0~127
   $ t4 |9 ~3 d4 @0 x
4. * @param       y  : 0~63
   
5. * @param       dot: 1 填充 0,清空
   1 |4 B  K- I" D: h. M
6. * @retval      无
   
7. */
   
8. void oled_draw_point(uint8_t x, uint8_t y, uint8_t dot)
   
9. {
   
10.     uint8_t pos, bx, temp = 0;
    
11. 
    * K8 u$ I. x$ y3 k: B% Y
12.     if (x > 127 || y > 63) return;  /* 超出范围了 */
    
13. 
    * d7 a, u3 H6 k  ]2 v0 J
14.     pos = y / 8;     /* 计算GRAM里面的y坐标所在的字节, 每个字节可以存储8个行坐标 */
    2 Y9 j3 l; y2 M+ x1 G
15. 
    0 g+ w  ]; \8 O% v$ o( E/ h" I
16.     bx = y % 8;                /* 取余数,方便计算y在对应字节里面的位置,及行(y)位置 */
    # y8 ^. E& i; Q8 }  k3 D& m1 J1 z
17.     temp = 1 << bx;         /* 高位表示高行号, 得到y对应的bit位置,将该bit先置1 */
    
18. 
    
19.     if (dot)    /* 画实心点 */
    
20.     {
    
21.         g_oled_gram[x][pos] |= temp;
    
22.     }
    5 D  K7 E' Q  k1 r) z
23.     else        /* 画空点,即不显示 */
    
24.     {
    / l$ v- S  E2 {0 P# L6 m! p: l
25.         g_oled_gram[x][pos] &= ~temp;
    $ |. g7 z. v( f" r- N4 @( F5 |
26.     }
    3 c* W$ {, E) |. s3 M
27. }

复制代码

7 A9 \1 U" E9 d" z5 Q# c" [* V- G3 o该函数有3个形参，前两个是横纵坐标，第三个为要写入1还是0。该函数实现了我们在OLED模块上任意位置画点的功能。
1 l1 `/ {3 r1 [% L6 e! ~. v前面我们知道取模方式是：从上到下，从左到右，高位在前。下面根据取模的方式来编写显示字符oled_show_char函数，其定义如下：

1. /**
   7 d; n5 Y) L6 H, w
2. * @brief       在指定位置显示一个字符,包括部分字符
   
3. * @param       x   : 0~127
   0 I( m! w5 W  {: P) F5 u! Z
4. * @param       y   : 0~63
   ) b% \9 Q& d/ a- b1 D3 y0 {
5. * @param       size: 选择字体 12/16/24
   ; P& F5 `7 H+ d; K( N
6. * @param       mode: 0,反白显示;1,正常显示
   7 i6 t. x0 g! ?- ]/ F% m8 C6 X: j
7. * @retval      无
   
8. */
   , Q& b* x4 ^6 l; a" `/ j4 U" e' D; w
9. void oled_show_char(uint8_t x,uint8_t y,uint8_t chr,uint8_t size,uint8_t mode)
   
10. {
    
11.     uint8_t temp, t, t1;
    ! e8 |9 Q/ ^  K
12.     uint8_t y0 = y;
    
13. uint8_t *pfont = 0;
    * }0 f: E2 {% T- O. }$ y
14. /* 得到字体一个字符对应点阵集所占的字节数 */
    ; s* [  |0 q2 N, `: a
15.     uint8_t csize = (size / 8 + ((size % 8) ? 1 : 0)) * (size / 2);
    
16.     chr = chr - ' ';      /* 得到偏移后的值,因为字库是从空格开始存储的,第一个字符是空格 */
    
17. 
    
18.     if (size == 12)       /* 调用1206字体 */
    ( Q5 ^( P( L. v  o/ a+ t/ K+ M
19.     {
    8 k1 V* M9 m' ^$ Z8 r5 \5 K! p
20.         pfont = (uint8_t *)oled_asc2_1206[chr];        
    4 B3 C$ W. o3 Q9 K* y
21.     }
    ( a, o( }0 h/ X; d0 O- J% D3 y# U
22.     else if (size == 16) /* 调用1608字体 */
    9 b- O3 z% L& J. z0 J8 d/ G; J! T) E
23.     {
    5 T6 s. y. p5 n6 F. V
24.         pfont = (uint8_t *)oled_asc2_1608[chr];
    , F: {4 M  z  c2 k
25.     }
    
26.     else if (size == 24) /* 调用2412字体 */
    - c$ f" h/ O: P. H: a4 t: V
27.     {
    8 O4 H8 ^3 ]) e! q
28.         pfont = (uint8_t *)oled_asc2_2412[chr];
    
29.     }
    9 s: {! X( `, g* @7 q5 w
30.     else                    /* 没有的字库 */
    
31.     {
    
32.         return;   
    ( t' Q4 r, P7 l  C1 w; T' {
33.     }
    4 L& h$ ?3 w9 y8 ^) A; t+ n3 o
34. 
    9 Q" I4 }: ~% R! G. U- ^3 Z
35.     for (t = 0; t < csize; t++)
    
36.     {
    
37.         temp = pfont[t];
    
38.         for (t1 = 0; t1 < 8; t1++)
    
39.         {
    5 T3 z4 n/ ?  G. i. `4 c
40.             if (temp & 0x80)oled_draw_point(x, y, mode);
    
41.             else oled_draw_point(x, y, !mode);
    
42. 
    5 y6 `$ G7 P% @- L3 v5 N" @
43.             temp <<= 1;
    6 a3 r5 T" j' {, W  ^" t
44.             y++;
    7 }3 D& w7 u/ k1 i# G, ?2 z1 m$ k  @
45. 
    
46.             if ((y - y0) == size)
    # A3 o- ?2 k9 w* y- P! l' D# t5 Z' L1 X
47.             {
    & I, E- G5 K$ k" f: D$ ]& n0 Q& M
48.                 y = y0;
    4 b9 I, b" L4 p# w3 y
49.                 x++;
    
50.                 break;
      N: ^& `2 l( p. v% ~- w
51.             }
    
52.         }
    4 {9 h, l3 G3 x" P+ r
53.     }
    
54. }

复制代码

% ?/ H3 r: Y4 J' M: C! i$ K该函数为字符以及字符串显示的核心部分，函数中chr = chr - ’ ';这句是要得到在字符点阵数据里面的实际地址，因为我们的取模是从空格键开始的，例如oled_asc2_1206 [0][0]，代表的是空格符开始的点阵码。在接下来的代码，我们也是按照从上到小(先y++)，从左到右（再x++）的取模方式来编写的，先得到最高位，然后判断是写1还是0，画点；接着读第二位，如此循环，直到一个字符的点阵全部取完为止。这其中涉及到列地址和行地址的自增，根据取模方式来理解，就不难了。
' B; U! o, q, \8 x& f! x2 P' g8 v" @oled.c的内容比较多，其他的函数请大家自行理解，下面开始main.c文件的介绍。
2. main.c代码
0 ~$ U, Z0 U" w3 C+ h& u7 I在main.c里面编写如下代码：

/ S9 g0 t$ k: e; o% b2 D$ }, A

1. int main(void)
   
2. {
   
3.     uint8_t t = 0;
     t3 K+ [6 y' i& B( k3 U' O
4.     sys_cache_enable();                             /* 打开L1-Cache */
   
5.     HAL_Init();                                       /* 初始化HAL库 */
   
6.     sys_stm32_clock_init(240, 2, 2, 4);          /* 设置时钟, 480Mhz */
   5 Y3 a6 F- D9 V# ^) V/ _
7.     delay_init(480);                                 /* 延时初始化 */
   
8.     usart_init(115200);                             /* 串口初始化为115200 */
   
9.     led_init();                                       /* 初始化LED */
   
10.     oled_init();                                      /* 初始化OLED */
    9 D4 F+ \% r4 I2 Y& v# d2 I" ]
11.     oled_show_string(0, 0, "ALIENTEK", 24);
    # b  z# E" |4 {+ N# L5 }" V# B
12.     oled_show_string(0, 24, "0.96' OLED TEST", 16);
    5 l- ~: o& T( {8 i7 O
13.     oled_show_string(0, 40, "ATOM 2020/3/22", 12);
    ( ~- p% n1 |# G  E
14.     oled_show_string(0, 52, "ASCII:", 12);
    
15.     oled_show_string(64, 52, "CODE:", 12);
    : [1 r% e5 X& C! t1 L. h
16.     oled_refresh_gram();    /* 更新显示到OLED */
      o- a7 {9 `  ^9 o7 h3 u9 Q, X$ r
17. t = ' ';
    . X- ?. v- K, Z8 V
18.     while (1)
    
19.     {
    & i0 ?& }) R3 a. P; X2 f- x" u
20.         oled_show_char(36, 52, t, 12, 1);        /* 显示ASCII字符 */
    
21.         oled_show_num(94, 52, t, 3, 12);         /* 显示ASCII字符的码值 */
    % V& B6 d9 h+ k6 Z: v) Q
22.         oled_refresh_gram();                       /* 更新显示到OLED */
    
23.         t++;
    
24.         if (t > '~')t = ' ';
    
25.         delay_ms(500);
    
26.         LED0_TOGGLE();  /* LED0闪烁 */
    ' j! ~; c& Z1 {! d9 s
27.     }
    + ?, I) v6 {# M
28. }

复制代码

8 \- f  g' F! M1 Y, S, UMain.c主要功能就是在OLED上显示一些实验信息字符，然后开始从空格键开始不停的循环显示ASCII字符集，并显示该字符的ASCII值。最后LED0闪烁提示程序正在运行。
+ k" ]$ i. x- C/ J4 {, j% ]23.4 下载验证
( [( f% \# r" w6 |0 ?3 f下载代码后，LED0不停的闪烁，提示程序已经在运行了。同时OLED模块显示ASCII字符集等信息，如图23.4.1所示：



图23.4.1 OLED显示效果
OLED显示了三种尺寸的字符：2412（ALIENTEK）、168（0.96’ OLED TEST）和12*6（剩下的内容）。说明我们的实验是成功的，实现了三种不同尺寸ASCII字符的显示，在最后一行不停的显示ASCII字符以及其码值。
$ n0 ~" {4 n1 _3 ~/ G6 i$ ^9 T5 I通过这一章的学习，我们学会了ALIENTEK OLED模块的使用，在调试代码的时候，又多了一种显示信息的途径，在以后的程序编写中，大家可以好好利用。
$ C* d* Y: ^# l5 f————————————————
3 n# _; H+ P5 n) P# l# q! _$ {0 J- x版权声明：正点原子