01. OLED概述
1 c. L9 T; j, u* A" H% K" uOLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（OrganicElectroluminesence Display， OELD）。OLED 由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。

LCD 都需要背光，而 OLED 不需要，因为它是自发光的。这样同样的显示，OLED 效果要来得好一些。以目前的技术，OLED 的尺寸还难以大型化，但是分辨率确可以做到很高。
$ T% D0 r2 E: u( [  i9 n
% @$ L( a& o( `( h+ w- J2 Z02. OLED初始化



驱动 IC 的初始化代码，我们直接使用厂家推荐的设置就可以了，只要对细节部分进行一些修改，使其满足我们自己的要求即可，其他不需要变动。
% Y% v3 R: N: U  o# z8 {' i
$ |. K* }8 r: L6 G! F5 r& iOLED 显示需要的相关设置步骤如下：

- D' y$ f% j; l" z% k4 c1 ）设置 STM32F4 与 与 OLED 模块相连接的 IO 。
这一步，先将我们与 OLED 模块相连的 IO 口设置为输出，具体使用哪些 IO 口，这里需要根据连接电路以及 OLED 模块所设置的通讯模式来确定。
1 W( h* x+ x" G% n: w
2 ）初始化 OLED 模块。
9 S; z1 R2 |5 m  s其实这里就是上面的初始化框图的内容，通过对 OLED 相关寄存器的初始化，来启动 OLED的显示。
; o/ x/ x8 @$ B
9 w3 B; O8 c0 M+ c' N7 @5 e3 ）通过函数将字符和数字显示到 OLED 模块上。
+ Y7 T: Z0 y# Y, Y" \5 N! q这里就是通过我们设计的程序，将要显示的字符送到 OLED 模块就可以了

3 m# ~/ a/ R  b! o通过以上三步，我们就可以使用 ALIENTEK OLED 模块来显示字符和数字了。

03. 硬件设计
用到的硬件资源有：
1） 指示灯 DS0
# e$ f9 L5 a/ x  [2） OLED 模块

* }% M- ~' Y( H- S: T) N! J6 Y硬件上，OLED 与探索者 STM32F4 开发板的 IO 口对应关系如下：
- ?' k' i) E5 y7 h% p; UOLED_CS 对应 DCMI_VSYNC，即：PB7;
OLED_RS 对应 DCMI_SCL，即：PD6;
OLED_WR 对应 DCMI_HREF，即：PA4;
( `% {9 r$ y0 z% O! ?/ NOLED_RD 对应 DCMI_SDA，即：PD7;
OLED_RST 对应 DCMI_RESET，即：PG15;
3 N' V/ S5 V$ T; h. M4 ZOLED_D[7:0]对应 DCMI_D[7:0]，即：PE6/PE5/PB6/PC11/PC9/PC8/PC7/PC6;

04. 程序示例
4 w" f9 s# w8 J$ i( Noled.h

% e* O: Q8 J! y

1. #ifndef __OLED_H
   - U  d7 @6 x' E' ?
2. #define __OLED_H                                   
   
3. #include "sys.h"
   ' q3 `4 ]) |: {. |8 H
4. #include "stdlib.h"            
   , @- ]" u, Q  `) A/ m1 n2 B
5. 
   
6. //OLED模式设置
   
7. //0: 4线串行模式  （模块的BS1，BS2均接GND）
   , ~, P: ?7 L( @& ?  V. I! R/ z
8. //1: 并行8080模式 （模块的BS1，BS2均接VCC）
   ' K  S+ F1 }7 f
9. #define OLED_MODE         1
   
10.                                                                      
    8 F4 @0 s1 ?4 ?) @
11. //-----------------OLED端口定义----------------                                             
    5 I5 h. D- ?9 Y) R4 @
12. #define OLED_CS         PBout(7)
    
13. #define OLED_RST  PGout(15)        
    
14. #define OLED_RS         PDout(6)
    2 {5 Q8 C# j8 d- v! V; H
15. #define OLED_WR         PAout(4)                  
    
16. #define OLED_RD         PDout(7)
    
17. 
    
18. //使用4线串行接口时使用
    
19. #define OLED_SCLK         PCout(6)
    
20. #define OLED_SDIN         PCout(7)
    
21.                      
    ( i3 i4 r0 I+ l
22. #define OLED_CMD          0                //写命令
    
23. #define OLED_DATA         1                //写数据
    5 B1 i8 O% {# L9 i/ L" c
24. //OLED控制用函数
    
25. void OLED_WR_Byte(u8 dat,u8 cmd);            
    
26. void OLED_Display_On(void);
    
27. void OLED_Display_Off(void);
    2 I( Y5 Z  u- O8 G5 T- ]( a
28. void OLED_Refresh_Gram(void);                  
    7 x$ |. W' s$ u8 h5 _
29.                                                                               
    
30. void OLED_Init(void);
    
31. void OLED_Clear(void);
    
32. void OLED_DrawPoint(u8 x,u8 y,u8 t);
    ) C- H/ m! T! f. L6 Z, 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);
    
36. void OLED_ShowString(u8 x,u8 y,const u8 *p,u8 size);         
    
37. #endif  

复制代码

oled.c
/ c1 z" U: n3 _3 x& @! m) F

1. #include "oled.h"
   
2. #include "stdlib.h"
   
3. #include "oledfont.h"           
   
4. #include "delay.h"
   / z. x! Z' j2 Q1 R$ k
5. 
   ; \/ Z) n; u5 ^( B) a3 }/ \
6. //OLED的显存
   / Z+ t1 S  |/ b5 ]; h3 o, }
7. //存放格式如下.
   ' m! x) i& ~# F! l  Z% c
8. //[0]0 1 2 3 ... 127        
   
9. //[1]0 1 2 3 ... 127        
   
10. //[2]0 1 2 3 ... 127        
    
11. //[3]0 1 2 3 ... 127        
    + |0 {0 ~' P' ~' ^( @5 ?( R, ~
12. //[4]0 1 2 3 ... 127        
    
13. //[5]0 1 2 3 ... 127        
      x3 l  X5 L& b- m6 ?; x% w/ ]4 c
14. //[6]0 1 2 3 ... 127        
    
15. //[7]0 1 2 3 ... 127                    
    
16. u8 OLED_GRAM[128][8];         
    
17. 
    
18. //更新显存到LCD                 
    
19. void OLED_Refresh_Gram(void)
    
20. {
    
21.         u8 i,n;                    
    
22.         for(i=0;i<8;i++)  
    
23.         {  
    $ [; ?7 h6 a* w! s$ r
24.                 OLED_WR_Byte (0xb0+i,OLED_CMD);    //设置页地址（0~7）
    9 _( Z" C" E% K# U$ k2 J( L) w
25.                 OLED_WR_Byte (0x00,OLED_CMD);      //设置显示位置—列低地址
    . F7 N. A2 u- A- t
26.                 OLED_WR_Byte (0x10,OLED_CMD);      //设置显示位置—列高地址   
    ! s& F% y7 ]+ B0 |# U
27.                 for(n=0;n<128;n++)OLED_WR_Byte(OLED_GRAM[n]<i>,OLED_DATA);
    
28.         }   
    6 e- X: g1 W9 q; A
29. }
    
30. //8080并口
    
31. //通过拼凑的方法向OLED输出一个8位数据
    & `0 Y" A- Y5 X7 a- p3 Q1 d
32. //data:要输出的数据
    2 y" C$ @# k8 J4 V, k* _
33. void OLED_Data_Out(u8 data)
    / |# o+ M+ f+ E7 z& Y3 ?
34. {
    
35.         u16 dat=data&0X0F;
    
36.         GPIOC->ODR&=~(0XF<<6);                //清空6~9
    9 F: `- ?, i8 I) g
37.         GPIOC->ODR|=dat<<6;                        //D[3:0]-->PC[9:6]
    
38.         GPIO_Write(GPIOC,dat<<6);
    ( R) V: _! \: P% U
39.         PCout(11)=(data>>4)&0X01;        //D4
      A- b) T( v5 r3 B. n6 ~
40.         PBout(6)=(data>>5)&0X01;        //D5
    $ }2 o8 n0 ]8 A
41.         PEout(5)=(data>>6)&0X01;        //D6
    4 ^4 u- u5 G* R
42.         PEout(6)=(data>>7)&0X01;        //D7
    
43. }
    , i# m$ l' ~3 p8 C
44. //向SSD1306写入一个字节。
    
45. //dat:要写入的数据/命令
    / K* h- P, l: E" n- D
46. //cmd:数据/命令标志 0,表示命令;1,表示数据;
    + ~) H9 f6 |2 b% @; [
47. void OLED_WR_Byte(u8 dat,u8 cmd)
    . O2 ?/ n3 }# X; G, `5 d8 m
48. {
    
49.         OLED_Data_Out(dat);            
    # u8 o# @3 L, u0 c' A6 ~4 S" b' D. B
50.          OLED_RS=cmd;
    # @9 V& J; s1 S! \- H; K" K, B
51.         OLED_CS=0;           
    & K; H- O  _. X
52.         OLED_WR=0;         
    
53.         OLED_WR=1;
    ) m# A; l# _7 ^; e* H
54.         OLED_CS=1;         
    5 N% d1 w1 e  I, ?  T; Z
55.         OLED_RS=1;         
    4 D+ U3 Y5 H7 x# M7 N
56. }                        
    $ O  P0 {3 s2 ?3 p. T: D) t* l
57.                     
    
58. //开启OLED显示   
    6 w1 c3 B9 B. B( |& X4 U7 `
59. void OLED_Display_On(void)
    " W, {# e3 H& ^- }& K" f
60. {
    
61.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    6 i% Z1 Y/ G6 r9 n
62.         OLED_WR_Byte(0X14,OLED_CMD);  //DCDC ON
    0 j5 ]" d; L# \
63.         OLED_WR_Byte(0XAF,OLED_CMD);  //DISPLAY ON
    2 L/ ^' X! S2 j  H" h) }7 F. r
64. }
    - z. W, N: H" n) w, s: A/ b# w
65. //关闭OLED显示     
    3 D7 F- |- I9 `$ s# W
66. void OLED_Display_Off(void)
    . p1 R* ^: I# w% a& _
67. {
    ( Y! g( C3 U8 M( w
68.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    % `6 Y! |  {! T, G- N6 }3 w
69.         OLED_WR_Byte(0X10,OLED_CMD);  //DCDC OFF
    
70.         OLED_WR_Byte(0XAE,OLED_CMD);  //DISPLAY OFF
    
71. }                                            
    
72. //清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!         
    ; k, a/ J5 t& ?) w' J  D: a4 S
73. void OLED_Clear(void)  
    
74. {  
    6 a) W( A2 e2 S4 c3 u3 p
75.         u8 i,n;  
    ' L* y' h2 y( ?7 B1 H6 Z9 w6 c
76.         for(i=0;i<8;i++)for(n=0;n<128;n++)OLED_GRAM[n]<i>=0X00;  
    
77.         OLED_Refresh_Gram();//更新显示
    
78. }
    
79. //画点
    # [1 G# [! a6 j4 j1 c" n
80. //x:0~127
    , K9 E6 ?+ R3 R& w
81. //y:0~63
    
82. //t:1 填充 0,清空                                   
    
83. void OLED_DrawPoint(u8 x,u8 y,u8 t)
    
84. {
    
85.         u8 pos,bx,temp=0;
    - e5 ]7 p4 q: M* Z/ a, `
86.         if(x>127||y>63)return;//超出范围了.
    % |1 e0 v- X2 p* ]& g, X6 [
87.         pos=7-y/8;
      M! `# O. k1 G2 P$ e
88.         bx=y%8;
    
89.         temp=1<<(7-bx);
    
90.         if(t)OLED_GRAM[x][pos]|=temp;
    
91.         else OLED_GRAM[x][pos]&=~temp;            
    
92. }
    " N  z! Y+ X5 [4 p" r8 Z$ o6 A* h4 ~- W
93. //x1,y1,x2,y2 填充区域的对角坐标
    
94. //确保x1<=x2;y1<=y2 0<=x1<=127 0<=y1<=63                  
    7 n6 n- A7 A9 M# N3 E9 I
95. //dot:0,清空;1,填充         
    0 Q. U$ i1 }: K4 j7 }5 S& D
96. void OLED_Fill(u8 x1,u8 y1,u8 x2,u8 y2,u8 dot)  
    
97. {  
    ; U5 h, ]: S$ B5 |1 U
98.         u8 x,y;  
    5 {, G" L, z1 b; ]$ h3 K( A
99.         for(x=x1;x<=x2;x++)
    # M* m1 Q7 E$ n  p
100.         {
     ) C1 A) E+ x- L5 i  G* A% |
101.                 for(y=y1;y<=y2;y++)OLED_DrawPoint(x,y,dot);
     
102.         }                                                                                                            
     : F2 Z$ N% I8 s* W# q" d0 V9 X
103.         OLED_Refresh_Gram();//更新显示
     
104. }
     
105. //在指定位置显示一个字符,包括部分字符
     
106. //x:0~127
     " y. q* }7 g9 V1 Y1 U2 A
107. //y:0~63
     ' h' R0 Q. \" q& u" D, L
108. //mode:0,反白显示;1,正常显示                                 
     
109. //size:选择字体 12/16/24
     - i8 A$ v* b& ^8 a
110. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size,u8 mode)
     8 W( I* t6 x9 a6 O3 z
111. {                                 
     ) V! |4 T" H$ f  W9 M
112.         u8 temp,t,t1;
     % e% ?2 v; n) k% b4 C4 C+ }
113.         u8 y0=y;
     & Z4 G2 B0 Y, r8 b' q
114.         u8 csize=(size/8+((size%8)?1:0))*(size/2);                //得到字体一个字符对应点阵集所占的字节数
     
115.         chr=chr-' ';//得到偏移后的值                 
     
116.     for(t=0;t<csize;t++)
     2 w" \' f7 ~) P4 h
117.     {   
     
118.                 if(size==12)temp=asc2_1206[chr][t];                  //调用1206字体
     9 a0 H  P) t, L; r9 a' T0 b9 ?
119.                 else if(size==16)temp=asc2_1608[chr][t];        //调用1608字体
     : Y) w7 Q' s9 x4 [' V( q
120.                 else if(size==24)temp=asc2_2412[chr][t];        //调用2412字体
     - v6 q+ m% c  n6 o3 o' n
121.                 else return;                                                                //没有的字库
     4 i. X* ^) n( w
122.         for(t1=0;t1<8;t1++)
     
123.                 {
     
124.                         if(temp&0x80)OLED_DrawPoint(x,y,mode);
     
125.                         else OLED_DrawPoint(x,y,!mode);
     
126.                         temp<<=1;
     2 k7 E/ J0 e* f' C! q" F( [
127.                         y++;
     
128.                         if((y-y0)==size)
     
129.                         {
     / }) x, i/ k7 L) d4 l# p
130.                                 y=y0;
     
131.                                 x++;
     & U5 k0 G; u8 U. }1 `
132.                                 break;
     
133.                         }
     
134.                 }           
     
135.     }         
     2 H2 E1 Y' H9 X5 {
136. }
     
137. //m^n函数
     
138. u32 mypow(u8 m,u8 n)
     
139. {
     ) r0 ?' i; D( q& P
140.         u32 result=1;         
     
141.         while(n--)result*=m;   
     ( [& R4 {/ w% j5 z4 K! \
142.         return result;
     
143. }                                 
     , i: r+ M0 S" t- g% `
144. //显示2个数字
     
145. //x,y :起点坐标         
     ( N% b! U( _0 E0 i
146. //len :数字的位数
     9 ~$ t& \/ m- p4 c) h
147. //size:字体大小
     
148. //mode:模式        0,填充模式;1,叠加模式
     
149. //num:数值(0~4294967295);                           
     5 B3 d4 R3 Y8 d* L
150. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size)
     
151. {                 
     4 s0 a5 n& X* I. }! X! ]
152.         u8 t,temp;
     
153.         u8 enshow=0;                                                   
     # q0 F# U+ l9 I4 k5 N, u
154.         for(t=0;t<len;t++)
     3 I6 X! W# k  c& ?( m2 P
155.         {
     $ f- b1 t) v* ~9 F3 W( Z
156.                 temp=(num/mypow(10,len-t-1))%10;
     
157.                 if(enshow==0&&t<(len-1))
     
158.                 {
     
159.                         if(temp==0)
     ( U4 ~- n: Z9 h2 O: c) C  m
160.                         {
     
161.                                 OLED_ShowChar(x+(size/2)*t,y,' ',size,1);
     0 Z2 l; ?8 H9 u; n; X# }
162.                                 continue;
     
163.                         }else enshow=1;
     
164.                           
     
165.                 }
     
166.                  OLED_ShowChar(x+(size/2)*t,y,temp+'0',size,1);
     
167.         }
     
168. }
     5 f& y3 ~- `2 c, J& G, Q/ p
169. //显示字符串
     
170. //x,y:起点坐标  
     
171. //size:字体大小
     
172. //*p:字符串起始地址
     & E3 P: `! @7 s, k1 J# @- z& P
173. void OLED_ShowString(u8 x,u8 y,const u8 *p,u8 size)
     
174. {        
     
175.     while((*p<='~')&&(*p>=' '))//判断是不是非法字符!
     
176.     {      
     % _' `0 ]* _% [7 S( |
177.         if(x>(128-(size/2))){x=0;y+=size;}
     " z2 n" B: o  b6 W' e
178.         if(y>(64-size)){y=x=0;OLED_Clear();}
     
179.         OLED_ShowChar(x,y,*p,size,1);         
     2 ^  ]! L% K$ q: y
180.         x+=size/2;
     ( j( ]+ |/ `7 W  t
181.         p++;
     
182.     }  
     
183.         
     
184. }        
     
185. //初始化SSD1306                                            
     
186. void OLED_Init(void)
     
187. {                           
     + i# @( T" b7 D9 r' p- e; l% Q- j
188.   GPIO_InitTypeDef  GPIO_InitStructure;
     " D% [4 i$ n( q4 {8 E* N
189.         
     & Y' f7 a3 F2 i! ^  u) l1 M4 o
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时钟
     " ^) y8 N1 B% K) |  P* S
191. 
       [, V% y8 ^( P9 b
192. //使用8080并口模式               
       U9 i* X5 t& J- g% S  |
193.         
     
194.         //GPIO初始化设置
     
195.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 ;
     7 b0 D( T; K2 P2 |! F9 Y/ D
196.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
     $ r, e3 z! D: s2 K7 Q
197.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
     
198.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
     $ R) B  n0 q8 _3 a( S
199.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
     : g9 `4 v+ w* f" k  w
200.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化
     
201.         
     
202.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7 ;        
     
203.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
     * |, C, [* e0 @/ q- F- C& E
204. 
     
205.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_11;        
     3 S/ |" G0 p: J; J  a1 T4 n) @
206.         GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化        
     
207. 
     + }! r9 x. N) k7 k. k+ H! v( L
208.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;        
     1 U2 F+ v9 @; t. u
209.         GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化        
     1 r  m  P/ S9 S7 q7 z' Z8 }0 t  u1 e: z
210.         
     
211.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_5;        
     - ~+ L; h+ m/ r$ j1 U( ]7 `
212.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化        
     
213.         
     
214.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;        
     , X+ J3 h* C$ d- s. Z* n! [6 {
215.         GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化        
     8 O- J- Z: W1 v: R# f
216. 
     % C0 g! P; f2 R/ b
217.         
     - [% c: I( |3 t! I* ]: u% n
218.          OLED_WR=1;
     ) y9 ~* i; Z4 I3 @
219.         OLED_RD=1;
     ) `/ y' V9 B4 T: X, m
220. 
     % `. ?  g8 S% j$ w4 s
221.         OLED_CS=1;
     2 Z; ~# e9 @" q' A$ G1 P/ o
222.         OLED_RS=1;         
     
223.         
     3 Q' M5 T# j; e) B, T4 [/ r
224.         OLED_RST=0;
     
225.         delay_ms(100);
     
226.         OLED_RST=1;
     - n; k& ?0 l8 ^% J, r* Y6 k
227.                                           
     7 h0 r! h! h% X
228.         OLED_WR_Byte(0xAE,OLED_CMD); //关闭显示
     
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); //设置显示偏移
     
234.         OLED_WR_Byte(0X00,OLED_CMD); //默认为0
     
235. 
     1 w# P8 d& ~; R' |
236.         OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.
     
237.                                                                                                             
     % g  v. @+ F! }5 Z1 X" K7 x
238.         OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置
     ' o. l. g$ y1 x% C' v" U
239.         OLED_WR_Byte(0x14,OLED_CMD); //bit2，开启/关闭
     # A; F; ?/ i5 v# w1 U3 T4 s
240.         OLED_WR_Byte(0x20,OLED_CMD); //设置内存地址模式
     6 y+ V9 a5 }2 Y/ Y( H' [
241.         OLED_WR_Byte(0x02,OLED_CMD); //[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
     ; o  _4 @% C" Y/ o# s8 u
242.         OLED_WR_Byte(0xA1,OLED_CMD); //段重定义设置,bit0:0,0->0;1,0->127;
     $ [8 E$ H& L  J1 V7 g. b
243.         OLED_WR_Byte(0xC0,OLED_CMD); //设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
     
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); //对比度设置
     + f5 [& Q. x/ D* g
248.         OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
     
249.         OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期
     # _. v1 A1 x$ {$ {7 i! ^( M4 X  I
250.         OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
     
251.         OLED_WR_Byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率
     4 {8 \+ D2 X  S* u1 g6 \  I3 ?8 [
252.         OLED_WR_Byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
     6 A5 v- r  _+ [; D
253. 
     
254.         OLED_WR_Byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
     
255.         OLED_WR_Byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示                                                               
     ( N' R) Z" r: a: G
256.         OLED_WR_Byte(0xAF,OLED_CMD); //开启显示         
     
257.         OLED_Clear();
     
258. }  </i></i>

复制代码

4 S6 L- Q9 ?+ R3 k' fmain.c
% e3 e( O4 S2 E7 m; C3 w

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "oled.h"
   ! M) \( c- R$ Y" b' i7 s$ R+ X
6. 
   + d! Q( h; L1 b
7. 
   / ^! K3 [  @" U
8. int main(void)
   
9. {
   6 _6 U6 [' [6 S5 T
10.         u8 t=0;
    & X3 r" f( h$ m/ S. c
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    ; l  M$ i# Q; z* A, Z
12.         delay_init(168);     //初始化延时函数
    
13.         uart_init(115200);        //初始化串口波特率为115200
    / D! w  n3 M& U4 t* O; ^, K" u1 K
14.         LED_Init();                                        //初始化LED
    : s% j% W' ?7 W$ `- A; E0 X4 c$ W* \
15.          OLED_Init();                                //初始化OLED
    
16.   OLED_ShowString(0,0,"ALIENTEK",24);  
    . Q- ?! d8 b0 W# Q' D
17.         OLED_ShowString(0,24, "0.96' OLED TEST",16);  
    
18.          OLED_ShowString(0,40,"ATOM 2014/5/4",12);  
    $ `3 `1 E6 h3 c- ?* O
19.          OLED_ShowString(0,52,"ASCII:",12);  
    
20.          OLED_ShowString(64,52,"CODE:",12);  
    ( W" \( s5 j/ a5 z# U; _
21.         OLED_Refresh_Gram();//更新显示到OLED         
    + Y9 p% L0 }& K0 `' h; c- h5 ^: g
22.         t=' ';  
    
23.         while(1)
    
24.         {               
    
25.                 OLED_ShowChar(36,52,t,12,1);//显示ASCII字符        
    % V3 V& `; V7 @1 S6 p$ r0 E
26.                 OLED_ShowNum(94,52,t,3,12);        //显示ASCII字符的码值   
    
27.                 OLED_Refresh_Gram();        //更新显示到OLED
    
28.                 t++;
    + k  G  v& t: K" M/ a) I, p; o
29.                 if(t>'~')t=' ';  
    
30.                 delay_ms(500);
    
31.                 LED0=!LED0;
    $ D0 H  Z. G, ?/ Z3 p
32.         }
    6 x7 T( u$ A6 {. v
33. }
    
34. 
    

复制代码

! A& A% J5 ?' i. G; D