12864液晶模块的详细使用

备注：这篇文章是对12864操作的具体介绍，仅限刚接触12864的新手，大神请拍砖，文章写的较散，建议先参考12864手册及控制驱动器ST7920英文手册有个初步理解之后再阅读该篇文章，将会有更深的认识。强烈建议阅读ST7920英文手册，细节内容里面有详细介绍，中文的12864也是从中译过来的。

本文分三个步骤介绍12864的内部资源原理，指令集详细讲解，以及应用例子。

对12864的所有操作概括起来有4种：

1）、读忙状态（同时读出指针地址内容），初始化之后每次对12864的读写均要进行忙检测。

2）、写命令：所有的命令可以查看指令表，后续讲解指令的详细用法。写地址也是写指令。

3）、写数据：操作对象有DDRAM、CGRAM、GDRAM。

4）、读数据：操作对象也是DDRAM、CGRAM、GDRAM。

 

对12864的学习首相要了解其内部资源，知道了它里面有哪些东西，你就可以更加方便的使用它。

先介绍几个英文的名字：

DDRAM：（Data Display Ram），数据显示RAM，往里面写啥，屏幕就会显示啥。

CGROM：（Character Generation ROM）,字符发生ROM。里面存储了中文汉字的字模，也称作中文字库，编码方式有GB2312（中文简体）和BIG5（中文繁体）。笔者使用的是育松电子的QC12864B，讲解以此为例。

CGRAM：（Character Generation RAM），字符发生RAM，，12864内部提供了64×2B的CGRAM，可用于用户自定义4个16×16字符，每个字符占用32个字节。

GDRAM：（Graphic Display RAM）：图形显示RAM，这一块区域用于绘图，往里面写啥，屏幕就会显示啥，它与DDRAM的区别在于，往DDRAM中写的数据是字符的编码，字符的显示先是在CGROM中找到字模，然后映射到屏幕上，而往GDRAM中写的数据时图形的点阵信息，每个点用1bit来保存其显示与否。

HCGROM：（Half height Character Generation ROM）：半宽字符发生器，就是字母与数字，也就是ASCII码。

至于ICON RAM（IRAM）：貌似市场上的12864没有该项功能，笔者也没有找到它的应用资料，所以不作介绍。

下面就围绕着上面列举的这列资源展开对12864的讲解：

DDRAM：

    笔者使用的这块12864内部有4行×32字节的DDRAM空间。但是某一时刻，屏幕只能显示2行×32字节的空间，那么剩余的这些空间呢？它们可以用于缓存，在实现卷屏显示时这些空间就派上用场了。

    DDRAM结构如下所示：

80H、81H、82H、83H、84H、85H、86H、87H、88H、89H、8AH、8BH、8CH、8DH、8EH、8FH

90H、91H、92H、93H、94H、95H、96H、97H、98H、99H、9AH、9BH、9CH、9DH、9EH、9FH

A0H、A1H、A2H、A3H、A4H、A5H、A6H、A7H、A8H、A9H、AAH、ABH、ACH、ADH、AEH、AFH

B0H、B1H、B2H、B3H、B4H、B5H、B6H、B7H、B8H、B9H、BAH、BBH、BCH、BDH、BEH、BFH

地址与屏幕显示对应关系如下：

第一行：80H、81H、82H、83H、84H、85H、86H、87H

第二行：90H、91H、92H、93H、94H、95H、96H、97H 

第三行：88H、89H、8AH、8BH、8CH、8DH、8EH、8FH

第四行：98H、99H、9AH、9BH、9CH、9DH、9EH、9FH

说明：红色部分的数据归上半屏显示，绿色部分的数据归下半屏显示。一般我们用于显示字符使用的是上面两行的空间，也就是80H~8FH，90H~9FH，每个地址的空间是2个字节，也就是1个字，所以可以用于存储字符编码的空间总共是128字节。因为每个汉字的编码是2个字节，所以每个地址需要使用2个字节来存储一个汉字。当然如果将2个字节拆开来使用也可以，那就是显示2个半宽字符。

    DDRAM内部存储的数据是字符的编码，可以写入的编码有ASCII码、GB2312码、BIG5码。笔者使用的12864字库貌似不太全，字符“数”都无法显示，而是显示其他字符。如果显示长篇汉字文章就不太适合吧。

    DDRAM数据读写：

    所有的数据读写都是先送地址，然后进行读写。对DDRAM写数据时，确保在基本指令集下（使用指令0x30开启），然后写入地址，之后连续写入两个字节的数据。读数据时，在基本指令集下先写地址，然后假读一次，之后再连续读2个字节的数据，读完之后地址指针自动加一，跳到下一个字，若需要读下一个字的内容，只需再执行连续读2个字节的数据。这里的假读需要注意，不光是读CGRAM需要假读，读其他的GDRAM、DDRAM都需要先假读一次，之后的读才是真读，假读就是读一次数据，但不存储该数据，也就是说送地址之后第一次读的数据时错误的，之后的数据才是正确的。（dummy为假读）

    关于编码在DDRAM中的存储需要说明事项如下：

    1）、每次对DDRAM的操作单位是一个字，也就是2个字节，当往DDRAM写入数据时，首先写地址，然后连续送入2个字节的数据，先送高字节数据，再送低字节数据。读数据时也是如此，先写地址，然后读出高字节数据，再读出低字节数据（读数据时注意先假读一次）。

    2）、显示ASCII码半宽字符时，往每个地址送入2个字节的ASCII编码，对应屏幕上的位置就会显示2个半宽字符，左边的为高字节字符，右边的为低字节字符。

    3）、显示汉字时，汉字编码的2个字节必须存储在同一地址空间中，不能分开放在2个地址存放，否则显示的就不是你想要的字符。每个字中的2个字节自动结合查找字模并显示字符。所以，如果我们往一个地址中写入的是一个汉字的2字节编码就会正确显示该字符，编码高字节存放在前一地址低字节，编码低字节存放在后一地址高字节，显然他们就不会结合查找字模，而是与各地址相应字节结合查找字模。

    4)、因为控制器ST7920提供了4个自定义字符，所以这4个自定义字符也是可以显示出来的，同样这4个自定义字符也是采用编码的方式，但是这4个字符的编码是固定的，分别是0000H,0002H,0004H,0006H。如下图所示：

上图只是把2个字符的CGRAM空间画出来，后续还有2个字符。可以看到每个字符都有16行16列，每一行使用2个字节，因此一个字符占用的空间是32字节，地址是6位的，4个字符的地址分别是：00H~0FH、10H~1FH、20H~2FH、30H~3FH。编码使用2个字节，可以看到有2个位是任意的，说明其实这4个字符的编码可以有多个，只是我们常用前面列举的4个编码。

CGRAM： （数据读写）

    CGRAM的结构就是上面所示了，这里再补充一些读写CGRAM的内容，读写之前先写地址，写CGRAM的指令为0x40+地址。但是我们写地址时只需要写第一行的地址，例如第一个字符就是0x40+00H,然后连续写入2个字节的数据，之后地址指针会自动加一，跳到下一行的地址，然后再写入2个字节的数据。其实编程实现就是写入地址，然后连续写入32个字节的数据。读数据也是先写首地址，然后假读一次，接着连续读32个字节的数据。

GDRAM:（绘图显示RAM）

绘图RAM的空间结构如下图所示：

这些都是点阵，绘图RAM就是给这些点阵置1或置0，可以看到其实它本来是32行×256列的，但是分成了上下两屏显示，每个点对应了屏幕上的一个点。要使用绘图功能需要开启扩展指令。然后写地址，再读写数据。

    GDRAM的读写：

    首先说明对GDRAM的操作基本单位是一个字，也就是2个字节，就是说读写GDRAM时一次最少写2个字节，一次最少读2个字节。

    写数据：先开启扩展指令集（0x36）,然后送地址，这里的地址与DDRAM中的略有不同，DDRAM中的地址只有一个，那就是字地址。而GDRAM中的地址有2个，分别是字地址（列地址/水平地址X）和位地址（行地址/垂直地址Y），上图中的垂直地址就是00H~31H，水平地址就是00H~15H,写地址时先写垂直地址（行地址）再写水平地址（列地址），也就是连续写入两个地址，然后再连续写入2个字节的数据。如图中所示，左边为高字节右边为低字节。为1的点被描黑，为0的点则显示空白。这里列举个写地址的例子：写GDRAM地址指令是0x80+地址。被加上的地址就是上面列举的X和Y,假设我们要写第一行的2个字节，那么写入地址就是0x00H(写行地址)然后写0x80H（列地址），之后才连续写入2个字节的数据（先高字节后低字节）。再如写屏幕右下角的2个字节，先写行地址0x9F（0x80+32），再写列地址0x8F(0x80+15)，然后连续写入2个字节的数据。编程中写地址函数中直接用参数（0x+32），而不必自己相加。

    读数据：先开启扩展指令集，然后写行地址、写列地址，假读一次，再连续读2字节的数据（先高字节后低字节）。

读写时序：

读写时序图如下：（上图为写，下图为读）

时序图中的信号引脚就是12864主要的引脚，分别是：

RS：命令/数据寄存器选择端

WR：读写控制端
E：使能端

DB7~DB0：数据端

 

所有对12864的操作都是围绕着几根引脚展开的。包括写命令、写数据、读数据、读状态就是通过这些引脚的高低电平搭配来实现的。

根据时序图可以编写相应的写命令函数、写数据函数、读数据函数、读状态函数。需要的注意的是有效数据出现的那段时间Tc必须合适，不能太短，否则会造成读写失败。

 

给出几个函数示例：

//忙检测，若忙则等待，最长等待时间为60ms
void busychk_12864(void){

 unsigned int timeout = 0;
 E_12864 = 0;
 RS_12864 = 0;
 RW_12864 = 1;
 E_12864 = 1;
 while((IO_12864 & 0x80) && ++timeout != 0);  //忙状态检测，等待超时时间为60ms
 E_12864 = 0;

}

 

//写命令子程序
void wrtcom_12864(unsigned char com){

 busychk_12864();
 E_12864 = 0; 
 RS_12864 = 0;
 RW_12864 = 0;
 IO_12864 = com;
 E_12864 = 1;
 delay_12864(50);    //50us使能延时!!!注意这里，如果是较快的CPU应该延时久一些
 E_12864 = 0;  
}

 

//读数据子程序
unsigned char reddat_12864(void){
 unsigned char temp;

 busychk_12864();
 E_12864 = 0;
 IO_12864 = 0xff;  //IO口置高电平，读引脚
 RS_12864 = 1;
 RW_12864 = 1;
 E_12864 = 1;
 delay_12864(50);    //使能延时!!!注意这里，如果是较快的CPU应该延时久一些
 temp = IO_12864;
 
 return temp; 
}

 

//写数据子程序
void wrtdat_12864(unsigned char dat){

 busychk_12864();
 E_12864 = 0;
 RS_12864 = 1;
 RW_12864 = 0;
 E_12864 = 1;
 IO_12864 = dat;
 delay_12864(50);    //使能延时!!!注意这里，如果是较快的CPU应该延时久一些
 E_12864 = 0;  
}

 

其中，忙检测是必要的，当BF=1时，表示内部正在进行有关的操作，即处于忙状态。在BF变回0之前ST7920不会接受任何指令。MCU必须检测BF以确定ST7920内部操作是否完成，然后才能再发送指令。也可以用延时来替代忙检测，但是需要延时足够的时间。盲检测实际就是读内部的状态寄存器，该寄存器最高位（D7）为忙标志BF，剩余7位为地址指针的内容，所以进行盲检测实际上也把地址指针中的地址读出来了。

 

指令集：

指令集分为基本指令集和扩展指令集，使用相应的指令集必须先写相应指令表明后续指令均为该类指令。如使用基本指令集时，写指令（0x30），需要使用扩展指令集时写指令（0x34）切换到扩展指令集。

 

一）基本指令集（RE=0）:（使用扩展指令集先写指令0x30,这使得RE=0）

 

清屏指令（0x01）:往DDRAM写满0x20,指针地址写0x00。表现在屏幕就是显示空白。

回车指令（0x02/0x03）：地址指针内容写0x00.

进入模式：0 0 0 0 0 1 I/D S：设置读写数据之后光标、显示移位的方向。内部有2个可编程位，I/D表示读写一个字符后数据指针是加一还是减一。I/D=1指针加一，I/D=0指针减一。S=1开启整屏移动。

S I/D= H H，屏幕每次左移一个字符。

S I/D= H L ，屏幕每次右移一个字符。

但是平时不开启屏幕移动，这里说明一个概念，就是屏幕移动，实际试验中若开启了屏幕移动你会发生显示是灰常怪异的，说明如下：由于DDRAM的结构是下方表所示：

上半屏                                             下半屏

80H、81H、82H、83H、84H、85H、86H、87H、88H、89H、8AH、8BH、8CH、8DH、8EH、8FH

90H、91H、92H、93H、94H、95H、96H、97H、98H、99H、9AH、9BH、9CH、9DH、9EH、9FH

A0H、A1H、A2H、A3H、A4H、A5H、A6H、A7H、A8H、A9H、AAH、ABH、ACH、ADH、AEH、AFH

B0H、B1H、B2H、B3H、B4H、B5H、B6H、B7H、B8H、B9H、BAH、BBH、BCH、BDH、BEH、BFH

在未开启屏移时，屏幕是以表格第一列作为参考起点，然后前8列归上半屏显示，后8列归下半屏显示。如果此时向左屏移一个字符，那么DDRAM内容与显示映射关系变为：

80H、81H、82H、83H、84H、85H、86H、87H、88H、89H、8AH、8BH、8CH、8DH、8EH、8FH

90H、91H、92H、93H、94H、95H、96H、97H、98H、99H、9AH、9BH、9CH、9DH、9EH、9FH

A0H、A1H、A2H、A3H、A4H、A5H、A6H、A7H、A8H、A9H、AAH、ABH、ACH、ADH、AEH、AFH

B0H、B1H、B2H、B3H、B4H、B5H、B6H、B7H、B8H、B9H、BAH、BBH、BCH、BDH、BEH、BFH

可以看到实际上原来第三第四行开始的字符跑到了第一行第二行的末尾，整个DDRAM的结构就是一种循环的结构，发生屏移时DDRAM与显示映射关系不断在改变。但是这不太符合我们的阅读习惯，所以如果需要使用该项功能还需编程校正之。

显示、光标、闪烁开关：0 0 0 0 0 0 1 D C B：

D=1: 显示开（Display） C=1: 光标开（Cursor） B=1: 光标位置闪烁开（Blink）。为0则为关。

光标显示移位控制：0 0 0 1 S/C R/L X X

 

说明：

LL：这时仅仅是将地址指针AC的值减1。在屏幕上表现是光标左移一个字符。

LH：这时仅仅是将地址指针AC的值加1。在屏幕上表现是光标右移一个字符。

HL：AC指针不变，向左屏移一个字符。这是DDRAM结构循环左移，80H接在8FH后面，90H接在9FH后面。这与上面讲的屏移是一样的。

HH：AC指针不变，向右屏移一个字符。这是DDRAM结构循环右移，80H接在8FH后面，90H接在9FH后面。

功能设置：0 0 1 DL X RE X X：（切换基本指令集与扩展指令集）

DL=1表示8为接口，DL=0表示4为接口。

RE=1表示开启扩展指令，RE=0表示使用基本指令。

开启基本指令则设置为0x30，开启扩展指令则设置为0x34。

CGRAM地址设置：0x40+地址。地址范围是00H~3FH。前提是SR=0，即允许设置IRAM和CGRAM地址！！！

DDRAM地址设置：只有字地址。如下表所示。（注意DDRAM地址有4行×16字）如下所示：

80H、81H、82H、83H、84H、85H、86H、87H、88H、89H、8AH、8BH、8CH、8DH、8EH、8FH

90H、91H、92H、93H、94H、95H、96H、97H、98H、99H、9AH、9BH、9CH、9DH、9EH、9FH

A0H、A1H、A2H、A3H、A4H、A5H、A6H、A7H、A8H、A9H、AAH、ABH、ACH、ADH、AEH、AFH

B0H、B1H、B2H、B3H、B4H、B5H、B6H、B7H、B8H、B9H、BAH、BBH、BCH、BDH、BEH、BFH

所以某一时刻只能显示其中的2行。只有卷动显示才能将另两行的数据显示出来。

读忙标志（地址）：同时忙标志和地址读出来。忙状态时，ST7920不会接受任何指令。按照时序图将RS置0，RW置1，然后读取状态寄存器。

写RAM(DDRAM/CGRAM/GDRAM)：写了控制逻辑（函数wrtcom_12864(地址);）之后，直接送数据(wrtdat_12864)。写完后地址指针根据进入模式中的设置加一或减一。写数据前先写地址，而写地址本身是一个写地址命令，然后再写数据。

读RAM(DDRAM/CGRAM/GDRAM)：记得先假读一次，后面的才是真读，假读之后不需要再假读了，除非重设了地址。

 

二）扩展指令集（RE=1）：（使用扩展指令集先写指令0x34,这使得RE=1）

 

待机模式：0x01，不影响DDRAM，所以跟清屏指令不同，任何指令可以结束待机模式。

卷动地址/IRAM地址允许设置：0 0 0 0 0 0 1 SR：

SR=1：允许设置垂直卷动地址。SR=0：允许设置IRAM和CGRAM地址。

设置卷动/IRAM地址：0x40+地址。（卷动地址为行地址，即纵向地址）.

这里讲解卷动，卷动就是上下滚屏，实现屏幕的垂直滚动。

卷动地址：地址范围为0x00~0x63，共64行卷动地址其实就是垂直地址。每一个地址代表着DDRAM中的一行的像素点。卷动一次就是把该行所有点移到上半屏和下半屏幕最上方。

80H、81H、82H、83H、84H、85H、86H、87H、88H、89H、8AH、8BH、8CH、8DH、8EH、8FH

90H、91H、92H、93H、94H、95H、96H、97H、98H、99H、9AH、9BH、9CH、9DH、9EH、9FH

A0H、A1H、A2H、A3H、A4H、A5H、A6H、A7H、A8H、A9H、AAH、ABH、ACH、ADH、AEH、AFH

B0H、B1H、B2H、B3H、B4H、B5H、B6H、B7H、B8H、B9H、BAH、BBH、BCH、BDH、BEH、BFH

还是DDRAM的结构图，需要注意的是卷屏是分上半屏卷动和下半屏卷动，两屏之间没有关系，也就是DDRAM中左边红色部分在上半屏滚动，右边绿色部分在下半屏滚动。

B0H、B1H、B2H、B3H、B4H、B5H、B6H、B7H 的下一行是

80H、81H、82H、83H、84H、85H、86H、87H

也就是说左边是一个上下相接的循环结构。同理右边也是上下相接的循环结构。左边内存中的字符上下滚动。右边内存中的字符上下滚动，两者木有关系。

要开启卷动，首先开启扩展指令集，然后允许卷动地址设置，再设置卷动地址。

wrtcom_12864(0x34);              //打开扩展指令
wrtcom_12864(0x03);              //允许输入卷动地址
wrtcom_12864(0x40 + 地址    //设置卷动地址
wrtcom_12864(0x30);              //回到基本指令

要实现全屏滚动，就必须使用循环不断地修改卷动地址。从00~63如此循环，但遗憾的是这也不符合我们的阅读习惯，后续的应用的中将讲解全屏滚动的实现方法。这里只是把卷动原理讲清楚。

反白显示：0 0 0 0 0 1 R1 R0：

R1、R0初始化的值为00。选择1~4任一行反白显示并可决定是否反白。

如何开启反白显示：首先开启扩展指令（0x34），然后设置选中某一行设置反白显示（0x04+R1R0）。00为第一行，01为第二行，10为第三行，11为第四行。需要说明的是，这里的行是指DDRAM所有内存的行，而不是显示的行，屏幕只显示2行。

所以如果我们开启第3第4行的反白显示，不卷动我们是看不到效果的。

同时，如果我们开启第1行反白显示，那么在屏幕中第1行第3行都会反白显示，第2行则对应屏幕第2第4行，这一点需要注意。

如何关闭反白显示：只需在此写一次地址即可关闭，也就说，第一次写第一开启反白，第二次写相同的地址关闭反白显示。

wrtcom_12864(0x34);  //反白显示试验
wrtcom_12864(0x04);  //开启反白显示
delay_12864(60000);  //延时
delay_12864(60000);  //延时

wrtcom_12864(0x04); //关闭反白显示
wrtcom_12864(0x30);  //开启基本指令集

扩展功能设置：0x36设置绘图显示开。

当GDRAM写完了之后，写0x36则屏幕显示你所绘制的图形。

0 0 0 0 1 DL x RE G x （RE=1扩展指令，G=1开绘图显示，DL=1表示8为接口）

设置GDRAM地址：绘图时，需要将GDRAM的地址写入地址指针中，然后才能写入数据。连续写入两个字节，第一个为行地址（Y），第二个为列地址（X）。

需要注意的是：写了数据之后，地址指针会自动加一（以字为单位），当到达该行的行尾时，指针下一次加一会使得地址指针跳回该行行首，也就说如果地址值为8FH时，下一次它就是80H（以第一行为例）。指针地址在本行之间循环。

指令介绍完

再讲下初始化过程，根据ST7920的手册提供的初始化步骤就可以了。

初始化函数如下：

//延时子程序
void delay_12864(unsigned int del){
 unsigned int i;
 for(i = 0; i < del; i++){; }
}

 

//初始化12864子函数
void initial_12864(void){

 delay_12864(40000);
 RST_12864 = 1;
 RST_12864 = 0;    //复位
 delay_12864(500);
 RST_12864 = 1;

 wrtcom_12864(0x30);   //设置为基本指令集动作
 delay_12864(100);
 wrtcom_12864(0x30);   //设置为基本指令集动作
 delay_12864(37);
 wrtcom_12864(0x08);   //设置显示、光标、闪烁全关。
 delay_12864(100);
 wrtcom_12864(0x01);   //清屏，并且DDRAM数据指针清零
 delay_12864(100000);
 wrtcom_12864(0x06);      //进入模式设置
}

 

应用部分：

这里讲解12864的几个典型应用：

1）、自编字符创建以及显示

2）、GDRAM的绘制及显示

3）、全屏卷动的实现方法

 

 

1）、自编字符创建以及显示

先明确的要点，12864具有4个自编字符，每个字符的编码为0000H、0002H、0004H、0006H,4个自定义字符的CGRAM地址分别为00H~0FH、10H~1FH、20H~2FH、30H~3FH。

我们以第3个字符为例：

在这里先把整个源文件的宏定义以及各子函数贴出：

#include <reg52.h>

#define IO_12864  P0

sbit RS_12864 = P2^5;
sbit RW_12864 = P2^6;
sbit E_12864 = P2^7;
sbit RST_12864 = P2^2;

//忙检测，若忙则等待，最长等待时间为60ms
void busychk_12864(void){

 unsigned int timeout = 0;
 E_12864 = 0;
 RS_12864 = 0;
 RW_12864 = 1;
 E_12864 = 1;
 while((IO_12864 & 0x80) && ++timeout != 0);  //忙状态检测，等待超时时间为60ms
 E_12864 = 0;

}

 

//写命令子程序
void wrtcom_12864(unsigned char com){

 busychk_12864();
 E_12864 = 0; 
 RS_12864 = 0;
 RW_12864 = 0;
 IO_12864 = com;
 E_12864 = 1;
 delay_12864(50);    //使能延时!!!注意这里，如果是较快的CPU应该延时久一些
 E_12864 = 0;  
}

 

//读数据子程序
unsigned char reddat_12864(void){
 unsigned char temp;

 busychk_12864();
 E_12864 = 0;
 IO_12864 = 0xff;  //IO口置高电平，读引脚
 RS_12864 = 1;
 RW_12864 = 1;
 E_12864 = 1;
 delay_12864(50);    //使能延时!!!注意这里，如果是较快的CPU应该延时久一些
 temp = IO_12864;
 
 return temp; 
}

 

//写数据子程序
void wrtdat_12864(unsigned char dat){

 busychk_12864();
 E_12864 = 0;
 RS_12864 = 1;
 RW_12864 = 0;
 E_12864 = 1;
 IO_12864 = dat;
 delay_12864(50);    //使能延时!!!注意这里，如果是较快的CPU应该延时久一些
 E_12864 = 0;  
}

 

//初始化12864子函数
void initial_12864(void){

 delay_12864(40000);
 RST_12864 = 1;
 RST_12864 = 0;    //复位
 delay_12864(500);
 RST_12864 = 1;

 wrtcom_12864(0x30);   //设置为基本指令集动作
 delay_12864(100);
 wrtcom_12864(0x30);   //设置为基本指令集动作
 delay_12864(37);
 wrtcom_12864(0x08);   //设置显示、光标、闪烁全关。
 delay_12864(100);
 wrtcom_12864(0x01);   //清屏，并且DDRAM数据指针清零
 delay_12864(100000);
 wrtcom_12864(0x06);   //进入模式设置

 wrtcom_12864(0x0c);   //开显示
 
}

 

以上函数定义在main()函数之前，我们在主函数中编写程序：

void main(){

  unsigned char i,*addr;

  unsigned char defchar[] = {0x08,0x10,0x08,0x10,0x08,0x10,0x7F,0xFE,0x20,0x04,0x12,0x48,0x08,0x10,0x05,0xA0,0x02,0x40,0x01,0x80,0x01,0x80,0x07,0xE0,0x09,0x90,0x11,0x88,0x11,0x88,0x11,0x88};    //自定义字符，这里是笔者画的一个小机器人。

 

  delay_12864(100);      //启动延时

  initial_12864();       //初始化12864

  addr = defchar;

  wrtcom_12864(0x40+0x20); //写CGRAM首行地址

  for(i = 0; i < 32; i++){

    wrtdat_12864(*addr++);   

  }

  wrtcom_12864(0x80);     //在第一行第一个字符出显示自定义字符

  wrtdat_12864(0x00);     //写第三个自定义字符编码的高字节

  wrtdat_12864(0x04);     //写第三个自定义字符编码的低字节

 

  while(1);

 

}

运行程序就可以看到第一个字符处出现一个小机器人了。

 

2）、GDRAM的绘制及显示

先明确的要点，GDRAM是32行×16字。写数据之前必须先送行地址，然后送列地址。读写的基本操作单元是字（2个字节）。读写完一个字后地址指针在本行自动加一，到达行末则返回行首地址（地址循环）。

我们这里先以一个画点函数函数为例，然后再根据画点函数写一个绘制矩形的函数：

先建一个坐标左上角为（0，0），右下角为（63,127）。

画点原理：由于GDRAM的读写基本操作单元是字，那么我们需要画一个点但是又不改变其他点的内容，那么需要把该点所处的字中的2个字节均读出，然后再单独修改我们需要画的那个点（其他位保持不变），最后把该字再写回去。

因此，涉及的操作有先读GDRAM，再写GDRAM，再显示GDRAM。

在写主函数之前先写几个子函数，说明其作用：

void clnGDR_12864(void)  //清空GDRAM
void drawdot_12864(unsigned char y,unsigned char x,unsigned char type) //画点子函数

 

为什么要清空GDRAM呢，因为指令集中没有GDRAM清空指令，而我们往里写了什么它就会一直保存着，所以我们画点之前先清空GDRAM，其实清空GDRAM就是不断往里写0x00。

 

//清空GDRAM,总共就是写1KB的0x00。
void clnGDR_12864(void){

  unsigned char j,k;

  wrtcom_12864(0x34);      //在写GDRAM的地址之前一定要打开扩充指令集

                           //否则地址写不进去！！
  for( j = 0 ; j < 32 ; j++ )
  {
   
    wrtcom_12864(0x80 + j) ;    //写Y 坐标
    wrtcom_12864(0x80) ;        //写X 坐标
  
    for( k = 0 ; k < 32 ; k++ ) //写一整行数据
    {
     wrtdat_12864( 0x00 );
    }
  }  
}

 

//画点函数,左上角为参考点（0，0）
//右下角为（63,127），点坐标形式为(行坐标，列坐标)
//参数type用于设置画黑点、白点或取反（黑变白，白变黑）
//type = 0为白色，1 为黑色，2为取反
void drawdot_12864(unsigned char y,unsigned char x,unsigned char type){
  
 unsigned char X,Y,k;  //X存储行地址，Y存储列地址

                       //k存储点在字中的位置从左至右为0~15
 unsigned char DH,DL;  //存放读出数据的高字节和低字节
 
 if(y >= 0 && y <= 63 && x >= 0 && x <= 127) {
  
  if(y < 32){     //算法：确定所画点的地址行与列地址
   X = 0x80 + (x >> 4);
   Y = 0x80 + y; 
  }else{
   X = 0x88 + (x >> 4);
   Y = 0x80 + (y - 32);
  }
       
  wrtcom_12864(0x34);  //开启扩展指令，关闭绘图显示
  wrtcom_12864(Y);  //写入所确定的点的行位地址  
  wrtcom_12864(X);   //写入所确定的点的列字地址
 
  DH = reddat_12864(); //假读
  DH = reddat_12864();    //读高字节
  DL = reddat_12864(); //读低字节
 
  k = x % 16;          //余数为点在字中的位置
 

  //画点
  switch(type){     //画点类型，1黑或0白或2取反
   
   case 0:
        if(k < 8){   //点在高字节
      DH &= ~(0x01 << (7 - k));  //修改该点同时保持其他位不变
     }else{          //点在低字节
      DL &= ~(0x01 << (7 - (k % 8)));  //修改该点同时保持其他位不变
     }
     break;
   case 1:
     if(k < 8){
      DH |= (0x01 << (7 - k));  //修改该点同时保持其他位不变
     }else{
      DL |= (0x01 << (7 - (k % 8))); //修改该点同时保持其他位不变
     }
     break;
   case 2:
     if(k < 8){
      DH ^= (0x01 << (7 - k));  //修改该点同时保持其他位不变
     }else{
      DL ^= (0x01 << (7 - (k % 8)));   //修改该点同时保持其他位不变
     }
     break;
   default:
     break;  
  }
  
  wrtcom_12864(Y);  //写行位地址
  wrtcom_12864(X);     //写列字地址
 
  wrtdat_12864(DH);  //将高字节数据写回
  wrtdat_12864(DL);  //将低字节数据写回
 
  wrtcom_12864(0x30);  //转回普通指令
 }
}

 

下面编写主函数，这就简单了，如下：

 

void main(void){

 delay_12864(1000);
 initial_12864();

 clnGDR_12864();           //清空GDRAM
 drawdot_12864(20,50,1);   //画点
 wrtcom_12864(0x36);       //开绘图显示

 while(1);
}

 

程序运行后相应位置出现了一个黑点，手机坏了，拍不了照，不然就贴下照片。

然后根据画点函数，扩展一个画矩形的函数吧：

 

//画矩形子函数，参数为（点1行坐标，点1列坐标，

//点2行坐标，点2列坐标，线条颜色（0为白，1为黑，2对原色取反））           
void drawrec_12864(unsigned char y1,unsigned char x1,unsigned char y2,unsigned char x2,unsigned char type){
 
 unsigned char largex,largey,smallx,smally;  //将两点横纵坐标按大小存储
 unsigned char i;

 if(x1 > x2){
  largex = x1;
  smallx = x2;
 }else{
  largex = x2;
  smallx = x1;
 }
 
 if(y1 > y2){
  largey = y1;
  smally = y2;
 }else{
  largey = y2;
  smally = y1;
 }
 

//以下绘制4条矩形边框

 for(i = smallx; i < largex; i++){
  drawdot_12864(largey,i,type); 
 }
 for(i = largey; i > smally; i--){
  drawdot_12864(i,largex,type);
 }
 for(i = largex; i > smallx; i--){
  drawdot_12864(smally,i,type);
 }
 for(i = smally; i < largey; i++){
  drawdot_12864(i,smallx,type);
 }
 
 wrtcom_12864(0x30);     //返回普通指令  
}

 

主函数为：

void main(void){

 delay_12864(1000);
 initial_12864();

 clnGDR_12864();                  //清空GDRAM
 drawrec_12864(20,50,30,120,1);   //画矩形

 wrtcom_12864(0x36);              //开绘图显示

 while(1);
}

 

关于GDRAM的操作就到这吧，下面讲解下12864全屏卷动的实现方法。

 

3）、12864全屏卷动的实现方法

首先需要明确的要点：

DDRAM的结构如下：

80H、81H、82H、83H、84H、85H、86H、87H、88H、89H、8AH、8BH、8CH、8DH、8EH、8FH

90H、91H、92H、93H、94H、95H、96H、97H、98H、99H、9AH、9BH、9CH、9DH、9EH、9FH

A0H、A1H、A2H、A3H、A4H、A5H、A6H、A7H、A8H、A9H、AAH、ABH、ACH、ADH、AEH、AFH

B0H、B1H、B2H、B3H、B4H、B5H、B6H、B7H、B8H、B9H、BAH、BBH、BCH、BDH、BEH、BFH

卷屏是分上下屏个各自卷动的，上半屏卷动左边红色区域的内容，下半屏卷动右边绿色区域的内容。

 

为了实现全屏卷动显示，必须使用拼接的方法实现。

笔者花了几个小时研究了下算法，然后第二天实现了。现讲述如下：

细心观察DDRAM的结构发现，如果在卷动过程中，在同一时刻屏幕显示的内容最多涉及3行DDRAM的内容，而另一行是没有显示的，那么这一行就是用来缓存的数据的。

当屏幕显示如下2行时开始卷动（一）：

80H、81H、82H、83H、84H、85H、86H、87H、88H、89H、8AH、8BH、8CH、8DH、8EH、8FH

90H、91H、92H、93H、94H、95H、96H、97H、98H、99H、9AH、9BH、9CH、9DH、9EH、9FH

则屏幕同时出现以下3行DDRAM内容（二）：

80H、81H、82H、83H、84H、85H、86H、87H、88H、89H、8AH、8BH、8CH、8DH、8EH、8FH

90H、91H、92H、93H、94H、95H、96H、97H、98H、99H、9AH、9BH、9CH、9DH、9EH、9FH

A0H、A1H、A2H、A3H、A4H、A5H、A6H、A7H、A8H、A9H、AAH、ABH、ACH、ADH、AEH、AFH

需要注意的是，左边是上半屏显示，右边是下半屏显示。

在程序的开始处往DDRAM对应区域填写如下内容：

第一行字符   第三行字符-->  开始显示

第二行字符   第四行字符

第三行字符   第五行字符-->  即将显示

第四行字符   第六行字符

这样在开始卷动之后，就可以实现拼接的效果了。当卷动了16次之后，也就是第一行字符已经移出屏幕，屏幕显示的DDRAM如下：

第一行字符   第三行字符

第二行字符   第四行字符

第三行字符   第五行字符

第四行字符   第六行字符

此时，屏幕接着滚动，显示内容涉及3行的DDRAM,如下：

第一行字符   第三行字符-->  已显示完毕

第二行字符   第四行字符

第三行字符   第五行字符

第四行字符   第六行字符-->  即将显示

第一行DDRAM是空余的，下次就该往第一行写数据，写完后DDRAM内容如下：

第五行字符   第七行字符

第二行字符   第四行字符

第三行字符   第五行字符

第四行字符   第六行字符

经过又一次的16次卷屏之后屏幕显示内容如下：

第五行字符   第七行字符-->  即将显示

第二行字符   第四行字符-->  显示完毕

第三行字符   第五行字符

第四行字符   第六行字符

然后接下来又卷动16次，笔者的算法是，在每一次卷动后写一个字到显示完毕的那一行中，卷完16次，显示完毕的那一行也就写完了。然后接下来的16次卷动又写刚刚显示完毕的那一行，而刚被写完的那一行将在后面16次卷动中显示。

原理就是如此，然后从中提取出规律，设计出算法，并编程实现：

下面是程序实现：

void main(void){

 unsigned char code ser[] = {"一一一一一一一一二二二二二二二二叁叁叁叁叁叁叁叁四四四四四四四四中国中国中国中国"}; //这是要显示的字符串

//没有检测换行符功能，只能显示一长串的汉字或一串ASCII码字符。
 unsigned char i,addr,flag,hang,over,*ptdat;

//addr用于存储写入地址

//flag存储卷动地址，名字没取好！

//hang存储下一行要写入数据的行号（1~4）

//over记录写入的空字符数

//ptdat存储字符串的指针

 

 delay_12864(1000);
 initial_12864();

 

 ptdat = ser;
 over = 0;    //写入空字符数

 

//这里先把前面DDRAM中的前3行的字符数据写入

//如果字符不足<=4行，那么不卷动，之后字符>4行才卷动

//一直到末行显示完毕则停止卷动

 wrtcom_12864(0x80); //写屏幕第一行字符
 for(i = 0; i < 16; i++){
  if(*ptdat != '\0'){
   wrtdat_12864(*ptdat++);
  }else{
   wrtdat_12864(0x20);
   over++;
  }
 }
 wrtcom_12864(0x90); //写屏幕第二行字符

 for(i = 0; i < 16; i++){
  if(*ptdat != '\0'){
   wrtdat_12864(*ptdat++);
  }else{
   wrtdat_12864(0x20);
   over++;
  }
 }
 wrtcom_12864(0x88);//写屏幕第三行字符
 for(i = 0; i < 16; i++){
  if(*ptdat != '\0'){
   wrtdat_12864(*ptdat++);
  }else{
   wrtdat_12864(0x20);
   over++;
  }
 }
 wrtcom_12864(0x98);//写屏幕第四行字符
 for(i = 0; i < 16; i++){
  if(*ptdat != '\0'){
   wrtdat_12864(*ptdat++);
  }else{
   wrtdat_12864(0x20);
   over++;
  }
 }

 ptdat = ptdat - 32;
 wrtcom_12864(0xa0); //写DDRAM第3行数据
 for(i = 0; i < 16; i++){
  if(*ptdat != '\0'){
   wrtdat_12864(*ptdat++);
  }else{
   wrtdat_12864(0x20);
   over++;
  }
 }

 ptdat = ptdat + 16;
 for(i = 0; i < 16; i++){
  if(*ptdat != '\0'){
   wrtdat_12864(*ptdat++);
  }else{
   wrtdat_12864(0x20);
   over++;
  }
 }

//前面的代码是往DDRAM中写如下内容：

//第一行字符   第三行字符

//第二行字符   第四行字符

//第三行字符   第五行字符

//如果写第5行时全为空，说明字符刚好4行，不卷动。

//此时第5行写入16个0x20空字符，over用于记录空字符个数。

//如果不足4行，则前面也将会写入空字符，此时写完了3行DDRAM后

//over的值必大于16，而只要over>15，就不卷动

 

 wrtcom_12864(0x0c);   //开显示
 if(over > 15){;}   //显示字符不足4行，不卷动
 else      //显示字符大于4行，开启卷动
 {

  hang = 4;  //接下来要写DDRAM第4行数据
  flag = 0x01; //初始卷动地址为1
 
  while(1){
 
   switch(hang){   //设置写入DDRAM的地址
    
    case 1: addr = 0x80; break;  //往地址变量中写第一行首地址
    case 2: addr = 0x90; break;  //往地址变量中写第二行首地址
    case 3: addr = 0xa0; break;  //往地址变量中写第三行首地址
    case 4: addr = 0xb0; break;  //往地址变量中写第四行首地址

   }
 
   switch(hang){   //指出下一次要写的行地址
    
    case 1: hang = 2; break;//第1行写完了，下一行要写第2行
    case 2: hang = 3; break;//第2行写完了，下一行要写第3行
    case 3: hang = 4; break;//第3行写完了，下一行要写第4行
    case 4: hang = 1; break;//第4行写完了，下一行要写第1行  
   }

//后续代码为往每一行写数据，卷动一次写一个字。
   ptdat = ptdat - 32;
   for(i = 0; i < 8; i++){  //写一行中的前8个字符
    wrtcom_12864(0x34);     //打开扩展指令
    wrtcom_12864(0x03);     //允许输入卷动地址
    wrtcom_12864(0x40 + flag++);  //设置卷动地址
    wrtcom_12864(0x30);     //回到基本指令
    wrtcom_12864(addr + i);
    delay_12864(20000);
 
    if(*ptdat != '\0'){
     wrtdat_12864(*ptdat++);   //写入高字节
    }else{
     wrtdat_12864(0x20);    //字符串结束则写入空字符
    }         
            
    if(*ptdat != '\0'){
     wrtdat_12864(*ptdat++);   //写入低字节
    }else{
     wrtdat_12864(0x20);    //字符串结束则写入空字符
    }
 
   }
 
   ptdat = ptdat + 16;
   for(i = 8; i < 16; i++){  //写一行中的后8个字符
    wrtcom_12864(0x34);     //打开扩展指令
    wrtcom_12864(0x03);     //允许输入卷动地址
    if(flag == 64){flag = 0;}
    wrtcom_12864(0x40 + flag);   //设置卷动地址
    flag++;
    wrtcom_12864(0x30);     //回到基本指令
    wrtcom_12864(addr + i);
    delay_12864(20000);
 
    if(*ptdat != '\0'){
     wrtdat_12864(*ptdat++);   //写入高字节
    }else{
     over++;       //写完最后一行字符，需要再卷动16次才能显示出来。
     wrtdat_12864(0x20);      //字符串结束则写入空字符  
    }         
            
    if(*ptdat != '\0'){
     wrtdat_12864(*ptdat++);   //写入低字节
    }else{
     wrtdat_12864(0x20);       //字符串结束则写入空字符
    }
   }

   if(over < 8){;}
   else {break;}
  }
 }

 

while(1);
}

到这里所有的内容都介绍完了。

笔者愚钝，花了一个星期的时间琢磨它，本文就算是给自己的一个交代吧！