设为首页收藏本站
开启辅助访问 切换到窄版

独闷闷网

 找回密码
 立即注册
搜索
独闷闷网»首页 › 单片机与PCB › 51单片机 › 从业将近十年！手把手教你单片机程序框架（连载）
1234567下一页
返回列表 发新帖
楼主: jianhong_wu
打印 上一主题 下一主题
收起左侧

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

[复制链接]
81#
 楼主| 发表于 2014-9-9 09:35:25 | 显示全部楼层
第六十六节：单片机外部中断的基础。

开场白：
外部中断是单片机非常重要的内部资源，应用很广，它是单片机的高速开关感应器输入接口，它可以检测脉冲输入，可以接收红外遥控器的输入信号，可以检测高速运转的车轮或者电机圆周运动的反馈信号，可以检测输液器里瞬间即逝的水滴信号，可以接收模拟串口的数据信息，等等。
    这一节要教大家两个知识点：
   第一个：外部中断的初始化代码和中断函数的基本程序模板。
   第二个：当系统存在两种中断以上时，如何设置外部中断0为最高优先级，实现中断嵌套功能。

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

（1）硬件平台：
    基于坚鸿51单片机学习板。用S1按键作为模拟外部中断0的下降沿脉冲输入。原来S1按键是直接连接到P0^0口的，因此必须通过跳线把P0^0口连接到单片机外部中断0专用IO口P3^2上，只需把P0^0和P3^2的两根黄颜色跳冒去掉，通过一根线把P0^0和P3^2相互连接起来即可。这时每按下一次S1按键，就会给P3^2口产生一个下降沿的脉冲，然后程序会自动跳到中断函数中执行一次。

（2）实现功能：
    用数码管低4位显示记录当前的下降沿脉冲数。用S1按键经过跳线后模拟外部中断0的下降沿输入，每按一次数码管就会显示往上累加的脉冲数。由于按键按下去的时候有抖动，也就按一次可能产生几个脉冲，所以按一次往往看到数据一次加了三四个，这种实验现象都是正常的。

（3）源代码讲解如下：
  1. #include "REG52.H"

  3. #define const_voice_short  40   //蜂鸣器短叫的持续时间
  4. #define const_key_time1  20    //按键去抖动延时的时间

  6. void initial_myself();   
  7. void initial_peripheral();
  8. void delay_short(unsigned int uiDelayShort);
  9. void delay_long(unsigned int uiDelaylong);
  10. //驱动数码管的74HC595
  11. void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);  
  12. void display_drive(); //显示数码管字模的驱动函数
  13. void display_service(); //显示的窗口菜单服务程序
  14. //驱动LED的74HC595
  15. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
  16. void T0_time();  //定时中断函数
  17. void INT0_int();//外部0中断函数



  21. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
  22. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口


  25. sbit dig_hc595_sh_dr=P2^0;     //数码管的74HC595程序
  26. sbit dig_hc595_st_dr=P2^1;  
  27. sbit dig_hc595_ds_dr=P2^2;  


  30. unsigned char ucDigShow8;  //第8位数码管要显示的内容
  31. unsigned char ucDigShow7;  //第7位数码管要显示的内容
  32. unsigned char ucDigShow6;  //第6位数码管要显示的内容
  33. unsigned char ucDigShow5;  //第5位数码管要显示的内容
  34. unsigned char ucDigShow4;  //第4位数码管要显示的内容
  35. unsigned char ucDigShow3;  //第3位数码管要显示的内容
  36. unsigned char ucDigShow2;  //第2位数码管要显示的内容
  37. unsigned char ucDigShow1;  //第1位数码管要显示的内容

  39. unsigned char ucDigDot8;  //数码管8的小数点是否显示的标志
  40. unsigned char ucDigDot7;  //数码管7的小数点是否显示的标志
  41. unsigned char ucDigDot6;  //数码管6的小数点是否显示的标志
  42. unsigned char ucDigDot5;  //数码管5的小数点是否显示的标志
  43. unsigned char ucDigDot4;  //数码管4的小数点是否显示的标志
  44. unsigned char ucDigDot3;  //数码管3的小数点是否显示的标志
  45. unsigned char ucDigDot2;  //数码管2的小数点是否显示的标志
  46. unsigned char ucDigDot1;  //数码管1的小数点是否显示的标志
  47. unsigned char ucDigShowTemp=0; //临时中间变量
  48. unsigned char ucDisplayDriveStep=1;  //动态扫描数码管的步骤变量

  50. unsigned char ucWd1Update=1; //窗口1更新显示标志

  52. unsigned char ucWd=1;  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。本程序只有一个显示窗口
  53. unsigned int  uiPluseCnt=0;  //本程序中累加中断脉冲数的变量

  55. unsigned char ucTemp1=0;  //中间过渡变量
  56. unsigned char ucTemp2=0;  //中间过渡变量
  57. unsigned char ucTemp3=0;  //中间过渡变量
  58. unsigned char ucTemp4=0;  //中间过渡变量

  60. //根据原理图得出的共阴数码管字模表
  61. code unsigned char dig_table[]=
  62. {
  63. 0x3f,  //0       序号0
  64. 0x06,  //1       序号1
  65. 0x5b,  //2       序号2
  66. 0x4f,  //3       序号3
  67. 0x66,  //4       序号4
  68. 0x6d,  //5       序号5
  69. 0x7d,  //6       序号6
  70. 0x07,  //7       序号7
  71. 0x7f,  //8       序号8
  72. 0x6f,  //9       序号9
  73. 0x00,  //无      序号10
  74. 0x40,  //-       序号11
  75. 0x73,  //P       序号12
  76. };
  77. void main()
  78.   {
  79.    initial_myself();  
  80.    delay_long(100);   
  81.    initial_peripheral();
  82.    while(1)  
  83.    {
  84.        display_service(); //显示的窗口菜单服务程序
  85.    }
  86. }


  89. void display_service() //显示的窗口菜单服务程序
  90. {

  92.    switch(ucWd)  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  93.    {
  94.        case 1:   //显示第一个窗口的数据  本系统中只有一个显示窗口
  95.             if(ucWd1Update==1)  //窗口1要全部更新显示
  96.             {
  97.                ucWd1Update=0;  //及时清零标志，避免一直进来扫描
  98.                ucDigShow8=10;  //第8位数码管显示无
  99.                ucDigShow7=10;  //第7位数码管显示无
  100.                ucDigShow6=10;  //第6位数码管显示无
  101.                ucDigShow5=10;  //第5位数码管显示无

  103.               //先分解数据
  104.                ucTemp4=uiPluseCnt/1000;     
  105.                ucTemp3=uiPluseCnt%1000/100;
  106.                ucTemp2=uiPluseCnt%100/10;
  107.                ucTemp1=uiPluseCnt%10;
  108.   
  109.              //再过渡需要显示的数据到缓冲变量里，让过渡的时间越短越好

  111.               //以下增加的if判断就是略作修改，把整个4位数据中高位为0的去掉不显示。
  112.                if(uiPluseCnt<1000)   
  113.                {
  114.                    ucDigShow4=10;  //如果小于1000，千位显示无
  115.                }
  116.                else
  117.                {
  118.                   ucDigShow4=ucTemp4;  //第4位数码管要显示的内容
  119.                }
  120.                if(uiPluseCnt<100)
  121.                {
  122.                   ucDigShow3=10;  //如果小于100，百位显示无
  123.                }
  124.                else
  125.                {
  126.                   ucDigShow3=ucTemp3;  //第3位数码管要显示的内容
  127.                }
  128.                if(uiPluseCnt<10)
  129.                {
  130.                   ucDigShow2=10;  //如果小于10，十位显示无
  131.                }
  132.                else
  133.                {
  134.                   ucDigShow2=ucTemp2;  //第2位数码管要显示的内容
  135.                }
  136.                ucDigShow1=ucTemp1;  //第1位数码管要显示的内容
  137.             }
  138.             break;
  139.    
  140.     }
  141.    

  143. }


  146. void display_drive()  
  147. {
  148.    //以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
  149.    switch(ucDisplayDriveStep)
  150.    {
  151.       case 1:  //显示第1位
  152.            ucDigShowTemp=dig_table[ucDigShow1];
  153.                    if(ucDigDot1==1)
  154.                    {
  155.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  156.                    }
  157.            dig_hc595_drive(ucDigShowTemp,0xfe);
  158.                break;
  159.       case 2:  //显示第2位
  160.            ucDigShowTemp=dig_table[ucDigShow2];
  161.                    if(ucDigDot2==1)
  162.                    {
  163.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  164.                    }
  165.            dig_hc595_drive(ucDigShowTemp,0xfd);
  166.                break;
  167.       case 3:  //显示第3位
  168.            ucDigShowTemp=dig_table[ucDigShow3];
  169.                    if(ucDigDot3==1)
  170.                    {
  171.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  172.                    }
  173.            dig_hc595_drive(ucDigShowTemp,0xfb);
  174.                break;
  175.       case 4:  //显示第4位
  176.            ucDigShowTemp=dig_table[ucDigShow4];
  177.                    if(ucDigDot4==1)
  178.                    {
  179.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  180.                    }
  181.            dig_hc595_drive(ucDigShowTemp,0xf7);
  182.                break;
  183.       case 5:  //显示第5位
  184.            ucDigShowTemp=dig_table[ucDigShow5];
  185.                    if(ucDigDot5==1)
  186.                    {
  187.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  188.                    }
  189.            dig_hc595_drive(ucDigShowTemp,0xef);
  190.                break;
  191.       case 6:  //显示第6位
  192.            ucDigShowTemp=dig_table[ucDigShow6];
  193.                    if(ucDigDot6==1)
  194.                    {
  195.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  196.                    }
  197.            dig_hc595_drive(ucDigShowTemp,0xdf);
  198.                break;
  199.       case 7:  //显示第7位
  200.            ucDigShowTemp=dig_table[ucDigShow7];
  201.                    if(ucDigDot7==1)
  202.                    {
  203.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  204.            }
  205.            dig_hc595_drive(ucDigShowTemp,0xbf);
  206.                break;
  207.       case 8:  //显示第8位
  208.            ucDigShowTemp=dig_table[ucDigShow8];
  209.                    if(ucDigDot8==1)
  210.                    {
  211.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  212.                    }
  213.            dig_hc595_drive(ucDigShowTemp,0x7f);
  214.                break;
  215.    }
  216.    ucDisplayDriveStep++;
  217.    if(ucDisplayDriveStep>8)  //扫描完8个数码管后，重新从第一个开始扫描
  218.    {
  219.      ucDisplayDriveStep=1;
  220.    }

  222. }

  224. //数码管的74HC595驱动函数
  225. void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
  226. {
  227.    unsigned char i;
  228.    unsigned char ucTempData;
  229.    dig_hc595_sh_dr=0;
  230.    dig_hc595_st_dr=0;
  231.    ucTempData=ucDigStatusTemp16_09;  //先送高8位
  232.    for(i=0;i<8;i++)
  233.    {
  234.          if(ucTempData>=0x80)dig_hc595_ds_dr=1;
  235.          else dig_hc595_ds_dr=0;
  236.          dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  237.          delay_short(1);
  238.          dig_hc595_sh_dr=1;
  239.          delay_short(1);
  240.          ucTempData=ucTempData<<1;
  241.    }
  242.    ucTempData=ucDigStatusTemp08_01;  //再先送低8位
  243.    for(i=0;i<8;i++)
  244.    {
  245.          if(ucTempData>=0x80)dig_hc595_ds_dr=1;
  246.          else dig_hc595_ds_dr=0;
  247.          dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  248.          delay_short(1);
  249.          dig_hc595_sh_dr=1;
  250.          delay_short(1);
  251.          ucTempData=ucTempData<<1;
  252.    }
  253.    dig_hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
  254.    delay_short(1);
  255.    dig_hc595_st_dr=1;
  256.    delay_short(1);
  257.    dig_hc595_sh_dr=0;    //拉低，抗干扰就增强
  258.    dig_hc595_st_dr=0;
  259.    dig_hc595_ds_dr=0;
  260. }

  262. void T0_time() interrupt 1   //定时器中断函数
  263. {
  264.   TF0=0;  //清除中断标志
  265.   TR0=0; //关中断

  267.   display_drive();  //数码管字模的驱动函数

  269.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  270.   TL0=0x0b;
  271.   TR0=1;  //开中断
  272. }


  275. /* 注释一：
  276. * 用坚鸿51学习板中的S1按键作为模拟外部中断0的下降沿脉冲输入。
  277. * 原来S1按键是直接连接到P0^0口的，因此必须通过跳线把P0^0口连接到
  278. * 单片机外部中断0专用IO口P3^2上，只需把P0^0和P3^2的两个黄颜色跳冒去掉，通过一根
  279. * 线把P0^0和P3^2相互连接起来即可。这时每按下一次S1按键，就会给P3^2口
  280. * 产生一个下降沿的脉冲，然后程序会自动跳到以下中断函数中执行一次。
  281. * 由于按键按下去的时候有抖动，也就按一次可能产生几个脉冲，所以按一次往往看到数据一次加了三四个，
  282. * 这种实验现象都是正常的。
  283. */

  285. void  INT0_int(void) interrupt 0  //INT0外部中断函数
  286. {
  287.    EX0=0;   //禁止外部0中断 这个只是我个人的编程习惯，也可以不关闭

  289.    uiPluseCnt++;  //累计外部中断下降沿的脉冲数
  290.    ucWd1Update=1;  //窗口1更新显示

  292.    EX0=1;  //打开外部0中断
  293. }

  295. void delay_short(unsigned int uiDelayShort)
  296. {
  297.    unsigned int i;  
  298.    for(i=0;i<uiDelayShort;i++)
  299.    {
  300.      ;   //一个分号相当于执行一条空语句
  301.    }
  302. }

  304. void delay_long(unsigned int uiDelayLong)
  305. {
  306.    unsigned int i;
  307.    unsigned int j;
  308.    for(i=0;i<uiDelayLong;i++)
  309.    {
  310.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  311.           {
  312.              ; //一个分号相当于执行一条空语句
  313.           }
  314.    }
  315. }

  317. void initial_myself()  //初始化单片机
  318. {
  319. /* 注释二：
  320. * 矩阵键盘也可以做独立按键，前提是把某一根公共输出线输出低电平，
  321. * 模拟独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
  322. * 坚鸿51学习板的S1就是本程序中用到的一个独立按键。S1经过跳线后
  323. * 连接到单片机的外部中断专用接口P3^2上，用来模拟外部下降沿脉冲输入。
  324. */
  325.   key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
  326.   beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

  328.   TMOD=0x01;  //设置定时器0为工作方式1
  329.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  330.   TL0=0x0b;
  331. }

  333. void initial_peripheral() //初始化外围
  334. {

  336.    ucDigDot8=0;   //小数点全部不显示
  337.    ucDigDot7=0;  
  338.    ucDigDot6=0;
  339.    ucDigDot5=0;  
  340.    ucDigDot4=0;
  341.    ucDigDot3=0;  
  342.    ucDigDot2=0;
  343.    ucDigDot1=0;

  345.    EX0=1; //允许外部中断0
  346.    IT0=1;  //下降沿触发外部中断0   如果是0代表低电平中断

  348. /* 注释三：
  349. * 注意，由于本系统中用了2个中断，一个是定时中断，一个是外部中断，
  350. * 因此必须设置IP寄存器，让外部中断0为最高优先级，让外部中断0可以打断
  351. * 定时中断。
  352. */

  354.    IP=0x01; //设置外部中断0为最高优先级，可以打断低优先级中断服务。实现中断嵌套功能

  356.    EA=1;     //开总中断
  357.    ET0=1;    //允许定时中断
  358.    TR0=1;    //启动定时中断


  361. }
复制代码

总结陈词：
    这节讲了外部中断的基本程序模板，下一节我会讲一个外部中断的实际应用项目例子。欲知详情，请听下回分解----利用外部中断实现模拟串口数据的收发。

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

乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

82#
 楼主| 发表于 2014-9-13 15:26:50 | 显示全部楼层
第六十七节：利用外部中断实现模拟串口数据的收发。

开场白：
     鸿哥曾经亲自用外部中断做过红外遥控器的数据接收，步进电机圆周运动的光电反馈信号检测，输液器里瞬间即逝的水滴信号，以及本节的模拟串口数据的接收，其实这些项目的原理都大同小异，会一样即可触类旁通其它的。
    这一节要教大家四个知识点：
   第一个：如何利用外部中断实现模拟串口数据的收发。
   第二个：在退出外部中断函数时，必须通过软件把外部中断标志位IE0清零，否则在接收到的数据包最后面会多收到一个无效的字节0xFF。
   第三个：实际做项目的时候，尽量利用单片机内部自带的集成串口，不到万不得已尽量不要用自制的模拟串口，如果非要用本节讲的模拟串口，那么一次接收的数据包不要太长，尽可能越短越好，因为自己做的模拟串口在稳定性上肯定比不上单片机自带的串口。这种模拟串口在批量生产时容易因为晶振的误差，以及外界各地温度的温差而影响产品的一致性，是有隐患的。
第四个：用模拟串口时，尽量不要选用动态数码管的显示方案，因为单片机在收发串口数据时，只能专心干一件事，此时不能中途被动态数码管扫描程序占用。而动态数码管得不到均匀扫描，就会产生略微闪烁的现象瑕疵。

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

（1）硬件平台：
    基于坚鸿51单片机学习板。当把程序下载到单片机之后，要做以下跳线处理：
   单片机原来的P3.1引脚是TI串口输出引脚，P3.0是RI串口输入引脚，分别把P3.1和P3.0的黄颜色跳冒去掉，同时也把外部中断0的引脚P3.2和一根IO口P1.0引脚的换颜色跳冒去掉，把P3.2跳冒的右针连接到P3.0跳冒的左针，作为模拟串口的接收数据线。把P1.0跳冒的右针连接到P3.1跳冒的左针，作为模拟串口的发送数据线。

（2）实现功能：
    波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机任意发送一串不超过10个的数据包，单片机如实地返回接收到的整包数据给上位机。

例如：
(a)上位机发送数据：01 02 03 04 05 06 07 08 09 0A
单片机返回：    01 02 03 04 05 06 07 08 09 0A

(b)上位机发送数据： 05 07 EE A8 F9
单片机返回：     05 07 EE A8 F9


（3）源代码讲解如下：
  1. #include "REG52.H"

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

  5. #define const_rc_size  20  //接收串口中断数据的缓冲区数组大小

  7. #define const_receive_time  5  //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小


  10. /* 注释一：
  11. * 以下时序脉冲延时参数我是在keil uVision2 平台下,Memory Model在small模式，Code Rom Size在Large模式下编译的，
  12. * 如果在不同keil版本，不同的模式下，编译出来的程序有可能此参数会不一样。
  13. * 以下的时序脉冲延时参数是需要一步一步慢慢调的。我一开始的时候先编写一个简单的发送数据测试程序，
  14. * 先确调试出合适的发送时序延时数据。然后再编写串口接收数据的程序，从而调试出接收时序的延时参数。
  15. * 比如：我第一步发送数据的测试程序是这样的：
  16. void main()
  17.   {
  18.    initial_myself();  
  19.    delay_long(100);   
  20.    initial_peripheral();
  21.    while(1)  
  22.    {
  23.   //      usart_service();  //串口服务程序
  24.        eusart_send(0x08);    //测试程序，让它不断发送数据给上位机观察，确保发送延时时序的参数准确性
  25.            delay_long(300);

  27.        eusart_send(0xE5);    //测试程序，让它不断发送数据给上位机观察，确保发送延时时序的参数准确性
  28.            delay_long(300);
  29.    }

  31. }
  32. */


  35. #define const_t_1  10  //发送时序延时1  第一步先调出此数据
  36. #define const_t_2  9  //发送时序延时2   第一步先调出此数据


  39. #define const_r_1  7  //接收时序延时1   第二步再调出此数据
  40. #define const_r_2  9 //接收时序延时2  第二步再调出此数据

  42. void initial_myself(void);   
  43. void initial_peripheral(void);
  44. void delay_long(unsigned int uiDelaylong);
  45. void delay_short(unsigned int uiDelayShort);
  46. void delay_minimum(unsigned char ucDelayMinimum);  //细分度最小的延时,用char类型一个字节

  48. void T0_time(void);  //定时中断函数
  49. void INT0_int(void);  //外部0中断函数，在本系统中是模拟串口的接收中断函数。
  50. void usart_service(void);  //串口服务程序,在main函数里


  53. void eusart_send(unsigned char ucSendData);
  54. unsigned char read_eusart_byte();//从串口读一个字节


  57. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
  58. sbit ti_dr=P1^0;  //模拟串口发送数据的IO口
  59. sbit ri_sr=P3^2;  //模拟串口接收数据的IO口 也是外部中断0的复用IO口
  60. unsigned int  uiSendCnt=0;     //用来识别串口是否接收完一串数据的计时器
  61. unsigned char ucSendLock=1;    //串口服务程序的自锁变量，每次接收完一串数据只处理一次
  62. unsigned int  uiRcregTotal=0;  //代表当前缓冲区已经接收了多少个数据
  63. unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组

  65. unsigned char ucTest=0;

  67. void main()
  68.   {
  69.    initial_myself();  
  70.    delay_long(100);   
  71.    initial_peripheral();
  72.    while(1)  
  73.    {
  74.         usart_service();  //串口服务程序

  76.    }

  78. }



  82. void usart_service(void)  //串口服务程序,在main函数里
  83. {

  85.      unsigned char i=0;   

  87.      if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
  88.      {

  90.             ucSendLock=0;    //处理一次就锁起来，不用每次都进来,除非有新接收的数据

  92.             //下面的代码进入数据协议解析和数据处理的阶段


  95.                         for(i=0;i<uiRcregTotal;i++)  //返回全部接收到的数据包
  96.                         {
  97.                            eusart_send(ucRcregBuf[i]);
  98.                         }
  99.          
  100.                                          
  101.             uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据
  102.   
  103.      }
  104.                         
  105. }


  108. //往串口发送一个字节
  109. void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
  110. {
  111.      unsigned char i=8;
  112.      EA=0;     //关总中断
  113.      ti_dr=0; //发送启始位
  114.          delay_minimum(const_t_1); //发送时序延时1   delay_minimum是本程序细分度最小的延时
  115.      while(i--)
  116.      {
  117.          ti_dr=ucSendData&0x01;      //先传低位
  118.              delay_minimum(const_t_2); //发送时序延时2   delay_minimum是本程序细分度最小的延时
  119.          ucSendData=ucSendData>>1;
  120.      }

  122.      ti_dr=1;  //发送结束位
  123.      delay_short(400);  //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
  124.      EA=1;     //开总中断
  125. }


  128. //从串口读取一个字节
  129. unsigned char read_eusart_byte()
  130. {
  131.     unsigned char  ucReadData=0;
  132.     unsigned char  i=8;


  135.          delay_minimum(const_r_1);  //接收时序延时1 。作用是等过起始位  delay_minimum是本程序细分度最小的延时
  136.      while(i--)
  137.      {
  138.          ucReadData >>=1;
  139.          if(ri_sr==1)
  140.                  {  
  141.                      ucReadData|=0x80;      //先收低位
  142.                  }

  144.          if(ri_sr==0) //此处空指令，是为了让驱动时序的时间保持一致性
  145.                  {  
  146.                      ;
  147.                  }

  149.              delay_minimum(const_r_2);    //接收时序延时2    delay_minimum是本程序细分度最小的延时   
  150.      }

  152.      return ucReadData;
  153. }




  158. void T0_time(void) interrupt 1    //定时中断
  159. {
  160.   TF0=0;  //清除中断标志
  161.   TR0=0; //关中断


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



  172.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  173.   TL0=0x0b;
  174.   TR0=1;  //开中断
  175. }


  178.                              
  179. void  INT0_int(void) interrupt 0  //INT0外部中断函数
  180. {
  181.    EX0=0;   //禁止外部0中断 这个只是我个人的编程习惯，也可以不关闭

  183.    ++uiRcregTotal;
  184.    if(uiRcregTotal>const_rc_size)  //超过缓冲区
  185.    {
  186.            uiRcregTotal=const_rc_size;
  187.    }
  188.    ucRcregBuf[uiRcregTotal-1]=read_eusart_byte();   //将串口接收到的数据缓存到接收缓冲区里
  189.    uiSendCnt=0;  //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。

  191. /* 注释二：
  192. * 注意，此处必须把IE0中断标志清零，否则在接收到的数据包最后面会多收到一个无效的字节0xFF。
  193. */

  195.    IE0=0;  //外部中断0标志位清零，必须的！

  197.    EX0=1;  //打开外部0中断
  198. }


  201. void delay_long(unsigned int uiDelayLong)
  202. {
  203.    unsigned int i;
  204.    unsigned int j;
  205.    for(i=0;i<uiDelayLong;i++)
  206.    {
  207.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  208.           {
  209.              ; //一个分号相当于执行一条空语句
  210.           }
  211.    }
  212. }

  214. void delay_short(unsigned int uiDelayShort)
  215. {
  216.    unsigned int i;  
  217.    for(i=0;i<uiDelayShort;i++)
  218.    {
  219.      ;   //一个分号相当于执行一条空语句
  220.    }
  221. }


  224. /* 注释三：
  225. * 由于IO口模拟的串口时序要求很高，所以用的延时函数尽可能细分度越高越好，以下用一个字节的延时计时器
  226. */
  227. void delay_minimum(unsigned char ucDelayMinimum)  //细分度最小的延时,用char类型一个字节
  228. {
  229.    unsigned char i;  
  230.    for(i=0;i<ucDelayMinimum;i++)
  231.    {
  232.      ;   //一个分号相当于执行一条空语句
  233.    }

  235. }

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

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

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


  248. }

  250. void initial_peripheral(void) //第二区 初始化外围
  251. {

  253.    EX0=1; //允许外部中断0
  254.    IT0=1;  //下降沿触发外部中断0   如果是0代表低电平中断
  255.    IP=0x01; //设置外部中断0为最高优先级，可以打断低优先级中断服务。实现中断嵌套功能

  257.    EA=1;     //开总中断
  258.    ET0=1;    //允许定时中断
  259.    TR0=1;    //启动定时中断

  261. }
复制代码

总结陈词：
这节讲完了外部中断的应用例子，下一节我会开始讲单片机C语言的多文件编程技巧。很多人也把多文件编程称作模块化编程，其实我觉得叫多文件编程会更加符合实际一些。多文件编程有两个最大的好处，一个是给我们的程序增加了目录，方便我们查找。另外一个好处是方便移植别人已经做好的功能程序模块，利用这个特点，特别适合团队一起做大型项目。很多初学者刚开始学多文件编程时，会经常遇到重复定义等问题，想知道怎么解决这些问题吗？欲知详情，请听下回分解----单片机C语言的多文件编程技巧。

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

乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

83#
 楼主| 发表于 2014-9-14 21:08:05 | 显示全部楼层
waphaoyun 发表于 2014-9-14 20:35
鸿哥辛苦了，  我表示一直在看，

感谢你的鼓励。
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

84#
 楼主| 发表于 2014-9-17 13:39:45 | 显示全部楼层
第六十八节：单片机C语言的多文件编程技巧。
开场白：
很多人也把多文件编程称作模块化编程，其实我觉得叫多文件编程会更加符合实际一些。多文件编程有两个最大的好处，一个是给我们的程序增加了目录，方便我们查找。另外一个好处是方便移植别人已经做好的功能程序模块，利用这个特点，特别适合团队一起做大型项目。很多初学者刚开始学多文件编程时，会经常遇到重复定义等问题，想知道怎么解决这些问题吗？只要按照以下鸿哥教的规则来做，这些问题就不存在了。
第一个：每个文件保持成双成对出现。每个.c源文件必须有一个.h头文件跟它对应，每个.h头文件必须有一个.c源文件跟它对应。比如：main.c与main.h，delay.c与 delay.h。

第二个：.c源文件只负责函数的定义和变量的定义，但是不负责函数的声明和变量的声明。比如：
unsigned char ucLedStep=0; //这个是全局变量的定义
void led_flicker()   //这个是函数的定义
{
   //…里面是具体代码内容
  }

第三个：.h头文件只负责函数的声明和变量的声明，以及常量和IO口的宏定义，但是不负责函数的定义和变量的定义。比如：
#define const_time_level 200  //这个是常量的宏定义
sbit led_dr=P3^5;    //这个是IO口的宏定义
void led_flicker();     //这个是函数的声明
extern unsigned char ucLedStep;   //这个是全局变量的声明，不能赋初始值
第四个：每个.h头文件都必须固定以#ifndef，#define，#endif语句为模板，此模板是用来避免编译时由于重复包含头文件里面的内容而导致出错。其中标志变量_XXX_鸿哥建议用它本身的文件名称加前后下划线_。
比如：
#ifndef _LED_   //标志变量_LED_是用它本身的文件名称命名
#define _LED_   //标志变量_LED_是用它本身的文件名称命名
#define const_time_level 200  //这个是常量的宏定义
sbit led_dr=P3^5;    //这个是IO口的宏定义
void led_flicker();     //这个是函数的声明
extern unsigned char ucLedStep;   //这个是全局变量的声明，不能赋初始值
#endif  
第五个：每个.h头文件里都必须声明它对应的.c源文件里的所有定义函数和全局变量，注意：.c源文件里所有的全局变量都要在它所对应的.h头文件里声明一次，不仅仅是函数，这个地方很容易被人忽略。
比如：在led.h头文件中:
void led_flicker();     //这个是函数的声明,因为在这个函数在led.c文件里定义了。
   extern unsigned char ucLedStep;   //这个是全局变量的声明，不许赋初值
第六个：每个.c源文件里都必须包含两个文件，一个是单片机的系统头文件REG52.H，另外一个是它自己本身的头文件比如initial.h.剩下其它的头文件看实际情况来决定是否调用，我们用到了哪些文件的函数，全局变量或者宏定义，就需要调用对应的头文件。
比如：在initial.c源文件中:
#include"REG52.H"  //必须包含的单片机系统头文件
#include"initial.h"  //必须包含它本身的头文件
/* 注释：
   由于本源文件中用到了led_dr的语句，而led_dr是在led.h文件里宏定义的，所以必须把led.h也包含进来
*/  
#include"led.h"  //由于本源文件中用到了led_dr的语句，所以必须把led.h也包含进来
void initial_myself()  //这个是函数定义
{
  led_dr=0;  //led_dr是在led文件里定义和声明的
}
第七个：声明一个全局变量必须加extern关键字，同时千万不能在声明全局变量的时候赋初始值，比如：
extern unsigned char ucLedStep=0; //这样是绝对错误的。
extern unsigned char ucLedStep; //这个是全局变量的声明，这个才是正确的
第八个：对于函数与全局变量的声明，编译器都不分配内存空间。对于函数与全局变量的定义，编译器都分配内存空间。函数与全局变量的定义只能在一个.c源文件中出现一次，而函数与全局变量的声明可以在多个.h文件中出现。

具体内容，请看源代码讲解，本程序例程是直接把前面第四节一个源文件更改成多文件编程方式。

（1）硬件平台：
    基于朱兆祺51单片机学习板。把前面第四节一个源文件更改成多文件编程方式。

（2）实现功能：跟前面第四节的功能一模一样，让一个LED闪烁。
   
（3）keil多文件编程的截图预览：
（4）整个源代码讲解工程文件下载：
more_file_4.rar (23.69 KB, 下载次数: 2763)
（5）源代码讲解如下（注意，以下代码不能直接放到一个源文件里编译）：
/*以下是 main.h 的内容*/

/* 注释一：
  每个头文件都是固定以#ifndef，#define，#endif
  为模板，其中标志变量_XXX_我建议用它本身的文件名称加前后下划线_。
  此标志变量名称是用来预防多次包含出错的，详细讲解请看注释二。
  每个头文件只做函数的声明和变量的声明，以及常量和IO口的宏定义，不做
  函数的定义与变量的定义。
*/  
#ifndef _MAIN_   //标志变量_MAIN_是用它本身的文件名称命名
#define _MAIN_   //标志变量_MAIN_是用它本身的文件名称命名

void main();  //这个是函数的声明

#endif  

/* 注释二：
以上语句
#ifndef  
#define
插入其它内容...
#endif

类似于把_MAIN_看成是一个标志变量
if(_MAIN_==0)  // 相当于#ifndef _MAIN_
{
    _MAIN_=1;  // 相当于#define _MAIN_
     插入其它内容...

}               //相当于#endif

目的是通过一个标志位变量的赋值，让编译器在编译的时候，只包含一次此头文件，避免多次包含出错
*/  

/*------分割线--------------------------------------------------*/

/*以下是 main.c 的内容*/

/* 注释一：
  每个源文件都必须包含两个文件，一个是单片机的系统头文件REG52.H，
  另外一个是它自己本身的头文件main.h.剩下其它的头文件看实际情况来
  决定是否调用，我们用到了哪些文件的函数，全局变量或者宏定义，就需要调用对应的头文件。
  每个源文件只做函数的定义和变量的定义，不做函数的声明和变量的声明。
*/  

#include "REG52.H"  //必须包含的单片机系统头文件
#include "main.h"  //必须包含它本身的头文件

/* 注释二：
   (1)由于本源文件中调用initial_myself()和initial_peripheral()函数，而这两个函数
      都是在initial文件里定义和声明的，所以必须把initial.h也包含进来。
   (2)由于本源文件中调用delay_long(100)函数，而这个函数
      是在delay文件里定义和声明的，所以必须把delay.h也包含进来。
   (2)由于本源文件中调用led_flicker()函数，而这个函数
      是在led文件里定义和声明的，所以必须把led.h也包含进来。
*/  


#include "initial.h"  //由于本源文件中用到了initial_myself()和initial_peripheral()函数，所以必须把initial.h也包含进来
#include "delay.h"  //由于本源文件中用到了delay_long(100)函数，所以必须把delay.h也包含进来
#include "led.h"  //由于本源文件中用到了led_flicker()函数，所以必须把led.h也包含进来

void main()  //这个是函数的定义
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral();
   while(1)   
   {
      led_flicker();   
   }

}

/*------分割线--------------------------------------------------*/

/*以下是 delay.h 的内容*/


#ifndef _DELAY_   //标志变量_DELAY_是用它本身的文件名称命名
#define _DELAY_   //标志变量_DELAY_是用它本身的文件名称命名

void delay_long(unsigned int uiDelaylong); //这个是函数的声明，每一个源文件里的函数都要在它的头文件里声明


#endif  

/*------分割线--------------------------------------------------*/

/*以下是 delay.c 的内容*/


#include "REG52.H"  //必须包含的单片机系统头文件
#include "delay.h"  //必须包含它本身的头文件


void delay_long(unsigned int uiDelayLong)  //这个是函数的定义
{
   unsigned int i;   //这个是局部变量的定义
   unsigned int j;   //这个是局部变量的定义
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)
          {
             ;
          }
   }
}
/*------分割线--------------------------------------------------*/
/*以下是 initial.h 的内容*/

#ifndef _INITIAL_   //标志变量_INITIAL_是用它本身的文件名称命名
#define _INITIAL_   //标志变量_INITIAL_是用它本身的文件名称命名

void initial_myself();    //这个是函数声明，每一个源文件里的函数都要在它的头文件里声明
void initial_peripheral(); //这个是函数声明，每一个源文件里的函数都要在它的头文件里声明

#endif  

/*------分割线--------------------------------------------------*/
/*以下是 initial.c 的内容*/


#include "REG52.H"  //必须包含的单片机系统头文件
#include "initial.h"  //必须包含它本身的头文件

/* 注释一：
   由于本源文件中用到了led_dr的语句，而led_dr是在led文件里宏定义的，所以必须把led.h也包含进来
*/  
#include "led.h"  //由于本源文件中用到了led_dr的语句，所以必须把led.h也包含进来

void initial_myself()  //这个是函数定义
{


  TMOD=0x01;  //以下能直接用TMOD,TH0,TL0,EA,ET0,TR0这些寄存器关键字，是因为包含了REG52.H头文件

  TH0=0xf8;  
  TL0=0x2f;   

  led_dr=0;  //led_dr是在led文件里定义和声明的
}


void initial_peripheral() //这个是函数定义
{
  EA=1;     
  ET0=1;   
  TR0=1;   

}

/*------分割线--------------------------------------------------*/
/*以下是 interrupt.h 的内容*/


#ifndef _INTERRUPT_   //标志变量_INTERRUPT_是用它本身的文件名称命名
#define _INTERRUPT_   //标志变量_INTERRUPT_是用它本身的文件名称命名

void T0_time();  //这个是函数声明，每一个源文件里的函数都要在它的头文件里声明

/* 注释一：
声明一个外部全局变量必须加extern关键字，同时千万不能在声明全局变量的时候赋初始值，比如：
extern unsigned int uiTimeCnt=0; 这样是绝对错误的。
*/  
extern unsigned int uiTimeCnt; //这个是全局变量的声明，不能赋初始值


#endif  

/*------分割线--------------------------------------------------*/
/*以下是 interrupt.c 的内容*/


#include "REG52.H"  //必须包含的单片机系统头文件
#include "interrupt.h"  //必须包含它本身的头文件

unsigned int uiTimeCnt=0; //这个是全局变量的定义，可以赋初值


void T0_time() interrupt 1  //这个是函数定义
{
  TF0=0;   //以下能直接用TF0,TR0,TH0,TL0这些寄存器关键字，是因为包含了REG52.H头文件
  TR0=0;

  if(uiTimeCnt<0xffff)
  {
      uiTimeCnt++;
  }

  TH0=0xf8;  
  TL0=0x2f;
  TR0=1;
}


/*------分割线--------------------------------------------------*/
/*以下是 led.h 的内容*/


#ifndef _LED_   //标志变量_LED_是用它本身的文件名称命名
#define _LED_   //标志变量_LED_是用它本身的文件名称命名


#define const_time_level 200   //宏定义都放在头文件里

/* 注释一：
  IO口的宏定义也放在头文件里，
  如果是PIC单片机，以下IO口定义相当于宏定义 #define  led_dr LATBbits.LATB4等语句
*/  
sbit led_dr=P3^5; //如果是PIC单片机，相当于宏定义 #define  led_dr LATBbits.LATB4等语句

void led_flicker();   //这个是函数的声明，每一个源文件里的函数都要在它的头文件里声明

/* 注释三：
声明一个全局变量必须加extern关键字，同时千万不能在声明全局变量的时候赋初始值，比如：
extern unsigned char ucLedStep=0; 这样是绝对错误的。
*/  
extern unsigned char ucLedStep; //这个是全局变量的声明



#endif  

/*------分割线--------------------------------------------------*/
/*以下是 led.c 的内容*/

#include "REG52.H"  //必须包含的单片机系统头文件
#include "led.h"  //必须包含它本身的头文件


/* 注释一：
   由于本源文件中用到了uiTimeCnt全局变量，而uiTimeCnt是在interrupt文件里声明和定义的，
   所以必须把interrupt.h也包含进来
*/  
#include "interrupt.h"  //必须包含它本身的头文件

unsigned char ucLedStep=0; //这个是全局变量的定义，可以赋初值

void led_flicker()   //这个是函数的定义
{
  switch(ucLedStep)
  {
     case 0:

         if(uiTimeCnt>=const_time_level)
         {

             ET0=0;  //以下能直接用ET0寄存器关键字，是因为包含了REG52.H头文件
             uiTimeCnt=0; //uiTimeCnt此变量是在interrupt文件里声明和定义的，所以必须把interrupt.h也包含进来
             ET0=1;
             led_dr=1;  //此IO口定义已经在led.h头文件中定义了
             ucLedStep=1; //切换到下一个步骤
         }
         break;
     case 1:
         if(uiTimeCnt>=const_time_level)
         {
             ET0=0;
             uiTimeCnt=0;
             ET0=1;  
             led_dr=0;   
             ucLedStep=0; //返回到上一个步骤
         }
         break;
  
  }

}


/*------分割线--------------------------------------------------*/

总结陈词：
下一节开始讲液晶屏显示方面的内容。欲知详情，请听下回分解----带字库12864液晶屏的常用点阵字体程序。

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

乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

85#
 楼主| 发表于 2014-9-18 12:51:27 | 显示全部楼层
第六十九节：使用static关键字可以减少全局变量的使用

开场白：
本来这一节打算开始讲液晶屏的，但是昨天经过网友“任军”的点拨，我发现了一个惊天秘密，原来static关键字是这么好的东西我却错过了那么多年。以前就有一些网友抱怨，鸿哥的程序好是好，就是全局变量满天飞，当时我觉得我也没招呀，C语言就全局变量和局部变量，单单靠局部变量肯定不行，局部变量每次进入函数内部数值都会被初始化改变，所以我在很多场合也只能靠全局变量了。但是自从昨天知道了static关键字的秘密后，我恍然大悟，很多场合只要在局部变量前面加上static关键字，就可以大大减少全局变量的使用了。
这一节要教会大家一个知识点：
  大家都知道，普通的局部变量在每次程序执行到函数内部的时候，数值都会被重新初始化，数值会发生变化，不能保持之前的数值。但是在局部变量加上static关键字后，系统在刚上电的时候就已经把带static的局部变量赋初始值了，从此程序每次进入函数内部，都不会初始化带static关键字的局部变量，它会保持最近一次被程序执行更改的数值不变，像全局变量一样。跟全局变量唯一的差别是，带static关键字的局部变量的作用域仅仅在函数内部，而普通全局变量的作用域是整个工程。

本程序例程是直接在第八节程序上修改，大大减少了全局变量的使用。具体内容，请看源代码讲解。

（1）硬件平台：
     基于坚鸿51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键，记得把输出线P0.4一直输出低电平，模拟独立按键的触发地GND。

（2）实现功能：跟前面第八节的功能一模一样，有两个独立按键，每按一个独立按键，蜂鸣器发出“滴”的一声后就停。
   
（3）源代码讲解如下：

#include "REG52.H"

#define const_voice_short  40  

#define const_key_time1  20   
#define const_key_time2  20   

void initial_myself();   
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time();
void key_service();
void key_scan();

sbit key_sr1=P0^0;
sbit key_sr2=P0^1;
sbit key_gnd_dr=P0^4;

sbit beep_dr=P2^7;

unsigned char ucKeySec=0;   //一些需要在不同函数之间使用的核心变量，只能用全局变量
unsigned int  uiVoiceCnt=0;  //一些需要在不同函数之间使用的核心变量，只能用全局变量

void main()
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral();
   while(1)  
   {
       key_service();
   }

}

void key_scan()
{  
/* 注释一：
   (1)大家都知道，普通的局部变量在每次程序执行到函数内部的时候，数值都会被重新初始化，
   数值会发生变化，不能保持之前的数值。
   (2)但是在局部变量加上static关键字后，系统在刚上电的时候就已经把带static的局部变量
   赋初始值了，从此程序每次进入函数内部，都不会初始化带static关键字的局部变量，它会保持
   最近一次被程序执行更改的数值不变，像全局变量一样。跟全局变量唯一的差别是，带static关键字
   的局部变量的作用域仅仅在函数内部，而普通全局变量的作用域是整个工程。
   (3)以下这些变量我原来在第八节是用普通全局变量的，现在改成用static的局部变量了，减少了全局变量
   的使用，让程序阅读起来更加简洁。大家也可以试试把以下变量的static去掉试试，结果会发现去掉了static后，
   按键就不会被触发了。
*/

static unsigned int  uiKeyTimeCnt1=0; //带static的局部变量
static unsigned char ucKeyLock1=0;   
static unsigned int  uiKeyTimeCnt2=0;
static unsigned char ucKeyLock2=0;


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

  if(key_sr2==1)
  {
     ucKeyLock2=0;
         uiKeyTimeCnt2=0;
  }
  else if(ucKeyLock2==0)
  {
     uiKeyTimeCnt2++;
     if(uiKeyTimeCnt2>const_key_time2)
     {
        uiKeyTimeCnt2=0;
        ucKeyLock2=1;
        ucKeySec=2;   
     }
  }

}


void key_service()
{
  switch(ucKeySec)
  {
    case 1:

          uiVoiceCnt=const_voice_short;
          ucKeySec=0;
          break;        
    case 2:
          uiVoiceCnt=const_voice_short;
          ucKeySec=0;
          break;                    
  }               
}



void T0_time() interrupt 1
{
  TF0=0;
  TR0=0;

  key_scan();

  if(uiVoiceCnt!=0)
  {
     uiVoiceCnt--;
     beep_dr=0;  
  }
  else
  {
     ;
     beep_dr=1;
  }


  TH0=0xf8;   
  TL0=0x2f;
  TR0=1;
}


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  
      {
         ;
      }
   }
}


void initial_myself()
{


  key_gnd_dr=0;

  beep_dr=1;

  TMOD=0x01;  

  TH0=0xf8;   
  TL0=0x2f;

}
void initial_peripheral()
{
  EA=1;     
  ET0=1;   
  TR0=1;   
}
总结陈词：
下一节开始讲液晶屏显示方面的内容。欲知详情，请听下回分解----带字库12864液晶屏的常用点阵字体程序。

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


乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

86#
 楼主| 发表于 2014-9-22 00:43:18 | 显示全部楼层
KR770906 发表于 2014-9-21 08:58
贴合实战，膜拜鸿哥。

感谢支持。
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

87#
 楼主| 发表于 2014-9-24 14:09:35 | 显示全部楼层
本帖最后由 jianhong_wu 于 2014-11-16 21:26 编辑

第七十节：深入讲解液晶屏的构字过程。

开场白：
    液晶屏模块本身带控制芯片，驱动液晶屏的本质就是单片机通过串行或者并行方式，根据芯片资料指定的协议跟液晶芯片进行通讯的过程。这个详细的通讯协议驱动程序厂家都会免费提供的，也可以在网上找到大量的示范程序。那么我们最应该关注的核心是什么？我认为最核心的是要理清楚程序坐标与实际显示坐标之间的关系规律。本程序不使用模块自带的字库，而是使用自己构造的字库，目的就是为了让读者理解更底层的字模显示。
这一节要教会大家三个知识点：
第一个：对于驱动芯片是st7920的12864液晶屏，它的真实坐标体系的本质是256x32的点阵液晶屏。
第二个：鸿哥刻意在驱动显示函数里增加了大延时函数，目的是通过慢镜头回放，让大家观察到横向取模的字是如何一个字节一个字节构建而成的。
第三个：数组带const关键字，表示数据常量存放在ROM程序区，不占用RAM的变量。

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

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

（2）实现功能：开机上电后，可以观察到0x01,0x02,0x03,0x04这4个显示数字在不同的排列方式下，出现在不同的液晶屏显示位置。也可以观察到“馒头”这两个字是如何一个字节一个字节构建而成的，加深理解字模数组跟显示现象的关系。
   
（3）源代码讲解如下：
#include "REG52.H"


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

void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount); //显示任意点阵函数
void display_clear(void); // 清屏

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

/* 注释一：
* 数组带const关键字，表示数据常量存放在ROM程序区，不占用RAM的变量
*/
const unsigned char Hz1616_man[]= /*馒   横向取模  16X16点阵 网上有很多免费的字模软件生成字模数组 */
{
0x21,0xF8,0x21,0x08,0x21,0xF8,0x3D,0x08,0x45,0xF8,0x48,0x00,0x83,0xFC,0x22,0x94,
0x23,0xFC,0x20,0x00,0x21,0xF8,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x00,0x00,
};

const unsigned char Hz1616_tou[]= /*头   横向取模  16X16点阵 网上有很多免费的字模软件生成字模数组 */
{
0x00,0x80,0x10,0x80,0x0C,0x80,0x04,0x80,0x10,0x80,0x0C,0x80,0x08,0x80,0x00,0x80,
0xFF,0xFE,0x00,0x80,0x01,0x40,0x02,0x20,0x04,0x30,0x08,0x18,0x10,0x0C,0x20,0x08,
};

/* 注释二：
* 为了方便观察字模的数字与显示的关系，以下3个数组的本质是完全一样的，只是排列不一样而已。
*/
const unsigned char Byte_1[]=  //4横，1列
{
0x01,0x02,0x03,0x04,
};

const unsigned char Byte_2[]= //2横，2列
{
0x01,0x02,
0x03,0x04,
};

const unsigned char Byte_3[]= //1横，4列
{
0x01,
0x02,
0x03,
0x04,
};


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

    display_clear(); // 清屏

        display_lattice(0,0,Byte_1,0,4,1);    //显示<4横，1列>的数组数字
        display_lattice(0,16,Byte_1,1,4,1);   //显示<4横，1列>的数组数字 反显

        display_lattice(7,0,Byte_2,0,2,2);   //显示<2横，2列>的数组数字
        display_lattice(7,16,Byte_2,1,2,2);  //显示<2横，2列>的数组数字 反显

        display_lattice(8,0,Byte_3,0,1,4);  //显示<1横，4列>的数组数字
        display_lattice(8,16,Byte_3,1,1,4); //显示<1横，4列>的数组数字 反显

        display_lattice(14,0,Hz1616_man,0,2,16);  //显示<馒>字
        display_lattice(15,0,Hz1616_tou,0,2,16);  //显示<头>字
        display_lattice(14,16,Hz1616_man,1,2,16); //显示<馒>字 反显
        display_lattice(15,16,Hz1616_tou,1,2,16); //显示<头>字 反显
    while(1)  
    {
       ;
    }

}

/* 注释三：真实坐标体系的本质。
* 从坐标体系的角度来看，本液晶屏表面上是128x64的液晶屏，实际上可以看做是256x32的液晶屏。
* 把256x32的液晶屏分左右两半，把左半屏128x32放在上面，把右半屏128x32放下面，就合并成了
* 一个128x64的液晶屏。由于液晶模块内部控制器的原因，虽然横向有256个点阵，但是我们的x轴
* 坐标没办法精确到每个点，只能以16个点(2个字节)为一个单位，因此256个点的x轴坐标范围是0至15。
* 而y轴的坐标可以精确到每个点为一行，所以32个点的y轴坐标范围是0至31.
*/

void display_clear(void) // 清屏
{   

        unsigned char x,y;
  //  WriteCommand(0x34);  //关显示缓冲指令            
    WriteCommand(0x36); //这次为了观察每个数字在显示屏上的关系，所以把这个显示缓冲的命令提前打开，下一节放到本函数最后
         y=0;
        while(y<32)  //y轴的范围0至31
    {
                 WriteCommand(y+0x80);        //垂直地址
         WriteCommand(0x80);          //水平地址
         for(x=0;x<32;x++)  //256个横向点，有32个字节
         {  
            LCDWriteData(0x00);
             }
                 y++;
    }


}


/* 注释四：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
* 本函数后面故意增加一个长延时delay_short(30000)，是为了方便读者观察横向取模的
* 字是如何一个字节一个字节构建而成的。
*/
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 j=0;
   unsigned int i=0;
   unsigned char ucTemp;
//  WriteCommand(0x34);   //关显示缓冲指令   
   WriteCommand(0x36);  //这次为了观察每个数字在显示屏上的关系，所以把这个显示缓冲的命令提前打开，下一节放到本函数最后
   for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
   {
       WriteCommand(y+j+0x80);        //垂直地址
       WriteCommand(x+0x80);          //水平地址
       for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
       {
         ucTemp=ucArray[j*x_amount+i];
             if(ucFbFlag==1)  //反白显示
                 {
            ucTemp=~ucTemp;
         }
             LCDWriteData(ucTemp);
                 delay_short(30000);  //本函数故意增加这个长延时，是为了方便读者观察横向取模的字是如何一个字节一个字节构建而成的。
      }
   }

}

/* 注释五：
* 以下是液晶屏模块的驱动程序，我觉得没有什么好讲的，因为我是直接在网上寻找现成的驱动时序修改而成。
* 它的本质就是单片机跟这个液晶模块芯片进行串行通信。
*/
void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
{
        unsigned char i;
        for ( i = 0; i < 8; i++ )
        {
                if ( (ucData << i) & 0x80 )
                {
                        LCDSID_dr = 1;
                }
                else
                {
                        LCDSID_dr = 0;
                }
                LCDCLK_dr = 0;
                LCDCLK_dr = 1;
        }
}

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


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

        LCDCS_dr = 0;
        LCDCS_dr = 1;
        SPIWrite(ucCommand, 0);
        delay_short(90);
}

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

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



void delay_short(unsigned int uiDelayShort) //延时函数
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;  
   }
}

总结陈词：
这节重点讲了液晶屏的构字过程，下节将会在本节的基础上，略作修改，显示常用的不同点阵字模。欲知详情，请听下回分解-----液晶屏的字符，16点阵，24点阵和32点阵的显示程序。

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

乐于分享，勇于质疑！
回复 支持 1 反对 0

使用道具 举报

88#
 楼主| 发表于 2014-9-25 11:09:37 | 显示全部楼层
KR770906 发表于 2014-9-25 08:43
鸿哥，ds1302芯片内置万年历和电池，好像不用判断闰月，直接对时就可以使用了。不知对否？

（1）DS1302没有内置电池。
（2）从DS1302读取的数据是不用判断闰月的，但是你往里面写入修改的时间数据时，建议还是判断一下，因为假如你不判断就写入一个错误的时间，我不知道ds1302内部会怎么处理。
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

89#
 楼主| 发表于 2014-9-25 11:10:27 | 显示全部楼层
第七十一节：液晶屏的字符，16点阵，24点阵和32点阵的显示程序。
开场白：
这一节要教会大家二个知识点：
第一个：如何利用任意点阵字体显示函数display_lattice来显示8x16的字符，16点阵汉字，24点阵汉字和32点阵汉字。
第二个：纠正上一节的一个小错误。C51编译器跟其它单片机的编译器有点不一样。想把常量数据保存在ROM程序存储区里并不是用const关键字，而是是用code关键字。

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

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

（2）实现功能：开机上电后，可以看到液晶屏分别显示32点阵，24点阵和16点阵的“馒头”两个字，还有“V5”这两个8x16点阵的字符。
   
（3）源代码讲解如下：
#include "REG52.H"

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

void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount); //显示任意点阵函数
void display_clear(void); // 清屏

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

/* 注释一：
* 纠正上一节的一个小错误。C51编译器跟其它的编译器有点不一样。
* 存在ROM程序存储区里的常量数据并不是用const关键字，而是是用code关键字。
*/
code unsigned char Hz3232_man[]= /*馒   横向取模  32x32点阵 */
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x07,0x03,0x00,0x0F,0x87,0xFF,0x80,
0x0F,0x07,0x03,0x80,0x0E,0x07,0x03,0x80,0x0E,0x37,0xFF,0x80,0x1C,0x7F,0x03,0x80,
0x1F,0xFF,0x03,0x80,0x18,0x77,0xFF,0x00,0x38,0xE0,0x00,0xC0,0x36,0xDF,0xFF,0xF0,
0x77,0x9C,0xCE,0xE0,0x67,0x1C,0xCE,0xE0,0xC7,0x1C,0xCE,0xE0,0x07,0x1C,0xCE,0xE0,
0x07,0x1F,0xFF,0xE0,0x07,0x18,0x00,0x00,0x07,0x00,0x03,0x80,0x07,0x0F,0xFF,0xC0,
0x07,0x71,0x8F,0x00,0x07,0xE0,0xDE,0x00,0x07,0xC0,0xFC,0x00,0x07,0x80,0x78,0x00,
0x0F,0x01,0xFE,0x00,0x07,0x03,0x8F,0xE0,0x00,0x1E,0x03,0xF0,0x00,0xF8,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};


code unsigned char Hz3232_tou[]= /*头   横向取模  32x32点阵 */
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xC0,0x00,0x00,0x03,0xE0,0x00,
0x03,0xC3,0xC0,0x00,0x00,0xF3,0x80,0x00,0x00,0x7B,0x80,0x00,0x00,0x7B,0x80,0x00,
0x00,0x3B,0x80,0x00,0x0E,0x03,0x80,0x00,0x07,0x83,0x80,0x00,0x03,0xC3,0x80,0x00,
0x01,0xE3,0x80,0x00,0x01,0xE3,0x80,0x00,0x00,0xC3,0x80,0x00,0x00,0x03,0x81,0xE0,
0x7F,0xFF,0xFF,0xF0,0x00,0x07,0x80,0x30,0x00,0x07,0x00,0x00,0x00,0x07,0x80,0x00,
0x00,0x0E,0xE0,0x00,0x00,0x1E,0x7C,0x00,0x00,0x3C,0x1F,0x00,0x00,0x78,0x0F,0xC0,
0x00,0xF0,0x03,0xC0,0x03,0xC0,0x01,0xE0,0x0F,0x00,0x00,0xE0,0x78,0x00,0x00,0x00,
0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};

code unsigned char Hz2424_man[]= /*馒   横向取模  24x24点阵 */
{
0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x18,0x30,0x1E,0x1F,0xF8,0x1C,0x1C,0x38,0x1C,
0x1F,0xF8,0x19,0xFC,0x38,0x3F,0xFF,0xF8,0x31,0x98,0x30,0x7B,0xE0,0x0E,0x6F,0x7F,
0xFE,0x6E,0x76,0xEE,0xCC,0x76,0xEE,0x0C,0x7F,0xFE,0x0C,0x70,0x0C,0x0C,0x00,0x38,
0x0C,0x3F,0xF8,0x0D,0xCE,0x70,0x0F,0x87,0xE0,0x0F,0x03,0x80,0x1E,0x07,0xE0,0x0C,
0x1C,0x7E,0x01,0xF0,0x1F,0x00,0x00,0x00,
};


code unsigned char Hz2424_tou[]= /*头   横向取模  24x24点阵 */
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0E,0x00,0x06,0x0F,0x00,0x07,0x8E,0x00,0x01,
0xEE,0x00,0x00,0xEE,0x00,0x00,0xEC,0x00,0x1C,0x0C,0x00,0x0F,0x0C,0x00,0x07,0x9C,
0x00,0x03,0x9C,0x00,0x00,0x1C,0x0C,0x00,0x1C,0x1E,0x7F,0xFF,0xF6,0x00,0x1C,0x00,
0x00,0x3C,0x00,0x00,0x3F,0x80,0x00,0x71,0xE0,0x00,0xE0,0xF8,0x01,0xC0,0x3C,0x07,
0x00,0x1C,0x3C,0x00,0x0C,0x70,0x00,0x00,
};


code unsigned char Hz1616_man[]= /*馒   横向取模  16X16点阵 */
{
0x21,0xF8,0x21,0x08,0x21,0xF8,0x3D,0x08,0x45,0xF8,0x48,0x00,0x83,0xFC,0x22,0x94,
0x23,0xFC,0x20,0x00,0x21,0xF8,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x00,0x00,
};

code unsigned char Hz1616_tou[]= /*头   横向取模  16X16点阵 */
{
0x00,0x80,0x10,0x80,0x0C,0x80,0x04,0x80,0x10,0x80,0x0C,0x80,0x08,0x80,0x00,0x80,
0xFF,0xFE,0x00,0x80,0x01,0x40,0x02,0x20,0x04,0x30,0x08,0x18,0x10,0x0C,0x20,0x08,
};

code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 */
{
0x00,0x00,0x00,0xE7,0x42,0x42,0x44,0x24,0x24,0x28,0x28,0x18,0x10,0x10,0x00,0x00,
};

code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 */
{
0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};



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

    display_clear(); // 清屏

        display_lattice(0,0,Hz3232_man,0,4,32);  //显示32点阵的<馒>字
        display_lattice(2,0,Hz3232_tou,0,4,32);  //显示32点阵的<头>字

        display_lattice(4,0,Hz2424_man,0,3,24);  //显示24点阵的<馒>字
        display_lattice(6,0,Hz2424_tou,0,3,24);  //显示24点阵的<头>字

        display_lattice(8,0,Hz1616_man,0,2,16);  //显示16点阵的<馒>字
        display_lattice(9,0,Hz1616_tou,0,2,16);  //显示16点阵的<头>字

        display_lattice(11,0,Zf816_V,0,1,16);  //显示8x16点阵的<V>字符
        display_lattice(12,0,Zf816_5,0,1,16);  //显示8x16点阵的<5>字符

    while(1)  
    {
       ;
    }

}



void display_clear(void) // 清屏
{   

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

}


/* 注释二：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
*/
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 j=0;
   unsigned int i=0;
   unsigned char ucTemp;
   WriteCommand(0x34);  //关显示缓冲指令            
   WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
   for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
   {
       WriteCommand(y+j+0x80);        //垂直地址
       WriteCommand(x+0x80);          //水平地址
       for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
       {
         ucTemp=ucArray[j*x_amount+i];
             if(ucFbFlag==1)  //反白显示
                 {
            ucTemp=~ucTemp;
         }
             LCDWriteData(ucTemp);
          //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
      }
   }
   WriteCommand(0x36); //开显示缓冲指令
}


void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
{
        unsigned char i;
        for ( i = 0; i < 8; i++ )
        {
                if ( (ucData << i) & 0x80 )
                {
                        LCDSID_dr = 1;
                }
                else
                {
                        LCDSID_dr = 0;
                }
                LCDCLK_dr = 0;
                LCDCLK_dr = 1;
        }
}

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


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

        LCDCS_dr = 0;
        LCDCS_dr = 1;
        SPIWrite(ucCommand, 0);
        delay_short(90);
}

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

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



void delay_short(unsigned int uiDelayShort) //延时函数
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;  
   }
}


总结陈词：
    我们现在讲的字体显示都是横向的，如果某个项目要把整个液晶屏顺时针旋转90度，要求像对联一样纵向显示一串字体的时候，该怎么办？我前两个月就遇到了这样的项目，当时我的做法就是把字体的字库数组通过算法旋转90度就达到了目的。这种算法程序是怎样编写的？欲知详情，请听下回分解-----把字体顺时针旋转90度显示的算法程序。

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

乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

90#
 楼主| 发表于 2014-10-6 12:29:46 | 显示全部楼层
又一个暑假 发表于 2014-10-6 12:14
鸿哥下次能不能把把整个工程文件夹压缩好附在后面传上来啊，在这里复制代码自己在建个工程挺懒的

我的都是一个源文件的，复制很简单的。你的请求被驳回了。
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

91#
 楼主| 发表于 2014-10-10 12:38:36 | 显示全部楼层
第七十二节：在液晶屏中把字体顺时针旋转90度显示的算法程序。
开场白：
我曾经遇到过这样的项目，客户由于外壳结果的原因，故意把液晶屏物理位置逆时针旋转了90度，在这种情况下，如果按之前的显示驱动就会发现字体也跟着倒了过来，影响了阅读。当时我的解决办法就是把字体的字库数组通过算法顺时针旋转90度就达到了目的。这一节把这个算法教给大家。
这个算法的本质是：请看以下附图1，附图2，附图3.
第一步：旋转90度的本质，就是把原来横向取模改成纵向去模。先把代表每一行16个点阵数的2个char型数据合并成1个int型数据。
第二步：再把每一列的16个点阵按2个字节分别取到一个数组里，就是纵向取模的过程了。
具体内容，请看源代码讲解。

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

（2）实现功能：把液晶屏物理位置逆时针旋转了90度，开机上电后，可以看到液晶屏像对联的显示顺序一样，从上往下分别显示“馒头V5”四个字。
   
（3）源代码讲解如下：
  1. #include "REG52.H"

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

  8. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  9. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  10. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  11. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  12. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  13. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount); //显示任意点阵函数
  14. void display_clear(void); // 清屏
  15. void hz1616_s90(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把16x16汉字字模顺时针旋转90度的转换函数
  16. void hz816_s90(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把8x16字符字模顺时针旋转90度的转换函数

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

  20. code unsigned char Hz1616_man[]= /*馒   横向取模  16X16点阵 */
  21. {
  22. 0x21,0xF8,0x21,0x08,0x21,0xF8,0x3D,0x08,0x45,0xF8,0x48,0x00,0x83,0xFC,0x22,0x94,
  23. 0x23,0xFC,0x20,0x00,0x21,0xF8,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x00,0x00,
  24. };

  26. code unsigned char Hz1616_tou[]= /*头   横向取模  16X16点阵 */
  27. {
  28. 0x00,0x80,0x10,0x80,0x0C,0x80,0x04,0x80,0x10,0x80,0x0C,0x80,0x08,0x80,0x00,0x80,
  29. 0xFF,0xFE,0x00,0x80,0x01,0x40,0x02,0x20,0x04,0x30,0x08,0x18,0x10,0x0C,0x20,0x08,
  30. };


  33. code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 */
  34. {
  35. 0x00,0x00,0x00,0xE7,0x42,0x42,0x44,0x24,0x24,0x28,0x28,0x18,0x10,0x10,0x00,0x00,
  36. };

  38. code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 */
  39. {
  40. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  41. };


  44. unsigned char ucBufferResult[32]; //用于临时存放转换结束后的字模数组

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

  50.         display_clear(); // 清屏

  52. /* 注释一：
  53. * (1)把原来的液晶屏物理位置逆时针旋转90度后，从上往下阅读，类似对联的阅读习惯。所以请注意坐标体系参数的变化。
  54. * (2)为了让字符居中显示，请注意在显示V和5两个字符时坐标体系的变化。
  55. * (3)字符8x16经过旋转处理后，变成了16x8，在调用display_lattice函数时，要注意修改响应的参数。
  56. */

  58.         hz1616_s90(Hz1616_man,ucBufferResult);  //把<馒>字顺时针旋转90度放到ucBufferResult临时变量里。
  59.         display_lattice(7,0,ucBufferResult,0,2,16);  //显示旋转90度后的<馒>字

  61.         hz1616_s90(Hz1616_tou,ucBufferResult);  //把<头>字顺时针旋转90度放到ucBufferResult临时变量里。
  62.         display_lattice(6,0,ucBufferResult,0,2,16);  //显示旋转90度后的<头>字


  65.         hz816_s90(Zf816_V,ucBufferResult);  //把<V>字符顺时针旋转90度放到ucBufferResult临时变量里。
  66.         display_lattice(5,4,ucBufferResult,0,2,8);  //显示旋转90度后的<V>字符。注意在最后两个个参数，2表示每一行有2个字节，8表示8列。第二个坐标参数4是为了偏移居中显示。

  68.         hz816_s90(Zf816_5,ucBufferResult);  //把<5>字符顺时针旋转90度放到ucBufferResult临时变量里。
  69.         display_lattice(4,4,ucBufferResult,0,2,8);  //显示旋转90度后的<5>字符。注意在最后两个个参数，2表示每一行有2个字节，8表示8列。第二个坐标参数4是为了偏移居中显示。


  72.     while(1)  
  73.     {
  74.        ;
  75.     }

  77. }



  81. void display_clear(void) // 清屏
  82. {   

  84.     unsigned char x,y;
  85.     WriteCommand(0x34);  //关显示缓冲指令            
  86.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  87.     y=0;
  88.     while(y<32)  //y轴的范围0至31
  89.     {
  90.          WriteCommand(y+0x80);        //垂直地址
  91.          WriteCommand(0x80);          //水平地址
  92.          for(x=0;x<32;x++)  //256个横向点，有32个字节
  93.          {  
  94.             LCDWriteData(0x00);
  95.          }
  96.          y++;
  97.     }
  98.     WriteCommand(0x36); //开显示缓冲指令

  100. }


  103. /* 注释二：
  104. * 把16x16汉字字模顺时针旋转90度的步骤：请看附图1，附图2，附图3.
  105. * 第一步：旋转90度的本质，就是把原来横向取模改成纵向去模。先把代表每一行16个点阵数的2个char型数据合并成1个int型数据。
  106. * 第二步：再把每一列的16个点阵按2个字节分别取到一个数组里，就是纵向取模的过程了。以下程序int型数据每取8个数据的最高位，
  107. * 就左移一次，本质就是纵向取模的过程。
  108. */
  109. void hz1616_s90(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把16x16汉字字模顺时针旋转90度的转换函数
  110. {
  111.          unsigned char a;
  112.          unsigned char b;
  113.          unsigned char c;
  114.      unsigned int uiBuffer[16];  //注意，是int类型数据，一个数据包含2个字节。
  115.        
  116.          for(a=0;a<16;a++) //把原来以字节为单位的字库每一行的2个字节合并成1个int型数据。放到一个包含16个int类型的数组里，为旋转90度算法处理做准备
  117.          {
  118.          uiBuffer[a]=p_ucHz[a*2];
  119.                  uiBuffer[a]=uiBuffer[a]<<8;
  120.                  uiBuffer[a]=uiBuffer[a]+p_ucHz[a*2+1];
  121.      }
  122.          
  123.          c=0;
  124.          for(a=0;a<16;a++)  //这里的16代表16列
  125.          {
  126.                  for(b=0;b<8;b++)   //每一列中有16个点，有2个字节，这里的8代表第一个字节的8个位或点。
  127.                  {
  128.                           p_ucResult[c]=p_ucResult[c]<<1;   
  129.               p_ucResult[c]=p_ucResult[c]&0xfe;                 
  130.               if(uiBuffer[15-b]>=0x8000)    //注意，int类型数据的判断是0x8000,char型的是0x80
  131.                       {
  132.                  p_ucResult[c]=p_ucResult[c]+1;
  133.               }
  134.                       uiBuffer[15-b]=uiBuffer[15-b]<<1;
  135.          }
  136.                  c++;
  137.                  
  138.                  for(b=0;b<8;b++) //每一列中有16个点，有2个字节，这里的8代表第二个字节的8个位或点。
  139.                  {
  140.                           p_ucResult[c]=p_ucResult[c]<<1;  
  141.               p_ucResult[c]=p_ucResult[c]&0xfe;                                          
  142.               if(uiBuffer[7-b]>=0x8000)      
  143.                       {
  144.                    p_ucResult[c]=p_ucResult[c]+1;
  145.               }
  146.                              uiBuffer[7-b]=uiBuffer[7-b]<<1;
  147.          }
  148.                  c++;
  149.     }
  150.          
  151. }


  154. /* 注释三：
  155. * 把8x16字符字模顺时针旋转90度的步骤：
  156. * 第一步：旋转90度的本质，就是把原来横向取模改成纵向去模。由于原来的字库存放在带code关键字的ROM区，只能读不能写，所以
  157. * 先把原来的字模数组读取出来，放到一个变量缓冲区里。
  158. * 第二步：再把每一列的16个点阵按2个字节分别取到一个数组里，就是纵向取模的过程了。以下程序int型数据每取8个数据的最高位，
  159.    就左移一次，本质就是纵向取模的过程。
  160. */
  161. void hz816_s90(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把8x16字符字模顺时针旋转90度的转换函数
  162. {
  163.          unsigned char a;
  164.          unsigned char b;
  165.          unsigned char c;
  166.      unsigned char uiBuffer[16]; //注意，跟16x16点阵不一样，这里是char数据。因为横向的只有8个点
  167.        
  168.          for(a=0;a<16;a++) //把存放在ROM的字库放到一个16个char类型的数组里
  169.          {
  170.          uiBuffer[a]=p_ucHz[a];
  171.      }
  172.          
  173.          c=0;
  174.          for(a=0;a<8;a++)  //这里的8代表8列
  175.          {
  176.                  for(b=0;b<8;b++)  //每一列中有16个点，有2个字节，这里的8代表第一个字节的8个位或点。
  177.                  {
  178.                           p_ucResult[c]=p_ucResult[c]<<1;
  179.               p_ucResult[c]=p_ucResult[c]&0xfe;                                         
  180.               if(uiBuffer[15-b]>=0x80)   //注意，int类型数据的判断是0x8000,char型的是0x80
  181.                         {
  182.                   p_ucResult[c]=p_ucResult[c]+1;
  183.               }
  184.                       uiBuffer[15-b]=uiBuffer[15-b]<<1;
  185.          }
  186.                c++;
  187.                  
  188.                  for(b=0;b<8;b++)  //每一列中有16个点，有2个字节，这里的8代表第二个字节的8个位或点。
  189.                  {
  190.                           p_ucResult[c]=p_ucResult[c]<<1;
  191.               p_ucResult[c]=p_ucResult[c]&0xfe;                                         
  192.               if(uiBuffer[7-b]>=0x80)   //注意，int类型数据的判断是0x8000,char型的是0x80
  193.                           {
  194.                  p_ucResult[c]=p_ucResult[c]+1;
  195.               }
  196.                           uiBuffer[7-b]=uiBuffer[7-b]<<1;
  197.          }
  198.                  c++;
  199.      }
  200.          
  201. }



  205. /* 注释四：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  206. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
  207. * 第3个参数*ucArray是字模的数组。
  208. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  209. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  210. */
  211. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
  212. {
  213.    unsigned int j=0;
  214.    unsigned int i=0;
  215.    unsigned char ucTemp;
  216.    WriteCommand(0x34);  //关显示缓冲指令            
  217.    WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  218.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  219.    {
  220.        WriteCommand(y+j+0x80);        //垂直地址
  221.        WriteCommand(x+0x80);          //水平地址
  222.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  223.        {
  224.          ucTemp=ucArray[j*x_amount+i];
  225.              if(ucFbFlag==1)  //反白显示
  226.                  {
  227.             ucTemp=~ucTemp;
  228.          }
  229.              LCDWriteData(ucTemp);
  230.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
  231.       }
  232.    }
  233.    WriteCommand(0x36); //开显示缓冲指令
  234. }


  237. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  238. {
  239.         unsigned char i;
  240.         for ( i = 0; i < 8; i++ )
  241.         {
  242.                 if ( (ucData << i) & 0x80 )
  243.                 {
  244.                         LCDSID_dr = 1;
  245.                 }
  246.                 else
  247.                 {
  248.                         LCDSID_dr = 0;
  249.                 }
  250.                 LCDCLK_dr = 0;
  251.                 LCDCLK_dr = 1;
  252.         }
  253. }

  255. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  256. {
  257.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
  258.         SendByteToLcd( ucWData & 0xf0 );
  259.         SendByteToLcd( (ucWData << 4) & 0xf0);
  260. }


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

  266.         LCDCS_dr = 0;
  267.         LCDCS_dr = 1;
  268.         SPIWrite(ucCommand, 0);
  269.         delay_short(90);
  270. }

  272. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
  273. {
  274.         LCDCS_dr = 0;
  275.         LCDCS_dr = 1;
  276.         SPIWrite(ucData, 1);
  277. }

  279. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
  280. {
  281.         LCDRST_dr = 1;  //复位
  282.         LCDRST_dr = 0;
  283.         LCDRST_dr = 1;
  284. }



  288. void delay_short(unsigned int uiDelayShort) //延时函数
  289. {
  290.    unsigned int i;  
  291.    for(i=0;i<uiDelayShort;i++)
  292.    {
  293.      ;  
  294.    }
  295. }
复制代码

总结陈词：
    有的项目会要求把字体或者图像进行镜像显示处理，这种算法程序是怎样编写的？欲知详情，请听下回分解-----在液晶屏中把字体镜像显示的算法程序。
（未完待续，下节更精彩，不要走开哦）

乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

92#
 楼主| 发表于 2014-10-10 13:45:53 | 显示全部楼层
海~~ 发表于 2014-10-10 12:48
非常有用啊，鸿哥。

那当然，我分享的都是实际项目的经验，不是精华我不发。
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

93#
 楼主| 发表于 2014-10-12 10:54:10 | 显示全部楼层
KR770906 发表于 2014-10-11 21:30
十一大假后鸿哥又出手了，呵呵。

一直会有的，根本停不下来。
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

94#
 楼主| 发表于 2014-10-13 10:45:24 | 显示全部楼层
第七十三节：在液晶屏中把字体镜像显示的算法程序。

开场白：
有的项目会要求把字体或者图像进行镜像显示处理，这一节把这个算法教给大家。
    这个算法的本质是：
16x16点阵的图像或者字体有16行，每行有2个字节，如果把这2个字节看成是一个16位int型数据，那么就是要这个数据从原来左边是高位，右边是低位的顺序颠倒过来。本程序没有把2个字节合并成一个int型数据，而是直接在一个字节数据内把高低位顺序颠倒过来，然后把第1字节数据跟第2字节数据交换。
8x16点阵的图像或者字体有16行，每行有1个字节，把这个数据从原来左边是高位，右边是低位的顺序颠倒过来。
具体内容，请看源代码讲解。

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

（2）实现功能：开机上电后，从上往下分别显示“馒头V5”四个字以及右边镜像后的“馒头V5”四个字。
   
（3）源代码讲解如下：
  1. #include "REG52.H"

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

  8. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  9. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  10. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  11. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  12. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  13. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount); //显示任意点阵函数
  14. void display_clear(void); // 清屏
  15. void hz1616_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把16x16点阵字库镜像
  16. void hz816_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把8x16点阵字库镜像

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

  20. code unsigned char Hz1616_man[]= /*馒   横向取模  16X16点阵 */
  21. {
  22. 0x21,0xF8,0x21,0x08,0x21,0xF8,0x3D,0x08,0x45,0xF8,0x48,0x00,0x83,0xFC,0x22,0x94,
  23. 0x23,0xFC,0x20,0x00,0x21,0xF8,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x00,0x00,
  24. };

  26. code unsigned char Hz1616_tou[]= /*头   横向取模  16X16点阵 */
  27. {
  28. 0x00,0x80,0x10,0x80,0x0C,0x80,0x04,0x80,0x10,0x80,0x0C,0x80,0x08,0x80,0x00,0x80,
  29. 0xFF,0xFE,0x00,0x80,0x01,0x40,0x02,0x20,0x04,0x30,0x08,0x18,0x10,0x0C,0x20,0x08,
  30. };


  33. code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 */
  34. {
  35. 0x00,0x00,0x00,0xE7,0x42,0x42,0x44,0x24,0x24,0x28,0x28,0x18,0x10,0x10,0x00,0x00,
  36. };

  38. code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 */
  39. {
  40. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  41. };


  44. unsigned char ucBufferResult[32]; //用于临时存放转换结束后的字模数组

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

  50.         display_clear(); // 清屏

  52.         display_lattice(0,0,Hz1616_man,0,2,16);  //显示镜像前的<馒>字
  53.         hz1616_mirror(Hz1616_man,ucBufferResult);  //把<馒>字镜像后放到ucBufferResult临时变量里。
  54.         display_lattice(1,0,ucBufferResult,0,2,16);  //显示镜像后的<馒>字


  57.         display_lattice(0,16,Hz1616_tou,0,2,16);  //显示镜像前的<头>字
  58.         hz1616_mirror(Hz1616_tou,ucBufferResult);  //把<头>字镜像后放到ucBufferResult临时变量里。
  59.         display_lattice(1,16,ucBufferResult,0,2,16);  //显示镜像后的<头>字

  61.         display_lattice(8,0,Zf816_V,0,1,16);  //显示镜像前的<V>字符
  62.         hz816_mirror(Zf816_V,ucBufferResult);  //把<V>字符镜像后放到ucBufferResult临时变量里。
  63.         display_lattice(9,0,ucBufferResult,0,1,16);  //显示镜像后的<V>字符

  65.         display_lattice(8,16,Zf816_5,0,1,16);  //显示镜像前的<5>字符
  66.         hz816_mirror(Zf816_5,ucBufferResult);  //把<5>字符镜像后放到ucBufferResult临时变量里。
  67.         display_lattice(9,16,ucBufferResult,0,1,16);  //显示镜像后的<5>字符

  69.         while(1)  
  70.         {
  71.              ;
  72.         }

  74. }



  78. void display_clear(void) // 清屏
  79. {   

  81.     unsigned char x,y;
  82.     WriteCommand(0x34);  //关显示缓冲指令            
  83.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  84.     y=0;
  85.     while(y<32)  //y轴的范围0至31
  86.     {
  87.          WriteCommand(y+0x80);        //垂直地址
  88.          WriteCommand(0x80);          //水平地址
  89.          for(x=0;x<32;x++)  //256个横向点，有32个字节
  90.          {  
  91.             LCDWriteData(0x00);
  92.          }
  93.          y++;
  94.     }
  95.     WriteCommand(0x36); //开显示缓冲指令

  97. }

  99. /* 注释一：
  100. * 16x16点阵镜像的本质：
  101. * 16x16点阵有16行，每行有2个字节，如果把这2个字节看成是一个16位int型数据，
  102. * 那么就是要这个数据从原来左边是高位，右边是低位的顺序颠倒过来。本程序没有把2个字节
  103. * 合并成一个int型数据，而是直接在一个字节数据内把高低位顺序颠倒过来，然后把第1字节数据跟第2字节数据交换。
  104. */
  105. void hz1616_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把16x16点阵字库镜像的函数
  106. {
  107.          unsigned char a;
  108.          unsigned char b;
  109.          unsigned char c;
  110.          unsigned char d;
  111.        
  112.          for(a=0;a<16;a++) //这里16代表有16行。每一行有2个字节。把每一个字节看做一列，这里先把第1列字节的数据从原来左边是高位，右边是低位的顺序颠倒过来，相当于镜像。
  113.          {
  114.             b=p_ucHz[a*2+0];  //这里的2代表16x16点阵每行有2列字节，0代表从第1列开始。
  115.             c=0;
  116.             for(d=0;d<8;d++)  //把一个字节调换顺序
  117.                 {
  118.                c=c>>1;
  119.            if((b&0x80)==0x80)
  120.                    {
  121.              c=c|0x80;
  122.            }
  123.                    b=b<<1;
  124.         }                 
  125.         p_ucResult[a*2+1]=c;   //注意，因为是镜像，所以要把颠倒顺序后的字节从原来是第1列的调换到第2列         
  126.      }
  127.          
  128.          for(a=0;a<16;a++)  //这里16代表有16行。每一行有2个字节。把每一个字节看做一列，这里先把第2列字节的数据从原来左边是高位，右边是低位的顺序颠倒过来，相当于镜像。
  129.          {
  130.             b=p_ucHz[a*2+1];   //这里的2代表16x16点阵每行有2列字节，1代表从第2列开始。
  131.                  
  132.             c=0;
  133.             for(d=0;d<8;d++)  //把一个字节调换顺序
  134.                 {
  135.                         c=c>>1;
  136.             if((b&0x80)==0x80)
  137.                         {
  138.               c=c|0x80;
  139.             }
  140.                         b=b<<1;
  141.          }

  143.          p_ucResult[a*2+0]=c;         //注意，因为是镜像，所以要把颠倒顺序后的字节从原来是第2列的调换到第1列        

  145.                  
  146.      }
  147.          

  149. }



  153. /* 注释二：
  154. * 8x16点阵镜像的本质：
  155. * 8x16点阵有16行，每行有1个字节，把这个数据从原来左边是高位，右边是低位的顺序颠倒过来。
  156. */
  157. void hz816_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把8x16点阵字库镜像的函数
  158. {
  159.          unsigned char a;
  160.          unsigned char b;
  161.          unsigned char c;
  162.          unsigned char d;
  163.        
  164.          for(a=0;a<16;a++) //这里16代表有16行。每一行有1个字节。这里先把每一行字节的数据从原来左边是高位，右边是低位的顺序颠倒过来，相当于镜像。
  165.          {
  166.             b=p_ucHz[a*1+0];  //这里的1代表8x16点阵每行有1列字节，0代表从第1列开始。
  167.             c=0;
  168.             for(d=0;d<8;d++)  //把一个字节调换顺序
  169.                 {
  170.                c=c>>1;
  171.            if((b&0x80)==0x80)
  172.                    {
  173.              c=c|0x80;
  174.            }
  175.                    b=b<<1;
  176.         }                 
  177.         p_ucResult[a*1+0]=c;   //注意，因为每一行只有一列，所以不用像16x16点阵那样把第1列跟第2列对调交换。
  178.      }
  179.          
  180. }



  184. /* 注释三：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  185. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
  186. * 第3个参数*ucArray是字模的数组。
  187. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  188. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  189. */
  190. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
  191. {
  192.    unsigned int j=0;
  193.    unsigned int i=0;
  194.    unsigned char ucTemp;
  195.    WriteCommand(0x34);  //关显示缓冲指令            
  196.    WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  197.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  198.    {
  199.        WriteCommand(y+j+0x80);        //垂直地址
  200.        WriteCommand(x+0x80);          //水平地址
  201.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  202.        {
  203.          ucTemp=ucArray[j*x_amount+i];
  204.              if(ucFbFlag==1)  //反白显示
  205.                  {
  206.             ucTemp=~ucTemp;
  207.          }
  208.              LCDWriteData(ucTemp);
  209.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
  210.       }
  211.    }
  212.    WriteCommand(0x36); //开显示缓冲指令
  213. }


  216. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  217. {
  218.         unsigned char i;
  219.         for ( i = 0; i < 8; i++ )
  220.         {
  221.                 if ( (ucData << i) & 0x80 )
  222.                 {
  223.                         LCDSID_dr = 1;
  224.                 }
  225.                 else
  226.                 {
  227.                         LCDSID_dr = 0;
  228.                 }
  229.                 LCDCLK_dr = 0;
  230.                 LCDCLK_dr = 1;
  231.         }
  232. }

  234. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  235. {
  236.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
  237.         SendByteToLcd( ucWData & 0xf0 );
  238.         SendByteToLcd( (ucWData << 4) & 0xf0);
  239. }


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

  245.         LCDCS_dr = 0;
  246.         LCDCS_dr = 1;
  247.         SPIWrite(ucCommand, 0);
  248.         delay_short(90);
  249. }

  251. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
  252. {
  253.         LCDCS_dr = 0;
  254.         LCDCS_dr = 1;
  255.         SPIWrite(ucData, 1);
  256. }

  258. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
  259. {
  260.         LCDRST_dr = 1;  //复位
  261.         LCDRST_dr = 0;
  262.         LCDRST_dr = 1;
  263. }



  267. void delay_short(unsigned int uiDelayShort) //延时函数
  268. {
  269.    unsigned int i;  
  270.    for(i=0;i<uiDelayShort;i++)
  271.    {
  272.      ;  
  273.    }
  274. }
复制代码


总结陈词：
    细心的网友一定会发现，这种12864液晶屏普遍有个毛病，在坐标轴x,y方向上不能完全做到以一个点阵为单位进行随心所欲的显示，比如横向的至少是一个字节8个点阵为单位，而第1,2行跟第3,4行又做不到无缝对接显示，假如我要把汉字一半显示在第2行一半显示在第3行，行不行？当然可以。但是需要我们编写额外的算法程序。这种算法程序是怎样编写的？欲知详情，请听下回分解-----在液晶屏中让字体可以跨区域无缝对接显示的算法程序。

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

乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

95#
 楼主| 发表于 2014-10-16 15:05:10 | 显示全部楼层
第七十四节：在液晶屏中让字体可以跨区域无缝对接显示的算法程序。
开场白：
细心的网友会发现，这种12864液晶屏在显示自造字库时普遍有个毛病，在坐标轴x方向上是以每16个点阵为一个单位的，如果显示两个8x16字符”V”和”5”，虽然它们的x坐标轴是相邻的，但是实际显示的效果是中间隔了8个点阵。另外，这种12864液晶屏是由上半屏和下半屏组成的，软件上的坐标体系并没有做到跟物理的坐标体系一致，需要转换的。如果我们想把一个整体字符的一半显示在上半屏，另一半显示在下半屏，那怎么办？
这一节就要教给大家这个算法程序：
为了实现跨区域无缝显示，就先在某个区域显示一块画布，我们只要在这块画布数组中插入字模数组，就可以达到跨区域无缝显示的目的。
具体内容，请看源代码讲解。

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

（2）实现功能：开机上电后，看到液晶屏所有的点阵都显示。正中间露出一小方块空白的32x16点阵画布，从左到右分别显示“V5”两个字符。这两个字符是紧紧挨在一起的，中间并没有8个点阵的空格，同时这两个字符的上半部分显示在上半屏，下半部分显示在下半屏。实现了真正的跨区域无缝对接显示。
（3）源代码讲解如下：
  1. #include "REG52.H"

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

  8. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  9. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  10. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  11. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  12. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  13. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
  14. 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);//把字模插入画布.
  15. 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); //显示任意点阵函数
  16. void delay_short(unsigned int uiDelayshort); //延时

  18. code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 每一行只要1个字节，共16行 */
  19. {
  20. 0x00,
  21. 0x00,
  22. 0x00,
  23. 0xE7,
  24. 0x42,
  25. 0x42,
  26. 0x44,
  27. 0x24,
  28. 0x24,
  29. 0x28,
  30. 0x28,
  31. 0x18,
  32. 0x10,
  33. 0x10,
  34. 0x00,
  35. 0x00,
  36. };

  38. code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 每一行只要1个字节，共16行 */
  39. {
  40. 0x00,
  41. 0x00,
  42. 0x00,
  43. 0x7E,
  44. 0x40,
  45. 0x40,
  46. 0x40,
  47. 0x58,
  48. 0x64,
  49. 0x02,
  50. 0x02,
  51. 0x42,
  52. 0x44,
  53. 0x38,
  54. 0x00,
  55. 0x00,
  56. };


  59. /* 注释一：
  60. * 为了实现跨区域无缝显示，就先在某个区域显示一块画布，我们只要在这块画布数组中插入字模数组，
  61. * 就可以达到跨区域无缝显示的目的。根据上几节的介绍，12864液晶屏由上下两半屏组成，以下这块画布
  62. * 显示在上半屏和下半屏之间。横向4个字节，纵向16行。其中上半屏显示8行，下半屏显示8行。注意，这个数组
  63. * 不带code关键字，是全局变量，这样可读可写。画布的横向x坐标范围是0至3，因为画布的横向只要4个字节。
  64. * 画布的纵向y坐标范围是0至15，因为画布的纵向只有16行。
  65. */
  66. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
  67. {
  68. 0x00,0x00,0x00,0x00,  //上半屏
  69. 0x00,0x00,0x00,0x00,
  70. 0x00,0x00,0x00,0x00,
  71. 0x00,0x00,0x00,0x00,
  72. 0x00,0x00,0x00,0x00,
  73. 0x00,0x00,0x00,0x00,
  74. 0x00,0x00,0x00,0x00,
  75. 0x00,0x00,0x00,0x00,

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

  79. 0x00,0x00,0x00,0x00,  //下半屏
  80. 0x00,0x00,0x00,0x00,
  81. 0x00,0x00,0x00,0x00,
  82. 0x00,0x00,0x00,0x00,
  83. 0x00,0x00,0x00,0x00,
  84. 0x00,0x00,0x00,0x00,
  85. 0x00,0x00,0x00,0x00,
  86. 0x00,0x00,0x00,0x00,
  87. };



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

  95.         display_clear(0xff); // 清屏 全部显示空填充0x00   全部显示点阵用0xff

  97.         insert_buffer_to_canvas(0,0,Zf816_V,0,1,16);//把<V>的字模插入画布
  98.         insert_buffer_to_canvas(1,0,Zf816_5,0,1,16);//把<5>的字模插入画布

  100.         display_lattice(3,24,ucCanvasBuffer,0,4,8,0);   //显示上半屏的画布,最后的参数0是偏移量
  101.         display_lattice(11,0,ucCanvasBuffer,0,4,8,32);  //显示下半屏的画布,最后的参数32是偏移量


  104.         while(1)  
  105.         {
  106.              ;
  107.         }

  109. }



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

  116.     unsigned char x,y;
  117.     WriteCommand(0x34);  //关显示缓冲指令            
  118.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  119.     y=0;
  120.     while(y<32)  //y轴的范围0至31
  121.     {
  122.          WriteCommand(y+0x80);        //垂直地址
  123.          WriteCommand(0x80);          //水平地址
  124.          for(x=0;x<32;x++)  //256个横向点，有32个字节
  125.          {  
  126.             LCDWriteData(ucFillDate);
  127.          }
  128.          y++;
  129.     }
  130.     WriteCommand(0x36); //开显示缓冲指令

  132. }

  134. /* 注释二：
  135. * 把字模插入画布的函数.
  136. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  137. * 第1，2个参数x,y是在画布中的坐标体系。
  138. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
  139. * 第3个参数*ucArray是字模的数组。
  140. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  141. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  142. */
  143. 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)
  144. {
  145.    unsigned int j=0;
  146.    unsigned int i=0;
  147.    unsigned char ucTemp;
  148.    for(j=0;j<y_amount;j++)
  149.    {
  150.       for(i=0;i<x_amount;i++)
  151.       {
  152.                    ucTemp=ucArray[j*x_amount+i];
  153.                    if(ucFbFlag==0)
  154.                    {
  155.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
  156.                    }
  157.                    else
  158.                    {
  159.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
  160.                    }
  161.       }
  162.    }         

  164. }

  166. /* 注释三：
  167. * 显示任意点阵函数.
  168. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
  169. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  170. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
  171. * 第3个参数*ucArray是字模的数组。
  172. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  173. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  174. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
  175. */
  176. 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)
  177. {
  178.    unsigned int j=0;
  179.    unsigned int i=0;
  180.    unsigned char ucTemp;
  181.    WriteCommand(0x34);  //关显示缓冲指令            
  182.    WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  183.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  184.    {
  185.        WriteCommand(y+j+0x80);        //垂直地址
  186.        WriteCommand(x+0x80);          //水平地址
  187.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  188.        {
  189.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
  190.            if(ucFbFlag==1)  //反白显示
  191.            {
  192.                ucTemp=~ucTemp;
  193.            }
  194.            LCDWriteData(ucTemp);
  195.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
  196.       }
  197.    }
  198.    WriteCommand(0x36); //开显示缓冲指令
  199. }


  202. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  203. {
  204.         unsigned char i;
  205.         for ( i = 0; i < 8; i++ )
  206.         {
  207.                 if ( (ucData << i) & 0x80 )
  208.                 {
  209.                         LCDSID_dr = 1;
  210.                 }
  211.                 else
  212.                 {
  213.                         LCDSID_dr = 0;
  214.                 }
  215.                 LCDCLK_dr = 0;
  216.                 LCDCLK_dr = 1;
  217.         }
  218. }

  220. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  221. {
  222.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
  223.         SendByteToLcd( ucWData & 0xf0 );
  224.         SendByteToLcd( (ucWData << 4) & 0xf0);
  225. }


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

  231.         LCDCS_dr = 0;
  232.         LCDCS_dr = 1;
  233.         SPIWrite(ucCommand, 0);
  234.         delay_short(90);
  235. }

  237. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
  238. {
  239.         LCDCS_dr = 0;
  240.         LCDCS_dr = 1;
  241.         SPIWrite(ucData, 1);
  242. }

  244. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
  245. {
  246.         LCDRST_dr = 1;  //复位
  247.         LCDRST_dr = 0;
  248.         LCDRST_dr = 1;
  249. }



  253. void delay_short(unsigned int uiDelayShort) //延时函数
  254. {
  255.    unsigned int i;  
  256.    for(i=0;i<uiDelayShort;i++)
  257.    {
  258.      ;  
  259.    }
  260. }
复制代码

总结陈词：
    经过这一节的算法处理后，字符终于可以在x轴上紧紧挨着显示了。也就是把原来x坐标是16个点阵为一个单位，改成了以8个点阵为一个单位。如果要求以1个点阵为单位显示，那该怎么办？这个还真有点难度，因为横向的最小显示单位就是一个字节8个点，不过鸿哥在下一节中照样有办法实现这个功能。欲知详情，请听下回分解-----在12864液晶屏中让字体以1个点阵为单位进行移动显示的算法程序。
（未完待续，下节更精彩，不要走开哦）

乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

96#
 楼主| 发表于 2014-10-19 10:03:11 | 显示全部楼层
第七十五节：在12864液晶屏中让字体以1个点阵为单位进行移动显示的算法程序。

开场白：
    假设有一个固定的四方形透明窗口，在窗口里面放了一张画布，只要想办法让这个画布
往右边拖动，那么画布里面的内容就会跟着画布整体往右边移动，这个就是能以1个点阵为单位进行移动显示的本质。同理，这个画布有16行，每行有4个字节，我们只要把每行4个字节看作是一个首尾连接的二进制数据，把每一行的二进制数据每次整体往右边移动一位，就相当于移动一个点阵了。这一节就要把这个算法教给大家。

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

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

（2）实现功能：开机上电后，能看到正中间显示的两个字符“V5”整体以1个点阵为单位向右边慢慢移动。

（3）源代码讲解如下：
  1. #include "REG52.H"

  3. #define const_MoveTime 400  //每移动一位后的延时时间

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

  10. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  11. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  12. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  13. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  14. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  15. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
  16. 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);//把字模插入画布.
  17. 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); //显示任意点阵函数
  18. void delay_short(unsigned int uiDelayshort); //延时

  20. void move_service(void); //整体画布移动的应用程序
  21. void lcd_display_service(void); //应用层面的液晶屏显示程序
  22. void move_canvas_to_one_bit(void);  //把画布整体往右边移动一个点阵
  23. void clear_all_canvas(void);  //把画布全部清零

  25. void T0_time(void);  //定时中断函数

  27. code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 每一行只要1个字节，共16行 */
  28. {
  29. 0x00,
  30. 0x00,
  31. 0x00,
  32. 0xE7,
  33. 0x42,
  34. 0x42,
  35. 0x44,
  36. 0x24,
  37. 0x24,
  38. 0x28,
  39. 0x28,
  40. 0x18,
  41. 0x10,
  42. 0x10,
  43. 0x00,
  44. 0x00,
  45. };

  47. code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 每一行只要1个字节，共16行 */
  48. {
  49. 0x00,
  50. 0x00,
  51. 0x00,
  52. 0x7E,
  53. 0x40,
  54. 0x40,
  55. 0x40,
  56. 0x58,
  57. 0x64,
  58. 0x02,
  59. 0x02,
  60. 0x42,
  61. 0x44,
  62. 0x38,
  63. 0x00,
  64. 0x00,
  65. };


  68. /* 注释一：
  69. * 为了实现跨区域无缝显示，就先在某个区域显示一块画布，我们只要在这块画布数组中插入字模数组，
  70. * 就可以达到跨区域无缝显示的目的。根据上几节的介绍，12864液晶屏由上下两半屏组成，以下这块画布
  71. * 显示在上半屏和下半屏之间。横向4个字节，纵向16行。其中上半屏显示8行，下半屏显示8行。注意，这个数组
  72. * 不带code关键字，是全局变量，这样可读可写。画布的横向x坐标范围是0至3，因为画布的横向只要4个字节。
  73. * 画布的纵向y坐标范围是0至15，因为画布的纵向只有16行。
  74. */
  75. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
  76. {
  77. 0x00,0x00,0x00,0x00,  //上半屏
  78. 0x00,0x00,0x00,0x00,
  79. 0x00,0x00,0x00,0x00,
  80. 0x00,0x00,0x00,0x00,
  81. 0x00,0x00,0x00,0x00,
  82. 0x00,0x00,0x00,0x00,
  83. 0x00,0x00,0x00,0x00,
  84. 0x00,0x00,0x00,0x00,

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

  88. 0x00,0x00,0x00,0x00,  //下半屏
  89. 0x00,0x00,0x00,0x00,
  90. 0x00,0x00,0x00,0x00,
  91. 0x00,0x00,0x00,0x00,
  92. 0x00,0x00,0x00,0x00,
  93. 0x00,0x00,0x00,0x00,
  94. 0x00,0x00,0x00,0x00,
  95. 0x00,0x00,0x00,0x00,
  96. };

  98. unsigned char ucDisplayUpdate=1;  //更新显示变量
  99. unsigned char ucMoveStepReset=0;  //这个变量是为了方便外部程序初始化应用程序内部后缀为step的步骤变量

  101. unsigned char ucMoveTimeStart=0; //定时器的开关标志  也相当于原子锁或互斥量的功能
  102. unsigned int uiMoveTime=0;  //定时器累计时间

  104. void main()
  105.   {

  107.         LCDInit(); //初始化12864 内部包含液晶模块的复位
  108.         display_clear(0xff); // 清屏 全部显示空填充0x00   全部显示点阵用0xff


  111.         TMOD=0x01;  //设置定时器0为工作方式1
  112.         TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  113.         TL0=0x2f;
  114.         EA=1;     //开总中断
  115.         ET0=1;    //允许定时中断
  116.         TR0=1;    //启动定时中断


  119.         while(1)  
  120.         {
  121.            move_service(); //整体画布移动的应用程序
  122.            lcd_display_service(); //应用层面的液晶屏显示程序
  123.         }

  125. }



  129. void move_service(void) //整体画布移动的应用程序
  130. {
  131.    static unsigned char ucMoveStep=0; //运行步骤。前面加关键字static表示上电后这个变量只初始化一次，以后每次进出函数此变量不会重新初始化，保存之前的更改数值不变。
  132.    static unsigned char ucMoveCnt=0; //统计当前已经往左边移动了多少位。关键字static表示此变量上电后只初始化一次，不会每次进入函数都初始化。

  134.    if(ucMoveStepReset==1)  //运行步骤的复位标志，此段代码结构方便外部程序初始化函数内部的步骤变量ucMoveStep
  135.    {
  136.       ucMoveStepReset=0; //及时把复位标志清零。避免一直处于复位的状态、

  138.           ucMoveStep=0; //运行步骤变量被外部程序通过复位标志初始化。
  139.    }

  141.    switch(ucMoveStep)
  142.    {
  143.       case 0:
  144.                clear_all_canvas();  //把画布全部清零
  145.            insert_buffer_to_canvas(0,0,Zf816_V,0,1,16);//把<V>的字模插入画布
  146.            insert_buffer_to_canvas(1,0,Zf816_5,0,1,16);//把<5>的字模插入画布
  147.            ucDisplayUpdate=1; //更新液晶屏显示
  148.                   
  149.                    uiMoveTime=0;  //定时器清零
  150.                    ucMoveTimeStart=1; //开定时器     也相当于原子锁或互斥量的功能
  151.                    ucMoveCnt=0; //统计当前已经往左边移动了多少位
  152.                    ucMoveStep=1; //切换到下一个运行步骤

  154.                break;

  156.       case 1:
  157.                if(uiMoveTime>const_MoveTime)  //延时一定的时间后
  158.                    {
  159.                               ucMoveTimeStart=0; //关定时器    也相当于原子锁或互斥量的功能
  160.                        uiMoveTime=0;  //定时器清零

  162.                    if(ucMoveCnt<16)
  163.                        {
  164.                           ucMoveCnt++;
  165.                   move_canvas_to_one_bit(); //把画布整体往左边移动一个点阵
  166.                   ucDisplayUpdate=1; //更新液晶屏显示
  167.                                   ucMoveTimeStart=1; //开定时器   也相当于原子锁或互斥量的功能

  169.                        }
  170.                        else
  171.                        {
  172.                                   ucMoveStep=0; //移动了16个点阵后，返回上一个运行步骤，把字模重新插入画布
  173.                        }



  177.            }
  178.                break;
  179.    }

  181. }


  184. void lcd_display_service(void) //应用层面的液晶屏显示程序
  185. {
  186.     if(ucDisplayUpdate==1)  //需要更新显示
  187.     {
  188.        ucDisplayUpdate=0;  //及时把标志清零，避免一直处于不断更新的状态。


  191.        display_lattice(3,24,ucCanvasBuffer,0,4,8,0);   //显示上半屏的画布,最后的参数0是偏移量
  192.        display_lattice(11,0,ucCanvasBuffer,0,4,8,32);  //显示下半屏的画布,最后的参数32是偏移量
  193.     }
  194. }

  196. /* 注释二：
  197. * 假设有一个固定的四方形透明窗口，在窗口里面放了一张画布，只要想办法让这个画布
  198. * 往右边拖动，那么画布里面的内容就会跟着画布整体往右边移动，这个就是能以1个点阵为单位进行移动显示的本质。
  199. * 同理，这个画布有16行，每行有4个字节，我们只要把每行4个字节看作是一个首尾连接的二进制数据，
  200. * 把每一行的二进制数据每次整体往右边移动一位，就相当于移动一个点阵了。
  201. */

  203. void move_canvas_to_one_bit(void)  //把画布整体往右边移动一个点阵
  204. {
  205.    unsigned int j=0;
  206.    unsigned int i=0;
  207.    unsigned char ucBitH;  //临时保存一个字节中的最高位
  208.    unsigned char ucBitL;  //临时保存一个字节中的最低位

  210.    for(j=0;j<16;j++)  //这里的16表示画布有16行
  211.    {
  212.       ucBitH=0;   
  213.           ucBitL=0;   
  214.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
  215.       {
  216.                   if((ucCanvasBuffer[j*4+i]&0x01)==0x01)  //临时保存一个字节中的最低位
  217.                   {
  218.                      ucBitL=1;
  219.                   }
  220.                   else
  221.                   {
  222.                      ucBitL=0;
  223.                   }
  224.                   ucCanvasBuffer[j*4+i]=ucCanvasBuffer[j*4+i]>>1;  //一行中的一个字节右移一位

  226.                   if(ucBitH==1)   //原来左边相邻的字节最低位移动到了当前字节的最高位
  227.                   {
  228.              ucCanvasBuffer[j*4+i]=ucCanvasBuffer[j*4+i]|0x80; //把最高位补上
  229.                   }
  230.           ucBitH=ucBitL;  //把当前的最低位赋值给最高位，为下一个相邻字节做准备。
  231.       }
  232.    }         

  234. }


  237. void clear_all_canvas(void)  //把画布全部清零
  238. {
  239.    unsigned int j=0;
  240.    unsigned int i=0;

  242.    for(j=0;j<16;j++)  //这里的16表示画布有16行
  243.    {
  244.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
  245.       {
  246.                   ucCanvasBuffer[j*4+i]=0x00;
  247.       }
  248.    }         

  250. }


  253. void T0_time(void) interrupt 1  //定时中断函数
  254. {
  255.   TF0=0;  //清除中断标志
  256.   TR0=0; //关中断

  258.   if(ucMoveTimeStart==1) //已经开了定时器  也相当于原子锁或互斥量的功能
  259.   {
  260.       uiMoveTime++; //定时器累加计时开始
  261.   }

  263.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  264.   TL0=0x2f;
  265.   TR0=1;  //开中断
  266. }



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

  273.     unsigned char x,y;
  274.     WriteCommand(0x34);  //关显示缓冲指令            
  275.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  276.     y=0;
  277.     while(y<32)  //y轴的范围0至31
  278.     {
  279.          WriteCommand(y+0x80);        //垂直地址
  280.          WriteCommand(0x80);          //水平地址
  281.          for(x=0;x<32;x++)  //256个横向点，有32个字节
  282.          {  
  283.             LCDWriteData(ucFillDate);
  284.          }
  285.          y++;
  286.     }
  287.     WriteCommand(0x36); //开显示缓冲指令

  289. }

  291. /* 注释三：
  292. * 把字模插入画布的函数.
  293. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  294. * 第1，2个参数x,y是在画布中的坐标体系。
  295. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
  296. * 第3个参数*ucArray是字模的数组。
  297. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  298. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  299. */
  300. 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)
  301. {
  302.    unsigned int j=0;
  303.    unsigned int i=0;
  304.    unsigned char ucTemp;
  305.    for(j=0;j<y_amount;j++)
  306.    {
  307.       for(i=0;i<x_amount;i++)
  308.       {
  309.                    ucTemp=ucArray[j*x_amount+i];
  310.                    if(ucFbFlag==0)
  311.                    {
  312.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
  313.                    }
  314.                    else
  315.                    {
  316.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
  317.                    }
  318.       }
  319.    }         

  321. }

  323. /* 注释四：
  324. * 显示任意点阵函数.
  325. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
  326. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  327. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
  328. * 第3个参数*ucArray是字模的数组。
  329. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  330. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  331. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
  332. */
  333. 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)
  334. {
  335.    unsigned int j=0;
  336.    unsigned int i=0;
  337.    unsigned char ucTemp;

  339. //注意，要把以下两行指令屏蔽，否则屏幕在更新显示时会整屏闪动
  340. //  WriteCommand(0x34);  //关显示缓冲指令            
  341. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  342.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  343.    {
  344.        WriteCommand(y+j+0x80);        //垂直地址
  345.        WriteCommand(x+0x80);          //水平地址
  346.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  347.        {
  348.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
  349.            if(ucFbFlag==1)  //反白显示
  350.            {
  351.                ucTemp=~ucTemp;
  352.            }
  353.            LCDWriteData(ucTemp);
  354.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
  355.       }
  356.    }
  357.    WriteCommand(0x36); //开显示缓冲指令
  358. }




  363. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  364. {
  365.         unsigned char i;
  366.         for ( i = 0; i < 8; i++ )
  367.         {
  368.                 if ( (ucData << i) & 0x80 )
  369.                 {
  370.                         LCDSID_dr = 1;
  371.                 }
  372.                 else
  373.                 {
  374.                         LCDSID_dr = 0;
  375.                 }
  376.                 LCDCLK_dr = 0;
  377.                 LCDCLK_dr = 1;
  378.         }
  379. }

  381. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  382. {
  383.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
  384.         SendByteToLcd( ucWData & 0xf0 );
  385.         SendByteToLcd( (ucWData << 4) & 0xf0);
  386. }


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

  392.         LCDCS_dr = 0;
  393.         LCDCS_dr = 1;
  394.         SPIWrite(ucCommand, 0);
  395.         delay_short(90);
  396. }

  398. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
  399. {
  400.         LCDCS_dr = 0;
  401.         LCDCS_dr = 1;
  402.         SPIWrite(ucData, 1);
  403. }

  405. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
  406. {
  407.         LCDRST_dr = 1;  //复位
  408.         LCDRST_dr = 0;
  409.         LCDRST_dr = 1;
  410. }



  414. void delay_short(unsigned int uiDelayShort) //延时函数
  415. {
  416.    unsigned int i;  
  417.    for(i=0;i<uiDelayShort;i++)
  418.    {
  419.      ;  
  420.    }
  421. }
复制代码

总结陈词：
从下一节开始讲大家关注已久的液晶屏菜单程序。欲知详情，请听下回分解-----在1个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

（未完待续，下节更精彩，不要走开哦）
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

97#
 楼主| 发表于 2014-10-23 11:31:33 | 显示全部楼层
第七十六节：如何把一个任意数值的变量显示在液晶屏上。

开场白：
本来这一节打算开始讲液晶屏的菜单程序，但是我担心跳跃太大，恐怕很多初学者跟不上，所以多插入这一节讲讲后面菜单程序中经常用到的基本功能，如何把一个任意数值的变量显示在液晶屏上。我们需要做一个变量转换成字模的函数，以后只要调用这个转换函数就可以了。这一节就要把这个转换函数教给大家。

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

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

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

（3）源代码讲解如下：
  1. #include "REG52.H"

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

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


  21. void initial_myself();   
  22. void initial_peripheral();


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

  28. code unsigned char Zf816_0[]=
  29. {
  30. /*--  文字:  0  --*/
  31. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  32. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  33. };

  35. code unsigned char Zf816_1[]=
  36. {
  37. /*--  文字:  1  --*/
  38. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  39. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  40. };

  42. code unsigned char Zf816_2[]=
  43. {
  44. /*--  文字:  2  --*/
  45. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  46. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  47. };

  49. code unsigned char Zf816_3[]=
  50. {
  51. /*--  文字:  3  --*/
  52. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  53. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  54. };

  56. code unsigned char Zf816_4[]=
  57. {
  58. /*--  文字:  4  --*/
  59. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  60. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  61. };

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

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


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

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

  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. };


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


  106. /* 注释一：
  107. * 为了实现跨区域无缝显示，就先在某个区域显示一块画布，我们只要在这块画布数组中插入字模数组，
  108. * 就可以达到跨区域无缝显示的目的。根据上几节的介绍，12864液晶屏由上下两半屏组成，以下这块画布
  109. * 显示在上半屏和下半屏之间。横向4个字节，纵向16行。其中上半屏显示8行，下半屏显示8行。注意，这个数组
  110. * 不带code关键字，是全局变量，这样可读可写。画布的横向x坐标范围是0至3，因为画布的横向只要4个字节。
  111. * 画布的纵向y坐标范围是0至15，因为画布的纵向只有16行。
  112. */
  113. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
  114. {
  115. 0x00,0x00,0x00,0x00,  //上半屏
  116. 0x00,0x00,0x00,0x00,
  117. 0x00,0x00,0x00,0x00,
  118. 0x00,0x00,0x00,0x00,
  119. 0x00,0x00,0x00,0x00,
  120. 0x00,0x00,0x00,0x00,
  121. 0x00,0x00,0x00,0x00,
  122. 0x00,0x00,0x00,0x00,

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

  126. 0x00,0x00,0x00,0x00,  //下半屏
  127. 0x00,0x00,0x00,0x00,
  128. 0x00,0x00,0x00,0x00,
  129. 0x00,0x00,0x00,0x00,
  130. 0x00,0x00,0x00,0x00,
  131. 0x00,0x00,0x00,0x00,
  132. 0x00,0x00,0x00,0x00,
  133. 0x00,0x00,0x00,0x00,
  134. };


  137. unsigned char ucDisplayUpdate=1;  //更新显示变量


  140. /* 注释二：
  141. * 以下变量就是本程序的任意变量，网友可以自己更改它的大小来测试本程序，不要超过255.
  142. */
  143. unsigned char ucAnyNumber=218;  //任意变量默认初始化为218。


  146. void main()
  147.   {
  148.         initial_myself();      //第一区,上电后马上初始化
  149.         delay_long(100);       //一线，延时线。延时一段时间
  150.         initial_peripheral();  //第二区,上电后延时一段时间再初始化

  152.         while(1)   //第三区
  153.         {
  154.             lcd_display_service(); //应用层面的液晶屏显示程序
  155.         }

  157. }


  160. void initial_myself()  //第一区 上电后马上初始化
  161. {
  162.     ;
  163. }
  164. void initial_peripheral() //第二区 上电后延时一段时间再初始化
  165. {
  166.     LCDInit(); //初始化12864 内部包含液晶模块的复位
  167.     display_clear(0xff); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
  168. }



  172. /* 注释三：
  173. * 本程序的核心转换函数。
  174. * 是可以把一位任意数字变量的函数转换成对应的字模，由于字模是数组，所以返回的是指针，代表字模数组的首地址。
  175. */
  176. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
  177. {
  178.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小，分别调用不同的字库。

  180.         switch(ucBitNumber)  //根据ucBitNumber数值的大小，分别调用不同的字库。
  181.         {
  182.             case 0:
  183.              p_ucAnyNumber=Zf816_0;
  184.                      break;
  185.             case 1:
  186.              p_ucAnyNumber=Zf816_1;
  187.                      break;
  188.             case 2:
  189.              p_ucAnyNumber=Zf816_2;
  190.                      break;
  191.             case 3:
  192.              p_ucAnyNumber=Zf816_3;
  193.                      break;
  194.             case 4:
  195.              p_ucAnyNumber=Zf816_4;
  196.                      break;
  197.             case 5:
  198.              p_ucAnyNumber=Zf816_5;
  199.                      break;
  200.             case 6:
  201.              p_ucAnyNumber=Zf816_6;
  202.                      break;
  203.             case 7:
  204.              p_ucAnyNumber=Zf816_7;
  205.                      break;
  206.             case 8:
  207.              p_ucAnyNumber=Zf816_8;
  208.                      break;
  209.             case 9:
  210.              p_ucAnyNumber=Zf816_9;
  211.                      break;
  212.             case 10:
  213.              p_ucAnyNumber=Zf816_nc;
  214.                      break;
  215.                 default:   //如果上面的条件都不符合，那么默认指向空字模
  216.              p_ucAnyNumber=Zf816_nc;
  217.                      break;
  218.         }

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


  224. void lcd_display_service(void) //应用层面的液晶屏显示程序
  225. {
  226.     static unsigned char ucAnyNumber_1; //分解变量的个位
  227.     static unsigned char ucAnyNumber_10; //分解变量的十位
  228.     static unsigned char ucAnyNumber_100; //分解变量的百位

  230.     static unsigned char *p_ucAnyNumber_1; //经过数字转换成字模后，分解变量的个位字模首地址
  231.     static unsigned char *p_ucAnyNumber_10; //经过数字转换成字模后，分解变量的十位字模首地址
  232.     static unsigned char *p_ucAnyNumber_100; //经过数字转换成字模后，分解变量的百位字模首地址

  234.     if(ucDisplayUpdate==1)  //需要更新显示
  235.     {
  236.        ucDisplayUpdate=0;  //及时把标志清零，避免一直处于不断更新的状态。

  238.            if(ucAnyNumber>=100) //有3位数以上
  239.            {
  240.            ucAnyNumber_100=ucAnyNumber/100; //百位
  241.        }
  242.            else //否则显示空
  243.            {
  244.                ucAnyNumber_100=10;  //在下面的转换函数中，代码10表示空字模
  245.            }

  247.            if(ucAnyNumber>=10) //有2位数以上
  248.            {
  249.            ucAnyNumber_10=ucAnyNumber%100/10;  //十位
  250.        }
  251.            else //否则显示空
  252.            {
  253.                ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  254.            }

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

  258.            p_ucAnyNumber_100=number_to_matrix(ucAnyNumber_100); //把数字转换成字模首地址      
  259.            p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  260.            p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址

  262.        clear_all_canvas();  //把画布全部清零
  263.        insert_buffer_to_canvas(0,0,p_ucAnyNumber_100,0,1,16);//把百位的字模插入画布
  264.        insert_buffer_to_canvas(1,0,p_ucAnyNumber_10,0,1,16);//把十的字模插入画布
  265.        insert_buffer_to_canvas(2,0,p_ucAnyNumber_1,0,1,16);//把个的字模插入画布

  267.        display_lattice(3,24,ucCanvasBuffer,0,4,8,0);   //显示上半屏的画布,最后的参数0是偏移量
  268.        display_lattice(11,0,ucCanvasBuffer,0,4,8,32);  //显示下半屏的画布,最后的参数32是偏移量
  269.     }
  270. }



  274. void clear_all_canvas(void)  //把画布全部清零
  275. {
  276.    unsigned int j=0;
  277.    unsigned int i=0;

  279.    for(j=0;j<16;j++)  //这里的16表示画布有16行
  280.    {
  281.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
  282.       {
  283.                   ucCanvasBuffer[j*4+i]=0x00;
  284.       }
  285.    }         

  287. }





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

  296.     unsigned char x,y;
  297.     WriteCommand(0x34);  //关显示缓冲指令            
  298.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  299.     y=0;
  300.     while(y<32)  //y轴的范围0至31
  301.     {
  302.          WriteCommand(y+0x80);        //垂直地址
  303.          WriteCommand(0x80);          //水平地址
  304.          for(x=0;x<32;x++)  //256个横向点，有32个字节
  305.          {  
  306.             LCDWriteData(ucFillDate);
  307.          }
  308.          y++;
  309.     }
  310.     WriteCommand(0x36); //开显示缓冲指令

  312. }

  314. /* 注释四：
  315. * 把字模插入画布的函数.
  316. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  317. * 第1，2个参数x,y是在画布中的坐标体系。
  318. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
  319. * 第3个参数*ucArray是字模的数组。
  320. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  321. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  322. */
  323. 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)
  324. {
  325.    unsigned int j=0;
  326.    unsigned int i=0;
  327.    unsigned char ucTemp;
  328.    for(j=0;j<y_amount;j++)
  329.    {
  330.       for(i=0;i<x_amount;i++)
  331.       {
  332.                    ucTemp=ucArray[j*x_amount+i];
  333.                    if(ucFbFlag==0)
  334.                    {
  335.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
  336.                    }
  337.                    else
  338.                    {
  339.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
  340.                    }
  341.       }
  342.    }         

  344. }

  346. /* 注释五：
  347. * 显示任意点阵函数.
  348. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
  349. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  350. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
  351. * 第3个参数*ucArray是字模的数组。
  352. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  353. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  354. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
  355. */
  356. 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)
  357. {
  358.    unsigned int j=0;
  359.    unsigned int i=0;
  360.    unsigned char ucTemp;

  362. //注意，要把以下两行指令屏蔽，否则屏幕在更新显示时会整屏闪动
  363. //  WriteCommand(0x34);  //关显示缓冲指令            
  364. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  365.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  366.    {
  367.        WriteCommand(y+j+0x80);        //垂直地址
  368.        WriteCommand(x+0x80);          //水平地址
  369.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  370.        {
  371.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
  372.            if(ucFbFlag==1)  //反白显示
  373.            {
  374.                ucTemp=~ucTemp;
  375.            }
  376.            LCDWriteData(ucTemp);
  377.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
  378.       }
  379.    }
  380.    WriteCommand(0x36); //开显示缓冲指令
  381. }




  386. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  387. {
  388.         unsigned char i;
  389.         for ( i = 0; i < 8; i++ )
  390.         {
  391.                 if ( (ucData << i) & 0x80 )
  392.                 {
  393.                         LCDSID_dr = 1;
  394.                 }
  395.                 else
  396.                 {
  397.                         LCDSID_dr = 0;
  398.                 }
  399.                 LCDCLK_dr = 0;
  400.                 LCDCLK_dr = 1;
  401.         }
  402. }

  404. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  405. {
  406.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
  407.         SendByteToLcd( ucWData & 0xf0 );
  408.         SendByteToLcd( (ucWData << 4) & 0xf0);
  409. }


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

  415.         LCDCS_dr = 0;
  416.         LCDCS_dr = 1;
  417.         SPIWrite(ucCommand, 0);
  418.         delay_short(90);
  419. }

  421. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
  422. {
  423.         LCDCS_dr = 0;
  424.         LCDCS_dr = 1;
  425.         SPIWrite(ucData, 1);
  426. }

  428. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
  429. {
  430.         LCDRST_dr = 1;  //复位
  431.         LCDRST_dr = 0;
  432.         LCDRST_dr = 1;
  433. }



  437. void delay_short(unsigned int uiDelayShort) //延时函数
  438. {
  439.    unsigned int i;  
  440.    for(i=0;i<uiDelayShort;i++)
  441.    {
  442.      ;  
  443.    }
  444. }


  447. void delay_long(unsigned int uiDelayLong)
  448. {
  449.    unsigned int i;
  450.    unsigned int j;
  451.    for(i=0;i<uiDelayLong;i++)
  452.    {
  453.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  454.           {
  455.              ; //一个分号相当于执行一条空语句
  456.           }
  457.    }
  458. }
复制代码

总结陈词：
有了这一节的基础，我们继续循序渐进，下一节将会讲到液晶屏的菜单程序。欲知详情，请听下回分解-----在1个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

（未完待续，下节更精彩，不要走开哦）
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

98#
 楼主| 发表于 2014-10-26 09:21:20 | 显示全部楼层
本帖最后由 jianhong_wu 于 2014-10-28 17:25 编辑

第七十七节：在1个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

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

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

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

（2）实现功能：
     通过按键设置4个不同的参数。
    有1个窗口。每个窗口显示4个参数。每个参数的范围是从0到99。
   有4个按键：
（a）        一个是设置参数S13按键，按下此按键，液晶屏的第一行会出现反显的光标，表示进入设置参数模式，再次按下此按键，反显光标会消失，表示退出设置参数模式。
（b）        一个是移动光标S9按键，在进入设置参数的模式下，依次按下此按键，液晶屏上的光标会从上往下移动，表示选中不同的参数。
（c）        一个是减数S5按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐减小。
（d）        一个是加数S1按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐加大。

（3）源代码讲解如下：
  1. #include "REG52.H"


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

  6. #define const_key_time1  20    //按键去抖动延时的时间
  7. #define const_key_time2  20    //按键去抖动延时的时间
  8. #define const_key_time3  20    //按键去抖动延时的时间
  9. #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键

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

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

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

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

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

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


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

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

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

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

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

  77. code unsigned char Zf816_4[]=
  78. {
  79. /*--  文字:  4  --*/
  80. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  81. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  82. };

  84. code unsigned char Zf816_5[]=
  85. {
  86. /*--  文字:  5  --*/
  87. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  88. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  89. };

  91. code unsigned char Zf816_6[]=
  92. {
  93. /*--  文字:  6  --*/
  94. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  95. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  96. };


  99. code unsigned char Zf816_7[]=
  100. {
  101. /*--  文字:  7  --*/
  102. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  103. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  104. };

  106. code unsigned char Zf816_8[]=
  107. {
  108. /*--  文字:  8  --*/
  109. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  110. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  111. };

  113. code unsigned char Zf816_9[]=
  114. {
  115. /*--  文字:  9  --*/
  116. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  117. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
  118. };


  121. code unsigned char Zf816_nc[]=  //空字模
  122. {
  123. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  124. };

  126. code unsigned char Zf816_mao_hao[]=  //冒号
  127. {
  128. /*--  文字:  :  --*/
  129. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  130. 0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
  131. };

  133. code unsigned char Hz1616_yi[]=
  134. {
  135. /*--  文字:  一  --*/
  136. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  137. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
  138. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  139. };

  141. code unsigned char Hz1616_er[]=
  142. {
  143. /*--  文字:  二  --*/
  144. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  145. 0x00,0x00,0x00,0x10,0x3F,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  146. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,
  147. };

  149. code unsigned char Hz1616_san[]=
  150. {
  151. /*--  文字:  三  --*/
  152. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  153. 0x00,0x00,0x00,0x00,0x7F,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0xF8,
  154. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0xFE,0x00,0x00,0x00,0x00,
  155. };

  157. code unsigned char Hz1616_si[]=
  158. {
  159. /*--  文字:  四  --*/
  160. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  161. 0x00,0x00,0x7F,0xFC,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,
  162. 0x48,0x84,0x48,0x7C,0x50,0x04,0x60,0x04,0x40,0x04,0x7F,0xFC,0x40,0x04,0x00,0x00,
  163. };

  165. code unsigned char Hz1616_chuang[]=
  166. {
  167. /*--  文字:  窗  --*/
  168. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  169. 0x01,0x00,0x00,0x80,0x7F,0xFE,0x40,0x22,0x09,0x18,0x12,0x06,0x7F,0xF8,0x11,0x08,
  170. 0x13,0xE8,0x14,0x48,0x1A,0x88,0x11,0x08,0x12,0x88,0x14,0x08,0x1F,0xF8,0x10,0x08,
  171. };

  173. code unsigned char Hz1616_kou[]=
  174. {
  175. /*--  文字:  口  --*/
  176. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  177. 0x00,0x00,0x00,0x00,0x3F,0xF8,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,
  178. 0x20,0x08,0x20,0x08,0x20,0x08,0x3F,0xF8,0x20,0x08,0x20,0x08,0x00,0x00,0x00,0x00,
  179. };

  181. code unsigned char Hz1616_hang[]=
  182. {
  183. /*--  文字:  行  --*/
  184. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  185. 0x08,0x00,0x1C,0x00,0x31,0xFC,0x40,0x00,0x88,0x00,0x0C,0x00,0x1B,0xFE,0x30,0x20,
  186. 0x50,0x20,0x90,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0xA0,0x10,0x40,
  187. };


  190. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
  191. {
  192. 0x00,0x00,0x00,0x00,  //上半屏
  193. 0x00,0x00,0x00,0x00,
  194. 0x00,0x00,0x00,0x00,
  195. 0x00,0x00,0x00,0x00,
  196. 0x00,0x00,0x00,0x00,
  197. 0x00,0x00,0x00,0x00,
  198. 0x00,0x00,0x00,0x00,
  199. 0x00,0x00,0x00,0x00,

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

  203. 0x00,0x00,0x00,0x00,  //下半屏
  204. 0x00,0x00,0x00,0x00,
  205. 0x00,0x00,0x00,0x00,
  206. 0x00,0x00,0x00,0x00,
  207. 0x00,0x00,0x00,0x00,
  208. 0x00,0x00,0x00,0x00,
  209. 0x00,0x00,0x00,0x00,
  210. 0x00,0x00,0x00,0x00,
  211. };



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


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


  223. unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量      1代表更新显示，响应函数内部会清零
  224. unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量  1代表更新显示，响应函数内部会清零
  225. unsigned char ucWd1Part2Update=0; //窗口1的第2行局部更新显示变量  1代表更新显示，响应函数内部会清零
  226. unsigned char ucWd1Part3Update=0; //窗口1的第3行局部更新显示变量  1代表更新显示，响应函数内部会清零
  227. unsigned char ucWd1Part4Update=0; //窗口1的第4行局部更新显示变量  1代表更新显示，响应函数内部会清零



  231. unsigned char ucData_1_1=8;  //第1个窗口第1行的被设置数据
  232. unsigned char ucData_1_2=9;  //第1个窗口第2行的被设置数据
  233. unsigned char ucData_1_3=10;  //第1个窗口第3行的被设置数据
  234. unsigned char ucData_1_4=11;  //第1个窗口第4行的被设置数据

  236. void main()
  237.   {
  238.         initial_myself();      //第一区,上电后马上初始化
  239.         delay_long(100);       //一线，延时线。延时一段时间
  240.         initial_peripheral();  //第二区,上电后延时一段时间再初始化

  242.         while(1)   //第三区
  243.         {
  244.                     key_service(); //按键服务的应用程序
  245.             lcd_display_service(); //应用层面的液晶屏显示程序
  246.         }

  248. }


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

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

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


  271.     EA=1;     //开总中断
  272.     ET0=1;    //允许定时中断
  273.     TR0=1;    //启动定时中断

  275. }


  278. void T0_time() interrupt 1
  279. {
  280.   TF0=0;  //清除中断标志
  281.   TR0=0; //关中断

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

  285.   if(uiVoiceCnt!=0)
  286.   {
  287.      uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
  288.          beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
  289.   }
  290.   else
  291.   {
  292.      ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
  293.            beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  294.   }


  297.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  298.   TL0=0x2f;
  299.   TR0=1;  //开中断
  300. }



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


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

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

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

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

  320.   if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  321.   {
  322.      ucKeyLock1=0; //按键自锁标志清零
  323.      uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  324.   }
  325.   else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
  326.   {
  327.      uiKeyTimeCnt1++; //累加定时中断次数
  328.      if(uiKeyTimeCnt1>const_key_time1)
  329.      {
  330.         uiKeyTimeCnt1=0;
  331.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
  332.         ucKeySec=1;    //触发1号键
  333.      }
  334.   }

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

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

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

  384. }


  387. void key_service(void) //按键服务的应用程序
  388. {
  389.   switch(ucKeySec) //按键服务状态切换
  390.   {
  391.     case 1:// 加按键 对应朱兆祺学习板的S1键
  392.           switch(ucWd)  //在不同的窗口下，设置不同的参数
  393.           {
  394.               case 1:
  395.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
  396.                    {
  397.                           case 0:   //无光标显示的状态 此处的case 0可以省略

  399.                                 break;
  400.                           case 1:   //设置第1行参数
  401.                                 ucData_1_1++;
  402.                                                                 if(ucData_1_1>99)
  403.                                                                 {
  404.                                                                    ucData_1_1=99;
  405.                                                                 }
  406.                                 ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
  407.                                 break;
  408.                           case 2:   //设置第2行参数
  409.                                 ucData_1_2++;
  410.                                                                 if(ucData_1_2>99)
  411.                                                                 {
  412.                                                                    ucData_1_2=99;
  413.                                                                 }
  414.                                 ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
  415.                                 break;
  416.                           case 3:   //设置第3行参数
  417.                                 ucData_1_3++;
  418.                                                                 if(ucData_1_3>99)
  419.                                                                 {
  420.                                                                    ucData_1_3=99;
  421.                                                                 }
  422.                                 ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
  423.                                 break;
  424.                           case 4:   //设置第4行参数
  425.                                 ucData_1_4++;
  426.                                                                 if(ucData_1_4>99)
  427.                                                                 {
  428.                                                                    ucData_1_4=99;
  429.                                                                 }
  430.                                 ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
  431.                                 break;


  434.                    }
  435.                    break;
  436.          
  437.           }     
  438.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  439.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
  440.           break;   
  441.    
  442.     case 2:// 减按键 对应朱兆祺学习板的S5键
  443.           switch(ucWd)  //在不同的窗口下，设置不同的参数
  444.           {
  445.               case 1:
  446.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
  447.                    {
  448.                           case 0:   //无光标显示的状态 此处的case 0可以省略

  450.                                 break;
  451.                           case 1:   //设置第1行参数
  452.                                 ucData_1_1--;
  453.                                                                 if(ucData_1_1>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  454.                                                                 {
  455.                                                                    ucData_1_1=0;
  456.                                                                 }
  457.                                 ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
  458.                                 break;
  459.                           case 2:   //设置第2行参数
  460.                                 ucData_1_2--;
  461.                                                                 if(ucData_1_2>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  462.                                                                 {
  463.                                                                    ucData_1_2=0;
  464.                                                                 }
  465.                                 ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
  466.                                 break;
  467.                           case 3:   //设置第3行参数
  468.                                 ucData_1_3--;
  469.                                                                 if(ucData_1_3>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  470.                                                                 {
  471.                                                                    ucData_1_3=0;
  472.                                                                 }
  473.                                 ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
  474.                                 break;
  475.                           case 4:   //设置第4行参数
  476.                                 ucData_1_4--;
  477.                                                                 if(ucData_1_4>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  478.                                                                 {
  479.                                                                    ucData_1_4=0;
  480.                                                                 }
  481.                                 ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
  482.                                 break;


  485.                    }
  486.                    break;
  487.          
  488.           }     
  489.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  490.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
  491.           break;  

  493.     case 3:// 切换"光标"移动按键 对应朱兆祺学习板的S9键
  494.           switch(ucWd)  //在不同的窗口下，设置不同的参数
  495.           {
  496.               case 1:
  497.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
  498.                    {
  499.                           case 0:   //无光标显示的状态 此处的case 0可以省略

  501.                                 break;
  502.                           case 1:   //设置第1行参数
  503.                                 ucPart=2; //光标切换到下一行
  504.                                 ucWd1Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  505.                                 ucWd1Part2Update=1; //更新显示下一行，    目的是更新反显光标的状态
  506.                                 break;
  507.                           case 2:   //设置第2行参数
  508.                                 ucPart=3; //光标切换到下一行
  509.                                 ucWd1Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  510.                                 ucWd1Part3Update=1; //更新显示下一行，    目的是更新反显光标的状态
  511.                                 break;
  512.                           case 3:   //设置第3行参数
  513.                                 ucPart=4; //光标切换到下一行
  514.                                 ucWd1Part3Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  515.                                 ucWd1Part4Update=1; //更新显示下一行，    目的是更新反显光标的状态
  516.                                 break;
  517.                           case 4:   //设置第4行参数
  518.                                 ucPart=1; //光标返回到最上面第一行
  519.                                 ucWd1Part4Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  520.                                 ucWd1Part1Update=1; //更新显示最上面第一行，    目的是更新反显光标的状态
  521.                                 break;


  524.                    }
  525.                    break;
  526.          
  527.           }         
  528.         
  529.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  530.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
  531.           break;      
  532.    
  533.     case 4: // 设置按键  对应朱兆祺学习板的S13键，按一次进入设置状态，出现反显光标。再按一次推出设置状态，消除反显光标
  534.           switch(ucWd)  //在不同的窗口下，设置不同的参数
  535.           {
  536.               case 1:
  537.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
  538.                    {

  540.                           case 0:   //无光标显示的状态
  541.                                 ucPart=1; //光标显示第一行，进入设置模式
  542.                                 ucWd1Part1Update=1; //更新显示
  543.                                 break;
  544.                           case 1:   //设置第1行参数
  545.                                 ucPart=0; //无光标显示，退出设置模式
  546.                                 ucWd1Part1Update=1; //更新显示
  547.                                 break;
  548.                           case 2:   //设置第2行参数
  549.                                 ucPart=0; //无光标显示，退出设置模式
  550.                                 ucWd1Part2Update=1; //更新显示
  551.                                 break;
  552.                           case 3:   //设置第3行参数
  553.                                 ucPart=0; //无光标显示，退出设置模式
  554.                                 ucWd1Part3Update=1; //更新显示
  555.                                 break;
  556.                           case 4:   //设置第4行参数
  557.                                 ucPart=0; //无光标显示，退出设置模式
  558.                                 ucWd1Part4Update=1; //更新显示
  559.                                 break;


  562.                    }
  563.                    break;
  564.          
  565.           }   

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

  571.   }               
  572. }


  575. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
  576. {
  577.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小，分别调用不同的字库。

  579.         switch(ucBitNumber)  //根据ucBitNumber数值的大小，分别调用不同的字库。
  580.         {
  581.             case 0:
  582.              p_ucAnyNumber=Zf816_0;
  583.                      break;
  584.             case 1:
  585.              p_ucAnyNumber=Zf816_1;
  586.                      break;
  587.             case 2:
  588.              p_ucAnyNumber=Zf816_2;
  589.                      break;
  590.             case 3:
  591.              p_ucAnyNumber=Zf816_3;
  592.                      break;
  593.             case 4:
  594.              p_ucAnyNumber=Zf816_4;
  595.                      break;
  596.             case 5:
  597.              p_ucAnyNumber=Zf816_5;
  598.                      break;
  599.             case 6:
  600.              p_ucAnyNumber=Zf816_6;
  601.                      break;
  602.             case 7:
  603.              p_ucAnyNumber=Zf816_7;
  604.                      break;
  605.             case 8:
  606.              p_ucAnyNumber=Zf816_8;
  607.                      break;
  608.             case 9:
  609.              p_ucAnyNumber=Zf816_9;
  610.                      break;
  611.             case 10:
  612.              p_ucAnyNumber=Zf816_nc;
  613.                      break;
  614.                 default:   //如果上面的条件都不符合，那么默认指向空字模
  615.              p_ucAnyNumber=Zf816_nc;
  616.                      break;
  617.         }

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



  624. void lcd_display_service(void) //应用层面的液晶屏显示程序
  625. {
  626.     unsigned char ucAnyNumber_1; //分解变量的个位
  627.     unsigned char ucAnyNumber_10; //分解变量的十位


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

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

  635.     switch(ucWd)  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  636.     {
  637.         case 1:   //显示窗口1的数据

  639. /* 注释二：
  640. * 把每一个窗口的内容分为两种类型，一种类型是那些不用经常刷新显示的内容，只有在切换窗口的时候
  641. * 才需要更新，这种内容放在整屏更新显示的括号里，比如清屏操作等内容。另外一种是那些经常需要
  642. * 刷新显示的内容，这种内容放在局部更新显示的括号里。
  643. */
  644.                       if(ucWd1Update==1)  //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
  645.                           {
  646.                              ucWd1Update=0;  //及时清零，避免一直更新

  648.                  ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
  649.                  ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
  650.                  ucWd1Part3Update=1; //激活窗口1的第3行局部更新显示变量，这里在前面数码管显示框架上有所改进
  651.                  ucWd1Part4Update=1; //激活窗口1的第4行局部更新显示变量，这里在前面数码管显示框架上有所改进

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

  657.                  display_lattice(0,0,Hz1616_yi,0,2,16,0);    //一窗口一行，这些内容不用经常更新，只有在切换窗口的时候才更新显示
  658.                  display_lattice(1,0,Hz1616_chuang,0,2,16,0);   
  659.                  display_lattice(2,0,Hz1616_kou,0,2,16,0);   
  660.                  display_lattice(3,0,Hz1616_yi,0,2,16,0);
  661.                  display_lattice(4,0,Hz1616_hang,0,2,16,0);

  663.                  display_lattice(0,16,Hz1616_yi,0,2,16,0);    //一窗口二行
  664.                  display_lattice(1,16,Hz1616_chuang,0,2,16,0);   
  665.                  display_lattice(2,16,Hz1616_kou,0,2,16,0);   
  666.                  display_lattice(3,16,Hz1616_er,0,2,16,0);
  667.                  display_lattice(4,16,Hz1616_hang,0,2,16,0);

  669.                  display_lattice(8,0,Hz1616_yi,0,2,16,0);    //一窗口三行
  670.                  display_lattice(9,0,Hz1616_chuang,0,2,16,0);   
  671.                  display_lattice(10,0,Hz1616_kou,0,2,16,0);   
  672.                  display_lattice(11,0,Hz1616_san,0,2,16,0);
  673.                  display_lattice(12,0,Hz1616_hang,0,2,16,0);

  675.                  display_lattice(8,16,Hz1616_yi,0,2,16,0);    //一窗口四行
  676.                  display_lattice(9,16,Hz1616_chuang,0,2,16,0);   
  677.                  display_lattice(10,16,Hz1616_kou,0,2,16,0);   
  678.                  display_lattice(11,16,Hz1616_si,0,2,16,0);
  679.                  display_lattice(12,16,Hz1616_hang,0,2,16,0);

  681.                           }

  683. /* 注释三：
  684. * 注意！我前面讲数码管显示的时候有一句话讲错了，我那时说<局部更新应该写在整屏更新之前>,这是不对的。
  685. * 按照现在的显示程序框架<即整屏显示更新括号里包含了所有局部变量的激活>，应该是<整屏更新应该写在局部更新之前>
  686. * 这样才对。
  687. */
  688.                           if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
  689.                           {
  690.                              ucWd1Part1Update=0; //及时清零，避免一直更新

  692.                      if(ucPart==1) //被选中
  693.                                  {
  694.                                     ucCursorFlag=1; //反显 显示
  695.                                  }
  696.                      else //没被选中
  697.                                  {
  698.                                     ucCursorFlag=0; //正常 显示
  699.                                  }

  701.                  if(ucData_1_1>=10) //有2位数以上
  702.                  {
  703.                     ucAnyNumber_10=ucData_1_1/10;  //十位
  704.                  }
  705.                  else //否则显示空
  706.                  {
  707.                     ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  708.                  }

  710.                  ucAnyNumber_1=ucData_1_1%10/1;  //个位

  712.    
  713.                  p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  714.                  p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

  722.                           
  723.                           }

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

  729.                      if(ucPart==2) //被选中
  730.                                  {
  731.                                     ucCursorFlag=1; //反显 显示
  732.                                  }
  733.                      else //没被选中
  734.                                  {
  735.                                     ucCursorFlag=0; //正常 显示
  736.                                  }

  738.                  if(ucData_1_2>=10) //有2位数以上
  739.                  {
  740.                     ucAnyNumber_10=ucData_1_2/10;  //十位
  741.                  }
  742.                  else //否则显示空
  743.                  {
  744.                     ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  745.                  }

  747.                  ucAnyNumber_1=ucData_1_2%10/1;  //个位

  749.    
  750.                  p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  751.                  p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

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

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

  774.                  if(ucData_1_3>=10) //有2位数以上
  775.                  {
  776.                     ucAnyNumber_10=ucData_1_3/10;  //十位
  777.                  }
  778.                  else //否则显示空
  779.                  {
  780.                     ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  781.                  }

  783.                  ucAnyNumber_1=ucData_1_3%10/1;  //个位

  785.    
  786.                  p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  787.                  p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

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

  801.                      if(ucPart==4) //被选中
  802.                                  {
  803.                                     ucCursorFlag=1; //反显 显示
  804.                                  }
  805.                      else //没被选中
  806.                                  {
  807.                                     ucCursorFlag=0; //正常 显示
  808.                                  }

  810.                  if(ucData_1_4>=10) //有2位数以上
  811.                  {
  812.                     ucAnyNumber_10=ucData_1_4/10;  //十位
  813.                  }
  814.                  else //否则显示空
  815.                  {
  816.                     ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  817.                  }

  819.                  ucAnyNumber_1=ucData_1_4%10/1;  //个位

  821.    
  822.                  p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  823.                  p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

  832.               break;
  833.         //本程序只有1个窗口，所以只有一个case 1，如果要增加窗口，就直接增加 case 2, case 3...        
  834.     }


  837. }



  841. void clear_all_canvas(void)  //把画布全部清零
  842. {
  843.    unsigned int j=0;
  844.    unsigned int i=0;

  846.    for(j=0;j<16;j++)  //这里的16表示画布有16行
  847.    {
  848.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
  849.       {
  850.                   ucCanvasBuffer[j*4+i]=0x00;
  851.       }
  852.    }         

  854. }





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

  863.     unsigned char x,y;
  864.     WriteCommand(0x34);  //关显示缓冲指令            
  865.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  866.     y=0;
  867.     while(y<32)  //y轴的范围0至31
  868.     {
  869.          WriteCommand(y+0x80);        //垂直地址
  870.          WriteCommand(0x80);          //水平地址
  871.          for(x=0;x<32;x++)  //256个横向点，有32个字节
  872.          {  
  873.             LCDWriteData(ucFillDate);
  874.          }
  875.          y++;
  876.     }
  877.     WriteCommand(0x36); //开显示缓冲指令

  879. }

  881. /* 注释四：
  882. * 把字模插入画布的函数.
  883. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  884. * 第1，2个参数x,y是在画布中的坐标体系。
  885. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
  886. * 第3个参数*ucArray是字模的数组。
  887. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  888. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  889. */
  890. 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)
  891. {
  892.    unsigned int j=0;
  893.    unsigned int i=0;
  894.    unsigned char ucTemp;
  895.    for(j=0;j<y_amount;j++)
  896.    {
  897.       for(i=0;i<x_amount;i++)
  898.       {
  899.                    ucTemp=ucArray[j*x_amount+i];
  900.                    if(ucFbFlag==0)
  901.                    {
  902.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
  903.                    }
  904.                    else
  905.                    {
  906.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
  907.                    }
  908.       }
  909.    }         

  911. }

  913. /* 注释五：
  914. * 显示任意点阵函数.
  915. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
  916. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  917. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
  918. * 第3个参数*ucArray是字模的数组。
  919. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  920. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  921. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
  922. */
  923. 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)
  924. {
  925.    unsigned int j=0;
  926.    unsigned int i=0;
  927.    unsigned char ucTemp;

  929. //注意，要把以下两行指令屏蔽，否则屏幕在更新显示时会整屏闪动
  930. //  WriteCommand(0x34);  //关显示缓冲指令            
  931. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  932.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  933.    {
  934.        WriteCommand(y+j+0x80);        //垂直地址
  935.        WriteCommand(x+0x80);          //水平地址
  936.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  937.        {
  938.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
  939.            if(ucFbFlag==1)  //反白显示
  940.            {
  941.                ucTemp=~ucTemp;
  942.            }
  943.            LCDWriteData(ucTemp);
  944.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
  945.       }
  946.    }
  947.    WriteCommand(0x36); //开显示缓冲指令
  948. }




  953. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  954. {
  955.         unsigned char i;
  956.         for ( i = 0; i < 8; i++ )
  957.         {
  958.                 if ( (ucData << i) & 0x80 )
  959.                 {
  960.                         LCDSID_dr = 1;
  961.                 }
  962.                 else
  963.                 {
  964.                         LCDSID_dr = 0;
  965.                 }
  966.                 LCDCLK_dr = 0;
  967.                 LCDCLK_dr = 1;
  968.         }
  969. }

  971. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  972. {
  973.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
  974.         SendByteToLcd( ucWData & 0xf0 );
  975.         SendByteToLcd( (ucWData << 4) & 0xf0);
  976. }


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

  982.         LCDCS_dr = 0;
  983.         LCDCS_dr = 1;
  984.         SPIWrite(ucCommand, 0);
  985.         delay_short(90);
  986. }

  988. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
  989. {
  990.         LCDCS_dr = 0;
  991.         LCDCS_dr = 1;
  992.         SPIWrite(ucData, 1);
  993. }

  995. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
  996. {
  997.         LCDRST_dr = 1;  //复位
  998.         LCDRST_dr = 0;
  999.         LCDRST_dr = 1;
  1000. }



  1004. void delay_short(unsigned int uiDelayShort) //延时函数
  1005. {
  1006.    unsigned int i;  
  1007.    for(i=0;i<uiDelayShort;i++)
  1008.    {
  1009.      ;  
  1010.    }
  1011. }


  1014. void delay_long(unsigned int uiDelayLong)
  1015. {
  1016.    unsigned int i;
  1017.    unsigned int j;
  1018.    for(i=0;i<uiDelayLong;i++)
  1019.    {
  1020.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  1021.           {
  1022.              ; //一个分号相当于执行一条空语句
  1023.           }
  1024.    }
  1025. }
复制代码

总结陈词：
这一节讲了在一个窗口里设置不同的参数，如果有几个窗口的情况下，该如何编程？欲知详情，请听下回分解-----在多个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

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

乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

99#
 楼主| 发表于 2014-10-28 14:33:31 | 显示全部楼层
本帖最后由 jianhong_wu 于 2014-10-28 17:32 编辑

第七十八节：在多个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

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

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

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

（2）实现功能：
     通过按键设置8个不同的参数。
    有2个窗口。每个窗口显示4个参数。每个参数的范围是从0到99。
    有4个按键：
（a）          一个是设置参数S13按键，按下此按键，液晶屏的第1个窗口第一行会出现反显的光标，表示进入设置参数模式，再次按下此按键，反显光标会消失，并且强行切换到第1个窗口，表示退出设置参数模式。
（b）         一个是移动光标S9按键，在进入设置参数的模式下，依次按下此按键，液晶屏上的光标会从上往下移动，表示选中不同的参数。当移动到每个窗口最下边那一行时，再按下此按键会进行切换窗口的操作。
（c）          一个是减数S5按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐减小。
（d）         一个是加数S1按键，在设置参数模式下，依次按下此按键，被选中的参数会逐渐加大。
（3）源代码讲解如下：
  1. #include "REG52.H"

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

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

  11. #define const_key_time1  20    //按键去抖动延时的时间
  12. #define const_key_time2  20    //按键去抖动延时的时间
  13. #define const_key_time3  20    //按键去抖动延时的时间
  14. #define const_key_time4  20    //按键去抖动延时的时间


  17. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  18. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  19. sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
  20. sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键

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

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

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

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

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

  47. void initial_myself();   
  48. void initial_peripheral();


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

  54. void wd1(void);//窗口1显示的内容
  55. void wd2(void);//窗口2显示的内容

  57. code unsigned char Zf816_0[]=
  58. {
  59. /*--  文字:  0  --*/
  60. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  61. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  62. };

  64. code unsigned char Zf816_1[]=
  65. {
  66. /*--  文字:  1  --*/
  67. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  68. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  69. };

  71. code unsigned char Zf816_2[]=
  72. {
  73. /*--  文字:  2  --*/
  74. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  75. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  76. };

  78. code unsigned char Zf816_3[]=
  79. {
  80. /*--  文字:  3  --*/
  81. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  82. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  83. };

  85. code unsigned char Zf816_4[]=
  86. {
  87. /*--  文字:  4  --*/
  88. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  89. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  90. };

  92. code unsigned char Zf816_5[]=
  93. {
  94. /*--  文字:  5  --*/
  95. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  96. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  97. };

  99. code unsigned char Zf816_6[]=
  100. {
  101. /*--  文字:  6  --*/
  102. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  103. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  104. };


  107. code unsigned char Zf816_7[]=
  108. {
  109. /*--  文字:  7  --*/
  110. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  111. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  112. };

  114. code unsigned char Zf816_8[]=
  115. {
  116. /*--  文字:  8  --*/
  117. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  118. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  119. };

  121. code unsigned char Zf816_9[]=
  122. {
  123. /*--  文字:  9  --*/
  124. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  125. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
  126. };


  129. code unsigned char Zf816_nc[]=  //空字模
  130. {
  131. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  132. };

  134. code unsigned char Zf816_mao_hao[]=  //冒号
  135. {
  136. /*--  文字:  :  --*/
  137. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
  138. 0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
  139. };

  141. code unsigned char Hz1616_yi[]=
  142. {
  143. /*--  文字:  一  --*/
  144. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  145. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
  146. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  147. };

  149. code unsigned char Hz1616_er[]=
  150. {
  151. /*--  文字:  二  --*/
  152. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  153. 0x00,0x00,0x00,0x10,0x3F,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  154. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,
  155. };

  157. code unsigned char Hz1616_san[]=
  158. {
  159. /*--  文字:  三  --*/
  160. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  161. 0x00,0x00,0x00,0x00,0x7F,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0xF8,
  162. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0xFE,0x00,0x00,0x00,0x00,
  163. };

  165. code unsigned char Hz1616_si[]=
  166. {
  167. /*--  文字:  四  --*/
  168. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  169. 0x00,0x00,0x7F,0xFC,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,0x44,0x84,
  170. 0x48,0x84,0x48,0x7C,0x50,0x04,0x60,0x04,0x40,0x04,0x7F,0xFC,0x40,0x04,0x00,0x00,
  171. };

  173. code unsigned char Hz1616_chuang[]=
  174. {
  175. /*--  文字:  窗  --*/
  176. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  177. 0x01,0x00,0x00,0x80,0x7F,0xFE,0x40,0x22,0x09,0x18,0x12,0x06,0x7F,0xF8,0x11,0x08,
  178. 0x13,0xE8,0x14,0x48,0x1A,0x88,0x11,0x08,0x12,0x88,0x14,0x08,0x1F,0xF8,0x10,0x08,
  179. };

  181. code unsigned char Hz1616_kou[]=
  182. {
  183. /*--  文字:  口  --*/
  184. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  185. 0x00,0x00,0x00,0x00,0x3F,0xF8,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,0x20,0x08,
  186. 0x20,0x08,0x20,0x08,0x20,0x08,0x3F,0xF8,0x20,0x08,0x20,0x08,0x00,0x00,0x00,0x00,
  187. };

  189. code unsigned char Hz1616_hang[]=
  190. {
  191. /*--  文字:  行  --*/
  192. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  193. 0x08,0x00,0x1C,0x00,0x31,0xFC,0x40,0x00,0x88,0x00,0x0C,0x00,0x1B,0xFE,0x30,0x20,
  194. 0x50,0x20,0x90,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0xA0,0x10,0x40,
  195. };


  198. unsigned char ucCanvasBuffer[]= //画布显示数组。注意，这里没有code关键字，是全局变量。初始化全部填充0x00
  199. {
  200. 0x00,0x00,0x00,0x00,  //上半屏
  201. 0x00,0x00,0x00,0x00,
  202. 0x00,0x00,0x00,0x00,
  203. 0x00,0x00,0x00,0x00,
  204. 0x00,0x00,0x00,0x00,
  205. 0x00,0x00,0x00,0x00,
  206. 0x00,0x00,0x00,0x00,
  207. 0x00,0x00,0x00,0x00,

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

  211. 0x00,0x00,0x00,0x00,  //下半屏
  212. 0x00,0x00,0x00,0x00,
  213. 0x00,0x00,0x00,0x00,
  214. 0x00,0x00,0x00,0x00,
  215. 0x00,0x00,0x00,0x00,
  216. 0x00,0x00,0x00,0x00,
  217. 0x00,0x00,0x00,0x00,
  218. 0x00,0x00,0x00,0x00,
  219. };



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


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


  231. unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量      1代表更新显示，响应函数内部会清零
  232. unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量  1代表更新显示，响应函数内部会清零
  233. unsigned char ucWd1Part2Update=0; //窗口1的第2行局部更新显示变量  1代表更新显示，响应函数内部会清零
  234. unsigned char ucWd1Part3Update=0; //窗口1的第3行局部更新显示变量  1代表更新显示，响应函数内部会清零
  235. unsigned char ucWd1Part4Update=0; //窗口1的第4行局部更新显示变量  1代表更新显示，响应函数内部会清零

  237. unsigned char ucWd2Update=0; //窗口2的整屏更新显示变量      1代表更新显示，响应函数内部会清零
  238. unsigned char ucWd2Part1Update=0; //窗口2的第1行局部更新显示变量  1代表更新显示，响应函数内部会清零
  239. unsigned char ucWd2Part2Update=0; //窗口2的第2行局部更新显示变量  1代表更新显示，响应函数内部会清零
  240. unsigned char ucWd2Part3Update=0; //窗口2的第3行局部更新显示变量  1代表更新显示，响应函数内部会清零
  241. unsigned char ucWd2Part4Update=0; //窗口2的第4行局部更新显示变量  1代表更新显示，响应函数内部会清零

  243. unsigned char ucData_1_1=8;  //第1个窗口第1行的被设置数据
  244. unsigned char ucData_1_2=9;  //第1个窗口第2行的被设置数据
  245. unsigned char ucData_1_3=10;  //第1个窗口第3行的被设置数据
  246. unsigned char ucData_1_4=11;  //第1个窗口第4行的被设置数据

  248. unsigned char ucData_2_1=12;  //第2个窗口第1行的被设置数据
  249. unsigned char ucData_2_2=13;  //第2个窗口第2行的被设置数据
  250. unsigned char ucData_2_3=14;  //第2个窗口第3行的被设置数据
  251. unsigned char ucData_2_4=15;  //第2个窗口第4行的被设置数据

  253. void main()
  254.   {
  255.         initial_myself();      //第一区,上电后马上初始化
  256.         delay_long(100);       //一线，延时线。延时一段时间
  257.         initial_peripheral();  //第二区,上电后延时一段时间再初始化

  259.         while(1)   //第三区
  260.         {
  261.                     key_service(); //按键服务的应用程序
  262.             lcd_display_service(); //应用层面的液晶屏显示程序
  263.         }

  265. }


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

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

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


  288.     EA=1;     //开总中断
  289.     ET0=1;    //允许定时中断
  290.     TR0=1;    //启动定时中断

  292. }


  295. void T0_time() interrupt 1
  296. {
  297.   TF0=0;  //清除中断标志
  298.   TR0=0; //关中断

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

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


  314.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  315.   TL0=0x2f;
  316.   TR0=1;  //开中断
  317. }



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


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

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

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

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

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

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

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

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

  401. }


  404. void key_service(void) //按键服务的应用程序
  405. {
  406.   switch(ucKeySec) //按键服务状态切换
  407.   {
  408.     case 1:// 加按键 对应朱兆祺学习板的S1键
  409.           switch(ucWd)  //在不同的窗口下，设置不同的参数
  410.           {
  411.               case 1:  //窗口1
  412.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
  413.                    {
  414.                           case 0:   //无光标显示的状态 此处的case 0可以省略

  416.                                 break;
  417.                           case 1:   //设置第1行参数
  418.                                 ucData_1_1++;
  419.                                 if(ucData_1_1>99)
  420.                                 {
  421.                                    ucData_1_1=99;
  422.                                 }
  423.                                 ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
  424.                                 break;
  425.                           case 2:   //设置第2行参数
  426.                                 ucData_1_2++;
  427.                                 if(ucData_1_2>99)
  428.                                 {
  429.                                    ucData_1_2=99;
  430.                                 }
  431.                                 ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
  432.                                 break;
  433.                           case 3:   //设置第3行参数
  434.                                 ucData_1_3++;
  435.                                 if(ucData_1_3>99)
  436.                                 {
  437.                                    ucData_1_3=99;
  438.                                 }
  439.                                 ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
  440.                                 break;
  441.                           case 4:   //设置第4行参数
  442.                                 ucData_1_4++;
  443.                                 if(ucData_1_4>99)
  444.                                 {
  445.                                    ucData_1_4=99;
  446.                                 }
  447.                                 ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
  448.                                 break;


  451.                    }
  452.                    break;
  453.               case 2:  //窗口2
  454.                    switch(ucPart)  //在窗口2下，根据不同的局部变量来设置不同的参数
  455.                    {
  456.                           case 0:   //无光标显示的状态 此处的case 0可以省略

  458.                                 break;
  459.                           case 1:   //设置第1行参数
  460.                                 ucData_2_1++;
  461.                                 if(ucData_2_1>99)
  462.                                 {
  463.                                    ucData_2_1=99;
  464.                                 }
  465.                                 ucWd2Part1Update=1; //1代表更新显示，响应函数内部会清零
  466.                                 break;
  467.                           case 2:   //设置第2行参数
  468.                                 ucData_2_2++;
  469.                                 if(ucData_2_2>99)
  470.                                 {
  471.                                    ucData_2_2=99;
  472.                                 }
  473.                                 ucWd2Part2Update=1; //1代表更新显示，响应函数内部会清零
  474.                                 break;
  475.                           case 3:   //设置第3行参数
  476.                                 ucData_2_3++;
  477.                                 if(ucData_2_3>99)
  478.                                 {
  479.                                    ucData_2_3=99;
  480.                                 }
  481.                                 ucWd2Part3Update=1; //1代表更新显示，响应函数内部会清零
  482.                                 break;
  483.                           case 4:   //设置第4行参数
  484.                                 ucData_2_4++;
  485.                                 if(ucData_2_4>99)
  486.                                 {
  487.                                    ucData_2_4=99;
  488.                                 }
  489.                                 ucWd2Part4Update=1; //1代表更新显示，响应函数内部会清零
  490.                                 break;


  493.                    }
  494.                    break;         
  495.           }     
  496.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  497.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
  498.           break;   
  499.    
  500.     case 2:// 减按键 对应朱兆祺学习板的S5键
  501.           switch(ucWd)  //在不同的窗口下，设置不同的参数
  502.           {
  503.               case 1:  //窗口1
  504.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
  505.                    {
  506.                           case 0:   //无光标显示的状态 此处的case 0可以省略

  508.                                 break;
  509.                           case 1:   //设置第1行参数
  510.                                 ucData_1_1--;
  511.                                 if(ucData_1_1>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  512.                                 {
  513.                                    ucData_1_1=0;
  514.                                 }
  515.                                 ucWd1Part1Update=1; //1代表更新显示，响应函数内部会清零
  516.                                 break;
  517.                           case 2:   //设置第2行参数
  518.                                 ucData_1_2--;
  519.                                 if(ucData_1_2>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  520.                                 {
  521.                                    ucData_1_2=0;
  522.                                 }
  523.                                 ucWd1Part2Update=1; //1代表更新显示，响应函数内部会清零
  524.                                 break;
  525.                           case 3:   //设置第3行参数
  526.                                 ucData_1_3--;
  527.                                 if(ucData_1_3>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  528.                                 {
  529.                                    ucData_1_3=0;
  530.                                 }
  531.                                 ucWd1Part3Update=1; //1代表更新显示，响应函数内部会清零
  532.                                 break;
  533.                           case 4:   //设置第4行参数
  534.                                 ucData_1_4--;
  535.                                 if(ucData_1_4>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  536.                                 {
  537.                                    ucData_1_4=0;
  538.                                 }
  539.                                 ucWd1Part4Update=1; //1代表更新显示，响应函数内部会清零
  540.                                 break;


  543.                    }
  544.                    break;
  545.               case 2:  //窗口2
  546.                    switch(ucPart)  //在窗口2下，根据不同的局部变量来设置不同的参数
  547.                    {
  548.                           case 0:   //无光标显示的状态 此处的case 0可以省略

  550.                                 break;
  551.                           case 1:   //设置第1行参数
  552.                                 ucData_2_1--;
  553.                                 if(ucData_2_1>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  554.                                 {
  555.                                    ucData_2_1=0;
  556.                                 }
  557.                                 ucWd2Part1Update=1; //1代表更新显示，响应函数内部会清零
  558.                                 break;
  559.                           case 2:   //设置第2行参数
  560.                                 ucData_2_2--;
  561.                                 if(ucData_2_2>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  562.                                 {
  563.                                    ucData_2_2=0;
  564.                                 }
  565.                                 ucWd2Part2Update=1; //1代表更新显示，响应函数内部会清零
  566.                                 break;
  567.                           case 3:   //设置第3行参数
  568.                                 ucData_2_3--;
  569.                                 if(ucData_2_3>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  570.                                 {
  571.                                    ucData_2_3=0;
  572.                                 }
  573.                                 ucWd2Part3Update=1; //1代表更新显示，响应函数内部会清零
  574.                                 break;
  575.                           case 4:   //设置第4行参数
  576.                                 ucData_2_4--;
  577.                                 if(ucData_2_4>99) //一直减到最后，单片机C语言编译器有一个特征，0减去1会溢出变成255(0xff)
  578.                                 {
  579.                                    ucData_2_4=0;
  580.                                 }
  581.                                 ucWd2Part4Update=1; //1代表更新显示，响应函数内部会清零
  582.                                 break;


  585.                    }
  586.                    break;         
  587.           }     
  588.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  589.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
  590.           break;  

  592.     case 3:// 切换"光标"移动按键 对应朱兆祺学习板的S9键
  593.           switch(ucWd)  //在不同的窗口下，设置不同的参数
  594.           {
  595.               case 1: //窗口1
  596.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
  597.                    {
  598.                           case 0:   //无光标显示的状态 此处的case 0可以省略

  600.                                 break;
  601.                           case 1:   //设置第1行参数
  602.                                 ucPart=2; //光标切换到下一行
  603.                                 ucWd1Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  604.                                 ucWd1Part2Update=1; //更新显示下一行，    目的是更新反显光标的状态
  605.                                 break;
  606.                           case 2:   //设置第2行参数
  607.                                 ucPart=3; //光标切换到下一行
  608.                                 ucWd1Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  609.                                 ucWd1Part3Update=1; //更新显示下一行，    目的是更新反显光标的状态
  610.                                 break;
  611.                           case 3:   //设置第3行参数
  612.                                 ucPart=4; //光标切换到下一行
  613.                                 ucWd1Part3Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  614.                                 ucWd1Part4Update=1; //更新显示下一行，    目的是更新反显光标的状态
  615.                                 break;
  616.                           case 4:   //设置第4行参数
  617.                                                         ucWd=2;  //切换到第2个窗口
  618.                                 ucPart=1; //光标返回到最上面第一行
  619.                                                                 ucWd2Update=1; //窗口2整屏更新
  620.                                 break;


  623.                    }
  624.                    break;
  625.               case 2: //窗口2
  626.                    switch(ucPart)  //在窗口2下，根据不同的局部变量来设置不同的参数
  627.                    {
  628.                           case 0:   //无光标显示的状态 此处的case 0可以省略

  630.                                 break;
  631.                           case 1:   //设置第1行参数
  632.                                 ucPart=2; //光标切换到下一行
  633.                                 ucWd2Part1Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  634.                                 ucWd2Part2Update=1; //更新显示下一行，    目的是更新反显光标的状态
  635.                                 break;
  636.                           case 2:   //设置第2行参数
  637.                                 ucPart=3; //光标切换到下一行
  638.                                 ucWd2Part2Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  639.                                 ucWd2Part3Update=1; //更新显示下一行，    目的是更新反显光标的状态
  640.                                 break;
  641.                           case 3:   //设置第3行参数
  642.                                 ucPart=4; //光标切换到下一行
  643.                                 ucWd2Part3Update=1; //更新显示原来那一行，目的是更新反显光标的状态
  644.                                 ucWd2Part4Update=1; //更新显示下一行，    目的是更新反显光标的状态
  645.                                 break;
  646.                           case 4:   //设置第4行参数
  647.                                                         ucWd=1;  //切换到第1个窗口
  648.                                 ucPart=1; //光标返回到最上面第一行
  649.                                                                 ucWd1Update=1; //窗口1整屏更新
  650.                                 break;


  653.                    }
  654.                    break;         
  655.           }         
  656.         
  657.           uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  658.           ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
  659.           break;      
  660.    
  661.     case 4: // 设置按键  对应朱兆祺学习板的S13键，按一次进入设置状态，出现反显光标。再按一次推出设置状态，消除反显光标,并且强行切换到第1个窗口
  662.           switch(ucWd)  //在不同的窗口下，设置不同的参数
  663.           {
  664.               case 1:  //窗口1
  665.                    switch(ucPart)  //在窗口1下，根据不同的局部变量来设置不同的参数
  666.                    {

  668.                           case 0:   //无光标显示的状态
  669.                                 ucPart=1; //光标显示第一行，进入设置模式
  670.                                 ucWd1Part1Update=1; //更新显示
  671.                                 break;
  672.                           case 1:   //设置第1行参数
  673.                                 ucPart=0; //无光标显示，退出设置模式
  674.                                 ucWd1Part1Update=1; //更新显示
  675.                                 break;
  676.                           case 2:   //设置第2行参数
  677.                                 ucPart=0; //无光标显示，退出设置模式
  678.                                 ucWd1Part2Update=1; //更新显示
  679.                                 break;
  680.                           case 3:   //设置第3行参数
  681.                                 ucPart=0; //无光标显示，退出设置模式
  682.                                 ucWd1Part3Update=1; //更新显示
  683.                                 break;
  684.                           case 4:   //设置第4行参数
  685.                                 ucPart=0; //无光标显示，退出设置模式
  686.                                 ucWd1Part4Update=1; //更新显示
  687.                                 break;


  690.                    }
  691.                    break;
  692.               case 2:  //窗口2
  693.                    switch(ucPart)  //在窗口2下，根据不同的局部变量来设置不同的参数
  694.                    {

  696.                           case 0:   //无光标显示的状态
  697.                                                         ucWd=1; //强行切换到第1个窗口
  698.                                 ucPart=1; //光标显示第一行，进入设置模式
  699.                                                                 ucWd1Update=1; //窗口1整屏更新
  700.                                 break;
  701.                           case 1:   //设置第1行参数
  702.                                                                   ucWd=1; //强行切换到第1个窗口
  703.                                 ucPart=0; //无光标显示，退出设置模式
  704.                                                                 ucWd1Update=1; //窗口1整屏更新
  705.                                 break;
  706.                           case 2:   //设置第2行参数
  707.                                                                   ucWd=1; //强行切换到第1个窗口
  708.                                 ucPart=0; //无光标显示，退出设置模式
  709.                                                                 ucWd1Update=1; //窗口1整屏更新
  710.                                 break;
  711.                           case 3:   //设置第3行参数
  712.                                                               ucWd=1; //强行切换到第1个窗口
  713.                                 ucPart=0; //无光标显示，退出设置模式
  714.                                                                 ucWd1Update=1; //窗口1整屏更新
  715.                                 break;
  716.                           case 4:   //设置第4行参数
  717.                                                                   ucWd=1; //强行切换到第1个窗口
  718.                                 ucPart=0; //无光标显示，退出设置模式
  719.                                                                 ucWd1Update=1; //窗口1整屏更新
  720.                                 break;


  723.                    }
  724.                    break;         
  725.           }   

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

  731.   }               
  732. }


  735. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
  736. {
  737.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小，分别调用不同的字库。

  739.         switch(ucBitNumber)  //根据ucBitNumber数值的大小，分别调用不同的字库。
  740.         {
  741.             case 0:
  742.              p_ucAnyNumber=Zf816_0;
  743.                      break;
  744.             case 1:
  745.              p_ucAnyNumber=Zf816_1;
  746.                      break;
  747.             case 2:
  748.              p_ucAnyNumber=Zf816_2;
  749.                      break;
  750.             case 3:
  751.              p_ucAnyNumber=Zf816_3;
  752.                      break;
  753.             case 4:
  754.              p_ucAnyNumber=Zf816_4;
  755.                      break;
  756.             case 5:
  757.              p_ucAnyNumber=Zf816_5;
  758.                      break;
  759.             case 6:
  760.              p_ucAnyNumber=Zf816_6;
  761.                      break;
  762.             case 7:
  763.              p_ucAnyNumber=Zf816_7;
  764.                      break;
  765.             case 8:
  766.              p_ucAnyNumber=Zf816_8;
  767.                      break;
  768.             case 9:
  769.              p_ucAnyNumber=Zf816_9;
  770.                      break;
  771.             case 10:
  772.              p_ucAnyNumber=Zf816_nc;
  773.                      break;
  774.                 default:   //如果上面的条件都不符合，那么默认指向空字模
  775.              p_ucAnyNumber=Zf816_nc;
  776.                      break;
  777.         }

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



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

  787.     switch(ucWd)  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  788.     {
  789.         case 1:  
  790.               wd1();  //窗口1显示的内容
  791.               break;
  792.         case 2:  
  793.               wd2();  //窗口2显示的内容
  794.               break;
  795.         //本程序只有2个窗口，所以只有一个case 1，如果要增加窗口，就直接增加 case 2, case 3...        
  796.     }

  798. }


  801. void wd1(void)  //窗口1显示的内容
  802. {
  803.     unsigned char ucAnyNumber_1; //分解变量的个位
  804.     unsigned char ucAnyNumber_10; //分解变量的十位


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

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

  812. /* 注释三：
  813. * 把每一个窗口的内容分为两种类型，一种类型是那些不用经常刷新显示的内容，只有在切换窗口的时候
  814. * 才需要更新，这种内容放在整屏更新显示的括号里，比如清屏操作等内容。另外一种是那些经常需要
  815. * 刷新显示的内容，这种内容放在局部更新显示的括号里。
  816. */
  817.     if(ucWd1Update==1)  //窗口1整屏更新，里面只放那些不用经常刷新显示的内容
  818.     {
  819.         ucWd1Update=0;  //及时清零，避免一直更新

  821.         ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
  822.         ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
  823.         ucWd1Part3Update=1; //激活窗口1的第3行局部更新显示变量，这里在前面数码管显示框架上有所改进
  824.         ucWd1Part4Update=1; //激活窗口1的第4行局部更新显示变量，这里在前面数码管显示框架上有所改进

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

  830.         display_lattice(0,0,Hz1616_yi,0,2,16,0);    //一窗口一行，这些内容不用经常更新，只有在切换窗口的时候才更新显示
  831.         display_lattice(1,0,Hz1616_chuang,0,2,16,0);   
  832.         display_lattice(2,0,Hz1616_kou,0,2,16,0);   
  833.         display_lattice(3,0,Hz1616_yi,0,2,16,0);
  834.         display_lattice(4,0,Hz1616_hang,0,2,16,0);

  836.         display_lattice(0,16,Hz1616_yi,0,2,16,0);    //一窗口二行
  837.         display_lattice(1,16,Hz1616_chuang,0,2,16,0);   
  838.         display_lattice(2,16,Hz1616_kou,0,2,16,0);   
  839.         display_lattice(3,16,Hz1616_er,0,2,16,0);
  840.         display_lattice(4,16,Hz1616_hang,0,2,16,0);

  842.         display_lattice(8,0,Hz1616_yi,0,2,16,0);    //一窗口三行
  843.         display_lattice(9,0,Hz1616_chuang,0,2,16,0);   
  844.         display_lattice(10,0,Hz1616_kou,0,2,16,0);   
  845.         display_lattice(11,0,Hz1616_san,0,2,16,0);
  846.         display_lattice(12,0,Hz1616_hang,0,2,16,0);

  848.         display_lattice(8,16,Hz1616_yi,0,2,16,0);    //一窗口四行
  849.         display_lattice(9,16,Hz1616_chuang,0,2,16,0);   
  850.         display_lattice(10,16,Hz1616_kou,0,2,16,0);   
  851.         display_lattice(11,16,Hz1616_si,0,2,16,0);
  852.         display_lattice(12,16,Hz1616_hang,0,2,16,0);

  854.     }

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

  865.         if(ucPart==1) //被选中
  866.         {
  867.              ucCursorFlag=1; //反显 显示
  868.         }
  869.         else //没被选中
  870.         {
  871.              ucCursorFlag=0; //正常 显示
  872.         }

  874.         if(ucData_1_1>=10) //有2位数以上
  875.         {
  876.              ucAnyNumber_10=ucData_1_1/10;  //十位
  877.         }
  878.         else //否则显示空
  879.         {
  880.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  881.         }

  883.         ucAnyNumber_1=ucData_1_1%10/1;  //个位

  885.    
  886.         p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  887.         p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

  895.                           
  896.     }

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

  902.          if(ucPart==2) //被选中
  903.          {
  904.              ucCursorFlag=1; //反显 显示
  905.          }
  906.          else //没被选中
  907.          {
  908.              ucCursorFlag=0; //正常 显示
  909.          }

  911.          if(ucData_1_2>=10) //有2位数以上
  912.          {
  913.              ucAnyNumber_10=ucData_1_2/10;  //十位
  914.          }
  915.          else //否则显示空
  916.          {
  917.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  918.          }

  920.          ucAnyNumber_1=ucData_1_2%10/1;  //个位

  922.    
  923.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  924.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

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

  938.          if(ucPart==3) //被选中
  939.          {
  940.              ucCursorFlag=1; //反显 显示
  941.          }
  942.          else //没被选中
  943.          {
  944.              ucCursorFlag=0; //正常 显示
  945.          }

  947.          if(ucData_1_3>=10) //有2位数以上
  948.          {
  949.              ucAnyNumber_10=ucData_1_3/10;  //十位
  950.          }
  951.          else //否则显示空
  952.          {
  953.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  954.          }

  956.          ucAnyNumber_1=ucData_1_3%10/1;  //个位

  958.    
  959.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  960.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

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

  974.          if(ucPart==4) //被选中
  975.          {
  976.              ucCursorFlag=1; //反显 显示
  977.          }
  978.          else //没被选中
  979.          {
  980.              ucCursorFlag=0; //正常 显示
  981.          }

  983.          if(ucData_1_4>=10) //有2位数以上
  984.          {
  985.              ucAnyNumber_10=ucData_1_4/10;  //十位
  986.          }
  987.          else //否则显示空
  988.          {
  989.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  990.          }

  992.          ucAnyNumber_1=ucData_1_4%10/1;  //个位

  994.    
  995.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  996.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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


  1006. }


  1009. void wd2(void)  //窗口2显示的内容
  1010. {
  1011.     unsigned char ucAnyNumber_1; //分解变量的个位
  1012.     unsigned char ucAnyNumber_10; //分解变量的十位


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

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

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

  1024.         ucWd2Part1Update=1; //激活窗口2的第1行局部更新显示变量，这里在前面数码管显示框架上有所改进
  1025.         ucWd2Part2Update=1; //激活窗口2的第2行局部更新显示变量，这里在前面数码管显示框架上有所改进
  1026.         ucWd2Part3Update=1; //激活窗口2的第3行局部更新显示变量，这里在前面数码管显示框架上有所改进
  1027.         ucWd2Part4Update=1; //激活窗口2的第4行局部更新显示变量，这里在前面数码管显示框架上有所改进

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

  1033.         display_lattice(0,0,Hz1616_er,0,2,16,0);    //二窗口一行，这些内容不用经常更新，只有在切换窗口的时候才更新显示
  1034.         display_lattice(1,0,Hz1616_chuang,0,2,16,0);   
  1035.         display_lattice(2,0,Hz1616_kou,0,2,16,0);   
  1036.         display_lattice(3,0,Hz1616_yi,0,2,16,0);
  1037.         display_lattice(4,0,Hz1616_hang,0,2,16,0);

  1039.         display_lattice(0,16,Hz1616_er,0,2,16,0);    //二窗口二行
  1040.         display_lattice(1,16,Hz1616_chuang,0,2,16,0);   
  1041.         display_lattice(2,16,Hz1616_kou,0,2,16,0);   
  1042.         display_lattice(3,16,Hz1616_er,0,2,16,0);
  1043.         display_lattice(4,16,Hz1616_hang,0,2,16,0);

  1045.         display_lattice(8,0,Hz1616_er,0,2,16,0);    //二窗口三行
  1046.         display_lattice(9,0,Hz1616_chuang,0,2,16,0);   
  1047.         display_lattice(10,0,Hz1616_kou,0,2,16,0);   
  1048.         display_lattice(11,0,Hz1616_san,0,2,16,0);
  1049.         display_lattice(12,0,Hz1616_hang,0,2,16,0);

  1051.         display_lattice(8,16,Hz1616_er,0,2,16,0);    //二窗口四行
  1052.         display_lattice(9,16,Hz1616_chuang,0,2,16,0);   
  1053.         display_lattice(10,16,Hz1616_kou,0,2,16,0);   
  1054.         display_lattice(11,16,Hz1616_si,0,2,16,0);
  1055.         display_lattice(12,16,Hz1616_hang,0,2,16,0);

  1057.     }

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

  1063.         if(ucPart==1) //被选中
  1064.         {
  1065.              ucCursorFlag=1; //反显 显示
  1066.         }
  1067.         else //没被选中
  1068.         {
  1069.              ucCursorFlag=0; //正常 显示
  1070.         }

  1072.         if(ucData_2_1>=10) //有2位数以上
  1073.         {
  1074.              ucAnyNumber_10=ucData_2_1/10;  //十位
  1075.         }
  1076.         else //否则显示空
  1077.         {
  1078.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  1079.         }

  1081.         ucAnyNumber_1=ucData_2_1%10/1;  //个位

  1083.    
  1084.         p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  1085.         p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

  1093.                           
  1094.     }

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

  1100.          if(ucPart==2) //被选中
  1101.          {
  1102.              ucCursorFlag=1; //反显 显示
  1103.          }
  1104.          else //没被选中
  1105.          {
  1106.              ucCursorFlag=0; //正常 显示
  1107.          }

  1109.          if(ucData_2_2>=10) //有2位数以上
  1110.          {
  1111.              ucAnyNumber_10=ucData_2_2/10;  //十位
  1112.          }
  1113.          else //否则显示空
  1114.          {
  1115.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  1116.          }

  1118.          ucAnyNumber_1=ucData_2_2%10/1;  //个位

  1120.    
  1121.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  1122.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

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

  1136.          if(ucPart==3) //被选中
  1137.          {
  1138.              ucCursorFlag=1; //反显 显示
  1139.          }
  1140.          else //没被选中
  1141.          {
  1142.              ucCursorFlag=0; //正常 显示
  1143.          }

  1145.          if(ucData_2_3>=10) //有2位数以上
  1146.          {
  1147.              ucAnyNumber_10=ucData_2_3/10;  //十位
  1148.          }
  1149.          else //否则显示空
  1150.          {
  1151.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  1152.          }

  1154.          ucAnyNumber_1=ucData_2_3%10/1;  //个位

  1156.    
  1157.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  1158.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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

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

  1172.          if(ucPart==4) //被选中
  1173.          {
  1174.              ucCursorFlag=1; //反显 显示
  1175.          }
  1176.          else //没被选中
  1177.          {
  1178.              ucCursorFlag=0; //正常 显示
  1179.          }

  1181.          if(ucData_2_4>=10) //有2位数以上
  1182.          {
  1183.              ucAnyNumber_10=ucData_2_4/10;  //十位
  1184.          }
  1185.          else //否则显示空
  1186.          {
  1187.              ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
  1188.          }

  1190.          ucAnyNumber_1=ucData_2_4%10/1;  //个位

  1192.    
  1193.          p_ucAnyNumber_10=number_to_matrix(ucAnyNumber_10); //把数字转换成字模首地址
  1194.          p_ucAnyNumber_1=number_to_matrix(ucAnyNumber_1); //把数字转换成字模首地址


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

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


  1204. }


  1207. void clear_all_canvas(void)  //把画布全部清零
  1208. {
  1209.    unsigned int j=0;
  1210.    unsigned int i=0;

  1212.    for(j=0;j<16;j++)  //这里的16表示画布有16行
  1213.    {
  1214.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
  1215.       {
  1216.                   ucCanvasBuffer[j*4+i]=0x00;
  1217.       }
  1218.    }         

  1220. }





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

  1229.     unsigned char x,y;
  1230.     WriteCommand(0x34);  //关显示缓冲指令            
  1231.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  1232.     y=0;
  1233.     while(y<32)  //y轴的范围0至31
  1234.     {
  1235.          WriteCommand(y+0x80);        //垂直地址
  1236.          WriteCommand(0x80);          //水平地址
  1237.          for(x=0;x<32;x++)  //256个横向点，有32个字节
  1238.          {  
  1239.             LCDWriteData(ucFillDate);
  1240.          }
  1241.          y++;
  1242.     }
  1243.     WriteCommand(0x36); //开显示缓冲指令

  1245. }

  1247. /* 注释五：
  1248. * 把字模插入画布的函数.
  1249. * 这是本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  1250. * 第1，2个参数x,y是在画布中的坐标体系。
  1251. * x的范围是0至3，因为画布的横向只要4个字节。y的范围是0至15，因为画布的纵向只有16行。
  1252. * 第3个参数*ucArray是字模的数组。
  1253. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  1254. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  1255. */
  1256. 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)
  1257. {
  1258.    unsigned int j=0;
  1259.    unsigned int i=0;
  1260.    unsigned char ucTemp;
  1261.    for(j=0;j<y_amount;j++)
  1262.    {
  1263.       for(i=0;i<x_amount;i++)
  1264.       {
  1265.                    ucTemp=ucArray[j*x_amount+i];
  1266.                    if(ucFbFlag==0)
  1267.                    {
  1268.               ucCanvasBuffer[(y+j)*4+x+i]=ucTemp; //这里的4代表画布每一行只有4个字节
  1269.                    }
  1270.                    else
  1271.                    {
  1272.               ucCanvasBuffer[(y+j)*4+x+i]=~ucTemp; //这里的4代表画布每一行只有4个字节
  1273.                    }
  1274.       }
  1275.    }         

  1277. }

  1279. /* 注释六：
  1280. * 显示任意点阵函数.
  1281. * 注意，本函数在前几节的基础上多增加了第7个参数uiOffSetAddr，它是偏移地址。
  1282. * 对于这个函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  1283. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
  1284. * 第3个参数*ucArray是字模的数组。
  1285. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  1286. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  1287. * 第7个参数uiOffSetAddr是偏移地址，代表字模数组的从第几个数据开始显示。
  1288. */
  1289. 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)
  1290. {
  1291.    unsigned int j=0;
  1292.    unsigned int i=0;
  1293.    unsigned char ucTemp;

  1295. //注意，要把以下两行指令屏蔽，否则屏幕在更新显示时会整屏闪动
  1296. //  WriteCommand(0x34);  //关显示缓冲指令            
  1297. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  1298.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  1299.    {
  1300.        WriteCommand(y+j+0x80);        //垂直地址
  1301.        WriteCommand(x+0x80);          //水平地址
  1302.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  1303.        {
  1304.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
  1305.            if(ucFbFlag==1)  //反白显示
  1306.            {
  1307.                ucTemp=~ucTemp;
  1308.            }
  1309.            LCDWriteData(ucTemp);
  1310.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
  1311.       }
  1312.    }
  1313.    WriteCommand(0x36); //开显示缓冲指令
  1314. }




  1319. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  1320. {
  1321.         unsigned char i;
  1322.         for ( i = 0; i < 8; i++ )
  1323.         {
  1324.                 if ( (ucData << i) & 0x80 )
  1325.                 {
  1326.                         LCDSID_dr = 1;
  1327.                 }
  1328.                 else
  1329.                 {
  1330.                         LCDSID_dr = 0;
  1331.                 }
  1332.                 LCDCLK_dr = 0;
  1333.                 LCDCLK_dr = 1;
  1334.         }
  1335. }

  1337. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  1338. {
  1339.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
  1340.         SendByteToLcd( ucWData & 0xf0 );
  1341.         SendByteToLcd( (ucWData << 4) & 0xf0);
  1342. }


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

  1348.         LCDCS_dr = 0;
  1349.         LCDCS_dr = 1;
  1350.         SPIWrite(ucCommand, 0);
  1351.         delay_short(90);
  1352. }

  1354. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
  1355. {
  1356.         LCDCS_dr = 0;
  1357.         LCDCS_dr = 1;
  1358.         SPIWrite(ucData, 1);
  1359. }

  1361. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
  1362. {
  1363.         LCDRST_dr = 1;  //复位
  1364.         LCDRST_dr = 0;
  1365.         LCDRST_dr = 1;
  1366. }



  1370. void delay_short(unsigned int uiDelayShort) //延时函数
  1371. {
  1372.    unsigned int i;  
  1373.    for(i=0;i<uiDelayShort;i++)
  1374.    {
  1375.      ;  
  1376.    }
  1377. }


  1380. void delay_long(unsigned int uiDelayLong)
  1381. {
  1382.    unsigned int i;
  1383.    unsigned int j;
  1384.    for(i=0;i<uiDelayLong;i++)
  1385.    {
  1386.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  1387.           {
  1388.              ; //一个分号相当于执行一条空语句
  1389.           }
  1390.    }
  1391. }
复制代码

总结陈词：
这一节讲了在多个窗口里设置不同的参数。还有一种常见的项目，要求把第1窗口是用来作为主菜单，主菜单里面有3个子菜单，可以通过移动光标进入不同的子菜单窗口进行参数设置，这类项目该如何编程？欲知详情，请听下回分解-----通过主菜单移动光标来进入子菜单窗口的液晶屏程序。

（未完待续，下节更精彩，不要走开哦）
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

100#
 楼主| 发表于 2014-10-28 15:35:21 | 显示全部楼层
又一个暑假 发表于 2014-10-28 15:15
鸿哥的液晶更新有点多节啦，得开始研究了

不要急，一节一节来慢慢消化。
乐于分享，勇于质疑！
回复 支持 反对

使用道具 举报

下一页 »
1234567下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

GMT+8, 2024-5-7 00:56 , Processed in 0.339986 second(s), 17 queries .

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