开启辅助访问

amobbs.com 阿莫电子技术论坛

登录 注册 找回密码
搜索
amobbs.com 阿莫电子技术论坛»论坛首页 › 单片机 › 51单片机 › 从业将近十年！手把手教你单片机程序框架（连载） ...
bottom↓
1 ...67891011121314... 15下一页
返回列表 发新帖
楼主: 吴坚鸿

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

  [复制链接]
zhouq3132

出0入0汤圆
发表于 2014-9-21 18:18:52 | 显示全部楼层
友情帮楼主顶！
回复

   举报本楼层   

JnzGoto

出0入0汤圆
发表于 2014-9-21 18:30:27 | 显示全部楼层
牛人,留个脚印
回复

   举报本楼层   

yaake

出0入0汤圆
发表于 2014-9-21 20:59:01 | 显示全部楼层
多谢分享。慢慢看，学习下。
回复

   举报本楼层   

sh0568

出0入0汤圆
发表于 2014-9-21 23:03:00 | 显示全部楼层
内容很多,做个记号,需要用点时间消化.
回复

   举报本楼层   

chhh

出0入0汤圆
发表于 2014-9-22 09:41:23 | 显示全部楼层
支持下，学习学习~~
回复

   举报本楼层   

crezoom

出0入0汤圆
发表于 2014-9-22 10:41:40 | 显示全部楼层
拜读，mark下，谢谢分享！
回复

   举报本楼层   

fugeone_copy

出0入0汤圆
发表于 2014-9-22 11:01:26 | 显示全部楼层
写的真不错，支持一下啊
回复

   举报本楼层   

20062516

出0入0汤圆
发表于 2014-9-22 11:39:15 | 显示全部楼层
好东西，感谢分享，支持，学习一下
回复

   举报本楼层   

mcu005

出0入0汤圆
发表于 2014-9-22 14:54:43 | 显示全部楼层
很好的总结，学习了
回复

   举报本楼层   

cclgxuanshao

出0入0汤圆
发表于 2014-9-22 16:24:46 | 显示全部楼层
支持楼主，感谢分享
回复

   举报本楼层   

dzlt2012

出0入0汤圆
发表于 2014-9-22 16:55:25 | 显示全部楼层
高人高风格。赞一个。
回复

   举报本楼层   

superxman

出0入0汤圆
发表于 2014-9-22 16:56:56 | 显示全部楼层
谢谢分享~
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-9-24 14:19:03 | 显示全部楼层
第七十节：深入讲解液晶屏的构字过程。

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

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

（1）硬件平台：
     基于朱兆祺51单片机学习板。

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

  1. #include "REG52.H"


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

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

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

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

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

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

  42. const unsigned char Byte_2[]= //2横，2列
  43. {
  44. 0x01,0x02,
  45. 0x03,0x04,
  46. };

  48. const unsigned char Byte_3[]= //1横，4列
  49. {
  50. 0x01,
  51. 0x02,
  52. 0x03,
  53. 0x04,
  54. };


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

  61.     display_clear(); // 清屏

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

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

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

  72.         display_lattice(14,0,Hz1616_man,0,2,16);  //显示<馒>字
  73.         display_lattice(15,0,Hz1616_tou,0,2,16);  //显示<头>字
  74.         display_lattice(14,16,Hz1616_man,1,2,16); //显示<馒>字 反显
  75.         display_lattice(15,16,Hz1616_tou,1,2,16); //显示<头>字 反显
  76.     while(1)  
  77.     {
  78.        ;
  79.     }

  81. }

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

  91. void display_clear(void) // 清屏
  92. {   

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


  110. }


  113. /* 注释四：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  114. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
  115. * 第3个参数*ucArray是字模的数组。
  116. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  117. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  118. * 本函数后面故意增加一个长延时delay_short(30000)，是为了方便读者观察横向取模的
  119. * 字是如何一个字节一个字节构建而成的。
  120. */
  121. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
  122. {
  123.    unsigned int j=0;
  124.    unsigned int i=0;
  125.    unsigned char ucTemp;
  126. //  WriteCommand(0x34);   //关显示缓冲指令   
  127.    WriteCommand(0x36);  //这次为了观察每个数字在显示屏上的关系，所以把这个显示缓冲的命令提前打开，下一节放到本函数最后
  128.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  129.    {
  130.        WriteCommand(y+j+0x80);        //垂直地址
  131.        WriteCommand(x+0x80);          //水平地址
  132.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  133.        {
  134.          ucTemp=ucArray[j*x_amount+i];
  135.              if(ucFbFlag==1)  //反白显示
  136.                  {
  137.             ucTemp=~ucTemp;
  138.          }
  139.              LCDWriteData(ucTemp);
  140.                  delay_short(30000);  //本函数故意增加这个长延时，是为了方便读者观察横向取模的字是如何一个字节一个字节构建而成的。
  141.       }
  142.    }

  144. }

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

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


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

  179.         LCDCS_dr = 0;
  180.         LCDCS_dr = 1;
  181.         SPIWrite(ucCommand, 0);
  182.         delay_short(90);
  183. }

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

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



  201. void delay_short(unsigned int uiDelayShort) //延时函数
  202. {
  203.    unsigned int i;  
  204.    for(i=0;i<uiDelayShort;i++)
  205.    {
  206.      ;  
  207.    }
  208. }
复制代码

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

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

回复

   举报本楼层   

bi大痣

出0入0汤圆
发表于 2014-9-24 14:28:22 | 显示全部楼层
先mark一下！好好看看！
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-9-25 11:44:50 | 显示全部楼层
第七十一节：液晶屏的字符，16点阵，24点阵和32点阵的显示程序。

开场白：
这一节要教会大家二个知识点：
第一个：如何利用任意点阵字体显示函数display_lattice来显示8x16的字符，16点阵汉字，24点阵汉字和32点阵汉字。
第二个：纠正上一节的一个小错误。C51编译器跟其它单片机的编译器有点不一样。想把常量数据保存在ROM程序存储区里并不是用const关键字，而是是用code关键字。

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

（1）硬件平台：
     基于朱兆祺51单片机学习板。

（2）实现功能：开机上电后，可以看到液晶屏分别显示32点阵，24点阵和16点阵的“馒头”两个字，还有“V5”这两个8x16点阵的字符。
   
（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); // 清屏

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

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


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

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


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


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

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

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

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



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

  95.     display_clear(); // 清屏

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

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

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

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

  109.     while(1)  
  110.     {
  111.        ;
  112.     }

  114. }



  118. void display_clear(void) // 清屏
  119. {   

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

  137. }


  140. /* 注释二：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
  141. * 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
  142. * 第3个参数*ucArray是字模的数组。
  143. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
  144. * 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
  145. */
  146. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
  147. {
  148.    unsigned int j=0;
  149.    unsigned int i=0;
  150.    unsigned char ucTemp;
  151.    WriteCommand(0x34);  //关显示缓冲指令            
  152.    WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  153.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  154.    {
  155.        WriteCommand(y+j+0x80);        //垂直地址
  156.        WriteCommand(x+0x80);          //水平地址
  157.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  158.        {
  159.          ucTemp=ucArray[j*x_amount+i];
  160.              if(ucFbFlag==1)  //反白显示
  161.                  {
  162.             ucTemp=~ucTemp;
  163.          }
  164.              LCDWriteData(ucTemp);
  165.           //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
  166.       }
  167.    }
  168.    WriteCommand(0x36); //开显示缓冲指令
  169. }


  172. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  173. {
  174.         unsigned char i;
  175.         for ( i = 0; i < 8; i++ )
  176.         {
  177.                 if ( (ucData << i) & 0x80 )
  178.                 {
  179.                         LCDSID_dr = 1;
  180.                 }
  181.                 else
  182.                 {
  183.                         LCDSID_dr = 0;
  184.                 }
  185.                 LCDCLK_dr = 0;
  186.                 LCDCLK_dr = 1;
  187.         }
  188. }

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


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

  201.         LCDCS_dr = 0;
  202.         LCDCS_dr = 1;
  203.         SPIWrite(ucCommand, 0);
  204.         delay_short(90);
  205. }

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

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



  223. void delay_short(unsigned int uiDelayShort) //延时函数
  224. {
  225.    unsigned int i;  
  226.    for(i=0;i<uiDelayShort;i++)
  227.    {
  228.      ;  
  229.    }
  230. }
复制代码


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

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

回复

   举报本楼层   

ghhuang

出0入4汤圆
发表于 2014-9-26 10:04:04 | 显示全部楼层
吴坚鸿 发表于 2014-9-18 13:02
第六十九节：使用static关键字可以减少全局变量的使用。

开场白：

不错！期待楼主出书！
回复

   举报本楼层   

tpstars

出0入0汤圆
发表于 2014-9-26 10:09:25 | 显示全部楼层
非常有用！感谢！
回复

   举报本楼层   

DepravedLucien

出0入0汤圆
发表于 2014-9-26 11:17:53 | 显示全部楼层
so cool         
回复

   举报本楼层   

rengh

出0入0汤圆
发表于 2014-9-26 14:30:19 | 显示全部楼层
不错，谢谢分享。
回复

   举报本楼层   

dongmakuaibu

出0入0汤圆
发表于 2014-9-26 16:45:37 | 显示全部楼层
热烈欢迎！
回复

   举报本楼层   

罗敏爱之恋

出0入0汤圆
发表于 2014-9-26 17:14:27 | 显示全部楼层
欢迎，欢迎。。。
回复

   举报本楼层   

Yahom

出0入0汤圆
发表于 2014-9-26 17:16:45 | 显示全部楼层
认真学习，期待更新！
回复

   举报本楼层   

youstupy

出0入0汤圆
发表于 2014-9-26 17:37:57 | 显示全部楼层
支持一下楼主
回复

   举报本楼层   

只为那梦的轮回

出0入0汤圆
发表于 2014-9-26 18:12:25 | 显示全部楼层
GOOD!!!,继续努力
回复

   举报本楼层   

千年明月

出0入0汤圆
发表于 2014-9-27 19:17:25 | 显示全部楼层
学习，谢谢啊
回复

   举报本楼层   

ccyhyxt

出0入0汤圆
发表于 2014-9-27 19:20:35 | 显示全部楼层
收藏学习
回复

   举报本楼层   

千年明月

出0入0汤圆
发表于 2014-9-27 22:12:56 | 显示全部楼层
欢迎，收藏
回复

   举报本楼层   

路过羊圈的狼

出0入0汤圆
发表于 2014-9-28 11:58:12 | 显示全部楼层
顶你一下。

感谢分享。
回复

   举报本楼层   

yt920419

出0入0汤圆
发表于 2014-9-28 12:11:19 | 显示全部楼层
收藏  虽然在搞了 还是想回来细读下
回复

   举报本楼层   

yaxiaoyu

出0入0汤圆
发表于 2014-9-28 12:18:50 | 显示全部楼层
支持下~！
回复

   举报本楼层   

fayuanye

出0入0汤圆
发表于 2014-9-29 20:49:39 | 显示全部楼层
吴坚鸿 发表于 2014-3-14 13:09
其实以前我年轻的时候也不愿意分享技术的，我想以后我的技术传男不传女，世世代代传下去。
后来我想开了 ...

佩服无私奉献精神！！谢谢你！！
回复

   举报本楼层   

fx568000

出0入0汤圆
发表于 2014-9-30 15:46:24 | 显示全部楼层
程序框架讲解，mark
回复

   举报本楼层   

nutos

出0入0汤圆
发表于 2014-9-30 16:34:02 | 显示全部楼层
拜读，支持
回复

   举报本楼层   

拣尽寒枝

出0入0汤圆
发表于 2014-10-4 21:59:46 | 显示全部楼层
感谢分享，学习了
回复

   举报本楼层   

chenshichao541

出0入0汤圆
发表于 2014-10-8 22:53:25 | 显示全部楼层
期待楼主的更新，好强大，慢慢理解，以后会关注楼主的每一期的更新，仔细研究研究，提升自己的能力，谢谢楼主的无私奉献。
回复

   举报本楼层   

stingxing

出0入0汤圆
发表于 2014-10-8 23:10:23 | 显示全部楼层
感谢楼主无私奉献
回复

   举报本楼层   

gy54321

出0入0汤圆
发表于 2014-10-9 01:02:39 | 显示全部楼层
写这么多真不容易， 学习都得好长时间！！！
回复

   举报本楼层   

MetalSeed

出0入0汤圆
发表于 2014-10-9 10:45:07 | 显示全部楼层
热烈欢迎~
回复

   举报本楼层   

陶新成

出0入0汤圆
发表于 2014-10-9 13:38:12 | 显示全部楼层
还挺精炼啊
回复

   举报本楼层   

atonghua

出0入0汤圆
发表于 2014-10-9 13:50:29 | 显示全部楼层
还有后期的教程吗？
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-10-9 14:21:21 | 显示全部楼层
atonghua 发表于 2014-10-9 13:50
还有后期的教程吗？

还有很多。凭我目前的库存，估计还能写几年才会写完。
我写技术贴都是必须等我某天情绪状态最好的时候才会动手写，因为我需要灵感。我正在等我最好的状态来临。这两天就会更新。
回复

   举报本楼层   

leo_advance

出0入0汤圆
发表于 2014-10-9 14:56:18 | 显示全部楼层
支持一下！
回复

   举报本楼层   

new_comer

出0入0汤圆
发表于 2014-10-9 15:37:29 来自手机 | 显示全部楼层
先顶后看，慢慢学习。
回复

   举报本楼层   

Samzzt

出0入0汤圆
发表于 2014-10-9 15:46:27 | 显示全部楼层
给楼主提个建议，希望能把实例代码以附件形式上传，排好版，要不然一股脑的帖在帖子里面太影响阅读了。呵呵，要求可能有点过分，希望楼主能满足。多谢楼主分享，对广大电工真是好福利。
回复

   举报本楼层   

Samzzt

出0入0汤圆
发表于 2014-10-9 15:47:38 | 显示全部楼层
一直在路上，不曾离开过！
回复

   举报本楼层   

lonely9391

出0入0汤圆
发表于 2014-10-9 19:54:50 | 显示全部楼层
板凳     
回复

   举报本楼层   

zmc009

出0入0汤圆
发表于 2014-10-9 20:43:34 | 显示全部楼层
衷心感谢楼主的无私奉献和良苦用心。
回复

   举报本楼层   

zhangjinzj

出0入0汤圆
发表于 2014-10-9 21:26:01 | 显示全部楼层

拜读，mark下，谢谢分享！
回复

   举报本楼层   

blade_li

出0入0汤圆
发表于 2014-10-9 22:07:58 来自手机 | 显示全部楼层
搬个板凳，坐听大侠赐教
回复

   举报本楼层   

liujie14565
头像被屏蔽

出0入0汤圆
发表于 2014-10-10 09:03:40 | 显示全部楼层
提示: 作者被禁止或删除 内容自动屏蔽
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-10-10 12:52:24 | 显示全部楼层
Samzzt 发表于 2014-10-9 15:46
给楼主提个建议，希望能把实例代码以附件形式上传，排好版，要不然一股脑的帖在帖子里面太影响阅读了。呵呵 ...

我这里有热心网友帮整理到71节的版本，有点击跳转目录，很方便阅读。现在分享给你。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有帐号？注册

x
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-10-10 12:54:27 | 显示全部楼层
第七十二节：在液晶屏中把字体顺时针旋转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. }
复制代码


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

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有帐号？注册

x
回复

   举报本楼层   

sonnybird

出0入0汤圆
发表于 2014-10-10 13:37:15 | 显示全部楼层
膜拜中 mark
回复

   举报本楼层   

ltmooner

出0入0汤圆
发表于 2014-10-10 14:16:00 | 显示全部楼层
热烈欢迎，热烈欢迎
回复

   举报本楼层   

hkjabcd

出0入0汤圆
发表于 2014-10-10 15:20:10 | 显示全部楼层
顶，一直关注！
回复

   举报本楼层   

tt98

出0入0汤圆
发表于 2014-10-10 20:51:32 | 显示全部楼层
照单全收
回复

   举报本楼层   

xiay123

出0入0汤圆
发表于 2014-10-11 11:02:43 | 显示全部楼层
mark mark 好！
回复

   举报本楼层   

ycping

出0入0汤圆
发表于 2014-10-11 11:27:13 | 显示全部楼层
学习，，学习。。。
回复

   举报本楼层   

lycf

出0入0汤圆
发表于 2014-10-11 13:13:58 | 显示全部楼层
好帖，先收藏下来，慢慢消化！
回复

   举报本楼层   

wzh2004

出0入0汤圆
发表于 2014-10-11 13:15:53 | 显示全部楼层
MARK一下慢慢欣赏
回复

   举报本楼层   

涵潇舒雅

出5入10汤圆
发表于 2014-10-11 14:52:04 | 显示全部楼层
mark一下 期待更新~
回复

   举报本楼层   

psbhero

出0入0汤圆
发表于 2014-10-11 14:58:42 | 显示全部楼层
支持楼主，一定取经，抽空看看
回复

   举报本楼层   

qqfirer

出0入0汤圆
发表于 2014-10-13 09:25:47 | 显示全部楼层
必定大火的帖子，全是经验之谈
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-10-13 10:54:08 | 显示全部楼层
第七十三节：在液晶屏中把字体镜像显示的算法程序。

开场白：
有的项目会要求把字体或者图像进行镜像显示处理，这一节把这个算法教给大家。
    这个算法的本质是：
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行，行不行？当然可以。但是需要我们编写额外的算法程序。这种算法程序是怎样编写的？欲知详情，请听下回分解-----在液晶屏中让字体可以跨区域无缝对接显示的算法程序。

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

回复

   举报本楼层   

ZJSXHWL000000

出0入0汤圆
发表于 2014-10-13 12:13:50 | 显示全部楼层
拜读，mark下，谢谢分享！
回复

   举报本楼层   

HZY//123456

出0入0汤圆
发表于 2014-10-13 18:12:21 | 显示全部楼层
没想到楼主也在西乡呢
回复

   举报本楼层   

Samzzt

出0入0汤圆
发表于 2014-10-13 20:48:24 | 显示全部楼层
回复

   举报本楼层   

stargraft

出0入0汤圆
发表于 2014-10-16 15:11:32 | 显示全部楼层
注释很详细，对初学者应该不能理解
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-10-16 15:12:52 | 显示全部楼层
第七十四节：在液晶屏中让字体可以跨区域无缝对接显示的算法程序。

开场白：
细心的网友会发现，这种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个点阵为单位进行移动显示的算法程序。

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

回复

   举报本楼层   

yuhuwyh

出0入0汤圆
发表于 2014-10-16 15:48:41 | 显示全部楼层
精彩继续！！！
回复

   举报本楼层   

guowanling8061

出0入0汤圆
发表于 2014-10-16 15:52:46 | 显示全部楼层
这个挺好，LZ有心人啊！！
回复

   举报本楼层   

tj7856

出0入0汤圆
发表于 2014-10-16 16:02:20 | 显示全部楼层
感谢分享
回复

   举报本楼层   

默默七

出0入0汤圆
发表于 2014-10-16 18:54:26 | 显示全部楼层
mark一下，单片机知识及入门
回复

   举报本楼层   

AbnerSmith

出0入0汤圆
发表于 2014-10-17 20:24:15 来自手机 | 显示全部楼层
支持一下，确实架构很重要，以前没感觉，后来也慢慢明白了
回复

   举报本楼层   

telwin

出0入0汤圆
发表于 2014-10-17 20:26:06 | 显示全部楼层
听课。。。。。
回复

   举报本楼层   

lze110

出0入0汤圆
发表于 2014-10-17 20:37:14 | 显示全部楼层
谢谢分享
回复

   举报本楼层   

littlebadbay

出0入0汤圆
发表于 2014-10-17 20:38:05 | 显示全部楼层
写的很好 收藏
回复

   举报本楼层   

lylm123

出0入0汤圆
发表于 2014-10-17 22:01:42 | 显示全部楼层
楼主加油！
回复

   举报本楼层   

tt98

出0入0汤圆
发表于 2014-10-18 20:04:57 | 显示全部楼层
继续听讲！鸿哥V5
回复

   举报本楼层   

洋芋擦擦

出0入0汤圆
发表于 2014-10-18 21:09:29 | 显示全部楼层
mark  一下吧 有时间看看
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-10-19 10:10:10 | 显示全部楼层
第七十五节：在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个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

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

   举报本楼层   

xiaolaoyu

出0入0汤圆
发表于 2014-10-19 20:18:17 | 显示全部楼层
好帖！顶顶！！！！！
回复

   举报本楼层   

protection

出0入0汤圆
发表于 2014-10-19 20:44:01 | 显示全部楼层
MARK 以后一定好好学习
回复

   举报本楼层   

gzwirelesss

出0入0汤圆
发表于 2014-10-19 21:46:52 | 显示全部楼层
不错，谢谢分享。
回复

   举报本楼层   

mediaclassic

出0入0汤圆
发表于 2014-10-19 23:03:49 | 显示全部楼层
不错，谢谢分享。
回复

   举报本楼层   

gqjxy

出0入0汤圆
发表于 2014-10-19 23:55:56 来自手机 | 显示全部楼层
学习，谢谢楼主，楼主辛苦
回复

   举报本楼层   

syflash

出0入0汤圆
发表于 2014-10-20 00:24:08 | 显示全部楼层
写得不错                              
回复

   举报本楼层   

含笑半步颠

出0入0汤圆
发表于 2014-10-20 00:32:47 | 显示全部楼层
记得去年在其他论坛上见过鸿哥的帖子，当时还没有这么系统，当时帖子说了鸿哥的一路历程，表示非常受感动。前两天注册的账号，在这里又看到鸿哥了，缘分呐~
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-10-20 13:50:59 | 显示全部楼层
含笑半步颠 发表于 2014-10-20 00:32
记得去年在其他论坛上见过鸿哥的帖子，当时还没有这么系统，当时帖子说了鸿哥的一路历程，表示非常受感动。 ...

缘分呀。
回复

   举报本楼层   

冷无痕

出0入0汤圆
发表于 2014-10-20 18:32:46 | 显示全部楼层
很不错的资料，收藏了。。。
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-10-23 11:37:22 | 显示全部楼层
第七十六节：如何把一个任意数值的变量显示在液晶屏上。

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

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

（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个窗口里通过移动光标来设置不同参数的液晶屏菜单程序。

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

   举报本楼层   

阿文

出0入0汤圆
发表于 2014-10-23 12:07:46 | 显示全部楼层
可以算得上是导师了。
回复

   举报本楼层   

xoao

出0入0汤圆
发表于 2014-10-23 12:17:16 | 显示全部楼层
支持一下！
回复

   举报本楼层   

3goodboy

出0入0汤圆
发表于 2014-10-23 13:20:34 来自手机 | 显示全部楼层
nb人物，支持
回复

   举报本楼层   

gaoshiduo

出0入0汤圆
发表于 2014-10-23 14:19:04 | 显示全部楼层
支持，收藏。。。
回复

   举报本楼层   

jeoo8888

出0入0汤圆
发表于 2014-10-24 09:11:12 | 显示全部楼层
楼主大大的好人。
回复

   举报本楼层   

我不乐意啊

出0入0汤圆
发表于 2014-10-25 20:02:09 | 显示全部楼层
收藏了，很不错！
回复

   举报本楼层   

吴坚鸿

出0入0汤圆
 楼主| 发表于 2014-10-26 09:41:48 | 显示全部楼层
第七十七节：在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. }
复制代码

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

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

   举报本楼层   

tt98

出0入0汤圆
发表于 2014-10-26 13:00:20 | 显示全部楼层
继续跟进
回复

   举报本楼层   

hao999a

出0入0汤圆
发表于 2014-10-27 16:58:49 | 显示全部楼层
楼主人太好了，每天学一节，                          
回复

   举报本楼层   

下一页 »
1 ...67891011121314... 15下一页
返回列表 发新帖
回帖提示： 反政府言论将被立即封锁ID 。在按“提交”前，请自问一下：我这样表达会给举报吗，会给自己惹麻烦吗？ 另外：尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片，浪费大家下载带宽和论坛服务器空间，请压缩后（图片小于1兆）才上传。压缩方法可以在微信里面发给自己（不要勾选“原图），然后下载，就能得到压缩后的图片。注意：要连续压缩2次才能满足要求！！】。另外，手机版只能上传图片，要上传附件需要切换到电脑版（不需要使用电脑，手机上切换到电脑版就行，页面底部）。
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有：东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案：44190002001997 ) )

GMT+8, 2024-7-23 08:22

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

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