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

LCD 都需要背光，而 OLED 不需要，因为它是自发光的。这样同样的显示，OLED 效果要来得好一些。以目前的技术，OLED 的尺寸还难以大型化，但是分辨率确可以做到很高。
8 u# A9 w: _9 K
* o  d8 c4 c3 b1 {$ V02. OLED初始化

$ I: p, `  \; G# ~

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

OLED 显示需要的相关设置步骤如下：
$ z; D' u1 E% S$ m" i' Z  _- f
; Q5 Q3 t& p9 L4 @- G% A; a: n% ]1 ）设置 STM32F4 与 与 OLED 模块相连接的 IO 。
这一步，先将我们与 OLED 模块相连的 IO 口设置为输出，具体使用哪些 IO 口，这里需要根据连接电路以及 OLED 模块所设置的通讯模式来确定。
7 J! I" i& x2 b+ x+ l3 o
; }2 q$ z  z0 P9 K2 ）初始化 OLED 模块。
8 ^+ W, N0 p$ A3 y4 z; k: A其实这里就是上面的初始化框图的内容，通过对 OLED 相关寄存器的初始化，来启动 OLED的显示。
$ n) [, c+ `& H' n
3 ）通过函数将字符和数字显示到 OLED 模块上。
这里就是通过我们设计的程序，将要显示的字符送到 OLED 模块就可以了

通过以上三步，我们就可以使用 ALIENTEK OLED 模块来显示字符和数字了。
* ?# ]4 L# P0 ?2 b! i  Q) G
9 p( Y& L+ Y5 y0 V7 S7 c) e03. 硬件设计
用到的硬件资源有：
1） 指示灯 DS0
2 a, E. k7 Q# I  l: a  \; O2 `2） OLED 模块

2 I/ e% @/ H+ \* p7 S硬件上，OLED 与探索者 STM32F4 开发板的 IO 口对应关系如下：
OLED_CS 对应 DCMI_VSYNC，即：PB7;
OLED_RS 对应 DCMI_SCL，即：PD6;
5 P1 o5 r9 e5 m+ E$ BOLED_WR 对应 DCMI_HREF，即：PA4;
: l+ r% }# m  w7 \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;
( d' a6 F% M, c( ]
04. 程序示例
2 V- w4 @6 Q2 Joled.h
2 W! T* y3 P6 H! t& `  h( U$ f
/ A7 J4 b6 k/ j/ G. y

1. #ifndef __OLED_H
   % n( B0 T$ R7 `0 x2 Y& ]
2. #define __OLED_H                                   
   $ U% r! a- X9 {$ |; N0 y
3. #include "sys.h"
   3 P/ {  j) E; u" u# G
4. #include "stdlib.h"            
   
5. 
   
6. //OLED模式设置
   
7. //0: 4线串行模式  （模块的BS1，BS2均接GND）
   
8. //1: 并行8080模式 （模块的BS1，BS2均接VCC）
   9 ?2 u0 {+ I* I
9. #define OLED_MODE         1
   5 y* q8 Z' ^! Q) z$ n- F7 x2 E
10.                                                                      
    
11. //-----------------OLED端口定义----------------                                             
    
12. #define OLED_CS         PBout(7)
    
13. #define OLED_RST  PGout(15)        
    
14. #define OLED_RS         PDout(6)
    
15. #define OLED_WR         PAout(4)                  
    
16. #define OLED_RD         PDout(7)
    
17. 
    7 J1 v* h0 ^: O+ V, {$ ?7 @
18. //使用4线串行接口时使用
    
19. #define OLED_SCLK         PCout(6)
    
20. #define OLED_SDIN         PCout(7)
    , E, _8 ?4 K  {8 p; g) R
21.                      
    
22. #define OLED_CMD          0                //写命令
    1 J% f' B( F% c8 w: k7 P9 P
23. #define OLED_DATA         1                //写数据
    
24. //OLED控制用函数
    
25. void OLED_WR_Byte(u8 dat,u8 cmd);            
    
26. void OLED_Display_On(void);
    
27. void OLED_Display_Off(void);
    5 n: [/ B4 x8 ?' i0 V* x: p
28. void OLED_Refresh_Gram(void);                  
    6 j9 l/ u+ W3 U* C, B' m
29.                                                                               
    
30. void OLED_Init(void);
    - y& Y) h; T* j" E& H9 v
31. void OLED_Clear(void);
    4 G( p& q/ o6 ^: }  R: X0 z
32. void OLED_DrawPoint(u8 x,u8 y,u8 t);
    9 S' ~, d6 }5 k5 ?
33. void OLED_Fill(u8 x1,u8 y1,u8 x2,u8 y2,u8 dot);
    5 H& A" |% b: y: v
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);         
    2 i; N- D, {1 P6 P$ `, q. U+ o
37. #endif  

复制代码

" v  u2 O1 ~" [# V" P" A% Holed.c

1. #include "oled.h"
   
2. #include "stdlib.h"
   % ?; P4 x! I2 ^. I
3. #include "oledfont.h"           
   
4. #include "delay.h"
   
5. 
     ]' b, I, h4 o1 E  J5 v  n$ \
6. //OLED的显存
   " N! K% y  c+ V. [! X- u# B
7. //存放格式如下.
   ( X/ c7 Y. \. M# M) E  m/ `
8. //[0]0 1 2 3 ... 127        
   5 V  G+ W9 L- l0 w2 V, f+ K% g
9. //[1]0 1 2 3 ... 127        
   
10. //[2]0 1 2 3 ... 127        
    5 l* O% o2 ~2 W
11. //[3]0 1 2 3 ... 127        
    
12. //[4]0 1 2 3 ... 127        
    " y# t% k% R" d
13. //[5]0 1 2 3 ... 127        
    ! V, J# |# g. P' _2 u$ c; P
14. //[6]0 1 2 3 ... 127        
    
15. //[7]0 1 2 3 ... 127                    
    
16. u8 OLED_GRAM[128][8];         
    : U4 r5 f5 w* }8 u
17. 
    
18. //更新显存到LCD                 
    8 q( F- A: x2 x8 v; G
19. void OLED_Refresh_Gram(void)
    
20. {
    $ w8 j7 o( s( g/ [7 ?! v# k
21.         u8 i,n;                    
    
22.         for(i=0;i<8;i++)  
    ( Y5 K2 ]' ?( L7 C% e
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);      //设置显示位置—列高地址   
    : M* `( U$ [4 I1 K2 k2 G) y% E
27.                 for(n=0;n<128;n++)OLED_WR_Byte(OLED_GRAM[n]<i>,OLED_DATA);
    
28.         }   
    8 F; H9 \8 _! e6 p* J$ g5 ^4 n) M2 ?
29. }
    . V! k) b* Y/ H2 C' P' N5 K
30. //8080并口
    
31. //通过拼凑的方法向OLED输出一个8位数据
    ( e) Q; U( J; s* I& Q8 A
32. //data:要输出的数据
    0 C* ~% C& D3 X/ j; X& t3 O$ c" g
33. void OLED_Data_Out(u8 data)
    8 E7 n1 D9 I, w, a1 w6 s% ^! }
34. {
    
35.         u16 dat=data&0X0F;
    6 @- H/ y2 k- V; Q* ~' Z
36.         GPIOC->ODR&=~(0XF<<6);                //清空6~9
    
37.         GPIOC->ODR|=dat<<6;                        //D[3:0]-->PC[9:6]
    7 X" O; ]$ v& f7 Q
38.         GPIO_Write(GPIOC,dat<<6);
    
39.         PCout(11)=(data>>4)&0X01;        //D4
    ) d0 M. I$ X7 S
40.         PBout(6)=(data>>5)&0X01;        //D5
    
41.         PEout(5)=(data>>6)&0X01;        //D6
      J- k  ]* \; _. G8 S5 d$ ]
42.         PEout(6)=(data>>7)&0X01;        //D7
    8 v: L9 }1 s6 n. k  l
43. }
    
44. //向SSD1306写入一个字节。
    $ b% w* `5 \* K: u
45. //dat:要写入的数据/命令
    5 b( ~; y: q- O/ f
46. //cmd:数据/命令标志 0,表示命令;1,表示数据;
    
47. void OLED_WR_Byte(u8 dat,u8 cmd)
    
48. {
    % M. K1 Z6 O: a$ N" `1 A% O! v# g
49.         OLED_Data_Out(dat);            
    
50.          OLED_RS=cmd;
    
51.         OLED_CS=0;           
    , S* m' ?3 s. S2 X+ Q
52.         OLED_WR=0;         
    $ d/ z$ I( k& Q: o7 B  j
53.         OLED_WR=1;
    
54.         OLED_CS=1;         
    
55.         OLED_RS=1;         
    
56. }                        
    ) ?& e; f. J0 C% l) m3 g+ m/ V
57.                     
    
58. //开启OLED显示   
    % t# y4 M+ D- A7 k: X
59. void OLED_Display_On(void)
    6 o3 e/ ?, z, I8 S+ [( F+ a6 b
60. {
    
61.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    4 h! F! h7 T  |* W; k  r
62.         OLED_WR_Byte(0X14,OLED_CMD);  //DCDC ON
    6 D$ N( P" Z- o' J: p+ M0 \( q* {
63.         OLED_WR_Byte(0XAF,OLED_CMD);  //DISPLAY ON
    
64. }
    5 Z6 r$ c5 S4 G0 P/ ~, w" C7 f
65. //关闭OLED显示     
    ) G. F2 l: c* c
66. void OLED_Display_Off(void)
    0 ?( @+ X8 ?' f( ^
67. {
    ) k- f" v' t- W2 j
68.         OLED_WR_Byte(0X8D,OLED_CMD);  //SET DCDC命令
    : B: x/ R+ E, G
69.         OLED_WR_Byte(0X10,OLED_CMD);  //DCDC OFF
    
70.         OLED_WR_Byte(0XAE,OLED_CMD);  //DISPLAY OFF
    
71. }                                            
    
72. //清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!         
    
73. void OLED_Clear(void)  
    . }8 M1 k# r6 X0 ~1 ]
74. {  
    ( M1 _6 H& j& I" U) T/ g
75.         u8 i,n;  
    
76.         for(i=0;i<8;i++)for(n=0;n<128;n++)OLED_GRAM[n]<i>=0X00;  
    
77.         OLED_Refresh_Gram();//更新显示
    
78. }
    
79. //画点
    $ u% ~4 |( _  e4 _. k. W' ^
80. //x:0~127
    
81. //y:0~63
    7 v3 F( S) Q' O; r
82. //t:1 填充 0,清空                                   
    
83. void OLED_DrawPoint(u8 x,u8 y,u8 t)
    - w6 V% {# t" b4 j% O
84. {
      A  d0 i4 G8 h. }/ B" P
85.         u8 pos,bx,temp=0;
    
86.         if(x>127||y>63)return;//超出范围了.
    7 G( U5 A  x. s5 ?4 J
87.         pos=7-y/8;
    
88.         bx=y%8;
    
89.         temp=1<<(7-bx);
    7 p* S) U. g- B$ [
90.         if(t)OLED_GRAM[x][pos]|=temp;
    ' T: x) i+ B" @" h( Q9 G7 a% W
91.         else OLED_GRAM[x][pos]&=~temp;            
    
92. }
    + K) k0 a# R6 S& m; i
93. //x1,y1,x2,y2 填充区域的对角坐标
    
94. //确保x1<=x2;y1<=y2 0<=x1<=127 0<=y1<=63                  
    
95. //dot:0,清空;1,填充         
    9 `+ p0 ?) i" P% `1 W. e
96. void OLED_Fill(u8 x1,u8 y1,u8 x2,u8 y2,u8 dot)  
    
97. {  
    6 p3 G* A1 d: f) {+ ?6 R
98.         u8 x,y;  
    $ [! Q# L' {3 v+ L
99.         for(x=x1;x<=x2;x++)
    5 n; R* O3 n7 Z
100.         {
     
101.                 for(y=y1;y<=y2;y++)OLED_DrawPoint(x,y,dot);
     
102.         }                                                                                                            
     ( m: {- ^2 {+ c0 U! d7 z
103.         OLED_Refresh_Gram();//更新显示
     : N5 |' n; A8 y; \" Y3 `
104. }
     
105. //在指定位置显示一个字符,包括部分字符
     4 }4 W" x" w  X/ Q& l( T3 m
106. //x:0~127
     - Y# _1 D0 k8 v1 F( p' y2 R- B6 H
107. //y:0~63
     7 i4 u, |. }/ v+ \" z9 f5 O
108. //mode:0,反白显示;1,正常显示                                 
     
109. //size:选择字体 12/16/24
     
110. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size,u8 mode)
     5 b5 h3 H7 x3 @8 ^
111. {                                 
     
112.         u8 temp,t,t1;
     
113.         u8 y0=y;
     
114.         u8 csize=(size/8+((size%8)?1:0))*(size/2);                //得到字体一个字符对应点阵集所占的字节数
     0 P/ a% u& t4 u1 e
115.         chr=chr-' ';//得到偏移后的值                 
     ! E! O  k8 t; f6 G5 k, j
116.     for(t=0;t<csize;t++)
     
117.     {   
     & e: A; b$ t) N: M( @# [3 \
118.                 if(size==12)temp=asc2_1206[chr][t];                  //调用1206字体
     
119.                 else if(size==16)temp=asc2_1608[chr][t];        //调用1608字体
     , W: B" F9 Z+ x6 a. V6 z' e+ ^
120.                 else if(size==24)temp=asc2_2412[chr][t];        //调用2412字体
     ! _" @& ]) y! |
121.                 else return;                                                                //没有的字库
     " ]- U7 g( b* c9 a
122.         for(t1=0;t1<8;t1++)
     
123.                 {
     ; I3 b8 U+ o% P+ K/ g
124.                         if(temp&0x80)OLED_DrawPoint(x,y,mode);
     
125.                         else OLED_DrawPoint(x,y,!mode);
     ) A' v( O: R: p/ Q8 N& _  C* J
126.                         temp<<=1;
     * j  H" z' n) J/ j
127.                         y++;
     
128.                         if((y-y0)==size)
     8 x0 M# g, R% O) q! D' k
129.                         {
     
130.                                 y=y0;
     
131.                                 x++;
     & f& e6 m( G) ^0 H# j" G# ~- N0 C" _+ T
132.                                 break;
     . q. s' A$ |2 J8 o, G/ }
133.                         }
     
134.                 }           
     
135.     }         
     + O8 Q4 N% A1 E
136. }
     
137. //m^n函数
     + C& u& k. l) g
138. u32 mypow(u8 m,u8 n)
     
139. {
     / d1 c# t8 ?4 x, |: ]
140.         u32 result=1;         
     # g* V% u; b3 E- @5 c, z. r) Z+ K. P: J
141.         while(n--)result*=m;   
     9 G3 j4 _8 w4 I* H- x2 N0 `
142.         return result;
     2 b, C9 n1 H& ?9 f9 \* u
143. }                                 
     # _- k" M/ Z, ]
144. //显示2个数字
     ( a" |6 E! G7 ?( q4 U
145. //x,y :起点坐标         
     
146. //len :数字的位数
     
147. //size:字体大小
     
148. //mode:模式        0,填充模式;1,叠加模式
     ; X7 K0 ]# }6 ?& q" u- m* O
149. //num:数值(0~4294967295);                           
     
150. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size)
     
151. {                 
     
152.         u8 t,temp;
     7 }- e! Z! t( w1 Y
153.         u8 enshow=0;                                                   
     # h5 L. v7 l. J0 N
154.         for(t=0;t<len;t++)
     
155.         {
     
156.                 temp=(num/mypow(10,len-t-1))%10;
     ! T& }* t: J! f! T
157.                 if(enshow==0&&t<(len-1))
     
158.                 {
     / H5 i* C4 Z7 A0 c' }5 L
159.                         if(temp==0)
     
160.                         {
     ( D. S3 R- U; ^
161.                                 OLED_ShowChar(x+(size/2)*t,y,' ',size,1);
     0 [8 i+ H9 F# n
162.                                 continue;
     ( `) q5 o0 t4 g. k
163.                         }else enshow=1;
     4 s3 w& s& d5 z  Q% e- U; p
164.                           
     
165.                 }
     
166.                  OLED_ShowChar(x+(size/2)*t,y,temp+'0',size,1);
     & ~8 S/ |0 ~9 r1 [' O. N
167.         }
     
168. }
     " r8 D; V/ I1 F8 n4 U& c  c, w8 E
169. //显示字符串
     & x4 u  G. z# n, F3 N& a
170. //x,y:起点坐标  
     5 Z1 V, z9 S! D+ ^
171. //size:字体大小
     8 @7 O# q( b" G" ^* g4 r
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);         
     
180.         x+=size/2;
     # ]7 D9 l) s! K7 W! z! X
181.         p++;
     
182.     }  
     
183.         
     0 R; V( W5 t  l' S0 ~# Q+ |, S1 Y: g
184. }        
     
185. //初始化SSD1306                                            
     6 V/ J9 N* @7 U$ T
186. void OLED_Init(void)
     & t/ u/ w: o. c; k$ C7 X
187. {                           
     
188.   GPIO_InitTypeDef  GPIO_InitStructure;
     2 O$ C) e+ H1 U  Q6 `
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时钟
     
191. 
     ) }% z( U" y( i3 O3 u
192. //使用8080并口模式               
     2 b. U8 Q' `# D6 @3 m
193.         
     ; M0 d, ^" M; c5 F
194.         //GPIO初始化设置
     
195.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 ;
     2 v# s) G$ o* I6 \8 B
196.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
     
197.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
     
198.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
     . [# V" H  i0 `. A! ~: O3 o% `
199.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
     
200.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化
     1 o5 z9 j' M4 S+ d; o/ D6 u
201.         
     8 }7 l; D. x5 P# S
202.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7 ;        
     + T8 T1 F  _6 H1 A  Y$ h
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;        
       r; b% X& t; v5 n0 Q8 r' F
206.         GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化        
     7 `( U/ Z- S1 @1 E
207. 
     
208.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;        
     ( h# N/ v6 W4 j! |' r( d5 h
209.         GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化        
     
210.         
     , x- X7 T1 {% i  v7 e" }: ]4 W
211.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_5;        
     * r$ F4 F; a* G; W! R' ?0 f- G
212.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化        
       g6 L3 t3 b1 S' c) G
213.         
     
214.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;        
     & T2 C/ L) R7 [" \9 i" B
215.         GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化        
     
216. 
     
217.         
     3 n  E- p: S3 x; U, g: B. Y2 d1 K
218.          OLED_WR=1;
     * S; v. P$ m( G8 d# F* k
219.         OLED_RD=1;
     
220. 
     % [. n; c' R' U) F* [
221.         OLED_CS=1;
     + I. A, l' D$ l. c9 E" F  I+ _
222.         OLED_RS=1;         
     % M4 J$ P/ n( Z) ]. }- x
223.         
     . u9 R) x* ~* X* ]7 {; C5 f
224.         OLED_RST=0;
     % m$ E, W! d. z8 [% i
225.         delay_ms(100);
     , _7 q0 ^  E6 _$ d2 w# Q6 c
226.         OLED_RST=1;
     " u+ Q; N  g! J  I
227.                                           
     
228.         OLED_WR_Byte(0xAE,OLED_CMD); //关闭显示
     
229.         OLED_WR_Byte(0xD5,OLED_CMD); //设置时钟分频因子,震荡频率
     , j8 ^$ `7 [6 B+ a0 p* g% z
230.         OLED_WR_Byte(80,OLED_CMD);   //[3:0],分频因子;[7:4],震荡频率
     " G) A4 m6 @  i* `
231.         OLED_WR_Byte(0xA8,OLED_CMD); //设置驱动路数
     
232.         OLED_WR_Byte(0X3F,OLED_CMD); //默认0X3F(1/64)
     0 P8 j' i# c" f# @& m. y
233.         OLED_WR_Byte(0xD3,OLED_CMD); //设置显示偏移
     & D& }: N( Z' i( }2 n& S- T) W
234.         OLED_WR_Byte(0X00,OLED_CMD); //默认为0
     
235. 
     7 f! V) P' M; z; ?$ }' e; l
236.         OLED_WR_Byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.
     ; ]) i6 ~6 V2 u9 q0 d
237.                                                                                                             
     7 |, J( ?- q% h; y# _! ?
238.         OLED_WR_Byte(0x8D,OLED_CMD); //电荷泵设置
     
239.         OLED_WR_Byte(0x14,OLED_CMD); //bit2，开启/关闭
     * a+ `1 q* e3 y1 @
240.         OLED_WR_Byte(0x20,OLED_CMD); //设置内存地址模式
     , r2 r3 x8 r$ X- h! w' m- x! J9 ~% y
241.         OLED_WR_Byte(0x02,OLED_CMD); //[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
     9 z- v4 a( j* H
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硬件引脚配置
     
245.         OLED_WR_Byte(0x12,OLED_CMD); //[5:4]配置
     
246.                  
     ( q6 p) w' [6 D4 E& P5 G9 a
247.         OLED_WR_Byte(0x81,OLED_CMD); //对比度设置
     2 q1 ^& S5 ^' K0 t1 v5 p
248.         OLED_WR_Byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
     3 f  ~1 U# [$ X) a2 |/ ]
249.         OLED_WR_Byte(0xD9,OLED_CMD); //设置预充电周期
     
250.         OLED_WR_Byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
     % {- ]! Z5 {! w/ m' ^, `6 ~
251.         OLED_WR_Byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率
     $ q  K; u  {, F8 H
252.         OLED_WR_Byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
     
253. 
       r$ K. W4 a4 h2 u/ }' h
254.         OLED_WR_Byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
     ' ?4 \( U7 J( o; {% v
255.         OLED_WR_Byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示                                                               
     ) u- d2 B+ q; K8 P! P
256.         OLED_WR_Byte(0xAF,OLED_CMD); //开启显示         
     - ?' C8 o6 z8 t- q, s" G0 Y! K& f
257.         OLED_Clear();
     / g) e7 `' K5 a2 M6 w. o6 n
258. }  </i></i>

复制代码

main.c

1. #include "sys.h"
   
2. #include "delay.h"
   ( m5 g9 u  ]9 _5 k
3. #include "usart.h"
   
4. #include "led.h"
   4 B* m9 b9 K: e4 I
5. #include "oled.h"
   ( {, m1 g* Y+ a! s9 e. f2 j
6. 
   8 E  Z  @9 m% S$ H& r1 V) q6 s
7. 
   ' {+ \9 B' n% N5 J( ^
8. int main(void)
   - ^7 T7 f5 B2 H8 N$ D
9. {
   
10.         u8 t=0;
    
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    " D- U1 z& w1 ~" T0 n
12.         delay_init(168);     //初始化延时函数
    / F! M/ l3 {( {/ e
13.         uart_init(115200);        //初始化串口波特率为115200
    
14.         LED_Init();                                        //初始化LED
    
15.          OLED_Init();                                //初始化OLED
    * |8 S0 r1 u) S  ^1 \* V
16.   OLED_ShowString(0,0,"ALIENTEK",24);  
    ' `( c; F5 ~; M8 c- f
17.         OLED_ShowString(0,24, "0.96' OLED TEST",16);  
    ! @* ?3 B9 T, y8 s& L# A/ O  E; B
18.          OLED_ShowString(0,40,"ATOM 2014/5/4",12);  
    
19.          OLED_ShowString(0,52,"ASCII:",12);  
    
20.          OLED_ShowString(64,52,"CODE:",12);  
    ! Z3 V* ?9 n6 ]9 D" H  u2 b
21.         OLED_Refresh_Gram();//更新显示到OLED         
    
22.         t=' ';  
    
23.         while(1)
    
24.         {               
    3 O* c& @* B4 w; K- W5 j3 H/ V
25.                 OLED_ShowChar(36,52,t,12,1);//显示ASCII字符        
    
26.                 OLED_ShowNum(94,52,t,3,12);        //显示ASCII字符的码值   
    & _! G  u0 W5 {; j, ^7 @
27.                 OLED_Refresh_Gram();        //更新显示到OLED
    9 F  p; v9 t: f0 o
28.                 t++;
    
29.                 if(t>'~')t=' ';  
      V' O: ?& z4 i& [" v
30.                 delay_ms(500);
    
31.                 LED0=!LED0;
    
32.         }
    
33. }
    
34. 
    9 W9 y6 O% ~3 ~, Z) v1 r

复制代码

3 K% x6 U$ P; s% o! r