21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 用单片机IO口直接驱动段式LCD的方法
返回列表 发新帖我要提问

[应用方案] 用单片机IO口直接驱动段式LCD的方法

[复制链接]
2682|2
 楼主| 734774645 发表于 2018-10-29 16:19 | 显示全部楼层 |阅读模式
IO, 段式LCD, 用单片机, 直接驱动, COM
用IO口驱动段式LED（数码管）的方法相信大家比较清楚，但用IO口直接驱动段式LCD的方法相对复杂一些。在网上搜了一下单片机IO口驱动段式LCD的方法，大部分资料讲得不够清晰、具体，而且简单问题复杂化。后来查了LCD的显示原理，结合网上的相关介绍，发现IO口直接驱动段式LCD原理比较简单，用几句话就可以描述清楚：
1.       LCD和LED的显示原理不一样：LED是加正向电压发光，而LCD必须交替加正、反向电压才会持续显示（可以做个实验，如果把恒定电压加到LCD的一段上，该段会显示一下，但马上不能显示，而且长时间加恒定电压，会加速LCD的老化和损坏）
2.       常听说1/2bias，1/3bias LCD，是什么意思呢？对于1/2bias LCD，假如LCD的显示电压是3V，则1/2bias是1.5V，也就是说在±3V电压作用时，LCD有显示；±1.5V及以下的电压作用时没有显示
3.       普通单片机IO口不能直接输出半高电平（1.5V），但可以用相等的上下拉电阻实现，当IO口设置为输入（高阻）时，由于上下拉电阻的分压作用，则产生一个半高电平（1.5V）

知道了以上3点后，动态驱动LCD就不是难事了，对于4*8段的LCD（4个COM，8个SEG，显示电压为3V，1/2bias），驱动方法如下：
1、  四个COM采用交替扫描的方式，每个COM在相邻两次扫描时又进行电压交变的方式。
2、  若扫描到某一个COM时，该COM输出3V（0V）:
与该COM相连的SEG输出与COM相反，ΔV=±3V，则该相连点亮；
与该COM相连的SEG输出与COM相同，ΔV=0，则该相连点不亮。
3、其他没有扫描到的COM，单片机IO口为输入，从而产生1/2 bias（1.5V），不管SEG为何值，ΔV<±1.5V，故该点不亮。

本人用4*8段的LCD自制了一个数字钟表，验证了以上方法的可行性，现把制作过程罗列如下
1.       原理图
20160909094240876.jpg
说明：由于管脚不够用，所以时钟芯片DS1302的RST和LCD的一个SEG是复用的，只要在这个SEG无效的时候去读取时间就可以了，另外，3PIN串口是ISP下载程序用的。
2.       备料
20160909094240467.jpg

3.       焊接
20160909094241239.jpg
4.       实验结果
20160909094241336.jpg
5.       不足之处
通过实验结果可以发现，不显示的SEG也有阴影
原因分析：纽扣电池电压3.7V，1/2bias是1.85V，大于1.5V，所以会出现阴影。
解决办法：选择工作电压小于3V的单片机和电压等于3V的电池（如2节干电池）


回复

收藏1 举报

相关帖子
 楼主| 734774645 发表于 2018-10-29 16:20 | 显示全部楼层
6. 程序源代码
复制
  1. /******************************************************************
    

  2. 段式LCD驱动实验             
    

  3. 外部晶体：12MHz 
    

  4. *****************************************************************/
    


  5. 

  6. #include <reg52.h>
    

  7. #include <stdio.h>
    


  8. 

  9. //管脚定义
    

  10. sbit COM0=P3^5;
    

  11. sbit COM1=P3^4;
    

  12. sbit COM2=P3^3;
    

  13. sbit COM3=P3^2;
    

  14. sbit BI_4=P3^7;
    

  15. sbit RTC_CLK=P3^0;
    

  16. sbit RTC_IO=P3^1;
    

  17. sbit RTC_RST=P3^7;   //复用
    


  18. 

  19. //P3口模式寄存器
    

  20. sfr P3M1=0xb1;
    

  21. sfr P3M0=0xb2;
    


  22. 

  23. //当前时间（BCD码）：秒、分、时、日、月、星期、年
    

  24. unsigned char ClockBuffer[8]={0x34,0x12,0x08,0x20,0x03,0x05,0x09};
    


  25. 

  26. //0～9的段码查询表
    

  27. //位序 D7 D6 D5 D4 D3 D2 D1 D0
    

  28. //段   A  B  C  D  E  F  G  DOT 
    

  29. code unsigned char seg_code[10]={~0x03,~0x9f,~0x25,~0x0d,~0x99,~0x49,~0x41,~0x1f,~0x01,~0x09};
    


  30. 

  31. unsigned char ScanCoun=0;                  //动态扫描显示位数计数器
    

  32. unsigned char DisplayBuf[4]={1,2,3,4};               //4位数字对应的显示暂存
    


  33. 

  34. //段码缓冲区
    

  35. unsigned char SegBuf[4]={0x00,0x00,0x00,0x00};//COM1、COM2、COM3、COM4的段码
    

  36. bit bi_4a=0; //COM0对应的4a
    

  37. bit bi_4b=0; //COM1对应的4a
    

  38. bit bi_4c=0; //COM2对应的4a
    


  39. 

  40. //延时
    

  41. void dly(unsigned char x)
    

  42.    {unsigned char i;
    

  43.     for (i=0; i<x; i++);
    

  44.     }
    


  45. 

  46. //ds1302写1字节
    

  47. void rtc_wt_byte(unsigned char sent_buf)
    

  48.          {unsigned char i;
    

  49.           for (i=0; i<8; i++)
    

  50.               {RTC_CLK=0;
    

  51.                if (sent_buf&0x01) RTC_IO=1;
    

  52.                else RTC_IO=0;
    

  53.                RTC_CLK=1;
    

  54.                dly(5);
    

  55.                sent_buf=sent_buf>>1;
    

  56.                }
    

  57.               RTC_CLK=0;
    

  58.               dly(5);
    

  59.            }
    


  60. 

  61. //ds1302读1字节
    

  62. unsigned char rtc_rd_byte(void)
    

  63.           {unsigned char i,read_buf;
    

  64.            RTC_IO=1;         //RTC_IO置1，保证为输入状态
    

  65.            for (i=0; i<8; i++)
    

  66.                {read_buf=read_buf>>1;
    

  67.                        RTC_CLK=0;
    

  68.                        dly(5);
    

  69.                 if (RTC_IO) read_buf=read_buf|0x80;
    

  70.                 else read_buf=read_buf&0x7f;
    

  71.                 RTC_CLK=1;
    

  72.                 dly(5);
    

  73.                }
    

  74.            RTC_CLK=0;
    

  75.            dly(5);
    

  76.            return read_buf;
    

  77.           }
    


  78. 

  79. //ds1302写入时间
    

  80. void rtc_wr_time(unsigned char *p_wt_time)
    

  81.            {unsigned char i;
    

  82.             unsigned char tmp1;
    

  83.             dly(30);
    

  84.             RTC_RST=1;
    

  85.             rtc_wt_byte(0xbe);         //burst写入时间
    

  86.             for (i=0; i<8; i++)
    

  87.                   {tmp1=*p_wt_time++;
    

  88.                    rtc_wt_byte(tmp1);
    

  89.                    }
    

  90.             RTC_CLK=0;
    

  91.             RTC_RST=0;
    

  92.            }
    


  93. 

  94. //ds1302读出时间
    

  95. void rtc_rd_time(unsigned char *p_rd_time)
    

  96.            {unsigned char i;
    

  97.             unsigned char tmp1;
    

  98.             dly(30);
    

  99.             RTC_RST=1;
    

  100.             rtc_wt_byte(0xbf);        //burst读取时间
    


  101. 

  102.             RTC_IO=1;
    

  103.             for (i=0; i<8; i++)
    

  104.                   {tmp1=rtc_rd_byte();
    

  105.                    *p_rd_time++=tmp1;
    

  106.                   }
    


  107. 

  108.             RTC_CLK=0;
    

  109.             RTC_RST=0;
    

  110.            }
    


  111. 


  112. 

  113. //ds1302初始化
    

  114. void ini_rtc()
    

  115.          {RTC_CLK=0;
    

  116.           RTC_RST=0;
    

  117.           dly(30);
    

  118.           
    

  119.           RTC_RST=1;                
    

  120.           rtc_wt_byte(0x8e);        //写CONTROL寄存器
    

  121.           rtc_wt_byte(0x00);        //值:去掉写保护
    

  122.           RTC_RST=0;                //复位
    


  123. 

  124.           RTC_RST=1;                //正常工作
    

  125.           rtc_wt_byte(0x90);        //写TRICKLE CHARGER寄存器
    

  126.           rtc_wt_byte(0xa9);        //值:使能充电，串联2个二极管，串联2k欧姆的电阻
    


  127. 

  128.           RTC_CLK=0;
    

  129.           RTC_RST=0;
    

  130.          }
    


  131. 


  132. 

  133. //把4位数字的SEG放到COM1、COM2、COM3、COM4对应的段码
    

  134. //LCD的管脚定义与LED不同，它不是一个COM对应一位数字，而是对应每个数字的一部分SEG
    

  135. // 1   2   3   4   5   6   7   8   9  10  11  12  13  14  15 
    

  136. // <  1f  1a  2f  2a      3f  3a  4f  4a   >              --   ---- COM0 
    

  137. // <  1g  1b  2g  2b      2g  3b  4g  4b   >          --       ---- COM1 
    

  138. // <  1e  1c  2e  2c   :  3e  3c  4e  4c   >      --           ---- COM2 
    

  139. //    1d  1h  2d  2h      3d  3h  4d          --               ---- COM3
    

  140. void Seg2Seg()
    

  141. {unsigned char SegXX;
    


  142. 

  143.  SegBuf[0]=0;
    

  144.  SegBuf[1]=0;
    

  145.  SegBuf[2]=0x08;
    

  146.  SegBuf[3]=0;
    

  147.  bi_4a=0;
    

  148.  bi_4b=0;
    

  149.  bi_4c=0;
    

  150.         
    

  151.  SegXX=seg_code[DisplayBuf[0]];      //第1位数字
    

  152.  if (SegXX&0x80) SegBuf[0]|=0x40;
    

  153.  if (SegXX&0x40) SegBuf[1]|=0x40;
    

  154.  if (SegXX&0x20) SegBuf[2]|=0x40;
    

  155.  if (SegXX&0x10) SegBuf[3]|=0x80;
    

  156.  if (SegXX&0x08) SegBuf[2]|=0x80;
    

  157.  if (SegXX&0x04) SegBuf[0]|=0x80;
    

  158.  if (SegXX&0x02) SegBuf[1]|=0x80;
    

  159.  if (SegXX&0x01) SegBuf[3]|=0x40;
    

  160.  
    

  161.   SegXX=seg_code[DisplayBuf[1]];    //第2位数字
    

  162.  if (SegXX&0x80) SegBuf[0]|=0x10;
    

  163.  if (SegXX&0x40) SegBuf[1]|=0x10;
    

  164.  if (SegXX&0x20) SegBuf[2]|=0x10;
    

  165.  if (SegXX&0x10) SegBuf[3]|=0x20;
    

  166.  if (SegXX&0x08) SegBuf[2]|=0x20;
    

  167.  if (SegXX&0x04) SegBuf[0]|=0x20;
    

  168.  if (SegXX&0x02) SegBuf[1]|=0x20;
    

  169.  if (SegXX&0x01) SegBuf[3]|=0x10;
    

  170.  
    

  171.  
    

  172.   SegXX=seg_code[DisplayBuf[2]];   //第3位数字
    

  173.  if (SegXX&0x80) SegBuf[0]|=0x02;
    

  174.  if (SegXX&0x40) SegBuf[1]|=0x02;
    

  175.  if (SegXX&0x20) SegBuf[2]|=0x02;
    

  176.  if (SegXX&0x10) SegBuf[3]|=0x04;
    

  177.  if (SegXX&0x08) SegBuf[2]|=0x04;
    

  178.  if (SegXX&0x04) SegBuf[0]|=0x04;
    

  179.  if (SegXX&0x02) SegBuf[1]|=0x04;
    

  180.  if (SegXX&0x01) SegBuf[3]|=0x02;
    

  181.  
    

  182.   SegXX=seg_code[DisplayBuf[3]];   //第4位数字
    

  183.  if (SegXX&0x80) bi_4a=1;
    

  184.  if (SegXX&0x40) bi_4b=1;
    

  185.  if (SegXX&0x20) bi_4c=1;
    

  186.  if (SegXX&0x10) SegBuf[3]|=0x01;
    

  187.  if (SegXX&0x08) SegBuf[2]|=0x01;
    

  188.  if (SegXX&0x04) SegBuf[0]|=0x01;
    

  189.  if (SegXX&0x02) SegBuf[1]|=0x01;
    


  190. 

  191. }
    


  192. 


  193. 

  194. /*一个BCD码转化成两个十进制数（如：0x79转化成0x07和0x09）*/
    

  195. BcdToDec(unsigned char BcdValue,unsigned char *pDecValue)
    

  196.        {//if (BcdValue>=0x9a||(BcdValue&0x0f)>=0x0a) return 0;
    

  197.                *pDecValue++=(BcdValue&0xf0)>>4;
    

  198.         *pDecValue=BcdValue&0x0f;
    

  199.         //return 1;
    

  200.        }
    


  201. 

  202. //初始化MCS51内部资源
    

  203. InitInterResource()
    

  204.        {IE=0;       //关全部中断
    

  205.         TCON=0;     //清全部中断请求
    

  206.         IP=0;       //清中断优先级   
    


  207. 

  208.         TMOD=0x01;  //T0工作方式1（16位定时器）
    

  209.         TH0=0x00;   //T0定时器辅初值
    

  210.         TL0=0x00;
    

  211.         TR0=1;      //允许T0定时
    

  212.         ET0=1;      //允许T0中断
    

  213.         EA=0;       //关全局中断
    

  214.         
    

  215.         RTC_RST=0;
    

  216.        }
    


  217. 


  218. 


  219. 


  220. 

  221. void main()
    

  222.     {    
    

  223.      InitInterResource();
    

  224.          
    

  225.      ini_rtc();                    //初始化DS1302
    

  226.      rtc_wr_time(ClockBuffer);     //写入时间初始值
    


  227. 

  228.      EA=1;         //开全局中断
    

  229.      while(1)
    

  230.         {         
    

  231.         }
    

  232.     }
    


  233. 


  234. 

  235. //定时器0中断服务程序，5ms定时器，4位数码管动态显示驱动
    

  236. void tmr0_p(void) interrupt 1
    

  237.     {
    

  238.      TL0=0x78;     //重新定时5ms
    

  239.      TH0=0xec;
    

  240.      Seg2Seg();
    

  241.      P3M1=0x3c;
    

  242.      P3M0=0x00;
    

  243.           switch(ScanCoun)                //动态扫描显示
    

  244.          { 
    

  245.           case 0:                        //COM0正向驱动
    

  246.           P1= SegBuf[0];
    

  247.           BI_4= bi_4a;
    

  248.           COM0=0;           
    

  249.           P3M1=0x1c;                      //除COM0输出外，其余COM设为输入
    

  250.           P3M0=0x00; 
    

  251.           break;
    

  252.           
    

  253.           case 1:                       //COM0反向驱动
    

  254.           P1= ~SegBuf[0];
    

  255.           BI_4= ~bi_4a;
    

  256.           COM0=1;              
    

  257.           P3M1=0x1c;
    

  258.           P3M0=0x00;
    

  259.           break;
    

  260.           
    

  261.           
    

  262.           case 2:                       //COM1正向驱动
    

  263.           P1= SegBuf[1];
    

  264.           BI_4= bi_4b;
    

  265.           COM1=0;             
    

  266.           P3M1=0x2c;
    

  267.           P3M0=0x00;
    

  268.           break;
    

  269.           
    

  270.           case 3:                       //COM1反向驱动
    

  271.           P1= ~SegBuf[1];
    

  272.           BI_4= ~bi_4b;
    

  273.           COM1=1;                  
    

  274.           P3M1=0x2c;
    

  275.           P3M0=0x00;
    

  276.           break;
    

  277.           
    

  278.           
    

  279.           case 4:                       //COM2正向驱动
    

  280.           P1= SegBuf[2];
    

  281.           BI_4= bi_4c;
    

  282.           COM2=0;                   
    

  283.           P3M1=0x34;
    

  284.           P3M0=0x00;
    

  285.           break;
    

  286.           
    

  287.           case 5:                       //COM2反向驱动
    

  288.           P1= ~SegBuf[2];
    

  289.           BI_4= ~bi_4c;
    

  290.           COM2=1;                  
    

  291.           P3M1=0x34;
    

  292.           P3M0=0x00;
    

  293.           break;
    

  294.           
    

  295.           case 6:                       //COM3正向驱动
    

  296.           P1= SegBuf[3];
    

  297.           COM3=0;                   
    

  298.           P3M1=0x38;
    

  299.           P3M0=0x00;
    

  300.           
    

  301.           RTC_RST=0;
    

  302.           rtc_rd_time(ClockBuffer);    //读时间
    

  303.           BcdToDec(ClockBuffer[0],DisplayBuf+2);     //秒送入显示缓冲
    

  304.           BcdToDec(ClockBuffer[1],DisplayBuf);       //分送入显示缓冲
    

  305.           BI_4= ~bi_4c;
    

  306.           break;
    

  307.           
    

  308.           case 7:                       //COM3反向驱动
    

  309.           P1= ~SegBuf[3];
    

  310.           COM3=1;                   
    

  311.           P3M1=0x38;
    

  312.           P3M0=0x00;
    

  313.           
    

  314.           break;
    

  315.           
    

  316.          }
    


  317. 

  318.      ScanCoun++;       //下一位
    

  319.      if (ScanCoun>7) ScanCoun=0;       
    

  320.      }


回复

收藏1 举报

 楼主| 734774645 发表于 2018-10-29 16:20 | 显示全部楼层
我看有人问普通单片机IO怎么驱动LCD，我也不会，我网上找了个，转来给需要的。
回复

收藏1 举报

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

本版积分规则

734774645

211

主题

3588

帖子

15

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