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

19.1 字符编码
, d5 [1 E* Z  E* B* Y计算机中存储的信息是以二进制的0或1来表示的，我们在屏幕上看到的汉字、英文和数字等信息是经过二进制转换后的结果。按照某种规则将字符存储在计算机中，例如ASCII 字符集中，字符’a’用十进制的97来表示，字符’A’用十进制的65来表示，我们称为“编码”，反之，将计算机中的二进制数据解释出来，我们称为“解码”。
字符集是各种文字和符号的集合，常见的字符集有ASCII字符集、GB2312字符集、BIG5字符集、Unicode字符集等。下面我们会介绍ASCII字符集，关于其它字符集，如果想深入了解，大家可以参考百度百科详细说明。计算机要准确的处理各种字符集的文字，就需要进行字符编码。字符编码也称作字集码，它是一套编码规则，是信息处理的一项基本技术，其在符号集与数字系统之间建立对应关系，将符号转换为计算机可以够识别和存储的数字。
ASCII码使用7位2进制数表示一个字符，7位2进制数可以表示出27个字符，共128个字符，其中有 96 个可打印字符，包括常用的字母、数字、标点符号等，另外还有 32 个控制字符，控制字符中，如LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格）、BEL（振铃）等，如下图中是ASCII字符代码表：


0 v& t" P3 Q8 {; I, h
图19.1. 1 ASCII字符代码表ASCII字符代码表
4 k  c( g! f# C/ S/ n本章实验，我们会使用以下ASCII字符集来显示英文字符和数字（第一个字符是空格）: !"#$%&’()+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~
; o- r6 ^, y' Y19.2 制作字模
" p9 v* X- v( l/ a1 r1 W) x! t8 a19.2.1 像素
' X% }7 f. u2 t9 {( F图像显示是用点阵的方式来显示的，屏幕上一个个很细小的点就是像素，像素点就类似一个灯(在 OLED 显示器中，像素点就是一个小灯)，通过控制这些小灯的亮和灭可以显示不同的图像。像素是图像最基本的单位，屏幕上像素点越小，像素密度越高的，图像的像素越高，显示的效果就越清晰。高分辨率的图像要比低分辨率的图像包含更多的像素，所以同样大小的图像，使用高分辨率的屏幕比低分辨率的屏幕来显示更清晰。提起显示器，我们都会听到 720P、1080P、2K 或 4K 这样的字眼，1080P 的意思就是一个屏幕上的像素数量是19201080 个，也就是这个屏幕一列 1080 个像素点，一共 1920 列，如下图所示：
( B+ H. R, k. R2 `6 L' w
  J5 i& b7 W6 I# X- I& d1 Y. Z7 {9 u

图19.2.1. 1像素点和分辨率关系示意图
上图中，X 轴就是1080P显示器的横轴，Y 轴就是1080P显示器的竖轴。图中的小方块就是像素点，一共有 1920*1080=2073600 个像素点。左上角的 A 点是第一个像素点，右下角的 C 点就是最后一个像素点。
1 }; F$ I  d' J  w: j! V19.2.2 字模
1.字模简介
( m" M) G' K* ~( I6 V! x字模就是字符或者图像在点阵上显示时对应的编码，字模也就是我们要计算机识别的符号或者图像的数据，以数字来表示，因为计算机只能识别数字0和1，所以我们要先把图像或者符号通过字模软件转化成字模。如下图，如果我们要显示一个英文字母“B”，以816个二进制数据位来表示，每个二进制数据位记录一个像素点的状态，则一个英文字母需要816/8=16个字节的二进制数据位来表示。字符的宽为1个字节，高为2个字节：
4 {5 Z# @* D9 [+ a4 l8 F

9 N* ]+ D  Q( @9 \9 X
: K4 A- _  S: ~+ x& A" x- `; u$ _图19.2.2. 1 显示英文字符
1 Y+ L9 @; |% S. o0 r% V如果是汉字，汉字字符是英文字符的两倍，一个汉字则需要16*16/8=32个字节的二进制数据位来表示，字符的宽为2个字节，高也为2个字节，即汉字字符的宽是英文字符的宽的2倍：
2. 制作字模
制作字模，有很多的优秀的软件，本实验我们使用“开发板光盘A-基础资料\3、软件\PCtoLCD2002完美版”字模软件来制作字模，该软件可以提供各种字符包括汉字（字体和大小都可以自己设置）点阵提取，且取模方式可以设置好几种，常用的取模方式，该软件都支持。该软件除了支持字符模式，还支持图形模式，也就是用户如果要显示一张图片的话，可以自己定义图片的大小，然后手动画图，或者可以导入一张已有的图片，该软件根据图片提取出点阵数据。下面我们来介绍此字模软件的使用方法。
（1）字符模式
9 S3 r$ ~( ?5 b' S①双击打开字模软件PCtoLCD2002完美版：


0 s. }+ d. Z6 F) E! ]6 A
' s+ e8 w& o0 U. }/ `( G图19.2.2. 3 PCtoLCD2002完美版
②对于要显示字符，我们先把要显示的字符输入字符输入框中，然后点击设置选项设置取模方式：
! s5 B. K) @2 H; k# P" a$ x: b/ x
. S6 f  H0 N7 H

/ F9 w  s( V/ U2 m4 N1 N2 l图19.2.2. 4 输入字符
③然后我们设置取模方式，如下图，红框处可以配置，其它部分我们先保持默认：

9 j7 o$ ?* f3 h8 |
# g" E  B# B/ i" H! G& C
图19.2.2. 5设置取模方式
点阵格式可以选择阴码或者阳码，字模也就是像素点的数据，每一个点都需要一个bit位来存储，该位为0代表该像素点不显示，为1代表显示。字模点阵中有笔迹像素位的状态是“1”（亮），没有笔记像素位的状态是“0”（灭）的方式为阴码；字模点阵中有笔迹像素位的状态是“0”（灭），没有笔记像素位的状态是“1”（亮）的方式为阳码。本节实验中选择阴码。
取模走向可以选择顺向或者逆向，也就是屏幕上同列中上行与下行哪个行对应生成字节的高位还是低位的问题，顺向就是屏幕下行属于高位，逆向就是屏幕上行属于低位。本节试验选择顺向。
6 A% ]4 s! T# v) W6 ~每行显示数据可以自行配置，点阵表示生成的字模中，每行最大可以显示多少个数据，索引则表示产生的索引中，每行显示多少个索引值。

5 ?! g, g" ]) [5 n6 B  y  r

. A$ l- k6 C: g$ Y图19.2.2. 6点阵数据
& E  }2 _0 J* l2 }! g! E: m例如配置为“点阵：12 索引：12”，以下字模每行最大为12个数据：
{0x00,0x04,0x00,0x3C,0x03,0xC4,0x1C,0x40,0x07,0x40,0x00,0xE4},
2 @9 m) N; P7 r5 P' u. W{0x00,0x1C,0x00,0x04},/“A”,0/
字宽和字高，字宽和字高可以自行配置，会有英文的字宽和字宽以及中文的字宽和字宽，我们前面也说过，汉字的字宽是英文字宽的两倍，如果配置汉字的字宽和字高都是16，那么英文的字宽和字高分别是8和16：

# j" A) ^, F+ S! A

' c/ Z( ^# O$ M; {图19.2.2. 7设置字宽和字高
自定义格式中，A51按汇编生成，C51按c格式生成，显然我们是c编程，选择C51即可。自定义格式处如果勾选后，我们可以配置生成的字模数据的格式。例如，如果生成的数据中不想要大括号“{}”，可以自定义去掉大括号：
* x# u$ u+ A* Z9 T8 J4 V  c

- D$ E+ O6 @0 j$ v
图19.2.2. 8自定义点阵数据的前缀和后缀
8 e" g& q. O& i4 M生成的点阵数据中就没有了大括号：
) A( ]+ c$ o, r, n0x10,0x04,0x1F,0xFC,0x10,0x04,0x00,0x04,0x00,0x04,0x00,0x04,
0x00,0x0C,0x00,0x00,/“L”,1/
& v, ~5 G& V, B3 Y1 n! r取模方式有逐列式、逐行式、列行式和行列式。不同的取模方式需要结合不同的算法。在右上角的取模说明里面有，即：从第一列开始向下每取8个点作为一个字节，如果最后不足8个点就补满8位。取模顺序是从高到低，即第一个点作为最高位。如*-------取为10000000。其实就是按如下图所示路径的这种方式：
. Y* U3 o' f7 o! p% X
  \5 P5 l2 E5 I! p) B
* m' y) t4 ~# s4 s8 ^' P! ~
图19.2.2. 9取模方式图解
从上到下，从左到右，高位在前。我们按这样的取模方式，然后把ASCII字符集按126大小、168和2412大小取模出来（对应汉字大小为1212、1616和2424，字符的只有汉字的一半大！），每个126的字符占用12个字节，每个168的字符占用16个字节，每个24*12的字符占用36个字节。
④点击生成字模，再保存字模，可以选择保存生成的字模：


  m& L1 C  K2 d0 P: x% j/ O
图19.2.2. 10生成和保存字模
（2）图形模式
9 ?- ^" Y& I4 IPCtoLCD2002完美版字模软件支持BMP格式的图片，如果要对某一张点阵图片取模，需要将此图片转化成.bmp格式的图片才可以。

# E( R* Y' G9 V

+ K1 m' x! u1 R0 ~' d图19.2.2. 11图形模式
; F+ m+ ~( W; q9 N2 I% a: o- Z如下图，选择图形模式后，点击文件打开，选择打开一张.bmp格式的文件即可：
6 d; q' [- t& X: o


% T: h0 a4 Y8 X图19.2.2. 12选择打开图形
或者可以选择文件新建，新建一张大小规定的图像（如果屏幕很小，建议设置的长和宽要比屏幕小，这样才可以显示完全），然后手动画图：


7 B" ]7 g! ]) v7 T3 q. U0 J
图19.2.2. 13手动画图
19.2.3 根据取模方式控制点阵显示字符
* j. _4 `3 {' l: f' {9 g% s2 k下面，我们先以显示简单的字符为例子，对字符显示做一个简单的讲解，为了方便讲解，此处讲解的代码先不在开发板上运行，我们先在以前学习C语言的工具（例如Visual C++ 6.0）上操作实现。此处的代码非常简单，如果没有安装此软件的也无关紧要，理解一遍代码即可。

1.显示英文字符
$ m0 u) u7 a3 {9 B- g9 m- W1 m（1）字模提取
. h5 `& y% C6 Z+ C4 r6 A' }如果我们要显示一个英文字符“A”，如下图，设置字体为宋体，字宽和字高都为16，这个是汉字格式，那么对应的英文格式字长就是8，字宽就是16。如果A这个字符按阴码、顺向、逐列式、十六进制方式取模（即从下到上、从左到右、从低位到高位取模），如下图，因为点阵格式是阴码，为1的地方表示亮，为0的地方表示灭：



19.2.3. 1设置取模方式
4 L  O7 {) i) e& D) e" i


19.2.3. 2英文字符A

0 d4 H2 F8 P0 Z

19.2.3. 3字符A对应的点阵数据
那么，取模得到的十六进制数据为：
$ H7 T! N$ a& A& j# ^( B0x00,0x04,0x00,0x3C,0x03,0xC4,0x1C,0x40,0x07,0x40,0x00,0xE4,0x00,0x1C,0x00,0x04,/“A”,0/
不同的取模方式得到的数据不一样，如果设置字体为宋体，字宽和字高都为16，我们的取模方式为阴码、顺向、行列式、十六进制方式提取（即从上到下、从右到左、从），则取模得到的十六进制的数据为：
8 {3 p2 ?* {' F  [  D

/ B* `/ b( ~7 k6 j
19.2.3. 4设置取模方式



% E) @# K/ x0 x19.2.3. 5字符A对应的点阵数据
取模得到的点阵数据如下：
; i) f- n7 ^0 ?- B6 a/ s0x00,0x00,0x00,0x10,0x10,0x18,0x28,0x28,0x24,0x3C,0x44,0x42,0x42,0xE7,0x00,0x00,/“A”,0/
（2）程序实现
# C# T& Q2 r9 x以上字模提取过程称为编码，不同的取模方式，算法会有些差别，我们使用程序将字符“A”打印出来，使用以上阴码、顺向、行列式、十六进制取模方式的编码数据，在Visual C++ 6.0下的程序如下：
1 ^- _2 I. Z9 J! n) E" Q
  b/ w. U7 R7 M7 y: G* v

1. 1   #include <stdio.h>  
   
2. 2   #include <stdlib.h>  
   5 }# F" D' U2 A: v# g- j3 c
3. 3     
   
4. 4   unsigned char ch[] = {0x00,0x00,0x00,0x10,0x10,0x18,0x28,0x28,0x24,0x3C,0x44,0x42,0x42,0xE7,0x00,0x00};  
   0 _+ H- d# ]! @. G' k
5. 5
   
6. 6   void showA(){  
   2 l5 i; X$ ^/ E" U/ x$ F* {) S& W
7. 7       int i,j;  
     t2 [1 s' t! i* t
8. 8       unsigned char t;  
   
9. 9       for (i = 0; i < 16; ++i)             /* 总共16个十六进制数据 */  
   
10. 10      {
    / r& o# S% b' K2 _7 v8 k
11. 11          t = ch<i>;                               /* 依次取出以上数组的数据  */
    
12. 12          for (j = 0; j < 8; ++j)          /* 对于某行中的每个点  */
    
13. 13          {   
    ! s, n9 t. o7 U# ?( {7 `
14. 14              if (0x80 & t)
    0 \+ G' p4 N0 c
15. 15              {                  
    
16. 16                  printf("*");  /* 从左到右如果最左位为1，则显示*号 */
    ; \' B( `0 l5 u8 I# T/ s, ]- c
17. 17              }
    " D* s* `/ D1 D8 v5 A
18. 18              else
    
19. 19              {  
    # m, i$ _& [8 ^9 |
20. 20                  printf(" ");  /* 从左到右如果最左位为0，则显示空格 */
    
21. 21              }  
    
22. 22              t <<= 1;          /* 将右边的数据往左移动  */
    
23. 23          }  
    7 C+ S) R  l8 S( ?# @+ |1 i6 R
24. 24          printf("\n");  
    
25. 25      }  
    7 J7 i6 I1 {* ?. H
26. 26  }  
    
27. 27   
    . s+ H4 T' @5 P
28. 28  int main(void) {  
    
29. 29      showA();  
    
30. 30      return EXIT_SUCCESS;  
    
31. 31  }  </i>

复制代码

& \) i; k8 Q/ J; b我们简单分析以上代码的实现逻辑。
第4行是讲取模得到的数据按照顺序排列到一个一维数组中；
第9行，一维数组共16个数据，每个数据代表一行（一行有8位），使用for循环依次取出这16个数据；
. N/ W) L& e- {: X0 z( @7 E$ |第11行，依次取出的数据存放到变量t中；
' H0 k( Q7 s; ^( H) ?第12行，每个数据是8bit的， j表示这8个位的第几位，有0~7个位，0表示第0位，每个位表示一个像素点。
9 u# n( P6 N7 H. n/ B! J$ k第14~17行，将这8位的每个位进行判断，如果某位为1，则打印*号；
第18~21行，如果某位为0，则打印空格；
1 }, i! s. [, V" J+ h! ?第22行，t左移，从第0个数据开始，直到将这16个数据都判断完毕为止。
第28~30行是固定格式，使用控制台输出。
以上代码使用for循环嵌套，对数据逐位进行判断。
# \! V. L7 z- {; b. O5 D& s3 S% `编译无报错，执行后控制台打印出A，效果如下：



6 B0 Y( \. N. _- |- z: U, a: f19.2.3. 6运行结果
2. 显示中文字符
我们前面说过，一个中文字符的字宽是一个英文字符的两倍，每个汉字每行有16个像素点，即2个字节的像素点，所以每行需要对2个字节的二进制数据进行打印，参考前面英文字符的显示方法，程序中我们将汉字分为左半部分和右半部分来实现，所以要再增加一个for循环。
（1）汉字取模
1 s. R, s5 n' U. ]前面我们说了，取模方式的不同，算法会有差别，前面的英文字符显示我们是采用阴码、顺向、行列式、十六进制取模方式。这里我们设置字体为宋体，字宽和字高都为16，使用阴码、顺向、逐行式、十六进制取模方式：
$ ~- w4 S2 y: r) f7 \% t" J
' X" i" m. f9 r5 {9 ~
' q. ]" k% z( e5 R7 h4 D  E3 G- u$ E
19.2.3. 7设置取模方式
; r8 V$ y1 |& x) z7 J3 F" @3 U1 ?

' D$ b% l. m3 J
- S. `4 ~/ T/ j3 t* c8 H19.2.3. 8字体效果
0 i. x, c0 M, B3 Z+ T
: Q6 b* E8 K7 K
+ C; K9 r; m; i. {5 p& e+ P# O
6 l1 [, ]% R/ C2 k7 B19.2.3. 9点阵数据排列
) p# K8 {0 k( @- a8 y取模后点阵的数据为：
" `  V" W9 }9 K- c3 o) A  `0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0xFF,0xFE,0x01,0x00,0x01,0x00,
0x02,0x80,0x02,0x80,0x04,0x40,0x04,0x40,0x08,0x20,0x10,0x10,0x20,0x08,0xC0,0x06,/“大”,0/
（2）程序实现
取模的数据中有两行十六进制数据，先以第一行的数据为例，第0个数据是左半边，第1个数据是右半边，第2个数据是左半边，第3个数据是右半边，也就是排序中，偶数对应左半边，奇数对应右半边，依此类推，数据交替存放。程序实现的代码如下：

% g. W' L6 r: m* Q$ K' G' w1 A

1. 1   #include <stdio.h>  
   
2. 2   #include <stdlib.h>  
   & h. k+ n  h$ S' F
3. 3     
   8 r# {2 d2 U7 m; ~2 f. E% b+ Y
4. 4   unsigned char ch[] = {  
   5 R  d2 L3 f- ^7 n1 b/ M8 H$ ?
5. 5   0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0xFF,0xFE,0x01,0x00,0x01,0x00,
   $ q1 V  d4 c& X2 l" n
6. 6   0x02,0x80,0x02,0x80,0x04,0x40,0x04,0x40,0x08,0x20,0x10,0x10,0x20,0x08,0xC0,0x06
   $ E3 W& W' v6 g( F0 ~1 f6 N+ p" J
7. 7   };  
   
8. 8     
   . m2 i5 X) v; ?8 X- r
9. 9   void show()  
   % z3 g* Y) z# S$ {  T' [5 P3 e
10. 10  {  
    
11. 11      int i, j;  
    
12. 12      unsigned char f, s;   /*表示一个汉字每行的左半边的8像素和右半边的8像素 */
    - h. G% }+ o3 A3 M3 o. R$ `# _6 |
13. 13      for (i = 0; i < 16; ++i)  /* 16个组合 */
    ; z. k  F& ~; ^8 c5 E! T
14. 14      {   
    
15. 15          f = ch[i * 2];        /* 取出左半边的数据 */
    
16. 16          s = ch[i * 2 + 1];    /* 取出右半边的数据 */
    $ e& d3 I/ X) G( Y
17. 17
    
18. 18          /* 先判断中文字符的左半边的数据 */
    9 Y: k4 A$ s+ b9 D; D" H
19. 19
    0 k: c1 h; K& _0 N
20. 20          for (j = 0; j < 8; ++j) /* 每个数据8位 */
    
21. 21          {   
    4 a; ~7 l2 M' a- s
22. 22             if (0x80 & f)
    $ ^9 z8 l) @9 Y. c7 B
23. 23              {      
    
24. 24                  printf("*");  /* 从左到右，如果某位为1，则显示*号 */
    8 b1 D$ w/ Y* t1 [" w
25. 25              }  
    
26. 26              else  
    0 @/ q& F6 ?3 w' g, Q$ l; \, H
27. 27              {  
    9 i0 [% [- g* P7 S; a
28. 28                  printf(" ");  /* 从左到右，如果某位为0，则显示空格 */
    
29. 29              }  
    / E& v$ S' l5 y! f! b) P9 l
30. 30              f <<= 1;          /* 将右边的数据往左移动 */
    ( Z* e" d* {) `6 F2 ?0 B5 W
31. 31          }  
    * _6 {9 y: z3 f$ S
32. 32
    
33. 33          /* 再判断中文字符右半边的数据 */
    
34. 34
    
35. 35          for (j = 0; j < 8; ++j)/* 每个数据8位 */  
    & W" E9 i% @% T
36. 36          {   
    # n7 x* Z) u/ ~2 \- K, J
37. 37             if (0x80 & s)
    2 E; H$ Y2 i+ a+ `. ?$ s; L
38. 38              {      
    
39. 39                  printf("*");/* 从左到右，如果某位为1，则显示*号 */  
    
40. 40              }  
    
41. 41              else  
    ( N3 l0 A' N2 i3 z
42. 42              {  
    
43. 43                  printf(" ");  /* 从左到右，如果某位为0，则显示空格 */
    
44. 44              }  
    & Z# b' L% S" w# e
45. 45              s <<= 1;         /* 将右边的数据往左移动 */
    
46. 46          }  
    
47. 47          printf("\n");  
    
48. 48      }  
    
49. 49  }  
    
50. 50   
    
51. 51  int main(void) {  
    2 v# l# n7 b" ~* a" z8 D8 `1 E
52. 52      show();  
    
53. 53      return EXIT_SUCCESS;  
    ; M. j6 a1 J5 W7 }3 J; D
54. 54  }  

复制代码

& x% F9 M! s2 S5 G$ m, n% r第12行，定义两个变量，f用于左半边的数据计算，f是偶数；s用于右半边的数据计算，s是奇数；
) Z, {5 }( h7 }1 l& Z% J- w$ U第13行，一维数组中有两行，每行16个十六进制的数据；
4 I. o, W8 R9 ~6 N7 _- ?第15行，依次取出左半边的数据，
, P) i' m- G; O3 d6 s第16行，依次取出右半边的数据；
第20~31行，像前面显示英文字符那样，将汉字的左半边显示出来；
6 ]2 f. h, q- r! U: E2 |+ X5 A4 H第35行~46行，像前面显示英文字符一样，将汉字的右半边显示出来；
编译不报错，运行程序，结果如下：



19.2.3. 10编译运行效果
3. 显示图片或者动图
3 {0 D5 r# j9 W+ M7 M) S0 h关于显示图片和动图，这里就不列出代码了，我们后面会有专门的实验。
（1）显示一张图片
, C8 V/ S3 w% g  b. ^如果只是想显示一张图片，只需要将此图片转化成.bmp格式的图片，再取模即可。要注意的是显示屏幕的分辨率，如果屏幕的分辨率比图片的分辨率要小，则屏幕上无法显示完全图片，可以修改图片的分辨率以后再进行取模。可以使用windows自带的画图工具先打开要修改的.bmp格式的文件，打开以后再手动修改像素：

$ ]% I/ b9 i' u# |  c- s

19.2.3. 11小改像素
（2）显示动图
如果要显示动图，如果只有一张.bmp格式的图片，可以通过程序将图片移动位置，如果是.gif格式的动图文件，可以使用gif分离器软件，例如开发板光盘A-基础资料\3、软件下的GIF2BMP软件，将动图拆分成一张张的.bmp格式的文件，然后再对每张图片取模。其实动图也就是由一帧帧的图片组合成的，拆分出的每一张.bmp格式的图片都是一帧图。
9 v% e  C/ H" S0 Y双击打开Gif分离器zhs9.exe，然后选择要分离的.gif格式文件以及分离后的文件保存路径，再点击开始分离，软件则进行分离。
6 `# W/ `0 j: {" K- P8 D& B
  t5 H& n6 b3 s2 I3 f. z; g

: Q: S; A* j- y4 {  A7 I& k19.2.3. 12分离图片
; o# \% R  Y& Z8 S+ T) i为了方便大家，在开发板光盘A-基础资料\3、软件\GIF2BMP下有放一张动图文件，文件名为2323.gif，像素为120*60帧。如下图，将2323.gif的动图分离后，最后得到58张.bmp格式的文件，即此动图有58帧：

: M) F1 L) @3 ~- n
: {' o6 v6 U$ k: N/ h/ S
19.2.3. 13分离后的图片
: b( K- _7 p; G3 p$ u8 X8 B- K后面的实验中，我们会选出其中的10张图片在OLED上显示出一个动图。
0 U* N8 h  C" k19.3 OLED简介
19.3.1 OLED简介
OLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（Organic Electroluminesence Display， OELD）。OLED由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。
LCD都需要背光，而OLED不需要，因为它是自发光的。这样同样的显示，OLED效果要来得好一些。以目前的技术，OLED的尺寸还难以大型化，但是分辨率确可以做到很高。在本章中，我们使用的是ALINETEK的OLED显示模块，该模块有以下特点：
- [3 w4 C" n( W8 k1）模块有单色和双色两种可选，单色为纯蓝色，而双色则为黄蓝双色。
- _/ E. b0 e) P6 M2）尺寸小，显示尺寸为0.96寸，而模块的尺寸仅为27mm26mm大小。
3）高分辨率，该模块的分辨率为12864。
( y6 c; Z: `+ S! z6 h: A4）多种接口方式，该模块提供了总共4种接口包括：6800、8080两种并行接口方式、4线SPI接口方式以及IIC接口方式（只需要2根线就可以控制OLED了！）。
5）不需要高压，直接接3.3V就可以工作了。
1 \! ?! z$ I3 O8 f6 o$ B19.3.2 OLED的模式简介
这里要提醒大家的是，该模块不和5.0V接口兼容，所以请大家在使用的时候一定要小心，别直接接到5V的系统上去，否则可能烧坏模块。以下4种模式通过模块的BS1和BS2设置，BS1和BS2的设置与模块接口模式的关系如下表所示：
! q8 G3 L: N$ z) \' ?( \


* `7 v* v5 l/ r7 N4 t  L. O8 @表19.3.2. 1 OLED模块接口方式设置表
表中：“1”代表接VCC，而“0”代表接GND。
" T7 G$ Q. r0 Y+ d; {- t该模块的外观图如下图所示：

4 {2 ?9 X6 Y* I4 z. k0 f6 v

图19.3.2. 1 ALIENTEK OLED模块外观图
7 z3 p# a( U% }4 L. yALIENTEK OLED模块默认设置是：BS1和BS2接VCC ，即使用8080并口方式，如果你想要设置为其他模式，则需要在OLED的背面，用烙铁修改BS1和BS2的设置。
模块的原理图如下图所示：
9 G" l) U( Q. d
1 y. J5 j, o  o6 A0 U6 u
4 n9 l- L& Z9 ]: i. M4 w9 ]
图19.3.2. 2 ALIENTEK OLED模块原理图
该模块采用8*2的2.54排针与外部连接，总共有16个管脚，在16条线中，我们只用了15条，有一个是悬空的。15条线中，电源和地线占了2条，还剩下13条信号线。
; q0 W6 Y9 R! ?# e( n6 e5 ~在不同模式下，我们需要的信号线数量是不同的，在8080模式下，需要全部13条，而在IIC模式下，仅需要2条线就够了！这其中有一条是共同的，那就是复位线RST（RES），RST上的低电平，将导致OLED复位，在每次初始化之前，都应该复位一下OLED模块。
ALIENTEK OLED模块的控制器是SSD1306，本章，我们将学习如何通过STM32H750来控制该模块显示字符和数字，本章的实例代码将可以支持两种方式与OLED模块连接，一种是8080的并口方式，另外一种是4线SPI方式。
1.8080并行接口方式
  E/ S& ]  a" P: x. s! R首先我们介绍一下模块的8080并行接口，8080并行接口的发明者是INTEL，该总线也被广泛应用于各类液晶显示器，ALIENTEK OLED模块也提供了这种接口，使得MCU可以快速的访问OLED。ALIENTEK OLED模块的8080接口方式需要如下一些信号线：
: [5 J8 h9 h/ xCS：OLED片选信号。
1 x* Y0 o6 c3 R4 zWR：向OLED写入数据。
- j9 ^; X& R2 f/ v3 _RD：从OLED读取数据。
7 ~! j; O, O$ j  A4 bD[7：0]：8位双向数据线。
+ X# E* U3 |. Q2 s8 c' KRST(RES)：硬复位OLED。
; b& n2 Z# Q1 W+ IDC：命令/数据标志（0，读写命令；1，读写数据）。
模块的8080并口读/写的过程为：先根据要写入/读取的数据的类型，设置DC为高（数据）/低（命令），然后拉低片选，选中SSD1306，接着我们根据是读数据，还是要写数据置RD/WR为低，然后：
在RD的上升沿， 使数据锁存到数据线（D[7：0]）上；
6 [0 J9 D3 C% H9 x- L9 |7 _: t在WR的上升沿，使数据写入到SSD1306里面；
SSD1306的8080并口写时序图如下图所示：



/ R. f* o" @2 b& _/ y) P图19.3.2. 3 8080并口写时序图
- }" G8 n; C. v+ Z7 J* e9 ~SSD1306的8080并口读时序图如下图所示：

" U# \& m" \2 l3 T2 i

图19.3.2. 48080并口读时序图
' j; C) X% Z& n& [: W  I$ `  vSSD1306的8080接口方式下，控制脚的信号状态所对应的功能如下表所示：
' i- z7 ^# B) ~0 @5 p
; p/ d' @* C7 U% {4 \6 w

8 r* j% m  B- ]( U1 k: G表19.3.2. 2控制脚信号状态功能表
, K2 `+ [: g9 ]1 }; A% |) h在8080方式下读数据操作的时候，我们有时候（例如读显存的时候）需要一个假读命（Dummy Read），以使得微控制器的操作频率和显存的操作频率相匹配。在读取真正的数据之前，由一个的假读的过程。这里的假读，其实就是第一个读到的字节丢弃不要，从第二个开始，才是我们真正要读的数据。
一个典型的读显存的时序图，如下图所示：
; C- M( ~8 E  Q
8 Y0 }9 x" |/ y. h6 l- W1 K

5 o; i7 Q0 D- p: K+ s- v图19.3.2. 5读显存时序图
可以看到，在发送了列地址之后，开始读数据，第一个是Dummy Read，也就是假读，我们从第二个开始，才算是真正有效的数据。
2. 4 线串行（SPI）方式
$ g- u/ n* u; \% j我们的代码同时兼容SPI方式的驱动，如果你使用的是这种驱动方式，则应该把代码中的宏OLED_MODE设置为：
$ W! F# \# H* J. Y% _#define OLED_MODE 0 /* 0: 4线串行模式 */
接下来介绍一下4线串行（SPI）方式，4线串口模式使用的信号线有如下几条：
CS：OLED片选信号。
RST(RES)：硬复位OLED。
5 d8 y) O4 u' X3 ~( Z8 k0 [DC：命令/数据标志（0，读写命令；1，读写数据）。
- p! |) s5 T: B' h- Z6 |6 ^' gSCLK：串行时钟线。在4线串行模式下，D0信号线作为串行时钟线SCLK。
SDIN：串行数据线。在4线串行模式下，D1信号线作为串行数据线SDIN。
* ]$ |, h. X+ N4 X) Q' T8 l1 _" N# e模块的D2需要悬空，其他引脚可以接到GND。在4线串行模式下，只能往模块写数据而不能读数据。
9 r  o3 ^: l7 k' Q$ M& @% q) w在4线SPI模式下，每个数据长度均为8位，在SCLK的上升沿，数据从SDIN移入到SSD1306，并且是高位在前的。DC线还是用作命令/数据的标志线。在4线SPI模式下，写操作的时序如下图所示：

5 [& Z7 U" t5 b5 D

图19.3.2. 6 4线SPI写操作时序图
4线串行模式就为大家介绍到这里。其他还有几种模式，在SSD1306的数据手册《SSD1306-Revision 1.1 (Charge Pump)》上都有详细的介绍，如果要使用这些方式，请大家参考该手册，手册位于“开发板光盘A-基础资料\6、硬件资料\1、芯片资料\【正点原子】0.96寸OLED模块12864资料”路径下。
7 ]/ F% v. Z% j8 F3. SSD1306的显存
接下来，我们介绍一下模块的显存，SSD1306的显存总共为128*64bit大小，SSD1306将这些显存分为了8页，其对应关系如下表所示：

# R# p) o6 d, `( G. Z7 B2 O' H3 M

* U0 j, z: }/ s3 k图19.3.2. 7 SSD1306显存与屏幕对应关系表
可以看出，SSD1306的每页包含了128个字节，总共8页，这样刚好是128*64的点阵大小。当GRAM的写入模式为页模式时，需要设置低字节起始的列地址（0x000x0F）和高字节的起始列地址（0x100x1F），芯片手册中给出了写入GRAM与显示的对应关系，写入列地址在写完一字节后自动按列增长，如下图所示：
" D2 `5 @, P# Y. `0 x3 Y, \
- P! u8 _( u1 a4 g$ F( F
0 z+ a8 H/ B" Z. u
图19.3.2. 8 GRAM与显示的对应关系
因为每次写入都是按字节写入的，这就存在一个问题，如果我们使用只写方式操作模块，那么，每次要写8个点，这样，我们在画点的时候，就必须把要设置的点所在的字节的每个位都搞清楚当前的状态（0/1？），否则写入的数据就会覆盖掉之前的状态，结果就是有些不需要显示的点，显示出来了，或者该显示的没有显示了。这个问题在能读的模式下，我们可以先读出来要写入的那个字节，得到当前状况，在修改了要改写的位之后再写进GRAM，这样就不会影响到之前的状况了。但是这样需要能读GRAM，对于4线SPI模式/IIC模式，模块是不支持读的，而且读改写的方式速度也比较慢。
6 u* u7 t) |& n. m3 b$ P所以我们采用的办法是在STM32MP157的内部建立一个虚拟的OLED的GRAM（共128*8=1024个字节），在每次修改的时候，只是修改STM32MP157上的GRAM（实际上就是SRAM），在修改完了之后，一次性把STM3MP157上的GRAM写入到OLED的GRAM。当然这个方法也有坏处，一个是对于那些SRAM很小的单片机（比如51系列）不太友好，另一个是每次都写入全屏，屏幕刷新率会变低。
4. SSD1306的命令
SSD1306的命令比较多，这里我们仅介绍几个比较常用的命令，这些命令如下表所示：
4 S& l" |* K" ^7 F! Z


1 d9 C* s8 U, L5 O: Q3 T8 D( l图19.3.2. 9 SSD1306常用命令表
. [1 M; w& D& p% Y, b& B1 g$ F) c8 t第一个命令为0X81，用于设置对比度的，这个命令包含了两个字节，第一个0X81为命令，随后发送的一个字节为要设置的对比度的值。这个值设置得越大屏幕就越亮。
4 f' r6 P: u& O4 M7 r, @第二个命令为0XAE/0XAF。0XAE为关闭显示命令；0XAF为开启显示命令。
& d5 M# f! M# V2 \# R/ k% T第三个命令为0X8D，该指令也包含2个字节，第一个为命令字，第二个为设置值，第二个字节的BIT2表示电荷泵的开关状态，该位为1，则开启电荷泵，为0则关闭。在模块初始化的时候，这个必须要开启，否则是看不到屏幕显示的。
第四个命令为0XB0~B7，该命令用于设置页地址，其低三位的值对应着GRAM的页地址。
第五个指令为0X00~0X0F，该指令用于设置显示时的起始列地址低四位。
第六个指令为0X10~0X1F，该指令用于设置显示时的起始列地址高四位。
/ S+ m: V" e! ]: P/ U( W! [其他命令，我们就不在这里一一介绍了，大家可以参考SSD1306 datasheet的第28页。从这页开始，对SSD1306的指令有详细的介绍。
, G. f# N5 s" o- G/ {5 F9 t5. OLED初始化过程
+ p, a9 K: C/ z1 y( K最后，我们再来介绍一下OLED模块的初始化过程，SSD1306的典型初始化框图如下图所示：

( {$ n9 e$ G* ^" S+ X# T! Q
3 J$ F6 t; H# M( S8 M
7 v& ]6 Q  u9 m( \图19.3.2. 10 SSD1306初始化框图
& B7 F- V& O* W0 I& U驱动IC的初始化代码，我们直接使用厂家推荐的设置就可以了，只要对细节部分进行一些修改，使其满足我们自己的要求即可，其他不需要变动。
& z. a4 F) {0 L( i- r6 @
19.4 OLED字符、数字显示实验
/ i+ G' ]: ^/ M# w, ^本实验配置好的实验工程已经放到了开发板光盘中，路径为：开发板光盘A-基础资料\1、程序源码\11、M4 CubeIDE裸机驱动例程\CubeIDE_project\ 12 OLED_DISPLAY。
前面我们重点向大家介绍了ALIENTEK OLED模块的相关知识，接下来我们将使用这个模块来显示字符和数字。通过以上介绍，我们可以得出OLED显示需要的相关设置步骤如下：
" D( Z  I7 a. V# x1）设置STM32MP157与OLED模块相连接的IO
这一步，先将我们与OLED模块相连的IO口设置为输出，具体使用哪些IO口，这里需要根据连接电路以及OLED模块所设置的通讯模式来确定。这些将在硬件设计部分向大家介绍。
* E$ [- z+ m2 a9 k  d( h7 _6 ~2）初始化OLED模块
其实这里就是上面的初始化框图的内容，通过对OLED相关寄存器的初始化，来启动OLED的显示。为后续显示字符和数字做准备。
3）通过函数将字符和数字显示到OLED模块上
$ @! K# V$ ?$ n! X* W) {4 j) j这里就是通过我们设计的程序，将要显示的字符送到OLED模块就可以了，这些函数将在软件设计部分向大家介绍。
6 p; d0 \6 x  d$ a通过以上三步，我们就可以使用ALIENTEK OLED模块来显示字符和数字了。
19.4.1 硬件设计
1.例程功能
使用8080并口模式驱动或者使用4线SPI串口模式，驱动OLED模块，不停的显示ASCII码和码值。LED0闪烁，提示程序运行。
! p4 i2 O- {2 m3 ~2 r2.硬件资源
! M( j# ?& t* S$ ?2 ^1）LED灯
LED0 - PI0
/ P  s. ~) [" |& }3 U8 O2）ALIENTEK 0.96寸OLED模块，在硬件上，OLED与开发板的IO口对应关系如下：
/ [- @9 B, b1 ^- w1 T  rOLED_RS（OLED 模块上的丝印是DC）对应12C5_SCL，即：PA11；
OLED模块上悬空/不接的引脚是DCMI_PIXCLK，即PA6；
2 b1 e1 ?9 g  g4 E+ r# n
: n- F4 Q  r/ v6 g" Q

表19.4.1. 1 IO口对应表
  G' {+ T: l: G" I注意，这里的OLED_D[7:0]因为不是接的连续的IO，所以后面的程序中得用拼凑的方式去组合一下，后续的程序部分会介绍到。
3. 原理图
OLED模块插在开发板底板的CAMERA接口上，接口的原理图如下，对应的IO口在前面已有详细说明了：
7 y! R8 Z" j* m3 z- G" \* d1 b

/ A8 M9 ?  m0 S5 l
3 L8 r0 ^  B+ H9 v1 V表19.4.1. 2 CAMERA接口部分原理图
" [4 i* h* ^) G/ ?( E下面我们介绍OLED模块与我们开发板的连接，开发板上有一个OLED/CAMERA的接口（P2接口）可以和ALIENTEK OLED模块直接对插（靠左插！），这些线的连接，开发板的内部已经连接好了，我们只需要将OLED模块插上去就好了，连接如下图所示：
* y7 p1 e  j( Z


  Z7 @% p# t+ S; G# @: D表19.4.1. 3 OLED模块连接示意图
* I! |' w# e' S  b6 L19.4.2 软件设计
OLED只是用到HAL库中GPIO外设的驱动代码，配置步骤在前面跑马灯实验已经介绍了。
1.程序流程图
: N: q+ d4 q. L) C& |+ c4 _# r) T下面看看本实验的程序流程图：


; Z7 H: d$ |/ t0 |/ W8 C( I
6 ?0 b# b! a8 \0 ]+ \图19.4.2. 1程序流程图
* M# `; r) `, G) N. m( K2. 新建工程和配置工程
) e7 c7 I9 d1 x/ {由于配置IO口和时钟的配置步骤在前面我们都已经详细讲解，这里就不再重复讲解之前的步骤了。
) E9 w3 z3 h3 L3 I; @3 ^新建一个工程OLED_DISPLAY，然后配置的IO口如下：
* e% M5 |9 u. e, s" h/ p# g+ d


' P0 O; B& h/ ~, h9 @图19.4.2. 2 IO口配置
  x. ]" I% V  T  E# q时钟的话，可以采用内部时钟或者外部时钟，我们就使用外部时钟HSE，配置AHB总线的时钟最大为104.5MHz。其它配置注意事项和前面跑马灯实验的一致，保存配置，然后生成工程，将上一章节实验的BSP文件夹拷贝到Src目录下，如下图所示：
5 T7 D/ S3 O5 p9 T7 Z


( z  ~& [5 |$ U  [图19.4.2. 3生成的工程
5 I3 p9 |  h! p) F" n然后，在BSP文件夹下新建oled.c文件，在BSP/Include文件夹下新建oled.h、oledfont.h文件
2 a% q2 C; M, Y5 r$ _: @3. 添加oledfont.h文件代码
oledfont.h文件用于存放ASICII字符集点阵数据，也就是将ASICII字符集取模后得到的数据，这里我们把 ASCII 字符集按字宽和字高为1212、1616和2424的大小取模出来。这里我们以按字宽和字高为1212为例子做讲解。设置字体为隶书，字宽和字高都为12，取模方式设置：阴码+逐列式+顺向+C51格式，最后将以下ASICII码字符拷贝到输入框，注意，第一个字符是空格，ASCII字符集: !"#$%&’()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~
% w9 V3 J; b9 C0 g2 p; V8 ^: q
5 n1 R2 M; b0 [. A* u
. x0 M7 ~  f& G% k$ |; @4 P
图19.4.2. 4设置取模方式
5 r9 Y+ v6 d( A% Z  f& N最后将数据保存在一个.tex文件中，得到的数据如下：
6 l, ~. h' @9 o9 T' d& B9 m5 m1 U

. t& }) i! ]4 V, ?* f: n
( q9 j3 [% r+ b) }* [5 o图19.4.2. 5取模得到的点阵数据
其它字宽和字高为1616和2424的数据生成也是同样的方法。oledfont.h文件的代码我们已经在本实验的工程中给出，大家可以直接使用。
4. 添加oled.h文件代码
oled.h文件代码如下：
, M1 c# o0 ?* m

1. 1   #ifndef __OLED_H
   
2. 2   #define __OLED_H
   1 r; c, x! i* w2 ^+ c9 g9 S: c+ O) P
3. 3  
   ( [( G2 O( d1 z3 |* Y9 d
4. 4   #include "stdlib.h"
   
5. 5   #include <stdint.h>
   $ A  x( J5 C! }$ ?2 E( v
6. 6   /* OLED模式设置
   
7. 7    * 0: 4线串行模式  （模块的BS1，BS2均接GND）
   
8. 8    * 1: 并行8080模式 （模块的BS1，BS2均接VCC）
   / a# E" c2 Q6 Z/ m
9. 9    */
   
10. 10  #define OLED_MODE       1   /* 默认使用8080并口模式 */
    
11. 11
    
12. 12  /*****************************************************************/
    
13. 13  /* OLED SPI模式引脚 定义 */
    
14. 14  /* 注意:这里仅定义了 OLED 4线SPI模式驱动时的引脚定义
    
15. 15                 8080并口模式引脚定义在gpio.c文件中已经包含了 */
    , `0 _# j2 C+ F% H8 H; K
16. 16  #define OLED_SPI_RST_PORT               GPIOE
    3 L4 q$ x5 D2 I9 o8 l2 n
17. 17  #define OLED_SPI_RST_PIN                GPIO_PIN_1
    + q. q( N! g5 f' Q) k! L& |
18. 18  /* PE口时钟使能 */
    
19. 19  #define OLED_SPI_RST_CLK_ENABLE() do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   
    
20. 20
    
21. 21  #define OLED_SPI_CS_PORT                GPIOB
    . j& C# h1 I+ \9 w% @) r; }
22. 22  #define OLED_SPI_CS_PIN                 GPIO_PIN_7
    ( }- T5 E% t2 N* {( c  O4 O+ i# T
23. 23  /* PB口时钟使能 */
    
24. 24  #define OLED_SPI_CS_CLK_ENABLE()  do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)   
    
25. 25
    
26. 26  #define OLED_SPI_RS_PORT                GPIOA
    
27. 27  #define OLED_SPI_RS_PIN                 GPIO_PIN_11
    
28. 28  /* PA口时钟使能 */
    
29. 29  #define OLED_SPI_RS_CLK_ENABLE()  do{ __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)   
    
30. 30
    
31. 31  #define OLED_SPI_SCLK_PORT              GPIOH
    + k. t5 u) g! g: K- f5 @
32. 32  #define OLED_SPI_SCLK_PIN               GPIO_PIN_9
    
33. 33  /* PH口时钟使能 */
    ! C5 ~* d. u9 l. P( P: D& M
34. 34  #define OLED_SPI_SCLK_CLK_ENABLE() do{ __HAL_RCC_GPIOH_CLK_ENABLE(); }while(0)   
      ?( g1 L1 x; S9 Y# j5 u0 P
35. 35
    ( S# x" z) Z9 x8 d8 }5 u
36. 36  #define OLED_SPI_SDIN_PORT              GPIOH
    
37. 37  #define OLED_SPI_SDIN_PIN               GPIO_PIN_10
    % U1 j1 b! I8 i; z
38. 38  /* PH口时钟使能 */
    
39. 39  #define OLED_SPI_SDIN_CLK_ENABLE() do{ __HAL_RCC_GPIOH_CLK_ENABLE(); }while(0)   
    ' t. c7 k0 w# U$ k# A
40. 40
      z9 i$ o& ]9 O+ q& l/ c
41. 41  /***************************************************************/
    
42. 42
      j# a! S! D3 J$ ~( B  o! ]+ G8 M
43. 43  /* OLED SPI模式相关端口控制函数 定义
    
44. 44   * 注意:OLED_RST/OLED_CS/OLED_RS,这三个是和80并口模式共用的,即80模式也必须
    $ ~. k8 R9 |+ C: |
45. 45   实现这3个函数!*/
    
46. 46  #define OLED_RST(x)   do{ x ? \
    
47. 47               HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_SET) : \
    * ]& X8 i2 p1 U2 g: b6 m- d+ [
48. 48               HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_RESET); \
    $ y' @+ F7 E- z9 h' ^. t% n% N
49. 49                        }while(0)       /* 设置RST引脚 */
    . G2 x6 b& k# G
50. 50
    
51. 51  #define OLED_CS(x)   do{ x ? \
    
52. 52                HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_SET) : \
    
53. 53                HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_RESET); \
    
54. 54                        }while(0)       /* 设置CS引脚 */
    
55. 55
    
56. 56  #define OLED_RS(x)   do{ x ? \
    , d; M+ V0 C  E6 q* u
57. 57                HAL_GPIO_WritePin(GPIOA, GPIO_PIN_11, GPIO_PIN_SET) : \
    % G- D. n1 g, S
58. 58                HAL_GPIO_WritePin(GPIOA, GPIO_PIN_11, GPIO_PIN_RESET); \
    
59. 59                        }while(0)       /* 设置RS引脚 */
    ) ~  E/ y- S1 l0 ]% x0 T, g( U5 D
60. 60  #define OLED_SCLK(x)   do{ x ? \
    
61. 61 HAL_GPIO_WritePin(OLED_SPI_SCLK_PORT, OLED_SPI_SCLK_PIN, GPIO_PIN_SET) : \
    4 d# ~, e- Y2 g6 j- L! c
62. 62 HAL_GPIO_WritePin(OLED_SPI_SCLK_PORT, OLED_SPI_SCLK_PIN, GPIO_PIN_RESET); \
    
63. 63                        }while(0)       /* 设置SCLK引脚 */
    6 i4 H8 ]5 U, n# `
64. 64
    - [" c6 A5 k: _) W- \1 l
65. 65  #define OLED_SDIN(x)   do{ x ? \
    + o, U6 E6 c% ^! G) k) Z
66. 66  HAL_GPIO_WritePin(OLED_SPI_SDIN_PORT, OLED_SPI_SDIN_PIN, GPIO_PIN_SET) : \
    / A: ?3 X; {# J2 ^) j! x) r
67. 67  HAL_GPIO_WritePin(OLED_SPI_SDIN_PORT, OLED_SPI_SDIN_PIN, GPIO_PIN_RESET); \
    6 U2 U& F4 E2 e  A; `
68. 68                        }while(0)       /* 设置SDIN引脚 */
    * k4 _) V& \5 L1 o8 t- e
69. 69
    0 `( Q- Y& G+ W- o( b% [
70. 70  /* OLED 80并口模式WR,RD端口控制函数 定义 */
    
71. 71  #define OLED_WR(x)   do{ x ? \
    8 V/ O: Y6 m* v3 b$ @/ c
72. 72      HAL_GPIO_WritePin(GPIOH, GPIO_PIN_8, GPIO_PIN_SET) : \
    
73. 73      HAL_GPIO_WritePin(GPIOH, GPIO_PIN_8, GPIO_PIN_RESET); \
    
74. 74                        }while(0)       /* 设置WR引脚 */
    : Q& j/ W  f% _- G  {
75. 75
    / T' f4 P0 A* Q1 ^
76. 76  #define OLED_RD(x)   do{ x ? \
    
77. 77      HAL_GPIO_WritePin(GPIOA, GPIO_PIN_12, GPIO_PIN_SET) : \
    
78. 78      HAL_GPIO_WritePin(GPIOA, GPIO_PIN_12, GPIO_PIN_RESET); \
    
79. 79                        }while(0)       /* 设置RD引脚 */
    
80. 80
    4 a  ~* o6 _* x# G+ U1 M- r8 P# ~8 @
81. 81  /* 命令/数据 定义 */
    $ F2 y5 r) O* c! u4 A! b0 Y
82. 82  #define OLED_CMD        0       /* 写命令 */
    
83. 83  #define OLED_DATA       1       /* 写数据 */
    
84. 84
    
85. 85  /****************************************************************/
    
86. 86
    
87. 87   void oled_wr_byte(uint8_t data, uint8_t cmd);    /* 写一个字节到OLED */
    ( O4 z. s6 p6 X8 C
88. 88   uint32_t oled_pow(uint8_t m, uint8_t n);         /* OLED求平方函数 */
    
89. 89
    
90. 90
      \7 W0 E! f6 ~8 i% q' h3 `
91. 91  void oled_init(void);           /* OLED初始化 */
    % b, \. C7 ~( @4 \1 c
92. 92  void oled_clear(void);          /* OLED清屏 */
    
93. 93  void oled_display_on(void);     /* 开启OLED显示 */
    * M8 Q) D% S2 _0 l  k/ Q4 [
94. 94  void oled_display_off(void);    /* 关闭OLED显示 */
    , s5 ~' n( x6 q/ A* n: i
95. 95  void oled_refresh_gram(void);   /* 更新显存到OLED */
    
96. 96   /* OLED画点 */
    * Q' H$ }9 W, X1 s; F
97. 97  void oled_draw_point(uint8_t x, uint8_t y, uint8_t dot);   
    % `" k6 U( W7 C# q
98. 98  /* OLED区域填充 */
    3 f5 l# M$ ~2 Z. Y
99. 99  void oled_fill(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t dot);  
    $ W, m5 L2 n! k1 L8 D' R
100. 100 /* OLED显示字符 */
     
101. 101 void oled_show_char(uint8_t x, uint8_t y, uint8_t chr, uint8_t size, uint8_t mode);
     
102. 102 /* OLED显示数字 */
     
103. 103 void oled_show_num(uint8_t x, uint8_t y, uint32_t num, uint8_t len, uint8_t size);  
     
104. 104 /* OLED显示字符串 */
     " n; D. T6 i! B* T3 G
105. 105 void oled_show_string(uint8_t x, uint8_t y, const char *p, uint8_t size);           

复制代码

第16~39行，为了和8080并口方式区别开来，重新定义了SPI模式的引脚；
第46~68行，SPI模式相关端口控制函数的定义；
第46~79行，8080并口模式相关端口控制函数定义；
第82~83，写命令和写数据宏定义；
: |5 I8 n+ {  T6 P6 i0 W# c第87~105行，一些函数的声明。
gpio.c文件中数前面我们配置的各个IO的初始化代码，8080口相关的初始化代码已经在gpio.c文件中完成了，以上为了和8080口的代码区别开来，所以重新定义了一组代码。

5.添加oled.c文件代码
下面我们来重点分析oled.c文件的代码，此文件中有很多函数，我们选择分析几个重要的函数。所有函数的代码清查看工程文件中的oled.c文件。
  v8 q2 Z+ @4 D（1）oled_init初始化函数

1. 1   /**
   " a& O- B9 y+ s5 {) B
2. 2    * @brief       初始化OLED(SSD1306)
   
3. 3    * @param       无
   
4. 4    * @retval      无
   3 o' B7 D: J9 C2 s$ A. g3 t7 H: _
5. 5    */
   3 S3 |' Q/ Q+ F  A9 Z0 s
6. 6   void oled_init(void)
   0 Z5 Q  }, f6 _3 \: A4 b. k1 W: v
7. 7   {
   1 |" }' c, }" X( i/ E
8. 8   #if OLED_MODE==1         /* 使用8080并口模式 */
     Y" _! K; m, c, }( ^' T/ k, [+ W
9. 9       OLED_WR(1);
   
10. 10      OLED_RD(1);
    
11. 11  #else
    * }3 P% I: P) V. j+ j' H! R7 _
12. 12      OLED_SDIN(1);
    0 e- }! P8 o  h4 I. ]' s
13. 13      OLED_SCLK(1);
    2 Y% ~& ?: ?1 R9 ^
14. 14  #endif
    : l$ A' y& v( b, `: c% }
15. 15
    / u. w: M, r) Y
16. 16      OLED_CS(1);
    
17. 17      OLED_RS(1);
    
18. 18
    ) o5 h; O$ g2 r7 p& {2 x
19. 19      OLED_RST(0);
    
20. 20      HAL_Delay(100);
    
21. 21      OLED_RST(1);
    
22. 22
    
23. 23      oled_wr_byte(0xAE, OLED_CMD);   /* 关闭显示 */
    
24. 24      oled_wr_byte(0xD5, OLED_CMD);   /* 设置时钟分频因子,震荡频率 */
    
25. 25      oled_wr_byte(80, OLED_CMD);     /* [3:0],分频因子;[7:4],震荡频率 */
    ) U. p9 v$ _- x* D& k+ E+ \; B: W
26. 26      oled_wr_byte(0xA8, OLED_CMD);   /* 设置驱动路数 */
    
27. 27      oled_wr_byte(0X3F, OLED_CMD);   /* 默认0X3F(1/64) */
    
28. 28      oled_wr_byte(0xD3, OLED_CMD);   /* 设置显示偏移 */
    ! q% p  N+ A9 c2 ?  T$ I: ^
29. 29      oled_wr_byte(0X00, OLED_CMD);   /* 默认为0 */
    
30. 30
    
31. 31      oled_wr_byte(0x40, OLED_CMD);   /* 设置显示开始行 [5:0],行数. */
    % h. h  `) W5 o
32. 32
    
33. 33      oled_wr_byte(0x8D, OLED_CMD);   /* 电荷泵设置 */
    2 p- t$ n8 l% ^* t% g7 x' ?
34. 34      oled_wr_byte(0x14, OLED_CMD);   /* bit2，开启/关闭 */
    2 o& @/ {4 g' K% s/ j
35. 35      oled_wr_byte(0x20, OLED_CMD);   /* 设置内存地址模式 */
    
36. 36      /* [1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10; */
    1 x/ H- Z  q; e; K; ]
37. 37      oled_wr_byte(0x02, OLED_CMD);  
    ' V: e5 t# d$ z: k+ j
38. 38      /* 段重定义设置,bit0:0,0->0;1,0->127; */      
    8 r1 o& M& l: T
39. 39      oled_wr_byte(0xA1, OLED_CMD);   
    
40. 40      /* 设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数 */
    ! s4 X$ T, C, a9 n) U  z
41. 41      oled_wr_byte(0xC0, OLED_CMD);   
    
42. 42      oled_wr_byte(0xDA, OLED_CMD);   /* 设置COM硬件引脚配置 */
    
43. 43      oled_wr_byte(0x12, OLED_CMD);   /* [5:4]配置 */
    # ?: w3 f' o( \  @1 |, c  w) _8 I6 d
44. 44
    
45. 45      oled_wr_byte(0x81, OLED_CMD);   /* 对比度设置 */
    
46. 46      oled_wr_byte(0xEF, OLED_CMD); /* 1~255;默认0X7F (亮度设置,越大越亮) */
    5 `9 K# q; q: N) {  u
47. 47      oled_wr_byte(0xD9, OLED_CMD);   /* 设置预充电周期 */
    ! s: O$ q; O. v6 c
48. 48      oled_wr_byte(0xf1, OLED_CMD);   /* [3:0],PHASE 1;[7:4],PHASE 2; */
    
49. 49      oled_wr_byte(0xDB, OLED_CMD);   /* 设置VCOMH 电压倍率 */
    9 i! _2 x! `& Z2 j4 R
50. 50       /* [6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc; */
    ! f+ o0 H  m6 w$ q
51. 51      oled_wr_byte(0x30, OLED_CMD);  
    & K+ m7 z5 L6 ?) L, M/ h0 c
52. 52       /* 全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏) */
    + n5 F8 `. P9 \: D7 X
53. 53      oled_wr_byte(0xA4, OLED_CMD);  
    5 ~! v* w1 N8 \+ i
54. 54      /* 设置显示方式;bit0:1,反相显示;0,正常显示 */
    7 N/ N4 ?/ U, ^0 ^/ W' p7 d
55. 55      oled_wr_byte(0xA6, OLED_CMD);   
    
56. 56      oled_wr_byte(0xAF, OLED_CMD);   /* 开启显示 */
    
57. 57      oled_clear();
    ' e+ T3 `* t, y( H$ g8 w
58. 58  }

复制代码

该函数的结构比较简单，开始是对GPIO口的初始化，这里我们用了宏定义OLED_MODE来决定要设置的IO口，后面的就是一些初始化序列了，我们按照厂家提供的资料来做就可以。值得注意一点的是，因为OLED是无背光的，在初始化之后，我们把显存都清空了，所以我们在屏幕上是看不到任何内容的，就像没通电一样，不要以为这就是初始化失败，要写入数据模块才会显示的。
) t& i1 ^2 ^/ z8 y& H" n2 q3 M6 A（2）oled_data_out函数
4 P) z  y# P5 {9 Noled_data_out函数是通过拼凑的方法向OLED输出一个8位数据。因为数据引脚使用到的IO口并不是连续的IO口，一个8位的数据要通过这8个不连续的IO口发送出去的话，我们使用拼凑的方式，即：
对于8080并口方式：
- D- h& b. t4 y6 c0 F


表19.4.2. 18位数据线接口方式
% [, F3 c0 J! I9 L& q+ `对于4线SPI串口方式，D0信号线作为串行时钟线SCLK，D1信号线作为串行数据线SDIN，数据通过D1一位一位地发送出去。
* @0 t! V1 t* p4 N6 ^
! p! W1 F* Q7 H0 p. Y8 L% J

1. 1   #if OLED_MODE == 1    /* 使用8080并口驱动OLED */
   ( n. n: y; i5 l9 @- a* h
2. 2   /**
   
3. 3    * @brief       通过拼凑的方法向OLED输出一个8位数据
   . |; a4 G4 v/ _+ m) ]6 n5 x) U
4. 4    * @param       data: 要输出的数据
   
5. 5    * @retval      无
   
6. 6    */
   , O" N  P& S4 ^
7. 7   static void oled_data_out(uint8_t data)
   ; h  |5 q! r+ M. U$ G
8. 8   {
   3 E& P5 f# Z9 U% o! F- i* R) |
9. 9       uint16_t dat = data & 0X0F;
   
10. 10
    
11. 11      GPIOH->ODR &= ~(0XF << 9);       /* 清空PH的第12~9位 */
    # c" h; o" [7 l
12. 12      GPIOH->ODR |= dat << 9;          /* 将D[3:0]分配给PH[12:9] */
    
13. 13
    
14. 14      GPIOH->ODR &= ~(0X1 << 14);                                     /* 清空PH的第14位 */
    
15. 15      GPIOH->ODR |= ((data >> 4) & 0x01) << 14;        /* 将D4给PH14 */
    - p7 o8 q4 b4 S( e' @7 V4 E% \
16. 16
    3 [- B  L- O. k9 O/ Z$ U& k8 X6 R
17. 17      GPIOI->ODR &= ~(0X1 << 4);                                      /* 清空PI4 */
    
18. 18      GPIOI->ODR |= ((data >> 5) & 0x01) << 4;        /* 将D5给PI4 */
    
19. 19
    + G' k/ ~5 U' k1 L1 ?" }
20. 20      GPIOB->ODR &= ~(0X1 << 8);                 /* 清空PB8 */
    
21. 21      GPIOB->ODR |= ((data >> 6) & 0x01) << 8;/* 将D6给PB8 */
    / m7 ^5 m  S1 Q
22. 22
    
23. 23      GPIOE->ODR &= ~(0X1 << 6);                                      /* 清空PE6 */
    
24. 24      GPIOE->ODR |= ((data >> 7) & 0x01) << 6;        /* 将D7给PE6 */
    2 R$ n! w9 Y0 ?& B4 ]$ y
25. 25  }
    
26. 26  /**
    
27. 27   * @brief       向OLED写入一个字节（使用8080并口方式）
    + e% _# T" P- }& C: z
28. 28   * @param       data: 要输出的数据
    
29. 29   * @param       cmd: 数据/命令标志 0,表示命令;1,表示数据;
    
30. 30   * @retval      无
    4 H5 c5 x/ g; I6 X/ r9 R0 {- |$ j
31. 31   */
    2 P7 ~/ M" u6 C4 O7 |1 C& t
32. 32   void oled_wr_byte(uint8_t data, uint8_t cmd)
    
33. 33  {
    
34. 34      oled_data_out(data);                 /* 向OLED输出一个8位字节 */
    
35. 35      OLED_RS(cmd);                                 /* cmd为0,表示命令;cmd为1,表示数据 */
      \) N3 w4 {! Q" U; d' v6 N: `
36. 36      OLED_CS(0);                                /* 片选引脚拉低，选中SSD1306 */
    
37. 37      OLED_WR(0);                                /* WR先拉低 */
    
38. 38      OLED_WR(1);/* WR再拉高，变成上升沿了，使字节写入到数据线D[7：0]上 */
    
39. 39      OLED_CS(1);                                /* 片选引脚拉高，关闭片选 */
    
40. 40      OLED_RS(1);                                /* 即DC设置为1,DC电平恢复至初始态 */
    
41. 41  }
    
42. 42  #else   /* 使用SPI驱动OLED */
    
43. 43  /**
    / ?, \6 k2 ~8 f0 r8 X/ J. I! ]
44. 44   * @brief       向OLED写入一个字节
    
45. 45   * @param       data: 要输出的数据
    + Y) L. J$ G& j  z' E/ A1 r3 c
46. 46   * @param       cmd: 数据/命令标志 0,表示命令;1,表示数据;
    8 C: K' ]. d/ m* ^2 U
47. 47   * @retval      无
    
48. 48   */
    & U5 I; C6 W/ I
49. 49  static void oled_wr_byte(uint8_t data, uint8_t cmd)
    5 m$ e& x' Z7 u; o$ w
50. 50  {
    6 b9 J" P- F- j- h- b
51. 51      uint8_t i;
    . P3 P  E* @1 e% O, S& `- M
52. 52      OLED_RS(cmd);                                 /* cmd为0,表示命令;cmd为1,表示数据 */
    2 N5 ?" H$ Y9 S/ H( s8 f
53. 53      OLED_CS(0);                                  /* 片选引脚拉低，选中SSD1306 */
    
54. 54
    
55. 55      for (i = 0; i < 8; i++) /* SPI是串行，一位一位地传输 */
    5 p) i1 p  E6 @$ l
56. 56      {
    4 j/ B8 w' d% Z' B: o, W9 O
57. 57          OLED_SCLK(0);                                /* SCLK为低电平，低电平开始采样数据 */
    
58. 58
    
59. 59          if (data & 0x80)                         /* 高位在前 */
    
60. 60          {
    $ y$ J1 Q3 k& L' h% t5 j
61. 61              OLED_SDIN(1);                        /* 写1 */
    
62. 62          }
    3 e9 b7 X! O. a' S: E' g
63. 63          else
    
64. 64          {
    5 \9 U8 z8 P) s) h- Y3 j
65. 65              OLED_SDIN(0);                        /* 写0 */
    ( v' S- E1 ]$ z6 [
66. 66          }
    6 M5 ]0 B  B% A! @( y! K1 t6 y+ B
67. 67          OLED_SCLK(1);                                /* SCLK为高电平 */
    
68. 68          data <<= 1;                                /* 左移 */
    
69. 69      }
    
70. 70
    ; {2 ~8 @# m) g3 B6 q% V2 J
71. 71      OLED_CS(1);                                        /* 关闭片选 */
    
72. 72      OLED_RS(1);                                         /* DC电平恢复至初始态 */
    4 N6 g- z4 a) N  Z
73. 73  }
    0 ?/ ^$ d3 D* x! a3 o: F9 k
74. 74  #endif

复制代码

" Y4 w2 w- H1 C# r- r: M* G' r（3）oled_wr_byte函数
oled_wr_byte函数的代码我们已经在上面列出了，通过此函数向OLED写入一个字节。8080并口方式和SPI方式接线不同，通信方式也会不同，所以这部分分为两种情况，如果使用SPI方式，只需要将宏OLED_MODE定义为0即可。此函数的代码是根据前文讲解的通信时序图编写的代码。我们来分析这段代码。
7 W! i" y9 I( N: y% l对于8080并口方式：
第34行，向OLED输出一个8位字节；
第35行，OLED_RS(cmd)中的cmd可选1或0，选1表示对数据进行操作，选0表示对命令进行操作；
第36行，片选引脚拉低，选中OLED芯片SSD1306；
第37和38行，先将WR拉低再拉高，这样就变成一个上升沿了，前面我们分析过，将数据写入SSD1306时，WR引脚的信号状态处于是上升沿：
功能 RD WR CS DC
写命令 H ↑ L L
7 G6 d/ @+ Y) p# X4 B$ O读状态 ↑ H L L
+ C( O$ c! ]  D, H& _写数据 H ↑ L H
! P* @2 M/ E2 |0 N- I, l3 U% D( P& X读数据 ↑ H L H
表19.4.2. 2功能引脚的状态
第39行，将片选拉高，关闭片选引脚；
第40行，设置DC引脚为高电平，回复为初始态。初始态下DC是高电平。
对于4线SPI方式：
第53行，将片选拉低，选中OLED芯片；
第55~69行，SPI通信方式是一位一位地进行传输，所以分8次传输。SPI通信是在SCLK未低电平的时候采样数据，为高电平的时候停止采样；
第71和72行，关闭片选，并将DC恢复至初始状态。
  d* \0 z0 X5 `% g4 p1 {- q) o（4）oled_refresh_gram和oled_clear函数
1 l; U5 s6 q4 t6 M3 V! ~oled_refresh_gram函数是把我们在程序中定义的二维数组g_oled_gram的值一次性刷新到OLED的显存GRAM中，该数组值与OLED显存GRAM值一一对应。在操作的时候我们只需要先修改该数组的值，然后再通过调用oled_refresh_gram函数把数组的值一次性刷新到OLED 的GRAM上即可。
oled_clear函数是清屏函数，g_oled_gram[n]的值为0x00，即屏幕的像素点是黑的，没有点亮。
7 d: M* |) q/ T+ ?: Z" l

1. 1   /*
   
2. 2    * OLED的显存
   , M( Q# W+ m( W
3. 3    * 每个字节表示8个像素, 128,表示有128列, 8表示有64行, 高位表示第行数.
   ) S- ~- r: j+ [) U; \
4. 4    * 比如:g_oled_gram[0][0],包含了第一列,第1~8行的数据.
   / j( P2 U; }- G, ^
5. 5    * g_oled_gram[0][0].7,即表示坐标(0,0)
   
6. 6    * 类似的: g_oled_gram[1][0].6,表示坐标(1,1), g_oled_gram[10][1].5,
   1 w& p' K7 H' s% F2 w' l
7. 7    * 表示坐标(10,10),
   
8. 8    *
   % D/ ~3 ^9 r( V. O
9. 9    * 存放格式如下(高位表示低行数).
   
10. 10   * [0]0 1 2 3 ... 127
    ; A! v+ @# ^4 `
11. 11   * [1]0 1 2 3 ... 127
    
12. 12   * [2]0 1 2 3 ... 127
    
13. 13   * [3]0 1 2 3 ... 127
    1 T' e8 f( V$ u& y
14. 14   * [4]0 1 2 3 ... 127
    ' n% C; n" F. @' s7 d3 b& W
15. 15   * [5]0 1 2 3 ... 127
    - D9 n) P" k* |& Q$ J3 \6 {
16. 16   * [6]0 1 2 3 ... 127
    
17. 17   * [7]0 1 2 3 ... 127
    4 T1 ^4 u( W' g% \# o( T) J! D
18. 18   */
    
19. 19  static uint8_t g_oled_gram[128][8];
    
20. 20
    
21. 21  /**
    
22. 22   * @brief       更新显存到OLED
    
23. 23   * @param       无
    
24. 24   * @retval      无
    
25. 25   */
    0 o0 Z$ P, x( g' n# X1 h. U
26. 26  void oled_refresh_gram(void)
    ' b; R: Q. z2 c- n0 l, C
27. 27  {
    
28. 28      uint8_t i, n;
    , ~  E# U" O) {* a5 ^  |# C
29. 29
    
30. 30      for (i = 0; i < 8; i++)
    7 N$ d9 r' |. s6 |
31. 31      {
    $ g4 b7 Z+ V( y0 X$ I! q& {: M
32. 32          oled_wr_byte (0xb0 + i, OLED_CMD); /* 设置页地址（0~7） */
    
33. 33          oled_wr_byte (0x00, OLED_CMD);     /* 设置显示位置—列低地址 */
    0 ^4 n) ?6 M3 k& J
34. 34          oled_wr_byte (0x10, OLED_CMD);     /* 设置显示位置—列高地址 */
    7 z5 I  V9 g, u3 U
35. 35
    
36. 36          for (n = 0; n < 128; n++)
    # G: r0 n; G, W* Q' z9 `4 A6 `
37. 37          {
    
38. 38              oled_wr_byte(g_oled_gram[n], OLED_DATA);
    ( M1 J3 ~& O: [9 V# b. U! c
39. 39          }
    * U  O! k" M5 h9 V
40. 40      }
    
41. 41  }
    . G) w6 |5 b. q3 Z6 e. \, H$ u
42. 42        /**
    
43. 43 * @brief       清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!
    
44. 44 * @param       无
    1 I! d4 |, [) U
45. 45 * @retval      无
    * T4 X3 L. a' y4 D
46. 46 */
    ( O5 B. y0 J& t5 t
47. 47        void oled_clear(void)
    
48. 48        {
    
49. 49    uint8_t i, n;
    9 s  p7 T" n# I- U
50. 50
    
51. 51 for (i = 0; i < 8; i++)for (n = 0; n < 128; n++)g_oled_gram[n] = 0X00;
    # X) ~7 T1 G* a# w- i- K7 j1 i
52. 52
    
53. 53    oled_refresh_gram();    /* 更新显示 */
    
54. 54        }

复制代码

g_oled_gram [128][8]二维数组中的128代表列数（x坐标），而8代表的是页，每页又包含8行，总共64行（y坐标），从高到低对应行数从小到大，如下图所示：

1 i6 z- s6 W  h/ x+ n4 w
2 }4 i# d" t# V! t& A
' S% W- [& J+ D* X图19.4.2. 6 OLED_GRAM和OLED屏坐标对应关系
上表中G代表OLED_GRAM，G[0][0]就表示OLED_GRAM[0][0]。比如，我们要在x=3，y=9这个点写入1，则可以用这个句子实现：
* l4 U$ N* k  S6 JOLED_GRAM[3][1]|=1<<6；
* O1 K2 c; x3 ^8 ^) Q3 i8 H' L1 F" Q一个通用的在点（x，y）置1表达式为：
OLED_GRAM[x][7-y/8]|=1<<(7-y%8)；
& E- {. j( q3 S1 k7 `( P, M1 G' r其中x的范围为：0127；y的范围为：063。
2 O5 O6 A6 B) N! N3 R4 @（5）oled_draw_point画点函数
下面我们介绍重要的画点函数，函数代码如下：

1. 1   /**
   5 N2 W: p. j5 K+ n
2. 2    * @brief       OLED画点
   * o2 d: X1 o) H- K# o
3. 3    * @param       x  : 0~127
   % V3 {: d: @0 s1 t* a$ ]4 ?' i
4. 4    * @param       y  : 0~63
   " y5 ?& d' P" q) h
5. 5    * @param       dot: 1 填充 0,清空
   
6. 6    * @retval      无
   
7. 7    */
   
8. 8   void oled_draw_point(uint8_t x, uint8_t y, uint8_t dot)
   
9. 9   {
   ; [0 U* ]! [4 i7 k- \! j# V- g
10. 10      uint8_t pos, bx, temp = 0;
    8 N5 ^# B& C# ~" r+ }/ j" N
11. 11
    ( ]( l* V) F* ]5 W2 o
12. 12      if (x > 127 || y > 63) return;  /* 超出范围了. */
    
13. 13
    
14. 14    pos = 7 - y / 8;/* 计算GRAM里面的y坐标所在的字节, 每个字节可以存储8个行坐标 */
    
15. 15
    4 d6 w$ B' g. [7 q& r+ r! X* w
16. 16   bx = y % 8; /* 取余数,方便计算y在对应字节里面的位置,及行(y)位置 */
    
17. 17    temp = 1 << (7 - bx);   /* 高位表示低行号, 得到y对应的bit位置,将该bit先置1 */
    & O. f1 m3 Q) k' u2 [
18. 18
    - e( [2 t/ q) m* @: R2 h
19. 19      if (dot)    /* 画实心点 */
    7 q2 P9 C) n+ z$ {! a5 \, n
20. 20      {
    4 Y" o8 d* A; n$ Q' \7 r% }
21. 21          g_oled_gram[x][pos] |= temp;
    
22. 22      }
    
23. 23      else        /* 画空点,即不显示 */
    , Y6 o4 k9 `( s
24. 24      {
    ; T9 ~2 v& h- I( c/ n, D8 H; b
25. 25          g_oled_gram[x][pos] &= ~temp;
    
26. 26      }
    
27. 27  }

复制代码

该函数有3个形参，前两个是横纵坐标，第三个dot为要写入1还是0。该函数实现了我们在OLED模块上任意位置画点的功能。
第12行，OLED屏幕的分辨率是128*64，x和y的坐标从0开始，x最大为127，y最大为63，如果超出范围，则屏幕上无法显示；
第14行，pos代表的是第几页，这行代码是为了确定页数。我们面对屏幕，由屏幕从上往下看，最上是第7页，最下是第0页；
第16行，bx = y % 8是为了确定移位的个数；
第17行，temp是表示该页的哪一列；
' D! i2 x# W6 U/ z, u0 S' i  S1 T如下图是本实验程序中硬件的页排序和程序中的页分布关系：


9 G/ W4 f! o$ k; U( G  ~0 a* h9 |
表19.4.2. 3硬件的页排序示意图
0 U- |7 J4 H( J, u5 Z上图是屏幕硬件上GRAM里页的排布的关系，下图是程序中的页排布关系，正因为这种关系，所以以上的画点程序作了特殊处理。
3 U* B* E/ X: {% ^0 D


图19.4.2. 7 程序中的页排布示意图
2 E7 t5 R6 q4 O' u( P; M8 k0 r（6）OLED显示字符、数字函数
! r, m0 x" P+ [$ _7 M
' u5 e2 S4 ?7 t! R( d& i( s& H

1. 1   /**
   
2. 2    * @brief       在指定位置显示一个字符,包括部分字符
   + Y7 G4 ?! g, o  O1 a# u1 D- p
3. 3    * @param       x   : 0~127
   
4. 4    * @param       y   : 0~63
   
5. 5    * @param       size: 选择字体 12/16/24
   
6. 6    * @param       mode: 0,反白显示;1,正常显示
   ' R8 Y& p% d: }4 |* {- j
7. 7    * @retval      无
   
8. 8    */
   
9. 9   void oled_show_char(uint8_t x, uint8_t y, uint8_t chr, uint8_t size, uint8_t mode)
   
10. 10  {
    
11. 11      uint8_t temp, t, t1;
    5 `9 l8 z3 X6 A6 p
12. 12      uint8_t y0 = y;
    ) L" M4 g) W& k( T- Q% b, N1 ]
13. 13      uint8_t *pfont = 0;
    
14. 14      /* 得到字体一个字符对应点阵集所占的字节数 */
    
15. 15      uint8_t csize = (size / 8 + ((size % 8) ? 1 : 0)) * (size / 2);
    5 @8 t0 _: G4 X2 }
16. 16      chr = chr - ' ';/* 得到偏移后的值,因为字库是从空格开始存储的,第一个字符是空格 */
    
17. 17
    - d7 D9 d5 b% R8 E
18. 18      if (size == 12)         /* 调用1206字体 */
    + k% \: q& h$ z" q9 a6 O; ]" u
19. 19      {
    
20. 20          pfont = (uint8_t *)oled_asc2_1206[chr];
    
21. 21      }
    & M8 f" w2 K) @
22. 22      else if (size == 16)    /* 调用1608字体 */
    
23. 23      {
    7 p7 w9 N2 s2 f5 q
24. 24          pfont = (uint8_t *)oled_asc2_1608[chr];
    
25. 25      }
    3 J* K# U& \3 E5 e: R( N- f
26. 26      else if (size == 24)    /* 调用2412字体 */
    
27. 27      {
    3 g& G" r& I6 O' K, Y; r
28. 28          pfont = (uint8_t *)oled_asc2_2412[chr];
    * @9 B6 G/ S6 f( S5 y8 m
29. 29      }
    
30. 30      else                    /* 没有的字库 */
    
31. 31      {
    
32. 32          return;
    
33. 33      }
    
34. 34
      l: Z7 _, c* q
35. 35      for (t = 0; t < csize; t++)
    
36. 36      {
    
37. 37          temp = pfont[t];
    ( a2 o& Y4 V( ?3 c
38. 38          for (t1 = 0; t1 < 8; t1++)
    
39. 39          {
    
40. 40              if (temp & 0x80)oled_draw_point(x, y, mode);
    
41. 41              else oled_draw_point(x, y, !mode);
    ; V2 P9 X( N; b
42. 42
      O$ N' A; N: F, S7 w5 P
43. 43              temp <<= 1;
    4 R& X4 X' i# }. g' J
44. 44              y++;
    , Q. v7 P1 G0 m4 Y) X2 B
45. 45
    
46. 46              if ((y - y0) == size)
    
47. 47              {
    
48. 48                  y = y0;
    
49. 49                  x++;
    
50. 50                  break;
    . u8 D) E* }! b
51. 51              }
    # Q2 F; o7 Y; ?7 [" {( a9 ^5 [
52. 52          }
    
53. 53      }
    
54. 54  }

复制代码

oled_show_char函数为字符以及字符串显示的核心部分，函数中chr = chr - ’ ';这句是要得到在字符点阵数据里面的实际地址，因为我们的取模是从空格键开始的，例如oled_asc2_1206 [0][0]，代表的是空格符开始的点阵码。在接下来的代码，我们也是按照从上到小(先y++)，从左到右（再x++）的取模方式来编写的，先得到最高位，然后判断是写1还是0，画点；接着读第二位，如此循环，直到一个字符的点阵全部取完为止。这其中涉及到列地址和行地址的自增，根据取模方式来理解，就不难了。
oled.c的内容比较多，其他的函数请大家自行理解，这里就不一一介绍了。下面开始main.c文件的介绍。
& ~& q/ G; ?9 V* ^8 [3 [  \6. 修改main.c文件
( x1 l% `- t; T3 M  wmain.c文件代码如下：
' O" m, _* _* I+ v3 @
: z, o! ?+ }: Z7 Y, X

1. #include "main.h"
   
2. #include "gpio.h"
   ) Q: C# i0 e' c! }: p
3. #include "gpio.h"
   6 E! x( \" I! \8 I5 b) u. [
4. #include "./BSP/Include/led.h"
   4 X- D& S* R. \( x: E5 _1 r- {
5. #include "./BSP/Include/oled.h"
   
6. void SystemClock_Config(void);
   # n( S; P) E8 ?- a. i; Z% @
7. 
   
8. int main(void)
   
9. {
   - W- M! L. g$ [. [* W- M
10.     uint8_t t = 0;
    . [6 Q3 l; W6 i4 o
11.     sys_cache_enable();                     /* 打开L1-Cache */
    
12.     HAL_Init();                               /* 初始化HAL库 */
    
13.     sys_stm32_clock_init(240, 2, 2, 4);  /* 设置时钟, 480Mhz */
    % z8 n! l( C9 p: W
14.     delay_init(480);                         /* 延时初始化 */
    : v5 o# Y. R2 J
15.     usart_init(115200);                     /* 串口初始化为115200 */
    6 u' h& N- E  R3 a
16.     led_init();                               /* 初始化LED */
    * h! ~  d3 d- a, I. v8 s6 T: ]
17.     oled_init();                              /* 初始化OLED */
    
18.     oled_show_string(0, 0, "ALIENTEK", 24);
    
19.     oled_show_string(0, 24, "0.96' OLED TEST", 16);
    
20.     oled_show_string(0, 40, "ATOM 2020/3/22", 12);
    
21.     oled_show_string(0, 52, "ASCII:", 12);
    $ e0 K* w, F5 U1 g9 R
22.     oled_show_string(64, 52, "CODE:", 12);
    , b+ F, y0 E7 F* C9 T
23.     oled_refresh_gram();    /* 更新显示到OLED */
    
24. 
    ; n, k9 D8 ~4 U( }; N$ m/ l
25.     t = ' ';
    
26.     while (1)
    
27.     {
    + d4 ], H: O# q6 V* |* o4 j0 d+ v
28.         oled_show_char(36, 52, t, 12, 1);/* 显示ASCII字符 */
    
29.         oled_show_num(94, 52, t, 3, 12); /*显示ASCII字符的码值 */
    
30.         oled_refresh_gram();               /*更新显示到OLED */
    ) u/ K* c/ S9 P0 ^) j; @- i0 q: E
31.         t++;
    
32. 
    
33.         if (t > '~')t = ' ';
    
34. 
    ( Y) }: ^, v. k4 Y4 D
35.         delay_ms(500);
    0 n2 ~% V% b! N% n& m& ]4 e
36.         LED0_TOGGLE();  /* LED0闪烁 */
    
37.     }
    
38. }
    0 D) D! x) P+ X: d* m
39. 
    * D4 s! C/ Q( f( ]' O

复制代码

4 o* L) |1 I8 m, dMain.c主要功能就是在OLED上显示一些实验信息字符，然后开始从空格键开始不停的循环显示ASCII字符集，并显示该字符的ASCII值。最后LED0闪烁提示程序正在运行。
19.4.3 下载验证
8 ?1 h3 C3 u% o' u8 a7 X- c下载代码后，LED0不停的闪烁，提示程序已经在运行了。同时OLED模块显示ASCII字符集等信息，如下图所示（本实验使用的OLED模块是双色的，显示的颜色有两种）：

; x/ v$ P! R5 ^; z
$ B2 b1 b1 v- [- O! O2 }
图19.4.3. 1 OLED显示效果
OLED显示了三种尺寸的字符：2412（ALIENTEK）、168（0.96’ OLED TEST）和12*6（剩下的内容）。说明我们的实验是成功的，实现了三种不同尺寸ASCII字符的显示，在最后一行不停的显示ASCII字符以及其码值。
通过这一章的学习，我们学会了ALIENTEK OLED模块的使用，在调试代码的时候，又多了一种显示信息的途径，在以后的程序编写中，大家可以好好利用。

8 U' u# U: I, `! ~, D+ n19.5 OLED显示图片实验
5 z: Y2 i$ x. R( j; J4 ~) o- A4 M本实验是在上一章实验的基础上修改的，注意main.c文件修改的地方。配置好的实验工程已经放到了开发板光盘中，由于几个实验共用一个工程，所以要测试哪个实验，就在min.c文件中把其它实验的代码注释掉即可。路径为：开发板光盘A-基础资料\1、程序源码\11、M4 CubeIDE裸机驱动例程\CubeIDE_project\ 12 OLED_DISPLAY。
19.5.1 取模
1.选择.bmp格式图片
我们在前面实验的基础上，实现此实验，本节实验需要借助前面实验的画点函数。我们选择前面使用gif分离器分离出的.bmp图片中的某一张来操作本实验，例如使用第一张图片，此图片像素是120*60：:



图19.5.1. 1选择一张bmp格式图片
' y2 R6 O0 [  G) O6 r1 @2. 取模
) G2 N. B8 g0 b" F# U! M& z$ t我们对上面选择的第一章图片取模如下，取模方式设置：阴码+逐列式+顺向+C51格式+十六进制，字宽和字高均为12：
8 J  `8 W7 Q6 d0 f  _8 _5 Z
, W8 H* f0 N! z; `9 ^1 c

图19.5.1. 2图片取模
# G" F4 C0 R4 k" E0 r$ p: k* ~
19.5.2 添加用户代码
1.添加logo.h文件代码
5 I2 d! r& H: p4 M$ H! x0 n在Src/BSP/Include目录下新建一个logo.h文件，将上面取模的数据拷贝到logo.h文件的一维数组Image[]中，此一维数组总共有960个十六进制的数据，也就是此.bmp的图片有最多960个像素点。

1. #ifndef _LOGO_H_
   8 \+ J7 P/ w2 N; r# V
2. #define _LOGO_H_
   % H: l  A0 {) E4 s: y5 {
3. 
   " G- b- k4 t4 I: \6 {
4. uint8_t Image[]={//960
   
5.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
6.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
7.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
8.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   2 z; T  g3 h; J+ i
9.          /***************省略部分数据 *************/
   4 K: i) p0 e& v- i1 I
10.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
11.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
12.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
13.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    9 H6 Y% O5 ?" L4 Y$ n! C
14. };
    . i3 a  E* y0 m' N  m/ }) C
15. #endif

复制代码

. ^/ F) N; R" j# n2.修改oled.c
2 B! q  F+ |* b# H4 [在oled.h文件中添加如下代码：
& [) o8 ?$ l* m( Mvoid OLED_Show(uint8_t x,uint8_t y,uint16_t bytenumber, uint8_t height, uint8_t* Image, uint8_t mode);
        在前面实验的oled.c文件中添加如下代码：
% ?, i8 v( e: `* Z8 A( y

1. /**
   + e+ r8 m6 \: s1 Q/ R6 t% z
2. * @brief       显示图片
   
3. * @param       x,y : 起始坐标
   7 ]7 @# Z! f# V2 p: @
4. *              number: 图片像素点的个数
   
5. *              height：图片像素点的高度，即每一列总共有几行
   9 E; ^9 k5 \6 Z* t# C+ [
6. *             Image : 包含图像数据的一维数组首地址
   
7. *              mode  :1点亮数据点,0不点亮数据点
   ) E% [+ E/ K8 v; x# p
8. * @retval      无
   ) |" E6 T7 V  f5 P! p3 O
9. */
   3 V5 \3 K6 S5 I: E. G8 W
10. void OLED_Show(uint8_t x,uint8_t y,uint16_t number, uint8_t height, uint8_t* Image, uint8_t mode)
    
11. {
    
12.     uint16_t i=0;
    . _4 \. h  f. U- |8 ~6 g* G/ w
13.     uint8_t y0=y, temp=0, j=0;
    1 t/ i( w2 Z  C9 M8 i
14. 
    6 w+ A$ U4 P2 m) R- L
15.     for(i=0; i<number; i++)                 /* number个像素点就要循环number次 */
    
16.     {
    " c: ^$ p. ^9 o4 T) O+ L
17.         temp=Image;
    ! [, H6 }3 z/ U8 F5 i
18.         for(j=0; j<8; j++)                 /* 对于某行中的每个点进行判断  */
    
19.         {
    6 j" H$ v( y) v4 W# @: M7 t9 `
20.             if(temp&0x80)                         /* 如果像素点是1，则点亮数据点 */
    
21.                 oled_draw_point(x,y,mode);
    
22.             else                                        /* 如果像素点是0，则不点亮数据点 */
    * B( d( u( @1 ]4 y: Y
23.                 oled_draw_point(x,y,!mode);
    , z7 p$ a: u/ V  ?
24.             temp <<= 1;                         /* 将右边的数据往左移动  */
    
25.             y++;        
    
26.             if(y-y0 == height)
    # \! [6 S0 }! c" i  A$ g
27.             {
    
28.                 y=y0;
    
29.                 x++;
    
30.                 break;
      |. k- Y7 a0 F
31.             }
    , ]7 y: I$ x9 V: S2 P
32.         }
    0 h" a3 C+ U0 S  P
33.     }
    - W! t; e( B1 k( N$ f
34. }
    

复制代码

6 u6 o$ g+ x9 z" S8 \3.修改main.c
在main.c文件中添加如下代码：
* N% r. Z) r6 f

1. #include "main.h"
   
2. #include "gpio.h"
   . R5 S$ T# k- X! V9 X3 s5 d
3. #include "gpio.h"
   . ~$ x0 e6 M! G3 r6 A
4. #include "./BSP/Include/led.h"
   " o" t" ]1 i! `+ J) Q, f
5. #include "./BSP/Include/oled.h"
   
6. #include "./BSP/Include/logo.h"
   ; [/ s2 Y$ A: w
7. void SystemClock_Config(void);
   
8. int main(void)
   
9. {
   
10.   HAL_Init();
    2 T' W  }0 N  W7 ?
11.   if(IS_ENGINEERING_BOOT_MODE())
    
12.   {
    
13.     SystemClock_Config();
    ; D$ Q9 Z% t6 I  l: T
14.   }
    $ e+ q5 ]- n5 |3 h; Z
15.     MX_GPIO_Init();
    3 M# d4 o9 o. A$ p& B% G2 J
16. /* USER CODE BEGIN 2 */
    
17.     led_init();
    # q7 M$ ~! n' h( l: Z
18.     oled_init();
    
19. /* USER CODE END 2 */
    
20.   while (1)
    
21.   {
    
22. /* USER CODE BEGIN 3 */
    : Z) s" k' w) K. `- O6 H2 R
23.     OLED_Show(0,0,960, 60, Image, 1);
    
24.     oled_refresh_gram();
    2 u' W! C6 {8 n8 H
25.     HAL_Delay(500);
    
26.     LED0_TOGGLE();  
    
27.   }
    
28. /* USER CODE END 3 */
    : ?* b$ ^/ Z) `
29. }
    

复制代码

注意OLED_Show(0,0,960, 60, Image, 1)这一行，x和y坐标均是0，像素点个数是960（前面取模后我们计算出来.bmp的图片有最多960个像素点），像素点的高度是60，因为我们使用的图片像素是120*60的，高度则为60。
% y' ^) V1 T. y$ G: V( @/ N( O' M
6 w; D2 V+ z! X, ^; ?6 L8 P2 H, V19.5.3 编译运行
编译无报错，运行后的效果如下图所示：
) c# w0 F8 a, C5 \5 ?, i( d6 V
图19.5.3. 1编译运行结果
19.6 OLED显示动图实验
本实验是在上一章实验的基础上修改的，注意main.c文件修改的地方。配置好的实验工程已经放到了开发板光盘中，由于几个实验共用一个工程，所以要测试哪个实验，就在min.c文件中把其它实验的代码注释掉即可。路径为：开发板光盘A-基础资料\1、程序源码\11、M4 CubeIDE裸机驱动例程\CubeIDE_project\ 12 OLED_DISPLAY。
19.6.1 取模
1.选择.bmp格式文件
" o/ r0 W% d! F5 ~  A: X) W1 O每一张动图是由一帧帧的图片组合成的，前面我们使用gif图片分离器分离出了58张的.bmp格式的文件，我们可以考虑使用其中几张的图片来生成点阵数据，再将每张图片显示出来，显示的每张图片延时400ms的时间，这样看上去就像是一个动图了。如下，我们选择这58张图片中的10张（0/2/6/13/16/22/34/43/48/57）：

2 `+ y. p* M- \4 m8 D
. P( o1 |  w! P* T) Z
/ v$ c$ t& v3 |$ m图19.6.1. 1选取图片
2. 取模
我们依次对这10张图片进行取模，保存每张图片取模后的数据，取模方式和前面的一样，即阴码+逐列式+顺向+C51格式+十六进制，字宽和字高均为12：

8 R) t/ }5 t: P

8 H7 w' f3 g' F图19.6.1. 2取模配置
观察取模后的数据，每张图片的数据的个数都是960个（即每张图片的像素点个数是960）。
. |1 H( m9 d4 i* W2 b# d
" H4 J& O; Z6 e) [- y4 L6 Z
19.6.2 添加用户代码
! Y5 I" S2 @' N6 @0 g2 A3 \1.修改logo.h
# t8 G: W. K1 X4 i我们可以直接在上一章节的logo.h文件中创建10个一维数组，每个数组存放一张图片的数据。由于代码太多，我们这里只截图一部分，具体可以参考本实验的工程代码：

) a) i1 z$ R7 _% P) g( a! ^

图19.6.2. 1 logo.h中添加的代码
2. 修改main.c
然后在main.c文件中直接添加如下代码：

1. OLED_Show(0,0,960, 60, Image1, 1);
     v$ c: l! Z# p# x
2. oled_refresh_gram();
   
3. HAL_Delay(400);
   
4. OLED_Show(0,0,960, 60, Image2, 1);
   
5. oled_refresh_gram();
   % J. h' @/ U# v) X: K
6. HAL_Delay(400);
     t) D2 V0 k6 C' S2 p2 p: }' v
7. OLED_Show(0,0,960, 60, Image3, 1);
   , \) h7 r9 s2 b  j3 p* D1 a6 E
8. oled_refresh_gram();
   . a! M, T% k% D7 J6 B+ ~5 W
9. HAL_Delay(400);
   $ b" |5 c3 z. _
10. OLED_Show(0,0,960, 60, Image4, 1);
    ' N: L2 c1 c% g5 m' h
11. oled_refresh_gram();
    
12. HAL_Delay(400);
    * i% N) _" o1 U# p* ^- [
13. OLED_Show(0,0,960, 60, Image5, 1);
    ) b# B/ k7 U! b" f
14. oled_refresh_gram();
    
15. HAL_Delay(400);
    ( p( E1 e/ V6 L; B$ V" ^, T$ ?. n
16. OLED_Show(0,0,960, 60, Image6, 1);
    " G0 a: u0 i2 ]( d7 M2 [+ r) J
17. oled_refresh_gram();
    
18. HAL_Delay(400);
    / {" m! o: J* }
19. OLED_Show(0,0,960, 60, Image7, 1);
    
20. oled_refresh_gram();
    ' l1 U$ ^, j0 ^/ N1 J* P$ h
21. HAL_Delay(400);
    
22. OLED_Show(0,0,960, 60, Image8, 1);
    
23. oled_refresh_gram();
    
24. HAL_Delay(400);
    
25. OLED_Show(0,0,960, 60, Image9, 1);
    
26. oled_refresh_gram();
    
27. HAL_Delay(400);
    
28. OLED_Show(0,0,960, 60, Image10, 1);
    " ~) M2 f  H; W
29. oled_refresh_gram();
    
30. HAL_Delay(400);

复制代码

以上是创建了10个一维的数组，然后分10次进行显示，每次显示一张图片，每张图片显示400ms。编译后测试，就可以看到一个动图了。
以上代码比较繁琐，下面我们将以上代码进行改进。

- I$ n( Z* z+ u5 R3.修改image.h
下面我们在Src/BSP/Include下创建一个image.h头文件，在此头文件中创建一个二维数组，数组中的常量表达式1是图片的索引值，共有10张图片，所以值为10，每张图片的像素点个数为960，所以数组中的常量表达式2的值为960：
$ g1 z3 ?8 s# e7 o" _% c! z) O

1. uint8_t BMP[10][960]={
   
2.     {//IMG00000.bmp
   , h' }2 o& ?- ]% t# o+ X
3.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
4.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
5.      /***********省略部分代码**********************************/
   ; s5 |$ C0 @" A6 W
6.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
7.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
8.     },
   
9.     {//IMG00002.bmp
   % u, K# e) X6 M) r% J4 Z
10.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
11.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
12.     /***********省略部分代码**********************************/
    % K- @- u3 \: A6 |- u
13.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    : p' J$ x# A. H: T
14.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    ( e1 ]) N+ ^9 s- t3 t8 l
15.     },
    
16.     .
    % E$ y: D% M  x1 b1 A! E$ X
17.     .
    : J/ c; A2 S- }
18.     .
    
19.      {//IMG00057.bmp
    
20.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
21.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    3 c5 }4 c4 O* U0 u2 I( r( j# |
22.      /***********省略部分代码**********************************/
    # I0 h5 ?/ {5 V+ j
23.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    / I7 w; }8 ^: ]' e* P8 g
24.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
25.     },
    9 q  Z% h$ Y3 y% j0 H! x
26. };

复制代码

4.修改oled.c
在oled.c文件中添加代码如下：

1. #include "./Include/image.h"
   ) O: H" p. J2 T7 G- [: C  `
2. /**
   ! V4 ?- _( E, c: x  S
3. * @brief     显示图片
   
4. * @param     x,y : 起始坐标
   ; H: k7 c" D6 {8 o) V! D
5. *            px,py: 图片的宽度和高度，本实验所使用的图片
   3 C( p- @8 z6 @3 g2 J$ p9 e
6. *            宽是120像素，高是60像素
   
7. *            index : 图片的索引，为0~9，共10张图
   
8. *            mode  :1点亮数据点,0不点亮数据点
   
9. * @retval    无
   6 b( U' K5 h! \& {! B0 [
10. */
    # C; I  F7 J& o, k+ N9 n
11. void OLED_ShowBMP(uint8_t x, uint8_t y, uint8_t px, uint8_t py, uint8_t index, uint8_t mode)
    
12. {
    
13.     uint8_t temp,t1;
    
14.     uint16_t j,i;
    ' e, v1 U3 z$ k$ U
15.     uint8_t y0=y;
    
16. 
    
17.     i=960;
    
18.    // i = (px/2)*(py/4); /* 或者使用此函数 */
    
19. 
    
20.     for(j = 0; j < i;j++)
    
21.     {
    7 E/ j$ [3 \! B7 R, ?1 w4 f
22.         temp = BMP[index][j]; /* 调用图片 */
    
23.         for(t1=0;t1<8;t1++)  /* 对于某行中的每个点进行判断  */
    ! o* Y+ u% @/ t1 V& g
24.         {
    7 d- ?& n4 t/ o' T7 P' i% L
25.             if(temp&0x80)/* 如果像素点是1，则点亮数据点 */
    5 S1 Q3 x* e  q: x
26.                 oled_draw_point(x,y,mode);
    
27.             else        /* 如果像素点是0，则不点亮数据点 */
    
28.                 oled_draw_point(x,y,!mode);
    4 Y/ s8 E8 T! C+ I, K0 f
29.             temp<<= 1;  /* 将右边的数据往左移动  */
    
30.             y++;
    % ^! N8 n/ b6 T2 e2 o$ ~, J
31.             if((y-y0) == py)
    
32.             {
    ( {4 Z+ r' D  p$ x* A/ n& s' B
33.                 y=y0;
    2 X: i7 v( L) E5 S  W; H! U$ ~
34.                 x++;
    0 T4 a3 c( P* m
35.                 break;
    
36.             }
    
37.         }
    
38.     }
    1 g8 q% L: ^- u$ y
39. }
    6 I6 z2 A% g( J0 a: l- [3 M

复制代码

/ Q+ \' K' z" X3 p. M( h以上代码中，index是索引值，取值为0~9。

5.修改main.c
main.c文件代码如下：

1. #include "main.h"
   $ I# c$ w6 j% d7 b3 j4 A; ?
2. #include "gpio.h"
   ( y! r* ^: z! p6 `9 e$ a: k% B
3. 
   % Y; S4 ^& B! u1 |. d5 |
4. /* USER CODE BEGIN Includes */
   8 V$ S2 R; X+ ?1 I$ G8 a3 M1 ^
5. #include "gpio.h"
   
6. #include "./BSP/Include/led.h"
   # {* w4 W$ `5 S7 l( l
7. #include "./BSP/Include/oled.h"
   
8. #include "./BSP/Include/logo.h"
   2 z% w* F% S% o5 w' R/ e
9. /* USER CODE END Includes */
   
10. 
    
11. void SystemClock_Config(void);
    ; ^2 w' ?+ F: x$ ]4 M) z) x
12. 
    
13. int main(void)
    
14. {
    , v  ~' L* f- d: l
15.   HAL_Init();
    
16.   if(IS_ENGINEERING_BOOT_MODE())
    ; C8 L% X+ E* X
17.   {
    
18.     SystemClock_Config();
    
19.   }
    
20.     MX_GPIO_Init();
    
21.     /* USER CODE BEGIN 2 */
    
22.     led_init();
    
23.     oled_init();
    
24.     /* USER CODE END 2 */
    # w; V, |4 f8 x0 a7 G  W. R) x
25.   while (1)
    
26.   {
    
27. /* USER CODE BEGIN 3 */
    
28.     int i;
    
29.     for(i = 0;i < 10;i ++)
    
30.     {
    
31.      OLED_ShowBMP(0,0,120, 60,  i, 1);
    % x0 s) m+ j# g
32.      oled_refresh_gram();
    
33.     HAL_Delay(400);
    4 t8 {. K+ j% Z) e
34.     }
    $ `; n6 w( T& I9 W; _
35.     HAL_Delay(500);
    ( C" W# x* Q: S9 w6 t& G) n& g
36.     LED0_TOGGLE();  
    ! C+ q0 z. h) \
37.   }
    ! Q2 Z  [7 ?7 B! `3 c1 h
38. /* USER CODE END 3 */
    
39. }

复制代码

以上代码中，定义i，取i依次为0~9，每隔400ms显示一张图片，效果和前面的实验一样。
3 m7 A9 s" V3 @: G  u2 Y; V
19.6.3 编译测试
' B; D4 z( P- c' n  j' X3 s编译运行，可以看到一个动图效果：


% ~; Q/ Q# A5 z9 D* J! A3 w
+ x% w! [$ M; d/ h- K- N4 N图19.6.3. 1实验效果
; y. q5 v* `: C8 Q& x3 o; `6 f
. Q$ B0 H2 D7 C, ]. u. s9 i7 T% E19.7 显示一个汉字
本实验是在上一章实验的基础上修改的，注意main.c文件修改的地方。配置好的实验工程已经放到了开发板光盘中，由于几个实验共用一个工程，所以要测试哪个实验，就在min.c文件中把其它实验的代码注释掉即可。路径为：开发板光盘A-基础资料\1、程序源码\11、M4 CubeIDE裸机驱动例程\CubeIDE_project\ 12 OLED_DISPLAY。
, Y6 ?$ F( o- @4 {$ i- D; i' a本小节实验我们按照19.2.3小节讲解中文字体显示的思路来显示一个汉字，本节的实验代码就不去深究GB2312这些编码了。下面以一个简单的例子来讲解，大家可以编写适合自己的代码显示一句话。
6 N7 k! b5 O2 ~! a: D. T2 |19.7.1 取模
我们选择显示一个宋体“正”字。这里我们设置字体为宋体，字宽和字高可以随意，我们后面的程序会对字宽和字高做处理，使用阴码、顺向、逐列式、十六进制取模方式：



图19.7.1. 1取模设置
取模后的点阵数据如下，共有128个十六进制数据（每个数据8位，相当于1个字节），如果将其分为两组，每组为64个：

* V! ?# C" ~  e% j5 T" O0 G

图19.7.1. 2点阵数据
19.7.2 添加用户代码
1.修改logo.h
在logo.h后面添加一个一维数组Chinese[]，数组的成员就是上面取模后的点阵数据：
- [. r3 @  O4 Q- W& i# P* J8 \
' ?; P. v9 \) b
/ ^' Y; D. m( j6 ~$ o, }; Q
图19.7.2. 1添加的一维数组
5 ~/ ^7 r- U7 r, A2. 修改oled.c
8 R+ n) [3 r' n4 v1 K) E在oled.c文件中添加显示中文函数OLED_Show_Chinese如下：

1. 1   /**
   6 w5 X; M; w' f
2. 2   * @brief     显示一个汉字
   
3. 3   * @param     x,y : 起始坐标
   
4. 4   *            px,py: 分别是中文的字宽和字高
   
5. 5   *            ch : 包含汉字数据的一维数组首地址
   3 B8 u& _* M/ Q0 B1 M) d
6. 6   *            mode  :1点亮数据点,0不点亮数据点
   
7. 7   * @retval    无
   - L3 ]7 O) O, J& i3 {; k4 {% ~' R, C
8. 8   */
   
9. 9   void OLED_Show_Chinese(uint8_t x,uint8_t y, uint8_t px, uint8_t                                                                                                         py,uint8_t* ch, uint8_t mode)
   
10. 10  {
    
11. 11      uint8_t j,y0=y;
    
12. 12      uint16_t i,number;
    
13. 13      unsigned char f, s;
    
14. 14      number=px*py/16;        /* number是字体所占用的字节数除以2 */
    * w9 D6 s# b- \( E, T8 @
15. 15      //number=64; /* 或者直接写等于64 */
    
16. 16      for (i = 0; i <number ; ++i)
    ' n) k4 U7 {& \' _4 Y2 p
17. 17      {
    * h" `( A! B, E5 i$ ^* x/ M1 C
18. 18          f = ch[i * 2];
    
19. 19          s = ch[i * 2 + 1];
    
20. 20          /* 第一个for循环 */
    4 C  J+ Y; K0 V3 z( w) T( P
21. 21          for (j = 0; j < 8; ++j)
    ) k0 \8 Q& {- o8 K
22. 22          {
    
23. 23              if (0x80 & f)
      W# {* e# o4 ~+ B" s, z+ G
24. 24                  oled_draw_point(x,y,mode);
    
25. 25              else
    3 o* h% s' D6 F
26. 26                  oled_draw_point(x,y,!mode);
    0 u8 n* k) {+ v" i8 ]: R
27. 27              f <<= 1;
    
28. 28              y++;
    7 |: m0 O7 h$ ]! f
29. 29              if(y-y0 == py)
    
30. 30              {
    
31. 31                  y=y0;
    
32. 32                  x++;
    : ?1 h6 Q/ C- W8 K0 p
33. 33                  break;
    ( L8 c1 ~! U; @7 M* o- H% A  F
34. 34              }
    ! N" T" T+ Q4 y, h
35. 35          }
    ; y% k# u& d5 Q: a  d$ O8 [
36. 36          /* 第二个for循环 */
    . W4 J0 c$ @  a# ?* C
37. 37          for (j = 0; j < 8; ++j)
    ! b# g0 Y, ]+ l
38. 38          {
    
39. 39              if (0x80 & s)
    
40. 40                  oled_draw_point(x,y,mode);
    / n/ m! H6 X3 e' p5 T9 y. ^
41. 41              else
    
42. 42                  oled_draw_point(x,y,!mode);
    
43. 43              s <<= 1;
    
44. 44              y++;
    
45. 45              if(y-y0 == py)
    & g  a' h+ {$ C( A+ b( o
46. 46              {
    ' G0 ]! o3 _7 S: L6 E/ S
47. 47                  y=y0;
    
48. 48                  x++;
    
49. 49                  break;
    ) I) |. w0 v5 E7 _
50. 50              }
    
51. 51          }
    3 u4 p  `& n. j, P( A
52. 52
    , G3 e+ X1 L- s( M; l4 Q' d: Q
53. 53      }
    ' R) z' H/ @* t8 V% p  g
54. 54  }

复制代码

/ `9 q, S& {4 c我们参考前面第19.2.3讲解的显示汉字的方法，显示一个英文字符使用的是一个for循环就可以了，因为汉字的字宽是英文字符的两倍，所以将一个汉字分为两个部分进行显示（相当于两个英文字符），所以用到两个for循环。
程序中，x和y分别代表要在屏幕上显示的坐标点。px和py是要显示的汉字的字宽和字高，字宽和字高可以根据取模软件上设置的来，本实验我们取模软件上设置的字宽是33，字高是26，所以如果在main.c文件中调用此函数的话，这两个数字要写正确，否则可能会导致显示异常。
第14行number是字体所占用的字节数除以2，即将字体所占用的字节数分为两组，所以后面会有两个for循环。本实验生成的字模共有128个十六进制数据，所以可以将number直接设置为64（即128/2）。
9 f, O9 |: ^! v7 j( E# ?; H0 l
3.修改main.c
! h. b; r! d0 V* t* q- Pmain.c文件代码如下，OLED_Show_Chinese(0,0, 33,26, Chinese, 1)这一行，x和y坐标是0，字宽和字高分别为33和26。
) Y7 p7 A+ Y" t8 u$ Z( J

1. #include "main.h"
   : d( S! @5 ^! s3 N
2. #include "gpio.h"
   & \4 B7 B2 n# y0 }0 q$ H) _
3. 
   ; m+ u: f# t% T7 o! x7 }
4. /* USER CODE BEGIN Includes */
   ! V2 H9 Q6 [, n# Y! H
5. #include "gpio.h"
   8 m- P+ g# Y$ b" Q* O) n
6. #include "./BSP/Include/led.h"
   8 Q, K' ?9 N7 s0 O" z) A8 X
7. #include "./BSP/Include/oled.h"
   
8. #include "./BSP/Include/logo.h"
   & i5 b  E6 X7 D$ N! w+ Z: Q" y
9. /* USER CODE END Includes */
   
10. 
    - x; E' W/ s3 F: _- i" n0 A$ _3 a4 [
11. void SystemClock_Config(void);
    1 Z# D) z# E; s/ x
12. 
    
13. int main(void)
    
14. {
    ! |+ _: m: t. p# Q! L
15.   HAL_Init();
    ' |& K9 q4 a: L# B
16.   if(IS_ENGINEERING_BOOT_MODE())
    ! T& Q* `; ]* K. A" w9 r$ f
17.   {
    4 e1 P& _4 I# [, w
18.     SystemClock_Config();
    & w( \5 u# ?: F6 d" t$ X; C
19.   }
    % ]. E/ l. [+ `- V0 g$ K& w3 V
20.   MX_GPIO_Init();
    
21.     /* USER CODE BEGIN 2 */
    
22.     led_init();
    . }; {" M' }: C' L
23.     oled_init();
    
24.     /* USER CODE END 2 */
    6 `" d4 n3 r6 f+ z: F! C
25.   while (1)
    8 G/ Y/ h' w3 Q+ ]+ C' b
26.   {
    ( `  T  |: M) o# f* a5 d
27.     /* USER CODE BEGIN 3 */
    , q3 G3 m% {- j- X+ h
28.     OLED_Show_Chinese(0,0, 33,26, Chinese, 1);
    * `4 A: G8 c$ d
29.     oled_refresh_gram();
    
30.     HAL_Delay(500);
    
31.     LED0_TOGGLE();  /* LED0闪烁 */
    3 U* @4 Z3 Z5 x+ N# m7 o8 N
32.   }
    
33.   /* USER CODE END 3 */
    ) z4 N& M0 I, S4 K/ p
34. }

复制代码

19.7.3 编译运行
编译运行，显示结果如下：
9 H0 q6 a2 O0 T! V8 A6 [
9 @0 M: D2 a+ [

图19.7.3. 1实验效果
————————————————
1 S* S3 K1 W" j8 D& s版权声明：正点原子

) J! ]: N5 s$ ?) M" O, o