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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › LCD1602如何连续输入?附单片机程序
返回列表 发新帖
查看: 2121|回复: 5
收起左侧

LCD1602如何连续输入?附单片机程序

[复制链接]
ID:652716 发表于 2020-1-22 15:39 | 显示全部楼层 |阅读模式
#include"reg52.h"
#define led P0           //定义led数码管连在P0口
#define key P3                          //定义矩阵键盘连在P3口
#define LCD1602_D P0              //lcd I/O口连在P0口
#define uchar unsigned char
#define uint unsigned int
sbit E=P3^4;                              //定义lcd端口
sbit RW=P3^6;
sbit RS=P3^5;
void LcdWriteCom(uchar com);          //函数声明
void WriteDat(uchar dat);
void Lcdxs(uchar x,uchar y,uchar dat);
uchar code lcd[]={0x2f,0x2a,0x2d,0x2b,0x3d,0x39,0x36,0x33,0x30,0x38,0x35,0x32,0x2e,0x37,0x34,0x31};    //   123+456-789*#0/=
                          //   /        *         -          +           =        9        6          3           0        8         5         2           .        7         4         1
uchar a,c;                                       
void delay(uint i)           //延时函数
{
  while(i--)
  {;}
}
void keydownup()        //矩阵按键扫描程序
{
char b=0;
key=0x0f;
if(key!=0x0f)
{
  delay(1000);                 //延时消抖
  if(key!=0x0f)
  {
   key=0x0f;                           //检测列  使高四位为低，低四位为高，判断低四位是否有低电平出现（有则key!=0x0f）
   switch(key)
   {
    case 0x07:a=0;break;
        case 0x0b:a=1;break;
        case 0x0d:a=2;break;
        case 0x0e:a=3;break;
   }
   key=0xf0;                          //检测行  使高四位为高，低四位为低，判断高四位是否有低电平出现（有则key!=0xf0）
   switch(key)
   {
    case 0x70:a=a;   break;
        case 0xb0:a=a+4; break;
        case 0xd0:a=a+8; break;
        case 0xe0:a=a+12;break;
   }
   while((b<50)&&key!=0xf0)           //判断按键按下后是否松开  超时或者按键松开则跳出循环
   {
    delay(1000);
        b++;
   }
  }
}
}
void LcdWriteCom(uchar com)                    //写指令函数
{
E=0;                                 //允许使能
RS=0;                                 //指令
RW=0;                                 //写入
LCD1602_D=com;
delay(1);
E=1;                                   //写入时序
delay(1);
E=0;
}
void WriteDat(uchar dat)                       //写数据函数
{
E=0;                                 //允许使能
RS=1;                                 //数据
RW=0;                                 //写入
LCD1602_D=dat;
delay(1);
E=1;                                   //写入时序
delay(1);
E=0;
}
void Lcdxs(uchar x,uchar y,uchar dat)          //显示一个字符的函数
{
uchar t;
if(y==1)
   t=0x80+x;
else
   t=0xc0+x;
LcdWriteCom(t);
WriteDat(dat);
}
void main()
{
LcdWriteCom(0x38);          //开显示
LcdWriteCom(0x0c);          //开显示不开光标
LcdWriteCom(0x06);          //写一个指针加1
LcdWriteCom(0x01);          //清屏
delay(100);
while(1)
{
  keydownup();                //矩阵按键扫描程序
  Lcdxs(0,1,lcd[a]);    //显示按键按下后数组中对应的值

}
}
怎么改，让他连续输入

回复

使用道具 举报

ID:97554 发表于 2020-1-23 14:55 | 显示全部楼层

lcdxs(0,1,lcd[a])

设置一个变量K，按键每按一下K+1

lcdxs(0,k,lcd[a])
回复

使用道具 举报

ID:155507 发表于 2020-1-23 19:21 | 显示全部楼层
我给你来个程序参考

  1. #include<reg52.h>
  2. #include<math.h>
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5. #define lcddata P1

  7. sbit LCDRS   = P3^3;
  8. sbit LCDRW   = P3^4;
  9. sbit LCDEN   = P3^5;
  10. sbit beep    = P3^7;
  11. sbit zhongduan   = P3^2;
  12. sbit kaifang =  P0^6;
  13. sbit cifang  = P0^7;
  14. sbit qingling=P0^5;
  15. sbit kaiguan=P0^4;

  17. uchar keyscan1(void);
  18. void keyscan(void);
  19. void count(void);
  20. void anjianshibie();
  21. void write_com(uchar i);
  22. void write_data(uchar i);
  23. void write_string(uchar *s);
  24. void write_num(long n);
  25. void lcdwrite_float(float n);
  26. void lcd_init(void);
  27. void xinxing();

  29. void delayms(uint z)
  30. {
  31.         uint x,y;
  32.         for(x=z;x>0;x--)
  33.            for(y=110;y>0;y--);
  34. }

  36. uchar code table[]=
  37. {
  38.         1,2,3,0x2b-0x30,                         // 1,   2,   3,    +
  39.         4,5,6,0x2d-0x30,                         // 4,   5,   6,    -
  40.         7,8,9,0x2a-0x30,                         // 7,   8,   9,    x
  41.         0,0x3d-0x30,0x2e-0x30,0x2f-0x30          // 0,   =,   清零, /
  42. };
  43. uchar code table1[]={0x03,0x07,0x0f,0x1f,0x1f,0x1f,0x1f,0x1f,
  44.         0x18,0x1E,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,
  45.         0x07,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,
  46.         0x01,0x18,0x1c,0x1e,0x1e,0x1e,0x1e,0x1e,
  47.         0x0f,0x07,0x03,0x01,0x00,0x00,0x00,0x00,
  48.         0x1f,0x1f,0x1f,0x1f,0x1f,0x0f,0x07,0x01,
  49.         0x1f,0x1f,0x1f,0x1f,0x1f,0x1c,0x18,0x00,
  50.         0x1c,0x18,0x10,0x00,0x00,0x00,0x00,0x00
  51. };
  52. uchar num='N',flag=0,flag1=0,flag2=0,fuhao=0,temp=0,shu[18]={0},beepflag=1,y=0,j;
  53. float a=0,b=0,c=0,d,point=0;

  55. void main()
  56. {        
  57.         xinxing();
  58.         delayms(1000);
  59.         write_com(0x01);
  60.         write_com(0x80);
  61.         EA=1;          //全局中断开
  62.         EX0=1;         //外部中断0开
  63.         IT0=0;         //电平触发（边沿触发IT0=1；）
  64.         while(1)
  65.         {     
  66.                 keyscan();  
  67.                 anjianshibie();         
  68.         }
  69. }

  71. /*按键检测*/
  72. uchar keyscan1(void)  //键盘扫描函数，使用行列反转扫描法
  73. {
  74.         unsigned char cord_h,cord_l;//行列值中间变量
  75.         P2=0x0f;            //行线输出全为0
  76.         cord_h=P2&0x0f;     //读入列线值
  77.         if(cord_h!=0x0f)    //先检测有无按键按下
  78.         {
  79.                 delayms(10);        //去抖
  80.                 if((P2&0x0f)!=0x0f)
  81.                 {
  82.                         if(beepflag==1)  //若开声音则每一次按键均鸣叫
  83.                         {
  84.                                 beep=0;
  85.                                 delayms(50);
  86.                                 beep=1;
  87.                         }
  88.                         cord_h=P2&0x0f;  //读入列线值
  89.                         P2=cord_h|0xf0;  //输出当前列线值
  90.                         cord_l=P2&0xf0;  //读入行线值
  91.                         while((P2&0xf0)!=0xf0); //等待松开并输出
  92.                         return(cord_h+cord_l);  //键盘最后组合码值
  93.                 }
  94.         }
  95.         return(0xff);     //返回该值
  96. }
  97. void keyscan()
  98. {
  99.         switch(keyscan1())
  100.         {
  101.         case 0xEE:num=0;break;
  102.         case 0xDE:num=1;break;
  103.         case 0xBE:num=2;break;
  104.         case 0x7E:num=3;break;
  105.         case 0xED:num=4;break;
  106.         case 0xDD:num=5;break;
  107.         case 0xBD:num=6;break;
  108.         case 0x7D:num=7;break;
  109.         case 0xEB:num=8;break;
  110.         case 0xDB:num=9;break;
  111.         case 0xBB:num=10;break;
  112.         case 0x7B:num=11;break;
  113.         case 0xE7:num=12;break;
  114.         case 0xD7:num=13;break;
  115.         case 0xB7:num=14;break;
  116.         case 0x77:num=15;break;   
  117.         }
  118. }
  119. /*按键识别函数*/
  120. void anjianshibie()
  121. {
  122.         if(num==0||num==1||num==2||num==4||num==5||num==6||num==8||num==9||num==10||num==12||num==14)
  123.         {
  124.                 if(temp>=2)
  125.                 {
  126.                         write_com(0x01);
  127.                         write_string("math error");
  128.                 }
  129.                 else
  130.                 {
  131.                         if(flag==0)
  132.                         {
  133.                                 if(num==14)
  134.                                 {flag2=1;}
  135.                                 if(num!=14&&flag2==0)
  136.                                 {a=a*10+table[num];}
  137.                                 if(num!=14&&flag2==1)
  138.                                 {
  139.                                         y++;
  140.                                         point=table[num]*pow(0.1,y);
  141.                                         a=a+point;         
  142.                                 }                                                                                  
  143.                                 write_data(0x30+table[num]);
  144.                                 delayms(5);
  145.                         }
  146.                         if(flag==1)
  147.                         {
  148.                                 if(num==14)
  149.                                 {flag2=1;}
  150.                                 if(num!=14&&flag2==0)
  151.                                 {b=b*10+table[num];}
  152.                                 if(num!=14&&flag2==1)
  153.                                 {
  154.                                         y++;
  155.                                         point=table[num]*pow(0.1,y);
  156.                                         b=b+point;         
  157.                                 }                                                                                  
  158.                                 write_data(0x30+table[num]);
  159.                                 delayms(5);                       
  160.                         }
  161.                 }
  162.                 num='N';           //一定要加这个，否则会出现满屏的按键对应的数
  163.         }
  164.         if(num==3||num==7||num==11||num==15)
  165.         {
  166.                 flag=1;
  167.                 flag2=0;
  168.                 y=0;
  169.                 temp++;//判断运算符号按下的个数
  170.                 switch(num)
  171.                 {
  172.                 case 3:fuhao=1;break;                 //加
  173.                 case 7:fuhao=2;break;                 // 减
  174.                 case 11:fuhao=3;break;             // 乘
  175.                 case 15:fuhao=4;break;                 // 除
  176.                 }
  177.                 write_data(0x30+table[num]);
  178.                 num='N';                       
  179.         }
  180.         if(num==13)           //13等号，14清零
  181.         {              
  182.                 temp=0;     //temp清零
  183.                 flag=0;
  184.                 flag2=0;     
  185.                 if(flag1==0)
  186.                 {write_com(0x80+0x40);}
  187.                 write_data(0x30+table[num]);
  188.                 delayms(5);                  
  189.                 count();           //计算c的值
  190.                 /*     if(c==0)
  191.                         {
  192.                                 write_com(0x80+0x41);//如果c为零，直接在等号后边显示出来
  193.                                 write_data(0x30);
  194.                         }
  195.                 if(c>0)
  196.                         {
  197.                                 d=c;
  198.                         }
  199.                 if(c<0)
  200.                         {
  201.                                 d=0-c;
  202.                                 write_data(0x2d);        //把小数点显示出来
  203.                         }  */
  204.                 lcdwrite_float(c);
  205.                 flag1++;                                                                         
  206.                 num='N';
  207.         }
  208.         if(kaifang==0)
  209.         {
  210.                 delayms(10);
  211.                 if(kaifang==0)                //去抖
  212.                 {
  213.                         if(beepflag==1)  //若开声音则每一次按键均鸣叫
  214.                         {
  215.                                 beep=0;
  216.                                 delayms(50);
  217.                                 beep=1;
  218.                         }
  219.                         temp++;
  220.                         flag=1;
  221.                         flag2=0;
  222.                         y=0;
  223.                         write_data(0xe8);
  224.                         fuhao=5;
  225.                 }
  226.                 while(!kaifang);        //按键释放
  227.         }
  228.         if(cifang==0)
  229.         {
  230.                 delayms(10);                          // 去抖
  231.                 if(cifang==0)
  232.                 {
  233.                         if(beepflag==1)  //若开声音则每一次按键均鸣叫
  234.                         {
  235.                                 beep=0;
  236.                                 delayms(50);
  237.                                 beep=1;
  238.                         }
  239.                         temp++;
  240.                         flag=1;
  241.                         flag2=0;
  242.                         y=0;
  243.                         write_data(0x5e);
  244.                         fuhao=6;
  245.                 }
  246.                 while(!cifang);        // 按键释放
  247.         }
  248.         if(qingling==0)
  249.         {
  250.                 delayms(10);                          // 去抖
  251.                 if(qingling==0)
  252.                 {
  253.                         if(beepflag==1)  //若开声音则每一次按键均鸣叫
  254.                         {
  255.                                 beep=0;
  256.                                 delayms(50);
  257.                                 beep=1;
  258.                         }
  259.                         write_com(0x01);
  260.                         a=0;
  261.                         b=0;
  262.                         c=0;
  263.                         point=0;
  264.                         flag=0;
  265.                         flag1=0;
  266.                         flag2=0;
  267.                         temp=0;
  268.                         fuhao=0;
  269.                         j=0;
  270.                         num='N';
  271.                 }
  272.                 while(!qingling);        // 按键释放
  273.         }
  274.         /*if(kaiguan==0)
  275. {
  276. delayms(10);                          // 去抖
  277. if(kaiguan==0)
  278. {
  279.         beepflag=~beepflag;
  280. }
  281. while(!cifang);        // 按键释放
  282. }*/
  283. }       

  285. /*计算函数*/
  286. void count()
  287. {      
  288.         if(fuhao==1)    //如果符号键是+，执行加法运算
  289.         {
  290.                 c=a+b;
  291.                 a=c;
  292.                 b=0;
  293.         }                 
  294.         if(fuhao==2)                           // 如果符号键是-，执行减法运算
  295.         {
  296.                 c=a-b;
  297.                 a=c;
  298.                 b=0;
  299.         }                                                                                                            
  300.         if(fuhao==3)   //如果符号键是*执行乘法运算
  301.         {        
  302.                 c=a*b;
  303.                 a=c;
  304.                 b=0;
  305.         }
  306.         if(fuhao==4)      //如果符号键是/ 执行除法运算               
  307.         {
  308.                 if(b==0)
  309.                 {
  310.                         write_com(0x01);
  311.                         write_string("math error");                   //被除数不能为零，否则输出math error
  312.                 }
  313.                 else
  314.                 {
  315.                         c=a/b;
  316.                         a=c;
  317.                         b=0;
  318.                 }         //这么设置就可连续运算                                                                                                                                                                                                           
  319.         }
  320.         if(fuhao==5)
  321.         {
  322.                 if(b<0)
  323.                 {
  324.                         write_com(0x01);
  325.                         write_string("math error");
  326.                 }
  327.                 else
  328.                 {
  329.                         c=sqrt(b);

  331.                 }
  332.         }
  333.         if(fuhao==6)
  334.         {
  335.                 float x=a;
  336.                 c=a;
  337.                 for(;b>1;b--)
  338.                 {                                       
  339.                         c=x*a;
  340.                         x=c;
  341.                 }
  342.         }                                    
  343. }

  345. /*写命令*/
  346. void write_com(uchar i)
  347. {
  348.         LCDEN=0;
  349.         LCDRS=0;
  350.         lcddata=i;
  351.         delayms(5);
  352.         LCDEN=1;
  353.         delayms(5);
  354.         LCDEN=0;
  355. }
  356. /*******写数据***********/
  357. void write_data(uchar i)
  358. {
  359.         LCDEN=0;
  360.         LCDRS=1;
  361.         lcddata=i;
  362.         delayms(5);
  363.         LCDEN=1;
  364.         delayms(5);
  365.         LCDEN=0;
  366. }
  367. /*写字符串*/
  368. void write_string(uchar *s)
  369. {
  370.         while(*s)
  371.         {
  372.                 write_data(*s);
  373.                 s++;
  374.                 delayms(5);
  375.         }
  376. }
  377. /*******初始化液晶*******/
  378. void lcd_init(void)
  379. {
  380.         LCDEN=0;
  381.         LCDRW=0;
  382.         //write_com(0x01); //显示清屏
  383.         // write_com(0x01); //显示清屏
  384.         write_com(0x38);//设置成1602显示
  385.         delayms(5);
  386.         write_com(0x38);//设置成1602显示
  387.         delayms(5);
  388.         write_com(0x38);//设置成1602显示
  389.         delayms(5);
  390.         // write_com(0x0f); //开显示 0x0e-->显示开，光标开
  391.         write_com(0x0c);//显示开
  392.         write_com(0x06); //设置光标移动方向增量方式，并指定显示不移动
  393.         write_com(0x01);
  394. }
  395. /*开机界面*/
  396. void xinxing()
  397. {
  398.         uchar mingzi[]="by 51Hei"        ;
  399.         uchar num1;                                                        //循环变量
  400.         lcd_init();                                                         //初始化
  401.         write_com(0x40);                                       
  402.         for(num1=0;num1<64;num1++)
  403.         {
  404.                 write_data(table1[num1]);
  405.         }

  407.         write_com(0x85);                               
  408.         for(num1=0;num1<4;num1++)
  409.         {
  410.                 write_data(num1);
  411.         }
  412.         write_com(0xc5);                                       
  413.         for(num1=4;num1<8;num1++)
  414.         {
  415.                 write_data(num1);
  416.         }
  417.         write_com(0x80+0x4a);
  418.         for(num1=0;num1<6;num1++)
  419.         {
  420.                 write_data(mingzi[num1]);
  421.         }
  422.        
  423. }
  424. void waibu(void) interrupt 0 //using 1
  425. {
  426.         if(zhongduan==0)                    //如果检测到低电平
  427.         {
  428.                 delayms(10);        //延时，去抖动，一般为10ms
  429.                 if(zhongduan==0)                //如果去抖动之后还是低电平，说明按下了
  430.                 {
  431.                         if(beepflag==1)  //若开声音则每一次按键均鸣叫
  432.                         {
  433.                                 beep=0;
  434.                                 delayms(50);
  435.                                 beep=1;
  436.                         }
  437.                         beepflag=~beepflag;     //进入中断程序执行程序  
  438.                 }
  439.                 while(!zhongduan);          //等待释放，如果没有释放，则一直等待
  440.         }

  442. }
  443. /******显示7位小数*********/
  444. void lcdwrite_float(float n)
  445. {
  446.         uchar i=0;
  447.         long nxtemp;
  448.         if(n==0)
  449.         {
  450.                 write_data('0');
  451.                 return;
  452.         }       
  453.         if(n<0)
  454.         {
  455.                 write_data('-');
  456.                 n=0-n;
  457.         }          
  458.         nxtemp=n;
  459.         n=n;//+0.000002;
  460.         write_num(nxtemp);
  461.         if((n-nxtemp)>0)
  462.         {       
  463.                 write_data('.');
  464.                 nxtemp=(n-nxtemp)*10000000;
  465.                 //        n=n-1;
  466.                 //        nxtemp=n;
  467.                 //        if(nxtemp%10!=0)
  468.                 write_data(nxtemp/1000000+0x30);//显示第7位小数
  469.                 //        if((nxtemp%1000000%100000%10000%1000%100/10!=0)||(nxtemp%1000000%100000%10000%1000/100!=0)||(nxtemp%1000000%100000%10000/1000!=0)||(nxtemp%1000000%100000/10000!=0)||(nxtemp%1000000/100000!=0))
  470.                 write_data(nxtemp%1000000/100000+0x30);//显示第6位小数
  471.                 //        if((nxtemp%1000000%100000%10000%1000%100/10!=0)||(nxtemp%1000000%100000%10000%1000/100!=0)||(nxtemp%1000000%100000%10000/1000!=0)||(nxtemp%1000000%100000/10000!=0))
  472.                 write_data(nxtemp%1000000%100000/10000+0x30);//显示第5位小数
  473.                 //        if((nxtemp%1000000%100000%10000%1000%100/10!=0)||(nxtemp%1000000%100000%10000%1000/100!=0)||(nxtemp%1000000%100000%10000/1000!=0))
  474.                 write_data(nxtemp%1000000%100000%10000/1000+0x30);//显示第4位小数
  475.                 //        if((nxtemp%1000000%100000%10000%1000%100/10!=0)||(nxtemp%1000000%100000%10000%1000/100!=0))
  476.                 write_data(nxtemp%1000000%100000%10000%1000/100+0x30);//显示第3位小数
  477.                 //        if((nxtemp%1000000%100000%10000%1000%100/10!=0))
  478.                 write_data(nxtemp%1000000%100000%10000%1000%100/10+0x30);//显示第2位小数
  479.                 write_data(nxtemp%10+0x30);//显示第1位小数        */

  481.         }
  482.         else
  483.         return;
  484. }
  485. /*显示多位数*/
  486. void write_num(long n)
  487. {
  488.         //        uchar length=0,j=0,a[8]={0,0,0,0,0,0,0,0};
  489.         long nx;
  490.         /*        if(n==0)
  491.         {
  492.                 write_data('0');
  493.                 return;
  494.         }       
  495.         if(n<0)
  496.         {
  497.                 write_data('-');
  498.                 n=0-n;
  499.         } */
  500.         //        nx=n;       
  501.         //        for(j=0;j<8;j++)
  502.         //        {
  503.         //                if(nx>=1)
  504.         //                        length++;
  505.         //                nx/=10;
  506.         //        }
  507.         nx=n;
  508.         if(nx==0)
  509.         {
  510.                 write_data('0');
  511.         }
  512.         else
  513.         {
  514.                 while(nx>0)
  515.                 {
  516.                         shu[j]=nx%10;                        //把n的每一位放进数组
  517.                         nx=nx/10;
  518.                         j++;   
  519.                 }                         
  520.                 for(;j>0;j--)
  521.                 {                                                                 //显示整数n的每一位
  522.                         write_data(shu[j-1]+0x30);
  523.                         delayms(5);
  524.                 }
  525.         }
  526. }


复制代码
回复

使用道具 举报

ID:652716 发表于 2020-1-23 20:24 | 显示全部楼层
杨雪飞 发表于 2020-1-23 14:55
lcdxs(0,1,lcd[a])

设置一个变量K，按键每按一下K+1

lcdxs(0,1,lcd[a])
if语句判读是否按下
按下k+1，没按下k不变
a=k+1；
lcdxs(0,k,lcd[a])
回复

使用道具 举报

ID:584814 发表于 2020-2-1 07:55 | 显示全部楼层
1602的三线接在了P3口，高低端都占了些，而P3又定义成矩阵键盘并且还以高低口有无信号做为标志，这样肯定不好玩。建议将1602的三线换到P1或P2试试。
回复

使用道具 举报

ID:692513 发表于 2020-2-17 20:39 | 显示全部楼层
angmall 发表于 2020-1-23 19:21
我给你来个程序参考

请问一下硬件是如何连接的，比如P0、P1口要连接什么
回复

使用道具 举报

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

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

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