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

jianhong_wu · 发表于 2014-10-30 15:22:11

第七十九节：通过主菜单移动光标来进入子菜单窗口的液晶屏程序。

开场白：

其实主菜单窗口与子菜单窗口本质都是多窗口菜单程序，只不过我在按键服务程序里面建立起来了一条主窗口与子窗口的关系链。这个关系链还是用switch语句搭建起来的，在某个窗口某个局部显示上，操作某个按键就会切换到不同的窗口显示。

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

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

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

（2）实现功能：
通过按键设置6个不同的参数。
有4个窗口。第1个窗口是主菜单界面，通过光标切换可以进去设置不同参数的子菜单界面。第2个窗口是设置时间范围界面。第3个窗口是设置速度范围界面。第4个窗口是设置频率范围界面。每个设置界面显示2个参数。每个参数的范围是从0到99。
有4个按键：

（a）一个是进入和退出S13按键，按一次进入选中的子菜单。再按一次退出子菜单。

（b）一个是移动光标S9按键，依次按下此按键，液晶屏上的光标会从上往下移动，表示选中不同的参数。当移动到每个窗口最下边那一行时，再按下此按键会把光标移动到第一个参数。

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

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

（3）源代码讲解如下：

#include "REG52.H"
/* 注释一：
* 本程序用到的变量比较多，所以在keil编译模式里要设置一下编译模式memory model，
* 否则编译会出错.右键单击Target选择“Options for Target'Target1'”就会出来一个框
* 在memory model中选择compact:variables in pdata 就可以了。
*/
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_key_time1 20 //按键去抖动延时的时间
#define const_key_time2 20 //按键去抖动延时的时间
#define const_key_time3 20 //按键去抖动延时的时间
#define const_key_time4 20 //按键去抖动延时的时间
sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
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_clear(unsigned char ucFillDate); // 清屏全部显示空填充0x00 全部显示点阵用0xff
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);//把字模插入画布.
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); //显示任意点阵函数
unsigned char *number_to_matrix(unsigned char ucBitNumber); //把一位数字转换成字模首地址的函数
void delay_short(unsigned int uiDelayshort); //延时
void delay_long(unsigned int uiDelayLong);
void T0_time(); //定时中断函数
void key_service(void); //按键服务的应用程序
void key_scan(void);//按键扫描函数放在定时中断里
void initial_myself();
void initial_peripheral();
void lcd_display_service(void); //应用层面的液晶屏显示程序
void clear_all_canvas(void); //把画布全部清零
void wd1(void);//窗口1 主菜单
void wd2(void);//窗口2 设置时间
void wd3(void);//窗口3 设置速度
void wd4(void);//窗口4 设置频率
code unsigned char Zf816_0[]=
{
/*-- 文字: 0 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_1[]=
{
/*-- 文字: 1 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
};
code unsigned char Zf816_2[]=
{
/*-- 文字: 2 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
};
code unsigned char Zf816_3[]=
{
/*-- 文字: 3 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_4[]=
{
/*-- 文字: 4 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
};
code unsigned char Zf816_5[]=
{
/*-- 文字: 5 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_6[]=
{
/*-- 文字: 6 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_7[]=
{
/*-- 文字: 7 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
};
code unsigned char Zf816_8[]=
{
/*-- 文字: 8 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
};
code unsigned char Zf816_9[]=
{
/*-- 文字: 9 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
};
code unsigned char Zf816_nc[]= //空字模
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Zf816_mao_hao[]= //冒号
{
/*-- 文字: : --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
};
code unsigned char Hz1616_zhu[]=
{
/*-- 文字: 主 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x02,0x00,0x01,0x80,0x01,0x00,0x00,0x08,0x3F,0xFC,0x01,0x00,0x01,0x00,0x01,0x08,
0x3F,0xFC,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x04,0x7F,0xFE,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_cai[]=
{
/*-- 文字: 菜 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x04,0x40,0xFF,0xFE,0x04,0x40,0x04,0x40,0x3F,0xF8,0x22,0x08,0x11,0x10,0x08,0x20,
0x01,0x00,0x7F,0xFE,0x03,0x80,0x05,0x40,0x09,0x30,0x11,0x1C,0x61,0x08,0x01,0x00,
};
code unsigned char Hz1616_dan[]=
{
/*-- 文字: 单 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x08,0x20,0x06,0x30,0x04,0x40,0x3F,0xF8,0x21,0x08,0x3F,0xF8,0x21,0x08,0x21,0x08,
0x3F,0xF8,0x21,0x08,0x01,0x00,0xFF,0xFE,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
};
code unsigned char Hz1616_she[]=
{
/*-- 文字: 设 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x40,0x00,0x21,0xF0,0x31,0x10,0x21,0x10,0x01,0x10,0x01,0x10,0xE2,0x0E,0x25,0xF8,
0x21,0x08,0x21,0x08,0x20,0x90,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x0C,0x04,
};
code unsigned char Hz1616_zhi[]=
{
/*-- 文字: 置 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x3F,0xF8,0x24,0x48,0x24,0x48,0x3F,0xF8,0x01,0x00,0x7F,0xFC,0x02,0x00,0x1F,0xF0,
0x10,0x10,0x1F,0xF0,0x10,0x10,0x1F,0xF0,0x10,0x10,0x1F,0xF0,0x10,0x10,0xFF,0xFE,
};
code unsigned char Hz1616_su[]=
{
/*-- 文字: 速 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x80,0x40,0x80,0x2F,0xFC,0x20,0x80,0x00,0x80,0x07,0xF8,0xE4,0x88,0x24,0x88,
0x27,0xF8,0x21,0xA0,0x22,0x98,0x2C,0x88,0x20,0x80,0x50,0x80,0x8F,0xFE,0x00,0x00,
};
code unsigned char Hz1616_du[]=
{
/*-- 文字: 度 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x01,0x00,0x00,0x80,0x3F,0xFE,0x22,0x20,0x22,0x20,0x2F,0xFC,0x22,0x20,0x23,0xE0,
0x20,0x00,0x27,0xF8,0x22,0x10,0x21,0x20,0x20,0xC0,0x41,0x30,0x46,0x0E,0x98,0x04,
};
code unsigned char Hz1616_shi[]=
{
/*-- 文字: 时 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x10,0x00,0x10,0x7C,0x10,0x44,0x10,0x47,0xFE,0x44,0x10,0x7C,0x10,0x45,0x10,
0x44,0x90,0x44,0x90,0x7C,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x50,0x00,0x20,
};
code unsigned char Hz1616_jian[]=
{
/*-- 文字: 间 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x20,0x00,0x13,0xFC,0x10,0x04,0x40,0x04,0x47,0xE4,0x44,0x24,0x44,0x24,0x47,0xE4,
0x44,0x24,0x44,0x24,0x47,0xE4,0x40,0x04,0x40,0x04,0x40,0x04,0x40,0x14,0x40,0x08,
};
code unsigned char Hz1616_pin[]=
{
/*-- 文字: 频 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x08,0x00,0x08,0xFE,0x4E,0x20,0x48,0x40,0x48,0xFC,0xFE,0x84,0x00,0xA4,0x08,0xA4,
0x4A,0xA4,0x4A,0xA4,0x84,0xA4,0x08,0x50,0x10,0x48,0x20,0x86,0xC3,0x02,0x00,0x00,
};
code unsigned char Hz1616_lv[]=
{
/*-- 文字: 率 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x02,0x00,0x01,0x00,0x7F,0xFE,0x41,0x00,0x22,0x28,0x17,0xD0,0x04,0x80,0x11,0x10,
0x22,0x48,0x47,0xC4,0x01,0x20,0xFF,0xFE,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
};
code unsigned char Hz1616_fan[]=
{
/*-- 文字: 范 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x04,0x20,0x04,0x20,0xFF,0xFE,0x04,0x60,0x40,0x00,0x31,0xF8,0x91,0x08,0x61,0x08,
0x49,0x08,0x09,0x38,0x11,0x10,0xE1,0x00,0x21,0x04,0x21,0x04,0x20,0xFC,0x20,0x00,
};
code unsigned char Hz1616_wei[]=
{
/*-- 文字: 围 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x7F,0xFC,0x42,0x04,0x42,0x04,0x5F,0xF4,0x42,0x04,0x4F,0xE4,0x42,0x04,0x5F,0xE4,
0x42,0x24,0x42,0x24,0x42,0x24,0x42,0xA4,0x42,0x44,0x40,0x04,0x7F,0xFC,0x40,0x04,
};
code unsigned char Hz1616_shang[]=
{
/*-- 文字: 上 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0xF8,0x01,0x00,
0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x04,0x7F,0xFE,0x00,0x00,
};
code unsigned char Hz1616_xia[]=
{
/*-- 文字: 下 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x04,0x7F,0xFE,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0xC0,0x01,0x60,0x01,0x30,
0x01,0x20,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
};
code unsigned char Hz1616_xian[]=
{
/*-- 文字: 限 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0xFB,0xF8,0x92,0x08,0x93,0xF8,0xA2,0x08,0xA2,0x08,0x93,0xF8,0x8A,0x80,
0x8A,0x48,0xAA,0x50,0x92,0x20,0x82,0x20,0x82,0x10,0x82,0x8E,0x83,0x04,0x82,0x00,
};
unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
{
0x00,0x00,0x00,0x00, //上半屏
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
//------------上半屏和下半屏的分割线-----------
0x00,0x00,0x00,0x00, //下半屏
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
};
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucWd=1; //窗口变量
unsigned char ucWd1Part=1; //窗口1的局部变量，代表选中某一行。
unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part1Update=0; //窗口1的第1个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part2Update=0; //窗口1的第2个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part3Update=0; //窗口1的第3个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd2Part=1; //窗口2的局部变量，代表选中某一行。
unsigned char ucWd2Update=0; //窗口2的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd2Part1Update=0; //窗口2的第1个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd2Part2Update=0; //窗口2的第2个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd3Part=1; //窗口3的局部变量，代表选中某一行。
unsigned char ucWd3Update=0; //窗口3的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd3Part1Update=0; //窗口3的第1个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd3Part2Update=0; //窗口3的第2个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd4Part=1; //窗口4的局部变量，代表选中某一行。
unsigned char ucWd4Update=0; //窗口4的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd4Part1Update=0; //窗口4的第1个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd4Part2Update=0; //窗口4的第2个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucTimeH=2; //设置时间的上限数据
unsigned char ucTimeL=1; //设置时间的下限数据
unsigned char ucSpeedH=4; //设置速度的上限数据
unsigned char ucSpeedL=3; //设置速度的下限数据
unsigned char ucFreqH=6; //设置频率的上限数据
unsigned char ucFreqL=5; //设置频率的下限数据
void main()
{
initial_myself(); //第一区,上电后马上初始化
delay_long(100); //一线，延时线。延时一段时间
initial_peripheral(); //第二区,上电后延时一段时间再初始化
while(1) //第三区
{
key_service(); //按键服务的应用程序
lcd_display_service(); //应用层面的液晶屏显示程序
}
}
void initial_myself() //第一区上电后马上初始化
{
/* 注释二：
* 矩阵键盘也可以做独立按键，前提是把某一根公共输出线输出低电平，
* 模拟独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
* 坚鸿51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
*/
key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
}
void initial_peripheral() //第二区上电后延时一段时间再初始化
{
LCDInit(); //初始化12864 内部包含液晶模块的复位
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}
void T0_time() interrupt 1
{
TF0=0; //清除中断标志
TR0=0; //关中断
key_scan(); //按键扫描函数
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
TR0=1; //开中断
}
void key_scan(void)//按键扫描函数放在定时中断里
{
static unsigned int uiKeyTimeCnt1=0; //按键去抖动延时计数器
static unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
static unsigned int uiKeyTimeCnt2=0; //按键去抖动延时计数器
static unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
static unsigned int uiKeyTimeCnt3=0; //按键去抖动延时计数器
static unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
static unsigned int uiKeyTimeCnt4=0; //按键去抖动延时计数器
static unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志
if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock1=0; //按键自锁标志清零
uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt1++; //累加定时中断次数
if(uiKeyTimeCnt1>const_key_time1)
{
uiKeyTimeCnt1=0;
ucKeyLock1=1; //自锁按键置位,避免一直触发
ucKeySec=1; //触发1号键
}
}
if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock2=0; //按键自锁标志清零
uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt2++; //累加定时中断次数
if(uiKeyTimeCnt2>const_key_time2)
{
uiKeyTimeCnt2=0;
ucKeyLock2=1; //自锁按键置位,避免一直触发
ucKeySec=2; //触发2号键
}
}
if(key_sr3==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock3=0; //按键自锁标志清零
uiKeyTimeCnt3=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock3==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt3++; //累加定时中断次数
if(uiKeyTimeCnt3>const_key_time3)
{
uiKeyTimeCnt3=0;
ucKeyLock3=1; //自锁按键置位,避免一直触发
ucKeySec=3; //触发3号键
}
}
if(key_sr4==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock4=0; //按键自锁标志清零
uiKeyTimeCnt4=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock4==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt4++; //累加定时中断次数
if(uiKeyTimeCnt4>const_key_time4)
{
uiKeyTimeCnt4=0;
ucKeyLock4=1; //自锁按键置位,避免一直触发
ucKeySec=4; //触发4号键
}
}
}
void key_service(void) //按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 加按键对应朱兆祺学习板的S1键
switch(ucWd) //在不同的窗口下，设置不同的参数
{
case 2: //窗口2 设置时间
switch(ucWd2Part) //在窗口2下，根据不同的局部变量来设置不同的参数
{
case 1: //设置时间上限
ucTimeH++;
if(ucTimeH>99)
{
ucTimeH=99;
}
ucWd2Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置时间下限
ucTimeL++;
if(ucTimeL>99)
{
ucTimeL=99;
}
ucWd2Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
case 3: //窗口3 设置速度
switch(ucWd3Part) //在窗口3下，根据不同的局部变量来设置不同的参数
{
case 1: //设置速度上限
ucSpeedH++;
if(ucSpeedH>99)
{
ucSpeedH=99;
}
ucWd3Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置速度下限
ucSpeedL++;
if(ucSpeedL>99)
{
ucSpeedL=99;
}
ucWd3Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
case 4: //窗口4 设置速度
switch(ucWd4Part) //在窗口4下，根据不同的局部变量来设置不同的参数
{
case 1: //设置频率上限
ucFreqH++;
if(ucFreqH>99)
{
ucFreqH=99;
}
ucWd4Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置频率下限
ucFreqL++;
if(ucFreqL>99)
{
ucFreqL=99;
}
ucWd4Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 减按键对应朱兆祺学习板的S5键
switch(ucWd) //在不同的窗口下，设置不同的参数
{
case 2: //窗口2 设置时间
switch(ucWd2Part) //在窗口2下，根据不同的局部变量来设置不同的参数
{
case 1: //设置时间上限
ucTimeH--;
if(ucTimeH>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucTimeH=0;
}
ucWd2Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置时间下限
ucTimeL--;
if(ucTimeL>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucTimeL=0;
}
ucWd2Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
case 3: //窗口3 设置速度
switch(ucWd3Part) //在窗口3下，根据不同的局部变量来设置不同的参数
{
case 1: //设置速度上限
ucSpeedH--;
if(ucSpeedH>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucSpeedH=0;
}
ucWd3Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置速度下限
ucSpeedL--;
if(ucSpeedL>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucSpeedL=0;
}
ucWd3Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
case 4: //窗口4 设置频率
switch(ucWd4Part) //在窗口4下，根据不同的局部变量来设置不同的参数
{
case 1: //设置频率上限
ucFreqH--;
if(ucFreqH>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucFreqH=0;
}
ucWd4Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置频率下限
ucFreqL--;
if(ucFreqL>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucFreqL=0;
}
ucWd4Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3:// 切换"光标"移动按键对应朱兆祺学习板的S9键
switch(ucWd) //在不同的窗口下，设置不同的参数
{
case 1: //窗口1 主菜单
switch(ucWd1Part) //在窗口1下，根据不同的局部变量来设置不同的参数
{
case 1: //设置时间
ucWd1Part=2; //光标切换到下一行
ucWd1Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd1Part2Update=1; //更新显示下一行，目的是更新反显光标的状态
break;
case 2: //设置速度
ucWd1Part=3; //光标切换到下一行
ucWd1Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd1Part3Update=1; //更新显示下一行，目的是更新反显光标的状态
break;
case 3: //设置第3行参数
ucWd1Part=1; //光标返回到第一行
ucWd1Part3Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd1Part1Update=1; //更新显示下一行，目的是更新反显光标的状态
break;
}
break;
case 2: //窗口2 设置时间
switch(ucWd2Part) //在窗口2下，根据不同的局部变量来设置不同的参数
{
case 1: //时间上限
ucWd2Part=2; //光标切换到下一行
ucWd2Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd2Part2Update=1; //更新显示下一行，目的是更新反显光标的状态
break;
case 2: //时间下限
ucWd2Part=1; //光标返回到第一行
ucWd2Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd2Part1Update=1; //更新显示下一行，目的是更新反显光标的状态
break;
}
break;
case 3: //窗口3 设置速度
switch(ucWd3Part) //在窗口3下，根据不同的局部变量来设置不同的参数
{
case 1: //速度上限
ucWd3Part=2; //光标切换到下一行
ucWd3Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd3Part2Update=1; //更新显示下一行，目的是更新反显光标的状态
break;
case 2: //速度下限
ucWd3Part=1; //光标返回到第一行
ucWd3Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd3Part1Update=1; //更新显示下一行，目的是更新反显光标的状态
break;
}
break;
case 4: //窗口4 设置频率
switch(ucWd4Part) //在窗口4下，根据不同的局部变量来设置不同的参数
{
case 1: //频率上限
ucWd4Part=2; //光标切换到下一行
ucWd4Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd4Part2Update=1; //更新显示下一行，目的是更新反显光标的状态
break;
case 2: //频率下限
ucWd4Part=1; //光标返回到第一行
ucWd4Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd4Part1Update=1; //更新显示下一行，目的是更新反显光标的状态
break;
}
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 4: // 进入和退出按键对应朱兆祺学习板的S13键，按一次进入选中的子菜单。再按一次退出子菜单。
switch(ucWd) //在不同的窗口下，设置不同的参数
{
case 1: //窗口1
switch(ucWd1Part) //在窗口1下，根据不同的局部变量来设置不同的参数
{
case 1: //设置时间
ucWd=2; //进入设置时间的窗口2
ucWd2Update=1; //窗口2整屏更新
break;
case 2: //设置速度
ucWd=3; //进入设置速度的窗口3
ucWd3Update=1; //窗口3整屏更新
break;
case 3: //设置频率
ucWd=4; //进入设置频率的窗口4
ucWd4Update=1; //窗口4整屏更新
break;
}
break;
case 2: //窗口2
ucWd=1; //返回主菜单窗口1
ucWd1Update=1; //窗口1整屏更新
break;
case 3: //窗口3
ucWd=1; //返回主菜单窗口1
ucWd1Update=1; //窗口1整屏更新
break;
case 4: //窗口4
ucWd=1; //返回主菜单窗口1
ucWd1Update=1; //窗口1整屏更新
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
unsigned char *number_to_matrix(unsigned char ucBitNumber)
{
unsigned char *p_ucAnyNumber; //此指针根据ucBitNumber数值的大小，分别调用不同的字库。
switch(ucBitNumber) //根据ucBitNumber数值的大小，分别调用不同的字库。
{
case 0:
p_ucAnyNumber=Zf816_0;
break;
case 1:
p_ucAnyNumber=Zf816_1;
break;
case 2:
p_ucAnyNumber=Zf816_2;
break;
case 3:
p_ucAnyNumber=Zf816_3;
break;
case 4:
p_ucAnyNumber=Zf816_4;
break;
case 5:
p_ucAnyNumber=Zf816_5;
break;
case 6:
p_ucAnyNumber=Zf816_6;
break;
case 7:
p_ucAnyNumber=Zf816_7;
break;
case 8:
p_ucAnyNumber=Zf816_8;
break;
case 9:
p_ucAnyNumber=Zf816_9;
break;
case 10:
p_ucAnyNumber=Zf816_nc;
break;
default: //如果上面的条件都不符合，那么默认指向空字模
p_ucAnyNumber=Zf816_nc;
break;
}
return p_ucAnyNumber; //返回转换结束后的指针
}
void lcd_display_service(void) //应用层面的液晶屏显示程序
{
switch(ucWd) //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
{
case 1:
wd1(); //主菜单
break;
case 2:
wd2(); //设置时间
break;
case 3:
wd3(); //设置速度
break;
case 4:
wd4(); //设置频率
break;
//本程序只有4个窗口，所以只有4个case ，如果要增加窗口，就直接增加 case 5, case 6...
}
}
void wd1(void) //窗口1 主菜单
{
unsigned char ucCursorFlag; //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
/* 注释三：
* 把每一个窗口的内容分为两种类型，一种类型是那些不用经常刷新显示的内容，只有在切换窗口的时候
* 才需要更新，这种内容放在整屏更新显示的括号里，比如清屏操作等内容。另外一种是那些经常需要
* 刷新显示的内容，这种内容放在局部更新显示的括号里。
*/
if(ucWd1Update==1) //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd1Update=0; //及时清零，避免一直更新
ucWd1Part1Update=1; //激活窗口1的第1个局部更新显示变量
ucWd1Part2Update=1; //激活窗口1的第2个局部更新显示变量
ucWd1Part3Update=1; //激活窗口1的第3个局部更新显示变量
display_clear(0x00); // 清屏操作，全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas(); //把画布全部清零
insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布
display_lattice(2,0,Hz1616_zhu,0,2,16,0); //主菜单。这些内容不用经常更新，只有在切换窗口的时候才更新显示
display_lattice(3,0,Hz1616_cai,0,2,16,0);
display_lattice(4,0,Hz1616_dan,0,2,16,0);
}
/* 注释四：
* 注意！我前面讲数码管显示的时候有一句话讲错了，我那时说<局部更新应该写在整屏更新之前>,这是不对的。
* 按照现在的显示程序框架<即整屏显示更新括号里包含了所有局部变量的激活>，应该是<整屏更新应该写在局部更新之前>
* 这样才对。
*/
if(ucWd1Part1Update==1) //窗口1的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part1Update=0; //及时清零，避免一直更新
if(ucWd1Part==1) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
display_lattice(0,16,Hz1616_she,ucCursorFlag,2,16,0); //设置时间范围
display_lattice(1,16,Hz1616_zhi,ucCursorFlag,2,16,0);
display_lattice(2,16,Hz1616_shi,ucCursorFlag,2,16,0);
display_lattice(3,16,Hz1616_jian,ucCursorFlag,2,16,0);
display_lattice(4,16,Hz1616_fan,ucCursorFlag,2,16,0);
display_lattice(5,16,Hz1616_wei,ucCursorFlag,2,16,0);
}
if(ucWd1Part2Update==1) //窗口1的第2个局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part2Update=0; //及时清零，避免一直更新
if(ucWd1Part==2) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
display_lattice(8,0,Hz1616_she,ucCursorFlag,2,16,0); //设置速度范围
display_lattice(9,0,Hz1616_zhi,ucCursorFlag,2,16,0);
display_lattice(10,0,Hz1616_su,ucCursorFlag,2,16,0);
display_lattice(11,0,Hz1616_du,ucCursorFlag,2,16,0);
display_lattice(12,0,Hz1616_fan,ucCursorFlag,2,16,0);
display_lattice(13,0,Hz1616_wei,ucCursorFlag,2,16,0);
}
if(ucWd1Part3Update==1) //窗口1的第3行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part3Update=0; //及时清零，避免一直更新
if(ucWd1Part==3) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
display_lattice(8,16,Hz1616_she,ucCursorFlag,2,16,0); //设置频率范围
display_lattice(9,16,Hz1616_zhi,ucCursorFlag,2,16,0);
display_lattice(10,16,Hz1616_pin,ucCursorFlag,2,16,0);
display_lattice(11,16,Hz1616_lv,ucCursorFlag,2,16,0);
display_lattice(12,16,Hz1616_fan,ucCursorFlag,2,16,0);
display_lattice(13,16,Hz1616_wei,ucCursorFlag,2,16,0);
}
}
void wd2(void) //窗口2 设置时间
{
unsigned char ucAnyNumber_1; //分解变量的个位
unsigned char ucAnyNumber_10; //分解变量的十位
unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
unsigned char ucCursorFlag; //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
if(ucWd2Update==1) //窗口2整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd2Update=0; //及时清零，避免一直更新
ucWd2Part1Update=1; //激活窗口2的第1个局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd2Part2Update=1; //激活窗口2的第2个局部更新显示变量，这里在前面数码管显示框架上有所改进
display_clear(0x00); // 清屏操作，全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas(); //把画布全部清零
insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布
display_lattice(2,0,Hz1616_she,0,2,16,0); //设置时间。这些内容不用经常更新，只有在切换窗口的时候才更新显示
display_lattice(3,0,Hz1616_zhi,0,2,16,0);
display_lattice(4,0,Hz1616_shi,0,2,16,0);
display_lattice(5,0,Hz1616_jian,0,2,16,0);
display_lattice(0,16,Hz1616_shi,0,2,16,0); //时间上限
display_lattice(1,16,Hz1616_jian,0,2,16,0);
display_lattice(2,16,Hz1616_shang,0,2,16,0);
display_lattice(3,16,Hz1616_xian,0,2,16,0);
display_lattice(8,0,Hz1616_shi,0,2,16,0); //时间下限
display_lattice(9,0,Hz1616_jian,0,2,16,0);
display_lattice(10,0,Hz1616_xia,0,2,16,0);
display_lattice(11,0,Hz1616_xian,0,2,16,0);
}
if(ucWd2Part1Update==1) //窗口2的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd2Part1Update=0; //及时清零，避免一直更新
if(ucWd2Part==1) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ucTimeH>=10) //有2位数以上
{
ucAnyNumber_10=ucTimeH/10; //十位
}
else //否则显示空
{
ucAnyNumber_10=10; //在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucTimeH%10/1; //个位
p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
display_lattice(4,16,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd2Part2Update==1) //窗口2的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd2Part2Update=0; //及时清零，避免一直更新
if(ucWd2Part==2) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ucTimeL>=10) //有2位数以上
{
ucAnyNumber_10=ucTimeL/10; //十位
}
else //否则显示空
{
ucAnyNumber_10=10; //在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucTimeL%10/1; //个位
p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
display_lattice(12,0,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
}
void wd3(void) //窗口3 设置速度
{
unsigned char ucAnyNumber_1; //分解变量的个位
unsigned char ucAnyNumber_10; //分解变量的十位
unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
unsigned char ucCursorFlag; //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
if(ucWd3Update==1) //窗口3整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd3Update=0; //及时清零，避免一直更新
ucWd3Part1Update=1; //激活窗口3的第1个局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd3Part2Update=1; //激活窗口3的第2个局部更新显示变量，这里在前面数码管显示框架上有所改进
display_clear(0x00); // 清屏操作，全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas(); //把画布全部清零
insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布
display_lattice(2,0,Hz1616_she,0,2,16,0); //设置速度。这些内容不用经常更新，只有在切换窗口的时候才更新显示
display_lattice(3,0,Hz1616_zhi,0,2,16,0);
display_lattice(4,0,Hz1616_su,0,2,16,0);
display_lattice(5,0,Hz1616_du,0,2,16,0);
display_lattice(0,16,Hz1616_su,0,2,16,0); //速度上限
display_lattice(1,16,Hz1616_du,0,2,16,0);
display_lattice(2,16,Hz1616_shang,0,2,16,0);
display_lattice(3,16,Hz1616_xian,0,2,16,0);
display_lattice(8,0,Hz1616_su,0,2,16,0); //速度下限
display_lattice(9,0,Hz1616_du,0,2,16,0);
display_lattice(10,0,Hz1616_xia,0,2,16,0);
display_lattice(11,0,Hz1616_xian,0,2,16,0);
}
if(ucWd3Part1Update==1) //窗口3的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd3Part1Update=0; //及时清零，避免一直更新
if(ucWd3Part==1) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ucSpeedH>=10) //有2位数以上
{
ucAnyNumber_10=ucSpeedH/10; //十位
}
else //否则显示空
{
ucAnyNumber_10=10; //在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucSpeedH%10/1; //个位
p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
display_lattice(4,16,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd3Part2Update==1) //窗口3的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd3Part2Update=0; //及时清零，避免一直更新
if(ucWd3Part==2) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ucSpeedL>=10) //有2位数以上
{
ucAnyNumber_10=ucSpeedL/10; //十位
}
else //否则显示空
{
ucAnyNumber_10=10; //在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucSpeedL%10/1; //个位
p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
display_lattice(12,0,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
}
void wd4(void) //窗口4 设置频率
{
unsigned char ucAnyNumber_1; //分解变量的个位
unsigned char ucAnyNumber_10; //分解变量的十位
unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
unsigned char ucCursorFlag; //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
if(ucWd4Update==1) //窗口4整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd4Update=0; //及时清零，避免一直更新
ucWd4Part1Update=1; //激活窗口4的第1个局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd4Part2Update=1; //激活窗口4的第2个局部更新显示变量，这里在前面数码管显示框架上有所改进
display_clear(0x00); // 清屏操作，全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas(); //把画布全部清零
insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布
display_lattice(2,0,Hz1616_she,0,2,16,0); //设置频率。这些内容不用经常更新，只有在切换窗口的时候才更新显示
display_lattice(3,0,Hz1616_zhi,0,2,16,0);
display_lattice(4,0,Hz1616_pin,0,2,16,0);
display_lattice(5,0,Hz1616_lv,0,2,16,0);
display_lattice(0,16,Hz1616_pin,0,2,16,0); //频率上限
display_lattice(1,16,Hz1616_lv,0,2,16,0);
display_lattice(2,16,Hz1616_shang,0,2,16,0);
display_lattice(3,16,Hz1616_xian,0,2,16,0);
display_lattice(8,0,Hz1616_pin,0,2,16,0); //频率下限
display_lattice(9,0,Hz1616_lv,0,2,16,0);
display_lattice(10,0,Hz1616_xia,0,2,16,0);
display_lattice(11,0,Hz1616_xian,0,2,16,0);
}
if(ucWd4Part1Update==1) //窗口4的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd4Part1Update=0; //及时清零，避免一直更新
if(ucWd4Part==1) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ucFreqH>=10) //有2位数以上
{
ucAnyNumber_10=ucFreqH/10; //十位
}
else //否则显示空
{
ucAnyNumber_10=10; //在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucFreqH%10/1; //个位
p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
display_lattice(4,16,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd4Part2Update==1) //窗口4的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd4Part2Update=0; //及时清零，避免一直更新
if(ucWd4Part==2) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ucFreqL>=10) //有2位数以上
{
ucAnyNumber_10=ucFreqL/10; //十位
}
else //否则显示空
{
ucAnyNumber_10=10; //在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucFreqL%10/1; //个位
p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址
insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布
display_lattice(12,0,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
}
void clear_all_canvas(void) //把画布全部清零
{
unsigned int j=0;
unsigned int i=0;
for(j=0;j<16;j++) //这里的16表示画布有16行
{
for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
{
ucCanvasBuffer[j*4+i]=0x00;
}
}
}
void display_clear(unsigned char ucFillDate) // 清屏全部显示空填充0x00 全部显示点阵用0xff
{
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(ucFillDate);
}
y++;
}
WriteCommand(0x36); //开显示缓冲指令
}
/* 注释五：
* 把字模插入画布的函数.
* 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是在画布中的坐标体系。
* x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
*/
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)
{
unsigned int j=0;
unsigned int i=0;
unsigned char ucTemp;
for(j=0;j<y_amount;j++)
{
for(i=0;i<x_amount;i++)
{
ucTemp=ucArray[j*x_amount+i];
if(ucFbFlag==0)
{
ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
}
else
{
ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
}
}
}
}
/* 注释六：
* 显示任意点阵函数.
* 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
* 对于这个函数，读者尤其要搞懂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分别代表字模数组的横向有多少个字节，纵向有几横。
* 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
*/
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)
{
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+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
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++)
{
;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}

复制代码

总结陈词：

我前面几节液晶屏程序的字模都是通过外围工具软件生成的，其实这款12864液晶模块本身就是自带字库，编程的时候只要在源代码里直接写入所需要的汉字或者字符，就可以自动调用相对应的字库了。但是细心的网友一定会问，为什么在源代码上直接写入某个汉字就可以调用到这个汉字的字库?在这个过程中，C51编译器到底还干了哪些鲜为人知的好事？欲知详情，请听下回分解-----液晶屏自带字库跟汉字机内码的关系。

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

jianhong_wu · 发表于 2014-11-3 15:11:53

第八十节：调用液晶屏内部字库来显示汉字或字符的坐标体系和本质。

开场白：
前面章节讲的内容全部都是用自构字库的，相当于使用液晶屏的图像模式。其实这个款12864液晶屏的驱动芯片是st7920，它内部是自带16x16字库的，可以显示16x16的汉字或者8x16的字符。这一节开始就跟大家讲讲这方面的内容。要教会大家四个知识点：
第一个：内部字库的真实坐标体系的本质。当我们用内部字库的时候，它的坐标体系跟前面讲的自造字库坐标不一样，不再是256x32的液晶屏。它还原成为128x64的液晶屏，横坐标x轴坐标没办法精确到每个点，只能以16个点(2个字节)为一个单位，因此128个点的x轴坐标范围是0至8。而y轴的坐标也是以16个点(2个字节)为一个单位，因此64个点的x轴坐标范围是0至3。把12864液晶屏分成4行8列，每个数代表一个坐标点。
第二个：在使用内部字库时，C51编译器暗地里干了啥？如果使用液晶屏内部自带字库，编程的时候只要在源代码里直接写入所需要的汉字或者字符，就可以自动调用相对应的字库了。但是细心的网友一定会问，为什么在源代码上直接写入某个汉字就可以调用到这个汉字的字库？其实，表面上我们写下具体的某个汉字或者字符，但是C51编译器会自动对数组内的汉字翻译成机内码(2字节)，会自动对数组内的字符翻译成 ASCII码(1字节)。
第三个：12864的控制芯片st7920内部有两套驱动显示指令方式，一种是前面章节讲的自构字库模式，也是图像模式。另外一种就是本节讲的用内部字库模式。在切换模式的时候，发送命令字0x0c表示用内部字库模式，发送命令字0x36表示用自构字库模式。
第四个：12864整屏有4行8列，一共32个坐标点，每个坐标点可以显示一个16x16的汉字，但是在显示8x16字符时候，必须一次显示2个字符筹够16x16的点阵。例如，只想达到显示一个字符的时候，应该在另外一个空位置上显示空字符来填充。

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

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

（2）实现功能：
开机上电后，液晶屏第一行调用直接汉字书写方式的数组来显示(馒头V5)的内容。第四行调用机内码和ASCII码的数组来显示(馒头V5)的内容。

（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_clear(void); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
void display_hz1616(unsigned int x,unsigned int y,const unsigned char *ucArray);
void display_double_zf816(unsigned int x,unsigned int y,const unsigned char *ucArray1,const unsigned char *ucArray2);
void delay_short(unsigned int uiDelayshort); //延时
/* 注释一：内部字库的真实坐标体系的本质。
* 当我们用内部字库的时候，它的坐标体系跟前面讲的自造字库坐标不一样，不再是256x32的液晶屏。
* 它还原成为128x64的液晶屏，横坐标x轴坐标没办法精确到每个点，只能以16个点(2个字节)为一个单位，
* 因此128个点的x轴坐标范围是0至8。而y轴的坐标也是以16个点(2个字节)为一个单位，因此64个点的x轴
* 坐标范围是0至3。以下是坐标地址的位置编码。把12864液晶屏分成4行8列，每个数代表一个坐标点，
* 用深究具体含义，液晶驱动芯片ST7920的手册上有提到。
*/
code unsigned char ucAddrTable[]= //调用内部字库时，液晶屏的坐标体系，位置编码，是驱动内容，读者可以不用深究它的含义。
{
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,
};
/* 注释二：在使用内部字库时，C51编译器暗地里干了啥？
* 如果使用液晶屏内部自带字库，以下编程的时候只要在源代码里直接写入所需要的汉字或者字符，
* 就可以自动调用相对应的字库了。但是细心的网友一定会问，为什么在源代码上直接写入某个汉字
* 就可以调用到这个汉字的字库？其实，表面上我们写下具体的某个汉字或者字符，但是C51编译器
* 会自动对数组内的汉字翻译成机内码(2字节)，会自动对数组内的字符翻译成 ASCII码(1字节)。
* 本节程序会做这个实验来验证它。以下两种书写方式不一样，但本质是一样的。
*/
code unsigned char Hz1616_man[]="馒"; //对于数组内的汉字，编译会自动翻译成机内码(2字节)
code unsigned char JN1616_man[]= //机内码馒网上有很多把汉字或者字符转换成相关编码的工具软件
{
0xC2,
0xF8,
};
code unsigned char Hz1616_tou[]="头"; //对于数组内的汉字，编译会自动翻译成机内码(2字节)
code unsigned char JN1616_tou[]= //机内码头网上有很多把汉字或者字符转换成相关编码的工具软件
{
0xCD,
0xB7,
};
code unsigned char Zf816_V[]="V"; //对于数组内的字符，编译会自动翻译成 ASCII码(1字节)
code unsigned char ASCII816_V[]= //ASCII码 V 网上有很多把汉字或者字符转换成相关编码的工具软件
{
0x56,
};
code unsigned char Zf816_5[]="5"; //对于数组内的字符，编译会自动翻译成 ASCII码(1字节)
code unsigned char ASCII816_5[]= //ASCII码 5 网上有很多把汉字或者字符转换成相关编码的工具软件
{
0x35,
};
code unsigned char Zf816_nc[]=" "; //对于数组内的字符，编译会自动翻译成 ASCII码(1字节)
code unsigned char ASCII816_nc[]= //ASCII码空字符网上有很多把汉字或者字符转换成相关编码的工具软件
{
0x20,
};
void main()
{
LCDInit(); //初始化12864 内部包含液晶模块的复位
/* 注释三：
* 12864的控制芯片st7920内部有两套驱动显示指令方式，一种是前面章节讲的自构字库模式，也是图像模式。
* 另外一种就是本节讲的用内部字库模式。以下是切换模式的命令，命令字0x0c表示用内部字库模式。
* 命令字0x36表示用自构字库模式。
*/
WriteCommand(0x0C); //命令字0x0c表示用内部字库模式。命令字0x36表示用自构字库模式。
display_clear(); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
display_hz1616(0,0,Hz1616_man); //第一行，调用直接汉字书写方式的数组来显示(馒头V5)，
display_hz1616(1,0,Hz1616_tou);
display_double_zf816(2,0,Zf816_V,Zf816_5);
display_hz1616(0,3,JN1616_man); //第四行，调用机内码和ASCII码的数组来显示(馒头V5)，
display_hz1616(1,3,JN1616_tou);
display_double_zf816(2,3,ASCII816_V,Zf816_5);
while(1)
{
;
}
}
/* 注释四：在一个坐标点显示1个内部字库汉字的函数
* 第1，2个参数x,y是坐标体系。x的范围是0至8，y的范围是0至3.
* 第3个参数*ucArray是汉字机内码，是有2个字节的数组。
*/
void display_hz1616(unsigned int x,unsigned int y,const unsigned char *ucArray)
{
WriteCommand(0x30); //基本指令集
WriteCommand(ucAddrTable[8*y+x]); //起始位置
LCDWriteData(ucArray[0]);
LCDWriteData(ucArray[1]);
}
/* 注释五：在一个坐标点显示2个内部字库字符的函数
* 注意，由于一个坐标点是16x16点阵，而一个字符是8x16点阵的，所以务必要显示2个字符筹够1个坐标点。
* 第1，2个参数x,y是坐标体系。x的范围是0至8，y的范围是0至3.
* 第3个参数*ucArray1是左边第1个字符ASCII码，是有1个字节的数组。
* 第4个参数*ucArray2是右边第2个字符ASCII码，是有1个字节的数组。
*/
void display_double_zf816(unsigned int x,unsigned int y,const unsigned char *ucArray1,const unsigned char *ucArray2)
{
WriteCommand(0x30); //基本指令集
WriteCommand(ucAddrTable[8*y+x]); //起始位置
LCDWriteData(ucArray1[0]);
LCDWriteData(ucArray2[0]);
}
void display_clear(void) // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
{
unsigned int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<8;j++)
{
display_double_zf816(j,i,Zf816_nc,ASCII816_nc); //Zf816_nc与ASCII816_nc本质是一样的，只是书写方式不一样。
}
}
}
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++)
{
;
}
}

复制代码

总结陈词：
通过本节的实验，我们发现汉字的识别本质是机内码，字符的识别本质是ASCII码。不管是机内码还是ASCII码，这些都是16进制的数字，也就是我们手机平时接收和发送的信息本质都是这些数字编码，但是机内码是2个字节，ASCII码是1个字节，如果在一串随机的信息中，同时包含汉字和字符两种数字信息，我们的程序又该如何能筛选和识别它们，会不会把机内码和ASCII码搞混乱了？不会的。其实这两种编码都是有规律可以筛选识别的，欲知详情，请听下回分解-----液晶屏显示串口发送过来的任意汉字和字符。

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

jianhong_wu · 发表于 2014-11-6 15:49:23

第八十一节：液晶屏显示串口发送过来的任意汉字和字符。

开场白：

通过上一节的学习，我们发现汉字的识别本质是机内码，字符的识别本质是ASCII码。不管是机内码还是ASCII码，这些都是16进制的数字，也就是我们手机平时接收和发送的信息本质都是这些数字编码，但是机内码是2个字节，ASCII码是1个字节，如果在一串随机的信息中，同时包含汉字和字符两种数字信息，我们的程序又该如何能筛选和识别它们，会不会把机内码和ASCII码搞混乱了？这一节要教大家三个知识点：

第一个：ASCII码与汉字机内码不一样的规律是，ASCII码都是小于128(0x80)的，根据这个特点可以编程序把它们区分开来。

第二个：当任意一串信息中既包含汉字机内码，又包含字符ASCII码时，并且当ASCII码左右相邻个数是以奇数存在的时候，如何巧妙地插入填充空格字符0x20使它们能够符合一个坐标点显示2个字符的要求。

第三个：本节程序串口部分是在第39节内容基础上移植修改而成，本节程序中多添加了如何通过结束标志0x0D 0x0A来提取有效数据的内容，读者可以学习一下其中的框架。

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

（1）硬件平台：基于朱兆祺51单片机学习板。

（2）实现功能：

开机上电后，液晶屏第1行显示“请发送信息”。任意时刻，从电脑“串口调试助手”根据以下协议要求，发送一串不超过24个汉字或者字符的信息，液晶屏就实时把这些信息显示在第2,3,4行。并且蜂鸣器会鸣叫一声表示数据接收正确。

波特率是：9600 。
通讯协议：EB 00 55 XX XX XXXX …XX XX 0D 0A

最前面3个字节EB 00 55 表示数据头。

最后面2个字节0D 0A表示信息的结束标志。

中间的XX是机内码和ASCII码信息。比如：要发送“曹健1人学习51单片机”的信息，它们对应的指令是：

EB 00 55 B2 DC BD A1 31 C8 CB D1 A7 CF B0 3531 B5 A5 C6 AC BB FA 0D 0A

（3）源代码讲解如下：

#include "REG52.H"
/* 注释一：
* 本程序的串口那部分内容是从《第三十九节：判断数据头来接收一串数据的串口通用程序框架。》
* 移植过来的，但是以下要把接收缓冲区的数据从10改成60.同时，协议后面多增加了数据结束标志0x0d 0x0a。
*/
#define const_rc_size 60 //接收串口中断数据的缓冲区数组大小
#define const_receive_time 5 //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
#define const_voice_short 40 //蜂鸣器短叫的持续时间
sbit LCDCS_dr = P1^6; //片选线
sbit LCDSID_dr = P1^7; //串行数据线
sbit LCDCLK_dr = P3^2; //串行时钟线
sbit LCDRST_dr = P3^4; //复位线
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
void initial_myself(void);
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
void display_service(void); //显示服务程序,在main函数里
void empty_diaplay_buffer(void); //把显示缓冲区全部填充空格字符0x20
void diaplay_all_buffer(void); //显示第2,3,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_clear(void); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
void display_double_code(unsigned int x,unsigned int y,const unsigned char ucArray1,const unsigned char ucArray2); //在一个坐标点显示1个汉字或者2个字符的函数
void delay_short(unsigned int uiDelayshort); //延时
code unsigned char ucAddrTable[]= //调用内部字库时，液晶屏的坐标体系，位置编码，是驱动内容，读者可以不用深究它的含义。
{
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,
};
code unsigned char JN1616_qing[]= //机内码请
{
0xC7,0xEB, //请
};
code unsigned char JN1616_fa[]= //机内码发
{
0xB7,0xA2,
};
code unsigned char JN1616_song[]= //机内码送
{
0xCB,0xCD,
};
code unsigned char JN1616_xin[]= //机内码信
{
0xD0,0xC5,
};
code unsigned char JN1616_xi[]= //机内码息
{
0xCF,0xA2,
};
unsigned int uiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned int uiRcregTotal=0; //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int uiRcMoveIndex=0; //用来解析数据协议的中间变量
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part1Update=0; //窗口1的第1个局部更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucDispplayBuffer[48]; //第2,3,4行显示内容的缓冲区
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
display_service(); //显示服务程序
}
}
/* 注释二：在一个坐标点显示1个汉字或者2个字符的函数
* 第1，2个参数x,y是坐标体系。x的范围是0至8，y的范围是0至3.
* 第3个参数ucArray1是第1个汉字机内码或者ASCII码。
* 第4个参数ucArray2是第2个汉字机内码或者ASCII码。
*/
void display_double_code(unsigned int x,unsigned int y,const unsigned char ucArray1,const unsigned char ucArray2)
{
WriteCommand(0x30); //基本指令集
WriteCommand(ucAddrTable[8*y+x]); //起始位置
LCDWriteData(ucArray1);
LCDWriteData(ucArray2);
}
void display_clear(void) // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
{
unsigned int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<8;j++)
{
display_double_code(j,i,0x20,0x20); //0x20是空格的ASCII码
}
}
}
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 empty_diaplay_buffer(void) //把显示缓冲区全部填充空格字符0x20
{
unsigned int i;
for(i=0;i<48;i++)
{
ucDispplayBuffer[i]=0x20; //第2,3,4行显示内容的缓冲区全部填充0x20空格字符
}
}
void diaplay_all_buffer(void) //显示第2,3,4行全部缓冲区的内容
{
unsigned int i,j;
for(i=0;i<3;i++) //i代表行数
{
for(j=0;j<8;j++) //j代表某行的某个坐标在第几列
{
display_double_code(j,i+1,ucDispplayBuffer[i*16+j*2],ucDispplayBuffer[i*16+j*2+1]); //这里的16代表一行可以显示16个字符
}
}
}
void display_service(void) //显示服务程序,在main函数里
{
if(ucWd1Update==1) //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd1Update=0; //及时清零，避免一直更新
ucWd1Part1Update=1; //激活窗口1的第1个局部更新显示变量
display_clear(); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
//显示第一行固定的内容：请发送信息
display_double_code(1,0,JN1616_qing[0],JN1616_qing[1]); //请
display_double_code(2,0,JN1616_fa[0],JN1616_fa[1]); //发
display_double_code(3,0,JN1616_song[0],JN1616_song[1]); //送
display_double_code(4,0,JN1616_xin[0],JN1616_xin[1]); //信
display_double_code(5,0,JN1616_xi[0],JN1616_xi[1]); //息
}
if(ucWd1Part1Update==1) //窗口1的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part1Update=0; //及时清零，避免一直更新
diaplay_all_buffer(); //显示第2,3,4行全部缓冲区的内容
}
}
/* 注释三：
* 以下有效信息截取和如何判断机内码与ASCII码是本程序的核心，请仔细看讲解。
* 凡是ASCII码都是小于0x80(128)的，根据这个特点可以把ASCII码和机内码分离出来，
* 同时，由于液晶屏的1个坐标必须显示2个编码，对于单个存在的ASCII码，我们要在
* 它的右边多插入一个空格字符0x20。至于如何插入空格0x20字符，请看以下代码。
*/
void usart_service(void) //串口服务程序,在main函数里
{
unsigned int i;
unsigned int uiCodeCnt; //统计接收的有效编码数量
unsigned int uiCodeYu; //对uiCodeCnt求2的余数，方便识别是否是1个ASCII码相邻
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动这个变量是用来抗干扰处理的
while(uiRcregTotal>=6&&uiRcMoveIndex<=(uiRcregTotal-6)) //这里的6表示有3个字节的数据头，至少1个有效数据，2个数据结束标志0x0d 0x0a
{
if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55) //数据头eb 00 55的判断
{
empty_diaplay_buffer(); //把显示缓冲区全部填充空格字符0x20
uiCodeCnt=0; //统计接收的有效编码数量清零
for(i=0;i<(uiRcregTotal-uiRcMoveIndex-3)&&i<48;i++)//这里的3表示有3个字节的数据头。48表示最大只能接收24个汉字，一共48个字节的机内码.
{
if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志0x0d 0x0a的判断
{
uiVoiceCnt=const_voice_short; //蜂鸣器发出声音,表示数据接收正确完毕
ucWd1Part1Update=1; //及时更新显示第2,3,4行内容的信息
break; //退出for循环
}
else //收集有效信息编码进入显示缓冲区
{
uiCodeYu=uiCodeCnt%2; //对2求余数，用来识别相信的2个是否是机内码，否则要进行插入填充0x20处理
if(uiCodeYu==1)
{
if(ucRcregBuf[uiRcMoveIndex+3+i]>=0x80&&ucRcregBuf[uiRcMoveIndex+3+i-1]<0x80) //如果当前的是机内码，而上一个不是机内码
{
ucDispplayBuffer[uiCodeCnt]=0x20; //当前的先填充插入空格字符0x20
uiCodeCnt++; //统计接收的有效编码数量
}
}
ucDispplayBuffer[uiCodeCnt]=ucRcregBuf[uiRcMoveIndex+3+i]; //收集有效信息编码进入显示缓冲区
uiCodeCnt++; //统计接收的有效编码数量
}
}
break; //退出while循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiSendCnt<const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
{
uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
ucSendLock=1; //开自锁标志
}
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
TR0=1; //开中断
}
void usart_receive(void) interrupt 4 //串口接收数据中断
{
if(RI==1)
{
RI = 0;
++uiRcregTotal;
if(uiRcregTotal>const_rc_size) //超过缓冲区
{
uiRcregTotal=const_rc_size;
}
ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接收到的数据缓存到接收缓冲区里
uiSendCnt=0; //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
}
else //我在其它单片机上都不用else这段代码的，可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
{
TI = 0;
}
}
void delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself(void) //第一区初始化单片机
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
//配置定时器
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
//配置串口
SCON=0x50;
TMOD=0X21;
IP =0x10; //把串口中断设置为最高优先级，必须的。
TH1=TL1=-(11059200L/12/32/9600); //这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
TR1=1;
}
void initial_peripheral(void) //第二区初始化外围
{
EA=1; //开总中断
ES=1; //允许串口中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
LCDInit(); //初始化12864 内部包含液晶模块的复位
WriteCommand(0x0C); //命令字0x0c表示用内部字库模式。命令字0x36表示用自构字库模式。
empty_diaplay_buffer(); //把显示缓冲区全部填充空格字符0x20
}

复制代码

总结陈词：

我们现在是调用液晶屏内部字库来显示内容，如果要某行内容反显或者光标闪烁改怎么编程？欲知详情，请听下回分解-----如何在调用液晶屏内部字库时让某行内容反显或者光标闪烁。

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

jianhong_wu · 发表于 2014-11-7 17:03:41

KR770906 发表于 2014-11-7 10:30
鸿哥，按键去抖动延时计数器uiKeyTimeCnt1、uiKeyTimeCnt2、uiKeyTimeCnt3……能否合并成一个变量？

好像不行。合并不好，感觉有隐患，还是分开来吧。

jianhong_wu · 发表于 2014-11-14 11:38:17

本帖最后由 jianhong_wu 于 2014-11-14 12:13 编辑

第八十二节：如何通过调用液晶屏内部字库把一个任意数值的变量显示出来。

开场白：

本来这一节打算开始讲调用液晶屏内部字库时的反显程序，但是我担心跳跃太大，恐怕很多初学者跟不上，所以多插入这一节讲讲后面菜单程序中经常用到的基本功能，在调用内部字库的情况下，如何把一个任意数值的变量显示在液晶屏上。这一节的功能需求跟前面第76节是一模一样的，只不过前面的不是用自带字库，现在的是用自带字库而已。我们还是需要做一个变量转换成ASCII码的函数，以后只要调用这个转换函数就可以了。这一节就要把这个转换函数和框架思路教给大家。

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

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

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

（3）源代码讲解如下：

#include "REG52.H"
sbit LCDCS_dr = P1^6; //片选线
sbit LCDSID_dr = P1^7; //串行数据线
sbit LCDCLK_dr = P3^2; //串行时钟线
sbit LCDRST_dr = P3^4; //复位线
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
void initial_myself(void);
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);
unsigned char *number_to_ASCII(unsigned char ucBitNumber);
void display_service(void); //显示服务程序,在main函数里
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_clear(void); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
void display_double_code(unsigned int x,unsigned int y,const unsigned char ucArray1,const unsigned char ucArray2); //在一个坐标点显示1个汉字或者2个字符的函数
void delay_short(unsigned int uiDelayshort); //延时
code unsigned char ucAddrTable[]= //调用内部字库时，液晶屏的坐标体系，位置编码，是驱动内容，读者可以不用深究它的含义。
{
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,
};
code unsigned char ASCII816_0[]="0"; //0 对于数组内的字符，编译会自动翻译成 ASCII码(1字节)
code unsigned char ASCII816_1[]="1"; //1
code unsigned char ASCII816_2[]="2"; //2
code unsigned char ASCII816_3[]="3"; //3
code unsigned char ASCII816_4[]="4"; //4
code unsigned char ASCII816_5[]="5"; //5
code unsigned char ASCII816_6[]="6"; //6
code unsigned char ASCII816_7[]="7"; //7
code unsigned char ASCII816_8[]="8"; //8
code unsigned char ASCII816_9[]="9"; //9
code unsigned char ASCII816_nc[]=" "; //空格
/* 注释一：
* 以下变量就是本程序的任意变量，网友可以自己更改它的大小来测试本程序，不要超过255.
*/
unsigned char ucAnyNumber=218; //任意变量默认初始化为218。
unsigned char ucWd1Part1Update=1; //窗口1的第1个局部更新显示变量 1代表更新显示，响应函数内部会清零
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
display_service(); //显示服务程序
}
}
/* 注释二：在一个坐标点显示1个汉字或者2个字符的函数
* 第1，2个参数x,y是坐标体系。x的范围是0至8，y的范围是0至3.
* 第3个参数ucArray1是第1个汉字机内码或者ASCII码。
* 第4个参数ucArray2是第2个汉字机内码或者ASCII码。
*/
void display_double_code(unsigned int x,unsigned int y,const unsigned char ucArray1,const unsigned char ucArray2)
{
WriteCommand(0x30); //基本指令集
WriteCommand(ucAddrTable[8*y+x]); //起始位置
LCDWriteData(ucArray1);
LCDWriteData(ucArray2);
}
void display_clear(void) // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
{
unsigned int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<8;j++)
{
display_double_code(j,i,0x20,0x20); //0x20是空格的ASCII码
}
}
}
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;
}
/* 注释三：
* 本程序的核心转换函数。
* 是可以把一位任意数字变量的函数转换成对应的ASCII码，由于ASCII码放在数组里，所以返回的是指针，代表数组的首地址。
*/
unsigned char *number_to_ASCII(unsigned char ucBitNumber)
{
unsigned char *p_ucAnyNumber; //此指针根据ucBitNumber数值的大小，分别调用不同的ASCII码。
switch(ucBitNumber) //根据ucBitNumber数值的大小，分别调用不同的ASCII码。
{
case 0:
p_ucAnyNumber=ASCII816_0;
break;
case 1:
p_ucAnyNumber=ASCII816_1;
break;
case 2:
p_ucAnyNumber=ASCII816_2;
break;
case 3:
p_ucAnyNumber=ASCII816_3;
break;
case 4:
p_ucAnyNumber=ASCII816_4;
break;
case 5:
p_ucAnyNumber=ASCII816_5;
break;
case 6:
p_ucAnyNumber=ASCII816_6;
break;
case 7:
p_ucAnyNumber=ASCII816_7;
break;
case 8:
p_ucAnyNumber=ASCII816_8;
break;
case 9:
p_ucAnyNumber=ASCII816_9;
break;
case 10:
p_ucAnyNumber=ASCII816_nc;
break;
default: //如果上面的条件都不符合，那么默认指向空格ASCII码
p_ucAnyNumber=ASCII816_nc;
break;
}
return p_ucAnyNumber; //返回转换结束后的指针
}
void display_service(void) //显示服务程序,在main函数里
{
/* 注释四：
* 这里的局部变量用static关键词修饰，是因为这个函数一直在主函数while(1)里循环扫描，我不希望它每次进来这个函数
* 都多花几条指令去初始化这些局部变量，这样会多耗掉几个指令，所以我就用static关键字避免了这种情况，让这些局部变量
* 只在上电那一刻就初始化了，以后每次进来这个函数不用再初始化这些变量。
*/
static unsigned char ucAnyNumber_1; //分解变量的个位
static unsigned char ucAnyNumber_10; //分解变量的十位
static unsigned char ucAnyNumber_100; //分解变量的百位
static unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
static unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
static unsigned char *p_ucAnyNumber_100; //经过数字转换成字模后，分解变量的百位字模首地址
if(ucWd1Part1Update==1) //窗口1的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part1Update=0; //及时清零，避免一直更新
if(ucAnyNumber>=100) //有3位数以上
{
ucAnyNumber_100=ucAnyNumber/100; //百位
}
else //否则显示空
{
ucAnyNumber_100=10; //在下面的转换函数中，代码10表示空字模
}
if(ucAnyNumber>=10) //有2位数以上
{
ucAnyNumber_10=ucAnyNumber%100/10; //十位
}
else //否则显示空
{
ucAnyNumber_10=10; //在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucAnyNumber%10/1; //个位
p_ucAnyNumber_100=number_to_ASCII(ucAnyNumber_100); //把数字转换成字符ASCII码
p_ucAnyNumber_10=number_to_ASCII(ucAnyNumber_10); //把数字转换成字符ASCII码
p_ucAnyNumber_1=number_to_ASCII(ucAnyNumber_1); //把数字转换成字符ASCII码
display_double_code(2,1,ASCII816_nc[0],p_ucAnyNumber_100[0]);//液晶屏的显示驱动函数这里的ASCII816_nc[0]代表填充显示一个空格字符
display_double_code(3,1,p_ucAnyNumber_10[0],p_ucAnyNumber_1[0]);//液晶屏的显示驱动函数
}
}
void delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself(void) //第一区初始化单片机
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
}
void initial_peripheral(void) //第二区初始化外围
{
LCDInit(); //初始化12864 内部包含液晶模块的复位
WriteCommand(0x0C); //命令字0x0c表示用内部字库模式。命令字0x36表示用自构字库模式。
display_clear(); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
}

复制代码

总结陈词：

在液晶屏程序里，经常要用到反显的功能来表示选中某一项菜单。在调用内部字库时，这样的驱动程序又该怎么写？欲知详情，请听下回分解-----如何在调用液晶屏内部字库时让某行内容反显。

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

jianhong_wu · 发表于 2014-12-3 18:13:42

waphaoyun 发表于 2014-12-3 16:36
鸿哥，有几天木有更新啦

这两个星期有点忙。

jianhong_wu · 发表于 2014-12-9 13:16:37

华菲发表于 2014-12-9 12:42
等鸿哥的第九页呢

这两天一直在等待好的状态来临再动手。

jianhong_wu · 发表于 2014-12-17 13:08:01

第八十三节：矩阵键盘输入任意数字或小数点的液晶屏显示程序。

开场白：

本来这节打算讲调用液晶屏内部字库时让某行内容反显的，但是在昨天调试过程中，发现一个很奇怪的问题，当调用内部字库时，按照数据手册，我执行一条反显指令时，应该是仅仅某一行反显，但是却同时出现两行反显。比如，当我执行
WriteCommand(0x34); //扩充指令集
WriteCommand(0x04); //第1行反显
指令时，发现第一行和第三行反显，后来想想，我猜测这种12864的屏应该是25632折成左右半屏，左半屏在上面，右半屏在下面。经过这次经验，我觉得大家以后尽量不要用液晶屏的内部字库模式，应该用自构字库的模式（图形模式）。因为我觉得用内部字库模式的时候，这个集成的反显扩展指令不好用。而用自构字库的模式（图形模式），却可以顺心所欲的灵活运用，适合做菜单程序。

既然发现内部字库不好用，所以不再讲内部字库模式，这节仅仅接着前面第79节内容，继续讲在自构字库的模式（图形模式）下，如何通过矩阵键盘直接输入数字和小数点，就像普通的计算器一样键盘输入。这个功能表面简单，其实有以下四个地方值得注意：

第一：如何用数组接收按键输入的BCD码数据。

第二：如何限制输入参数的小数点个数和数组的有效个数。

第三：如果第0个位置是0，那么继续输入的数据直接覆盖0，否则就移位再输入。

第四：如果第0个位置是0，那么继续输入的小数点要移位输入。

要仔细了解以上提到的关键点，必须好好研究本程序中的void set_data(…)函数。同时也要温习一下之前讲的自构字库模式的液晶屏显示内容，尤其是插入画布显示的内容。

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

（1）硬件平台：
基于坚鸿51单片机学习板。数字1键对应S1键，数字2键对应S2键，数字3键对应S3键…. 数字9键对应S9键, 数字0键对应S10键。小数键对应S11，清零键对应S16，其它按键不用。

（2）实现功能：

用矩阵键盘输入任意数字或小数点。小数点不能超过2位，一旦超过2位，再按其它按键则输入无效。有效数字也不能超过6位（包括小数点），一旦超过6位，再按其它按键则输入无效。

想重新输入，必须按S16清零按键才能重新输入。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_key_time 10 //按键去抖动延时的时间
sbit key_sr1=P0^0; //第一行输入
sbit key_sr2=P0^1; //第二行输入
sbit key_sr3=P0^2; //第三行输入
sbit key_sr4=P0^3; //第四行输入
sbit key_dr1=P0^4; //第一列输出
sbit key_dr2=P0^5; //第二列输出
sbit key_dr3=P0^6; //第三列输出
sbit key_dr4=P0^7; //第四列输出
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
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_clear(unsigned char ucFillDate); // 清屏全部显示空填充0x00 全部显示点阵用0xff
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);//把字模插入画布.
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); //显示任意点阵函数
unsigned char *number_to_matrix(unsigned char ucBitNumber); //把一位数字转换成字模首地址的函数
void delay_short(unsigned int uiDelayshort); //延时
void delay_long(unsigned int uiDelayLong);
void key_number_input(unsigned char ucKeyNumber); //输入数字按键
void set_data(unsigned char ucKeyNumberTemp,unsigned char ucDotBitMax,unsigned char ucDataCntMax,unsigned char *p_ucDotCnt,unsigned char *p_ucDotBitS,unsigned char *p_ucWdPartCnt,unsigned char *p_ucSetDataBuffer);
void key_delete_input(void); //删除按键
void T0_time(); //定时中断函数
void key_service();
void key_scan(); //按键扫描函数放在定时中断里
void initial_myself();
void initial_peripheral();
void lcd_display_service(void); //应用层面的液晶屏显示程序
void clear_all_canvas(void); //把画布全部清零
code unsigned char Zf816_0[]=
{
/*-- 文字: 0 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_1[]=
{
/*-- 文字: 1 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
};
code unsigned char Zf816_2[]=
{
/*-- 文字: 2 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
};
code unsigned char Zf816_3[]=
{
/*-- 文字: 3 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_4[]=
{
/*-- 文字: 4 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
};
code unsigned char Zf816_5[]=
{
/*-- 文字: 5 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_6[]=
{
/*-- 文字: 6 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_7[]=
{
/*-- 文字: 7 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
};
code unsigned char Zf816_8[]=
{
/*-- 文字: 8 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
};
code unsigned char Zf816_9[]=
{
/*-- 文字: 9 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
};
code unsigned char Zf816_nc[]= //空字模
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Zf816_dot[]= //小数点
{
/*-- 文字: . --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x00,0x00,
};
code unsigned char Zf816_mao_hao[]= //冒号
{
/*-- 文字: : --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
};
code unsigned char Hz1616_yi[]=
{
/*-- 文字: 一 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_xiang[]=
{
/*-- 文字: 项 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x03,0xFE,0xFC,0x20,0x10,0x40,0x11,0xFC,0x11,0x04,0x11,0x24,0x11,0x24,
0x11,0x24,0x11,0x24,0x1D,0x24,0xE1,0x34,0x00,0x48,0x01,0x86,0x06,0x02,0x00,0x00,
};
code unsigned char Hz1616_shu[]=
{
/*-- 文字: 数 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x08,0x20,0x49,0x30,0x2A,0x20,0x1C,0x20,0xFF,0x7E,0x1C,0x44,0x2B,0x44,0x48,0xC4,
0x08,0x28,0xFF,0x28,0x12,0x10,0x34,0x10,0x0C,0x28,0x32,0x4E,0xC0,0x84,0x00,0x00,
};
code unsigned char Hz1616_zhu[]=
{
/*-- 文字: 组 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x10,0x00,0x19,0xF8,0x11,0x08,0x25,0x08,0x25,0x08,0x79,0xF8,0x09,0x08,0x11,0x08,
0x21,0x08,0x7D,0xF8,0x01,0x08,0x01,0x08,0x0D,0x08,0x73,0xFE,0x00,0x00,0x00,0x00,
};
/* 注释一：
* 以下是画布显示数组。横向是6个字节，纵向16行，可以显示3个16x16的汉字.
* 注意，这节内容的画布跟前面章节的画布大小不一样，前面章节的横向是4个字节，这节的横向是6个字节。
*/
unsigned char ucCanvasBuffer[]=
{
0x00,0x00,0x00,0x00,0x00,0x00, //上半屏
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
//------------上半屏和下半屏的分割线-----------
0x00,0x00,0x00,0x00,0x00,0x00, //下半屏
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
};
/* 注释二：
* 以下4个变量记录一个参数的4种信息，包括小数点的数量，个数，数据的位置，数组具体值.
*/
unsigned char ucDotCnt_1=0; //记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效
unsigned char ucDotBitS_1=0; //记录当前输入的小数点个数，如果小数点的个量如果超过规定2位，此时再按任何输入按键则无效
unsigned char ucWdPartCnt_1=0; //记录当前输入的数据在数组中的位置。
unsigned char ucDataBuffer_1[6]={0,10,10,10,10,10}; //一项的BCD码数组缓冲
unsigned char ucKeyStep=1; //按键扫描步骤变量
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiKeyTimeCnt=0; //按键去抖动延时计数器
unsigned char ucKeyLock=0; //按键触发后自锁的变量标志
unsigned char ucRowRecord=1; //记录当前扫描到第几列了
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucWd=1; //窗口变量
unsigned char ucPart=1; //局部变量 0代表没有选中任何一行，其它数值1到4代表选中某一行
unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量 1代表更新显示，响应函数内部会清零
void main()
{
initial_myself(); //第一区,上电后马上初始化
delay_long(100); //一线，延时线。延时一段时间
initial_peripheral(); //第二区,上电后延时一段时间再初始化
while(1) //第三区
{
key_service(); //按键服务程序
lcd_display_service(); //应用层面的液晶屏显示程序
}
}
void initial_myself() //第一区上电后马上初始化
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
}
void initial_peripheral() //第二区上电后延时一段时间再初始化
{
LCDInit(); //初始化12864 内部包含液晶模块的复位
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}
void T0_time() interrupt 1
{
TF0=0; //清除中断标志
TR0=0; //关中断
key_scan();//按键扫描函数放在定时中断里
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
TR0=1; //开中断
}
void key_scan()//按键扫描函数放在定时中断里
{
switch(ucKeyStep)
{
case 1: //按键扫描输出第ucRowRecord列低电平
if(ucRowRecord==1) //第一列输出低电平
{
key_dr1=0;
key_dr2=1;
key_dr3=1;
key_dr4=1;
}
else if(ucRowRecord==2) //第二列输出低电平
{
key_dr1=1;
key_dr2=0;
key_dr3=1;
key_dr4=1;
}
else if(ucRowRecord==3) //第三列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=0;
key_dr4=1;
}
else //第四列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=1;
key_dr4=0;
}
uiKeyTimeCnt=0; //延时计数器清零
ucKeyStep++; //切换到下一个运行步骤
break;
case 2: //此处的小延时用来等待刚才列输出信号稳定，再判断输入信号。不是去抖动延时。
uiKeyTimeCnt++;
if(uiKeyTimeCnt>1)
{
uiKeyTimeCnt=0;
ucKeyStep++; //切换到下一个运行步骤
}
break;
case 3:
if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
{
ucKeyStep=1; //如果没有按键按下，返回到第一个运行步骤重新开始扫描
ucKeyLock=0; //按键自锁标志清零
uiKeyTimeCnt=0; //按键去抖动延时计数器清零，此行非常巧妙
ucRowRecord++; //输出下一列
if(ucRowRecord>4)
{
ucRowRecord=1; //依次输出完四列之后，继续从第一列开始输出低电平
}
}
else if(ucKeyLock==0) //有按键按下，且是第一次触发
{
if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=1; //触发1号键对应朱兆祺学习板的S1键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=2; //触发2号键对应朱兆祺学习板的S2键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=3; //触发3号键对应朱兆祺学习板的S3键
}
else //第四列输出低电平
{
ucKeySec=4; //触发4号键对应朱兆祺学习板的S4键
}
}
}
else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=5; //触发5号键对应朱兆祺学习板的S5键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=6; //触发6号键对应朱兆祺学习板的S6键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=7; //触发7号键对应朱兆祺学习板的S7键
}
else //第四列输出低电平
{
ucKeySec=8; //触发8号键对应朱兆祺学习板的S8键
}
}
}
else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=9; //触发9号键对应朱兆祺学习板的S9键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=10; //触发10号键对应朱兆祺学习板的S10键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=11; //触发11号键对应朱兆祺学习板的S11键
}
else //第四列输出低电平
{
ucKeySec=12; //触发12号键对应朱兆祺学习板的S12键
}
}
}
else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=13; //触发13号键对应朱兆祺学习板的S13键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=14; //触发14号键对应朱兆祺学习板的S14键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=15; //触发15号键对应朱兆祺学习板的S15键
}
else //第四列输出低电平
{
ucKeySec=16; //触发16号键对应朱兆祺学习板的S16键
}
}
}
}
break;
}
}
void key_service() //按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 数字1 对应朱兆祺学习板的S1键
key_number_input(1); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 数字2 对应朱兆祺学习板的S2键
key_number_input(2); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3:// 数字3 对应朱兆祺学习板的S3键
key_number_input(3); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 4:// 数字4 对应朱兆祺学习板的S4键
key_number_input(4); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 5:// 数字5 对应朱兆祺学习板的S5键
key_number_input(5); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 6:// 数字6 对应朱兆祺学习板的S6键
key_number_input(6); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 7:// 数字7 对应朱兆祺学习板的S7键
key_number_input(7); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 8: //数字8 对应朱兆祺学习板的S8键
key_number_input(8); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 9:// 数字9 对应朱兆祺学习板的S9键
key_number_input(9); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 10:// 数字0 对应朱兆祺学习板的S10键
key_number_input(0); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 11:// 小数点按键对应朱兆祺学习板的S11键
key_number_input(11); //输入数字按键 11代表小数点
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 12:// 本节暂时不用对应朱兆祺学习板的S12键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 13:// 本节暂时不用对应朱兆祺学习板的S13键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 14:// 本节暂时不用对应朱兆祺学习板的S14键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 15:// 本节暂时不用对应朱兆祺学习板的S15键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 16:// 清除按键对应朱兆祺学习板的S16键
key_delete_input(); //删除按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
void key_number_input(unsigned char ucKeyNumber) //输入数字按键
{
switch(ucWd)
{
case 1: //第1窗口。本节程序只有1个窗口
switch(ucPart)
{
case 1: //1窗口第1项
set_data(ucKeyNumber,2,6,&ucDotCnt_1,&ucDotBitS_1,&ucWdPartCnt_1,ucDataBuffer_1); //设置参数，请看本函数具体内容。本节的核心内容，值得好好研究!
ucWd1Part1Update=1;//更新显示
break;
}
break;
}
}
/* 注释三：
* 本节的核心函数，值得好好研究！
* 涉及到参数的4种信息，包括小数点的数量，个数，数据的位置，数组具体值。以及它们之间的相互作用关系。
* 以下参数，指针类型的参数是让代入的全局变量在退出函数后维持它当前最新更改的数值不变。
* 第1个参数ucKeyNumberTemp是当前按键输入的数值。
* 第2个参数ucDotBitMax是限定被设置参数的小数点最大位数。
* 第3个参数ucDataCntMax是限定被设置参数的最大数组个数。
* 第4个参数*p_ucDotCnt是记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效。
* 第5个参数*p_ucDotBitS是记录当前输入的小数点个数，如果小数点的个量如果超过规定2位，此时再按任何输入按键则无效
* 第6个参数*p_ucWdPartCnt是记录当前输入的数据在数组中的位置，方便锁定每次按键输入的数字显示位置。
* 第7个参数*p_ucSetDataBuffer是BCD码数组缓冲的具体数字内容。
*/
void set_data(unsigned char ucKeyNumberTemp,unsigned char ucDotBitMax,unsigned char ucDataCntMax,unsigned char *p_ucDotCnt,unsigned char *p_ucDotBitS,unsigned char *p_ucWdPartCnt,unsigned char *p_ucSetDataBuffer)
{
unsigned int i;
if(ucKeyNumberTemp==11) //等于小数点
{
if(ucDotBitMax==0) //如果限定的小数点最大数是0，就意味着此数据不允许带小数点，必须是整数。
{
return; //直接返回退出
}
else if(*p_ucDotCnt>0) //小数点个数大于0，意味着当前数组已经包含了小数点，此时再输入小数点则无效。
{
return; //直接返回退出
}
else //否则有效，记录当前已经包含一个小数点的信息。
{
*p_ucDotCnt=1; //只能包含一个小数点
}
}
else if(*p_ucDotCnt==1) //如果输入的不是小数点，并且之前已经输入了一个小数点，那么此时输入的数字就是小数点后的数据
{
if(*p_ucDotBitS<ucDotBitMax) //如果小数点位数还没超过最大限制位数，则继续加1记录当前小数点位数。
{
*p_ucDotBitS=(*p_ucDotBitS)+1;
}
else //如果小数点位数已经超过允许的范围，则输入的按键无效，直接退出。
{
return; //直接返回退出
}
}
if(*p_ucWdPartCnt<(ucDataCntMax-1)) //当输入的有效BCD码不超过最大数组缓冲时
{
if(*p_ucWdPartCnt==0&&p_ucSetDataBuffer[0]==0&&ucKeyNumberTemp!=11) //如果当前默认位置是第0个位置，并且默认第0个数据是0，并且当前的按键输入不是小数点，则不用移位
{
;
}
else //否则，移位
{
for(i=0;i<(ucDataCntMax-1);i++) //移位
{
p_ucSetDataBuffer[ucDataCntMax-1-i]=p_ucSetDataBuffer[ucDataCntMax-2-i];
}
*p_ucWdPartCnt=(*p_ucWdPartCnt)+1;
}
p_ucSetDataBuffer[0]=ucKeyNumberTemp; //当前输入的数字或者小数点永远在第右边第0个位置。
}
}
void key_delete_input(void) //删除按键
{
static unsigned int i;
switch(ucWd)
{
case 1: //第1窗口。本节程序只有1个窗口
switch(ucPart)
{
case 1: //1窗口第1项
//清零
ucDotBitS_1=0;
ucDotCnt_1=0;
ucWdPartCnt_1=0;
for(i=0;i<6;i++)
{
ucDataBuffer_1[i]=10;
}
ucDataBuffer_1[0]=0; //第0个位置填入0
ucWd1Part1Update=1;//更新显示
break;
}
break;
}
}
unsigned char *number_to_matrix(unsigned char ucBitNumber)
{
unsigned char *p_ucAnyNumber; //此指针根据ucBitNumber数值的大小，分别调用不同的字库。
switch(ucBitNumber) //根据ucBitNumber数值的大小，分别调用不同的字库。
{
case 0:
p_ucAnyNumber=Zf816_0;
break;
case 1:
p_ucAnyNumber=Zf816_1;
break;
case 2:
p_ucAnyNumber=Zf816_2;
break;
case 3:
p_ucAnyNumber=Zf816_3;
break;
case 4:
p_ucAnyNumber=Zf816_4;
break;
case 5:
p_ucAnyNumber=Zf816_5;
break;
case 6:
p_ucAnyNumber=Zf816_6;
break;
case 7:
p_ucAnyNumber=Zf816_7;
break;
case 8:
p_ucAnyNumber=Zf816_8;
break;
case 9:
p_ucAnyNumber=Zf816_9;
break;
case 10: //空格
p_ucAnyNumber=Zf816_nc;
break;
case 11: //小数点
p_ucAnyNumber=Zf816_dot;
break;
default: //如果上面的条件都不符合，那么默认指向空字模
p_ucAnyNumber=Zf816_nc;
break;
}
return p_ucAnyNumber; //返回转换结束后的指针
}
void lcd_display_service(void) //应用层面的液晶屏显示程序
{
static unsigned char *p_ucAnyNumber; //经过数字转换成字模后，分解变量的某位字模首地址
static unsigned char ucCursorFlag; //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
static unsigned int i;
switch(ucWd) //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
{
case 1: //显示窗口1的数据
if(ucWd1Update==1) //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd1Update=0; //及时清零，避免一直更新
ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
display_clear(0x00); // 清屏操作，全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas(); //把画布全部清零
display_lattice(0,0,Hz1616_yi,0,2,16,0); //一窗口一行，这些内容不用经常更新，只有在切换窗口的时候才更新显示
display_lattice(1,0,Hz1616_xiang,0,2,16,0);
display_lattice(2,0,Hz1616_shu,0,2,16,0);
display_lattice(3,0,Hz1616_zhu,0,2,16,0);
display_lattice(4,0,Zf816_mao_hao,0,1,16,0); //冒号
}
if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part1Update=0; //及时清零，避免一直更新
if(ucPart==1) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
{
p_ucAnyNumber=number_to_matrix(ucDataBuffer_1[5-i]);
insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16); //这里的i是画布的横向地址，一共可以显示6个字符，因此取值范围是0到5
}
display_lattice(5,0,ucCanvasBuffer,ucCursorFlag,6,16,0); //显示整屏的画布,最后的参数0是偏移量
}
break;
//本程序只有1个窗口，所以只有一个case 1，如果要增加窗口，就直接增加 case 2, case 3...
}
}
void clear_all_canvas(void) //把画布全部清零
{
unsigned int j=0;
unsigned int i=0;
for(j=0;j<16;j++) //这里的16表示画布有16行
{
for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
{
ucCanvasBuffer[j*4+i]=0x00;
}
}
}
void display_clear(unsigned char ucFillDate) // 清屏全部显示空填充0x00 全部显示点阵用0xff
{
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(ucFillDate);
}
y++;
}
WriteCommand(0x36); //开显示缓冲指令
}
/* 注释四：
* 注意，这节内容的画布跟前面章节的画布大小不一样，前面章节的横向是4个字节，这节的横向是6个字节。
* 把字模插入画布的函数.
* 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是在画布中的坐标体系。
* x的范围是0至5，因为画布的横向只要6个字节。y的范围是0至15，因为画布的纵向只有16行。
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
*/
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)
{
unsigned int j=0;
unsigned int i=0;
unsigned char ucTemp;
for(j=0;j<y_amount;j++)
{
for(i=0;i<x_amount;i++)
{
ucTemp=ucArray[j*x_amount+i];
if(ucFbFlag==0)
{
ucCanvasBuffer[(y+j)*6+x+i]=ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节，要稍微注意的。
}
else
{
ucCanvasBuffer[(y+j)*6+x+i]=~ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节，要稍微注意的。
}
}
}
}
/* 注释五：
* 显示任意点阵函数.
* 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
* 对于这个函数，读者尤其要搞懂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分别代表字模数组的横向有多少个字节，纵向有几横。
* 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
*/
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)
{
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+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
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++)
{
;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}

复制代码

总结陈词：

这节讲的是键盘输入数字或者小数点的BCD码用来显示，实际项目中，我们经常要知道所输入的BCD码数组到底有效数值是多少，这个该怎么办？欲知详情，请听下回分解----

实时同步把键盘输入的BCD码数组转换成数值的液晶屏显示程序。

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

jianhong_wu · 发表于 2014-12-19 15:40:11

第八十四节：实时同步把键盘输入的BCD码数组转换成数值的液晶屏显示程序。

开场白：

键盘直接输入的是带小数点的BCD码数组，要把它们转换成具体的数值才可以更好的在程序里运算或者处理。如何把BCD码数组实时同步转换成数值？这一节主要跟大家讲这方面的算法程序。另外，有一个地方值得注意：上一节键盘输入的小数点个数可以限制成最大2位，但是整数部分没有限制。这节为了也能限制整数部分的最大个数为3位，我修改了上一节的void set_data(…)函数。所以这节的void set_data(…)函数跟上一节的void set_data(…)函数有点不一样，需要特别注意。

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

（1）硬件平台：
基于坚鸿51单片机学习板。数字1键对应S1键，数字2键对应S2键，数字3键对应S3键…. 数字9键对应S9键, 数字0键对应S10键。小数键对应S11，清零键对应S16，其它按键不用。

（2）实现功能：

用矩阵键盘输入任意数字或小数点。小数点不能超过2位，一旦超过2位，再按其它按键则输入无效。整数部分不能超过3位，一旦超过3位，再按其它按键则输入无效。想重新输入，必须按S16清零按键才能重新输入。每次键盘输入的第一行BCD码数组会同步更新显示在第二行的数值上。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_key_time 10 //按键去抖动延时的时间
sbit key_sr1=P0^0; //第一行输入
sbit key_sr2=P0^1; //第二行输入
sbit key_sr3=P0^2; //第三行输入
sbit key_sr4=P0^3; //第四行输入
sbit key_dr1=P0^4; //第一列输出
sbit key_dr2=P0^5; //第二列输出
sbit key_dr3=P0^6; //第三列输出
sbit key_dr4=P0^7; //第四列输出
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
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_clear(unsigned char ucFillDate); // 清屏全部显示空填充0x00 全部显示点阵用0xff
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);//把字模插入画布.
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); //显示任意点阵函数
unsigned char *number_to_matrix(unsigned char ucBitNumber); //把一位数字转换成字模首地址的函数
void delay_short(unsigned int uiDelayshort); //延时
void delay_long(unsigned int uiDelayLong);
void key_number_input(unsigned char ucKeyNumber); //输入数字按键
void set_data(unsigned char ucKeyNumberTemp, //设置参数
unsigned char ucDotBitMax,
unsigned char ucDataCntMax,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucSetDataBuffer,
unsigned char ucIntCntMax,
unsigned char *p_ucIntCnt);
unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer); //把带小数点的BCD数组转换成long类型的数值。
void key_delete_input(void); //删除按键
void T0_time(); //定时中断函数
void key_service();
void key_scan(); //按键扫描函数放在定时中断里
void initial_myself();
void initial_peripheral();
void lcd_display_service(void); //应用层面的液晶屏显示程序
void clear_all_canvas(void); //把画布全部清零
code unsigned char Zf816_0[]=
{
/*-- 文字: 0 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_1[]=
{
/*-- 文字: 1 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
};
code unsigned char Zf816_2[]=
{
/*-- 文字: 2 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
};
code unsigned char Zf816_3[]=
{
/*-- 文字: 3 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_4[]=
{
/*-- 文字: 4 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
};
code unsigned char Zf816_5[]=
{
/*-- 文字: 5 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_6[]=
{
/*-- 文字: 6 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_7[]=
{
/*-- 文字: 7 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
};
code unsigned char Zf816_8[]=
{
/*-- 文字: 8 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
};
code unsigned char Zf816_9[]=
{
/*-- 文字: 9 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
};
code unsigned char Zf816_nc[]= //空字模
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Zf816_dot[]= //小数点
{
/*-- 文字: . --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x00,0x00,
};
code unsigned char Zf816_mao_hao[]= //冒号
{
/*-- 文字: : --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
};
code unsigned char Hz1616_yi[]=
{
/*-- 文字: 一 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_xiang[]=
{
/*-- 文字: 项 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x03,0xFE,0xFC,0x20,0x10,0x40,0x11,0xFC,0x11,0x04,0x11,0x24,0x11,0x24,
0x11,0x24,0x11,0x24,0x1D,0x24,0xE1,0x34,0x00,0x48,0x01,0x86,0x06,0x02,0x00,0x00,
};
code unsigned char Hz1616_shu[]=
{
/*-- 文字: 数 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x08,0x20,0x49,0x30,0x2A,0x20,0x1C,0x20,0xFF,0x7E,0x1C,0x44,0x2B,0x44,0x48,0xC4,
0x08,0x28,0xFF,0x28,0x12,0x10,0x34,0x10,0x0C,0x28,0x32,0x4E,0xC0,0x84,0x00,0x00,
};
code unsigned char Hz1616_zhu[]=
{
/*-- 文字: 组 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x10,0x00,0x19,0xF8,0x11,0x08,0x25,0x08,0x25,0x08,0x79,0xF8,0x09,0x08,0x11,0x08,
0x21,0x08,0x7D,0xF8,0x01,0x08,0x01,0x08,0x0D,0x08,0x73,0xFE,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_zhi[]=
{
/*-- 文字: 值 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x10,0x40,0x18,0x60,0x17,0xFC,0x10,0x40,0x20,0x80,0x33,0xF8,0x62,0x08,0xA3,0xF8,
0x22,0x08,0x23,0xF8,0x22,0x08,0x23,0xF8,0x22,0x08,0x22,0x08,0x2F,0xFE,0x20,0x00,
};
/* 注释一：
* 以下是画布显示数组。横向是6个字节，纵向16行，可以显示3个16x16的汉字.
* 注意，这节内容的画布跟前面79章节的画布大小不一样，79节前面的横向是4个字节，这节的横向是6个字节。
*/
unsigned char ucCanvasBuffer[]=
{
0x00,0x00,0x00,0x00,0x00,0x00, //上半屏
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
//------------上半屏和下半屏的分割线-----------
0x00,0x00,0x00,0x00,0x00,0x00, //下半屏
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
};
/* 注释二：
* 以下5个变量记录一个参数的5种信息，包括小数点的数量，小数点个数，数据的位置，数组具体值，整数个数
*/
unsigned char ucDotCnt_1=0; //记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效
unsigned char ucDotBitS_1=0; //记录当前输入的小数点个数，如果小数点的个数如果超过规定ucDotBitMax位，此时再按任何输入按键则无效
unsigned char ucWdPartCnt_1=0; //记录当前输入的数据在数组中的位置。
unsigned char ucDataBuffer_1[6]={0,10,10,10,10,10}; //一项的BCD码数组缓冲
unsigned char ucIntCnt_1=0; //记录当前输入的整数个数，如果整数的个数如果超过规定ucIntCntMax位，此时再按任何输入按键则无效
unsigned long ulData_1=0; //用一个long变量表示BCD码的具体数值。
unsigned char ucKeyStep=1; //按键扫描步骤变量
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiKeyTimeCnt=0; //按键去抖动延时计数器
unsigned char ucKeyLock=0; //按键触发后自锁的变量标志
unsigned char ucRowRecord=1; //记录当前扫描到第几列了
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucWd=1; //窗口变量
unsigned char ucPart=1; //局部变量 0代表没有选中任何一行，其它数值1到4代表选中某一行
unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量 1代表更新显示，响应函数内部会自动把它清零
unsigned char ucWd1Part2Update=0; //窗口1的第2行局部更新显示变量 1代表更新显示，响应函数内部会自动把它清零
void main()
{
initial_myself(); //第一区,上电后马上初始化
delay_long(100); //一线，延时线。延时一段时间
initial_peripheral(); //第二区,上电后延时一段时间再初始化
while(1) //第三区
{
key_service(); //按键服务程序
lcd_display_service(); //应用层面的液晶屏显示程序
}
}
void initial_myself() //第一区上电后马上初始化
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
}
void initial_peripheral() //第二区上电后延时一段时间再初始化
{
LCDInit(); //初始化12864 内部包含液晶模块的复位
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}
void T0_time() interrupt 1
{
TF0=0; //清除中断标志
TR0=0; //关中断
key_scan();//按键扫描函数放在定时中断里
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
TR0=1; //开中断
}
void key_scan()//按键扫描函数放在定时中断里
{
switch(ucKeyStep)
{
case 1: //按键扫描输出第ucRowRecord列低电平
if(ucRowRecord==1) //第一列输出低电平
{
key_dr1=0;
key_dr2=1;
key_dr3=1;
key_dr4=1;
}
else if(ucRowRecord==2) //第二列输出低电平
{
key_dr1=1;
key_dr2=0;
key_dr3=1;
key_dr4=1;
}
else if(ucRowRecord==3) //第三列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=0;
key_dr4=1;
}
else //第四列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=1;
key_dr4=0;
}
uiKeyTimeCnt=0; //延时计数器清零
ucKeyStep++; //切换到下一个运行步骤
break;
case 2: //此处的小延时用来等待刚才列输出信号稳定，再判断输入信号。不是去抖动延时。
uiKeyTimeCnt++;
if(uiKeyTimeCnt>1)
{
uiKeyTimeCnt=0;
ucKeyStep++; //切换到下一个运行步骤
}
break;
case 3:
if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
{
ucKeyStep=1; //如果没有按键按下，返回到第一个运行步骤重新开始扫描
ucKeyLock=0; //按键自锁标志清零
uiKeyTimeCnt=0; //按键去抖动延时计数器清零，此行非常巧妙
ucRowRecord++; //输出下一列
if(ucRowRecord>4)
{
ucRowRecord=1; //依次输出完四列之后，继续从第一列开始输出低电平
}
}
else if(ucKeyLock==0) //有按键按下，且是第一次触发
{
if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=1; //触发1号键对应朱兆祺学习板的S1键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=2; //触发2号键对应朱兆祺学习板的S2键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=3; //触发3号键对应朱兆祺学习板的S3键
}
else //第四列输出低电平
{
ucKeySec=4; //触发4号键对应朱兆祺学习板的S4键
}
}
}
else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=5; //触发5号键对应朱兆祺学习板的S5键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=6; //触发6号键对应朱兆祺学习板的S6键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=7; //触发7号键对应朱兆祺学习板的S7键
}
else //第四列输出低电平
{
ucKeySec=8; //触发8号键对应朱兆祺学习板的S8键
}
}
}
else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=9; //触发9号键对应朱兆祺学习板的S9键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=10; //触发10号键对应朱兆祺学习板的S10键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=11; //触发11号键对应朱兆祺学习板的S11键
}
else //第四列输出低电平
{
ucKeySec=12; //触发12号键对应朱兆祺学习板的S12键
}
}
}
else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=13; //触发13号键对应朱兆祺学习板的S13键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=14; //触发14号键对应朱兆祺学习板的S14键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=15; //触发15号键对应朱兆祺学习板的S15键
}
else //第四列输出低电平
{
ucKeySec=16; //触发16号键对应朱兆祺学习板的S16键
}
}
}
}
break;
}
}
void key_service() //按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 数字1 对应朱兆祺学习板的S1键
key_number_input(1); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 数字2 对应朱兆祺学习板的S2键
key_number_input(2); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3:// 数字3 对应朱兆祺学习板的S3键
key_number_input(3); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 4:// 数字4 对应朱兆祺学习板的S4键
key_number_input(4); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 5:// 数字5 对应朱兆祺学习板的S5键
key_number_input(5); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 6:// 数字6 对应朱兆祺学习板的S6键
key_number_input(6); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 7:// 数字7 对应朱兆祺学习板的S7键
key_number_input(7); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 8: //数字8 对应朱兆祺学习板的S8键
key_number_input(8); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 9:// 数字9 对应朱兆祺学习板的S9键
key_number_input(9); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 10:// 数字0 对应朱兆祺学习板的S10键
key_number_input(0); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 11:// 小数点按键对应朱兆祺学习板的S11键
key_number_input(11); //输入数字按键 11代表小数点
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 12:// 本节暂时不用对应朱兆祺学习板的S12键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 13:// 本节暂时不用对应朱兆祺学习板的S13键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 14:// 本节暂时不用对应朱兆祺学习板的S14键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 15:// 本节暂时不用对应朱兆祺学习板的S15键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 16:// 清除按键对应朱兆祺学习板的S16键
key_delete_input(); //删除按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
void key_number_input(unsigned char ucKeyNumber) //输入数字按键
{
switch(ucWd)
{
case 1: //第1窗口。本节程序只有1个窗口
switch(ucPart)
{
case 1: //1窗口第1项
set_data(ucKeyNumber, //本函数跟前面第83节内容有所改动，请看本函数具体内容。本节的核心内容，值得好好研究!
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_1,
&ucDotBitS_1,
&ucWdPartCnt_1,
ucDataBuffer_1,
3, //整数部分的最大个数
&ucIntCnt_1);
ulData_1=buffer_to_data(6,2,ucDataBuffer_1); //把带小数点的BCD码数组转换成long数值。
ucWd1Part1Update=1;//第一行局部更新显示
ucWd1Part2Update=1;//第二行局部更新显示
break;
}
break;
}
}
/* 注释三：
* 本函数在前面第83节内容的函数上有改动，为了限制整数部分的个数，多添加了第8和第9这两个参数。
* 本节的核心函数，值得好好研究！
* 涉及到参数的4种信息，包括小数点的数量，小数点的个数，数据的位置，数组具体值，整数的数量，整数的个数，以及它们之间的相互作用关系。
* 以下参数，指针类型的参数是让代入的全局变量在退出函数后维持它当前最新更改的数值不变。
* 第1个参数ucKeyNumberTemp是当前按键输入的数值。
* 第2个参数ucDotBitMax是限定被设置参数的小数点最大位数。
* 第3个参数ucDataCntMax是限定被设置参数的最大数组个数。
* 第4个参数*p_ucDotCnt是记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效。
* 第5个参数*p_ucDotBitS是记录当前输入的小数点个数，如果小数点的个数如果超过规定ucDotBitMax位，此时再按任何输入按键则无效
* 第6个参数*p_ucWdPartCnt是记录当前输入的数据在数组中的位置，方便锁定每次按键输入的数字显示位置。
* 第7个参数*p_ucSetDataBuffer是BCD码数组缓冲的具体数字内容。
* 第8个参数ucIntCntMax是限定被设置参数的整数部分的最大位数。
* 第9个参数*p_ucIntCnt是记录当前输入的整数部分个数，如果整数部分的个数如果超过规定ucIntCntMax位，此时再按任何输入按键则无效
*/
void set_data(unsigned char ucKeyNumberTemp,
unsigned char ucDotBitMax,
unsigned char ucDataCntMax,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucSetDataBuffer,
unsigned char ucIntCntMax,
unsigned char *p_ucIntCnt)
{
unsigned int i;
if(ucKeyNumberTemp==11) //等于小数点
{
if(ucDotBitMax==0) //如果限定的小数点最大数是0，就意味着此数据不允许带小数点，必须是整数。
{
return; //直接返回退出
}
else if(*p_ucDotCnt>0) //小数点个数大于0，意味着当前数组已经包含了小数点，此时再输入小数点则无效。
{
return; //直接返回退出
}
else //否则有效，记录当前已经包含一个小数点的信息。
{
*p_ucDotCnt=1; //只能包含一个小数点
}
}
else //如果输入的不是小数点
{
if(*p_ucDotCnt==1) //如果之前已经输入了一个小数点，那么此时输入的数字就是小数点后的数据
{
if(*p_ucDotBitS<ucDotBitMax) //如果小数点位数还没超过最大限制位数，则继续加1记录当前小数点位数。
{
*p_ucDotBitS=(*p_ucDotBitS)+1;
}
else //如果小数点位数已经超过允许的范围，则输入的按键无效，直接退出。
{
return; //直接返回退出
}
}
else if(*p_ucIntCnt<ucIntCntMax)//如果之前没有输入小数点，那么输入的就是整数个数超，整数个数没有超过极限
{
*p_ucIntCnt=(*p_ucIntCnt)+1;
}
else //整数个数超过极限
{
return; //直接返回退出
}
}
if(*p_ucWdPartCnt==0&&p_ucSetDataBuffer[0]==0&&ucKeyNumberTemp!=11) //如果当前默认位置是第0个位置，并且默认第0个数据是0，并且当前的按键输入不是小数点，则不用移位
{
;
}
else //否则，移位
{
for(i=0;i<(ucDataCntMax-1);i++) //移位
{
p_ucSetDataBuffer[ucDataCntMax-1-i]=p_ucSetDataBuffer[ucDataCntMax-2-i];
}
*p_ucWdPartCnt=(*p_ucWdPartCnt)+1;
}
p_ucSetDataBuffer[0]=ucKeyNumberTemp; //当前输入的数字或者小数点永远在第右边第0个位置。
}
/* 注释四：
* 本节的核心函数，值得好好研究！
* 功能：把一个带小数点的BCD码数组转换成一个long类型的数值。
* 第1个参数ucConverDataSize是这个数组的最大有效个数。
* 第2个参数ucConverDotCnt是这个数组要转换成的long数值带几个小数点
* 第3个参数*p_ucConverBuffer是具体此数组的数据
* 函数最后返回被转换的long数值。
*/
unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer)
{
unsigned long ulConverResult=0;
unsigned long ulConverResultTemp=0;
unsigned char ucConverResultBuffer[6]; //因为本节内容的ucConverDataSize是6，所以取6.
unsigned char i;
unsigned char j;
unsigned char ucConverFlag;
for(i=0;i<ucConverDataSize;i++)
{
ucConverResultBuffer[i]=0; //先把临时缓冲区清零
}
j=0;
ucConverFlag=0;
for(i=0;i<ucConverDataSize;i++)
{
if(p_ucConverBuffer[i]==11) //小数点
{
ucConverFlag=i; //记录小数点的位置
}
else if(p_ucConverBuffer[i]<10)
{
ucConverResultBuffer[j]=p_ucConverBuffer[i]; //提取数组中的有效数字
j++;
}
}
for(i=0;i<ucConverDataSize;i++) //通过处理每一位从而合成一个long类型的数值
{
ulConverResultTemp=0;
ulConverResultTemp=ucConverResultBuffer[i];
for(j=0;j<i;j++)
{
ulConverResultTemp=ulConverResultTemp*10; //把每一位对应的进位扩大到对应的倍数
}
ulConverResult=ulConverResult+ulConverResultTemp;
}
for(i=ucConverFlag;i<ucConverDotCnt;i++) //根据数组小数点的位置和实际要转换成的小数点个数，来扩大到对应的倍数。
{
ulConverResult=ulConverResult*10;
}
return ulConverResult;
}
void key_delete_input(void) //删除按键
{
static unsigned int i;
switch(ucWd)
{
case 1: //第1窗口。本节程序只有1个窗口
switch(ucPart)
{
case 1: //1窗口第1项
//清零
ulData_1=0; //long数值清零
ucIntCnt_1=0;
ucDotBitS_1=0;
ucDotCnt_1=0;
ucWdPartCnt_1=0;
for(i=0;i<6;i++)
{
ucDataBuffer_1[i]=10;
}
ucDataBuffer_1[0]=0; //第0个位置填入0
ucWd1Part1Update=1;//第一行局部更新显示
ucWd1Part2Update=1;//第二行局部更新显示
break;
}
break;
}
}
unsigned char *number_to_matrix(unsigned char ucBitNumber)
{
unsigned char *p_ucAnyNumber; //此指针根据ucBitNumber数值的大小，分别调用不同的字库。
switch(ucBitNumber) //根据ucBitNumber数值的大小，分别调用不同的字库。
{
case 0:
p_ucAnyNumber=Zf816_0;
break;
case 1:
p_ucAnyNumber=Zf816_1;
break;
case 2:
p_ucAnyNumber=Zf816_2;
break;
case 3:
p_ucAnyNumber=Zf816_3;
break;
case 4:
p_ucAnyNumber=Zf816_4;
break;
case 5:
p_ucAnyNumber=Zf816_5;
break;
case 6:
p_ucAnyNumber=Zf816_6;
break;
case 7:
p_ucAnyNumber=Zf816_7;
break;
case 8:
p_ucAnyNumber=Zf816_8;
break;
case 9:
p_ucAnyNumber=Zf816_9;
break;
case 10: //空格
p_ucAnyNumber=Zf816_nc;
break;
case 11: //小数点
p_ucAnyNumber=Zf816_dot;
break;
default: //如果上面的条件都不符合，那么默认指向空字模
p_ucAnyNumber=Zf816_nc;
break;
}
return p_ucAnyNumber; //返回转换结束后的指针
}
void lcd_display_service(void) //应用层面的液晶屏显示程序
{
static unsigned char *p_ucAnyNumber; //经过数字转换成字模后，分解变量的某位字模首地址
static unsigned char ucCursorFlag; //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
static unsigned int i;
static unsigned char ucDataBuffer_temp[6]; //分解一个10进制的long类型数据的每一位
switch(ucWd) //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
{
case 1: //显示窗口1的数据
if(ucWd1Update==1) //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd1Update=0; //及时清零，避免一直更新
ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
display_clear(0x00); // 清屏操作，全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas(); //把画布全部清零
display_lattice(0,0,Hz1616_yi,0,2,16,0); //一项数组
display_lattice(1,0,Hz1616_xiang,0,2,16,0);
display_lattice(2,0,Hz1616_shu,0,2,16,0);
display_lattice(3,0,Hz1616_zhu,0,2,16,0);
display_lattice(4,0,Zf816_mao_hao,0,1,16,0); //冒号
display_lattice(0,16,Hz1616_yi,0,2,16,0); //一项数值
display_lattice(1,16,Hz1616_xiang,0,2,16,0);
display_lattice(2,16,Hz1616_shu,0,2,16,0);
display_lattice(3,16,Hz1616_zhi,0,2,16,0);
display_lattice(4,16,Zf816_mao_hao,0,1,16,0); //冒号
}
if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part1Update=0; //及时清零，避免一直更新
if(ucPart==1) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
{
p_ucAnyNumber=number_to_matrix(ucDataBuffer_1[5-i]);
insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16); //这里的i是画布的横向地址，一共可以显示6个字符，因此取值范围是0到5
}
display_lattice(5,0,ucCanvasBuffer,ucCursorFlag,6,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd1Part2Update==1) //窗口1的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part2Update=0; //及时清零，避免一直更新
if(ucPart==2) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ulData_1>=10000)
{
ucDataBuffer_temp[5]=ulData_1%100000/10000;
}
else
{
ucDataBuffer_temp[5]=10; //空格
}
if(ulData_1>=1000)
{
ucDataBuffer_temp[4]=ulData_1%10000/1000;
}
else
{
ucDataBuffer_temp[4]=10; //空格
}
ucDataBuffer_temp[3]=ulData_1%1000/100;
ucDataBuffer_temp[2]=11; //11代表小数点
ucDataBuffer_temp[1]=ulData_1%100/10;
ucDataBuffer_temp[0]=ulData_1%10/1;
for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
{
p_ucAnyNumber=number_to_matrix(ucDataBuffer_temp[5-i]);
insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16); //这里的i是画布的横向地址，一共可以显示6个字符，因此取值范围是0到5
}
display_lattice(5,16,ucCanvasBuffer,ucCursorFlag,6,16,0); //显示整屏的画布,最后的参数0是偏移量
}
break;
//本程序只有1个窗口，所以只有一个case 1，如果要增加窗口，就直接增加 case 2, case 3...
}
}
void clear_all_canvas(void) //把画布全部清零
{
unsigned int j=0;
unsigned int i=0;
for(j=0;j<16;j++) //这里的16表示画布有16行
{
for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
{
ucCanvasBuffer[j*4+i]=0x00;
}
}
}
void display_clear(unsigned char ucFillDate) // 清屏全部显示空填充0x00 全部显示点阵用0xff
{
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(ucFillDate);
}
y++;
}
WriteCommand(0x36); //开显示缓冲指令
}
/* 注释五：
* 注意，这节内容的画布跟第79节前面的画布大小不一样，第79节前面的横向是4个字节，这节的横向是6个字节。
* 把字模插入画布的函数.
* 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是在画布中的坐标体系。
* x的范围是0至5，因为画布的横向只要6个字节。y的范围是0至15，因为画布的纵向只有16行。
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
*/
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)
{
unsigned int j=0;
unsigned int i=0;
unsigned char ucTemp;
for(j=0;j<y_amount;j++)
{
for(i=0;i<x_amount;i++)
{
ucTemp=ucArray[j*x_amount+i];
if(ucFbFlag==0)
{
ucCanvasBuffer[(y+j)*6+x+i]=ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节，要稍微注意的。
}
else
{
ucCanvasBuffer[(y+j)*6+x+i]=~ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节，要稍微注意的。
}
}
}
}
/* 注释六：
* 显示任意点阵函数.
* 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
* 对于这个函数，读者尤其要搞懂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分别代表字模数组的横向有多少个字节，纵向有几横。
* 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
*/
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)
{
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+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
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++)
{
;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}

复制代码

总结陈词：

这节讲了把BCD码数组同步实时转换成数值的算法程序，相反，把数值转换成BCD码数组的逆运算程序应该怎么写？欲知详情，请听下回分解----实时同步把加减按键输入的数值转换成BCD码数组的液晶屏显示程序。

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

jianhong_wu · 发表于 2014-12-19 23:14:52

szdzjs 发表于 2014-12-19 22:26
来欣赏鸿哥的大作

欢迎

jianhong_wu · 发表于 2014-12-24 10:41:02

第八十五节：实时同步把加减按键输入的数值转换成BCD码数组的液晶屏显示程序。

开场白：

把运算处理完的数值转换成BCD码数组才可以更好方便显示和数字按键的输入编辑。这一节主要跟大家讲这方面的算法程序。本节的核心转换函数是void data_to_buffer(…)。

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

（1）硬件平台：
基于坚鸿51单片机学习板。数字1键对应S1键，数字2键对应S2键，数字3键对应S3键…. 数字9键对应S9键, 数字0键对应S10键。小数键对应S11，S13按键是加按键，S14按键是减按键，清零键对应S16，其它按键不用。

（2）实现功能：

通过S13,S14这两个加减按键更改第2行显示的数值，此数值会同步更新显示在第1行的BCD码数组上。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_key_time 10 //按键去抖动延时的时间
sbit key_sr1=P0^0; //第一行输入
sbit key_sr2=P0^1; //第二行输入
sbit key_sr3=P0^2; //第三行输入
sbit key_sr4=P0^3; //第四行输入
sbit key_dr1=P0^4; //第一列输出
sbit key_dr2=P0^5; //第二列输出
sbit key_dr3=P0^6; //第三列输出
sbit key_dr4=P0^7; //第四列输出
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
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_clear(unsigned char ucFillDate); // 清屏全部显示空填充0x00 全部显示点阵用0xff
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);//把字模插入画布.
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); //显示任意点阵函数
unsigned char *number_to_matrix(unsigned char ucBitNumber); //把一位数字转换成字模首地址的函数
void delay_short(unsigned int uiDelayshort); //延时
void delay_long(unsigned int uiDelayLong);
void key_number_input(unsigned char ucKeyNumber); //输入数字按键
void set_data(unsigned char ucKeyNumberTemp, //设置参数
unsigned char ucDotBitMax,
unsigned char ucDataCntMax,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucSetDataBuffer,
unsigned char ucIntCntMax,
unsigned char *p_ucIntCnt);
void data_to_buffer(unsigned long ulWillConverData, //把数值转换成数组
unsigned char ucConverDotCnt,
unsigned char ucConverDataSize,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucConverBuffer);
unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer); //把带小数点的BCD数组转换成long类型的数值。
void key_delete_input(void); //删除按键
void T0_time(); //定时中断函数
void key_service();
void key_scan(); //按键扫描函数放在定时中断里
void initial_myself();
void initial_peripheral();
void lcd_display_service(void); //应用层面的液晶屏显示程序
void clear_all_canvas(void); //把画布全部清零
code unsigned char Zf816_0[]=
{
/*-- 文字: 0 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_1[]=
{
/*-- 文字: 1 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
};
code unsigned char Zf816_2[]=
{
/*-- 文字: 2 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
};
code unsigned char Zf816_3[]=
{
/*-- 文字: 3 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_4[]=
{
/*-- 文字: 4 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
};
code unsigned char Zf816_5[]=
{
/*-- 文字: 5 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_6[]=
{
/*-- 文字: 6 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_7[]=
{
/*-- 文字: 7 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
};
code unsigned char Zf816_8[]=
{
/*-- 文字: 8 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
};
code unsigned char Zf816_9[]=
{
/*-- 文字: 9 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
};
code unsigned char Zf816_nc[]= //空字模
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Zf816_dot[]= //小数点
{
/*-- 文字: . --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x00,0x00,
};
code unsigned char Zf816_mao_hao[]= //冒号
{
/*-- 文字: : --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
};
code unsigned char Hz1616_yi[]=
{
/*-- 文字: 一 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_xiang[]=
{
/*-- 文字: 项 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x03,0xFE,0xFC,0x20,0x10,0x40,0x11,0xFC,0x11,0x04,0x11,0x24,0x11,0x24,
0x11,0x24,0x11,0x24,0x1D,0x24,0xE1,0x34,0x00,0x48,0x01,0x86,0x06,0x02,0x00,0x00,
};
code unsigned char Hz1616_shu[]=
{
/*-- 文字: 数 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x08,0x20,0x49,0x30,0x2A,0x20,0x1C,0x20,0xFF,0x7E,0x1C,0x44,0x2B,0x44,0x48,0xC4,
0x08,0x28,0xFF,0x28,0x12,0x10,0x34,0x10,0x0C,0x28,0x32,0x4E,0xC0,0x84,0x00,0x00,
};
code unsigned char Hz1616_zhu[]=
{
/*-- 文字: 组 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x10,0x00,0x19,0xF8,0x11,0x08,0x25,0x08,0x25,0x08,0x79,0xF8,0x09,0x08,0x11,0x08,
0x21,0x08,0x7D,0xF8,0x01,0x08,0x01,0x08,0x0D,0x08,0x73,0xFE,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_zhi[]=
{
/*-- 文字: 值 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x10,0x40,0x18,0x60,0x17,0xFC,0x10,0x40,0x20,0x80,0x33,0xF8,0x62,0x08,0xA3,0xF8,
0x22,0x08,0x23,0xF8,0x22,0x08,0x23,0xF8,0x22,0x08,0x22,0x08,0x2F,0xFE,0x20,0x00,
};
/* 注释一：
* 以下是画布显示数组。横向是6个字节，纵向16行，可以显示3个16x16的汉字.
* 注意，这节内容的画布跟前面79章节的画布大小不一样，79节前面的横向是4个字节，这节的横向是6个字节。
*/
unsigned char ucCanvasBuffer[]=
{
0x00,0x00,0x00,0x00,0x00,0x00, //上半屏
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
//------------上半屏和下半屏的分割线-----------
0x00,0x00,0x00,0x00,0x00,0x00, //下半屏
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
};
/* 注释二：
* 以下5个变量记录一个参数的5种信息，包括小数点的数量，小数点个数，数据的位置，数组具体值，整数个数
*/
unsigned char ucDotCnt_1=0; //记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效
unsigned char ucDotBitS_1=0; //记录当前输入的小数点个数，如果小数点的个数如果超过规定ucDotBitMax位，此时再按任何输入按键则无效
unsigned char ucWdPartCnt_1=0; //记录当前输入的数据在数组中的位置。
unsigned char ucDataBuffer_1[6]={0,10,10,10,10,10}; //一项的BCD码数组缓冲
unsigned char ucIntCnt_1=0; //记录当前输入的整数个数，如果整数的个数如果超过规定ucIntCntMax位，此时再按任何输入按键则无效
unsigned long ulData_1=0; //用一个long变量表示BCD码的具体数值。
unsigned char ucKeyStep=1; //按键扫描步骤变量
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiKeyTimeCnt=0; //按键去抖动延时计数器
unsigned char ucKeyLock=0; //按键触发后自锁的变量标志
unsigned char ucRowRecord=1; //记录当前扫描到第几列了
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucWd=1; //窗口变量
unsigned char ucPart=2; //局部变量 0代表没有选中任何一行，其它数值1到4代表选中某一行
unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量 1代表更新显示，响应函数内部会自动把它清零
unsigned char ucWd1Part2Update=0; //窗口1的第2行局部更新显示变量 1代表更新显示，响应函数内部会自动把它清零
void main()
{
initial_myself(); //第一区,上电后马上初始化
delay_long(100); //一线，延时线。延时一段时间
initial_peripheral(); //第二区,上电后延时一段时间再初始化
while(1) //第三区
{
key_service(); //按键服务程序
lcd_display_service(); //应用层面的液晶屏显示程序
}
}
void initial_myself() //第一区上电后马上初始化
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
}
void initial_peripheral() //第二区上电后延时一段时间再初始化
{
LCDInit(); //初始化12864 内部包含液晶模块的复位
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}
void T0_time() interrupt 1
{
TF0=0; //清除中断标志
TR0=0; //关中断
key_scan();//按键扫描函数放在定时中断里
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
TR0=1; //开中断
}
void key_scan()//按键扫描函数放在定时中断里
{
switch(ucKeyStep)
{
case 1: //按键扫描输出第ucRowRecord列低电平
if(ucRowRecord==1) //第一列输出低电平
{
key_dr1=0;
key_dr2=1;
key_dr3=1;
key_dr4=1;
}
else if(ucRowRecord==2) //第二列输出低电平
{
key_dr1=1;
key_dr2=0;
key_dr3=1;
key_dr4=1;
}
else if(ucRowRecord==3) //第三列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=0;
key_dr4=1;
}
else //第四列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=1;
key_dr4=0;
}
uiKeyTimeCnt=0; //延时计数器清零
ucKeyStep++; //切换到下一个运行步骤
break;
case 2: //此处的小延时用来等待刚才列输出信号稳定，再判断输入信号。不是去抖动延时。
uiKeyTimeCnt++;
if(uiKeyTimeCnt>1)
{
uiKeyTimeCnt=0;
ucKeyStep++; //切换到下一个运行步骤
}
break;
case 3:
if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
{
ucKeyStep=1; //如果没有按键按下，返回到第一个运行步骤重新开始扫描
ucKeyLock=0; //按键自锁标志清零
uiKeyTimeCnt=0; //按键去抖动延时计数器清零，此行非常巧妙
ucRowRecord++; //输出下一列
if(ucRowRecord>4)
{
ucRowRecord=1; //依次输出完四列之后，继续从第一列开始输出低电平
}
}
else if(ucKeyLock==0) //有按键按下，且是第一次触发
{
if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=1; //触发1号键对应朱兆祺学习板的S1键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=2; //触发2号键对应朱兆祺学习板的S2键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=3; //触发3号键对应朱兆祺学习板的S3键
}
else //第四列输出低电平
{
ucKeySec=4; //触发4号键对应朱兆祺学习板的S4键
}
}
}
else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=5; //触发5号键对应朱兆祺学习板的S5键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=6; //触发6号键对应朱兆祺学习板的S6键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=7; //触发7号键对应朱兆祺学习板的S7键
}
else //第四列输出低电平
{
ucKeySec=8; //触发8号键对应朱兆祺学习板的S8键
}
}
}
else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=9; //触发9号键对应朱兆祺学习板的S9键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=10; //触发10号键对应朱兆祺学习板的S10键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=11; //触发11号键对应朱兆祺学习板的S11键
}
else //第四列输出低电平
{
ucKeySec=12; //触发12号键对应朱兆祺学习板的S12键
}
}
}
else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=13; //触发13号键对应朱兆祺学习板的S13键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=14; //触发14号键对应朱兆祺学习板的S14键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=15; //触发15号键对应朱兆祺学习板的S15键
}
else //第四列输出低电平
{
ucKeySec=16; //触发16号键对应朱兆祺学习板的S16键
}
}
}
}
break;
}
}
void key_service() //按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 数字1 对应朱兆祺学习板的S1键
key_number_input(1); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 数字2 对应朱兆祺学习板的S2键
key_number_input(2); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3:// 数字3 对应朱兆祺学习板的S3键
key_number_input(3); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 4:// 数字4 对应朱兆祺学习板的S4键
key_number_input(4); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 5:// 数字5 对应朱兆祺学习板的S5键
key_number_input(5); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 6:// 数字6 对应朱兆祺学习板的S6键
key_number_input(6); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 7:// 数字7 对应朱兆祺学习板的S7键
key_number_input(7); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 8: //数字8 对应朱兆祺学习板的S8键
key_number_input(8); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 9:// 数字9 对应朱兆祺学习板的S9键
key_number_input(9); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 10:// 数字0 对应朱兆祺学习板的S10键
key_number_input(0); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 11:// 小数点按键对应朱兆祺学习板的S11键
key_number_input(11); //输入数字按键 11代表小数点
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 12:// 本节暂时不用对应朱兆祺学习板的S12键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 13:// 加按键对应朱兆祺学习板的S13键
ulData_1++;
if(ulData_1>99999)
{
ulData_1=99999;
}
data_to_buffer(ulData_1, //把数值转换成数组，这是本节核心函数，请好好研究此函数的具体功能。
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_1,
&ucDotBitS_1,
&ucWdPartCnt_1,
ucDataBuffer_1); //被转换成的数组
ucWd1Part1Update=1; //实时更新显示数组
ucWd1Part2Update=1; //实时更新显示数值
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 14:// 减按键对应朱兆祺学习板的S14键
ulData_1--;
if(ulData_1>99999) //unsigned long类型的变量0减去1会变成0xffffffff
{
ulData_1=0;
}
data_to_buffer(ulData_1, //把数值转换成数组，这是本节核心函数，请好好研究此函数的具体功能。
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_1,
&ucDotBitS_1,
&ucWdPartCnt_1,
ucDataBuffer_1); //被转换成的数组
ucWd1Part1Update=1; //实时更新显示数组
ucWd1Part2Update=1; //实时更新显示数值
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 15:// 本节暂时不用对应朱兆祺学习板的S15键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 16:// 清除按键对应朱兆祺学习板的S16键
key_delete_input(); //删除按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
void key_number_input(unsigned char ucKeyNumber) //输入数字按键
{
switch(ucWd)
{
case 1: //第1窗口。本节程序只有1个窗口
switch(ucPart)
{
case 1: //1窗口第1项
set_data(ucKeyNumber,
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_1,
&ucDotBitS_1,
&ucWdPartCnt_1,
ucDataBuffer_1,
3, //整数部分的最大个数
&ucIntCnt_1);
ulData_1=buffer_to_data(6,2,ucDataBuffer_1); //把带小数点的BCD码数组转换成long数值。
ucWd1Part1Update=1;//第一行局部更新显示
ucWd1Part2Update=1;//第二行局部更新显示
break;
}
break;
}
}
/* 注释三：
* 涉及到参数的4种信息，包括小数点的数量，小数点的个数，数据的位置，数组具体值，整数的数量，整数的个数，以及它们之间的相互作用关系。
* 以下参数，指针类型的参数是让代入的全局变量在退出函数后维持它当前最新更改的数值不变。
* 第1个参数ucKeyNumberTemp是当前按键输入的数值。
* 第2个参数ucDotBitMax是限定被设置参数的小数点最大位数。
* 第3个参数ucDataCntMax是限定被设置参数的最大数组个数。
* 第4个参数*p_ucDotCnt是记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效。
* 第5个参数*p_ucDotBitS是记录当前输入的小数点个数，如果小数点的个数如果超过规定ucDotBitMax位，此时再按任何输入按键则无效
* 第6个参数*p_ucWdPartCnt是记录当前输入的数据在数组中的位置，方便锁定每次按键输入的数字显示位置。
* 第7个参数*p_ucSetDataBuffer是BCD码数组缓冲的具体数字内容。
* 第8个参数ucIntCntMax是限定被设置参数的整数部分的最大位数。
* 第9个参数*p_ucIntCnt是记录当前输入的整数部分个数，如果整数部分的个数如果超过规定ucIntCntMax位，此时再按任何输入按键则无效
*/
void set_data(unsigned char ucKeyNumberTemp,
unsigned char ucDotBitMax,
unsigned char ucDataCntMax,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucSetDataBuffer,
unsigned char ucIntCntMax,
unsigned char *p_ucIntCnt)
{
unsigned int i;
if(ucKeyNumberTemp==11) //等于小数点
{
if(ucDotBitMax==0) //如果限定的小数点最大数是0，就意味着此数据不允许带小数点，必须是整数。
{
return; //直接返回退出
}
else if(*p_ucDotCnt>0) //小数点个数大于0，意味着当前数组已经包含了小数点，此时再输入小数点则无效。
{
return; //直接返回退出
}
else //否则有效，记录当前已经包含一个小数点的信息。
{
*p_ucDotCnt=1; //只能包含一个小数点
}
}
else //如果输入的不是小数点
{
if(*p_ucDotCnt==1) //如果之前已经输入了一个小数点，那么此时输入的数字就是小数点后的数据
{
if(*p_ucDotBitS<ucDotBitMax) //如果小数点位数还没超过最大限制位数，则继续加1记录当前小数点位数。
{
*p_ucDotBitS=(*p_ucDotBitS)+1;
}
else //如果小数点位数已经超过允许的范围，则输入的按键无效，直接退出。
{
return; //直接返回退出
}
}
else if(*p_ucIntCnt<ucIntCntMax)//如果之前没有输入小数点，那么输入的就是整数个数超，整数个数没有超过极限
{
*p_ucIntCnt=(*p_ucIntCnt)+1;
}
else //整数个数超过极限
{
return; //直接返回退出
}
}
if(*p_ucWdPartCnt==0&&p_ucSetDataBuffer[0]==0&&ucKeyNumberTemp!=11) //如果当前默认位置是第0个位置，并且默认第0个数据是0，并且当前的按键输入不是小数点，则不用移位
{
;
}
else //否则，移位
{
for(i=0;i<(ucDataCntMax-1);i++) //移位
{
p_ucSetDataBuffer[ucDataCntMax-1-i]=p_ucSetDataBuffer[ucDataCntMax-2-i];
}
*p_ucWdPartCnt=(*p_ucWdPartCnt)+1;
}
p_ucSetDataBuffer[0]=ucKeyNumberTemp; //当前输入的数字或者小数点永远在第右边第0个位置。
}
/* 注释四：
* 功能：把一个带小数点的BCD码数组转换成一个long类型的数值。
* 第1个参数ucConverDataSize是这个数组的最大有效个数。
* 第2个参数ucConverDotCnt是这个数组要转换成的long数值带几个小数点
* 第3个参数*p_ucConverBuffer是具体此数组的数据
* 函数最后返回被转换的long数值。
*/
unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer)
{
unsigned long ulConverResult=0;
unsigned long ulConverResultTemp=0;
unsigned char ucConverResultBuffer[6]; //因为本节内容的ucConverDataSize是6，所以取6.
unsigned char i;
unsigned char j;
unsigned char ucConverFlag;
for(i=0;i<ucConverDataSize;i++)
{
ucConverResultBuffer[i]=0; //先把临时缓冲区清零
}
j=0;
ucConverFlag=0;
for(i=0;i<ucConverDataSize;i++)
{
if(p_ucConverBuffer[i]==11) //小数点
{
ucConverFlag=i; //记录小数点的位置
}
else if(p_ucConverBuffer[i]<10)
{
ucConverResultBuffer[j]=p_ucConverBuffer[i]; //提取数组中的有效数字
j++;
}
}
for(i=0;i<ucConverDataSize;i++) //通过处理每一位从而合成一个long类型的数值
{
ulConverResultTemp=0;
ulConverResultTemp=ucConverResultBuffer[i];
for(j=0;j<i;j++)
{
ulConverResultTemp=ulConverResultTemp*10; //把每一位对应的进位扩大到对应的倍数
}
ulConverResult=ulConverResult+ulConverResultTemp;
}
for(i=ucConverFlag;i<ucConverDotCnt;i++) //根据数组小数点的位置和实际要转换成的小数点个数，来扩大到对应的倍数。
{
ulConverResult=ulConverResult*10;
}
return ulConverResult;
}
/* 注释五：
* 本节的核心函数，值得好好研究！
* 功能：把一个long类型的数值转换成一个带小数点的BCD码数组
* 第1个参数ulWillConverData是即将被转换的unsigned long类型数值。
* 第2个参数ucConverDotCnt是这个数值带几个小数点
* 第3个参数ucConverDataSize是这个数组的最大有效个数。
* 第4个参数*p_ucDotCnt是记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效。
* 第5个参数*p_ucDotBitS是记录当前输入的小数点个数，如果小数点的个数如果超过规定ucDotBitMax位，此时再按任何输入按键则无效
* 第6个参数*p_ucWdPartCnt是记录当前输入的数据在数组中的位置，方便锁定每次按键输入的数字显示位置。
* 第7个参数*p_ucConverBuffer是具体此数组的数据。
*/
void data_to_buffer(unsigned long ulWillConverData,
unsigned char ucConverDotCnt,
unsigned char ucConverDataSize,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucConverBuffer)
{
unsigned char ucConverResultBuffer[6]; //因为本节内容的ucConverDataSize是6，所以取6.
unsigned char i;
unsigned char ucValidaDotCnt=0;
if(ucConverDotCnt==0) //没有小数点
{
*p_ucDotCnt=0; //当前没有输入小数点的标志
*p_ucDotBitS=0; //当前输入的小数点个数是0
ucConverResultBuffer[5]=10; //没有小数点的时候，第5位必然是显示空格
//以下是具体把数值转换成数组，不需要显示的高位填入10表示显示空格
if(ulWillConverData>=10000)
{
ucConverResultBuffer[4]=ulWillConverData%100000/10000;
}
else
{
ucConverResultBuffer[4]=10;
}
if(ulWillConverData>=1000)
{
ucConverResultBuffer[3]=ulWillConverData%10000/1000;
}
else
{
ucConverResultBuffer[3]=10;
}
if(ulWillConverData>=100)
{
ucConverResultBuffer[2]=ulWillConverData%1000/100;
}
else
{
ucConverResultBuffer[2]=10;
}
if(ulWillConverData>=10)
{
ucConverResultBuffer[1]=ulWillConverData%100/10;
}
else
{
ucConverResultBuffer[1]=10;
}
ucConverResultBuffer[0]=ulWillConverData%10;
}
else if(ucConverDotCnt==1) //1位小数点
{
*p_ucDotCnt=1; //当前已经有输入小数点的标志
*p_ucDotBitS=1; //当前输入的小数点个数是1
ucConverResultBuffer[1]=11; //第1位填入小数点11
//以下是具体把数值转换成数组，不需要显示的高位填入10表示显示空格
if(ulWillConverData>=10000)
{
ucConverResultBuffer[5]=ulWillConverData%100000/10000;
}
else
{
ucConverResultBuffer[5]=10;
}
if(ulWillConverData>=1000)
{
ucConverResultBuffer[4]=ulWillConverData%10000/1000;
}
else
{
ucConverResultBuffer[4]=10;
}
if(ulWillConverData>=100)
{
ucConverResultBuffer[3]=ulWillConverData%1000/100;
}
else
{
ucConverResultBuffer[3]=10;
}
ucConverResultBuffer[2]=ulWillConverData%100/10;
ucConverResultBuffer[0]=ulWillConverData%10;
}
else if(ucConverDotCnt==2) //2位小数点
{
*p_ucDotCnt=1; //当前已经有输入小数点的标志
*p_ucDotBitS=2; //当前输入的小数点个数是2
ucConverResultBuffer[2]=11; //第2位填入小数点11
//以下是具体把数值转换成数组，不需要显示的高位填入10表示显示空格
if(ulWillConverData>=10000)
{
ucConverResultBuffer[5]=ulWillConverData%100000/10000;
}
else
{
ucConverResultBuffer[5]=10;
}
if(ulWillConverData>=1000)
{
ucConverResultBuffer[4]=ulWillConverData%10000/1000;
}
else
{
ucConverResultBuffer[4]=10;
}
ucConverResultBuffer[3]=ulWillConverData%1000/100;
ucConverResultBuffer[1]=ulWillConverData%100/10;
ucConverResultBuffer[0]=ulWillConverData%10;
}
ucValidaDotCnt=0;
for(i=0;i<ucConverDataSize;i++)
{
if(ucConverResultBuffer[i]!=10) //统计数组有效的BCD码位数
{
ucValidaDotCnt++;
}
p_ucConverBuffer[i]=ucConverResultBuffer[i]; //把转换的结果传输给实际的数组用来外部显示
}
*p_ucWdPartCnt=ucValidaDotCnt-1; //当前显示的实际位置
}
void key_delete_input(void) //删除按键
{
static unsigned int i;
switch(ucWd)
{
case 1: //第1窗口。本节程序只有1个窗口
switch(ucPart)
{
case 1: //1窗口第1行
//清零
ulData_1=0; //long数值清零
ucIntCnt_1=0;
ucDotBitS_1=0;
ucDotCnt_1=0;
ucWdPartCnt_1=0;
for(i=0;i<6;i++)
{
ucDataBuffer_1[i]=10;
}
ucDataBuffer_1[0]=0; //第0个位置填入0
ucWd1Part1Update=1;//第一行局部更新显示
ucWd1Part2Update=1;//第二行局部更新显示
break;
case 2: //1窗口第2行
//清零
ulData_1=0; //long数值清零
ucIntCnt_1=0;
ucDotBitS_1=0;
ucDotCnt_1=0;
ucWdPartCnt_1=0;
for(i=0;i<6;i++)
{
ucDataBuffer_1[i]=10;
}
ucDataBuffer_1[0]=0; //第0个位置填入0
ucWd1Part1Update=1;//第一行局部更新显示
ucWd1Part2Update=1;//第二行局部更新显示
break;
}
break;
}
}
unsigned char *number_to_matrix(unsigned char ucBitNumber)
{
unsigned char *p_ucAnyNumber; //此指针根据ucBitNumber数值的大小，分别调用不同的字库。
switch(ucBitNumber) //根据ucBitNumber数值的大小，分别调用不同的字库。
{
case 0:
p_ucAnyNumber=Zf816_0;
break;
case 1:
p_ucAnyNumber=Zf816_1;
break;
case 2:
p_ucAnyNumber=Zf816_2;
break;
case 3:
p_ucAnyNumber=Zf816_3;
break;
case 4:
p_ucAnyNumber=Zf816_4;
break;
case 5:
p_ucAnyNumber=Zf816_5;
break;
case 6:
p_ucAnyNumber=Zf816_6;
break;
case 7:
p_ucAnyNumber=Zf816_7;
break;
case 8:
p_ucAnyNumber=Zf816_8;
break;
case 9:
p_ucAnyNumber=Zf816_9;
break;
case 10: //空格
p_ucAnyNumber=Zf816_nc;
break;
case 11: //小数点
p_ucAnyNumber=Zf816_dot;
break;
default: //如果上面的条件都不符合，那么默认指向空字模
p_ucAnyNumber=Zf816_nc;
break;
}
return p_ucAnyNumber; //返回转换结束后的指针
}
void lcd_display_service(void) //应用层面的液晶屏显示程序
{
static unsigned char *p_ucAnyNumber; //经过数字转换成字模后，分解变量的某位字模首地址
static unsigned char ucCursorFlag; //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
static unsigned int i;
static unsigned char ucDataBuffer_temp[6]; //分解一个10进制的long类型数据的每一位
switch(ucWd) //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
{
case 1: //显示窗口1的数据
if(ucWd1Update==1) //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd1Update=0; //及时清零，避免一直更新
ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
display_clear(0x00); // 清屏操作，全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas(); //把画布全部清零
display_lattice(0,0,Hz1616_yi,0,2,16,0); //一项数组
display_lattice(1,0,Hz1616_xiang,0,2,16,0);
display_lattice(2,0,Hz1616_shu,0,2,16,0);
display_lattice(3,0,Hz1616_zhu,0,2,16,0);
display_lattice(4,0,Zf816_mao_hao,0,1,16,0); //冒号
display_lattice(0,16,Hz1616_yi,0,2,16,0); //一项数值
display_lattice(1,16,Hz1616_xiang,0,2,16,0);
display_lattice(2,16,Hz1616_shu,0,2,16,0);
display_lattice(3,16,Hz1616_zhi,0,2,16,0);
display_lattice(4,16,Zf816_mao_hao,0,1,16,0); //冒号
}
if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part1Update=0; //及时清零，避免一直更新
if(ucPart==1) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
{
p_ucAnyNumber=number_to_matrix(ucDataBuffer_1[5-i]);
insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16); //这里的i是画布的横向地址，一共可以显示6个字符，因此取值范围是0到5
}
display_lattice(5,0,ucCanvasBuffer,ucCursorFlag,6,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd1Part2Update==1) //窗口1的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part2Update=0; //及时清零，避免一直更新
if(ucPart==2) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ulData_1>=10000)
{
ucDataBuffer_temp[5]=ulData_1%100000/10000;
}
else
{
ucDataBuffer_temp[5]=10; //空格
}
if(ulData_1>=1000)
{
ucDataBuffer_temp[4]=ulData_1%10000/1000;
}
else
{
ucDataBuffer_temp[4]=10; //空格
}
ucDataBuffer_temp[3]=ulData_1%1000/100;
ucDataBuffer_temp[2]=11; //11代表小数点
ucDataBuffer_temp[1]=ulData_1%100/10;
ucDataBuffer_temp[0]=ulData_1%10/1;
for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
{
p_ucAnyNumber=number_to_matrix(ucDataBuffer_temp[5-i]);
insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16); //这里的i是画布的横向地址，一共可以显示6个字符，因此取值范围是0到5
}
display_lattice(5,16,ucCanvasBuffer,ucCursorFlag,6,16,0); //显示整屏的画布,最后的参数0是偏移量
}
break;
//本程序只有1个窗口，所以只有一个case 1，如果要增加窗口，就直接增加 case 2, case 3...
}
}
void clear_all_canvas(void) //把画布全部清零
{
unsigned int j=0;
unsigned int i=0;
for(j=0;j<16;j++) //这里的16表示画布有16行
{
for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
{
ucCanvasBuffer[j*4+i]=0x00;
}
}
}
void display_clear(unsigned char ucFillDate) // 清屏全部显示空填充0x00 全部显示点阵用0xff
{
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(ucFillDate);
}
y++;
}
WriteCommand(0x36); //开显示缓冲指令
}
/* 注释六：
* 注意，这节内容的画布跟第79节前面的画布大小不一样，第79节前面的横向是4个字节，这节的横向是6个字节。
* 把字模插入画布的函数.
* 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是在画布中的坐标体系。
* x的范围是0至5，因为画布的横向只要6个字节。y的范围是0至15，因为画布的纵向只有16行。
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
*/
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)
{
unsigned int j=0;
unsigned int i=0;
unsigned char ucTemp;
for(j=0;j<y_amount;j++)
{
for(i=0;i<x_amount;i++)
{
ucTemp=ucArray[j*x_amount+i];
if(ucFbFlag==0)
{
ucCanvasBuffer[(y+j)*6+x+i]=ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节，要稍微注意的。
}
else
{
ucCanvasBuffer[(y+j)*6+x+i]=~ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节，要稍微注意的。
}
}
}
}
/* 注释七：
* 显示任意点阵函数.
* 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
* 对于这个函数，读者尤其要搞懂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分别代表字模数组的横向有多少个字节，纵向有几横。
* 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
*/
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)
{
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+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
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++)
{
;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}

复制代码

总结陈词：

前面两节都讲了数组和数值的相互转换函数，结合前面的基础，下一节讲数字键盘与液晶菜单的综合程序，欲知详情，请听下回分解----数字键盘与液晶菜单的综合程序。

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

jianhong_wu · 发表于 2014-12-24 16:07:32

安之发表于 2014-12-24 15:20
吴哥，我准备跟着你学习，但是一开始我就遇到一个问题就是：第二区的外围初始化一加进去就有警告，而且程序 ...

有什么警告？我这边没有。你加这个QQ群：110291944，我在群里帮你解答。

jianhong_wu · 发表于 2014-12-24 23:45:35

szdzjs 发表于 2014-12-24 19:38
看到鸿哥新出的大作很兴奋，但想想85都出了，是不是到86就封贴了，总觉得意犹未尽。。。

这个不会那么快封贴的，我大概写到100左右会暂时停顿一会，专注去开一个零基础的技术贴，等零基础的贴写完了，出书了，录视频了，然后再回来从100节内容继续更新下去，因为我还有很多东西要分享出去。

jianhong_wu · 发表于 2014-12-26 11:05:08

第八十六节：数字键盘与液晶菜单的综合程序。

开场白：

前面已经介绍完数值跟BCD码数组相互转换的算法，但是按键只能设置一项数据。如果多增加一项数据，变成两项数据，按键与显示菜单之间该如何关联起来，这样的程序框架是什么样的？其实很简单很有规律的，只需要在前面的基础上，在按键和显示函数里，根据不同的uPart行变量添加进不同的代码，即可完成。这就是鸿哥写的程序代码，不管添加多少代码，都是有一个“道”可循，非常有规律性。

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

（1）硬件平台：
基于坚鸿51单片机学习板。数字1键对应S1键，数字2键对应S2键，数字3键对应S3键…. 数字9键对应S9键, 数字0键对应S10键。小数键对应S11，S12按键是光标移动按键，S13按键是加按键，S14按键是减按键，清零键对应S16，其它按键不用。

（2）实现功能：

通过S12光标移动按键，可以把负显光标切换到不同的行里面，根据光标所在位置，

通过S13,S14这两个加减按键可以更改对应的数。第1行和第2行的数据会彼此有关联，只要改其中一个，另外一个就会同步被更新。同理，第3行和第4行的数据也会彼此有关联，只要改其中一个，另外一个也会同步被更新。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_key_time 10 //按键去抖动延时的时间
sbit key_sr1=P0^0; //第一行输入
sbit key_sr2=P0^1; //第二行输入
sbit key_sr3=P0^2; //第三行输入
sbit key_sr4=P0^3; //第四行输入
sbit key_dr1=P0^4; //第一列输出
sbit key_dr2=P0^5; //第二列输出
sbit key_dr3=P0^6; //第三列输出
sbit key_dr4=P0^7; //第四列输出
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
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_clear(unsigned char ucFillDate); // 清屏全部显示空填充0x00 全部显示点阵用0xff
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);//把字模插入画布.
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); //显示任意点阵函数
unsigned char *number_to_matrix(unsigned char ucBitNumber); //把一位数字转换成字模首地址的函数
void delay_short(unsigned int uiDelayshort); //延时
void delay_long(unsigned int uiDelayLong);
void key_number_input(unsigned char ucKeyNumber); //输入数字按键
void set_data(unsigned char ucKeyNumberTemp, //设置参数
unsigned char ucDotBitMax,
unsigned char ucDataCntMax,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucSetDataBuffer,
unsigned char ucIntCntMax,
unsigned char *p_ucIntCnt);
void data_to_buffer(unsigned long ulWillConverData, //把数值转换成数组
unsigned char ucConverDotCnt,
unsigned char ucConverDataSize,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucConverBuffer);
unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer); //把带小数点的BCD数组转换成long类型的数值。
void key_delete_input(void); //删除按键
void T0_time(); //定时中断函数
void key_service();
void key_scan(); //按键扫描函数放在定时中断里
void initial_myself();
void initial_peripheral();
void lcd_display_service(void); //应用层面的液晶屏显示程序
void clear_all_canvas(void); //把画布全部清零
code unsigned char Zf816_0[]=
{
/*-- 文字: 0 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_1[]=
{
/*-- 文字: 1 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
};
code unsigned char Zf816_2[]=
{
/*-- 文字: 2 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
};
code unsigned char Zf816_3[]=
{
/*-- 文字: 3 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_4[]=
{
/*-- 文字: 4 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
};
code unsigned char Zf816_5[]=
{
/*-- 文字: 5 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};
code unsigned char Zf816_6[]=
{
/*-- 文字: 6 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
};
code unsigned char Zf816_7[]=
{
/*-- 文字: 7 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
};
code unsigned char Zf816_8[]=
{
/*-- 文字: 8 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
};
code unsigned char Zf816_9[]=
{
/*-- 文字: 9 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
};
code unsigned char Zf816_nc[]= //空字模
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Zf816_dot[]= //小数点
{
/*-- 文字: . --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x00,0x00,
};
code unsigned char Zf816_mao_hao[]= //冒号
{
/*-- 文字: : --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=8x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
};
code unsigned char Hz1616_yi[]=
{
/*-- 文字: 一 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_er[]=
{
/*-- 文字: 二 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x00,0x10,0x3F,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_xiang[]=
{
/*-- 文字: 项 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x03,0xFE,0xFC,0x20,0x10,0x40,0x11,0xFC,0x11,0x04,0x11,0x24,0x11,0x24,
0x11,0x24,0x11,0x24,0x1D,0x24,0xE1,0x34,0x00,0x48,0x01,0x86,0x06,0x02,0x00,0x00,
};
code unsigned char Hz1616_shu[]=
{
/*-- 文字: 数 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x08,0x20,0x49,0x30,0x2A,0x20,0x1C,0x20,0xFF,0x7E,0x1C,0x44,0x2B,0x44,0x48,0xC4,
0x08,0x28,0xFF,0x28,0x12,0x10,0x34,0x10,0x0C,0x28,0x32,0x4E,0xC0,0x84,0x00,0x00,
};
code unsigned char Hz1616_zhu[]=
{
/*-- 文字: 组 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x10,0x00,0x19,0xF8,0x11,0x08,0x25,0x08,0x25,0x08,0x79,0xF8,0x09,0x08,0x11,0x08,
0x21,0x08,0x7D,0xF8,0x01,0x08,0x01,0x08,0x0D,0x08,0x73,0xFE,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_zhi[]=
{
/*-- 文字: 值 --*/
/*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/
0x10,0x40,0x18,0x60,0x17,0xFC,0x10,0x40,0x20,0x80,0x33,0xF8,0x62,0x08,0xA3,0xF8,
0x22,0x08,0x23,0xF8,0x22,0x08,0x23,0xF8,0x22,0x08,0x22,0x08,0x2F,0xFE,0x20,0x00,
};
/* 注释一：
* 以下是画布显示数组。横向是6个字节，纵向16行，可以显示3个16x16的汉字.
* 注意，这节内容的画布跟前面79章节的画布大小不一样，79节前面的横向是4个字节，这节的横向是6个字节。
*/
unsigned char ucCanvasBuffer[]=
{
0x00,0x00,0x00,0x00,0x00,0x00, //上半屏
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
//------------上半屏和下半屏的分割线-----------
0x00,0x00,0x00,0x00,0x00,0x00, //下半屏
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
};
/* 注释二：
* 以下5个变量记录一个参数的5种信息，包括小数点的数量，小数点个数，数据的位置，数组具体值，整数个数
*/
unsigned char ucDotCnt_1=0; //记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效
unsigned char ucDotBitS_1=0; //记录当前输入的小数点个数，如果小数点的个数如果超过规定ucDotBitMax位，此时再按任何输入按键则无效
unsigned char ucWdPartCnt_1=0; //记录当前输入的数据在数组中的位置。
unsigned char ucDataBuffer_1[6]={0,10,10,10,10,10}; //一项的BCD码数组缓冲
unsigned char ucIntCnt_1=0; //记录当前输入的整数个数，如果整数的个数如果超过规定ucIntCntMax位，此时再按任何输入按键则无效
unsigned long ulData_1=0; //用一个long变量表示BCD码的具体数值。
unsigned char ucDotCnt_2=0; //记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效
unsigned char ucDotBitS_2=0; //记录当前输入的小数点个数，如果小数点的个数如果超过规定ucDotBitMax位，此时再按任何输入按键则无效
unsigned char ucWdPartCnt_2=0; //记录当前输入的数据在数组中的位置。
unsigned char ucDataBuffer_2[6]={0,10,10,10,10,10}; //一项的BCD码数组缓冲
unsigned char ucIntCnt_2=0; //记录当前输入的整数个数，如果整数的个数如果超过规定ucIntCntMax位，此时再按任何输入按键则无效
unsigned long ulData_2=0; //用一个long变量表示BCD码的具体数值。
unsigned char ucKeyStep=1; //按键扫描步骤变量
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiKeyTimeCnt=0; //按键去抖动延时计数器
unsigned char ucKeyLock=0; //按键触发后自锁的变量标志
unsigned char ucRowRecord=1; //记录当前扫描到第几列了
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucWd=1; //窗口变量
unsigned char ucPart=1; //局部变量 0代表没有选中任何一行，其它数值1到4代表选中某一行
unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量 1代表更新显示，响应函数内部会自动把它清零
unsigned char ucWd1Part2Update=0; //窗口1的第2行局部更新显示变量 1代表更新显示，响应函数内部会自动把它清零
unsigned char ucWd1Part3Update=0; //窗口1的第1行局部更新显示变量 1代表更新显示，响应函数内部会自动把它清零
unsigned char ucWd1Part4Update=0; //窗口1的第2行局部更新显示变量 1代表更新显示，响应函数内部会自动把它清零
void main()
{
initial_myself(); //第一区,上电后马上初始化
delay_long(100); //一线，延时线。延时一段时间
initial_peripheral(); //第二区,上电后延时一段时间再初始化
while(1) //第三区
{
key_service(); //按键服务程序
lcd_display_service(); //应用层面的液晶屏显示程序
}
}
void initial_myself() //第一区上电后马上初始化
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
}
void initial_peripheral() //第二区上电后延时一段时间再初始化
{
LCDInit(); //初始化12864 内部包含液晶模块的复位
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}
void T0_time() interrupt 1
{
TF0=0; //清除中断标志
TR0=0; //关中断
key_scan();//按键扫描函数放在定时中断里
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
TR0=1; //开中断
}
void key_scan()//按键扫描函数放在定时中断里
{
switch(ucKeyStep)
{
case 1: //按键扫描输出第ucRowRecord列低电平
if(ucRowRecord==1) //第一列输出低电平
{
key_dr1=0;
key_dr2=1;
key_dr3=1;
key_dr4=1;
}
else if(ucRowRecord==2) //第二列输出低电平
{
key_dr1=1;
key_dr2=0;
key_dr3=1;
key_dr4=1;
}
else if(ucRowRecord==3) //第三列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=0;
key_dr4=1;
}
else //第四列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=1;
key_dr4=0;
}
uiKeyTimeCnt=0; //延时计数器清零
ucKeyStep++; //切换到下一个运行步骤
break;
case 2: //此处的小延时用来等待刚才列输出信号稳定，再判断输入信号。不是去抖动延时。
uiKeyTimeCnt++;
if(uiKeyTimeCnt>1)
{
uiKeyTimeCnt=0;
ucKeyStep++; //切换到下一个运行步骤
}
break;
case 3:
if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
{
ucKeyStep=1; //如果没有按键按下，返回到第一个运行步骤重新开始扫描
ucKeyLock=0; //按键自锁标志清零
uiKeyTimeCnt=0; //按键去抖动延时计数器清零，此行非常巧妙
ucRowRecord++; //输出下一列
if(ucRowRecord>4)
{
ucRowRecord=1; //依次输出完四列之后，继续从第一列开始输出低电平
}
}
else if(ucKeyLock==0) //有按键按下，且是第一次触发
{
if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=1; //触发1号键对应朱兆祺学习板的S1键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=2; //触发2号键对应朱兆祺学习板的S2键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=3; //触发3号键对应朱兆祺学习板的S3键
}
else //第四列输出低电平
{
ucKeySec=4; //触发4号键对应朱兆祺学习板的S4键
}
}
}
else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=5; //触发5号键对应朱兆祺学习板的S5键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=6; //触发6号键对应朱兆祺学习板的S6键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=7; //触发7号键对应朱兆祺学习板的S7键
}
else //第四列输出低电平
{
ucKeySec=8; //触发8号键对应朱兆祺学习板的S8键
}
}
}
else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=9; //触发9号键对应朱兆祺学习板的S9键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=10; //触发10号键对应朱兆祺学习板的S10键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=11; //触发11号键对应朱兆祺学习板的S11键
}
else //第四列输出低电平
{
ucKeySec=12; //触发12号键对应朱兆祺学习板的S12键
}
}
}
else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
{
uiKeyTimeCnt++; //去抖动延时计数器
if(uiKeyTimeCnt>const_key_time)
{
uiKeyTimeCnt=0;
ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
if(ucRowRecord==1) //第一列输出低电平
{
ucKeySec=13; //触发13号键对应朱兆祺学习板的S13键
}
else if(ucRowRecord==2) //第二列输出低电平
{
ucKeySec=14; //触发14号键对应朱兆祺学习板的S14键
}
else if(ucRowRecord==3) //第三列输出低电平
{
ucKeySec=15; //触发15号键对应朱兆祺学习板的S15键
}
else //第四列输出低电平
{
ucKeySec=16; //触发16号键对应朱兆祺学习板的S16键
}
}
}
}
break;
}
}
void key_service() //按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 数字1 对应朱兆祺学习板的S1键
key_number_input(1); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 数字2 对应朱兆祺学习板的S2键
key_number_input(2); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3:// 数字3 对应朱兆祺学习板的S3键
key_number_input(3); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 4:// 数字4 对应朱兆祺学习板的S4键
key_number_input(4); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 5:// 数字5 对应朱兆祺学习板的S5键
key_number_input(5); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 6:// 数字6 对应朱兆祺学习板的S6键
key_number_input(6); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 7:// 数字7 对应朱兆祺学习板的S7键
key_number_input(7); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 8: //数字8 对应朱兆祺学习板的S8键
key_number_input(8); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 9:// 数字9 对应朱兆祺学习板的S9键
key_number_input(9); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 10:// 数字0 对应朱兆祺学习板的S10键
key_number_input(0); //输入数字按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 11:// 小数点按键对应朱兆祺学习板的S11键
key_number_input(11); //输入数字按键 11代表小数点
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 12:// 光标移动按键对应朱兆祺学习板的S12键
//ucPart++;
//if(ucPart>4)
//{
// ucPart=1;
//}
switch(ucPart) //根据不同的行来进行不同的操作
{
case 1:
ucPart=2;
ucWd1Part1Update=1; //实时更新显示数组
ucWd1Part2Update=1; //实时更新显示数值
break;
case 2:
ucPart=3;
ucWd1Part2Update=1; //实时更新显示数组
ucWd1Part3Update=1; //实时更新显示数值
break;
case 3:
ucPart=4;
ucWd1Part3Update=1; //实时更新显示数组
ucWd1Part4Update=1; //实时更新显示数值
break;
case 4:
ucPart=1;
ucWd1Part4Update=1; //实时更新显示数组
ucWd1Part1Update=1; //实时更新显示数值
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 13:// 加按键对应朱兆祺学习板的S13键
switch(ucPart) //根据不同的行来进行不同的操作
{
case 2:
ulData_1++;
if(ulData_1>99999)
{
ulData_1=99999;
}
data_to_buffer(ulData_1, //把数值转换成数组，这是本节核心函数，请好好研究此函数的具体功能。
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_1,
&ucDotBitS_1,
&ucWdPartCnt_1,
ucDataBuffer_1); //被转换成的数组
ucWd1Part1Update=1; //实时更新显示数组
ucWd1Part2Update=1; //实时更新显示数值
break;
case 4:
ulData_2++;
if(ulData_2>99999)
{
ulData_2=99999;
}
data_to_buffer(ulData_2, //把数值转换成数组，这是本节核心函数，请好好研究此函数的具体功能。
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_2,
&ucDotBitS_2,
&ucWdPartCnt_2,
ucDataBuffer_2); //被转换成的数组
ucWd1Part3Update=1; //实时更新显示数组
ucWd1Part4Update=1; //实时更新显示数值
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 14:// 减按键对应朱兆祺学习板的S14键
switch(ucPart) //根据不同的行来进行不同的操作
{
case 2:
ulData_1--;
if(ulData_1>99999) //unsigned long类型的变量0减去1会变成0xffffffff
{
ulData_1=0;
}
data_to_buffer(ulData_1, //把数值转换成数组，这是本节核心函数，请好好研究此函数的具体功能。
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_1,
&ucDotBitS_1,
&ucWdPartCnt_1,
ucDataBuffer_1); //被转换成的数组
ucWd1Part1Update=1; //实时更新显示数组
ucWd1Part2Update=1; //实时更新显示数值
break;
case 4:
ulData_2--;
if(ulData_2>99999) //unsigned long类型的变量0减去1会变成0xffffffff
{
ulData_2=0;
}
data_to_buffer(ulData_2, //把数值转换成数组，这是本节核心函数，请好好研究此函数的具体功能。
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_2,
&ucDotBitS_2,
&ucWdPartCnt_2,
ucDataBuffer_2); //被转换成的数组
ucWd1Part3Update=1; //实时更新显示数组
ucWd1Part4Update=1; //实时更新显示数值
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 15:// 本节暂时不用对应朱兆祺学习板的S15键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 16:// 清除按键对应朱兆祺学习板的S16键
key_delete_input(); //删除按键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
void key_number_input(unsigned char ucKeyNumber) //输入数字按键
{
switch(ucWd)
{
case 1: //第1窗口。本节程序只有1个窗口
switch(ucPart)
{
case 1: //1窗口第1行
set_data(ucKeyNumber,
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_1,
&ucDotBitS_1,
&ucWdPartCnt_1,
ucDataBuffer_1,
3, //整数部分的最大个数
&ucIntCnt_1);
ulData_1=buffer_to_data(6,2,ucDataBuffer_1); //把带小数点的BCD码数组转换成long数值。
ucWd1Part1Update=1;//第一行局部更新显示
ucWd1Part2Update=1;//第二行局部更新显示
break;
case 3: //1窗口第3行
set_data(ucKeyNumber,
2, //小数点最大个数
6, //数组缓冲最大个数
&ucDotCnt_2,
&ucDotBitS_2,
&ucWdPartCnt_2,
ucDataBuffer_2,
3, //整数部分的最大个数
&ucIntCnt_2);
ulData_2=buffer_to_data(6,2,ucDataBuffer_2); //把带小数点的BCD码数组转换成long数值。
ucWd1Part3Update=1;//第三行局部更新显示
ucWd1Part4Update=1;//第四行局部更新显示
break;
}
break;
}
}
/* 注释三：
* 涉及到参数的4种信息，包括小数点的数量，小数点的个数，数据的位置，数组具体值，整数的数量，整数的个数，以及它们之间的相互作用关系。
* 以下参数，指针类型的参数是让代入的全局变量在退出函数后维持它当前最新更改的数值不变。
* 第1个参数ucKeyNumberTemp是当前按键输入的数值。
* 第2个参数ucDotBitMax是限定被设置参数的小数点最大位数。
* 第3个参数ucDataCntMax是限定被设置参数的最大数组个数。
* 第4个参数*p_ucDotCnt是记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效。
* 第5个参数*p_ucDotBitS是记录当前输入的小数点个数，如果小数点的个数如果超过规定ucDotBitMax位，此时再按任何输入按键则无效
* 第6个参数*p_ucWdPartCnt是记录当前输入的数据在数组中的位置，方便锁定每次按键输入的数字显示位置。
* 第7个参数*p_ucSetDataBuffer是BCD码数组缓冲的具体数字内容。
* 第8个参数ucIntCntMax是限定被设置参数的整数部分的最大位数。
* 第9个参数*p_ucIntCnt是记录当前输入的整数部分个数，如果整数部分的个数如果超过规定ucIntCntMax位，此时再按任何输入按键则无效
*/
void set_data(unsigned char ucKeyNumberTemp,
unsigned char ucDotBitMax,
unsigned char ucDataCntMax,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucSetDataBuffer,
unsigned char ucIntCntMax,
unsigned char *p_ucIntCnt)
{
unsigned int i;
if(ucKeyNumberTemp==11) //等于小数点
{
if(ucDotBitMax==0) //如果限定的小数点最大数是0，就意味着此数据不允许带小数点，必须是整数。
{
return; //直接返回退出
}
else if(*p_ucDotCnt>0) //小数点个数大于0，意味着当前数组已经包含了小数点，此时再输入小数点则无效。
{
return; //直接返回退出
}
else //否则有效，记录当前已经包含一个小数点的信息。
{
*p_ucDotCnt=1; //只能包含一个小数点
}
}
else //如果输入的不是小数点
{
if(*p_ucDotCnt==1) //如果之前已经输入了一个小数点，那么此时输入的数字就是小数点后的数据
{
if(*p_ucDotBitS<ucDotBitMax) //如果小数点位数还没超过最大限制位数，则继续加1记录当前小数点位数。
{
*p_ucDotBitS=(*p_ucDotBitS)+1;
}
else //如果小数点位数已经超过允许的范围，则输入的按键无效，直接退出。
{
return; //直接返回退出
}
}
else if(*p_ucIntCnt<ucIntCntMax)//如果之前没有输入小数点，那么输入的就是整数个数超，整数个数没有超过极限
{
*p_ucIntCnt=(*p_ucIntCnt)+1;
}
else //整数个数超过极限
{
return; //直接返回退出
}
}
if(*p_ucWdPartCnt==0&&p_ucSetDataBuffer[0]==0&&ucKeyNumberTemp!=11) //如果当前默认位置是第0个位置，并且默认第0个数据是0，并且当前的按键输入不是小数点，则不用移位
{
;
}
else //否则，移位
{
for(i=0;i<(ucDataCntMax-1);i++) //移位
{
p_ucSetDataBuffer[ucDataCntMax-1-i]=p_ucSetDataBuffer[ucDataCntMax-2-i];
}
*p_ucWdPartCnt=(*p_ucWdPartCnt)+1;
}
p_ucSetDataBuffer[0]=ucKeyNumberTemp; //当前输入的数字或者小数点永远在第右边第0个位置。
}
/* 注释四：
* 功能：把一个带小数点的BCD码数组转换成一个long类型的数值。
* 第1个参数ucConverDataSize是这个数组的最大有效个数。
* 第2个参数ucConverDotCnt是这个数组要转换成的long数值带几个小数点
* 第3个参数*p_ucConverBuffer是具体此数组的数据
* 函数最后返回被转换的long数值。
*/
unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer)
{
unsigned long ulConverResult=0;
unsigned long ulConverResultTemp=0;
unsigned char ucConverResultBuffer[6]; //因为本节内容的ucConverDataSize是6，所以取6.
unsigned char i;
unsigned char j;
unsigned char ucConverFlag;
for(i=0;i<ucConverDataSize;i++)
{
ucConverResultBuffer[i]=0; //先把临时缓冲区清零
}
j=0;
ucConverFlag=0;
for(i=0;i<ucConverDataSize;i++)
{
if(p_ucConverBuffer[i]==11) //小数点
{
ucConverFlag=i; //记录小数点的位置
}
else if(p_ucConverBuffer[i]<10)
{
ucConverResultBuffer[j]=p_ucConverBuffer[i]; //提取数组中的有效数字
j++;
}
}
for(i=0;i<ucConverDataSize;i++) //通过处理每一位从而合成一个long类型的数值
{
ulConverResultTemp=0;
ulConverResultTemp=ucConverResultBuffer[i];
for(j=0;j<i;j++)
{
ulConverResultTemp=ulConverResultTemp*10; //把每一位对应的进位扩大到对应的倍数
}
ulConverResult=ulConverResult+ulConverResultTemp;
}
for(i=ucConverFlag;i<ucConverDotCnt;i++) //根据数组小数点的位置和实际要转换成的小数点个数，来扩大到对应的倍数。
{
ulConverResult=ulConverResult*10;
}
return ulConverResult;
}
/* 注释五：
* 本节的核心函数，值得好好研究！
* 功能：把一个long类型的数值转换成一个带小数点的BCD码数组
* 第1个参数ulWillConverData是即将被转换的unsigned long类型数值。
* 第2个参数ucConverDotCnt是这个数值带几个小数点
* 第3个参数ucConverDataSize是这个数组的最大有效个数。
* 第4个参数*p_ucDotCnt是记录当前输入的小数点数量，如果小数点的数量不为0，说明当前数组已包含小数点，此时再按小数点按键则无效。
* 第5个参数*p_ucDotBitS是记录当前输入的小数点个数，如果小数点的个数如果超过规定ucDotBitMax位，此时再按任何输入按键则无效
* 第6个参数*p_ucWdPartCnt是记录当前输入的数据在数组中的位置，方便锁定每次按键输入的数字显示位置。
* 第7个参数*p_ucConverBuffer是具体此数组的数据。
*/
void data_to_buffer(unsigned long ulWillConverData,
unsigned char ucConverDotCnt,
unsigned char ucConverDataSize,
unsigned char *p_ucDotCnt,
unsigned char *p_ucDotBitS,
unsigned char *p_ucWdPartCnt,
unsigned char *p_ucConverBuffer)
{
unsigned char ucConverResultBuffer[6]; //因为本节内容的ucConverDataSize是6，所以取6.
unsigned char i;
unsigned char ucValidaDotCnt=0;
if(ucConverDotCnt==0) //没有小数点
{
*p_ucDotCnt=0; //当前没有输入小数点的标志
*p_ucDotBitS=0; //当前输入的小数点个数是0
ucConverResultBuffer[5]=10; //没有小数点的时候，第5位必然是显示空格
//以下是具体把数值转换成数组，不需要显示的高位填入10表示显示空格
if(ulWillConverData>=10000)
{
ucConverResultBuffer[4]=ulWillConverData%100000/10000;
}
else
{
ucConverResultBuffer[4]=10;
}
if(ulWillConverData>=1000)
{
ucConverResultBuffer[3]=ulWillConverData%10000/1000;
}
else
{
ucConverResultBuffer[3]=10;
}
if(ulWillConverData>=100)
{
ucConverResultBuffer[2]=ulWillConverData%1000/100;
}
else
{
ucConverResultBuffer[2]=10;
}
if(ulWillConverData>=10)
{
ucConverResultBuffer[1]=ulWillConverData%100/10;
}
else
{
ucConverResultBuffer[1]=10;
}
ucConverResultBuffer[0]=ulWillConverData%10;
}
else if(ucConverDotCnt==1) //1位小数点
{
*p_ucDotCnt=1; //当前已经有输入小数点的标志
*p_ucDotBitS=1; //当前输入的小数点个数是1
ucConverResultBuffer[1]=11; //第1位填入小数点11
//以下是具体把数值转换成数组，不需要显示的高位填入10表示显示空格
if(ulWillConverData>=10000)
{
ucConverResultBuffer[5]=ulWillConverData%100000/10000;
}
else
{
ucConverResultBuffer[5]=10;
}
if(ulWillConverData>=1000)
{
ucConverResultBuffer[4]=ulWillConverData%10000/1000;
}
else
{
ucConverResultBuffer[4]=10;
}
if(ulWillConverData>=100)
{
ucConverResultBuffer[3]=ulWillConverData%1000/100;
}
else
{
ucConverResultBuffer[3]=10;
}
ucConverResultBuffer[2]=ulWillConverData%100/10;
ucConverResultBuffer[0]=ulWillConverData%10;
}
else if(ucConverDotCnt==2) //2位小数点
{
*p_ucDotCnt=1; //当前已经有输入小数点的标志
*p_ucDotBitS=2; //当前输入的小数点个数是2
ucConverResultBuffer[2]=11; //第2位填入小数点11
//以下是具体把数值转换成数组，不需要显示的高位填入10表示显示空格
if(ulWillConverData>=10000)
{
ucConverResultBuffer[5]=ulWillConverData%100000/10000;
}
else
{
ucConverResultBuffer[5]=10;
}
if(ulWillConverData>=1000)
{
ucConverResultBuffer[4]=ulWillConverData%10000/1000;
}
else
{
ucConverResultBuffer[4]=10;
}
ucConverResultBuffer[3]=ulWillConverData%1000/100;
ucConverResultBuffer[1]=ulWillConverData%100/10;
ucConverResultBuffer[0]=ulWillConverData%10;
}
ucValidaDotCnt=0;
for(i=0;i<ucConverDataSize;i++)
{
if(ucConverResultBuffer[i]!=10) //统计数组有效的BCD码位数
{
ucValidaDotCnt++;
}
p_ucConverBuffer[i]=ucConverResultBuffer[i]; //把转换的结果传输给实际的数组用来外部显示
}
*p_ucWdPartCnt=ucValidaDotCnt-1; //当前显示的实际位置
}
void key_delete_input(void) //删除按键
{
static unsigned int i;
switch(ucWd)
{
case 1: //第1窗口。本节程序只有1个窗口
switch(ucPart)
{
case 1: //1窗口第1行
//清零
ulData_1=0; //long数值清零
ucIntCnt_1=0;
ucDotBitS_1=0;
ucDotCnt_1=0;
ucWdPartCnt_1=0;
for(i=0;i<6;i++)
{
ucDataBuffer_1[i]=10;
}
ucDataBuffer_1[0]=0; //第0个位置填入0
ucWd1Part1Update=1;//第一行局部更新显示
ucWd1Part2Update=1;//第二行局部更新显示
break;
case 2: //1窗口第2行
//清零
ulData_1=0; //long数值清零
ucIntCnt_1=0;
ucDotBitS_1=0;
ucDotCnt_1=0;
ucWdPartCnt_1=0;
for(i=0;i<6;i++)
{
ucDataBuffer_1[i]=10;
}
ucDataBuffer_1[0]=0; //第0个位置填入0
ucWd1Part1Update=1;//第一行局部更新显示
ucWd1Part2Update=1;//第二行局部更新显示
break;
case 3: //1窗口第3行
//清零
ulData_2=0; //long数值清零
ucIntCnt_2=0;
ucDotBitS_2=0;
ucDotCnt_2=0;
ucWdPartCnt_2=0;
for(i=0;i<6;i++)
{
ucDataBuffer_2[i]=10;
}
ucDataBuffer_2[0]=0; //第0个位置填入0
ucWd1Part3Update=1;//第三行局部更新显示
ucWd1Part4Update=1;//第四行局部更新显示
break;
case 4: //1窗口第4行
//清零
ulData_2=0; //long数值清零
ucIntCnt_2=0;
ucDotBitS_2=0;
ucDotCnt_2=0;
ucWdPartCnt_2=0;
for(i=0;i<6;i++)
{
ucDataBuffer_2[i]=10;
}
ucDataBuffer_2[0]=0; //第0个位置填入0
ucWd1Part3Update=1;//第三行局部更新显示
ucWd1Part4Update=1;//第四行局部更新显示
break;
}
break;
}
}
unsigned char *number_to_matrix(unsigned char ucBitNumber)
{
unsigned char *p_ucAnyNumber; //此指针根据ucBitNumber数值的大小，分别调用不同的字库。
switch(ucBitNumber) //根据ucBitNumber数值的大小，分别调用不同的字库。
{
case 0:
p_ucAnyNumber=Zf816_0;
break;
case 1:
p_ucAnyNumber=Zf816_1;
break;
case 2:
p_ucAnyNumber=Zf816_2;
break;
case 3:
p_ucAnyNumber=Zf816_3;
break;
case 4:
p_ucAnyNumber=Zf816_4;
break;
case 5:
p_ucAnyNumber=Zf816_5;
break;
case 6:
p_ucAnyNumber=Zf816_6;
break;
case 7:
p_ucAnyNumber=Zf816_7;
break;
case 8:
p_ucAnyNumber=Zf816_8;
break;
case 9:
p_ucAnyNumber=Zf816_9;
break;
case 10: //空格
p_ucAnyNumber=Zf816_nc;
break;
case 11: //小数点
p_ucAnyNumber=Zf816_dot;
break;
default: //如果上面的条件都不符合，那么默认指向空字模
p_ucAnyNumber=Zf816_nc;
break;
}
return p_ucAnyNumber; //返回转换结束后的指针
}
void lcd_display_service(void) //应用层面的液晶屏显示程序
{
static unsigned char *p_ucAnyNumber; //经过数字转换成字模后，分解变量的某位字模首地址
static unsigned char ucCursorFlag; //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
static unsigned int i;
static unsigned char ucDataBuffer_temp[6]; //分解一个10进制的long类型数据的每一位
switch(ucWd) //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
{
case 1: //显示窗口1的数据
if(ucWd1Update==1) //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd1Update=0; //及时清零，避免一直更新
ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd1Part3Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd1Part4Update=1; //激活窗口1的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
display_clear(0x00); // 清屏操作，全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas(); //把画布全部清零
display_lattice(0,0,Hz1616_yi,0,2,16,0); //一项数组
display_lattice(1,0,Hz1616_xiang,0,2,16,0);
display_lattice(2,0,Hz1616_shu,0,2,16,0);
display_lattice(3,0,Hz1616_zhu,0,2,16,0);
display_lattice(4,0,Zf816_mao_hao,0,1,16,0); //冒号
display_lattice(0,16,Hz1616_yi,0,2,16,0); //一项数值
display_lattice(1,16,Hz1616_xiang,0,2,16,0);
display_lattice(2,16,Hz1616_shu,0,2,16,0);
display_lattice(3,16,Hz1616_zhi,0,2,16,0);
display_lattice(4,16,Zf816_mao_hao,0,1,16,0); //冒号
display_lattice(8,0,Hz1616_er,0,2,16,0); //二项数组
display_lattice(9,0,Hz1616_xiang,0,2,16,0);
display_lattice(10,0,Hz1616_shu,0,2,16,0);
display_lattice(11,0,Hz1616_zhu,0,2,16,0);
display_lattice(12,0,Zf816_mao_hao,0,1,16,0); //冒号
display_lattice(8,16,Hz1616_er,0,2,16,0); //二项数值
display_lattice(9,16,Hz1616_xiang,0,2,16,0);
display_lattice(10,16,Hz1616_shu,0,2,16,0);
display_lattice(11,16,Hz1616_zhi,0,2,16,0);
display_lattice(12,16,Zf816_mao_hao,0,1,16,0); //冒号
}
if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part1Update=0; //及时清零，避免一直更新
if(ucPart==1) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
{
p_ucAnyNumber=number_to_matrix(ucDataBuffer_1[5-i]);
insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16); //这里的i是画布的横向地址，一共可以显示6个字符，因此取值范围是0到5
}
display_lattice(5,0,ucCanvasBuffer,ucCursorFlag,6,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd1Part2Update==1) //窗口1的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part2Update=0; //及时清零，避免一直更新
if(ucPart==2) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ulData_1>=10000)
{
ucDataBuffer_temp[5]=ulData_1%100000/10000;
}
else
{
ucDataBuffer_temp[5]=10; //空格
}
if(ulData_1>=1000)
{
ucDataBuffer_temp[4]=ulData_1%10000/1000;
}
else
{
ucDataBuffer_temp[4]=10; //空格
}
ucDataBuffer_temp[3]=ulData_1%1000/100;
ucDataBuffer_temp[2]=11; //11代表小数点
ucDataBuffer_temp[1]=ulData_1%100/10;
ucDataBuffer_temp[0]=ulData_1%10/1;
for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
{
p_ucAnyNumber=number_to_matrix(ucDataBuffer_temp[5-i]);
insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16); //这里的i是画布的横向地址，一共可以显示6个字符，因此取值范围是0到5
}
display_lattice(5,16,ucCanvasBuffer,ucCursorFlag,6,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd1Part3Update==1) //窗口1的第3行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part3Update=0; //及时清零，避免一直更新
if(ucPart==3) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
{
p_ucAnyNumber=number_to_matrix(ucDataBuffer_2[5-i]);
insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16); //这里的i是画布的横向地址，一共可以显示6个字符，因此取值范围是0到5
}
display_lattice(13,0,ucCanvasBuffer,ucCursorFlag,6,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd1Part4Update==1) //窗口1的第4行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part4Update=0; //及时清零，避免一直更新
if(ucPart==4) //被选中
{
ucCursorFlag=1; //反显显示
}
else //没被选中
{
ucCursorFlag=0; //正常显示
}
if(ulData_2>=10000)
{
ucDataBuffer_temp[5]=ulData_2%100000/10000;
}
else
{
ucDataBuffer_temp[5]=10; //空格
}
if(ulData_2>=1000)
{
ucDataBuffer_temp[4]=ulData_2%10000/1000;
}
else
{
ucDataBuffer_temp[4]=10; //空格
}
ucDataBuffer_temp[3]=ulData_2%1000/100;
ucDataBuffer_temp[2]=11; //11代表小数点
ucDataBuffer_temp[1]=ulData_2%100/10;
ucDataBuffer_temp[0]=ulData_2%10/1;
for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
{
p_ucAnyNumber=number_to_matrix(ucDataBuffer_temp[5-i]);
insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16); //这里的i是画布的横向地址，一共可以显示6个字符，因此取值范围是0到5
}
display_lattice(13,16,ucCanvasBuffer,ucCursorFlag,6,16,0); //显示整屏的画布,最后的参数0是偏移量
}
break;
//本程序只有1个窗口，所以只有一个case 1，如果要增加窗口，就直接增加 case 2, case 3...
}
}
void clear_all_canvas(void) //把画布全部清零
{
unsigned int j=0;
unsigned int i=0;
for(j=0;j<16;j++) //这里的16表示画布有16行
{
for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
{
ucCanvasBuffer[j*4+i]=0x00;
}
}
}
void display_clear(unsigned char ucFillDate) // 清屏全部显示空填充0x00 全部显示点阵用0xff
{
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(ucFillDate);
}
y++;
}
WriteCommand(0x36); //开显示缓冲指令
}
/* 注释六：
* 注意，这节内容的画布跟第79节前面的画布大小不一样，第79节前面的横向是4个字节，这节的横向是6个字节。
* 把字模插入画布的函数.
* 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是在画布中的坐标体系。
* x的范围是0至5，因为画布的横向只要6个字节。y的范围是0至15，因为画布的纵向只有16行。
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
*/
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)
{
unsigned int j=0;
unsigned int i=0;
unsigned char ucTemp;
for(j=0;j<y_amount;j++)
{
for(i=0;i<x_amount;i++)
{
ucTemp=ucArray[j*x_amount+i];
if(ucFbFlag==0)
{
ucCanvasBuffer[(y+j)*6+x+i]=ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节，要稍微注意的。
}
else
{
ucCanvasBuffer[(y+j)*6+x+i]=~ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节，要稍微注意的。
}
}
}
}
/* 注释七：
* 显示任意点阵函数.
* 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
* 对于这个函数，读者尤其要搞懂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分别代表字模数组的横向有多少个字节，纵向有几横。
* 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
*/
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)
{
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+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
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++)
{
;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}

复制代码

总结陈词：

液晶屏显示的内容到这一节为止基本讲完。前面第38节到第45节是讲串口的，我的串口程序大部分都是通过靠时间来识别每一串数据是否接收完毕，只要第41节内容不是靠时间来判断，而是根据特定关键字来快速识别数据串是否接收完毕，下一节我打算结合我最新的一个项目经验，继续讲一个这方面的例子。欲知详情，请听下回分解----当主机连续不断地发送一串串数据给从机时，从机串口如何快速截取有效数据串。

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

jianhong_wu · 发表于 2014-12-26 18:28:47

第八十七节：郑文显捐赠的工控项目源代码。

开场白：

根据上一节的预告，本来这节要讲关于串口的一个小项目，但是今天中午的时候，有个厦门客户的出现，让我决定先插入这节内容。

他叫郑文显，是做PLC开发的。今天中午他要我帮他写一个工控程序让他来学习，也是基于坚鸿51单片机学习板的，他想把这个源代码经过自己修改后移植到他自己做的工控板上。我一开始报价4000元，被他砍价到1000元，我看一下也不算很难就答应了下来。刚才下午花了3个小时终于做好了。郑文显爽快的付了款，并且在电话那里跟我讲，他说独乐乐不如众乐乐，资源只有分享才能发挥它的最大价值，因此他决定要把这个源代码捐赠出来给大家一起学。非常感谢他的慈善壮举。种善因，得善果。好人一生平安。他的这个项目不难，跟我第25节内容很类似，略加修改就可以了。具体功能需求请看以下第（2）点。

（1）硬件平台：

基于坚鸿51单片机学习板。

（2）实现功能：

他的系统要控制2个气缸，没有任何传感器。第1个气缸先伸出去，1秒钟后再收回来。然后第2个气缸再伸出去，1秒钟后再收回来，算完成一个过程，然后重头开始循环下去。每一个过程要计数加1显示在右边的4位数码管上，左边的4位数码管显示设定的最大计数上限，一旦超过这个计数上限就自动停止。有4个按键，一个按键用来启动，一个按键用来急停。另外两个按键是加减按键，用来设置左边显示的最大计数上限。断电要求数据不丢失。如果同时按下加减两个按键，可以清零当前计数的内容。

这4个按键都是独立按键。S1键是加键，S5键是减键，S9键是启动键，S13键是急停键。其中74HC595驱动丝印为D1的LED灯模拟第1个气缸，丝印为D2的LED灯模拟第2个气缸。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_key_time1 20 //按键去抖动延时的时间
#define const_key_time2 20 //按键去抖动延时的时间
#define const_key_time3 20 //按键去抖动延时的时间
#define const_key_time4 20 //按键去抖动延时的时间
#define const_key_time12 20 //按键去抖动延时的时间
#define const_1s 500 //1秒钟大概的定时中断次数
void start24(void); //开始位
void ack24(void); //确认位
void stop24(void); //停止位
unsigned char read24(void); //读取一个字节的时序
void write24(unsigned char dd); //发送一个字节的时序
unsigned char read_eeprom(unsigned int address); //从一个地址读取出一个字节数据
void write_eeprom(unsigned int address,unsigned char dd); //往一个地址存入一个字节数据
unsigned int read_eeprom_int(unsigned int address); //从一个地址读取出一个int类型的数据
void write_eeprom_int(unsigned int address,unsigned int uiWriteData); //往一个地址存入一个int类型的数据
void initial_myself();
void initial_peripheral();
void delay_short(unsigned int uiDelayShort);
void delay_long(unsigned int uiDelaylong);
//驱动数码管的74HC595
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);
void display_drive(); //显示数码管字模的驱动函数
void display_service(); //显示的窗口菜单服务程序
//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
void T0_time(); //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan();//按键扫描函数放在定时中断里
void run(); //设备自动控制程序
void left_to_right(); //从左边移动到右边
void right_to_left(); //从右边返回到左边
void up_to_down(); //从上边移动到下边
void down_to_up(); //从下边返回到上边
void led_update(); //LED更新函数
void delay_timer(unsigned int uiDelayTimerTemp);
sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
sbit led_dr=P3^5; //作为中途暂停指示灯亮的时候表示中途暂停
sbit dig_hc595_sh_dr=P2^0; //数码管的74HC595程序
sbit dig_hc595_st_dr=P2^1;
sbit dig_hc595_ds_dr=P2^2;
sbit hc595_sh_dr=P2^3; //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;
sbit hc595_ds_dr=P2^5;
sbit eeprom_scl_dr=P3^7; //时钟线
sbit eeprom_sda_dr_sr=P3^6; //数据的输出线和输入线
//根据原理图得出的共阴数码管字模表
code unsigned char dig_table[]=
{
0x3f, //0 序号0
0x06, //1 序号1
0x5b, //2 序号2
0x4f, //3 序号3
0x66, //4 序号4
0x6d, //5 序号5
0x7d, //6 序号6
0x07, //7 序号7
0x7f, //8 序号8
0x6f, //9 序号9
0x00, //无序号10
0x40, //- 序号11
0x73, //P 序号12
};
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucDigShow8; //第8位数码管要显示的内容
unsigned char ucDigShow7; //第7位数码管要显示的内容
unsigned char ucDigShow6; //第6位数码管要显示的内容
unsigned char ucDigShow5; //第5位数码管要显示的内容
unsigned char ucDigShow4; //第4位数码管要显示的内容
unsigned char ucDigShow3; //第3位数码管要显示的内容
unsigned char ucDigShow2; //第2位数码管要显示的内容
unsigned char ucDigShow1; //第1位数码管要显示的内容
unsigned char ucDigDot8; //数码管8的小数点是否显示的标志
unsigned char ucDigDot7; //数码管7的小数点是否显示的标志
unsigned char ucDigDot6; //数码管6的小数点是否显示的标志
unsigned char ucDigDot5; //数码管5的小数点是否显示的标志
unsigned char ucDigDot4; //数码管4的小数点是否显示的标志
unsigned char ucDigDot3; //数码管3的小数点是否显示的标志
unsigned char ucDigDot2; //数码管2的小数点是否显示的标志
unsigned char ucDigDot1; //数码管1的小数点是否显示的标志
unsigned char ucDigShowTemp=0; //临时中间变量
unsigned char ucDisplayDriveStep=1; //动态扫描数码管的步骤变量
unsigned char ucWd1Part1Update=1; //左边4位数码管更新显示标志
unsigned char ucWd1Part2Update=1; //右边4位数码管更新显示标志
unsigned int uiSetData=18; //需要被设置的计数上限
unsigned int uiRunCnt=0; //实际运行的计数值
unsigned char ucRunTimeFlag=0; //延时计数器的开关
unsigned int uiRunTimeCnt=0; //运动中的时间延时计数器变量
unsigned char ucRunStep=1; //运动控制的步骤变量
unsigned char ucRunFlag=0; //是否启动运行的标志 1代表运行
unsigned char ucDelayTimerFlag=0; //计时器的开关
unsigned int uiDelayTimer=0;
unsigned char ucLed_dr1=0; //代表16个灯的亮灭状态，0代表灭，1代表亮
unsigned char ucLed_dr2=0;
unsigned char ucLed_dr3=0;
unsigned char ucLed_dr4=0;
unsigned char ucLed_dr5=0;
unsigned char ucLed_dr6=0;
unsigned char ucLed_dr7=0;
unsigned char ucLed_dr8=0;
unsigned char ucLed_dr9=0;
unsigned char ucLed_dr10=0;
unsigned char ucLed_dr11=0;
unsigned char ucLed_dr12=0;
unsigned char ucLed_dr13=0;
unsigned char ucLed_dr14=0;
unsigned char ucLed_dr15=0;
unsigned char ucLed_dr16=0;
unsigned char ucLed_update=1; //刷新变量。每次更改LED灯的状态都要更新一次。
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
key_service(); //按键服务的应用程序
run(); //设备自动控制程序
display_service(); //显示的窗口菜单服务程序
led_update(); //LED更新函数
}
}
void left_to_right() //从左边移动到右边
{
ucLed_dr1=1; // 1代表左右气缸从左边移动到右边
ucLed_update=1; //刷新变量。每次更改LED灯的状态都要更新一次。
}
void right_to_left() //从右边返回到左边
{
ucLed_dr1=0; // 0代表左右气缸从右边返回到左边
ucLed_update=1; //刷新变量。每次更改LED灯的状态都要更新一次。
}
void up_to_down() //从上边移动到下边
{
ucLed_dr2=1; // 1代表上下气缸从上边移动到下边
ucLed_update=1; //刷新变量。每次更改LED灯的状态都要更新一次。
}
void down_to_up() //从下边返回到上边
{
ucLed_dr2=0; // 0代表上下气缸从下边返回到上边
ucLed_update=1; //刷新变量。每次更改LED灯的状态都要更新一次。
}
void run() //设备自动控制程序
{
if(ucRunFlag==1) //是否启动运行的标志
{
switch(ucRunStep)
{
case 1: //机械手从左边往右边移动
left_to_right();
ucRunTimeFlag=0; //延时计数器关在清零uiRunTimeCnt变量前，最好先关闭计时器开关，起到跟中断互锁作用
uiRunTimeCnt=0; //时间计数器清零，为接下来延时1秒钟做准备
ucRunTimeFlag=1; //延时计数器开感谢郑文显捐助本节源代码
ucRunStep=2; //这就是鸿哥传说中的怎样灵活控制步骤变量
break;
case 2: //延时1秒
if(uiRunTimeCnt>const_1s) //延时1秒
{
ucRunStep=3; //这就是鸿哥传说中的怎样灵活控制步骤变量
}
break;
case 3: //机械手从右边往左边移动
right_to_left();
ucRunTimeFlag=0; //延时计数器关在清零uiRunTimeCnt变量前，最好先关闭计时器开关，起到跟中断互锁作用
uiRunTimeCnt=0; //时间计数器清零，为接下来延时1秒钟做准备
ucRunTimeFlag=1; //延时计数器开
ucRunStep=4; //这就是鸿哥传说中的怎样灵活控制步骤变量
break;
case 4: //延时1秒
if(uiRunTimeCnt>const_1s) //延时1秒
{
ucRunStep=5; //这就是鸿哥传说中的怎样灵活控制步骤变量
}
break;
case 5: //机械手//从上边移动到下边
up_to_down();
ucRunTimeFlag=0; //延时计数器关在清零uiRunTimeCnt变量前，最好先关闭计时器开关，起到跟中断互锁作用
uiRunTimeCnt=0; //时间计数器清零，为接下来延时1秒钟做准备
ucRunTimeFlag=1; //延时计数器开
ucRunStep=6; //这就是鸿哥传说中的怎样灵活控制步骤变量
break;
case 6: //延时1秒
if(uiRunTimeCnt>const_1s) //延时1秒
{
ucRunStep=7; //这就是鸿哥传说中的怎样灵活控制步骤变量
}
break;
case 7: //机械手从下边返回到上边
down_to_up();
ucRunTimeFlag=0; //延时计数器关在清零uiRunTimeCnt变量前，最好先关闭计时器开关，起到跟中断互锁作用
uiRunTimeCnt=0; //时间计数器清零，为接下来延时1秒钟做准备
ucRunTimeFlag=1; //延时计数器开感谢郑文显捐助本节源代码
ucRunStep=8; //这就是鸿哥传说中的怎样灵活控制步骤变量
break;
case 8: //延时1秒
if(uiRunTimeCnt>const_1s) //延时1秒
{
uiRunCnt++; //实际运行的计数值累加
if(uiRunCnt>9999) //数码管最大显示4位9999，如果超过了，继续默认为9999
{
uiRunCnt=9999;
}
ucWd1Part2Update=1; //右边4位数码管更新显示
write_eeprom_int(2,uiRunCnt); //及时把数据存进EEPROM，避免掉电丢失数据
if(uiRunCnt>=uiSetData) //如果实际的计数大于或者等于设定上限，则停止
{
ucRunFlag=0; //停止
ucRunStep=1; //切换到第一步为下一次准备
}
else
{
ucRunStep=1; //切换到第一步继续运行
}
}
break;
}
}
}
void display_service() //显示的窗口菜单服务程序
{
//加了static关键字后，此局部变量不会每次进来函数都初始化一次，这样减少了一点指令消耗的时间。
static unsigned char ucTemp4; //中间过渡变量
static unsigned char ucTemp3; //中间过渡变量
static unsigned char ucTemp2; //中间过渡变量
static unsigned char ucTemp1; //中间过渡变量
//左边4位数码管显示设置的计数上限
if(ucWd1Part1Update==1) //左边4位数码管要全部更新显示
{
ucWd1Part1Update=0; //及时清零标志，避免一直进来扫描
//先分解数据用来显示每一位
ucTemp4=uiSetData/1000;
ucTemp3=uiSetData%1000/100;
ucTemp2=uiSetData%100/10;
ucTemp1=uiSetData%10;
if(uiSetData<1000)
{
ucDigShow8=10; //如果小于1000，千位显示无
}
else
{
ucDigShow8=ucTemp4; //第8位数码管要显示的内容
}
if(uiSetData<100)
{
ucDigShow7=10; //如果小于100，百位显示无
}
else
{
ucDigShow7=ucTemp3; //第7位数码管要显示的内容
}
if(uiSetData<10)
{
ucDigShow6=10; //如果小于10，十位显示无
}
else
{
ucDigShow6=ucTemp2; //第6位数码管要显示的内容
}
ucDigShow5=ucTemp1; //第5位数码管要显示的内容
}
//右边4位数码管显示实际的计数
if(ucWd1Part2Update==1) //右边4位数码管要全部更新显示
{
ucWd1Part2Update=0; //及时清零标志，避免一直进来扫描
//先分解数据用来显示每一位
ucTemp4=uiRunCnt/1000;
ucTemp3=uiRunCnt%1000/100;
ucTemp2=uiRunCnt%100/10;
ucTemp1=uiRunCnt%10;
if(uiRunCnt<1000)
{
ucDigShow4=10; //如果小于1000，千位显示无
}
else
{
ucDigShow4=ucTemp4; //第8位数码管要显示的内容
}
if(uiRunCnt<100)
{
ucDigShow3=10; //如果小于100，百位显示无
}
else
{
ucDigShow3=ucTemp3; //第7位数码管要显示的内容
}
if(uiRunCnt<10)
{
ucDigShow2=10; //如果小于10，十位显示无
}
else
{
ucDigShow2=ucTemp2; //第6位数码管要显示的内容
}
ucDigShow1=ucTemp1; //第5位数码管要显示的内容
}
}
void key_scan()//按键扫描函数放在定时中断里
{
//加了static关键字后，此局部变量不会每次进来函数都被初始化一次，这样可以记录保存上一次执行本函数后的数值
static unsigned int uiKeyTimeCnt1=0; //按键去抖动延时计数器
static unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
static unsigned int uiKeyTimeCnt2=0; //按键去抖动延时计数器
static unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
static unsigned int uiKeyTimeCnt3=0; //按键去抖动延时计数器
static unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
static unsigned int uiKeyTimeCnt4=0; //按键去抖动延时计数器
static unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志
static unsigned int uiKeyTimeCnt12=0; //按键去抖动延时计数器
static unsigned char ucKeyLock12=0; //按键触发后自锁的变量标志
if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock1=0; //按键自锁标志清零
uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt1++; //累加定时中断次数
if(uiKeyTimeCnt1>const_key_time1)
{
uiKeyTimeCnt1=0;
ucKeyLock1=1; //自锁按键置位,避免一直触发
ucKeySec=1; //触发1号键
}
}
if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock2=0; //按键自锁标志清零
uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt2++; //累加定时中断次数
if(uiKeyTimeCnt2>const_key_time2)
{
uiKeyTimeCnt2=0;
ucKeyLock2=1; //自锁按键置位,避免一直触发
ucKeySec=2; //触发2号键
}
}
if(key_sr3==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock3=0; //按键自锁标志清零
uiKeyTimeCnt3=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock3==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt3++; //累加定时中断次数
if(uiKeyTimeCnt3>const_key_time3)
{
uiKeyTimeCnt3=0;
ucKeyLock3=1; //自锁按键置位,避免一直触发
ucKeySec=3; //触发3号键
}
}
if(key_sr4==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock4=0; //按键自锁标志清零
uiKeyTimeCnt4=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock4==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt4++; //累加定时中断次数
if(uiKeyTimeCnt4>const_key_time4)
{
uiKeyTimeCnt4=0;
ucKeyLock4=1; //自锁按键置位,避免一直触发
ucKeySec=4; //触发4号键
}
}
//5号组合键
if(key_sr1==1||key_sr2==1)//IO是高电平，说明两个按键没有全部被按下，这时要及时清零一些标志位
{
ucKeyLock12=0; //按键自锁标志清零
uiKeyTimeCnt12=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock12==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt12++; //累加定时中断次数
if(uiKeyTimeCnt12>const_key_time12)
{
uiKeyTimeCnt12=0;
ucKeyLock12=1; //自锁按键置位,避免一直触发
ucKeySec=5; //触发5号组合键
}
}
}
void key_service() //按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 加按键对应朱兆祺学习板的S1键
if(ucRunFlag==0) //如果系统还没运行
{
uiSetData++; //被设置的计数上限
if(uiSetData>9999) //最大值是9999
{
uiSetData=9999;
}
ucWd1Part1Update=1; //左边4位数码管更新显示
write_eeprom_int(0,uiSetData); //及时保存数据进EEPROM，避免掉电丢失
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
}
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 减按键对应朱兆祺学习板的S5键
if(ucRunFlag==0) //如果系统还没运行
{
uiSetData--;
if(uiSetData>9999) //unsigned int 类型的0减去1会变成65535(0xffff)
{
uiSetData=0; //最小值是0
}
ucWd1Part1Update=1; //左边4位数码管更新显示
write_eeprom_int(0,uiSetData); //及时保存数据进EEPROM，避免掉电丢失
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
}
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3://启动按键对应朱兆祺学习板的S9键
if(ucRunFlag==0&&uiRunCnt<uiSetData) //如果系统还没运行，并且实际运行的次数小于设定的最大次数，则启动
{
ucRunFlag=1;
ucRunStep=1;
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
}
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 4://急停按键对应朱兆祺学习板的S9键
ucRunFlag=0; //急停
ucRunStep=1;
right_to_left(); //从右边返回到左边
down_to_up(); //从下边返回到上边
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 5://清零的组合按键对应朱兆祺学习板的(S1+S5)组合键
if(ucRunFlag==0) //如果系统还没运行
{
uiRunCnt=0; //实际计数清零
ucWd1Part2Update=1; //右边4位数码管更新显示
write_eeprom_int(2,uiRunCnt); //存入uiRunCnt，内部占用2个字节地址
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
}
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
void led_update() //LED更新函数
{
//加了static关键字后，此局部变量不会每次进来函数都被初始化一次，这样可以记录保存上一次执行本函数后的数值
static unsigned char ucLedStatus16_09=0; //代表底层74HC595输出状态的中间变量
static unsigned char ucLedStatus08_01=0; //代表底层74HC595输出状态的中间变量
if(ucLed_update==1)
{
ucLed_update=0; //及时清零，让它产生只更新一次的效果，避免一直更新。
if(ucLed_dr1==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x01;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xfe;
}
if(ucLed_dr2==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x02;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xfd;
}
if(ucLed_dr3==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x04;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xfb;
}
if(ucLed_dr4==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x08;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xf7;
}
if(ucLed_dr5==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x10;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xef;
}
if(ucLed_dr6==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x20;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xdf;
}
if(ucLed_dr7==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x40;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xbf;
}
if(ucLed_dr8==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x80;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0x7f;
}
if(ucLed_dr9==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x01;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xfe;
}
if(ucLed_dr10==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x02;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xfd;
}
if(ucLed_dr11==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x04;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xfb;
}
if(ucLed_dr12==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x08;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xf7;
}
if(ucLed_dr13==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x10;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xef;
}
if(ucLed_dr14==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x20;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xdf;
}
if(ucLed_dr15==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x40;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xbf;
}
if(ucLed_dr16==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x80;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0x7f;
}
hc595_drive(ucLedStatus16_09,ucLedStatus08_01); //74HC595底层驱动函数
}
}
void display_drive()
{
//以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
switch(ucDisplayDriveStep)
{
case 1: //显示第1位
ucDigShowTemp=dig_table[ucDigShow1];
if(ucDigDot1==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfe);
break;
case 2: //显示第2位
ucDigShowTemp=dig_table[ucDigShow2];
if(ucDigDot2==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfd);
break;
case 3: //显示第3位
ucDigShowTemp=dig_table[ucDigShow3];
if(ucDigDot3==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfb);
break;
case 4: //显示第4位
ucDigShowTemp=dig_table[ucDigShow4];
if(ucDigDot4==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xf7);
break;
case 5: //显示第5位
ucDigShowTemp=dig_table[ucDigShow5];
if(ucDigDot5==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xef);
break;
case 6: //显示第6位
ucDigShowTemp=dig_table[ucDigShow6];
if(ucDigDot6==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xdf);
break;
case 7: //显示第7位
ucDigShowTemp=dig_table[ucDigShow7];
if(ucDigDot7==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xbf);
break;
case 8: //显示第8位
ucDigShowTemp=dig_table[ucDigShow8];
if(ucDigDot8==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0x7f);
break;
}
ucDisplayDriveStep++;
if(ucDisplayDriveStep>8) //扫描完8个数码管后，重新从第一个开始扫描
{
ucDisplayDriveStep=1;
}
}
//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
unsigned char i;
unsigned char ucTempData;
dig_hc595_sh_dr=0;
dig_hc595_st_dr=0;
ucTempData=ucDigStatusTemp16_09; //先送高8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)dig_hc595_ds_dr=1;
else dig_hc595_ds_dr=0;
dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
dig_hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
ucTempData=ucDigStatusTemp08_01; //再先送低8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)dig_hc595_ds_dr=1;
else dig_hc595_ds_dr=0;
dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
dig_hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
dig_hc595_st_dr=0; //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
delay_short(1);
dig_hc595_st_dr=1;
delay_short(1);
dig_hc595_sh_dr=0; //拉低，抗干扰就增强
dig_hc595_st_dr=0;
dig_hc595_ds_dr=0;
}
//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
unsigned char i;
unsigned char ucTempData;
hc595_sh_dr=0;
hc595_st_dr=0;
ucTempData=ucLedStatusTemp16_09; //先送高8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)hc595_ds_dr=1;
else hc595_ds_dr=0;
hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
ucTempData=ucLedStatusTemp08_01; //再先送低8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)hc595_ds_dr=1;
else hc595_ds_dr=0;
hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
hc595_st_dr=0; //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
delay_short(1);
hc595_st_dr=1;
delay_short(1);
hc595_sh_dr=0; //拉低，抗干扰就增强
hc595_st_dr=0;
hc595_ds_dr=0;
}
//AT24C02驱动程序
void start24(void) //开始位
{
eeprom_sda_dr_sr=1;
eeprom_scl_dr=1;
delay_short(15);
eeprom_sda_dr_sr=0;
delay_short(15);
eeprom_scl_dr=0;
}
void ack24(void) //确认位时序
{
eeprom_sda_dr_sr=1; //51单片机在读取数据之前要先置一，表示数据输入
eeprom_scl_dr=1;
delay_short(15);
eeprom_scl_dr=0;
delay_short(15);
//在本驱动程序中，我没有对ACK信号进行出错判断，因为我这么多年一直都是这样用也没出现过什么问题。
//有兴趣的朋友可以自己增加出错判断，不一定非要按我的方式去做。
}
void stop24(void) //停止位
{
eeprom_sda_dr_sr=0;
eeprom_scl_dr=1;
delay_short(15);
eeprom_sda_dr_sr=1;
}
unsigned char read24(void) //读取一个字节的时序
{
unsigned char outdata,tempdata;
outdata=0;
eeprom_sda_dr_sr=1; //51单片机的IO口在读取数据之前要先置一，表示数据输入
delay_short(2);
for(tempdata=0;tempdata<8;tempdata++)
{
eeprom_scl_dr=0;
delay_short(2);
eeprom_scl_dr=1;
delay_short(2);
outdata<<=1;
if(eeprom_sda_dr_sr==1)outdata++;
eeprom_sda_dr_sr=1; //51单片机的IO口在读取数据之前要先置一，表示数据输入
delay_short(2);
}
return(outdata);
}
void write24(unsigned char dd) //发送一个字节的时序
{
unsigned char tempdata;
for(tempdata=0;tempdata<8;tempdata++)
{
if(dd>=0x80)eeprom_sda_dr_sr=1;
else eeprom_sda_dr_sr=0;
dd<<=1;
delay_short(2);
eeprom_scl_dr=1;
delay_short(4);
eeprom_scl_dr=0;
}
}
unsigned char read_eeprom(unsigned int address) //从一个地址读取出一个字节数据
{
unsigned char dd,cAddress;
cAddress=address; //把低字节地址传递给一个字节变量。
EA=0; //禁止中断
start24(); //IIC通讯开始
write24(0xA0); //此字节包含读写指令和芯片地址两方面的内容。
//指令为写指令。地址为"000"的信息，此信息由A0,A1,A2的引脚决定
ack24(); //发送应答信号
write24(cAddress); //发送读取的存储地址(范围是0至255)
ack24(); //发送应答信号
start24(); //开始
write24(0xA1); //此字节包含读写指令和芯片地址两方面的内容。
//指令为读指令。地址为"000"的信息，此信息由A0,A1,A2的引脚决定
ack24(); //发送应答信号
dd=read24(); //读取一个字节
ack24(); //发送应答信号
stop24(); //停止
EA=1; //允许中断
delay_timer(2); //一气呵成的定时器延时方式，在延时的时候还可以动态扫描数码管
return(dd);
}
void write_eeprom(unsigned int address,unsigned char dd) //往一个地址存入一个字节数据
{
unsigned char cAddress;
cAddress=address; //把低字节地址传递给一个字节变量。
EA=0; //禁止中断
start24(); //IIC通讯开始
write24(0xA0); //此字节包含读写指令和芯片地址两方面的内容。
//指令为写指令。地址为"000"的信息，此信息由A0,A1,A2的引脚决定
ack24(); //发送应答信号
write24(cAddress); //发送写入的存储地址(范围是0至255)
ack24(); //发送应答信号
write24(dd); //写入存储的数据
ack24(); //发送应答信号
stop24(); //停止
EA=1; //允许中断
delay_timer(4); //一气呵成的定时器延时方式，在延时的时候还可以动态扫描数码管
}
unsigned int read_eeprom_int(unsigned int address) //从一个地址读取出一个int类型的数据
{
unsigned char ucReadDataH;
unsigned char ucReadDataL;
unsigned int uiReadDate;
ucReadDataH=read_eeprom(address); //读取高字节
ucReadDataL=read_eeprom(address+1); //读取低字节
uiReadDate=ucReadDataH; //把两个字节合并成一个int类型数据
uiReadDate=uiReadDate<<8;
uiReadDate=uiReadDate+ucReadDataL;
return uiReadDate;
}
void write_eeprom_int(unsigned int address,unsigned int uiWriteData) //往一个地址存入一个int类型的数据
{
unsigned char ucWriteDataH;
unsigned char ucWriteDataL;
ucWriteDataH=uiWriteData>>8;
ucWriteDataL=uiWriteData;
write_eeprom(address,ucWriteDataH); //存入高字节
write_eeprom(address+1,ucWriteDataL); //存入低字节
}
void T0_time() interrupt 1
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(ucRunTimeFlag==1) //void run函数中的延时计数器开关
{
uiRunTimeCnt++; //延时计数器
}
if(ucDelayTimerFlag==1)//delay_timer函数中的延时计数器开关
{
if(uiDelayTimer>0)
{
uiDelayTimer--; //一气呵成的定时器延时方式的计时器
}
}
key_scan(); //按键扫描函数
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
// beep_dr=1; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
// beep_dr=0; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
display_drive(); //数码管字模的驱动函数
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
TR0=1; //开中断
}
void delay_timer(unsigned int uiDelayTimerTemp)
{
ucDelayTimerFlag=0; //延时计时器关在设置参数前，先关闭计时器
uiDelayTimer=uiDelayTimerTemp;
ucDelayTimerFlag=1; //延时计时器开
while(uiDelayTimer!=0); //一气呵成的定时器方式延时等待
}
void delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself() //第一区初始化单片机
{
/* 注释一：
* 矩阵键盘也可以做独立按键，前提是把某一根公共输出线输出低电平，
* 模拟独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
* 坚鸿51学习板的S1就是本程序中用到的一个独立按键。
*/
key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
led_dr=0; //关闭独立LED灯感谢郑文显捐助本节源代码
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
hc595_drive(0x00,0x00); //关闭所有经过另外两个74HC595驱动的LED灯
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
}
void initial_peripheral() //第二区初始化外围
{
ucDigDot8=0; //小数点全部不显示
ucDigDot7=0;
ucDigDot6=0;
ucDigDot5=0;
ucDigDot4=0;
ucDigDot3=0;
ucDigDot2=0;
ucDigDot1=0;
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
uiSetData=read_eeprom_int(0); //读取uiSetData，内部占用2个字节地址
if(uiSetData>9999) //不在范围内
{
uiSetData=0; //填入一个初始化数据
write_eeprom_int(0,uiSetData); //存入uiSetData，内部占用2个字节地址
}
uiRunCnt=read_eeprom_int(2); //读取uiRunCnt，内部占用2个字节地址
if(uiRunCnt>9999)//不在范围内
{
uiRunCnt=0; //填入一个初始化数据
write_eeprom_int(2,uiRunCnt); //存入uiRunCnt，内部占用2个字节地址
}
}

复制代码

总结陈词：

再次感谢郑文显的无私奉献。前面第38节到第45节是讲串口的，我的串口程序大部分都是通过靠时间来识别每一串数据是否接收完毕，只要第41节内容不是靠时间来判断，而是根据特定关键字来快速识别数据串是否接收完毕，下一节我打算结合我最新的一个项目经验，继续讲一个这方面的例子。欲知详情，请听下回分解----当主机连续不断地发送一串串数据给从机时，从机串口如何快速截取有效数据串。

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

jianhong_wu · 发表于 2014-12-30 12:44:56

第八十八节：电子称连续不断从串口对外发送数据，单片机靠关键字快速截取有效数据串。

开场白：

我前面串口程序大部分都是通过靠时间来识别每一串数据是否接收完毕，有一些串口项目的协议是固定不变的，而且也不需要从机反馈任何应答信号，这类项目只需根据特定关键字来快速识别数据串是否接收完毕即可。比如现在有一种电子称，它的测量范围是0.00克到500.00克，他是靠串口不断对外发送当前重量数据的，每串数据固定长度26个字节，最后两个字节是回车换行符0x0d 0x0a，倒数第9,10,11,12,13,14为有效的ASCII码数字，其中倒数第11位为固定的小数点，其它的数据可以忽略不计。这类串口框架的思路是：根据数据尾是否有0x0d 0x0a来判断数据串是否有效的，一旦发现有此关键字，再判断总的数据长度是否等于或者大于一串数据的固定长度，如果满足，则把相关标志位置位，通知主函数中的串口服务程序进行处理。同时也及时关闭串口中断，避免在处理串口数据期间受到串口数据的中断干扰，等串口服务程序处理完毕再打开。

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

（1）硬件平台：

基于坚鸿51单片机学习板。

（2）实现功能：

波特率是：9600。把当前电子称的重量数据显示在数码管上，在电脑上用串口助手软件来模拟电子称发送以下格式协议的3串数据，它的协议很简单，每串数据固定长度26个字节，最后两个字节是回车换行符0x0d 0x0a，倒数第9,10,11,12,13,14为有效的ASCII码数字，其中倒数第11位为固定的小数点，其它的数据可以忽略不计。

（a）字符是：

ST,GS,+ 0.77 g

转换成16进制是：

20 53 54 2C 47 53 2C 2B 20 20 20 20 20 20 30 2E 37 37 20 2020 20 20 67 0D 0A

数码管显示：0.77

(b)

字符是：

ST,GS,+ 136.39 g

转换成16进制是：

20 53 54 2C 47 53 2C 2B 20 20 20 20 31 33 36 2E 33 39 20 2020 20 20 67 0D 0A

数码管显示：136.39

(c)

字符是：

ST,GS,+ 0.00 g

转换成16进制是：

20 53 54 2C 47 53 2C 2B 20 20 20 20 20 20 30 2E 30 30 20 2020 20 20 67 0D 0A

数码管显示：0.00

（3）源代码讲解如下：

#include "REG52.H"
#define const_rc_size 36 //接收串口中断数据的缓冲区数组大小
#define const_least_size 26 //一串标准数据的大小
void initial_myself();
void initial_peripheral();
void delay_short(unsigned int uiDelayShort);
void delay_long(unsigned int uiDelaylong);
//驱动数码管的74HC595
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);
void display_drive(); //显示数码管字模的驱动函数
void display_service(); //显示的窗口菜单服务程序
//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
void usart_service(void); //串口接收服务程序,在main函数里
void usart_receive(void); //串口接收中断函数
void T0_time(); //定时中断函数
sbit dig_hc595_sh_dr=P2^0; //数码管的74HC595程序
sbit dig_hc595_st_dr=P2^1;
sbit dig_hc595_ds_dr=P2^2;
sbit hc595_sh_dr=P2^3; //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;
sbit hc595_ds_dr=P2^5;
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
sbit led_dr=P3^5; //独立LED灯
//根据原理图得出的共阴数码管字模表
code unsigned char dig_table[]=
{
0x3f, //0 序号0
0x06, //1 序号1
0x5b, //2 序号2
0x4f, //3 序号3
0x66, //4 序号4
0x6d, //5 序号5
0x7d, //6 序号6
0x07, //7 序号7
0x7f, //8 序号8
0x6f, //9 序号9
0x00, //无序号10
0x40, //- 序号11
0x73, //P 序号12
};
unsigned int uiRcregTotal=0; //代表当前缓冲区已经接收了多少个数据
unsigned int uiRcregTotalTemp=0; //代表当前缓冲区已经接收了多少个数据的中间变量
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned char ucReceiveFlag=0; //接收成功标志
unsigned char ucDigShow8; //第8位数码管要显示的内容
unsigned char ucDigShow7; //第7位数码管要显示的内容
unsigned char ucDigShow6; //第6位数码管要显示的内容
unsigned char ucDigShow5; //第5位数码管要显示的内容
unsigned char ucDigShow4; //第4位数码管要显示的内容
unsigned char ucDigShow3; //第3位数码管要显示的内容
unsigned char ucDigShow2; //第2位数码管要显示的内容
unsigned char ucDigShow1; //第1位数码管要显示的内容
unsigned char ucDigDot8; //数码管8的小数点是否显示的标志
unsigned char ucDigDot7; //数码管7的小数点是否显示的标志
unsigned char ucDigDot6; //数码管6的小数点是否显示的标志
unsigned char ucDigDot5; //数码管5的小数点是否显示的标志
unsigned char ucDigDot4; //数码管4的小数点是否显示的标志
unsigned char ucDigDot3; //数码管3的小数点是否显示的标志
unsigned char ucDigDot2; //数码管2的小数点是否显示的标志
unsigned char ucDigDot1; //数码管1的小数点是否显示的标志
unsigned char ucDigShowTemp=0; //临时中间变量
unsigned char ucDisplayDriveStep=1; //动态扫描数码管的步骤变量
unsigned char ucWd1Part1Update=1; //8位数码管更新显示标志
unsigned long ulWeightCurrent=12345; //显示当前实际的重量
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口接收服务程序
display_service(); //显示的窗口菜单服务程序
}
}
/* 注释一：
* 本节内容处理串口数据是根据数据尾是否有0x0d 0x0a来判断数据串是否有效的，一旦发现有此关键字，
* 再判断总的数据长度是否等于或者大于一串数据的固定长度，如果满足，则把相关标志位置位，通知主函数中
* 的串口服务程序进行处理。同时也及时关闭串口中断，避免在处理串口数据期间受到串口数据的中断干扰，
* 等串口服务程序处理完毕再打开。
*/
void usart_receive(void) interrupt 4 //串口接收数据中断函数
{
if(RI==1)
{
RI = 0;
++uiRcregTotal;
ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接收到的数据缓存到接收缓冲区里
if(uiRcregTotal>=2&&ucRcregBuf[uiRcregTotal-2]==0x0d&&ucRcregBuf[uiRcregTotal-1]==0x0a) //一旦发现后缀是0x0d 0x0a关键字的就进去处理判断
{
if(uiRcregTotal<const_least_size) //如果发现总的接收数据小于一串数据的固定长度。则无效，清零重新开始。
{
uiRcregTotal=0;
}
else
{
uiRcregTotalTemp=uiRcregTotal; //把接收到的总数据传递给一个中间变量，在主函数那边处理这个中间变量
ucReceiveFlag=1; //通知主程序接收成功
ES=0; // 禁止接收中断,等主函数处理完接收的数据后再打开串口中断，避免在处理串口数据期间受到串口数据的中断干扰。
}
}
else if(uiRcregTotal>=const_rc_size) //超过缓冲区
{
uiRcregTotal=0;
}
}
else //如果不是串口接收中断，那么必然是串口发送中断，及时清除发送中断的标志，否则一直发送中断
{
TI = 0;
}
}
void usart_service(void) //串口接收服务程序,在main函数里
{
//加了static关键字后，此局部变量不会每次进来函数都初始化一次，这样有可能减少了一点指令消耗的时间。
static unsigned long ulReceiveData10000; //定义成long类型，是为了方便后面换算的乘法运算，让它不会溢出而出错。
static unsigned long ulReceiveData1000;
static unsigned long ulReceiveData100;
static unsigned long ulReceiveData10;
static unsigned long ulReceiveData1;
if(ucReceiveFlag==1) //说明有数据接收成功，进入数据处理分析
{
ulReceiveData10000=0;
ulReceiveData1000=0;
ulReceiveData100=0;
ulReceiveData10=0;
ulReceiveData1=0;
/* 注释二：
* 根据协议，倒数第9,10,11,12,13,14为有效的ASCII码数字，其中倒数第11位为固定的小数点，因此省略不写。
*/
if(ucRcregBuf[uiRcregTotalTemp-9]>=0x30)
{
ulReceiveData1=ucRcregBuf[uiRcregTotalTemp-9]-0x30; //接收到的ASCII码数字减去0x30变成实际数值.
}
if(ucRcregBuf[uiRcregTotalTemp-10]>=0x30)
{
ulReceiveData10=ucRcregBuf[uiRcregTotalTemp-10]-0x30;
ulReceiveData10=ulReceiveData10*10;
}
if(ucRcregBuf[uiRcregTotalTemp-12]>=0x30)
{
ulReceiveData100=ucRcregBuf[uiRcregTotalTemp-12]-0x30;
ulReceiveData100=ulReceiveData100*100;
}
if(ucRcregBuf[uiRcregTotalTemp-13]>=0x30)
{
ulReceiveData1000=ucRcregBuf[uiRcregTotalTemp-13]-0x30;
ulReceiveData1000=ulReceiveData1000*1000;
}
if(ucRcregBuf[uiRcregTotalTemp-14]>=0x30)
{
ulReceiveData10000=ucRcregBuf[uiRcregTotalTemp-14]-0x30;
ulReceiveData10000=ulReceiveData10000*10000;
}
ulWeightCurrent=ulReceiveData10000+ulReceiveData1000+ulReceiveData100+ulReceiveData10+ulReceiveData1;
ucWd1Part1Update=1; //更新显示
uiRcregTotalTemp=0; //清零实际接收到的字节数的中间变量
uiRcregTotal=0; //清零实际接收到的字节数
ucReceiveFlag=0; //清零完成标志
ES = 1; // 允许接收中断
}
}
void display_service() //显示的窗口菜单服务程序
{
//加了static关键字后，此局部变量不会每次进来函数都初始化一次，这样有可能减少了一点指令消耗的时间。
static unsigned char ucTemp5; //中间过渡变量
static unsigned char ucTemp4; //中间过渡变量
static unsigned char ucTemp3; //中间过渡变量
static unsigned char ucTemp2; //中间过渡变量
static unsigned char ucTemp1; //中间过渡变量
if(ucWd1Part1Update==1) //更新显示
{
ucWd1Part1Update=0; //及时清零标志，避免一直进来扫描
//先分解数据用来显示每一位
ucTemp5=ulWeightCurrent%100000/10000;
ucTemp4=ulWeightCurrent%10000/1000;
ucTemp3=ulWeightCurrent%1000/100;
ucTemp2=ulWeightCurrent%100/10;
ucTemp1=ulWeightCurrent%10;
ucDigDot3=1; //显示第3位数码管的小数点，实际数据带2位小数点。
ucDigShow8=10; //没有用到第8位数码管，因此显示无。10代表显示空。
ucDigShow7=10; //没有用到第7位数码管，因此显示无。10代表显示空。
ucDigShow6=10; //没有用到第6位数码管，因此显示无。10代表显示空。
if(ulWeightCurrent<10000)
{
ucDigShow5=10; //如果小于1000，千位显示无
}
else
{
ucDigShow5=ucTemp5; //第5位数码管要显示的内容
}
if(ulWeightCurrent<1000)
{
ucDigShow4=10; //如果小于1000，千位显示无
}
else
{
ucDigShow4=ucTemp4; //第4位数码管要显示的内容
}
//因为带2位小数点，因此最前面3位数据都是有效数，必然要显示，不要判断去0的空显示处理。
ucDigShow3=ucTemp3; //第3位数码管要显示的内容
ucDigShow2=ucTemp2; //第2位数码管要显示的内容
ucDigShow1=ucTemp1; //第1位数码管要显示的内容
}
}
void display_drive()
{
//以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
switch(ucDisplayDriveStep)
{
case 1: //显示第1位
ucDigShowTemp=dig_table[ucDigShow1];
if(ucDigDot1==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfe);
break;
case 2: //显示第2位
ucDigShowTemp=dig_table[ucDigShow2];
if(ucDigDot2==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfd);
break;
case 3: //显示第3位
ucDigShowTemp=dig_table[ucDigShow3];
if(ucDigDot3==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfb);
break;
case 4: //显示第4位
ucDigShowTemp=dig_table[ucDigShow4];
if(ucDigDot4==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xf7);
break;
case 5: //显示第5位
ucDigShowTemp=dig_table[ucDigShow5];
if(ucDigDot5==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xef);
break;
case 6: //显示第6位
ucDigShowTemp=dig_table[ucDigShow6];
if(ucDigDot6==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xdf);
break;
case 7: //显示第7位
ucDigShowTemp=dig_table[ucDigShow7];
if(ucDigDot7==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xbf);
break;
case 8: //显示第8位
ucDigShowTemp=dig_table[ucDigShow8];
if(ucDigDot8==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0x7f);
break;
}
ucDisplayDriveStep++;
if(ucDisplayDriveStep>8) //扫描完8个数码管后，重新从第一个开始扫描
{
ucDisplayDriveStep=1;
}
}
//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
unsigned char i;
unsigned char ucTempData;
dig_hc595_sh_dr=0;
dig_hc595_st_dr=0;
ucTempData=ucDigStatusTemp16_09; //先送高8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)dig_hc595_ds_dr=1;
else dig_hc595_ds_dr=0;
dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
dig_hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
ucTempData=ucDigStatusTemp08_01; //再先送低8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)dig_hc595_ds_dr=1;
else dig_hc595_ds_dr=0;
dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
dig_hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
dig_hc595_st_dr=0; //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
delay_short(1);
dig_hc595_st_dr=1;
delay_short(1);
dig_hc595_sh_dr=0; //拉低，抗干扰就增强
dig_hc595_st_dr=0;
dig_hc595_ds_dr=0;
}
//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
unsigned char i;
unsigned char ucTempData;
hc595_sh_dr=0;
hc595_st_dr=0;
ucTempData=ucLedStatusTemp16_09; //先送高8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)hc595_ds_dr=1;
else hc595_ds_dr=0;
hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
ucTempData=ucLedStatusTemp08_01; //再先送低8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)hc595_ds_dr=1;
else hc595_ds_dr=0;
hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
hc595_st_dr=0; //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
delay_short(1);
hc595_st_dr=1;
delay_short(1);
hc595_sh_dr=0; //拉低，抗干扰就增强
hc595_st_dr=0;
hc595_ds_dr=0;
}
void T0_time() interrupt 1
{
TF0=0; //清除中断标志
TR0=0; //关中断
display_drive(); //数码管字模的驱动函数
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
TR0=1; //开中断
}
void delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself() //第一区初始化单片机
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
led_dr=0; //关闭独立LED灯
hc595_drive(0x00,0x00); //关闭所有经过另外两个74HC595驱动的LED灯
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
//配置串口
SCON=0x50;
TMOD=0X21;
/* 注释三：
* 为了保证串口中断接收的数据不丢失，必须设置IP = 0x10，相当于把串口中断设置为最高优先级，
* 这个时候，串口中断可以打断任何其他的中断服务函数实现嵌套，
*/
IP =0x10; //把串口中断设置为最高优先级，必须的。
TH1=TL1=-(11059200L/12/32/9600); //串口波特率为9600。
TR1=1;
}
void initial_peripheral() //第二区初始化外围
{
ucDigDot8=0; //初始化小数点全部不显示
ucDigDot7=0;
ucDigDot6=0;
ucDigDot5=0;
ucDigDot4=0;
ucDigDot3=0;
ucDigDot2=0;
ucDigDot1=0;
EA=1; //开总中断
ES=1; //允许串口中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：

前面我在第48节里讲过用ds1302做的时钟程序，但是后来很多网友建议，为了方便初学者学习编程思路，我应该用单片机定时器做一个时钟程序。因此，我决定下一节讲这方面的内容。欲知详情，请听下回分解----用单片机内部定时器做一个时钟。

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

jianhong_wu · 发表于 2015-1-4 11:10:55

第八十九节：用单片机内部定时器做一个时钟。

开场白：

很多网友建议，为了方便初学者学习编程思路，我应该用单片机定时器做一个时钟程序供大家参考学习。其实我前面第48节就已经用ds1302做了一个可以显示和更高时间的时钟，这一节只要在第48节的源代码基础上，大的框架不用动，只需要把ds1302产生的时间改成用定时中断产生的时间就可以了，改动的地方非常小。但是为了让时间的精度更高，最后必须跟标准时间进行校验，来修正系统中一秒钟需要多个定时中断的误差，这个误差决定了系统的时间精度，其实这个校验方法我在前面很多章节上跟大家介绍过了：

第一步：在程序代码上先写入1秒钟大概需要200个定时中断。

第二步：把程序烧录进单片机后，上电开始测试，手上同步打开手机里的秒表，当手机的标准时间跑了780秒(这个标准时间跑得越长校验精度越高)，而此时单片机仅仅跑了1632秒。那么最终得出1秒钟需要的定时中断次数是:const_time_1s=(200*1632)/780=418。

第三步：如果发现时钟还是不太准，可以继续返回第一步根据最新1秒钟的时间是418次，多校验几次，来不断调整const_time_1s的数值，直到找到相对精度的时间为止。

本系统仅供学习，精度不可能做得很好，因为影响时间精度的因素还有定时中断的重装值，定时中断里面的代码尽量少，以及晶振等不好控制的因素。所以鸿哥一直不推荐在实际项目中用单片机的内部定时器做实时时钟，因为精度有限。真正想要准确的时钟时间，还是强烈建议大家用外部专用的时钟芯片或者用CPLD/FPGA来做。

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

（1 硬件平台.

基于朱兆祺51单片机学习板。

（2）实现功能：

本程序有2两个窗口。

第1个窗口显示日期。显示格式“年-月-日”。注意中间有“-”分开。

第2个窗口显示时间。显示格式“时分秒”。注意中间没“-”，只有空格分开。

系统上电后，默认显示第2个窗口，实时显示动态的“时分秒”时间。此时按下S13按键不松手就会切换到显示日期的第1个窗口。松手后自动切换回第2个显示动态时间的窗口。

需要更改时间的时候，长按S9按键不松手超过3秒后，系统将进入修改时间的状态，切换到第1个日期窗口，并且显示“年”的两位数码管会闪烁，此时可以按S1或者S5加减按键修改年的参数，修改完年后，继续短按S9按键，会切换到“月”的参数闪烁状态，只要依次不断按下S9按键，就会依次切换年，月，日，时，分，秒的参数闪烁状态，最后修改完秒的参数后，系统会自动把我们修改设置的日期时间一次性更改到定时中断函数内部的时间变量，达到修改日期时间的目的。

S13是电平变化按键，用来切换窗口的，专门用来查看当前日期。按下S13按键时显示日期窗口，松手后返回到显示实时时间的窗口。

[size=10.5000pt]（3）源代码讲解如下：

#include "REG52.H"
#define const_dpy_time_half 200 //数码管闪烁时间的半值
#define const_dpy_time_all 400 //数码管闪烁时间的全值一定要比const_dpy_time_half 大
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_key_time1 20 //按键去抖动延时的时间
#define const_key_time2 20 //按键去抖动延时的时间
#define const_key_time3 20 //按键去抖动延时的时间
#define const_key_time4 20 //按键去抖动延时的时间
#define const_key_time17 1200 //长按超过3秒的时间
/* 注释一：
* const_timer_1s这个是产生多少次定时中断才算1秒钟的标准。这个标准决定了时钟的精度。这个标准最后是需要校验的。
* 那么是如何检验的呢？根据我们前面介绍的校验时间方法：
* 步骤：
* 第一步：在程序代码上先写入1秒钟大概需要200个定时中断。
* 第二步：把程序烧录进单片机后，上电开始测试，手上同步打开手机里的秒表，当手机的标准时间跑了780秒(这个标准时间跑得越长校验精度越高)，
* 而此时单片机仅仅跑了1632秒。那么最终得出1秒钟需要的定时中断次数是:const_time_1s=(200*1632)/780=418。
* 第三步：如果发现时钟还是不太准，可以继续返回第一步根据最新1秒钟的时间是418次，多校验几次。本系统仅供学习，精度不可能做得很好，因为
* 影响时间精度的因素还有定时中断的重装值，定时中断里面的代码尽量少，以及晶振等不好控制的因素。所以鸿哥一直不推荐在实际项目中
* 用单片机的内部定时器做实时时钟，因为精度有限。真正想要准确的时钟时间，还是强烈建议大家用外部专用的时钟芯片或者用CPLD/FPGA来做。
*/
//#define const_timer_1s 200 //第一次假设大概1秒的时间需要200个定时中断
#define const_timer_1s 418 //第二次校验后，最终选定大概1秒的时间需要418个定时中断。如果发现时间还是不准，可以在此基础上继续校验来调整此数据。
void initial_myself(void);
void initial_peripheral(void);
void delay_short(unsigned int uiDelayShort);
void delay_long(unsigned int uiDelaylong);
//驱动数码管的74HC595
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);
void display_drive(void); //显示数码管字模的驱动函数
void display_service(void); //显示的窗口菜单服务程序
//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
void T0_time(void); //定时中断函数
void key_service(void); //按键服务的应用程序
void key_scan(void);//按键扫描函数放在定时中断里
void timer_sampling(void); //定时器采样程序，内部每秒钟采集更新一次
unsigned char get_date(unsigned char ucYearTemp,unsigned char ucMonthTemp); //获取当前月份的最大天数
//日调整每个月份的日最大取值不同，有的最大28日，有的最大29日，有的最大30，有的最大31
unsigned char date_adjust(unsigned char ucYearTemp,unsigned char ucMonthTemp,unsigned char ucDateTemp); //日调整
sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
sbit dig_hc595_sh_dr=P2^0; //数码管的74HC595程序
sbit dig_hc595_st_dr=P2^1;
sbit dig_hc595_ds_dr=P2^2;
sbit hc595_sh_dr=P2^3; //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;
sbit hc595_ds_dr=P2^5;
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
unsigned int uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
unsigned int uiKeyTimeCnt3=0; //按键去抖动延时计数器
unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
unsigned int uiKey4Cnt1=0; //在软件滤波中，用到的变量
unsigned int uiKey4Cnt2=0;
unsigned char ucKey4Sr=1; //实时反映按键的电平状态
unsigned char ucKey4SrRecord=0; //记录上一次按键的电平状态
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucVoiceLock=0; //蜂鸣器鸣叫的原子锁
unsigned char ucDigShow8; //第8位数码管要显示的内容
unsigned char ucDigShow7; //第7位数码管要显示的内容
unsigned char ucDigShow6; //第6位数码管要显示的内容
unsigned char ucDigShow5; //第5位数码管要显示的内容
unsigned char ucDigShow4; //第4位数码管要显示的内容
unsigned char ucDigShow3; //第3位数码管要显示的内容
unsigned char ucDigShow2; //第2位数码管要显示的内容
unsigned char ucDigShow1; //第1位数码管要显示的内容
unsigned char ucDigDot8; //数码管8的小数点是否显示的标志
unsigned char ucDigDot7; //数码管7的小数点是否显示的标志
unsigned char ucDigDot6; //数码管6的小数点是否显示的标志
unsigned char ucDigDot5; //数码管5的小数点是否显示的标志
unsigned char ucDigDot4; //数码管4的小数点是否显示的标志
unsigned char ucDigDot3; //数码管3的小数点是否显示的标志
unsigned char ucDigDot2; //数码管2的小数点是否显示的标志
unsigned char ucDigDot1; //数码管1的小数点是否显示的标志
unsigned char ucDigShowTemp=0; //临时中间变量
unsigned char ucDisplayDriveStep=1; //动态扫描数码管的步骤变量
unsigned char ucWd=2; //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
unsigned char ucPart=0;//本程序的核心变量，局部显示变量。类似于二级菜单的变量。代表显示不同的局部。
unsigned char ucWd1Update=0; //窗口1更新显示标志
unsigned char ucWd2Update=1; //窗口2更新显示标志
unsigned char ucWd1Part1Update=0; //在窗口1中，局部1的更新显示标志
unsigned char ucWd1Part2Update=0; //在窗口1中，局部2的更新显示标志
unsigned char ucWd1Part3Update=0; //在窗口1中，局部3的更新显示标志
unsigned char ucWd2Part1Update=0; //在窗口2中，局部1的更新显示标志
unsigned char ucWd2Part2Update=0; //在窗口2中，局部2的更新显示标志
unsigned char ucWd2Part3Update=0; //在窗口2中，局部3的更新显示标志
unsigned char ucYear=15; //用来显示和设置的时间变量
unsigned char ucMonth=1;
unsigned char ucDate=1;
unsigned char ucHour=12;
unsigned char ucMinute=0;
unsigned char ucSecond=0;
unsigned int uiTimerCnt=0; //计时器的时基
unsigned char ucTimerYear=15; //在定时器内部时基产生的时间变量
unsigned char ucTimerMonth=1;
unsigned char ucTimerDate=1;
unsigned char ucTimerHour=12;
unsigned char ucTimerMinute=0;
unsigned char ucTimerSecond=0;
unsigned char ucTimerDateMax=31; //当前月份的最大天数
unsigned char ucTimerUpdate=0; //定时器每1秒钟所产生的标志
unsigned char ucTimerStart=1; //是否打开定时器内部时间的标志，在本程序相当于原子锁的作用。
unsigned char ucTemp1=0; //中间过渡变量
unsigned char ucTemp2=0; //中间过渡变量
unsigned char ucTemp4=0; //中间过渡变量
unsigned char ucTemp5=0; //中间过渡变量
unsigned char ucTemp7=0; //中间过渡变量
unsigned char ucTemp8=0; //中间过渡变量
unsigned char ucDelayTimerLock=0; //原子锁
unsigned int uiDelayTimer=0;
unsigned char ucDpyTimeLock=0; //原子锁
unsigned int uiDpyTimeCnt=0; //数码管的闪烁计时器,放在定时中断里不断累加
//根据原理图得出的共阴数码管字模表
code unsigned char dig_table[]=
{
0x3f, //0 序号0
0x06, //1 序号1
0x5b, //2 序号2
0x4f, //3 序号3
0x66, //4 序号4
0x6d, //5 序号5
0x7d, //6 序号6
0x07, //7 序号7
0x7f, //8 序号8
0x6f, //9 序号9
0x00, //无序号10
0x40, //- 序号11
0x73, //P 序号12
};
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
key_service(); //按键服务的应用程序
timer_sampling(); //定时器采样程序，内部每秒钟采集更新一次
display_service(); //显示的窗口菜单服务程序
}
}
/* 注释二：
* 系统不用时时刻刻采集定时器的内部数据，每隔1秒钟的时间更新采集一次就可以了。
* 这个1秒钟的时间是根据定时器内部ucTimerUpdate变量来判断。
*/
void timer_sampling(void) //采样定时器的程序，内部每秒钟采集更新一次
{
if(ucPart==0) //当系统不是处于设置日期和时间的情况下
{
if(ucTimerUpdate==1) //每隔1秒钟时间就更新采集一次定时器的时间数据
{
ucTimerUpdate=0; //及时清零，避免一直更新。
ucYear=ucTimerYear; //读取定时器内部的年
ucMonth=ucTimerMonth; //读取定时器内部的月
ucDate=ucTimerDate; //读取定时器内部的日
ucHour=ucTimerHour; //读取定时器内部的时
ucMinute=ucTimerMinute; //读取定时器内部的分
ucSecond=ucTimerSecond; //读取定时器内部的秒
ucWd2Update=1; //窗口2更新显示时间
}
}
}
/* 注释三：
* 根据年份和月份来获取当前这个月的最大天数。每个月份的天数最大取值不同，有的最大28日，
* 有的最大29日，有的最大30，有的最大31。
*/
unsigned char get_date(unsigned char ucYearTemp,unsigned char ucMonthTemp)
{
unsigned char ucDayResult;
unsigned int uiYearTemp;
unsigned int uiYearYu;
ucDayResult=31; //默认最大是31天，以下根据不同的年份和月份来决定是否需要修正这个值
switch(ucMonthTemp) //根据不同的月份来获取当前月份天数的最大值
{
case 2: //二月份要计算是否是闰年
uiYearTemp=2000+ucYearTemp;
uiYearYu=uiYearTemp%4;
if(uiYearYu==0) //闰年
{
ucDayResult=29;
}
else
{
ucDayResult=28;
}
break;
case 4:
case 6:
case 9:
case 11:
ucDayResult=30;
break;
}
return ucDayResult;
}
//日调整每个月份的日最大取值不同，有的最大28日，有的最大29日，有的最大30，有的最大31
unsigned char date_adjust(unsigned char ucYearTemp,unsigned char ucMonthTemp,unsigned char ucDateTemp) //日调整
{
unsigned char ucDayResult;
unsigned int uiYearTemp;
unsigned int uiYearYu;
ucDayResult=ucDateTemp;
switch(ucMonthTemp) //根据不同的月份来修正不同的日最大值
{
case 2: //二月份要计算是否是闰年
uiYearTemp=2000+ucYearTemp;
uiYearYu=uiYearTemp%4;
if(uiYearYu==0) //闰年
{
if(ucDayResult>29)
{
ucDayResult=29;
}
}
else
{
if(ucDayResult>28)
{
ucDayResult=28;
}
}
break;
case 4:
case 6:
case 9:
case 11:
if(ucDayResult>30)
{
ucDayResult=30;
}
break;
}
return ucDayResult;
}
void display_service(void) //显示的窗口菜单服务程序
{
switch(ucWd) //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
{
case 1: //显示日期窗口的数据数据格式 NN-YY-RR 年-月-日
if(ucWd1Update==1) //窗口1要全部更新显示
{
ucWd1Update=0; //及时清零标志，避免一直进来扫描
ucDigShow6=11; //显示一杠"-"
ucDigShow3=11; //显示一杠"-"
ucWd1Part1Update=1; //局部年更新显示
ucWd1Part2Update=1; //局部月更新显示
ucWd1Part3Update=1; //局部日更新显示
}
if(ucWd1Part1Update==1)//局部年更新显示
{
ucWd1Part1Update=0;
ucTemp8=ucYear/10; //年
ucTemp7=ucYear%10;
ucDigShow8=ucTemp8; //数码管显示实际内容
ucDigShow7=ucTemp7;
}
if(ucWd1Part2Update==1)//局部月更新显示
{
ucWd1Part2Update=0;
ucTemp5=ucMonth/10; //月
ucTemp4=ucMonth%10;
ucDigShow5=ucTemp5; //数码管显示实际内容
ucDigShow4=ucTemp4;
}
if(ucWd1Part3Update==1) //局部日更新显示
{
ucWd1Part3Update=0;
ucTemp2=ucDate/10; //日
ucTemp1=ucDate%10;
ucDigShow2=ucTemp2; //数码管显示实际内容
ucDigShow1=ucTemp1;
}
//数码管闪烁
switch(ucPart) //相当于二级菜单，根据局部变量的值，使对应的参数产生闪烁的动态效果。
{
case 0: //都不闪烁
break;
case 1: //年参数闪烁
if(uiDpyTimeCnt==const_dpy_time_half)
{
ucDigShow8=ucTemp8; //数码管显示实际内容
ucDigShow7=ucTemp7;
}
else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
{
ucDpyTimeLock=1; //原子锁加锁
uiDpyTimeCnt=0; //及时把闪烁记时器清零
ucDpyTimeLock=0; //原子锁解锁
ucDigShow8=10; //数码管显示空，什么都不显示
ucDigShow7=10;
}
break;
case 2: //月参数闪烁
if(uiDpyTimeCnt==const_dpy_time_half)
{
ucDigShow5=ucTemp5; //数码管显示实际内容
ucDigShow4=ucTemp4;
}
else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
{
ucDpyTimeLock=1; //原子锁加锁
uiDpyTimeCnt=0; //及时把闪烁记时器清零
ucDpyTimeLock=0; //原子锁解锁
ucDigShow5=10; //数码管显示空，什么都不显示
ucDigShow4=10;
}
break;
case 3: //日参数闪烁
if(uiDpyTimeCnt==const_dpy_time_half)
{
ucDigShow2=ucTemp2; //数码管显示实际内容
ucDigShow1=ucTemp1;
}
else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
{
ucDpyTimeLock=1; //原子锁加锁
uiDpyTimeCnt=0; //及时把闪烁记时器清零
ucDpyTimeLock=0; //原子锁解锁
ucDigShow2=10; //数码管显示空，什么都不显示
ucDigShow1=10;
}
break;
}
break;
case 2: //显示时间窗口的数据数据格式 SS FF MM 时分秒
if(ucWd2Update==1) //窗口2要全部更新显示
{
ucWd2Update=0; //及时清零标志，避免一直进来扫描
ucDigShow6=10; //显示空
ucDigShow3=10; //显示空
ucWd2Part3Update=1; //局部时更新显示
ucWd2Part2Update=1; //局部分更新显示
ucWd2Part1Update=1; //局部秒更新显示
}
if(ucWd2Part1Update==1)//局部时更新显示
{
ucWd2Part1Update=0;
ucTemp8=ucHour/10; //时
ucTemp7=ucHour%10;
ucDigShow8=ucTemp8; //数码管显示实际内容
ucDigShow7=ucTemp7;
}
if(ucWd2Part2Update==1)//局部分更新显示
{
ucWd2Part2Update=0;
ucTemp5=ucMinute/10; //分
ucTemp4=ucMinute%10;
ucDigShow5=ucTemp5; //数码管显示实际内容
ucDigShow4=ucTemp4;
}
if(ucWd2Part3Update==1) //局部秒更新显示
{
ucWd2Part3Update=0;
ucTemp2=ucSecond/10; //秒
ucTemp1=ucSecond%10;
ucDigShow2=ucTemp2; //数码管显示实际内容
ucDigShow1=ucTemp1;
}
//数码管闪烁
switch(ucPart) //相当于二级菜单，根据局部变量的值，使对应的参数产生闪烁的动态效果。
{
case 0: //都不闪烁
break;
case 1: //时参数闪烁
if(uiDpyTimeCnt==const_dpy_time_half)
{
ucDigShow8=ucTemp8; //数码管显示实际内容
ucDigShow7=ucTemp7;
}
else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
{
ucDpyTimeLock=1; //原子锁加锁
uiDpyTimeCnt=0; //及时把闪烁记时器清零
ucDpyTimeLock=0; //原子锁解锁
ucDigShow8=10; //数码管显示空，什么都不显示
ucDigShow7=10;
}
break;
case 2: //分参数闪烁
if(uiDpyTimeCnt==const_dpy_time_half)
{
ucDigShow5=ucTemp5; //数码管显示实际内容
ucDigShow4=ucTemp4;
}
else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
{
ucDpyTimeLock=1; //原子锁加锁
uiDpyTimeCnt=0; //及时把闪烁记时器清零
ucDpyTimeLock=0; //原子锁解锁
ucDigShow5=10; //数码管显示空，什么都不显示
ucDigShow4=10;
}
break;
case 3: //秒参数闪烁
if(uiDpyTimeCnt==const_dpy_time_half)
{
ucDigShow2=ucTemp2; //数码管显示实际内容
ucDigShow1=ucTemp1;
}
else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
{
ucDpyTimeLock=1; //原子锁加锁
uiDpyTimeCnt=0; //及时把闪烁记时器清零
ucDpyTimeLock=0; //原子锁解锁
ucDigShow2=10; //数码管显示空，什么都不显示
ucDigShow1=10;
}
break;
}
break;
}
}
void key_scan(void)//按键扫描函数放在定时中断里
{
if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock1=0; //按键自锁标志清零
uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt1++; //累加定时中断次数
if(uiKeyTimeCnt1>const_key_time1)
{
uiKeyTimeCnt1=0;
ucKeyLock1=1; //自锁按键置位,避免一直触发
ucKeySec=1; //触发1号键
}
}
if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock2=0; //按键自锁标志清零
uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt2++; //累加定时中断次数
if(uiKeyTimeCnt2>const_key_time2)
{
uiKeyTimeCnt2=0;
ucKeyLock2=1; //自锁按键置位,避免一直触发
ucKeySec=2; //触发2号键
}
}
/* 注释四：
* 注意，此处把一个按键的短按和长按的功能都实现了。
*/
if(key_sr3==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock3=0; //按键自锁标志清零
uiKeyTimeCnt3=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock3==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt3++; //累加定时中断次数
if(uiKeyTimeCnt3>const_key_time3)
{
uiKeyTimeCnt3=0;
ucKeyLock3=1; //自锁按键置位,避免一直触发
ucKeySec=3; //短按触发3号键
}
}
else if(uiKeyTimeCnt3<const_key_time17) //长按3秒
{
uiKeyTimeCnt3++; //累加定时中断次数
if(uiKeyTimeCnt3==const_key_time17) //等于3秒钟，触发17号长按按键
{
ucKeySec=17; //长按3秒触发17号键
}
}
/* 注释五：
* 注意，此处是电平按键的滤波抗干扰处理
*/
if(key_sr4==1) //对应朱兆祺学习板的S13键
{
uiKey4Cnt1=0; //在软件滤波中，非常关键的语句！！！类似按键去抖动程序的及时清零
uiKey4Cnt2++; //类似独立按键去抖动的软件抗干扰处理
if(uiKey4Cnt2>const_key_time4)
{
uiKey4Cnt2=0;
ucKey4Sr=1; //实时反映按键松手时的电平状态
}
}
else
{
uiKey4Cnt2=0; //在软件滤波中，非常关键的语句！！！类似按键去抖动程序的及时清零
uiKey4Cnt1++;
if(uiKey4Cnt1>const_key_time4)
{
uiKey4Cnt1=0;
ucKey4Sr=0; //实时反映按键按下时的电平状态
}
}
}
void key_service(void) //按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 加按键对应朱兆祺学习板的S1键
switch(ucWd) //在不同的窗口下，设置不同的参数
{
case 1:
switch(ucPart) //在不同的局部变量下，相当于二级菜单
{
case 1: //年
ucYear++;
if(ucYear>99)
{
ucYear=99;
}
ucWd1Part1Update=1; //更新显示
break;
case 2: //月
ucMonth++;
if(ucMonth>12)
{
ucMonth=12;
}
ucWd1Part2Update=1; //更新显示
break;
case 3: //日
ucDate++;
if(ucDate>31)
{
ucDate=31;
}
ucWd1Part3Update=1; //更新显示
break;
}
break;
case 2:
switch(ucPart) //在不同的局部变量下，相当于二级菜单
{
case 1: //时
ucHour++;
if(ucHour>23)
{
ucHour=23;
}
ucWd2Part1Update=1; //更新显示
break;
case 2: //分
ucMinute++;
if(ucMinute>59)
{
ucMinute=59;
}
ucWd2Part2Update=1; //更新显示
break;
case 3: //秒
ucSecond++;
if(ucSecond>59)
{
ucSecond=59;
}
ucWd2Part3Update=1; //更新显示
break;
}
break;
}
ucVoiceLock=1; //原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucVoiceLock=0; //原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 减按键对应朱兆祺学习板的S5键
switch(ucWd) //在不同的窗口下，设置不同的参数
{
case 1:
switch(ucPart) //在不同的局部变量下，相当于二级菜单
{
case 1: //年
ucYear--;
if(ucYear>99)
{
ucYear=0;
}
ucWd1Part1Update=1; //更新显示
break;
case 2: //月
ucMonth--;
if(ucMonth<1)
{
ucMonth=1;
}
ucWd1Part2Update=1; //更新显示
break;
case 3: //日
ucDate--;
if(ucDate<1)
{
ucDate=1;
}
ucWd1Part3Update=1; //更新显示
break;
}
break;
case 2:
switch(ucPart) //在不同的局部变量下，相当于二级菜单
{
case 1: //时
ucHour--;
if(ucHour>23)
{
ucHour=0;
}
ucWd2Part1Update=1; //更新显示
break;
case 2: //分
ucMinute--;
if(ucMinute>59)
{
ucMinute=0;
}
ucWd2Part2Update=1; //更新显示
break;
case 3: //秒
ucSecond--;
if(ucSecond>59)
{
ucSecond=0;
}
ucWd2Part3Update=1; //更新显示
break;
}
break;
}
ucVoiceLock=1; //原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucVoiceLock=0; //原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3://短按设置按键对应朱兆祺学习板的S9键
switch(ucWd) //在不同的窗口下，设置不同的参数
{
case 1:
ucPart++;
if(ucPart>3)
{
ucPart=1;
ucWd=2; //切换到第二个窗口，设置时分秒
ucWd2Update=1; //窗口2更新显示
}
ucWd1Update=1; //窗口1更新显示
break;
case 2:
if(ucPart>0) //在窗口2的时候，要第一次激活设置时间，必须是长按3秒才可以，这里短按激活不了第一次
{
ucPart++;
if(ucPart>3) //设置时间结束
{
ucPart=0;
/* 注释六：
* 每个月份的天数最大值是不一样的，在写入ds1302时钟芯片内部数据前，应该做一次调整。
* 有的月份最大28天，有的月份最大29天，有的月份最大30天，有的月份最大31天，
*/
ucDate=date_adjust(ucYear,ucMonth,ucDate); //日调整避免日的数值在某个月份超范围
ucTimerStart=0; //关闭定时器的时间。在更改定时器内部时间数据时，先关闭它，相当于原子锁的加锁作用。
ucTimerYear=ucYear; //把设置和显示的数据更改到定时器内部的时间变量
ucTimerMonth=ucMonth;
ucTimerDate=ucDate;
ucTimerHour=ucHour;
ucTimerMinute=ucMinute;
ucTimerSecond=ucSecond;
ucTimerStart=1; //打开定时器的时间。在更改定时器内部时间数据后，再打开它，相当于原子锁的解锁作用。
}
ucWd2Update=1; //窗口2更新显示
}
break;
}
ucVoiceLock=1; //原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucVoiceLock=0; //原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 17://长按3秒设置按键对应朱兆祺学习板的S9键
switch(ucWd) //在不同的窗口下，设置不同的参数
{
case 2:
if(ucPart==0) //处于非设置时间的状态下，要第一次激活设置时间，必须是长按3秒才可以
{
ucWd=1;
ucPart=1; //进入到设置日期的状态下
ucWd1Update=1; //窗口1更新显示
}
break;
}
ucVoiceLock=1; //原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucVoiceLock=0; //原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
/* 注释七：
* 注意，此处就是第一次出现的电平按键程序，跟以往的下降沿按键不一样。
* ucKey4Sr是经过软件滤波处理后，直接反应IO口电平状态的变量.当电平发生
* 变化时，就会切换到不同的显示界面，这里多用了一个ucKey4SrRecord变量
* 记录上一次的电平状态，是为了避免一直刷新显示。
*/
if(ucKey4Sr!=ucKey4SrRecord) //说明S13的切换按键电平状态发生变化
{
ucKey4SrRecord=ucKey4Sr;//及时记录当前最新的按键电平状态避免一直进来触发
if(ucKey4Sr==1) //松手后切换到显示时间的窗口
{
ucWd=2; //显示时分秒的窗口
ucPart=0; //进入到非设置时间的状态下
ucWd2Update=1; //窗口2更新显示
}
else //按下去切换到显示日期的窗口
{
ucWd=1; //显示年月日的窗口
ucPart=0; //进入到非设置时间的状态下
ucWd1Update=1; //窗口1更新显示
}
}
}
void display_drive(void)
{
//以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
switch(ucDisplayDriveStep)
{
case 1: //显示第1位
ucDigShowTemp=dig_table[ucDigShow1];
if(ucDigDot1==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfe);
break;
case 2: //显示第2位
ucDigShowTemp=dig_table[ucDigShow2];
if(ucDigDot2==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfd);
break;
case 3: //显示第3位
ucDigShowTemp=dig_table[ucDigShow3];
if(ucDigDot3==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfb);
break;
case 4: //显示第4位
ucDigShowTemp=dig_table[ucDigShow4];
if(ucDigDot4==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xf7);
break;
case 5: //显示第5位
ucDigShowTemp=dig_table[ucDigShow5];
if(ucDigDot5==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xef);
break;
case 6: //显示第6位
ucDigShowTemp=dig_table[ucDigShow6];
if(ucDigDot6==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xdf);
break;
case 7: //显示第7位
ucDigShowTemp=dig_table[ucDigShow7];
if(ucDigDot7==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xbf);
break;
case 8: //显示第8位
ucDigShowTemp=dig_table[ucDigShow8];
if(ucDigDot8==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0x7f);
break;
}
ucDisplayDriveStep++;
if(ucDisplayDriveStep>8) //扫描完8个数码管后，重新从第一个开始扫描
{
ucDisplayDriveStep=1;
}
}
//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
unsigned char i;
unsigned char ucTempData;
dig_hc595_sh_dr=0;
dig_hc595_st_dr=0;
ucTempData=ucDigStatusTemp16_09; //先送高8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)dig_hc595_ds_dr=1;
else dig_hc595_ds_dr=0;
dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
dig_hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
ucTempData=ucDigStatusTemp08_01; //再先送低8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)dig_hc595_ds_dr=1;
else dig_hc595_ds_dr=0;
dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
dig_hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
dig_hc595_st_dr=0; //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
delay_short(1);
dig_hc595_st_dr=1;
delay_short(1);
dig_hc595_sh_dr=0; //拉低，抗干扰就增强
dig_hc595_st_dr=0;
dig_hc595_ds_dr=0;
}
//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
unsigned char i;
unsigned char ucTempData;
hc595_sh_dr=0;
hc595_st_dr=0;
ucTempData=ucLedStatusTemp16_09; //先送高8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)hc595_ds_dr=1;
else hc595_ds_dr=0;
hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
ucTempData=ucLedStatusTemp08_01; //再先送低8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)hc595_ds_dr=1;
else hc595_ds_dr=0;
hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
hc595_st_dr=0; //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
delay_short(1);
hc595_st_dr=1;
delay_short(1);
hc595_sh_dr=0; //拉低，抗干扰就增强
hc595_st_dr=0;
hc595_ds_dr=0;
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
/* 注释八：
* 以下是本节内容的核心程序，是定时器内部产生的时间。const_timer_1s这个是产生多少次定时中断才
* 算1秒钟的标准。这个标准决定了时钟的精度。这个标准最后是需要校验的。
*/
if(ucTimerStart==1) //定时器的时间已经打开
{
uiTimerCnt++; //产生1秒钟的时基
if(uiTimerCnt>=const_timer_1s) //一秒钟的时间到。这个const_timer_1s具体数值最后需要校验得出。
{
uiTimerCnt=0; //清零为产生下一个1秒钟准备
ucTimerUpdate=1; //定时器每1秒钟所产生的标志，通知主函数及时更新采集时间数据
ucTimerSecond++; //秒时间累加1
if(ucTimerSecond>=60)
{
ucTimerSecond=0;
ucTimerMinute++; //分时间累加1
if(ucTimerMinute>=60)
{
ucTimerMinute=0;
ucTimerHour++; //小时的时间累加1，为了避免if的嵌套过多，把小时的判断放到外面两层的if来继续判断
}
}
if(ucTimerHour>=24)
{
ucTimerHour=0;
ucTimerDate++; //天时间累加1
ucTimerDateMax=get_date(ucTimerYear,ucTimerMonth); //根据年和月获取当前月份的最大天数
if(ucTimerDate>ucTimerDateMax) //
{
ucTimerDate=1; //每个月都是从1号开始
ucTimerMonth++; //月时间累加1
if(ucTimerMonth>12)
{
ucTimerMonth=1; //每年从1月份开始
ucTimerYear++; //年时间累加1
if(ucTimerYear>99) //本系统的最高有效年份是2099年
{
ucTimerYear=99;
}
}
}
}
}
}
if(ucVoiceLock==0) //原子锁判断
{
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
}
if(ucDpyTimeLock==0) //原子锁判断
{
uiDpyTimeCnt++; //数码管的闪烁计时器
}
key_scan(); //按键扫描函数
display_drive(); //数码管字模的驱动函数
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
TR0=1; //开中断
}
void delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself(void) //第一区初始化单片机
{
key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
hc595_drive(0x00,0x00); //关闭所有经过另外两个74HC595驱动的LED灯
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
}
void initial_peripheral(void) //第二区初始化外围
{
ucDigDot8=0; //小数点全部不显示
ucDigDot7=0;
ucDigDot6=0;
ucDigDot5=0;
ucDigDot4=0;
ucDigDot3=0;
ucDigDot2=0;
ucDigDot1=0;
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：

任何一个电子产品在投入生产的时候都要考虑到生产的测试，朱兆祺51单片机学习板在生产加工后也一样要进行测试。那么这个测试的程序如何能够做到快速，全面，易用这三个要求呢？欲知详情，请听下回分解-----生产朱兆祺51学习板的从机自检测试程序源代码.。

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

jianhong_wu · 发表于 2015-1-9 22:09:53

wysh_2004 发表于 2015-1-9 17:13
鸿哥的单片机程序框架有点类似于PLC的顺序程序控制思想！

有可能。

jianhong_wu · 发表于 2015-1-14 22:52:36

又一个暑假发表于 2015-1-13 20:08
年底大家都比较忙，鸿哥的巨作也放慢了脚步

帐号		自动登录	找回密码
密码			立即注册

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