01. OLED概述
7 e2 m  R! p0 `1 S9 v0 Y9 v8 @OLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（OrganicElectroluminesence Display， OELD）。OLED 由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被认为是下一代的平面显示器新兴应用技术。

& [/ S+ \! m' b  ELCD 都需要背光，而 OLED 不需要，因为它是自发光的。这样同样的显示，OLED 效果要来得好一些。以目前的技术，OLED 的尺寸还难以大型化，但是分辨率确可以做到很高。
2 e( V* P6 g3 X9 i+ e
02. OLED初始化
0 w+ G( O' M; p) C3 ^3 g7 |
5 y* d( p: R0 n' c, l/ O

# w9 g* s0 N& @) W驱动 IC 的初始化代码，我们直接使用厂家推荐的设置就可以了，只要对细节部分进行一些修改，使其满足我们自己的要求即可，其他不需要变动。

OLED 显示需要的相关设置步骤如下：
+ `4 N+ c( E) p: ^: v5 ~
6 _1 G/ L8 Y. o+ \1 ）设置 STM32F4 与 与 OLED 模块相连接的 IO 。
这一步，先将我们与 OLED 模块相连的 IO 口设置为输出，具体使用哪些 IO 口，这里需要根据连接电路以及 OLED 模块所设置的通讯模式来确定。

  H  Z; L# N: ^2 ）初始化 OLED 模块。
其实这里就是上面的初始化框图的内容，通过对 OLED 相关寄存器的初始化，来启动 OLED的显示。
& `; w/ L9 m+ i- L. P( c
+ }" [0 X5 S& Z) Y# w6 ~# o3 ）通过函数将字符和数字显示到 OLED 模块上。
" }/ X" L" K. d1 t7 T+ R这里就是通过我们设计的程序，将要显示的字符送到 OLED 模块就可以了

% P. v6 x7 U8 K* K通过以上三步，我们就可以使用 ALIENTEK OLED 模块来显示字符和数字了。

03. 硬件设计
用到的硬件资源有：
1） 指示灯 DS0
) l/ F/ J# t3 x. a2） OLED 模块
6 C- c9 ]% W' D' z6 V
' F1 Z7 [* j* }硬件上，OLED 与探索者 STM32F4 开发板的 IO 口对应关系如下：
OLED_CS 对应 DCMI_VSYNC，即：PB7;
- D4 m; z  C4 kOLED_RS 对应 DCMI_SCL，即：PD6;
OLED_WR 对应 DCMI_HREF，即：PA4;
OLED_RD 对应 DCMI_SDA，即：PD7;
OLED_RST 对应 DCMI_RESET，即：PG15;
OLED_D[7:0]对应 DCMI_D[7:0]，即：PE6/PE5/PB6/PC11/PC9/PC8/PC7/PC6;

04. 程序示例
oled.h
( ]- @0 s- |  D( p1 C1 p

1. #ifndef __OLED_H
   , v8 |& C+ e' t& C8 G
2. #define __OLED_H                                   
   9 I  D( s0 n5 E) x- b
3. #include "sys.h"
   
4. #include "stdlib.h"            
   5 t. R% W' ^$ _5 V, e; ^6 x
5. 
   $ ]! P! x8 h8 B% G8 Y! V# t. T
6. //OLED模式设置
   
7. //0: 4线串行模式  （模块的BS1，BS2均接GND）
   4 u* P/ U' S% i5 k9 Z5 a9 e
8. //1: 并行8080模式 （模块的BS1，BS2均接VCC）
   3 A. `, f! h0 N( f( ^9 u5 U
9. #define OLED_MODE         1
   . ~( s8 u% I# a4 D& h/ ]6 O8 h
10.                                                                      
    7 Q8 I4 _; k, \8 Q8 Z
11. //-----------------OLED端口定义----------------                                             
    , w# b6 w0 R0 A( F3 b" S$ ]
12. #define OLED_CS         PBout(7)
    " I: F% l6 a+ F# @8 J
13. #define OLED_RST  PGout(15)        
    " o0 C5 M0 Y! P
14. #define OLED_RS         PDout(6)
    
15. #define OLED_WR         PAout(4)                  
    9 [' a: G9 C' [) C/ H
16. #define OLED_RD         PDout(7)
    3 v3 e3 s4 L$ P0 q. G: e+ A# i
17. 
    
18. //使用4线串行接口时使用
    
19. #define OLED_SCLK         PCout(6)
    
20. #define OLED_SDIN         PCout(7)
    
21.                      
    6 ^/ j( \$ H1 G' O
22. #define OLED_CMD          0                //写命令
    ! U; U: _3 d* i- }. E5 A
23. #define OLED_DATA         1                //写数据
    
24. //OLED控制用函数
    
25. void OLED_WR_Byte(u8 dat,u8 cmd);            
    - [) J# `. s3 W' J: _! H& f* q
26. void OLED_Display_On(void);
    
27. void OLED_Display_Off(void);
    
28. void OLED_Refresh_Gram(void);                  
    
29.                                                                               
    7 w% H) p0 i. a( n, [- m, |; e
30. void OLED_Init(void);
    
31. void OLED_Clear(void);
    3 {7 t% U; h  A5 x  y, M
32. void OLED_DrawPoint(u8 x,u8 y,u8 t);
    " `% q* O; g7 J5 |. E1 G3 r& E
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);
    5 J! w7 R$ u/ \6 c
35. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size);
    7 V0 D7 {- W$ V: G8 M, @' v
36. void OLED_ShowString(u8 x,u8 y,const u8 *p,u8 size);         
    + }- g, q  F7 F' Y! p* w$ x2 n
37. #endif  

复制代码

; i2 X5 C- m; j0 Uoled.c
# E8 Y  }' A0 |' O- F; O8 I
0 G& l8 T. e* g! U% q& E- J

1. #include "oled.h"
   
2. #include "stdlib.h"
   % c% k, @, a' Y
3. #include "oledfont.h"           
   
4. #include "delay.h"
   / J7 p& I5 T+ s2 h
5. 
   
6. //OLED的显存
   
7. //存放格式如下.
   ' I! x% v) u; r+ N4 M$ g& u1 ~) Q
8. //[0]0 1 2 3 ... 127        
   / d0 U- ?1 T' r
9. //[1]0 1 2 3 ... 127        
   4 Y0 e6 u" D7 V' w( R% H
10. //[2]0 1 2 3 ... 127        
    % _. [2 C8 a4 }) F2 Y( _9 x& H1 F' p
11. //[3]0 1 2 3 ... 127        
    0 S( M' c  N- W2 {/ o7 F
12. //[4]0 1 2 3 ... 127        
    ( C# |# m5 I5 [" r. x
13. //[5]0 1 2 3 ... 127        
    
14. //[6]0 1 2 3 ... 127        
    
15. //[7]0 1 2 3 ... 127                    
    
16. u8 OLED_GRAM[128][8];         
    
17. 
      [3 B+ l9 d" G: N- w& ^
18. //更新显存到LCD                 
    3 O( j$ E9 S, z' }
19. void OLED_Refresh_Gram(void)
    
20. {
    
21.         u8 i,n;                    
    
22.         for(i=0;i<8;i++)  
    9 e( a) b1 Z9 V7 p* o7 X: ^
23.         {  
    
24.                 OLED_WR_Byte (0xb0+i,OLED_CMD);    //设置页地址（0~7）
    
25.                 OLED_WR_Byte (0x00,OLED_CMD);      //设置显示位置—列低地址
    
26.                 OLED_WR_Byte (0x10,OLED_CMD);      //设置显示位置—列高地址   
    ) {0 t6 G( I6 K; S( l9 z
27.                 for(n=0;n<128;n++)OLED_WR_Byte(OLED_GRAM[n]<i>,OLED_DATA);
    6 r" W9 T0 ]1 ~8 Y. A  U6 i8 c
28.         }   
    , Z) J* I- j* z9 `
29. }
    1 O5 z2 C  Q/ \8 g. [
30. //8080并口
    
31. //通过拼凑的方法向OLED输出一个8位数据
    ; d6 ?, \% {3 P" E7 ~8 [. s& V; a
32. //data:要输出的数据
    
33. void OLED_Data_Out(u8 data)
    5 I0 j: K: y5 ~: n" C+ F4 S
34. {
    # ^$ ~) V6 B5 W" ^  x
35.         u16 dat=data&0X0F;
    
36.         GPIOC->ODR&=~(0XF<<6);                //清空6~9
    4 `* W) @, T) e. s
37.         GPIOC->ODR|=dat<<6;                        //D[3:0]-->PC[9:6]
    5 D% G1 {: k5 O( ?0 B$ {% O
38.         GPIO_Write(GPIOC,dat<<6);
    5 [& _( e+ P$ @; b4 Y$ e* r
39.         PCout(11)=(data>>4)&0X01;        //D4
    
40.         PBout(6)=(data>>5)&0X01;        //D5
    
41.         PEout(5)=(data>>6)&0X01;        //D6
    
42.         PEout(6)=(data>>7)&0X01;        //D7
    
43. }
    & H; Q& M- \! a1 T( m' k! L
44. //向SSD1306写入一个字节。
    9 C0 v$ v4 d3 j9 A% Q1 w7 k
45. //dat:要写入的数据/命令
    # y: C# F" h' D
46. //cmd:数据/命令标志 0,表示命令;1,表示数据;
    
47. void OLED_WR_Byte(u8 dat,u8 cmd)
    
48. {
    
49.         OLED_Data_Out(dat);            
    3 I( J* b+ w: v; H& w
50.          OLED_RS=cmd;
    : @) t7 A# q, E+ [- d
51.         OLED_CS=0;           
    
52.         OLED_WR=0;         
    / W- d2 X! I! j6 P3 T( B3 V: @
53.         OLED_WR=1;
    6 `! Z& X5 Z  D' j" `7 L5 R0 ?! p
54.         OLED_CS=1;         
    
55.         OLED_RS=1;         
    
56. }                        
    
57.                     
    
58. //开启OLED显示   
    
59. void OLED_Display_On(void)
    ; d% Y6 E! `& N) ]2 S+ ]
60. {
    $ ^- v/ S" ]. E6 }( |$ _; x, I
61.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    
62.         OLED_WR_Byte(0X14,OLED_CMD);  //DCDC ON
    # Z& o, Q4 i4 g6 |6 l; I
63.         OLED_WR_Byte(0XAF,OLED_CMD);  //DISPLAY ON
    " p/ _- J8 y- T! R' [
64. }
    
65. //关闭OLED显示     
    
66. void OLED_Display_Off(void)
    
67. {
    / |: S; r; @$ i! ^- L. @/ Z
68.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    
69.         OLED_WR_Byte(0X10,OLED_CMD);  //DCDC OFF
    
70.         OLED_WR_Byte(0XAE,OLED_CMD);  //DISPLAY OFF
    0 Q" m3 C" B1 j6 I2 X7 R/ q+ j
71. }                                            
    
72. //清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!         
    
73. void OLED_Clear(void)  
    4 y4 d" r9 f. n" F
74. {  
    
75.         u8 i,n;  
    6 ^4 U$ U2 Q" {) ^) K4 k& h
76.         for(i=0;i<8;i++)for(n=0;n<128;n++)OLED_GRAM[n]<i>=0X00;  
    
77.         OLED_Refresh_Gram();//更新显示
      P& W1 v. L. {% {2 D* R  q) `
78. }
    
79. //画点
    
80. //x:0~127
    
81. //y:0~63
    
82. //t:1 填充 0,清空                                   
    
83. void OLED_DrawPoint(u8 x,u8 y,u8 t)
    
84. {
    ) t5 [" \8 X, y
85.         u8 pos,bx,temp=0;
    
86.         if(x>127||y>63)return;//超出范围了.
    6 R( O! c, V' _6 s: M5 C
87.         pos=7-y/8;
    
88.         bx=y%8;
    % J4 p8 Z+ Z- m* T. J4 h
89.         temp=1<<(7-bx);
    ! l% ^( `7 F9 K
90.         if(t)OLED_GRAM[x][pos]|=temp;
    ( W' T6 P) a( B3 M( x1 d. i
91.         else OLED_GRAM[x][pos]&=~temp;            
    + k' Y3 ~$ R. ^, W6 s- I8 t
92. }
    / ]0 g% _* C7 |
93. //x1,y1,x2,y2 填充区域的对角坐标
    
94. //确保x1<=x2;y1<=y2 0<=x1<=127 0<=y1<=63                  
    
95. //dot:0,清空;1,填充         
      E1 k+ F- Y, @
96. void OLED_Fill(u8 x1,u8 y1,u8 x2,u8 y2,u8 dot)  
    
97. {  
    
98.         u8 x,y;  
    ' o& T4 r1 ^6 y+ B5 G' D  f# T
99.         for(x=x1;x<=x2;x++)
    
100.         {
     0 y& L8 b3 |& i5 `3 G1 a8 Q
101.                 for(y=y1;y<=y2;y++)OLED_DrawPoint(x,y,dot);
     
102.         }                                                                                                            
     3 e$ E9 r4 s! g- T8 x
103.         OLED_Refresh_Gram();//更新显示
     # }4 Y/ m# g3 @8 I" ]
104. }
     ) A  J* o2 j1 P1 m" z" f9 ?3 o
105. //在指定位置显示一个字符,包括部分字符
     
106. //x:0~127
     & m$ w. G7 N- `/ v1 C$ q
107. //y:0~63
     
108. //mode:0,反白显示;1,正常显示                                 
     8 x2 `7 H% t; [7 g+ |; G
109. //size:选择字体 12/16/24
     3 L% c8 t) j8 p, @7 b& k* K
110. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size,u8 mode)
     
111. {                                 
     * e* L: m( E. M# {9 ?7 W: d
112.         u8 temp,t,t1;
     % L" {1 |5 s% O; V% p
113.         u8 y0=y;
     
114.         u8 csize=(size/8+((size%8)?1:0))*(size/2);                //得到字体一个字符对应点阵集所占的字节数
     
115.         chr=chr-' ';//得到偏移后的值                 
     
116.     for(t=0;t<csize;t++)
     # u! d7 F0 o5 I! `3 Y
117.     {   
     / B5 V# z8 h8 `* A
118.                 if(size==12)temp=asc2_1206[chr][t];                  //调用1206字体
     
119.                 else if(size==16)temp=asc2_1608[chr][t];        //调用1608字体
     
120.                 else if(size==24)temp=asc2_2412[chr][t];        //调用2412字体
     
121.                 else return;                                                                //没有的字库
     : |; J" ?9 l" ~% f$ ?' }
122.         for(t1=0;t1<8;t1++)
     & u) ^/ @; A/ L6 A6 b5 D- e
123.                 {
     
124.                         if(temp&0x80)OLED_DrawPoint(x,y,mode);
     6 [- _4 S8 j! v8 |% j$ r- p$ P
125.                         else OLED_DrawPoint(x,y,!mode);
     + z+ y% _8 n1 Q. E1 m
126.                         temp<<=1;
     1 n! g4 {: f0 b! i5 o' i
127.                         y++;
     
128.                         if((y-y0)==size)
     
129.                         {
     
130.                                 y=y0;
     
131.                                 x++;
     ( J! `- v8 c6 r4 t
132.                                 break;
     
133.                         }
     3 c4 u% N" D" x
134.                 }           
     
135.     }         
     
136. }
     # o( V; x: z7 {
137. //m^n函数
     
138. u32 mypow(u8 m,u8 n)
     ( X8 t9 r5 a' r8 I
139. {
     
140.         u32 result=1;         
     
141.         while(n--)result*=m;   
     9 Q5 H* q, Z+ c3 H; f3 }  z* S
142.         return result;
     
143. }                                 
       v0 Y+ R- Z1 [+ E$ |* N* d7 D5 E
144. //显示2个数字
     
145. //x,y :起点坐标         
     
146. //len :数字的位数
     " b- _* M* E3 L5 |7 u/ b$ l6 ]
147. //size:字体大小
     ! P# n& X. L- h5 s! K5 ]
148. //mode:模式        0,填充模式;1,叠加模式
     
149. //num:数值(0~4294967295);                           
     ! r; W9 A: O% N5 S1 A. {
150. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size)
     
151. {                 
     
152.         u8 t,temp;
     3 d5 |  @4 _# V$ M4 V* L4 k
153.         u8 enshow=0;                                                   
       \+ s$ u$ M0 P
154.         for(t=0;t<len;t++)
     " `3 T, @: t- ~0 e) c
155.         {
     8 h: y9 V/ l! @$ y* A- @* A
156.                 temp=(num/mypow(10,len-t-1))%10;
     
157.                 if(enshow==0&&t<(len-1))
     7 c0 C: f+ p7 J  `) Z: N( i7 e9 z
158.                 {
     . k& R" T/ L) l5 ^6 `, e; [! J
159.                         if(temp==0)
     9 Q- f3 w& U0 o
160.                         {
     
161.                                 OLED_ShowChar(x+(size/2)*t,y,' ',size,1);
     ! P- _0 J0 V! B9 d+ D  [
162.                                 continue;
     
163.                         }else enshow=1;
     
164.                           
     . F7 |& V" r" B0 Y
165.                 }
     * A+ V) w0 w' {8 ~3 ]/ N( l
166.                  OLED_ShowChar(x+(size/2)*t,y,temp+'0',size,1);
     $ f' v  K8 N! s6 s" a
167.         }
     
168. }
     
169. //显示字符串
     5 R% ~+ m' S* s' K8 @
170. //x,y:起点坐标  
       K! q* m2 ]6 s3 V
171. //size:字体大小
     
172. //*p:字符串起始地址
     8 R5 ], t. S3 D! u
173. void OLED_ShowString(u8 x,u8 y,const u8 *p,u8 size)
     ! n! f9 i/ Z$ V7 e6 M' x4 f
174. {        
     
175.     while((*p<='~')&&(*p>=' '))//判断是不是非法字符!
     1 k# H9 X8 c0 J  Q, q" `" q
176.     {      
     5 S+ ]" P, _" l" o/ E
177.         if(x>(128-(size/2))){x=0;y+=size;}
     
178.         if(y>(64-size)){y=x=0;OLED_Clear();}
     
179.         OLED_ShowChar(x,y,*p,size,1);         
     & {, l$ I. w5 T& n/ T
180.         x+=size/2;
     ! A7 Q# N1 q; A! B
181.         p++;
     . T+ @4 l" U* ]2 E; r6 K
182.     }  
     2 }  N$ n, {7 t
183.         
     
184. }        
     ( r7 D! u% \) Y8 G; |# d( t1 Q
185. //初始化SSD1306                                            
     
186. void OLED_Init(void)
     
187. {                           
     ; M! i  f1 _- R2 i
188.   GPIO_InitTypeDef  GPIO_InitStructure;
     
189.         
     0 v6 \+ ^5 `2 T1 e
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时钟
     6 A: f% X- n  d* s% X
191. 
     
192. //使用8080并口模式               
     & Z; K3 [8 I. v  ]* H! R8 h
193.         
     
194.         //GPIO初始化设置
     
195.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 ;
     
196.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
     ) N- F, ?4 q% `3 {2 N7 e6 [9 ]8 C, r
197.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
     " u" k& i/ P1 `: J( s$ I+ K5 ^% K
198.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
     
199.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
     
200.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化
     - d0 G, Q& d$ y* e$ I
201.         
     6 k6 i3 O9 ?+ S2 _
202.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7 ;        
     
203.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
     
204. 
     
205.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_11;        
     # h9 ?! W3 _& `* r7 X- C
206.         GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化        
     3 Z0 _% h0 X' m$ x! b- Z9 |
207. 
     
208.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;        
     - L  B  S8 S* J: M9 c* m  X& J& r
209.         GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化        
     
210.         
     0 d& p2 P) O* o' Q9 i
211.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_5;        
     
212.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化        
     - e, K6 v% w% r8 R
213.         
     * P/ b) {, n3 @2 A% J
214.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;        
     
215.         GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化        
     $ B. {, s  B; _" p
216. 
     ( K3 P8 x# f6 B2 {2 E9 c+ F
217.         
     
218.          OLED_WR=1;
     
219.         OLED_RD=1;
     9 e* V. k( O0 w% Q; D
220. 
     
221.         OLED_CS=1;
     ) c) _, s- N% X: l+ }9 k8 p
222.         OLED_RS=1;         
     
223.         
     8 u1 h" q$ y; G1 Y' o% [
224.         OLED_RST=0;
     
225.         delay_ms(100);
     
226.         OLED_RST=1;
     
227.                                           
     
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)
     + w2 e5 _0 c" d% z0 |2 ^
233.         OLED_WR_Byte(0xD3,OLED_CMD); //设置显示偏移
     % n6 h: \$ l+ y( y
234.         OLED_WR_Byte(0X00,OLED_CMD); //默认为0
     
235. 
     ( F& C& y7 e) }5 e" R0 V0 F+ B
236.         OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.
     
237.                                                                                                             
     7 u( B: E" Y* F# T! M2 C2 \
238.         OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置
     & l$ ^  ^' Z/ F! C
239.         OLED_WR_Byte(0x14,OLED_CMD); //bit2，开启/关闭
     
240.         OLED_WR_Byte(0x20,OLED_CMD); //设置内存地址模式
     + D3 \& q7 _( B/ e; p
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;
     ' L/ G& f- X8 w* _. g; {; ~# L1 @( c
243.         OLED_WR_Byte(0xC0,OLED_CMD); //设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
     
244.         OLED_WR_Byte(0xDA,OLED_CMD); //设置COM硬件引脚配置
     : i" o' `( v$ v9 t% y- s
245.         OLED_WR_Byte(0x12,OLED_CMD); //[5:4]配置
     
246.                  
     
247.         OLED_WR_Byte(0x81,OLED_CMD); //对比度设置
     
248.         OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
     9 \  o5 S# B. z4 @6 Q
249.         OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期
     " ]' h1 t9 I* c& ?3 H; t
250.         OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
     
251.         OLED_WR_Byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率
       X/ k( `  q$ \* ^. Z, y& O& ]0 ]( I
252.         OLED_WR_Byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
     
253. 
     / z, m6 @0 |8 @5 |# K# u4 ]
254.         OLED_WR_Byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
     - @1 N4 k  g7 |2 l5 n- }( d
255.         OLED_WR_Byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示                                                               
     
256.         OLED_WR_Byte(0xAF,OLED_CMD); //开启显示         
     
257.         OLED_Clear();
     
258. }  </i></i>

复制代码

/ G8 Y' T8 g+ u' \& W! [, ]main.c
$ e! A+ {- ^" S$ v8 k# `/ R) S2 g2 W

1. #include "sys.h"
   
2. #include "delay.h"
   & d2 r3 s. s) b# u
3. #include "usart.h"
   % \! r* x: T' M; n  h
4. #include "led.h"
   ) U1 w9 }$ S6 ^5 C3 u4 X* g4 a9 [
5. #include "oled.h"
   + {  b% Y, r! M3 W
6. 
   
7. 
   1 k- J9 m0 {0 k! w& M. H/ p
8. int main(void)
   
9. {
   9 e' i( N* w, Q9 _, }1 ]1 }; K
10.         u8 t=0;
    
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    
12.         delay_init(168);     //初始化延时函数
    : D. ~( v% f# n. t- v( C# P3 E
13.         uart_init(115200);        //初始化串口波特率为115200
    
14.         LED_Init();                                        //初始化LED
    
15.          OLED_Init();                                //初始化OLED
    8 ^/ ]$ {5 d* ?7 K
16.   OLED_ShowString(0,0,"ALIENTEK",24);  
    + U. ?% P6 C( L9 U6 M3 k7 r6 K, q
17.         OLED_ShowString(0,24, "0.96' OLED TEST",16);  
    
18.          OLED_ShowString(0,40,"ATOM 2014/5/4",12);  
    " Q3 W, n" b' }1 h1 U  q1 g+ a' \
19.          OLED_ShowString(0,52,"ASCII:",12);  
    - z" u5 e# E/ J$ l
20.          OLED_ShowString(64,52,"CODE:",12);  
    
21.         OLED_Refresh_Gram();//更新显示到OLED         
    3 e% n5 J2 y* l$ e0 I
22.         t=' ';  
    
23.         while(1)
    ; U" q# Y7 k+ a( M. D
24.         {               
    7 i$ C/ I: Z! s% ]- e
25.                 OLED_ShowChar(36,52,t,12,1);//显示ASCII字符        
    
26.                 OLED_ShowNum(94,52,t,3,12);        //显示ASCII字符的码值   
    : U' Z1 A$ K! a0 h0 K$ d+ b# A
27.                 OLED_Refresh_Gram();        //更新显示到OLED
    & P. s5 l! W8 t8 Y1 j
28.                 t++;
    ! A, L& {( E4 h
29.                 if(t>'~')t=' ';  
    
30.                 delay_ms(500);
    
31.                 LED0=!LED0;
    
32.         }
    
33. }
    8 W: \+ u) w) m% d7 N# o, B, W3 h; W
34. 
    6 }3 z; l1 i. D* `; i4 @

复制代码

3 e+ t8 \) H0 n! |, e. O0 G7 r1 [