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

& `8 b$ R: \: N  {! U7 V+ b一、配置OLED的IO口
因为OLED模块分为8080串行、SPI四线、I2C，不同的数据传输模式导致了其不同的接线方法以及配置方法。
: c# w5 o# b6 Y
1.8080并口模式
, ~/ U* Q- p  X对于8080并口的配置，参考正点原子的例程。
其中8080并口，总共需要13根信号线通信，
这些信号线如下：

' o* m7 `5 \6 g

1. CS： OLED 片选信号。
   
2. WR(RW)：向 OLED 写入数据。
   9 r" D' w% p9 a# i, m
3. RD：从 OLED 读取数据。
     `  J1 L' K0 T% G2 a
4. D[7:0]： 8 位双向数据线。
   : }; a& o, T. r# m$ E0 M
5. RST(RES)：硬复位 OLED。
   ! m" d0 g/ l( t& }
6. DC：命令/数据标志（0，读写命令； 1，读写数据）

复制代码

$ ~3 u) f* }0 v' E) F( k在知道了接线之后，我们必须将所使用到的IO口使能：

1. //初始化SSD1306                                            
   
2. void OLED_Init(void)
   
3. {         
   " g+ ^' K3 ]" r7 ?0 N9 F; O
4. 
   
5.          GPIO_InitTypeDef  GPIO_InitStructure;
   1 G0 ]- z2 M" q
6.          
   
7.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOG, ENABLE);         //使能PC,D,G端口时钟
   3 H9 p+ I. c- L; I
8. 
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_6;         //PD3,PD6推挽输出  
   ; x. H% @' ?! f! S. O4 X. ^
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
    # c" G# _6 c, W; U7 H5 R' Z
13.          GPIO_SetBits(GPIOD,GPIO_Pin_3|GPIO_Pin_6);        //PD3,PD6 输出高
    / |3 {' x: e/ k2 J1 s; v
14. 
    
15. 
    3 d/ d; ]8 f- @2 H# o
16.          GPIO_InitStructure.GPIO_Pin =0xFF; //PC0~7 OUT推挽输出
    
17.          GPIO_Init(GPIOC, &GPIO_InitStructure);
    ( u. s+ V" J; ]5 Z* n  u
18.          GPIO_SetBits(GPIOC,0xFF); //PC0~7输出高
    
19. 
    9 P2 W' z1 f: J  v0 C: a" C6 C' i
20.          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;                                 //PG13,14,15 OUT推挽输出
    
21.          GPIO_Init(GPIOG, &GPIO_InitStructure);
    7 a/ W' S4 }3 b# M$ S5 Z$ k! R
22.          GPIO_SetBits(GPIOG,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);                                                 //PG13,14,15 OUT  输出高
    / b- Q3 d# k( B1 K7 U2 b

复制代码

在将IO口初始化之后，我们需要做的第三件事情便是如何写入命令或者数据到OLED中，因为使用OLED的时候，需要配置，而那些配置的命令是每个OLED出厂的已经存在了，属于命令范畴，我们所要了解的就是如何使用8080并口模式向OLED中写入命令。
$ o1 K% n4 M- s: |7 x7 n9 C1 u如正点原子里写的，
8 L5 ^- R8 a/ f9 ?
  j2 s8 c3 N* i3 \- @$ t

1. 
   
2. #define DATAOUT(x) GPIO_Write(GPIOC,x);//输出  
   
3. 
   2 Y0 I: Y" ~8 o& T: W& p% t9 H" N1 t
4. void OLED_WR_Byte(u8 dat,u8 cmd)
   
5. {
   . R+ a( s& Y# {- {' c" @' g
6.         DATAOUT(dat);            
   ; d( d- a( P5 [) K( h
7.          OLED_RS=cmd;   //DC位
   
8.         OLED_CS=0;           
   3 v% Y* h* j. f/ H5 h7 t' D
9.         OLED_WR=0;         
   
10.         OLED_WR=1;                //只有在WR由低变高的时候才能传入数据
    
11.         OLED_CS=1;         
    # u; `7 n! w4 Z' ^1 k8 l
12.         OLED_RS=1;         
    
13. }  

复制代码

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

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

1. /*
   , T  p1 Q- y" N/ v( M  M
2.         OLED0.96                                                                          STM32
   7 T: \, E2 f9 i7 B  {
3.         GND                                        <----------->                                        GND
   
4.         VCC                                        <----------->                                        3.3V
   , n$ f8 J+ Z6 s- e! _
5.         SCL                         <----------->                                        PE3
   
6.         SDA                                        <----------->                                        PE4
   ! h7 e( w2 Y- m9 |
7.         DC(Data/Command)            <----------->                                        PE0
   ' r7 ^2 q8 n$ B2 \, I9 F( C
8.         RST                                                <----------->                                        PE2
   ' Z. ~2 n# i* ?/ {
9. */
   
10. 
    1 g" h/ l, J; f' h$ y0 K5 l

复制代码

这里拿我之前所使用过的一个串口配置为主，来讲解。
4 t& A* O# c4 {' D
首先也是不变的初始化各个IO口：
' K( i1 X. \( l& ]' C' t6 D
  I( U, W" c5 @; A/ {

1. void OLED_Init()
   7 z: F& k) n7 A
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStructure;
   
4. 
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
   
6.         
   + b2 {7 G+ E1 {1 `' R* \, f
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 ;
     T( E0 \0 `; P' X3 y( C, H3 C
8.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   
9.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   + D" F; R+ ]5 J
10.         GPIO_Init(GPIOE, &GPIO_InitStructure);
    
11.         
    
12.         GPIO_SetBits(GPIOE, GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4);

复制代码

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

, q  U4 \: F- b1 l8 [7 W$ ]$ h4 y

1. 
   
2. //dat:要写入的数据/命令
   " S9 @' u) ?6 b( }
3. //cmd:数据/命令标志 0,表示命令;1,表示数据;
   
4. void OLED_WR_Byte(u8 dat,u8 cmd)
   
5. {        
   & c" \* o, C- n" \5 O
6.         u8 i;                          
   
7.         if(cmd)
   
8.           OLED_RS_Set();
   0 P% j" X, ]" _* v$ T2 B3 k
9.         else
   
10.           OLED_RS_Clr();                  
    . _4 Q" F/ Q( A- u, P: _
11.         for(i=0;i<8;i++)
    7 x0 T. ^  x( _  l
12.         {                          
    - I) R0 g( u. t' ?: _
13.                 OLED_SCLK_Clr();
    
14.                 if(dat&0x80)
    0 F0 I, [+ I* D4 `( g6 e1 f7 U
15.                    OLED_SDIN_Set();
    ( P0 z7 l7 S. ~( I5 ^
16.                 else
    
17.                    OLED_SDIN_Clr();
    & I" K( A4 s5 ^  m
18.                 OLED_SCLK_Set();
    
19.                 dat<<=1;   
    
20.         }                                                   
    
21.         OLED_RS_Set();            
    
22. }

复制代码

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

+ A: R# y& }& r8 n5 |

1.         OLED_RST_Set();
   & n0 c7 [- q8 a! c& y; u) ^
2.         delay_us(100000);
   
3.         OLED_RST_Clr();
   4 }  K" A6 g' F4 E' W! R* S
4.         delay_us(20);
   
5.         OLED_RST_Set();
   9 `9 s* Q! Z4 o7 H3 A
6.         
   
7.         OLED_WR_Byte(0xA8, OLED_CMD);
   $ V( V5 A. @  Q+ F* O8 g' V
8.         OLED_WR_Byte(0x3F, OLED_CMD);
   
9.         OLED_WR_Byte(0xD3, OLED_CMD);
   * E5 _( s: w8 \3 H7 W( D
10.         OLED_WR_Byte(0x00, OLED_CMD);
    
11.         OLED_WR_Byte(0x40, OLED_CMD);
    " Q# x% ]6 T' C
12.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
    - V) A" [6 f, E
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:逐行显示
    # U& @% ~" S. t+ X  w% H
16.         OLED_WR_Byte(0x81, OLED_CMD);
    
17.         OLED_WR_Byte(0x7F, OLED_CMD);
    # n' P+ L& `- ^3 X* c
18.         OLED_WR_Byte(0xA4, OLED_CMD);
    
19.         OLED_WR_Byte(0xA6, OLED_CMD);
    ; ]' s: l  V0 o. e  G2 }. t4 {
20.         OLED_WR_Byte(0xD5, OLED_CMD);
    
21.         OLED_WR_Byte(0x80, OLED_CMD);
    
22.         OLED_WR_Byte(0x8D, OLED_CMD);
    
23.         OLED_WR_Byte(0x14, OLED_CMD);
    
24.         OLED_WR_Byte(0xAF, OLED_CMD);
    8 @( D+ O- Y  y) q7 ^8 @: E6 d% s' o
25.         
    ) q' c8 Z2 E/ _0 {" `
26.         OLED_Clear();

复制代码

. ?1 P9 t' g9 p( P3.I2C
这里I2C和上文提到的OLED的初始化以及功能实现都大致相同，就不做太多的语言描述。
- X+ K( P5 Y% L
: g4 [/ M! ~. }! d0 l

1. /*
   
2.         OLED0.96                                                                          STM32
   
3.         GND                                        <----------->                                        GND
   + X) g& c! |# x! y( G: s
4.         VCC                                        <----------->                                        3.3V
   % R" B9 D0 l$ d/ A- V1 @" w2 {
5.         D0(SCLK)                    <----------->                                        PA0                        
   
6.         D1SDIN()                      <----------->                                        PA1
   8 {, K2 z, y6 R
7.         RES                                         <----------->                                        PA2
   & b  [2 Q# S; d6 ]5 M
8.         DC(Data/Command)           <----------->                                        PA3
   
9.         CS                                                <----------->                                        PA4
   
10. */

复制代码

% V# q. L9 i. H! n2 E3 D. q' UOLED的初始化和配置如下：

% K4 b! y  I4 f0 h9 T7 e$ k3 q

1. void OLED_Init(void)
   
2. {
   & a0 _1 q& q: \* c5 L
3.         GPIO_InitTypeDef GPIO_InitStructure;
   
4. 
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
   + `0 h& q1 @, _1 z! t1 L2 Z
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);
    
11.         
    
12.         GPIO_SetBits(GPIOA, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4);
    , f9 F& f$ P5 t8 q4 e7 o
13.         
    
14.         OLED_RST_Set();
    
15.         delay_us(100000);
    $ r. e  n, B6 j5 N
16.         OLED_RST_Clr();
    . v' [8 X1 x4 p) P8 R7 k% U$ i
17.         delay_us(20);
    5 D+ e& f6 j# D+ i* T* u4 ?
18.         OLED_RST_Set();
    ! @" P+ z8 `* M7 a
19.         
    
20.         OLED_WR_Byte(0xA8, OLED_CMD);
    7 v* o- v1 Y  v3 }: V8 U$ F
21.         OLED_WR_Byte(0x3F, OLED_CMD);
    % z" t2 m5 }+ C) i1 d
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:控制屏幕显示左右映射翻转的
    
26.         OLED_WR_Byte(0xC0, OLED_CMD);   //C0/C8：控制屏幕上下映射翻转的
    
27.         OLED_WR_Byte(0xDA, OLED_CMD);
    ( ]+ z  ~! t' ^
28.         OLED_WR_Byte(0x12, OLED_CMD);   //02h:隔行显示  12h:逐行显示
    " l/ `1 o/ m' n  I
29.         OLED_WR_Byte(0x81, OLED_CMD);
    5 G/ D6 i# n3 U  f2 Z$ b5 |1 q
30.         OLED_WR_Byte(0x7F, OLED_CMD);
    # ?& a3 l/ b6 ~- s' M
31.         OLED_WR_Byte(0xA4, OLED_CMD);
    * r6 i0 t. ^0 N
32.         OLED_WR_Byte(0xA6, OLED_CMD);
    
33.         OLED_WR_Byte(0xD5, OLED_CMD);
    
34.         OLED_WR_Byte(0x80, OLED_CMD);
    ' m' ^/ V6 f8 X; d3 U
35.         OLED_WR_Byte(0x8D, OLED_CMD);
    * G4 Y# }  C. o
36.         OLED_WR_Byte(0x14, OLED_CMD);
    
37.         OLED_WR_Byte(0xAF, OLED_CMD);
    
38.         
    
39.         OLED_Clear();
    # H1 b& e8 `5 H( |
40. }

复制代码

1 Q9 J. a/ c: L3 x* I+ E9 I也是照着本文提到的第二种方法能完成的。这里就不太多描述。
但是，与上文提到的第二种方法不同，在数据/命令选择中，与上文不同

- S3 h, f7 S$ o: Y) F# ^

1. //dat:要写入的数据/命令
   
2. //cmd：0表示命令，1表示数据
   ; U  j6 k' ?& ^
3. void OLED_WR_Byte(u8 dat,u8 cmd)
   . A( e% M& @  e& C# `
4. {
   / r: V8 |. w% F
5.         u8 i;
   0 W  I/ B  G/ e5 F. t
6.         
   + H8 z) Z1 m7 L! `+ z" @$ a% c
7.         if(cmd)
   ' m! h& K' e; Y
8.                 OLED_DC_Set();
   
9.         else
   
10.                 OLED_DC_Clr();   
    
11.         
    
12.         OLED_CS_Clr();  //拉低CS
    0 J( l. b) ^" c1 J& V5 s1 J# Z2 ~
13.         
    6 `8 R+ o9 _/ e5 Y% {3 q
14.         for(i = 0; i < 8; i++)
    
15.         {
    ' m5 L& i- d4 h9 `  n7 U* g
16.                 OLED_SCLK_Clr();
    
17.                 if(dat & 0x80)
    
18.                         OLED_SDIN_Set();
    
19.                 else
    
20.                         OLED_SDIN_Clr();
    
21.                 OLED_SCLK_Set();
    
22.                
    
23.                 dat <<= 1;
    % U, P7 g( G+ o) a
24.         }
    
25.         
    
26.         OLED_CS_Set();
    
27. }

复制代码

代码分析：
与上面不同的是，使用此方法驱动的OLED的IO多了SDIN这一个IO口，而这个IO的存在，导致其OLED_WR_ Byte()的写法不太一样。需要注意一下即可。
- O, \  ~' W: l5 ^  Y( e
二、阅读datasheet（数据手册）
* M5 j; L; ~1 S  L  r9 l1 UOLED可以传输命令（cmd）或者是数据（data），而传输命令或者传输数据，都需要依靠之前提到的函数，以8080串口方式为例的OLED初始化，正点原子的代码中也很明确的注释了：

1.         OLED_WR_Byte(0xAE,OLED_CMD); //关闭显示
   ! d  e, c1 l  H9 [; \
2.         OLED_WR_Byte(0xD5,OLED_CMD); //设置时钟分频因子,震荡频率
   & o- r; N8 C4 e% j
3.         OLED_WR_Byte(80,OLED_CMD);   //[3:0],分频因子;[7:4],震荡频率
   
4.         OLED_WR_Byte(0xA8,OLED_CMD); //设置驱动路数
   
5.         OLED_WR_Byte(0X3F,OLED_CMD); //默认0X3F(1/64)
   
6.         OLED_WR_Byte(0xD3,OLED_CMD); //设置显示偏移
   * p" D! g% H$ O; r+ N: X9 a
7.         OLED_WR_Byte(0X00,OLED_CMD); //默认为0
   
8. 
   5 e: k: k# m1 }) o7 O
9.         OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.
   
10.                                                                                                             
    1 r" J5 t( ^2 @" Z- I' u- R1 y0 L& ~
11.         OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置
    
12.         OLED_WR_Byte(0x14,OLED_CMD); //bit2，开启/关闭
    2 V  X1 j% g& I: h$ M' o( k
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]配置
    
19.                  
    
20.         OLED_WR_Byte(0x81,OLED_CMD); //对比度设置
    $ e7 C4 k$ @6 ?2 P# W1 X( Z
21.         OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
    
22.         OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期
    0 J' B( x! r& E7 @; h
23.         OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
    
24.         OLED_WR_Byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率
    1 X( o0 |+ i) O  I5 V5 z
25.         OLED_WR_Byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
    
26. 
    
27.         OLED_WR_Byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
    
28.         OLED_WR_Byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示                                                               
    , l+ T' H6 l# w' }) u. u
29.         OLED_WR_Byte(0xAF,OLED_CMD); //开启显示         
    
30.         OLED_Clear();

复制代码

由于使用的同一厂家的OLED屏幕，所以往OLED中写入的命令字符也是大致的相同，SPI四线写入的命令为：
4 B: R7 R! A  v" p6 ]

1.       
   
2.         OLED_WR_Byte(0xA8, OLED_CMD);
   
3.         OLED_WR_Byte(0x3F, OLED_CMD);
   
4.         OLED_WR_Byte(0xD3, OLED_CMD);
   : K- t' |) T$ e& p* G7 x" \+ ^
5.         OLED_WR_Byte(0x00, OLED_CMD);
   
6.         OLED_WR_Byte(0x40, OLED_CMD);
   4 U/ e9 L3 C9 W3 h% \
7.         OLED_WR_Byte(0xA1, OLED_CMD);   //A0/A1:控制屏幕显示左右映射翻转的
   
8.         OLED_WR_Byte(0xC0, OLED_CMD);   //C0/C8：控制屏幕上下映射翻转的
   ( D/ q4 }" x, O7 s! V
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);
    5 g) ]0 H. X( I4 L: I  Q, C, t* K$ [
13.         OLED_WR_Byte(0xA4, OLED_CMD);
    : }* X; S% h$ k) ^  Q* l. y
14.         OLED_WR_Byte(0xA6, OLED_CMD);
    & G# l+ |/ B) `  Z3 |: a
15.         OLED_WR_Byte(0xD5, OLED_CMD);
    ' p$ R! C+ x! F
16.         OLED_WR_Byte(0x80, OLED_CMD);
    1 U7 X0 a+ S# d4 ~6 D" X
17.         OLED_WR_Byte(0x8D, OLED_CMD);
    . ~/ l$ l$ Z1 g) P# Q* G( f6 H5 M0 t+ n
18.         OLED_WR_Byte(0x14, OLED_CMD);
    
19.         OLED_WR_Byte(0xAF, OLED_CMD);
    
20.         
    ) }: `* z0 x- D% u" B7 Z
21.         OLED_Clear();

复制代码

不难发现，也是万变不离其宗。
6 |$ B1 O  a. K2 x  L. C) l
! P% Y! o6 ^/ D2 t* \总结
在这三种OLED的驱动方式中，最重要的还是需要了解OLED_WR_Byte（）这个函数后续的显示操作也是和此函数息息相关。而对于一些OLED屏幕的描点函数和显示数字和字符函数，如果后续有时间的话，我会逐渐完善的。

（SPI驱动OLED的方法和I2C驱动OLED的方法我在上文好像混淆了，准确的说第二种方法应该叫六针OLED，而第三种应该是七针OLED）
, k* T$ k7 c# E
; ~; c( o6 `  d* C对于该篇文章的话，我也不太敢打包票说我能讲清楚OLED不同驱动方式下的详细步骤以及为什么，我只能尽我所能。如果有什么不足以及不对的地方希望大家指正。
' f% O+ ^/ S' F; m4 r
. \. m8 L6 f/ {5 K) I