从业将近十年！手把手教你单片机程序框架（连载）

jianhong_wu

第七十节：深入讲解液晶屏的构字过程。

开场白：
    液晶屏模块本身带控制芯片，驱动液晶屏的本质就是单片机通过串行或者并行方式，根据芯片资料指定的协议跟液晶芯片进行通讯的过程。这个详细的通讯协议驱动程序厂家都会免费提供的，也可以在网上找到大量的示范程序。那么我们最应该关注的核心是什么？我认为最核心的是要理清楚程序坐标与实际显示坐标之间的关系规律。本程序不使用模块自带的字库，而是使用自己构造的字库，目的就是为了让读者理解更底层的字模显示。
这一节要教会大家三个知识点：
第一个：对于驱动芯片是st7920的12864液晶屏，它的真实坐标体系的本质是256x32的点阵液晶屏。
第二个：鸿哥刻意在驱动显示函数里增加了大延时函数，目的是通过慢镜头回放，让大家观察到横向取模的字是如何一个字节一个字节构建而成的。
第三个：数组带const关键字，表示数据常量存放在ROM程序区，不占用RAM的变量。

具体内容，请看源代码讲解。

（1）硬件平台：
     基于坚鸿51单片机学习板。

（2）实现功能：开机上电后，可以观察到0x01,0x02,0x03,0x04这4个显示数字在不同的排列方式下，出现在不同的液晶屏显示位置。也可以观察到“馒头”这两个字是如何一个字节一个字节构建而成的，加深理解字模数组跟显示现象的关系。
   
（3）源代码讲解如下：
#include "REG52.H"


sbit  LCDCS_dr  = P1^6;  //片选线
sbit  LCDSID_dr = P1^7;  //串行数据线
sbit  LCDCLK_dr = P3^2;  //串行时钟线
sbit  LCDRST_dr = P3^4;  //复位线

void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount); //显示任意点阵函数
void display_clear(void); // 清屏

void delay_short(unsigned int uiDelayshort); //延时

/* 注释一：
* 数组带const关键字，表示数据常量存放在ROM程序区，不占用RAM的变量
*/
const unsigned char Hz1616_man[]= /*馒   横向取模  16X16点阵 网上有很多免费的字模软件生成字模数组 */
{
0x21,0xF8,0x21,0x08,0x21,0xF8,0x3D,0x08,0x45,0xF8,0x48,0x00,0x83,0xFC,0x22,0x94,
0x23,0xFC,0x20,0x00,0x21,0xF8,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x00,0x00,
};

const unsigned char Hz1616_tou[]= /*头   横向取模  16X16点阵 网上有很多免费的字模软件生成字模数组 */
{
0x00,0x80,0x10,0x80,0x0C,0x80,0x04,0x80,0x10,0x80,0x0C,0x80,0x08,0x80,0x00,0x80,
0xFF,0xFE,0x00,0x80,0x01,0x40,0x02,0x20,0x04,0x30,0x08,0x18,0x10,0x0C,0x20,0x08,
};

/* 注释二：
* 为了方便观察字模的数字与显示的关系，以下3个数组的本质是完全一样的，只是排列不一样而已。
*/
const unsigned char Byte_1[]=  //4横，1列
{
0x01,0x02,0x03,0x04,
};

const unsigned char Byte_2[]= //2横，2列
{
0x01,0x02,
0x03,0x04,
};

const unsigned char Byte_3[]= //1横，4列
{
0x01,
0x02,
0x03,
0x04,
};


void main()
  {
        LCDInit(); //初始化12864 内部包含液晶模块的复位

    display_clear(); // 清屏

        display_lattice(0,0,Byte_1,0,4,1);    //显示<4横，1列>的数组数字
        display_lattice(0,16,Byte_1,1,4,1);   //显示<4横，1列>的数组数字 反显

        display_lattice(7,0,Byte_2,0,2,2);   //显示<2横，2列>的数组数字
        display_lattice(7,16,Byte_2,1,2,2);  //显示<2横，2列>的数组数字 反显

        display_lattice(8,0,Byte_3,0,1,4);  //显示<1横，4列>的数组数字
        display_lattice(8,16,Byte_3,1,1,4); //显示<1横，4列>的数组数字 反显

        display_lattice(14,0,Hz1616_man,0,2,16);  //显示<馒>字
        display_lattice(15,0,Hz1616_tou,0,2,16);  //显示<头>字
        display_lattice(14,16,Hz1616_man,1,2,16); //显示<馒>字 反显
        display_lattice(15,16,Hz1616_tou,1,2,16); //显示<头>字 反显
    while(1)  
    {
       ;
    }

}

/* 注释三：真实坐标体系的本质。
* 从坐标体系的角度来看，本液晶屏表面上是128x64的液晶屏，实际上可以看做是256x32的液晶屏。
* 把256x32的液晶屏分左右两半，把左半屏128x32放在上面，把右半屏128x32放下面，就合并成了
* 一个128x64的液晶屏。由于液晶模块内部控制器的原因，虽然横向有256个点阵，但是我们的x轴
* 坐标没办法精确到每个点，只能以16个点(2个字节)为一个单位，因此256个点的x轴坐标范围是0至15。
* 而y轴的坐标可以精确到每个点为一行，所以32个点的y轴坐标范围是0至31.
*/

void display_clear(void) // 清屏
{   

        unsigned char x,y;
  //  WriteCommand(0x34);  //关显示缓冲指令            
    WriteCommand(0x36); //这次为了观察每个数字在显示屏上的关系，所以把这个显示缓冲的命令提前打开，下一节放到本函数最后
         y=0;
        while(y<32)  //y轴的范围0至31
    {
                 WriteCommand(y+0x80);        //垂直地址
         WriteCommand(0x80);          //水平地址
         for(x=0;x<32;x++)  //256个横向点，有32个字节
         {  
            LCDWriteData(0x00);
             }
                 y++;
    }


}


/* 注释四：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
* 本函数后面故意增加一个长延时delay_short(30000)，是为了方便读者观察横向取模的
* 字是如何一个字节一个字节构建而成的。
*/
void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
{
   unsigned int j=0;
   unsigned int i=0;
   unsigned char ucTemp;
//  WriteCommand(0x34);   //关显示缓冲指令   
   WriteCommand(0x36);  //这次为了观察每个数字在显示屏上的关系，所以把这个显示缓冲的命令提前打开，下一节放到本函数最后
   for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
   {
       WriteCommand(y+j+0x80);        //垂直地址
       WriteCommand(x+0x80);          //水平地址
       for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
       {
         ucTemp=ucArray[j*x_amount+i];
             if(ucFbFlag==1)  //反白显示
                 {
            ucTemp=~ucTemp;
         }
             LCDWriteData(ucTemp);
                 delay_short(30000);  //本函数故意增加这个长延时，是为了方便读者观察横向取模的字是如何一个字节一个字节构建而成的。
      }
   }

}

/* 注释五：
* 以下是液晶屏模块的驱动程序，我觉得没有什么好讲的，因为我是直接在网上寻找现成的驱动时序修改而成。
* 它的本质就是单片机跟这个液晶模块芯片进行串行通信。
*/
void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
{
        unsigned char i;
        for ( i = 0; i < 8; i++ )
        {
                if ( (ucData << i) & 0x80 )
                {
                        LCDSID_dr = 1;
                }
                else
                {
                        LCDSID_dr = 0;
                }
                LCDCLK_dr = 0;
                LCDCLK_dr = 1;
        }
}

void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
{
        SendByteToLcd( 0xf8 + (ucWRS << 1) );
        SendByteToLcd( ucWData & 0xf0 );
        SendByteToLcd( (ucWData << 4) & 0xf0);
}


void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
{

        LCDCS_dr = 0;
        LCDCS_dr = 1;
        SPIWrite(ucCommand, 0);
        delay_short(90);
}

void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
{
        LCDCS_dr = 0;
        LCDCS_dr = 1;
        SPIWrite(ucData, 1);
}

void LCDInit(void) //初始化  函数内部包括液晶模块的复位
{
        LCDRST_dr = 1;  //复位
        LCDRST_dr = 0;
        LCDRST_dr = 1;
}



void delay_short(unsigned int uiDelayShort) //延时函数
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;  
   }
}

总结陈词：
这节重点讲了液晶屏的构字过程，下节将会在本节的基础上，略作修改，显示常用的不同点阵字模。欲知详情，请听下回分解-----液晶屏的字符，16点阵，24点阵和32点阵的显示程序。

（未完待续，下节更精彩，不要走开哦）

KR770906

鸿哥，ds1302芯片内置万年历和电池，好像不用判断闰月，直接对时就可以使用了。不知对否？

jianhong_wu

KR770906 发表于 2014-9-25 08:43
鸿哥，ds1302芯片内置万年历和电池，好像不用判断闰月，直接对时就可以使用了。不知对否？

（1）DS1302没有内置电池。
（2）从DS1302读取的数据是不用判断闰月的，但是你往里面写入修改的时间数据时，建议还是判断一下，因为假如你不判断就写入一个错误的时间，我不知道ds1302内部会怎么处理。

jianhong_wu

第七十一节：液晶屏的字符，16点阵，24点阵和32点阵的显示程序。

开场白：

这一节要教会大家二个知识点：

第一个：如何利用任意点阵字体显示函数display_lattice来显示8x16的字符，16点阵汉字，24点阵汉字和32点阵汉字。

第二个：纠正上一节的一个小错误。C51编译器跟其它单片机的编译器有点不一样。想把常量数据保存在ROM程序存储区里并不是用const关键字，而是是用code关键字。

具体内容，请看源代码讲解。

（1）硬件平台：
    基于坚鸿51单片机学习板。

（2）实现功能：开机上电后，可以看到液晶屏分别显示32点阵，24点阵和16点阵的“馒头”两个字，还有“V5”这两个8x16点阵的字符。

   

（3）源代码讲解如下：

#include "REG52.H"

sbit  LCDCS_dr  = P1^6;  //片选线
sbit  LCDSID_dr = P1^7;  //串行数据线
sbit  LCDCLK_dr = P3^2;  //串行时钟线
sbit  LCDRST_dr = P3^4;  //复位线

void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount); //显示任意点阵函数
void display_clear(void); // 清屏

void delay_short(unsigned int uiDelayshort); //延时

/* 注释一：
* 纠正上一节的一个小错误。C51编译器跟其它的编译器有点不一样。
* 存在ROM程序存储区里的常量数据并不是用const关键字，而是是用code关键字。
*/
code unsigned char Hz3232_man[]= /*馒   横向取模  32x32点阵 */
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x07,0x03,0x00,0x0F,0x87,0xFF,0x80,
0x0F,0x07,0x03,0x80,0x0E,0x07,0x03,0x80,0x0E,0x37,0xFF,0x80,0x1C,0x7F,0x03,0x80,
0x1F,0xFF,0x03,0x80,0x18,0x77,0xFF,0x00,0x38,0xE0,0x00,0xC0,0x36,0xDF,0xFF,0xF0,
0x77,0x9C,0xCE,0xE0,0x67,0x1C,0xCE,0xE0,0xC7,0x1C,0xCE,0xE0,0x07,0x1C,0xCE,0xE0,
0x07,0x1F,0xFF,0xE0,0x07,0x18,0x00,0x00,0x07,0x00,0x03,0x80,0x07,0x0F,0xFF,0xC0,
0x07,0x71,0x8F,0x00,0x07,0xE0,0xDE,0x00,0x07,0xC0,0xFC,0x00,0x07,0x80,0x78,0x00,
0x0F,0x01,0xFE,0x00,0x07,0x03,0x8F,0xE0,0x00,0x1E,0x03,0xF0,0x00,0xF8,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};


code unsigned char Hz3232_tou[]= /*头   横向取模  32x32点阵 */
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xC0,0x00,0x00,0x03,0xE0,0x00,
0x03,0xC3,0xC0,0x00,0x00,0xF3,0x80,0x00,0x00,0x7B,0x80,0x00,0x00,0x7B,0x80,0x00,
0x00,0x3B,0x80,0x00,0x0E,0x03,0x80,0x00,0x07,0x83,0x80,0x00,0x03,0xC3,0x80,0x00,
0x01,0xE3,0x80,0x00,0x01,0xE3,0x80,0x00,0x00,0xC3,0x80,0x00,0x00,0x03,0x81,0xE0,
0x7F,0xFF,0xFF,0xF0,0x00,0x07,0x80,0x30,0x00,0x07,0x00,0x00,0x00,0x07,0x80,0x00,
0x00,0x0E,0xE0,0x00,0x00,0x1E,0x7C,0x00,0x00,0x3C,0x1F,0x00,0x00,0x78,0x0F,0xC0,
0x00,0xF0,0x03,0xC0,0x03,0xC0,0x01,0xE0,0x0F,0x00,0x00,0xE0,0x78,0x00,0x00,0x00,
0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};

code unsigned char Hz2424_man[]= /*馒   横向取模  24x24点阵 */
{
0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x18,0x30,0x1E,0x1F,0xF8,0x1C,0x1C,0x38,0x1C,
0x1F,0xF8,0x19,0xFC,0x38,0x3F,0xFF,0xF8,0x31,0x98,0x30,0x7B,0xE0,0x0E,0x6F,0x7F,
0xFE,0x6E,0x76,0xEE,0xCC,0x76,0xEE,0x0C,0x7F,0xFE,0x0C,0x70,0x0C,0x0C,0x00,0x38,
0x0C,0x3F,0xF8,0x0D,0xCE,0x70,0x0F,0x87,0xE0,0x0F,0x03,0x80,0x1E,0x07,0xE0,0x0C,
0x1C,0x7E,0x01,0xF0,0x1F,0x00,0x00,0x00,
};


code unsigned char Hz2424_tou[]= /*头   横向取模  24x24点阵 */
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0E,0x00,0x06,0x0F,0x00,0x07,0x8E,0x00,0x01,
0xEE,0x00,0x00,0xEE,0x00,0x00,0xEC,0x00,0x1C,0x0C,0x00,0x0F,0x0C,0x00,0x07,0x9C,
0x00,0x03,0x9C,0x00,0x00,0x1C,0x0C,0x00,0x1C,0x1E,0x7F,0xFF,0xF6,0x00,0x1C,0x00,
0x00,0x3C,0x00,0x00,0x3F,0x80,0x00,0x71,0xE0,0x00,0xE0,0xF8,0x01,0xC0,0x3C,0x07,
0x00,0x1C,0x3C,0x00,0x0C,0x70,0x00,0x00,
};


code unsigned char Hz1616_man[]= /*馒   横向取模  16X16点阵 */
{
0x21,0xF8,0x21,0x08,0x21,0xF8,0x3D,0x08,0x45,0xF8,0x48,0x00,0x83,0xFC,0x22,0x94,
0x23,0xFC,0x20,0x00,0x21,0xF8,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x00,0x00,
};

code unsigned char Hz1616_tou[]= /*头   横向取模  16X16点阵 */
{
0x00,0x80,0x10,0x80,0x0C,0x80,0x04,0x80,0x10,0x80,0x0C,0x80,0x08,0x80,0x00,0x80,
0xFF,0xFE,0x00,0x80,0x01,0x40,0x02,0x20,0x04,0x30,0x08,0x18,0x10,0x0C,0x20,0x08,
};

code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 */
{
0x00,0x00,0x00,0xE7,0x42,0x42,0x44,0x24,0x24,0x28,0x28,0x18,0x10,0x10,0x00,0x00,
};

code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 */
{
0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};



void main()
  {
        LCDInit(); //初始化12864 内部包含液晶模块的复位

    display_clear(); // 清屏

        display_lattice(0,0,Hz3232_man,0,4,32);  //显示32点阵的<馒>字
        display_lattice(2,0,Hz3232_tou,0,4,32);  //显示32点阵的<头>字

        display_lattice(4,0,Hz2424_man,0,3,24);  //显示24点阵的<馒>字
        display_lattice(6,0,Hz2424_tou,0,3,24);  //显示24点阵的<头>字

        display_lattice(8,0,Hz1616_man,0,2,16);  //显示16点阵的<馒>字
        display_lattice(9,0,Hz1616_tou,0,2,16);  //显示16点阵的<头>字

        display_lattice(11,0,Zf816_V,0,1,16);  //显示8x16点阵的<V>字符
        display_lattice(12,0,Zf816_5,0,1,16);  //显示8x16点阵的<5>字符

    while(1)  
    {
       ;
    }

}



void display_clear(void) // 清屏
{   

        unsigned char x,y;
    WriteCommand(0x34);  //关显示缓冲指令            
    WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
         y=0;
        while(y<32)  //y轴的范围0至31
    {
                 WriteCommand(y+0x80);        //垂直地址
         WriteCommand(0x80);          //水平地址
         for(x=0;x<32;x++)  //256个横向点，有32个字节
         {  
            LCDWriteData(0x00);
             }
                 y++;
    }
    WriteCommand(0x36); //开显示缓冲指令

}


/* 注释二：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
*/
void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
{
   unsigned int j=0;
   unsigned int i=0;
   unsigned char ucTemp;
   WriteCommand(0x34);  //关显示缓冲指令            
   WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
   for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
   {
       WriteCommand(y+j+0x80);        //垂直地址
       WriteCommand(x+0x80);          //水平地址
       for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
       {
         ucTemp=ucArray[j*x_amount+i];
             if(ucFbFlag==1)  //反白显示
                 {
            ucTemp=~ucTemp;
         }
             LCDWriteData(ucTemp);
          //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
      }
   }
   WriteCommand(0x36); //开显示缓冲指令
}


void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
{
        unsigned char i;
        for ( i = 0; i < 8; i++ )
        {
                if ( (ucData << i) & 0x80 )
                {
                        LCDSID_dr = 1;
                }
                else
                {
                        LCDSID_dr = 0;
                }
                LCDCLK_dr = 0;
                LCDCLK_dr = 1;
        }
}

void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
{
        SendByteToLcd( 0xf8 + (ucWRS << 1) );
        SendByteToLcd( ucWData & 0xf0 );
        SendByteToLcd( (ucWData << 4) & 0xf0);
}


void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
{

        LCDCS_dr = 0;
        LCDCS_dr = 1;
        SPIWrite(ucCommand, 0);
        delay_short(90);
}

void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
{
        LCDCS_dr = 0;
        LCDCS_dr = 1;
        SPIWrite(ucData, 1);
}

void LCDInit(void) //初始化  函数内部包括液晶模块的复位
{
        LCDRST_dr = 1;  //复位
        LCDRST_dr = 0;
        LCDRST_dr = 1;
}



void delay_short(unsigned int uiDelayShort) //延时函数
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;  
   }
}

总结陈词：

    我们现在讲的字体显示都是横向的，如果某个项目要把整个液晶屏顺时针旋转90度，要求像对联一样纵向显示一串字体的时候，该怎么办？我前两个月就遇到了这样的项目，当时我的做法就是把字体的字库数组通过算法旋转90度就达到了目的。这种算法程序是怎样编写的？欲知详情，请听下回分解-----把字体顺时针旋转90度显示的算法程序。

（未完待续，下节更精彩，不要走开哦）

KR770906

ds1302写入数据鸿哥想得周全，对的，判断一下数据。

又一个暑假

鸿哥下次能不能把把整个工程文件夹压缩好附在后面传上来啊，在这里复制代码自己在建个工程挺懒的

jianhong_wu

又一个暑假 发表于 2014-10-6 12:14
鸿哥下次能不能把把整个工程文件夹压缩好附在后面传上来啊，在这里复制代码自己在建个工程挺懒的

我的都是一个源文件的，复制很简单的。你的请求被驳回了。

又一个暑假

jianhong_wu 发表于 2014-10-6 12:29
我的都是一个源文件的，复制很简单的。你的请求被驳回了。

我以为你后期要用多文件来编

jianhong_wu

第七十二节：在液晶屏中把字体顺时针旋转90度显示的算法程序。

开场白：

我曾经遇到过这样的项目，客户由于外壳结果的原因，故意把液晶屏物理位置逆时针旋转了90度，在这种情况下，如果按之前的显示驱动就会发现字体也跟着倒了过来，影响了阅读。当时我的解决办法就是把字体的字库数组通过算法顺时针旋转90度就达到了目的。这一节把这个算法教给大家。

这个算法的本质是：请看以下附图1，附图2，附图3.

第一步：旋转90度的本质，就是把原来横向取模改成纵向去模。先把代表每一行16个点阵数的2个char型数据合并成1个int型数据。

第二步：再把每一列的16个点阵按2个字节分别取到一个数组里，就是纵向取模的过程了。

具体内容，请看源代码讲解。

（1）硬件平台：
    基于坚鸿51单片机学习板。

（2）实现功能：把液晶屏物理位置逆时针旋转了90度，开机上电后，可以看到液晶屏像对联的显示顺序一样，从上往下分别显示“馒头V5”四个字。

   

（3）源代码讲解如下：

1. #include "REG52.H"
   
2. 
   
3. sbit  LCDCS_dr  = P1^6;  //片选线
   
4. sbit  LCDSID_dr = P1^7;  //串行数据线
   
5. sbit  LCDCLK_dr = P3^2;  //串行时钟线
   
6. sbit  LCDRST_dr = P3^4;  //复位线
   
7. 
   
8. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
   
9. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
   
10. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
    
11. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
    
12. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
    
13. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount); //显示任意点阵函数
    
14. void display_clear(void); // 清屏
    
15. void hz1616_s90(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把16x16汉字字模顺时针旋转90度的转换函数
    
16. void hz816_s90(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把8x16字符字模顺时针旋转90度的转换函数
    
17. 
    
18. void delay_short(unsigned int uiDelayshort); //延时
    
19. 
    
20. code unsigned char Hz1616_man[]= /*馒   横向取模  16X16点阵 */
    
21. {
    
22. 0x21,0xF8,0x21,0x08,0x21,0xF8,0x3D,0x08,0x45,0xF8,0x48,0x00,0x83,0xFC,0x22,0x94,
    
23. 0x23,0xFC,0x20,0x00,0x21,0xF8,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x00,0x00,
    
24. };
    
25. 
    
26. code unsigned char Hz1616_tou[]= /*头   横向取模  16X16点阵 */
    
27. {
    
28. 0x00,0x80,0x10,0x80,0x0C,0x80,0x04,0x80,0x10,0x80,0x0C,0x80,0x08,0x80,0x00,0x80,
    
29. 0xFF,0xFE,0x00,0x80,0x01,0x40,0x02,0x20,0x04,0x30,0x08,0x18,0x10,0x0C,0x20,0x08,
    
30. };
    
31. 
    
32. 
    
33. code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 */
    
34. {
    
35. 0x00,0x00,0x00,0xE7,0x42,0x42,0x44,0x24,0x24,0x28,0x28,0x18,0x10,0x10,0x00,0x00,
    
36. };
    
37. 
    
38. code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 */
    
39. {
    
40. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
    
41. };
    
42. 
    
43. 
    
44. unsigned char ucBufferResult[32]; //用于临时存放转换结束后的字模数组
    
45. 
    
46. void main()
    
47.   {
    
48.         LCDInit(); //初始化12864 内部包含液晶模块的复位
    
49. 
    
50.         display_clear(); // 清屏
    
51. 
    
52. /* 注释一：
    
53. * (1)把原来的液晶屏物理位置逆时针旋转90度后，从上往下阅读，类似对联的阅读习惯。所以请注意坐标体系参数的变化。
    
54. * (2)为了让字符居中显示，请注意在显示V和5两个字符时坐标体系的变化。
    
55. * (3)字符8x16经过旋转处理后，变成了16x8，在调用display_lattice函数时，要注意修改响应的参数。
    
56. */
    
57. 
    
58.         hz1616_s90(Hz1616_man,ucBufferResult);  //把<馒>字顺时针旋转90度放到ucBufferResult临时变量里。
    
59.         display_lattice(7,0,ucBufferResult,0,2,16);  //显示旋转90度后的<馒>字
    
60. 
    
61.         hz1616_s90(Hz1616_tou,ucBufferResult);  //把<头>字顺时针旋转90度放到ucBufferResult临时变量里。
    
62.         display_lattice(6,0,ucBufferResult,0,2,16);  //显示旋转90度后的<头>字
    
63. 
    
64. 
    
65.         hz816_s90(Zf816_V,ucBufferResult);  //把<V>字符顺时针旋转90度放到ucBufferResult临时变量里。
    
66.         display_lattice(5,4,ucBufferResult,0,2,8);  //显示旋转90度后的<V>字符。注意在最后两个个参数，2表示每一行有2个字节，8表示8列。第二个坐标参数4是为了偏移居中显示。
    
67. 
    
68.         hz816_s90(Zf816_5,ucBufferResult);  //把<5>字符顺时针旋转90度放到ucBufferResult临时变量里。
    
69.         display_lattice(4,4,ucBufferResult,0,2,8);  //显示旋转90度后的<5>字符。注意在最后两个个参数，2表示每一行有2个字节，8表示8列。第二个坐标参数4是为了偏移居中显示。
    
70. 
    
71. 
    
72.     while(1)  
    
73.     {
    
74.        ;
    
75.     }
    
76. 
    
77. }
    
78. 
    
79. 
    
80. 
    
81. void display_clear(void) // 清屏
    
82. {   
    
83. 
    
84.     unsigned char x,y;
    
85.     WriteCommand(0x34);  //关显示缓冲指令            
    
86.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
    
87.     y=0;
    
88.     while(y<32)  //y轴的范围0至31
    
89.     {
    
90.          WriteCommand(y+0x80);        //垂直地址
    
91.          WriteCommand(0x80);          //水平地址
    
92.          for(x=0;x<32;x++)  //256个横向点，有32个字节
    
93.          {  
    
94.             LCDWriteData(0x00);
    
95.          }
    
96.          y++;
    
97.     }
    
98.     WriteCommand(0x36); //开显示缓冲指令
    
99. 
    
100. }
     
101. 
     
102. 
     
103. /* 注释二：
     
104. * 把16x16汉字字模顺时针旋转90度的步骤：请看附图1，附图2，附图3.
     
105. * 第一步：旋转90度的本质，就是把原来横向取模改成纵向去模。先把代表每一行16个点阵数的2个char型数据合并成1个int型数据。
     
106. * 第二步：再把每一列的16个点阵按2个字节分别取到一个数组里，就是纵向取模的过程了。以下程序int型数据每取8个数据的最高位，
     
107. * 就左移一次，本质就是纵向取模的过程。
     
108. */
     
109. void hz1616_s90(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把16x16汉字字模顺时针旋转90度的转换函数
     
110. {
     
111.          unsigned char a;
     
112.          unsigned char b;
     
113.          unsigned char c;
     
114.      unsigned int uiBuffer[16];  //注意，是int类型数据，一个数据包含2个字节。
     
115.        
     
116.          for(a=0;a<16;a++) //把原来以字节为单位的字库每一行的2个字节合并成1个int型数据。放到一个包含16个int类型的数组里，为旋转90度算法处理做准备
     
117.          {
     
118.          uiBuffer[a]=p_ucHz[a*2];
     
119.                  uiBuffer[a]=uiBuffer[a]<<8;
     
120.                  uiBuffer[a]=uiBuffer[a]+p_ucHz[a*2+1];
     
121.      }
     
122.          
     
123.          c=0;
     
124.          for(a=0;a<16;a++)  //这里的16代表16列
     
125.          {
     
126.                  for(b=0;b<8;b++)   //每一列中有16个点，有2个字节，这里的8代表第一个字节的8个位或点。
     
127.                  {
     
128.                           p_ucResult[c]=p_ucResult[c]<<1;   
     
129.               p_ucResult[c]=p_ucResult[c]&0xfe;                 
     
130.               if(uiBuffer[15-b]>=0x8000)    //注意，int类型数据的判断是0x8000,char型的是0x80
     
131.                       {
     
132.                  p_ucResult[c]=p_ucResult[c]+1;
     
133.               }
     
134.                       uiBuffer[15-b]=uiBuffer[15-b]<<1;
     
135.          }
     
136.                  c++;
     
137.                  
     
138.                  for(b=0;b<8;b++) //每一列中有16个点，有2个字节，这里的8代表第二个字节的8个位或点。
     
139.                  {
     
140.                           p_ucResult[c]=p_ucResult[c]<<1;  
     
141.               p_ucResult[c]=p_ucResult[c]&0xfe;                                          
     
142.               if(uiBuffer[7-b]>=0x8000)      
     
143.                       {
     
144.                    p_ucResult[c]=p_ucResult[c]+1;
     
145.               }
     
146.                              uiBuffer[7-b]=uiBuffer[7-b]<<1;
     
147.          }
     
148.                  c++;
     
149.     }
     
150.          
     
151. }
     
152. 
     
153. 
     
154. /* 注释三：
     
155. * 把8x16字符字模顺时针旋转90度的步骤：
     
156. * 第一步：旋转90度的本质，就是把原来横向取模改成纵向去模。由于原来的字库存放在带code关键字的ROM区，只能读不能写，所以
     
157. * 先把原来的字模数组读取出来，放到一个变量缓冲区里。
     
158. * 第二步：再把每一列的16个点阵按2个字节分别取到一个数组里，就是纵向取模的过程了。以下程序int型数据每取8个数据的最高位，
     
159.    就左移一次，本质就是纵向取模的过程。
     
160. */
     
161. void hz816_s90(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把8x16字符字模顺时针旋转90度的转换函数
     
162. {
     
163.          unsigned char a;
     
164.          unsigned char b;
     
165.          unsigned char c;
     
166.      unsigned char uiBuffer[16]; //注意，跟16x16点阵不一样，这里是char数据。因为横向的只有8个点
     
167.        
     
168.          for(a=0;a<16;a++) //把存放在ROM的字库放到一个16个char类型的数组里
     
169.          {
     
170.          uiBuffer[a]=p_ucHz[a];
     
171.      }
     
172.          
     
173.          c=0;
     
174.          for(a=0;a<8;a++)  //这里的8代表8列
     
175.          {
     
176.                  for(b=0;b<8;b++)  //每一列中有16个点，有2个字节，这里的8代表第一个字节的8个位或点。
     
177.                  {
     
178.                           p_ucResult[c]=p_ucResult[c]<<1;
     
179.               p_ucResult[c]=p_ucResult[c]&0xfe;                                         
     
180.               if(uiBuffer[15-b]>=0x80)   //注意，int类型数据的判断是0x8000,char型的是0x80
     
181.                         {
     
182.                   p_ucResult[c]=p_ucResult[c]+1;
     
183.               }
     
184.                       uiBuffer[15-b]=uiBuffer[15-b]<<1;
     
185.          }
     
186.                c++;
     
187.                  
     
188.                  for(b=0;b<8;b++)  //每一列中有16个点，有2个字节，这里的8代表第二个字节的8个位或点。
     
189.                  {
     
190.                           p_ucResult[c]=p_ucResult[c]<<1;
     
191.               p_ucResult[c]=p_ucResult[c]&0xfe;                                         
     
192.               if(uiBuffer[7-b]>=0x80)   //注意，int类型数据的判断是0x8000,char型的是0x80
     
193.                           {
     
194.                  p_ucResult[c]=p_ucResult[c]+1;
     
195.               }
     
196.                           uiBuffer[7-b]=uiBuffer[7-b]<<1;
     
197.          }
     
198.                  c++;
     
199.      }
     
200.          
     
201. }
     
202. 
     
203. 
     
204. 
     
205. /* 注释四：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
206. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
     
207. * 第3个参数*ucArray是字模的数组。
     
208. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
209. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
210. */
     
211. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
     
212. {
     
213.    unsigned int j=0;
     
214.    unsigned int i=0;
     
215.    unsigned char ucTemp;
     
216.    WriteCommand(0x34);  //关显示缓冲指令            
     
217.    WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
218.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
     
219.    {
     
220.        WriteCommand(y+j+0x80);        //垂直地址
     
221.        WriteCommand(x+0x80);          //水平地址
     
222.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
     
223.        {
     
224.          ucTemp=ucArray[j*x_amount+i];
     
225.              if(ucFbFlag==1)  //反白显示
     
226.                  {
     
227.             ucTemp=~ucTemp;
     
228.          }
     
229.              LCDWriteData(ucTemp);
     
230.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
     
231.       }
     
232.    }
     
233.    WriteCommand(0x36); //开显示缓冲指令
     
234. }
     
235. 
     
236. 
     
237. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
     
238. {
     
239.         unsigned char i;
     
240.         for ( i = 0; i < 8; i++ )
     
241.         {
     
242.                 if ( (ucData << i) & 0x80 )
     
243.                 {
     
244.                         LCDSID_dr = 1;
     
245.                 }
     
246.                 else
     
247.                 {
     
248.                         LCDSID_dr = 0;
     
249.                 }
     
250.                 LCDCLK_dr = 0;
     
251.                 LCDCLK_dr = 1;
     
252.         }
     
253. }
     
254. 
     
255. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
     
256. {
     
257.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
     
258.         SendByteToLcd( ucWData & 0xf0 );
     
259.         SendByteToLcd( (ucWData << 4) & 0xf0);
     
260. }
     
261. 
     
262. 
     
263. void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
     
264. {
     
265. 
     
266.         LCDCS_dr = 0;
     
267.         LCDCS_dr = 1;
     
268.         SPIWrite(ucCommand, 0);
     
269.         delay_short(90);
     
270. }
     
271. 
     
272. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
     
273. {
     
274.         LCDCS_dr = 0;
     
275.         LCDCS_dr = 1;
     
276.         SPIWrite(ucData, 1);
     
277. }
     
278. 
     
279. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
     
280. {
     
281.         LCDRST_dr = 1;  //复位
     
282.         LCDRST_dr = 0;
     
283.         LCDRST_dr = 1;
     
284. }
     
285. 
     
286. 
     
287. 
     
288. void delay_short(unsigned int uiDelayShort) //延时函数
     
289. {
     
290.    unsigned int i;  
     
291.    for(i=0;i<uiDelayShort;i++)
     
292.    {
     
293.      ;  
     
294.    }
     
295. }
     

复制代码

总结陈词：

    有的项目会要求把字体或者图像进行镜像显示处理，这种算法程序是怎样编写的？欲知详情，请听下回分解-----在液晶屏中把字体镜像显示的算法程序。

（未完待续，下节更精彩，不要走开哦）

海~~

非常有用啊，鸿哥。

jianhong_wu

海~~ 发表于 2014-10-10 12:48
非常有用啊，鸿哥。

那当然，我分享的都是实际项目的经验，不是精华我不发。

KR770906

十一大假后鸿哥又出手了，呵呵。

jianhong_wu

KR770906 发表于 2014-10-11 21:30
十一大假后鸿哥又出手了，呵呵。

一直会有的，根本停不下来。

jianhong_wu

第七十三节：在液晶屏中把字体镜像显示的算法程序。

开场白：
有的项目会要求把字体或者图像进行镜像显示处理，这一节把这个算法教给大家。
    这个算法的本质是：
16x16点阵的图像或者字体有16行，每行有2个字节，如果把这2个字节看成是一个16位int型数据，那么就是要这个数据从原来左边是高位，右边是低位的顺序颠倒过来。本程序没有把2个字节合并成一个int型数据，而是直接在一个字节数据内把高低位顺序颠倒过来，然后把第1字节数据跟第2字节数据交换。
8x16点阵的图像或者字体有16行，每行有1个字节，把这个数据从原来左边是高位，右边是低位的顺序颠倒过来。
具体内容，请看源代码讲解。

（1）硬件平台：
     基于坚鸿51单片机学习板。

（2）实现功能：开机上电后，从上往下分别显示“馒头V5”四个字以及右边镜像后的“馒头V5”四个字。
   
（3）源代码讲解如下：

1. #include "REG52.H"
   
2. 
   
3. sbit  LCDCS_dr  = P1^6;  //片选线
   
4. sbit  LCDSID_dr = P1^7;  //串行数据线
   
5. sbit  LCDCLK_dr = P3^2;  //串行时钟线
   
6. sbit  LCDRST_dr = P3^4;  //复位线
   
7. 
   
8. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
   
9. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
   
10. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
    
11. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
    
12. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
    
13. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount); //显示任意点阵函数
    
14. void display_clear(void); // 清屏
    
15. void hz1616_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把16x16点阵字库镜像
    
16. void hz816_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把8x16点阵字库镜像
    
17. 
    
18. void delay_short(unsigned int uiDelayshort); //延时
    
19. 
    
20. code unsigned char Hz1616_man[]= /*馒   横向取模  16X16点阵 */
    
21. {
    
22. 0x21,0xF8,0x21,0x08,0x21,0xF8,0x3D,0x08,0x45,0xF8,0x48,0x00,0x83,0xFC,0x22,0x94,
    
23. 0x23,0xFC,0x20,0x00,0x21,0xF8,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x00,0x00,
    
24. };
    
25. 
    
26. code unsigned char Hz1616_tou[]= /*头   横向取模  16X16点阵 */
    
27. {
    
28. 0x00,0x80,0x10,0x80,0x0C,0x80,0x04,0x80,0x10,0x80,0x0C,0x80,0x08,0x80,0x00,0x80,
    
29. 0xFF,0xFE,0x00,0x80,0x01,0x40,0x02,0x20,0x04,0x30,0x08,0x18,0x10,0x0C,0x20,0x08,
    
30. };
    
31. 
    
32. 
    
33. code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 */
    
34. {
    
35. 0x00,0x00,0x00,0xE7,0x42,0x42,0x44,0x24,0x24,0x28,0x28,0x18,0x10,0x10,0x00,0x00,
    
36. };
    
37. 
    
38. code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 */
    
39. {
    
40. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
    
41. };
    
42. 
    
43. 
    
44. unsigned char ucBufferResult[32]; //用于临时存放转换结束后的字模数组
    
45. 
    
46. void main()
    
47.   {
    
48.         LCDInit(); //初始化12864 内部包含液晶模块的复位
    
49. 
    
50.         display_clear(); // 清屏
    
51. 
    
52.         display_lattice(0,0,Hz1616_man,0,2,16);  //显示镜像前的<馒>字
    
53.         hz1616_mirror(Hz1616_man,ucBufferResult);  //把<馒>字镜像后放到ucBufferResult临时变量里。
    
54.         display_lattice(1,0,ucBufferResult,0,2,16);  //显示镜像后的<馒>字
    
55. 
    
56. 
    
57.         display_lattice(0,16,Hz1616_tou,0,2,16);  //显示镜像前的<头>字
    
58.         hz1616_mirror(Hz1616_tou,ucBufferResult);  //把<头>字镜像后放到ucBufferResult临时变量里。
    
59.         display_lattice(1,16,ucBufferResult,0,2,16);  //显示镜像后的<头>字
    
60. 
    
61.         display_lattice(8,0,Zf816_V,0,1,16);  //显示镜像前的<V>字符
    
62.         hz816_mirror(Zf816_V,ucBufferResult);  //把<V>字符镜像后放到ucBufferResult临时变量里。
    
63.         display_lattice(9,0,ucBufferResult,0,1,16);  //显示镜像后的<V>字符
    
64. 
    
65.         display_lattice(8,16,Zf816_5,0,1,16);  //显示镜像前的<5>字符
    
66.         hz816_mirror(Zf816_5,ucBufferResult);  //把<5>字符镜像后放到ucBufferResult临时变量里。
    
67.         display_lattice(9,16,ucBufferResult,0,1,16);  //显示镜像后的<5>字符
    
68. 
    
69.         while(1)  
    
70.         {
    
71.              ;
    
72.         }
    
73. 
    
74. }
    
75. 
    
76. 
    
77. 
    
78. void display_clear(void) // 清屏
    
79. {   
    
80. 
    
81.     unsigned char x,y;
    
82.     WriteCommand(0x34);  //关显示缓冲指令            
    
83.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
    
84.     y=0;
    
85.     while(y<32)  //y轴的范围0至31
    
86.     {
    
87.          WriteCommand(y+0x80);        //垂直地址
    
88.          WriteCommand(0x80);          //水平地址
    
89.          for(x=0;x<32;x++)  //256个横向点，有32个字节
    
90.          {  
    
91.             LCDWriteData(0x00);
    
92.          }
    
93.          y++;
    
94.     }
    
95.     WriteCommand(0x36); //开显示缓冲指令
    
96. 
    
97. }
    
98. 
    
99. /* 注释一：
    
100. * 16x16点阵镜像的本质：
     
101. * 16x16点阵有16行，每行有2个字节，如果把这2个字节看成是一个16位int型数据，
     
102. * 那么就是要这个数据从原来左边是高位，右边是低位的顺序颠倒过来。本程序没有把2个字节
     
103. * 合并成一个int型数据，而是直接在一个字节数据内把高低位顺序颠倒过来，然后把第1字节数据跟第2字节数据交换。
     
104. */
     
105. void hz1616_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把16x16点阵字库镜像的函数
     
106. {
     
107.          unsigned char a;
     
108.          unsigned char b;
     
109.          unsigned char c;
     
110.          unsigned char d;
     
111.        
     
112.          for(a=0;a<16;a++) //这里16代表有16行。每一行有2个字节。把每一个字节看做一列，这里先把第1列字节的数据从原来左边是高位，右边是低位的顺序颠倒过来，相当于镜像。
     
113.          {
     
114.             b=p_ucHz[a*2+0];  //这里的2代表16x16点阵每行有2列字节，0代表从第1列开始。
     
115.             c=0;
     
116.             for(d=0;d<8;d++)  //把一个字节调换顺序
     
117.                 {
     
118.                c=c>>1;
     
119.            if((b&0x80)==0x80)
     
120.                    {
     
121.              c=c|0x80;
     
122.            }
     
123.                    b=b<<1;
     
124.         }                 
     
125.         p_ucResult[a*2+1]=c;   //注意，因为是镜像，所以要把颠倒顺序后的字节从原来是第1列的调换到第2列         
     
126.      }
     
127.          
     
128.          for(a=0;a<16;a++)  //这里16代表有16行。每一行有2个字节。把每一个字节看做一列，这里先把第2列字节的数据从原来左边是高位，右边是低位的顺序颠倒过来，相当于镜像。
     
129.          {
     
130.             b=p_ucHz[a*2+1];   //这里的2代表16x16点阵每行有2列字节，1代表从第2列开始。
     
131.                  
     
132.             c=0;
     
133.             for(d=0;d<8;d++)  //把一个字节调换顺序
     
134.                 {
     
135.                         c=c>>1;
     
136.             if((b&0x80)==0x80)
     
137.                         {
     
138.               c=c|0x80;
     
139.             }
     
140.                         b=b<<1;
     
141.          }
     
142. 
     
143.          p_ucResult[a*2+0]=c;         //注意，因为是镜像，所以要把颠倒顺序后的字节从原来是第2列的调换到第1列        
     
144. 
     
145.                  
     
146.      }
     
147.          
     
148. 
     
149. }
     
150. 
     
151. 
     
152. 
     
153. /* 注释二：
     
154. * 8x16点阵镜像的本质：
     
155. * 8x16点阵有16行，每行有1个字节，把这个数据从原来左边是高位，右边是低位的顺序颠倒过来。
     
156. */
     
157. void hz816_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把8x16点阵字库镜像的函数
     
158. {
     
159.          unsigned char a;
     
160.          unsigned char b;
     
161.          unsigned char c;
     
162.          unsigned char d;
     
163.        
     
164.          for(a=0;a<16;a++) //这里16代表有16行。每一行有1个字节。这里先把每一行字节的数据从原来左边是高位，右边是低位的顺序颠倒过来，相当于镜像。
     
165.          {
     
166.             b=p_ucHz[a*1+0];  //这里的1代表8x16点阵每行有1列字节，0代表从第1列开始。
     
167.             c=0;
     
168.             for(d=0;d<8;d++)  //把一个字节调换顺序
     
169.                 {
     
170.                c=c>>1;
     
171.            if((b&0x80)==0x80)
     
172.                    {
     
173.              c=c|0x80;
     
174.            }
     
175.                    b=b<<1;
     
176.         }                 
     
177.         p_ucResult[a*1+0]=c;   //注意，因为每一行只有一列，所以不用像16x16点阵那样把第1列跟第2列对调交换。
     
178.      }
     
179.          
     
180. }
     
181. 
     
182. 
     
183. 
     
184. /* 注释三：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
185. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
     
186. * 第3个参数*ucArray是字模的数组。
     
187. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
188. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
189. */
     
190. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
     
191. {
     
192.    unsigned int j=0;
     
193.    unsigned int i=0;
     
194.    unsigned char ucTemp;
     
195.    WriteCommand(0x34);  //关显示缓冲指令            
     
196.    WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
197.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
     
198.    {
     
199.        WriteCommand(y+j+0x80);        //垂直地址
     
200.        WriteCommand(x+0x80);          //水平地址
     
201.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
     
202.        {
     
203.          ucTemp=ucArray[j*x_amount+i];
     
204.              if(ucFbFlag==1)  //反白显示
     
205.                  {
     
206.             ucTemp=~ucTemp;
     
207.          }
     
208.              LCDWriteData(ucTemp);
     
209.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
     
210.       }
     
211.    }
     
212.    WriteCommand(0x36); //开显示缓冲指令
     
213. }
     
214. 
     
215. 
     
216. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
     
217. {
     
218.         unsigned char i;
     
219.         for ( i = 0; i < 8; i++ )
     
220.         {
     
221.                 if ( (ucData << i) & 0x80 )
     
222.                 {
     
223.                         LCDSID_dr = 1;
     
224.                 }
     
225.                 else
     
226.                 {
     
227.                         LCDSID_dr = 0;
     
228.                 }
     
229.                 LCDCLK_dr = 0;
     
230.                 LCDCLK_dr = 1;
     
231.         }
     
232. }
     
233. 
     
234. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
     
235. {
     
236.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
     
237.         SendByteToLcd( ucWData & 0xf0 );
     
238.         SendByteToLcd( (ucWData << 4) & 0xf0);
     
239. }
     
240. 
     
241. 
     
242. void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
     
243. {
     
244. 
     
245.         LCDCS_dr = 0;
     
246.         LCDCS_dr = 1;
     
247.         SPIWrite(ucCommand, 0);
     
248.         delay_short(90);
     
249. }
     
250. 
     
251. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
     
252. {
     
253.         LCDCS_dr = 0;
     
254.         LCDCS_dr = 1;
     
255.         SPIWrite(ucData, 1);
     
256. }
     
257. 
     
258. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
     
259. {
     
260.         LCDRST_dr = 1;  //复位
     
261.         LCDRST_dr = 0;
     
262.         LCDRST_dr = 1;
     
263. }
     
264. 
     
265. 
     
266. 
     
267. void delay_short(unsigned int uiDelayShort) //延时函数
     
268. {
     
269.    unsigned int i;  
     
270.    for(i=0;i<uiDelayShort;i++)
     
271.    {
     
272.      ;  
     
273.    }
     
274. }
     

复制代码

总结陈词：
    细心的网友一定会发现，这种12864液晶屏普遍有个毛病，在坐标轴x,y方向上不能完全做到以一个点阵为单位进行随心所欲的显示，比如横向的至少是一个字节8个点阵为单位，而第1,2行跟第3,4行又做不到无缝对接显示，假如我要把汉字一半显示在第2行一半显示在第3行，行不行？当然可以。但是需要我们编写额外的算法程序。这种算法程序是怎样编写的？欲知详情，请听下回分解-----在液晶屏中让字体可以跨区域无缝对接显示的算法程序。

（未完待续，下节更精彩，不要走开哦）

jianhong_wu

第七十四节：在液晶屏中让字体可以跨区域无缝对接显示的算法程序。

开场白：

细心的网友会发现，这种12864液晶屏在显示自造字库时普遍有个毛病，在坐标轴x方向上是以每16个点阵为一个单位的，如果显示两个8x16字符”V”和”5”，虽然它们的x坐标轴是相邻的，但是实际显示的效果是中间隔了8个点阵。另外，这种12864液晶屏是由上半屏和下半屏组成的，软件上的坐标体系并没有做到跟物理的坐标体系一致，需要转换的。如果我们想把一个整体字符的一半显示在上半屏，另一半显示在下半屏，那怎么办？

这一节就要教给大家这个算法程序：

为了实现跨区域无缝显示，就先在某个区域显示一块画布，我们只要在这块画布数组中插入字模数组，就可以达到跨区域无缝显示的目的。

具体内容，请看源代码讲解。

（1）硬件平台：
    基于坚鸿51单片机学习板。

（2）实现功能：开机上电后，看到液晶屏所有的点阵都显示。正中间露出一小方块空白的32x16点阵画布，从左到右分别显示“V5”两个字符。这两个字符是紧紧挨在一起的，中间并没有8个点阵的空格，同时这两个字符的上半部分显示在上半屏，下半部分显示在下半屏。实现了真正的跨区域无缝对接显示。

（3）源代码讲解如下：

1. #include "REG52.H"
   
2. 
   
3. sbit  LCDCS_dr  = P1^6;  //片选线
   
4. sbit  LCDSID_dr = P1^7;  //串行数据线
   
5. sbit  LCDCLK_dr = P3^2;  //串行时钟线
   
6. sbit  LCDRST_dr = P3^4;  //复位线
   
7. 
   
8. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
   
9. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
   
10. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
    
11. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
    
12. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
    
13. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
    
14. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount);//把字模插入画布.
    
15. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr); //显示任意点阵函数
    
16. void delay_short(unsigned int uiDelayshort); //延时
    
17. 
    
18. code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 每一行只要1个字节，共16行 */
    
19. {
    
20. 0x00,
    
21. 0x00,
    
22. 0x00,
    
23. 0xE7,
    
24. 0x42,
    
25. 0x42,
    
26. 0x44,
    
27. 0x24,
    
28. 0x24,
    
29. 0x28,
    
30. 0x28,
    
31. 0x18,
    
32. 0x10,
    
33. 0x10,
    
34. 0x00,
    
35. 0x00,
    
36. };
    
37. 
    
38. code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 每一行只要1个字节，共16行 */
    
39. {
    
40. 0x00,
    
41. 0x00,
    
42. 0x00,
    
43. 0x7E,
    
44. 0x40,
    
45. 0x40,
    
46. 0x40,
    
47. 0x58,
    
48. 0x64,
    
49. 0x02,
    
50. 0x02,
    
51. 0x42,
    
52. 0x44,
    
53. 0x38,
    
54. 0x00,
    
55. 0x00,
    
56. };
    
57. 
    
58. 
    
59. /* 注释一：
    
60. * 为了实现跨区域无缝显示，就先在某个区域显示一块画布，我们只要在这块画布数组中插入字模数组，
    
61. * 就可以达到跨区域无缝显示的目的。根据上几节的介绍，12864液晶屏由上下两半屏组成，以下这块画布
    
62. * 显示在上半屏和下半屏之间。横向4个字节，纵向16行。其中上半屏显示8行，下半屏显示8行。注意，这个数组
    
63. * 不带code关键字，是全局变量，这样可读可写。画布的横向x坐标范围是0至3，因为画布的横向只要4个字节。
    
64. * 画布的纵向y坐标范围是0至15，因为画布的纵向只有16行。
    
65. */
    
66. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
    
67. {
    
68. 0x00,0x00,0x00,0x00,  //上半屏
    
69. 0x00,0x00,0x00,0x00,
    
70. 0x00,0x00,0x00,0x00,
    
71. 0x00,0x00,0x00,0x00,
    
72. 0x00,0x00,0x00,0x00,
    
73. 0x00,0x00,0x00,0x00,
    
74. 0x00,0x00,0x00,0x00,
    
75. 0x00,0x00,0x00,0x00,
    
76. 
    
77. //------------上半屏和下半屏的分割线-----------
    
78. 
    
79. 0x00,0x00,0x00,0x00,  //下半屏
    
80. 0x00,0x00,0x00,0x00,
    
81. 0x00,0x00,0x00,0x00,
    
82. 0x00,0x00,0x00,0x00,
    
83. 0x00,0x00,0x00,0x00,
    
84. 0x00,0x00,0x00,0x00,
    
85. 0x00,0x00,0x00,0x00,
    
86. 0x00,0x00,0x00,0x00,
    
87. };
    
88. 
    
89. 
    
90. 
    
91. void main()
    
92.   {
    
93.         LCDInit(); //初始化12864 内部包含液晶模块的复位
    
94. 
    
95.         display_clear(0xff); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
    
96. 
    
97.         insert_buffer_to_canvas(0,0,Zf816_V,0,1,16);//把<V>的字模插入画布
    
98.         insert_buffer_to_canvas(1,0,Zf816_5,0,1,16);//把<5>的字模插入画布
    
99. 
    
100.         display_lattice(3,24,ucCanvasBuffer,0,4,8,0);   //显示上半屏的画布,最后的参数0是偏移量
     
101.         display_lattice(11,0,ucCanvasBuffer,0,4,8,32);  //显示下半屏的画布,最后的参数32是偏移量
     
102. 
     
103. 
     
104.         while(1)  
     
105.         {
     
106.              ;
     
107.         }
     
108. 
     
109. }
     
110. 
     
111. 
     
112. 
     
113. void display_clear(unsigned char ucFillDate) // 清屏  全部显示空填充0x00   全部显示点阵用0xff
     
114. {   
     
115. 
     
116.     unsigned char x,y;
     
117.     WriteCommand(0x34);  //关显示缓冲指令            
     
118.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
119.     y=0;
     
120.     while(y<32)  //y轴的范围0至31
     
121.     {
     
122.          WriteCommand(y+0x80);        //垂直地址
     
123.          WriteCommand(0x80);          //水平地址
     
124.          for(x=0;x<32;x++)  //256个横向点，有32个字节
     
125.          {  
     
126.             LCDWriteData(ucFillDate);
     
127.          }
     
128.          y++;
     
129.     }
     
130.     WriteCommand(0x36); //开显示缓冲指令
     
131. 
     
132. }
     
133. 
     
134. /* 注释二：
     
135. * 把字模插入画布的函数.
     
136. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
137. * 第1，2个参数x,y是在画布中的坐标体系。
     
138. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
     
139. * 第3个参数*ucArray是字模的数组。
     
140. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
141. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
142. */
     
143. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
     
144. {
     
145.    unsigned int j=0;
     
146.    unsigned int i=0;
     
147.    unsigned char ucTemp;
     
148.    for(j=0;j<y_amount;j++)
     
149.    {
     
150.       for(i=0;i<x_amount;i++)
     
151.       {
     
152.                    ucTemp=ucArray[j*x_amount+i];
     
153.                    if(ucFbFlag==0)
     
154.                    {
     
155.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
     
156.                    }
     
157.                    else
     
158.                    {
     
159.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
     
160.                    }
     
161.       }
     
162.    }         
     
163. 
     
164. }
     
165. 
     
166. /* 注释三：
     
167. * 显示任意点阵函数.
     
168. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
     
169. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
170. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
     
171. * 第3个参数*ucArray是字模的数组。
     
172. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
173. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
174. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
     
175. */
     
176. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr)
     
177. {
     
178.    unsigned int j=0;
     
179.    unsigned int i=0;
     
180.    unsigned char ucTemp;
     
181.    WriteCommand(0x34);  //关显示缓冲指令            
     
182.    WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
183.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
     
184.    {
     
185.        WriteCommand(y+j+0x80);        //垂直地址
     
186.        WriteCommand(x+0x80);          //水平地址
     
187.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
     
188.        {
     
189.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
     
190.            if(ucFbFlag==1)  //反白显示
     
191.            {
     
192.                ucTemp=~ucTemp;
     
193.            }
     
194.            LCDWriteData(ucTemp);
     
195.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
     
196.       }
     
197.    }
     
198.    WriteCommand(0x36); //开显示缓冲指令
     
199. }
     
200. 
     
201. 
     
202. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
     
203. {
     
204.         unsigned char i;
     
205.         for ( i = 0; i < 8; i++ )
     
206.         {
     
207.                 if ( (ucData << i) & 0x80 )
     
208.                 {
     
209.                         LCDSID_dr = 1;
     
210.                 }
     
211.                 else
     
212.                 {
     
213.                         LCDSID_dr = 0;
     
214.                 }
     
215.                 LCDCLK_dr = 0;
     
216.                 LCDCLK_dr = 1;
     
217.         }
     
218. }
     
219. 
     
220. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
     
221. {
     
222.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
     
223.         SendByteToLcd( ucWData & 0xf0 );
     
224.         SendByteToLcd( (ucWData << 4) & 0xf0);
     
225. }
     
226. 
     
227. 
     
228. void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
     
229. {
     
230. 
     
231.         LCDCS_dr = 0;
     
232.         LCDCS_dr = 1;
     
233.         SPIWrite(ucCommand, 0);
     
234.         delay_short(90);
     
235. }
     
236. 
     
237. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
     
238. {
     
239.         LCDCS_dr = 0;
     
240.         LCDCS_dr = 1;
     
241.         SPIWrite(ucData, 1);
     
242. }
     
243. 
     
244. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
     
245. {
     
246.         LCDRST_dr = 1;  //复位
     
247.         LCDRST_dr = 0;
     
248.         LCDRST_dr = 1;
     
249. }
     
250. 
     
251. 
     
252. 
     
253. void delay_short(unsigned int uiDelayShort) //延时函数
     
254. {
     
255.    unsigned int i;  
     
256.    for(i=0;i<uiDelayShort;i++)
     
257.    {
     
258.      ;  
     
259.    }
     
260. }
     

复制代码

总结陈词：

    经过这一节的算法处理后，字符终于可以在x轴上紧紧挨着显示了。也就是把原来x坐标是16个点阵为一个单位，改成了以8个点阵为一个单位。如果要求以1个点阵为单位显示，那该怎么办？这个还真有点难度，因为横向的最小显示单位就是一个字节8个点，不过鸿哥在下一节中照样有办法实现这个功能。欲知详情，请听下回分解-----在12864液晶屏中让字体以1个点阵为单位进行移动显示的算法程序。

（未完待续，下节更精彩，不要走开哦）

jianhong_wu

第七十五节：在12864液晶屏中让字体以1个点阵为单位进行移动显示的算法程序。

开场白：
    假设有一个固定的四方形透明窗口，在窗口里面放了一张画布，只要想办法让这个画布
往右边拖动，那么画布里面的内容就会跟着画布整体往右边移动，这个就是能以1个点阵为单位进行移动显示的本质。同理，这个画布有16行，每行有4个字节，我们只要把每行4个字节看作是一个首尾连接的二进制数据，把每一行的二进制数据每次整体往右边移动一位，就相当于移动一个点阵了。这一节就要把这个算法教给大家。

具体内容，请看源代码讲解。

（1）硬件平台：
    基于坚鸿51单片机学习板。

（2）实现功能：开机上电后，能看到正中间显示的两个字符“V5”整体以1个点阵为单位向右边慢慢移动。

（3）源代码讲解如下：

1. #include "REG52.H"
   
2. 
   
3. #define const_MoveTime 400  //每移动一位后的延时时间
   
4. 
   
5. sbit  LCDCS_dr  = P1^6;  //片选线
   
6. sbit  LCDSID_dr = P1^7;  //串行数据线
   
7. sbit  LCDCLK_dr = P3^2;  //串行时钟线
   
8. sbit  LCDRST_dr = P3^4;  //复位线
   
9. 
   
10. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
    
11. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
    
12. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
    
13. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
    
14. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
    
15. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
    
16. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount);//把字模插入画布.
    
17. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr); //显示任意点阵函数
    
18. void delay_short(unsigned int uiDelayshort); //延时
    
19. 
    
20. void move_service(void); //整体画布移动的应用程序
    
21. void lcd_display_service(void); //应用层面的液晶屏显示程序
    
22. void move_canvas_to_one_bit(void);  //把画布整体往右边移动一个点阵
    
23. void clear_all_canvas(void);  //把画布全部清零
    
24. 
    
25. void T0_time(void);  //定时中断函数
    
26. 
    
27. code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 每一行只要1个字节，共16行 */
    
28. {
    
29. 0x00,
    
30. 0x00,
    
31. 0x00,
    
32. 0xE7,
    
33. 0x42,
    
34. 0x42,
    
35. 0x44,
    
36. 0x24,
    
37. 0x24,
    
38. 0x28,
    
39. 0x28,
    
40. 0x18,
    
41. 0x10,
    
42. 0x10,
    
43. 0x00,
    
44. 0x00,
    
45. };
    
46. 
    
47. code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 每一行只要1个字节，共16行 */
    
48. {
    
49. 0x00,
    
50. 0x00,
    
51. 0x00,
    
52. 0x7E,
    
53. 0x40,
    
54. 0x40,
    
55. 0x40,
    
56. 0x58,
    
57. 0x64,
    
58. 0x02,
    
59. 0x02,
    
60. 0x42,
    
61. 0x44,
    
62. 0x38,
    
63. 0x00,
    
64. 0x00,
    
65. };
    
66. 
    
67. 
    
68. /* 注释一：
    
69. * 为了实现跨区域无缝显示，就先在某个区域显示一块画布，我们只要在这块画布数组中插入字模数组，
    
70. * 就可以达到跨区域无缝显示的目的。根据上几节的介绍，12864液晶屏由上下两半屏组成，以下这块画布
    
71. * 显示在上半屏和下半屏之间。横向4个字节，纵向16行。其中上半屏显示8行，下半屏显示8行。注意，这个数组
    
72. * 不带code关键字，是全局变量，这样可读可写。画布的横向x坐标范围是0至3，因为画布的横向只要4个字节。
    
73. * 画布的纵向y坐标范围是0至15，因为画布的纵向只有16行。
    
74. */
    
75. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
    
76. {
    
77. 0x00,0x00,0x00,0x00,  //上半屏
    
78. 0x00,0x00,0x00,0x00,
    
79. 0x00,0x00,0x00,0x00,
    
80. 0x00,0x00,0x00,0x00,
    
81. 0x00,0x00,0x00,0x00,
    
82. 0x00,0x00,0x00,0x00,
    
83. 0x00,0x00,0x00,0x00,
    
84. 0x00,0x00,0x00,0x00,
    
85. 
    
86. //------------上半屏和下半屏的分割线-----------
    
87. 
    
88. 0x00,0x00,0x00,0x00,  //下半屏
    
89. 0x00,0x00,0x00,0x00,
    
90. 0x00,0x00,0x00,0x00,
    
91. 0x00,0x00,0x00,0x00,
    
92. 0x00,0x00,0x00,0x00,
    
93. 0x00,0x00,0x00,0x00,
    
94. 0x00,0x00,0x00,0x00,
    
95. 0x00,0x00,0x00,0x00,
    
96. };
    
97. 
    
98. unsigned char ucDisplayUpdate=1;  //更新显示变量
    
99. unsigned char ucMoveStepReset=0;  //这个变量是为了方便外部程序初始化应用程序内部后缀为step的步骤变量
    
100. 
     
101. unsigned char ucMoveTimeStart=0; //定时器的开关标志  也相当于原子锁或互斥量的功能
     
102. unsigned int uiMoveTime=0;  //定时器累计时间
     
103. 
     
104. void main()
     
105.   {
     
106. 
     
107.         LCDInit(); //初始化12864 内部包含液晶模块的复位
     
108.         display_clear(0xff); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
     
109. 
     
110. 
     
111.         TMOD=0x01;  //设置定时器0为工作方式1
     
112.         TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
     
113.         TL0=0x2f;
     
114.         EA=1;     //开总中断
     
115.         ET0=1;    //允许定时中断
     
116.         TR0=1;    //启动定时中断
     
117. 
     
118. 
     
119.         while(1)  
     
120.         {
     
121.            move_service(); //整体画布移动的应用程序
     
122.            lcd_display_service(); //应用层面的液晶屏显示程序
     
123.         }
     
124. 
     
125. }
     
126. 
     
127. 
     
128. 
     
129. void move_service(void) //整体画布移动的应用程序
     
130. {
     
131.    static unsigned char ucMoveStep=0; //运行步骤。前面加关键字static表示上电后这个变量只初始化一次，以后每次进出函数此变量不会重新初始化，保存之前的更改数值不变。
     
132.    static unsigned char ucMoveCnt=0; //统计当前已经往左边移动了多少位。关键字static表示此变量上电后只初始化一次，不会每次进入函数都初始化。
     
133. 
     
134.    if(ucMoveStepReset==1)  //运行步骤的复位标志，此段代码结构方便外部程序初始化函数内部的步骤变量ucMoveStep
     
135.    {
     
136.       ucMoveStepReset=0; //及时把复位标志清零。避免一直处于复位的状态、
     
137. 
     
138.           ucMoveStep=0; //运行步骤变量被外部程序通过复位标志初始化。
     
139.    }
     
140. 
     
141.    switch(ucMoveStep)
     
142.    {
     
143.       case 0:
     
144.                clear_all_canvas();  //把画布全部清零
     
145.            insert_buffer_to_canvas(0,0,Zf816_V,0,1,16);//把<V>的字模插入画布
     
146.            insert_buffer_to_canvas(1,0,Zf816_5,0,1,16);//把<5>的字模插入画布
     
147.            ucDisplayUpdate=1; //更新液晶屏显示
     
148.                   
     
149.                    uiMoveTime=0;  //定时器清零
     
150.                    ucMoveTimeStart=1; //开定时器     也相当于原子锁或互斥量的功能
     
151.                    ucMoveCnt=0; //统计当前已经往左边移动了多少位
     
152.                    ucMoveStep=1; //切换到下一个运行步骤
     
153. 
     
154.                break;
     
155. 
     
156.       case 1:
     
157.                if(uiMoveTime>const_MoveTime)  //延时一定的时间后
     
158.                    {
     
159.                               ucMoveTimeStart=0; //关定时器    也相当于原子锁或互斥量的功能
     
160.                        uiMoveTime=0;  //定时器清零
     
161. 
     
162.                    if(ucMoveCnt<16)
     
163.                        {
     
164.                           ucMoveCnt++;
     
165.                   move_canvas_to_one_bit(); //把画布整体往左边移动一个点阵
     
166.                   ucDisplayUpdate=1; //更新液晶屏显示
     
167.                                   ucMoveTimeStart=1; //开定时器   也相当于原子锁或互斥量的功能
     
168. 
     
169.                        }
     
170.                        else
     
171.                        {
     
172.                                   ucMoveStep=0; //移动了16个点阵后，返回上一个运行步骤，把字模重新插入画布
     
173.                        }
     
174. 
     
175. 
     
176. 
     
177.            }
     
178.                break;
     
179.    }
     
180. 
     
181. }
     
182. 
     
183. 
     
184. void lcd_display_service(void) //应用层面的液晶屏显示程序
     
185. {
     
186.     if(ucDisplayUpdate==1)  //需要更新显示
     
187.     {
     
188.        ucDisplayUpdate=0;  //及时把标志清零，避免一直处于不断更新的状态。
     
189. 
     
190. 
     
191.        display_lattice(3,24,ucCanvasBuffer,0,4,8,0);   //显示上半屏的画布,最后的参数0是偏移量
     
192.        display_lattice(11,0,ucCanvasBuffer,0,4,8,32);  //显示下半屏的画布,最后的参数32是偏移量
     
193.     }
     
194. }
     
195. 
     
196. /* 注释二：
     
197. * 假设有一个固定的四方形透明窗口，在窗口里面放了一张画布，只要想办法让这个画布
     
198. * 往右边拖动，那么画布里面的内容就会跟着画布整体往右边移动，这个就是能以1个点阵为单位进行移动显示的本质。
     
199. * 同理，这个画布有16行，每行有4个字节，我们只要把每行4个字节看作是一个首尾连接的二进制数据，
     
200. * 把每一行的二进制数据每次整体往右边移动一位，就相当于移动一个点阵了。
     
201. */
     
202. 
     
203. void move_canvas_to_one_bit(void)  //把画布整体往右边移动一个点阵
     
204. {
     
205.    unsigned int j=0;
     
206.    unsigned int i=0;
     
207.    unsigned char ucBitH;  //临时保存一个字节中的最高位
     
208.    unsigned char ucBitL;  //临时保存一个字节中的最低位
     
209. 
     
210.    for(j=0;j<16;j++)  //这里的16表示画布有16行
     
211.    {
     
212.       ucBitH=0;   
     
213.           ucBitL=0;   
     
214.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
     
215.       {
     
216.                   if((ucCanvasBuffer[j*4+i]&0x01)==0x01)  //临时保存一个字节中的最低位
     
217.                   {
     
218.                      ucBitL=1;
     
219.                   }
     
220.                   else
     
221.                   {
     
222.                      ucBitL=0;
     
223.                   }
     
224.                   ucCanvasBuffer[j*4+i]=ucCanvasBuffer[j*4+i]>>1;  //一行中的一个字节右移一位
     
225. 
     
226.                   if(ucBitH==1)   //原来左边相邻的字节最低位移动到了当前字节的最高位
     
227.                   {
     
228.              ucCanvasBuffer[j*4+i]=ucCanvasBuffer[j*4+i]|0x80; //把最高位补上
     
229.                   }
     
230.           ucBitH=ucBitL;  //把当前的最低位赋值给最高位，为下一个相邻字节做准备。
     
231.       }
     
232.    }         
     
233. 
     
234. }
     
235. 
     
236. 
     
237. void clear_all_canvas(void)  //把画布全部清零
     
238. {
     
239.    unsigned int j=0;
     
240.    unsigned int i=0;
     
241. 
     
242.    for(j=0;j<16;j++)  //这里的16表示画布有16行
     
243.    {
     
244.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
     
245.       {
     
246.                   ucCanvasBuffer[j*4+i]=0x00;
     
247.       }
     
248.    }         
     
249. 
     
250. }
     
251. 
     
252. 
     
253. void T0_time(void) interrupt 1  //定时中断函数
     
254. {
     
255.   TF0=0;  //清除中断标志
     
256.   TR0=0; //关中断
     
257. 
     
258.   if(ucMoveTimeStart==1) //已经开了定时器  也相当于原子锁或互斥量的功能
     
259.   {
     
260.       uiMoveTime++; //定时器累加计时开始
     
261.   }
     
262. 
     
263.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
     
264.   TL0=0x2f;
     
265.   TR0=1;  //开中断
     
266. }
     
267. 
     
268. 
     
269. 
     
270. void display_clear(unsigned char ucFillDate) // 清屏  全部显示空填充0x00   全部显示点阵用0xff
     
271. {   
     
272. 
     
273.     unsigned char x,y;
     
274.     WriteCommand(0x34);  //关显示缓冲指令            
     
275.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
276.     y=0;
     
277.     while(y<32)  //y轴的范围0至31
     
278.     {
     
279.          WriteCommand(y+0x80);        //垂直地址
     
280.          WriteCommand(0x80);          //水平地址
     
281.          for(x=0;x<32;x++)  //256个横向点，有32个字节
     
282.          {  
     
283.             LCDWriteData(ucFillDate);
     
284.          }
     
285.          y++;
     
286.     }
     
287.     WriteCommand(0x36); //开显示缓冲指令
     
288. 
     
289. }
     
290. 
     
291. /* 注释三：
     
292. * 把字模插入画布的函数.
     
293. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
294. * 第1，2个参数x,y是在画布中的坐标体系。
     
295. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
     
296. * 第3个参数*ucArray是字模的数组。
     
297. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
298. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
299. */
     
300. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
     
301. {
     
302.    unsigned int j=0;
     
303.    unsigned int i=0;
     
304.    unsigned char ucTemp;
     
305.    for(j=0;j<y_amount;j++)
     
306.    {
     
307.       for(i=0;i<x_amount;i++)
     
308.       {
     
309.                    ucTemp=ucArray[j*x_amount+i];
     
310.                    if(ucFbFlag==0)
     
311.                    {
     
312.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
     
313.                    }
     
314.                    else
     
315.                    {
     
316.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
     
317.                    }
     
318.       }
     
319.    }         
     
320. 
     
321. }
     
322. 
     
323. /* 注释四：
     
324. * 显示任意点阵函数.
     
325. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
     
326. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
327. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
     
328. * 第3个参数*ucArray是字模的数组。
     
329. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
330. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
331. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
     
332. */
     
333. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr)
     
334. {
     
335.    unsigned int j=0;
     
336.    unsigned int i=0;
     
337.    unsigned char ucTemp;
     
338. 
     
339. //注意，要把以下两行指令屏蔽，否则屏幕在更新显示时会整屏闪动
     
340. //  WriteCommand(0x34);  //关显示缓冲指令            
     
341. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
342.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
     
343.    {
     
344.        WriteCommand(y+j+0x80);        //垂直地址
     
345.        WriteCommand(x+0x80);          //水平地址
     
346.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
     
347.        {
     
348.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
     
349.            if(ucFbFlag==1)  //反白显示
     
350.            {
     
351.                ucTemp=~ucTemp;
     
352.            }
     
353.            LCDWriteData(ucTemp);
     
354.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
     
355.       }
     
356.    }
     
357.    WriteCommand(0x36); //开显示缓冲指令
     
358. }
     
359. 
     
360. 
     
361. 
     
362. 
     
363. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
     
364. {
     
365.         unsigned char i;
     
366.         for ( i = 0; i < 8; i++ )
     
367.         {
     
368.                 if ( (ucData << i) & 0x80 )
     
369.                 {
     
370.                         LCDSID_dr = 1;
     
371.                 }
     
372.                 else
     
373.                 {
     
374.                         LCDSID_dr = 0;
     
375.                 }
     
376.                 LCDCLK_dr = 0;
     
377.                 LCDCLK_dr = 1;
     
378.         }
     
379. }
     
380. 
     
381. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
     
382. {
     
383.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
     
384.         SendByteToLcd( ucWData & 0xf0 );
     
385.         SendByteToLcd( (ucWData << 4) & 0xf0);
     
386. }
     
387. 
     
388. 
     
389. void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
     
390. {
     
391. 
     
392.         LCDCS_dr = 0;
     
393.         LCDCS_dr = 1;
     
394.         SPIWrite(ucCommand, 0);
     
395.         delay_short(90);
     
396. }
     
397. 
     
398. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
     
399. {
     
400.         LCDCS_dr = 0;
     
401.         LCDCS_dr = 1;
     
402.         SPIWrite(ucData, 1);
     
403. }
     
404. 
     
405. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
     
406. {
     
407.         LCDRST_dr = 1;  //复位
     
408.         LCDRST_dr = 0;
     
409.         LCDRST_dr = 1;
     
410. }
     
411. 
     
412. 
     
413. 
     
414. void delay_short(unsigned int uiDelayShort) //延时函数
     
415. {
     
416.    unsigned int i;  
     
417.    for(i=0;i<uiDelayShort;i++)
     
418.    {
     
419.      ;  
     
420.    }
     
421. }
     

复制代码

总结陈词：
从下一节开始讲大家关注已久的液晶屏菜单程序。欲知详情，请听下回分解-----在1个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

（未完待续，下节更精彩，不要走开哦）

KR770906

到液晶菜单了，太给力了。鸿哥威武。

jianhong_wu

第七十六节：如何把一个任意数值的变量显示在液晶屏上。

开场白：
本来这一节打算开始讲液晶屏的菜单程序，但是我担心跳跃太大，恐怕很多初学者跟不上，所以多插入这一节讲讲后面菜单程序中经常用到的基本功能，如何把一个任意数值的变量显示在液晶屏上。我们需要做一个变量转换成字模的函数，以后只要调用这个转换函数就可以了。这一节就要把这个转换函数教给大家。

具体内容，请看源代码讲解。

（1）硬件平台：
    基于坚鸿51单片机学习板。

（2）实现功能：我们定义一个char型的全局变量，把它默认初始化为218，开机上电后，能看到正中间恰好显示这个全局变量的数值218。大家也可以试着更改它的默认初始值，只要不超过char型最大数值255范围，我们就会看到它上电后显示的就是这个初始值。

（3）源代码讲解如下：

1. #include "REG52.H"
   
2. 
   
3. sbit  LCDCS_dr  = P1^6;  //片选线
   
4. sbit  LCDSID_dr = P1^7;  //串行数据线
   
5. sbit  LCDCLK_dr = P3^2;  //串行时钟线
   
6. sbit  LCDRST_dr = P3^4;  //复位线
   
7. 
   
8. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
   
9. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
   
10. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
    
11. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
    
12. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
    
13. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
    
14. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount);//把字模插入画布.
    
15. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr); //显示任意点阵函数
    
16. unsigned char *number_to_matrix(unsigned char  ucBitNumber); //把一位数字转换成字模首地址的函数
    
17. void delay_short(unsigned int uiDelayshort); //延时
    
18. void delay_long(unsigned int uiDelayLong);
    
19. 
    
20. 
    
21. void initial_myself();   
    
22. void initial_peripheral();
    
23. 
    
24. 
    
25. void lcd_display_service(void); //应用层面的液晶屏显示程序
    
26. void clear_all_canvas(void);  //把画布全部清零
    
27. 
    
28. code unsigned char Zf816_0[]=
    
29. {
    
30. /*--  文字:  0  --*/
    
31. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
32. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
    
33. };
    
34. 
    
35. code unsigned char Zf816_1[]=
    
36. {
    
37. /*--  文字:  1  --*/
    
38. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
39. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
    
40. };
    
41. 
    
42. code unsigned char Zf816_2[]=
    
43. {
    
44. /*--  文字:  2  --*/
    
45. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
46. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
    
47. };
    
48. 
    
49. code unsigned char Zf816_3[]=
    
50. {
    
51. /*--  文字:  3  --*/
    
52. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
53. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
    
54. };
    
55. 
    
56. code unsigned char Zf816_4[]=
    
57. {
    
58. /*--  文字:  4  --*/
    
59. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
60. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
    
61. };
    
62. 
    
63. code unsigned char Zf816_5[]=
    
64. {
    
65. /*--  文字:  5  --*/
    
66. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
67. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
    
68. };
    
69. 
    
70. code unsigned char Zf816_6[]=
    
71. {
    
72. /*--  文字:  6  --*/
    
73. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
74. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
    
75. };
    
76. 
    
77. 
    
78. code unsigned char Zf816_7[]=
    
79. {
    
80. /*--  文字:  7  --*/
    
81. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
82. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
    
83. };
    
84. 
    
85. code unsigned char Zf816_8[]=
    
86. {
    
87. /*--  文字:  8  --*/
    
88. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
89. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
    
90. };
    
91. 
    
92. code unsigned char Zf816_9[]=
    
93. {
    
94. /*--  文字:  9  --*/
    
95. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
96. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
    
97. };
    
98. 
    
99. 
    
100. code unsigned char Zf816_nc[]=  //空字模
     
101. {
     
102. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
103. };
     
104. 
     
105. 
     
106. /* 注释一：
     
107. * 为了实现跨区域无缝显示，就先在某个区域显示一块画布，我们只要在这块画布数组中插入字模数组，
     
108. * 就可以达到跨区域无缝显示的目的。根据上几节的介绍，12864液晶屏由上下两半屏组成，以下这块画布
     
109. * 显示在上半屏和下半屏之间。横向4个字节，纵向16行。其中上半屏显示8行，下半屏显示8行。注意，这个数组
     
110. * 不带code关键字，是全局变量，这样可读可写。画布的横向x坐标范围是0至3，因为画布的横向只要4个字节。
     
111. * 画布的纵向y坐标范围是0至15，因为画布的纵向只有16行。
     
112. */
     
113. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
     
114. {
     
115. 0x00,0x00,0x00,0x00,  //上半屏
     
116. 0x00,0x00,0x00,0x00,
     
117. 0x00,0x00,0x00,0x00,
     
118. 0x00,0x00,0x00,0x00,
     
119. 0x00,0x00,0x00,0x00,
     
120. 0x00,0x00,0x00,0x00,
     
121. 0x00,0x00,0x00,0x00,
     
122. 0x00,0x00,0x00,0x00,
     
123. 
     
124. //------------上半屏和下半屏的分割线-----------
     
125. 
     
126. 0x00,0x00,0x00,0x00,  //下半屏
     
127. 0x00,0x00,0x00,0x00,
     
128. 0x00,0x00,0x00,0x00,
     
129. 0x00,0x00,0x00,0x00,
     
130. 0x00,0x00,0x00,0x00,
     
131. 0x00,0x00,0x00,0x00,
     
132. 0x00,0x00,0x00,0x00,
     
133. 0x00,0x00,0x00,0x00,
     
134. };
     
135. 
     
136. 
     
137. unsigned char ucDisplayUpdate=1;  //更新显示变量
     
138. 
     
139. 
     
140. /* 注释二：
     
141. * 以下变量就是本程序的任意变量，网友可以自己更改它的大小来测试本程序，不要超过255.
     
142. */
     
143. unsigned char ucAnyNumber=218;  //任意变量默认初始化为218。
     
144. 
     
145. 
     
146. void main()
     
147.   {
     
148.         initial_myself();      //第一区,上电后马上初始化
     
149.         delay_long(100);       //一线，延时线。延时一段时间
     
150.         initial_peripheral();  //第二区,上电后延时一段时间再初始化
     
151. 
     
152.         while(1)   //第三区
     
153.         {
     
154.             lcd_display_service(); //应用层面的液晶屏显示程序
     
155.         }
     
156. 
     
157. }
     
158. 
     
159. 
     
160. void initial_myself()  //第一区 上电后马上初始化
     
161. {
     
162.     ;
     
163. }
     
164. void initial_peripheral() //第二区 上电后延时一段时间再初始化
     
165. {
     
166.     LCDInit(); //初始化12864 内部包含液晶模块的复位
     
167.     display_clear(0xff); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
     
168. }
     
169. 
     
170. 
     
171. 
     
172. /* 注释三：
     
173. * 本程序的核心转换函数。
     
174. * 是可以把一位任意数字变量的函数转换成对应的字模，由于字模是数组，所以返回的是指针，代表字模数组的首地址。
     
175. */
     
176. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
     
177. {
     
178.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小，分别调用不同的字库。
     
179. 
     
180.         switch(ucBitNumber)  //根据ucBitNumber数值的大小，分别调用不同的字库。
     
181.         {
     
182.             case 0:
     
183.              p_ucAnyNumber=Zf816_0;
     
184.                      break;
     
185.             case 1:
     
186.              p_ucAnyNumber=Zf816_1;
     
187.                      break;
     
188.             case 2:
     
189.              p_ucAnyNumber=Zf816_2;
     
190.                      break;
     
191.             case 3:
     
192.              p_ucAnyNumber=Zf816_3;
     
193.                      break;
     
194.             case 4:
     
195.              p_ucAnyNumber=Zf816_4;
     
196.                      break;
     
197.             case 5:
     
198.              p_ucAnyNumber=Zf816_5;
     
199.                      break;
     
200.             case 6:
     
201.              p_ucAnyNumber=Zf816_6;
     
202.                      break;
     
203.             case 7:
     
204.              p_ucAnyNumber=Zf816_7;
     
205.                      break;
     
206.             case 8:
     
207.              p_ucAnyNumber=Zf816_8;
     
208.                      break;
     
209.             case 9:
     
210.              p_ucAnyNumber=Zf816_9;
     
211.                      break;
     
212.             case 10:
     
213.              p_ucAnyNumber=Zf816_nc;
     
214.                      break;
     
215.                 default:   //如果上面的条件都不符合，那么默认指向空字模
     
216.              p_ucAnyNumber=Zf816_nc;
     
217.                      break;
     
218.         }
     
219. 
     
220.     return p_ucAnyNumber;  //返回转换结束后的指针
     
221. }
     
222. 
     
223. 
     
224. void lcd_display_service(void) //应用层面的液晶屏显示程序
     
225. {
     
226.     static unsigned char ucAnyNumber_1; //分解变量的个位
     
227.     static unsigned char ucAnyNumber_10; //分解变量的十位
     
228.     static unsigned char ucAnyNumber_100; //分解变量的百位
     
229. 
     
230.     static unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
     
231.     static unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
     
232.     static unsigned char *p_ucAnyNumber_100; //经过数字转换成字模后，分解变量的百位字模首地址
     
233. 
     
234.     if(ucDisplayUpdate==1)  //需要更新显示
     
235.     {
     
236.        ucDisplayUpdate=0;  //及时把标志清零，避免一直处于不断更新的状态。
     
237. 
     
238.            if(ucAnyNumber>=100) //有3位数以上
     
239.            {
     
240.            ucAnyNumber_100=ucAnyNumber/100; //百位
     
241.        }
     
242.            else //否则显示空
     
243.            {
     
244.                ucAnyNumber_100=10;  //在下面的转换函数中，代码10表示空字模
     
245.            }
     
246. 
     
247.            if(ucAnyNumber>=10) //有2位数以上
     
248.            {
     
249.            ucAnyNumber_10=ucAnyNumber%100/10;  //十位
     
250.        }
     
251.            else //否则显示空
     
252.            {
     
253.                ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
     
254.            }
     
255. 
     
256.        ucAnyNumber_1=ucAnyNumber%10/1;  //个位
     
257. 
     
258.            p_ucAnyNumber_100=number_to_matrix(ucAnyNumber_100); //把数字转换成字模首地址      
     
259.            p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
     
260.            p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
     
261. 
     
262.        clear_all_canvas();  //把画布全部清零
     
263.        insert_buffer_to_canvas(0,0,p_ucAnyNumber_100,0,1,16);//把百位的字模插入画布
     
264.        insert_buffer_to_canvas(1,0,p_ucAnyNumber_10,0,1,16);//把十的字模插入画布
     
265.        insert_buffer_to_canvas(2,0,p_ucAnyNumber_1,0,1,16);//把个的字模插入画布
     
266. 
     
267.        display_lattice(3,24,ucCanvasBuffer,0,4,8,0);   //显示上半屏的画布,最后的参数0是偏移量
     
268.        display_lattice(11,0,ucCanvasBuffer,0,4,8,32);  //显示下半屏的画布,最后的参数32是偏移量
     
269.     }
     
270. }
     
271. 
     
272. 
     
273. 
     
274. void clear_all_canvas(void)  //把画布全部清零
     
275. {
     
276.    unsigned int j=0;
     
277.    unsigned int i=0;
     
278. 
     
279.    for(j=0;j<16;j++)  //这里的16表示画布有16行
     
280.    {
     
281.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
     
282.       {
     
283.                   ucCanvasBuffer[j*4+i]=0x00;
     
284.       }
     
285.    }         
     
286. 
     
287. }
     
288. 
     
289. 
     
290. 
     
291. 
     
292. 
     
293. void display_clear(unsigned char ucFillDate) // 清屏  全部显示空填充0x00   全部显示点阵用0xff
     
294. {   
     
295. 
     
296.     unsigned char x,y;
     
297.     WriteCommand(0x34);  //关显示缓冲指令            
     
298.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
299.     y=0;
     
300.     while(y<32)  //y轴的范围0至31
     
301.     {
     
302.          WriteCommand(y+0x80);        //垂直地址
     
303.          WriteCommand(0x80);          //水平地址
     
304.          for(x=0;x<32;x++)  //256个横向点，有32个字节
     
305.          {  
     
306.             LCDWriteData(ucFillDate);
     
307.          }
     
308.          y++;
     
309.     }
     
310.     WriteCommand(0x36); //开显示缓冲指令
     
311. 
     
312. }
     
313. 
     
314. /* 注释四：
     
315. * 把字模插入画布的函数.
     
316. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
317. * 第1，2个参数x,y是在画布中的坐标体系。
     
318. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
     
319. * 第3个参数*ucArray是字模的数组。
     
320. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
321. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
322. */
     
323. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
     
324. {
     
325.    unsigned int j=0;
     
326.    unsigned int i=0;
     
327.    unsigned char ucTemp;
     
328.    for(j=0;j<y_amount;j++)
     
329.    {
     
330.       for(i=0;i<x_amount;i++)
     
331.       {
     
332.                    ucTemp=ucArray[j*x_amount+i];
     
333.                    if(ucFbFlag==0)
     
334.                    {
     
335.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
     
336.                    }
     
337.                    else
     
338.                    {
     
339.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
     
340.                    }
     
341.       }
     
342.    }         
     
343. 
     
344. }
     
345. 
     
346. /* 注释五：
     
347. * 显示任意点阵函数.
     
348. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
     
349. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
350. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
     
351. * 第3个参数*ucArray是字模的数组。
     
352. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
353. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
354. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
     
355. */
     
356. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr)
     
357. {
     
358.    unsigned int j=0;
     
359.    unsigned int i=0;
     
360.    unsigned char ucTemp;
     
361. 
     
362. //注意，要把以下两行指令屏蔽，否则屏幕在更新显示时会整屏闪动
     
363. //  WriteCommand(0x34);  //关显示缓冲指令            
     
364. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
365.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
     
366.    {
     
367.        WriteCommand(y+j+0x80);        //垂直地址
     
368.        WriteCommand(x+0x80);          //水平地址
     
369.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
     
370.        {
     
371.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
     
372.            if(ucFbFlag==1)  //反白显示
     
373.            {
     
374.                ucTemp=~ucTemp;
     
375.            }
     
376.            LCDWriteData(ucTemp);
     
377.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
     
378.       }
     
379.    }
     
380.    WriteCommand(0x36); //开显示缓冲指令
     
381. }
     
382. 
     
383. 
     
384. 
     
385. 
     
386. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
     
387. {
     
388.         unsigned char i;
     
389.         for ( i = 0; i < 8; i++ )
     
390.         {
     
391.                 if ( (ucData << i) & 0x80 )
     
392.                 {
     
393.                         LCDSID_dr = 1;
     
394.                 }
     
395.                 else
     
396.                 {
     
397.                         LCDSID_dr = 0;
     
398.                 }
     
399.                 LCDCLK_dr = 0;
     
400.                 LCDCLK_dr = 1;
     
401.         }
     
402. }
     
403. 
     
404. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
     
405. {
     
406.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
     
407.         SendByteToLcd( ucWData & 0xf0 );
     
408.         SendByteToLcd( (ucWData << 4) & 0xf0);
     
409. }
     
410. 
     
411. 
     
412. void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
     
413. {
     
414. 
     
415.         LCDCS_dr = 0;
     
416.         LCDCS_dr = 1;
     
417.         SPIWrite(ucCommand, 0);
     
418.         delay_short(90);
     
419. }
     
420. 
     
421. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
     
422. {
     
423.         LCDCS_dr = 0;
     
424.         LCDCS_dr = 1;
     
425.         SPIWrite(ucData, 1);
     
426. }
     
427. 
     
428. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
     
429. {
     
430.         LCDRST_dr = 1;  //复位
     
431.         LCDRST_dr = 0;
     
432.         LCDRST_dr = 1;
     
433. }
     
434. 
     
435. 
     
436. 
     
437. void delay_short(unsigned int uiDelayShort) //延时函数
     
438. {
     
439.    unsigned int i;  
     
440.    for(i=0;i<uiDelayShort;i++)
     
441.    {
     
442.      ;  
     
443.    }
     
444. }
     
445. 
     
446. 
     
447. void delay_long(unsigned int uiDelayLong)
     
448. {
     
449.    unsigned int i;
     
450.    unsigned int j;
     
451.    for(i=0;i<uiDelayLong;i++)
     
452.    {
     
453.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
     
454.           {
     
455.              ; //一个分号相当于执行一条空语句
     
456.           }
     
457.    }
     
458. }
     

复制代码

总结陈词：
有了这一节的基础，我们继续循序渐进，下一节将会讲到液晶屏的菜单程序。欲知详情，请听下回分解-----在1个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

（未完待续，下节更精彩，不要走开哦）

jianhong_wu

第七十七节：在1个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

开场白：
    这一节要教会大家两个知识点：
第一个知识点：我在前面讲数码管显示的时候就提出了一个 “一二级菜单显示理论”：凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。把每一个窗口的内容分为两种类型，一种类型是那些不用经常刷新显示的内容，只有在切换窗口的时候才需要更新的，这种内容放在整屏更新显示的括号里，比如清屏操作等内容。另外一种是那些经常需要刷新显示的内容，这种内容放在局部更新显示的括号里。
第二个知识点：按键如何跟液晶屏显示有机的结合起来？只要遵循鸿哥总结出来的一个规律“在不同的窗口下，根据不同的局部变量来操作不同的参数”，这样再复杂的人机交互程序都会显得很简单清晰。

具体内容，请看源代码讲解。

（1）硬件平台：基于坚鸿51单片机学习板。加按键对应S1键，减按键对应S5键，切换“光标”移动按键对应S9键，设置参数按键对应S13键。

（2）实现功能：
     通过按键设置4个不同的参数。
    有1个窗口。每个窗口显示4个参数。每个参数的范围是从0到99。
   有4个按键：
（a）        一个是设置参数S13按键，按下此按键，液晶屏的第一行会出现反显的光标，表示进入设置参数模式，再次按下此按键，反显光标会消失，表示退出设置参数模式。
（b）        一个是移动光标S9按键，在进入设置参数的模式下，依次按下此按键，液晶屏上的光标会从上往下移动，表示选中不同的参数。
（c）        一个是减数S5按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐减小。
（d）        一个是加数S1按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐加大。

（3）源代码讲解如下：

1. #include "REG52.H"
   
2. 
   
3. 
   
4. #define const_voice_short  40   //蜂鸣器短叫的持续时间
   
5. 
   
6. #define const_key_time1  20    //按键去抖动延时的时间
   
7. #define const_key_time2  20    //按键去抖动延时的时间
   
8. #define const_key_time3  20    //按键去抖动延时的时间
   
9. #define const_key_time4  20    //按键去抖动延时的时间
   
10. 
    
11. 
    
12. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
    
13. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
    
14. sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
    
15. sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键
    
16. 
    
17. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
    
18. 
    
19. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
    
20. 
    
21. sbit  LCDCS_dr  = P1^6;  //片选线
    
22. sbit  LCDSID_dr = P1^7;  //串行数据线
    
23. sbit  LCDCLK_dr = P3^2;  //串行时钟线
    
24. sbit  LCDRST_dr = P3^4;  //复位线
    
25. 
    
26. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
    
27. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
    
28. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
    
29. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
    
30. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
    
31. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
    
32. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount);//把字模插入画布.
    
33. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr); //显示任意点阵函数
    
34. unsigned char *number_to_matrix(unsigned char  ucBitNumber); //把一位数字转换成字模首地址的函数
    
35. void delay_short(unsigned int uiDelayshort); //延时
    
36. void delay_long(unsigned int uiDelayLong);
    
37. 
    
38. void T0_time(); //定时中断函数
    
39. void key_service(void); //按键服务的应用程序
    
40. void key_scan(void);//按键扫描函数 放在定时中断里
    
41. 
    
42. void initial_myself();   
    
43. void initial_peripheral();
    
44. 
    
45. 
    
46. void lcd_display_service(void); //应用层面的液晶屏显示程序
    
47. void clear_all_canvas(void);  //把画布全部清零
    
48. 
    
49. code unsigned char Zf816_0[]=
    
50. {
    
51. /*--  文字:  0  --*/
    
52. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
53. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
    
54. };
    
55. 
    
56. code unsigned char Zf816_1[]=
    
57. {
    
58. /*--  文字:  1  --*/
    
59. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
60. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
    
61. };
    
62. 
    
63. code unsigned char Zf816_2[]=
    
64. {
    
65. /*--  文字:  2  --*/
    
66. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
67. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
    
68. };
    
69. 
    
70. code unsigned char Zf816_3[]=
    
71. {
    
72. /*--  文字:  3  --*/
    
73. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
74. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
    
75. };
    
76. 
    
77. code unsigned char Zf816_4[]=
    
78. {
    
79. /*--  文字:  4  --*/
    
80. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
81. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
    
82. };
    
83. 
    
84. code unsigned char Zf816_5[]=
    
85. {
    
86. /*--  文字:  5  --*/
    
87. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
88. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
    
89. };
    
90. 
    
91. code unsigned char Zf816_6[]=
    
92. {
    
93. /*--  文字:  6  --*/
    
94. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
95. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
    
96. };
    
97. 
    
98. 
    
99. code unsigned char Zf816_7[]=
    
100. {
     
101. /*--  文字:  7  --*/
     
102. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
     
103. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
     
104. };
     
105. 
     
106. code unsigned char Zf816_8[]=
     
107. {
     
108. /*--  文字:  8  --*/
     
109. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
     
110. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
     
111. };
     
112. 
     
113. code unsigned char Zf816_9[]=
     
114. {
     
115. /*--  文字:  9  --*/
     
116. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
     
117. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
     
118. };
     
119. 
     
120. 
     
121. code unsigned char Zf816_nc[]=  //空字模
     
122. {
     
123. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
124. };
     
125. 
     
126. code unsigned char Zf816_mao_hao[]=  //冒号
     
127. {
     
128. /*--  文字:  :  --*/
     
129. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
     
130. 0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
     
131. };
     
132. 
     
133. code unsigned char Hz1616_yi[]=
     
134. {
     
135. /*--  文字:  一  --*/
     
136. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
137. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
     
138. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
139. };
     
140. 
     
141. code unsigned char Hz1616_er[]=
     
142. {
     
143. /*--  文字:  二  --*/
     
144. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
145. 0x00,0x00,0x00,0x10,0x3F,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
146. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,
     
147. };
     
148. 
     
149. code unsigned char Hz1616_san[]=
     
150. {
     
151. /*--  文字:  三  --*/
     
152. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
153. 0x00,0x00,0x00,0x00,0x7F,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0xF8,
     
154. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0xFE,0x00,0x00,0x00,0x00,
     
155. };
     
156. 
     
157. code unsigned char Hz1616_si[]=
     
158. {
     
159. /*--  文字:  四  --*/
     
160. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
161. 0x00,0x00,0x7F,0xFC,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,
     
162. 0x48,0x84,0x48,0x7C,0x50,0x04,0x60,0x04,0x40,0x04,0x7F,0xFC,0x40,0x04,0x00,0x00,
     
163. };
     
164. 
     
165. code unsigned char Hz1616_chuang[]=
     
166. {
     
167. /*--  文字:  窗  --*/
     
168. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
169. 0x01,0x00,0x00,0x80,0x7F,0xFE,0x40,0x22,0x09,0x18,0x12,0x06,0x7F,0xF8,0x11,0x08,
     
170. 0x13,0xE8,0x14,0x48,0x1A,0x88,0x11,0x08,0x12,0x88,0x14,0x08,0x1F,0xF8,0x10,0x08,
     
171. };
     
172. 
     
173. code unsigned char Hz1616_kou[]=
     
174. {
     
175. /*--  文字:  口  --*/
     
176. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
177. 0x00,0x00,0x00,0x00,0x3F,0xF8,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,
     
178. 0x20,0x08,0x20,0x08,0x20,0x08,0x3F,0xF8,0x20,0x08,0x20,0x08,0x00,0x00,0x00,0x00,
     
179. };
     
180. 
     
181. code unsigned char Hz1616_hang[]=
     
182. {
     
183. /*--  文字:  行  --*/
     
184. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
185. 0x08,0x00,0x1C,0x00,0x31,0xFC,0x40,0x00,0x88,0x00,0x0C,0x00,0x1B,0xFE,0x30,0x20,
     
186. 0x50,0x20,0x90,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0xA0,0x10,0x40,
     
187. };
     
188. 
     
189. 
     
190. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
     
191. {
     
192. 0x00,0x00,0x00,0x00,  //上半屏
     
193. 0x00,0x00,0x00,0x00,
     
194. 0x00,0x00,0x00,0x00,
     
195. 0x00,0x00,0x00,0x00,
     
196. 0x00,0x00,0x00,0x00,
     
197. 0x00,0x00,0x00,0x00,
     
198. 0x00,0x00,0x00,0x00,
     
199. 0x00,0x00,0x00,0x00,
     
200. 
     
201. //------------上半屏和下半屏的分割线-----------
     
202. 
     
203. 0x00,0x00,0x00,0x00,  //下半屏
     
204. 0x00,0x00,0x00,0x00,
     
205. 0x00,0x00,0x00,0x00,
     
206. 0x00,0x00,0x00,0x00,
     
207. 0x00,0x00,0x00,0x00,
     
208. 0x00,0x00,0x00,0x00,
     
209. 0x00,0x00,0x00,0x00,
     
210. 0x00,0x00,0x00,0x00,
     
211. };
     
212. 
     
213. 
     
214. 
     
215. unsigned char ucKeySec=0;   //被触发的按键编号
     
216. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器
     
217. 
     
218. 
     
219. unsigned char ucWd=1; //窗口变量
     
220. unsigned char ucPart=0; //局部变量 0代表没有选中任何一行，其它数值1到4代表选中某一行
     
221. 
     
222. 
     
223. unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量      1代表更新显示，响应函数内部会清零
     
224. unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
225. unsigned char ucWd1Part2Update=0; //窗口1的第2行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
226. unsigned char ucWd1Part3Update=0; //窗口1的第3行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
227. unsigned char ucWd1Part4Update=0; //窗口1的第4行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
228. 
     
229. 
     
230. 
     
231. unsigned char ucData_1_1=8;  //第1个窗口第1行的被设置数据
     
232. unsigned char ucData_1_2=9;  //第1个窗口第2行的被设置数据
     
233. unsigned char ucData_1_3=10;  //第1个窗口第3行的被设置数据
     
234. unsigned char ucData_1_4=11;  //第1个窗口第4行的被设置数据
     
235. 
     
236. void main()
     
237.   {
     
238.         initial_myself();      //第一区,上电后马上初始化
     
239.         delay_long(100);       //一线，延时线。延时一段时间
     
240.         initial_peripheral();  //第二区,上电后延时一段时间再初始化
     
241. 
     
242.         while(1)   //第三区
     
243.         {
     
244.                     key_service(); //按键服务的应用程序
     
245.             lcd_display_service(); //应用层面的液晶屏显示程序
     
246.         }
     
247. 
     
248. }
     
249. 
     
250. 
     
251. void initial_myself()  //第一区 上电后马上初始化
     
252. {
     
253. /* 注释一：
     
254. * 矩阵键盘也可以做独立按键，前提是把某一根公共输出线输出低电平，
     
255. * 模拟独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
     
256. * 坚鸿51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
     
257. */
     
258.    key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
     
259.    beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
     
260. 
     
261.    TMOD=0x01;  //设置定时器0为工作方式1
     
262. 
     
263.    TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
     
264.    TL0=0x2f;
     
265. }
     
266. void initial_peripheral() //第二区 上电后延时一段时间再初始化
     
267. {
     
268.     LCDInit(); //初始化12864 内部包含液晶模块的复位
     
269. 
     
270. 
     
271.     EA=1;     //开总中断
     
272.     ET0=1;    //允许定时中断
     
273.     TR0=1;    //启动定时中断
     
274. 
     
275. }
     
276. 
     
277. 
     
278. void T0_time() interrupt 1
     
279. {
     
280.   TF0=0;  //清除中断标志
     
281.   TR0=0; //关中断
     
282. 
     
283.   key_scan(); //按键扫描函数
     
284. 
     
285.   if(uiVoiceCnt!=0)
     
286.   {
     
287.      uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
     
288.          beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
     
289.   }
     
290.   else
     
291.   {
     
292.      ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
     
293.            beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
     
294.   }
     
295. 
     
296. 
     
297.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
     
298.   TL0=0x2f;
     
299.   TR0=1;  //开中断
     
300. }
     
301. 
     
302. 
     
303. 
     
304. void key_scan(void)//按键扫描函数 放在定时中断里
     
305. {  
     
306. 
     
307. 
     
308.   static unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
     
309.   static unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
     
310. 
     
311.   static unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
     
312.   static unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
     
313. 
     
314.   static unsigned int  uiKeyTimeCnt3=0; //按键去抖动延时计数器
     
315.   static unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
     
316. 
     
317.   static unsigned int  uiKeyTimeCnt4=0; //按键去抖动延时计数器
     
318.   static unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志
     
319. 
     
320.   if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
     
321.   {
     
322.      ucKeyLock1=0; //按键自锁标志清零
     
323.      uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
     
324.   }
     
325.   else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
     
326.   {
     
327.      uiKeyTimeCnt1++; //累加定时中断次数
     
328.      if(uiKeyTimeCnt1>const_key_time1)
     
329.      {
     
330.         uiKeyTimeCnt1=0;
     
331.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
     
332.         ucKeySec=1;    //触发1号键
     
333.      }
     
334.   }
     
335. 
     
336.   if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
     
337.   {
     
338.      ucKeyLock2=0; //按键自锁标志清零
     
339.      uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
     
340.   }
     
341.   else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
     
342.   {
     
343.      uiKeyTimeCnt2++; //累加定时中断次数
     
344.      if(uiKeyTimeCnt2>const_key_time2)
     
345.      {
     
346.         uiKeyTimeCnt2=0;
     
347.         ucKeyLock2=1;  //自锁按键置位,避免一直触发
     
348.         ucKeySec=2;    //触发2号键
     
349.      }
     
350.   }
     
351. 
     
352.   if(key_sr3==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
     
353.   {
     
354.      ucKeyLock3=0; //按键自锁标志清零
     
355.      uiKeyTimeCnt3=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
     
356.   }
     
357.   else if(ucKeyLock3==0)//有按键按下，且是第一次被按下
     
358.   {
     
359.      uiKeyTimeCnt3++; //累加定时中断次数
     
360.      if(uiKeyTimeCnt3>const_key_time3)
     
361.      {
     
362.         uiKeyTimeCnt3=0;
     
363.         ucKeyLock3=1;  //自锁按键置位,避免一直触发
     
364.         ucKeySec=3;    //触发3号键
     
365.      }
     
366.   }
     
367. 
     
368.   if(key_sr4==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
     
369.   {
     
370.      ucKeyLock4=0; //按键自锁标志清零
     
371.      uiKeyTimeCnt4=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
     
372.   }
     
373.   else if(ucKeyLock4==0)//有按键按下，且是第一次被按下
     
374.   {
     
375.      uiKeyTimeCnt4++; //累加定时中断次数
     
376.      if(uiKeyTimeCnt4>const_key_time4)
     
377.      {
     
378.         uiKeyTimeCnt4=0;
     
379.         ucKeyLock4=1;  //自锁按键置位,避免一直触发
     
380.         ucKeySec=4;    //触发4号键
     
381.      }
     
382.   }
     
383. 
     
384. }
     
385. 
     
386. 
     
387. void key_service(void) //按键服务的应用程序
     
388. {
     
389.   switch(ucKeySec) //按键服务状态切换
     
390.   {
     
391.     case 1:// 加按键 对应朱兆祺学习板的S1键
     
392.           switch(ucWd)  //在不同的窗口下，设置不同的参数
     
393.           {
     
394.               case 1:
     
395.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
     
396.                    {
     
397.                           case 0:   //无光标显示的状态 此处的case 0可以省略
     
398. 
     
399.                                 break;
     
400.                           case 1:   //设置第1行参数
     
401.                                 ucData_1_1++;
     
402.                                                                 if(ucData_1_1>99)
     
403.                                                                 {
     
404.                                                                    ucData_1_1=99;
     
405.                                                                 }
     
406.                                 ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
     
407.                                 break;
     
408.                           case 2:   //设置第2行参数
     
409.                                 ucData_1_2++;
     
410.                                                                 if(ucData_1_2>99)
     
411.                                                                 {
     
412.                                                                    ucData_1_2=99;
     
413.                                                                 }
     
414.                                 ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
     
415.                                 break;
     
416.                           case 3:   //设置第3行参数
     
417.                                 ucData_1_3++;
     
418.                                                                 if(ucData_1_3>99)
     
419.                                                                 {
     
420.                                                                    ucData_1_3=99;
     
421.                                                                 }
     
422.                                 ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
     
423.                                 break;
     
424.                           case 4:   //设置第4行参数
     
425.                                 ucData_1_4++;
     
426.                                                                 if(ucData_1_4>99)
     
427.                                                                 {
     
428.                                                                    ucData_1_4=99;
     
429.                                                                 }
     
430.                                 ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
     
431.                                 break;
     
432. 
     
433. 
     
434.                    }
     
435.                    break;
     
436.          
     
437.           }     
     
438.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
     
439.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
     
440.           break;   
     
441.    
     
442.     case 2:// 减按键 对应朱兆祺学习板的S5键
     
443.           switch(ucWd)  //在不同的窗口下，设置不同的参数
     
444.           {
     
445.               case 1:
     
446.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
     
447.                    {
     
448.                           case 0:   //无光标显示的状态 此处的case 0可以省略
     
449. 
     
450.                                 break;
     
451.                           case 1:   //设置第1行参数
     
452.                                 ucData_1_1--;
     
453.                                                                 if(ucData_1_1>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
454.                                                                 {
     
455.                                                                    ucData_1_1=0;
     
456.                                                                 }
     
457.                                 ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
     
458.                                 break;
     
459.                           case 2:   //设置第2行参数
     
460.                                 ucData_1_2--;
     
461.                                                                 if(ucData_1_2>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
462.                                                                 {
     
463.                                                                    ucData_1_2=0;
     
464.                                                                 }
     
465.                                 ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
     
466.                                 break;
     
467.                           case 3:   //设置第3行参数
     
468.                                 ucData_1_3--;
     
469.                                                                 if(ucData_1_3>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
470.                                                                 {
     
471.                                                                    ucData_1_3=0;
     
472.                                                                 }
     
473.                                 ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
     
474.                                 break;
     
475.                           case 4:   //设置第4行参数
     
476.                                 ucData_1_4--;
     
477.                                                                 if(ucData_1_4>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
478.                                                                 {
     
479.                                                                    ucData_1_4=0;
     
480.                                                                 }
     
481.                                 ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
     
482.                                 break;
     
483. 
     
484. 
     
485.                    }
     
486.                    break;
     
487.          
     
488.           }     
     
489.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
     
490.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
     
491.           break;  
     
492. 
     
493.     case 3:// 切换"光标"移动按键 对应朱兆祺学习板的S9键
     
494.           switch(ucWd)  //在不同的窗口下，设置不同的参数
     
495.           {
     
496.               case 1:
     
497.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
     
498.                    {
     
499.                           case 0:   //无光标显示的状态 此处的case 0可以省略
     
500. 
     
501.                                 break;
     
502.                           case 1:   //设置第1行参数
     
503.                                 ucPart=2; //光标切换到下一行
     
504.                                 ucWd1Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
505.                                 ucWd1Part2Update=1; //更新显示下一行，    目的是更新反显光标的状态
     
506.                                 break;
     
507.                           case 2:   //设置第2行参数
     
508.                                 ucPart=3; //光标切换到下一行
     
509.                                 ucWd1Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
510.                                 ucWd1Part3Update=1; //更新显示下一行，    目的是更新反显光标的状态
     
511.                                 break;
     
512.                           case 3:   //设置第3行参数
     
513.                                 ucPart=4; //光标切换到下一行
     
514.                                 ucWd1Part3Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
515.                                 ucWd1Part4Update=1; //更新显示下一行，    目的是更新反显光标的状态
     
516.                                 break;
     
517.                           case 4:   //设置第4行参数
     
518.                                 ucPart=1; //光标返回到最上面第一行
     
519.                                 ucWd1Part4Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
520.                                 ucWd1Part1Update=1; //更新显示最上面第一行，    目的是更新反显光标的状态
     
521.                                 break;
     
522. 
     
523. 
     
524.                    }
     
525.                    break;
     
526.          
     
527.           }         
     
528.         
     
529.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
     
530.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
     
531.           break;      
     
532.    
     
533.     case 4: // 设置按键  对应朱兆祺学习板的S13键，按一次进入设置状态，出现反显光标。再按一次推出设置状态，消除反显光标
     
534.           switch(ucWd)  //在不同的窗口下，设置不同的参数
     
535.           {
     
536.               case 1:
     
537.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
     
538.                    {
     
539. 
     
540.                           case 0:   //无光标显示的状态
     
541.                                 ucPart=1; //光标显示第一行，进入设置模式
     
542.                                 ucWd1Part1Update=1; //更新显示
     
543.                                 break;
     
544.                           case 1:   //设置第1行参数
     
545.                                 ucPart=0; //无光标显示，退出设置模式
     
546.                                 ucWd1Part1Update=1; //更新显示
     
547.                                 break;
     
548.                           case 2:   //设置第2行参数
     
549.                                 ucPart=0; //无光标显示，退出设置模式
     
550.                                 ucWd1Part2Update=1; //更新显示
     
551.                                 break;
     
552.                           case 3:   //设置第3行参数
     
553.                                 ucPart=0; //无光标显示，退出设置模式
     
554.                                 ucWd1Part3Update=1; //更新显示
     
555.                                 break;
     
556.                           case 4:   //设置第4行参数
     
557.                                 ucPart=0; //无光标显示，退出设置模式
     
558.                                 ucWd1Part4Update=1; //更新显示
     
559.                                 break;
     
560. 
     
561. 
     
562.                    }
     
563.                    break;
     
564.          
     
565.           }   
     
566. 
     
567.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
     
568.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
     
569.           break;         
     
570. 
     
571.   }               
     
572. }
     
573. 
     
574. 
     
575. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
     
576. {
     
577.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小，分别调用不同的字库。
     
578. 
     
579.         switch(ucBitNumber)  //根据ucBitNumber数值的大小，分别调用不同的字库。
     
580.         {
     
581.             case 0:
     
582.              p_ucAnyNumber=Zf816_0;
     
583.                      break;
     
584.             case 1:
     
585.              p_ucAnyNumber=Zf816_1;
     
586.                      break;
     
587.             case 2:
     
588.              p_ucAnyNumber=Zf816_2;
     
589.                      break;
     
590.             case 3:
     
591.              p_ucAnyNumber=Zf816_3;
     
592.                      break;
     
593.             case 4:
     
594.              p_ucAnyNumber=Zf816_4;
     
595.                      break;
     
596.             case 5:
     
597.              p_ucAnyNumber=Zf816_5;
     
598.                      break;
     
599.             case 6:
     
600.              p_ucAnyNumber=Zf816_6;
     
601.                      break;
     
602.             case 7:
     
603.              p_ucAnyNumber=Zf816_7;
     
604.                      break;
     
605.             case 8:
     
606.              p_ucAnyNumber=Zf816_8;
     
607.                      break;
     
608.             case 9:
     
609.              p_ucAnyNumber=Zf816_9;
     
610.                      break;
     
611.             case 10:
     
612.              p_ucAnyNumber=Zf816_nc;
     
613.                      break;
     
614.                 default:   //如果上面的条件都不符合，那么默认指向空字模
     
615.              p_ucAnyNumber=Zf816_nc;
     
616.                      break;
     
617.         }
     
618. 
     
619.     return p_ucAnyNumber;  //返回转换结束后的指针
     
620. }
     
621. 
     
622. 
     
623. 
     
624. void lcd_display_service(void) //应用层面的液晶屏显示程序
     
625. {
     
626.     unsigned char ucAnyNumber_1; //分解变量的个位
     
627.     unsigned char ucAnyNumber_10; //分解变量的十位
     
628. 
     
629. 
     
630.     unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
     
631.     unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
     
632. 
     
633.         unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
     
634. 
     
635.     switch(ucWd)  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
     
636.     {
     
637.         case 1:   //显示窗口1的数据
     
638. 
     
639. /* 注释二：
     
640. * 把每一个窗口的内容分为两种类型，一种类型是那些不用经常刷新显示的内容，只有在切换窗口的时候
     
641. * 才需要更新，这种内容放在整屏更新显示的括号里，比如清屏操作等内容。另外一种是那些经常需要
     
642. * 刷新显示的内容，这种内容放在局部更新显示的括号里。
     
643. */
     
644.                       if(ucWd1Update==1)  //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
     
645.                           {
     
646.                              ucWd1Update=0;  //及时清零，避免一直更新
     
647. 
     
648.                  ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
     
649.                  ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
     
650.                  ucWd1Part3Update=1; //激活窗口1的第3行局部更新显示变量，这里在前面数码管显示框架上有所改进
     
651.                  ucWd1Part4Update=1; //激活窗口1的第4行局部更新显示变量，这里在前面数码管显示框架上有所改进
     
652. 
     
653.                  display_clear(0x00); // 清屏操作， 全部显示空填充0x00，全部显示点阵用0xff。
     
654.                  clear_all_canvas();  //把画布全部清零
     
655.                  insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布
     
656. 
     
657.                  display_lattice(0,0,Hz1616_yi,0,2,16,0);    //一窗口一行，这些内容不用经常更新，只有在切换窗口的时候才更新显示
     
658.                  display_lattice(1,0,Hz1616_chuang,0,2,16,0);   
     
659.                  display_lattice(2,0,Hz1616_kou,0,2,16,0);   
     
660.                  display_lattice(3,0,Hz1616_yi,0,2,16,0);
     
661.                  display_lattice(4,0,Hz1616_hang,0,2,16,0);
     
662. 
     
663.                  display_lattice(0,16,Hz1616_yi,0,2,16,0);    //一窗口二行
     
664.                  display_lattice(1,16,Hz1616_chuang,0,2,16,0);   
     
665.                  display_lattice(2,16,Hz1616_kou,0,2,16,0);   
     
666.                  display_lattice(3,16,Hz1616_er,0,2,16,0);
     
667.                  display_lattice(4,16,Hz1616_hang,0,2,16,0);
     
668. 
     
669.                  display_lattice(8,0,Hz1616_yi,0,2,16,0);    //一窗口三行
     
670.                  display_lattice(9,0,Hz1616_chuang,0,2,16,0);   
     
671.                  display_lattice(10,0,Hz1616_kou,0,2,16,0);   
     
672.                  display_lattice(11,0,Hz1616_san,0,2,16,0);
     
673.                  display_lattice(12,0,Hz1616_hang,0,2,16,0);
     
674. 
     
675.                  display_lattice(8,16,Hz1616_yi,0,2,16,0);    //一窗口四行
     
676.                  display_lattice(9,16,Hz1616_chuang,0,2,16,0);   
     
677.                  display_lattice(10,16,Hz1616_kou,0,2,16,0);   
     
678.                  display_lattice(11,16,Hz1616_si,0,2,16,0);
     
679.                  display_lattice(12,16,Hz1616_hang,0,2,16,0);
     
680. 
     
681.                           }
     
682. 
     
683. /* 注释三：
     
684. * 注意！我前面讲数码管显示的时候有一句话讲错了，我那时说<局部更新应该写在整屏更新之前>,这是不对的。
     
685. * 按照现在的显示程序框架<即整屏显示更新括号里包含了所有局部变量的激活>，应该是<整屏更新应该写在局部更新之前>
     
686. * 这样才对。
     
687. */
     
688.                           if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
     
689.                           {
     
690.                              ucWd1Part1Update=0; //及时清零，避免一直更新
     
691. 
     
692.                      if(ucPart==1) //被选中
     
693.                                  {
     
694.                                     ucCursorFlag=1; //反显 显示
     
695.                                  }
     
696.                      else //没被选中
     
697.                                  {
     
698.                                     ucCursorFlag=0; //正常 显示
     
699.                                  }
     
700. 
     
701.                  if(ucData_1_1>=10) //有2位数以上
     
702.                  {
     
703.                     ucAnyNumber_10=ucData_1_1/10;  //十位
     
704.                  }
     
705.                  else //否则显示空
     
706.                  {
     
707.                     ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
     
708.                  }
     
709. 
     
710.                  ucAnyNumber_1=ucData_1_1%10/1;  //个位
     
711. 
     
712.    
     
713.                  p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
     
714.                  p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
     
715. 
     
716. 
     
717.                  insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
     
718.                  insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
     
719. 
     
720.                  display_lattice(5,0,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
     
721. 
     
722.                           
     
723.                           }
     
724. 
     
725.                           if(ucWd1Part2Update==1) //窗口1的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
     
726.                           {
     
727.                              ucWd1Part2Update=0; //及时清零，避免一直更新
     
728. 
     
729.                      if(ucPart==2) //被选中
     
730.                                  {
     
731.                                     ucCursorFlag=1; //反显 显示
     
732.                                  }
     
733.                      else //没被选中
     
734.                                  {
     
735.                                     ucCursorFlag=0; //正常 显示
     
736.                                  }
     
737. 
     
738.                  if(ucData_1_2>=10) //有2位数以上
     
739.                  {
     
740.                     ucAnyNumber_10=ucData_1_2/10;  //十位
     
741.                  }
     
742.                  else //否则显示空
     
743.                  {
     
744.                     ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
     
745.                  }
     
746. 
     
747.                  ucAnyNumber_1=ucData_1_2%10/1;  //个位
     
748. 
     
749.    
     
750.                  p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
     
751.                  p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
     
752. 
     
753. 
     
754.                  insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
     
755.                  insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
     
756. 
     
757.                  display_lattice(5,16,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
     
758.                           
     
759.                           }
     
760. 
     
761.                           if(ucWd1Part3Update==1) //窗口1的第3行局部更新显示变量,里面放一些经常需要刷新显示的内容
     
762.                           {
     
763.                              ucWd1Part3Update=0; //及时清零，避免一直更新
     
764. 
     
765.                      if(ucPart==3) //被选中
     
766.                                  {
     
767.                                     ucCursorFlag=1; //反显 显示
     
768.                                  }
     
769.                      else //没被选中
     
770.                                  {
     
771.                                     ucCursorFlag=0; //正常 显示
     
772.                                  }
     
773. 
     
774.                  if(ucData_1_3>=10) //有2位数以上
     
775.                  {
     
776.                     ucAnyNumber_10=ucData_1_3/10;  //十位
     
777.                  }
     
778.                  else //否则显示空
     
779.                  {
     
780.                     ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
     
781.                  }
     
782. 
     
783.                  ucAnyNumber_1=ucData_1_3%10/1;  //个位
     
784. 
     
785.    
     
786.                  p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
     
787.                  p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
     
788. 
     
789. 
     
790.                  insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
     
791.                  insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
     
792. 
     
793.                  display_lattice(13,0,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
     
794.                           
     
795.                           }
     
796. 
     
797.                           if(ucWd1Part4Update==1) //窗口1的第4行局部更新显示变量,里面放一些经常需要刷新显示的内容
     
798.                           {
     
799.                              ucWd1Part4Update=0; //及时清零，避免一直更新
     
800. 
     
801.                      if(ucPart==4) //被选中
     
802.                                  {
     
803.                                     ucCursorFlag=1; //反显 显示
     
804.                                  }
     
805.                      else //没被选中
     
806.                                  {
     
807.                                     ucCursorFlag=0; //正常 显示
     
808.                                  }
     
809. 
     
810.                  if(ucData_1_4>=10) //有2位数以上
     
811.                  {
     
812.                     ucAnyNumber_10=ucData_1_4/10;  //十位
     
813.                  }
     
814.                  else //否则显示空
     
815.                  {
     
816.                     ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
     
817.                  }
     
818. 
     
819.                  ucAnyNumber_1=ucData_1_4%10/1;  //个位
     
820. 
     
821.    
     
822.                  p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
     
823.                  p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
     
824. 
     
825. 
     
826.                  insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
     
827.                  insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
     
828. 
     
829.                  display_lattice(13,16,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量                          
     
830.                           }
     
831. 
     
832.               break;
     
833.         //本程序只有1个窗口，所以只有一个case 1，如果要增加窗口，就直接增加 case 2, case 3...        
     
834.     }
     
835. 
     
836. 
     
837. }
     
838. 
     
839. 
     
840. 
     
841. void clear_all_canvas(void)  //把画布全部清零
     
842. {
     
843.    unsigned int j=0;
     
844.    unsigned int i=0;
     
845. 
     
846.    for(j=0;j<16;j++)  //这里的16表示画布有16行
     
847.    {
     
848.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
     
849.       {
     
850.                   ucCanvasBuffer[j*4+i]=0x00;
     
851.       }
     
852.    }         
     
853. 
     
854. }
     
855. 
     
856. 
     
857. 
     
858. 
     
859. 
     
860. void display_clear(unsigned char ucFillDate) // 清屏  全部显示空填充0x00   全部显示点阵用0xff
     
861. {   
     
862. 
     
863.     unsigned char x,y;
     
864.     WriteCommand(0x34);  //关显示缓冲指令            
     
865.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
866.     y=0;
     
867.     while(y<32)  //y轴的范围0至31
     
868.     {
     
869.          WriteCommand(y+0x80);        //垂直地址
     
870.          WriteCommand(0x80);          //水平地址
     
871.          for(x=0;x<32;x++)  //256个横向点，有32个字节
     
872.          {  
     
873.             LCDWriteData(ucFillDate);
     
874.          }
     
875.          y++;
     
876.     }
     
877.     WriteCommand(0x36); //开显示缓冲指令
     
878. 
     
879. }
     
880. 
     
881. /* 注释四：
     
882. * 把字模插入画布的函数.
     
883. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
884. * 第1，2个参数x,y是在画布中的坐标体系。
     
885. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
     
886. * 第3个参数*ucArray是字模的数组。
     
887. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
888. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
889. */
     
890. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
     
891. {
     
892.    unsigned int j=0;
     
893.    unsigned int i=0;
     
894.    unsigned char ucTemp;
     
895.    for(j=0;j<y_amount;j++)
     
896.    {
     
897.       for(i=0;i<x_amount;i++)
     
898.       {
     
899.                    ucTemp=ucArray[j*x_amount+i];
     
900.                    if(ucFbFlag==0)
     
901.                    {
     
902.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
     
903.                    }
     
904.                    else
     
905.                    {
     
906.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
     
907.                    }
     
908.       }
     
909.    }         
     
910. 
     
911. }
     
912. 
     
913. /* 注释五：
     
914. * 显示任意点阵函数.
     
915. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
     
916. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
     
917. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
     
918. * 第3个参数*ucArray是字模的数组。
     
919. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
     
920. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
     
921. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
     
922. */
     
923. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr)
     
924. {
     
925.    unsigned int j=0;
     
926.    unsigned int i=0;
     
927.    unsigned char ucTemp;
     
928. 
     
929. //注意，要把以下两行指令屏蔽，否则屏幕在更新显示时会整屏闪动
     
930. //  WriteCommand(0x34);  //关显示缓冲指令            
     
931. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
     
932.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
     
933.    {
     
934.        WriteCommand(y+j+0x80);        //垂直地址
     
935.        WriteCommand(x+0x80);          //水平地址
     
936.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
     
937.        {
     
938.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
     
939.            if(ucFbFlag==1)  //反白显示
     
940.            {
     
941.                ucTemp=~ucTemp;
     
942.            }
     
943.            LCDWriteData(ucTemp);
     
944.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
     
945.       }
     
946.    }
     
947.    WriteCommand(0x36); //开显示缓冲指令
     
948. }
     
949. 
     
950. 
     
951. 
     
952. 
     
953. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
     
954. {
     
955.         unsigned char i;
     
956.         for ( i = 0; i < 8; i++ )
     
957.         {
     
958.                 if ( (ucData << i) & 0x80 )
     
959.                 {
     
960.                         LCDSID_dr = 1;
     
961.                 }
     
962.                 else
     
963.                 {
     
964.                         LCDSID_dr = 0;
     
965.                 }
     
966.                 LCDCLK_dr = 0;
     
967.                 LCDCLK_dr = 1;
     
968.         }
     
969. }
     
970. 
     
971. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
     
972. {
     
973.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
     
974.         SendByteToLcd( ucWData & 0xf0 );
     
975.         SendByteToLcd( (ucWData << 4) & 0xf0);
     
976. }
     
977. 
     
978. 
     
979. void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
     
980. {
     
981. 
     
982.         LCDCS_dr = 0;
     
983.         LCDCS_dr = 1;
     
984.         SPIWrite(ucCommand, 0);
     
985.         delay_short(90);
     
986. }
     
987. 
     
988. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
     
989. {
     
990.         LCDCS_dr = 0;
     
991.         LCDCS_dr = 1;
     
992.         SPIWrite(ucData, 1);
     
993. }
     
994. 
     
995. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
     
996. {
     
997.         LCDRST_dr = 1;  //复位
     
998.         LCDRST_dr = 0;
     
999.         LCDRST_dr = 1;
     
1000. }
      
1001. 
      
1002. 
      
1003. 
      
1004. void delay_short(unsigned int uiDelayShort) //延时函数
      
1005. {
      
1006.    unsigned int i;  
      
1007.    for(i=0;i<uiDelayShort;i++)
      
1008.    {
      
1009.      ;  
      
1010.    }
      
1011. }
      
1012. 
      
1013. 
      
1014. void delay_long(unsigned int uiDelayLong)
      
1015. {
      
1016.    unsigned int i;
      
1017.    unsigned int j;
      
1018.    for(i=0;i<uiDelayLong;i++)
      
1019.    {
      
1020.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
      
1021.           {
      
1022.              ; //一个分号相当于执行一条空语句
      
1023.           }
      
1024.    }
      
1025. }
      

复制代码

总结陈词：
这一节讲了在一个窗口里设置不同的参数，如果有几个窗口的情况下，该如何编程？欲知详情，请听下回分解-----在多个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

（未完待续，下节更精彩，不要走开哦）

jianhong_wu

第七十八节：在多个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

开场白：

上一节讲了1个窗口下如何设置参数的菜单程序，这一节多增加1个窗口变成2个窗口，看看它们两个窗口之间是如何通过按键程序进行切换的。继续巩固上一节教给大家的两个知识点：
   第一个知识点：我在前面讲数码管显示的时候就提出了一个 “一二级菜单显示理论”：凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。把每一个窗口的内容分为两种类型，一种类型是那些不用经常刷新显示的内容，只有在切换窗口的时候才需要更新的，这种内容放在整屏更新显示的括号里，比如清屏操作等内容。另外一种是那些经常需要刷新显示的内容，这种内容放在局部更新显示的括号里。
    第二个知识点：按键如何跟液晶屏显示有机的结合起来？只要遵循鸿哥总结出来的一个规律“在不同的窗口下，根据不同的局部变量来操作不同的参数”，这样再复杂的人机交互程序都会显得很简单清晰。

具体内容，请看源代码讲解。

（1）硬件平台：基于坚鸿51单片机学习板。加按键对应S1键，减按键对应S5键，切换“光标”移动按键对应S9键，设置参数按键对应S13键。

（2）实现功能：
     通过按键设置8个不同的参数。
    有2个窗口。每个窗口显示4个参数。每个参数的范围是从0到99。
    有4个按键：

（a）          一个是设置参数S13按键，按下此按键，液晶屏的第1个窗口第一行会出现反显的光标，表示进入设置参数模式，再次按下此按键，反显光标会消失，并且强行切换到第1个窗口，表示退出设置参数模式。

（b）         一个是移动光标S9按键，在进入设置参数的模式下，依次按下此按键，液晶屏上的光标会从上往下移动，表示选中不同的参数。当移动到每个窗口最下边那一行时，再按下此按键会进行切换窗口的操作。

（c）          一个是减数S5按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐减小。

（d）         一个是加数S1按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐加大。

（3）源代码讲解如下：

1. #include "REG52.H"
   
2. 
   
3. /* 注释一：
   
4. * 本程序用到的变量比较多，所以在keil编译模式里要设置一下编译模式memory model，
   
5. * 否则编译会出错.右键单击Target选择“Options for Target'Target1'”就会出来一个框
   
6. * 在memory model中选择compact:variables in pdata 就可以了。
   
7. */
   
8. 
   
9. #define const_voice_short  40   //蜂鸣器短叫的持续时间
   
10. 
    
11. #define const_key_time1  20    //按键去抖动延时的时间
    
12. #define const_key_time2  20    //按键去抖动延时的时间
    
13. #define const_key_time3  20    //按键去抖动延时的时间
    
14. #define const_key_time4  20    //按键去抖动延时的时间
    
15. 
    
16. 
    
17. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
    
18. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
    
19. sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
    
20. sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键
    
21. 
    
22. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
    
23. 
    
24. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
    
25. 
    
26. sbit  LCDCS_dr  = P1^6;  //片选线
    
27. sbit  LCDSID_dr = P1^7;  //串行数据线
    
28. sbit  LCDCLK_dr = P3^2;  //串行时钟线
    
29. sbit  LCDRST_dr = P3^4;  //复位线
    
30. 
    
31. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
    
32. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
    
33. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
    
34. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
    
35. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
    
36. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
    
37. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount);//把字模插入画布.
    
38. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr); //显示任意点阵函数
    
39. unsigned char *number_to_matrix(unsigned char  ucBitNumber); //把一位数字转换成字模首地址的函数
    
40. void delay_short(unsigned int uiDelayshort); //延时
    
41. void delay_long(unsigned int uiDelayLong);
    
42. 
    
43. void T0_time(); //定时中断函数
    
44. void key_service(void); //按键服务的应用程序
    
45. void key_scan(void);//按键扫描函数 放在定时中断里
    
46. 
    
47. void initial_myself();   
    
48. void initial_peripheral();
    
49. 
    
50. 
    
51. void lcd_display_service(void); //应用层面的液晶屏显示程序
    
52. void clear_all_canvas(void);  //把画布全部清零
    
53. 
    
54. void wd1(void);//窗口1显示的内容
    
55. void wd2(void);//窗口2显示的内容
    
56. 
    
57. code unsigned char Zf816_0[]=
    
58. {
    
59. /*--  文字:  0  --*/
    
60. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
61. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
    
62. };
    
63. 
    
64. code unsigned char Zf816_1[]=
    
65. {
    
66. /*--  文字:  1  --*/
    
67. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
68. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
    
69. };
    
70. 
    
71. code unsigned char Zf816_2[]=
    
72. {
    
73. /*--  文字:  2  --*/
    
74. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
75. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
    
76. };
    
77. 
    
78. code unsigned char Zf816_3[]=
    
79. {
    
80. /*--  文字:  3  --*/
    
81. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
82. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
    
83. };
    
84. 
    
85. code unsigned char Zf816_4[]=
    
86. {
    
87. /*--  文字:  4  --*/
    
88. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
89. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
    
90. };
    
91. 
    
92. code unsigned char Zf816_5[]=
    
93. {
    
94. /*--  文字:  5  --*/
    
95. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    
96. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
    
97. };
    
98. 
    
99. code unsigned char Zf816_6[]=
    
100. {
     
101. /*--  文字:  6  --*/
     
102. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
     
103. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
     
104. };
     
105. 
     
106. 
     
107. code unsigned char Zf816_7[]=
     
108. {
     
109. /*--  文字:  7  --*/
     
110. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
     
111. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
     
112. };
     
113. 
     
114. code unsigned char Zf816_8[]=
     
115. {
     
116. /*--  文字:  8  --*/
     
117. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
     
118. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
     
119. };
     
120. 
     
121. code unsigned char Zf816_9[]=
     
122. {
     
123. /*--  文字:  9  --*/
     
124. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
     
125. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
     
126. };
     
127. 
     
128. 
     
129. code unsigned char Zf816_nc[]=  //空字模
     
130. {
     
131. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
132. };
     
133. 
     
134. code unsigned char Zf816_mao_hao[]=  //冒号
     
135. {
     
136. /*--  文字:  :  --*/
     
137. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
     
138. 0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
     
139. };
     
140. 
     
141. code unsigned char Hz1616_yi[]=
     
142. {
     
143. /*--  文字:  一  --*/
     
144. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
145. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
     
146. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
147. };
     
148. 
     
149. code unsigned char Hz1616_er[]=
     
150. {
     
151. /*--  文字:  二  --*/
     
152. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
153. 0x00,0x00,0x00,0x10,0x3F,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
154. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,
     
155. };
     
156. 
     
157. code unsigned char Hz1616_san[]=
     
158. {
     
159. /*--  文字:  三  --*/
     
160. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
161. 0x00,0x00,0x00,0x00,0x7F,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0xF8,
     
162. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0xFE,0x00,0x00,0x00,0x00,
     
163. };
     
164. 
     
165. code unsigned char Hz1616_si[]=
     
166. {
     
167. /*--  文字:  四  --*/
     
168. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
169. 0x00,0x00,0x7F,0xFC,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,
     
170. 0x48,0x84,0x48,0x7C,0x50,0x04,0x60,0x04,0x40,0x04,0x7F,0xFC,0x40,0x04,0x00,0x00,
     
171. };
     
172. 
     
173. code unsigned char Hz1616_chuang[]=
     
174. {
     
175. /*--  文字:  窗  --*/
     
176. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
177. 0x01,0x00,0x00,0x80,0x7F,0xFE,0x40,0x22,0x09,0x18,0x12,0x06,0x7F,0xF8,0x11,0x08,
     
178. 0x13,0xE8,0x14,0x48,0x1A,0x88,0x11,0x08,0x12,0x88,0x14,0x08,0x1F,0xF8,0x10,0x08,
     
179. };
     
180. 
     
181. code unsigned char Hz1616_kou[]=
     
182. {
     
183. /*--  文字:  口  --*/
     
184. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
185. 0x00,0x00,0x00,0x00,0x3F,0xF8,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,
     
186. 0x20,0x08,0x20,0x08,0x20,0x08,0x3F,0xF8,0x20,0x08,0x20,0x08,0x00,0x00,0x00,0x00,
     
187. };
     
188. 
     
189. code unsigned char Hz1616_hang[]=
     
190. {
     
191. /*--  文字:  行  --*/
     
192. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
193. 0x08,0x00,0x1C,0x00,0x31,0xFC,0x40,0x00,0x88,0x00,0x0C,0x00,0x1B,0xFE,0x30,0x20,
     
194. 0x50,0x20,0x90,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0xA0,0x10,0x40,
     
195. };
     
196. 
     
197. 
     
198. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
     
199. {
     
200. 0x00,0x00,0x00,0x00,  //上半屏
     
201. 0x00,0x00,0x00,0x00,
     
202. 0x00,0x00,0x00,0x00,
     
203. 0x00,0x00,0x00,0x00,
     
204. 0x00,0x00,0x00,0x00,
     
205. 0x00,0x00,0x00,0x00,
     
206. 0x00,0x00,0x00,0x00,
     
207. 0x00,0x00,0x00,0x00,
     
208. 
     
209. //------------上半屏和下半屏的分割线-----------
     
210. 
     
211. 0x00,0x00,0x00,0x00,  //下半屏
     
212. 0x00,0x00,0x00,0x00,
     
213. 0x00,0x00,0x00,0x00,
     
214. 0x00,0x00,0x00,0x00,
     
215. 0x00,0x00,0x00,0x00,
     
216. 0x00,0x00,0x00,0x00,
     
217. 0x00,0x00,0x00,0x00,
     
218. 0x00,0x00,0x00,0x00,
     
219. };
     
220. 
     
221. 
     
222. 
     
223. unsigned char ucKeySec=0;   //被触发的按键编号
     
224. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器
     
225. 
     
226. 
     
227. unsigned char ucWd=1; //窗口变量
     
228. unsigned char ucPart=0; //局部变量 0代表没有选中任何一行，其它数值1到4代表选中某一行
     
229. 
     
230. 
     
231. unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量      1代表更新显示，响应函数内部会清零
     
232. unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
233. unsigned char ucWd1Part2Update=0; //窗口1的第2行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
234. unsigned char ucWd1Part3Update=0; //窗口1的第3行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
235. unsigned char ucWd1Part4Update=0; //窗口1的第4行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
236. 
     
237. unsigned char ucWd2Update=0; //窗口2的整屏更新显示变量      1代表更新显示，响应函数内部会清零
     
238. unsigned char ucWd2Part1Update=0; //窗口2的第1行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
239. unsigned char ucWd2Part2Update=0; //窗口2的第2行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
240. unsigned char ucWd2Part3Update=0; //窗口2的第3行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
241. unsigned char ucWd2Part4Update=0; //窗口2的第4行局部更新显示变量  1代表更新显示，响应函数内部会清零
     
242. 
     
243. unsigned char ucData_1_1=8;  //第1个窗口第1行的被设置数据
     
244. unsigned char ucData_1_2=9;  //第1个窗口第2行的被设置数据
     
245. unsigned char ucData_1_3=10;  //第1个窗口第3行的被设置数据
     
246. unsigned char ucData_1_4=11;  //第1个窗口第4行的被设置数据
     
247. 
     
248. unsigned char ucData_2_1=12;  //第2个窗口第1行的被设置数据
     
249. unsigned char ucData_2_2=13;  //第2个窗口第2行的被设置数据
     
250. unsigned char ucData_2_3=14;  //第2个窗口第3行的被设置数据
     
251. unsigned char ucData_2_4=15;  //第2个窗口第4行的被设置数据
     
252. 
     
253. void main()
     
254.   {
     
255.         initial_myself();      //第一区,上电后马上初始化
     
256.         delay_long(100);       //一线，延时线。延时一段时间
     
257.         initial_peripheral();  //第二区,上电后延时一段时间再初始化
     
258. 
     
259.         while(1)   //第三区
     
260.         {
     
261.                     key_service(); //按键服务的应用程序
     
262.             lcd_display_service(); //应用层面的液晶屏显示程序
     
263.         }
     
264. 
     
265. }
     
266. 
     
267. 
     
268. void initial_myself()  //第一区 上电后马上初始化
     
269. {
     
270. /* 注释二：
     
271. * 矩阵键盘也可以做独立按键，前提是把某一根公共输出线输出低电平，
     
272. * 模拟独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
     
273. * 坚鸿51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
     
274. */
     
275.    key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
     
276.    beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
     
277. 
     
278.    TMOD=0x01;  //设置定时器0为工作方式1
     
279. 
     
280.    TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
     
281.    TL0=0x2f;
     
282. }
     
283. void initial_peripheral() //第二区 上电后延时一段时间再初始化
     
284. {
     
285.     LCDInit(); //初始化12864 内部包含液晶模块的复位
     
286. 
     
287. 
     
288.     EA=1;     //开总中断
     
289.     ET0=1;    //允许定时中断
     
290.     TR0=1;    //启动定时中断
     
291. 
     
292. }
     
293. 
     
294. 
     
295. void T0_time() interrupt 1
     
296. {
     
297.   TF0=0;  //清除中断标志
     
298.   TR0=0; //关中断
     
299. 
     
300.   key_scan(); //按键扫描函数
     
301. 
     
302.   if(uiVoiceCnt!=0)
     
303.   {
     
304.      uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
     
305.          beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
     
306.   }
     
307.   else
     
308.   {
     
309.      ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
     
310.            beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
     
311.   }
     
312. 
     
313. 
     
314.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
     
315.   TL0=0x2f;
     
316.   TR0=1;  //开中断
     
317. }
     
318. 
     
319. 
     
320. 
     
321. void key_scan(void)//按键扫描函数 放在定时中断里
     
322. {  
     
323. 
     
324. 
     
325.   static unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
     
326.   static unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
     
327. 
     
328.   static unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
     
329.   static unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
     
330. 
     
331.   static unsigned int  uiKeyTimeCnt3=0; //按键去抖动延时计数器
     
332.   static unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
     
333. 
     
334.   static unsigned int  uiKeyTimeCnt4=0; //按键去抖动延时计数器
     
335.   static unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志
     
336. 
     
337.   if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
     
338.   {
     
339.      ucKeyLock1=0; //按键自锁标志清零
     
340.      uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
     
341.   }
     
342.   else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
     
343.   {
     
344.      uiKeyTimeCnt1++; //累加定时中断次数
     
345.      if(uiKeyTimeCnt1>const_key_time1)
     
346.      {
     
347.         uiKeyTimeCnt1=0;
     
348.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
     
349.         ucKeySec=1;    //触发1号键
     
350.      }
     
351.   }
     
352. 
     
353.   if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
     
354.   {
     
355.      ucKeyLock2=0; //按键自锁标志清零
     
356.      uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
     
357.   }
     
358.   else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
     
359.   {
     
360.      uiKeyTimeCnt2++; //累加定时中断次数
     
361.      if(uiKeyTimeCnt2>const_key_time2)
     
362.      {
     
363.         uiKeyTimeCnt2=0;
     
364.         ucKeyLock2=1;  //自锁按键置位,避免一直触发
     
365.         ucKeySec=2;    //触发2号键
     
366.      }
     
367.   }
     
368. 
     
369.   if(key_sr3==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
     
370.   {
     
371.      ucKeyLock3=0; //按键自锁标志清零
     
372.      uiKeyTimeCnt3=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
     
373.   }
     
374.   else if(ucKeyLock3==0)//有按键按下，且是第一次被按下
     
375.   {
     
376.      uiKeyTimeCnt3++; //累加定时中断次数
     
377.      if(uiKeyTimeCnt3>const_key_time3)
     
378.      {
     
379.         uiKeyTimeCnt3=0;
     
380.         ucKeyLock3=1;  //自锁按键置位,避免一直触发
     
381.         ucKeySec=3;    //触发3号键
     
382.      }
     
383.   }
     
384. 
     
385.   if(key_sr4==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
     
386.   {
     
387.      ucKeyLock4=0; //按键自锁标志清零
     
388.      uiKeyTimeCnt4=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
     
389.   }
     
390.   else if(ucKeyLock4==0)//有按键按下，且是第一次被按下
     
391.   {
     
392.      uiKeyTimeCnt4++; //累加定时中断次数
     
393.      if(uiKeyTimeCnt4>const_key_time4)
     
394.      {
     
395.         uiKeyTimeCnt4=0;
     
396.         ucKeyLock4=1;  //自锁按键置位,避免一直触发
     
397.         ucKeySec=4;    //触发4号键
     
398.      }
     
399.   }
     
400. 
     
401. }
     
402. 
     
403. 
     
404. void key_service(void) //按键服务的应用程序
     
405. {
     
406.   switch(ucKeySec) //按键服务状态切换
     
407.   {
     
408.     case 1:// 加按键 对应朱兆祺学习板的S1键
     
409.           switch(ucWd)  //在不同的窗口下，设置不同的参数
     
410.           {
     
411.               case 1:  //窗口1
     
412.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
     
413.                    {
     
414.                           case 0:   //无光标显示的状态 此处的case 0可以省略
     
415. 
     
416.                                 break;
     
417.                           case 1:   //设置第1行参数
     
418.                                 ucData_1_1++;
     
419.                                 if(ucData_1_1>99)
     
420.                                 {
     
421.                                    ucData_1_1=99;
     
422.                                 }
     
423.                                 ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
     
424.                                 break;
     
425.                           case 2:   //设置第2行参数
     
426.                                 ucData_1_2++;
     
427.                                 if(ucData_1_2>99)
     
428.                                 {
     
429.                                    ucData_1_2=99;
     
430.                                 }
     
431.                                 ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
     
432.                                 break;
     
433.                           case 3:   //设置第3行参数
     
434.                                 ucData_1_3++;
     
435.                                 if(ucData_1_3>99)
     
436.                                 {
     
437.                                    ucData_1_3=99;
     
438.                                 }
     
439.                                 ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
     
440.                                 break;
     
441.                           case 4:   //设置第4行参数
     
442.                                 ucData_1_4++;
     
443.                                 if(ucData_1_4>99)
     
444.                                 {
     
445.                                    ucData_1_4=99;
     
446.                                 }
     
447.                                 ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
     
448.                                 break;
     
449. 
     
450. 
     
451.                    }
     
452.                    break;
     
453.               case 2:  //窗口2
     
454.                    switch(ucPart)  //在窗口2下，根据不同的局部变量来设置不同的参数
     
455.                    {
     
456.                           case 0:   //无光标显示的状态 此处的case 0可以省略
     
457. 
     
458.                                 break;
     
459.                           case 1:   //设置第1行参数
     
460.                                 ucData_2_1++;
     
461.                                 if(ucData_2_1>99)
     
462.                                 {
     
463.                                    ucData_2_1=99;
     
464.                                 }
     
465.                                 ucWd2Part1Update=1; //1代表更新显示，响应函数内部会清零
     
466.                                 break;
     
467.                           case 2:   //设置第2行参数
     
468.                                 ucData_2_2++;
     
469.                                 if(ucData_2_2>99)
     
470.                                 {
     
471.                                    ucData_2_2=99;
     
472.                                 }
     
473.                                 ucWd2Part2Update=1; //1代表更新显示，响应函数内部会清零
     
474.                                 break;
     
475.                           case 3:   //设置第3行参数
     
476.                                 ucData_2_3++;
     
477.                                 if(ucData_2_3>99)
     
478.                                 {
     
479.                                    ucData_2_3=99;
     
480.                                 }
     
481.                                 ucWd2Part3Update=1; //1代表更新显示，响应函数内部会清零
     
482.                                 break;
     
483.                           case 4:   //设置第4行参数
     
484.                                 ucData_2_4++;
     
485.                                 if(ucData_2_4>99)
     
486.                                 {
     
487.                                    ucData_2_4=99;
     
488.                                 }
     
489.                                 ucWd2Part4Update=1; //1代表更新显示，响应函数内部会清零
     
490.                                 break;
     
491. 
     
492. 
     
493.                    }
     
494.                    break;         
     
495.           }     
     
496.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
     
497.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
     
498.           break;   
     
499.    
     
500.     case 2:// 减按键 对应朱兆祺学习板的S5键
     
501.           switch(ucWd)  //在不同的窗口下，设置不同的参数
     
502.           {
     
503.               case 1:  //窗口1
     
504.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
     
505.                    {
     
506.                           case 0:   //无光标显示的状态 此处的case 0可以省略
     
507. 
     
508.                                 break;
     
509.                           case 1:   //设置第1行参数
     
510.                                 ucData_1_1--;
     
511.                                 if(ucData_1_1>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
512.                                 {
     
513.                                    ucData_1_1=0;
     
514.                                 }
     
515.                                 ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
     
516.                                 break;
     
517.                           case 2:   //设置第2行参数
     
518.                                 ucData_1_2--;
     
519.                                 if(ucData_1_2>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
520.                                 {
     
521.                                    ucData_1_2=0;
     
522.                                 }
     
523.                                 ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
     
524.                                 break;
     
525.                           case 3:   //设置第3行参数
     
526.                                 ucData_1_3--;
     
527.                                 if(ucData_1_3>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
528.                                 {
     
529.                                    ucData_1_3=0;
     
530.                                 }
     
531.                                 ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
     
532.                                 break;
     
533.                           case 4:   //设置第4行参数
     
534.                                 ucData_1_4--;
     
535.                                 if(ucData_1_4>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
536.                                 {
     
537.                                    ucData_1_4=0;
     
538.                                 }
     
539.                                 ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
     
540.                                 break;
     
541. 
     
542. 
     
543.                    }
     
544.                    break;
     
545.               case 2:  //窗口2
     
546.                    switch(ucPart)  //在窗口2下，根据不同的局部变量来设置不同的参数
     
547.                    {
     
548.                           case 0:   //无光标显示的状态 此处的case 0可以省略
     
549. 
     
550.                                 break;
     
551.                           case 1:   //设置第1行参数
     
552.                                 ucData_2_1--;
     
553.                                 if(ucData_2_1>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
554.                                 {
     
555.                                    ucData_2_1=0;
     
556.                                 }
     
557.                                 ucWd2Part1Update=1; //1代表更新显示，响应函数内部会清零
     
558.                                 break;
     
559.                           case 2:   //设置第2行参数
     
560.                                 ucData_2_2--;
     
561.                                 if(ucData_2_2>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
562.                                 {
     
563.                                    ucData_2_2=0;
     
564.                                 }
     
565.                                 ucWd2Part2Update=1; //1代表更新显示，响应函数内部会清零
     
566.                                 break;
     
567.                           case 3:   //设置第3行参数
     
568.                                 ucData_2_3--;
     
569.                                 if(ucData_2_3>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
570.                                 {
     
571.                                    ucData_2_3=0;
     
572.                                 }
     
573.                                 ucWd2Part3Update=1; //1代表更新显示，响应函数内部会清零
     
574.                                 break;
     
575.                           case 4:   //设置第4行参数
     
576.                                 ucData_2_4--;
     
577.                                 if(ucData_2_4>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
     
578.                                 {
     
579.                                    ucData_2_4=0;
     
580.                                 }
     
581.                                 ucWd2Part4Update=1; //1代表更新显示，响应函数内部会清零
     
582.                                 break;
     
583. 
     
584. 
     
585.                    }
     
586.                    break;         
     
587.           }     
     
588.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
     
589.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
     
590.           break;  
     
591. 
     
592.     case 3:// 切换"光标"移动按键 对应朱兆祺学习板的S9键
     
593.           switch(ucWd)  //在不同的窗口下，设置不同的参数
     
594.           {
     
595.               case 1: //窗口1
     
596.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
     
597.                    {
     
598.                           case 0:   //无光标显示的状态 此处的case 0可以省略
     
599. 
     
600.                                 break;
     
601.                           case 1:   //设置第1行参数
     
602.                                 ucPart=2; //光标切换到下一行
     
603.                                 ucWd1Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
604.                                 ucWd1Part2Update=1; //更新显示下一行，    目的是更新反显光标的状态
     
605.                                 break;
     
606.                           case 2:   //设置第2行参数
     
607.                                 ucPart=3; //光标切换到下一行
     
608.                                 ucWd1Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
609.                                 ucWd1Part3Update=1; //更新显示下一行，    目的是更新反显光标的状态
     
610.                                 break;
     
611.                           case 3:   //设置第3行参数
     
612.                                 ucPart=4; //光标切换到下一行
     
613.                                 ucWd1Part3Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
614.                                 ucWd1Part4Update=1; //更新显示下一行，    目的是更新反显光标的状态
     
615.                                 break;
     
616.                           case 4:   //设置第4行参数
     
617.                                                         ucWd=2;  //切换到第2个窗口
     
618.                                 ucPart=1; //光标返回到最上面第一行
     
619.                                                                 ucWd2Update=1; //窗口2整屏更新
     
620.                                 break;
     
621. 
     
622. 
     
623.                    }
     
624.                    break;
     
625.               case 2: //窗口2
     
626.                    switch(ucPart)  //在窗口2下，根据不同的局部变量来设置不同的参数
     
627.                    {
     
628.                           case 0:   //无光标显示的状态 此处的case 0可以省略
     
629. 
     
630.                                 break;
     
631.                           case 1:   //设置第1行参数
     
632.                                 ucPart=2; //光标切换到下一行
     
633.                                 ucWd2Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
634.                                 ucWd2Part2Update=1; //更新显示下一行，    目的是更新反显光标的状态
     
635.                                 break;
     
636.                           case 2:   //设置第2行参数
     
637.                                 ucPart=3; //光标切换到下一行
     
638.                                 ucWd2Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
639.                                 ucWd2Part3Update=1; //更新显示下一行，    目的是更新反显光标的状态
     
640.                                 break;
     
641.                           case 3:   //设置第3行参数
     
642.                                 ucPart=4; //光标切换到下一行
     
643.                                 ucWd2Part3Update=1; //更新显示原来那一行，目的是更新反显光标的状态
     
644.                                 ucWd2Part4Update=1; //更新显示下一行，    目的是更新反显光标的状态
     
645.                                 break;
     
646.                           case 4:   //设置第4行参数
     
647.                                                         ucWd=1;  //切换到第1个窗口
     
648.                                 ucPart=1; //光标返回到最上面第一行
     
649.                                                                 ucWd1Update=1; //窗口1整屏更新
     
650.                                 break;
     
651. 
     
652. 
     
653.                    }
     
654.                    break;         
     
655.           }         
     
656.         
     
657.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
     
658.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
     
659.           break;      
     
660.    
     
661.     case 4: // 设置按键  对应朱兆祺学习板的S13键，按一次进入设置状态，出现反显光标。再按一次推出设置状态，消除反显光标,并且强行切换到第1个窗口
     
662.           switch(ucWd)  //在不同的窗口下，设置不同的参数
     
663.           {
     
664.               case 1:  //窗口1
     
665.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
     
666.                    {
     
667. 
     
668.                           case 0:   //无光标显示的状态
     
669.                                 ucPart=1; //光标显示第一行，进入设置模式
     
670.                                 ucWd1Part1Update=1; //更新显示
     
671.                                 break;
     
672.                           case 1:   //设置第1行参数
     
673.                                 ucPart=0; //无光标显示，退出设置模式
     
674.                                 ucWd1Part1Update=1; //更新显示
     
675.                                 break;
     
676.                           case 2:   //设置第2行参数
     
677.                                 ucPart=0; //无光标显示，退出设置模式
     
678.                                 ucWd1Part2Update=1; //更新显示
     
679.                                 break;
     
680.                           case 3:   //设置第3行参数
     
681.                                 ucPart=0; //无光标显示，退出设置模式
     
682.                                 ucWd1Part3Update=1; //更新显示
     
683.                                 break;
     
684.                           case 4:   //设置第4行参数
     
685.                                 ucPart=0; //无光标显示，退出设置模式
     
686.                                 ucWd1Part4Update=1; //更新显示
     
687.                                 break;
     
688. 
     
689. 
     
690.                    }
     
691.                    break;
     
692.               case 2:  //窗口2
     
693.                    switch(ucPart)  //在窗口2下，根据不同的局部变量来设置不同的参数
     
694.                    {
     
695. 
     
696.                           case 0:   //无光标显示的状态
     
697.                                                         ucWd=1; //强行切换到第1个窗口
     
698.                                 ucPart=1; //光标显示第一行，进入设置模式
     
699.                                                                 ucWd1Update=1; //窗口1整屏更新
     
700.                                 break;
     
701.                           case 1:   //设置第1行参数
     
702.                                                                   ucWd=1; //强行切换到第1个窗口
     
703.                                 ucPart=0; //无光标显示，退出设置模式
     
704.                                                                 ucWd1Update=1; //窗口1整屏更新
     
705.                                 break;
     
706.                           case 2:   //设置第2行参数
     
707.                                                                   ucWd=1; //强行切换到第1个窗口
     
708.                                 ucPart=0; //无光标显示，退出设置模式
     
709.                                                                 ucWd1Update=1; //窗口1整屏更新
     
710.                                 break;
     
711.                           case 3:   //设置第3行参数
     
712.                                                               ucWd=1; //强行切换到第1个窗口
     
713.                                 ucPart=0; //无光标显示，退出设置模式
     
714.                                                                 ucWd1Update=1; //窗口1整屏更新
     
715.                                 break;
     
716.                           case 4:   //设置第4行参数
     
717.                                                                   ucWd=1; //强行切换到第1个窗口
     
718.                                 ucPart=0; //无光标显示，退出设置模式
     
719.                                                                 ucWd1Update=1; //窗口1整屏更新
     
720.                                 break;
     
721. 
     
722. 
     
723.                    }
     
724.                    break;         
     
725.           }   
     
726. 
     
727.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
     
728.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
     
729.           break;         
     
730. 
     
731.   }               
     
732. }
     
733. 
     
734. 
     
735. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
     
736. {
     
737.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小，分别调用不同的字库。
     
738. 
     
739.         switch(ucBitNumber)  //根据ucBitNumber数值的大小，分别调用不同的字库。
     
740.         {
     
741.             case 0:
     
742.              p_ucAnyNumber=Zf816_0;
     
743.                      break;
     
744.             case 1:
     
745.              p_ucAnyNumber=Zf816_1;
     
746.                      break;
     
747.             case 2:
     
748.              p_ucAnyNumber=Zf816_2;
     
749.                      break;
     
750.             case 3:
     
751.              p_ucAnyNumber=Zf816_3;
     
752.                      break;
     
753.             case 4:
     
754.              p_ucAnyNumber=Zf816_4;
     
755.                      break;
     
756.             case 5:
     
757.              p_ucAnyNumber=Zf816_5;
     
758.                      break;
     
759.             case 6:
     
760.              p_ucAnyNumber=Zf816_6;
     
761.                      break;
     
762.             case 7:
     
763.              p_ucAnyNumber=Zf816_7;
     
764.                      break;
     
765.             case 8:
     
766.              p_ucAnyNumber=Zf816_8;
     
767.                      break;
     
768.             case 9:
     
769.              p_ucAnyNumber=Zf816_9;
     
770.                      break;
     
771.             case 10:
     
772.              p_ucAnyNumber=Zf816_nc;
     
773.                      break;
     
774.                 default:   //如果上面的条件都不符合，那么默认指向空字模
     
775.              p_ucAnyNumber=Zf816_nc;
     
776.                      break;
     
777.         }
     
778. 
     
779.     return p_ucAnyNumber;  //返回转换结束后的指针
     
780. }
     
781. 
     
782. 
     
783. 
     
784. void lcd_display_service(void) //应用层面的液晶屏显示程序
     
785. {
     
786. 
     
787.     switch(ucWd)  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
     
788.     {
     
789.         case 1:  
     
790.               wd1();  //窗口1显示的内容
     
791.               break;
     
792.         case 2:  
     
793.               wd2();  //窗口2显示的内容
     
794.               break;
     
795.         //本程序只有2个窗口，所以只有一个case 1，如果要增加窗口，就直接增加 case 2, case 3...        
     
796.     }
     
797. 
     
798. }
     
799. 
     
800. 
     
801. void wd1(void)  //窗口1显示的内容
     
802. {
     
803.     unsigned char ucAnyNumber_1; //分解变量的个位
     
804.     unsigned char ucAnyNumber_10; //分解变量的十位
     
805. 
     
806. 
     
807.     unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
     
808.     unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
     
809. 
     
810.     unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
     
811. 
     
812. /* 注释三：
     
813. * 把每一个窗口的内容分为两种类型，一种类型是那些不用经常刷新显示的内容，只有在切换窗口的时候
     
814. * 才需要更新，这种内容放在整屏更新显示的括号里，比如清屏操作等内容。另外一种是那些经常需要
     
815. * 刷新显示的内容，这种内容放在局部更新显示的括号里。
     
816. */
     
817.     if(ucWd1Update==1)  //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
     
818.     {
     
819.         ucWd1Update=0;  //及时清零，避免一直更新
     
820. 
     
821.         ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
     
822.         ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
     
823.         ucWd1Part3Update=1; //激活窗口1的第3行局部更新显示变量，这里在前面数码管显示框架上有所改进
     
824.         ucWd1Part4Update=1; //激活窗口1的第4行局部更新显示变量，这里在前面数码管显示框架上有所改进
     
825. 
     
826.         display_clear(0x00); // 清屏操作， 全部显示空填充0x00，全部显示点阵用0xff。
     
827.         clear_all_canvas();  //把画布全部清零
     
828.         insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布
     
829. 
     
830.         display_lattice(0,0,Hz1616_yi,0,2,16,0);    //一窗口一行，这些内容不用经常更新，只有在切换窗口的时候才更新显示
     
831.         display_lattice(1,0,Hz1616_chuang,0,2,16,0);   
     
832.         display_lattice(2,0,Hz1616_kou,0,2,16,0);   
     
833.         display_lattice(3,0,Hz1616_yi,0,2,16,0);
     
834.         display_lattice(4,0,Hz1616_hang,0,2,16,0);
     
835. 
     
836.         display_lattice(0,16,Hz1616_yi,0,2,16,0);    //一窗口二行
     
837.         display_lattice(1,16,Hz1616_chuang,0,2,16,0);   
     
838.         display_lattice(2,16,Hz1616_kou,0,2,16,0);   
     
839.         display_lattice(3,16,Hz1616_er,0,2,16,0);
     
840.         display_lattice(4,16,Hz1616_hang,0,2,16,0);
     
841. 
     
842.         display_lattice(8,0,Hz1616_yi,0,2,16,0);    //一窗口三行
     
843.         display_lattice(9,0,Hz1616_chuang,0,2,16,0);   
     
844.         display_lattice(10,0,Hz1616_kou,0,2,16,0);   
     
845.         display_lattice(11,0,Hz1616_san,0,2,16,0);
     
846.         display_lattice(12,0,Hz1616_hang,0,2,16,0);
     
847. 
     
848.         display_lattice(8,16,Hz1616_yi,0,2,16,0);    //一窗口四行
     
849.         display_lattice(9,16,Hz1616_chuang,0,2,16,0);   
     
850.         display_lattice(10,16,Hz1616_kou,0,2,16,0);   
     
851.         display_lattice(11,16,Hz1616_si,0,2,16,0);
     
852.         display_lattice(12,16,Hz1616_hang,0,2,16,0);
     
853. 
     
854.     }
     
855. 
     
856. /* 注释四：
     
857. * 注意！我前面讲数码管显示的时候有一句话讲错了，我那时说<局部更新应该写在整屏更新之前>,这是不对的。
     
858. * 按照现在的显示程序框架<即整屏显示更新括号里包含了所有局部变量的激活>，应该是<整屏更新应该写在局部更新之前>
     
859. * 这样才对。
     
860. */
     
861.     if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
     
862.     {
     
863.         ucWd1Part1Update=0; //及时清零，避免一直更新
     
864. 
     
865.         if(ucPart==1) //被选中
     
866.         {
     
867.              ucCursorFlag=1; //反显 显示
     
868.         }
     
869.         else //没被选中
     
870.         {
     
871.              ucCursorFlag=0; //正常 显示
     
872.         }
     
873. 
     
874.         if(ucData_1_1>=10) //有2位数以上
     
875.         {
     
876.              ucAnyNumber_10=ucData_1_1/10;  //十位
     
877.         }
     
878.         else //否则显示空
     
879.         {
     
880.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
     
881.         }
     
882. 
     
883.         ucAnyNumber_1=ucData_1_1%10/1;  //个位
     
884. 
     
885.    
     
886.         p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
     
887.         p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
     
888. 
     
889. 
     
890.         insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
     
891.         insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
     
892. 
     
893.         display_lattice(5,0,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
     
894. 
     
895.                           
     
896.     }
     
897. 
     
898.     if(ucWd1Part2Update==1) //窗口1的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
     
899.     {
     
900.          ucWd1Part2Update=0; //及时清零，避免一直更新
     
901. 
     
902.          if(ucPart==2) //被选中
     
903.          {
     
904.              ucCursorFlag=1; //反显 显示
     
905.          }
     
906.          else //没被选中
     
907.          {
     
908.              ucCursorFlag=0; //正常 显示
     
909.          }
     
910. 
     
911.          if(ucData_1_2>=10) //有2位数以上
     
912.          {
     
913.              ucAnyNumber_10=ucData_1_2/10;  //十位
     
914.          }
     
915.          else //否则显示空
     
916.          {
     
917.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
     
918.          }
     
919. 
     
920.          ucAnyNumber_1=ucData_1_2%10/1;  //个位
     
921. 
     
922.    
     
923.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
     
924.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
     
925. 
     
926. 
     
927.          insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
     
928.          insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
     
929. 
     
930.          display_lattice(5,16,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
     
931.                           
     
932.      }
     
933. 
     
934.      if(ucWd1Part3Update==1) //窗口1的第3行局部更新显示变量,里面放一些经常需要刷新显示的内容
     
935.      {
     
936.          ucWd1Part3Update=0; //及时清零，避免一直更新
     
937. 
     
938.          if(ucPart==3) //被选中
     
939.          {
     
940.              ucCursorFlag=1; //反显 显示
     
941.          }
     
942.          else //没被选中
     
943.          {
     
944.              ucCursorFlag=0; //正常 显示
     
945.          }
     
946. 
     
947.          if(ucData_1_3>=10) //有2位数以上
     
948.          {
     
949.              ucAnyNumber_10=ucData_1_3/10;  //十位
     
950.          }
     
951.          else //否则显示空
     
952.          {
     
953.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
     
954.          }
     
955. 
     
956.          ucAnyNumber_1=ucData_1_3%10/1;  //个位
     
957. 
     
958.    
     
959.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
     
960.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
     
961. 
     
962. 
     
963.          insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
     
964.          insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
     
965. 
     
966.          display_lattice(13,0,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
     
967.                           
     
968.      }
     
969. 
     
970.      if(ucWd1Part4Update==1) //窗口1的第4行局部更新显示变量,里面放一些经常需要刷新显示的内容
     
971.      {
     
972.          ucWd1Part4Update=0; //及时清零，避免一直更新
     
973. 
     
974.          if(ucPart==4) //被选中
     
975.          {
     
976.              ucCursorFlag=1; //反显 显示
     
977.          }
     
978.          else //没被选中
     
979.          {
     
980.              ucCursorFlag=0; //正常 显示
     
981.          }
     
982. 
     
983.          if(ucData_1_4>=10) //有2位数以上
     
984.          {
     
985.              ucAnyNumber_10=ucData_1_4/10;  //十位
     
986.          }
     
987.          else //否则显示空
     
988.          {
     
989.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
     
990.          }
     
991. 
     
992.          ucAnyNumber_1=ucData_1_4%10/1;  //个位
     
993. 
     
994.    
     
995.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
     
996.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
     
997. 
     
998. 
     
999.          insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
     
1000.          insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
      
1001. 
      
1002.          display_lattice(13,16,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量                          
      
1003.      }
      
1004. 
      
1005. 
      
1006. }
      
1007. 
      
1008. 
      
1009. void wd2(void)  //窗口2显示的内容
      
1010. {
      
1011.     unsigned char ucAnyNumber_1; //分解变量的个位
      
1012.     unsigned char ucAnyNumber_10; //分解变量的十位
      
1013. 
      
1014. 
      
1015.     unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
      
1016.     unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
      
1017. 
      
1018.     unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
      
1019. 
      
1020.     if(ucWd2Update==1)  //窗口2整屏更新，里面只放那些不用经常刷新显示的内容
      
1021.     {
      
1022.         ucWd2Update=0;  //及时清零，避免一直更新
      
1023. 
      
1024.         ucWd2Part1Update=1; //激活窗口2的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
      
1025.         ucWd2Part2Update=1; //激活窗口2的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
      
1026.         ucWd2Part3Update=1; //激活窗口2的第3行局部更新显示变量，这里在前面数码管显示框架上有所改进
      
1027.         ucWd2Part4Update=1; //激活窗口2的第4行局部更新显示变量，这里在前面数码管显示框架上有所改进
      
1028. 
      
1029.         display_clear(0x00); // 清屏操作， 全部显示空填充0x00，全部显示点阵用0xff。
      
1030.         clear_all_canvas();  //把画布全部清零
      
1031.         insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布
      
1032. 
      
1033.         display_lattice(0,0,Hz1616_er,0,2,16,0);    //二窗口一行，这些内容不用经常更新，只有在切换窗口的时候才更新显示
      
1034.         display_lattice(1,0,Hz1616_chuang,0,2,16,0);   
      
1035.         display_lattice(2,0,Hz1616_kou,0,2,16,0);   
      
1036.         display_lattice(3,0,Hz1616_yi,0,2,16,0);
      
1037.         display_lattice(4,0,Hz1616_hang,0,2,16,0);
      
1038. 
      
1039.         display_lattice(0,16,Hz1616_er,0,2,16,0);    //二窗口二行
      
1040.         display_lattice(1,16,Hz1616_chuang,0,2,16,0);   
      
1041.         display_lattice(2,16,Hz1616_kou,0,2,16,0);   
      
1042.         display_lattice(3,16,Hz1616_er,0,2,16,0);
      
1043.         display_lattice(4,16,Hz1616_hang,0,2,16,0);
      
1044. 
      
1045.         display_lattice(8,0,Hz1616_er,0,2,16,0);    //二窗口三行
      
1046.         display_lattice(9,0,Hz1616_chuang,0,2,16,0);   
      
1047.         display_lattice(10,0,Hz1616_kou,0,2,16,0);   
      
1048.         display_lattice(11,0,Hz1616_san,0,2,16,0);
      
1049.         display_lattice(12,0,Hz1616_hang,0,2,16,0);
      
1050. 
      
1051.         display_lattice(8,16,Hz1616_er,0,2,16,0);    //二窗口四行
      
1052.         display_lattice(9,16,Hz1616_chuang,0,2,16,0);   
      
1053.         display_lattice(10,16,Hz1616_kou,0,2,16,0);   
      
1054.         display_lattice(11,16,Hz1616_si,0,2,16,0);
      
1055.         display_lattice(12,16,Hz1616_hang,0,2,16,0);
      
1056. 
      
1057.     }
      
1058. 
      
1059.     if(ucWd2Part1Update==1) //窗口2的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
      
1060.     {
      
1061.         ucWd2Part1Update=0; //及时清零，避免一直更新
      
1062. 
      
1063.         if(ucPart==1) //被选中
      
1064.         {
      
1065.              ucCursorFlag=1; //反显 显示
      
1066.         }
      
1067.         else //没被选中
      
1068.         {
      
1069.              ucCursorFlag=0; //正常 显示
      
1070.         }
      
1071. 
      
1072.         if(ucData_2_1>=10) //有2位数以上
      
1073.         {
      
1074.              ucAnyNumber_10=ucData_2_1/10;  //十位
      
1075.         }
      
1076.         else //否则显示空
      
1077.         {
      
1078.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
      
1079.         }
      
1080. 
      
1081.         ucAnyNumber_1=ucData_2_1%10/1;  //个位
      
1082. 
      
1083.    
      
1084.         p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
      
1085.         p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
      
1086. 
      
1087. 
      
1088.         insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
      
1089.         insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
      
1090. 
      
1091.         display_lattice(5,0,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
      
1092. 
      
1093.                           
      
1094.     }
      
1095. 
      
1096.     if(ucWd2Part2Update==1) //窗口2的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
      
1097.     {
      
1098.          ucWd2Part2Update=0; //及时清零，避免一直更新
      
1099. 
      
1100.          if(ucPart==2) //被选中
      
1101.          {
      
1102.              ucCursorFlag=1; //反显 显示
      
1103.          }
      
1104.          else //没被选中
      
1105.          {
      
1106.              ucCursorFlag=0; //正常 显示
      
1107.          }
      
1108. 
      
1109.          if(ucData_2_2>=10) //有2位数以上
      
1110.          {
      
1111.              ucAnyNumber_10=ucData_2_2/10;  //十位
      
1112.          }
      
1113.          else //否则显示空
      
1114.          {
      
1115.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
      
1116.          }
      
1117. 
      
1118.          ucAnyNumber_1=ucData_2_2%10/1;  //个位
      
1119. 
      
1120.    
      
1121.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
      
1122.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
      
1123. 
      
1124. 
      
1125.          insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
      
1126.          insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
      
1127. 
      
1128.          display_lattice(5,16,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
      
1129.                           
      
1130.      }
      
1131. 
      
1132.      if(ucWd2Part3Update==1) //窗口2的第3行局部更新显示变量,里面放一些经常需要刷新显示的内容
      
1133.      {
      
1134.          ucWd2Part3Update=0; //及时清零，避免一直更新
      
1135. 
      
1136.          if(ucPart==3) //被选中
      
1137.          {
      
1138.              ucCursorFlag=1; //反显 显示
      
1139.          }
      
1140.          else //没被选中
      
1141.          {
      
1142.              ucCursorFlag=0; //正常 显示
      
1143.          }
      
1144. 
      
1145.          if(ucData_2_3>=10) //有2位数以上
      
1146.          {
      
1147.              ucAnyNumber_10=ucData_2_3/10;  //十位
      
1148.          }
      
1149.          else //否则显示空
      
1150.          {
      
1151.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
      
1152.          }
      
1153. 
      
1154.          ucAnyNumber_1=ucData_2_3%10/1;  //个位
      
1155. 
      
1156.    
      
1157.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
      
1158.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
      
1159. 
      
1160. 
      
1161.          insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
      
1162.          insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
      
1163. 
      
1164.          display_lattice(13,0,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
      
1165.                           
      
1166.      }
      
1167. 
      
1168.      if(ucWd2Part4Update==1) //窗口2的第4行局部更新显示变量,里面放一些经常需要刷新显示的内容
      
1169.      {
      
1170.          ucWd2Part4Update=0; //及时清零，避免一直更新
      
1171. 
      
1172.          if(ucPart==4) //被选中
      
1173.          {
      
1174.              ucCursorFlag=1; //反显 显示
      
1175.          }
      
1176.          else //没被选中
      
1177.          {
      
1178.              ucCursorFlag=0; //正常 显示
      
1179.          }
      
1180. 
      
1181.          if(ucData_2_4>=10) //有2位数以上
      
1182.          {
      
1183.              ucAnyNumber_10=ucData_2_4/10;  //十位
      
1184.          }
      
1185.          else //否则显示空
      
1186.          {
      
1187.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
      
1188.          }
      
1189. 
      
1190.          ucAnyNumber_1=ucData_2_4%10/1;  //个位
      
1191. 
      
1192.    
      
1193.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
      
1194.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
      
1195. 
      
1196. 
      
1197.          insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
      
1198.          insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
      
1199. 
      
1200.          display_lattice(13,16,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量                          
      
1201.      }
      
1202. 
      
1203. 
      
1204. }
      
1205. 
      
1206. 
      
1207. void clear_all_canvas(void)  //把画布全部清零
      
1208. {
      
1209.    unsigned int j=0;
      
1210.    unsigned int i=0;
      
1211. 
      
1212.    for(j=0;j<16;j++)  //这里的16表示画布有16行
      
1213.    {
      
1214.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
      
1215.       {
      
1216.                   ucCanvasBuffer[j*4+i]=0x00;
      
1217.       }
      
1218.    }         
      
1219. 
      
1220. }
      
1221. 
      
1222. 
      
1223. 
      
1224. 
      
1225. 
      
1226. void display_clear(unsigned char ucFillDate) // 清屏  全部显示空填充0x00   全部显示点阵用0xff
      
1227. {   
      
1228. 
      
1229.     unsigned char x,y;
      
1230.     WriteCommand(0x34);  //关显示缓冲指令            
      
1231.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
      
1232.     y=0;
      
1233.     while(y<32)  //y轴的范围0至31
      
1234.     {
      
1235.          WriteCommand(y+0x80);        //垂直地址
      
1236.          WriteCommand(0x80);          //水平地址
      
1237.          for(x=0;x<32;x++)  //256个横向点，有32个字节
      
1238.          {  
      
1239.             LCDWriteData(ucFillDate);
      
1240.          }
      
1241.          y++;
      
1242.     }
      
1243.     WriteCommand(0x36); //开显示缓冲指令
      
1244. 
      
1245. }
      
1246. 
      
1247. /* 注释五：
      
1248. * 把字模插入画布的函数.
      
1249. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
      
1250. * 第1，2个参数x,y是在画布中的坐标体系。
      
1251. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
      
1252. * 第3个参数*ucArray是字模的数组。
      
1253. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
      
1254. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
      
1255. */
      
1256. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
      
1257. {
      
1258.    unsigned int j=0;
      
1259.    unsigned int i=0;
      
1260.    unsigned char ucTemp;
      
1261.    for(j=0;j<y_amount;j++)
      
1262.    {
      
1263.       for(i=0;i<x_amount;i++)
      
1264.       {
      
1265.                    ucTemp=ucArray[j*x_amount+i];
      
1266.                    if(ucFbFlag==0)
      
1267.                    {
      
1268.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
      
1269.                    }
      
1270.                    else
      
1271.                    {
      
1272.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
      
1273.                    }
      
1274.       }
      
1275.    }         
      
1276. 
      
1277. }
      
1278. 
      
1279. /* 注释六：
      
1280. * 显示任意点阵函数.
      
1281. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
      
1282. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
      
1283. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
      
1284. * 第3个参数*ucArray是字模的数组。
      
1285. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
      
1286. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
      
1287. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
      
1288. */
      
1289. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr)
      
1290. {
      
1291.    unsigned int j=0;
      
1292.    unsigned int i=0;
      
1293.    unsigned char ucTemp;
      
1294. 
      
1295. //注意，要把以下两行指令屏蔽，否则屏幕在更新显示时会整屏闪动
      
1296. //  WriteCommand(0x34);  //关显示缓冲指令            
      
1297. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
      
1298.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
      
1299.    {
      
1300.        WriteCommand(y+j+0x80);        //垂直地址
      
1301.        WriteCommand(x+0x80);          //水平地址
      
1302.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
      
1303.        {
      
1304.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
      
1305.            if(ucFbFlag==1)  //反白显示
      
1306.            {
      
1307.                ucTemp=~ucTemp;
      
1308.            }
      
1309.            LCDWriteData(ucTemp);
      
1310.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
      
1311.       }
      
1312.    }
      
1313.    WriteCommand(0x36); //开显示缓冲指令
      
1314. }
      
1315. 
      
1316. 
      
1317. 
      
1318. 
      
1319. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
      
1320. {
      
1321.         unsigned char i;
      
1322.         for ( i = 0; i < 8; i++ )
      
1323.         {
      
1324.                 if ( (ucData << i) & 0x80 )
      
1325.                 {
      
1326.                         LCDSID_dr = 1;
      
1327.                 }
      
1328.                 else
      
1329.                 {
      
1330.                         LCDSID_dr = 0;
      
1331.                 }
      
1332.                 LCDCLK_dr = 0;
      
1333.                 LCDCLK_dr = 1;
      
1334.         }
      
1335. }
      
1336. 
      
1337. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
      
1338. {
      
1339.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
      
1340.         SendByteToLcd( ucWData & 0xf0 );
      
1341.         SendByteToLcd( (ucWData << 4) & 0xf0);
      
1342. }
      
1343. 
      
1344. 
      
1345. void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
      
1346. {
      
1347. 
      
1348.         LCDCS_dr = 0;
      
1349.         LCDCS_dr = 1;
      
1350.         SPIWrite(ucCommand, 0);
      
1351.         delay_short(90);
      
1352. }
      
1353. 
      
1354. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
      
1355. {
      
1356.         LCDCS_dr = 0;
      
1357.         LCDCS_dr = 1;
      
1358.         SPIWrite(ucData, 1);
      
1359. }
      
1360. 
      
1361. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
      
1362. {
      
1363.         LCDRST_dr = 1;  //复位
      
1364.         LCDRST_dr = 0;
      
1365.         LCDRST_dr = 1;
      
1366. }
      
1367. 
      
1368. 
      
1369. 
      
1370. void delay_short(unsigned int uiDelayShort) //延时函数
      
1371. {
      
1372.    unsigned int i;  
      
1373.    for(i=0;i<uiDelayShort;i++)
      
1374.    {
      
1375.      ;  
      
1376.    }
      
1377. }
      
1378. 
      
1379. 
      
1380. void delay_long(unsigned int uiDelayLong)
      
1381. {
      
1382.    unsigned int i;
      
1383.    unsigned int j;
      
1384.    for(i=0;i<uiDelayLong;i++)
      
1385.    {
      
1386.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
      
1387.           {
      
1388.              ; //一个分号相当于执行一条空语句
      
1389.           }
      
1390.    }
      
1391. }
      

复制代码

总结陈词：

这一节讲了在多个窗口里设置不同的参数。还有一种常见的项目，要求把第1窗口是用来作为主菜单，主菜单里面有3个子菜单，可以通过移动光标进入不同的子菜单窗口进行参数设置，这类项目该如何编程？欲知详情，请听下回分解-----通过主菜单移动光标来进入子菜单窗口的液晶屏程序。

（未完待续，下节更精彩，不要走开哦）