OLED 显示实验
前面所有的介绍都没有涉及到液晶显示，从这一节开始，我们将陆续向大家介绍几款液晶
显示模块。本节我们将向大家介绍相对简单的 OLED。本节分为如下几个部分：
" ~. D* W2 u$ O& m6 T4 ^2 F1 OLED 简介
* @8 p5 _7 Q" U" P; w1 n9 c) {OLED，即有机发光二极管（Organic Light-Emitting Diode），又称为有机电激光显示（Organic
9 E) j( o0 M1 k$ ]4 T  B/ Z- a1 bElectroluminesence  Display，  OELD）。OLED 由于同时具备自发光，不需背光源、对比度高、
厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优
异之特性，被认为是下一代的平面显示器新兴应用技术。
LCD 都需要背光，而 OLED 不需要，因为它是自发光的。这样同样的显示，OLED 效果要
来得好一些。OLED 的尺寸难以大型化，但是分辨率确可以做到很高。这一节，我们使用的是
+ m7 _) }$ w" X( A, w) pALINETEK 的 OLED 显示模块，该模块有以下特点：
6 J4 `& U; V; M) {1）模块有单色和双色两种可选，单色为纯白色，而双色则为黄蓝双色。
% `: R; a# P1 M0 a' R1 T) [% s6 h2）尺寸小，显示尺寸为 0.96 寸，而模块的尺寸仅为 27mm*26mm 大小。
4 T3 t1 g( o0 {5 J3）高分辨率，该模块的分辨率为 128*64。
* k* z7 p* w1 X4）多种接口方式，该模块提供了总共 5 种接口包括：6800、8080 两种并行接口方式、3
# d& ~- c; o9 \线或 4 线的穿行 SPI 接口方式，、IIC 接口方式（只需要 2 根线就可以控制 OLED 了！）。
5）不需要高压，直接接 3.3V 就可以工作了。
这里要提醒大家的是，该模块不和 5.0V 接口兼容，所以请大家在使用的时候一定要小心，
2 X; B2 u9 y2 q7 w8 S别接到 5V 的系统上去，否则可能烧坏模块。以上 5 种模式通过模块的 BS0~2 设置，BS0~2 的
$ B5 v$ w, N* K. [* e设置与模块接口模式的关系如下表：
7 ~* i7 @) ]' N* h: p上表中：“1”代表接 VCC，而“0”代表接 GND。该模块的外观图如下：
4 H) O# U" l8 m! a% g; E
该模块采用 8*2 的 2.54 排针与外部连接，其引线图如上图所示，总共有 16 个管脚，在 16
条线中，我们只用了 15 条，有一个是悬空的。15 条线中，电源和地线占了 2 条，还剩下 13 条
信号线。在不同模式下，我们需要的信号线数量是不同的，在 8080 模式下，需要全部 13 条，
* C# M$ O1 @, U而在 IIC 模式下，仅需要 2 条线就够了！这其中有一条是共同的，那就是复位线 RST（RES），
该线我们可以直接接在 MCU 的复位上（要先确认复位方式一样），这样可以省掉一条线。
ALIENTEK  OLED 模块的控制器是 SSD1306，这一节，我们将学习如何通过 STM32 来控
3 U) l/ Z$ q, J5 b, K" `& [6 w5 X制该模块显示字符和数字，本节实例将可以支持 2 种方式与 OLED 模块连接，一种是 8080 的
并口方式，另外一种是 4 线 SPI 方式。
首先我们介绍一下模块的 8080 并行接口，8080 并行接口的发明者是 INTEL，该总线也被
广泛应用于各类液晶显示器，ALIENTEK OLED 模块也提供了这种接口，使得 MCU 可以快速
的访问 OLED。ALIENTEK OLED 模块的 8080 接口方式需要如下一些信号线：
CS：OLED 片选信号。
2 M. J- }8 @2 S1 M+ k( Q9 e" xWR：向 OLED 写入数据。
RD：从 OLED 读取数据。
, {- Q" Z) L2 d7 N$ ZD[7:0]：8 位双向数据线。
RST(RES)：硬复位 OLED。
DC：命令/数据标志（0，读写命令；1，读写数据）。
模块的 8080 并口读/写的过程为：先根据要写入/读取的数据的类型，设置 DC 为高（数据）
- G+ n* J# h0 ^; j$ h  M; r) f/低（命令），然后拉低片选，选中 SSD1306，接着我们根据是读数据，还是要写数据置 RD/WR
为低，然后：
在 RD 的上升沿，  使数据锁存到数据线（D[7:0]）上；
# W) f; U; a- c/ w5 @0 [9 @. f在 WR 的上升沿，使数据写入到 SSD1306 里面；
SSD1306 的 8080 并口写时序图如下：

在 8080 方式下读数据操作的时候，我们有时候（例如读显存的时候）需要一个假读命
（Dummy Read），以使得微控制器的操作频率和显存的操作频率相匹配。在读取真正的数据之
! t0 a- ?0 D5 F7 T$ n前，由一个的假读的过程。这里的假读，其实就是第一个读到的字节丢弃不要，从第二个开始，
才是我们真正要读的数据。
! I+ G% V- M7 j) m' h  b, z1 S6 G# ^一个典型的读显存的时序图，如下图所示：

' C. r4 Q/ u% j7 w" u, w可以看到，在发送了列地址之后，开始读数据，第一个是 Dummy  Read，也就是假读，我
0 b$ C) e8 v& D# v6 ~( u( q们从第二个开始，才算是真正有效的数据。
' e/ T4 I3 N1 ^; q7 B并行接口模式就介绍到这里，我们接下来介绍一下 4 线串行（SPI）方式，4 先串口模式使
7 |6 f0 A" x2 y7 x用的信号线有如下几条：
CS：OLED 片选信号。
' J5 C, p$ @2 n$ }4 K/ k: J/ n7 q3 g% sRST(RES)：硬复位 OLED。
9 ?' n- g. p- }7 S% KDC：命令/数据标志（0，读写命令；1，读写数据）。
SCLK：串行时钟线。在 4 线串行模式下，D0 信号线作为串行时钟线 SCLK。
: B/ s: W4 a4 r$ O6 gSDIN：串行数据线。在 4 线串行模式下，D1 信号线作为串行数据线 SDIN。
' S0 D3 I. M  p! H, d2 v模块的 D2 需要悬空，其他引脚可以接到 GND。在 4 线串行模式下，只能往模块写数据而
. ]6 _" I/ a& Y( S% b3 K. m7 Q& _3 K不能读数据。
2 p+ U) d  O9 m! |! X: p& K在 4 线 SPI 模式下，每个数据长度均为 8 位，在 SCLK 的上升沿，数据从 SDIN 移入到
1 o4 P' b, j( w" c6 YSSD1306，并且是高位在前的。DC 线还是用作命令/数据的标志线。在 4 线 SPI 模式下，写操
. b5 l; ]0 q& b; D5 {# Z作的时序如下：
0 K* P3 _, M; V7 s$ y- h+ ~4 线串行模式就为大家介绍到这里。其他还有几种模式，在 SSD1306 的数据手册上都有详
$ U& V  x/ `$ \7 P, W9 T& E& k细的介绍，如果要使用这些方式，请大家参考该手册。
接下来，我们介绍一下模块的显存，SSD1306 的显存总共为 128*64bit 大小，SSD1306 将
这些显存分为了 8 页，其对应关系如下：
可以看出，SSD1306 的每页包含了 128 个字节，总共 8 页，这样刚好是 128*64 的点阵大
! J/ d) Y( ]# f) _7 N: B) K小。因为每次写入都是按字节写入的，这就存在一个问题，如果我们使用只写方式操作模块，
那么，每次要写 8 个点，这样，我们在画点的时候，就必须把要设置的点所在的字节的每个位
8 z( j8 w- q8 t9 @- h- C% j& W: T都搞清楚当前的状态（0/1？），否则写入的数据就会覆盖掉之前的状态，结果就是有些不需要
显示的点，显示出来了，或者该显示的没有显示了。这个问题在能读的模式下，我们可以先读
: M; Z) e5 _& Y0 h' f1 K出来要写入的那个字节，得到当前状况，在修改了要改写的位之后再写进 GRAM，这样就不会
影响到之前的状况了。但是这样需要能读 GRAM，对于 3 线或 4 线 SPI 模式，模块是不支持读
! c8 K$ R' ?& F% e的，而且读->改->写的方式速度也比较慢。
所以我们采用的办法是在 STM32 的内部建立一个 OLED 的 GRAM （共 128 个字节），在每
次修改的时候，只是修改 STM32 上的 GRAM （实际上就是 SRAM），在修改完了之后，一次性
把 STM32 上的 GRAM 写入到 OLED 的 GRAM。当然这个方法也有坏处，就是对于那些 SRAM
( M" O. m# v# |很小的单片机（比如 51 系列）就比较麻烦了。
SSD1306 的命令比较多，这里我们仅介绍几个比较常用的命令，这些命令如下表：
% R; g0 i$ b7 D! u* q$ ~
第一个命令为 0X81，用于设置对比度的，这个命令包含了两个字节，第一个 0X81 为命令，
' A* G$ c) }# F随后发送的一个字节为要设置的对比度的值。这个值设置得越大屏幕就越亮。
第二个命令为 0XAE/0XAF。0XAE 为关闭显示命令；0XAF 为开启显示命令。
2 v" K" V8 e; C7 e6 d第三个命令为 0X8D，该指令也包含 2 个字节，第一个为命令字，第二个为设置值，第二
个字节的 BIT2 表示电荷泵的开关状态，该位为 1，则开启电荷泵，为 0 则关闭。在模块初始化
7 H  M7 w- O: Q$ R3 R的时候，这个必须要开启，否则是看不到屏幕显示的。
* X5 H9 j8 H+ D, H第四个命令为 0XB0~B7，该命令用于设置页地址，其低三位的值对应着 GRAM 的页地址。
: G$ ^4 r' {! S6 c第五个指令为 0X00~0X0F，该指令用于设置显示时的起始列地址低四位。
9 e# S5 n/ N: W# N0 e3 x9 h第六个指令为 0X10~0X1F，该指令用于设置显示时的起始列地址高四位。
其他命令，我们就不在这里一一介绍了，大家可以参考 SSD1306  datasheet 的第 28 页。从
1 g1 }* G$ b! S- _这页开始，对 SSD1306 的指令有详细的介绍。OLED 的介绍就到此为止，我们重点向大家介绍了 ALIENTEK OLED 模块的相关知识，接
+ O: _) H' X" N9 W. f; }; U下来我们将使用这个模块来显示字符和数字。通过以上介绍，我们可以得出 OLED 显示需要的
相关设置步骤如下：
1）设置 STM32 与 OLED 模块相连接的 IO。
这一步，先将我们与 OLED 模块相连的 IO 口设置为输出，具体使用哪些 IO 口，这里需要根据
. \+ F0 S: E+ |5 \: c1 `连接电路以及 OLED 模块所设置的通讯模式来确定。这些将在硬件设计部分向大家介绍。
: [! z+ x& r' z4 u, Z4 l6 `2）初始化 OLED 模块。
其实这里就是上面的初始化框图的内容，通过对 OLED 相关寄存器的初始化，来启动 OLED 的
8 {; k$ N0 `1 F0 W* M8 S显示。为后续显示字符和数字做准备。
2 ~  O' ~/ `+ O# q7 _  V  G3）通过函数将字符和数字显示到 OLED 模块上。
这里就是通过我们设计的程序，将要显示的字符送到 OLED 模块就可以了，这些函数将在软件
* a9 }5 P) F( F1 X/ u* Z) z8 ^1 w设计部分向大家介绍。
& }# m1 N. w2 P; L; D! c通过以上三步，我们就可以使用 ALIENTEK OLED 模块来显示字符和数字了，在后面我们还将
会给大家介绍显示汉字的方法。这一部分就先介绍到这里。
5 t% r0 h6 C% p6 i0 v$ k
3  软件设计
软件设计我们依旧在之前的工程上面增加，首先在 HARDWARE 文件夹下新建一个 OLED
的文件夹。然后打开 USER 文件夹下的工程，新建一个 oled.c 的文件和 oled.h 的头文件，保存
7 M1 B7 p8 y' A. H  q: N在 OLED 文件夹下，并将 OLED 文件夹加入头文件包含路径。
2 K- @% N# }2 l+ Z. g! ^/ H: Y( d$ w打开 oled.c，输入如下代码：
#include "oled.h"
2 X' t: s: X3 q& o1 ~% p* p#include "stdlib.h"
#include "font.h"      
! e/ }! J9 T3 {$ e: y' X#include "delay.h"
//OLED 的显存
2 X0 x, D" Z& [% ?//存放格式如下.
0 w' C, n$ ~( U3 Q- E//[0]0 1 2 3 ... 127
//[1]0 1 2 3 ... 127
) P2 }7 M3 I9 c  K//[2]0 1 2 3 ... 127
//[3]0 1 2 3 ... 127
! N# F( ?( h* Q) o  [//[4]0 1 2 3 ... 127
//[5]0 1 2 3 ... 127
//[6]0 1 2 3 ... 127
//[7]0 1 2 3 ... 127      
u8 OLED_GRAM[128][8];   
& ]* |! R* t  v. X* e6 p8 i7 Z//更新显存到 LCD     
void OLED_Refresh_Gram(void)
{
6 b" h* o$ P. ^5 E+ g* [8 Hu8 i，n;   
5 H( [6 Y# {0 a+ xfor(i=0;i<8;i++)  
" a" a9 Y: E  H* y/ x' n% h{  
OLED_WR_Byte (0xb0+i，OLED_CMD);     //设置页地址（0~7）
OLED_WR_Byte (0x00，OLED_CMD);       //设置显示位置—列低地址   
OLED_WR_Byte (0x10，OLED_CMD);       //设置显示位置—列高地址
$ V- P, @  Z: Pfor(n=0;n<128;n++)OLED_WR_Byte(OLED_GRAM[n]，OLED_DATA);
}   
}
#if OLED_MODE==1
//向 SSD1306 写入一个字节。
//dat:要写入的数据/命令
$ U' y4 j) b% f) z, O& G& W3 {- v//cmd:数据/命令标志  0，表示命令;1，表示数据;
void OLED_WR_Byte(u8 dat，u8 cmd)
: E6 k! i* Z. Q{
6 f8 C1 Z5 c6 G8 iDATAOUT(dat);
OLED_RS=cmd;
0 T( A& z) W) z. F7 rOLED_CS=0;
6 U. q" V& o  ~0 w, ^: uOLED_WR=0; OLED_WR=1;  
& w0 z+ q: i  w5 d! u+ l7 J, eOLED_CS=1; OLED_RS=1;   
}         
0 {* u& W( m3 G0 s' K1 a; l% S#else
: ?$ v2 t3 P* r: `8 t+ N& u//向 SSD1306 写入一个字节。
//dat:要写入的数据/命令
//cmd:数据/命令标志  0，表示命令;1，表示数据;
1 e9 x6 {6 P' {" y, U% x+ S; r# hvoid OLED_WR_Byte(u8 dat，u8 cmd)
, Y% e) t: J+ d" m3 ~- D{
0 w# O( O! P. j9 _5 Z0 i7 Ju8 i;     
OLED_RS=cmd; //写命令
OLED_CS=0;  
for(i=0;i<8;i++)
1 X. C/ L" q$ [. H{   
# B3 N# f/ n, h7 h9 f9 W8 N! a8 g. R" KOLED_SCLK=0;
if(dat&0x80)OLED_SDIN=1;
! y2 u- e+ H, G' S& ?. Q% P5 v% k3 a5 N2 Welse OLED_SDIN=0;
0 k- m- i7 Z0 W  \OLED_SCLK=1;
8 P$ g" X' {' D8 B+ U; V1 n& Ldat<<=1;   
}      
7 W! r" e% o! Q8 vOLED_CS=1; OLED_RS=1;      
}
#endif   
9 D+ x* J/ U! M//开启 OLED 显示
void OLED_Display_On(void)
{
3 l! H6 D1 K$ N+ h; @/ nOLED_WR_Byte(0X8D，OLED_CMD);   //SET DCDC 命令
" c* m( g$ W5 [# uOLED_WR_Byte(0X14，OLED_CMD);   //DCDC ON
OLED_WR_Byte(0XAF，OLED_CMD);   //DISPLAY ON
}
//关闭 OLED 显示   
void OLED_Display_Off(void)
# n( ]8 Q2 X- T7 p) O. g/ l- e{
OLED_WR_Byte(0X8D，OLED_CMD);   //SET DCDC 命令
OLED_WR_Byte(0X10，OLED_CMD);   //DCDC OFF
OLED_WR_Byte(0XAE，OLED_CMD);   //DISPLAY OFF
}            
//清屏函数，清完屏，整个屏幕是黑色的!和没点亮一样!!!   
$ g2 I, V( P- G+ zvoid OLED_Clear(void)  
/ E6 h  r  Y- K1 N{  
: d: z& Y/ E/ B  l% s8 ou8 i，n;  
' A$ _5 F: L, ffor(i=0;i<8;i++)for(n=0;n<128;n++)OLED_GRAM[n]=0X00;  
5 D4 G: J% Q. ^& DOLED_Refresh_Gram();//更新显示
}
//画点
//x:0~127
( M2 e( N6 D+ B+ ~& X//y:0~63
: H* E0 J# N3 z( F+ w//t:1  填充  0，清空         
void OLED_DrawPoint(u8 x，u8 y，u8 t)
. E3 Z$ |5 C  c{
u8 pos，bx，temp=0;
if(x>127||y>63)return;//超出范围了.
pos=7-y/8;
bx=y%8;
temp=1<<(7-bx);
4 h9 n4 K4 R& Q% @/ r2 h* J. _! _if(t)OLED_GRAM[x][pos]|=temp;
1 {3 L, @' f1 Z1 Y# Z6 e* oelse OLED_GRAM[x][pos]&=~temp;   
}
//x1，y1，x2，y2  填充区域的对角坐标
+ G- E" P. {& I! }  f//确保 x1<=x2;y1<=y2 0<=x1<=127 0<=y1<=63      
//dot:0，清空;1，填充   
void OLED_Fill(u8 x1，u8 y1，u8 x2，u8 y2，u8 dot)  
0 u' V, q9 r# Z# M# d! Q/ W{  
u8 x，y;  
' j4 t% J: q/ E' x! u. @5 r; Ifor(x=x1;x<=x2;x++)
{
for(y=y1;y<=y2;y++)OLED_DrawPoint(x，y，dot);
}                        
OLED_Refresh_Gram();//更新显示
( `. ^  u& }! `2 t. m8 n8 K" ^}
/ M0 `. o# N! t8 t! |& [8 @$ Z//在指定位置显示一个字符，包括部分字符
//x:0~127
7 t" }" n( F- A//y:0~63
//mode:0，反白显示;1，正常显示         
//size:选择字体  16/12
void OLED_ShowChar(u8 x，u8 y，u8 chr，u8 size，u8 mode)
4 G2 @% a. l  q5 n{            
  t" }' X. D# M7 A& _! z& Qu8 temp，t，t1;
4 u' ?/ C  h. L! Q5 m/ Q% tu8 y0=y;
chr=chr-' ';//得到偏移后的值      
, H. c/ _  \  w# ?) x  g- rfor(t=0;t<size;t++)
{   
% Y9 o* a$ l6 J$ zif(size==12)temp=asc2_1206[chr][t];   //调用 1206 字体
- ^) s: Z; y0 ~( R( m. q& jelse temp=asc2_1608[chr][t];      //调用 1608 字体                        
for(t1=0;t1<8;t1++)
( M2 I4 w5 ~# J3 @0 F& R{
if(temp&0x80)OLED_DrawPoint(x，y，mode);
else OLED_DrawPoint(x，y，!mode);
5 L- U# Z. i4 K/ }$ k  j9 ~temp<<=1;
2 I$ c  @& ~3 h, J  u9 Y  x) iy++;
if((y-y0)==size)
  M; R/ `% w/ h{
y=y0; x++;
+ X0 g6 [5 g" m2 G' rbreak;
4 h8 T# q. r0 Z/ t2 G}
}   
7 T2 t; N- N4 Y# p2 ~2 h! G# \+ V}         
/ T: \6 @4 V  y' `7 {) Q! x6 Z}
! k7 G6 }# M( ?* W7 j+ G+ I//m^n 函数
u32 mypow(u8 m，u8 n)
, b5 K3 Y/ r. T% a{
& a- E1 T, s4 Z' }! fu32 result=1;
while(n--)result*=m;   
return result;
}         
, x7 k2 k% p  S% d& G4 _//显示 2 个数字
//x，y :起点坐标   
* r. y6 j) B/ z  T//len :数字的位数
//size:字体大小
" W/ D" r, {" E+ q2 k; ?//mode:模式  0，填充模式;1，叠加模式
) D7 }1 v5 q2 o4 S: c0 D* @+ C//num:数值(0~4294967295);         
  w% \! ~/ S5 x- F7 i# ivoid OLED_ShowNum(u8 x，u8 y，u32 num，u8 len，u8 size)
& Z0 M3 Y) z7 r; M* V{         
u8 t，temp;
' z4 W/ s$ E: V4 o* Eu8 enshow=0;           
for(t=0;t<len;t++)
% X: z2 J+ S* K; N/ _5 ?9 [{
1 |8 ~5 d  j5 F" y" `$ f( Y& Utemp=(num/mypow(10，len-t-1))%10;
( B* P" F/ w, j0 f3 z. [4 sif(enshow==0&&t<(len-1))
{
* ?0 j; b% E9 N# m; ?6 gif(temp==0)
0 M7 ~/ g/ f$ x6 h2 d{
( |: o: G. k  p/ O! `5 U2 L$ m( AOLED_ShowChar(x+(size/2)*t，y，' '，size，1);
continue;
}else enshow=1;
}
* @- }8 c4 q$ o6 @OLED_ShowChar(x+(size/2)*t，y，temp+'0'，size，1);
- l. U5 ~3 y  {- J2 h* c}
}   
//显示字符串
5 h+ ~/ {# `2 @; Y0 k: W0 r" y//x，y:起点坐标
//*p:字符串起始地址
//用 16 字体
. Z$ |$ o8 s7 }void OLED_ShowString(u8 x，u8 y，const u8 *p)
{
#define MAX_CHAR_POSX 122
#define MAX_CHAR_POSY 58         
while(*p!='\0')
; d" [) `, h7 J9 m$ ^/ [{      
7 J7 g- A2 a1 ^$ k0 S$ H5 U& `if(x>MAX_CHAR_POSX){x=0;y+=16;}
if(y>MAX_CHAR_POSY){y=x=0;OLED_Clear();}
/ y! t" v( L" e* m3 R6 w" nOLED_ShowChar(x，y，*p，16，1);
x+=8;
' F4 i" J* \4 W, Lp++;
}  
}   
8 i2 B5 R! T: E; E//初始化 SSD1303           
( q4 S/ l: F  I& V1 O, B1 Fvoid OLED_Init(void)
{                             
8 P  Q- S6 f: U) f) {; f6 S% ?4 ^RCC->APB2ENR|=1<<3;     //使能 PORTB 时钟
3 f% r# b" z9 {RCC->APB2ENR|=1<<4;     //使能 PORTC 时钟     
' J3 M' Q' ^/ g+ Z3 [8 U#if OLED_MODE==1         
" A) C' h5 t7 G; [/ j& x# s; I  |0 [RCC->APB2ENR|=1<<0;     //开启辅助时钟
1 y) h4 d5 O! e) D. Z+ nAFIO->MAPR=0X04000000; //关闭 JTAG
GPIOB->CRL=0X33333333;
GPIOB->ODR|=0XFFFF;
GPIOC->CRH&=0XFFFFFF00;
; K0 J) \; t$ @GPIOC->CRL&=0X00FFFFFF;
& @/ w5 H: G% L! O* AGPIOC->CRH|=0X00000033;
0 M% H( R" X5 V4 |# S* GGPIOC->CRL|=0X33000000;
' k8 m1 h$ ~/ |: Z% ?* JGPIOC->ODR|=0X03C0;
#else
GPIOB->CRL&=0XFFFFFF00;
GPIOB->CRL|=0XF0000033;
2 x: [; @7 m5 x) w9 ^: K# z; {GPIOB->ODR|=0X03;
GPIOC->CRH&=0XFFFFFF00;
GPIOC->CRH|=0X00000033;
GPIOC->ODR|=3<<8;
% r( N$ g$ J7 E' v#endif         
//OLED_RST=0; delay_ms(100); OLED_RST=1;
OLED_WR_Byte(0xAE，OLED_CMD); //关闭显示
OLED_WR_Byte(0xD5，OLED_CMD); //设置时钟分频因子，震荡频率
& C& k" ]3 b# p7 uOLED_WR_Byte(80，OLED_CMD);    //[3:0]，分频因子;[7:4]，震荡频率
# u/ K3 F: U- G- DOLED_WR_Byte(0xA8，OLED_CMD); //设置驱动路数
% ?' k- }4 \/ _9 [5 @8 |9 ZOLED_WR_Byte(0X3F，OLED_CMD); //默认 0X3F(1/64)
- R# o* J0 [% Z" |9 D5 |) E/ GOLED_WR_Byte(0xD3，OLED_CMD); //设置显示偏移
6 S: O. o. v* V2 [- y: ?: I0 iOLED_WR_Byte(0X00，OLED_CMD); //默认为 0
OLED_WR_Byte(0x40，OLED_CMD); //设置显示开始行  [5:0]，行数.
OLED_WR_Byte(0x8D，OLED_CMD); //电荷泵设置
OLED_WR_Byte(0x14，OLED_CMD); //bit2，开启/关闭
& U9 H8 }" f! ^& `. nOLED_WR_Byte(0x20，OLED_CMD); //设置内存地址模式
OLED_WR_Byte(0x02，OLED_CMD);
, N; v/ |' W7 q* Q) ]//[1:0]，00，列地址模式;01，行地址模式;10，页地址模式;默认 10;
5 C+ r# n+ q6 @- N0 ?5 `' EOLED_WR_Byte(0xA1，OLED_CMD); //段重定义设置，bit0:0，0->0;1，0->127;
; G/ ^( f' H( P: {OLED_WR_Byte(0xC0，OLED_CMD);
//设置 COM 扫描方向;bit3:0，普通模式;1，重定义模式  COM[N-1]->COM0;N:驱动路数
) U1 Y# w! @- M9 l+ VOLED_WR_Byte(0xDA，OLED_CMD); //设置 COM 硬件引脚配置
OLED_WR_Byte(0x12，OLED_CMD); //[5:4]配置
OLED_WR_Byte(0x81，OLED_CMD); //对比度设置
OLED_WR_Byte(0xEF，OLED_CMD); //1~255;默认 0X7F (亮度设置，越大越亮)
OLED_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  电压倍率
7 {+ E  L2 {. D6 xOLED_WR_Byte(0x30， OLED_CMD); //[6:4] 000， 0.65*vcc;001， 0.77*vcc;011， 0.83*vcc;
# c* W" [' {# |: aOLED_WR_Byte(0xA4，OLED_CMD); //全局显示开启;bit0:1，开启;0，关闭;
OLED_WR_Byte(0xA6，OLED_CMD); //设置显示方式;bit0:1，反相显示;0，正常显示
5 a6 U9 N4 N2 F' U4 \3 u. n7 r3 DOLED_WR_Byte(0xAF，OLED_CMD); //开启显示
3 E; ^9 k, y$ z( @1 T$ L3 BOLED_Clear();
}  
& D6 m( K7 U, m这里代码明显比之前的例程多了，函数也比较多，这里我们仅针对几个比较重要的函数进
行介绍。
首先要介绍的是我们定义在 STM32 内部的 GRAM，u8  OLED_GRAM[128][8];此部分
GRAM 对应 OLED 模块上的 GRAM。在操作的时候，我们只要修改 STM32 内部的 GRAM 就
2 V- d  N( @4 y& I' e可以了，然后通过 OLED_Refresh_Gram 函数把 GRAM 一次刷新到 OLED  的 GRAM 上。该函
, O: N- _+ ]2 o; B$ [" t" H数代码如下：
; K5 v+ d& N  K' L: J4 e7 n2 gvoid OLED_Refresh_Gram(void)
{
u8 i，n;   
for(i=0;i<8;i++)  
- |6 {4 s- j* m{  
OLED_WR_Byte (0xb0+i，OLED_CMD);//设置页地址（0~7）
OLED_WR_Byte (0x00，OLED_CMD); //设置显示位置—列低地址
OLED_WR_Byte (0x10，OLED_CMD); //设置显示位置—列高地址
7 t" B! o9 ]# Y7 d1 J/ b7 |! t% ifor(n=0;n<128;n++)OLED_WR_Byte(OLED_GRAM[n]，OLED_DATA);
! g) P  v$ d" o6 X3 @# [' n}     
, @( N, R- I6 X6 R7 F: s  k5 I% e, Q}
函数先设置页地址，然后写入列地址（也就是纵坐标），然后从 0 开始写入 128 个字节，写
满该页，最后循环把 8 页的内容都写入，就实现了整个从 STM32 显存到 OLED 显存的拷贝。   。
) d+ d2 _5 Q6 m# t3 O: yOLED_Refresh_Gram 函数还用到了一个外部函数 OLED_WR_Byte，该函数直接和硬件相关，
2 R/ W' E  E" V# T, v$ ]3 P该函数代码如下：
, F% E8 w$ z7 m8 ^! Y& ^- d" f#if OLED_MODE==1
void OLED_WR_Byte(u8 dat，u8 cmd)
- x# @/ w2 e4 ?, ^+ u{
5 C( E2 c) k( k. }DATAOUT(dat);
8 F! K9 X: i( E* jOLED_RS=cmd;
OLED_CS=0;
OLED_WR=0; OLED_WR=1;
OLED_CS=1; OLED_RS=1;   
/ v8 r& n; ]* }}         
#else
( r; A. v: j' p9 F; X8 Ivoid OLED_WR_Byte(u8 dat，u8 cmd)
# w2 N1 j$ F0 w( B, H! i" K5 ]{
+ Y& J9 K6 F6 S8 _- r1 m( q; [/ K& Nu8 i;     
OLED_RS=cmd; //写命令
OLED_CS=0;  
$ y" S( _2 P) S8 Pfor(i=0;i<8;i++)
{   
OLED_SCLK=0;
if(dat&0x80)OLED_SDIN=1;
& H3 R/ m/ p8 ~7 h0 S. b" welse OLED_SDIN=0;
OLED_SCLK=1;
dat<<=1;   
; h: i' Q" n- w2 P& O0 ^}      
OLED_CS=1; OLED_RS=1;     
}
#endif
这里有 2 个一样的函数，通过宏定义 OLED_MODE 来决定使用哪一个。如果
' H$ ]2 I; N. L2 l& c. OOLED_MODE=1，就定义为并口模式，选择第一个函数，而如果为 0，则为 4 线串口模式，选
择第二个函数。这两个函数输入参数均为 2 个：dat 和 cmd，dat 为要写入的数据，cmd 则表明
该数据是命令还是数据。这两个函数的时序操作就是根据上面我们对 8080 接口以及 4 线 SPI
接口的时序来编写的。
OLED_GRAM[128][8]中的 128 代表列数，也就是 x 坐标，而 8 代表的是页，每个代表 8
个列，从高到底对应列数从小到大。比如，我们要在 x=100，y=29 这个点写入 1，则可以用这
个句子实现：
5 B, V" d; ~! a$ h5 O' y0 b  `9 AOLED_GRAM[100][4]|=1<<2；
+ _# |, D) S- i# c/ |) A一个通用的在点（x，y）置 1 表达式为：
3 M- }3 K, r  r  s2 ]4 L+ {4 wOLED_GRAM[x][y/8]|=1<<(7-y%8)；
因此，我们可以得出下一个画点函数， void OLED_DrawPoint(u8 x， u8 y， u8 t)；代码如下：
void OLED_DrawPoint(u8 x，u8 y，u8 t)
{
u8 pos，bx，temp=0;
7 F9 e+ [! H: i0 Zif(x>127||y>63)return;//超出范围了.
pos=7-y/8;
5 L7 ^3 \# r7 W) C6 D( q) |bx=y%8;
, p0 }8 y4 M& j0 Utemp=1<<(7-bx);
. x! e! Q' J. L8 cif(t)OLED_GRAM[x][pos]|=temp;
+ n4 F2 X; j8 V% J) ~5 W- [& d. ?' A& zelse OLED_GRAM[x][pos]&=~temp;   
}
: Q3 ~& _9 x% ]

0 s* H6 l+ J% n" R5 A

过来看看

谢谢分享，

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

# ]& n; H1 ~  K3 l0 g
好文章，值得学习

看看

……

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

标题不到ucos么