前言
" I( t4 _& X) v: v! G* tOLED作为STM32的一个较为重要的外设，其作用也是为了方便调试代码。OLED模块的驱动可以使用8080、SPI四线、SPI3线、I2C的方法进行驱动。本文主要根据OLED的数据手册分析8080、SPI四线、I2C的使用。

" p5 I$ b8 w6 W一、配置OLED的IO口
因为OLED模块分为8080串行、SPI四线、I2C，不同的数据传输模式导致了其不同的接线方法以及配置方法。

1.8080并口模式
  E& U% l* Q/ s对于8080并口的配置，参考正点原子的例程。
其中8080并口，总共需要13根信号线通信，
这些信号线如下：

* c% D) P% _, ~$ c! f2 _  h

1. CS： OLED 片选信号。
   
2. WR(RW)：向 OLED 写入数据。
   % V' c8 |0 K: P& b+ o8 d
3. RD：从 OLED 读取数据。
   
4. D[7:0]： 8 位双向数据线。
   
5. RST(RES)：硬复位 OLED。
   ( A& c! t# D2 X; R/ e& D3 {) V" \; m
6. DC：命令/数据标志（0，读写命令； 1，读写数据）

复制代码

在知道了接线之后，我们必须将所使用到的IO口使能：
" e# {! V* t( ]

1. //初始化SSD1306                                            
   
2. void OLED_Init(void)
   6 K5 Y$ R% x3 T
3. {         
   3 a- n/ I0 {3 x
4. 
   9 L; P' j4 W" S) T
5.          GPIO_InitTypeDef  GPIO_InitStructure;
   " q6 ?$ p* S, A4 o* `
6.          
   + @4 S$ A1 L1 V4 L) e9 O* c) `
7.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOG, ENABLE);         //使能PC,D,G端口时钟
   " _6 {8 E6 |8 f) ~) ]
8. 
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_6;         //PD3,PD6推挽输出  
   
10.          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    
11.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//速度50MHz
    
12.          GPIO_Init(GPIOD, &GPIO_InitStructure);          //初始化GPIOD3,6
    3 B4 a/ p% k% q: I1 _+ {
13.          GPIO_SetBits(GPIOD,GPIO_Pin_3|GPIO_Pin_6);        //PD3,PD6 输出高
    , A; }6 s, R8 _7 j/ y: Q1 K, j8 G
14. 
    
15. 
    1 W0 i) B& b$ ]5 a$ }6 ^3 I
16.          GPIO_InitStructure.GPIO_Pin =0xFF; //PC0~7 OUT推挽输出
    
17.          GPIO_Init(GPIOC, &GPIO_InitStructure);
    : D8 ]. f+ ?3 u! b8 D
18.          GPIO_SetBits(GPIOC,0xFF); //PC0~7输出高
    
19. 
    # F, `; W; v3 @
20.          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;                                 //PG13,14,15 OUT推挽输出
    1 S, f0 E4 A- Y- L, \7 }, U# k& m
21.          GPIO_Init(GPIOG, &GPIO_InitStructure);
    
22.          GPIO_SetBits(GPIOG,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);                                                 //PG13,14,15 OUT  输出高
    ) N5 d( ?: ?  G, Q

复制代码

在将IO口初始化之后，我们需要做的第三件事情便是如何写入命令或者数据到OLED中，因为使用OLED的时候，需要配置，而那些配置的命令是每个OLED出厂的已经存在了，属于命令范畴，我们所要了解的就是如何使用8080并口模式向OLED中写入命令。
如正点原子里写的，
+ W' ^+ R: o* l

1. 
   + w3 O) v; q' j+ j& B
2. #define DATAOUT(x) GPIO_Write(GPIOC,x);//输出  
   
3. 
   
4. void OLED_WR_Byte(u8 dat,u8 cmd)
   ; Z& r" B  X( s! I& l
5. {
   
6.         DATAOUT(dat);            
   ' {+ E9 p3 c7 {: r( d* n9 m) }6 a- w/ I
7.          OLED_RS=cmd;   //DC位
   
8.         OLED_CS=0;           
   ' |! F+ U( R' U4 O
9.         OLED_WR=0;         
   % I8 |; k2 O, S8 P7 T; k
10.         OLED_WR=1;                //只有在WR由低变高的时候才能传入数据
    
11.         OLED_CS=1;         
    ! T1 b9 T/ _" ]
12.         OLED_RS=1;         
    9 J- ~( F3 u- Q; G# q
13. }  

复制代码

# u) m  ^" k9 `5 c1 _代码分析：根据之前的相应IO口连接，同时在OLED的数据手册中有提及到的，只有当OLED的片选CS拉低后以及WR拉低后，才可以开始往OLED中写入数据。后续的OLED初始化配置都是基于这个函数所进行的操作的。
* X2 N: r" i1 W6 ]+ T( |/ j1 N6 Z
- ^/ R6 S( \- m2 r/ ^6 q- w2.SPI四线
8 ~5 y2 |9 ~) P9 U' QSPI四线的OLED也只是万变不离其宗，一样的初始化过程，先确认接线，相比于8080串口接线方法，SPI四线极大的缩小了IO口的使用数量，更加便于使用。
0 B5 T: [8 A8 _6 _* |
1 t0 t3 ^& u: F; c

1. /*
   
2.         OLED0.96                                                                          STM32
   
3.         GND                                        <----------->                                        GND
   3 T3 @6 b' h2 H* D5 }+ a
4.         VCC                                        <----------->                                        3.3V
   . {6 G% W3 ]' q& t3 ?- k
5.         SCL                         <----------->                                        PE3
   1 |' g3 m( w$ Y) K6 S" K* O% g; e( w
6.         SDA                                        <----------->                                        PE4
   " ?% b  e( u' I
7.         DC(Data/Command)            <----------->                                        PE0
   - E" T4 N" @( h/ z' \; G* I- z- K1 f
8.         RST                                                <----------->                                        PE2
   : |" s* w% ~1 D' K5 i
9. */
   : v) z( ?3 X% V# w# V! k1 i4 _
10. 
    0 R4 F" {6 }& A% j* t6 S: l$ B

复制代码

6 c# [7 ]4 i* F3 \# V, B这里拿我之前所使用过的一个串口配置为主，来讲解。
& I& N8 n. W! O9 a4 C4 Y* F$ c, \
首先也是不变的初始化各个IO口：

' ?& j8 B1 I: T

1. void OLED_Init()
   , f' D- U- h$ O& q
2. {
   0 ?6 Y0 C  T; T" M
3.         GPIO_InitTypeDef GPIO_InitStructure;
   6 b" g7 Z: O+ o5 j  N6 `0 c
4. 
   6 X) q9 x4 v% D- f. b& I6 {
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
   
6.         
   # k' H" ^4 C% R3 D
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 ;
   
8.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   
9.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   ; N0 g/ Z. i9 D
10.         GPIO_Init(GPIOE, &GPIO_InitStructure);
    
11.         
    # U/ w6 X, v0 \1 ~# T. A6 ?6 S
12.         GPIO_SetBits(GPIOE, GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4);

复制代码

初始化完成后，也是需要进行判断，判断用户是打算写入数据还是写入命令：
# V* H7 T+ y1 z
2 @7 K# g0 W4 f

1. 
   " o  K3 [- N: i) w
2. //dat:要写入的数据/命令
   * w) M2 t4 W) E  X5 ]
3. //cmd:数据/命令标志 0,表示命令;1,表示数据;
   
4. void OLED_WR_Byte(u8 dat,u8 cmd)
   % {7 D4 l$ X2 J1 b( A1 b+ Z$ }
5. {        
   5 k: h( g  u' z# L! F/ t+ n
6.         u8 i;                          
   
7.         if(cmd)
   
8.           OLED_RS_Set();
   1 r& R3 o& S) c% n
9.         else
   
10.           OLED_RS_Clr();                  
    
11.         for(i=0;i<8;i++)
    
12.         {                          
    
13.                 OLED_SCLK_Clr();
    
14.                 if(dat&0x80)
    
15.                    OLED_SDIN_Set();
      T2 B. i$ V; O6 i
16.                 else
    
17.                    OLED_SDIN_Clr();
    
18.                 OLED_SCLK_Set();
    4 w& s  Z- b" e* ?  Z
19.                 dat<<=1;   
    
20.         }                                                   
    
21.         OLED_RS_Set();            
    
22. }

复制代码

有了这个主要的函数之后，便可以对OLED进行配置，如同上文所提到的8080串口配置一样，
: N! \2 [/ ]5 r8 q. x+ `
8 J" G3 t9 y$ ]2 y

1.         OLED_RST_Set();
   ( S, L; }2 ~1 f/ _
2.         delay_us(100000);
   
3.         OLED_RST_Clr();
   ( e" ?; r$ t7 w: q
4.         delay_us(20);
   
5.         OLED_RST_Set();
   
6.         
   7 b3 n& E7 c2 j# u. j  \7 `
7.         OLED_WR_Byte(0xA8, OLED_CMD);
   6 d/ e$ e6 h+ Q; B  c# T: R! R4 ^
8.         OLED_WR_Byte(0x3F, OLED_CMD);
   
9.         OLED_WR_Byte(0xD3, OLED_CMD);
   2 S/ h* r& Q* G- ^3 y3 q
10.         OLED_WR_Byte(0x00, OLED_CMD);
    * J, w5 o9 ?9 Z8 D, V$ }2 v
11.         OLED_WR_Byte(0x40, OLED_CMD);
    ; A) U; U6 f3 z$ T6 K& b8 m
12.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
    0 U" |: i: v7 s$ W$ Q  `
13.         OLED_WR_Byte(0xC0, OLED_CMD);   //C0/C8：控制屏幕上下映射翻转的
    
14.         OLED_WR_Byte(0xDA, OLED_CMD);
    
15.         OLED_WR_Byte(0x12, OLED_CMD);   //02h:隔行显示  12h:逐行显示
    
16.         OLED_WR_Byte(0x81, OLED_CMD);
    
17.         OLED_WR_Byte(0x7F, OLED_CMD);
    % E& P$ h+ a/ @3 k( d
18.         OLED_WR_Byte(0xA4, OLED_CMD);
    
19.         OLED_WR_Byte(0xA6, OLED_CMD);
    
20.         OLED_WR_Byte(0xD5, OLED_CMD);
    0 Z3 R7 _1 R1 @
21.         OLED_WR_Byte(0x80, OLED_CMD);
    
22.         OLED_WR_Byte(0x8D, OLED_CMD);
    4 `0 [' a& m% P# r
23.         OLED_WR_Byte(0x14, OLED_CMD);
    ) @6 H# s5 B- G& Z: ]
24.         OLED_WR_Byte(0xAF, OLED_CMD);
      I( v8 ^( ^% D# f% R1 e+ \- S( Z2 {
25.         
    + x- [2 d- ?7 y" D: V0 b
26.         OLED_Clear();

复制代码

( P" y% [8 ?! S" J6 @3.I2C
这里I2C和上文提到的OLED的初始化以及功能实现都大致相同，就不做太多的语言描述。

1. /*
   
2.         OLED0.96                                                                          STM32
   0 ]8 ?! O0 x! {1 @% I
3.         GND                                        <----------->                                        GND
   0 Q: D, j4 T( q0 d
4.         VCC                                        <----------->                                        3.3V
   
5.         D0(SCLK)                    <----------->                                        PA0                        
   
6.         D1SDIN()                      <----------->                                        PA1
   
7.         RES                                         <----------->                                        PA2
   ! O  x! i# M6 J- x, G) z" u) u
8.         DC(Data/Command)           <----------->                                        PA3
   
9.         CS                                                <----------->                                        PA4
   
10. */

复制代码

OLED的初始化和配置如下：

, ~9 M  a4 q4 d" ^4 K' v0 M% ?

1. void OLED_Init(void)
   
2. {
   ! t- Y2 |0 \5 J+ r/ R% ]3 _
3.         GPIO_InitTypeDef GPIO_InitStructure;
   3 p- J* |8 X  h0 ]/ i- O
4. 
   6 P+ Q) E& M* @0 R
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
   + p7 @! O, l" ?# g
6.         
   
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4;
   
8.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   
9.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   
10.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    9 t% {9 X7 ?+ q" S
11.         
    
12.         GPIO_SetBits(GPIOA, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4);
    - b* _2 r  l& b- ~# V
13.         
    
14.         OLED_RST_Set();
    
15.         delay_us(100000);
    
16.         OLED_RST_Clr();
    
17.         delay_us(20);
    $ H; \; x4 `( ]0 ^1 H$ K
18.         OLED_RST_Set();
    5 P+ g, v2 |) Q# i( M! B
19.         
    
20.         OLED_WR_Byte(0xA8, OLED_CMD);
    
21.         OLED_WR_Byte(0x3F, OLED_CMD);
    
22.         OLED_WR_Byte(0xD3, OLED_CMD);
    , q+ j) I) ?  ?, u' m9 y6 c
23.         OLED_WR_Byte(0x00, OLED_CMD);
    " p- H) l% ^5 j+ s+ d# t# ?
24.         OLED_WR_Byte(0x40, OLED_CMD);
    
25.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
    
26.         OLED_WR_Byte(0xC0, OLED_CMD);   //C0/C8：控制屏幕上下映射翻转的
    : q/ y" j' N% p# A# D
27.         OLED_WR_Byte(0xDA, OLED_CMD);
      P' C0 S% A, [- ?4 k7 V
28.         OLED_WR_Byte(0x12, OLED_CMD);   //02h:隔行显示  12h:逐行显示
    7 ?- M% {9 ?5 F
29.         OLED_WR_Byte(0x81, OLED_CMD);
    
30.         OLED_WR_Byte(0x7F, OLED_CMD);
    
31.         OLED_WR_Byte(0xA4, OLED_CMD);
    
32.         OLED_WR_Byte(0xA6, OLED_CMD);
    
33.         OLED_WR_Byte(0xD5, OLED_CMD);
    
34.         OLED_WR_Byte(0x80, OLED_CMD);
    + e7 [! }' _$ b! ^; d- G
35.         OLED_WR_Byte(0x8D, OLED_CMD);
    : X2 g& J) x/ p6 J( N
36.         OLED_WR_Byte(0x14, OLED_CMD);
    
37.         OLED_WR_Byte(0xAF, OLED_CMD);
      L& {" |' v4 h/ K3 w
38.         
    
39.         OLED_Clear();
    9 V( |" l' C  H1 i1 \0 ?5 B5 e+ @
40. }

复制代码

: l3 |, ^( ^/ W也是照着本文提到的第二种方法能完成的。这里就不太多描述。
但是，与上文提到的第二种方法不同，在数据/命令选择中，与上文不同

1. //dat:要写入的数据/命令
   
2. //cmd：0表示命令，1表示数据
   # I9 g* S( ~' ~: L  Y
3. void OLED_WR_Byte(u8 dat,u8 cmd)
   
4. {
   7 l0 d, S8 ^) B9 u1 Q
5.         u8 i;
   7 R1 V( r9 L. N$ ~- \) j4 k
6.         
   
7.         if(cmd)
   3 `0 R; I: X& t( c+ m% C0 P- v
8.                 OLED_DC_Set();
   7 q; M9 ^3 V0 f; W- ], p5 [
9.         else
   1 e, _) |  V5 o/ Y& ~
10.                 OLED_DC_Clr();   
    + V% c' n' Z! l4 ~1 M) y5 L
11.         
    / g4 V/ ]2 i8 G" k& ^# f
12.         OLED_CS_Clr();  //拉低CS
    9 c$ u# {$ k" x& z* [% Q
13.         
    
14.         for(i = 0; i < 8; i++)
    8 o- @* W1 x0 e' t( ]6 L+ x
15.         {
    ; C, {# V9 l; j0 V% f7 X# F
16.                 OLED_SCLK_Clr();
    
17.                 if(dat & 0x80)
    
18.                         OLED_SDIN_Set();
    - r9 j2 z; Y' `) G0 Z
19.                 else
    8 G& Z9 b" B7 D) s  N
20.                         OLED_SDIN_Clr();
    , h8 Q1 }' a. b" R5 u8 G% c
21.                 OLED_SCLK_Set();
    0 V* W" d* t# k/ M" ?6 _5 V
22.                
    ! [$ E7 }: e3 S+ P" w/ {4 O
23.                 dat <<= 1;
    
24.         }
    : u1 _) G7 e2 u2 ~
25.         
    5 C% O  R, d7 `7 ^; ]( g
26.         OLED_CS_Set();
    
27. }

复制代码

代码分析：
) |+ x4 L  U. g6 a% T# m与上面不同的是，使用此方法驱动的OLED的IO多了SDIN这一个IO口，而这个IO的存在，导致其OLED_WR_ Byte()的写法不太一样。需要注意一下即可。

二、阅读datasheet（数据手册）
) @6 a8 d( V: q; pOLED可以传输命令（cmd）或者是数据（data），而传输命令或者传输数据，都需要依靠之前提到的函数，以8080串口方式为例的OLED初始化，正点原子的代码中也很明确的注释了：

1.         OLED_WR_Byte(0xAE,OLED_CMD); //关闭显示
   
2.         OLED_WR_Byte(0xD5,OLED_CMD); //设置时钟分频因子,震荡频率
   & w6 `. b: }8 b; j
3.         OLED_WR_Byte(80,OLED_CMD);   //[3:0],分频因子;[7:4],震荡频率
     {8 U8 L0 |8 Q. b4 q! K4 b" j
4.         OLED_WR_Byte(0xA8,OLED_CMD); //设置驱动路数
   + w8 b3 h) v& S* @3 P
5.         OLED_WR_Byte(0X3F,OLED_CMD); //默认0X3F(1/64)
   7 {! h; }/ p0 r- u% J
6.         OLED_WR_Byte(0xD3,OLED_CMD); //设置显示偏移
   
7.         OLED_WR_Byte(0X00,OLED_CMD); //默认为0
   
8. 
   7 ?+ y: |6 v2 E1 N% I2 t
9.         OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.
   
10.                                                                                                             
    , S# k  z) e; U& u) Q0 E+ X  s
11.         OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置
    ; p/ B! H. `' K
12.         OLED_WR_Byte(0x14,OLED_CMD); //bit2，开启/关闭
    
13.         OLED_WR_Byte(0x20,OLED_CMD); //设置内存地址模式
    . c& I( j3 g  Q1 J  C
14.         OLED_WR_Byte(0x02,OLED_CMD); //[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
    * S( c! x. P) e  q
15.         OLED_WR_Byte(0xA1,OLED_CMD); //段重定义设置,bit0:0,0->0;1,0->127;
    
16.         OLED_WR_Byte(0xC0,OLED_CMD); //设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
    ( ^6 x7 B/ ^% |. E
17.         OLED_WR_Byte(0xDA,OLED_CMD); //设置COM硬件引脚配置
    4 t; Q+ |, i# E
18.         OLED_WR_Byte(0x12,OLED_CMD); //[5:4]配置
    5 l% a+ Q! c: \/ W
19.                  
    & t4 w: k( K! ~5 x
20.         OLED_WR_Byte(0x81,OLED_CMD); //对比度设置
    
21.         OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
    / Y) `6 \5 X- N1 A8 U" G6 x
22.         OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期
    $ r2 ?2 W8 ?; r* O1 J! `
23.         OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
    
24.         OLED_WR_Byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率
    : a# K5 L6 ^) B- p8 P
25.         OLED_WR_Byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
    
26. 
    1 }7 L5 h2 N4 p* P3 S
27.         OLED_WR_Byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
    * A& |2 J; J6 g3 l3 F8 h* p
28.         OLED_WR_Byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示                                                               
    , V8 W1 s6 o: x6 ^3 v
29.         OLED_WR_Byte(0xAF,OLED_CMD); //开启显示         
    1 m3 i" m. p. ?1 ^2 t( Z$ T5 F
30.         OLED_Clear();

复制代码

1 E1 I4 l& e  l: Y: o" ^1 K由于使用的同一厂家的OLED屏幕，所以往OLED中写入的命令字符也是大致的相同，SPI四线写入的命令为：
' i$ }; F* b6 w3 @7 }! p" o) L

1.       
   8 k* B; U( H9 f( a
2.         OLED_WR_Byte(0xA8, OLED_CMD);
   ; i0 Z, N- [9 L; F( c+ i( x7 G( b
3.         OLED_WR_Byte(0x3F, OLED_CMD);
   4 S1 J3 G  s( H5 v4 V( m/ i9 W
4.         OLED_WR_Byte(0xD3, OLED_CMD);
   
5.         OLED_WR_Byte(0x00, OLED_CMD);
   
6.         OLED_WR_Byte(0x40, OLED_CMD);
     ~0 O4 H! ?% s% q" w/ @
7.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
   , S( n+ K+ d6 R) H% s; I8 p! H, P0 {
8.         OLED_WR_Byte(0xC0, OLED_CMD);   //C0/C8：控制屏幕上下映射翻转的
   
9.         OLED_WR_Byte(0xDA, OLED_CMD);
   
10.         OLED_WR_Byte(0x12, OLED_CMD);   //02h:隔行显示  12h:逐行显示
    1 D* X7 h7 |. m* |" F
11.         OLED_WR_Byte(0x81, OLED_CMD);
    2 R$ O1 Y' Q2 r7 s" I7 M
12.         OLED_WR_Byte(0x7F, OLED_CMD);
    4 Q, `( L/ m& u! W! c$ W
13.         OLED_WR_Byte(0xA4, OLED_CMD);
    2 U  _& b/ N7 V" Y7 ^! m
14.         OLED_WR_Byte(0xA6, OLED_CMD);
    
15.         OLED_WR_Byte(0xD5, OLED_CMD);
    
16.         OLED_WR_Byte(0x80, OLED_CMD);
    
17.         OLED_WR_Byte(0x8D, OLED_CMD);
    9 V6 |! {) R6 Q4 h5 Q- X. j& k' g
18.         OLED_WR_Byte(0x14, OLED_CMD);
    ; C' w2 c5 [0 _* U" B  e
19.         OLED_WR_Byte(0xAF, OLED_CMD);
    
20.         
    
21.         OLED_Clear();

复制代码

2 B  ^# o3 Q0 ~* p3 L2 {) t' ~不难发现，也是万变不离其宗。

9 ?% D* {) G' @/ C0 }7 k总结
在这三种OLED的驱动方式中，最重要的还是需要了解OLED_WR_Byte（）这个函数后续的显示操作也是和此函数息息相关。而对于一些OLED屏幕的描点函数和显示数字和字符函数，如果后续有时间的话，我会逐渐完善的。
% z  m8 ?4 N8 ~6 ^8 o3 n
（SPI驱动OLED的方法和I2C驱动OLED的方法我在上文好像混淆了，准确的说第二种方法应该叫六针OLED，而第三种应该是七针OLED）
8 X0 A9 c6 a/ U$ O8 @
) F& L; q3 |6 n" Y: {- T% z对于该篇文章的话，我也不太敢打包票说我能讲清楚OLED不同驱动方式下的详细步骤以及为什么，我只能尽我所能。如果有什么不足以及不对的地方希望大家指正。

" N9 m  a: v4 k2 O