一.OLED简介
: R8 f& h: R, g" }) H7 sOLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（OrganicElectroluminesence Display， OELD）。 OLED 由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。
$ ?* V+ r9 p6 T! n# ^, ^模块特点：
没有背光，需要通过写入指令来开启显示
尺寸小：0.96寸，分辨率高：128*64
提供多种通信接口：6800、8080、3线/4线SPI、IIC
7 T" f( Y1 |* t/ G4 }供电3.3V
: O& P- s$ t: U* t: z
5 \7 ~1 b; s  e3 _9 f2 ^# `
需要改变模块的通信接口时，只需要改变模块背后的电阻位置即可，如示：
/ a+ L' [1 I# n, R: k; q
3 U$ Q6 t  t* m( ?! k! p6 m" g
9 ]# X( h; ~$ d; M# D& C6 H

1 M% X8 q0 @3 a/ F& S) N1 @
3 @  c) D% v! H  s我是使用4线SPI驱动OLED的。


/ \# z( R9 o3 q- l二.驱动SSD1306所需知识
! m. [& h7 h/ c+ `& y1.引脚介绍
8 i% j, Z! [6 Y# ^. z) D3 M3 x3 F

3 h$ V, u- O) }8 w' Q* p

" E6 M- k, h( X! g/ z
如图所示，各引脚的介绍如下：
GND：接地引脚
VCC：接电源引脚，接3.3V直流电源即可
# E4 z2 E$ U& t: oD0：SPI的时钟线SCLK
D1：SPI的数据线SDIN
RES：复位接口，低电平初始化（复位），正常时高电平
( F, T; Y- Q: A( \$ MDC：用来选择命令or数据，低电平命令，高电平数据
CS：片选线

' @' u6 I! l- p; O' @0 U
% C5 e/ P/ B0 |* j) u* {' d' c$ K0 e注意：4线SPI模式时，只能写，不能读！
4 T5 z' v' h. [在本文的代码中，对应的接口如下：
SCLKC0 D0
2 \6 o* K% c3 J# j0 p: eSDINC1 D1
& U9 [' J* C# }5 o2 x. bRES G15 拉低时初始化（复位），正常时拉高
DC D3 （0:命令 1:数据）
CS D6


6 O) M9 O  [0 I) ^2.通信时序
0 p5 @; z0 l/ A) q* v$ u7 N' v单片机与OLED通信是4线SPI，每个数据长度为8位，在SCLK的上升沿数据有效，在上升沿数据从SDIN移入SSD1306，高位先行，D/C用来说明是传输命令还是数据。其通信时序图如示：

3 l5 k% I0 _+ L8 e  {

; h/ n" x3 T0 o" M" l/ o( r
: X' X( R) f& r8 v) d5 A
由图知，SSD1306与单片机通信可以分为如下几步：
3 G; W. {. N5 V1.拉低片选CS，作为正常通信的前提
0 t2 i& p% m+ W2 Y/ M2.根据需求操作D/C，低电平代表传输命令，高电平代表传输数据
3.时钟线SCLK不断产生时钟信号，上升沿数据线有效
4.数据线SDIN根据SCLK的上升沿，从高位开始传输一帧数据（8位），置高代表1，拉低代表0


. P! @9 _! v6 r. l9 {# J3.显存GRAM
在OLED上显示图像，图像的数据就存储在显存GRAM中，由于SSD1306的分辨率是128*64，代表屏幕上总共有128x64个像素点，所以其显存大小就是128x64bit，恰好可以存储一帧图像的信息。
0 m. O' |1 W' S/ V: ?7 KSSD1306的在逻辑上把GRAM分为8页，每页包含128个字节（1个字节8位），即8x128x8=128x64，所以屏幕上的每一个像素点都对应着GRAM中的每一位，要想点亮屏幕上的某一个像素点，只要在开启显示的前提下，将GRAM中的相应位置一即可。
SSD1306的GRAM与屏幕上像素点的对应关系表如示：
3 f* d, j4 @& P. @; {) E$ ], Q

2 _$ e) F" R4 |0 ?


以屏幕的左上角为原点，可以想象出一副坐标系，屏幕的大小范围就是x：0~ 127，y：0~64，实际上我们后续画点也是以此为基础的！
) k' t0 N& M+ [4 T- `* i: E我们用一个二维数组来抽象的映射出屏幕上的每一个像素点：

1. /* OLED的显存 */
   ; o) F7 n) [+ J: X5 f! _
2. uint8_t OLED_GRAM[128][8];
   5 n" }5 C1 T$ C$ u7 |. R
3. /*
   : B0 R) y4 q" d* u$ B5 z
4. OLED_GRAM[128][8]中是8位二进制为一个单位
   ' v5 l0 L9 G& ?9 |/ p7 D
5. 其逻辑排序如示：（高位先行）
   ' I* s/ p* Y& c- [6 J
6. 7 7
   . G$ c& G' h5 L% n6 u& m1 x
7. 6 6
   - \0 c7 q& @) Q
8. 5 5
   
9. 4 4  ...
   ' S, N) A, T3 l% }) G- h2 V2 p! |
10. 3 3
    
11. 2 2
    
12. 1 1
    2 _6 A( T, N( w' G+ J
13. 0 0
    - e% h- z& l# E' d' p
14. */
    

复制代码

& `7 e$ ?" P8 |$ ^: e8 c到此，我们只需要把要显示图像的信息写入OLED_GRAM[128][8]数组中，再通过画点函数操作OLED_GRAM[128][8]中的每一位对应的像素点，就可以在OLED屏幕中显示图像了。
' v. z, {) {; E' s
1 I: |, g& F# |2 c. G
* r2 c# F! K% V4.字库
1 _* x0 \: X3 k要在屏幕中显示图像，最常见的是显示一些字符，这个时候就需要这些字符的图像信息了，这就涉及到字库。我理解，一个包含了一些字符图像的数组就可以称作字库，这样做的好处就是，可以根据所要显示的字符直接从字库中提取图像信息到GRAM，这样显示字符就方便多了。
本项目所使用的字库大小有（高x宽）：12x6、16x8、24x12
& Y, O" J* V* |5 k3 _) ?. ?而且字库的取模方式：阴码+逐列式+顺向+C51格式（用了取模软件PC2LCD2002）
每个字符所占用的字节数为size/8+((size%8)?1:0))*(size/2),其中size:是字库生成时的点阵大小
( K! K. M2 N9 l" H4 w- n% H3 v$ ~8 R比如12x6字库信息如示：
) M: {. N5 g7 y# n% f# F

1. //12*6 ASCII字符集点阵
   2 `& N& x4 O) I, d4 l! i4 M9 [
2. const unsigned char asc2_1206[95][12]={
   # m% U# |  m- o% @9 m1 F
3. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*" ",0*/
   
4. {0x00,0x00,0x00,0x00,0x3F,0x40,0x00,0x00,0x00,0x00,0x00,0x00},/*"!",1*/
   & v/ J! V. B& J6 i+ m
5. {0x00,0x00,0x30,0x00,0x40,0x00,0x30,0x00,0x40,0x00,0x00,0x00},/*""",2*/
   * _4 F% k# y( h( g
6. {0x09,0x00,0x0B,0xC0,0x3D,0x00,0x0B,0xC0,0x3D,0x00,0x09,0x00},/*"#",3*/
   4 j* e+ ?8 |$ s* U0 F
7. {0x18,0xC0,0x24,0x40,0x7F,0xE0,0x22,0x40,0x31,0x80,0x00,0x00},/*"$",4*/
   $ T8 _! C& y! ]# s1 t  F: L; i
8. {0x18,0x00,0x24,0xC0,0x1B,0x00,0x0D,0x80,0x32,0x40,0x01,0x80},/*"%",5*/
   
9. {0x03,0x80,0x1C,0x40,0x27,0x40,0x1C,0x80,0x07,0x40,0x00,0x40},/*"&",6*/
   $ y: q+ c+ }5 B0 J# L+ b5 a" n: o; t
10. {0x10,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"'",7*/
    
11. {0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x80,0x20,0x40,0x40,0x20},/*"(",8*/
    5 @% ^" s" Q: k6 t1 h: Y
12. {0x00,0x00,0x40,0x20,0x20,0x40,0x1F,0x80,0x00,0x00,0x00,0x00},/*")",9*/
    % M1 j  P/ d( a0 h
13. {0x09,0x00,0x06,0x00,0x1F,0x80,0x06,0x00,0x09,0x00,0x00,0x00},/*"*",10*/
    
14. {0x04,0x00,0x04,0x00,0x3F,0x80,0x04,0x00,0x04,0x00,0x00,0x00},/*"+",11*/
    
15. {0x00,0x10,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*",",12*/
    
16. {0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x00,0x00},/*"-",13*/
    
17. {0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*".",14*/
    
18. {0x00,0x20,0x01,0xC0,0x06,0x00,0x38,0x00,0x40,0x00,0x00,0x00},/*"/",15*/
    
19. {0x1F,0x80,0x20,0x40,0x20,0x40,0x20,0x40,0x1F,0x80,0x00,0x00},/*"0",16*/
    % g: ^& C% Q! T9 _! C6 R6 Z
20. {0x00,0x00,0x10,0x40,0x3F,0xC0,0x00,0x40,0x00,0x00,0x00,0x00},/*"1",17*/
    " c7 \8 p$ H6 G$ S& {6 i( q
21. {0x18,0xC0,0x21,0x40,0x22,0x40,0x24,0x40,0x18,0x40,0x00,0x00},/*"2",18*/
    0 B& V+ S7 v. ]( I: a% g; u
22. {0x10,0x80,0x20,0x40,0x24,0x40,0x24,0x40,0x1B,0x80,0x00,0x00},/*"3",19*/
    6 C0 C0 N% b! ]7 f( Z' C9 D
23. {0x02,0x00,0x0D,0x00,0x11,0x00,0x3F,0xC0,0x01,0x40,0x00,0x00},/*"4",20*/
    ' L- {5 a; a! e& t/ J2 j0 W0 i
24. {0x3C,0x80,0x24,0x40,0x24,0x40,0x24,0x40,0x23,0x80,0x00,0x00},/*"5",21*/
    
25. {0x1F,0x80,0x24,0x40,0x24,0x40,0x34,0x40,0x03,0x80,0x00,0x00},/*"6",22*/
    
26. {0x30,0x00,0x20,0x00,0x27,0xC0,0x38,0x00,0x20,0x00,0x00,0x00},/*"7",23*/
    . O% C2 V1 ~' ]& i- x$ X0 y
27. {0x1B,0x80,0x24,0x40,0x24,0x40,0x24,0x40,0x1B,0x80,0x00,0x00},/*"8",24*/
    
28. {0x1C,0x00,0x22,0xC0,0x22,0x40,0x22,0x40,0x1F,0x80,0x00,0x00},/*"9",25*/
    
29. {0x00,0x00,0x00,0x00,0x08,0x40,0x00,0x00,0x00,0x00,0x00,0x00},/*":",26*/
    
30. {0x00,0x00,0x00,0x00,0x04,0x60,0x00,0x00,0x00,0x00,0x00,0x00},/*";",27*/
    
31. {0x00,0x00,0x04,0x00,0x0A,0x00,0x11,0x00,0x20,0x80,0x40,0x40},/*"<",28*/
    
32. {0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x00,0x00},/*"=",29*/
    
33. {0x00,0x00,0x40,0x40,0x20,0x80,0x11,0x00,0x0A,0x00,0x04,0x00},/*">",30*/
    
34. {0x18,0x00,0x20,0x00,0x23,0x40,0x24,0x00,0x18,0x00,0x00,0x00},/*"?",31*/
    
35. {0x1F,0x80,0x20,0x40,0x27,0x40,0x29,0x40,0x1F,0x40,0x00,0x00},/*"@",32*/
    . X1 G9 f( T  ]4 V) f
36. {0x00,0x40,0x07,0xC0,0x39,0x00,0x0F,0x00,0x01,0xC0,0x00,0x40},/*"A",33*/
    
37. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x24,0x40,0x1B,0x80,0x00,0x00},/*"B",34*/
    
38. {0x1F,0x80,0x20,0x40,0x20,0x40,0x20,0x40,0x30,0x80,0x00,0x00},/*"C",35*/
    / Z" ^8 U) @' b. V  K
39. {0x20,0x40,0x3F,0xC0,0x20,0x40,0x20,0x40,0x1F,0x80,0x00,0x00},/*"D",36*/
    
40. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x2E,0x40,0x30,0xC0,0x00,0x00},/*"E",37*/
    : ]; z$ G5 k' _
41. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x2E,0x00,0x30,0x00,0x00,0x00},/*"F",38*/
    
42. {0x0F,0x00,0x10,0x80,0x20,0x40,0x22,0x40,0x33,0x80,0x02,0x00},/*"G",39*/
    
43. {0x20,0x40,0x3F,0xC0,0x04,0x00,0x04,0x00,0x3F,0xC0,0x20,0x40},/*"H",40*/
    ; U* L7 q: u8 ^0 h6 u8 E
44. {0x20,0x40,0x20,0x40,0x3F,0xC0,0x20,0x40,0x20,0x40,0x00,0x00},/*"I",41*/
    ! |9 X% J% M! W. O" n. j8 z
45. {0x00,0x60,0x20,0x20,0x20,0x20,0x3F,0xC0,0x20,0x00,0x20,0x00},/*"J",42*/
    " H# C% y+ A! X) _5 D0 i+ @( A
46. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x0B,0x00,0x30,0xC0,0x20,0x40},/*"K",43*/
    ; `- J: Q+ _+ Z7 T' E; l
47. {0x20,0x40,0x3F,0xC0,0x20,0x40,0x00,0x40,0x00,0x40,0x00,0xC0},/*"L",44*/
    
48. {0x3F,0xC0,0x3C,0x00,0x03,0xC0,0x3C,0x00,0x3F,0xC0,0x00,0x00},/*"M",45*/
    
49. {0x20,0x40,0x3F,0xC0,0x0C,0x40,0x23,0x00,0x3F,0xC0,0x20,0x00},/*"N",46*/
    
50. {0x1F,0x80,0x20,0x40,0x20,0x40,0x20,0x40,0x1F,0x80,0x00,0x00},/*"O",47*/
    
51. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x24,0x00,0x18,0x00,0x00,0x00},/*"P",48*/
    6 r5 @0 v! ]$ I% M! k
52. {0x1F,0x80,0x21,0x40,0x21,0x40,0x20,0xE0,0x1F,0xA0,0x00,0x00},/*"Q",49*/
    
53. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x26,0x00,0x19,0xC0,0x00,0x40},/*"R",50*/
    
54. {0x18,0xC0,0x24,0x40,0x24,0x40,0x22,0x40,0x31,0x80,0x00,0x00},/*"S",51*/
    : M: K; i: b4 b2 m0 T' }
55. {0x30,0x00,0x20,0x40,0x3F,0xC0,0x20,0x40,0x30,0x00,0x00,0x00},/*"T",52*/
    
56. {0x20,0x00,0x3F,0x80,0x00,0x40,0x00,0x40,0x3F,0x80,0x20,0x00},/*"U",53*/
    
57. {0x20,0x00,0x3E,0x00,0x01,0xC0,0x07,0x00,0x38,0x00,0x20,0x00},/*"V",54*/
    
58. {0x38,0x00,0x07,0xC0,0x3C,0x00,0x07,0xC0,0x38,0x00,0x00,0x00},/*"W",55*/
    
59. {0x20,0x40,0x39,0xC0,0x06,0x00,0x39,0xC0,0x20,0x40,0x00,0x00},/*"X",56*/
    $ p# [6 i8 i+ u& N& |
60. {0x20,0x00,0x38,0x40,0x07,0xC0,0x38,0x40,0x20,0x00,0x00,0x00},/*"Y",57*/
    
61. {0x30,0x40,0x21,0xC0,0x26,0x40,0x38,0x40,0x20,0xC0,0x00,0x00},/*"Z",58*/
    
62. {0x00,0x00,0x00,0x00,0x7F,0xE0,0x40,0x20,0x40,0x20,0x00,0x00},/*"[",59*/
    
63. {0x00,0x00,0x70,0x00,0x0C,0x00,0x03,0x80,0x00,0x40,0x00,0x00},/*"",60*/
    : B4 J& ^: n& _& f5 t
64. {0x00,0x00,0x40,0x20,0x40,0x20,0x7F,0xE0,0x00,0x00,0x00,0x00},/*"]",61*/
    
65. {0x00,0x00,0x20,0x00,0x40,0x00,0x20,0x00,0x00,0x00,0x00,0x00},/*"^",62*/
    
66. {0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10},/*"_",63*/
    , E# Y/ h3 p) q7 H/ F! r
67. {0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"`",64*/
    
68. {0x00,0x00,0x02,0x80,0x05,0x40,0x05,0x40,0x03,0xC0,0x00,0x40},/*"a",65*/
    $ R" h) X% M: `( H0 P7 i
69. {0x20,0x00,0x3F,0xC0,0x04,0x40,0x04,0x40,0x03,0x80,0x00,0x00},/*"b",66*/
    * _9 H& r8 f% [0 r
70. {0x00,0x00,0x03,0x80,0x04,0x40,0x04,0x40,0x06,0x40,0x00,0x00},/*"c",67*/
    ! e- T" I0 M; {/ O* c2 F2 Y$ I
71. {0x00,0x00,0x03,0x80,0x04,0x40,0x24,0x40,0x3F,0xC0,0x00,0x40},/*"d",68*/
    7 G5 @2 d2 ^9 n, ^; }/ w" X
72. {0x00,0x00,0x03,0x80,0x05,0x40,0x05,0x40,0x03,0x40,0x00,0x00},/*"e",69*/
    
73. {0x00,0x00,0x04,0x40,0x1F,0xC0,0x24,0x40,0x24,0x40,0x20,0x00},/*"f",70*/
    
74. {0x00,0x00,0x02,0xE0,0x05,0x50,0x05,0x50,0x06,0x50,0x04,0x20},/*"g",71*/
    1 r# f, Z+ o- i  B
75. {0x20,0x40,0x3F,0xC0,0x04,0x40,0x04,0x00,0x03,0xC0,0x00,0x40},/*"h",72*/
    
76. {0x00,0x00,0x04,0x40,0x27,0xC0,0x00,0x40,0x00,0x00,0x00,0x00},/*"i",73*/
    - k  z6 }0 H& p1 ^* N. b
77. {0x00,0x10,0x00,0x10,0x04,0x10,0x27,0xE0,0x00,0x00,0x00,0x00},/*"j",74*/
    
78. {0x20,0x40,0x3F,0xC0,0x01,0x40,0x07,0x00,0x04,0xC0,0x04,0x40},/*"k",75*/
    
79. {0x20,0x40,0x20,0x40,0x3F,0xC0,0x00,0x40,0x00,0x40,0x00,0x00},/*"l",76*/
    
80. {0x07,0xC0,0x04,0x00,0x07,0xC0,0x04,0x00,0x03,0xC0,0x00,0x00},/*"m",77*/
    
81. {0x04,0x40,0x07,0xC0,0x04,0x40,0x04,0x00,0x03,0xC0,0x00,0x40},/*"n",78*/
    
82. {0x00,0x00,0x03,0x80,0x04,0x40,0x04,0x40,0x03,0x80,0x00,0x00},/*"o",79*/
    7 I2 a5 {8 a9 z+ s, Y" z1 L
83. {0x04,0x10,0x07,0xF0,0x04,0x50,0x04,0x40,0x03,0x80,0x00,0x00},/*"p",80*/
    1 a0 O2 @) E) N+ o  a8 h# x
84. {0x00,0x00,0x03,0x80,0x04,0x40,0x04,0x50,0x07,0xF0,0x00,0x10},/*"q",81*/
    
85. {0x04,0x40,0x07,0xC0,0x02,0x40,0x04,0x00,0x04,0x00,0x00,0x00},/*"r",82*/
    ! i. B9 C1 F! p9 u1 l
86. {0x00,0x00,0x06,0x40,0x05,0x40,0x05,0x40,0x04,0xC0,0x00,0x00},/*"s",83*/
    
87. {0x00,0x00,0x04,0x00,0x1F,0x80,0x04,0x40,0x00,0x40,0x00,0x00},/*"t",84*/
    
88. {0x04,0x00,0x07,0x80,0x00,0x40,0x04,0x40,0x07,0xC0,0x00,0x40},/*"u",85*/
    : H" v0 {! B* [4 k8 a! l7 x3 F
89. {0x04,0x00,0x07,0x00,0x04,0xC0,0x01,0x80,0x06,0x00,0x04,0x00},/*"v",86*/
    
90. {0x06,0x00,0x01,0xC0,0x07,0x00,0x01,0xC0,0x06,0x00,0x00,0x00},/*"w",87*/
    
91. {0x04,0x40,0x06,0xC0,0x01,0x00,0x06,0xC0,0x04,0x40,0x00,0x00},/*"x",88*/
    % A# E% B% O/ P5 \. Z+ V4 b2 q" `
92. {0x04,0x10,0x07,0x10,0x04,0xE0,0x01,0x80,0x06,0x00,0x04,0x00},/*"y",89*/
    
93. {0x00,0x00,0x04,0x40,0x05,0xC0,0x06,0x40,0x04,0x40,0x00,0x00},/*"z",90*/
    0 C6 X8 V' B- f* a; K
94. {0x00,0x00,0x00,0x00,0x04,0x00,0x7B,0xE0,0x40,0x20,0x00,0x00},/*"{",91*/
    
95. {0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xF0,0x00,0x00,0x00,0x00},/*"|",92*/
    
96. {0x00,0x00,0x40,0x20,0x7B,0xE0,0x04,0x00,0x00,0x00,0x00,0x00},/*"}",93*/
    
97. {0x40,0x00,0x80,0x00,0x40,0x00,0x20,0x00,0x20,0x00,0x40,0x00},/*"~",94*/
    1 h$ T! _/ l/ M% i1 ~# }) t
98. };  
    0 L! I  w$ D; G

复制代码

5.SSD1306基本命令
4 {0 o8 `0 ^, t1 @上面介绍了显存，我们已经知道OLED的图像显示原理了。然鹅，在显示图像之前，还要对SSD1306做一系列的初始化操作，这就用到一些相关指令了。
6 s. v# a' S. a

暂停一下！！！捋一下命令与数据的关系：
上面介绍过D/C线，D/C低电平代表传输命令，高电平代表传输数据。数据就是显存GRAM的内容，而命令就是下面要介绍的。所以OLED与单片机通信就是由单片机向OLED写入信息，开始写入命令来初始化，之后写入GRAM（图像的信息）即可！
1 q1 l1 L( \/ T2 D7 M
" |+ S/ E+ x+ y8 Q8 h
一些常用的命令如图所示：
. j0 r6 A% F2 I. i7 i


6 N* |# ?6 g. F7 C/ j! j5 B1 _4 l

0 }' @6 I# e) K. T  N! v3 x+ q比较重要的是设置起始坐标的三个命令
命令为 0XB0~B7，该命令用于设置页地址，其低三位的值对应着 GRAM 的页地址。
8 T9 P( p3 U' S9 A0 E; y% E* B命令为 0X00~0X0F，该指令用于设置显示时的起始列地址低四位。
命令为 0X10~0X1F，该指令用于设置显示时的起始列地址高四位。

* Y8 Y# h3 A9 l) o+ j  V! {
' q( ~) N3 G/ j/ `/ A  q/ C有关初始化OLED的所有命令会在下午代码讲解部分列出！
* Q9 g( R; G  x- n- k" I

( ^/ r' L5 i# [* L) _三.代码讲解
1.相关引脚配置
+ Q- s, Z* a7 }0 w9 k上面介绍了相应的引脚，这里对相应引脚进行配置，注意：除了GND和VCC引脚，其余所有引脚的模式均为推挽输出，代码如下：
, d2 d+ x& A3 Z1 u- S2 Z

1. /*
   
2. 配置4线SPI模式的所有引脚
   
3. 4线SPI模式只能写，不能读
   0 P6 c  ]# d7 e
4. SCLK:PC0  D0
   
5. SDIN:PC1  D1
   5 ^. {) L3 O/ P5 b$ ^! c' M
6. RES :PG15  拉低时初始化（复位），正常时拉高
   
7. DC  :PD3  （0:命令  1:数据）
   
8. CS  :PD6
   
9. */
   
10. void OLED_GPIO_Config( void )
    
11. {
    
12.         GPIO_InitTypeDef GPIO_InitStruct;
    - ]/ k1 _1 C4 D1 ]6 @% q; r9 f+ e
13.        
    ) t" W: r; L- {
14.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOG, ENABLE );
    . B$ B* L2 `+ Q, @
15.        
    
16.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    , C" \9 O" n8 |% L
17.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    1 H( L8 _1 T; c4 @; B7 i; J
18.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    * k+ q: a4 R  t& z: N% [6 J
19.         GPIO_Init( GPIOC, &GPIO_InitStruct );
    ) Z* D" B$ O: y$ Z
20.        
    7 [. Q5 p& X  a# t0 I3 J4 Y/ j
21.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    
22.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_6;
    
23.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    ! b- e5 I$ N7 X% ^- l* ]: i5 d7 H
24.         GPIO_Init( GPIOD, &GPIO_InitStruct );
    $ K2 Q" ]+ R) }" H6 W. s# O
25. 
    
26.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    
27.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_15;
    4 T, G/ }+ l- d) \$ w( o
28.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    5 ~6 F! x+ f; r3 t5 h% K
29.         GPIO_Init( GPIOG, &GPIO_InitStruct );
    ( _9 s( d6 V; e8 @% U* C
30. }
    ! e' `2 J! U! N" B2 `0 {

复制代码

由通信时序知，通信的过程中需要不断改变引脚的电平，所以我写了一些对引脚电平操作的函数（格式都一样）：

1. void OLED_SCLK( uint8_t x )
   # L4 T7 v8 b' e% \
2. {
   
3.         if( x==1 )
   
4.                 GPIO_SetBits( GPIOC, GPIO_Pin_0 );
   : _3 Y) b7 |, Q
5.         else
   
6.                 GPIO_ResetBits( GPIOC, GPIO_Pin_0 );
   
7. }
   5 e! j" H8 [" j/ }& }8 i
8. 
   
9. void OLED_SDIN( uint8_t x )
   7 j4 a- D+ o. b& q4 I
10. {
    
11.         if( x==0 )
    & w. N& G* H/ ~( e3 I( i" O  @+ g
12.                 GPIO_ResetBits( GPIOC, GPIO_Pin_1 );
    9 _" u' T. K7 |
13.         else
    
14.                 GPIO_SetBits( GPIOC, GPIO_Pin_1 );
    
15. }
    9 r% S1 `. `5 h3 [4 F7 C  r
16. 
    1 l/ R" t/ V" I3 W
17. void OLED_RES( uint8_t x )
      P  C5 z2 n+ k5 S+ ~0 w" ^
18. {
    4 N) k4 w1 ]+ W0 B
19.         if( x==1 )
    * Z+ c( s2 u* L# P3 \+ X
20.                 GPIO_SetBits( GPIOG, GPIO_Pin_15 );
    ! K3 Q& [3 I# B8 G, R
21.         else
    
22.                 GPIO_ResetBits( GPIOG, GPIO_Pin_15 );
    
23. }
    
24. 
    
25. void OLED_DC( uint8_t x )
    8 H2 U3 O8 e; L- P
26. {
    6 t0 t3 Q+ H% z
27.         if( x==1 )
    
28.                 GPIO_SetBits( GPIOD, GPIO_Pin_3 );
    
29.         else
    & j. M1 f% ?( y9 a
30.                 GPIO_ResetBits( GPIOD, GPIO_Pin_3 );
    # _8 T/ y" Q7 O2 k% l" P) c
31. }
    2 t1 S4 V& O- N( l, `7 |" y
32. 
    7 ~! L, u0 @+ Y& T) q
33. void OLED_CS( uint8_t x )
    
34. {
    5 F5 @6 W4 q; D2 F; l" {1 j  |
35.         if( x==1 )
    8 \# ~/ p/ p& v6 T
36.                 GPIO_SetBits( GPIOD, GPIO_Pin_6 );
    % p9 V; s2 u# t; B0 ]
37.         else
    " ~) z8 I9 }( l% I. [
38.                 GPIO_ResetBits( GPIOD, GPIO_Pin_6 );
    
39. }
    $ k+ ]( m& e4 J

复制代码

; l5 n) q. t% ~% h3 U3 y2.模拟SPI通信
+ \8 T9 `* o# M我根据时序图模拟了SPI的通信协议，按照时序图对相应的引脚操作即可，一共写了俩个函数：写数据和写命令。函数如示：
! {" u0 F( B  {7 h) U8 I

1. 
   
2. /* 写一个命令 高位先行 */
   7 h! q* g8 a+ y) [
3. void OLED_WR_Cmd( uint8_t cmd )
   . g) t# \& v. C& u
4. {
     B! B. Q* a0 E: Q
5.         uint8_t i,k;
   4 s& a3 n9 [1 l$ w! V6 Z# q
6.         /* 拉低片选CS，写命令拉低DC */
   
7.         OLED_CS(0);
   
8.         OLED_DC(0);
   
9.        
   
10.         for( i=0;i<8;i++ )
    8 A$ R% C# D' D
11.         {
    
12.                 /* 时钟线，上升沿有效 */
    
13.                 OLED_SCLK(0);
    $ _/ _3 y. c5 D1 f5 V7 W
14.                 k=cmd&(0x80);
    
15.                 OLED_SDIN(k);
    
16.                 OLED_SCLK(1);
    
17.                 cmd<<=1;
    
18.         }
    0 p3 E$ @$ E* {# v3 P
19.         OLED_CS(1);
    . m3 z5 c4 {: q
20.         OLED_DC(1);       
    
21. }
    
22. 
    & R! _$ \- C: Z/ |7 Q& Y% @
23. 
    
24. /* 写一个数据 高位先行 */
    
25. void OLED_WR_Data( uint8_t data )
    
26. {
    
27.         uint8_t i,k;
    7 T$ Q  {" o' {* W
28.         /* 拉低片选CS，写数据拉高DC */
    
29.         OLED_CS(0);
    . X# D: U# Q/ [
30.         OLED_DC(1);
    0 |* d! p7 b2 e# [$ v  v
31.        
    
32.         for( i=0;i<8;i++ )
    ! [2 g9 i/ ~- k
33.         {
    
34.                 /* 时钟线，上升沿有效 */
    7 v; p: [6 g/ ~6 I6 @
35.                 OLED_SCLK(0);
    & Q: z! G  l1 h: j( ~, T+ Z' I
36.                 k=data&(0x80);
    4 f, J! i5 b( z( t
37.                 OLED_SDIN(k);
    & ^' K3 X# j9 X( w7 ]
38.                 OLED_SCLK(1);
    : s' E0 I" g- r6 d% I
39.                 data<<=1;
    1 c# Q; Q1 Q) A( q- t
40.         }
    / T, w+ B/ Q: m" p5 a9 |/ [
41.         OLED_CS(1);
    
42.         OLED_DC(1);
    
43. }
    

复制代码

! N( _- p/ \, v8 }# E/ o) L8 S+ ~要注意：无论数据还是命令的传输，都是高位先行，这是根据时序图知道的。
9 E; C% V- j- L6 l
7 ^$ W3 z) e% r5 C4 l3.OLED初始化函数
. U+ `, ]- }; t! q. h) Y9 t前面说了，会有一堆初始化命令：
( Q2 Z1 q3 R* T) z

1. 
   
2. /* OLED初始化函数 */
   
3. void OLED_Init( void )
   
4. {
   1 M3 L* l' V( T+ r, \
5.         /* 引脚初始化 */
   ! ~! ?, p# K1 C) z
6.         OLED_GPIO_Config();
   # L/ r. ^# |& W
7.        
   4 Q7 n( C+ N( b0 V$ v6 A; P; M& M7 t
8.         OLED_CS(1);
   
9.         OLED_DC(1);
   
10.        
    
11.         /* 复位 */
    ; h4 k- v' W6 W2 M2 @0 k) k& l
12.         OLED_RES(0);
    
13.         Delay_ms(1000);
      V5 ~8 N! {# ^' p8 A4 A1 p
14.         OLED_RES(1);
    ) P- o7 d& Y/ g
15.        
    
16.         /* 开始写入初始化命令 */
    
17.         OLED_WR_Cmd(0xAE);//关闭显示
    / W3 |: C  G0 G( p9 n2 N7 I
18.         OLED_WR_Cmd(0xD5);//设置时钟分频因子
    
19.         OLED_WR_Cmd(80);
    
20.        
    
21.         OLED_WR_Cmd(0xA8);//设置驱动路数
    5 h/ Y0 e4 \0 q/ L, h$ t3 H$ d7 C5 Q
22.         OLED_WR_Cmd(0x3F);//路数默认0x3F（1/64）
    4 i, W' A2 u. `% T5 T2 t$ T/ B9 v
23.        
    
24.         OLED_WR_Cmd(0xD3);//设置显示偏移
    
25.         OLED_WR_Cmd(0x00);//偏移默认为0
    ; \4 m( K1 t6 k8 ]9 P
26.        
    - k1 Q# l; ~/ ?# F; r
27.         OLED_WR_Cmd(0x40);//设置显示开始行[5:0]
    4 w- z  N( y3 L' ~) }; B1 P
28.        
      w, K+ o6 a# t8 G( Z' o
29.         OLED_WR_Cmd(0x8D);//电荷泵设置
    
30.         OLED_WR_Cmd(0x14);//bit2，开启/关闭
    ' v3 T% O( ^8 l. ?. R! D# ?% `' O
31.        
    : R" B1 z. p$ O8 i
32.         OLED_WR_Cmd(0x20);//设置内存地址模式
    
33.         OLED_WR_Cmd(0x02);//[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
    + B+ {& A) Y+ D2 t! d
34.        
    , @1 f* m- C. Y+ I
35.         OLED_WR_Cmd(0xA1);//段重定义设置,bit0:0,0->0;1,0->127;
    
36.         OLED_WR_Cmd(0xC0);//设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
    8 K! K& d, W( M+ Z: h
37.         OLED_WR_Cmd(0xDA);//设置COM硬件引脚配置
    0 ^% i4 q/ h. c& t( w* @. j
38.         OLED_WR_Cmd(0x12);//[5:4]配置
    3 `5 o2 E1 D! C( a
39.        
    
40.         OLED_WR_Cmd(0x81);//对比度设置
    
41.         OLED_WR_Cmd(0xEF);//默认0x7F（范围1~255，越大越亮）
    
42.        
    
43.         OLED_WR_Cmd(0xD9);//设置预充电周期
    
44.         OLED_WR_Cmd(0xF1);//[3:0],PHASE 1;[7:4],PHASE 2;
    1 {/ h( L; y# F0 e# @; o: [
45.        
    
46.         OLED_WR_Cmd(0xDB);//设置VCOMH 电压倍率
    
47.         OLED_WR_Cmd(0x30);//[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
    
48.        
    
49.         OLED_WR_Cmd(0xA4);//全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
    
50.         OLED_WR_Cmd(0xA6);//设置显示方式;bit0:1,反相显示;0,正常显示
    ! E% y) K6 N$ M& n- {1 d, o
51.        
      K5 W; K! @5 k" Y7 ^% u2 m
52.         OLED_WR_Cmd(0xAF);//开启显示
    
53.        
      F' E+ J' w- w6 k& v
54.         /* 清屏函数 */
    ; U# I; M# R1 b# n; r% e3 j
55.         OLED_Clear();
    . e  ~& ]5 i& C$ I
56. }
    

复制代码

6 C' n% N/ r, K0 Q) ?: y, S' z啥也不说了，照着写就完事了！
0 C/ \  Z: p+ W2 _

- p' i# S/ D0 Q# X6 \$ }! |4.图像刷新与清屏函数
假设图像的信息都已经写到GRAM中了，那么就可以通过图像刷新函数，将GRAM中的图像画到OLED屏幕中，刷新函数如示：
0 J6 [/ g& N; T" y$ d

1. /* 图像刷新函数 */
   & G* E( p9 h+ S7 `! Q; o3 [
2. void OLED_Refresh_GRAM( void )
   
3. {
   , Q8 _) b5 }1 H+ R% a
4.         uint8_t i,j;
   $ G# Z7 v& @* g/ [) X! ~) f
5.         for( i=0;i<8;i++ )
   
6.         {
     O/ L7 O' l9 ^# G# j! E
7.                 /* 设置显示的起始地址 */
   & x7 R6 T( _5 p
8.                 OLED_WR_Cmd(0xB0+i);//设置页地址（行）
   ' m) B) M/ f% ?& O+ }
9.                 OLED_WR_Cmd(0x00);//设置列地址的低四位
   ! t5 X7 F3 {+ ^+ d  T4 t$ ~) D4 u2 w8 ]
10.                 OLED_WR_Cmd(0x10);//设置列地址的高四位
    1 |7 H: G# L5 t6 ^
11.                 for( j=0;j<128;j++ )
    
12.                 {
    2 _+ Z  Y; s9 A8 L
13.                         OLED_WR_Data(OLED_GRAM[j][i]);//将GRAM中图像信息写入屏幕
    
14.                 }
    
15.         }
    
16. }
    % }% _- p& d: I" K3 }" `* u, P4 E4 M8 o1 z

复制代码

对应的，清屏函数就是将GRAM中图像的信息抹去，然后刷新一下：
4 _2 _- J8 s& y% V( B5 ]2 a6 {

1. * 清屏函数 */
   8 W; R2 T; T% ^- |$ f
2. void OLED_Clear( void )
   
3. {
   " W: N4 t4 n9 g) N
4.         uint8_t i,j;
   
5.         for( i=0;i<8;i++ )
   , e& o% X2 p% Z* o+ F
6.                 for( j=0;j<128;j++ )
   
7.                         OLED_GRAM[j][i]=0x00;
   
8.         OLED_Refresh_GRAM();
   - h4 b7 S3 G( l+ M7 Y& ~3 ~' L
9. }
   2 K4 c4 l! q9 f4 C  m2 K

复制代码

5.画点函数
所谓画点，就是将屏幕中指定位置的像素点点亮。在GRAM中就相当于把相对应的位置一，难点在于根据屏幕上的坐标推算出GRAM中的位置，函数如下：
, l' J; h4 S: T& L

1. //OLED_GRAM[128][8]
   ' k: K9 ~( u9 Y" O. q4 ]8 [  T( S% f( z) z
2. /* 画点函数，以屏幕像素点为单位，以左上角为原点 x:0~127 y:0~63
   
3. （x,y）坐标换算:OLED_GRAM[x][7-y/8]|=1<<(7-y%8)；
   
4. 
   * R+ \/ {' w7 u' D" t7 L, u
5. mode取1正显，取0反显
   
6. */
   
7. void OLED_DrawPoint( uint8_t x,uint8_t y,uint8_t mode )
   
8. {
   
9.         /* 主要是求出y坐标，根据y坐标来位运算OLED_GRAM中相应的位 */
   / Y- u- V9 ?0 d3 Q
10.         uint8_t i,j,temp;
    
11.         /* 判断坐标是否超出范围 */
      x3 R3 ]6 U* Y
12.         if(x>127||y>63)return;
    " h+ s9 M# b( w* V4 `/ R4 \
13.        
    + f; a# U4 i9 {4 {6 g0 `2 U
14.         i=7-y/8;//算出第几页
    
15.         j=y%8;
    
16.         temp=0x01<<(7-j);//由位运算精确找出坐标像素点
      t$ c  \* a# i
17.         if(mode==0)
    
18.                 OLED_GRAM[x][i]&=~temp;
    
19.         else
    2 V# p- r! E( e# l9 Y6 U2 \
20.                 OLED_GRAM[x][i]|=temp;
    3 }! Z2 Y/ N- W
21. }
    2 C! C9 W: w; G3 h+ p* y0 A4 t

复制代码

6.显示字符函数
2 ^( D& |9 L4 w' c; J在某一坐标显示指定大小的字符，而且是从字库中提取字符图像信息，这就是显示字符函数：
& V0 X0 l- ^. z9 n& \

1. /* 在（x,y）坐标正显/反显指定大小字符chr
   7 C( C; L) I+ Y
2. mode：0是反显，1是正常显示
   
3. size：12/16/24
   8 P+ b7 q" Z8 d* @  \
4. ASCII字符集: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
   7 ~( g0 }7 \- V: J' U9 _4 u
5. */
   . C  J! L( ]0 x1 r; n9 Q
6. void OLED_Show_Char( uint8_t x,uint8_t y,uint8_t chr,uint8_t size,uint8_t mode )
   
7. {
   
8.         /* temp是当前对应的一个字节的点集，y0是初始坐标 */
   ( k- P  R+ _1 B' u8 ]. A
9.         uint8_t temp,t,t1;
   
10.         uint8_t y0=y;
    ) V+ n* R+ y2 ^. J5 F8 m! G
11.         /* csize是单个字符所占字节的多少 */
    0 \6 d& V! L( |1 G0 k7 f
12.         uint8_t csize=(size/8+((size%8)?1:0))*(size/2);
    
13.         /* 求出偏移的地址差，即得到该字符在字库中的序号（从零开始） */
    
14.         /* chr会锁定字符在字库中的的序号 */
    & c3 j" a$ D) C# |  \' E$ c
15.         chr=chr-' ';
    $ {: _8 o& M$ f: t' q7 j( C
16.        
    7 j. Y' r* ^, T6 h
17.         /* 相应字符点集有多少个字节 */
    + L0 c( c: a7 b0 N! ?1 `. j
18.         for( t=0;t<csize;t++ )
    7 D$ X3 }. U8 k' ]+ r
19.         {
    
20.                 /* 根据字符的大小选择相应字库，根据chr得到具体的字符地址 */
    3 W. b3 n% x8 m
21.                 switch( size )
    * F! U0 u' y' {5 D; Z% b) g1 Y
22.                 {
    
23.                         case 12:temp=asc2_1206[chr][t];break;//12x6(行x列)
    ) q2 M8 [- b) r- {: R
24.                         case 16:temp=asc2_1608[chr][t];break;//16x8
    
25.                         case 24:temp=asc2_2412[chr][t];break;//24x12
    - U9 l" V* `+ f$ ~; @  A# t) K5 o
26.                         default:return;//没有相应字库
    
27.                 }
    - P6 t2 o2 o+ P- U  W
28.                
    : q& v" l4 |( k$ T# J- l( `
29.                 /* 画出每一列的点 */
    
30.                 for( t1=0;t1<8;t1++ )
    . }, Y5 ^8 F. u% ?) A8 I
31.                 {
    
32.                         if( temp&0x80 )
    
33.                                 OLED_DrawPoint( x,y,mode );
    
34.                         else
    5 b% [6 R* x( |4 R7 m. d
35.                                 OLED_DrawPoint( x,y,!mode );
    
36.                        
    
37.                         temp<<=1;
    
38.                         y++;
    
39.                        
    
40.                         /* 根据给出每一列的像素点的多少，判断列是否满：
    + q" r4 W+ B3 f& r
41.                         满了就换列，不满继续在此列画点 （与字库画点原理相关）                       
    
42.                         */
    $ K+ V) F$ A+ e$ O3 ~5 h
43.                         if( ( y-y0 )==size )
    0 g1 g/ o: t8 B+ d' l5 V
44.                         {
    
45.                                 y=y0;
    
46.                                 x++;
    
47.                                 /* 一列满，跳出循环，直接转到下一个字节点集的打印 */
    $ M' J' F, o6 _, |
48.                                 break;
    
49.                         }
    9 z# [6 t" T+ I' g
50.                 }
    
51.         }
    6 \0 h7 M. |6 r( Q% _3 w. u$ m  Y3 ]3 A0 o
52. }
    

复制代码

/ l( m( y* O$ y, l, J7.显示字符串函数
显示字符串，就是显示字符的加强版：
6 d, R) n1 q6 u; x$ a8 `; p( c% u3 Z

1. /* （x,y）是显示的坐标，*p是字符串的首地址，size是字符点集大小 */
   
2. void OLED_Show_String( uint8_t x, uint8_t y, const uint8_t *p, uint8_t size, uint8_t mode )
   
3. {
   ' f) V( y+ L+ z0 k  \
4.                 /* 判断是否合法字符，同时也限定了范围 */
   
5.         while( (*p<='~')&&(*p>=' ') )
   % D! I) I# T6 R7 z4 T. i
6.         {
   
7.                 /* 如果初始行放不下，移动到下一行 */
   
8.                 if( x>(128-(size/2)) )
   : k' ?1 x- R8 a% I7 a
9.                 {
   
10.                         x=0;
    & E9 b7 u+ Z2 ]+ J
11.                         y=y+size;
    
12.                 }
    $ s/ A; q: Q# R/ D
13.                 if( y>(64-size) )
    ; M! V0 V6 x& E0 ?- |# @' b
14.                 {
    
15.                         x=y=0;
    
16.                         OLED_Clear();
    ( U0 l6 x. i; x8 {: C
17.                 }
    8 D) k) s" H3 {
18.                
    
19.                 OLED_Show_Char( x,y,*p,size,mode );
    ; v5 O8 X+ y: I2 H9 L$ c9 i; g' o# y
20.                 /* 移动到下一个字符位置，size/2是因为做点集时就是：行X列，而且 行=2X列，所以size就是行数 */
    
21.                 x=x+size/2;
    
22.                 p++;
    7 a- A) B3 s5 V1 p
23.         }
    
24. }
    
25. 
    

复制代码

8.显示特殊图像
显示特殊图像的方法和显示ASCII字符一样，只需要知道特殊图像的点阵信息即可，这个可以使用取模软件自己画点，再适当修改显示函数即可，学会了可以做一些特殊图像，包括汉字。当然，汉字也有字库，就是太大了，加上使用英文完全可以表达，所以只把需要显示的汉字做出来就行。当然，用来表白也是不错的！
8 R9 V. V3 \: A! x" n0 S5 @
/ o5 _1 L& s. j' r9 |( Y( |* r
) X( ~( p8 j3 I4 V. a
  a  l- q9 x7 _; p  Q2 R2 ?! B

! u( w% c- ~# ?. p! ~8 x0 h————————————————
9 g! e+ m! I4 O/ B版权声明：Aspirant-GQ
+ N; o0 p* v2 V+ J