前言
OLED作为STM32的一个较为重要的外设，其作用也是为了方便调试代码。OLED模块的驱动可以使用8080、SPI四线、SPI3线、I2C的方法进行驱动。本文主要根据OLED的数据手册分析8080、SPI四线、I2C的使用。
5 `& V; J( [# L5 |1 a# D
一、配置OLED的IO口
因为OLED模块分为8080串行、SPI四线、I2C，不同的数据传输模式导致了其不同的接线方法以及配置方法。
: Y7 N9 v6 U3 ~1 A
1.8080并口模式
对于8080并口的配置，参考正点原子的例程。
其中8080并口，总共需要13根信号线通信，
6 _* z5 s1 Q/ j4 C$ E4 y5 z5 i这些信号线如下：

1. CS： OLED 片选信号。
   
2. WR(RW)：向 OLED 写入数据。
   
3. RD：从 OLED 读取数据。
   
4. D[7:0]： 8 位双向数据线。
   
5. RST(RES)：硬复位 OLED。
   
6. DC：命令/数据标志（0，读写命令； 1，读写数据）

复制代码

( B; t0 R' m5 b5 S4 R. X* _在知道了接线之后，我们必须将所使用到的IO口使能：
! M/ S7 E4 d3 h1 j

1. //初始化SSD1306                                            
   
2. void OLED_Init(void)
   8 u. o; {9 H, s
3. {         
   
4. 
   
5.          GPIO_InitTypeDef  GPIO_InitStructure;
   " m0 J0 n9 u/ o! z; G$ r
6.          
   $ j' i; A% W1 w. k% r$ M
7.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOG, ENABLE);         //使能PC,D,G端口时钟
   
8. 
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_6;         //PD3,PD6推挽输出  
   * p, ^! H" K. N/ Z
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
    % }' {& m- O, O
13.          GPIO_SetBits(GPIOD,GPIO_Pin_3|GPIO_Pin_6);        //PD3,PD6 输出高
    ; M# w" v6 K5 A/ `" |  {
14. 
    
15. 
    3 k9 ^& k6 |0 J9 U6 Z
16.          GPIO_InitStructure.GPIO_Pin =0xFF; //PC0~7 OUT推挽输出
    1 @7 I5 Y) ]/ N% b( n
17.          GPIO_Init(GPIOC, &GPIO_InitStructure);
    
18.          GPIO_SetBits(GPIOC,0xFF); //PC0~7输出高
    ! c* n5 ?; o* ~. X+ R- u
19. 
    
20.          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;                                 //PG13,14,15 OUT推挽输出
    1 e# `, Q3 L; q% R: o
21.          GPIO_Init(GPIOG, &GPIO_InitStructure);
    ( c6 [8 D+ O0 W( F
22.          GPIO_SetBits(GPIOG,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);                                                 //PG13,14,15 OUT  输出高
    

复制代码

% b0 Y4 D, h+ j& d; F在将IO口初始化之后，我们需要做的第三件事情便是如何写入命令或者数据到OLED中，因为使用OLED的时候，需要配置，而那些配置的命令是每个OLED出厂的已经存在了，属于命令范畴，我们所要了解的就是如何使用8080并口模式向OLED中写入命令。
如正点原子里写的，

7 S& U, S) f  p* o. x

1. 
   
2. #define DATAOUT(x) GPIO_Write(GPIOC,x);//输出  
   
3. 
   & k- x- P' P0 m, b% M2 W5 n" Z
4. void OLED_WR_Byte(u8 dat,u8 cmd)
   5 v* o3 T) v$ x2 U5 r, Q
5. {
     X1 h2 v/ [5 w$ v* G1 q" M
6.         DATAOUT(dat);            
   
7.          OLED_RS=cmd;   //DC位
   1 x) c: R7 F: }5 a5 ?2 {
8.         OLED_CS=0;           
   ; C5 e7 _& E1 m/ v% }
9.         OLED_WR=0;         
   9 p+ O4 E+ }! i$ _, L* J& t5 {
10.         OLED_WR=1;                //只有在WR由低变高的时候才能传入数据
    3 X% o# C9 b5 z: u/ t5 d0 `; [
11.         OLED_CS=1;         
    . W: `  Q4 L6 o0 C4 e
12.         OLED_RS=1;         
    3 B7 r' n; D9 M+ P- w3 J
13. }  

复制代码

- d( A# W9 `/ ^/ h6 O代码分析：根据之前的相应IO口连接，同时在OLED的数据手册中有提及到的，只有当OLED的片选CS拉低后以及WR拉低后，才可以开始往OLED中写入数据。后续的OLED初始化配置都是基于这个函数所进行的操作的。
6 a1 J2 n- g1 ^( U( C' N5 Q: l. E* d
$ M  |) ~- N2 F2.SPI四线
SPI四线的OLED也只是万变不离其宗，一样的初始化过程，先确认接线，相比于8080串口接线方法，SPI四线极大的缩小了IO口的使用数量，更加便于使用。

: Y; Z0 |' |, L$ ^! G" F/ c" K

1. /*
   
2.         OLED0.96                                                                          STM32
   0 P: `4 s8 S6 R7 [4 p3 `( G$ U
3.         GND                                        <----------->                                        GND
   7 `; k3 B2 N# Q. h& |7 E1 E8 [
4.         VCC                                        <----------->                                        3.3V
   . S7 D# [# x2 Q( H6 j. M+ W- G
5.         SCL                         <----------->                                        PE3
   
6.         SDA                                        <----------->                                        PE4
   
7.         DC(Data/Command)            <----------->                                        PE0
   
8.         RST                                                <----------->                                        PE2
   
9. */
   # m3 r7 L+ J1 w; v9 @9 K. A
10. 
    , N) L8 v" L; A/ l3 a6 {

复制代码

2 V  F, @& f$ `7 |$ [! e3 @这里拿我之前所使用过的一个串口配置为主，来讲解。

首先也是不变的初始化各个IO口：

. \8 F/ h7 @) o. O) o1 H% i9 h  P

1. void OLED_Init()
   0 b$ \/ l/ C2 f  Z2 o9 A
2. {
   # a8 Q0 O# ~% ^7 @
3.         GPIO_InitTypeDef GPIO_InitStructure;
   
4. 
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
   2 D( }" E3 U/ s3 T5 Q7 f
6.         
   0 W  D5 K4 I2 N" ^) `* y
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;
   7 k( Z) B  W4 E; K: e; [8 Z0 T0 c
10.         GPIO_Init(GPIOE, &GPIO_InitStructure);
    5 K) O& t, B: w( T+ V
11.         
    
12.         GPIO_SetBits(GPIOE, GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4);

复制代码

初始化完成后，也是需要进行判断，判断用户是打算写入数据还是写入命令：

5 P6 X5 x: Q) W# z& y+ _2 c

1. 
   , R8 o; {) m$ U4 g* d
2. //dat:要写入的数据/命令
   
3. //cmd:数据/命令标志 0,表示命令;1,表示数据;
   
4. void OLED_WR_Byte(u8 dat,u8 cmd)
   ; C: g4 P' f2 M( |4 d
5. {        
   
6.         u8 i;                          
   
7.         if(cmd)
   % h8 G- N( k/ M! _$ [/ S  I1 T
8.           OLED_RS_Set();
   
9.         else
   
10.           OLED_RS_Clr();                  
    ! G+ R+ Q/ ]. T  f0 A7 }7 P
11.         for(i=0;i<8;i++)
    3 a+ ^6 b* g; j! L$ b8 A! O1 W
12.         {                          
    
13.                 OLED_SCLK_Clr();
    
14.                 if(dat&0x80)
    
15.                    OLED_SDIN_Set();
    ! G% o& o. v# I9 x# h! s8 d; O
16.                 else
    - q7 ^1 [5 {5 n+ j
17.                    OLED_SDIN_Clr();
    ' z3 Y6 C  A5 t, p2 w2 s: U( f
18.                 OLED_SCLK_Set();
    
19.                 dat<<=1;   
    
20.         }                                                   
    4 R6 i0 V' p' c
21.         OLED_RS_Set();            
    
22. }

复制代码

6 h7 \& h% b( u  i2 G* o有了这个主要的函数之后，便可以对OLED进行配置，如同上文所提到的8080串口配置一样，

1.         OLED_RST_Set();
   4 N- X% c( _! t. ]- ]
2.         delay_us(100000);
   
3.         OLED_RST_Clr();
   
4.         delay_us(20);
   ) p& Q8 f+ ~. V
5.         OLED_RST_Set();
   
6.         
   
7.         OLED_WR_Byte(0xA8, OLED_CMD);
   8 T8 @$ g0 y8 G& u% E, P" _
8.         OLED_WR_Byte(0x3F, OLED_CMD);
   - Y  p/ x/ V$ ?$ v- |
9.         OLED_WR_Byte(0xD3, OLED_CMD);
   
10.         OLED_WR_Byte(0x00, OLED_CMD);
    
11.         OLED_WR_Byte(0x40, OLED_CMD);
    2 W' s4 S& ?- k: K+ ~( U
12.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
    
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:逐行显示
    4 j$ x! E/ e& F- p( c
16.         OLED_WR_Byte(0x81, OLED_CMD);
    
17.         OLED_WR_Byte(0x7F, OLED_CMD);
    2 f& ]4 F, V5 U2 ]/ A, G
18.         OLED_WR_Byte(0xA4, OLED_CMD);
    0 Q* `% }8 k6 u( Y
19.         OLED_WR_Byte(0xA6, OLED_CMD);
    , B4 i3 g5 z+ Z7 ]% E
20.         OLED_WR_Byte(0xD5, OLED_CMD);
    ' p9 m& a, t7 f
21.         OLED_WR_Byte(0x80, OLED_CMD);
    : B0 Y  ^: T# V$ h0 N
22.         OLED_WR_Byte(0x8D, OLED_CMD);
    : c- j+ x" W- M' S$ S. X3 Q
23.         OLED_WR_Byte(0x14, OLED_CMD);
    ( e$ P+ I- p0 c" y$ R5 {# J$ f/ Y& w
24.         OLED_WR_Byte(0xAF, OLED_CMD);
    * f8 }' O/ o: a$ A2 ], d! ]
25.         
    
26.         OLED_Clear();

复制代码

* C* y7 x. o; Z$ y- B' t6 T3.I2C
5 Q& d3 K7 t  E* u$ x5 Y& ?) G! j这里I2C和上文提到的OLED的初始化以及功能实现都大致相同，就不做太多的语言描述。
9 z( D& Q  i( g" a& I. O' o

1. /*
   + n% i2 _4 N* [$ y0 s2 C7 Y7 Y
2.         OLED0.96                                                                          STM32
   
3.         GND                                        <----------->                                        GND
   
4.         VCC                                        <----------->                                        3.3V
   
5.         D0(SCLK)                    <----------->                                        PA0                        
   
6.         D1SDIN()                      <----------->                                        PA1
   
7.         RES                                         <----------->                                        PA2
   
8.         DC(Data/Command)           <----------->                                        PA3
   
9.         CS                                                <----------->                                        PA4
   
10. */

复制代码

OLED的初始化和配置如下：
0 A- w" ~; A  }' ?) M
7 [; ]1 Y' I8 x/ A# V

1. void OLED_Init(void)
   
2. {
   ' `+ J" U7 F3 B1 V2 [; S
3.         GPIO_InitTypeDef GPIO_InitStructure;
   
4. 
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
   
6.         
   / f7 p# x- C0 ]  e7 P) `& F
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4;
   ) e2 X' W5 _- M, j
8.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   
9.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   
10.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    . A- G' J$ X$ u% V" f
11.         
    
12.         GPIO_SetBits(GPIOA, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4);
    
13.         
    ; |' E* c3 f/ d8 g* W: b6 M" ?
14.         OLED_RST_Set();
    
15.         delay_us(100000);
    ! e0 x) H0 m/ o$ s
16.         OLED_RST_Clr();
    
17.         delay_us(20);
    
18.         OLED_RST_Set();
    2 ^$ |, y+ z& K! M" H3 I0 r
19.         
    ! r( \: Z+ {7 w% v' w4 l
20.         OLED_WR_Byte(0xA8, OLED_CMD);
      H( i1 A1 |' |+ N
21.         OLED_WR_Byte(0x3F, OLED_CMD);
    
22.         OLED_WR_Byte(0xD3, OLED_CMD);
    + B, [" H, F  s, d; E) K0 ^
23.         OLED_WR_Byte(0x00, OLED_CMD);
    9 m- U0 u9 [3 I" f) T
24.         OLED_WR_Byte(0x40, OLED_CMD);
    
25.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
    0 G% i$ K/ O# Y0 V
26.         OLED_WR_Byte(0xC0, OLED_CMD);   //C0/C8：控制屏幕上下映射翻转的
    5 F/ v; V2 d- ]8 K- r
27.         OLED_WR_Byte(0xDA, OLED_CMD);
    & g/ @8 t4 v( N: b# E6 r! X1 x
28.         OLED_WR_Byte(0x12, OLED_CMD);   //02h:隔行显示  12h:逐行显示
    0 ~, i/ v1 _& g' ^& E" i: ?" g
29.         OLED_WR_Byte(0x81, OLED_CMD);
    5 n1 K* I$ P1 G# `+ l) y% q) n
30.         OLED_WR_Byte(0x7F, OLED_CMD);
    5 }5 E& e" o! Q; w  h, K
31.         OLED_WR_Byte(0xA4, OLED_CMD);
    % i3 K# H& ?) A+ {: M0 y
32.         OLED_WR_Byte(0xA6, OLED_CMD);
    , k3 m, Q% c5 u$ T: ~: U2 n5 ]8 S
33.         OLED_WR_Byte(0xD5, OLED_CMD);
    
34.         OLED_WR_Byte(0x80, OLED_CMD);
    $ g* m9 ?# s* v+ {& H" @1 W
35.         OLED_WR_Byte(0x8D, OLED_CMD);
    6 S/ p! v" o. V( Z5 {
36.         OLED_WR_Byte(0x14, OLED_CMD);
    ) g6 C7 I! ~) {1 T! R* f
37.         OLED_WR_Byte(0xAF, OLED_CMD);
    
38.         
    
39.         OLED_Clear();
    7 ^( q8 t0 o. ?  N% @6 e
40. }

复制代码

4 |$ {) g$ N( i' z3 A: f也是照着本文提到的第二种方法能完成的。这里就不太多描述。
但是，与上文提到的第二种方法不同，在数据/命令选择中，与上文不同
) v0 Q) q( m, s8 C# B
" R3 h- B* r# m3 ^4 l3 G& i: O

1. //dat:要写入的数据/命令
   ' r. S( g/ {3 ~* w6 t
2. //cmd：0表示命令，1表示数据
   
3. void OLED_WR_Byte(u8 dat,u8 cmd)
   
4. {
   
5.         u8 i;
   % Z: S2 f& ^( h- N! s% j2 p; T
6.         
   0 _: V" I" U) {7 Q
7.         if(cmd)
   7 K% k3 N  ?. B5 f/ Z$ d
8.                 OLED_DC_Set();
   
9.         else
   
10.                 OLED_DC_Clr();   
    
11.         
    
12.         OLED_CS_Clr();  //拉低CS
    
13.         
    4 n: u  D# y, |8 c0 i3 Q
14.         for(i = 0; i < 8; i++)
    
15.         {
    
16.                 OLED_SCLK_Clr();
    
17.                 if(dat & 0x80)
    ; z: f" l* r8 s! n1 q) R
18.                         OLED_SDIN_Set();
    . d  b( x6 z+ a7 c: u0 n9 X6 j
19.                 else
    
20.                         OLED_SDIN_Clr();
    
21.                 OLED_SCLK_Set();
    6 q' \6 g5 G: q* W
22.                
    
23.                 dat <<= 1;
    
24.         }
    
25.         
    $ \! B, z% z3 G3 V1 y$ M
26.         OLED_CS_Set();
    1 b! H8 e& e6 _* O* d7 R' ^8 _
27. }

复制代码

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

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

1.         OLED_WR_Byte(0xAE,OLED_CMD); //关闭显示
   9 F: I# ~" ?1 s4 K; `4 d3 k
2.         OLED_WR_Byte(0xD5,OLED_CMD); //设置时钟分频因子,震荡频率
   ' a! C- L6 b) t
3.         OLED_WR_Byte(80,OLED_CMD);   //[3:0],分频因子;[7:4],震荡频率
   / }% F) s" E7 V' @' X$ B/ y
4.         OLED_WR_Byte(0xA8,OLED_CMD); //设置驱动路数
   
5.         OLED_WR_Byte(0X3F,OLED_CMD); //默认0X3F(1/64)
   $ h6 t4 A" x; f. N" T9 N
6.         OLED_WR_Byte(0xD3,OLED_CMD); //设置显示偏移
   
7.         OLED_WR_Byte(0X00,OLED_CMD); //默认为0
   7 p2 y+ L1 m( ^* N0 o, T  T
8. 
   
9.         OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.
   ; u6 }. I; X$ t1 n/ @1 f6 L
10.                                                                                                             
    8 v) Q$ k/ K% b3 E2 c3 I9 o
11.         OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置
    
12.         OLED_WR_Byte(0x14,OLED_CMD); //bit2，开启/关闭
    . y7 ?% C* U$ Y, m- R' r. O
13.         OLED_WR_Byte(0x20,OLED_CMD); //设置内存地址模式
    
14.         OLED_WR_Byte(0x02,OLED_CMD); //[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
    
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:驱动路数
    
17.         OLED_WR_Byte(0xDA,OLED_CMD); //设置COM硬件引脚配置
    
18.         OLED_WR_Byte(0x12,OLED_CMD); //[5:4]配置
    ! v) `/ R9 ^( d+ V+ N; S
19.                  
    ! U4 a/ O# g2 U* i) k/ b/ E# V" `
20.         OLED_WR_Byte(0x81,OLED_CMD); //对比度设置
    
21.         OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
    7 J0 q4 z& h4 b. `2 U
22.         OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期
    / M0 G5 u. Q9 }* r6 [5 t
23.         OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
    ; D8 Z5 o8 k0 c* F
24.         OLED_WR_Byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率
    
25.         OLED_WR_Byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
    
26. 
    & p* m) t" ?- y5 R
27.         OLED_WR_Byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
    
28.         OLED_WR_Byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示                                                               
    
29.         OLED_WR_Byte(0xAF,OLED_CMD); //开启显示         
    # p7 ~9 p+ v( p0 P, q) ~0 U! a
30.         OLED_Clear();

复制代码

% x% S! }; t2 G: o) N# e; C* o由于使用的同一厂家的OLED屏幕，所以往OLED中写入的命令字符也是大致的相同，SPI四线写入的命令为：

1.       
   
2.         OLED_WR_Byte(0xA8, OLED_CMD);
   0 t' v# w4 Y  t
3.         OLED_WR_Byte(0x3F, OLED_CMD);
   
4.         OLED_WR_Byte(0xD3, OLED_CMD);
   
5.         OLED_WR_Byte(0x00, OLED_CMD);
   8 u3 i  Y' x2 m# Z8 j' q
6.         OLED_WR_Byte(0x40, OLED_CMD);
   ! z  A) _- q/ I
7.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
   
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:逐行显示
    
11.         OLED_WR_Byte(0x81, OLED_CMD);
    
12.         OLED_WR_Byte(0x7F, OLED_CMD);
    - @6 Z% F5 |: @8 z; ^+ s/ A
13.         OLED_WR_Byte(0xA4, OLED_CMD);
    
14.         OLED_WR_Byte(0xA6, OLED_CMD);
    * {& \* A$ J  a9 s
15.         OLED_WR_Byte(0xD5, OLED_CMD);
    
16.         OLED_WR_Byte(0x80, OLED_CMD);
      q2 c: B. D( V
17.         OLED_WR_Byte(0x8D, OLED_CMD);
    
18.         OLED_WR_Byte(0x14, OLED_CMD);
    
19.         OLED_WR_Byte(0xAF, OLED_CMD);
    
20.         
    / L2 O) S+ t1 x* l9 H
21.         OLED_Clear();

复制代码

不难发现，也是万变不离其宗。

总结
在这三种OLED的驱动方式中，最重要的还是需要了解OLED_WR_Byte（）这个函数后续的显示操作也是和此函数息息相关。而对于一些OLED屏幕的描点函数和显示数字和字符函数，如果后续有时间的话，我会逐渐完善的。
6 Y+ o- X. Y5 N; Q6 u9 m6 B
（SPI驱动OLED的方法和I2C驱动OLED的方法我在上文好像混淆了，准确的说第二种方法应该叫六针OLED，而第三种应该是七针OLED）

对于该篇文章的话，我也不太敢打包票说我能讲清楚OLED不同驱动方式下的详细步骤以及为什么，我只能尽我所能。如果有什么不足以及不对的地方希望大家指正。

/ w* K+ |' u8 @- K
& E# b( B8 w2 f8 w; M# P+ T