OLED 显示实验
5 y7 M7 Q* |4 @+ ]& }2 n前面所有的介绍都没有涉及到液晶显示，从这一节开始，我们将陆续向大家介绍几款液晶
显示模块。本节我们将向大家介绍相对简单的 OLED。本节分为如下几个部分：
2 q/ A  o, l2 H  T1 OLED 简介
/ K; I1 @9 N% D, G3 N8 {# zOLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（Organic
Electroluminesence  Display，  OELD）。OLED 由于同时具备自发光，不需背光源、对比度高、
厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优
* d1 Z! J1 a! b  g4 {" y* r异之特性，被认为是下一代的平面显示器新兴应用技术。
LCD 都需要背光，而 OLED 不需要，因为它是自发光的。这样同样的显示，OLED 效果要
% t8 S% X% i! P* t来得好一些。OLED 的尺寸难以大型化，但是分辨率确可以做到很高。这一节，我们使用的是
  @3 i% d; H: X2 B- m- H2 G2 T1 TALINETEK 的 OLED 显示模块，该模块有以下特点：
& @) O' N3 V2 M3 H& e1）模块有单色和双色两种可选，单色为纯白色，而双色则为黄蓝双色。
3 m  D: U4 c' L; `# I: A0 w: D: \2）尺寸小，显示尺寸为 0.96 寸，而模块的尺寸仅为 27mm*26mm 大小。
8 M' G5 b; f" Z' y; `3）高分辨率，该模块的分辨率为 128*64。
7 `4 f; c: c: _% p' c+ M4）多种接口方式，该模块提供了总共 5 种接口包括：6800、8080 两种并行接口方式、3
+ ~: R2 k0 U9 O) T% F线或 4 线的穿行 SPI 接口方式，、IIC 接口方式（只需要 2 根线就可以控制 OLED 了！）。
5）不需要高压，直接接 3.3V 就可以工作了。
1 z! n; E+ ]  p* {这里要提醒大家的是，该模块不和 5.0V 接口兼容，所以请大家在使用的时候一定要小心，
别接到 5V 的系统上去，否则可能烧坏模块。以上 5 种模式通过模块的 BS0~2 设置，BS0~2 的
设置与模块接口模式的关系如下表：
6 I& j2 a# I- |7 i2 S' ~& J上表中：“1”代表接 VCC，而“0”代表接 GND。该模块的外观图如下：
- H6 h" D# @$ M" k; b: I
该模块采用 8*2 的 2.54 排针与外部连接，其引线图如上图所示，总共有 16 个管脚，在 16
条线中，我们只用了 15 条，有一个是悬空的。15 条线中，电源和地线占了 2 条，还剩下 13 条
信号线。在不同模式下，我们需要的信号线数量是不同的，在 8080 模式下，需要全部 13 条，
而在 IIC 模式下，仅需要 2 条线就够了！这其中有一条是共同的，那就是复位线 RST（RES），
$ g  d7 c8 _* `该线我们可以直接接在 MCU 的复位上（要先确认复位方式一样），这样可以省掉一条线。
ALIENTEK  OLED 模块的控制器是 SSD1306，这一节，我们将学习如何通过 STM32 来控
' n8 e) c  G+ r8 L3 R3 {制该模块显示字符和数字，本节实例将可以支持 2 种方式与 OLED 模块连接，一种是 8080 的
并口方式，另外一种是 4 线 SPI 方式。
; L* }7 r( R% D首先我们介绍一下模块的 8080 并行接口，8080 并行接口的发明者是 INTEL，该总线也被
广泛应用于各类液晶显示器，ALIENTEK OLED 模块也提供了这种接口，使得 MCU 可以快速
: H/ [$ k7 a+ u) Q; X的访问 OLED。ALIENTEK OLED 模块的 8080 接口方式需要如下一些信号线：
CS：OLED 片选信号。
0 a) F: v0 e% B2 P+ WWR：向 OLED 写入数据。
RD：从 OLED 读取数据。
7 \1 ~: R4 P4 F: i+ W$ nD[7:0]：8 位双向数据线。
) y. B# t/ V7 C5 _/ d' CRST(RES)：硬复位 OLED。
! D) m9 M! m1 _& IDC：命令/数据标志（0，读写命令；1，读写数据）。
模块的 8080 并口读/写的过程为：先根据要写入/读取的数据的类型，设置 DC 为高（数据）
. C# o$ b5 M8 k( k$ ?/低（命令），然后拉低片选，选中 SSD1306，接着我们根据是读数据，还是要写数据置 RD/WR
$ k: v* ?  n$ @为低，然后：
在 RD 的上升沿，  使数据锁存到数据线（D[7:0]）上；
在 WR 的上升沿，使数据写入到 SSD1306 里面；
: `; R$ t9 ?4 N8 uSSD1306 的 8080 并口写时序图如下：
6 H+ W" r) S8 l9 l: I* V: j- q
在 8080 方式下读数据操作的时候，我们有时候（例如读显存的时候）需要一个假读命
; N8 ]9 e* c) A1 R5 d( _& W( v! C（Dummy Read），以使得微控制器的操作频率和显存的操作频率相匹配。在读取真正的数据之
& j9 h; I- [& x! {3 W; o( t6 T, r前，由一个的假读的过程。这里的假读，其实就是第一个读到的字节丢弃不要，从第二个开始，
才是我们真正要读的数据。
6 B8 y3 z% F0 H8 A一个典型的读显存的时序图，如下图所示：
1 N5 q2 B6 s! k
可以看到，在发送了列地址之后，开始读数据，第一个是 Dummy  Read，也就是假读，我
3 e, ?- i1 j5 P1 s; o们从第二个开始，才算是真正有效的数据。
5 ?- I* j1 b9 p: u! y并行接口模式就介绍到这里，我们接下来介绍一下 4 线串行（SPI）方式，4 先串口模式使
* K, Y9 o5 t' ]; N2 E! ~用的信号线有如下几条：
CS：OLED 片选信号。
RST(RES)：硬复位 OLED。
) {9 o* |1 q) P' \; qDC：命令/数据标志（0，读写命令；1，读写数据）。
SCLK：串行时钟线。在 4 线串行模式下，D0 信号线作为串行时钟线 SCLK。
SDIN：串行数据线。在 4 线串行模式下，D1 信号线作为串行数据线 SDIN。
模块的 D2 需要悬空，其他引脚可以接到 GND。在 4 线串行模式下，只能往模块写数据而
不能读数据。
2 Z$ @3 Q& s( f" O+ I4 b8 O在 4 线 SPI 模式下，每个数据长度均为 8 位，在 SCLK 的上升沿，数据从 SDIN 移入到
SSD1306，并且是高位在前的。DC 线还是用作命令/数据的标志线。在 4 线 SPI 模式下，写操
作的时序如下：
7 P' @6 {3 S. A9 D) }+ W4 线串行模式就为大家介绍到这里。其他还有几种模式，在 SSD1306 的数据手册上都有详
细的介绍，如果要使用这些方式，请大家参考该手册。
4 C( J( M" L' b8 X$ b1 Y接下来，我们介绍一下模块的显存，SSD1306 的显存总共为 128*64bit 大小，SSD1306 将
这些显存分为了 8 页，其对应关系如下：
可以看出，SSD1306 的每页包含了 128 个字节，总共 8 页，这样刚好是 128*64 的点阵大
  Q, o  E0 [' z* i8 Y小。因为每次写入都是按字节写入的，这就存在一个问题，如果我们使用只写方式操作模块，
那么，每次要写 8 个点，这样，我们在画点的时候，就必须把要设置的点所在的字节的每个位
! T, y4 p- X- e都搞清楚当前的状态（0/1？），否则写入的数据就会覆盖掉之前的状态，结果就是有些不需要
显示的点，显示出来了，或者该显示的没有显示了。这个问题在能读的模式下，我们可以先读
出来要写入的那个字节，得到当前状况，在修改了要改写的位之后再写进 GRAM，这样就不会
9 i  W, q5 t# p' s$ }5 @影响到之前的状况了。但是这样需要能读 GRAM，对于 3 线或 4 线 SPI 模式，模块是不支持读
+ a# u1 T) x* @# i& v$ ^* Q的，而且读->改->写的方式速度也比较慢。
6 U7 e; |+ y  r) k0 Q$ o, d8 `所以我们采用的办法是在 STM32 的内部建立一个 OLED 的 GRAM （共 128 个字节），在每
次修改的时候，只是修改 STM32 上的 GRAM （实际上就是 SRAM），在修改完了之后，一次性
+ N3 s0 _) f$ F1 |0 K5 S; Z把 STM32 上的 GRAM 写入到 OLED 的 GRAM。当然这个方法也有坏处，就是对于那些 SRAM
很小的单片机（比如 51 系列）就比较麻烦了。
SSD1306 的命令比较多，这里我们仅介绍几个比较常用的命令，这些命令如下表：

" l6 `+ ~, |1 m0 ^  E' C5 w6 E第一个命令为 0X81，用于设置对比度的，这个命令包含了两个字节，第一个 0X81 为命令，
随后发送的一个字节为要设置的对比度的值。这个值设置得越大屏幕就越亮。
第二个命令为 0XAE/0XAF。0XAE 为关闭显示命令；0XAF 为开启显示命令。
5 `8 [7 W* g/ Z, p第三个命令为 0X8D，该指令也包含 2 个字节，第一个为命令字，第二个为设置值，第二
个字节的 BIT2 表示电荷泵的开关状态，该位为 1，则开启电荷泵，为 0 则关闭。在模块初始化
; ^; B* X3 C% e5 n的时候，这个必须要开启，否则是看不到屏幕显示的。
  ~& N! \) Z) K第四个命令为 0XB0~B7，该命令用于设置页地址，其低三位的值对应着 GRAM 的页地址。
- h$ U5 Y- G) u# Q第五个指令为 0X00~0X0F，该指令用于设置显示时的起始列地址低四位。
+ ^9 i. _: T+ [0 }! p第六个指令为 0X10~0X1F，该指令用于设置显示时的起始列地址高四位。
其他命令，我们就不在这里一一介绍了，大家可以参考 SSD1306  datasheet 的第 28 页。从
) Y. W% ^# ?' j! G) W这页开始，对 SSD1306 的指令有详细的介绍。OLED 的介绍就到此为止，我们重点向大家介绍了 ALIENTEK OLED 模块的相关知识，接
& Y/ t$ K; o" ?$ a下来我们将使用这个模块来显示字符和数字。通过以上介绍，我们可以得出 OLED 显示需要的
; `7 P8 p. w* Z7 r相关设置步骤如下：
1）设置 STM32 与 OLED 模块相连接的 IO。
这一步，先将我们与 OLED 模块相连的 IO 口设置为输出，具体使用哪些 IO 口，这里需要根据
连接电路以及 OLED 模块所设置的通讯模式来确定。这些将在硬件设计部分向大家介绍。
2）初始化 OLED 模块。
其实这里就是上面的初始化框图的内容，通过对 OLED 相关寄存器的初始化，来启动 OLED 的
显示。为后续显示字符和数字做准备。
3）通过函数将字符和数字显示到 OLED 模块上。
这里就是通过我们设计的程序，将要显示的字符送到 OLED 模块就可以了，这些函数将在软件
设计部分向大家介绍。
通过以上三步，我们就可以使用 ALIENTEK OLED 模块来显示字符和数字了，在后面我们还将
会给大家介绍显示汉字的方法。这一部分就先介绍到这里。
3 g  ]4 P( P, x# D! N2 ?7 w
3  软件设计
" x9 {+ R8 w( C# R' P软件设计我们依旧在之前的工程上面增加，首先在 HARDWARE 文件夹下新建一个 OLED
的文件夹。然后打开 USER 文件夹下的工程，新建一个 oled.c 的文件和 oled.h 的头文件，保存
; q- U9 [! [4 F5 b) C# B在 OLED 文件夹下，并将 OLED 文件夹加入头文件包含路径。
' e/ J/ j. G* h) t/ v, z- o打开 oled.c，输入如下代码：
, r! s3 i* X1 \" ]% A/ f! E# U#include "oled.h"
: U! O+ q. E7 u) r) x#include "stdlib.h"
5 t% l8 j; r+ r+ a* ~#include "font.h"      
#include "delay.h"
//OLED 的显存
' @8 O* @- N) t. p6 l//存放格式如下.
7 y; Z) w$ _8 K4 |! K//[0]0 1 2 3 ... 127
//[1]0 1 2 3 ... 127
//[2]0 1 2 3 ... 127
//[3]0 1 2 3 ... 127
+ X# k# P7 [+ ]0 l8 O5 d1 ]//[4]0 1 2 3 ... 127
1 M/ D+ h# P" b9 f! Z8 e//[5]0 1 2 3 ... 127
2 @# G1 w, x" b0 X5 k//[6]0 1 2 3 ... 127
) ]' ~3 H* N6 s//[7]0 1 2 3 ... 127      
4 y) U: e% q& V/ y6 |' H- uu8 OLED_GRAM[128][8];   
//更新显存到 LCD     
0 S* ^, C3 t) h6 q7 Y6 R  c; g' nvoid OLED_Refresh_Gram(void)
{
u8 i，n;   
for(i=0;i<8;i++)  
{  
" }" h: f/ D( Z5 W. }  f. K0 xOLED_WR_Byte (0xb0+i，OLED_CMD);     //设置页地址（0~7）
OLED_WR_Byte (0x00，OLED_CMD);       //设置显示位置—列低地址   
; E1 b5 \' x8 t4 D6 gOLED_WR_Byte (0x10，OLED_CMD);       //设置显示位置—列高地址
for(n=0;n<128;n++)OLED_WR_Byte(OLED_GRAM[n]，OLED_DATA);
8 p* C! e, v) s) y}   
# Z' A9 m, Z/ U$ T/ W: A}
#if OLED_MODE==1
//向 SSD1306 写入一个字节。
//dat:要写入的数据/命令
//cmd:数据/命令标志  0，表示命令;1，表示数据;
void OLED_WR_Byte(u8 dat，u8 cmd)
% E( p" E8 N/ S' R! @{
% a& F8 C  F- I; z  |6 b7 |) L" j5 IDATAOUT(dat);
1 v* U1 i0 j" ^; }OLED_RS=cmd;
  A4 R: A7 `7 Y* `; WOLED_CS=0;
OLED_WR=0; OLED_WR=1;  
OLED_CS=1; OLED_RS=1;   
}         
#else
; f2 ^9 f3 G1 c: z, I2 o  }( N//向 SSD1306 写入一个字节。
//dat:要写入的数据/命令
//cmd:数据/命令标志  0，表示命令;1，表示数据;
void OLED_WR_Byte(u8 dat，u8 cmd)
{
  W/ ^5 Q! Z3 z- y5 s- du8 i;     
5 Q: `9 I$ P2 VOLED_RS=cmd; //写命令
OLED_CS=0;  
for(i=0;i<8;i++)
& X& [/ ~/ E! _6 `{   
, w: @4 m! u' N0 |" n( {' sOLED_SCLK=0;
if(dat&0x80)OLED_SDIN=1;
else OLED_SDIN=0;
OLED_SCLK=1;
) ~) Z: E0 W. ]( _  ~5 adat<<=1;   
9 F' V0 f  \3 Q" u! }0 ?- V}      
  s% p2 Q8 O- U) G* qOLED_CS=1; OLED_RS=1;      
}
#endif   
4 B/ b' k- G0 ^% C# \8 l//开启 OLED 显示
void OLED_Display_On(void)
{
OLED_WR_Byte(0X8D，OLED_CMD);   //SET DCDC 命令
! o; ]; o5 \) e8 S- Q6 s/ r) e3 I3 cOLED_WR_Byte(0X14，OLED_CMD);   //DCDC ON
' `4 K: ?) J. T9 oOLED_WR_Byte(0XAF，OLED_CMD);   //DISPLAY ON
}
1 J  H6 C7 f" C- ]1 ^! W$ T  u* w//关闭 OLED 显示   
void OLED_Display_Off(void)
{
OLED_WR_Byte(0X8D，OLED_CMD);   //SET DCDC 命令
$ I" m6 K% b) R! R) K. u, \! F1 ~OLED_WR_Byte(0X10，OLED_CMD);   //DCDC OFF
( V+ E4 R$ g! d6 {" b" zOLED_WR_Byte(0XAE，OLED_CMD);   //DISPLAY OFF
9 A7 G7 z; F/ m* p8 G}            
+ e, u1 D  R+ z/ t1 l//清屏函数，清完屏，整个屏幕是黑色的!和没点亮一样!!!   
void OLED_Clear(void)  
{  
u8 i，n;  
for(i=0;i<8;i++)for(n=0;n<128;n++)OLED_GRAM[n]=0X00;  
4 `; U+ G% G  k% ?; i+ ]+ B/ cOLED_Refresh_Gram();//更新显示
" k, |4 d  z& H  g, ]}
//画点
/ _1 F" U! J% F: ~3 [//x:0~127
//y:0~63
% p6 I# |% C, i//t:1  填充  0，清空         
void OLED_DrawPoint(u8 x，u8 y，u8 t)
{
  M' Q. g  s& @# o6 b" e) Mu8 pos，bx，temp=0;
6 _* Y+ v6 q# O7 c( Oif(x>127||y>63)return;//超出范围了.
pos=7-y/8;
6 _3 b2 L, q* ubx=y%8;
( G5 ^* T8 C  J) T% S5 ]) E' mtemp=1<<(7-bx);
0 h9 A- U4 j% M1 L( V; O, iif(t)OLED_GRAM[x][pos]|=temp;
else OLED_GRAM[x][pos]&=~temp;   
}
4 l6 v9 _, P" s! H; q1 q7 G//x1，y1，x2，y2  填充区域的对角坐标
4 {% O8 m$ X7 d8 n2 Y//确保 x1<=x2;y1<=y2 0<=x1<=127 0<=y1<=63      
! h+ ^4 n7 j  H6 }5 q$ s1 Q//dot:0，清空;1，填充   
void OLED_Fill(u8 x1，u8 y1，u8 x2，u8 y2，u8 dot)  
) F: p6 }+ F; [{  
( |. E) _* x" v3 h# r+ U2 ?1 tu8 x，y;  
for(x=x1;x<=x2;x++)
{
+ b1 Z( H" _( m  G2 Xfor(y=y1;y<=y2;y++)OLED_DrawPoint(x，y，dot);
}                        
OLED_Refresh_Gram();//更新显示
6 |% f; F( p4 k6 u}
//在指定位置显示一个字符，包括部分字符
: x' K# D) r) o) M2 T# h' K- L//x:0~127
7 z7 V) Z7 f0 a1 T# l: V//y:0~63
//mode:0，反白显示;1，正常显示         
//size:选择字体  16/12
+ F; L6 k+ F$ w/ o% _( o4 Svoid OLED_ShowChar(u8 x，u8 y，u8 chr，u8 size，u8 mode)
{            
u8 temp，t，t1;
. i# O& H) X! A: R* nu8 y0=y;
chr=chr-' ';//得到偏移后的值      
% j5 N, `; Q2 R. T; U. I3 wfor(t=0;t<size;t++)
{   
if(size==12)temp=asc2_1206[chr][t];   //调用 1206 字体
else temp=asc2_1608[chr][t];      //调用 1608 字体                        
for(t1=0;t1<8;t1++)
6 Q8 B( U( N5 w  {{
if(temp&0x80)OLED_DrawPoint(x，y，mode);
( y. u: ]& j9 j7 qelse OLED_DrawPoint(x，y，!mode);
temp<<=1;
! h% ?) R6 P4 j8 My++;
( X! Y1 G" c% y! j  Hif((y-y0)==size)
; T5 o7 P2 d) d( w5 T{
- T. o! e, R+ R% ?' L! \8 Q9 f1 M6 Z" Ty=y0; x++;
break;
}
: c+ ~! e% e9 H# ~' I}   
}         
}
9 _6 a  H% a3 E; a6 s4 n( P//m^n 函数
u32 mypow(u8 m，u8 n)
{
u32 result=1;
while(n--)result*=m;   
" A) g: a. |: Y+ C2 H* Preturn result;
7 L' U3 f- C- w3 L9 R}         
//显示 2 个数字
//x，y :起点坐标   
//len :数字的位数
//size:字体大小
6 S' L. o) w( \: {8 H2 |- @4 u//mode:模式  0，填充模式;1，叠加模式
/ b; V" C0 o; Z% g- U6 Q: W//num:数值(0~4294967295);         
void OLED_ShowNum(u8 x，u8 y，u32 num，u8 len，u8 size)
; }" y/ F7 h6 S4 _* O{         
u8 t，temp;
! e* \( z9 w; [, G% L. d* ru8 enshow=0;           
for(t=0;t<len;t++)
1 y9 J+ `1 i( c' p% w9 M( {& Q{
temp=(num/mypow(10，len-t-1))%10;
: J/ R7 M8 `! g( O5 a: x2 R) kif(enshow==0&&t<(len-1))
{
if(temp==0)
/ D  q+ W5 z! z8 S{
  Q' d0 d, I- E" M9 uOLED_ShowChar(x+(size/2)*t，y，' '，size，1);
: _( \8 y$ ?! O3 U. `5 A& R' icontinue;
}else enshow=1;
}
3 n5 l/ G3 O5 h6 W. P8 QOLED_ShowChar(x+(size/2)*t，y，temp+'0'，size，1);
" ^9 X" f6 @& F$ o' \. b}
}   
//显示字符串
//x，y:起点坐标
2 F  f/ x. F( A( O+ L5 a7 ^//*p:字符串起始地址
& N: Q% `/ P  p) Y/ o, _, M//用 16 字体
void OLED_ShowString(u8 x，u8 y，const u8 *p)
( ^) l9 W& B4 w1 J/ J0 v- @{
! m1 |6 j7 [" u  S1 C' _#define MAX_CHAR_POSX 122
#define MAX_CHAR_POSY 58         
while(*p!='\0')
{      
7 L5 j) Y; d+ }" ]if(x>MAX_CHAR_POSX){x=0;y+=16;}
if(y>MAX_CHAR_POSY){y=x=0;OLED_Clear();}
OLED_ShowChar(x，y，*p，16，1);
; d+ k* c  k" Y# Sx+=8;
p++;
}  
}   
1 _  o0 q* J6 |( ?/ z# K& i//初始化 SSD1303           
void OLED_Init(void)
4 M! _1 y0 K+ R* g: f0 q0 g* h5 C{                             
RCC->APB2ENR|=1<<3;     //使能 PORTB 时钟
RCC->APB2ENR|=1<<4;     //使能 PORTC 时钟     
7 {% |2 c' ~; m$ C- R#if OLED_MODE==1         
# ]6 T4 Z# L6 |2 BRCC->APB2ENR|=1<<0;     //开启辅助时钟
0 h- h$ Z. z2 ^! V% o' A) c: E% DAFIO->MAPR=0X04000000; //关闭 JTAG
. |) W5 v" G7 l, e7 pGPIOB->CRL=0X33333333;
GPIOB->ODR|=0XFFFF;
GPIOC->CRH&=0XFFFFFF00;
6 p. K$ R4 a% G. bGPIOC->CRL&=0X00FFFFFF;
GPIOC->CRH|=0X00000033;
3 @" ^( O9 g# U- i9 Y/ `% IGPIOC->CRL|=0X33000000;
GPIOC->ODR|=0X03C0;
#else
/ i8 ]& D- R: K* a% cGPIOB->CRL&=0XFFFFFF00;
GPIOB->CRL|=0XF0000033;
GPIOB->ODR|=0X03;
! _6 y7 g- I2 P. }7 M& K# J+ |3 z4 AGPIOC->CRH&=0XFFFFFF00;
GPIOC->CRH|=0X00000033;
GPIOC->ODR|=3<<8;
" y8 j4 G1 X; V1 R#endif         
//OLED_RST=0; delay_ms(100); OLED_RST=1;
OLED_WR_Byte(0xAE，OLED_CMD); //关闭显示
OLED_WR_Byte(0xD5，OLED_CMD); //设置时钟分频因子，震荡频率
OLED_WR_Byte(80，OLED_CMD);    //[3:0]，分频因子;[7:4]，震荡频率
OLED_WR_Byte(0xA8，OLED_CMD); //设置驱动路数
3 m! `* V# O8 ZOLED_WR_Byte(0X3F，OLED_CMD); //默认 0X3F(1/64)
2 y2 B5 K. R& {" \: TOLED_WR_Byte(0xD3，OLED_CMD); //设置显示偏移
. D$ Q' V0 [3 y- U$ _% P' I+ f- BOLED_WR_Byte(0X00，OLED_CMD); //默认为 0
OLED_WR_Byte(0x40，OLED_CMD); //设置显示开始行  [5:0]，行数.
OLED_WR_Byte(0x8D，OLED_CMD); //电荷泵设置
* o* _. A+ d, q* K: COLED_WR_Byte(0x14，OLED_CMD); //bit2，开启/关闭
OLED_WR_Byte(0x20，OLED_CMD); //设置内存地址模式
OLED_WR_Byte(0x02，OLED_CMD);
, N3 V+ P* _& j" |$ c! n" k//[1:0]，00，列地址模式;01，行地址模式;10，页地址模式;默认 10;
  W% r- J. I0 rOLED_WR_Byte(0xA1，OLED_CMD); //段重定义设置，bit0:0，0->0;1，0->127;
( z8 P: L4 @$ A5 Y" T, i$ |OLED_WR_Byte(0xC0，OLED_CMD);
8 d" L3 _0 B6 n( I1 G//设置 COM 扫描方向;bit3:0，普通模式;1，重定义模式  COM[N-1]->COM0;N:驱动路数
OLED_WR_Byte(0xDA，OLED_CMD); //设置 COM 硬件引脚配置
+ f: |% \; c7 |5 M4 T+ M7 H6 S7 \OLED_WR_Byte(0x12，OLED_CMD); //[5:4]配置
OLED_WR_Byte(0x81，OLED_CMD); //对比度设置
+ m* A! [- y9 LOLED_WR_Byte(0xEF，OLED_CMD); //1~255;默认 0X7F (亮度设置，越大越亮)
' k$ x  ^6 s! |6 ROLED_WR_Byte(0xD9，OLED_CMD); //设置预充电周期
OLED_WR_Byte(0xf1，OLED_CMD); //[3:0]，PHASE 1;[7:4]，PHASE 2;
OLED_WR_Byte(0xDB，OLED_CMD); //设置 VCOMH  电压倍率
OLED_WR_Byte(0x30， OLED_CMD); //[6:4] 000， 0.65*vcc;001， 0.77*vcc;011， 0.83*vcc;
( X5 g$ m6 F+ rOLED_WR_Byte(0xA4，OLED_CMD); //全局显示开启;bit0:1，开启;0，关闭;
/ m  [0 V1 t; d& r1 vOLED_WR_Byte(0xA6，OLED_CMD); //设置显示方式;bit0:1，反相显示;0，正常显示
% k1 I6 o3 |. r! zOLED_WR_Byte(0xAF，OLED_CMD); //开启显示
3 k6 l# ~# e' E; c* W, KOLED_Clear();
}  
* f+ {# w! C5 S. Y9 n- ?这里代码明显比之前的例程多了，函数也比较多，这里我们仅针对几个比较重要的函数进
行介绍。
% Q) O/ H# G5 j- E% c4 C首先要介绍的是我们定义在 STM32 内部的 GRAM，u8  OLED_GRAM[128][8];此部分
GRAM 对应 OLED 模块上的 GRAM。在操作的时候，我们只要修改 STM32 内部的 GRAM 就
- n8 A# q  ?4 V* G! w+ I6 s可以了，然后通过 OLED_Refresh_Gram 函数把 GRAM 一次刷新到 OLED  的 GRAM 上。该函
数代码如下：
void OLED_Refresh_Gram(void)
1 @$ k. J" h# a" L" J$ o{
3 \/ z. w% K5 S! U& l$ H; _u8 i，n;   
" K6 ?! h& t2 O% P( u8 p' H( Z0 `/ @for(i=0;i<8;i++)  
{  
OLED_WR_Byte (0xb0+i，OLED_CMD);//设置页地址（0~7）
; y$ F, U3 S+ Q1 {! MOLED_WR_Byte (0x00，OLED_CMD); //设置显示位置—列低地址
% y" Y6 @# S5 J& |OLED_WR_Byte (0x10，OLED_CMD); //设置显示位置—列高地址
% D4 N+ W$ _8 d7 hfor(n=0;n<128;n++)OLED_WR_Byte(OLED_GRAM[n]，OLED_DATA);
}     
}
3 L7 W) s/ f" r" n$ b6 J4 p函数先设置页地址，然后写入列地址（也就是纵坐标），然后从 0 开始写入 128 个字节，写
" s) l! z; G2 R0 a5 l( {满该页，最后循环把 8 页的内容都写入，就实现了整个从 STM32 显存到 OLED 显存的拷贝。   。
2 Q3 s4 B2 q& ^( D6 Q$ F, ^2 ]OLED_Refresh_Gram 函数还用到了一个外部函数 OLED_WR_Byte，该函数直接和硬件相关，
该函数代码如下：
/ Q4 S9 `2 d) T+ h& u( p9 f) o#if OLED_MODE==1
void OLED_WR_Byte(u8 dat，u8 cmd)
4 F/ p9 A! B; M2 G: h: m{
: r! ?% Z1 z( @6 E/ H! [DATAOUT(dat);
OLED_RS=cmd;
+ l: Q/ L0 H7 d2 w1 k3 L" lOLED_CS=0;
0 t: a! I& N' g# V: _0 }OLED_WR=0; OLED_WR=1;
OLED_CS=1; OLED_RS=1;   
}         
- [# J- J+ m3 f2 Z6 f- @#else
0 a5 @. ?6 Y0 mvoid OLED_WR_Byte(u8 dat，u8 cmd)
{
' Q1 c3 ~/ p. n7 y* su8 i;     
0 u4 s) M8 ~5 t/ |OLED_RS=cmd; //写命令
$ f9 c  a0 j1 ~0 g  pOLED_CS=0;  
2 l: v: G7 [6 t, m$ H- r7 zfor(i=0;i<8;i++)
{   
OLED_SCLK=0;
( c  c3 |2 F( e# n* ^2 w3 eif(dat&0x80)OLED_SDIN=1;
! j" ?, n, _& g* T5 \+ nelse OLED_SDIN=0;
  N' N/ b9 J/ A( z' Y# bOLED_SCLK=1;
dat<<=1;   
# G3 i" p8 ?% g}      
5 E: I% z6 n; vOLED_CS=1; OLED_RS=1;     
}
#endif
% f& N: C* K+ `这里有 2 个一样的函数，通过宏定义 OLED_MODE 来决定使用哪一个。如果
OLED_MODE=1，就定义为并口模式，选择第一个函数，而如果为 0，则为 4 线串口模式，选
择第二个函数。这两个函数输入参数均为 2 个：dat 和 cmd，dat 为要写入的数据，cmd 则表明
" p! }; a* ?# I/ L该数据是命令还是数据。这两个函数的时序操作就是根据上面我们对 8080 接口以及 4 线 SPI
+ d& F% E6 V) N; x' x接口的时序来编写的。
OLED_GRAM[128][8]中的 128 代表列数，也就是 x 坐标，而 8 代表的是页，每个代表 8
6 o) K; n" B7 L  x  o2 ^# G个列，从高到底对应列数从小到大。比如，我们要在 x=100，y=29 这个点写入 1，则可以用这
( M: t' X! _5 w! v7 O% o个句子实现：
5 D, Y, @) |  c  J: x" MOLED_GRAM[100][4]|=1<<2；
一个通用的在点（x，y）置 1 表达式为：
OLED_GRAM[x][y/8]|=1<<(7-y%8)；
  X, }5 W, M  T% T5 }& ~5 |因此，我们可以得出下一个画点函数， void OLED_DrawPoint(u8 x， u8 y， u8 t)；代码如下：
, e# Q& x0 L2 p6 g* Avoid OLED_DrawPoint(u8 x，u8 y，u8 t)
{
u8 pos，bx，temp=0;
$ `" y% o2 T5 w1 Y( K( ^4 W! s) g  Bif(x>127||y>63)return;//超出范围了.
pos=7-y/8;
% P: Q( ^, t' ?/ n$ A+ ~' C# ~bx=y%8;
temp=1<<(7-bx);
if(t)OLED_GRAM[x][pos]|=temp;
else OLED_GRAM[x][pos]&=~temp;   
. H5 q4 U! s- m  k+ O0 W* L}

+ u" c, M" c4 r) g1 k3 z2 a' M
% M* x0 R# E: I7 l1 q

过来看看

谢谢分享，

试过I2C的方式没？I2C刷屏快不？

6 y2 Y( Y' J! i0 N! o
/ U& ~, _+ p6 a3 D; J好文章，值得学习

看看

……

路过！~学习学习！~感谢分享！~

标题不到ucos么