一.OLED简介
OLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（OrganicElectroluminesence Display， OELD）。 OLED 由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。
1 v% _0 {$ j0 c3 q模块特点：
没有背光，需要通过写入指令来开启显示
尺寸小：0.96寸，分辨率高：128*64
提供多种通信接口：6800、8080、3线/4线SPI、IIC
8 I8 O+ v6 W  V* N1 w供电3.3V


) W. U4 n$ a1 b4 k' p, b5 P* a" k需要改变模块的通信接口时，只需要改变模块背后的电阻位置即可，如示：

* j4 @& ]. L' D& J: N

  D/ h7 S% m4 p6 E/ q
$ [* l6 V6 N* p% u8 C
1 H. \6 {/ a! A5 l0 }7 y+ Q我是使用4线SPI驱动OLED的。


0 w# ]' y0 |. L- q  u二.驱动SSD1306所需知识
9 X$ \% _9 i/ o/ A) o1.引脚介绍
* v* ^$ j- O+ a- R8 y



8 U- T  O: G6 ~
如图所示，各引脚的介绍如下：
$ h! }- N6 s% }. F) e8 `GND：接地引脚
& w- l% W- H7 dVCC：接电源引脚，接3.3V直流电源即可
0 p: [/ b; z5 o$ P! tD0：SPI的时钟线SCLK
$ I: K7 _& v  m8 N$ tD1：SPI的数据线SDIN
- R) Q' g4 N0 a, s6 ?6 p" [RES：复位接口，低电平初始化（复位），正常时高电平
, o! f7 G* l8 D1 Q& v2 o& n' `DC：用来选择命令or数据，低电平命令，高电平数据
1 T( D1 x( }# \( j4 l( K. bCS：片选线
) J: g$ P7 M9 ?4 C% M( B; f

1 M# ?8 q4 B( {7 |9 ]注意：4线SPI模式时，只能写，不能读！
在本文的代码中，对应的接口如下：
6 M6 l9 l7 W, K( Q! cSCLKC0 D0
SDINC1 D1
. ~$ H' i. `& f7 CRES G15 拉低时初始化（复位），正常时拉高
DC D3 （0:命令 1:数据）
9 D# D9 j. Q) p# q, L+ QCS D6


; G3 h& ^; A. y3 B' J" ?# J2.通信时序
单片机与OLED通信是4线SPI，每个数据长度为8位，在SCLK的上升沿数据有效，在上升沿数据从SDIN移入SSD1306，高位先行，D/C用来说明是传输命令还是数据。其通信时序图如示：
( W  Z$ ?$ `- v7 L

0 G# C) ~& a; `% O, z' H4 p* ^

! j8 F" R1 J4 Z
由图知，SSD1306与单片机通信可以分为如下几步：
1.拉低片选CS，作为正常通信的前提
+ X- B% W& R: v* @) s2.根据需求操作D/C，低电平代表传输命令，高电平代表传输数据
& s+ ^3 z/ B" I9 I3.时钟线SCLK不断产生时钟信号，上升沿数据线有效
4.数据线SDIN根据SCLK的上升沿，从高位开始传输一帧数据（8位），置高代表1，拉低代表0


8 d5 g9 C, l( ~" c* P4 E* L! @3.显存GRAM
2 s' Q3 K8 E( p1 e在OLED上显示图像，图像的数据就存储在显存GRAM中，由于SSD1306的分辨率是128*64，代表屏幕上总共有128x64个像素点，所以其显存大小就是128x64bit，恰好可以存储一帧图像的信息。
SSD1306的在逻辑上把GRAM分为8页，每页包含128个字节（1个字节8位），即8x128x8=128x64，所以屏幕上的每一个像素点都对应着GRAM中的每一位，要想点亮屏幕上的某一个像素点，只要在开启显示的前提下，将GRAM中的相应位置一即可。
/ M* A5 t, b& kSSD1306的GRAM与屏幕上像素点的对应关系表如示：
. n7 K& i  M' Z6 f" X

3 M3 M" L! m6 h0 L% B


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

1. /* OLED的显存 */
   
2. uint8_t OLED_GRAM[128][8];
   
3. /*
   7 g4 v, n( C2 _, A4 z7 `- d( v  y
4. OLED_GRAM[128][8]中是8位二进制为一个单位
   
5. 其逻辑排序如示：（高位先行）
   ( o  f& B& P' L8 J6 p; u/ y: _
6. 7 7
   4 |! G. ^3 Q% I7 T$ S
7. 6 6
   
8. 5 5
   
9. 4 4  ...
   
10. 3 3
    
11. 2 2
    
12. 1 1
      P. j* b  ?  c
13. 0 0
    + ]# Z3 M+ i+ Q3 L5 d+ z6 `* h
14. */
    

复制代码

7 t2 m6 W4 I7 [( e到此，我们只需要把要显示图像的信息写入OLED_GRAM[128][8]数组中，再通过画点函数操作OLED_GRAM[128][8]中的每一位对应的像素点，就可以在OLED屏幕中显示图像了。
/ N4 d' X5 W1 u9 n4 T. P! l
/ x1 c& e6 Y# G. F7 p. _9 A
' G: W; Y( T% H5 x4.字库
, @, G8 w% q' ], K2 Y$ o要在屏幕中显示图像，最常见的是显示一些字符，这个时候就需要这些字符的图像信息了，这就涉及到字库。我理解，一个包含了一些字符图像的数组就可以称作字库，这样做的好处就是，可以根据所要显示的字符直接从字库中提取图像信息到GRAM，这样显示字符就方便多了。
' U6 L7 D: t6 q! b. b本项目所使用的字库大小有（高x宽）：12x6、16x8、24x12
! `7 C% e( f* k) K而且字库的取模方式：阴码+逐列式+顺向+C51格式（用了取模软件PC2LCD2002）
每个字符所占用的字节数为size/8+((size%8)?1:0))*(size/2),其中size:是字库生成时的点阵大小
比如12x6字库信息如示：
( G, F: X9 K8 P5 d$ C4 a

1. //12*6 ASCII字符集点阵
   ' Y$ P% `# }3 ?5 g
2. const unsigned char asc2_1206[95][12]={
   
3. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*" ",0*/
   ; u& h# X9 e7 \# l& K3 f
4. {0x00,0x00,0x00,0x00,0x3F,0x40,0x00,0x00,0x00,0x00,0x00,0x00},/*"!",1*/
   ) `  B  E$ H% _! d! ~; v
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*/
   ' Z1 a% S  M8 q( e/ M' T
8. {0x18,0x00,0x24,0xC0,0x1B,0x00,0x0D,0x80,0x32,0x40,0x01,0x80},/*"%",5*/
   ' o# ?' r: \4 B
9. {0x03,0x80,0x1C,0x40,0x27,0x40,0x1C,0x80,0x07,0x40,0x00,0x40},/*"&",6*/
   5 Z$ X( d* d% U8 |0 q
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*/
    
12. {0x00,0x00,0x40,0x20,0x20,0x40,0x1F,0x80,0x00,0x00,0x00,0x00},/*")",9*/
    % r+ g/ i: c. @- O
13. {0x09,0x00,0x06,0x00,0x1F,0x80,0x06,0x00,0x09,0x00,0x00,0x00},/*"*",10*/
    ; U! s3 O3 j2 x) x6 `
14. {0x04,0x00,0x04,0x00,0x3F,0x80,0x04,0x00,0x04,0x00,0x00,0x00},/*"+",11*/
    ( I: I% v0 y- E. a. T* W
15. {0x00,0x10,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*",",12*/
    + |) w3 ]. u' R) N
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*/
    ; c) P* p4 c+ }& M$ f; A3 \2 N" N% M
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*/
    ( g8 k) E8 n6 M2 S+ `8 G
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*/
    & ?% z" q* L4 e% K
23. {0x02,0x00,0x0D,0x00,0x11,0x00,0x3F,0xC0,0x01,0x40,0x00,0x00},/*"4",20*/
    : O& C+ ]* C4 ?0 K. |& h
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*/
    " Q  a& J3 ]: X+ L& P( |3 S8 y0 ^" V- w
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*/
    1 m- P* \( A/ Y8 v& u
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*/
    & z0 g0 r, p" ~3 y( ^
31. {0x00,0x00,0x04,0x00,0x0A,0x00,0x11,0x00,0x20,0x80,0x40,0x40},/*"<",28*/
    8 Z6 t# Z+ r/ X  K, j/ Q9 _
32. {0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x00,0x00},/*"=",29*/
    $ B1 R! w. j  l; g( B8 I8 n" g
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*/
    ' p4 @2 J0 J0 m" O% r( U
35. {0x1F,0x80,0x20,0x40,0x27,0x40,0x29,0x40,0x1F,0x40,0x00,0x00},/*"@",32*/
    ) q& B4 q5 ?% K- g% `
36. {0x00,0x40,0x07,0xC0,0x39,0x00,0x0F,0x00,0x01,0xC0,0x00,0x40},/*"A",33*/
    & Z, Z" X& C" n
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*/
      }6 V+ E5 m+ X, C
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*/
    & K9 Z5 r; E6 v5 r5 D
42. {0x0F,0x00,0x10,0x80,0x20,0x40,0x22,0x40,0x33,0x80,0x02,0x00},/*"G",39*/
    & O9 g% S: E; k8 R" J  w7 N
43. {0x20,0x40,0x3F,0xC0,0x04,0x00,0x04,0x00,0x3F,0xC0,0x20,0x40},/*"H",40*/
      t0 n, w% e& k5 D1 C: ^/ @
44. {0x20,0x40,0x20,0x40,0x3F,0xC0,0x20,0x40,0x20,0x40,0x00,0x00},/*"I",41*/
    ) v6 n  Y$ D, i; E: Z
45. {0x00,0x60,0x20,0x20,0x20,0x20,0x3F,0xC0,0x20,0x00,0x20,0x00},/*"J",42*/
    & V. t, g, c- K3 B9 }
46. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x0B,0x00,0x30,0xC0,0x20,0x40},/*"K",43*/
    - }. y( k0 i$ E+ h/ \" ]: M
47. {0x20,0x40,0x3F,0xC0,0x20,0x40,0x00,0x40,0x00,0x40,0x00,0xC0},/*"L",44*/
    5 |' V' k1 |3 t/ ^3 a+ z- t; x
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*/
    6 e2 Y; _" O4 u! D
51. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x24,0x00,0x18,0x00,0x00,0x00},/*"P",48*/
    4 D! K' {/ @9 v# {
52. {0x1F,0x80,0x21,0x40,0x21,0x40,0x20,0xE0,0x1F,0xA0,0x00,0x00},/*"Q",49*/
    . T3 K# {" M/ ^$ G7 f
53. {0x20,0x40,0x3F,0xC0,0x24,0x40,0x26,0x00,0x19,0xC0,0x00,0x40},/*"R",50*/
    - C. g1 K# o. U9 B& y" h( K: @
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*/
    0 \% m5 m, X# l& p* e) A
56. {0x20,0x00,0x3F,0x80,0x00,0x40,0x00,0x40,0x3F,0x80,0x20,0x00},/*"U",53*/
    " B0 `+ Q- e) o1 @- _) F
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*/
    9 q" s0 \0 ?! U! u
59. {0x20,0x40,0x39,0xC0,0x06,0x00,0x39,0xC0,0x20,0x40,0x00,0x00},/*"X",56*/
    5 m6 s, t+ H* ?& n
60. {0x20,0x00,0x38,0x40,0x07,0xC0,0x38,0x40,0x20,0x00,0x00,0x00},/*"Y",57*/
    # O1 y9 x1 H6 B! o- p( Q/ |7 u% a
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*/
    ' O0 a' O0 R/ h
63. {0x00,0x00,0x70,0x00,0x0C,0x00,0x03,0x80,0x00,0x40,0x00,0x00},/*"",60*/
    : E4 X4 R& w6 Y/ N2 \" X% r9 W
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*/
    / l- B1 L" z- ]" k0 _
66. {0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10},/*"_",63*/
    $ u3 V: H, n/ a8 h/ A
67. {0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"`",64*/
    % `' d+ l$ H! Z5 N4 u3 N) j' v
68. {0x00,0x00,0x02,0x80,0x05,0x40,0x05,0x40,0x03,0xC0,0x00,0x40},/*"a",65*/
    
69. {0x20,0x00,0x3F,0xC0,0x04,0x40,0x04,0x40,0x03,0x80,0x00,0x00},/*"b",66*/
    ) n5 m9 m4 a# t7 ?1 _6 m
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*/
    
72. {0x00,0x00,0x03,0x80,0x05,0x40,0x05,0x40,0x03,0x40,0x00,0x00},/*"e",69*/
    9 S0 f6 x8 i# l# i. o
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*/
    4 L, c7 ^% a" o4 W1 ~, W
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*/
    
78. {0x20,0x40,0x3F,0xC0,0x01,0x40,0x07,0x00,0x04,0xC0,0x04,0x40},/*"k",75*/
    , F5 J+ H; c) c* @8 q
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*/
    
83. {0x04,0x10,0x07,0xF0,0x04,0x50,0x04,0x40,0x03,0x80,0x00,0x00},/*"p",80*/
    & _& }  g0 i1 ~. O
84. {0x00,0x00,0x03,0x80,0x04,0x40,0x04,0x50,0x07,0xF0,0x00,0x10},/*"q",81*/
    ; w# n* c, I: p  z
85. {0x04,0x40,0x07,0xC0,0x02,0x40,0x04,0x00,0x04,0x00,0x00,0x00},/*"r",82*/
    
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*/
    7 ~4 V2 e( R  m7 T& H% b7 K
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*/
    
92. {0x04,0x10,0x07,0x10,0x04,0xE0,0x01,0x80,0x06,0x00,0x04,0x00},/*"y",89*/
    $ N  ?/ r( ?: w( L. S4 b
93. {0x00,0x00,0x04,0x40,0x05,0xC0,0x06,0x40,0x04,0x40,0x00,0x00},/*"z",90*/
    - m% j+ q; ]8 c7 U& e7 ~7 c( k
94. {0x00,0x00,0x00,0x00,0x04,0x00,0x7B,0xE0,0x40,0x20,0x00,0x00},/*"{",91*/
    7 h- H. h8 P4 f* n; V; |* i/ d
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*/
    " j. ^) f! K; j. v
97. {0x40,0x00,0x80,0x00,0x40,0x00,0x20,0x00,0x20,0x00,0x40,0x00},/*"~",94*/
    
98. };  
    ) ]% _" y4 n! C9 E% w" |; o

复制代码

5.SSD1306基本命令
8 D9 x* c6 Y! ~; g# a- I. U9 h6 `上面介绍了显存，我们已经知道OLED的图像显示原理了。然鹅，在显示图像之前，还要对SSD1306做一系列的初始化操作，这就用到一些相关指令了。


暂停一下！！！捋一下命令与数据的关系：
# P( _. {5 c/ N* ~% x0 X上面介绍过D/C线，D/C低电平代表传输命令，高电平代表传输数据。数据就是显存GRAM的内容，而命令就是下面要介绍的。所以OLED与单片机通信就是由单片机向OLED写入信息，开始写入命令来初始化，之后写入GRAM（图像的信息）即可！
: A  `- \5 J6 Z( @
/ H+ a1 K& S: G$ k% T" }( G7 I. D4 e
一些常用的命令如图所示：
" ?- K( j" }' _4 f8 A7 H

" j- H+ k# j! ^% C" j! q


比较重要的是设置起始坐标的三个命令
, {0 v5 a' L8 V0 C2 B命令为 0XB0~B7，该命令用于设置页地址，其低三位的值对应着 GRAM 的页地址。
& d3 B" T0 a' V4 D' A命令为 0X00~0X0F，该指令用于设置显示时的起始列地址低四位。
命令为 0X10~0X1F，该指令用于设置显示时的起始列地址高四位。
1 s* l) k9 r( C) t/ k8 k, A( B* D
( r* w& [7 ?1 R! I- G6 Y& @- e
& V5 ^: v0 V- `2 |- s2 N0 P有关初始化OLED的所有命令会在下午代码讲解部分列出！

5 h/ }; z! B3 y5 `+ O
5 Q  B/ d, w0 N' e& N三.代码讲解
1.相关引脚配置
: y3 v- u  v1 i) r4 l9 b# N上面介绍了相应的引脚，这里对相应引脚进行配置，注意：除了GND和VCC引脚，其余所有引脚的模式均为推挽输出，代码如下：

1. /*
   0 R3 a# q6 J& V" K0 I6 ]
2. 配置4线SPI模式的所有引脚
   7 V, I' O# P: t+ [$ y
3. 4线SPI模式只能写，不能读
   # I/ S3 S5 H! J6 d3 k, D
4. SCLK:PC0  D0
     U( I( T/ s. o# A  P$ }0 o! m4 Y( y
5. SDIN:PC1  D1
   
6. RES :PG15  拉低时初始化（复位），正常时拉高
   8 d5 s1 A# O- z# c
7. DC  :PD3  （0:命令  1:数据）
   
8. CS  :PD6
   * n9 ?1 u' u" p5 N/ P4 A# `
9. */
   + {  a; P) D7 f4 e* a
10. void OLED_GPIO_Config( void )
    
11. {
    
12.         GPIO_InitTypeDef GPIO_InitStruct;
    ( U) |2 N) N3 h3 d' D( o
13.        
    
14.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOG, ENABLE );
    : m; h7 H, Y  @* f( n3 K1 l
15.        
    1 \) O, L9 l- ?0 F% h8 R( v; i; j
16.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    
17.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    6 ~6 O/ z0 L5 p9 Z3 \
18.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    
19.         GPIO_Init( GPIOC, &GPIO_InitStruct );
    
20.        
    " C% h! n6 ~! `: L
21.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    
22.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_6;
    # J0 l4 F3 L- \, |3 j
23.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    ' ?' }  F' Y! W4 Y
24.         GPIO_Init( GPIOD, &GPIO_InitStruct );
    
25. 
    
26.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    * B! M3 o7 o$ h/ K  z8 v
27.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_15;
    
28.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    9 I2 W: q9 f, I* C" [4 }; S
29.         GPIO_Init( GPIOG, &GPIO_InitStruct );
    
30. }
    : K  ~8 Y9 y! z5 h; \& z6 _* y; w

复制代码

4 T. w! p  t6 s  J1 W1 D由通信时序知，通信的过程中需要不断改变引脚的电平，所以我写了一些对引脚电平操作的函数（格式都一样）：
) e) w! x7 n$ D

1. void OLED_SCLK( uint8_t x )
   ) ^& ~2 F& r/ v. y
2. {
   
3.         if( x==1 )
   1 i9 e% a6 p' ?. }2 j" J
4.                 GPIO_SetBits( GPIOC, GPIO_Pin_0 );
   
5.         else
   5 t$ j+ F" n% S; b5 V* Y! o
6.                 GPIO_ResetBits( GPIOC, GPIO_Pin_0 );
     G( f- k: z9 u
7. }
   2 q1 _/ r2 Z/ t; f
8. 
   , H  M* u+ i& R
9. void OLED_SDIN( uint8_t x )
   
10. {
    . T/ I4 f5 V$ O" Q! A6 F/ t, q8 x
11.         if( x==0 )
    9 |  n* G; \% r( t$ x2 Y
12.                 GPIO_ResetBits( GPIOC, GPIO_Pin_1 );
    
13.         else
    - b/ T' k: F$ \9 \, ^, Y3 G( A/ C3 O
14.                 GPIO_SetBits( GPIOC, GPIO_Pin_1 );
    
15. }
    
16. 
    / o+ ~. [! U5 ]" W
17. void OLED_RES( uint8_t x )
    ! o& Q1 L: H+ O' U$ S1 k1 @
18. {
    
19.         if( x==1 )
    
20.                 GPIO_SetBits( GPIOG, GPIO_Pin_15 );
    % {2 j) E7 M4 N2 `
21.         else
    
22.                 GPIO_ResetBits( GPIOG, GPIO_Pin_15 );
    + t+ i1 i5 X" l. F, ^: U
23. }
    
24. 
    
25. void OLED_DC( uint8_t x )
    
26. {
    
27.         if( x==1 )
    : Y5 i, J) `) i+ C( b* ~; r& p! o
28.                 GPIO_SetBits( GPIOD, GPIO_Pin_3 );
    5 t, X* k5 v6 `( r
29.         else
    4 ^$ K8 ^7 E  ^2 T( K4 x
30.                 GPIO_ResetBits( GPIOD, GPIO_Pin_3 );
    
31. }
    
32. 
    
33. void OLED_CS( uint8_t x )
    
34. {
    ( S+ ]( D+ Z+ I
35.         if( x==1 )
    6 E; u; b- |. z: H, G
36.                 GPIO_SetBits( GPIOD, GPIO_Pin_6 );
    
37.         else
    
38.                 GPIO_ResetBits( GPIOD, GPIO_Pin_6 );
    + k7 U! M1 h5 T' L' y. Z# _. Q" W
39. }
    

复制代码

& A0 q! {1 K3 {6 `: g# N3 p8 {1 m2.模拟SPI通信
; [& @% D6 R- D1 Q, ^9 @我根据时序图模拟了SPI的通信协议，按照时序图对相应的引脚操作即可，一共写了俩个函数：写数据和写命令。函数如示：

1. 
   
2. /* 写一个命令 高位先行 */
   9 g( \. s4 E0 w5 H
3. void OLED_WR_Cmd( uint8_t cmd )
   2 \' u- P- m' ^2 A( j* _" A8 w
4. {
   
5.         uint8_t i,k;
   
6.         /* 拉低片选CS，写命令拉低DC */
   ) x' s6 L4 G9 @" [# c# B
7.         OLED_CS(0);
   # Z& b0 N7 _6 G$ s. d* _4 U
8.         OLED_DC(0);
   " H, C' A% g( I4 a/ A  k7 k
9.        
   5 z! p; a) {, ]+ Y! g* b
10.         for( i=0;i<8;i++ )
    7 Q$ e% Z% ]/ A' n& p
11.         {
    
12.                 /* 时钟线，上升沿有效 */
    
13.                 OLED_SCLK(0);
    2 w, w# {* D$ M& J- C% N" O, A2 J
14.                 k=cmd&(0x80);
    1 D. b2 `  \* r- x5 i/ Q6 U1 b
15.                 OLED_SDIN(k);
    ; U$ ^  h6 W6 l
16.                 OLED_SCLK(1);
    3 d/ ]1 ?5 m6 t. x: A  J9 s
17.                 cmd<<=1;
    
18.         }
    ) |( Q+ z" K  o$ n: m8 G* L
19.         OLED_CS(1);
    
20.         OLED_DC(1);       
    
21. }
    5 B, f+ N( u4 `3 b( K+ T
22. 
    
23. 
    
24. /* 写一个数据 高位先行 */
    ; i" F) i9 b# N3 P
25. void OLED_WR_Data( uint8_t data )
    
26. {
    
27.         uint8_t i,k;
    
28.         /* 拉低片选CS，写数据拉高DC */
    : @8 @% u# @) z! D4 E
29.         OLED_CS(0);
    
30.         OLED_DC(1);
    : h. N8 a. y! ]" D4 C$ i
31.        
    
32.         for( i=0;i<8;i++ )
    
33.         {
    
34.                 /* 时钟线，上升沿有效 */
    ( m* F3 @# m4 @) c  _
35.                 OLED_SCLK(0);
    
36.                 k=data&(0x80);
    
37.                 OLED_SDIN(k);
    
38.                 OLED_SCLK(1);
    9 H& w2 ^3 ]* X+ f4 c
39.                 data<<=1;
      `6 C) f. }3 q! x, U
40.         }
    3 j  p: Y' A9 x; @3 {1 G
41.         OLED_CS(1);
    1 C2 L; R& b+ a
42.         OLED_DC(1);
    ) L3 x5 g# u2 U* }0 K
43. }
    " b& h& P7 I' x

复制代码

. H8 M# Q/ f# G0 i4 x+ S5 k要注意：无论数据还是命令的传输，都是高位先行，这是根据时序图知道的。
& s( v1 ^, F. ?6 K
* @  u# \9 e* g1 ~, u- X; T" o3.OLED初始化函数
前面说了，会有一堆初始化命令：

1. 
   0 [% A' R0 C. d: F! ]2 v# R) f
2. /* OLED初始化函数 */
   # `' ^8 f# E& K8 F1 Y; t( E( ?5 s# W
3. void OLED_Init( void )
   ) u: V" X* }; U1 b. _+ w; O, S
4. {
   
5.         /* 引脚初始化 */
   
6.         OLED_GPIO_Config();
   ( x; k/ n6 }8 j
7.        
   2 R: |9 X5 e7 }' y8 R! j. r
8.         OLED_CS(1);
   
9.         OLED_DC(1);
   
10.        
    0 S5 f& O5 S4 D
11.         /* 复位 */
    
12.         OLED_RES(0);
    
13.         Delay_ms(1000);
    
14.         OLED_RES(1);
    
15.        
    + y% j* z& I% b
16.         /* 开始写入初始化命令 */
    + B; t3 e  x& ~1 S. _) V
17.         OLED_WR_Cmd(0xAE);//关闭显示
    ) m2 j" U6 i; _; r; F* q
18.         OLED_WR_Cmd(0xD5);//设置时钟分频因子
    3 ~0 X0 B% q6 \/ ^
19.         OLED_WR_Cmd(80);
    
20.        
    4 s4 c2 L8 Y4 t* L
21.         OLED_WR_Cmd(0xA8);//设置驱动路数
    % D7 h8 m$ `, |! y$ B; ]8 Z! C
22.         OLED_WR_Cmd(0x3F);//路数默认0x3F（1/64）
    - f7 m6 i2 H. t, D
23.        
    5 L2 F  E$ h- ]7 R- W5 l8 R
24.         OLED_WR_Cmd(0xD3);//设置显示偏移
    ! ?# h( Q: A" o3 C& D; x
25.         OLED_WR_Cmd(0x00);//偏移默认为0
    
26.        
    % C0 T! Y( e7 T/ c, e
27.         OLED_WR_Cmd(0x40);//设置显示开始行[5:0]
    1 d; `& z/ j9 G  F# @6 R+ a: d$ W3 M
28.        
    
29.         OLED_WR_Cmd(0x8D);//电荷泵设置
    
30.         OLED_WR_Cmd(0x14);//bit2，开启/关闭
    
31.        
    
32.         OLED_WR_Cmd(0x20);//设置内存地址模式
    / N3 c4 d5 \5 j6 n' F' y2 B% B
33.         OLED_WR_Cmd(0x02);//[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
    9 s: O- ^% m5 @
34.        
    4 x8 f. ?) N# F$ h
35.         OLED_WR_Cmd(0xA1);//段重定义设置,bit0:0,0->0;1,0->127;
    : y4 v5 h5 A4 i
36.         OLED_WR_Cmd(0xC0);//设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
    
37.         OLED_WR_Cmd(0xDA);//设置COM硬件引脚配置
    $ O: W/ |1 L8 N9 ?6 ~) {. _
38.         OLED_WR_Cmd(0x12);//[5:4]配置
    0 N9 ~4 C& A, ]
39.        
    
40.         OLED_WR_Cmd(0x81);//对比度设置
    # ~) j1 I+ u% u7 L9 f9 i/ z' |, O
41.         OLED_WR_Cmd(0xEF);//默认0x7F（范围1~255，越大越亮）
    
42.        
    
43.         OLED_WR_Cmd(0xD9);//设置预充电周期
    2 S& H8 y3 x2 w8 V' ~
44.         OLED_WR_Cmd(0xF1);//[3:0],PHASE 1;[7:4],PHASE 2;
    
45.        
      m2 b: c# P+ |/ S& L
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;
    + s& r; ~9 }& n" n5 q9 R; B) z
48.        
    7 }9 _7 B0 i  X, W# E1 u
49.         OLED_WR_Cmd(0xA4);//全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
    , [8 h5 x$ W5 a" R
50.         OLED_WR_Cmd(0xA6);//设置显示方式;bit0:1,反相显示;0,正常显示
    
51.        
    
52.         OLED_WR_Cmd(0xAF);//开启显示
    " g+ ^5 `" M7 w" ~# r' G
53.        
    
54.         /* 清屏函数 */
    
55.         OLED_Clear();
    
56. }
    

复制代码

1 p) g& w3 N0 ]. _+ c8 Z0 u3 J啥也不说了，照着写就完事了！
8 K  `- e& b1 z5 A# c5 f8 X

, q' ]/ W7 T9 b7 P, j# R4.图像刷新与清屏函数
假设图像的信息都已经写到GRAM中了，那么就可以通过图像刷新函数，将GRAM中的图像画到OLED屏幕中，刷新函数如示：

1. /* 图像刷新函数 */
   9 m' Y1 l) N* a  A" I
2. void OLED_Refresh_GRAM( void )
   
3. {
   9 k' T3 O7 g" e" f
4.         uint8_t i,j;
   
5.         for( i=0;i<8;i++ )
   
6.         {
   ' ~  h. W  q3 `8 z4 j' x( z
7.                 /* 设置显示的起始地址 */
   
8.                 OLED_WR_Cmd(0xB0+i);//设置页地址（行）
   * C' A, V; W0 o0 Z5 O# B
9.                 OLED_WR_Cmd(0x00);//设置列地址的低四位
   
10.                 OLED_WR_Cmd(0x10);//设置列地址的高四位
    
11.                 for( j=0;j<128;j++ )
    + R9 p# S8 K7 l5 u& {' E' n& N
12.                 {
    1 ]2 m/ U$ D( x  G; Z# u
13.                         OLED_WR_Data(OLED_GRAM[j][i]);//将GRAM中图像信息写入屏幕
    ) m% L8 K& r5 |, ^2 n
14.                 }
    5 x1 L' B5 m; x" p* {, j/ u
15.         }
    0 r7 i7 }" C) C5 X
16. }
    & k. }0 n) n; {/ [9 Y

复制代码

/ e( |1 f! o0 C, t对应的，清屏函数就是将GRAM中图像的信息抹去，然后刷新一下：

1. * 清屏函数 */
   , X& o3 W& i1 L2 j' I3 V; y( p( p
2. void OLED_Clear( void )
   ; I, y8 i7 b; Y5 H/ L' i% d+ C
3. {
   
4.         uint8_t i,j;
   # h: {3 I( _7 y+ V- k* w2 {) i
5.         for( i=0;i<8;i++ )
   
6.                 for( j=0;j<128;j++ )
   
7.                         OLED_GRAM[j][i]=0x00;
   
8.         OLED_Refresh_GRAM();
   ( }1 ?# ^3 @3 P
9. }
   ! b, c/ F% ^! s! Y" M

复制代码

  q$ T7 C% d  a5 c5.画点函数
所谓画点，就是将屏幕中指定位置的像素点点亮。在GRAM中就相当于把相对应的位置一，难点在于根据屏幕上的坐标推算出GRAM中的位置，函数如下：

1. //OLED_GRAM[128][8]
   
2. /* 画点函数，以屏幕像素点为单位，以左上角为原点 x:0~127 y:0~63
   8 c& O! ]) W. i8 A
3. （x,y）坐标换算:OLED_GRAM[x][7-y/8]|=1<<(7-y%8)；
   # ]& n: o! j$ L/ {- ~* D3 O
4. 
   
5. mode取1正显，取0反显
   
6. */
   
7. void OLED_DrawPoint( uint8_t x,uint8_t y,uint8_t mode )
   
8. {
   
9.         /* 主要是求出y坐标，根据y坐标来位运算OLED_GRAM中相应的位 */
   
10.         uint8_t i,j,temp;
    
11.         /* 判断坐标是否超出范围 */
    
12.         if(x>127||y>63)return;
    
13.        
    2 ~2 E0 m8 b2 k% [
14.         i=7-y/8;//算出第几页
    
15.         j=y%8;
    0 m, P! i, F. h- E: \# P) l; H
16.         temp=0x01<<(7-j);//由位运算精确找出坐标像素点
    
17.         if(mode==0)
    
18.                 OLED_GRAM[x][i]&=~temp;
    
19.         else
    
20.                 OLED_GRAM[x][i]|=temp;
    2 [# C; q3 i0 C
21. }
    2 l( ]5 k- M/ ^/ u& \

复制代码

$ Y/ o( `7 \$ Y! ?6.显示字符函数
6 c# z8 F0 O% f在某一坐标显示指定大小的字符，而且是从字库中提取字符图像信息，这就是显示字符函数：
: m' v( W# i+ |0 v5 m+ [& z0 A

1. /* 在（x,y）坐标正显/反显指定大小字符chr
   
2. mode：0是反显，1是正常显示
   
3. size：12/16/24
   
4. ASCII字符集: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
   
5. */
   
6. void OLED_Show_Char( uint8_t x,uint8_t y,uint8_t chr,uint8_t size,uint8_t mode )
   # Q3 Q5 v* j0 }
7. {
   " o" P8 E! _- T( A$ w
8.         /* temp是当前对应的一个字节的点集，y0是初始坐标 */
   - R* @0 q* C, I- v
9.         uint8_t temp,t,t1;
   0 G* a9 j* b% S" K  Z) u
10.         uint8_t y0=y;
    8 i8 _4 @) b2 o! g0 {0 f9 v, c1 L
11.         /* csize是单个字符所占字节的多少 */
    
12.         uint8_t csize=(size/8+((size%8)?1:0))*(size/2);
    % j, ^! F; t8 f" q
13.         /* 求出偏移的地址差，即得到该字符在字库中的序号（从零开始） */
    9 x5 M# w  f8 ]. Q
14.         /* chr会锁定字符在字库中的的序号 */
    1 Z& M. Z9 E2 n
15.         chr=chr-' ';
    # d! ?9 N5 u( x" I( |$ V! K
16.        
    0 S9 S& p! C1 S( N( z6 _# _
17.         /* 相应字符点集有多少个字节 */
    
18.         for( t=0;t<csize;t++ )
    
19.         {
    9 b& P2 ]) U; X* }5 c: f5 l
20.                 /* 根据字符的大小选择相应字库，根据chr得到具体的字符地址 */
    9 l: O, r( ~, T7 a0 W! A, r
21.                 switch( size )
    4 ?4 @$ ~! B3 F8 @" y
22.                 {
      L) L' }/ }2 P) m* L
23.                         case 12:temp=asc2_1206[chr][t];break;//12x6(行x列)
    
24.                         case 16:temp=asc2_1608[chr][t];break;//16x8
    " I; |' D$ E" t& I% _3 X
25.                         case 24:temp=asc2_2412[chr][t];break;//24x12
    
26.                         default:return;//没有相应字库
    
27.                 }
    . c6 q; o2 P; H; `9 `/ ?. w
28.                
    
29.                 /* 画出每一列的点 */
    
30.                 for( t1=0;t1<8;t1++ )
    ' X7 g$ l+ R, G1 \1 b2 O: M$ {* E
31.                 {
    $ ~# R$ y  s1 \9 Y! E0 Q
32.                         if( temp&0x80 )
    
33.                                 OLED_DrawPoint( x,y,mode );
    
34.                         else
    , g# ~" N& b) w" f% {
35.                                 OLED_DrawPoint( x,y,!mode );
    4 c3 ]" b! A: G
36.                        
    ; R9 Q! \" O2 l
37.                         temp<<=1;
    9 m/ f  i3 i4 p) E7 _/ \, h
38.                         y++;
    
39.                        
    - o2 l5 }$ |( `+ h
40.                         /* 根据给出每一列的像素点的多少，判断列是否满：
    
41.                         满了就换列，不满继续在此列画点 （与字库画点原理相关）                       
    
42.                         */
    0 e# ?% G' ^0 W) Z5 u% T$ V
43.                         if( ( y-y0 )==size )
    & ?' f% s. `9 _) h3 g1 D/ J
44.                         {
    
45.                                 y=y0;
    
46.                                 x++;
    0 S0 q6 J: u% ~$ ~5 T
47.                                 /* 一列满，跳出循环，直接转到下一个字节点集的打印 */
    / G6 ~& Q( y6 V6 A1 n7 }
48.                                 break;
    
49.                         }
    / f, E& H/ f# N. \6 N. \
50.                 }
    
51.         }
    
52. }
    : `. H+ B' u4 ]+ K  B& x

复制代码

7.显示字符串函数
' o6 Z1 h1 M# t2 @& I4 q2 m/ X: L) M显示字符串，就是显示字符的加强版：

1. /* （x,y）是显示的坐标，*p是字符串的首地址，size是字符点集大小 */
   1 k0 U$ ~" B0 B/ u9 G
2. void OLED_Show_String( uint8_t x, uint8_t y, const uint8_t *p, uint8_t size, uint8_t mode )
   9 C; ]# C; ~' |
3. {
   
4.                 /* 判断是否合法字符，同时也限定了范围 */
   0 _7 M5 c  l7 I) T$ r* u9 ~9 j/ ~4 t$ O: N- P
5.         while( (*p<='~')&&(*p>=' ') )
   
6.         {
   
7.                 /* 如果初始行放不下，移动到下一行 */
   $ m+ ~1 o" J3 o' `/ O1 ?. y) ]
8.                 if( x>(128-(size/2)) )
   
9.                 {
   1 k1 L  \* A% w& `! J$ ?
10.                         x=0;
    
11.                         y=y+size;
    
12.                 }
    
13.                 if( y>(64-size) )
    ( J' X) f  l& d# y6 U
14.                 {
    ' p% n+ A6 q4 ^( g" m2 H$ a+ c
15.                         x=y=0;
    
16.                         OLED_Clear();
    ; J0 q8 j0 t# c6 a8 U+ t
17.                 }
    
18.                
    % Q- r, R! A1 \
19.                 OLED_Show_Char( x,y,*p,size,mode );
    , m( U- ~, p) v+ b* P/ @+ I( G
20.                 /* 移动到下一个字符位置，size/2是因为做点集时就是：行X列，而且 行=2X列，所以size就是行数 */
    
21.                 x=x+size/2;
    
22.                 p++;
    
23.         }
    
24. }
    ( q$ i5 {1 A2 Q: T, k9 x3 i
25. 
    5 Y% v& k% v5 [- U! g+ k

复制代码

8.显示特殊图像
4 F1 m% z0 D" s" s+ e  T" m显示特殊图像的方法和显示ASCII字符一样，只需要知道特殊图像的点阵信息即可，这个可以使用取模软件自己画点，再适当修改显示函数即可，学会了可以做一些特殊图像，包括汉字。当然，汉字也有字库，就是太大了，加上使用英文完全可以表达，所以只把需要显示的汉字做出来就行。当然，用来表白也是不错的！



2 {# O$ A8 [1 S- |; Z

————————————————
- p/ H1 E" |* E0 q* H版权声明：Aspirant-GQ