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

& j/ Z4 C+ d3 n" N) |LCD 都需要背光，而 OLED 不需要，因为它是自发光的。这样同样的显示，OLED 效果要来得好一些。以目前的技术，OLED 的尺寸还难以大型化，但是分辨率确可以做到很高。
; g+ X% ?: ~8 @( H: n$ D% x
' h! E1 b1 \) B) F* ^1 ?* C02. OLED初始化


! q- P' ?" F  W8 j) u  l
& B$ Z+ T: p0 O% W8 y% e. z" _驱动 IC 的初始化代码，我们直接使用厂家推荐的设置就可以了，只要对细节部分进行一些修改，使其满足我们自己的要求即可，其他不需要变动。
6 @( h: c/ K" L
OLED 显示需要的相关设置步骤如下：

1 ）设置 STM32F4 与 与 OLED 模块相连接的 IO 。
7 v, @6 G% C( `" h& L- }3 b这一步，先将我们与 OLED 模块相连的 IO 口设置为输出，具体使用哪些 IO 口，这里需要根据连接电路以及 OLED 模块所设置的通讯模式来确定。

2 ）初始化 OLED 模块。
  ?' v) A7 k" ?. V其实这里就是上面的初始化框图的内容，通过对 OLED 相关寄存器的初始化，来启动 OLED的显示。
5 n6 e, q! p- F, E' ?; F$ H- B' C
3 ）通过函数将字符和数字显示到 OLED 模块上。
( d9 M& W, F6 ?5 q这里就是通过我们设计的程序，将要显示的字符送到 OLED 模块就可以了
' ~& F1 {( Z9 T. z
) }# q: b" D, k4 I通过以上三步，我们就可以使用 ALIENTEK OLED 模块来显示字符和数字了。
% _% m' `* ?' O: f- V8 i
03. 硬件设计
7 p, S+ a/ V% \3 k0 L用到的硬件资源有：
1） 指示灯 DS0
5 `% a! ~5 T5 z, u2） OLED 模块

% a" X) s! S1 S2 D7 T, Y, L硬件上，OLED 与探索者 STM32F4 开发板的 IO 口对应关系如下：
OLED_CS 对应 DCMI_VSYNC，即：PB7;
8 g2 U& K+ n: C5 |OLED_RS 对应 DCMI_SCL，即：PD6;
; V5 g; H) Z# e1 R( AOLED_WR 对应 DCMI_HREF，即：PA4;
OLED_RD 对应 DCMI_SDA，即：PD7;
OLED_RST 对应 DCMI_RESET，即：PG15;
8 W0 O+ B9 R/ x: A$ L6 `( X5 _OLED_D[7:0]对应 DCMI_D[7:0]，即：PE6/PE5/PB6/PC11/PC9/PC8/PC7/PC6;
/ H6 _4 C3 q2 l# T% ?+ `# N3 b
8 ~2 q+ p9 r0 J( O7 o4 e" U( y04. 程序示例
' f3 N6 {/ A$ D. yoled.h
1 U) N- [# y5 h+ t, S8 g) E# U

1. #ifndef __OLED_H
   
2. #define __OLED_H                                   
   
3. #include "sys.h"
   * K: d) s% n+ |/ a, o3 y
4. #include "stdlib.h"            
   
5. 
   9 R1 Z6 z$ O4 v, _0 W8 `* ^
6. //OLED模式设置
   " ]+ p' A9 v# K
7. //0: 4线串行模式  （模块的BS1，BS2均接GND）
   - V, @, V, [; O4 C6 h8 L, O
8. //1: 并行8080模式 （模块的BS1，BS2均接VCC）
   
9. #define OLED_MODE         1
   3 O3 p7 R. @) F
10.                                                                      
    / V& P$ ]) L. ^- h+ A: Y4 J
11. //-----------------OLED端口定义----------------                                             
    
12. #define OLED_CS         PBout(7)
    
13. #define OLED_RST  PGout(15)        
    3 u; C6 N1 m% B
14. #define OLED_RS         PDout(6)
    
15. #define OLED_WR         PAout(4)                  
    
16. #define OLED_RD         PDout(7)
    
17. 
    % ?% |3 ~1 X, I2 T$ \
18. //使用4线串行接口时使用
    
19. #define OLED_SCLK         PCout(6)
    
20. #define OLED_SDIN         PCout(7)
    
21.                      
    
22. #define OLED_CMD          0                //写命令
    
23. #define OLED_DATA         1                //写数据
    6 c2 o: K. b% l- n
24. //OLED控制用函数
    
25. void OLED_WR_Byte(u8 dat,u8 cmd);            
    
26. void OLED_Display_On(void);
    $ B8 ]: z) F, y
27. void OLED_Display_Off(void);
    
28. void OLED_Refresh_Gram(void);                  
    
29.                                                                               
    
30. void OLED_Init(void);
    ! C. E# P* F% M7 Y* q, W; t
31. void OLED_Clear(void);
    
32. void OLED_DrawPoint(u8 x,u8 y,u8 t);
    
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);
    8 ?- P9 m' N. ~1 V
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);         
    2 T2 l+ \, x. i3 m) Z% ]
37. #endif  
    / |% G; t/ j* O7 R. {% ^! r; C

复制代码

( k; O$ y% U/ W5 d; h, O8 Woled.c
4 g4 d  Z) r8 X, |# W. e
; g' u1 t  w" u2 D) ~1 S

1. #include "oled.h"
   4 P4 S' p, ~6 ]
2. #include "stdlib.h"
   
3. #include "oledfont.h"           
   
4. #include "delay.h"
   7 o  X7 H6 o. r8 B; b
5. 
   
6. //OLED的显存
   - s4 V' Y. d8 i
7. //存放格式如下.
   
8. //[0]0 1 2 3 ... 127        
   - i0 Y* K  V6 E9 l0 p6 G; n% P. @1 o
9. //[1]0 1 2 3 ... 127        
   + d& O; |4 |$ K8 G
10. //[2]0 1 2 3 ... 127        
    
11. //[3]0 1 2 3 ... 127        
    
12. //[4]0 1 2 3 ... 127        
    
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. 
    % N' V& u$ C$ `2 s3 }' G5 p
18. //更新显存到LCD                 
    
19. void OLED_Refresh_Gram(void)
    
20. {
    + Q8 w+ b, H  D  e9 F8 u4 S, i8 S0 [& t
21.         u8 i,n;                    
    8 s% Q/ K5 b* h9 @
22.         for(i=0;i<8;i++)  
    , T$ ]/ s' P. N4 A) n/ q
23.         {  
    : U: ]% T( p  P
24.                 OLED_WR_Byte (0xb0+i,OLED_CMD);    //设置页地址（0~7）
    / l, m& |7 g. _
25.                 OLED_WR_Byte (0x00,OLED_CMD);      //设置显示位置—列低地址
    
26.                 OLED_WR_Byte (0x10,OLED_CMD);      //设置显示位置—列高地址   
    4 n5 i* J& l8 Y3 F
27.                 for(n=0;n<128;n++)OLED_WR_Byte(OLED_GRAM[n],OLED_DATA);
    3 Y( D2 D; \  t
28.         }   
    
29. }
    
30. //8080并口
    2 S" @+ i3 y  e6 o4 c+ b" j
31. //通过拼凑的方法向OLED输出一个8位数据
    
32. //data:要输出的数据
    
33. void OLED_Data_Out(u8 data)
    ) d/ |: I, Q* L! \: u* k+ }
34. {
    
35.         u16 dat=data&0X0F;
    
36.         GPIOC->ODR&=~(0XF<<6);                //清空6~9
    
37.         GPIOC->ODR|=dat<<6;                        //D[3:0]-->PC[9:6]
    ; u  g; U1 ]! [
38.         GPIO_Write(GPIOC,dat<<6);
    $ \& i# M* |$ c9 ]
39.         PCout(11)=(data>>4)&0X01;        //D4
    * l) R! e! l- f, O- ~
40.         PBout(6)=(data>>5)&0X01;        //D5
    
41.         PEout(5)=(data>>6)&0X01;        //D6
    
42.         PEout(6)=(data>>7)&0X01;        //D7
    ; S6 w* U* a6 \
43. }
    
44. //向SSD1306写入一个字节。
    
45. //dat:要写入的数据/命令
    
46. //cmd:数据/命令标志 0,表示命令;1,表示数据;
    ; q1 i! K* p* d. _; a; x, [: g/ I
47. void OLED_WR_Byte(u8 dat,u8 cmd)
    
48. {
    
49.         OLED_Data_Out(dat);            
    ' b$ Y5 D7 E+ |7 b" Z- F; `* L! j
50.          OLED_RS=cmd;
    
51.         OLED_CS=0;           
    * C: ]; Z" K: g/ [- m
52.         OLED_WR=0;         
    1 p  }( o/ Q' H" }
53.         OLED_WR=1;
    0 E$ N# r( |( I/ X. d
54.         OLED_CS=1;         
    
55.         OLED_RS=1;         
    
56. }                        
    
57.                     
    
58. //开启OLED显示   
    7 J- N% t2 k& u. d. H$ V% D7 U
59. void OLED_Display_On(void)
    
60. {
    0 B4 k* W% ]" t$ X8 I
61.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    1 i1 X5 _# n( [  H3 l- y1 C2 p. @8 d
62.         OLED_WR_Byte(0X14,OLED_CMD);  //DCDC ON
    % y- L0 ]* @9 c& o5 b+ I
63.         OLED_WR_Byte(0XAF,OLED_CMD);  //DISPLAY ON
    - k2 N. X% H4 w- X  @- s  d5 Q* _7 h
64. }
    # P2 t! ^# j: \
65. //关闭OLED显示     
    / V  Y7 Q6 W& H2 i' E  V
66. void OLED_Display_Off(void)
    5 V/ \2 g6 _, B$ |* \# V0 h& E# R
67. {
    2 X7 \! ^+ v+ ]  b2 @
68.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    7 c8 e1 F8 R  ?, W
69.         OLED_WR_Byte(0X10,OLED_CMD);  //DCDC OFF
    
70.         OLED_WR_Byte(0XAE,OLED_CMD);  //DISPLAY OFF
    
71. }                                            
    
72. //清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!         
    $ y9 t- E1 u$ I7 |
73. void OLED_Clear(void)  
    
74. {  
    
75.         u8 i,n;  
    
76. for(i=0;i<8;i++)for(n=0;n<128;n++)OLED_GRAM[n]=0X00;  
    0 G  s. j3 ~5 Y; f& \
77.         OLED_Refresh_Gram();//更新显示
    1 ~" Q: m: x7 Z. t- V
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. {
    
85.         u8 pos,bx,temp=0;
    
86.         if(x>127||y>63)return;//超出范围了.
      t" c: @# i" V8 h! d
87.         pos=7-y/8;
    
88.         bx=y%8;
    
89.         temp=1<<(7-bx);
      J' E" @9 c- @- f3 X; f* m5 b" D+ {
90.         if(t)OLED_GRAM[x][pos]|=temp;
    
91.         else OLED_GRAM[x][pos]&=~temp;            
    
92. }
    + V- Q+ K1 V$ ^9 g- U- e
93. //x1,y1,x2,y2 填充区域的对角坐标
    
94. //确保x1<=x2;y1<=y2 0<=x1<=127 0<=y1<=63                  
    * @: t0 H7 N/ F9 Q5 Z
95. //dot:0,清空;1,填充         
    
96. void OLED_Fill(u8 x1,u8 y1,u8 x2,u8 y2,u8 dot)  
    
97. {  
    * r0 t) u* I1 d6 l/ v- r1 c3 m
98.         u8 x,y;  
    # |+ J) ]& ~0 `- K% Q
99.         for(x=x1;x<=x2;x++)
    5 ~1 b4 C! L6 _3 F" V
100.         {
     
101.                 for(y=y1;y<=y2;y++)OLED_DrawPoint(x,y,dot);
     
102.         }                                                                                                            
     
103.         OLED_Refresh_Gram();//更新显示
     
104. }
     
105. //在指定位置显示一个字符,包括部分字符
     
106. //x:0~127
     $ n1 |' V$ c- ?0 Q
107. //y:0~63
     
108. //mode:0,反白显示;1,正常显示                                 
     
109. //size:选择字体 12/16/24
     # _  p, U4 X5 Q. \/ \
110. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size,u8 mode)
     
111. {                                 
     " m0 N, C7 L' v8 K
112.         u8 temp,t,t1;
     ) v# V/ s6 b+ b8 z
113.         u8 y0=y;
     
114.         u8 csize=(size/8+((size%8)?1:0))*(size/2);                //得到字体一个字符对应点阵集所占的字节数
     
115.         chr=chr-' ';//得到偏移后的值                 
     * V6 `/ E' x# p4 E5 b3 |
116.     for(t=0;t<csize;t++)
     + r/ D( m+ V6 s7 w% B
117.     {   
     8 }+ R$ l$ X8 n9 u; S: x. u; B
118.                 if(size==12)temp=asc2_1206[chr][t];                  //调用1206字体
     1 _4 i( l2 b3 F- D
119.                 else if(size==16)temp=asc2_1608[chr][t];        //调用1608字体
     
120.                 else if(size==24)temp=asc2_2412[chr][t];        //调用2412字体
     + N  v) W4 h) u% x
121.                 else return;                                                                //没有的字库
     
122.         for(t1=0;t1<8;t1++)
     
123.                 {
     
124.                         if(temp&0x80)OLED_DrawPoint(x,y,mode);
     8 l$ w# T5 K8 f" V8 d0 W4 {' J5 K, F
125.                         else OLED_DrawPoint(x,y,!mode);
     
126.                         temp<<=1;
     
127.                         y++;
     " o% X0 \- |4 p% Y/ _
128.                         if((y-y0)==size)
     , J; n8 _4 o0 R- ?
129.                         {
     * j3 {4 ^5 R$ E, K5 }2 F
130.                                 y=y0;
     $ G2 ?1 r. ]3 q" S
131.                                 x++;
     
132.                                 break;
     
133.                         }
     
134.                 }           
     . x9 \. a) q8 }* `
135.     }         
     
136. }
     
137. //m^n函数
     
138. u32 mypow(u8 m,u8 n)
     
139. {
     
140.         u32 result=1;         
     
141.         while(n--)result*=m;   
     
142.         return result;
     
143. }                                 
     
144. //显示2个数字
     . \# g+ m- G! h/ \7 i2 m0 K' n3 w
145. //x,y :起点坐标         
     
146. //len :数字的位数
     
147. //size:字体大小
     8 E+ v8 V7 v3 ]: _0 x
148. //mode:模式        0,填充模式;1,叠加模式
       H7 r# Z; O2 Z# u8 @8 q* D5 Z) H
149. //num:数值(0~4294967295);                           
     
150. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size)
     3 ~6 W- l7 n9 v" j
151. {                 
     # p$ H" f/ ?7 C: r) I9 V. j
152.         u8 t,temp;
     
153.         u8 enshow=0;                                                   
     2 i, c* {/ N0 |: s, K& f
154.         for(t=0;t<len;t++)
     3 i3 _5 @* I. x9 \
155.         {
     
156.                 temp=(num/mypow(10,len-t-1))%10;
     
157.                 if(enshow==0&&t<(len-1))
     ) H3 g" M, U$ d! ^1 W
158.                 {
     $ n0 r% Y( |- f" t
159.                         if(temp==0)
     
160.                         {
     . m# D( c1 z. C
161.                                 OLED_ShowChar(x+(size/2)*t,y,' ',size,1);
     
162.                                 continue;
     
163.                         }else enshow=1;
     
164.                           
     
165.                 }
     3 F8 x" d! u2 O8 r
166.                  OLED_ShowChar(x+(size/2)*t,y,temp+'0',size,1);
     , v) O# u5 \5 T: C
167.         }
     
168. }
     
169. //显示字符串
     9 K) l7 ]2 C% Z' r& t0 v( A: u
170. //x,y:起点坐标  
     ( c% K+ `& Y2 I% V: g
171. //size:字体大小
     , `1 Q# |8 R/ f
172. //*p:字符串起始地址
     
173. void OLED_ShowString(u8 x,u8 y,const u8 *p,u8 size)
     
174. {        
     
175.     while((*p<='~')&&(*p>=' '))//判断是不是非法字符!
     
176.     {      
     
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);         
     ! b" x- u% A& j( w
180.         x+=size/2;
     
181.         p++;
     
182.     }  
     . f% R' C& |$ E, t0 y
183.         
     
184. }        
     
185. //初始化SSD1306                                            
     ' I) }* e; u3 w
186. void OLED_Init(void)
     ( m- `" s8 _4 G$ F7 n' D
187. {                           
     
188.   GPIO_InitTypeDef  GPIO_InitStructure;
     
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时钟
       [  Y* ]0 |+ H; i$ ?
191. 
     ' V9 l7 [9 n- Y; }# X
192. //使用8080并口模式               
     ; V8 a% \  k" F% l+ g
193.         
     
194.         //GPIO初始化设置
     
195.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 ;
     
196.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
     . a. ]7 k5 h5 {: D
197.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
     7 K9 Q9 |, o( i" m, j6 y( O
198.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
     
199.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
     1 r! Y3 l* \6 O  g( B4 d$ }. s; {6 y
200.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化
     7 f2 y1 A( H1 ]0 \8 l" _
201.         
     $ m' |7 y4 T6 }$ Q* Q
202.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7 ;        
     
203.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
     4 V9 V% Y' }, L# _8 E
204. 
     ( V: e' Q6 g+ _/ l4 }" N
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);//初始化        
     - P* r; f! S% Z0 \. u
207. 
     
208.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;        
     
209.         GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化        
     ) R* K9 D' ~- ~1 i7 z* ^
210.         
     / G% R/ b- P2 `: X
211.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_5;        
     
212.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化        
     
213.         
       U. \6 q$ |( L9 ~# h# {  a
214.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;        
     * I6 v& G7 ~$ m
215.         GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化        
     3 v5 M/ N. ^# R2 Z
216. 
     7 `9 l% C/ F/ }$ r
217.         
     
218.          OLED_WR=1;
     $ i& @/ {' \+ m* ~* p
219.         OLED_RD=1;
     
220. 
     
221.         OLED_CS=1;
     
222.         OLED_RS=1;         
     / k; M8 g0 l' W$ J+ C! x; Y
223.         
       {$ ?' }6 p, t
224.         OLED_RST=0;
     
225.         delay_ms(100);
     
226.         OLED_RST=1;
     
227.                                           
     / E1 ^* t! e, g. o- L
228.         OLED_WR_Byte(0xAE,OLED_CMD); //关闭显示
     
229.         OLED_WR_Byte(0xD5,OLED_CMD); //设置时钟分频因子,震荡频率
     : e" J& ^7 r2 p& t. w3 h
230.         OLED_WR_Byte(80,OLED_CMD);   //[3:0],分频因子;[7:4],震荡频率
     $ {. n3 |1 M2 e+ r
231.         OLED_WR_Byte(0xA8,OLED_CMD); //设置驱动路数
     
232.         OLED_WR_Byte(0X3F,OLED_CMD); //默认0X3F(1/64)
     
233.         OLED_WR_Byte(0xD3,OLED_CMD); //设置显示偏移
     # g8 d4 G0 I0 U9 S
234.         OLED_WR_Byte(0X00,OLED_CMD); //默认为0
     ( @. O# p" o2 i: t6 d6 e
235. 
     7 i) j, Y& A# y3 M/ s5 B' c) K
236.         OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.
     
237.                                                                                                             
     
238.         OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置
     
239.         OLED_WR_Byte(0x14,OLED_CMD); //bit2，开启/关闭
     
240.         OLED_WR_Byte(0x20,OLED_CMD); //设置内存地址模式
     
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;
     
243.         OLED_WR_Byte(0xC0,OLED_CMD); //设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
     
244.         OLED_WR_Byte(0xDA,OLED_CMD); //设置COM硬件引脚配置
     " E7 z8 i; d. r
245.         OLED_WR_Byte(0x12,OLED_CMD); //[5:4]配置
     " _  k4 W* f- U# u/ c/ f9 P2 |, r
246.                  
     0 t  ^6 P- ?) N3 K" n
247.         OLED_WR_Byte(0x81,OLED_CMD); //对比度设置
     
248.         OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
     ! l7 f  {) `# I/ U# G9 l
249.         OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期
     
250.         OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
     
251.         OLED_WR_Byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率
     8 T7 c% W4 e9 ]( P' }  d* [
252.         OLED_WR_Byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
     3 M" ?7 p, F3 d8 e# J6 W5 `& z
253. 
     
254.         OLED_WR_Byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
       G. ?6 d, w' ?+ g. r
255.         OLED_WR_Byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示                                                               
     
256.         OLED_WR_Byte(0xAF,OLED_CMD); //开启显示         
     
257.         OLED_Clear();
     * A; `; r6 f+ ?& g- E  E
258. }  

复制代码

/ d5 B6 h5 ]/ q! V0 q. a5 Mmain.c
$ x# L- j- Z6 f8 x3 D
* d; @, [# R) H

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   - H" H+ L; M; T0 s; I6 }* r" I& ]0 y4 o
5. #include "oled.h"
   7 e5 ^7 x' r4 g: S& `: p; H+ O8 ?$ d
6. 
   
7. 
   
8. int main(void)
   
9. {
   
10.         u8 t=0;
    
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    
12.         delay_init(168);     //初始化延时函数
    
13.         uart_init(115200);        //初始化串口波特率为115200
    
14.         LED_Init();                                        //初始化LED
    6 A& X9 D0 x! {+ h# O2 q
15.          OLED_Init();                                //初始化OLED
    8 m. Z8 p) D; e2 S9 {4 F5 I5 P
16.   OLED_ShowString(0,0,"ALIENTEK",24);  
    
17.         OLED_ShowString(0,24, "0.96' OLED TEST",16);  
    
18.          OLED_ShowString(0,40,"ATOM 2014/5/4",12);  
    
19.          OLED_ShowString(0,52,"ASCII:",12);  
    & @+ }! C  {: U  l' s& b
20.          OLED_ShowString(64,52,"CODE:",12);  
    * r# m/ N! C% m( ^, y# I" d$ C/ |
21.         OLED_Refresh_Gram();//更新显示到OLED         
    + H. H" @9 o4 Y6 E
22.         t=' ';  
    
23.         while(1)
    
24.         {               
    
25.                 OLED_ShowChar(36,52,t,12,1);//显示ASCII字符        
    ! ~% s3 O" C* I3 S& T& W& V
26.                 OLED_ShowNum(94,52,t,3,12);        //显示ASCII字符的码值   
    
27.                 OLED_Refresh_Gram();        //更新显示到OLED
    4 n, N$ ~& Y6 S0 p+ c: [: W% `2 `
28.                 t++;
    + u7 W( k, L) J
29.                 if(t>'~')t=' ';  
    5 ^+ j7 X. W0 d- O7 E  `% O3 o3 w0 p
30.                 delay_ms(500);
    
31.                 LED0=!LED0;
    
32.         }
    
33. }
    8 E' t, S3 e* U
34. 
    

复制代码

, o+ _2 [! A) Z) A. C