21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 从业将近十年！手把手教你单片机程序框架（连载） ...
1 ...242526272829303132... 45下一页
返回列表 发新帖我要提问

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

[复制链接]
294134|913
langgao183 发表于 2014-10-9 22:05 | 显示全部楼层
  key_scan();为什么放在中断？我觉得中断程序越少越好
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-10-10 12:57 | 显示全部楼层
langgao183 发表于 2014-10-9 22:05
key_scan();为什么放在中断？我觉得中断程序越少越好

不一定非要放中断里，看情况吧。我大部分的项目都是放在中断里，因为我的按键扫描虽然代码多，但是不耗时间，放在中断里很好用，已经应用在大量的项目上了。但是我建议，如果一些实时性非常高的项目，还是不要放在中断里。
回复

收藏343 举报

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



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

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


  2. 

  3. sbit  LCDCS_dr  = P1^6;  //片选线
    

  4. sbit  LCDSID_dr = P1^7;  //串行数据线
    

  5. sbit  LCDCLK_dr = P3^2;  //串行时钟线
    

  6. sbit  LCDRST_dr = P3^4;  //复位线
    


  7. 

  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度的转换函数
    


  17. 

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


  19. 

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


  25. 

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


  31. 


  32. 

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


  37. 

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


  42. 


  43. 

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


  45. 

  46. void main() 
    

  47.   {
    

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


  49. 

  50.         display_clear(); // 清屏
    


  51. 

  52. /* 注释一：
    

  53.  * (1)把原来的液晶屏物理位置逆时针旋转90度后，从上往下阅读，类似对联的阅读习惯。所以请注意坐标体系参数的变化。
    

  54.  * (2)为了让字符居中显示，请注意在显示V和5两个字符时坐标体系的变化。
    

  55.  * (3)字符8x16经过旋转处理后，变成了16x8，在调用display_lattice函数时，要注意修改响应的参数。
    

  56.  */
    


  57. 

  58.         hz1616_s90(Hz1616_man,ucBufferResult);  //把<馒>字顺时针旋转90度放到ucBufferResult临时变量里。
    

  59.         display_lattice(7,0,ucBufferResult,0,2,16);  //显示旋转90度后的<馒>字
    


  60. 

  61.         hz1616_s90(Hz1616_tou,ucBufferResult);  //把<头>字顺时针旋转90度放到ucBufferResult临时变量里。
    

  62.         display_lattice(6,0,ucBufferResult,0,2,16);  //显示旋转90度后的<头>字
    


  63. 


  64. 

  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是为了偏移居中显示。
    


  67. 

  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是为了偏移居中显示。
    


  70. 


  71. 

  72.     while(1)  
    

  73.     { 
    

  74.        ;
    

  75.     }
    


  76. 

  77. }
    


  78. 


  79. 


  80. 

  81. void display_clear(void) // 清屏
    

  82. {    
    


  83. 

  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); //开显示缓冲指令
    


  99. 

  100. }
    


  101. 


  102. 

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


  152. 


  153. 

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


  202. 


  203. 


  204. 

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


  235. 


  236. 

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


  254. 

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


  261. 


  262. 

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

  264. {
    


  265. 

  266.         LCDCS_dr = 0;
    

  267.         LCDCS_dr = 1;
    

  268.         SPIWrite(ucCommand, 0);
    

  269.         delay_short(90); 
    

  270. }
    


  271. 

  272. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
    

  273. {
    

  274.         LCDCS_dr = 0;
    

  275.         LCDCS_dr = 1;
    

  276.         SPIWrite(ucData, 1);
    

  277. }
    


  278. 

  279. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
    

  280. {
    

  281.         LCDRST_dr = 1;  //复位
    

  282.         LCDRST_dr = 0;
    

  283.         LCDRST_dr = 1;
    

  284. }
    


  285. 


  286. 


  287. 

  288. void delay_short(unsigned int uiDelayShort) //延时函数
    

  289. {
    

  290.    unsigned int i;  
    

  291.    for(i=0;i<uiDelayShort;i++)
    

  292.    {
    

  293.      ;  
    

  294.    }
    

  295. }

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

本帖子中包含更多资源

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

×
回复

收藏343 举报

逝去的堕落青春 发表于 2014-10-12 13:04 | 显示全部楼层
jianhong_wu 发表于 2014-9-18 12:59
第六十九节：使用static关键字可以减少全局变量的使用。

开场白：

个人觉得，在函数内使用static定义变量时，应该在函数的开头对该变量做异常的处理机制。如：
void Working（void）
{
    static uint8_t Work_Step=0;
   
    if(某种情况)
       Work_Step=0;
/////////////////////////////////////////
    Your code
}
这样做实现外部程序对该变量进行强制初始化动作。

这样方便统一将大量函数中的大量static 变量进行异常处理。

以上纯属个人习惯，分享一下，因为我在这方面吃过亏.........
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-10-12 18:08 | 显示全部楼层
逝去的堕落青春 发表于 2014-10-12 13:04
个人觉得，在函数内使用static定义变量时，应该在函数的开头对该变量做异常的处理机制。如：
void Workin ...

非常好的建议。感谢你的分享。
回复

收藏343 举报

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

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

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

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


  2. 

  3. sbit  LCDCS_dr  = P1^6;  //片选线
    

  4. sbit  LCDSID_dr = P1^7;  //串行数据线
    

  5. sbit  LCDCLK_dr = P3^2;  //串行时钟线
    

  6. sbit  LCDRST_dr = P3^4;  //复位线
    


  7. 

  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点阵字库镜像
    


  17. 

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


  19. 

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


  25. 

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


  31. 


  32. 

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


  37. 

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


  42. 


  43. 

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


  45. 

  46. void main() 
    

  47.   {
    

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


  49. 

  50.         display_clear(); // 清屏
    


  51. 

  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);  //显示镜像后的<馒>字
    


  55. 


  56. 

  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);  //显示镜像后的<头>字
    


  60. 

  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>字符
    


  64. 

  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>字符
    


  68. 

  69.         while(1)  
    

  70.         { 
    

  71.              ;
    

  72.         }
    


  73. 

  74. }
    


  75. 


  76. 


  77. 

  78. void display_clear(void) // 清屏
    

  79. {    
    


  80. 

  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); //开显示缓冲指令
    


  96. 

  97. }
    


  98. 

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


  142. 

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


  144. 

  145.                  
    

  146.      }
    

  147.          
    


  148. 

  149. }
    


  150. 


  151. 


  152. 

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


  181. 


  182. 


  183. 

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


  214. 


  215. 

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


  233. 

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


  240. 


  241. 

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

  243. {
    


  244. 

  245.         LCDCS_dr = 0;
    

  246.         LCDCS_dr = 1;
    

  247.         SPIWrite(ucCommand, 0);
    

  248.         delay_short(90); 
    

  249. }
    


  250. 

  251. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
    

  252. {
    

  253.         LCDCS_dr = 0;
    

  254.         LCDCS_dr = 1;
    

  255.         SPIWrite(ucData, 1);
    

  256. }
    


  257. 

  258. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
    

  259. {
    

  260.         LCDRST_dr = 1;  //复位
    

  261.         LCDRST_dr = 0;
    

  262.         LCDRST_dr = 1;
    

  263. }
    


  264. 


  265. 


  266. 

  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行，行不行？当然可以。但是需要我们编写额外的算法程序。这种算法程序是怎样编写的？欲知详情，请听下回分解-----在液晶屏中让字体可以跨区域无缝对接显示的算法程序。

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

回复

收藏343 举报

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

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

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

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

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

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


  2. 

  3. sbit  LCDCS_dr  = P1^6;  //片选线
    

  4. sbit  LCDSID_dr = P1^7;  //串行数据线
    

  5. sbit  LCDCLK_dr = P3^2;  //串行时钟线
    

  6. sbit  LCDRST_dr = P3^4;  //复位线
    


  7. 

  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); //延时
    


  17. 

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


  37. 

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


  57. 


  58. 

  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, 
    


  76. 

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


  78. 

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


  88. 


  89. 


  90. 

  91. void main() 
    

  92.   {
    

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


  94. 

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


  96. 

  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>的字模插入画布
    


  99. 

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

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


  102. 


  103. 

  104.         while(1)  
    

  105.         { 
    

  106.              ;
    

  107.         }
    


  108. 

  109. }
    


  110. 


  111. 


  112. 

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

  114. {    
    


  115. 

  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); //开显示缓冲指令
    


  131. 

  132. }
    


  133. 

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


  163. 

  164. }
    


  165. 

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


  200. 


  201. 

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


  219. 

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


  226. 


  227. 

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

  229. {
    


  230. 

  231.         LCDCS_dr = 0;
    

  232.         LCDCS_dr = 1;
    

  233.         SPIWrite(ucCommand, 0);
    

  234.         delay_short(90); 
    

  235. }
    


  236. 

  237. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
    

  238. {
    

  239.         LCDCS_dr = 0;
    

  240.         LCDCS_dr = 1;
    

  241.         SPIWrite(ucData, 1);
    

  242. }
    


  243. 

  244. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
    

  245. {
    

  246.         LCDRST_dr = 1;  //复位
    

  247.         LCDRST_dr = 0;
    

  248.         LCDRST_dr = 1;
    

  249. }
    


  250. 


  251. 


  252. 

  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个点阵为单位进行移动显示的算法程序。

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

回复

收藏343 举报

评论

阿新学单片机
这个段代码谁能再清晰的解释一下吗  发表于 2018-9-6 14:01
阿新学单片机
c=0; for(a=0;a<16;a++) //这里的16代表16列 { for(b=0;b<8;b++) //每一列中有16个点，有2个字节，这里的8代表第一个字节的8个位或点。 { p_ucResult[c]=p_ucResult[c]<<1; p_ucResult[c]  发表于 2018-9-6 14:00
armxu 发表于 2014-10-17 15:56 来自手机 | 显示全部楼层
没有源码，能发上来吗？
回复

收藏343 举报

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

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

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

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

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

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


  2. 

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


  4. 

  5. sbit  LCDCS_dr  = P1^6;  //片选线
    

  6. sbit  LCDSID_dr = P1^7;  //串行数据线
    

  7. sbit  LCDCLK_dr = P3^2;  //串行时钟线
    

  8. sbit  LCDRST_dr = P3^4;  //复位线
    


  9. 

  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); //延时
    


  19. 

  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);  //把画布全部清零
    


  24. 

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


  26. 

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


  46. 

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


  66. 


  67. 

  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, 
    


  85. 

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


  87. 

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


  97. 

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

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


  100. 

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

  102. unsigned int uiMoveTime=0;  //定时器累计时间
    


  103. 

  104. void main() 
    

  105.   {
    


  106. 

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

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


  109. 


  110. 

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

  112.         TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
    

  113.         TL0=0x2f;
    

  114.         EA=1;     //开总中断
    

  115.         ET0=1;    //允许定时中断
    

  116.         TR0=1;    //启动定时中断
    


  117. 


  118. 

  119.         while(1)  
    

  120.         { 
    

  121.            move_service(); //整体画布移动的应用程序
    

  122.            lcd_display_service(); //应用层面的液晶屏显示程序
    

  123.         }
    


  124. 

  125. }
    


  126. 


  127. 


  128. 

  129. void move_service(void) //整体画布移动的应用程序
    

  130. {
    

  131.    static unsigned char ucMoveStep=0; //运行步骤。前面加关键字static表示上电后这个变量只初始化一次，以后每次进出函数此变量不会重新初始化，保存之前的更改数值不变。
    

  132.    static unsigned char ucMoveCnt=0; //统计当前已经往左边移动了多少位。关键字static表示此变量上电后只初始化一次，不会每次进入函数都初始化。
    


  133. 

  134.    if(ucMoveStepReset==1)  //运行步骤的复位标志，此段代码结构方便外部程序初始化函数内部的步骤变量ucMoveStep
    

  135.    {
    

  136.       ucMoveStepReset=0; //及时把复位标志清零。避免一直处于复位的状态、
    


  137. 

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

  139.    }
    


  140. 

  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; //切换到下一个运行步骤
    


  153. 

  154.                break;
    


  155. 

  156.       case 1:
    

  157.                if(uiMoveTime>const_MoveTime)  //延时一定的时间后
    

  158.                    {
    

  159.                               ucMoveTimeStart=0; //关定时器    也相当于原子锁或互斥量的功能
    

  160.                        uiMoveTime=0;  //定时器清零
    


  161. 

  162.                    if(ucMoveCnt<16)
    

  163.                        {
    

  164.                           ucMoveCnt++;
    

  165.                   move_canvas_to_one_bit(); //把画布整体往左边移动一个点阵
    

  166.                   ucDisplayUpdate=1; //更新液晶屏显示
    

  167.                                   ucMoveTimeStart=1; //开定时器   也相当于原子锁或互斥量的功能
    


  168. 

  169.                        }
    

  170.                        else
    

  171.                        {
    

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

  173.                        }
    


  174. 


  175. 


  176. 

  177.            }
    

  178.                break;
    

  179.    }
    


  180. 

  181. }
    


  182. 


  183. 

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

  185. {
    

  186.     if(ucDisplayUpdate==1)  //需要更新显示
    

  187.     {
    

  188.        ucDisplayUpdate=0;  //及时把标志清零，避免一直处于不断更新的状态。
    


  189. 


  190. 

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

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

  193.     }
    

  194. }
    


  195. 

  196. /* 注释二：
    

  197.  * 假设有一个固定的四方形透明窗口，在窗口里面放了一张画布，只要想办法让这个画布
    

  198.  * 往右边拖动，那么画布里面的内容就会跟着画布整体往右边移动，这个就是能以1个点阵为单位进行移动显示的本质。
    

  199.  * 同理，这个画布有16行，每行有4个字节，我们只要把每行4个字节看作是一个首尾连接的二进制数据，
    

  200.  * 把每一行的二进制数据每次整体往右边移动一位，就相当于移动一个点阵了。
    

  201.  */
    


  202. 

  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;  //临时保存一个字节中的最低位
    


  209. 

  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;  //一行中的一个字节右移一位
    


  225. 

  226.                   if(ucBitH==1)   //原来左边相邻的字节最低位移动到了当前字节的最高位
    

  227.                   {
    

  228.              ucCanvasBuffer[j*4+i]=ucCanvasBuffer[j*4+i]|0x80; //把最高位补上
    

  229.                   }
    

  230.           ucBitH=ucBitL;  //把当前的最低位赋值给最高位，为下一个相邻字节做准备。
    

  231.       }
    

  232.    }         
    


  233. 

  234. }
    


  235. 


  236. 

  237. void clear_all_canvas(void)  //把画布全部清零
    

  238. {
    

  239.    unsigned int j=0;
    

  240.    unsigned int i=0;
    


  241. 

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


  249. 

  250. }
    


  251. 


  252. 

  253. void T0_time(void) interrupt 1  //定时中断函数
    

  254. {
    

  255.   TF0=0;  //清除中断标志
    

  256.   TR0=0; //关中断
    


  257. 

  258.   if(ucMoveTimeStart==1) //已经开了定时器  也相当于原子锁或互斥量的功能
    

  259.   {
    

  260.       uiMoveTime++; //定时器累加计时开始
    

  261.   }
    


  262. 

  263.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
    

  264.   TL0=0x2f;
    

  265.   TR0=1;  //开中断
    

  266. }
    


  267. 


  268. 


  269. 

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

  271. {    
    


  272. 

  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); //开显示缓冲指令
    


  288. 

  289. }
    


  290. 

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


  320. 

  321. }
    


  322. 

  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;
    


  338. 

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


  359. 


  360. 


  361. 


  362. 

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


  380. 

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


  387. 


  388. 

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

  390. {
    


  391. 

  392.         LCDCS_dr = 0;
    

  393.         LCDCS_dr = 1;
    

  394.         SPIWrite(ucCommand, 0);
    

  395.         delay_short(90); 
    

  396. }
    


  397. 

  398. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
    

  399. {
    

  400.         LCDCS_dr = 0;
    

  401.         LCDCS_dr = 1;
    

  402.         SPIWrite(ucData, 1);
    

  403. }
    


  404. 

  405. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
    

  406. {
    

  407.         LCDRST_dr = 1;  //复位
    

  408.         LCDRST_dr = 0;
    

  409.         LCDRST_dr = 1;
    

  410. }
    


  411. 


  412. 


  413. 

  414. void delay_short(unsigned int uiDelayShort) //延时函数
    

  415. {
    

  416.    unsigned int i;  
    

  417.    for(i=0;i<uiDelayShort;i++)
    

  418.    {
    

  419.      ;  
    

  420.    }
    

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

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

收藏343 举报

armxu 发表于 2014-10-19 14:31 来自手机 | 显示全部楼层
不知为何手机看不到源码。
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-10-19 16:20 | 显示全部楼层
armxu 发表于 2014-10-19 14:31
不知为何手机看不到源码。

可能跟论坛系统软件有关系。你用电脑就可以看到。
回复

收藏343 举报

蓝魔大师 发表于 2014-10-19 17:48 | 显示全部楼层
学习学习，，，，，，，，，，
回复

收藏343 举报

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

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

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

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

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

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


  2. 

  3. sbit  LCDCS_dr  = P1^6;  //片选线
    

  4. sbit  LCDSID_dr = P1^7;  //串行数据线
    

  5. sbit  LCDCLK_dr = P3^2;  //串行时钟线
    

  6. sbit  LCDRST_dr = P3^4;  //复位线
    


  7. 

  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);
    


  19. 


  20. 

  21. void initial_myself();    
    

  22. void initial_peripheral();
    


  23. 


  24. 

  25. void lcd_display_service(void); //应用层面的液晶屏显示程序
    

  26. void clear_all_canvas(void);  //把画布全部清零
    


  27. 

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


  34. 

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


  41. 

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


  48. 

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


  55. 

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


  62. 

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


  69. 

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


  76. 


  77. 

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


  84. 

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


  91. 

  92. code unsigned char Zf816_9[]= 
    

  93. {
    

  94. /*--  文字:  9  --*/
    

  95. /*--  宋体12;  此字体下对应的点阵为：宽x高=8x16   --*/
    

  96. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
    

  97. };
    


  98. 


  99. 

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


  104. 


  105. 

  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, 
    


  123. 

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


  125. 

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


  135. 


  136. 

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


  138. 


  139. 

  140. /* 注释二：
    

  141.  * 以下变量就是本程序的任意变量，网友可以自己更改它的大小来测试本程序，不要超过255.
    

  142.  */
    

  143. unsigned char ucAnyNumber=218;  //任意变量默认初始化为218。
    


  144. 


  145. 

  146. void main() 
    

  147.   {
    

  148.         initial_myself();      //第一区,上电后马上初始化
    

  149.         delay_long(100);       //一线，延时线。延时一段时间
    

  150.         initial_peripheral();  //第二区,上电后延时一段时间再初始化
    


  151. 

  152.         while(1)   //第三区
    

  153.         { 
    

  154.             lcd_display_service(); //应用层面的液晶屏显示程序
    

  155.         }
    


  156. 

  157. }
    


  158. 


  159. 

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

  161. {
    

  162.     ;
    

  163. }
    

  164. void initial_peripheral() //第二区 上电后延时一段时间再初始化
    

  165. {
    

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

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

  168. }
    


  169. 


  170. 


  171. 

  172. /* 注释三：
    

  173.  * 本程序的核心转换函数。
    

  174.  * 是可以把一位任意数字变量的函数转换成对应的字模，由于字模是数组，所以返回的是指针，代表字模数组的首地址。
    

  175.  */
    

  176. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
    

  177. {
    

  178.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小，分别调用不同的字库。
    


  179. 

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


  219. 

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

  221. }
    


  222. 


  223. 

  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; //分解变量的百位
    


  229. 

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

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

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


  233. 

  234.     if(ucDisplayUpdate==1)  //需要更新显示
    

  235.     {
    

  236.        ucDisplayUpdate=0;  //及时把标志清零，避免一直处于不断更新的状态。
    


  237. 

  238.            if(ucAnyNumber>=100) //有3位数以上
    

  239.            {
    

  240.            ucAnyNumber_100=ucAnyNumber/100; //百位
    

  241.        }
    

  242.            else //否则显示空
    

  243.            {
    

  244.                ucAnyNumber_100=10;  //在下面的转换函数中，代码10表示空字模
    

  245.            }
    


  246. 

  247.            if(ucAnyNumber>=10) //有2位数以上
    

  248.            {
    

  249.            ucAnyNumber_10=ucAnyNumber%100/10;  //十位
    

  250.        }
    

  251.            else //否则显示空
    

  252.            {
    

  253.                ucAnyNumber_10=10;  //在下面的转换函数中，代码10表示空字模
    

  254.            }
    


  255. 

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


  257. 

  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); //把数字转换成字模首地址
    


  261. 

  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);//把个的字模插入画布
    


  266. 

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

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

  269.     }
    

  270. }
    


  271. 


  272. 


  273. 

  274. void clear_all_canvas(void)  //把画布全部清零
    

  275. {
    

  276.    unsigned int j=0;
    

  277.    unsigned int i=0;
    


  278. 

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


  286. 

  287. }
    


  288. 


  289. 


  290. 


  291. 


  292. 

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

  294. {    
    


  295. 

  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); //开显示缓冲指令
    


  311. 

  312. }
    


  313. 

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


  343. 

  344. }
    


  345. 

  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;
    


  361. 

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


  382. 


  383. 


  384. 


  385. 

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


  403. 

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


  410. 


  411. 

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

  413. {
    


  414. 

  415.         LCDCS_dr = 0;
    

  416.         LCDCS_dr = 1;
    

  417.         SPIWrite(ucCommand, 0);
    

  418.         delay_short(90); 
    

  419. }
    


  420. 

  421. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
    

  422. {
    

  423.         LCDCS_dr = 0;
    

  424.         LCDCS_dr = 1;
    

  425.         SPIWrite(ucData, 1);
    

  426. }
    


  427. 

  428. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
    

  429. {
    

  430.         LCDRST_dr = 1;  //复位
    

  431.         LCDRST_dr = 0;
    

  432.         LCDRST_dr = 1;
    

  433. }
    


  434. 


  435. 


  436. 

  437. void delay_short(unsigned int uiDelayShort) //延时函数
    

  438. {
    

  439.    unsigned int i;  
    

  440.    for(i=0;i<uiDelayShort;i++)
    

  441.    {
    

  442.      ;  
    

  443.    }
    

  444. }
    


  445. 


  446. 

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

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

收藏343 举报

lsc201100 发表于 2014-10-24 09:01 | 显示全部楼层
      复杂啊，眼花。
回复

收藏343 举报

jimiy123 发表于 2014-10-24 11:39 | 显示全部楼层
鸿哥，我是学自动化的，刚毕业，也学习单片机，在学校里面单片机没怎么学好，工作后，感觉到压力很大，不知道该怎么办，自己买了STC51单片机在摸索，也没人带我，就自己一个人学习，连接，敲代码，仿真，我今年都24了，现在把大学里的大学里的单片机拿过来再学习一遍，感觉有点小小的迷茫，现在在这家公司，2500一个月，硬件设施也不齐全，我是很想做项目搞技术，真想有人能指导我一下，带带我，看您发了那么多，都不知道该从哪里去学，也不知道从头学来未来怎么样，将来从事单片机行业的前景怎么样？
鸿哥，您是过来人，能指导一下我吗？
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-10-24 14:42 | 显示全部楼层
本帖最后由 jianhong_wu 于 2014-10-24 14:43 编辑
jimiy123 发表于 2014-10-24 11:39
鸿哥，我是学自动化的，刚毕业，也学习单片机，在学校里面单片机没怎么学好，工作后，感觉到压力很大，不知 ...

（1）如何学好单片机？我还是建议你买一套朱兆祺的51学习板，然后跟着我的连载帖子去学，只要把我的按键，数码管，跑马灯，串口搞懂了，基本上你就会掌握了做项目的核心程序框架。朱兆祺的51学习板你可以在淘宝上搜索到。
（2）单片机的前景怎么样？行行出状元，单片机毕竟是一个技术工具，它的前途有多大取决你把它应用在哪些行业，取决于你在什么样的公司岗位。但是我觉得单片机是电子行业的基础与核心，如果从事电子行业，单片机还是必须要懂的。
回复

收藏343 举报

chen125318 发表于 2014-10-25 12:52 | 显示全部楼层
我现在大四 正在找工作 学的电子信息工程  现在找工作遇到一个大问题就是我英语四级没过 很多公司简历都过不了 好伤心 单片机我也算是很熟悉 一些比赛题目基本一个人就能稳稳的搞定 stm32也在学 但是这个简历都直接被刷了 又比较内向不太会表达 面试发挥又差展示不出自己的东西 哎 最近好痛苦 说出来发泄发泄好受一点
回复

收藏343 举报

cjseng 发表于 2014-10-25 12:59 | 显示全部楼层
chen125318 发表于 2014-10-25 12:52
我现在大四 正在找工作 学的电子信息工程  现在找工作遇到一个大问题就是我英语四级没过 很多公司简历都过 ...

找工作要看英语4级成绩吗？你难道要去外资公司。
回复

收藏343 举报

chen125318 发表于 2014-10-25 13:05 | 显示全部楼层
cjseng 发表于 2014-10-25 12:59
找工作要看英语4级成绩吗？你难道要去外资公司。

国企央企基本硬性要求四级，比较大的私企跟国企央企一样。其他的小企业有不要求四级的但是要求你能力够强
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-10-25 13:27 | 显示全部楼层
chen125318 发表于 2014-10-25 12:52
我现在大四 正在找工作 学的电子信息工程  现在找工作遇到一个大问题就是我英语四级没过 很多公司简历都过 ...

我06年毕业的时候英语四级对毕业生找工作是很重要的，那时我大二的时候英语就过了四级。对于搞电子行业的人来说，英语的阅读能力确实太重要了。即使不为了证书，英语能力还是要过关的。另外，也有一些公司不看四级证书的，尤其是一些小公司。找工作很多时候也看运气，运气来了，可能就找到适合自己的。看开点，不要太难过。
回复

收藏343 举报

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

本版积分规则

快速回复 在线客服 返回列表 返回顶部