一.OLED简介
9 r; _  B. ~1 B% W& l3 v" xOLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（OrganicElectroluminesence Display， OELD）。 OLED 由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。
模块特点：
没有背光，需要通过写入指令来开启显示
. R& S0 [3 a3 o+ U& r& P尺寸小：0.96寸，分辨率高：128*64
提供多种通信接口：6800、8080、3线/4线SPI、IIC
# J$ \( }& r9 F, o1 t- X7 a: T供电3.3V
& d# R* B! S- @: t

8 q! q1 P, r2 Z! q9 a' A; F6 h需要改变模块的通信接口时，只需要改变模块背后的电阻位置即可，如示：
& V% }' d8 X1 q0 w! G! ^
1 ?" ?5 s/ ?" d; R' Q, T



我是使用4线SPI驱动OLED的。


: L" _8 i( J& o6 S二.驱动SSD1306所需知识
1.引脚介绍
" h. G* r3 o( y) \
+ ~( @; c0 c5 f; H$ A; ?



  c% G' D: S/ V如图所示，各引脚的介绍如下：
+ {0 p. @$ W" y1 ]# xGND：接地引脚
VCC：接电源引脚，接3.3V直流电源即可
* r, H1 |' D( C: S4 g3 \( ND0：SPI的时钟线SCLK
  q! k# F& w  ]: g2 `: h- C, r, ND1：SPI的数据线SDIN
# T2 @: e6 F/ ZRES：复位接口，低电平初始化（复位），正常时高电平
8 n1 J  [+ o8 k/ WDC：用来选择命令or数据，低电平命令，高电平数据
3 ~* R9 z. w# }, bCS：片选线
' q  {2 r$ \' X: }" L6 W) J: O
& O) ?  Q+ F* H' C, p! O3 M% p5 g
4 v8 n* z1 N5 D, G注意：4线SPI模式时，只能写，不能读！
6 ^% P) x0 E9 W. W在本文的代码中，对应的接口如下：
SCLKC0 D0
SDINC1 D1
RES G15 拉低时初始化（复位），正常时拉高
DC D3 （0:命令 1:数据）
CS D6

5 ?3 S+ d7 q; u2 ~' H
2 @3 t2 X- s$ J$ V2.通信时序
单片机与OLED通信是4线SPI，每个数据长度为8位，在SCLK的上升沿数据有效，在上升沿数据从SDIN移入SSD1306，高位先行，D/C用来说明是传输命令还是数据。其通信时序图如示：
, @+ c5 H, v% v# {) `$ ?8 _

1 V" p* U. [1 l0 z8 Z- y! G! d
& K, P/ N2 B1 y8 h

3 S' p" l0 L3 _5 |& S由图知，SSD1306与单片机通信可以分为如下几步：
1.拉低片选CS，作为正常通信的前提
: y" z7 |& D# D0 q% B# {$ e2.根据需求操作D/C，低电平代表传输命令，高电平代表传输数据
3.时钟线SCLK不断产生时钟信号，上升沿数据线有效
6 p7 T/ W1 z: [9 B" j0 y4 F" P4.数据线SDIN根据SCLK的上升沿，从高位开始传输一帧数据（8位），置高代表1，拉低代表0
3 i8 w7 [- ^7 `3 a9 s* ~8 C! c
8 ^' d- i4 }, a( w
& _; h. A* R* @+ t3.显存GRAM
, U; }' V( j  W4 q! |0 A7 k在OLED上显示图像，图像的数据就存储在显存GRAM中，由于SSD1306的分辨率是128*64，代表屏幕上总共有128x64个像素点，所以其显存大小就是128x64bit，恰好可以存储一帧图像的信息。
SSD1306的在逻辑上把GRAM分为8页，每页包含128个字节（1个字节8位），即8x128x8=128x64，所以屏幕上的每一个像素点都对应着GRAM中的每一位，要想点亮屏幕上的某一个像素点，只要在开启显示的前提下，将GRAM中的相应位置一即可。
SSD1306的GRAM与屏幕上像素点的对应关系表如示：





以屏幕的左上角为原点，可以想象出一副坐标系，屏幕的大小范围就是x：0~ 127，y：0~64，实际上我们后续画点也是以此为基础的！
我们用一个二维数组来抽象的映射出屏幕上的每一个像素点：

1. /* OLED的显存 */
   
2. uint8_t OLED_GRAM[128][8];
   
3. /*
   ! N7 @0 v2 O( Q- Z( N  U
4. OLED_GRAM[128][8]中是8位二进制为一个单位
   
5. 其逻辑排序如示：（高位先行）
   3 q5 v% i& X2 H) `; y# a: ]
6. 7 7
   / s- W( [; J( C5 M1 B8 i5 D
7. 6 6
   - _7 Y) }) R. Q2 k
8. 5 5
   
9. 4 4  ...
   
10. 3 3
    ) G; P# R" b5 @1 A5 V# I! {2 }
11. 2 2
    
12. 1 1
    # d: _) ^. U2 E9 ?6 ~
13. 0 0
    . y1 ]8 Y. ~& {1 l3 N. ~
14. */
    

复制代码

到此，我们只需要把要显示图像的信息写入OLED_GRAM[128][8]数组中，再通过画点函数操作OLED_GRAM[128][8]中的每一位对应的像素点，就可以在OLED屏幕中显示图像了。
0 y6 G- T+ @, t

4.字库
要在屏幕中显示图像，最常见的是显示一些字符，这个时候就需要这些字符的图像信息了，这就涉及到字库。我理解，一个包含了一些字符图像的数组就可以称作字库，这样做的好处就是，可以根据所要显示的字符直接从字库中提取图像信息到GRAM，这样显示字符就方便多了。
! M6 F/ K9 C& E) L  i本项目所使用的字库大小有（高x宽）：12x6、16x8、24x12
而且字库的取模方式：阴码+逐列式+顺向+C51格式（用了取模软件PC2LCD2002）
& v# S0 ?2 B, V7 G/ }& ^每个字符所占用的字节数为size/8+((size%8)?1:0))*(size/2),其中size:是字库生成时的点阵大小
比如12x6字库信息如示：

1. //12*6 ASCII字符集点阵
   
2. const unsigned char asc2_1206[95][12]={
   5 M# K/ l; j+ ~& F: f( w% D
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*/
   ! {8 h8 e/ I  R' l9 U3 W9 }
5. {0x00,0x00,0x30,0x00,0x40,0x00,0x30,0x00,0x40,0x00,0x00,0x00},/*""",2*/
   
6. {0x09,0x00,0x0B,0xC0,0x3D,0x00,0x0B,0xC0,0x3D,0x00,0x09,0x00},/*"#",3*/
   
7. {0x18,0xC0,0x24,0x40,0x7F,0xE0,0x22,0x40,0x31,0x80,0x00,0x00},/*"$",4*/
   
8. {0x18,0x00,0x24,0xC0,0x1B,0x00,0x0D,0x80,0x32,0x40,0x01,0x80},/*"%",5*/
   : v' B* Y5 n1 c5 \
9. {0x03,0x80,0x1C,0x40,0x27,0x40,0x1C,0x80,0x07,0x40,0x00,0x40},/*"&",6*/
   
10. {0x10,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"'",7*/
    / X9 O* \8 j4 e0 B4 k9 t7 R
11. {0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x80,0x20,0x40,0x40,0x20},/*"(",8*/
    ! R$ q# Z' |. C% j7 J" S
12. {0x00,0x00,0x40,0x20,0x20,0x40,0x1F,0x80,0x00,0x00,0x00,0x00},/*")",9*/
    - U+ m6 ?7 j4 n0 g
13. {0x09,0x00,0x06,0x00,0x1F,0x80,0x06,0x00,0x09,0x00,0x00,0x00},/*"*",10*/
    ; l+ d) G0 t' {0 \5 X7 |
14. {0x04,0x00,0x04,0x00,0x3F,0x80,0x04,0x00,0x04,0x00,0x00,0x00},/*"+",11*/
    8 c% \- I% ]" a+ H, h
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*/
    % u6 K& B% B/ w) @5 X" J3 N3 J. T
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*/
    
20. {0x00,0x00,0x10,0x40,0x3F,0xC0,0x00,0x40,0x00,0x00,0x00,0x00},/*"1",17*/
    
21. {0x18,0xC0,0x21,0x40,0x22,0x40,0x24,0x40,0x18,0x40,0x00,0x00},/*"2",18*/
    
22. {0x10,0x80,0x20,0x40,0x24,0x40,0x24,0x40,0x1B,0x80,0x00,0x00},/*"3",19*/
    , M0 ]4 ]- w( ]3 m, c; L
23. {0x02,0x00,0x0D,0x00,0x11,0x00,0x3F,0xC0,0x01,0x40,0x00,0x00},/*"4",20*/
    3 ?' W  \) x% o3 x
24. {0x3C,0x80,0x24,0x40,0x24,0x40,0x24,0x40,0x23,0x80,0x00,0x00},/*"5",21*/
    2 l/ _9 A0 F, X* ~0 f
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*/
    
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*/
    / A/ c% t& Z5 M" n
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*/
    ( |# m8 @- v' y. V
32. {0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x00,0x00},/*"=",29*/
    + ~  R3 t) m, M( L- G) F0 K7 p
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*/
    1 f$ l0 m. v! T( t% h" V
35. {0x1F,0x80,0x20,0x40,0x27,0x40,0x29,0x40,0x1F,0x40,0x00,0x00},/*"@",32*/
    
36. {0x00,0x40,0x07,0xC0,0x39,0x00,0x0F,0x00,0x01,0xC0,0x00,0x40},/*"A",33*/
    4 x; E; E8 r' z4 e9 i
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*/
    
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*/
    
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*/
    " t' \6 ]* ?2 b- k
43. {0x20,0x40,0x3F,0xC0,0x04,0x00,0x04,0x00,0x3F,0xC0,0x20,0x40},/*"H",40*/
    . v! c3 v3 \% U& Z+ u( k% i
44. {0x20,0x40,0x20,0x40,0x3F,0xC0,0x20,0x40,0x20,0x40,0x00,0x00},/*"I",41*/
    7 s, Y" D7 Y1 X9 x7 o, o5 P
45. {0x00,0x60,0x20,0x20,0x20,0x20,0x3F,0xC0,0x20,0x00,0x20,0x00},/*"J",42*/
    
46. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x0B,0x00,0x30,0xC0,0x20,0x40},/*"K",43*/
    
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*/
    * i7 v7 P' V4 c/ O0 y9 a( \
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*/
    2 B7 G2 M* i6 R* c
51. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x24,0x00,0x18,0x00,0x00,0x00},/*"P",48*/
    
52. {0x1F,0x80,0x21,0x40,0x21,0x40,0x20,0xE0,0x1F,0xA0,0x00,0x00},/*"Q",49*/
    5 n- M  p" y7 b
53. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x26,0x00,0x19,0xC0,0x00,0x40},/*"R",50*/
    $ t/ L- @9 f3 t. R: p( W
54. {0x18,0xC0,0x24,0x40,0x24,0x40,0x22,0x40,0x31,0x80,0x00,0x00},/*"S",51*/
    
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*/
    # f5 E2 |# m6 Q
57. {0x20,0x00,0x3E,0x00,0x01,0xC0,0x07,0x00,0x38,0x00,0x20,0x00},/*"V",54*/
    " |: `/ j( K5 s2 G5 g
58. {0x38,0x00,0x07,0xC0,0x3C,0x00,0x07,0xC0,0x38,0x00,0x00,0x00},/*"W",55*/
    # n% ]6 ?0 T- T8 ~- H
59. {0x20,0x40,0x39,0xC0,0x06,0x00,0x39,0xC0,0x20,0x40,0x00,0x00},/*"X",56*/
    
60. {0x20,0x00,0x38,0x40,0x07,0xC0,0x38,0x40,0x20,0x00,0x00,0x00},/*"Y",57*/
    " l- t  P7 f" l' c6 K
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*/
    ) y0 a) a( F1 \1 Z
63. {0x00,0x00,0x70,0x00,0x0C,0x00,0x03,0x80,0x00,0x40,0x00,0x00},/*"",60*/
    " @$ Q: y) E: _8 c  \  j
64. {0x00,0x00,0x40,0x20,0x40,0x20,0x7F,0xE0,0x00,0x00,0x00,0x00},/*"]",61*/
    " ]* z" _/ E5 V* d
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*/
    ' P5 ~2 n( q7 g0 i( K
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*/
    8 B) h; a- T4 Y  }3 U9 I
69. {0x20,0x00,0x3F,0xC0,0x04,0x40,0x04,0x40,0x03,0x80,0x00,0x00},/*"b",66*/
    
70. {0x00,0x00,0x03,0x80,0x04,0x40,0x04,0x40,0x06,0x40,0x00,0x00},/*"c",67*/
    " U, e; y2 y* F" Y# Z
71. {0x00,0x00,0x03,0x80,0x04,0x40,0x24,0x40,0x3F,0xC0,0x00,0x40},/*"d",68*/
    
72. {0x00,0x00,0x03,0x80,0x05,0x40,0x05,0x40,0x03,0x40,0x00,0x00},/*"e",69*/
    & J" e! i- ~& N
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*/
    3 x4 G% I, l& C: e
75. {0x20,0x40,0x3F,0xC0,0x04,0x40,0x04,0x00,0x03,0xC0,0x00,0x40},/*"h",72*/
    + x4 i7 G' E5 `0 z: X
76. {0x00,0x00,0x04,0x40,0x27,0xC0,0x00,0x40,0x00,0x00,0x00,0x00},/*"i",73*/
    . w/ n. _. a- ^
77. {0x00,0x10,0x00,0x10,0x04,0x10,0x27,0xE0,0x00,0x00,0x00,0x00},/*"j",74*/
    ' ^$ Q% b7 B: n0 P0 s- o/ ]
78. {0x20,0x40,0x3F,0xC0,0x01,0x40,0x07,0x00,0x04,0xC0,0x04,0x40},/*"k",75*/
    ( i8 }* V  w  D, }4 G
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*/
    - `# m5 D- t; O: v% ]5 O
82. {0x00,0x00,0x03,0x80,0x04,0x40,0x04,0x40,0x03,0x80,0x00,0x00},/*"o",79*/
    3 g" p' p5 U1 m' S6 F
83. {0x04,0x10,0x07,0xF0,0x04,0x50,0x04,0x40,0x03,0x80,0x00,0x00},/*"p",80*/
    
84. {0x00,0x00,0x03,0x80,0x04,0x40,0x04,0x50,0x07,0xF0,0x00,0x10},/*"q",81*/
    ) x8 l( D5 e, m! n7 ]& c
85. {0x04,0x40,0x07,0xC0,0x02,0x40,0x04,0x00,0x04,0x00,0x00,0x00},/*"r",82*/
    9 I2 `1 c, z1 W: J% }# I
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*/
    . s2 J2 c1 k7 L! h
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*/
    ; O+ `* [4 d2 _2 B  f
91. {0x04,0x40,0x06,0xC0,0x01,0x00,0x06,0xC0,0x04,0x40,0x00,0x00},/*"x",88*/
    0 G* X& p! t! e
92. {0x04,0x10,0x07,0x10,0x04,0xE0,0x01,0x80,0x06,0x00,0x04,0x00},/*"y",89*/
    $ [8 Y& L' ]5 R
93. {0x00,0x00,0x04,0x40,0x05,0xC0,0x06,0x40,0x04,0x40,0x00,0x00},/*"z",90*/
    
94. {0x00,0x00,0x00,0x00,0x04,0x00,0x7B,0xE0,0x40,0x20,0x00,0x00},/*"{",91*/
    3 C. U1 b. `: E6 \1 W2 j
95. {0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xF0,0x00,0x00,0x00,0x00},/*"|",92*/
    8 Q$ B( j: C5 g! W
96. {0x00,0x00,0x40,0x20,0x7B,0xE0,0x04,0x00,0x00,0x00,0x00,0x00},/*"}",93*/
    $ J, O5 A) i, w9 V1 r6 e; T
97. {0x40,0x00,0x80,0x00,0x40,0x00,0x20,0x00,0x20,0x00,0x40,0x00},/*"~",94*/
    
98. };  
    ! Z% q8 c6 h$ u" _$ Q0 @2 d

复制代码

5.SSD1306基本命令
上面介绍了显存，我们已经知道OLED的图像显示原理了。然鹅，在显示图像之前，还要对SSD1306做一系列的初始化操作，这就用到一些相关指令了。


暂停一下！！！捋一下命令与数据的关系：
上面介绍过D/C线，D/C低电平代表传输命令，高电平代表传输数据。数据就是显存GRAM的内容，而命令就是下面要介绍的。所以OLED与单片机通信就是由单片机向OLED写入信息，开始写入命令来初始化，之后写入GRAM（图像的信息）即可！
# s) w: ?" o, z# b/ H. r" C( k

! u3 g5 u3 Y/ t7 u一些常用的命令如图所示：

; R% k/ m# x; k' J


* w1 Q5 w6 U* y: S# W/ v
比较重要的是设置起始坐标的三个命令
命令为 0XB0~B7，该命令用于设置页地址，其低三位的值对应着 GRAM 的页地址。
3 X3 y3 }3 J8 m. n2 {命令为 0X00~0X0F，该指令用于设置显示时的起始列地址低四位。
+ R8 i! M: s6 F命令为 0X10~0X1F，该指令用于设置显示时的起始列地址高四位。

, B6 C5 O* t& Z7 n% b( G
- D" t2 s3 c0 \2 V) N4 B/ M: S有关初始化OLED的所有命令会在下午代码讲解部分列出！


/ O3 |6 M; I% s$ k5 M8 P# Q# N三.代码讲解
1.相关引脚配置
上面介绍了相应的引脚，这里对相应引脚进行配置，注意：除了GND和VCC引脚，其余所有引脚的模式均为推挽输出，代码如下：
6 O* v& s& X4 a/ F: h1 |

1. /*
   
2. 配置4线SPI模式的所有引脚
   
3. 4线SPI模式只能写，不能读
   
4. SCLK:PC0  D0
   
5. SDIN:PC1  D1
   
6. RES :PG15  拉低时初始化（复位），正常时拉高
   
7. DC  :PD3  （0:命令  1:数据）
   ' {1 [! K* g" I6 I
8. CS  :PD6
   0 T* t; i7 x9 X+ p0 l% w( H
9. */
   
10. void OLED_GPIO_Config( void )
    
11. {
    
12.         GPIO_InitTypeDef GPIO_InitStruct;
    
13.        
    
14.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOG, ENABLE );
    - l% Y  ^$ [5 |- C! y" ?
15.        
    % A2 o! Y7 o0 D9 y3 M: s
16.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    
17.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    
18.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    
19.         GPIO_Init( GPIOC, &GPIO_InitStruct );
    , @2 |( c9 s5 {! G9 R0 c
20.        
    . i, U8 a# ~% v6 S* X6 S+ ]- y( j
21.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    * b" L+ |+ r- O) u, [
22.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_6;
    9 ^  L" W/ U9 z. ]
23.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    
24.         GPIO_Init( GPIOD, &GPIO_InitStruct );
    2 Z9 ~" S/ A% _' L
25. 
    
26.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    
27.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_15;
    5 X! E+ P3 T5 D8 t
28.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    # o5 a0 x) d3 J- r* ?1 Q
29.         GPIO_Init( GPIOG, &GPIO_InitStruct );
    
30. }
    * M% T' u+ T3 o

复制代码

% y3 T) d7 H* V. Y# Z" Q由通信时序知，通信的过程中需要不断改变引脚的电平，所以我写了一些对引脚电平操作的函数（格式都一样）：
: S! P# J1 o& R- ^+ g

1. void OLED_SCLK( uint8_t x )
   
2. {
   3 y4 K& q" S1 @  H8 m
3.         if( x==1 )
   
4.                 GPIO_SetBits( GPIOC, GPIO_Pin_0 );
   
5.         else
   1 Q# Y9 e! s) B. a* @2 c( }
6.                 GPIO_ResetBits( GPIOC, GPIO_Pin_0 );
   
7. }
   
8. 
   
9. void OLED_SDIN( uint8_t x )
   
10. {
    ! V+ ~2 P3 y; R
11.         if( x==0 )
    9 O! E' n5 \0 v7 n, V9 @. d0 |
12.                 GPIO_ResetBits( GPIOC, GPIO_Pin_1 );
    
13.         else
    5 n1 K3 g! G0 x
14.                 GPIO_SetBits( GPIOC, GPIO_Pin_1 );
    
15. }
    # j/ N+ S4 P  z1 I
16. 
    
17. void OLED_RES( uint8_t x )
    
18. {
    + Z3 |' Z9 q3 {6 ~$ e
19.         if( x==1 )
    $ U4 Q- u( M0 [9 O+ f
20.                 GPIO_SetBits( GPIOG, GPIO_Pin_15 );
    # W: I/ F9 ]/ a! N8 h* E8 X! l4 v
21.         else
    
22.                 GPIO_ResetBits( GPIOG, GPIO_Pin_15 );
    
23. }
    ( L5 K7 R$ D: r' c
24. 
    
25. void OLED_DC( uint8_t x )
    6 Q. x) a) c  o5 F
26. {
    
27.         if( x==1 )
    2 ^. V0 }2 q1 M% s0 h$ P4 Z
28.                 GPIO_SetBits( GPIOD, GPIO_Pin_3 );
    & H9 `3 S' m9 j4 ^5 g4 j5 M
29.         else
    # D( ]) ?) \$ c& X; w& v; d8 U0 S9 Y
30.                 GPIO_ResetBits( GPIOD, GPIO_Pin_3 );
    4 d) {! V) c7 Y) g2 f9 ^1 t
31. }
    : {( M; |6 v3 D7 X
32. 
    
33. void OLED_CS( uint8_t x )
    
34. {
    
35.         if( x==1 )
    - F# l5 X0 c0 ?$ o; R) Q: W2 X
36.                 GPIO_SetBits( GPIOD, GPIO_Pin_6 );
    
37.         else
    
38.                 GPIO_ResetBits( GPIOD, GPIO_Pin_6 );
    
39. }
    4 h3 Z2 p  k/ ?+ X6 F  m8 x

复制代码

% {5 F) Y. x* S6 u: g- A0 Q2.模拟SPI通信
我根据时序图模拟了SPI的通信协议，按照时序图对相应的引脚操作即可，一共写了俩个函数：写数据和写命令。函数如示：

1. 
   
2. /* 写一个命令 高位先行 */
   " ~6 K3 u$ K7 |6 Y
3. void OLED_WR_Cmd( uint8_t cmd )
   
4. {
   
5.         uint8_t i,k;
   
6.         /* 拉低片选CS，写命令拉低DC */
     h4 P4 L# z4 _% W
7.         OLED_CS(0);
   
8.         OLED_DC(0);
   
9.        
   % g8 C! \8 P1 E4 T/ g, P
10.         for( i=0;i<8;i++ )
    + }6 Y6 N# S) f* h" n
11.         {
    
12.                 /* 时钟线，上升沿有效 */
    
13.                 OLED_SCLK(0);
    
14.                 k=cmd&(0x80);
    
15.                 OLED_SDIN(k);
    6 M% \# R' d- P0 P7 j" _" A: I9 ]' @
16.                 OLED_SCLK(1);
      W  Z/ D# [4 S5 ~0 p9 b- k
17.                 cmd<<=1;
    
18.         }
    
19.         OLED_CS(1);
    
20.         OLED_DC(1);       
    
21. }
    . M2 M1 n! P! X, e8 v- ^
22. 
    
23. 
    / Q7 _: R" v: n/ t! \9 M* u
24. /* 写一个数据 高位先行 */
    
25. void OLED_WR_Data( uint8_t data )
    
26. {
    
27.         uint8_t i,k;
    
28.         /* 拉低片选CS，写数据拉高DC */
    
29.         OLED_CS(0);
    * i4 d% l: B1 o  v
30.         OLED_DC(1);
    5 ?4 F8 Z/ K% I7 Z, g( h
31.        
    % c: d3 I: y0 h- e% Y- ]2 F
32.         for( i=0;i<8;i++ )
      I$ R1 M% h" ~7 c# l) a+ D, M/ \
33.         {
    ; O9 n7 \! X$ R5 J1 {" \% k4 {7 A9 c
34.                 /* 时钟线，上升沿有效 */
    - T: q, w; i6 J: k) k$ T7 v
35.                 OLED_SCLK(0);
    6 R$ D7 M% ^* G
36.                 k=data&(0x80);
    , F) W: z5 z  X( c: T3 Q
37.                 OLED_SDIN(k);
    
38.                 OLED_SCLK(1);
    7 P6 x/ q  v1 Z4 N- |9 B
39.                 data<<=1;
    : b% K- _' \& X; C, I
40.         }
    ) S1 c& `) o1 }  s$ E1 I$ n+ U3 m
41.         OLED_CS(1);
    
42.         OLED_DC(1);
    ( a( h0 f% U2 {! l
43. }
    * S+ ~4 `& z& B4 {

复制代码

1 l8 C  @  K" P, O; g" j& X. h要注意：无论数据还是命令的传输，都是高位先行，这是根据时序图知道的。

3.OLED初始化函数
9 l; _4 d4 v5 b5 @3 C# f# j6 i前面说了，会有一堆初始化命令：

1. 
   
2. /* OLED初始化函数 */
   3 ~, O2 Q+ d  m) _
3. void OLED_Init( void )
   
4. {
   
5.         /* 引脚初始化 */
   % d) S; G& z, z  H! p9 i8 I* ?( r
6.         OLED_GPIO_Config();
   - I( i2 E* r7 Z; O; E, {
7.        
   . Z. l) Y# M6 @  m
8.         OLED_CS(1);
   2 R- h* O: ?& I
9.         OLED_DC(1);
   # L$ G6 g- V4 K
10.        
    
11.         /* 复位 */
      o: l  l' e6 c- f9 a' w- T0 Z
12.         OLED_RES(0);
    * e  P% ~. W9 }
13.         Delay_ms(1000);
    ; m# b5 Q3 y! a0 r4 M3 g' ~* E
14.         OLED_RES(1);
    
15.        
    & D: X8 V# _* l$ z% j- r  t
16.         /* 开始写入初始化命令 */
    ( |, X, B8 g' S
17.         OLED_WR_Cmd(0xAE);//关闭显示
    
18.         OLED_WR_Cmd(0xD5);//设置时钟分频因子
    
19.         OLED_WR_Cmd(80);
    8 e  S1 l  E  n( x0 I/ i
20.        
    7 b5 Y( O# X0 [4 J3 s
21.         OLED_WR_Cmd(0xA8);//设置驱动路数
    
22.         OLED_WR_Cmd(0x3F);//路数默认0x3F（1/64）
    
23.        
    9 M0 A4 V2 Q. G! Q! \
24.         OLED_WR_Cmd(0xD3);//设置显示偏移
    
25.         OLED_WR_Cmd(0x00);//偏移默认为0
    
26.        
      L' }* _: G7 Q: S# e
27.         OLED_WR_Cmd(0x40);//设置显示开始行[5:0]
    
28.        
    
29.         OLED_WR_Cmd(0x8D);//电荷泵设置
    / L: i) G) X2 N. i1 t
30.         OLED_WR_Cmd(0x14);//bit2，开启/关闭
    
31.        
    
32.         OLED_WR_Cmd(0x20);//设置内存地址模式
    
33.         OLED_WR_Cmd(0x02);//[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
    
34.        
    # d1 K; n! Z7 x8 n7 O1 c
35.         OLED_WR_Cmd(0xA1);//段重定义设置,bit0:0,0->0;1,0->127;
    & B( I- u/ L. f* @" J
36.         OLED_WR_Cmd(0xC0);//设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
    
37.         OLED_WR_Cmd(0xDA);//设置COM硬件引脚配置
    ' A; a% D) I: A- y: w
38.         OLED_WR_Cmd(0x12);//[5:4]配置
    
39.        
    
40.         OLED_WR_Cmd(0x81);//对比度设置
    ' ~* N( d; X& a. {/ l) j; ?; M
41.         OLED_WR_Cmd(0xEF);//默认0x7F（范围1~255，越大越亮）
    5 _6 X9 y  x- o. O% M/ M/ R) R
42.        
    
43.         OLED_WR_Cmd(0xD9);//设置预充电周期
    
44.         OLED_WR_Cmd(0xF1);//[3:0],PHASE 1;[7:4],PHASE 2;
    
45.        
    # ]# V* @$ _- Z2 j
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,正常显示
    3 o' `- P+ D5 J$ h1 r9 @: J0 w' I
51.        
    0 x: F- o) {5 C9 z8 F2 T( g, Y# I' B. V
52.         OLED_WR_Cmd(0xAF);//开启显示
    1 D; L7 z  ^$ ]2 M( }
53.        
    $ _# V- s% q' b3 n
54.         /* 清屏函数 */
      F) Z0 R8 f+ ?  A5 ~. |% P* ~+ Q0 y
55.         OLED_Clear();
    2 u# u& E4 k8 i4 T* P
56. }
    ( |2 l% h6 \3 m

复制代码

啥也不说了，照着写就完事了！


4.图像刷新与清屏函数
假设图像的信息都已经写到GRAM中了，那么就可以通过图像刷新函数，将GRAM中的图像画到OLED屏幕中，刷新函数如示：
6 f* y' l% ?, J- C8 [( `  k2 s

1. /* 图像刷新函数 */
   & h; H) Y; n8 R  e& @5 I2 o
2. void OLED_Refresh_GRAM( void )
   6 H3 D! Z1 f# m  c# F1 f8 O: T
3. {
   4 H  F% S+ {0 d+ L
4.         uint8_t i,j;
   
5.         for( i=0;i<8;i++ )
     i& X+ ]( h0 c2 |0 N4 K2 i& \
6.         {
   
7.                 /* 设置显示的起始地址 */
   
8.                 OLED_WR_Cmd(0xB0+i);//设置页地址（行）
   
9.                 OLED_WR_Cmd(0x00);//设置列地址的低四位
   
10.                 OLED_WR_Cmd(0x10);//设置列地址的高四位
    
11.                 for( j=0;j<128;j++ )
    ( j( r( @2 ]# ?1 y0 E# o$ G
12.                 {
    7 f- {& N8 Y2 y7 z
13.                         OLED_WR_Data(OLED_GRAM[j][i]);//将GRAM中图像信息写入屏幕
    6 L% c/ p9 {6 T! F
14.                 }
    ; ~  @1 S5 x+ M5 L: _
15.         }
    9 v$ C+ U. r1 x  ]- h7 o
16. }
    

复制代码

对应的，清屏函数就是将GRAM中图像的信息抹去，然后刷新一下：
& }% Z6 f; s% t1 O& I/ M/ q5 O

1. * 清屏函数 */
   * U. p* T  ?8 V5 |! w7 X
2. void OLED_Clear( void )
   0 {1 q1 x) V/ J& Q/ W/ Z
3. {
   
4.         uint8_t i,j;
   - K* e" I1 m2 S# }* S8 p5 `
5.         for( i=0;i<8;i++ )
   
6.                 for( j=0;j<128;j++ )
   
7.                         OLED_GRAM[j][i]=0x00;
   . H, u1 w( F+ d( t) t% {
8.         OLED_Refresh_GRAM();
   
9. }
   5 c+ M& t' |/ u

复制代码

7 Y2 E; ~! \+ g( m4 _$ C7 t  \5.画点函数
# e: {, ^. F5 |( _/ g所谓画点，就是将屏幕中指定位置的像素点点亮。在GRAM中就相当于把相对应的位置一，难点在于根据屏幕上的坐标推算出GRAM中的位置，函数如下：
1 v1 _1 a! s4 C3 s1 I8 V

1. //OLED_GRAM[128][8]
   ) {; B! V6 ~. c% L
2. /* 画点函数，以屏幕像素点为单位，以左上角为原点 x:0~127 y:0~63
   5 P* k& `  k# m' k2 F$ x
3. （x,y）坐标换算:OLED_GRAM[x][7-y/8]|=1<<(7-y%8)；
   
4. 
   9 i+ G0 K5 p9 a$ ]) k
5. mode取1正显，取0反显
   
6. */
   
7. void OLED_DrawPoint( uint8_t x,uint8_t y,uint8_t mode )
   ) l. J) g5 s3 |* \3 l# M& K1 G
8. {
   
9.         /* 主要是求出y坐标，根据y坐标来位运算OLED_GRAM中相应的位 */
   ! j! e4 `+ d4 f% d6 |0 |
10.         uint8_t i,j,temp;
    
11.         /* 判断坐标是否超出范围 */
    2 P- D% i; O: R$ d
12.         if(x>127||y>63)return;
    8 p; Y  S, t& ?& R! P7 c
13.        
    
14.         i=7-y/8;//算出第几页
    ' p% k$ K: q- w5 A' a9 j6 R
15.         j=y%8;
    ; s8 |3 {' u/ t9 }
16.         temp=0x01<<(7-j);//由位运算精确找出坐标像素点
    # `) b" @: N) a
17.         if(mode==0)
    % m; b( R: T6 ]! s8 O& O: @
18.                 OLED_GRAM[x][i]&=~temp;
    
19.         else
    7 l* a& w# p# H
20.                 OLED_GRAM[x][i]|=temp;
    " u# {$ W) ^. r7 \& ?
21. }
    

复制代码

6.显示字符函数
在某一坐标显示指定大小的字符，而且是从字库中提取字符图像信息，这就是显示字符函数：

1. /* 在（x,y）坐标正显/反显指定大小字符chr
   
2. mode：0是反显，1是正常显示
   
3. size：12/16/24
   2 M) w9 }2 i1 V
4. ASCII字符集: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
   4 i8 m  J1 v% M, O9 J8 z
5. */
   
6. void OLED_Show_Char( uint8_t x,uint8_t y,uint8_t chr,uint8_t size,uint8_t mode )
   4 Z8 H" @8 N$ m7 m( `
7. {
   
8.         /* temp是当前对应的一个字节的点集，y0是初始坐标 */
   9 Y  k7 [. I) b1 Z' T
9.         uint8_t temp,t,t1;
   
10.         uint8_t y0=y;
    
11.         /* csize是单个字符所占字节的多少 */
      U) G- D$ l; W
12.         uint8_t csize=(size/8+((size%8)?1:0))*(size/2);
    & Q' W% U; @( s5 p
13.         /* 求出偏移的地址差，即得到该字符在字库中的序号（从零开始） */
    . F! h1 |2 M" ], H+ Q7 t
14.         /* chr会锁定字符在字库中的的序号 */
    ' f. M# v# s7 p" ?7 p" r
15.         chr=chr-' ';
    & c# Z# O6 L3 @9 {! ~$ p! T( Q
16.        
    2 \7 ~  i7 M$ d: z
17.         /* 相应字符点集有多少个字节 */
    
18.         for( t=0;t<csize;t++ )
    8 \& p+ N$ ?; h4 d7 H
19.         {
    
20.                 /* 根据字符的大小选择相应字库，根据chr得到具体的字符地址 */
    , w* t" ?7 u9 D7 P
21.                 switch( size )
    & N- r/ L3 K9 H5 e
22.                 {
    
23.                         case 12:temp=asc2_1206[chr][t];break;//12x6(行x列)
    # h, P6 A7 C# @7 c; q, C
24.                         case 16:temp=asc2_1608[chr][t];break;//16x8
    
25.                         case 24:temp=asc2_2412[chr][t];break;//24x12
    4 o" [) O1 {- U3 F6 U. J
26.                         default:return;//没有相应字库
    ( }* T7 D! Z" P! n( f
27.                 }
    
28.                
    
29.                 /* 画出每一列的点 */
    
30.                 for( t1=0;t1<8;t1++ )
    
31.                 {
    
32.                         if( temp&0x80 )
    
33.                                 OLED_DrawPoint( x,y,mode );
    
34.                         else
    # p! v0 T) O1 R+ o; a
35.                                 OLED_DrawPoint( x,y,!mode );
    
36.                        
    
37.                         temp<<=1;
    
38.                         y++;
    
39.                        
    . f2 M1 Q/ A% R- Q
40.                         /* 根据给出每一列的像素点的多少，判断列是否满：
    ) V3 ?1 s5 `; [# x% B8 U) B
41.                         满了就换列，不满继续在此列画点 （与字库画点原理相关）                       
    
42.                         */
    - _9 A) l* D! M7 o) u% |
43.                         if( ( y-y0 )==size )
    1 c1 ]+ ]0 V9 ?" ?9 |
44.                         {
    
45.                                 y=y0;
    
46.                                 x++;
    
47.                                 /* 一列满，跳出循环，直接转到下一个字节点集的打印 */
    % h- P& x, \3 y9 v" \& B' h
48.                                 break;
    6 B7 M: h4 s# p" F% h
49.                         }
    - q0 b& B. }" x8 ]7 W: @
50.                 }
    ( N5 U& I% F8 J4 Z; }4 Z
51.         }
    
52. }
    

复制代码

7.显示字符串函数
/ }! [& u! {" q. _- j显示字符串，就是显示字符的加强版：

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 )
   ' d9 v3 p6 A5 c; D* o
3. {
   
4.                 /* 判断是否合法字符，同时也限定了范围 */
   9 K- U) l( j) e0 D4 }" U
5.         while( (*p<='~')&&(*p>=' ') )
   
6.         {
   
7.                 /* 如果初始行放不下，移动到下一行 */
   
8.                 if( x>(128-(size/2)) )
   2 A: Y: d" i3 P: u& @+ ^+ g
9.                 {
   , Q. x" ^. S- f+ V4 m
10.                         x=0;
    7 u5 G5 i2 C6 x% j& U7 @& }) A+ e: e
11.                         y=y+size;
    
12.                 }
    
13.                 if( y>(64-size) )
    6 R: x) W" B- X6 z
14.                 {
    ; k! A& y  {7 j/ w2 p- k
15.                         x=y=0;
    
16.                         OLED_Clear();
    8 c# e( _+ b) Y5 ^, R, A" X
17.                 }
    
18.                
    % Y* {  H5 |! ?" j
19.                 OLED_Show_Char( x,y,*p,size,mode );
    
20.                 /* 移动到下一个字符位置，size/2是因为做点集时就是：行X列，而且 行=2X列，所以size就是行数 */
    2 e% K! s/ U3 g" P, D$ @# [5 {1 D! e
21.                 x=x+size/2;
    & Z: A7 a: [7 @4 c. x8 M
22.                 p++;
    
23.         }
    
24. }
    
25. 
    7 h$ B- @6 P3 h) \; H/ ?  K. W0 C: T

复制代码

' o) z3 q2 [2 }$ Z& ~9 u1 ^8 D8.显示特殊图像
3 A7 E  v' [% Z显示特殊图像的方法和显示ASCII字符一样，只需要知道特殊图像的点阵信息即可，这个可以使用取模软件自己画点，再适当修改显示函数即可，学会了可以做一些特殊图像，包括汉字。当然，汉字也有字库，就是太大了，加上使用英文完全可以表达，所以只把需要显示的汉字做出来就行。当然，用来表白也是不错的！

4 X5 J  B1 a) p2 s



————————————————
  M! ~/ _% @) g$ G" c1 D版权声明：Aspirant-GQ

% H5 a4 [" O9 {2 c) j