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

szdzjs · 发表于 2014-12-24 19:38:38

看到鸿哥新出的大作很兴奋，但想想85都出了，是不是到86就封贴了，总觉得意犹未尽。。。

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

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

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

安之 · 发表于 2014-12-24 15:20:32

吴哥，我准备跟着你学习，但是一开始我就遇到一个问题就是：第二区的外围初始化一加进去就有警告，而且程序没有运行，请您帮忙解答，如有网友知道也帮忙解答一下

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++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}

复制代码

总结陈词：

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

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

mavericklx · 发表于 2014-12-22 16:41:51

真的很好～！非常感谢无私奉献

试试 · 发表于 2014-12-20 13:42:46

很好的分享。

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

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

欢迎

szdzjs · 发表于 2014-12-19 22:26:12

来欣赏鸿哥的大作

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-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码数组转换成数值的液晶屏显示程序。

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

华菲 · 发表于 2014-12-11 19:18:26

jianhong_wu 发表于 2014-12-9 13:16
这两天一直在等待好的状态来临再动手。

先忙你的，等状态好的时候再写

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

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

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

华菲 · 发表于 2014-12-9 12:42:38

等鸿哥的第九页呢

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

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

这两个星期有点忙。

waphaoyun · 发表于 2014-12-3 16:36:31

jianhong_wu 发表于 2014-11-14 11:38
第八十二节：如何通过调用液晶屏内部字库把一个任意数值的变量显示出来。
开场白：本来这一节打算开始讲调 ...

鸿哥，有几天木有更新啦

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-11-7 17:03:41

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

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

KR770906 · 发表于 2014-11-7 10:30:08

鸿哥，按键去抖动延时计数器uiKeyTimeCnt1、uiKeyTimeCnt2、uiKeyTimeCnt3……能否合并成一个变量？

yuansy00983 · 发表于 2014-11-6 22:25:20

继续学习，顶----顶--

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
}

复制代码

总结陈词：

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

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

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

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