一.OLED简介
OLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（OrganicElectroluminesence Display， OELD）。 OLED 由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。
模块特点：
没有背光，需要通过写入指令来开启显示
尺寸小：0.96寸，分辨率高：128*64
提供多种通信接口：6800、8080、3线/4线SPI、IIC
/ U+ r9 |: y* o& a, y% `供电3.3V
( h& r4 n  f" i) U# c1 V

/ m- L  e4 f2 o% r, j6 y' O$ D需要改变模块的通信接口时，只需要改变模块背后的电阻位置即可，如示：
# E' l: v$ h& X& i: N( c  E  t

# S; `; J+ {; B4 T8 v


7 g. p3 p1 H) O* j& r* U我是使用4线SPI驱动OLED的。

! N1 z1 a2 \. T( z$ Z. u
, J) u2 b7 p0 o# |" E" |2 G7 J( y二.驱动SSD1306所需知识
. v% U. e- y5 ?) {& `1 V4 H0 q1.引脚介绍
! n; s! F( x  {



  l! f) m. B9 k+ U( x) X  r  ?
3 g# p  v" A' ~1 v' e  }6 |如图所示，各引脚的介绍如下：
GND：接地引脚
VCC：接电源引脚，接3.3V直流电源即可
% Y# D3 R, S( E' d5 XD0：SPI的时钟线SCLK
* r  E6 L8 E- Z5 Y# m1 e% bD1：SPI的数据线SDIN
RES：复位接口，低电平初始化（复位），正常时高电平
  t" Z/ `! A/ f5 N; Q2 D& {  U' iDC：用来选择命令or数据，低电平命令，高电平数据
CS：片选线


注意：4线SPI模式时，只能写，不能读！
在本文的代码中，对应的接口如下：
SCLKC0 D0
SDINC1 D1
1 @- z/ B$ R. z% e2 bRES G15 拉低时初始化（复位），正常时拉高
DC D3 （0:命令 1:数据）
8 g# A: A0 {& hCS D6
5 R9 ]7 X* w1 @: D* _( k) R! C' V

$ w5 e! Y, ]8 j# Z( c, v+ j2.通信时序
单片机与OLED通信是4线SPI，每个数据长度为8位，在SCLK的上升沿数据有效，在上升沿数据从SDIN移入SSD1306，高位先行，D/C用来说明是传输命令还是数据。其通信时序图如示：
( @' G0 s& O% P" e2 G7 {9 }
7 F) b0 e6 S( Y- y
( k/ {5 ?- ~3 j* x, R4 V/ f

$ X8 U0 E$ z! R' V, Q: ]. j0 A
. h; q& c1 N9 O1 j由图知，SSD1306与单片机通信可以分为如下几步：
4 N  G  G" w+ O8 F8 y1.拉低片选CS，作为正常通信的前提
- h% T% w6 Y' J7 b. i2.根据需求操作D/C，低电平代表传输命令，高电平代表传输数据
3.时钟线SCLK不断产生时钟信号，上升沿数据线有效
: N# P6 B5 Q( G/ H4.数据线SDIN根据SCLK的上升沿，从高位开始传输一帧数据（8位），置高代表1，拉低代表0
7 E5 c1 ~. G, n2 d* i0 _

3.显存GRAM
, Q; `; d/ X) j2 ?在OLED上显示图像，图像的数据就存储在显存GRAM中，由于SSD1306的分辨率是128*64，代表屏幕上总共有128x64个像素点，所以其显存大小就是128x64bit，恰好可以存储一帧图像的信息。
. r0 f6 a$ J/ J: x  m( c& I3 E/ YSSD1306的在逻辑上把GRAM分为8页，每页包含128个字节（1个字节8位），即8x128x8=128x64，所以屏幕上的每一个像素点都对应着GRAM中的每一位，要想点亮屏幕上的某一个像素点，只要在开启显示的前提下，将GRAM中的相应位置一即可。
SSD1306的GRAM与屏幕上像素点的对应关系表如示：




" I! X& U) K8 w
以屏幕的左上角为原点，可以想象出一副坐标系，屏幕的大小范围就是x：0~ 127，y：0~64，实际上我们后续画点也是以此为基础的！
; q+ p" g. X: e% J! f我们用一个二维数组来抽象的映射出屏幕上的每一个像素点：

1. /* OLED的显存 */
   
2. uint8_t OLED_GRAM[128][8];
   
3. /*
   
4. OLED_GRAM[128][8]中是8位二进制为一个单位
   * C/ E7 I! n) _2 d5 X  k
5. 其逻辑排序如示：（高位先行）
   
6. 7 7
   6 E( e. `1 `6 {0 |9 H" l
7. 6 6
   
8. 5 5
   
9. 4 4  ...
   
10. 3 3
    0 W/ {8 @# ~; @) @
11. 2 2
    
12. 1 1
    ( A9 k. ~) l- X2 p
13. 0 0
    1 V  ]& Y  j" A- T0 R
14. */
    

复制代码

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


' T7 ~. c- c) c/ U4.字库
要在屏幕中显示图像，最常见的是显示一些字符，这个时候就需要这些字符的图像信息了，这就涉及到字库。我理解，一个包含了一些字符图像的数组就可以称作字库，这样做的好处就是，可以根据所要显示的字符直接从字库中提取图像信息到GRAM，这样显示字符就方便多了。
本项目所使用的字库大小有（高x宽）：12x6、16x8、24x12
而且字库的取模方式：阴码+逐列式+顺向+C51格式（用了取模软件PC2LCD2002）
4 C* ?$ _" F( {* P. P1 @每个字符所占用的字节数为size/8+((size%8)?1:0))*(size/2),其中size:是字库生成时的点阵大小
比如12x6字库信息如示：
8 u  j6 Z+ W* a  H  b

1. //12*6 ASCII字符集点阵
   : u( s7 e8 `6 U$ D# b8 o
2. const unsigned char asc2_1206[95][12]={
   
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*/
   
5. {0x00,0x00,0x30,0x00,0x40,0x00,0x30,0x00,0x40,0x00,0x00,0x00},/*""",2*/
   , r+ A) p, E3 l2 l5 A+ N" ?
6. {0x09,0x00,0x0B,0xC0,0x3D,0x00,0x0B,0xC0,0x3D,0x00,0x09,0x00},/*"#",3*/
   $ e- T6 D. M4 |6 r
7. {0x18,0xC0,0x24,0x40,0x7F,0xE0,0x22,0x40,0x31,0x80,0x00,0x00},/*"$",4*/
   ' U* f! l8 y7 c3 k3 ^" N2 `4 V
8. {0x18,0x00,0x24,0xC0,0x1B,0x00,0x0D,0x80,0x32,0x40,0x01,0x80},/*"%",5*/
   0 t" M# x9 P$ m- ~% N
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*/
    8 B4 u% R. u% G' b9 ]- P% C4 g- n
11. {0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x80,0x20,0x40,0x40,0x20},/*"(",8*/
    ' z$ t) E9 W4 T/ M; t; o5 a1 X7 K
12. {0x00,0x00,0x40,0x20,0x20,0x40,0x1F,0x80,0x00,0x00,0x00,0x00},/*")",9*/
    + T& b- \7 v1 v! ~! s! z
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*/
    : ^" I8 Q2 a" L
18. {0x00,0x20,0x01,0xC0,0x06,0x00,0x38,0x00,0x40,0x00,0x00,0x00},/*"/",15*/
    " m+ U  P1 {+ i( F& z* ]
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*/
    3 [3 q6 P1 ]6 `+ \6 r2 W9 z2 K/ B
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*/
    
23. {0x02,0x00,0x0D,0x00,0x11,0x00,0x3F,0xC0,0x01,0x40,0x00,0x00},/*"4",20*/
    
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*/
    * J6 m( A" V. b9 |: m! k$ A
27. {0x1B,0x80,0x24,0x40,0x24,0x40,0x24,0x40,0x1B,0x80,0x00,0x00},/*"8",24*/
    9 T$ a0 A' E: [- d( h
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*/
      R  [( x3 `7 X0 v
32. {0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x00,0x00},/*"=",29*/
    . [0 T( x/ B! U' g
33. {0x00,0x00,0x40,0x40,0x20,0x80,0x11,0x00,0x0A,0x00,0x04,0x00},/*">",30*/
    9 q+ H, K8 T9 v1 b
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*/
    
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*/
    5 P: O3 T" ^- X/ ^' {
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*/
    
43. {0x20,0x40,0x3F,0xC0,0x04,0x00,0x04,0x00,0x3F,0xC0,0x20,0x40},/*"H",40*/
    
44. {0x20,0x40,0x20,0x40,0x3F,0xC0,0x20,0x40,0x20,0x40,0x00,0x00},/*"I",41*/
    
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*/
    ! L9 g9 \* b- ]- F; G& 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*/
    . }) h* O1 h) B4 m( X! S5 S
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*/
    ; i  Q  I8 F$ k: K5 a! Y! z4 |
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*/
    
57. {0x20,0x00,0x3E,0x00,0x01,0xC0,0x07,0x00,0x38,0x00,0x20,0x00},/*"V",54*/
    , F3 o5 m% ^) C! ^. h
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*/
    
60. {0x20,0x00,0x38,0x40,0x07,0xC0,0x38,0x40,0x20,0x00,0x00,0x00},/*"Y",57*/
    8 `$ X7 {& A' x* i+ [
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*/
    ) E+ M1 J- f+ H# S, Y
63. {0x00,0x00,0x70,0x00,0x0C,0x00,0x03,0x80,0x00,0x40,0x00,0x00},/*"",60*/
    
64. {0x00,0x00,0x40,0x20,0x40,0x20,0x7F,0xE0,0x00,0x00,0x00,0x00},/*"]",61*/
      c! u% `. z7 ]
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*/
    
67. {0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"`",64*/
    ! r( c0 N5 K& B7 ~
68. {0x00,0x00,0x02,0x80,0x05,0x40,0x05,0x40,0x03,0xC0,0x00,0x40},/*"a",65*/
    ! c5 x& n/ j  f% N8 d, w' H
69. {0x20,0x00,0x3F,0xC0,0x04,0x40,0x04,0x40,0x03,0x80,0x00,0x00},/*"b",66*/
    9 K7 j9 E8 P/ j# ?! K
70. {0x00,0x00,0x03,0x80,0x04,0x40,0x04,0x40,0x06,0x40,0x00,0x00},/*"c",67*/
    
71. {0x00,0x00,0x03,0x80,0x04,0x40,0x24,0x40,0x3F,0xC0,0x00,0x40},/*"d",68*/
    # I, h2 C. A/ K( T4 g( u: j  G
72. {0x00,0x00,0x03,0x80,0x05,0x40,0x05,0x40,0x03,0x40,0x00,0x00},/*"e",69*/
    1 v/ U' M( w: F7 ^3 I
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*/
    
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*/
    
77. {0x00,0x10,0x00,0x10,0x04,0x10,0x27,0xE0,0x00,0x00,0x00,0x00},/*"j",74*/
    " d, [9 f5 R5 A7 i
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*/
    # Q( t" e+ g2 L+ g' y8 A5 K; o
80. {0x07,0xC0,0x04,0x00,0x07,0xC0,0x04,0x00,0x03,0xC0,0x00,0x00},/*"m",77*/
    2 e5 k/ ]4 N6 G, Q, `5 o
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*/
    
83. {0x04,0x10,0x07,0xF0,0x04,0x50,0x04,0x40,0x03,0x80,0x00,0x00},/*"p",80*/
    8 j5 d6 |  S3 u; w; v* N
84. {0x00,0x00,0x03,0x80,0x04,0x40,0x04,0x50,0x07,0xF0,0x00,0x10},/*"q",81*/
    8 G6 }6 V' K) ?% s( y
85. {0x04,0x40,0x07,0xC0,0x02,0x40,0x04,0x00,0x04,0x00,0x00,0x00},/*"r",82*/
    ( W6 x2 h) F+ |7 W  m* l8 C
86. {0x00,0x00,0x06,0x40,0x05,0x40,0x05,0x40,0x04,0xC0,0x00,0x00},/*"s",83*/
    : t# K7 y& @# s1 W0 z0 Q) `
87. {0x00,0x00,0x04,0x00,0x1F,0x80,0x04,0x40,0x00,0x40,0x00,0x00},/*"t",84*/
    # B$ V# R1 `0 O6 s! q, p
88. {0x04,0x00,0x07,0x80,0x00,0x40,0x04,0x40,0x07,0xC0,0x00,0x40},/*"u",85*/
    ) w0 e, i9 E" m( C
89. {0x04,0x00,0x07,0x00,0x04,0xC0,0x01,0x80,0x06,0x00,0x04,0x00},/*"v",86*/
    * Y: P# b8 G1 ~( {
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*/
    9 a4 P! x: x  G
92. {0x04,0x10,0x07,0x10,0x04,0xE0,0x01,0x80,0x06,0x00,0x04,0x00},/*"y",89*/
    % H1 Q# Q3 m. m# U4 k
93. {0x00,0x00,0x04,0x40,0x05,0xC0,0x06,0x40,0x04,0x40,0x00,0x00},/*"z",90*/
    ( H  k& {9 t$ C/ i3 S1 \
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*/
      S+ u! w6 f1 K7 d
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*/
    8 `7 B) G: A* J% j
98. };  
    

复制代码

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

暂停一下！！！捋一下命令与数据的关系：
上面介绍过D/C线，D/C低电平代表传输命令，高电平代表传输数据。数据就是显存GRAM的内容，而命令就是下面要介绍的。所以OLED与单片机通信就是由单片机向OLED写入信息，开始写入命令来初始化，之后写入GRAM（图像的信息）即可！
# z% K& u. C6 z7 J' i/ S* n7 |

一些常用的命令如图所示：

6 X) H4 X+ ]1 k0 H+ y1 ]! U; H


" V  ~1 ]6 C4 n2 k
% r7 f- p1 v' R比较重要的是设置起始坐标的三个命令
命令为 0XB0~B7，该命令用于设置页地址，其低三位的值对应着 GRAM 的页地址。
. X$ V7 P; o' ?- P( r3 @" G5 F1 n) i- q命令为 0X00~0X0F，该指令用于设置显示时的起始列地址低四位。
命令为 0X10~0X1F，该指令用于设置显示时的起始列地址高四位。
: J' _6 m& V+ M: F7 G; P1 r
; N: u) B* D/ |9 f; `8 L4 O
% |( G. p" }7 t9 x- I& ^2 ]有关初始化OLED的所有命令会在下午代码讲解部分列出！
1 l" `# a7 Q0 x) l% L3 q3 P$ ~+ V

三.代码讲解
. Z" J* k: O- `# u3 t5 s1.相关引脚配置
上面介绍了相应的引脚，这里对相应引脚进行配置，注意：除了GND和VCC引脚，其余所有引脚的模式均为推挽输出，代码如下：

1. /*
   
2. 配置4线SPI模式的所有引脚
   : z" [% R' G: o$ _# S( _
3. 4线SPI模式只能写，不能读
   ; k4 d2 u8 ^/ _2 c2 v
4. SCLK:PC0  D0
   
5. SDIN:PC1  D1
   
6. RES :PG15  拉低时初始化（复位），正常时拉高
   3 D. Y2 k* h8 d+ o& P% o! @- h
7. DC  :PD3  （0:命令  1:数据）
   & s: ?1 P( v  ?7 ~
8. CS  :PD6
   6 R  o2 J3 Q9 ]  g& H- v* F
9. */
   
10. void OLED_GPIO_Config( void )
    / S5 V) N: u1 H# [
11. {
    ( N3 z' @5 q9 Q. F2 o' d$ J4 q
12.         GPIO_InitTypeDef GPIO_InitStruct;
    1 o6 t, X! F' h1 j) }# s: z
13.        
    
14.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOG, ENABLE );
    # y; g5 U! y6 X* m
15.        
    ( P% s4 N) {/ \0 }# }/ T* k
16.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    
17.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    7 l" v. c! ?( ^& J
18.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    
19.         GPIO_Init( GPIOC, &GPIO_InitStruct );
    
20.        
    
21.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    & y  h4 B. m1 L: g, E2 b6 g
22.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_6;
    + r1 C2 m/ S" @# Q2 z
23.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    . \& N) W$ H+ z% @# A
24.         GPIO_Init( GPIOD, &GPIO_InitStruct );
    # y! v: M5 _0 _0 B# f8 M1 Q
25. 
    $ q! o* z* x& [3 L& L
26.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    
27.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_15;
    
28.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    
29.         GPIO_Init( GPIOG, &GPIO_InitStruct );
    
30. }
    - R# ?6 G! N6 i$ p

复制代码

' C: \# |9 v2 ^3 s& H) J+ C由通信时序知，通信的过程中需要不断改变引脚的电平，所以我写了一些对引脚电平操作的函数（格式都一样）：

1. void OLED_SCLK( uint8_t x )
   
2. {
   
3.         if( x==1 )
   ' x, s  L+ H& R! ], V
4.                 GPIO_SetBits( GPIOC, GPIO_Pin_0 );
   
5.         else
   
6.                 GPIO_ResetBits( GPIOC, GPIO_Pin_0 );
   # |. I$ B+ K+ a* E! E
7. }
   
8. 
   9 u! y, |/ `. |
9. void OLED_SDIN( uint8_t x )
   3 T; }1 Y- i- B
10. {
    
11.         if( x==0 )
    4 H0 A/ G% L) k( v
12.                 GPIO_ResetBits( GPIOC, GPIO_Pin_1 );
    ; K, T8 O! O+ {) e3 p0 j) {: s
13.         else
      ^) [) D/ h& l( k
14.                 GPIO_SetBits( GPIOC, GPIO_Pin_1 );
    8 z% F$ g0 N8 J8 ^
15. }
    , O, o; i. ~) Y! q5 Z
16. 
      Y/ b' l; c) a2 O+ b+ s& G; t4 ^
17. void OLED_RES( uint8_t x )
    
18. {
    
19.         if( x==1 )
    + k' A- O6 s6 z- G: O0 h- q6 M& U; Q
20.                 GPIO_SetBits( GPIOG, GPIO_Pin_15 );
    
21.         else
    4 O* E3 j* r$ ?* j
22.                 GPIO_ResetBits( GPIOG, GPIO_Pin_15 );
    , E: t5 \) a( ]( M
23. }
    
24. 
    + X- G  g$ Z2 R1 R
25. void OLED_DC( uint8_t x )
    ; v& P8 n7 L) s8 ~" B; e( T5 {
26. {
    # B; u# J# z- Q! C/ e+ l1 |/ N
27.         if( x==1 )
    
28.                 GPIO_SetBits( GPIOD, GPIO_Pin_3 );
    
29.         else
    9 a7 z, @! `7 ?" Z! G4 Y+ A1 l, ?
30.                 GPIO_ResetBits( GPIOD, GPIO_Pin_3 );
    # o( V6 y3 L/ o2 |& s) D2 s' {- |
31. }
    
32. 
    ( B2 E( z: F; Q$ H  ?, ?9 \/ B
33. void OLED_CS( uint8_t x )
    2 U# [  N+ p( b  V' R% i" R
34. {
    
35.         if( x==1 )
    + v4 w) J9 O  g
36.                 GPIO_SetBits( GPIOD, GPIO_Pin_6 );
    ! ~2 o# S6 \2 A9 ^( [
37.         else
    6 h6 {# p; ^. w8 G2 ]* c8 B
38.                 GPIO_ResetBits( GPIOD, GPIO_Pin_6 );
    ( z) u  K, y$ e2 i9 ]" u
39. }
    

复制代码

2.模拟SPI通信
我根据时序图模拟了SPI的通信协议，按照时序图对相应的引脚操作即可，一共写了俩个函数：写数据和写命令。函数如示：
+ J/ y/ }6 a! q) L5 ~7 s# d

1. 
   
2. /* 写一个命令 高位先行 */
   4 l) Q9 a# ~: Y# |8 a! n1 ?! u
3. void OLED_WR_Cmd( uint8_t cmd )
   
4. {
   
5.         uint8_t i,k;
   ; J3 d) k4 f( @, Q! k2 A: h
6.         /* 拉低片选CS，写命令拉低DC */
   
7.         OLED_CS(0);
   8 d/ {8 `# U7 T# g" R
8.         OLED_DC(0);
   
9.        
   
10.         for( i=0;i<8;i++ )
    $ r* p+ ~0 u3 ~
11.         {
    
12.                 /* 时钟线，上升沿有效 */
    
13.                 OLED_SCLK(0);
    
14.                 k=cmd&(0x80);
    ' q1 O& T- z4 j  C% Q
15.                 OLED_SDIN(k);
    
16.                 OLED_SCLK(1);
    $ [6 K& C& c1 {" F# n+ r
17.                 cmd<<=1;
    
18.         }
    : b  x" n8 v% J7 Q8 {4 R  J
19.         OLED_CS(1);
    5 e2 f# B( \! ~( J3 F- ?
20.         OLED_DC(1);       
    1 p2 d! d$ ]- b* z/ b$ z1 Z
21. }
    + C8 o7 w: L6 k5 X' G
22. 
    
23. 
    
24. /* 写一个数据 高位先行 */
    , W- }3 ?0 d# i, D; x  j
25. void OLED_WR_Data( uint8_t data )
    
26. {
    # V& X) P/ g% d7 {5 U/ N6 d
27.         uint8_t i,k;
      c  j( |% N& p; f. G1 t
28.         /* 拉低片选CS，写数据拉高DC */
    
29.         OLED_CS(0);
    7 G5 A% F( M3 f2 Z( e: S
30.         OLED_DC(1);
    : a. K' ~# M. }$ h5 q# r
31.        
      v3 C4 ^( l6 r2 c4 C) F: ]) U
32.         for( i=0;i<8;i++ )
    3 x( J5 X# s  ]* R0 O
33.         {
    4 ]. Q9 F9 i) M8 `0 L
34.                 /* 时钟线，上升沿有效 */
    
35.                 OLED_SCLK(0);
    2 H& m% Q; t6 T2 w: f, R7 I7 R
36.                 k=data&(0x80);
    
37.                 OLED_SDIN(k);
    
38.                 OLED_SCLK(1);
    ; R# I6 z2 L8 f8 p& G: O& I0 Z2 @
39.                 data<<=1;
    ) w- R" D) q" l! ?4 s# y
40.         }
    
41.         OLED_CS(1);
    6 _+ c. D8 P# x
42.         OLED_DC(1);
    
43. }
    

复制代码

要注意：无论数据还是命令的传输，都是高位先行，这是根据时序图知道的。

, L5 b9 H: p1 k* s( v& B5 M8 {0 S3.OLED初始化函数
前面说了，会有一堆初始化命令：
; L, x4 U. s* ?! ~

1. 
   3 S0 r* G6 ^+ _
2. /* OLED初始化函数 */
   8 s8 o0 k' z# p
3. void OLED_Init( void )
   
4. {
   
5.         /* 引脚初始化 */
   * r1 X8 ], p+ j7 z" k; P
6.         OLED_GPIO_Config();
   
7.        
   
8.         OLED_CS(1);
   
9.         OLED_DC(1);
   
10.        
    4 l( I; R" Z. M& x
11.         /* 复位 */
    ; u1 x5 y0 C+ ?0 e
12.         OLED_RES(0);
    7 d, L6 I5 A* a8 n/ ~
13.         Delay_ms(1000);
    ! |1 ]5 c: n1 O9 q
14.         OLED_RES(1);
    
15.        
    
16.         /* 开始写入初始化命令 */
    
17.         OLED_WR_Cmd(0xAE);//关闭显示
    ' j1 S1 g1 Y; N8 J' a
18.         OLED_WR_Cmd(0xD5);//设置时钟分频因子
    - G$ l; M3 g  F7 x7 }$ r
19.         OLED_WR_Cmd(80);
    9 P' S0 p5 g8 i8 t; z" L1 v; f% \3 J
20.        
    
21.         OLED_WR_Cmd(0xA8);//设置驱动路数
    ( D% n1 z: F, \. [
22.         OLED_WR_Cmd(0x3F);//路数默认0x3F（1/64）
    0 A- h' D4 {. a5 G3 U+ R
23.        
    
24.         OLED_WR_Cmd(0xD3);//设置显示偏移
    
25.         OLED_WR_Cmd(0x00);//偏移默认为0
    5 B8 H3 x2 A. o6 q! j$ C" S6 W
26.        
    
27.         OLED_WR_Cmd(0x40);//设置显示开始行[5:0]
    
28.        
    
29.         OLED_WR_Cmd(0x8D);//电荷泵设置
    1 ]5 C! ~' w% w* j& A
30.         OLED_WR_Cmd(0x14);//bit2，开启/关闭
    
31.        
    9 L9 S9 r/ g$ T& Z$ [. ^2 Y: o
32.         OLED_WR_Cmd(0x20);//设置内存地址模式
    2 l$ J' b# A8 e  h% s4 [
33.         OLED_WR_Cmd(0x02);//[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
    
34.        
    1 E! R* A- o; v+ g* [/ k; n
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:驱动路数
    4 X6 W" u$ G2 [% k: [/ D3 S  \6 k
37.         OLED_WR_Cmd(0xDA);//设置COM硬件引脚配置
    
38.         OLED_WR_Cmd(0x12);//[5:4]配置
    
39.        
    ! X/ ~/ {5 y' x; D+ V; G3 D8 P
40.         OLED_WR_Cmd(0x81);//对比度设置
    
41.         OLED_WR_Cmd(0xEF);//默认0x7F（范围1~255，越大越亮）
    
42.        
    
43.         OLED_WR_Cmd(0xD9);//设置预充电周期
    + P# k7 ?, b8 @1 ]
44.         OLED_WR_Cmd(0xF1);//[3:0],PHASE 1;[7:4],PHASE 2;
    
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,正常显示
    0 e5 L/ I9 e* q( i
51.        
    ( W0 u7 t7 s, h2 k6 M
52.         OLED_WR_Cmd(0xAF);//开启显示
    
53.        
    
54.         /* 清屏函数 */
    
55.         OLED_Clear();
    
56. }
    , S0 w7 H2 R  n* ?: {1 f+ `

复制代码

啥也不说了，照着写就完事了！
: W7 o- V% {$ K/ ~

4.图像刷新与清屏函数
% S8 f4 c1 G1 u2 G8 j5 u假设图像的信息都已经写到GRAM中了，那么就可以通过图像刷新函数，将GRAM中的图像画到OLED屏幕中，刷新函数如示：
, ?: S. K/ `# U- A" c: a9 D. F% t5 \

1. /* 图像刷新函数 */
   ' L* p) h0 T) m2 o* E3 y+ ], k
2. void OLED_Refresh_GRAM( void )
   * N, o) `' e" l+ U/ \) M  b! T% `
3. {
   ) M9 S7 N; D; D5 h0 w/ o( E
4.         uint8_t i,j;
   . U; ]: j9 C" z) r! u+ L1 t
5.         for( i=0;i<8;i++ )
   
6.         {
   
7.                 /* 设置显示的起始地址 */
   / z. M$ [' ^# x" i; s
8.                 OLED_WR_Cmd(0xB0+i);//设置页地址（行）
   * u6 B6 z# Y, u3 b( e& E  L
9.                 OLED_WR_Cmd(0x00);//设置列地址的低四位
     x: i. `# t( h0 z6 J  c
10.                 OLED_WR_Cmd(0x10);//设置列地址的高四位
    3 C$ V+ b9 w) r% t
11.                 for( j=0;j<128;j++ )
    
12.                 {
    ; k1 a5 h( M8 e8 ^8 N; p
13.                         OLED_WR_Data(OLED_GRAM[j][i]);//将GRAM中图像信息写入屏幕
    
14.                 }
    6 \5 j5 e- l2 r3 T; a
15.         }
    7 {8 N, i/ q" f, b3 c! P- m
16. }
    & m. I+ W7 p- f6 V8 |

复制代码

对应的，清屏函数就是将GRAM中图像的信息抹去，然后刷新一下：

1. * 清屏函数 */
   
2. void OLED_Clear( void )
   
3. {
   
4.         uint8_t i,j;
   # w% A- i6 l" [* N9 v
5.         for( i=0;i<8;i++ )
   # b# D/ x3 g  m. b
6.                 for( j=0;j<128;j++ )
   " y" {! j" k) `" g
7.                         OLED_GRAM[j][i]=0x00;
   
8.         OLED_Refresh_GRAM();
   
9. }
   2 C7 a, L6 j1 w* Q6 Y

复制代码

' F, }1 h0 z% H4 p5.画点函数
所谓画点，就是将屏幕中指定位置的像素点点亮。在GRAM中就相当于把相对应的位置一，难点在于根据屏幕上的坐标推算出GRAM中的位置，函数如下：
4 D8 o: b) Y: [! a, b* L

1. //OLED_GRAM[128][8]
   
2. /* 画点函数，以屏幕像素点为单位，以左上角为原点 x:0~127 y:0~63
   ) A3 b8 x# V" U1 A& o
3. （x,y）坐标换算:OLED_GRAM[x][7-y/8]|=1<<(7-y%8)；
   
4. 
   
5. mode取1正显，取0反显
   
6. */
   
7. void OLED_DrawPoint( uint8_t x,uint8_t y,uint8_t mode )
   
8. {
   6 ]/ u& E" _5 U% b4 w7 o1 e$ t
9.         /* 主要是求出y坐标，根据y坐标来位运算OLED_GRAM中相应的位 */
   8 K9 E7 X; L" m
10.         uint8_t i,j,temp;
    / p2 Y6 d. g7 c
11.         /* 判断坐标是否超出范围 */
    
12.         if(x>127||y>63)return;
    ; _2 _( L4 y8 z
13.        
    
14.         i=7-y/8;//算出第几页
    : a9 x1 j% M6 g% ]
15.         j=y%8;
    & ^/ u* @! i$ M& ^" t
16.         temp=0x01<<(7-j);//由位运算精确找出坐标像素点
    
17.         if(mode==0)
    
18.                 OLED_GRAM[x][i]&=~temp;
    
19.         else
    # o5 D3 R- c3 P7 C9 P
20.                 OLED_GRAM[x][i]|=temp;
    
21. }
    # i8 g  i& R: l- d* k6 i, Z5 O

复制代码

6.显示字符函数
在某一坐标显示指定大小的字符，而且是从字库中提取字符图像信息，这就是显示字符函数：
( F2 D; _: ?. Z; }7 H5 h

1. /* 在（x,y）坐标正显/反显指定大小字符chr
   
2. mode：0是反显，1是正常显示
   
3. size：12/16/24
   
4. ASCII字符集: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
   / |/ O- `$ C% l8 b2 q3 w1 J
5. */
   
6. void OLED_Show_Char( uint8_t x,uint8_t y,uint8_t chr,uint8_t size,uint8_t mode )
   % m9 _4 g* g5 p! A3 N
7. {
   & V! g8 @  l: a$ l/ Z& j0 r7 r
8.         /* temp是当前对应的一个字节的点集，y0是初始坐标 */
   9 b- s: {* A: N9 u
9.         uint8_t temp,t,t1;
   
10.         uint8_t y0=y;
    
11.         /* csize是单个字符所占字节的多少 */
    4 ^9 A' R% @3 M0 v
12.         uint8_t csize=(size/8+((size%8)?1:0))*(size/2);
    
13.         /* 求出偏移的地址差，即得到该字符在字库中的序号（从零开始） */
    
14.         /* chr会锁定字符在字库中的的序号 */
    , z$ N8 {0 _4 ?* S- P" K1 N( w
15.         chr=chr-' ';
    
16.        
    * v: e( i. D$ W% ~% x5 E$ |" s
17.         /* 相应字符点集有多少个字节 */
    & T8 Y4 s( F1 ~3 L( R# Y
18.         for( t=0;t<csize;t++ )
    ' E7 J% ^% }% n6 k' G0 P/ M
19.         {
    
20.                 /* 根据字符的大小选择相应字库，根据chr得到具体的字符地址 */
    
21.                 switch( size )
    
22.                 {
    # E$ c# |: @" g( a- F
23.                         case 12:temp=asc2_1206[chr][t];break;//12x6(行x列)
    3 I1 d' }. e# @0 o
24.                         case 16:temp=asc2_1608[chr][t];break;//16x8
    
25.                         case 24:temp=asc2_2412[chr][t];break;//24x12
    ) P' M8 w9 [% k* @
26.                         default:return;//没有相应字库
    
27.                 }
    
28.                
    
29.                 /* 画出每一列的点 */
    : q) Y. S. [8 i3 o$ K/ s7 n  c
30.                 for( t1=0;t1<8;t1++ )
    - R5 Y/ a6 |% v9 C4 v; ~7 R! h
31.                 {
    " w6 z, k3 \( Q. C( P- }3 y' s( r( V
32.                         if( temp&0x80 )
    
33.                                 OLED_DrawPoint( x,y,mode );
    
34.                         else
    - s4 H1 z: P( V' S% d4 u# I( D
35.                                 OLED_DrawPoint( x,y,!mode );
    
36.                        
    
37.                         temp<<=1;
    
38.                         y++;
    # w) c- P& K7 U( g. x
39.                        
    
40.                         /* 根据给出每一列的像素点的多少，判断列是否满：
    6 L' T7 |; Q% r/ v+ d! t/ A
41.                         满了就换列，不满继续在此列画点 （与字库画点原理相关）                       
    * O+ B; W. h6 W* F( n/ n
42.                         */
    
43.                         if( ( y-y0 )==size )
    
44.                         {
    - D( `6 S9 ?: j% \$ s- K
45.                                 y=y0;
    8 s, b( O6 ~' N/ b8 ]
46.                                 x++;
    : J8 J7 v( d, n4 t
47.                                 /* 一列满，跳出循环，直接转到下一个字节点集的打印 */
    
48.                                 break;
    6 P; e$ v% g$ p2 T  r( A# ?' Y
49.                         }
    0 b* @+ Y2 g" Z7 Q: e) x8 s0 m, E
50.                 }
    : E- _! {5 _7 x. N: Q$ A
51.         }
    3 {! y& P7 I+ y2 ^9 q2 E; ~
52. }
    1 n+ b3 u% n0 q. s; J% l

复制代码

- V* Q/ p$ {* |8 r7.显示字符串函数
显示字符串，就是显示字符的加强版：
" r" l3 Y. j8 T. 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. {
     r- Z6 _& c* O% ]. M
4.                 /* 判断是否合法字符，同时也限定了范围 */
   
5.         while( (*p<='~')&&(*p>=' ') )
   
6.         {
   
7.                 /* 如果初始行放不下，移动到下一行 */
   
8.                 if( x>(128-(size/2)) )
   ' r$ Y" A/ N) y
9.                 {
   5 p! d7 A% C( ^) V* B9 \
10.                         x=0;
    
11.                         y=y+size;
    ' X3 g" h- b9 o8 S
12.                 }
    6 K" C! |7 F( c+ X& I
13.                 if( y>(64-size) )
    ; U3 ~+ _' |( [$ v: A; V- l
14.                 {
    
15.                         x=y=0;
    & ]. q; ]8 s5 X$ |
16.                         OLED_Clear();
    
17.                 }
    
18.                
    
19.                 OLED_Show_Char( x,y,*p,size,mode );
    6 U3 i; i" f' W, x
20.                 /* 移动到下一个字符位置，size/2是因为做点集时就是：行X列，而且 行=2X列，所以size就是行数 */
    3 `* t/ g# ~- S0 `, }2 U
21.                 x=x+size/2;
    
22.                 p++;
    1 C% o0 v# h9 D. Y% C; K. Y
23.         }
    3 R6 [- ?: z8 f- h+ t7 l; N7 A
24. }
      p- M( q5 G" v1 H# R. B
25. 
    % F" L& E5 h( x7 W2 P

复制代码

8.显示特殊图像
3 t$ Q/ m5 n: F" F1 @+ [' b显示特殊图像的方法和显示ASCII字符一样，只需要知道特殊图像的点阵信息即可，这个可以使用取模软件自己画点，再适当修改显示函数即可，学会了可以做一些特殊图像，包括汉字。当然，汉字也有字库，就是太大了，加上使用英文完全可以表达，所以只把需要显示的汉字做出来就行。当然，用来表白也是不错的！
2 w* k8 C7 u% |- p7 F
5 `' U  D) a, W: Y6 O, w
5 G$ L8 ?, L* R


————————————————
& z) P3 m$ R* t: e! g版权声明：Aspirant-GQ