好人啊。。。。。。
这种基于状态机的菜单，好多SWITCH CASE ,我之前的写的代码就是这样。感觉好难维护。
100W收购论坛，这个也太便宜了吧，经营这么多年了，管理的还是相当的不错的~~~{:lol:}
阿文 发表于 2014-10-27 17:33
这种基于状态机的菜单，好多SWITCH CASE ,我之前的写的代码就是这样。感觉好难维护。 ...
其实也不难维护。我感觉这样写很清晰。
顶起！！！
本帖最后由 吴坚鸿 于 2014-10-28 14:52 编辑
第七十八节：在多个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。
开场白：
上一节讲了1个窗口下如何设置参数的菜单程序，这一节多增加1个窗口变成2个窗口，看看它们两个窗口之间是如何通过按键程序进行切换的。继续巩固上一节教给大家的两个知识点：
第一个知识点：我在前面讲数码管显示的时候就提出了一个 “一二级菜单显示理论”：凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。把每一个窗口的内容分为两种类型，一种类型是那些不用经常刷新显示的内容，只有在切换窗口的时候才需要更新的，这种内容放在整屏更新显示的括号里，比如清屏操作等内容。另外一种是那些经常需要刷新显示的内容，这种内容放在局部更新显示的括号里。
第二个知识点：按键如何跟液晶屏显示有机的结合起来？只要遵循鸿哥总结出来的一个规律“在不同的窗口下，根据不同的局部变量来操作不同的参数”，这样再复杂的人机交互程序都会显得很简单清晰。
具体内容，请看源代码讲解。
（1）硬件平台：基于朱兆祺51单片机学习板。加按键对应S1键，减按键对应S5键，切换“光标”移动按键对应S9键，设置参数按键对应S13键。
（2）实现功能：
通过按键设置8个不同的参数。
有2个窗口。每个窗口显示4个参数。每个参数的范围是从0到99。
有4个按键：
（a） 一个是设置参数S13按键，按下此按键，液晶屏的第1个窗口第一行会出现反显的光标，表示进入设置参数模式，再次按下此按键，反显光标会消失，并且强行切换到第1个窗口，表示退出设置参数模式。
（b） 一个是移动光标S9按键，在进入设置参数的模式下，依次按下此按键，液晶屏上的光标会从上往下移动，表示选中不同的参数。当移动到每个窗口最下边那一行时，再按下此按键会进行切换窗口的操作。
（c） 一个是减数S5按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐减小。
（d） 一个是加数S1按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐加大。
（3）源代码讲解如下：
#include "REG52.H"
/* 注释一：
* 本程序用到的变量比较多，所以在keil编译模式里要设置一下编译模式memory model，
* 否则编译会出错.右键单击Target选择“Options for Target'Target1'”就会出来一个框
* 在memory model中选择compact:variables in pdata 就可以了。
*/
#define const_voice_short40 //蜂鸣器短叫的持续时间
#define const_key_time120 //按键去抖动延时的时间
#define const_key_time220 //按键去抖动延时的时间
#define const_key_time320 //按键去抖动延时的时间
#define const_key_time420 //按键去抖动延时的时间
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口
sbitLCDCS_dr= P1^6;//片选线
sbitLCDSID_dr = P1^7;//串行数据线
sbitLCDCLK_dr = P3^2;//串行时钟线
sbitLCDRST_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 charucBitNumber); //把一位数字转换成字模首地址的函数
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显示的内容
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_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_san[]=
{
/*--文字:三--*/
/*--宋体12;此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x00,0x00,0x7F,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0xF8,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0xFE,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_si[]=
{
/*--文字:四--*/
/*--宋体12;此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x7F,0xFC,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,
0x48,0x84,0x48,0x7C,0x50,0x04,0x60,0x04,0x40,0x04,0x7F,0xFC,0x40,0x04,0x00,0x00,
};
code unsigned char Hz1616_chuang[]=
{
/*--文字:窗--*/
/*--宋体12;此字体下对应的点阵为：宽x高=16x16 --*/
0x01,0x00,0x00,0x80,0x7F,0xFE,0x40,0x22,0x09,0x18,0x12,0x06,0x7F,0xF8,0x11,0x08,
0x13,0xE8,0x14,0x48,0x1A,0x88,0x11,0x08,0x12,0x88,0x14,0x08,0x1F,0xF8,0x10,0x08,
};
code unsigned char Hz1616_kou[]=
{
/*--文字:口--*/
/*--宋体12;此字体下对应的点阵为：宽x高=16x16 --*/
0x00,0x00,0x00,0x00,0x3F,0xF8,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,
0x20,0x08,0x20,0x08,0x20,0x08,0x3F,0xF8,0x20,0x08,0x20,0x08,0x00,0x00,0x00,0x00,
};
code unsigned char Hz1616_hang[]=
{
/*--文字:行--*/
/*--宋体12;此字体下对应的点阵为：宽x高=16x16 --*/
0x08,0x00,0x1C,0x00,0x31,0xFC,0x40,0x00,0x88,0x00,0x0C,0x00,0x1B,0xFE,0x30,0x20,
0x50,0x20,0x90,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0xA0,0x10,0x40,
};
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 intuiVoiceCnt=0;//蜂鸣器鸣叫的持续时间计数器
unsigned char ucWd=1; //窗口变量
unsigned char ucPart=0; //局部变量 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的第3行局部更新显示变量1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part4Update=0; //窗口1的第4行局部更新显示变量1代表更新显示，响应函数内部会清零
unsigned char ucWd2Update=0; //窗口2的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd2Part1Update=0; //窗口2的第1行局部更新显示变量1代表更新显示，响应函数内部会清零
unsigned char ucWd2Part2Update=0; //窗口2的第2行局部更新显示变量1代表更新显示，响应函数内部会清零
unsigned char ucWd2Part3Update=0; //窗口2的第3行局部更新显示变量1代表更新显示，响应函数内部会清零
unsigned char ucWd2Part4Update=0; //窗口2的第4行局部更新显示变量1代表更新显示，响应函数内部会清零
unsigned char ucData_1_1=8;//第1个窗口第1行的被设置数据
unsigned char ucData_1_2=9;//第1个窗口第2行的被设置数据
unsigned char ucData_1_3=10;//第1个窗口第3行的被设置数据
unsigned char ucData_1_4=11;//第1个窗口第4行的被设置数据
unsigned char ucData_2_1=12;//第2个窗口第1行的被设置数据
unsigned char ucData_2_2=13;//第2个窗口第2行的被设置数据
unsigned char ucData_2_3=14;//第2个窗口第3行的被设置数据
unsigned char ucData_2_4=15;//第2个窗口第4行的被设置数据
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 intuiKeyTimeCnt1=0; //按键去抖动延时计数器
static unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
static unsigned intuiKeyTimeCnt2=0; //按键去抖动延时计数器
static unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
static unsigned intuiKeyTimeCnt3=0; //按键去抖动延时计数器
static unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
static unsigned intuiKeyTimeCnt4=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 1://窗口1
switch(ucPart)//在窗口1下，根据不同的局部变量来设置不同的参数
{
case 0: //无光标显示的状态 此处的case 0可以省略
break;
case 1: //设置第1行参数
ucData_1_1++;
if(ucData_1_1>99)
{
ucData_1_1=99;
}
ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置第2行参数
ucData_1_2++;
if(ucData_1_2>99)
{
ucData_1_2=99;
}
ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
case 3: //设置第3行参数
ucData_1_3++;
if(ucData_1_3>99)
{
ucData_1_3=99;
}
ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
break;
case 4: //设置第4行参数
ucData_1_4++;
if(ucData_1_4>99)
{
ucData_1_4=99;
}
ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
case 2://窗口2
switch(ucPart)//在窗口2下，根据不同的局部变量来设置不同的参数
{
case 0: //无光标显示的状态 此处的case 0可以省略
break;
case 1: //设置第1行参数
ucData_2_1++;
if(ucData_2_1>99)
{
ucData_2_1=99;
}
ucWd2Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置第2行参数
ucData_2_2++;
if(ucData_2_2>99)
{
ucData_2_2=99;
}
ucWd2Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
case 3: //设置第3行参数
ucData_2_3++;
if(ucData_2_3>99)
{
ucData_2_3=99;
}
ucWd2Part3Update=1; //1代表更新显示，响应函数内部会清零
break;
case 4: //设置第4行参数
ucData_2_4++;
if(ucData_2_4>99)
{
ucData_2_4=99;
}
ucWd2Part4Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0;//响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 减按键 对应朱兆祺学习板的S5键
switch(ucWd)//在不同的窗口下，设置不同的参数
{
case 1://窗口1
switch(ucPart)//在窗口1下，根据不同的局部变量来设置不同的参数
{
case 0: //无光标显示的状态 此处的case 0可以省略
break;
case 1: //设置第1行参数
ucData_1_1--;
if(ucData_1_1>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucData_1_1=0;
}
ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置第2行参数
ucData_1_2--;
if(ucData_1_2>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucData_1_2=0;
}
ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
case 3: //设置第3行参数
ucData_1_3--;
if(ucData_1_3>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucData_1_3=0;
}
ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
break;
case 4: //设置第4行参数
ucData_1_4--;
if(ucData_1_4>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucData_1_4=0;
}
ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
case 2://窗口2
switch(ucPart)//在窗口2下，根据不同的局部变量来设置不同的参数
{
case 0: //无光标显示的状态 此处的case 0可以省略
break;
case 1: //设置第1行参数
ucData_2_1--;
if(ucData_2_1>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucData_2_1=0;
}
ucWd2Part1Update=1; //1代表更新显示，响应函数内部会清零
break;
case 2: //设置第2行参数
ucData_2_2--;
if(ucData_2_2>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucData_2_2=0;
}
ucWd2Part2Update=1; //1代表更新显示，响应函数内部会清零
break;
case 3: //设置第3行参数
ucData_2_3--;
if(ucData_2_3>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucData_2_3=0;
}
ucWd2Part3Update=1; //1代表更新显示，响应函数内部会清零
break;
case 4: //设置第4行参数
ucData_2_4--;
if(ucData_2_4>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
{
ucData_2_4=0;
}
ucWd2Part4Update=1; //1代表更新显示，响应函数内部会清零
break;
}
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0;//响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3:// 切换"光标"移动按键 对应朱兆祺学习板的S9键
switch(ucWd)//在不同的窗口下，设置不同的参数
{
case 1: //窗口1
switch(ucPart)//在窗口1下，根据不同的局部变量来设置不同的参数
{
case 0: //无光标显示的状态 此处的case 0可以省略
break;
case 1: //设置第1行参数
ucPart=2; //光标切换到下一行
ucWd1Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd1Part2Update=1; //更新显示下一行， 目的是更新反显光标的状态
break;
case 2: //设置第2行参数
ucPart=3; //光标切换到下一行
ucWd1Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd1Part3Update=1; //更新显示下一行， 目的是更新反显光标的状态
break;
case 3: //设置第3行参数
ucPart=4; //光标切换到下一行
ucWd1Part3Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd1Part4Update=1; //更新显示下一行， 目的是更新反显光标的状态
break;
case 4: //设置第4行参数
ucWd=2;//切换到第2个窗口
ucPart=1; //光标返回到最上面第一行
ucWd2Update=1; //窗口2整屏更新
break;
}
break;
case 2: //窗口2
switch(ucPart)//在窗口2下，根据不同的局部变量来设置不同的参数
{
case 0: //无光标显示的状态 此处的case 0可以省略
break;
case 1: //设置第1行参数
ucPart=2; //光标切换到下一行
ucWd2Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd2Part2Update=1; //更新显示下一行， 目的是更新反显光标的状态
break;
case 2: //设置第2行参数
ucPart=3; //光标切换到下一行
ucWd2Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd2Part3Update=1; //更新显示下一行， 目的是更新反显光标的状态
break;
case 3: //设置第3行参数
ucPart=4; //光标切换到下一行
ucWd2Part3Update=1; //更新显示原来那一行，目的是更新反显光标的状态
ucWd2Part4Update=1; //更新显示下一行， 目的是更新反显光标的状态
break;
case 4: //设置第4行参数
ucWd=1;//切换到第1个窗口
ucPart=1; //光标返回到最上面第一行
ucWd1Update=1; //窗口1整屏更新
break;
}
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0;//响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 4: // 设置按键对应朱兆祺学习板的S13键，按一次进入设置状态，出现反显光标。再按一次推出设置状态，消除反显光标,并且强行切换到第1个窗口
switch(ucWd)//在不同的窗口下，设置不同的参数
{
case 1://窗口1
switch(ucPart)//在窗口1下，根据不同的局部变量来设置不同的参数
{
case 0: //无光标显示的状态
ucPart=1; //光标显示第一行，进入设置模式
ucWd1Part1Update=1; //更新显示
break;
case 1: //设置第1行参数
ucPart=0; //无光标显示，退出设置模式
ucWd1Part1Update=1; //更新显示
break;
case 2: //设置第2行参数
ucPart=0; //无光标显示，退出设置模式
ucWd1Part2Update=1; //更新显示
break;
case 3: //设置第3行参数
ucPart=0; //无光标显示，退出设置模式
ucWd1Part3Update=1; //更新显示
break;
case 4: //设置第4行参数
ucPart=0; //无光标显示，退出设置模式
ucWd1Part4Update=1; //更新显示
break;
}
break;
case 2://窗口2
switch(ucPart)//在窗口2下，根据不同的局部变量来设置不同的参数
{
case 0: //无光标显示的状态
ucWd=1; //强行切换到第1个窗口
ucPart=1; //光标显示第一行，进入设置模式
ucWd1Update=1; //窗口1整屏更新
break;
case 1: //设置第1行参数
ucWd=1; //强行切换到第1个窗口
ucPart=0; //无光标显示，退出设置模式
ucWd1Update=1; //窗口1整屏更新
break;
case 2: //设置第2行参数
ucWd=1; //强行切换到第1个窗口
ucPart=0; //无光标显示，退出设置模式
ucWd1Update=1; //窗口1整屏更新
break;
case 3: //设置第3行参数
ucWd=1; //强行切换到第1个窗口
ucPart=0; //无光标显示，退出设置模式
ucWd1Update=1; //窗口1整屏更新
break;
case 4: //设置第4行参数
ucWd=1; //强行切换到第1个窗口
ucPart=0; //无光标显示，退出设置模式
ucWd1Update=1; //窗口1整屏更新
break;
}
break;
}
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0;//响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
unsigned char *number_to_matrix(unsigned charucBitNumber)
{
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();//窗口1显示的内容
break;
case 2:
wd2();//窗口2显示的内容
break;
//本程序只有2个窗口，所以只有一个case 1，如果要增加窗口，就直接增加 case 2, case 3...
}
}
void wd1(void)//窗口1显示的内容
{
unsigned char ucAnyNumber_1; //分解变量的个位
unsigned char ucAnyNumber_10; //分解变量的十位
unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
unsigned char ucCursorFlag;//光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
/* 注释三：
* 把每一个窗口的内容分为两种类型，一种类型是那些不用经常刷新显示的内容，只有在切换窗口的时候
* 才需要更新，这种内容放在整屏更新显示的括号里，比如清屏操作等内容。另外一种是那些经常需要
* 刷新显示的内容，这种内容放在局部更新显示的括号里。
*/
if(ucWd1Update==1)//窗口1整屏更新，里面只放那些不用经常刷新显示的内容
{
ucWd1Update=0;//及时清零，避免一直更新
ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd1Part3Update=1; //激活窗口1的第3行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd1Part4Update=1; //激活窗口1的第4行局部更新显示变量，这里在前面数码管显示框架上有所改进
display_clear(0x00); // 清屏操作， 全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas();//把画布全部清零
insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布
display_lattice(0,0,Hz1616_yi,0,2,16,0); //一窗口一行，这些内容不用经常更新，只有在切换窗口的时候才更新显示
display_lattice(1,0,Hz1616_chuang,0,2,16,0);
display_lattice(2,0,Hz1616_kou,0,2,16,0);
display_lattice(3,0,Hz1616_yi,0,2,16,0);
display_lattice(4,0,Hz1616_hang,0,2,16,0);
display_lattice(0,16,Hz1616_yi,0,2,16,0); //一窗口二行
display_lattice(1,16,Hz1616_chuang,0,2,16,0);
display_lattice(2,16,Hz1616_kou,0,2,16,0);
display_lattice(3,16,Hz1616_er,0,2,16,0);
display_lattice(4,16,Hz1616_hang,0,2,16,0);
display_lattice(8,0,Hz1616_yi,0,2,16,0); //一窗口三行
display_lattice(9,0,Hz1616_chuang,0,2,16,0);
display_lattice(10,0,Hz1616_kou,0,2,16,0);
display_lattice(11,0,Hz1616_san,0,2,16,0);
display_lattice(12,0,Hz1616_hang,0,2,16,0);
display_lattice(8,16,Hz1616_yi,0,2,16,0); //一窗口四行
display_lattice(9,16,Hz1616_chuang,0,2,16,0);
display_lattice(10,16,Hz1616_kou,0,2,16,0);
display_lattice(11,16,Hz1616_si,0,2,16,0);
display_lattice(12,16,Hz1616_hang,0,2,16,0);
}
/* 注释四：
* 注意！我前面讲数码管显示的时候有一句话讲错了，我那时说<局部更新应该写在整屏更新之前>,这是不对的。
* 按照现在的显示程序框架<即整屏显示更新括号里包含了所有局部变量的激活>，应该是<整屏更新应该写在局部更新之前>
* 这样才对。
*/
if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part1Update=0; //及时清零，避免一直更新
if(ucPart==1) //被选中
{
ucCursorFlag=1; //反显 显示
}
else //没被选中
{
ucCursorFlag=0; //正常 显示
}
if(ucData_1_1>=10) //有2位数以上
{
ucAnyNumber_10=ucData_1_1/10;//十位
}
else //否则显示空
{
ucAnyNumber_10=10;//在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucData_1_1%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(5,0,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd1Part2Update==1) //窗口1的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part2Update=0; //及时清零，避免一直更新
if(ucPart==2) //被选中
{
ucCursorFlag=1; //反显 显示
}
else //没被选中
{
ucCursorFlag=0; //正常 显示
}
if(ucData_1_2>=10) //有2位数以上
{
ucAnyNumber_10=ucData_1_2/10;//十位
}
else //否则显示空
{
ucAnyNumber_10=10;//在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucData_1_2%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(5,16,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd1Part3Update==1) //窗口1的第3行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part3Update=0; //及时清零，避免一直更新
if(ucPart==3) //被选中
{
ucCursorFlag=1; //反显 显示
}
else //没被选中
{
ucCursorFlag=0; //正常 显示
}
if(ucData_1_3>=10) //有2位数以上
{
ucAnyNumber_10=ucData_1_3/10;//十位
}
else //否则显示空
{
ucAnyNumber_10=10;//在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucData_1_3%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(13,0,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd1Part4Update==1) //窗口1的第4行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd1Part4Update=0; //及时清零，避免一直更新
if(ucPart==4) //被选中
{
ucCursorFlag=1; //反显 显示
}
else //没被选中
{
ucCursorFlag=0; //正常 显示
}
if(ucData_1_4>=10) //有2位数以上
{
ucAnyNumber_10=ucData_1_4/10;//十位
}
else //否则显示空
{
ucAnyNumber_10=10;//在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucData_1_4%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(13,16,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数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行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd2Part3Update=1; //激活窗口2的第3行局部更新显示变量，这里在前面数码管显示框架上有所改进
ucWd2Part4Update=1; //激活窗口2的第4行局部更新显示变量，这里在前面数码管显示框架上有所改进
display_clear(0x00); // 清屏操作， 全部显示空填充0x00，全部显示点阵用0xff。
clear_all_canvas();//把画布全部清零
insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布
display_lattice(0,0,Hz1616_er,0,2,16,0); //二窗口一行，这些内容不用经常更新，只有在切换窗口的时候才更新显示
display_lattice(1,0,Hz1616_chuang,0,2,16,0);
display_lattice(2,0,Hz1616_kou,0,2,16,0);
display_lattice(3,0,Hz1616_yi,0,2,16,0);
display_lattice(4,0,Hz1616_hang,0,2,16,0);
display_lattice(0,16,Hz1616_er,0,2,16,0); //二窗口二行
display_lattice(1,16,Hz1616_chuang,0,2,16,0);
display_lattice(2,16,Hz1616_kou,0,2,16,0);
display_lattice(3,16,Hz1616_er,0,2,16,0);
display_lattice(4,16,Hz1616_hang,0,2,16,0);
display_lattice(8,0,Hz1616_er,0,2,16,0); //二窗口三行
display_lattice(9,0,Hz1616_chuang,0,2,16,0);
display_lattice(10,0,Hz1616_kou,0,2,16,0);
display_lattice(11,0,Hz1616_san,0,2,16,0);
display_lattice(12,0,Hz1616_hang,0,2,16,0);
display_lattice(8,16,Hz1616_er,0,2,16,0); //二窗口四行
display_lattice(9,16,Hz1616_chuang,0,2,16,0);
display_lattice(10,16,Hz1616_kou,0,2,16,0);
display_lattice(11,16,Hz1616_si,0,2,16,0);
display_lattice(12,16,Hz1616_hang,0,2,16,0);
}
if(ucWd2Part1Update==1) //窗口2的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd2Part1Update=0; //及时清零，避免一直更新
if(ucPart==1) //被选中
{
ucCursorFlag=1; //反显 显示
}
else //没被选中
{
ucCursorFlag=0; //正常 显示
}
if(ucData_2_1>=10) //有2位数以上
{
ucAnyNumber_10=ucData_2_1/10;//十位
}
else //否则显示空
{
ucAnyNumber_10=10;//在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucData_2_1%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(5,0,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd2Part2Update==1) //窗口2的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd2Part2Update=0; //及时清零，避免一直更新
if(ucPart==2) //被选中
{
ucCursorFlag=1; //反显 显示
}
else //没被选中
{
ucCursorFlag=0; //正常 显示
}
if(ucData_2_2>=10) //有2位数以上
{
ucAnyNumber_10=ucData_2_2/10;//十位
}
else //否则显示空
{
ucAnyNumber_10=10;//在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucData_2_2%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(5,16,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd2Part3Update==1) //窗口2的第3行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd2Part3Update=0; //及时清零，避免一直更新
if(ucPart==3) //被选中
{
ucCursorFlag=1; //反显 显示
}
else //没被选中
{
ucCursorFlag=0; //正常 显示
}
if(ucData_2_3>=10) //有2位数以上
{
ucAnyNumber_10=ucData_2_3/10;//十位
}
else //否则显示空
{
ucAnyNumber_10=10;//在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucData_2_3%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(13,0,ucCanvasBuffer,0,4,16,0); //显示整屏的画布,最后的参数0是偏移量
}
if(ucWd2Part4Update==1) //窗口2的第4行局部更新显示变量,里面放一些经常需要刷新显示的内容
{
ucWd2Part4Update=0; //及时清零，避免一直更新
if(ucPart==4) //被选中
{
ucCursorFlag=1; //反显 显示
}
else //没被选中
{
ucCursorFlag=0; //正常 显示
}
if(ucData_2_4>=10) //有2位数以上
{
ucAnyNumber_10=ucData_2_4/10;//十位
}
else //否则显示空
{
ucAnyNumber_10=10;//在下面的转换函数中，代码10表示空字模
}
ucAnyNumber_1=ucData_2_4%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(13,16,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=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;
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; //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++)//内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
总结陈词：
这一节讲了在多个窗口里设置不同的参数。还有一种常见的项目，要求把第1窗口是用来作为主菜单，主菜单里面有3个子菜单，可以通过移动光标进入不同的子菜单窗口进行参数设置，这类项目该如何编程？欲知详情，请听下回分解-----通过主菜单移动光标来进入子菜单窗口的液晶屏程序。
（未完待续，下节更精彩，不要走开哦）
继续哈!{:titter:}
很不错，必须支持一下，mark
好贴记号，程序结构框架喜欢就是介绍那些设计模式了
吴坚鸿 发表于 2014-6-1 14:15
在实际的项目中，如果采用静态显示方案，你不用担心影响按键的实时性，根据客户的使用习惯，我可以多加一 ...
学到了第四十九节：也看到代码里依然DS18B20动态扫描数码管显示，没整过静态显示，没看出回复中的按键实时性。还是要实践出真知，学到新经验，赞N个！{:lol:}
第七十九节：通过主菜单移动光标来进入子菜单窗口的液晶屏程序。
开场白：
其实主菜单窗口与子菜单窗口本质都是多窗口菜单程序，只不过我在按键服务程序里面建立起来了一条主窗口与子窗口的关系链。这个关系链还是用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_short40 //蜂鸣器短叫的持续时间
#define const_key_time120 //按键去抖动延时的时间
#define const_key_time220 //按键去抖动延时的时间
#define const_key_time320 //按键去抖动延时的时间
#define const_key_time420 //按键去抖动延时的时间
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口
sbitLCDCS_dr= P1^6;//片选线
sbitLCDSID_dr = P1^7;//串行数据线
sbitLCDCLK_dr = P3^2;//串行时钟线
sbitLCDRST_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 charucBitNumber); //把一位数字转换成字模首地址的函数
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 intuiVoiceCnt=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 intuiKeyTimeCnt1=0; //按键去抖动延时计数器
static unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
static unsigned intuiKeyTimeCnt2=0; //按键去抖动延时计数器
static unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
static unsigned intuiKeyTimeCnt3=0; //按键去抖动延时计数器
static unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
static unsigned intuiKeyTimeCnt4=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 charucBitNumber)
{
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=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;
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; //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编译器到底还干了哪些鲜为人知的好事？欲知详情，请听下回分解-----液晶屏自带字库跟汉字机内码的关系。
（未完待续，下节更精彩，不要走开哦）
支持下
好东西！mark!
再次收藏{:titter:}
出本书吧。。。我买一本。。
看得有点眼花呀
收藏先！！！
第八十节：调用液晶屏内部字库来显示汉字或字符的坐标体系和本质。
开场白：
前面章节讲的内容全部都是用自构字库的，相当于使用液晶屏的图像模式。其实这个款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"
sbitLCDCS_dr= P1^6;//片选线
sbitLCDSID_dr = P1^7;//串行数据线
sbitLCDCLK_dr = P3^2;//串行时钟线
sbitLCDRST_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 charucAddrTable[]=//调用内部字库时，液晶屏的坐标体系，位置编码，是驱动内容，读者可以不用深究它的含义。
{
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); //起始位置
LCDWriteData(ucArray);
LCDWriteData(ucArray);
}
/* 注释五：在一个坐标点显示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); //起始位置
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_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码搞混乱了？不会的。其实这两种编码都是有规律可以筛选识别的，欲知详情，请听下回分解-----液晶屏显示串口发送过来的任意汉字和字符。
（未完待续，下节更精彩，不要走开哦）
收藏，有空看看
真不错，第一节里面说的我表示认同。
先mark,有空一定要学习下
学习学习~~
mark 学习
持续跟踪楼主
不错，Mark上，仔细研读
各种学习中
第八十一节：液晶屏显示串口发送过来的任意汉字和字符。
开场白：
通过上一节的学习，我们发现汉字的识别本质是机内码，字符的识别本质是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 55XX XX XX XX …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 35 31 B5 A5 C6 AC BB FA 0D 0A
（3）源代码讲解如下：
#include "REG52.H"
/* 注释一：
* 本程序的串口那部分内容是从《第三十九节：判断数据头来接收一串数据的串口通用程序框架。》
* 移植过来的，但是以下要把接收缓冲区的数据从10改成60.同时，协议后面多增加了数据结束标志0x0d 0x0a。
*/
#define const_rc_size60//接收串口中断数据的缓冲区数组大小
#define const_receive_time5//如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
#define const_voice_short40 //蜂鸣器短叫的持续时间
sbitLCDCS_dr= P1^6;//片选线
sbitLCDSID_dr = P1^7;//串行数据线
sbitLCDCLK_dr = P3^2;//串行时钟线
sbitLCDRST_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 charucArray2); //在一个坐标点显示1个汉字或者2个字符的函数
void delay_short(unsigned int uiDelayshort); //延时
code unsigned charucAddrTable[]=//调用内部字库时，液晶屏的坐标体系，位置编码，是驱动内容，读者可以不用深究它的含义。
{
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 intuiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned intuiRcregTotal=0;//代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf; //接收串口中断数据的缓冲区数组
unsigned intuiRcMoveIndex=0;//用来解析数据协议的中间变量
unsigned intuiVoiceCnt=0;//蜂鸣器鸣叫的持续时间计数器
unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量 1代表更新显示，响应函数内部会清零
unsigned char ucWd1Part1Update=0; //窗口1的第1个局部更新显示变量1代表更新显示，响应函数内部会清零
unsigned char ucDispplayBuffer; //第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 charucArray2)
{
WriteCommand(0x30); //基本指令集
WriteCommand(ucAddrTable); //起始位置
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=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,ucDispplayBuffer); //这里的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,JN1616_qing); //请
display_double_code(2,0,JN1616_fa,JN1616_fa); //发
display_double_code(3,0,JN1616_song,JN1616_song); //送
display_double_code(4,0,JN1616_xin,JN1616_xin); //信
display_double_code(5,0,JN1616_xi,JN1616_xi); //息
}
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==0xeb&&ucRcregBuf==0x00&&ucRcregBuf==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==0x0d&&ucRcregBuf==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>=0x80&&ucRcregBuf<0x80) //如果当前的是机内码，而上一个不是机内码
{
ucDispplayBuffer=0x20; //当前的先填充插入空格字符0x20
uiCodeCnt++; //统计接收的有效编码数量
}
}
ucDispplayBuffer=ucRcregBuf; //收集有效信息编码进入显示缓冲区
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=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
}
总结陈词：
我们现在是调用液晶屏内部字库来显示内容，如果要某行内容反显或者光标闪烁改怎么编程？欲知详情，请听下回分解-----如何在调用液晶屏内部字库时让某行内容反显或者光标闪烁。
（未完待续，下节更精彩，不要走开哦）
看到后面液晶屏代码，身边没硬件实物演示，比较痛苦{:dizzy:}{:dizzy:}
建议楼主还是出本书好些
楼主加油，赞一个。
很受用啊，谢谢。
你在电子发烧友很火啊！
wo很奇怪为什么不是精华贴。。。
支持，学习一下！！
这个必需顶
楼主的程序框架是很可以的。不过这样写的代码同样也是有他不好的地方。作为一个简单的例程。楼主可以把代码放入中断，不过模块多，自然这样的方式就不合适的。例外，对于这样的时间片管理，还是不够合理统一不同的模块都需要使用这么多标志和计数器，而且都是独立的。楼主应该继续沉淀，看看如PT这样的方式。
楼主的框架指的是什么？
新手学习一下
表示关注一下！！
写了这么长支持一下
Mark,谢谢分享
拜读，谢谢分享支持
感谢楼主持续分享与更新！
学习了{:biggrin:}
谢谢楼主！
这个是精华啊！！！
mark,有时间来看
xkdwangcs 发表于 2014-11-9 19:14
楼主的程序框架是很可以的。不过这样写的代码同样也是有他不好的地方。作为一个简单的例程。楼主可以把代码 ...
感谢你的建议。
本帖最后由 吴坚鸿 于 2014-11-11 12:16 编辑
OYL 发表于 2014-11-9 19:24
楼主的框架指的是什么？
我的框架核心是switch状态机外加一个定时器中断。往大方面讲。其实我的按键，显示，串口，以及其它应用层如跑马灯的程序都有一个固定的套路。一直看我代码的网友他们会很清晰的感觉到这个套路的存在。
经验大总结，顶楼主
楼主可以出书了，有没有书！！想买本看看
tcscy 发表于 2014-11-11 16:26
楼主可以出书了，有没有书！！想买本看看
书要到明年才会整理。
楼主这是良心版的注释和讲解啊！谢谢！加油！
感谢楼主，赞一个
吴坚鸿 发表于 2014-3-10 13:56
第六节：在主函数中利用累计主循环次数来实现独立按键的检测。
开场白：
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(ucKeyLock1==0)//有按键按下，且是第一次被按下
一直搞不明白这一句是怎么判断有按键被按下的，不是应该是 key_sr1==0 才有按键被按下吗
楼主好贴！支持！
weimas 发表于 2014-11-14 09:21
麻烦问下楼主
if(ucKeyLock1==0)//有按键按下，且是第一次被按下
一直搞不明白这一句是怎么判断有按 ...
（1）首先，我们要明白C语言的语法中，
if(条件1)
{
}
else if(条件2)
{
}
以上语句是一对组合语句，不能分开来看。当条件1成立的时候，它是绝对不会判断条件2的。当条件1不成立的时候，才会判断条件2。
因此回到我们的问题，当程序执行到条件2 else if(ucKeyLock1==0)的时候，就已经默认了 条件1 if(key_sr1==1)不成立，这个条件不成立，就意味着key_sr1==0，也就是有按键被按下，所以，这里的else if(ucKeyLock1==0)等于else if(ucKeyLock1==0&&key_sr1==0)，而ucKeyLock1是一个自锁标志位，一旦按键被触发后，这个标志位会变1，防止按键按住不松手的时候不断触发按键。这样，按键只能按一次触发一次，松开手后再按一次，又触发一次。
本帖最后由 吴坚鸿 于 2014-11-14 12:10 编辑
第八十二节：如何通过调用液晶屏内部字库把一个任意数值的变量显示出来。
开场白：
本来这一节打算开始讲调用液晶屏内部字库时的反显程序，但是我担心跳跃太大，恐怕很多初学者跟不上，所以多插入这一节讲讲后面菜单程序中经常用到的基本功能，在调用内部字库的情况下，如何把一个任意数值的变量显示在液晶屏上。这一节的功能需求跟前面第76节是一模一样的，只不过前面的不是用自带字库，现在的是用自带字库而已。我们还是需要做一个变量转换成ASCII码的函数，以后只要调用这个转换函数就可以了。这一节就要把这个转换函数和框架思路教给大家。
具体内容，请看源代码讲解。
（1）硬件平台：
基于朱兆祺51单片机学习板。
（2）实现功能：我们定义一个char型的全局变量，把它默认初始化为218，开机上电后，能看到正中间恰好显示这个全局变量的数值218。大家也可以试着更改它的默认初始值，只要不超过char型最大数值255范围，我们就会看到它上电后显示的就是这个初始值。
（3）源代码讲解如下：
#include "REG52.H"
sbitLCDCS_dr= P1^6;//片选线
sbitLCDSID_dr = P1^7;//串行数据线
sbitLCDCLK_dr = P3^2;//串行时钟线
sbitLCDRST_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 charucBitNumber);
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 charucArray2); //在一个坐标点显示1个汉字或者2个字符的函数
void delay_short(unsigned int uiDelayshort); //延时
code unsigned charucAddrTable[]=//调用内部字库时，液晶屏的坐标体系，位置编码，是驱动内容，读者可以不用深究它的含义。
{
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 charucArray2)
{
WriteCommand(0x30); //基本指令集
WriteCommand(ucAddrTable); //起始位置
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 charucBitNumber)
{
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,p_ucAnyNumber_100);//液晶屏的显示驱动函数这里的ASCII816_nc代表填充显示一个空格字符
display_double_code(3,1,p_ucAnyNumber_10,p_ucAnyNumber_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)//第一区 初始化单片机
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
}
void initial_peripheral(void) //第二区 初始化外围
{
LCDInit(); //初始化12864 内部包含液晶模块的复位
WriteCommand(0x0C); //命令字0x0c表示用内部字库模式。命令字0x36表示用自构字库模式。
display_clear(); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
}
总结陈词：
在液晶屏程序里，经常要用到反显的功能来表示选中某一项菜单。在调用内部字库时，这样的驱动程序又该怎么写？欲知详情，请听下回分解-----如何在调用液晶屏内部字库时让某行内容反显。
（未完待续，下节更精彩，不要走开哦）
不错，支持楼主
谢谢楼主分享，支持楼主的精神。
真不错。很欣赏！
我是来听课的。
不会又是想卖书吧？周立功和你什么关系
表示支持下！
吴老师你做项目是也许也会遇到这样的问题一个系统多个SPI器件你是怎么保证每个SPI的实时性 有不丢任务，在系统中不能做等待，还望吴老师指导
支持一下楼主 无私奉献 赞
吴坚鸿 发表于 2014-11-14 12:00
第八十二节：如何通过调用液晶屏内部字库把一个任意数值的变量显示出来。
开场白：
楼主你好，我在看你的连载的时候，觉得在进入中断后的处理上，是否应该先关闭中断再清标志位。
262619890 发表于 2014-11-17 17:12
楼主你好，我在看你的连载的时候，觉得在进入中断后的处理上，是否应该先关闭中断再清标志位。 ...
这个我也不清楚，没有研究过这些细节。你可以自己测试一下。
chunyu 发表于 2014-11-17 16:25
吴老师你做项目是也许也会遇到这样的问题一个系统多个SPI器件你是怎么保证每个SPI的实时性 有不丢任 ...
单片机在一个时刻只能干一件事。很多事情是需要根据项目进行取舍的，不可能照顾到方方面面，没有十全十美的办法，只要能满足客户要求就好。我的思路是，如果一个单片机不行，就再加一个单片机，进行双核处理，比如我在驱动步进电机的时候，就经常用“双核”，两个单片机之间进行串口通讯，一个单片机负责人机界面等常用功能，一个单片机专门负责产生脉冲驱动步进电机。
吴坚鸿 发表于 2014-11-18 16:09
单片机在一个时刻只能干一件事。很多事情是需要根据项目进行取舍的，不可能照顾到方方面面，没有十全十美 ...
我想的是大多数情况下 SPI个一个一个的完成但是当多个地方使用不同芯片的（SPI接口）我想通过排队 让他们完成不知道这个方法行不行 不知道吴老师怎么看待
程序还行，注释也挺到位
mark下，谢谢分享！
今天发帖mark一下 学些了好久了，很好的资料
继续听讲{:lol:}
好多东西啊！
牛人啊！！小马扎！
kation122 发表于 2014-3-10 11:31
顶起，很实在很有用的东西。
太好了，顶起。
已经收藏了，每天看点点，感谢的付出
chunyu 发表于 2014-11-18 18:53
我想的是大多数情况下 SPI个一个一个的完成但是当多个地方使用不同芯片的（SPI接口）我想通过排队 让 ...
有的行，有的不行，看具体项目吧。这个问题不用讨论，你可以自己动手试试。
谢谢LZ的分享！社会就需要这样的正能量
mark下，谢谢分享！
像LZ这样的人多一些 学技术 就没那么费劲了 谢谢分享！
鸿哥，我把您在此贴的程序总体整理了一下，发到这个帖子上了，http://www.amobbs.com/thread-5606064-1-1.html 谢谢鸿哥
手把手教你单片机程序框架
学习了。。到最近才慢慢的将写程序进行升级。。谢谢
楼主是不已经出书了啊，呵呵，有个小建议 ucKeyLock1==0这样类型的是不写成 0==ucKeyLock1 更好一些，以前碰到过 ucKeyLock1==0 有时会出现误判，但几率并不高
牛贴应该穿裤子了啊
与狼共舞 发表于 2014-11-27 14:16
鸿哥，我把您在此贴的程序总体整理了一下，发到这个帖子上了，http://www.amobbs.com/thread-5606064-1-1.h ...
感谢你整理。辛苦了。
本帖最后由 吴坚鸿 于 2014-11-27 16:47 编辑
beijingqiang 发表于 2014-11-27 15:57
楼主是不已经出书了啊，呵呵，有个小建议 ucKeyLock1==0这样类型的是不写成 0==ucKeyLock1 更好一些，以前 ...
还没有出书。计划明年下半年才开始整理书稿。至于ucKeyLock1==0，感谢你的建议，之前也有很多高手提醒我防止出现if(ucKeyLock1=0)这样的错误，我以后尽量慢慢改过来。
拜读，支持下。
{:smile:}{:smile:}效率很高~~果断收藏学习
MARK!!!!!
必须支持！
mark !{:smile:}
MARK!!!!!!
真的很不错 ，学习了
先做个记号。有时间了好好看看。
一直在坚持.顶鸿哥
顶顶顶~~~
真的一直坚持在写，刚开始看到这个帖子，还以为楼主是一时脑袋发热，真的要写100节啊？写完可以出书了～～