01. OLED概述
OLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（OrganicElectroluminesence Display， OELD）。OLED 由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。
3 l% i3 Z; |* y% k% i
LCD 都需要背光，而 OLED 不需要，因为它是自发光的。这样同样的显示，OLED 效果要来得好一些。以目前的技术，OLED 的尺寸还难以大型化，但是分辨率确可以做到很高。
" \( r' ~$ R+ ]& u/ [
02. OLED初始化



驱动 IC 的初始化代码，我们直接使用厂家推荐的设置就可以了，只要对细节部分进行一些修改，使其满足我们自己的要求即可，其他不需要变动。
; Z% \' p+ [; a+ g! m
OLED 显示需要的相关设置步骤如下：

- z- ~$ O  j( p: U1 ）设置 STM32F4 与 与 OLED 模块相连接的 IO 。
这一步，先将我们与 OLED 模块相连的 IO 口设置为输出，具体使用哪些 IO 口，这里需要根据连接电路以及 OLED 模块所设置的通讯模式来确定。
; Y! z/ ]! C" f! Y" P
2 ）初始化 OLED 模块。
其实这里就是上面的初始化框图的内容，通过对 OLED 相关寄存器的初始化，来启动 OLED的显示。

1 t/ b9 u, f7 C: n" R, Z3 ）通过函数将字符和数字显示到 OLED 模块上。
这里就是通过我们设计的程序，将要显示的字符送到 OLED 模块就可以了
7 a: |2 ~. ^! \* X% U& S3 I/ K
通过以上三步，我们就可以使用 ALIENTEK OLED 模块来显示字符和数字了。

03. 硬件设计
用到的硬件资源有：
1） 指示灯 DS0
" I! [1 J5 ^" T# k5 b+ y: \) @. i# O2） OLED 模块

硬件上，OLED 与探索者 STM32F4 开发板的 IO 口对应关系如下：
8 B5 b6 e* L4 E4 J: d7 q7 a9 @  j8 m+ k6 iOLED_CS 对应 DCMI_VSYNC，即：PB7;
OLED_RS 对应 DCMI_SCL，即：PD6;
OLED_WR 对应 DCMI_HREF，即：PA4;
OLED_RD 对应 DCMI_SDA，即：PD7;
: y% W4 J" i9 \8 P8 S5 C3 v7 @OLED_RST 对应 DCMI_RESET，即：PG15;
! w. [# `5 l9 t. x5 m' t* a  qOLED_D[7:0]对应 DCMI_D[7:0]，即：PE6/PE5/PB6/PC11/PC9/PC8/PC7/PC6;
3 R, I3 V9 M$ ?+ {+ Z, Q  a
04. 程序示例
oled.h

1. #ifndef __OLED_H
   3 S2 C3 I0 N6 l( F: U3 i
2. #define __OLED_H                                   
   
3. #include "sys.h"
   
4. #include "stdlib.h"            
   
5. 
   
6. //OLED模式设置
   + ~* P% \+ A6 O7 |0 b! _) [
7. //0: 4线串行模式  （模块的BS1，BS2均接GND）
   
8. //1: 并行8080模式 （模块的BS1，BS2均接VCC）
   4 i7 X; {5 I: t) ~! k6 u  H
9. #define OLED_MODE         1
   
10.                                                                      
    
11. //-----------------OLED端口定义----------------                                             
      K3 P2 u7 h/ @  d; a( h
12. #define OLED_CS         PBout(7)
    
13. #define OLED_RST  PGout(15)        
    1 J  K, F" A: ?3 G6 ~
14. #define OLED_RS         PDout(6)
      l; E. a6 d' |! H" a
15. #define OLED_WR         PAout(4)                  
    5 b) N" k3 ?/ n  I9 d  a
16. #define OLED_RD         PDout(7)
    
17. 
    
18. //使用4线串行接口时使用
    
19. #define OLED_SCLK         PCout(6)
    ' S$ k1 T" R# [9 ?; U
20. #define OLED_SDIN         PCout(7)
    
21.                      
    
22. #define OLED_CMD          0                //写命令
    
23. #define OLED_DATA         1                //写数据
    
24. //OLED控制用函数
    
25. void OLED_WR_Byte(u8 dat,u8 cmd);            
    % Z3 I- M& K# r8 R+ Y1 A" Y
26. void OLED_Display_On(void);
    
27. void OLED_Display_Off(void);
    
28. void OLED_Refresh_Gram(void);                  
    : o+ h  X4 a/ Y! j& n2 b" ~
29.                                                                               
    - ^5 I) F2 E; \, o) e
30. void OLED_Init(void);
    % W7 l- b1 R) N3 d$ Q
31. void OLED_Clear(void);
    
32. void OLED_DrawPoint(u8 x,u8 y,u8 t);
    - \/ c) u1 X$ V2 }, d( x7 B
33. void OLED_Fill(u8 x1,u8 y1,u8 x2,u8 y2,u8 dot);
    
34. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size,u8 mode);
    
35. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size);
    3 `$ D" E; ~/ E  t0 ]
36. void OLED_ShowString(u8 x,u8 y,const u8 *p,u8 size);         
    % ], c. i# U$ |0 q, q
37. #endif  
    

复制代码

3 t: c3 u6 D* Uoled.c
& g! j. D) ^6 @) `/ P) v

1. #include "oled.h"
   
2. #include "stdlib.h"
   % o. M& J* G" n1 b$ U3 s0 T; u
3. #include "oledfont.h"           
   9 {) c4 d7 u" s6 S% a+ k
4. #include "delay.h"
   ( w+ O+ g& S9 u% g8 R& A1 u
5. 
   
6. //OLED的显存
   
7. //存放格式如下.
   6 }1 z& @: T& R! i: Z# ^/ w
8. //[0]0 1 2 3 ... 127        
   
9. //[1]0 1 2 3 ... 127        
   3 q! R3 \1 K2 b2 M4 M
10. //[2]0 1 2 3 ... 127        
    
11. //[3]0 1 2 3 ... 127        
    
12. //[4]0 1 2 3 ... 127        
    + H1 x+ i. K3 d8 G0 R, M* j% {
13. //[5]0 1 2 3 ... 127        
    % p2 ?/ M/ _1 e" X. r7 }, {
14. //[6]0 1 2 3 ... 127        
    0 s9 ^0 @/ ~5 e  ~* o; }$ x
15. //[7]0 1 2 3 ... 127                    
    ' o! q- a) ^! _1 L7 t2 F3 x/ v
16. u8 OLED_GRAM[128][8];         
    
17. 
    % i* b, m+ k9 G% H8 H) |0 l
18. //更新显存到LCD                 
    
19. void OLED_Refresh_Gram(void)
    7 ~! ~' `0 U+ x" w- l% h, ]
20. {
    
21.         u8 i,n;                    
    
22.         for(i=0;i<8;i++)  
    4 ?1 t  u' @) \: N% [/ C% C
23.         {  
    
24.                 OLED_WR_Byte (0xb0+i,OLED_CMD);    //设置页地址（0~7）
    
25.                 OLED_WR_Byte (0x00,OLED_CMD);      //设置显示位置—列低地址
    5 G* G6 `2 g- V# @) @# K2 H2 ^! T
26.                 OLED_WR_Byte (0x10,OLED_CMD);      //设置显示位置—列高地址   
    
27.                 for(n=0;n<128;n++)OLED_WR_Byte(OLED_GRAM[n],OLED_DATA);
    ; M6 Z7 C& K% p  q# r8 Q
28.         }   
    & i7 {/ I1 E$ R4 w0 O  }
29. }
    
30. //8080并口
    : A2 y5 ?  q0 |4 Q6 c& K" P% E
31. //通过拼凑的方法向OLED输出一个8位数据
    
32. //data:要输出的数据
    
33. void OLED_Data_Out(u8 data)
    
34. {
      @; A! S( M( Y! B/ ], G' p
35.         u16 dat=data&0X0F;
    
36.         GPIOC->ODR&=~(0XF<<6);                //清空6~9
    / e$ }& q1 \+ p. A+ h0 }
37.         GPIOC->ODR|=dat<<6;                        //D[3:0]-->PC[9:6]
    5 \: D* j1 `: y1 p. R" M* d9 d
38.         GPIO_Write(GPIOC,dat<<6);
    
39.         PCout(11)=(data>>4)&0X01;        //D4
    
40.         PBout(6)=(data>>5)&0X01;        //D5
    
41.         PEout(5)=(data>>6)&0X01;        //D6
      I/ a0 r4 Q8 r( c! y7 w5 r
42.         PEout(6)=(data>>7)&0X01;        //D7
    
43. }
    
44. //向SSD1306写入一个字节。
    * D1 h) P; P- J
45. //dat:要写入的数据/命令
    
46. //cmd:数据/命令标志 0,表示命令;1,表示数据;
    
47. void OLED_WR_Byte(u8 dat,u8 cmd)
    
48. {
    
49.         OLED_Data_Out(dat);            
    
50.          OLED_RS=cmd;
    
51.         OLED_CS=0;           
    
52.         OLED_WR=0;         
    5 T9 [7 x8 `3 E% {$ w/ Q7 H
53.         OLED_WR=1;
    / ?) M2 y' l0 `' _
54.         OLED_CS=1;         
    ( d$ ]9 o1 M" G
55.         OLED_RS=1;         
    
56. }                        
    
57.                     
    
58. //开启OLED显示   
    
59. void OLED_Display_On(void)
    
60. {
    
61.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    
62.         OLED_WR_Byte(0X14,OLED_CMD);  //DCDC ON
    8 O4 q3 p4 U1 _! T4 g
63.         OLED_WR_Byte(0XAF,OLED_CMD);  //DISPLAY ON
    * k5 B2 D+ D7 l, h5 W  ?
64. }
    5 G6 j! v, \! D6 |; ^
65. //关闭OLED显示     
    3 T, N2 A9 y( ?  d: r: a
66. void OLED_Display_Off(void)
    ( t( N( ]6 n6 Z: a
67. {
    7 R6 N4 q/ h3 C6 d: N5 V
68.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    
69.         OLED_WR_Byte(0X10,OLED_CMD);  //DCDC OFF
    7 H( C6 C. c$ u$ a$ Y2 ^
70.         OLED_WR_Byte(0XAE,OLED_CMD);  //DISPLAY OFF
    
71. }                                            
    ' Y% O4 ^! d8 `& Z
72. //清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!         
    
73. void OLED_Clear(void)  
    
74. {  
    7 v1 l& [0 s) ]7 a  n
75.         u8 i,n;  
    
76. for(i=0;i<8;i++)for(n=0;n<128;n++)OLED_GRAM[n]=0X00;  
    9 [  ^% U7 V) l0 f
77.         OLED_Refresh_Gram();//更新显示
    
78. }
    : G. a" k- C9 V' A
79. //画点
    
80. //x:0~127
    0 [( A5 F. v2 e9 M1 a/ M3 e
81. //y:0~63
    
82. //t:1 填充 0,清空                                   
    
83. void OLED_DrawPoint(u8 x,u8 y,u8 t)
    ; m6 w/ x* V8 d/ M+ L
84. {
    3 k4 h3 t$ P4 p! t" s# k0 j
85.         u8 pos,bx,temp=0;
    
86.         if(x>127||y>63)return;//超出范围了.
    
87.         pos=7-y/8;
    $ m: t5 P' S1 Y2 }1 G/ I1 P& o
88.         bx=y%8;
    
89.         temp=1<<(7-bx);
    $ G* j! H0 Y. m4 \0 X
90.         if(t)OLED_GRAM[x][pos]|=temp;
    4 Z1 Q& z/ }) P' E
91.         else OLED_GRAM[x][pos]&=~temp;            
    
92. }
    
93. //x1,y1,x2,y2 填充区域的对角坐标
    ! ]5 t, `/ O- w$ {8 Y# k* ?
94. //确保x1<=x2;y1<=y2 0<=x1<=127 0<=y1<=63                  
    
95. //dot:0,清空;1,填充         
    
96. void OLED_Fill(u8 x1,u8 y1,u8 x2,u8 y2,u8 dot)  
    7 U4 A/ a5 {9 a0 g
97. {  
    5 r/ H; j' x/ }
98.         u8 x,y;  
    
99.         for(x=x1;x<=x2;x++)
    
100.         {
     
101.                 for(y=y1;y<=y2;y++)OLED_DrawPoint(x,y,dot);
     + r" m- w$ _+ `& n  B2 O
102.         }                                                                                                            
     
103.         OLED_Refresh_Gram();//更新显示
     ( I- j/ `4 Z0 x
104. }
     % |* H: C4 R  E6 u' B3 J' s' R
105. //在指定位置显示一个字符,包括部分字符
     4 E+ P4 n/ {. B: ~
106. //x:0~127
     
107. //y:0~63
     8 `9 g( I( t7 X) K! I7 m
108. //mode:0,反白显示;1,正常显示                                 
     / B" U* v6 ~5 o/ `7 Z
109. //size:选择字体 12/16/24
     
110. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size,u8 mode)
     , H7 D' G: v  V/ V
111. {                                 
     ) ?4 m( n& J( f; E, D% c, X! F
112.         u8 temp,t,t1;
     
113.         u8 y0=y;
     
114.         u8 csize=(size/8+((size%8)?1:0))*(size/2);                //得到字体一个字符对应点阵集所占的字节数
     * L: ]% z4 }# F$ V
115.         chr=chr-' ';//得到偏移后的值                 
     
116.     for(t=0;t<csize;t++)
     . n. z! X. \( Q7 G2 v4 ]8 y
117.     {   
     - l  k& `! _) A) T' f
118.                 if(size==12)temp=asc2_1206[chr][t];                  //调用1206字体
     
119.                 else if(size==16)temp=asc2_1608[chr][t];        //调用1608字体
     " [- s: Z; j( n7 g+ G$ O6 H* x
120.                 else if(size==24)temp=asc2_2412[chr][t];        //调用2412字体
     
121.                 else return;                                                                //没有的字库
     3 q( `4 @0 v: C4 o/ I
122.         for(t1=0;t1<8;t1++)
     
123.                 {
     4 C: A+ z4 i/ Y% W# g
124.                         if(temp&0x80)OLED_DrawPoint(x,y,mode);
     
125.                         else OLED_DrawPoint(x,y,!mode);
     
126.                         temp<<=1;
     ! e5 j+ y$ p) @5 W9 F  G
127.                         y++;
     
128.                         if((y-y0)==size)
     9 j! t  v% j  ~6 U
129.                         {
     
130.                                 y=y0;
     
131.                                 x++;
     
132.                                 break;
     
133.                         }
     
134.                 }           
     " @% v2 y  K* e8 S/ J( C: e! w& F+ A5 n
135.     }         
     
136. }
     
137. //m^n函数
     ' v  L2 U) }2 \1 j% X- ^# @1 q! Q
138. u32 mypow(u8 m,u8 n)
     
139. {
     
140.         u32 result=1;         
     0 B5 v1 b( G- S0 \' K8 x6 }+ y6 g
141.         while(n--)result*=m;   
     
142.         return result;
     # [: @  r  U6 J
143. }                                 
     
144. //显示2个数字
     $ B# }7 V* j( f1 a/ K5 I. u% I
145. //x,y :起点坐标         
     
146. //len :数字的位数
     : f& j/ s- J2 V; b( V0 ]
147. //size:字体大小
     
148. //mode:模式        0,填充模式;1,叠加模式
     
149. //num:数值(0~4294967295);                           
     
150. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size)
     6 j0 G+ |' Z, f  Q1 r
151. {                 
     
152.         u8 t,temp;
     : @2 g& l$ h9 Z6 H! f, q; u
153.         u8 enshow=0;                                                   
     - ^6 u( N  i8 `1 @
154.         for(t=0;t<len;t++)
     
155.         {
     
156.                 temp=(num/mypow(10,len-t-1))%10;
     ; j. G4 i3 U% }3 e: H, ]
157.                 if(enshow==0&&t<(len-1))
     
158.                 {
     , S$ y5 ~' I2 s* L  c- y
159.                         if(temp==0)
     
160.                         {
     
161.                                 OLED_ShowChar(x+(size/2)*t,y,' ',size,1);
     
162.                                 continue;
     
163.                         }else enshow=1;
     
164.                           
     
165.                 }
     
166.                  OLED_ShowChar(x+(size/2)*t,y,temp+'0',size,1);
     
167.         }
     
168. }
     
169. //显示字符串
     7 N/ `" a) n& h1 }4 }6 b. M
170. //x,y:起点坐标  
     
171. //size:字体大小
     
172. //*p:字符串起始地址
     ) g! \% r. x4 l
173. void OLED_ShowString(u8 x,u8 y,const u8 *p,u8 size)
     : M2 @4 x- Z7 ?. Q3 Z6 f  a
174. {        
     6 ]6 t5 |4 t3 W( z1 E
175.     while((*p<='~')&&(*p>=' '))//判断是不是非法字符!
     
176.     {      
     
177.         if(x>(128-(size/2))){x=0;y+=size;}
     & G; L8 Q$ G$ j3 H
178.         if(y>(64-size)){y=x=0;OLED_Clear();}
     
179.         OLED_ShowChar(x,y,*p,size,1);         
     8 }- x) {' Y. k) K6 A9 C+ f
180.         x+=size/2;
     
181.         p++;
     ) T, @! V8 d5 s: {3 a$ m
182.     }  
     & T2 P) u& U0 z
183.         
     
184. }        
     3 u. ^5 e  D2 }/ \& l6 z# S
185. //初始化SSD1306                                            
     ; \( Q4 R+ _  H2 ~1 `
186. void OLED_Init(void)
     - C* h# S' N9 B5 c
187. {                           
     / w$ z% a+ B8 E" |
188.   GPIO_InitTypeDef  GPIO_InitStructure;
     1 @- U* U; D& b- z) b/ Z& y8 ?& F$ M
189.         
     
190.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA|RCC_AHB1Periph_GPIOB|RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOD|RCC_AHB1Periph_GPIOE|RCC_AHB1Periph_GPIOG, ENABLE);//使能PORTA~E,PORTG时钟
     4 |; g1 X8 ^* d* g  X: ^: i
191. 
     9 x: B3 ^4 X; k& P6 D+ ?8 G
192. //使用8080并口模式               
     ( d! C% P0 s  J0 L. p
193.         
     
194.         //GPIO初始化设置
     
195.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 ;
     ! [' h0 z1 b/ ^6 ^
196.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
     - ^3 k: n  ?2 F5 M4 v
197.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
     
198.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
     
199.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
     / @% D$ M# d$ g+ ^) a
200.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化
     6 g: T3 g" [9 Q+ D9 e; E- g# A+ o
201.         
     0 l4 J3 G0 u+ C% S4 ^% n% a/ H
202.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7 ;        
     + l* x5 \, K+ j, ?& P0 ~1 f' G
203.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
     
204. 
     ( d. }1 j% z9 Z- ~' e% Q3 H
205.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_11;        
     
206.         GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化        
     
207. 
     : G% z) S6 n* a  H  B) ~3 S  F# D
208.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;        
     
209.         GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化        
     
210.         
     9 Q2 ]: L2 ], ^( ^- y
211.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_5;        
     : b/ R5 x5 q5 ?4 @, n2 U7 _# s
212.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化        
     
213.         
     9 i6 @1 ?  K0 ]: I6 t
214.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;        
     % M& B$ O9 L# |; ~
215.         GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化        
     
216. 
     
217.         
     
218.          OLED_WR=1;
     
219.         OLED_RD=1;
       F1 H8 H$ g  f# p
220. 
     ; A. L4 V4 h; \0 U. c6 V* ^0 D* H
221.         OLED_CS=1;
     
222.         OLED_RS=1;         
     - Z  i$ E) q$ _1 a+ W- _3 K
223.         
     , M" D: A! |8 H  F4 ^) U5 O+ h
224.         OLED_RST=0;
     
225.         delay_ms(100);
     + {$ z' p8 Q  d: J5 S7 U. W
226.         OLED_RST=1;
     4 @% Z' w4 ?. D3 ]
227.                                           
     
228.         OLED_WR_Byte(0xAE,OLED_CMD); //关闭显示
     4 N! }1 I5 {$ U& O6 y5 Q
229.         OLED_WR_Byte(0xD5,OLED_CMD); //设置时钟分频因子,震荡频率
     
230.         OLED_WR_Byte(80,OLED_CMD);   //[3:0],分频因子;[7:4],震荡频率
     
231.         OLED_WR_Byte(0xA8,OLED_CMD); //设置驱动路数
     
232.         OLED_WR_Byte(0X3F,OLED_CMD); //默认0X3F(1/64)
     
233.         OLED_WR_Byte(0xD3,OLED_CMD); //设置显示偏移
     8 w7 j8 y8 U- c% j4 s; t
234.         OLED_WR_Byte(0X00,OLED_CMD); //默认为0
     
235. 
     
236.         OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.
     ' V- S% _( c: N/ S" l& J
237.                                                                                                             
     . c# L0 |! B& W$ B+ }
238.         OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置
     
239.         OLED_WR_Byte(0x14,OLED_CMD); //bit2，开启/关闭
     
240.         OLED_WR_Byte(0x20,OLED_CMD); //设置内存地址模式
     & C8 [$ X: g6 F+ W; j& j
241.         OLED_WR_Byte(0x02,OLED_CMD); //[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
     
242.         OLED_WR_Byte(0xA1,OLED_CMD); //段重定义设置,bit0:0,0->0;1,0->127;
     - s- x, K  V& E( C
243.         OLED_WR_Byte(0xC0,OLED_CMD); //设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
     3 Y; [5 b5 e, w6 t! X8 K
244.         OLED_WR_Byte(0xDA,OLED_CMD); //设置COM硬件引脚配置
     
245.         OLED_WR_Byte(0x12,OLED_CMD); //[5:4]配置
     
246.                  
     
247.         OLED_WR_Byte(0x81,OLED_CMD); //对比度设置
     ; K5 Q0 L. z3 E8 r' [; O
248.         OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
     ' U0 w$ z  Z% t0 u) Z3 T: A
249.         OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期
     5 h9 N9 h1 K3 `; s; S1 j
250.         OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
     9 m7 x) j- z' _5 f5 E+ w
251.         OLED_WR_Byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率
       k2 v+ V% u& a
252.         OLED_WR_Byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
     
253. 
     6 J( ]& r. a/ _' }' J: m- z, v
254.         OLED_WR_Byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
     : ]0 }- |5 Y* y) P3 O, f3 x
255.         OLED_WR_Byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示                                                               
     
256.         OLED_WR_Byte(0xAF,OLED_CMD); //开启显示         
     0 T; [+ h+ z8 c2 M
257.         OLED_Clear();
     0 C$ C1 W  f, C
258. }  

复制代码

main.c

1. #include "sys.h"
   $ Z0 b8 J# M) g' P
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "oled.h"
   : f- z6 R  x# W, q2 ^$ p+ H
6. 
   * y: C# ]' [/ i# V  R9 ]3 D
7. 
   
8. int main(void)
   ' e& e, S* |; {& J9 k' m
9. {
   . l: P$ w8 Q9 g
10.         u8 t=0;
    - z5 W$ ]1 U1 g6 z$ V% Q
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    
12.         delay_init(168);     //初始化延时函数
    % `# t1 m0 Z& u; c, f! x
13.         uart_init(115200);        //初始化串口波特率为115200
    
14.         LED_Init();                                        //初始化LED
    8 k+ f8 r  G5 v% r! o, {
15.          OLED_Init();                                //初始化OLED
    ; z& M0 S7 n+ a
16.   OLED_ShowString(0,0,"ALIENTEK",24);  
    " e$ V' U" C* B- D4 r
17.         OLED_ShowString(0,24, "0.96' OLED TEST",16);  
    
18.          OLED_ShowString(0,40,"ATOM 2014/5/4",12);  
    1 ^8 R( m* N; t% }8 r: d5 S0 z
19.          OLED_ShowString(0,52,"ASCII:",12);  
    3 P) @' h( P+ R7 m4 _9 K8 K; i
20.          OLED_ShowString(64,52,"CODE:",12);  
    8 c7 f8 O5 Y/ [( j$ C8 E
21.         OLED_Refresh_Gram();//更新显示到OLED         
    
22.         t=' ';  
    
23.         while(1)
    7 [' k7 d% k& I% W; p* @. P
24.         {               
    
25.                 OLED_ShowChar(36,52,t,12,1);//显示ASCII字符        
    ( k3 e/ p# k/ }& U5 J9 n. i1 v4 I, \
26.                 OLED_ShowNum(94,52,t,3,12);        //显示ASCII字符的码值   
    
27.                 OLED_Refresh_Gram();        //更新显示到OLED
    
28.                 t++;
    
29.                 if(t>'~')t=' ';  
    
30.                 delay_ms(500);
    
31.                 LED0=!LED0;
    
32.         }
    
33. }
    - X5 e: x# e9 W$ I3 Q8 Y) [
34. 
    # o. y1 t) S$ }4 _- O) v- _

复制代码

' s9 u/ N- E: B* I2 J3 K! v" X: g
2 D! \, o- t5 d) r# ^' e0 M