前言
$ Y! O) n4 N, uOLED作为STM32的一个较为重要的外设，其作用也是为了方便调试代码。OLED模块的驱动可以使用8080、SPI四线、SPI3线、I2C的方法进行驱动。本文主要根据OLED的数据手册分析8080、SPI四线、I2C的使用。

6 [4 J8 o7 {9 ^1 J' e一、配置OLED的IO口
6 a) r2 x& K4 c因为OLED模块分为8080串行、SPI四线、I2C，不同的数据传输模式导致了其不同的接线方法以及配置方法。

1 e4 l) r6 H( Y! V2 H% l/ Q1.8080并口模式
对于8080并口的配置，参考正点原子的例程。
其中8080并口，总共需要13根信号线通信，
- U+ f1 C9 V) r7 \这些信号线如下：

- K3 T4 a$ X- N& O& M, v( G

1. CS： OLED 片选信号。
   
2. WR(RW)：向 OLED 写入数据。
   
3. RD：从 OLED 读取数据。
     ?* ]( p. Y) {9 P4 L$ a: s
4. D[7:0]： 8 位双向数据线。
     m* v/ Y+ v$ \& h6 l6 w
5. RST(RES)：硬复位 OLED。
   % ^" K! k+ K. l# k6 K  t" R
6. DC：命令/数据标志（0，读写命令； 1，读写数据）

复制代码

在知道了接线之后，我们必须将所使用到的IO口使能：
6 [3 g6 A9 X" i& l0 G5 ~3 R

1. //初始化SSD1306                                            
   + p6 W& o5 v5 h7 I/ s
2. void OLED_Init(void)
   
3. {         
   
4. 
   . n3 J# [) k4 Q+ n6 ?2 [7 [
5.          GPIO_InitTypeDef  GPIO_InitStructure;
   # n( n, k# _' O
6.          
   ) \; S4 J- u$ _# v: m
7.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOG, ENABLE);         //使能PC,D,G端口时钟
   ! l! j9 W- O6 d
8. 
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_6;         //PD3,PD6推挽输出  
   6 O! }/ _! ]! f+ V
10.          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    
11.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//速度50MHz
    / v8 E) k" O1 v* Z3 B
12.          GPIO_Init(GPIOD, &GPIO_InitStructure);          //初始化GPIOD3,6
    
13.          GPIO_SetBits(GPIOD,GPIO_Pin_3|GPIO_Pin_6);        //PD3,PD6 输出高
    
14. 
    
15. 
    6 y& c9 [) b/ x$ R6 H
16.          GPIO_InitStructure.GPIO_Pin =0xFF; //PC0~7 OUT推挽输出
    - n5 l: T$ `5 e8 D
17.          GPIO_Init(GPIOC, &GPIO_InitStructure);
    
18.          GPIO_SetBits(GPIOC,0xFF); //PC0~7输出高
    
19. 
    * V: T# u! b* r1 d' A
20.          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;                                 //PG13,14,15 OUT推挽输出
    0 n- F* D& L; ~+ T3 O8 b" x
21.          GPIO_Init(GPIOG, &GPIO_InitStructure);
    2 I: I, f3 E# G( J7 D7 x, u
22.          GPIO_SetBits(GPIOG,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);                                                 //PG13,14,15 OUT  输出高
    $ r0 w" ]! e  [9 A

复制代码

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

1. 
   ' _5 `" |% S5 k8 _. Q
2. #define DATAOUT(x) GPIO_Write(GPIOC,x);//输出  
   * t+ O7 Y& N/ K% b2 {6 c# _
3. 
   # `& G" E1 ]  [5 }- o6 C
4. void OLED_WR_Byte(u8 dat,u8 cmd)
   , g3 Z& J2 u$ t- `! O* ^
5. {
   1 Q. B$ U! h! l. ?* d# x0 u
6.         DATAOUT(dat);            
   
7.          OLED_RS=cmd;   //DC位
   / E3 }9 f/ m$ Y4 c# l
8.         OLED_CS=0;           
   0 t" Q/ U: B1 c, f' P) W2 `7 c) X. i
9.         OLED_WR=0;         
   / g7 \, `7 _3 e( s) E5 q
10.         OLED_WR=1;                //只有在WR由低变高的时候才能传入数据
    
11.         OLED_CS=1;         
    
12.         OLED_RS=1;         
    % O! c: \) V/ o" ~/ F0 x# p
13. }  

复制代码

代码分析：根据之前的相应IO口连接，同时在OLED的数据手册中有提及到的，只有当OLED的片选CS拉低后以及WR拉低后，才可以开始往OLED中写入数据。后续的OLED初始化配置都是基于这个函数所进行的操作的。

, O8 x7 h; N, R2.SPI四线
SPI四线的OLED也只是万变不离其宗，一样的初始化过程，先确认接线，相比于8080串口接线方法，SPI四线极大的缩小了IO口的使用数量，更加便于使用。

3 U9 Y0 m# t& j2 Z, r

1. /*
   # l) @6 R) [9 i7 H. E! A2 D$ Y
2.         OLED0.96                                                                          STM32
   5 b" }7 b) O' K' M' s; Z  E
3.         GND                                        <----------->                                        GND
   
4.         VCC                                        <----------->                                        3.3V
   
5.         SCL                         <----------->                                        PE3
   
6.         SDA                                        <----------->                                        PE4
   
7.         DC(Data/Command)            <----------->                                        PE0
   5 X3 O1 R$ `5 U2 F
8.         RST                                                <----------->                                        PE2
   " w  G3 a! b+ P8 q
9. */
   4 ]  J# f4 Z$ Q" @" w
10. 
    

复制代码

" Y7 _1 t% o1 _0 K2 x. K0 g# O这里拿我之前所使用过的一个串口配置为主，来讲解。
* S; @; l5 A9 x- m, ~0 n0 C
首先也是不变的初始化各个IO口：
) F( z" @2 v3 g" A- J3 X8 T
. r+ O4 o; {! N1 S: p3 o* p

1. void OLED_Init()
   ! t9 O1 n0 N8 j1 p
2. {
   / e$ B4 A2 }' A8 u2 p; u  W
3.         GPIO_InitTypeDef GPIO_InitStructure;
   
4. 
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
   " R2 _8 A( e+ I% A; k) F/ `5 n1 B
6.         
   , u1 P- o. @: N- K* d
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 ;
   4 D' g4 [4 M, J- `& A
8.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   
9.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   
10.         GPIO_Init(GPIOE, &GPIO_InitStructure);
    1 o' q9 b0 G1 _. \+ W& f; D
11.         
    6 }8 Z/ {, ^0 I+ ^1 o! X9 D0 L
12.         GPIO_SetBits(GPIOE, GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4);

复制代码

- Y2 C3 C* y$ M8 n4 ?初始化完成后，也是需要进行判断，判断用户是打算写入数据还是写入命令：

1. 
   : ^. H' X" r; v2 @: W- h
2. //dat:要写入的数据/命令
   
3. //cmd:数据/命令标志 0,表示命令;1,表示数据;
   5 p- e) e+ J: V+ N3 W0 {
4. void OLED_WR_Byte(u8 dat,u8 cmd)
   9 j& f4 E+ ^* v5 }- F
5. {        
   
6.         u8 i;                          
   
7.         if(cmd)
   
8.           OLED_RS_Set();
   + c+ @. \' B0 r
9.         else
   
10.           OLED_RS_Clr();                  
    * `3 |* H9 l0 f) A/ X' O0 ^
11.         for(i=0;i<8;i++)
    
12.         {                          
    6 a0 ]1 m. i2 Q5 C, G8 W1 s
13.                 OLED_SCLK_Clr();
    
14.                 if(dat&0x80)
    : M$ [7 g; x% x1 f5 o4 M6 ?! [. p, P
15.                    OLED_SDIN_Set();
    
16.                 else
    
17.                    OLED_SDIN_Clr();
    
18.                 OLED_SCLK_Set();
    ; U' n# u* L& C7 a4 w* R
19.                 dat<<=1;   
    
20.         }                                                   
    
21.         OLED_RS_Set();            
    
22. }

复制代码

有了这个主要的函数之后，便可以对OLED进行配置，如同上文所提到的8080串口配置一样，

& C: r/ i- M- @. o3 c$ g

1.         OLED_RST_Set();
   
2.         delay_us(100000);
   
3.         OLED_RST_Clr();
   ) x/ C3 ?. b7 H
4.         delay_us(20);
   ! C! ]* i/ q  X/ r
5.         OLED_RST_Set();
   : o5 W. v. w4 {. u$ O5 T2 a& R- Z
6.         
   2 L9 N  B. d9 s& y( u# U
7.         OLED_WR_Byte(0xA8, OLED_CMD);
   
8.         OLED_WR_Byte(0x3F, OLED_CMD);
   
9.         OLED_WR_Byte(0xD3, OLED_CMD);
   % ~/ z2 w8 R6 Q+ x( x7 v: q
10.         OLED_WR_Byte(0x00, OLED_CMD);
    . ?5 U% v) U% U" J
11.         OLED_WR_Byte(0x40, OLED_CMD);
    
12.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
    : a. {. e3 w* N# M$ \
13.         OLED_WR_Byte(0xC0, OLED_CMD);   //C0/C8：控制屏幕上下映射翻转的
    
14.         OLED_WR_Byte(0xDA, OLED_CMD);
    2 H- I0 D3 u) J; B4 @
15.         OLED_WR_Byte(0x12, OLED_CMD);   //02h:隔行显示  12h:逐行显示
    8 P7 }# p0 X  G5 q+ _# I
16.         OLED_WR_Byte(0x81, OLED_CMD);
    
17.         OLED_WR_Byte(0x7F, OLED_CMD);
    
18.         OLED_WR_Byte(0xA4, OLED_CMD);
    ) ^4 b' i7 G2 q( M* B0 _
19.         OLED_WR_Byte(0xA6, OLED_CMD);
    
20.         OLED_WR_Byte(0xD5, OLED_CMD);
    
21.         OLED_WR_Byte(0x80, OLED_CMD);
    ; M& a( k" f) v! M8 V+ t# O! x# S
22.         OLED_WR_Byte(0x8D, OLED_CMD);
    
23.         OLED_WR_Byte(0x14, OLED_CMD);
    
24.         OLED_WR_Byte(0xAF, OLED_CMD);
    
25.         
    4 X" d' u( X4 w) f3 m- @
26.         OLED_Clear();

复制代码

3 X) C& N' J6 `! u+ u3.I2C
  m' g% m  y4 g% Y1 L) c这里I2C和上文提到的OLED的初始化以及功能实现都大致相同，就不做太多的语言描述。
2 _, s- g- M+ \) I0 `2 K
0 A$ J" Y  D& P1 x* v; Y! O

1. /*
   ) q' U7 p2 w3 H' h* R4 a
2.         OLED0.96                                                                          STM32
   
3.         GND                                        <----------->                                        GND
   7 R2 q1 e+ B) a0 T5 X7 D
4.         VCC                                        <----------->                                        3.3V
   ) |, a  G; N+ o; f
5.         D0(SCLK)                    <----------->                                        PA0                        
   
6.         D1SDIN()                      <----------->                                        PA1
   0 h. q! k1 ~+ i( ~( D: _
7.         RES                                         <----------->                                        PA2
   
8.         DC(Data/Command)           <----------->                                        PA3
   , X; x' p7 G& S, s
9.         CS                                                <----------->                                        PA4
   
10. */

复制代码

4 q* X3 |6 M# q; j9 qOLED的初始化和配置如下：
- I2 C8 Z# n( ^: G) s2 c) f* }

1. void OLED_Init(void)
   
2. {
   / B1 q1 u$ ]/ P3 _) \5 s
3.         GPIO_InitTypeDef GPIO_InitStructure;
   0 m7 o( [) Y# ], W2 @
4. 
   6 v+ e/ @, I1 l+ s
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
   ) g8 G! H+ h5 l  c5 B1 ~1 t4 `
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;
   + o( ^" j+ Z4 b; ]5 }+ f
9.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   
10.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    2 n9 `0 U* w' X7 K9 D
11.         
    
12.         GPIO_SetBits(GPIOA, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4);
    : o, ]/ B  L4 h; e
13.         
    ; r" A% n: A8 v) v
14.         OLED_RST_Set();
    * C6 m4 m2 d- \6 J$ @
15.         delay_us(100000);
    
16.         OLED_RST_Clr();
    
17.         delay_us(20);
    
18.         OLED_RST_Set();
    
19.         
    * e8 Y9 Q1 M3 \. @
20.         OLED_WR_Byte(0xA8, OLED_CMD);
    & V/ a9 B& ~) U  ^9 n6 j/ b; S% |8 ^
21.         OLED_WR_Byte(0x3F, OLED_CMD);
    ! N  Z) ], I$ `% P# }
22.         OLED_WR_Byte(0xD3, OLED_CMD);
    
23.         OLED_WR_Byte(0x00, OLED_CMD);
    
24.         OLED_WR_Byte(0x40, OLED_CMD);
    
25.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
    0 V; o% \) x$ \2 h% `6 g1 |
26.         OLED_WR_Byte(0xC0, OLED_CMD);   //C0/C8：控制屏幕上下映射翻转的
    6 i! a+ X1 G  h1 p
27.         OLED_WR_Byte(0xDA, OLED_CMD);
    
28.         OLED_WR_Byte(0x12, OLED_CMD);   //02h:隔行显示  12h:逐行显示
    + C4 Q( ^; V6 O3 f; p
29.         OLED_WR_Byte(0x81, OLED_CMD);
    
30.         OLED_WR_Byte(0x7F, OLED_CMD);
    , s4 Y" ]- P8 T4 O: A% p: p( d
31.         OLED_WR_Byte(0xA4, OLED_CMD);
    
32.         OLED_WR_Byte(0xA6, OLED_CMD);
    
33.         OLED_WR_Byte(0xD5, OLED_CMD);
    " f1 H5 _1 L- B3 D# X) b
34.         OLED_WR_Byte(0x80, OLED_CMD);
    
35.         OLED_WR_Byte(0x8D, OLED_CMD);
    1 w+ w, ], E  }9 S' V
36.         OLED_WR_Byte(0x14, OLED_CMD);
    
37.         OLED_WR_Byte(0xAF, OLED_CMD);
    
38.         
    8 _: h0 }/ U3 c2 @: ^2 S
39.         OLED_Clear();
    
40. }

复制代码

6 E* A& W4 @  r8 L+ s2 ^, k! `也是照着本文提到的第二种方法能完成的。这里就不太多描述。
但是，与上文提到的第二种方法不同，在数据/命令选择中，与上文不同

1. //dat:要写入的数据/命令
   & T% }7 O- f- F
2. //cmd：0表示命令，1表示数据
   
3. void OLED_WR_Byte(u8 dat,u8 cmd)
   
4. {
   % s4 o7 p$ x; L+ K) L
5.         u8 i;
   " H8 p& E/ l! F6 ?* N6 ?4 m
6.         
   7 E% c1 u8 k% g, k
7.         if(cmd)
   * p. T' c/ e3 V0 g  N9 a( W% R
8.                 OLED_DC_Set();
   
9.         else
   
10.                 OLED_DC_Clr();   
    
11.         
    
12.         OLED_CS_Clr();  //拉低CS
    ( {, x; x' F0 _
13.         
    9 v, _  X5 K2 \  F6 w
14.         for(i = 0; i < 8; i++)
    
15.         {
    
16.                 OLED_SCLK_Clr();
    
17.                 if(dat & 0x80)
    
18.                         OLED_SDIN_Set();
    / O  ]6 {! J5 ^, Z1 u9 E
19.                 else
    
20.                         OLED_SDIN_Clr();
    
21.                 OLED_SCLK_Set();
    
22.                
    
23.                 dat <<= 1;
    $ X4 G9 A7 w. z: o
24.         }
    6 E: J- z. S; j8 f) |
25.         
    ; k* S7 i9 M7 v) E0 i8 i
26.         OLED_CS_Set();
    
27. }

复制代码

1 j" h5 T% v+ |$ M/ `代码分析：
与上面不同的是，使用此方法驱动的OLED的IO多了SDIN这一个IO口，而这个IO的存在，导致其OLED_WR_ Byte()的写法不太一样。需要注意一下即可。

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

1.         OLED_WR_Byte(0xAE,OLED_CMD); //关闭显示
   
2.         OLED_WR_Byte(0xD5,OLED_CMD); //设置时钟分频因子,震荡频率
   3 R! Y! X; O( N5 S7 N5 f4 r
3.         OLED_WR_Byte(80,OLED_CMD);   //[3:0],分频因子;[7:4],震荡频率
   
4.         OLED_WR_Byte(0xA8,OLED_CMD); //设置驱动路数
   1 ]7 J6 b# Y/ [* R8 c' F
5.         OLED_WR_Byte(0X3F,OLED_CMD); //默认0X3F(1/64)
   
6.         OLED_WR_Byte(0xD3,OLED_CMD); //设置显示偏移
   
7.         OLED_WR_Byte(0X00,OLED_CMD); //默认为0
   
8. 
   + v/ m' Q- _( q4 Z# x- {
9.         OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.
   
10.                                                                                                             
    ) y" @6 Q6 s. Y0 W4 n# O
11.         OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置
    , ]4 G1 t/ w1 L( C( a
12.         OLED_WR_Byte(0x14,OLED_CMD); //bit2，开启/关闭
    
13.         OLED_WR_Byte(0x20,OLED_CMD); //设置内存地址模式
    9 d7 g, o: Z1 c* S
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:驱动路数
    , V4 ^# q) g5 Z$ @+ e0 e5 V
17.         OLED_WR_Byte(0xDA,OLED_CMD); //设置COM硬件引脚配置
    
18.         OLED_WR_Byte(0x12,OLED_CMD); //[5:4]配置
    
19.                  
    
20.         OLED_WR_Byte(0x81,OLED_CMD); //对比度设置
    0 b6 \( u8 V5 M$ n  J; L
21.         OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
    
22.         OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期
    
23.         OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
    
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. 
    : A' l" S9 _* a
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); //开启显示         
    
30.         OLED_Clear();

复制代码

- ~1 A& u$ b- |( Y由于使用的同一厂家的OLED屏幕，所以往OLED中写入的命令字符也是大致的相同，SPI四线写入的命令为：
9 q: L$ ?; l+ L+ N! R3 o! _

1.       
   ! d+ t8 z3 k7 O  G1 F: B
2.         OLED_WR_Byte(0xA8, OLED_CMD);
   4 D! F0 V4 x: |  V1 A% c/ G6 }
3.         OLED_WR_Byte(0x3F, OLED_CMD);
   
4.         OLED_WR_Byte(0xD3, OLED_CMD);
   # a$ Q2 r! Z6 f8 x+ O& ^- _
5.         OLED_WR_Byte(0x00, OLED_CMD);
   
6.         OLED_WR_Byte(0x40, OLED_CMD);
   & S4 U7 Z+ J- x: R
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);
   5 t9 T9 U& b5 q: o8 S. n; e
10.         OLED_WR_Byte(0x12, OLED_CMD);   //02h:隔行显示  12h:逐行显示
    2 v2 |! K, D$ i- k$ j
11.         OLED_WR_Byte(0x81, OLED_CMD);
    
12.         OLED_WR_Byte(0x7F, OLED_CMD);
    
13.         OLED_WR_Byte(0xA4, OLED_CMD);
    : {0 k! b7 ~/ i( P8 @4 M
14.         OLED_WR_Byte(0xA6, OLED_CMD);
    
15.         OLED_WR_Byte(0xD5, OLED_CMD);
    
16.         OLED_WR_Byte(0x80, OLED_CMD);
    & R5 t7 n3 ?  K; o" W
17.         OLED_WR_Byte(0x8D, OLED_CMD);
    
18.         OLED_WR_Byte(0x14, OLED_CMD);
    
19.         OLED_WR_Byte(0xAF, OLED_CMD);
    ( o0 g; P- w* B
20.         
    $ Q4 v5 k% g/ A; j' Z
21.         OLED_Clear();

复制代码

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

总结
/ p; i+ N" G. l1 H在这三种OLED的驱动方式中，最重要的还是需要了解OLED_WR_Byte（）这个函数后续的显示操作也是和此函数息息相关。而对于一些OLED屏幕的描点函数和显示数字和字符函数，如果后续有时间的话，我会逐渐完善的。

（SPI驱动OLED的方法和I2C驱动OLED的方法我在上文好像混淆了，准确的说第二种方法应该叫六针OLED，而第三种应该是七针OLED）

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

. ~- k( P8 d7 y( \6 a/ Z/ o
$ x% e! i" G, |7 A  [) d