1071

帖子

7

TA的资源

纯净的硅(中级)

141
 
给楼主赞一个
此帖出自51单片机论坛
 

回复

79

帖子

1

TA的资源

一粒金砂(中级)

142
 
赞一个!有时间慢慢学习!
此帖出自51单片机论坛
 
 
 

回复

98

帖子

0

TA的资源

一粒金砂(高级)

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

开场白:
本来这节打算讲调用液晶屏内部字库时让某行内容反显的,但是在昨天调试过程中,发现一个很奇怪的问题,当调用内部字库时,按照数据手册,我执行一条反显指令时,应该是仅仅某一行反显,但是却同时出现两行反显。比如,当我执行
       WriteCommand(0x34); //扩充指令集
       WriteCommand(0x04); //第1行反显
指令时,发现第一行和第三行反显,后来想想,我猜测这种12864的屏应该是25632折成左右半屏,左半屏在上面,右半屏在下面。经过这次经验,我觉得大家以后尽量不要用液晶屏的内部字库模式,应该用自构字库的模式(图形模式)。因为我觉得用内部字库模式的时候,这个集成的反显扩展指令不好用。而用自构字库的模式(图形模式),却可以顺心所欲的灵活运用,适合做菜单程序。
既然发现内部字库不好用,所以不再讲内部字库模式,这节仅仅接着前面第79节内容,继续讲在自构字库的模式(图形模式)下,如何通过矩阵键盘直接输入数字和小数点,就像普通的计算器一样键盘输入。这个功能表面简单,其实有以下四个地方值得注意:
第一:如何用数组接收按键输入的BCD码数据。
第二:如何限制输入参数的小数点个数和数组的有效个数。
第三:如果第0个位置是0,那么继续输入的数据直接覆盖0,否则就移位再输入。
第四:如果第0个位置是0,那么继续输入的小数点要移位输入。
要仔细了解以上提到的关键点,必须好好研究本程序中的void set_data(…)函数。同时也要温习一下之前讲的自构字库模式的液晶屏显示内容,尤其是插入画布显示的内容。

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

(1)     硬件平台:
基于朱兆祺51单片机学习板。数字1键对应S1键,数字2键对应S2键,数字3键对应S3键…. 数字9键对应S9键, 数字0键对应S10键。小数键对应S11,清零键对应S16,其它按键不用。

(2)     实现功能:
用矩阵键盘输入任意数字或小数点。小数点不能超过2位,一旦超过2位,再按其它按键则输入无效。有效数字也不能超过6位(包括小数点),一旦超过6位,再按其它按键则输入无效。
想重新输入,必须按S16清零按键才能重新输入。

(3)源代码讲解如下:
  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码数组转换成数值的液晶屏显示程序。

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

此帖出自51单片机论坛
 
 
 

回复

98

帖子

0

TA的资源

一粒金砂(高级)

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

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

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

(1)     硬件平台:
基于朱兆祺51单片机学习板。数字1键对应S1键,数字2键对应S2键,数字3键对应S3键…. 数字9键对应S9键, 数字0键对应S10键。小数键对应S11,清零键对应S16,其它按键不用。

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

(3)源代码讲解如下:
  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码数组的液晶屏显示程序。

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

此帖出自51单片机论坛
 
 
 

回复

30

帖子

0

TA的资源

一粒金砂(初级)

145
 
向你学习,谢谢辛苦了。
此帖出自51单片机论坛
 
 
 

回复

105

帖子

1

TA的资源

一粒金砂(中级)

146
 
鸿哥,能加个好友吗?
此帖出自51单片机论坛
 
 
 

回复

157

帖子

3

TA的资源

一粒金砂(中级)

147
 
jianhong_wu 发表于 2014-6-10 01:15
第一节:吴坚鸿谈初学单片机的误区。

(1)很难记住繁杂的寄存器?寄存器不用死记硬背,鸿哥我行走江湖多年,连一个寄存器都记不住。需要配置寄存器的时候,直接在网上或者书本上参考别人现成的配置程序是上策,查找芯片数据手册是中策,死记硬背寄存器是最最下策。

(2)很难记住繁杂的汇编语言指令?除非是在校学生要应付考试或者少数工作中绕不开汇编,否则学汇编就是浪费时间。鸿哥我行走江湖多年,从来就没有用汇编帮客户做过一个项目。

(3)C语言很难学?你不用学指针,你不用学带形参的函数,你不用学结构体,你不用学宏定义,你不用学文件操作,你也不用死记繁琐的数据类型。你只要会:
      5条指令语句switch语句,if else语句,while语句,for语句,=赋值语句。
      7个运算符+,-,*,/,|,&,!。
      4个逻辑关系符||,&&,!=,==.
      3个数据类型unsigned char, unsigned int, unsigned long。
      3个进制相互转化,二进制,十六进制,十进制。
      1个void函数。            
      1个一维数组code(或const) unsigned char array[]。
      那么世界上任何一种逻辑功能的单片机软件你都能做出来。
      鸿哥我当年刚毕业出来工作的时候才知道可以用C语言开发单片机,一开始只用if语句就把项目做出来了,没有用指针,没有用带形参的函数等复杂的功能。再到后来才慢慢开始用C语言其他的高级功能,但是我发现C语言其他的高级功能,本质上都是用我前面列举出来的最基本功能集合而成,只是书写更加简单方便了一点,编译后的机器码都大同小异。所以不会指针等高级功能你不用自卑,恰恰相反,当你会最简单的几个语句,就把这些高级功能的程序都做出来了,你才发现你对底层了解得更加透切,再学那些高级功能轻而易举。当你裸机跑的程序都能够协调得很好的时候,你才发现所谓高深的操作系统也不过如此,只要给你时间和金钱你也可以写个操作系统来玩玩。

(4)很难记住精确时间的计算公式?经常看到时间公式等于晶振,时钟周期,执行指令次数他们之间的乘除关系式。鸿哥我认为这些都是浮云,不用纠结也不用去记,大概了解一下就可以了。不管你对公式掌握得有多精确,你都不可能做出非常精确的时间。想用单片机做一个非常精确的时间这种想法一开始就是错的,不可能的。真想做一个比较精确的时间,应该用外围时钟芯片或者FPGA和CPLD,而不是单片机。

(5)很难记住繁杂的各种通信协议?什么IIC,SPI,232串口通讯,CAN,USB等等。这些都是浮云,你不用记那么多,你只要理解两种通讯方式就够了,那就是串行通讯方式和并行通讯方式。不管世界上有多少种通讯协议,物理世界上只有这两种通讯方式,其他各种名称的通讯协议都基于此两种方式演变而来。

(6)很难写短小精悍的程序?初学者不要纠结于此。做项目开发,程序容量不是刻意追求的目标,程序多一点少一点没关系,现在大容量的单片机品种非常多,容量不会是寸土寸金的事情,我们更加要关注程序的运行效率,可读性和可修改性。

      既然鸿哥列出了那么多误区,那么什么才是初学者关注的核心?预知详情,请听下回分解----delay()延时实现LED灯的闪烁。

(未完待续,下节更精彩,不要走开哦)
指针和结构体之妙用无穷,居然是没用的东西?



此帖出自51单片机论坛
 
个人签名千重雪  染蒹葭  谁  眉间砂  步步生莲花
 
 

回复

16

帖子

0

TA的资源

一粒金砂(初级)

148
 
这么好的文章,应该多多支持!我也有你说的那个朋友类似的经历,学了好久不得其门。希望你能够继续发文章!
此帖出自51单片机论坛
 
 
 

回复

1

帖子

0

TA的资源

一粒金砂(初级)

149
 
哇,程序这么长啊,感谢大神的无私奉献,小弟学习一下啦。
此帖出自51单片机论坛
 
 
 

回复

3

帖子

0

TA的资源

一粒金砂(初级)

150
 
不错,谢谢楼主
此帖出自51单片机论坛
 
 
 

回复

6

帖子

2

TA的资源

一粒金砂(初级)

151
 
楼主神勇,点赞点赞~~~~~~~~~
此帖出自51单片机论坛
 
 
 

回复

6

帖子

2

TA的资源

一粒金砂(初级)

152
 
楼主好人,好好学习下~~~~~~~~
此帖出自51单片机论坛
 
 
 

回复

12

帖子

0

TA的资源

一粒金砂(初级)

153
 
初学者来学习
此帖出自51单片机论坛
 
 
 

回复

4

帖子

1

TA的资源

一粒金砂(初级)

154
 
好东西,仔细阅读中
此帖出自51单片机论坛
 
 
 

回复

7

帖子

0

TA的资源

一粒金砂(初级)

155
 
换地方了?
此帖出自51单片机论坛
 
 
 

回复

30

帖子

0

TA的资源

一粒金砂(中级)

156
 
太好了!无法形容!多谢楼主
此帖出自51单片机论坛
 
 
 

回复

30

帖子

0

TA的资源

一粒金砂(中级)

157
 
太好了!谢谢楼主
此帖出自51单片机论坛
 
 
 

回复

3

帖子

1

TA的资源

一粒金砂(初级)

158
 
通俗易懂,很好的学习资料,谢谢!
此帖出自51单片机论坛
 
 
 

回复

3

帖子

1

TA的资源

一粒金砂(初级)

159
 
jianhong_wu 发表于 2014-6-10 01:18
第四节:累计定时中断次数使LED灯闪烁。

开场白:
上一节提到在累计主循环次数来实现计时,随着主函数里任务量的增加,为了保证延时时间的准确性,要不断修正设定上限阀值const_time_level 。我们该怎么解决这个问题呢?本节教大家利用累计定时中断次数的方法来解决这个问题。这一节要教会大家四个知识点:
第一点:利用累计定时中断次数的方法实现时间延时
第二点:展现鸿哥最完整的实战程序框架。在主函数循环里用switch语句实现状态机的切换,在定时中断里累计中断次数,这两个的结合就是我写代码最本质的框架思想。
第三点:提醒大家C语言中的int ,long变量是由几个字节构成的数据,凡是在main函数和中断函数里有可能同时改变的变量,这个变量应该在主函数中被更改之前,先关闭相应的中断,更改完了此变量,再打开中断,否则会留下不宜察觉的漏洞。当然在大部分的项目中可以不用这么操作,但是在一些要求非常高的项目中,有一些核心变量必须这么做。
第四点:定时中断的初始值该怎么设置。不用严格按公式来计算时间,一般取个经验值是最大初始值减去1000就可以了。
具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。

(2)实现功能:让一个LED闪烁。

(3)源代码讲解如下:

总结陈词:
本节程序麻雀虽小五脏俱全。在本节中已经展示了我最完整的实战程序框架。
本节程序只有一个LED灯闪烁的单任务,如果要多增加一个任务来并行处理,该怎么办?
欲知详情,请听下回分解-----蜂鸣器的驱动程序。

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

不知道是不是有点错误还是我没看懂:uiTimeCnt>=const_time_level为假,不能执行if里面的语句;中断函数好像还没有调用。
此帖出自51单片机论坛
 
 
 

回复

26

帖子

0

TA的资源

一粒金砂(中级)

160
 
本帖最后由 盛夏之蝉 于 2015-4-3 02:31 编辑
jianhong_wu 发表于 2014-7-6 11:12
第五十四节:指针的第二大好处,指针作为数组在函数中的输入接口。

开场白:
如果不会指针,当我们想把一个数组的数据传递进某个函数内部的时候,只能通过全局变量的方式,这种方法的缺点是阅读不直观,封装性不强,没有面对用户的输入接口。
针对以上问题,这一节要教大家一个知识点:通过指针,为函数增加一个数组输入接口。

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

(1)硬件平台:
基于朱兆祺51单片机学习板。

(2)实现功能:
把5个随机数据按从大到小排序,用冒泡法来排序。
通过电脑串口调试助手,往单片机发送EB 00 55 08 06 09 05 07  指令,其中EB 00 55是数据头,08 06 09 05 07 是参与排序的5个随机原始数据。单片机收到指令后就会返回13个数据,最前面5个数据是第1种方法的排序结果,中间3个数据EE EE EE是第1种和第2种的分割线,为了方便观察,没实际意义。最后5个数据是第2种方法的排序结果.

比如电脑发送:EB 00 55 08 06 09 05 07
单片机就返回:09 08 07 06 05 EE EE EE 09 08 07 06 05

串口程序的接收部分请参考第39节。串口程序的发送部分请参考第42节。

波特率是:9600 。

(3)源代码讲解如下:

总结陈词:
第2种方法通过指针,为函数增加了一个数组输入接口,已经比第1种纯粹用全局变量的方法直观多了,但是还有一个小小的遗憾,因为它的输出排序结果仍然要靠全局变量。为了让函数更加完美,我们能不能为函数再增加一个输出接口?当然可以。欲知详情,请听下回分解-----指针的第三大好处,指针作为数组在函数中的输出接口。

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

TH1=TL1=-(11059200L/12/32/9600);  //这段配置代码具体是什么意思,我也不太清楚,反正是跟串口波特率有关。
我解释一下这个,给定时器1的2个寄存器赋值,11059200L/12/32/9600这个公式是计算在11.0592Mhz晶振的情况下产生9600bps需要给定时器加载的值是多少,这个有专门公式暂时不讨论,可能大家疑惑的主要是为什么有个-(负号)这个问题,正常来说赋值应该是,TH1=TL1=256-128;(假设需要加载的值为128,只是为了举例说明)。256和128在单片机中是以原码(正数的补码和原码一样)的形式存在即0x100和0x80,当进行减法运算时,实际上是256+(-128的补码)并且结果舍弃进位,由于256(0x100)低8位为0,结果又舍弃进位,所以实际运算结果就是(-128的补码)。
因为负数在单片机中以补码存在,所以-128单片机自动会转换为补码的形式,而TH1和TL1又是无符号的,单片机强制把(-128)的补码复制到TH1和TL1中,完毕。可以实际给大家算一下:
256-128=128,即0x80.而-128 的补码是首先取得128(0x80)的反码也就是(0111111B)0x7f,再加一,得-128的补码为0x80,把0x80按照无符号读取那么就是128.
继续一个例子:256-100(0x64)=156(0x9c)。-100的反码是(10011011B)0x9b,再加一,得-100的补码为0x9c,把0x9c按照无符号读取就是156.

此帖出自51单片机论坛
 
个人签名最近研究STM32,会对库函数的源代码进行解读,会陆续更新
 
 

回复
您需要登录后才可以回帖 登录 | 注册

随便看看
查找数据手册?

EEWorld Datasheet 技术支持

相关文章 更多>>
关闭
站长推荐上一条 1/8 下一条

 
EEWorld订阅号

 
EEWorld服务号

 
汽车开发圈

About Us 关于我们 客户服务 联系方式 器件索引 网站地图 最新更新 手机版

站点相关: 国产芯 安防电子 汽车电子 手机便携 工业控制 家用电子 医疗电子 测试测量 网络通信 物联网

北京市海淀区中关村大街18号B座15层1530室 电话:(010)82350740 邮编:100190

电子工程世界版权所有 京B2-20211791 京ICP备10001474号-1 电信业务审批[2006]字第258号函 京公网安备 11010802033920号 Copyright © 2005-2025 EEWORLD.com.cn, Inc. All rights reserved
快速回复 返回顶部 返回列表