独闷闷网

 找回密码
 立即注册
搜索
楼主: jianhong_wu
收起左侧

[原创] 从业将近十年!手把手教你单片机程序框架(连载)

[复制链接]
发表于 2014-10-28 15:15:11 | 显示全部楼层
鸿哥的液晶更新有点多节啦,得开始研究了
乐于分享,勇于质疑!
 楼主| 发表于 2014-10-28 15:35:21 | 显示全部楼层
又一个暑假 发表于 2014-10-28 15:15
鸿哥的液晶更新有点多节啦,得开始研究了

不要急,一节一节来慢慢消化。
乐于分享,勇于质疑!
 楼主| 发表于 2014-10-30 15:22:11 | 显示全部楼层
第七十九节:通过主菜单移动光标来进入子菜单窗口的液晶屏程序。

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

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

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

(2)实现功能:
     通过按键设置6个不同的参数。
    有4个窗口。第1个窗口是主菜单界面,通过光标切换可以进去设置不同参数的子菜单界面。第2个窗口是设置时间范围界面。第3个窗口是设置速度范围界面。第4个窗口是设置频率范围界面。每个设置界面显示2个参数。每个参数的范围是从0到99。
    有4个按键:
(a)          一个是进入和退出S13按键,按一次进入选中的子菜单。再按一次退出子菜单。
(b)         一个是移动光标S9按键,依次按下此按键,液晶屏上的光标会从上往下移动,表示选中不同的参数。当移动到每个窗口最下边那一行时,再按下此按键会把光标移动到第一个参数。
(c)          一个是减数S5按键,在设置参数模式下,依次按下此按键,被选中的参数会逐渐减小。
(d)         一个是加数S1按键,在设置参数模式下,依次按下此按键,被选中的参数会逐渐加大。
主菜单1.jpg
设置时间1.jpg
设置速度1.jpg
设置频率1.jpg
3)源代码讲解如下:
  1. #include "REG52.H"

  2. /* 注释一:
  3. * 本程序用到的变量比较多,所以在keil编译模式里要设置一下编译模式memory model,
  4. * 否则编译会出错.右键单击Target选择“Options for Target'Target1'”就会出来一个框
  5. * 在memory model中选择compact:variables in pdata 就可以了。
  6. */

  7. #define const_voice_short  40   //蜂鸣器短叫的持续时间

  8. #define const_key_time1  20    //按键去抖动延时的时间
  9. #define const_key_time2  20    //按键去抖动延时的时间
  10. #define const_key_time3  20    //按键去抖动延时的时间
  11. #define const_key_time4  20    //按键去抖动延时的时间


  12. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  13. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  14. sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
  15. sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键

  16. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  17. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

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

  22. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  23. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  24. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  25. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  26. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  27. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
  28. 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);//把字模插入画布.
  29. 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); //显示任意点阵函数
  30. unsigned char *number_to_matrix(unsigned char  ucBitNumber); //把一位数字转换成字模首地址的函数
  31. void delay_short(unsigned int uiDelayshort); //延时
  32. void delay_long(unsigned int uiDelayLong);

  33. void T0_time(); //定时中断函数
  34. void key_service(void); //按键服务的应用程序
  35. void key_scan(void);//按键扫描函数 放在定时中断里

  36. void initial_myself();   
  37. void initial_peripheral();


  38. void lcd_display_service(void); //应用层面的液晶屏显示程序
  39. void clear_all_canvas(void);  //把画布全部清零

  40. void wd1(void);//窗口1  主菜单
  41. void wd2(void);//窗口2  设置时间
  42. void wd3(void);//窗口3  设置速度
  43. void wd4(void);//窗口4  设置频率

  44. code unsigned char Zf816_0[]=
  45. {
  46. /*--  文字:  0  --*/
  47. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  48. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  49. };

  50. code unsigned char Zf816_1[]=
  51. {
  52. /*--  文字:  1  --*/
  53. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  54. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  55. };

  56. code unsigned char Zf816_2[]=
  57. {
  58. /*--  文字:  2  --*/
  59. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  60. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  61. };

  62. code unsigned char Zf816_3[]=
  63. {
  64. /*--  文字:  3  --*/
  65. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  66. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  67. };

  68. code unsigned char Zf816_4[]=
  69. {
  70. /*--  文字:  4  --*/
  71. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  72. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  73. };

  74. code unsigned char Zf816_5[]=
  75. {
  76. /*--  文字:  5  --*/
  77. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  78. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  79. };

  80. code unsigned char Zf816_6[]=
  81. {
  82. /*--  文字:  6  --*/
  83. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  84. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  85. };


  86. code unsigned char Zf816_7[]=
  87. {
  88. /*--  文字:  7  --*/
  89. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  90. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  91. };

  92. code unsigned char Zf816_8[]=
  93. {
  94. /*--  文字:  8  --*/
  95. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  96. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  97. };

  98. code unsigned char Zf816_9[]=
  99. {
  100. /*--  文字:  9  --*/
  101. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  102. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
  103. };


  104. code unsigned char Zf816_nc[]=  //空字模
  105. {
  106. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  107. };

  108. code unsigned char Zf816_mao_hao[]=  //冒号
  109. {
  110. /*--  文字:  :  --*/
  111. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  112. 0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
  113. };


  114. code unsigned char Hz1616_zhu[]=
  115. {
  116. /*--  文字:  主  --*/
  117. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  118. 0x02,0x00,0x01,0x80,0x01,0x00,0x00,0x08,0x3F,0xFC,0x01,0x00,0x01,0x00,0x01,0x08,
  119. 0x3F,0xFC,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x04,0x7F,0xFE,0x00,0x00,0x00,0x00,
  120. };

  121. code unsigned char Hz1616_cai[]=
  122. {
  123. /*--  文字:  菜  --*/
  124. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  125. 0x04,0x40,0xFF,0xFE,0x04,0x40,0x04,0x40,0x3F,0xF8,0x22,0x08,0x11,0x10,0x08,0x20,
  126. 0x01,0x00,0x7F,0xFE,0x03,0x80,0x05,0x40,0x09,0x30,0x11,0x1C,0x61,0x08,0x01,0x00,
  127. };

  128. code unsigned char Hz1616_dan[]=
  129. {
  130. /*--  文字:  单  --*/
  131. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  132. 0x08,0x20,0x06,0x30,0x04,0x40,0x3F,0xF8,0x21,0x08,0x3F,0xF8,0x21,0x08,0x21,0x08,
  133. 0x3F,0xF8,0x21,0x08,0x01,0x00,0xFF,0xFE,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
  134. };

  135. code unsigned char Hz1616_she[]=
  136. {
  137. /*--  文字:  设  --*/
  138. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  139. 0x40,0x00,0x21,0xF0,0x31,0x10,0x21,0x10,0x01,0x10,0x01,0x10,0xE2,0x0E,0x25,0xF8,
  140. 0x21,0x08,0x21,0x08,0x20,0x90,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x0C,0x04,
  141. };

  142. code unsigned char Hz1616_zhi[]=
  143. {
  144. /*--  文字:  置  --*/
  145. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  146. 0x3F,0xF8,0x24,0x48,0x24,0x48,0x3F,0xF8,0x01,0x00,0x7F,0xFC,0x02,0x00,0x1F,0xF0,
  147. 0x10,0x10,0x1F,0xF0,0x10,0x10,0x1F,0xF0,0x10,0x10,0x1F,0xF0,0x10,0x10,0xFF,0xFE,
  148. };

  149. code unsigned char Hz1616_su[]=
  150. {
  151. /*--  文字:  速  --*/
  152. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  153. 0x00,0x80,0x40,0x80,0x2F,0xFC,0x20,0x80,0x00,0x80,0x07,0xF8,0xE4,0x88,0x24,0x88,
  154. 0x27,0xF8,0x21,0xA0,0x22,0x98,0x2C,0x88,0x20,0x80,0x50,0x80,0x8F,0xFE,0x00,0x00,
  155. };

  156. code unsigned char Hz1616_du[]=
  157. {
  158. /*--  文字:  度  --*/
  159. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  160. 0x01,0x00,0x00,0x80,0x3F,0xFE,0x22,0x20,0x22,0x20,0x2F,0xFC,0x22,0x20,0x23,0xE0,
  161. 0x20,0x00,0x27,0xF8,0x22,0x10,0x21,0x20,0x20,0xC0,0x41,0x30,0x46,0x0E,0x98,0x04,
  162. };

  163. code unsigned char Hz1616_shi[]=
  164. {
  165. /*--  文字:  时  --*/
  166. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  167. 0x00,0x10,0x00,0x10,0x7C,0x10,0x44,0x10,0x47,0xFE,0x44,0x10,0x7C,0x10,0x45,0x10,
  168. 0x44,0x90,0x44,0x90,0x7C,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x50,0x00,0x20,
  169. };

  170. code unsigned char Hz1616_jian[]=
  171. {
  172. /*--  文字:  间  --*/
  173. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  174. 0x20,0x00,0x13,0xFC,0x10,0x04,0x40,0x04,0x47,0xE4,0x44,0x24,0x44,0x24,0x47,0xE4,
  175. 0x44,0x24,0x44,0x24,0x47,0xE4,0x40,0x04,0x40,0x04,0x40,0x04,0x40,0x14,0x40,0x08,
  176. };

  177. code unsigned char Hz1616_pin[]=
  178. {
  179. /*--  文字:  频  --*/
  180. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  181. 0x08,0x00,0x08,0xFE,0x4E,0x20,0x48,0x40,0x48,0xFC,0xFE,0x84,0x00,0xA4,0x08,0xA4,
  182. 0x4A,0xA4,0x4A,0xA4,0x84,0xA4,0x08,0x50,0x10,0x48,0x20,0x86,0xC3,0x02,0x00,0x00,
  183. };

  184. code unsigned char Hz1616_lv[]=
  185. {
  186. /*--  文字:  率  --*/
  187. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  188. 0x02,0x00,0x01,0x00,0x7F,0xFE,0x41,0x00,0x22,0x28,0x17,0xD0,0x04,0x80,0x11,0x10,
  189. 0x22,0x48,0x47,0xC4,0x01,0x20,0xFF,0xFE,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
  190. };

  191. code unsigned char Hz1616_fan[]=
  192. {
  193. /*--  文字:  范  --*/
  194. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  195. 0x04,0x20,0x04,0x20,0xFF,0xFE,0x04,0x60,0x40,0x00,0x31,0xF8,0x91,0x08,0x61,0x08,
  196. 0x49,0x08,0x09,0x38,0x11,0x10,0xE1,0x00,0x21,0x04,0x21,0x04,0x20,0xFC,0x20,0x00,
  197. };

  198. code unsigned char Hz1616_wei[]=
  199. {
  200. /*--  文字:  围  --*/
  201. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  202. 0x7F,0xFC,0x42,0x04,0x42,0x04,0x5F,0xF4,0x42,0x04,0x4F,0xE4,0x42,0x04,0x5F,0xE4,
  203. 0x42,0x24,0x42,0x24,0x42,0x24,0x42,0xA4,0x42,0x44,0x40,0x04,0x7F,0xFC,0x40,0x04,
  204. };

  205. code unsigned char Hz1616_shang[]=
  206. {
  207. /*--  文字:  上  --*/
  208. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  209. 0x00,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0xF8,0x01,0x00,
  210. 0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x04,0x7F,0xFE,0x00,0x00,
  211. };

  212. code unsigned char Hz1616_xia[]=
  213. {
  214. /*--  文字:  下  --*/
  215. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  216. 0x00,0x04,0x7F,0xFE,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0xC0,0x01,0x60,0x01,0x30,
  217. 0x01,0x20,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
  218. };

  219. code unsigned char Hz1616_xian[]=
  220. {
  221. /*--  文字:  限  --*/
  222. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  223. 0x00,0x00,0xFB,0xF8,0x92,0x08,0x93,0xF8,0xA2,0x08,0xA2,0x08,0x93,0xF8,0x8A,0x80,
  224. 0x8A,0x48,0xAA,0x50,0x92,0x20,0x82,0x20,0x82,0x10,0x82,0x8E,0x83,0x04,0x82,0x00,
  225. };


  226. unsigned char ucCanvasBuffer[]= //画布显示数组。注意,这里没有code关键字,是全局变量。初始化全部填充0x00
  227. {
  228. 0x00,0x00,0x00,0x00,  //上半屏
  229. 0x00,0x00,0x00,0x00,
  230. 0x00,0x00,0x00,0x00,
  231. 0x00,0x00,0x00,0x00,
  232. 0x00,0x00,0x00,0x00,
  233. 0x00,0x00,0x00,0x00,
  234. 0x00,0x00,0x00,0x00,
  235. 0x00,0x00,0x00,0x00,

  236. //------------上半屏和下半屏的分割线-----------

  237. 0x00,0x00,0x00,0x00,  //下半屏
  238. 0x00,0x00,0x00,0x00,
  239. 0x00,0x00,0x00,0x00,
  240. 0x00,0x00,0x00,0x00,
  241. 0x00,0x00,0x00,0x00,
  242. 0x00,0x00,0x00,0x00,
  243. 0x00,0x00,0x00,0x00,
  244. 0x00,0x00,0x00,0x00,
  245. };


  246. unsigned char ucKeySec=0;   //被触发的按键编号
  247. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  248. unsigned char ucWd=1; //窗口变量

  249. unsigned char ucWd1Part=1;  //窗口1的局部变量,代表选中某一行。
  250. unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量      1代表更新显示,响应函数内部会清零
  251. unsigned char ucWd1Part1Update=0; //窗口1的第1个局部更新显示变量  1代表更新显示,响应函数内部会清零
  252. unsigned char ucWd1Part2Update=0; //窗口1的第2个局部更新显示变量  1代表更新显示,响应函数内部会清零
  253. unsigned char ucWd1Part3Update=0; //窗口1的第3个局部更新显示变量  1代表更新显示,响应函数内部会清零

  254. unsigned char ucWd2Part=1;  //窗口2的局部变量,代表选中某一行。
  255. unsigned char ucWd2Update=0; //窗口2的整屏更新显示变量      1代表更新显示,响应函数内部会清零
  256. unsigned char ucWd2Part1Update=0; //窗口2的第1个局部更新显示变量  1代表更新显示,响应函数内部会清零
  257. unsigned char ucWd2Part2Update=0; //窗口2的第2个局部更新显示变量  1代表更新显示,响应函数内部会清零

  258. unsigned char ucWd3Part=1;  //窗口3的局部变量,代表选中某一行。
  259. unsigned char ucWd3Update=0; //窗口3的整屏更新显示变量      1代表更新显示,响应函数内部会清零
  260. unsigned char ucWd3Part1Update=0; //窗口3的第1个局部更新显示变量  1代表更新显示,响应函数内部会清零
  261. unsigned char ucWd3Part2Update=0; //窗口3的第2个局部更新显示变量  1代表更新显示,响应函数内部会清零

  262. unsigned char ucWd4Part=1;  //窗口4的局部变量,代表选中某一行。
  263. unsigned char ucWd4Update=0; //窗口4的整屏更新显示变量      1代表更新显示,响应函数内部会清零
  264. unsigned char ucWd4Part1Update=0; //窗口4的第1个局部更新显示变量  1代表更新显示,响应函数内部会清零
  265. unsigned char ucWd4Part2Update=0; //窗口4的第2个局部更新显示变量  1代表更新显示,响应函数内部会清零


  266. unsigned char ucTimeH=2;  //设置时间的上限数据
  267. unsigned char ucTimeL=1;  //设置时间的下限数据

  268. unsigned char ucSpeedH=4;  //设置速度的上限数据
  269. unsigned char ucSpeedL=3;  //设置速度的下限数据

  270. unsigned char ucFreqH=6;  //设置频率的上限数据
  271. unsigned char ucFreqL=5;  //设置频率的下限数据

  272. void main()
  273.   {
  274.         initial_myself();      //第一区,上电后马上初始化
  275.         delay_long(100);       //一线,延时线。延时一段时间
  276.         initial_peripheral();  //第二区,上电后延时一段时间再初始化

  277.         while(1)   //第三区
  278.         {
  279.                     key_service(); //按键服务的应用程序
  280.             lcd_display_service(); //应用层面的液晶屏显示程序
  281.         }

  282. }


  283. void initial_myself()  //第一区 上电后马上初始化
  284. {
  285. /* 注释二:
  286. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  287. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  288. * 坚鸿51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
  289. */
  290.    key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平
  291.    beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。

  292.    TMOD=0x01;  //设置定时器0为工作方式1

  293.    TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  294.    TL0=0x2f;
  295. }
  296. void initial_peripheral() //第二区 上电后延时一段时间再初始化
  297. {
  298.     LCDInit(); //初始化12864 内部包含液晶模块的复位


  299.     EA=1;     //开总中断
  300.     ET0=1;    //允许定时中断
  301.     TR0=1;    //启动定时中断

  302. }


  303. void T0_time() interrupt 1
  304. {
  305.   TF0=0;  //清除中断标志
  306.   TR0=0; //关中断

  307.   key_scan(); //按键扫描函数

  308.   if(uiVoiceCnt!=0)
  309.   {
  310.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  311.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  312.   }
  313.   else
  314.   {
  315.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  316.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  317.   }


  318.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  319.   TL0=0x2f;
  320.   TR0=1;  //开中断
  321. }



  322. void key_scan(void)//按键扫描函数 放在定时中断里
  323. {  


  324.   static unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
  325.   static unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志

  326.   static unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
  327.   static unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

  328.   static unsigned int  uiKeyTimeCnt3=0; //按键去抖动延时计数器
  329.   static unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志

  330.   static unsigned int  uiKeyTimeCnt4=0; //按键去抖动延时计数器
  331.   static unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志

  332.   if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  333.   {
  334.      ucKeyLock1=0; //按键自锁标志清零
  335.      uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  336.   }
  337.   else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  338.   {
  339.      uiKeyTimeCnt1++; //累加定时中断次数
  340.      if(uiKeyTimeCnt1>const_key_time1)
  341.      {
  342.         uiKeyTimeCnt1=0;
  343.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
  344.         ucKeySec=1;    //触发1号键
  345.      }
  346.   }

  347.   if(key_sr2==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  348.   {
  349.      ucKeyLock2=0; //按键自锁标志清零
  350.      uiKeyTimeCnt2=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  351.   }
  352.   else if(ucKeyLock2==0)//有按键按下,且是第一次被按下
  353.   {
  354.      uiKeyTimeCnt2++; //累加定时中断次数
  355.      if(uiKeyTimeCnt2>const_key_time2)
  356.      {
  357.         uiKeyTimeCnt2=0;
  358.         ucKeyLock2=1;  //自锁按键置位,避免一直触发
  359.         ucKeySec=2;    //触发2号键
  360.      }
  361.   }

  362.   if(key_sr3==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  363.   {
  364.      ucKeyLock3=0; //按键自锁标志清零
  365.      uiKeyTimeCnt3=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  366.   }
  367.   else if(ucKeyLock3==0)//有按键按下,且是第一次被按下
  368.   {
  369.      uiKeyTimeCnt3++; //累加定时中断次数
  370.      if(uiKeyTimeCnt3>const_key_time3)
  371.      {
  372.         uiKeyTimeCnt3=0;
  373.         ucKeyLock3=1;  //自锁按键置位,避免一直触发
  374.         ucKeySec=3;    //触发3号键
  375.      }
  376.   }

  377.   if(key_sr4==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  378.   {
  379.      ucKeyLock4=0; //按键自锁标志清零
  380.      uiKeyTimeCnt4=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  381.   }
  382.   else if(ucKeyLock4==0)//有按键按下,且是第一次被按下
  383.   {
  384.      uiKeyTimeCnt4++; //累加定时中断次数
  385.      if(uiKeyTimeCnt4>const_key_time4)
  386.      {
  387.         uiKeyTimeCnt4=0;
  388.         ucKeyLock4=1;  //自锁按键置位,避免一直触发
  389.         ucKeySec=4;    //触发4号键
  390.      }
  391.   }

  392. }


  393. void key_service(void) //按键服务的应用程序
  394. {
  395.   switch(ucKeySec) //按键服务状态切换
  396.   {
  397.     case 1:// 加按键 对应朱兆祺学习板的S1键
  398.           switch(ucWd)  //在不同的窗口下,设置不同的参数
  399.           {
  400.               case 2:  //窗口2  设置时间
  401.                    switch(ucWd2Part)  //在窗口2下,根据不同的局部变量来设置不同的参数
  402.                    {

  403.                           case 1:   //设置时间上限
  404.                                 ucTimeH++;
  405.                                 if(ucTimeH>99)
  406.                                 {
  407.                                    ucTimeH=99;
  408.                                 }
  409.                                 ucWd2Part1Update=1; //1代表更新显示,响应函数内部会清零
  410.                                 break;
  411.                           case 2:   //设置时间下限
  412.                                 ucTimeL++;
  413.                                 if(ucTimeL>99)
  414.                                 {
  415.                                    ucTimeL=99;
  416.                                 }
  417.                                 ucWd2Part2Update=1; //1代表更新显示,响应函数内部会清零
  418.                                 break;
  419.                         
  420.                    }
  421.                    break;         
  422.               case 3:  //窗口3  设置速度
  423.                    switch(ucWd3Part)  //在窗口3下,根据不同的局部变量来设置不同的参数
  424.                    {

  425.                           case 1:   //设置速度上限
  426.                                 ucSpeedH++;
  427.                                 if(ucSpeedH>99)
  428.                                 {
  429.                                    ucSpeedH=99;
  430.                                 }
  431.                                 ucWd3Part1Update=1; //1代表更新显示,响应函数内部会清零
  432.                                 break;
  433.                           case 2:   //设置速度下限
  434.                                 ucSpeedL++;
  435.                                 if(ucSpeedL>99)
  436.                                 {
  437.                                    ucSpeedL=99;
  438.                                 }
  439.                                 ucWd3Part2Update=1; //1代表更新显示,响应函数内部会清零
  440.                                 break;
  441.                         
  442.                    }
  443.                    break;     
  444.               case 4:  //窗口4  设置速度
  445.                    switch(ucWd4Part)  //在窗口4下,根据不同的局部变量来设置不同的参数
  446.                    {

  447.                           case 1:   //设置频率上限
  448.                                 ucFreqH++;
  449.                                 if(ucFreqH>99)
  450.                                 {
  451.                                    ucFreqH=99;
  452.                                 }
  453.                                 ucWd4Part1Update=1; //1代表更新显示,响应函数内部会清零
  454.                                 break;
  455.                           case 2:   //设置频率下限
  456.                                 ucFreqL++;
  457.                                 if(ucFreqL>99)
  458.                                 {
  459.                                    ucFreqL=99;
  460.                                 }
  461.                                 ucWd4Part2Update=1; //1代表更新显示,响应函数内部会清零
  462.                                 break;
  463.                         
  464.                    }
  465.                    break;     
  466.           }     
  467.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  468.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  469.           break;   
  470.    
  471.     case 2:// 减按键 对应朱兆祺学习板的S5键
  472.           switch(ucWd)  //在不同的窗口下,设置不同的参数
  473.           {         
  474.               case 2:  //窗口2 设置时间
  475.                    switch(ucWd2Part)  //在窗口2下,根据不同的局部变量来设置不同的参数
  476.                    {
  477.                           case 1:   //设置时间上限
  478.                                 ucTimeH--;
  479.                                 if(ucTimeH>99) //一直减到最后,单片机C语言编译器有一个特征,0减去1会溢出变成255(0xff)
  480.                                 {
  481.                                    ucTimeH=0;
  482.                                 }
  483.                                 ucWd2Part1Update=1; //1代表更新显示,响应函数内部会清零
  484.                                 break;
  485.                           case 2:   //设置时间下限
  486.                                 ucTimeL--;
  487.                                 if(ucTimeL>99) //一直减到最后,单片机C语言编译器有一个特征,0减去1会溢出变成255(0xff)
  488.                                 {
  489.                                    ucTimeL=0;
  490.                                 }
  491.                                 ucWd2Part2Update=1; //1代表更新显示,响应函数内部会清零
  492.                                 break;
  493.                    }
  494.                    break;         
  495.               case 3:  //窗口3  设置速度
  496.                    switch(ucWd3Part)  //在窗口3下,根据不同的局部变量来设置不同的参数
  497.                    {
  498.                           case 1:   //设置速度上限
  499.                                 ucSpeedH--;
  500.                                 if(ucSpeedH>99) //一直减到最后,单片机C语言编译器有一个特征,0减去1会溢出变成255(0xff)
  501.                                 {
  502.                                    ucSpeedH=0;
  503.                                 }
  504.                                 ucWd3Part1Update=1; //1代表更新显示,响应函数内部会清零
  505.                                 break;
  506.                           case 2:   //设置速度下限
  507.                                 ucSpeedL--;
  508.                                 if(ucSpeedL>99) //一直减到最后,单片机C语言编译器有一个特征,0减去1会溢出变成255(0xff)
  509.                                 {
  510.                                    ucSpeedL=0;
  511.                                 }
  512.                                 ucWd3Part2Update=1; //1代表更新显示,响应函数内部会清零
  513.                                 break;
  514.                    }
  515.                    break;      
  516.               case 4:  //窗口4  设置频率
  517.                    switch(ucWd4Part)  //在窗口4下,根据不同的局部变量来设置不同的参数
  518.                    {
  519.                           case 1:   //设置频率上限
  520.                                 ucFreqH--;
  521.                                 if(ucFreqH>99) //一直减到最后,单片机C语言编译器有一个特征,0减去1会溢出变成255(0xff)
  522.                                 {
  523.                                    ucFreqH=0;
  524.                                 }
  525.                                 ucWd4Part1Update=1; //1代表更新显示,响应函数内部会清零
  526.                                 break;
  527.                           case 2:   //设置频率下限
  528.                                 ucFreqL--;
  529.                                 if(ucFreqL>99) //一直减到最后,单片机C语言编译器有一个特征,0减去1会溢出变成255(0xff)
  530.                                 {
  531.                                    ucFreqL=0;
  532.                                 }
  533.                                 ucWd4Part2Update=1; //1代表更新显示,响应函数内部会清零
  534.                                 break;
  535.                    }
  536.                    break;   
  537.           }     
  538.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  539.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  540.           break;  

  541.     case 3:// 切换"光标"移动按键 对应朱兆祺学习板的S9键
  542.           switch(ucWd)  //在不同的窗口下,设置不同的参数
  543.           {
  544.               case 1: //窗口1 主菜单
  545.                    switch(ucWd1Part)  //在窗口1下,根据不同的局部变量来设置不同的参数
  546.                    {

  547.                           case 1:   //设置时间
  548.                                 ucWd1Part=2; //光标切换到下一行
  549.                                 ucWd1Part1Update=1; //更新显示原来那一行,目的是更新反显光标的状态
  550.                                 ucWd1Part2Update=1; //更新显示下一行,    目的是更新反显光标的状态
  551.                                 break;
  552.                           case 2:   //设置速度
  553.                                 ucWd1Part=3; //光标切换到下一行
  554.                                 ucWd1Part2Update=1; //更新显示原来那一行,目的是更新反显光标的状态
  555.                                 ucWd1Part3Update=1; //更新显示下一行,    目的是更新反显光标的状态
  556.                                 break;
  557.                           case 3:   //设置第3行参数
  558.                                 ucWd1Part=1; //光标返回到第一行
  559.                                 ucWd1Part3Update=1; //更新显示原来那一行,目的是更新反显光标的状态
  560.                                 ucWd1Part1Update=1; //更新显示下一行,    目的是更新反显光标的状态
  561.                                 break;


  562.                    }
  563.                    break;
  564.               case 2: //窗口2 设置时间
  565.                    switch(ucWd2Part)  //在窗口2下,根据不同的局部变量来设置不同的参数
  566.                    {

  567.                           case 1:   //时间上限
  568.                                 ucWd2Part=2; //光标切换到下一行
  569.                                 ucWd2Part1Update=1; //更新显示原来那一行,目的是更新反显光标的状态
  570.                                 ucWd2Part2Update=1; //更新显示下一行,    目的是更新反显光标的状态
  571.                                 break;
  572.                           case 2:   //时间下限
  573.                                 ucWd2Part=1; //光标返回到第一行
  574.                                 ucWd2Part2Update=1; //更新显示原来那一行,目的是更新反显光标的状态
  575.                                 ucWd2Part1Update=1; //更新显示下一行,    目的是更新反显光标的状态
  576.                                 break;

  577.                    }
  578.                    break;      
  579.               case 3: //窗口3 设置速度
  580.                    switch(ucWd3Part)  //在窗口3下,根据不同的局部变量来设置不同的参数
  581.                    {

  582.                           case 1:   //速度上限
  583.                                 ucWd3Part=2; //光标切换到下一行
  584.                                 ucWd3Part1Update=1; //更新显示原来那一行,目的是更新反显光标的状态
  585.                                 ucWd3Part2Update=1; //更新显示下一行,    目的是更新反显光标的状态
  586.                                 break;
  587.                           case 2:   //速度下限
  588.                                 ucWd3Part=1; //光标返回到第一行
  589.                                 ucWd3Part2Update=1; //更新显示原来那一行,目的是更新反显光标的状态
  590.                                 ucWd3Part1Update=1; //更新显示下一行,    目的是更新反显光标的状态
  591.                                 break;

  592.                    }
  593.                    break;      
  594.               case 4: //窗口4 设置频率
  595.                    switch(ucWd4Part)  //在窗口4下,根据不同的局部变量来设置不同的参数
  596.                    {

  597.                           case 1:   //频率上限
  598.                                 ucWd4Part=2; //光标切换到下一行
  599.                                 ucWd4Part1Update=1; //更新显示原来那一行,目的是更新反显光标的状态
  600.                                 ucWd4Part2Update=1; //更新显示下一行,    目的是更新反显光标的状态
  601.                                 break;
  602.                           case 2:   //频率下限
  603.                                 ucWd4Part=1; //光标返回到第一行
  604.                                 ucWd4Part2Update=1; //更新显示原来那一行,目的是更新反显光标的状态
  605.                                 ucWd4Part1Update=1; //更新显示下一行,    目的是更新反显光标的状态
  606.                                 break;

  607.                    }
  608.                    break;     
  609.           }         
  610.         
  611.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  612.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  613.           break;      
  614.    
  615.     case 4: // 进入和退出按键  对应朱兆祺学习板的S13键,按一次进入选中的子菜单。再按一次退出子菜单。
  616.           switch(ucWd)  //在不同的窗口下,设置不同的参数
  617.           {
  618.               case 1:  //窗口1                               
  619.                    switch(ucWd1Part)  //在窗口1下,根据不同的局部变量来设置不同的参数
  620.                    {

  621.                           case 1:   //设置时间
  622.                                                         ucWd=2; //进入设置时间的窗口2
  623.                                                                 ucWd2Update=1; //窗口2整屏更新
  624.                                 break;
  625.                           case 2:   //设置速度
  626.                                                         ucWd=3; //进入设置速度的窗口3
  627.                                                                 ucWd3Update=1; //窗口3整屏更新
  628.                                 break;
  629.                           case 3:   //设置频率
  630.                                                         ucWd=4; //进入设置频率的窗口4
  631.                                                                 ucWd4Update=1; //窗口4整屏更新
  632.                                 break;


  633.                    }
  634.                    break;
  635.               case 2:  //窗口2
  636.                                    ucWd=1;        //返回主菜单窗口1
  637.                                    ucWd1Update=1; //窗口1整屏更新
  638.                    break;      
  639.               case 3:  //窗口3
  640.                                    ucWd=1;        //返回主菜单窗口1
  641.                                    ucWd1Update=1; //窗口1整屏更新
  642.                    break;   
  643.                case 4:  //窗口4
  644.                                    ucWd=1;        //返回主菜单窗口1
  645.                                    ucWd1Update=1; //窗口1整屏更新
  646.                    break;   

  647.           }   

  648.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  649.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  650.           break;         

  651.   }               
  652. }


  653. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
  654. {
  655.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小,分别调用不同的字库。

  656.         switch(ucBitNumber)  //根据ucBitNumber数值的大小,分别调用不同的字库。
  657.         {
  658.             case 0:
  659.              p_ucAnyNumber=Zf816_0;
  660.                      break;
  661.             case 1:
  662.              p_ucAnyNumber=Zf816_1;
  663.                      break;
  664.             case 2:
  665.              p_ucAnyNumber=Zf816_2;
  666.                      break;
  667.             case 3:
  668.              p_ucAnyNumber=Zf816_3;
  669.                      break;
  670.             case 4:
  671.              p_ucAnyNumber=Zf816_4;
  672.                      break;
  673.             case 5:
  674.              p_ucAnyNumber=Zf816_5;
  675.                      break;
  676.             case 6:
  677.              p_ucAnyNumber=Zf816_6;
  678.                      break;
  679.             case 7:
  680.              p_ucAnyNumber=Zf816_7;
  681.                      break;
  682.             case 8:
  683.              p_ucAnyNumber=Zf816_8;
  684.                      break;
  685.             case 9:
  686.              p_ucAnyNumber=Zf816_9;
  687.                      break;
  688.             case 10:
  689.              p_ucAnyNumber=Zf816_nc;
  690.                      break;
  691.                 default:   //如果上面的条件都不符合,那么默认指向空字模
  692.              p_ucAnyNumber=Zf816_nc;
  693.                      break;
  694.         }

  695.     return p_ucAnyNumber;  //返回转换结束后的指针
  696. }



  697. void lcd_display_service(void) //应用层面的液晶屏显示程序
  698. {

  699.     switch(ucWd)  //本程序的核心变量,窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  700.     {
  701.         case 1:  
  702.               wd1();  //主菜单
  703.               break;
  704.         case 2:  
  705.               wd2();  //设置时间
  706.               break;
  707.         case 3:  
  708.               wd3();  //设置速度
  709.               break;
  710.         case 4:  
  711.               wd4();  //设置频率
  712.               break;

  713.         //本程序只有4个窗口,所以只有4个case ,如果要增加窗口,就直接增加 case 5, case 6...        
  714.     }

  715. }


  716. void wd1(void)  //窗口1  主菜单
  717. {

  718.     unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的

  719. /* 注释三:
  720. * 把每一个窗口的内容分为两种类型,一种类型是那些不用经常刷新显示的内容,只有在切换窗口的时候
  721. * 才需要更新,这种内容放在整屏更新显示的括号里,比如清屏操作等内容。另外一种是那些经常需要
  722. * 刷新显示的内容,这种内容放在局部更新显示的括号里。
  723. */
  724.     if(ucWd1Update==1)  //窗口1整屏更新,里面只放那些不用经常刷新显示的内容
  725.     {
  726.         ucWd1Update=0;  //及时清零,避免一直更新

  727.         ucWd1Part1Update=1; //激活窗口1的第1个局部更新显示变量
  728.         ucWd1Part2Update=1; //激活窗口1的第2个局部更新显示变量
  729.         ucWd1Part3Update=1; //激活窗口1的第3个局部更新显示变量


  730.         display_clear(0x00); // 清屏操作, 全部显示空填充0x00,全部显示点阵用0xff。
  731.         clear_all_canvas();  //把画布全部清零
  732.         insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布

  733.         display_lattice(2,0,Hz1616_zhu,0,2,16,0);    //主菜单。这些内容不用经常更新,只有在切换窗口的时候才更新显示
  734.         display_lattice(3,0,Hz1616_cai,0,2,16,0);
  735.         display_lattice(4,0,Hz1616_dan,0,2,16,0);


  736.     }

  737. /* 注释四:
  738. * 注意!我前面讲数码管显示的时候有一句话讲错了,我那时说<局部更新应该写在整屏更新之前>,这是不对的。
  739. * 按照现在的显示程序框架<即整屏显示更新括号里包含了所有局部变量的激活>,应该是<整屏更新应该写在局部更新之前>
  740. * 这样才对。
  741. */
  742.     if(ucWd1Part1Update==1) //窗口1的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
  743.     {
  744.         ucWd1Part1Update=0; //及时清零,避免一直更新

  745.         if(ucWd1Part==1) //被选中
  746.         {
  747.              ucCursorFlag=1; //反显 显示
  748.         }
  749.         else //没被选中
  750.         {
  751.              ucCursorFlag=0; //正常 显示
  752.         }

  753.                 display_lattice(0,16,Hz1616_she,ucCursorFlag,2,16,0);    //设置时间范围
  754.         display_lattice(1,16,Hz1616_zhi,ucCursorFlag,2,16,0);   
  755.         display_lattice(2,16,Hz1616_shi,ucCursorFlag,2,16,0);   
  756.         display_lattice(3,16,Hz1616_jian,ucCursorFlag,2,16,0);
  757.         display_lattice(4,16,Hz1616_fan,ucCursorFlag,2,16,0);   
  758.         display_lattice(5,16,Hz1616_wei,ucCursorFlag,2,16,0);


  759.                           
  760.     }

  761.     if(ucWd1Part2Update==1) //窗口1的第2个局部更新显示变量,里面放一些经常需要刷新显示的内容
  762.     {
  763.          ucWd1Part2Update=0; //及时清零,避免一直更新

  764.          if(ucWd1Part==2) //被选中
  765.          {
  766.              ucCursorFlag=1; //反显 显示
  767.          }
  768.          else //没被选中
  769.          {
  770.              ucCursorFlag=0; //正常 显示
  771.          }

  772.          display_lattice(8,0,Hz1616_she,ucCursorFlag,2,16,0);      //设置速度范围
  773.          display_lattice(9,0,Hz1616_zhi,ucCursorFlag,2,16,0);   
  774.          display_lattice(10,0,Hz1616_su,ucCursorFlag,2,16,0);   
  775.          display_lattice(11,0,Hz1616_du,ucCursorFlag,2,16,0);
  776.          display_lattice(12,0,Hz1616_fan,ucCursorFlag,2,16,0);   
  777.          display_lattice(13,0,Hz1616_wei,ucCursorFlag,2,16,0);
  778.                           
  779.      }

  780.      if(ucWd1Part3Update==1) //窗口1的第3行局部更新显示变量,里面放一些经常需要刷新显示的内容
  781.      {
  782.          ucWd1Part3Update=0; //及时清零,避免一直更新

  783.          if(ucWd1Part==3) //被选中
  784.          {
  785.              ucCursorFlag=1; //反显 显示
  786.          }
  787.          else //没被选中
  788.          {
  789.              ucCursorFlag=0; //正常 显示
  790.          }

  791.          display_lattice(8,16,Hz1616_she,ucCursorFlag,2,16,0);    //设置频率范围
  792.          display_lattice(9,16,Hz1616_zhi,ucCursorFlag,2,16,0);   
  793.          display_lattice(10,16,Hz1616_pin,ucCursorFlag,2,16,0);   
  794.          display_lattice(11,16,Hz1616_lv,ucCursorFlag,2,16,0);
  795.          display_lattice(12,16,Hz1616_fan,ucCursorFlag,2,16,0);   
  796.          display_lattice(13,16,Hz1616_wei,ucCursorFlag,2,16,0);                           
  797.      }

  798.   
  799. }


  800. void wd2(void)  //窗口2 设置时间
  801. {
  802.     unsigned char ucAnyNumber_1; //分解变量的个位
  803.     unsigned char ucAnyNumber_10; //分解变量的十位


  804.     unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后,分解变量的个位字模首地址
  805.     unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后,分解变量的十位字模首地址

  806.     unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的

  807.     if(ucWd2Update==1)  //窗口2整屏更新,里面只放那些不用经常刷新显示的内容
  808.     {
  809.         ucWd2Update=0;  //及时清零,避免一直更新

  810.         ucWd2Part1Update=1; //激活窗口2的第1个局部更新显示变量,这里在前面数码管显示框架上有所改进
  811.         ucWd2Part2Update=1; //激活窗口2的第2个局部更新显示变量,这里在前面数码管显示框架上有所改进

  812.         display_clear(0x00); // 清屏操作, 全部显示空填充0x00,全部显示点阵用0xff。
  813.         clear_all_canvas();  //把画布全部清零
  814.         insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布


  815.         display_lattice(2,0,Hz1616_she,0,2,16,0);    //设置时间。这些内容不用经常更新,只有在切换窗口的时候才更新显示
  816.         display_lattice(3,0,Hz1616_zhi,0,2,16,0);
  817.         display_lattice(4,0,Hz1616_shi,0,2,16,0);
  818.         display_lattice(5,0,Hz1616_jian,0,2,16,0);


  819.                 display_lattice(0,16,Hz1616_shi,0,2,16,0);    //时间上限
  820.         display_lattice(1,16,Hz1616_jian,0,2,16,0);   
  821.         display_lattice(2,16,Hz1616_shang,0,2,16,0);   
  822.         display_lattice(3,16,Hz1616_xian,0,2,16,0);

  823.         display_lattice(8,0,Hz1616_shi,0,2,16,0);  //时间下限
  824.         display_lattice(9,0,Hz1616_jian,0,2,16,0);   
  825.         display_lattice(10,0,Hz1616_xia,0,2,16,0);   
  826.         display_lattice(11,0,Hz1616_xian,0,2,16,0);

  827.     }

  828.     if(ucWd2Part1Update==1) //窗口2的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
  829.     {
  830.         ucWd2Part1Update=0; //及时清零,避免一直更新

  831.         if(ucWd2Part==1) //被选中
  832.         {
  833.              ucCursorFlag=1; //反显 显示
  834.         }
  835.         else //没被选中
  836.         {
  837.              ucCursorFlag=0; //正常 显示
  838.         }

  839.         if(ucTimeH>=10) //有2位数以上
  840.         {
  841.              ucAnyNumber_10=ucTimeH/10;  //十位
  842.         }
  843.         else //否则显示空
  844.         {
  845.              ucAnyNumber_10=10;  //在下面的转换函数中,代码10表示空字模
  846.         }

  847.         ucAnyNumber_1=ucTimeH%10/1;  //个位

  848.    
  849.         p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  850.         p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


  851.         insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
  852.         insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布

  853.         display_lattice(4,16,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量

  854.                           
  855.     }

  856.     if(ucWd2Part2Update==1) //窗口2的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
  857.     {
  858.          ucWd2Part2Update=0; //及时清零,避免一直更新

  859.          if(ucWd2Part==2) //被选中
  860.          {
  861.              ucCursorFlag=1; //反显 显示
  862.          }
  863.          else //没被选中
  864.          {
  865.              ucCursorFlag=0; //正常 显示
  866.          }

  867.          if(ucTimeL>=10) //有2位数以上
  868.          {
  869.              ucAnyNumber_10=ucTimeL/10;  //十位
  870.          }
  871.          else //否则显示空
  872.          {
  873.              ucAnyNumber_10=10;  //在下面的转换函数中,代码10表示空字模
  874.          }

  875.          ucAnyNumber_1=ucTimeL%10/1;  //个位

  876.    
  877.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  878.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


  879.          insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
  880.          insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布

  881.          display_lattice(12,0,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
  882.                           
  883.      }

  884.    
  885. }



  886. void wd3(void)  //窗口3 设置速度
  887. {
  888.     unsigned char ucAnyNumber_1; //分解变量的个位
  889.     unsigned char ucAnyNumber_10; //分解变量的十位


  890.     unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后,分解变量的个位字模首地址
  891.     unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后,分解变量的十位字模首地址

  892.     unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的

  893.     if(ucWd3Update==1)  //窗口3整屏更新,里面只放那些不用经常刷新显示的内容
  894.     {
  895.         ucWd3Update=0;  //及时清零,避免一直更新

  896.         ucWd3Part1Update=1; //激活窗口3的第1个局部更新显示变量,这里在前面数码管显示框架上有所改进
  897.         ucWd3Part2Update=1; //激活窗口3的第2个局部更新显示变量,这里在前面数码管显示框架上有所改进

  898.         display_clear(0x00); // 清屏操作, 全部显示空填充0x00,全部显示点阵用0xff。
  899.         clear_all_canvas();  //把画布全部清零
  900.         insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布


  901.         display_lattice(2,0,Hz1616_she,0,2,16,0);    //设置速度。这些内容不用经常更新,只有在切换窗口的时候才更新显示
  902.         display_lattice(3,0,Hz1616_zhi,0,2,16,0);
  903.         display_lattice(4,0,Hz1616_su,0,2,16,0);
  904.         display_lattice(5,0,Hz1616_du,0,2,16,0);


  905.                 display_lattice(0,16,Hz1616_su,0,2,16,0);    //速度上限
  906.         display_lattice(1,16,Hz1616_du,0,2,16,0);   
  907.         display_lattice(2,16,Hz1616_shang,0,2,16,0);   
  908.         display_lattice(3,16,Hz1616_xian,0,2,16,0);

  909.         display_lattice(8,0,Hz1616_su,0,2,16,0);  //速度下限
  910.         display_lattice(9,0,Hz1616_du,0,2,16,0);   
  911.         display_lattice(10,0,Hz1616_xia,0,2,16,0);   
  912.         display_lattice(11,0,Hz1616_xian,0,2,16,0);

  913.     }

  914.     if(ucWd3Part1Update==1) //窗口3的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
  915.     {
  916.         ucWd3Part1Update=0; //及时清零,避免一直更新

  917.         if(ucWd3Part==1) //被选中
  918.         {
  919.              ucCursorFlag=1; //反显 显示
  920.         }
  921.         else //没被选中
  922.         {
  923.              ucCursorFlag=0; //正常 显示
  924.         }

  925.         if(ucSpeedH>=10) //有2位数以上
  926.         {
  927.              ucAnyNumber_10=ucSpeedH/10;  //十位
  928.         }
  929.         else //否则显示空
  930.         {
  931.              ucAnyNumber_10=10;  //在下面的转换函数中,代码10表示空字模
  932.         }

  933.         ucAnyNumber_1=ucSpeedH%10/1;  //个位

  934.    
  935.         p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  936.         p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


  937.         insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
  938.         insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布

  939.         display_lattice(4,16,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量

  940.                           
  941.     }

  942.     if(ucWd3Part2Update==1) //窗口3的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
  943.     {
  944.          ucWd3Part2Update=0; //及时清零,避免一直更新

  945.          if(ucWd3Part==2) //被选中
  946.          {
  947.              ucCursorFlag=1; //反显 显示
  948.          }
  949.          else //没被选中
  950.          {
  951.              ucCursorFlag=0; //正常 显示
  952.          }

  953.          if(ucSpeedL>=10) //有2位数以上
  954.          {
  955.              ucAnyNumber_10=ucSpeedL/10;  //十位
  956.          }
  957.          else //否则显示空
  958.          {
  959.              ucAnyNumber_10=10;  //在下面的转换函数中,代码10表示空字模
  960.          }

  961.          ucAnyNumber_1=ucSpeedL%10/1;  //个位

  962.    
  963.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  964.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


  965.          insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
  966.          insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布

  967.          display_lattice(12,0,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
  968.                           
  969.      }

  970.    
  971. }



  972. void wd4(void)  //窗口4 设置频率
  973. {
  974.     unsigned char ucAnyNumber_1; //分解变量的个位
  975.     unsigned char ucAnyNumber_10; //分解变量的十位


  976.     unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后,分解变量的个位字模首地址
  977.     unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后,分解变量的十位字模首地址

  978.     unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的

  979.     if(ucWd4Update==1)  //窗口4整屏更新,里面只放那些不用经常刷新显示的内容
  980.     {
  981.         ucWd4Update=0;  //及时清零,避免一直更新

  982.         ucWd4Part1Update=1; //激活窗口4的第1个局部更新显示变量,这里在前面数码管显示框架上有所改进
  983.         ucWd4Part2Update=1; //激活窗口4的第2个局部更新显示变量,这里在前面数码管显示框架上有所改进

  984.         display_clear(0x00); // 清屏操作, 全部显示空填充0x00,全部显示点阵用0xff。
  985.         clear_all_canvas();  //把画布全部清零
  986.         insert_buffer_to_canvas(0,0,Zf816_mao_hao,0,1,16);//把冒号的字模插入画布


  987.         display_lattice(2,0,Hz1616_she,0,2,16,0);    //设置频率。这些内容不用经常更新,只有在切换窗口的时候才更新显示
  988.         display_lattice(3,0,Hz1616_zhi,0,2,16,0);
  989.         display_lattice(4,0,Hz1616_pin,0,2,16,0);
  990.         display_lattice(5,0,Hz1616_lv,0,2,16,0);


  991.                 display_lattice(0,16,Hz1616_pin,0,2,16,0);    //频率上限
  992.         display_lattice(1,16,Hz1616_lv,0,2,16,0);   
  993.         display_lattice(2,16,Hz1616_shang,0,2,16,0);   
  994.         display_lattice(3,16,Hz1616_xian,0,2,16,0);

  995.         display_lattice(8,0,Hz1616_pin,0,2,16,0);  //频率下限
  996.         display_lattice(9,0,Hz1616_lv,0,2,16,0);   
  997.         display_lattice(10,0,Hz1616_xia,0,2,16,0);   
  998.         display_lattice(11,0,Hz1616_xian,0,2,16,0);

  999.     }

  1000.     if(ucWd4Part1Update==1) //窗口4的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
  1001.     {
  1002.         ucWd4Part1Update=0; //及时清零,避免一直更新

  1003.         if(ucWd4Part==1) //被选中
  1004.         {
  1005.              ucCursorFlag=1; //反显 显示
  1006.         }
  1007.         else //没被选中
  1008.         {
  1009.              ucCursorFlag=0; //正常 显示
  1010.         }

  1011.         if(ucFreqH>=10) //有2位数以上
  1012.         {
  1013.              ucAnyNumber_10=ucFreqH/10;  //十位
  1014.         }
  1015.         else //否则显示空
  1016.         {
  1017.              ucAnyNumber_10=10;  //在下面的转换函数中,代码10表示空字模
  1018.         }

  1019.         ucAnyNumber_1=ucFreqH%10/1;  //个位

  1020.    
  1021.         p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  1022.         p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


  1023.         insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
  1024.         insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布

  1025.         display_lattice(4,16,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量

  1026.                           
  1027.     }

  1028.     if(ucWd4Part2Update==1) //窗口4的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
  1029.     {
  1030.          ucWd4Part2Update=0; //及时清零,避免一直更新

  1031.          if(ucWd4Part==2) //被选中
  1032.          {
  1033.              ucCursorFlag=1; //反显 显示
  1034.          }
  1035.          else //没被选中
  1036.          {
  1037.              ucCursorFlag=0; //正常 显示
  1038.          }

  1039.          if(ucFreqL>=10) //有2位数以上
  1040.          {
  1041.              ucAnyNumber_10=ucFreqL/10;  //十位
  1042.          }
  1043.          else //否则显示空
  1044.          {
  1045.              ucAnyNumber_10=10;  //在下面的转换函数中,代码10表示空字模
  1046.          }

  1047.          ucAnyNumber_1=ucFreqL%10/1;  //个位

  1048.    
  1049.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  1050.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


  1051.          insert_buffer_to_canvas(2,0,p_ucAnyNumber_10,ucCursorFlag,1,16);//把十的字模插入画布
  1052.          insert_buffer_to_canvas(3,0,p_ucAnyNumber_1,ucCursorFlag,1,16);//把个的字模插入画布

  1053.          display_lattice(12,0,ucCanvasBuffer,0,4,16,0);   //显示整屏的画布,最后的参数0是偏移量
  1054.                           
  1055.      }

  1056.    
  1057. }


  1058. void clear_all_canvas(void)  //把画布全部清零
  1059. {
  1060.    unsigned int j=0;
  1061.    unsigned int i=0;

  1062.    for(j=0;j<16;j++)  //这里的16表示画布有16行
  1063.    {
  1064.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
  1065.       {
  1066.                   ucCanvasBuffer[j*4+i]=0x00;
  1067.       }
  1068.    }         

  1069. }





  1070. void display_clear(unsigned char ucFillDate) // 清屏  全部显示空填充0x00   全部显示点阵用0xff
  1071. {   

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

  1087. }

  1088. /* 注释五:
  1089. * 把字模插入画布的函数.
  1090. * 这是本节的核心函数,读者尤其要搞懂x_amount和y_amount对应的显示关系。
  1091. * 第1,2个参数x,y是在画布中的坐标体系。
  1092. * x的范围是0至3,因为画布的横向只要4个字节。y的范围是0至15,因为画布的纵向只有16行。
  1093. * 第3个参数*ucArray是字模的数组。
  1094. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示,1代表反白显示。
  1095. * 第5,6个参数x_amount,y_amount分别代表字模数组的横向有多少个字节,纵向有几横。
  1096. */
  1097. 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)
  1098. {
  1099.    unsigned int j=0;
  1100.    unsigned int i=0;
  1101.    unsigned char ucTemp;
  1102.    for(j=0;j<y_amount;j++)
  1103.    {
  1104.       for(i=0;i<x_amount;i++)
  1105.       {
  1106.                    ucTemp=ucArray[j*x_amount+i];
  1107.                    if(ucFbFlag==0)
  1108.                    {
  1109.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
  1110.                    }
  1111.                    else
  1112.                    {
  1113.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
  1114.                    }
  1115.       }
  1116.    }         

  1117. }

  1118. /* 注释六:
  1119. * 显示任意点阵函数.
  1120. * 注意,本函数在前几节的基础上多增加了第7个参数uiOffSetAddr,它是偏移地址。
  1121. * 对于这个函数,读者尤其要搞懂x_amount和y_amount对应的显示关系。
  1122. * 第1,2个参数x,y是坐标体系。x的范围是0至15,y的范围是0至31.
  1123. * 第3个参数*ucArray是字模的数组。
  1124. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示,1代表反白显示。
  1125. * 第5,6个参数x_amount,y_amount分别代表字模数组的横向有多少个字节,纵向有几横。
  1126. * 第7个参数uiOffSetAddr是偏移地址,代表字模数组的从第几个数据开始显示。
  1127. */
  1128. 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)
  1129. {
  1130.    unsigned int j=0;
  1131.    unsigned int i=0;
  1132.    unsigned char ucTemp;

  1133. //注意,要把以下两行指令屏蔽,否则屏幕在更新显示时会整屏闪动
  1134. //  WriteCommand(0x34);  //关显示缓冲指令            
  1135. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次,怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  1136.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  1137.    {
  1138.        WriteCommand(y+j+0x80);        //垂直地址
  1139.        WriteCommand(x+0x80);          //水平地址
  1140.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  1141.        {
  1142.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
  1143.            if(ucFbFlag==1)  //反白显示
  1144.            {
  1145.                ucTemp=~ucTemp;
  1146.            }
  1147.            LCDWriteData(ucTemp);
  1148.           //         delay_short(30000);  //把上一节这个延时函数去掉,加快刷屏速度
  1149.       }
  1150.    }
  1151.    WriteCommand(0x36); //开显示缓冲指令
  1152. }




  1153. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  1154. {
  1155.         unsigned char i;
  1156.         for ( i = 0; i < 8; i++ )
  1157.         {
  1158.                 if ( (ucData << i) & 0x80 )
  1159.                 {
  1160.                         LCDSID_dr = 1;
  1161.                 }
  1162.                 else
  1163.                 {
  1164.                         LCDSID_dr = 0;
  1165.                 }
  1166.                 LCDCLK_dr = 0;
  1167.                 LCDCLK_dr = 1;
  1168.         }
  1169. }

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


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

  1178.         LCDCS_dr = 0;
  1179.         LCDCS_dr = 1;
  1180.         SPIWrite(ucCommand, 0);
  1181.         delay_short(90);
  1182. }

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

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



  1195. void delay_short(unsigned int uiDelayShort) //延时函数
  1196. {
  1197.    unsigned int i;  
  1198.    for(i=0;i<uiDelayShort;i++)
  1199.    {
  1200.      ;  
  1201.    }
  1202. }


  1203. void delay_long(unsigned int uiDelayLong)
  1204. {
  1205.    unsigned int i;
  1206.    unsigned int j;
  1207.    for(i=0;i<uiDelayLong;i++)
  1208.    {
  1209.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  1210.           {
  1211.              ; //一个分号相当于执行一条空语句
  1212.           }
  1213.    }
  1214. }
复制代码

总结陈词:
    我前面几节液晶屏程序的字模都是通过外围工具软件生成的,其实这款12864液晶模块本身就是自带字库,编程的时候只要在源代码里直接写入所需要的汉字或者字符,就可以自动调用相对应的字库了。但是细心的网友一定会问,为什么在源代码上直接写入某个汉字就可以调用到这个汉字的字库?在这个过程中,C51编译器到底还干了哪些鲜为人知的好事?欲知详情,请听下回分解-----液晶屏自带字库跟汉字机内码的关系。
(未完待续,下节更精彩,不要走开哦)
乐于分享,勇于质疑!
发表于 2014-10-30 22:32:04 | 显示全部楼层
鸿哥,辛苦了,值得敬佩。
乐于分享,勇于质疑!
 楼主| 发表于 2014-11-3 15:11:53 | 显示全部楼层
第八十节:调用液晶屏内部字库来显示汉字或字符的坐标体系和本质。

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

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


(1)硬件平台:基于坚鸿51单片机学习板。

(2)实现功能:
     开机上电后,液晶屏第一行调用直接汉字书写方式的数组来显示(馒头V5)的内容。第四行调用机内码和ASCII码的数组来显示(馒头V5)的内容。
80节图片.jpg
(3)源代码讲解如下:
  1. #include "REG52.H"

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

  6. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  7. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  8. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  9. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  10. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  11. void display_clear(void); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。

  12. void display_hz1616(unsigned int x,unsigned int y,const unsigned char  *ucArray);
  13. void display_double_zf816(unsigned int x,unsigned int y,const unsigned char  *ucArray1,const unsigned char  *ucArray2);

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

  15. /* 注释一:内部字库的真实坐标体系的本质。
  16. * 当我们用内部字库的时候,它的坐标体系跟前面讲的自造字库坐标不一样,不再是256x32的液晶屏。
  17. * 它还原成为128x64的液晶屏,横坐标x轴坐标没办法精确到每个点,只能以16个点(2个字节)为一个单位,
  18. * 因此128个点的x轴坐标范围是0至8。而y轴的坐标也是以16个点(2个字节)为一个单位,因此64个点的x轴
  19. * 坐标范围是0至3。以下是坐标地址的位置编码。把12864液晶屏分成4行8列,每个数代表一个坐标点,
  20. * 用深究具体含义,液晶驱动芯片ST7920的手册上有提到。
  21. */
  22. code unsigned char  ucAddrTable[]=  //调用内部字库时,液晶屏的坐标体系,位置编码,是驱动内容,读者可以不用深究它的含义。
  23. {     
  24. 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
  25. 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
  26. 0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
  27. 0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,
  28. };


  29. /* 注释二:在使用内部字库时,C51编译器暗地里干了啥?
  30. * 如果使用液晶屏内部自带字库,以下编程的时候只要在源代码里直接写入所需要的汉字或者字符,
  31. * 就可以自动调用相对应的字库了。但是细心的网友一定会问,为什么在源代码上直接写入某个汉字
  32. * 就可以调用到这个汉字的字库?其实,表面上我们写下具体的某个汉字或者字符,但是C51编译器
  33. * 会自动对数组内的汉字翻译成 机内码(2字节),会自动对数组内的字符翻译成 ASCII码(1字节)。
  34. * 本节程序会做这个实验来验证它。以下两种书写方式不一样,但本质是一样的。
  35. */

  36. code unsigned char Hz1616_man[]="馒"; //对于数组内的汉字,编译会自动翻译成 机内码(2字节)
  37. code unsigned char JN1616_man[]=  //机内码  馒  网上有很多把汉字或者字符转换成相关编码的工具软件
  38. {
  39. 0xC2,
  40. 0xF8,
  41. };

  42. code unsigned char Hz1616_tou[]="头"; //对于数组内的汉字,编译会自动翻译成 机内码(2字节)
  43. code unsigned char JN1616_tou[]=  //机内码  头  网上有很多把汉字或者字符转换成相关编码的工具软件
  44. {
  45. 0xCD,
  46. 0xB7,
  47. };

  48. code unsigned char Zf816_V[]="V";     //对于数组内的字符,编译会自动翻译成 ASCII码(1字节)
  49. code unsigned char ASCII816_V[]= //ASCII码  V  网上有很多把汉字或者字符转换成相关编码的工具软件
  50. {
  51. 0x56,
  52. };

  53. code unsigned char Zf816_5[]="5";     //对于数组内的字符,编译会自动翻译成 ASCII码(1字节)
  54. code unsigned char ASCII816_5[]= //ASCII码  5  网上有很多把汉字或者字符转换成相关编码的工具软件
  55. {
  56. 0x35,
  57. };


  58. code unsigned char Zf816_nc[]=" ";     //对于数组内的字符,编译会自动翻译成 ASCII码(1字节)
  59. code unsigned char ASCII816_nc[]= //ASCII码  空字符  网上有很多把汉字或者字符转换成相关编码的工具软件
  60. {
  61. 0x20,
  62. };


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

  66. /* 注释三:
  67. * 12864的控制芯片st7920内部有两套驱动显示指令方式,一种是前面章节讲的自构字库模式,也是图像模式。
  68. * 另外一种就是本节讲的用内部字库模式。以下是切换模式的命令,命令字0x0c表示用内部字库模式。
  69. * 命令字0x36表示用自构字库模式。
  70. */
  71.         WriteCommand(0x0C); //命令字0x0c表示用内部字库模式。命令字0x36表示用自构字库模式。

  72.         display_clear(); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。


  73.         display_hz1616(0,0,Hz1616_man);  //第一行,调用直接汉字书写方式的数组来显示(馒头V5),
  74.         display_hz1616(1,0,Hz1616_tou);
  75.         display_double_zf816(2,0,Zf816_V,Zf816_5);

  76.         display_hz1616(0,3,JN1616_man);  //第四行,调用机内码和ASCII码的数组来显示(馒头V5),
  77.         display_hz1616(1,3,JN1616_tou);
  78.         display_double_zf816(2,3,ASCII816_V,Zf816_5);


  79.         while(1)  
  80.         {
  81.            ;
  82.         }

  83. }


  84. /* 注释四:在一个坐标点显示1个内部字库汉字的函数
  85. * 第1,2个参数x,y是坐标体系。x的范围是0至8,y的范围是0至3.
  86. * 第3个参数*ucArray是汉字机内码,是有2个字节的数组。
  87. */
  88. void display_hz1616(unsigned int x,unsigned int y,const unsigned char  *ucArray)
  89. {
  90.     WriteCommand(0x30);   //基本指令集
  91.         WriteCommand(ucAddrTable[8*y+x]);        //起始位置
  92.         LCDWriteData(ucArray[0]);
  93.         LCDWriteData(ucArray[1]);
  94. }

  95. /* 注释五:在一个坐标点显示2个内部字库字符的函数
  96. * 注意,由于一个坐标点是16x16点阵,而一个字符是8x16点阵的,所以务必要显示2个字符筹够1个坐标点。
  97. * 第1,2个参数x,y是坐标体系。x的范围是0至8,y的范围是0至3.
  98. * 第3个参数*ucArray1是左边第1个字符ASCII码,是有1个字节的数组。
  99. * 第4个参数*ucArray2是右边第2个字符ASCII码,是有1个字节的数组。
  100. */
  101. void display_double_zf816(unsigned int x,unsigned int y,const unsigned char *ucArray1,const unsigned char  *ucArray2)
  102. {
  103.     WriteCommand(0x30);   //基本指令集
  104.         WriteCommand(ucAddrTable[8*y+x]);        //起始位置
  105.         LCDWriteData(ucArray1[0]);
  106.         LCDWriteData(ucArray2[0]);
  107. }


  108. void display_clear(void) // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
  109. {   

  110.     unsigned int i,j;
  111.         for(i=0;i<4;i++)
  112.         {
  113.                 for(j=0;j<8;j++)
  114.                 {
  115.                    display_double_zf816(j,i,Zf816_nc,ASCII816_nc);  //Zf816_nc与ASCII816_nc本质是一样的,只是书写方式不一样。
  116.                 }
  117.         }


  118. }

  119. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  120. {
  121.         unsigned char i;
  122.         for ( i = 0; i < 8; i++ )
  123.         {
  124.                 if ( (ucData << i) & 0x80 )
  125.                 {
  126.                         LCDSID_dr = 1;
  127.                 }
  128.                 else
  129.                 {
  130.                         LCDSID_dr = 0;
  131.                 }
  132.                 LCDCLK_dr = 0;
  133.                 LCDCLK_dr = 1;
  134.         }
  135. }

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


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

  144.         LCDCS_dr = 0;
  145.         LCDCS_dr = 1;
  146.         SPIWrite(ucCommand, 0);
  147.         delay_short(90);
  148. }

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

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



  161. void delay_short(unsigned int uiDelayShort) //延时函数
  162. {
  163.    unsigned int i;  
  164.    for(i=0;i<uiDelayShort;i++)
  165.    {
  166.      ;  
  167.    }
  168. }
复制代码

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

(未完待续,下节更精彩,不要走开哦)

乐于分享,勇于质疑!
发表于 2014-11-3 20:23:26 | 显示全部楼层
持续关注,顶。
乐于分享,勇于质疑!
发表于 2014-11-4 13:44:34 | 显示全部楼层
适合自己的方法才是最好的
乐于分享,勇于质疑!
 楼主| 发表于 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
81节.jpg

3)源代码讲解如下:
  1. #include "REG52.H"


  2. /* 注释一:
  3. * 本程序的串口那部分内容是从《第三十九节:判断数据头来接收一串数据的串口通用程序框架。》
  4. * 移植过来的,但是以下要把接收缓冲区的数据从10改成60.同时,协议后面多增加了数据结束标志0x0d 0x0a。
  5. */

  6. #define const_rc_size  60  //接收串口中断数据的缓冲区数组大小
  7. #define const_receive_time  5  //如果超过这个时间没有串口数据过来,就认为一串数据已经全部接收完,这个时间根据实际情况来调整大小

  8. #define const_voice_short  40   //蜂鸣器短叫的持续时间

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

  13. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  14. void initial_myself(void);   
  15. void initial_peripheral(void);
  16. void delay_long(unsigned int uiDelaylong);
  17. void T0_time(void);  //定时中断函数
  18. void usart_receive(void); //串口接收中断函数
  19. void usart_service(void);  //串口服务程序,在main函数里

  20. void display_service(void); //显示服务程序,在main函数里
  21. void empty_diaplay_buffer(void); //把显示缓冲区全部填充空格字符0x20
  22. void diaplay_all_buffer(void); //显示第2,3,4行全部缓冲区的内容

  23. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  24. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  25. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  26. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  27. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  28. void display_clear(void); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
  29. void display_double_code(unsigned int x,unsigned int y,const unsigned char ucArray1,const unsigned char  ucArray2); //在一个坐标点显示1个汉字或者2个字符的函数
  30. void delay_short(unsigned int uiDelayshort); //延时


  31. code unsigned char  ucAddrTable[]=  //调用内部字库时,液晶屏的坐标体系,位置编码,是驱动内容,读者可以不用深究它的含义。
  32. {     
  33. 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
  34. 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
  35. 0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
  36. 0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,
  37. };

  38. code unsigned char JN1616_qing[]=  //机内码  请
  39. {
  40. 0xC7,0xEB, //请
  41. };

  42. code unsigned char JN1616_fa[]=  //机内码  发
  43. {
  44. 0xB7,0xA2,
  45. };

  46. code unsigned char JN1616_song[]=  //机内码  送
  47. {
  48. 0xCB,0xCD,
  49. };

  50. code unsigned char JN1616_xin[]=  //机内码  信
  51. {
  52. 0xD0,0xC5,
  53. };

  54. code unsigned char JN1616_xi[]=  //机内码  息
  55. {
  56. 0xCF,0xA2,
  57. };

  58. unsigned int  uiSendCnt=0;     //用来识别串口是否接收完一串数据的计时器
  59. unsigned char ucSendLock=1;    //串口服务程序的自锁变量,每次接收完一串数据只处理一次
  60. unsigned int  uiRcregTotal=0;  //代表当前缓冲区已经接收了多少个数据
  61. unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
  62. unsigned int  uiRcMoveIndex=0;  //用来解析数据协议的中间变量

  63. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  64. unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量      1代表更新显示,响应函数内部会清零
  65. unsigned char ucWd1Part1Update=0; //窗口1的第1个局部更新显示变量  1代表更新显示,响应函数内部会清零

  66. unsigned char ucDispplayBuffer[48]; //第2,3,4行显示内容的缓冲区

  67. void main()
  68.   {
  69.         initial_myself();  
  70.         delay_long(100);   
  71.         initial_peripheral();

  72.         while(1)  
  73.         {
  74.             usart_service();  //串口服务程序
  75.                         display_service(); //显示服务程序
  76.         }

  77. }



  78. /* 注释二:在一个坐标点显示1个汉字或者2个字符的函数
  79. * 第1,2个参数x,y是坐标体系。x的范围是0至8,y的范围是0至3.
  80. * 第3个参数ucArray1是第1个汉字机内码或者ASCII码。
  81. * 第4个参数ucArray2是第2个汉字机内码或者ASCII码。
  82. */
  83. void display_double_code(unsigned int x,unsigned int y,const unsigned char ucArray1,const unsigned char  ucArray2)
  84. {
  85.     WriteCommand(0x30);   //基本指令集
  86.     WriteCommand(ucAddrTable[8*y+x]);        //起始位置
  87.     LCDWriteData(ucArray1);
  88.     LCDWriteData(ucArray2);
  89. }


  90. void display_clear(void) // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
  91. {   

  92.     unsigned int i,j;
  93.         for(i=0;i<4;i++)
  94.         {
  95.                 for(j=0;j<8;j++)
  96.                 {
  97.                    display_double_code(j,i,0x20,0x20);  //0x20是空格的ASCII码
  98.                 }
  99.         }


  100. }

  101. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  102. {
  103.         unsigned char i;
  104.         for ( i = 0; i < 8; i++ )
  105.         {
  106.                 if ( (ucData << i) & 0x80 )
  107.                 {
  108.                         LCDSID_dr = 1;
  109.                 }
  110.                 else
  111.                 {
  112.                         LCDSID_dr = 0;
  113.                 }
  114.                 LCDCLK_dr = 0;
  115.                 LCDCLK_dr = 1;
  116.         }
  117. }

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


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

  126.         LCDCS_dr = 0;
  127.         LCDCS_dr = 1;
  128.         SPIWrite(ucCommand, 0);
  129.         delay_short(90);
  130. }

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

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


  143. void empty_diaplay_buffer(void) //把显示缓冲区全部填充空格字符0x20
  144. {
  145.    unsigned int i;

  146.    for(i=0;i<48;i++)
  147.    {
  148.       ucDispplayBuffer[i]=0x20; //第2,3,4行显示内容的缓冲区全部填充0x20空格字符
  149.    }

  150. }

  151. void diaplay_all_buffer(void) //显示第2,3,4行全部缓冲区的内容
  152. {
  153.    unsigned int i,j;

  154.    for(i=0;i<3;i++) //i代表行数
  155.    {
  156.       for(j=0;j<8;j++) //j代表某行的某个坐标在第几列
  157.       {
  158.          display_double_code(j,i+1,ucDispplayBuffer[i*16+j*2],ucDispplayBuffer[i*16+j*2+1]); //这里的16代表一行可以显示16个字符
  159.       }
  160.    }

  161. }


  162. void display_service(void) //显示服务程序,在main函数里
  163. {
  164.   if(ucWd1Update==1)  //窗口1整屏更新,里面只放那些不用经常刷新显示的内容
  165.     {
  166.         ucWd1Update=0;  //及时清零,避免一直更新

  167.         ucWd1Part1Update=1; //激活窗口1的第1个局部更新显示变量

  168.         display_clear(); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。

  169.                 //显示第一行固定的内容:请发送信息
  170.         display_double_code(1,0,JN1616_qing[0],JN1616_qing[1]);      //请
  171.         display_double_code(2,0,JN1616_fa[0],JN1616_fa[1]);          //发
  172.         display_double_code(3,0,JN1616_song[0],JN1616_song[1]);      //送
  173.         display_double_code(4,0,JN1616_xin[0],JN1616_xin[1]);        //信
  174.         display_double_code(5,0,JN1616_xi[0],JN1616_xi[1]);          //息

  175.     }

  176.     if(ucWd1Part1Update==1) //窗口1的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
  177.     {
  178.         ucWd1Part1Update=0; //及时清零,避免一直更新

  179.         diaplay_all_buffer(); //显示第2,3,4行全部缓冲区的内容
  180.         }
  181. }


  182. /* 注释三:
  183. * 以下有效信息截取和如何判断机内码与ASCII码是本程序的核心,请仔细看讲解。
  184. * 凡是ASCII码都是小于0x80(128)的,根据这个特点可以把ASCII码和机内码分离出来,
  185. * 同时,由于液晶屏的1个坐标必须显示2个编码,对于单个存在的ASCII码,我们要在
  186. * 它的右边多插入一个空格字符0x20。至于如何插入空格0x20字符,请看以下代码。
  187. */
  188. void usart_service(void)  //串口服务程序,在main函数里
  189. {
  190.      unsigned int i;
  191.          unsigned int uiCodeCnt; //统计接收的有效编码数量
  192.          unsigned int uiCodeYu;  //对uiCodeCnt求2的余数,方便识别是否是1个ASCII码相邻
  193.      if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内,再也没有新数据从串口来
  194.      {


  195.             ucSendLock=0;    //处理一次就锁起来,不用每次都进来,除非有新接收的数据
  196.             uiRcMoveIndex=0; //由于是判断数据头,所以下标移动变量从数组的0开始向最尾端移动  这个变量是用来抗干扰处理的

  197.             while(uiRcregTotal>=6&&uiRcMoveIndex<=(uiRcregTotal-6)) //这里的6表示有3个字节的数据头,至少1个有效数据,2个数据结束标志0x0d 0x0a
  198.             {
  199.                if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
  200.                {

  201.                               empty_diaplay_buffer(); //把显示缓冲区全部填充空格字符0x20
  202.                                   uiCodeCnt=0; //统计接收的有效编码数量清零
  203.                   for(i=0;i<(uiRcregTotal-uiRcMoveIndex-3)&&i<48;i++)//这里的3表示有3个字节的数据头。48表示最大只能接收24个汉字,一共48个字节的机内码.
  204.                                   {
  205.                       if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a)  //结束标志0x0d 0x0a的判断
  206.                       {
  207.                            uiVoiceCnt=const_voice_short; //蜂鸣器发出声音,表示数据接收正确完毕
  208.                                                    ucWd1Part1Update=1; //及时更新显示第2,3,4行内容的信息
  209.                                                    break; //退出for循环
  210.                       }       
  211.                                        else  //收集有效信息编码进入显示缓冲区
  212.                                           {
  213.                                               uiCodeYu=uiCodeCnt%2; //对2求余数,用来识别相信的2个是否是机内码,否则要进行插入填充0x20处理
  214.                                                   if(uiCodeYu==1)
  215.                                                   {
  216.                                                      if(ucRcregBuf[uiRcMoveIndex+3+i]>=0x80&&ucRcregBuf[uiRcMoveIndex+3+i-1]<0x80) //如果当前的是机内码,而上一个不是机内码
  217.                                                          {
  218.                                                                  ucDispplayBuffer[uiCodeCnt]=0x20; //当前的先填充插入空格字符0x20
  219.                                                                 uiCodeCnt++;   //统计接收的有效编码数量
  220.                                                          }
  221.                                                   }
  222.                                               ucDispplayBuffer[uiCodeCnt]=ucRcregBuf[uiRcMoveIndex+3+i]; //收集有效信息编码进入显示缓冲区
  223.                                               uiCodeCnt++;   //统计接收的有效编码数量
  224.                                           }
  225.                                   }
  226.                   break;   //退出while循环
  227.                }
  228.                uiRcMoveIndex++; //因为是判断数据头,游标向着数组最尾端的方向移动
  229.            }
  230.                                          
  231.            uiRcregTotal=0;  //清空缓冲的下标,方便下次重新从0下标开始接受新数据
  232.   
  233.      }
  234.                         
  235. }


  236. void T0_time(void) interrupt 1    //定时中断
  237. {
  238.   TF0=0;  //清除中断标志
  239.   TR0=0; //关中断


  240.   if(uiSendCnt<const_receive_time)   //如果超过这个时间没有串口数据过来,就认为一串数据已经全部接收完
  241.   {
  242.           uiSendCnt++;    //表面上这个数据不断累加,但是在串口中断里,每接收一个字节它都会被清零,除非这个中间没有串口数据过来
  243.       ucSendLock=1;     //开自锁标志
  244.   }

  245.   if(uiVoiceCnt!=0)
  246.   {
  247.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  248.      beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。

  249.   }
  250.   else
  251.   {
  252.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  253.      beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  254.   }


  255.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  256.   TL0=0x0b;
  257.   TR0=1;  //开中断
  258. }


  259. void usart_receive(void) interrupt 4                 //串口接收数据中断        
  260. {        

  261.    if(RI==1)  
  262.    {
  263.         RI = 0;

  264.             ++uiRcregTotal;
  265.         if(uiRcregTotal>const_rc_size)  //超过缓冲区
  266.         {
  267.            uiRcregTotal=const_rc_size;
  268.         }
  269.         ucRcregBuf[uiRcregTotal-1]=SBUF;   //将串口接收到的数据缓存到接收缓冲区里
  270.         uiSendCnt=0;  //及时喂狗,虽然main函数那边不断在累加,但是只要串口的数据还没发送完毕,那么它永远也长不大,因为每个中断都被清零。
  271.    
  272.    }
  273.    else  //我在其它单片机上都不用else这段代码的,可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
  274.    {
  275.         TI = 0;
  276.    }
  277.                                                          
  278. }                                


  279. void delay_short(unsigned int uiDelayShort)
  280. {
  281.    unsigned int i;  
  282.    for(i=0;i<uiDelayShort;i++)
  283.    {
  284.      ;  
  285.    }
  286. }

  287. void delay_long(unsigned int uiDelayLong)
  288. {
  289.    unsigned int i;
  290.    unsigned int j;
  291.    for(i=0;i<uiDelayLong;i++)
  292.    {
  293.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  294.           {
  295.              ; //一个分号相当于执行一条空语句
  296.           }
  297.    }
  298. }


  299. void initial_myself(void)  //第一区 初始化单片机
  300. {

  301.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。

  302.   //配置定时器
  303.   TMOD=0x01;  //设置定时器0为工作方式1
  304.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  305.   TL0=0x0b;


  306.   //配置串口
  307.   SCON=0x50;
  308.   TMOD=0X21;
  309.   IP =0x10;  //把串口中断设置为最高优先级,必须的。
  310.   TH1=TL1=-(11059200L/12/32/9600);  //这段配置代码具体是什么意思,我也不太清楚,反正是跟串口波特率有关。
  311.   TR1=1;

  312. }

  313. void initial_peripheral(void) //第二区 初始化外围
  314. {

  315.    EA=1;     //开总中断
  316.    ES=1;     //允许串口中断
  317.    ET0=1;    //允许定时中断
  318.    TR0=1;    //启动定时中断


  319.    LCDInit(); //初始化12864 内部包含液晶模块的复位
  320.    WriteCommand(0x0C); //命令字0x0c表示用内部字库模式。命令字0x36表示用自构字库模式。
  321.    empty_diaplay_buffer(); //把显示缓冲区全部填充空格字符0x20
  322. }




复制代码

总结陈词:
我们现在是调用液晶屏内部字库来显示内容,如果要某行内容反显或者光标闪烁改怎么编程?欲知详情,请听下回分解-----如何在调用液晶屏内部字库时让某行内容反显或者光标闪烁。
(未完待续,下节更精彩,不要走开哦)

乐于分享,勇于质疑!
发表于 2014-11-6 22:25:20 | 显示全部楼层
继续学习,顶----顶--
乐于分享,勇于质疑!
发表于 2014-11-7 10:30:08 | 显示全部楼层
鸿哥,按键去抖动延时计数器uiKeyTimeCnt1、uiKeyTimeCnt2、uiKeyTimeCnt3……能否合并成一个变量?
乐于分享,勇于质疑!
 楼主| 发表于 2014-11-7 17:03:41 | 显示全部楼层
KR770906 发表于 2014-11-7 10:30
鸿哥,按键去抖动延时计数器uiKeyTimeCnt1、uiKeyTimeCnt2、uiKeyTimeCnt3……能否合并成一个变量?

好像不行。合并不好,感觉有隐患,还是分开来吧。
乐于分享,勇于质疑!
 楼主| 发表于 2014-11-14 11:38:17 | 显示全部楼层
本帖最后由 jianhong_wu 于 2014-11-14 12:13 编辑

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

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

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

(1)硬件平台:
    基于坚鸿51单片机学习板。

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

(3)源代码讲解如下:
  1. #include "REG52.H"


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

  6. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  7. void initial_myself(void);   
  8. void initial_peripheral(void);
  9. void delay_long(unsigned int uiDelaylong);

  10. unsigned char *number_to_ASCII(unsigned char  ucBitNumber);
  11. void display_service(void); //显示服务程序,在main函数里


  12. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  13. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  14. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  15. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  16. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  17. void display_clear(void); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
  18. void display_double_code(unsigned int x,unsigned int y,const unsigned char ucArray1,const unsigned char  ucArray2); //在一个坐标点显示1个汉字或者2个字符的函数
  19. void delay_short(unsigned int uiDelayshort); //延时


  20. code unsigned char  ucAddrTable[]=  //调用内部字库时,液晶屏的坐标体系,位置编码,是驱动内容,读者可以不用深究它的含义。
  21. {     
  22. 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
  23. 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
  24. 0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
  25. 0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,
  26. };

  27. code unsigned char ASCII816_0[]="0";   //0  对于数组内的字符,编译会自动翻译成 ASCII码(1字节)
  28. code unsigned char ASCII816_1[]="1";   //1
  29. code unsigned char ASCII816_2[]="2";   //2
  30. code unsigned char ASCII816_3[]="3";   //3  
  31. code unsigned char ASCII816_4[]="4";   //4
  32. code unsigned char ASCII816_5[]="5";   //5  
  33. code unsigned char ASCII816_6[]="6";   //6  
  34. code unsigned char ASCII816_7[]="7";   //7
  35. code unsigned char ASCII816_8[]="8";   //8
  36. code unsigned char ASCII816_9[]="9";   //9  
  37. code unsigned char ASCII816_nc[]=" ";  //空格

  38. /* 注释一:
  39. * 以下变量就是本程序的任意变量,网友可以自己更改它的大小来测试本程序,不要超过255.
  40. */
  41. unsigned char ucAnyNumber=218;  //任意变量默认初始化为218。
  42. unsigned char ucWd1Part1Update=1; //窗口1的第1个局部更新显示变量  1代表更新显示,响应函数内部会清零


  43. void main()
  44.   {
  45.         initial_myself();  
  46.         delay_long(100);   
  47.         initial_peripheral();

  48.         while(1)  
  49.         {
  50.            display_service(); //显示服务程序
  51.         }

  52. }



  53. /* 注释二:在一个坐标点显示1个汉字或者2个字符的函数
  54. * 第1,2个参数x,y是坐标体系。x的范围是0至8,y的范围是0至3.
  55. * 第3个参数ucArray1是第1个汉字机内码或者ASCII码。
  56. * 第4个参数ucArray2是第2个汉字机内码或者ASCII码。
  57. */
  58. void display_double_code(unsigned int x,unsigned int y,const unsigned char ucArray1,const unsigned char  ucArray2)
  59. {
  60.     WriteCommand(0x30);   //基本指令集
  61.     WriteCommand(ucAddrTable[8*y+x]);        //起始位置
  62.     LCDWriteData(ucArray1);
  63.     LCDWriteData(ucArray2);
  64. }


  65. void display_clear(void) // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。
  66. {   

  67.     unsigned int i,j;
  68.         for(i=0;i<4;i++)
  69.         {
  70.                 for(j=0;j<8;j++)
  71.                 {
  72.                    display_double_code(j,i,0x20,0x20);  //0x20是空格的ASCII码
  73.                 }
  74.         }


  75. }

  76. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  77. {
  78.         unsigned char i;
  79.         for ( i = 0; i < 8; i++ )
  80.         {
  81.                 if ( (ucData << i) & 0x80 )
  82.                 {
  83.                         LCDSID_dr = 1;
  84.                 }
  85.                 else
  86.                 {
  87.                         LCDSID_dr = 0;
  88.                 }
  89.                 LCDCLK_dr = 0;
  90.                 LCDCLK_dr = 1;
  91.         }
  92. }

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


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

  101.         LCDCS_dr = 0;
  102.         LCDCS_dr = 1;
  103.         SPIWrite(ucCommand, 0);
  104.         delay_short(90);
  105. }

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

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



  118. /* 注释三:
  119. * 本程序的核心转换函数。
  120. * 是可以把一位任意数字变量的函数转换成对应的ASCII码,由于ASCII码放在数组里,所以返回的是指针,代表数组的首地址。
  121. */
  122. unsigned char *number_to_ASCII(unsigned char  ucBitNumber)
  123. {
  124.         unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小,分别调用不同的ASCII码。

  125.         switch(ucBitNumber)  //根据ucBitNumber数值的大小,分别调用不同的ASCII码。
  126.         {
  127.             case 0:
  128.                   p_ucAnyNumber=ASCII816_0;
  129.                   break;
  130.             case 1:
  131.                   p_ucAnyNumber=ASCII816_1;
  132.                   break;
  133.             case 2:
  134.                   p_ucAnyNumber=ASCII816_2;
  135.                   break;
  136.             case 3:
  137.                   p_ucAnyNumber=ASCII816_3;
  138.                   break;
  139.             case 4:
  140.                   p_ucAnyNumber=ASCII816_4;
  141.                   break;
  142.             case 5:
  143.                   p_ucAnyNumber=ASCII816_5;
  144.                   break;
  145.             case 6:
  146.                   p_ucAnyNumber=ASCII816_6;
  147.                   break;
  148.             case 7:
  149.                   p_ucAnyNumber=ASCII816_7;
  150.                   break;
  151.             case 8:
  152.                   p_ucAnyNumber=ASCII816_8;
  153.                   break;
  154.             case 9:
  155.                   p_ucAnyNumber=ASCII816_9;
  156.                   break;
  157.             case 10:
  158.                   p_ucAnyNumber=ASCII816_nc;
  159.                   break;
  160.             default:   //如果上面的条件都不符合,那么默认指向空格ASCII码
  161.                   p_ucAnyNumber=ASCII816_nc;
  162.                   break;
  163.         }

  164.         return p_ucAnyNumber;  //返回转换结束后的指针
  165. }


  166. void display_service(void) //显示服务程序,在main函数里
  167. {
  168. /* 注释四:
  169. * 这里的局部变量用static关键词修饰,是因为这个函数一直在主函数while(1)里循环扫描,我不希望它每次进来这个函数
  170. * 都多花几条指令去初始化这些局部变量,这样会多耗掉几个指令,所以我就用static关键字避免了这种情况,让这些局部变量
  171. * 只在上电那一刻就初始化了,以后每次进来这个函数不用再初始化这些变量。
  172. */
  173.     static unsigned char ucAnyNumber_1; //分解变量的个位
  174.     static unsigned char ucAnyNumber_10; //分解变量的十位
  175.     static unsigned char ucAnyNumber_100; //分解变量的百位

  176.     static unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后,分解变量的个位字模首地址
  177.     static unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后,分解变量的十位字模首地址
  178.     static unsigned char *p_ucAnyNumber_100; //经过数字转换成字模后,分解变量的百位字模首地址


  179.     if(ucWd1Part1Update==1) //窗口1的第1个局部更新显示变量,里面放一些经常需要刷新显示的内容
  180.     {
  181.         ucWd1Part1Update=0; //及时清零,避免一直更新

  182.         if(ucAnyNumber>=100) //有3位数以上
  183.         {
  184.            ucAnyNumber_100=ucAnyNumber/100; //百位
  185.         }
  186.         else //否则显示空
  187.         {
  188.            ucAnyNumber_100=10;  //在下面的转换函数中,代码10表示空字模
  189.         }

  190.         if(ucAnyNumber>=10) //有2位数以上
  191.         {
  192.            ucAnyNumber_10=ucAnyNumber%100/10;  //十位
  193.         }
  194.         else //否则显示空
  195.         {
  196.            ucAnyNumber_10=10;  //在下面的转换函数中,代码10表示空字模
  197.         }

  198.         ucAnyNumber_1=ucAnyNumber%10/1;  //个位

  199.         p_ucAnyNumber_100=number_to_ASCII(ucAnyNumber_100); //把数字转换成字符ASCII码      
  200.         p_ucAnyNumber_10=number_to_ASCII(ucAnyNumber_10);   //把数字转换成字符ASCII码
  201.         p_ucAnyNumber_1=number_to_ASCII(ucAnyNumber_1);     //把数字转换成字符ASCII码

  202.         display_double_code(2,1,ASCII816_nc[0],p_ucAnyNumber_100[0]);//液晶屏的显示驱动函数  这里的ASCII816_nc[0]代表填充显示一个空格字符
  203.         display_double_code(3,1,p_ucAnyNumber_10[0],p_ucAnyNumber_1[0]);//液晶屏的显示驱动函数

  204.     }
  205. }


  206. void delay_short(unsigned int uiDelayShort)
  207. {
  208.    unsigned int i;  
  209.    for(i=0;i<uiDelayShort;i++)
  210.    {
  211.      ;  
  212.    }
  213. }

  214. void delay_long(unsigned int uiDelayLong)
  215. {
  216.    unsigned int i;
  217.    unsigned int j;
  218.    for(i=0;i<uiDelayLong;i++)
  219.    {
  220.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  221.           {
  222.              ; //一个分号相当于执行一条空语句
  223.           }
  224.    }
  225. }


  226. void initial_myself(void)  //第一区 初始化单片机
  227. {

  228.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。



  229. }

  230. void initial_peripheral(void) //第二区 初始化外围
  231. {

  232.    LCDInit(); //初始化12864 内部包含液晶模块的复位
  233.    WriteCommand(0x0C); //命令字0x0c表示用内部字库模式。命令字0x36表示用自构字库模式。
  234.    display_clear(); // 清屏。4行8列的坐标点全部显示2个空字符相当于清屏了。

  235. }



复制代码

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

(未完待续,下节更精彩,不要走开哦)

乐于分享,勇于质疑!
发表于 2014-12-3 16:36:31 | 显示全部楼层
jianhong_wu 发表于 2014-11-14 11:38
第八十二节:如何通过调用液晶屏内部字库把一个任意数值的变量显示出来。
开场白:本来这一节打算开始讲调 ...

鸿哥,有几天木有更新啦
乐于分享,勇于质疑!
 楼主| 发表于 2014-12-3 18:13:42 | 显示全部楼层
waphaoyun 发表于 2014-12-3 16:36
鸿哥,有几天木有更新啦

这两个星期有点忙。
乐于分享,勇于质疑!
发表于 2014-12-9 12:42:38 | 显示全部楼层
等鸿哥的第九页呢
乐于分享,勇于质疑!
 楼主| 发表于 2014-12-9 13:16:37 | 显示全部楼层
华菲 发表于 2014-12-9 12:42
等鸿哥的第九页呢

这两天一直在等待好的状态来临再动手。
乐于分享,勇于质疑!
发表于 2014-12-11 19:18:26 | 显示全部楼层
jianhong_wu 发表于 2014-12-9 13:16
这两天一直在等待好的状态来临再动手。

先忙你的,等状态好的时候再写
乐于分享,勇于质疑!
 楼主| 发表于 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清零按键才能重新输入。
实物照片83.jpg
(3)源代码讲解如下:
  1. #include "REG52.H"


  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间

  3. #define const_key_time  10    //按键去抖动延时的时间

  4. sbit key_sr1=P0^0; //第一行输入
  5. sbit key_sr2=P0^1; //第二行输入
  6. sbit key_sr3=P0^2; //第三行输入
  7. sbit key_sr4=P0^3; //第四行输入

  8. sbit key_dr1=P0^4; //第一列输出
  9. sbit key_dr2=P0^5; //第二列输出
  10. sbit key_dr3=P0^6; //第三列输出
  11. sbit key_dr4=P0^7; //第四列输出

  12. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

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

  17. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  18. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  19. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  20. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  21. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  22. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
  23. 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);//把字模插入画布.
  24. 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); //显示任意点阵函数
  25. unsigned char *number_to_matrix(unsigned char  ucBitNumber); //把一位数字转换成字模首地址的函数
  26. void delay_short(unsigned int uiDelayshort); //延时
  27. void delay_long(unsigned int uiDelayLong);

  28. void key_number_input(unsigned char ucKeyNumber); //输入数字按键
  29. 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);
  30. void key_delete_input(void); //删除按键

  31. void T0_time(); //定时中断函数
  32. void key_service();
  33. void key_scan(); //按键扫描函数 放在定时中断里

  34. void initial_myself();   
  35. void initial_peripheral();


  36. void lcd_display_service(void); //应用层面的液晶屏显示程序
  37. void clear_all_canvas(void);  //把画布全部清零

  38. code unsigned char Zf816_0[]=
  39. {
  40. /*--  文字:  0  --*/
  41. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  42. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  43. };

  44. code unsigned char Zf816_1[]=
  45. {
  46. /*--  文字:  1  --*/
  47. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  48. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  49. };

  50. code unsigned char Zf816_2[]=
  51. {
  52. /*--  文字:  2  --*/
  53. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  54. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  55. };

  56. code unsigned char Zf816_3[]=
  57. {
  58. /*--  文字:  3  --*/
  59. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  60. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  61. };

  62. code unsigned char Zf816_4[]=
  63. {
  64. /*--  文字:  4  --*/
  65. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  66. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  67. };

  68. code unsigned char Zf816_5[]=
  69. {
  70. /*--  文字:  5  --*/
  71. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  72. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  73. };

  74. code unsigned char Zf816_6[]=
  75. {
  76. /*--  文字:  6  --*/
  77. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  78. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  79. };


  80. code unsigned char Zf816_7[]=
  81. {
  82. /*--  文字:  7  --*/
  83. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  84. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  85. };

  86. code unsigned char Zf816_8[]=
  87. {
  88. /*--  文字:  8  --*/
  89. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  90. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  91. };

  92. code unsigned char Zf816_9[]=
  93. {
  94. /*--  文字:  9  --*/
  95. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  96. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
  97. };


  98. code unsigned char Zf816_nc[]=  //空字模
  99. {
  100. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  101. };

  102. code unsigned char Zf816_dot[]=  //小数点
  103. {
  104. /*--  文字:  .  --*/
  105. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  106. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x00,0x00,
  107. };

  108. code unsigned char Zf816_mao_hao[]=  //冒号
  109. {
  110. /*--  文字:  :  --*/
  111. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  112. 0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
  113. };

  114. code unsigned char Hz1616_yi[]=
  115. {
  116. /*--  文字:  一  --*/
  117. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  118. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
  119. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  120. };

  121. code unsigned char Hz1616_xiang[]=
  122. {
  123. /*--  文字:  项  --*/
  124. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  125. 0x00,0x00,0x03,0xFE,0xFC,0x20,0x10,0x40,0x11,0xFC,0x11,0x04,0x11,0x24,0x11,0x24,
  126. 0x11,0x24,0x11,0x24,0x1D,0x24,0xE1,0x34,0x00,0x48,0x01,0x86,0x06,0x02,0x00,0x00,
  127. };

  128. code unsigned char Hz1616_shu[]=
  129. {
  130. /*--  文字:  数  --*/
  131. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  132. 0x08,0x20,0x49,0x30,0x2A,0x20,0x1C,0x20,0xFF,0x7E,0x1C,0x44,0x2B,0x44,0x48,0xC4,
  133. 0x08,0x28,0xFF,0x28,0x12,0x10,0x34,0x10,0x0C,0x28,0x32,0x4E,0xC0,0x84,0x00,0x00,
  134. };

  135. code unsigned char Hz1616_zhu[]=
  136. {
  137. /*--  文字:  组  --*/
  138. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  139. 0x10,0x00,0x19,0xF8,0x11,0x08,0x25,0x08,0x25,0x08,0x79,0xF8,0x09,0x08,0x11,0x08,
  140. 0x21,0x08,0x7D,0xF8,0x01,0x08,0x01,0x08,0x0D,0x08,0x73,0xFE,0x00,0x00,0x00,0x00,
  141. };

  142. /* 注释一:
  143. * 以下是画布显示数组。横向是6个字节,纵向16行,可以显示3个16x16的汉字.
  144. *  注意,这节内容的画布跟前面章节的画布大小不一样,前面章节的横向是4个字节,这节的横向是6个字节。
  145. */
  146. unsigned char ucCanvasBuffer[]=
  147. {
  148. 0x00,0x00,0x00,0x00,0x00,0x00,  //上半屏
  149. 0x00,0x00,0x00,0x00,0x00,0x00,
  150. 0x00,0x00,0x00,0x00,0x00,0x00,
  151. 0x00,0x00,0x00,0x00,0x00,0x00,
  152. 0x00,0x00,0x00,0x00,0x00,0x00,
  153. 0x00,0x00,0x00,0x00,0x00,0x00,
  154. 0x00,0x00,0x00,0x00,0x00,0x00,
  155. 0x00,0x00,0x00,0x00,0x00,0x00,

  156. //------------上半屏和下半屏的分割线-----------

  157. 0x00,0x00,0x00,0x00,0x00,0x00,  //下半屏
  158. 0x00,0x00,0x00,0x00,0x00,0x00,
  159. 0x00,0x00,0x00,0x00,0x00,0x00,
  160. 0x00,0x00,0x00,0x00,0x00,0x00,
  161. 0x00,0x00,0x00,0x00,0x00,0x00,
  162. 0x00,0x00,0x00,0x00,0x00,0x00,
  163. 0x00,0x00,0x00,0x00,0x00,0x00,
  164. 0x00,0x00,0x00,0x00,0x00,0x00,
  165. };


  166. /* 注释二:
  167. * 以下4个变量记录一个参数的4种信息,包括小数点的数量,个数,数据的位置,数组具体值.
  168. */
  169. unsigned char ucDotCnt_1=0;  //记录当前输入的小数点数量,如果小数点的数量不为0,说明当前数组已包含小数点,此时再按小数点按键则无效
  170. unsigned char ucDotBitS_1=0; //记录当前输入的小数点个数,如果小数点的个量如果超过规定2位,此时再按任何输入按键则无效
  171. unsigned char ucWdPartCnt_1=0; //记录当前输入的数据在数组中的位置。
  172. unsigned char ucDataBuffer_1[6]={0,10,10,10,10,10}; //一项的BCD码数组缓冲


  173. unsigned char ucKeyStep=1;  //按键扫描步骤变量

  174. unsigned char ucKeySec=0;   //被触发的按键编号
  175. unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
  176. unsigned char ucKeyLock=0; //按键触发后自锁的变量标志

  177. unsigned char ucRowRecord=1; //记录当前扫描到第几列了


  178. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器


  179. unsigned char ucWd=1; //窗口变量
  180. unsigned char ucPart=1; //局部变量 0代表没有选中任何一行,其它数值1到4代表选中某一行


  181. unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量      1代表更新显示,响应函数内部会清零
  182. unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量  1代表更新显示,响应函数内部会清零


  183. void main()
  184.   {
  185.         initial_myself();      //第一区,上电后马上初始化
  186.         delay_long(100);       //一线,延时线。延时一段时间
  187.         initial_peripheral();  //第二区,上电后延时一段时间再初始化

  188.         while(1)   //第三区
  189.         {
  190.                     key_service(); //按键服务程序
  191.             lcd_display_service(); //应用层面的液晶屏显示程序
  192.         }

  193. }


  194. void initial_myself()  //第一区 上电后马上初始化
  195. {

  196.    beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。

  197.    TMOD=0x01;  //设置定时器0为工作方式1

  198.    TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  199.    TL0=0x2f;
  200. }
  201. void initial_peripheral() //第二区 上电后延时一段时间再初始化
  202. {
  203.     LCDInit(); //初始化12864 内部包含液晶模块的复位


  204.     EA=1;     //开总中断
  205.     ET0=1;    //允许定时中断
  206.     TR0=1;    //启动定时中断

  207. }


  208. void T0_time() interrupt 1
  209. {
  210.   TF0=0;  //清除中断标志
  211.   TR0=0; //关中断

  212.   key_scan();//按键扫描函数 放在定时中断里

  213.   if(uiVoiceCnt!=0)
  214.   {
  215.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  216.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  217.   }
  218.   else
  219.   {
  220.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  221.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  222.   }


  223.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  224.   TL0=0x2f;
  225.   TR0=1;  //开中断
  226. }


  227. void key_scan()//按键扫描函数 放在定时中断里
  228. {  

  229.   switch(ucKeyStep)
  230.   {
  231.      case 1:   //按键扫描输出第ucRowRecord列低电平
  232.               if(ucRowRecord==1)  //第一列输出低电平
  233.                   {
  234.              key_dr1=0;      
  235.              key_dr2=1;
  236.              key_dr3=1;   
  237.              key_dr4=1;
  238.                   }
  239.               else if(ucRowRecord==2)  //第二列输出低电平
  240.                   {
  241.              key_dr1=1;      
  242.              key_dr2=0;
  243.              key_dr3=1;   
  244.              key_dr4=1;
  245.                   }
  246.               else if(ucRowRecord==3)  //第三列输出低电平
  247.                   {
  248.              key_dr1=1;      
  249.              key_dr2=1;
  250.              key_dr3=0;   
  251.              key_dr4=1;
  252.                   }
  253.               else   //第四列输出低电平
  254.                   {
  255.              key_dr1=1;      
  256.              key_dr2=1;
  257.              key_dr3=1;   
  258.              key_dr4=0;
  259.                   }

  260.           uiKeyTimeCnt=0;  //延时计数器清零
  261.           ucKeyStep++;     //切换到下一个运行步骤
  262.               break;

  263.      case 2:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
  264.           uiKeyTimeCnt++;
  265.                   if(uiKeyTimeCnt>1)
  266.                   {
  267.                      uiKeyTimeCnt=0;
  268.              ucKeyStep++;     //切换到下一个运行步骤
  269.                   }
  270.               break;

  271.      case 3:
  272.           if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  273.           {  
  274.              ucKeyStep=1;  //如果没有按键按下,返回到第一个运行步骤重新开始扫描
  275.              ucKeyLock=0;  //按键自锁标志清零
  276.              uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙     
  277.    
  278.                          ucRowRecord++;  //输出下一列
  279.                          if(ucRowRecord>4)  
  280.                          {
  281.                             ucRowRecord=1; //依次输出完四列之后,继续从第一列开始输出低电平
  282.                          }

  283.           }
  284.                   else if(ucKeyLock==0)  //有按键按下,且是第一次触发
  285.                   {
  286.                      if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  287.                          {
  288.                             uiKeyTimeCnt++;  //去抖动延时计数器
  289.                                 if(uiKeyTimeCnt>const_key_time)
  290.                                 {
  291.                                    uiKeyTimeCnt=0;
  292.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零

  293.                        if(ucRowRecord==1)  //第一列输出低电平
  294.                            {
  295.                                       ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
  296.                            }
  297.                        else if(ucRowRecord==2)  //第二列输出低电平
  298.                            {
  299.                                       ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
  300.                            }
  301.                        else if(ucRowRecord==3)  //第三列输出低电平
  302.                            {
  303.                                       ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
  304.                            }
  305.                        else   //第四列输出低电平
  306.                            {
  307.                                       ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
  308.                            }

  309.                                 }
  310.                         
  311.                          }
  312.                      else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
  313.                          {
  314.                             uiKeyTimeCnt++;  //去抖动延时计数器
  315.                                 if(uiKeyTimeCnt>const_key_time)
  316.                                 {
  317.                                    uiKeyTimeCnt=0;
  318.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  319.                        if(ucRowRecord==1)  //第一列输出低电平
  320.                            {
  321.                                       ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
  322.                            }
  323.                        else if(ucRowRecord==2)  //第二列输出低电平
  324.                            {
  325.                                       ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
  326.                            }
  327.                        else if(ucRowRecord==3)  //第三列输出低电平
  328.                            {
  329.                                       ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
  330.                            }
  331.                        else   //第四列输出低电平
  332.                            {
  333.                                       ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
  334.                            }
  335.                                 }
  336.                         
  337.                          }
  338.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
  339.                          {
  340.                             uiKeyTimeCnt++;  //去抖动延时计数器
  341.                                 if(uiKeyTimeCnt>const_key_time)
  342.                                 {
  343.                                    uiKeyTimeCnt=0;
  344.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  345.                        if(ucRowRecord==1)  //第一列输出低电平
  346.                            {
  347.                                       ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
  348.                            }
  349.                        else if(ucRowRecord==2)  //第二列输出低电平
  350.                            {
  351.                                       ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S10键
  352.                            }
  353.                        else if(ucRowRecord==3)  //第三列输出低电平
  354.                            {
  355.                                       ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
  356.                            }
  357.                        else   //第四列输出低电平
  358.                            {
  359.                                       ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
  360.                            }
  361.                                 }
  362.                         
  363.                          }
  364.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
  365.                          {
  366.                             uiKeyTimeCnt++;  //去抖动延时计数器
  367.                                 if(uiKeyTimeCnt>const_key_time)
  368.                                 {
  369.                                    uiKeyTimeCnt=0;
  370.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  371.                        if(ucRowRecord==1)  //第一列输出低电平
  372.                            {
  373.                                       ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
  374.                            }
  375.                        else if(ucRowRecord==2)  //第二列输出低电平
  376.                            {
  377.                                       ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S14键
  378.                            }
  379.                        else if(ucRowRecord==3)  //第三列输出低电平
  380.                            {
  381.                                       ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
  382.                            }
  383.                        else   //第四列输出低电平
  384.                            {
  385.                                       ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
  386.                            }
  387.                                 }
  388.                         
  389.                          }
  390.                   
  391.                   }
  392.               break;

  393.   }


  394. }


  395. void key_service() //按键服务的应用程序
  396. {
  397.   switch(ucKeySec) //按键服务状态切换
  398.   {
  399.     case 1:// 数字1 对应朱兆祺学习板的S1键
  400.           key_number_input(1); //输入数字按键
  401.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  402.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  403.           break;        
  404.     case 2:// 数字2 对应朱兆祺学习板的S2键
  405.           key_number_input(2); //输入数字按键
  406.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  407.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  408.           break;     
  409.     case 3:// 数字3 对应朱兆祺学习板的S3键
  410.           key_number_input(3); //输入数字按键
  411.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  412.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  413.           break;         
  414.     case 4:// 数字4 对应朱兆祺学习板的S4键
  415.           key_number_input(4); //输入数字按键
  416.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  417.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  418.           break;   
  419.     case 5:// 数字5 对应朱兆祺学习板的S5键
  420.           key_number_input(5); //输入数字按键
  421.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  422.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  423.           break;   
  424.     case 6:// 数字6 对应朱兆祺学习板的S6键
  425.           key_number_input(6); //输入数字按键
  426.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  427.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  428.           break;   
  429.     case 7:// 数字7 对应朱兆祺学习板的S7键
  430.           key_number_input(7); //输入数字按键
  431.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  432.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  433.           break;   
  434.     case 8: //数字8 对应朱兆祺学习板的S8键
  435.           key_number_input(8); //输入数字按键
  436.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  437.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  438.           break;   
  439.     case 9:// 数字9 对应朱兆祺学习板的S9键
  440.           key_number_input(9); //输入数字按键
  441.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  442.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  443.           break;   
  444.     case 10:// 数字0  对应朱兆祺学习板的S10键
  445.           key_number_input(0); //输入数字按键
  446.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  447.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  448.           break;   
  449.     case 11:// 小数点按键 对应朱兆祺学习板的S11键
  450.           key_number_input(11); //输入数字按键  11代表小数点
  451.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  452.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  453.           break;   
  454.     case 12:// 本节暂时不用 对应朱兆祺学习板的S12键  

  455.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  456.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  457.           break;   
  458.     case 13:// 本节暂时不用 对应朱兆祺学习板的S13键   

  459.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  460.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  461.           break;   
  462.     case 14:// 本节暂时不用  对应朱兆祺学习板的S14键   
  463.         
  464.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  465.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  466.           break;   
  467.     case 15:// 本节暂时不用 对应朱兆祺学习板的S15键

  468.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  469.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  470.           break;   
  471.     case 16:// 清除按键 对应朱兆祺学习板的S16键
  472.           key_delete_input(); //删除按键
  473.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  474.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  475.           break;   
  476.   }               
  477. }



  478. void key_number_input(unsigned char ucKeyNumber) //输入数字按键
  479. {

  480.         switch(ucWd)
  481.         {
  482.           case 1:   //第1窗口。本节程序只有1个窗口
  483.                    switch(ucPart)
  484.                    {

  485.              case 1:  //1窗口第1项
  486.                     set_data(ucKeyNumber,2,6,&ucDotCnt_1,&ucDotBitS_1,&ucWdPartCnt_1,ucDataBuffer_1); //设置参数,请看本函数具体内容。本节的核心内容,值得好好研究!               
  487.                                     ucWd1Part1Update=1;//更新显示
  488.                                     break;               
  489.           }
  490.                                        
  491.                     break;
  492.     }                       
  493.                                
  494. }


  495. /* 注释三:
  496. * 本节的核心函数,值得好好研究!
  497. * 涉及到参数的4种信息,包括小数点的数量,个数,数据的位置,数组具体值。以及它们之间的相互作用关系。
  498. * 以下参数,指针类型的参数是让代入的全局变量在退出函数后维持它当前最新更改的数值不变。
  499. * 第1个参数ucKeyNumberTemp是当前按键输入的数值。
  500. * 第2个参数ucDotBitMax是限定被设置参数的小数点最大位数。
  501. * 第3个参数ucDataCntMax是限定被设置参数的最大数组个数。
  502. * 第4个参数*p_ucDotCnt是记录当前输入的小数点数量,如果小数点的数量不为0,说明当前数组已包含小数点,此时再按小数点按键则无效。
  503. * 第5个参数*p_ucDotBitS是记录当前输入的小数点个数,如果小数点的个量如果超过规定2位,此时再按任何输入按键则无效
  504. * 第6个参数*p_ucWdPartCnt是记录当前输入的数据在数组中的位置,方便锁定每次按键输入的数字显示位置。
  505. * 第7个参数*p_ucSetDataBuffer是BCD码数组缓冲的具体数字内容。
  506. */
  507. 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)
  508. {
  509.                     unsigned int i;

  510.                     if(ucKeyNumberTemp==11) //等于小数点
  511.                     {
  512.                        if(ucDotBitMax==0) //如果限定的小数点最大数是0,就意味着此数据不允许带小数点,必须是整数。
  513.                        {
  514.                            return; //直接返回退出
  515.                        }
  516.                        else if(*p_ucDotCnt>0)  //小数点个数大于0,意味着当前数组已经包含了小数点,此时再输入小数点则无效。
  517.                        {
  518.                            return; //直接返回退出
  519.                        }
  520.                        else  //否则有效,记录当前已经包含一个小数点的信息。
  521.                        {
  522.                            *p_ucDotCnt=1;  //只能包含一个小数点
  523.                        }
  524.                     }
  525.                     else if(*p_ucDotCnt==1) //如果输入的不是小数点,并且之前已经输入了一个小数点,那么此时输入的数字就是小数点后的数据
  526.                     {
  527.                         if(*p_ucDotBitS<ucDotBitMax) //如果小数点位数还没超过最大限制位数,则继续加1记录当前小数点位数。
  528.                         {
  529.                             *p_ucDotBitS=(*p_ucDotBitS)+1;
  530.                         }
  531.                         else //如果小数点位数已经超过允许的范围,则输入的按键无效,直接退出。
  532.                         {
  533.                             return; //直接返回退出
  534.                         }
  535.                     }

  536.         
  537.                                     if(*p_ucWdPartCnt<(ucDataCntMax-1))  //当输入的有效BCD码不超过最大数组缓冲时
  538.                                     {               
  539.                        if(*p_ucWdPartCnt==0&&p_ucSetDataBuffer[0]==0&&ucKeyNumberTemp!=11)  //如果当前默认位置是第0个位置,并且默认第0个数据是0,并且当前的按键输入不是小数点,则不用移位
  540.                        {
  541.                            ;
  542.                        }       
  543.                        else  //否则,移位
  544.                        {               
  545.                            for(i=0;i<(ucDataCntMax-1);i++)  //移位
  546.                            {
  547.                               p_ucSetDataBuffer[ucDataCntMax-1-i]=p_ucSetDataBuffer[ucDataCntMax-2-i];
  548.                            }
  549.                                                *p_ucWdPartCnt=(*p_ucWdPartCnt)+1;
  550.                        }
  551.                        p_ucSetDataBuffer[0]=ucKeyNumberTemp; //当前输入的数字或者小数点永远在第右边第0个位置。
  552.                                                                
  553.                     }

  554. }


  555. void key_delete_input(void) //删除按键
  556. {
  557.         static unsigned int i;

  558.         switch(ucWd)
  559.         {
  560.           case 1:   //第1窗口。本节程序只有1个窗口
  561.                    switch(ucPart)
  562.                    {

  563.              case 1:  //1窗口第1项
  564.                     
  565.                                 //清零
  566.                     ucDotBitS_1=0;  
  567.                     ucDotCnt_1=0;  
  568.                     ucWdPartCnt_1=0;               
  569.                     for(i=0;i<6;i++)  
  570.                     {
  571.                        ucDataBuffer_1[i]=10;
  572.                     }
  573.                                         ucDataBuffer_1[0]=0; //第0个位置填入0
  574.        
  575.                                     ucWd1Part1Update=1;//更新显示
  576.                                     break;               
  577.       
  578.           }
  579.                                        
  580.                     break;
  581.        
  582.     }                       
  583.                                
  584. }

  585. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
  586. {
  587.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小,分别调用不同的字库。

  588.         switch(ucBitNumber)  //根据ucBitNumber数值的大小,分别调用不同的字库。
  589.         {
  590.             case 0:
  591.              p_ucAnyNumber=Zf816_0;
  592.                      break;
  593.             case 1:
  594.              p_ucAnyNumber=Zf816_1;
  595.                      break;
  596.             case 2:
  597.              p_ucAnyNumber=Zf816_2;
  598.                      break;
  599.             case 3:
  600.              p_ucAnyNumber=Zf816_3;
  601.                      break;
  602.             case 4:
  603.              p_ucAnyNumber=Zf816_4;
  604.                      break;
  605.             case 5:
  606.              p_ucAnyNumber=Zf816_5;
  607.                      break;
  608.             case 6:
  609.              p_ucAnyNumber=Zf816_6;
  610.                      break;
  611.             case 7:
  612.              p_ucAnyNumber=Zf816_7;
  613.                      break;
  614.             case 8:
  615.              p_ucAnyNumber=Zf816_8;
  616.                      break;
  617.             case 9:
  618.              p_ucAnyNumber=Zf816_9;
  619.                      break;
  620.             case 10:  //空格
  621.              p_ucAnyNumber=Zf816_nc;
  622.                      break;
  623.                         case 11:   //小数点
  624.              p_ucAnyNumber=Zf816_dot;
  625.                      break;
  626.                 default:   //如果上面的条件都不符合,那么默认指向空字模
  627.              p_ucAnyNumber=Zf816_nc;
  628.                      break;
  629.         }

  630.     return p_ucAnyNumber;  //返回转换结束后的指针
  631. }



  632. void lcd_display_service(void) //应用层面的液晶屏显示程序
  633. {


  634.     static unsigned char *p_ucAnyNumber; //经过数字转换成字模后,分解变量的某位字模首地址
  635.     static unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
  636.     static unsigned int i;

  637.     switch(ucWd)  //本程序的核心变量,窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  638.     {
  639.         case 1:   //显示窗口1的数据
  640.                if(ucWd1Update==1)  //窗口1整屏更新,里面只放那些不用经常刷新显示的内容
  641.                {
  642.                      ucWd1Update=0;  //及时清零,避免一直更新

  643.                      ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量,这里在前面数码管显示框架上有所改进


  644.                      display_clear(0x00); // 清屏操作, 全部显示空填充0x00,全部显示点阵用0xff。
  645.                      clear_all_canvas();  //把画布全部清零

  646.                      display_lattice(0,0,Hz1616_yi,0,2,16,0);    //一窗口一行,这些内容不用经常更新,只有在切换窗口的时候才更新显示
  647.                      display_lattice(1,0,Hz1616_xiang,0,2,16,0);   
  648.                      display_lattice(2,0,Hz1616_shu,0,2,16,0);   
  649.                      display_lattice(3,0,Hz1616_zhu,0,2,16,0);
  650.                      display_lattice(4,0,Zf816_mao_hao,0,1,16,0); //冒号

  651.                

  652.                }

  653.                if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
  654.                {
  655.                         ucWd1Part1Update=0; //及时清零,避免一直更新

  656.                         if(ucPart==1) //被选中
  657.                         {
  658.                            ucCursorFlag=1; //反显 显示
  659.                         }
  660.                         else //没被选中
  661.                         {
  662.                             ucCursorFlag=0; //正常 显示
  663.                         }

  664.                         
  665.                                                 for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
  666.                         {
  667.                                                     p_ucAnyNumber=number_to_matrix(ucDataBuffer_1[5-i]);
  668.                           insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16);  //这里的i是画布的横向地址,一共可以显示6个字符,因此取值范围是0到5
  669.                         }

  670.                         display_lattice(5,0,ucCanvasBuffer,ucCursorFlag,6,16,0);   //显示整屏的画布,最后的参数0是偏移量
  671.                }

  672.                      
  673.                break;
  674.         //本程序只有1个窗口,所以只有一个case 1,如果要增加窗口,就直接增加 case 2, case 3...        
  675.     }

  676. }



  677. void clear_all_canvas(void)  //把画布全部清零
  678. {
  679.    unsigned int j=0;
  680.    unsigned int i=0;

  681.    for(j=0;j<16;j++)  //这里的16表示画布有16行
  682.    {
  683.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
  684.       {
  685.                   ucCanvasBuffer[j*4+i]=0x00;
  686.       }
  687.    }         

  688. }





  689. void display_clear(unsigned char ucFillDate) // 清屏  全部显示空填充0x00   全部显示点阵用0xff
  690. {   

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

  706. }

  707. /* 注释四:
  708. * 注意,这节内容的画布跟前面章节的画布大小不一样,前面章节的横向是4个字节,这节的横向是6个字节。
  709. * 把字模插入画布的函数.
  710. * 这是本节的核心函数,读者尤其要搞懂x_amount和y_amount对应的显示关系。
  711. * 第1,2个参数x,y是在画布中的坐标体系。
  712. * x的范围是0至5,因为画布的横向只要6个字节。y的范围是0至15,因为画布的纵向只有16行。
  713. * 第3个参数*ucArray是字模的数组。
  714. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示,1代表反白显示。
  715. * 第5,6个参数x_amount,y_amount分别代表字模数组的横向有多少个字节,纵向有几横。
  716. */
  717. 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)
  718. {
  719.    unsigned int j=0;
  720.    unsigned int i=0;
  721.    unsigned char ucTemp;
  722.    for(j=0;j<y_amount;j++)
  723.    {
  724.       for(i=0;i<x_amount;i++)
  725.       {
  726.               ucTemp=ucArray[j*x_amount+i];
  727.               if(ucFbFlag==0)
  728.               {
  729.                  ucCanvasBuffer[(y+j)*6+x+i]=ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节,要稍微注意的。
  730.               }
  731.               else
  732.               {
  733.                  ucCanvasBuffer[(y+j)*6+x+i]=~ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节,要稍微注意的。
  734.               }
  735.       }
  736.    }         

  737. }

  738. /* 注释五:
  739. * 显示任意点阵函数.
  740. * 注意,本函数在前几节的基础上多增加了第7个参数uiOffSetAddr,它是偏移地址。
  741. * 对于这个函数,读者尤其要搞懂x_amount和y_amount对应的显示关系。
  742. * 第1,2个参数x,y是坐标体系。x的范围是0至15,y的范围是0至31.
  743. * 第3个参数*ucArray是字模的数组。
  744. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示,1代表反白显示。
  745. * 第5,6个参数x_amount,y_amount分别代表字模数组的横向有多少个字节,纵向有几横。
  746. * 第7个参数uiOffSetAddr是偏移地址,代表字模数组的从第几个数据开始显示。
  747. */
  748. 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)
  749. {
  750.    unsigned int j=0;
  751.    unsigned int i=0;
  752.    unsigned char ucTemp;

  753. //注意,要把以下两行指令屏蔽,否则屏幕在更新显示时会整屏闪动
  754. //  WriteCommand(0x34);  //关显示缓冲指令            
  755. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次,怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  756.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  757.    {
  758.        WriteCommand(y+j+0x80);        //垂直地址
  759.        WriteCommand(x+0x80);          //水平地址
  760.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  761.        {
  762.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
  763.            if(ucFbFlag==1)  //反白显示
  764.            {
  765.                ucTemp=~ucTemp;
  766.            }
  767.            LCDWriteData(ucTemp);
  768.           //         delay_short(30000);  //把上一节这个延时函数去掉,加快刷屏速度
  769.       }
  770.    }
  771.    WriteCommand(0x36); //开显示缓冲指令
  772. }




  773. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  774. {
  775.         unsigned char i;
  776.         for ( i = 0; i < 8; i++ )
  777.         {
  778.                 if ( (ucData << i) & 0x80 )
  779.                 {
  780.                         LCDSID_dr = 1;
  781.                 }
  782.                 else
  783.                 {
  784.                         LCDSID_dr = 0;
  785.                 }
  786.                 LCDCLK_dr = 0;
  787.                 LCDCLK_dr = 1;
  788.         }
  789. }

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


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

  798.         LCDCS_dr = 0;
  799.         LCDCS_dr = 1;
  800.         SPIWrite(ucCommand, 0);
  801.         delay_short(90);
  802. }

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

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



  815. void delay_short(unsigned int uiDelayShort) //延时函数
  816. {
  817.    unsigned int i;  
  818.    for(i=0;i<uiDelayShort;i++)
  819.    {
  820.      ;  
  821.    }
  822. }


  823. void delay_long(unsigned int uiDelayLong)
  824. {
  825.    unsigned int i;
  826.    unsigned int j;
  827.    for(i=0;i<uiDelayLong;i++)
  828.    {
  829.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  830.           {
  831.              ; //一个分号相当于执行一条空语句
  832.           }
  833.    }
  834. }



复制代码

总结陈词:
这节讲的是键盘输入数字或者小数点的BCD码用来显示,实际项目中,我们经常要知道所输入的BCD码数组到底有效数值是多少,这个该怎么办?欲知详情,请听下回分解----
实时同步把键盘输入的BCD码数组转换成数值的液晶屏显示程序。


(未完待续,下节更精彩,不要走开哦)

乐于分享,勇于质疑!
 楼主| 发表于 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码数组会同步更新显示在第二行的数值上。
84节照片.jpg
(3)源代码讲解如下:
  1. #include "REG52.H"


  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间

  3. #define const_key_time  10    //按键去抖动延时的时间

  4. sbit key_sr1=P0^0; //第一行输入
  5. sbit key_sr2=P0^1; //第二行输入
  6. sbit key_sr3=P0^2; //第三行输入
  7. sbit key_sr4=P0^3; //第四行输入

  8. sbit key_dr1=P0^4; //第一列输出
  9. sbit key_dr2=P0^5; //第二列输出
  10. sbit key_dr3=P0^6; //第三列输出
  11. sbit key_dr4=P0^7; //第四列输出

  12. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

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

  17. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  18. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  19. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  20. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  21. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  22. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
  23. 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);//把字模插入画布.
  24. 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); //显示任意点阵函数
  25. unsigned char *number_to_matrix(unsigned char  ucBitNumber); //把一位数字转换成字模首地址的函数
  26. void delay_short(unsigned int uiDelayshort); //延时
  27. void delay_long(unsigned int uiDelayLong);

  28. void key_number_input(unsigned char ucKeyNumber); //输入数字按键
  29. void set_data(unsigned char ucKeyNumberTemp, //设置参数
  30.               unsigned char ucDotBitMax,
  31.               unsigned char ucDataCntMax,
  32.               unsigned char *p_ucDotCnt,
  33.               unsigned char *p_ucDotBitS,
  34.                           unsigned char *p_ucWdPartCnt,
  35.                           unsigned char *p_ucSetDataBuffer,
  36.                           unsigned char ucIntCntMax,
  37.                           unsigned char *p_ucIntCnt);

  38. unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer); //把带小数点的BCD数组转换成long类型的数值。

  39. void key_delete_input(void); //删除按键

  40. void T0_time(); //定时中断函数
  41. void key_service();
  42. void key_scan(); //按键扫描函数 放在定时中断里

  43. void initial_myself();   
  44. void initial_peripheral();


  45. void lcd_display_service(void); //应用层面的液晶屏显示程序
  46. void clear_all_canvas(void);  //把画布全部清零

  47. code unsigned char Zf816_0[]=
  48. {
  49. /*--  文字:  0  --*/
  50. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  51. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  52. };

  53. code unsigned char Zf816_1[]=
  54. {
  55. /*--  文字:  1  --*/
  56. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  57. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  58. };

  59. code unsigned char Zf816_2[]=
  60. {
  61. /*--  文字:  2  --*/
  62. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  63. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  64. };

  65. code unsigned char Zf816_3[]=
  66. {
  67. /*--  文字:  3  --*/
  68. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  69. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  70. };

  71. code unsigned char Zf816_4[]=
  72. {
  73. /*--  文字:  4  --*/
  74. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  75. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  76. };

  77. code unsigned char Zf816_5[]=
  78. {
  79. /*--  文字:  5  --*/
  80. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  81. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  82. };

  83. code unsigned char Zf816_6[]=
  84. {
  85. /*--  文字:  6  --*/
  86. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  87. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  88. };


  89. code unsigned char Zf816_7[]=
  90. {
  91. /*--  文字:  7  --*/
  92. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  93. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  94. };

  95. code unsigned char Zf816_8[]=
  96. {
  97. /*--  文字:  8  --*/
  98. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  99. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  100. };

  101. code unsigned char Zf816_9[]=
  102. {
  103. /*--  文字:  9  --*/
  104. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  105. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
  106. };


  107. code unsigned char Zf816_nc[]=  //空字模
  108. {
  109. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  110. };

  111. code unsigned char Zf816_dot[]=  //小数点
  112. {
  113. /*--  文字:  .  --*/
  114. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  115. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x00,0x00,
  116. };

  117. code unsigned char Zf816_mao_hao[]=  //冒号
  118. {
  119. /*--  文字:  :  --*/
  120. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  121. 0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
  122. };

  123. code unsigned char Hz1616_yi[]=
  124. {
  125. /*--  文字:  一  --*/
  126. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  127. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
  128. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  129. };

  130. code unsigned char Hz1616_xiang[]=
  131. {
  132. /*--  文字:  项  --*/
  133. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  134. 0x00,0x00,0x03,0xFE,0xFC,0x20,0x10,0x40,0x11,0xFC,0x11,0x04,0x11,0x24,0x11,0x24,
  135. 0x11,0x24,0x11,0x24,0x1D,0x24,0xE1,0x34,0x00,0x48,0x01,0x86,0x06,0x02,0x00,0x00,
  136. };

  137. code unsigned char Hz1616_shu[]=
  138. {
  139. /*--  文字:  数  --*/
  140. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  141. 0x08,0x20,0x49,0x30,0x2A,0x20,0x1C,0x20,0xFF,0x7E,0x1C,0x44,0x2B,0x44,0x48,0xC4,
  142. 0x08,0x28,0xFF,0x28,0x12,0x10,0x34,0x10,0x0C,0x28,0x32,0x4E,0xC0,0x84,0x00,0x00,
  143. };

  144. code unsigned char Hz1616_zhu[]=
  145. {
  146. /*--  文字:  组  --*/
  147. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  148. 0x10,0x00,0x19,0xF8,0x11,0x08,0x25,0x08,0x25,0x08,0x79,0xF8,0x09,0x08,0x11,0x08,
  149. 0x21,0x08,0x7D,0xF8,0x01,0x08,0x01,0x08,0x0D,0x08,0x73,0xFE,0x00,0x00,0x00,0x00,
  150. };

  151. code unsigned char Hz1616_zhi[]=
  152. {
  153. /*--  文字:  值  --*/
  154. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  155. 0x10,0x40,0x18,0x60,0x17,0xFC,0x10,0x40,0x20,0x80,0x33,0xF8,0x62,0x08,0xA3,0xF8,
  156. 0x22,0x08,0x23,0xF8,0x22,0x08,0x23,0xF8,0x22,0x08,0x22,0x08,0x2F,0xFE,0x20,0x00,
  157. };

  158. /* 注释一:
  159. * 以下是画布显示数组。横向是6个字节,纵向16行,可以显示3个16x16的汉字.
  160. *  注意,这节内容的画布跟前面79章节的画布大小不一样,79节前面的横向是4个字节,这节的横向是6个字节。
  161. */
  162. unsigned char ucCanvasBuffer[]=
  163. {
  164. 0x00,0x00,0x00,0x00,0x00,0x00,  //上半屏
  165. 0x00,0x00,0x00,0x00,0x00,0x00,
  166. 0x00,0x00,0x00,0x00,0x00,0x00,
  167. 0x00,0x00,0x00,0x00,0x00,0x00,
  168. 0x00,0x00,0x00,0x00,0x00,0x00,
  169. 0x00,0x00,0x00,0x00,0x00,0x00,
  170. 0x00,0x00,0x00,0x00,0x00,0x00,
  171. 0x00,0x00,0x00,0x00,0x00,0x00,

  172. //------------上半屏和下半屏的分割线-----------

  173. 0x00,0x00,0x00,0x00,0x00,0x00,  //下半屏
  174. 0x00,0x00,0x00,0x00,0x00,0x00,
  175. 0x00,0x00,0x00,0x00,0x00,0x00,
  176. 0x00,0x00,0x00,0x00,0x00,0x00,
  177. 0x00,0x00,0x00,0x00,0x00,0x00,
  178. 0x00,0x00,0x00,0x00,0x00,0x00,
  179. 0x00,0x00,0x00,0x00,0x00,0x00,
  180. 0x00,0x00,0x00,0x00,0x00,0x00,
  181. };


  182. /* 注释二:
  183. * 以下5个变量记录一个参数的5种信息,包括小数点的数量,小数点个数,数据的位置,数组具体值,整数个数
  184. */
  185. unsigned char ucDotCnt_1=0;  //记录当前输入的小数点数量,如果小数点的数量不为0,说明当前数组已包含小数点,此时再按小数点按键则无效
  186. unsigned char ucDotBitS_1=0; //记录当前输入的小数点个数,如果小数点的个数如果超过规定ucDotBitMax位,此时再按任何输入按键则无效
  187. unsigned char ucWdPartCnt_1=0; //记录当前输入的数据在数组中的位置。
  188. unsigned char ucDataBuffer_1[6]={0,10,10,10,10,10}; //一项的BCD码数组缓冲
  189. unsigned char ucIntCnt_1=0; //记录当前输入的整数个数,如果整数的个数如果超过规定ucIntCntMax位,此时再按任何输入按键则无效

  190. unsigned long ulData_1=0; //用一个long变量表示BCD码的具体数值。


  191. unsigned char ucKeyStep=1;  //按键扫描步骤变量

  192. unsigned char ucKeySec=0;   //被触发的按键编号
  193. unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
  194. unsigned char ucKeyLock=0; //按键触发后自锁的变量标志

  195. unsigned char ucRowRecord=1; //记录当前扫描到第几列了


  196. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器


  197. unsigned char ucWd=1; //窗口变量
  198. unsigned char ucPart=1; //局部变量 0代表没有选中任何一行,其它数值1到4代表选中某一行


  199. unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量      1代表更新显示,响应函数内部会清零
  200. unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量  1代表更新显示,响应函数内部会自动把它清零
  201. unsigned char ucWd1Part2Update=0; //窗口1的第2行局部更新显示变量  1代表更新显示,响应函数内部会自动把它清零

  202. void main()
  203.   {
  204.         initial_myself();      //第一区,上电后马上初始化
  205.         delay_long(100);       //一线,延时线。延时一段时间
  206.         initial_peripheral();  //第二区,上电后延时一段时间再初始化

  207.         while(1)   //第三区
  208.         {
  209.                     key_service(); //按键服务程序
  210.             lcd_display_service(); //应用层面的液晶屏显示程序
  211.         }

  212. }


  213. void initial_myself()  //第一区 上电后马上初始化
  214. {

  215.    beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。

  216.    TMOD=0x01;  //设置定时器0为工作方式1

  217.    TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  218.    TL0=0x2f;
  219. }
  220. void initial_peripheral() //第二区 上电后延时一段时间再初始化
  221. {
  222.     LCDInit(); //初始化12864 内部包含液晶模块的复位


  223.     EA=1;     //开总中断
  224.     ET0=1;    //允许定时中断
  225.     TR0=1;    //启动定时中断

  226. }


  227. void T0_time() interrupt 1
  228. {
  229.   TF0=0;  //清除中断标志
  230.   TR0=0; //关中断

  231.   key_scan();//按键扫描函数 放在定时中断里

  232.   if(uiVoiceCnt!=0)
  233.   {
  234.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  235.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  236.   }
  237.   else
  238.   {
  239.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  240.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  241.   }


  242.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  243.   TL0=0x2f;
  244.   TR0=1;  //开中断
  245. }


  246. void key_scan()//按键扫描函数 放在定时中断里
  247. {  

  248.   switch(ucKeyStep)
  249.   {
  250.      case 1:   //按键扫描输出第ucRowRecord列低电平
  251.               if(ucRowRecord==1)  //第一列输出低电平
  252.                   {
  253.              key_dr1=0;      
  254.              key_dr2=1;
  255.              key_dr3=1;   
  256.              key_dr4=1;
  257.                   }
  258.               else if(ucRowRecord==2)  //第二列输出低电平
  259.                   {
  260.              key_dr1=1;      
  261.              key_dr2=0;
  262.              key_dr3=1;   
  263.              key_dr4=1;
  264.                   }
  265.               else if(ucRowRecord==3)  //第三列输出低电平
  266.                   {
  267.              key_dr1=1;      
  268.              key_dr2=1;
  269.              key_dr3=0;   
  270.              key_dr4=1;
  271.                   }
  272.               else   //第四列输出低电平
  273.                   {
  274.              key_dr1=1;      
  275.              key_dr2=1;
  276.              key_dr3=1;   
  277.              key_dr4=0;
  278.                   }

  279.           uiKeyTimeCnt=0;  //延时计数器清零
  280.           ucKeyStep++;     //切换到下一个运行步骤
  281.               break;

  282.      case 2:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
  283.           uiKeyTimeCnt++;
  284.                   if(uiKeyTimeCnt>1)
  285.                   {
  286.                      uiKeyTimeCnt=0;
  287.              ucKeyStep++;     //切换到下一个运行步骤
  288.                   }
  289.               break;

  290.      case 3:
  291.           if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  292.           {  
  293.              ucKeyStep=1;  //如果没有按键按下,返回到第一个运行步骤重新开始扫描
  294.              ucKeyLock=0;  //按键自锁标志清零
  295.              uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙     
  296.    
  297.                          ucRowRecord++;  //输出下一列
  298.                          if(ucRowRecord>4)  
  299.                          {
  300.                             ucRowRecord=1; //依次输出完四列之后,继续从第一列开始输出低电平
  301.                          }

  302.           }
  303.                   else if(ucKeyLock==0)  //有按键按下,且是第一次触发
  304.                   {
  305.                      if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  306.                          {
  307.                             uiKeyTimeCnt++;  //去抖动延时计数器
  308.                                 if(uiKeyTimeCnt>const_key_time)
  309.                                 {
  310.                                    uiKeyTimeCnt=0;
  311.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零

  312.                        if(ucRowRecord==1)  //第一列输出低电平
  313.                            {
  314.                                       ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
  315.                            }
  316.                        else if(ucRowRecord==2)  //第二列输出低电平
  317.                            {
  318.                                       ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
  319.                            }
  320.                        else if(ucRowRecord==3)  //第三列输出低电平
  321.                            {
  322.                                       ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
  323.                            }
  324.                        else   //第四列输出低电平
  325.                            {
  326.                                       ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
  327.                            }

  328.                                 }
  329.                         
  330.                          }
  331.                      else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
  332.                          {
  333.                             uiKeyTimeCnt++;  //去抖动延时计数器
  334.                                 if(uiKeyTimeCnt>const_key_time)
  335.                                 {
  336.                                    uiKeyTimeCnt=0;
  337.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  338.                        if(ucRowRecord==1)  //第一列输出低电平
  339.                            {
  340.                                       ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
  341.                            }
  342.                        else if(ucRowRecord==2)  //第二列输出低电平
  343.                            {
  344.                                       ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
  345.                            }
  346.                        else if(ucRowRecord==3)  //第三列输出低电平
  347.                            {
  348.                                       ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
  349.                            }
  350.                        else   //第四列输出低电平
  351.                            {
  352.                                       ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
  353.                            }
  354.                                 }
  355.                         
  356.                          }
  357.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
  358.                          {
  359.                             uiKeyTimeCnt++;  //去抖动延时计数器
  360.                                 if(uiKeyTimeCnt>const_key_time)
  361.                                 {
  362.                                    uiKeyTimeCnt=0;
  363.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  364.                        if(ucRowRecord==1)  //第一列输出低电平
  365.                            {
  366.                                       ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
  367.                            }
  368.                        else if(ucRowRecord==2)  //第二列输出低电平
  369.                            {
  370.                                       ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S10键
  371.                            }
  372.                        else if(ucRowRecord==3)  //第三列输出低电平
  373.                            {
  374.                                       ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
  375.                            }
  376.                        else   //第四列输出低电平
  377.                            {
  378.                                       ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
  379.                            }
  380.                                 }
  381.                         
  382.                          }
  383.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
  384.                          {
  385.                             uiKeyTimeCnt++;  //去抖动延时计数器
  386.                                 if(uiKeyTimeCnt>const_key_time)
  387.                                 {
  388.                                    uiKeyTimeCnt=0;
  389.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  390.                        if(ucRowRecord==1)  //第一列输出低电平
  391.                            {
  392.                                       ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
  393.                            }
  394.                        else if(ucRowRecord==2)  //第二列输出低电平
  395.                            {
  396.                                       ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S14键
  397.                            }
  398.                        else if(ucRowRecord==3)  //第三列输出低电平
  399.                            {
  400.                                       ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
  401.                            }
  402.                        else   //第四列输出低电平
  403.                            {
  404.                                       ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
  405.                            }
  406.                                 }
  407.                         
  408.                          }
  409.                   
  410.                   }
  411.               break;

  412.   }


  413. }


  414. void key_service() //按键服务的应用程序
  415. {
  416.   switch(ucKeySec) //按键服务状态切换
  417.   {
  418.     case 1:// 数字1 对应朱兆祺学习板的S1键
  419.           key_number_input(1); //输入数字按键
  420.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  421.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  422.           break;        
  423.     case 2:// 数字2 对应朱兆祺学习板的S2键
  424.           key_number_input(2); //输入数字按键
  425.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  426.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  427.           break;     
  428.     case 3:// 数字3 对应朱兆祺学习板的S3键
  429.           key_number_input(3); //输入数字按键
  430.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  431.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  432.           break;         
  433.     case 4:// 数字4 对应朱兆祺学习板的S4键
  434.           key_number_input(4); //输入数字按键
  435.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  436.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  437.           break;   
  438.     case 5:// 数字5 对应朱兆祺学习板的S5键
  439.           key_number_input(5); //输入数字按键
  440.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  441.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  442.           break;   
  443.     case 6:// 数字6 对应朱兆祺学习板的S6键
  444.           key_number_input(6); //输入数字按键
  445.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  446.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  447.           break;   
  448.     case 7:// 数字7 对应朱兆祺学习板的S7键
  449.           key_number_input(7); //输入数字按键
  450.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  451.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  452.           break;   
  453.     case 8: //数字8 对应朱兆祺学习板的S8键
  454.           key_number_input(8); //输入数字按键
  455.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  456.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  457.           break;   
  458.     case 9:// 数字9 对应朱兆祺学习板的S9键
  459.           key_number_input(9); //输入数字按键
  460.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  461.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  462.           break;   
  463.     case 10:// 数字0  对应朱兆祺学习板的S10键
  464.           key_number_input(0); //输入数字按键
  465.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  466.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  467.           break;   
  468.     case 11:// 小数点按键 对应朱兆祺学习板的S11键
  469.           key_number_input(11); //输入数字按键  11代表小数点
  470.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  471.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  472.           break;   
  473.     case 12:// 本节暂时不用 对应朱兆祺学习板的S12键  

  474.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  475.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  476.           break;   
  477.     case 13:// 本节暂时不用 对应朱兆祺学习板的S13键   

  478.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  479.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  480.           break;   
  481.     case 14:// 本节暂时不用  对应朱兆祺学习板的S14键   
  482.         
  483.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  484.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  485.           break;   
  486.     case 15:// 本节暂时不用 对应朱兆祺学习板的S15键

  487.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  488.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  489.           break;   
  490.     case 16:// 清除按键 对应朱兆祺学习板的S16键
  491.           key_delete_input(); //删除按键
  492.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  493.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  494.           break;   
  495.   }               
  496. }



  497. void key_number_input(unsigned char ucKeyNumber) //输入数字按键
  498. {

  499.     switch(ucWd)
  500.     {
  501.        case 1:   //第1窗口。本节程序只有1个窗口
  502.              switch(ucPart)
  503.              {

  504.                  case 1:  //1窗口第1项
  505.                       set_data(ucKeyNumber,  //本函数跟前面第83节内容有所改动,请看本函数具体内容。本节的核心内容,值得好好研究!     
  506.                                                    2,  //小数点最大个数
  507.                                                            6,  //数组缓冲最大个数
  508.                                                        &ucDotCnt_1,
  509.                                                            &ucDotBitS_1,
  510.                                                            &ucWdPartCnt_1,
  511.                                                            ucDataBuffer_1,
  512.                                                            3, //整数部分的最大个数
  513.                                                            &ucIntCnt_1);

  514.                                           ulData_1=buffer_to_data(6,2,ucDataBuffer_1); //把带小数点的BCD码数组转换成long数值。
  515.                       ucWd1Part1Update=1;//第一行局部更新显示
  516.                                           ucWd1Part2Update=1;//第二行局部更新显示
  517.                       break;               
  518.              }
  519.                                        
  520.              break;
  521.     }                        
  522.                                 
  523. }


  524. /* 注释三:
  525. * 本函数在前面第83节内容的函数上有改动,为了限制整数部分的个数,多添加了第8和第9这两个参数。
  526. * 本节的核心函数,值得好好研究!
  527. * 涉及到参数的4种信息,包括小数点的数量,小数点的个数,数据的位置,数组具体值,整数的数量,整数的个数,以及它们之间的相互作用关系。
  528. * 以下参数,指针类型的参数是让代入的全局变量在退出函数后维持它当前最新更改的数值不变。
  529. * 第1个参数ucKeyNumberTemp是当前按键输入的数值。
  530. * 第2个参数ucDotBitMax是限定被设置参数的小数点最大位数。
  531. * 第3个参数ucDataCntMax是限定被设置参数的最大数组个数。
  532. * 第4个参数*p_ucDotCnt是记录当前输入的小数点数量,如果小数点的数量不为0,说明当前数组已包含小数点,此时再按小数点按键则无效。
  533. * 第5个参数*p_ucDotBitS是记录当前输入的小数点个数,如果小数点的个数如果超过规定ucDotBitMax位,此时再按任何输入按键则无效
  534. * 第6个参数*p_ucWdPartCnt是记录当前输入的数据在数组中的位置,方便锁定每次按键输入的数字显示位置。
  535. * 第7个参数*p_ucSetDataBuffer是BCD码数组缓冲的具体数字内容。
  536. * 第8个参数ucIntCntMax是限定被设置参数的整数部分的最大位数。
  537. * 第9个参数*p_ucIntCnt是记录当前输入的整数部分个数,如果整数部分的个数如果超过规定ucIntCntMax位,此时再按任何输入按键则无效
  538. */
  539. void set_data(unsigned char ucKeyNumberTemp,
  540.               unsigned char ucDotBitMax,
  541.               unsigned char ucDataCntMax,
  542.               unsigned char *p_ucDotCnt,
  543.               unsigned char *p_ucDotBitS,
  544.                           unsigned char *p_ucWdPartCnt,
  545.                           unsigned char *p_ucSetDataBuffer,
  546.                           unsigned char ucIntCntMax,
  547.                           unsigned char *p_ucIntCnt)
  548. {
  549.                     unsigned int i;

  550.                     if(ucKeyNumberTemp==11) //等于小数点
  551.                     {
  552.                        if(ucDotBitMax==0) //如果限定的小数点最大数是0,就意味着此数据不允许带小数点,必须是整数。
  553.                        {
  554.                            return; //直接返回退出
  555.                        }
  556.                        else if(*p_ucDotCnt>0)  //小数点个数大于0,意味着当前数组已经包含了小数点,此时再输入小数点则无效。
  557.                        {
  558.                            return; //直接返回退出
  559.                        }
  560.                        else  //否则有效,记录当前已经包含一个小数点的信息。
  561.                        {
  562.                            *p_ucDotCnt=1;  //只能包含一个小数点
  563.                        }
  564.                     }
  565.                     else  //如果输入的不是小数点
  566.                     {
  567.                         if(*p_ucDotCnt==1) //如果之前已经输入了一个小数点,那么此时输入的数字就是小数点后的数据
  568.                                                 {
  569.                            if(*p_ucDotBitS<ucDotBitMax) //如果小数点位数还没超过最大限制位数,则继续加1记录当前小数点位数。
  570.                            {
  571.                                *p_ucDotBitS=(*p_ucDotBitS)+1;
  572.                            }
  573.                            else //如果小数点位数已经超过允许的范围,则输入的按键无效,直接退出。
  574.                            {
  575.                               return; //直接返回退出
  576.                            }
  577.                                             }
  578.                                                 else if(*p_ucIntCnt<ucIntCntMax)//如果之前没有输入小数点,那么输入的就是整数个数超,整数个数没有超过极限
  579.                                                 {
  580.                                                     *p_ucIntCnt=(*p_ucIntCnt)+1;
  581.                                                 }
  582.                                                 else //整数个数超过极限
  583.                                                 {
  584.                              return; //直接返回退出
  585.                                                 }
  586.                     }

  587.             
  588.             
  589.                     if(*p_ucWdPartCnt==0&&p_ucSetDataBuffer[0]==0&&ucKeyNumberTemp!=11)  //如果当前默认位置是第0个位置,并且默认第0个数据是0,并且当前的按键输入不是小数点,则不用移位
  590.                     {
  591.                         ;
  592.                     }        
  593.                     else  //否则,移位
  594.                     {               
  595.                        for(i=0;i<(ucDataCntMax-1);i++)  //移位
  596.                        {
  597.                           p_ucSetDataBuffer[ucDataCntMax-1-i]=p_ucSetDataBuffer[ucDataCntMax-2-i];
  598.                        }
  599.                        *p_ucWdPartCnt=(*p_ucWdPartCnt)+1;
  600.                     }
  601.                     p_ucSetDataBuffer[0]=ucKeyNumberTemp; //当前输入的数字或者小数点永远在第右边第0个位置。
  602.                                                                
  603.         

  604. }


  605. /* 注释四:
  606. * 本节的核心函数,值得好好研究!
  607. * 功能:把一个带小数点的BCD码数组转换成一个long类型的数值。
  608. * 第1个参数ucConverDataSize是这个数组的最大有效个数。
  609. * 第2个参数ucConverDotCnt是这个数组要转换成的long数值带几个小数点
  610. * 第3个参数*p_ucConverBuffer是具体此数组的数据
  611. * 函数最后返回被转换的long数值。
  612. */
  613. unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer)
  614. {
  615.    unsigned long ulConverResult=0;
  616.    unsigned long ulConverResultTemp=0;
  617.    unsigned char ucConverResultBuffer[6]; //因为本节内容的ucConverDataSize是6,所以取6.
  618.    unsigned char i;
  619.    unsigned char j;
  620.    unsigned char ucConverFlag;

  621.    for(i=0;i<ucConverDataSize;i++)
  622.    {
  623.       ucConverResultBuffer[i]=0;  //先把临时缓冲区清零
  624.    }

  625.    j=0;
  626.    ucConverFlag=0;
  627.    for(i=0;i<ucConverDataSize;i++)
  628.    {
  629.        if(p_ucConverBuffer[i]==11) //小数点
  630.        {
  631.           ucConverFlag=i; //记录小数点的位置
  632.        }
  633.        else if(p_ucConverBuffer[i]<10)
  634.        {
  635.           ucConverResultBuffer[j]=p_ucConverBuffer[i];  //提取数组中的有效数字
  636.           j++;
  637.        }


  638.    }


  639.    for(i=0;i<ucConverDataSize;i++)   //通过处理每一位从而合成一个long类型的数值
  640.    {
  641.        ulConverResultTemp=0;
  642.        ulConverResultTemp=ucConverResultBuffer[i];
  643.        for(j=0;j<i;j++)
  644.        {
  645.            ulConverResultTemp=ulConverResultTemp*10;  //把每一位对应的进位扩大到对应的倍数
  646.        }
  647.        ulConverResult=ulConverResult+ulConverResultTemp;
  648.    }


  649.    for(i=ucConverFlag;i<ucConverDotCnt;i++) //根据数组小数点的位置和实际要转换成的小数点个数,来扩大到对应的倍数。
  650.    {
  651.       ulConverResult=ulConverResult*10;
  652.    }

  653.    return ulConverResult;
  654. }

  655. void key_delete_input(void) //删除按键
  656. {
  657.     static unsigned int i;

  658.    switch(ucWd)
  659.    {
  660.       case 1:   //第1窗口。本节程序只有1个窗口
  661.            switch(ucPart)
  662.            {
  663.               case 1:  //1窗口第1项
  664.                     //清零
  665.                                         ulData_1=0; //long数值清零
  666.                                          ucIntCnt_1=0;
  667.                     ucDotBitS_1=0;  
  668.                     ucDotCnt_1=0;  
  669.                     ucWdPartCnt_1=0;               
  670.                     for(i=0;i<6;i++)  
  671.                     {
  672.                        ucDataBuffer_1[i]=10;
  673.                     }
  674.                     ucDataBuffer_1[0]=0; //第0个位置填入0
  675.         
  676.                     ucWd1Part1Update=1;//第一行局部更新显示
  677.                                     ucWd1Part2Update=1;//第二行局部更新显示
  678.                     break;               
  679.       
  680.            }
  681.                                        
  682.            break;
  683.         
  684.    }                        
  685.                                 
  686. }

  687. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
  688. {
  689.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小,分别调用不同的字库。

  690.         switch(ucBitNumber)  //根据ucBitNumber数值的大小,分别调用不同的字库。
  691.         {
  692.             case 0:
  693.              p_ucAnyNumber=Zf816_0;
  694.                      break;
  695.             case 1:
  696.              p_ucAnyNumber=Zf816_1;
  697.                      break;
  698.             case 2:
  699.              p_ucAnyNumber=Zf816_2;
  700.                      break;
  701.             case 3:
  702.              p_ucAnyNumber=Zf816_3;
  703.                      break;
  704.             case 4:
  705.              p_ucAnyNumber=Zf816_4;
  706.                      break;
  707.             case 5:
  708.              p_ucAnyNumber=Zf816_5;
  709.                      break;
  710.             case 6:
  711.              p_ucAnyNumber=Zf816_6;
  712.                      break;
  713.             case 7:
  714.              p_ucAnyNumber=Zf816_7;
  715.                      break;
  716.             case 8:
  717.              p_ucAnyNumber=Zf816_8;
  718.                      break;
  719.             case 9:
  720.              p_ucAnyNumber=Zf816_9;
  721.                      break;
  722.             case 10:  //空格
  723.              p_ucAnyNumber=Zf816_nc;
  724.                      break;
  725.                         case 11:   //小数点
  726.              p_ucAnyNumber=Zf816_dot;
  727.                      break;
  728.                 default:   //如果上面的条件都不符合,那么默认指向空字模
  729.              p_ucAnyNumber=Zf816_nc;
  730.                      break;
  731.         }

  732.     return p_ucAnyNumber;  //返回转换结束后的指针
  733. }



  734. void lcd_display_service(void) //应用层面的液晶屏显示程序
  735. {


  736.     static unsigned char *p_ucAnyNumber; //经过数字转换成字模后,分解变量的某位字模首地址
  737.     static unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
  738.     static unsigned int i;
  739.         static unsigned char ucDataBuffer_temp[6]; //分解一个10进制的long类型数据的每一位

  740.     switch(ucWd)  //本程序的核心变量,窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  741.     {
  742.         case 1:   //显示窗口1的数据
  743.                if(ucWd1Update==1)  //窗口1整屏更新,里面只放那些不用经常刷新显示的内容
  744.                {
  745.                      ucWd1Update=0;  //及时清零,避免一直更新

  746.                      ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量,这里在前面数码管显示框架上有所改进
  747.                      ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量,这里在前面数码管显示框架上有所改进

  748.                      display_clear(0x00); // 清屏操作, 全部显示空填充0x00,全部显示点阵用0xff。
  749.                      clear_all_canvas();  //把画布全部清零

  750.                      display_lattice(0,0,Hz1616_yi,0,2,16,0);    //一项数组
  751.                      display_lattice(1,0,Hz1616_xiang,0,2,16,0);   
  752.                      display_lattice(2,0,Hz1616_shu,0,2,16,0);   
  753.                      display_lattice(3,0,Hz1616_zhu,0,2,16,0);
  754.                      display_lattice(4,0,Zf816_mao_hao,0,1,16,0); //冒号

  755.                      display_lattice(0,16,Hz1616_yi,0,2,16,0);    //一项数值
  756.                      display_lattice(1,16,Hz1616_xiang,0,2,16,0);   
  757.                      display_lattice(2,16,Hz1616_shu,0,2,16,0);   
  758.                      display_lattice(3,16,Hz1616_zhi,0,2,16,0);
  759.                      display_lattice(4,16,Zf816_mao_hao,0,1,16,0); //冒号              

  760.                }

  761.                if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
  762.                {
  763.                         ucWd1Part1Update=0; //及时清零,避免一直更新

  764.                         if(ucPart==1) //被选中
  765.                         {
  766.                            ucCursorFlag=1; //反显 显示
  767.                         }
  768.                         else //没被选中
  769.                         {
  770.                             ucCursorFlag=0; //正常 显示
  771.                         }

  772.                         
  773.                         for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
  774.                         {
  775.                             p_ucAnyNumber=number_to_matrix(ucDataBuffer_1[5-i]);
  776.                             insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16);  //这里的i是画布的横向地址,一共可以显示6个字符,因此取值范围是0到5
  777.                         }

  778.                         display_lattice(5,0,ucCanvasBuffer,ucCursorFlag,6,16,0);   //显示整屏的画布,最后的参数0是偏移量
  779.                }

  780.                if(ucWd1Part2Update==1) //窗口1的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
  781.                {
  782.                         ucWd1Part2Update=0; //及时清零,避免一直更新

  783.                         if(ucPart==2) //被选中
  784.                         {
  785.                            ucCursorFlag=1; //反显 显示
  786.                         }
  787.                         else //没被选中
  788.                         {
  789.                             ucCursorFlag=0; //正常 显示
  790.                         }

  791.                         if(ulData_1>=10000)
  792.                                                 {
  793.                                                    ucDataBuffer_temp[5]=ulData_1%100000/10000;
  794.                                                 }
  795.                                                 else
  796.                                                 {
  797.                                                    ucDataBuffer_temp[5]=10; //空格
  798.                                                 }

  799.                         if(ulData_1>=1000)
  800.                                                 {
  801.                                                       ucDataBuffer_temp[4]=ulData_1%10000/1000;
  802.                         }
  803.                                                 else
  804.                                                 {
  805.                                                       ucDataBuffer_temp[4]=10; //空格
  806.                         }

  807.                                                 ucDataBuffer_temp[3]=ulData_1%1000/100;
  808.                                                 ucDataBuffer_temp[2]=11;  //11代表小数点
  809.                                                 ucDataBuffer_temp[1]=ulData_1%100/10;
  810.                                                 ucDataBuffer_temp[0]=ulData_1%10/1;
  811.                         
  812.                         for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
  813.                         {
  814.                             p_ucAnyNumber=number_to_matrix(ucDataBuffer_temp[5-i]);
  815.                             insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16);  //这里的i是画布的横向地址,一共可以显示6个字符,因此取值范围是0到5
  816.                         }

  817.                         display_lattice(5,16,ucCanvasBuffer,ucCursorFlag,6,16,0);   //显示整屏的画布,最后的参数0是偏移量
  818.                }

  819.                      
  820.                break;
  821.         //本程序只有1个窗口,所以只有一个case 1,如果要增加窗口,就直接增加 case 2, case 3...        
  822.     }

  823. }



  824. void clear_all_canvas(void)  //把画布全部清零
  825. {
  826.    unsigned int j=0;
  827.    unsigned int i=0;

  828.    for(j=0;j<16;j++)  //这里的16表示画布有16行
  829.    {
  830.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
  831.       {
  832.                   ucCanvasBuffer[j*4+i]=0x00;
  833.       }
  834.    }         

  835. }





  836. void display_clear(unsigned char ucFillDate) // 清屏  全部显示空填充0x00   全部显示点阵用0xff
  837. {   

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

  853. }

  854. /* 注释五:
  855. * 注意,这节内容的画布跟第79节前面的画布大小不一样,第79节前面的横向是4个字节,这节的横向是6个字节。
  856. * 把字模插入画布的函数.
  857. * 这是本节的核心函数,读者尤其要搞懂x_amount和y_amount对应的显示关系。
  858. * 第1,2个参数x,y是在画布中的坐标体系。
  859. * x的范围是0至5,因为画布的横向只要6个字节。y的范围是0至15,因为画布的纵向只有16行。
  860. * 第3个参数*ucArray是字模的数组。
  861. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示,1代表反白显示。
  862. * 第5,6个参数x_amount,y_amount分别代表字模数组的横向有多少个字节,纵向有几横。
  863. */
  864. 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)
  865. {
  866.    unsigned int j=0;
  867.    unsigned int i=0;
  868.    unsigned char ucTemp;
  869.    for(j=0;j<y_amount;j++)
  870.    {
  871.       for(i=0;i<x_amount;i++)
  872.       {
  873.               ucTemp=ucArray[j*x_amount+i];
  874.               if(ucFbFlag==0)
  875.               {
  876.                  ucCanvasBuffer[(y+j)*6+x+i]=ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节,要稍微注意的。
  877.               }
  878.               else
  879.               {
  880.                  ucCanvasBuffer[(y+j)*6+x+i]=~ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节,要稍微注意的。
  881.               }
  882.       }
  883.    }         

  884. }

  885. /* 注释六:
  886. * 显示任意点阵函数.
  887. * 注意,本函数在前几节的基础上多增加了第7个参数uiOffSetAddr,它是偏移地址。
  888. * 对于这个函数,读者尤其要搞懂x_amount和y_amount对应的显示关系。
  889. * 第1,2个参数x,y是坐标体系。x的范围是0至15,y的范围是0至31.
  890. * 第3个参数*ucArray是字模的数组。
  891. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示,1代表反白显示。
  892. * 第5,6个参数x_amount,y_amount分别代表字模数组的横向有多少个字节,纵向有几横。
  893. * 第7个参数uiOffSetAddr是偏移地址,代表字模数组的从第几个数据开始显示。
  894. */
  895. 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)
  896. {
  897.    unsigned int j=0;
  898.    unsigned int i=0;
  899.    unsigned char ucTemp;

  900. //注意,要把以下两行指令屏蔽,否则屏幕在更新显示时会整屏闪动
  901. //  WriteCommand(0x34);  //关显示缓冲指令            
  902. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次,怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  903.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  904.    {
  905.        WriteCommand(y+j+0x80);        //垂直地址
  906.        WriteCommand(x+0x80);          //水平地址
  907.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  908.        {
  909.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
  910.            if(ucFbFlag==1)  //反白显示
  911.            {
  912.                ucTemp=~ucTemp;
  913.            }
  914.            LCDWriteData(ucTemp);
  915.           //         delay_short(30000);  //把上一节这个延时函数去掉,加快刷屏速度
  916.       }
  917.    }
  918.    WriteCommand(0x36); //开显示缓冲指令
  919. }




  920. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  921. {
  922.         unsigned char i;
  923.         for ( i = 0; i < 8; i++ )
  924.         {
  925.                 if ( (ucData << i) & 0x80 )
  926.                 {
  927.                         LCDSID_dr = 1;
  928.                 }
  929.                 else
  930.                 {
  931.                         LCDSID_dr = 0;
  932.                 }
  933.                 LCDCLK_dr = 0;
  934.                 LCDCLK_dr = 1;
  935.         }
  936. }

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


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

  945.         LCDCS_dr = 0;
  946.         LCDCS_dr = 1;
  947.         SPIWrite(ucCommand, 0);
  948.         delay_short(90);
  949. }

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

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



  962. void delay_short(unsigned int uiDelayShort) //延时函数
  963. {
  964.    unsigned int i;  
  965.    for(i=0;i<uiDelayShort;i++)
  966.    {
  967.      ;  
  968.    }
  969. }


  970. void delay_long(unsigned int uiDelayLong)
  971. {
  972.    unsigned int i;
  973.    unsigned int j;
  974.    for(i=0;i<uiDelayLong;i++)
  975.    {
  976.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  977.           {
  978.              ; //一个分号相当于执行一条空语句
  979.           }
  980.    }
  981. }


复制代码

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

(未完待续,下节更精彩,不要走开哦)

乐于分享,勇于质疑!
发表于 2014-12-19 22:26:12 | 显示全部楼层
来欣赏鸿哥的大作
乐于分享,勇于质疑!
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|Archiver|手机版|独闷闷网 ( 粤ICP备12007667号-2 )

GMT+8, 2024-3-29 09:35 , Processed in 0.239836 second(s), 16 queries .

快速回复 返回顶部 返回列表