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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 这个单片机LCD1602程序仿真的时候为什么显示都是问号?
返回列表 发新帖
查看: 881|回复: 1
打印 上一主题 下一主题
收起左侧

这个单片机LCD1602程序仿真的时候为什么显示都是问号?

[复制链接]
回帖奖励 1 黑币 回复本帖可获得 1 黑币奖励! 每人限 1 次
跳转到指定楼层
楼主
ID:1072686 发表于 2023-4-20 13:29 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式

  1. #include<reg52.h>//52单片机头文件，规定了52单片机的寄存器和IO口等
  2. #include<intrins.h>//_nop_空指令及左右循环移位子函数库
  3. #define uchar unsigned char//宏定义
  4. #define uint unsigned int//宏定义
  5.         
  6. sbit lcd_rs=P2^0;//定义选数据寄存器选指令寄存器控制端
  7. sbit lcd_rw=P2^1;//定义下面通过lcd_rw来操作P2^5口，1602读写选择端
  8. sbit lcd_en=P2^2;//定义下面通过lcd_en来操作P2^7口,1602液晶使能控制端

  10. sbit DS_rst=P3^4;//DS1302复位
  11. sbit DS_sck=P3^5;//定义时钟总线
  12. sbit DS_io=P3^6;//定义DS1302数据总线

  14. sbit s1=P1^0;//定义设置按钮
  15. sbit s2=P1^1;//定义调时按钮
  16. sbit s3=P1^2;//定义确定按钮
  17. sbit s4=P1^3;//定义闹钟调整按钮

  19. sbit ACC0=ACC^0;//累加器
  20. sbit ACC7=ACC^7;

  22. sbit BELL=P1^6; //喇叭

  24. char fen,shi,miao,ri,yue,nian,zhou,s1num,s2num,s4num,flag1,flag2,lshi,lfen;
  25. uchar code table[]={" 2022-  -    W  "};//要写入1602液晶的数据
  26. uchar code table1[]={"  :  :    T  :  "};//字库中的字可直接以外加""号的形式直接写入
  27. uchar code table2[]={" Welcome To Lcd!"};//欢迎界面
  28. uchar code table3[]={"Happy Every Day!"};           //欢迎界面
  29. /*******************************************************************************
  30. 时函数,z的取值为这个函数的延时ms数，delay(200);大约延时200ms. delay(500);大约延时500ms
  31. *******************************************************************************/
  32. void delay(uint z)
  33. {                                                      
  34.         uint x,y;
  35.         for(x=z;x>0;x--)
  36.         for(y=110;y>0;y--);
  37. }
  38. /*********************蜂鸣器函数************************************************/
  39. void didi()
  40. {         
  41.     uchar i;
  42.      for(i=0;i<60;i++)
  43.       {
  44.         BELL = 0;
  45.                 delay(1);
  46.              BELL = 1;
  47.                 delay(1);
  48.        }
  49. }

  51. /*******************向1602液晶中写一个指令**************************************/
  52. void write_com(uchar com)
  53. {        
  54.         lcd_rw=0;                        //lcd_rw为读写控制端，lcd_rw=0,这里可不写
  55.         lcd_rs=0;           //液晶rs接口为0时,写指令，rs为1时写数据
  56.         P0=com;          //将要写的指令赋给P0口，
  57.         delay(5);    //由1602读写操作时序图，先将指令赋给P0口，延时后将使能
  58.         lcd_en=1;    //  端lcd_en置高，再延时一段时间，然后将lcd_en置低，这样指令
  59.         delay(5);          // 就写入到LCD了        
  60.         lcd_en=0;
  61. }
  62. /****************************向液晶写数据***************************************/
  63. void write_data(uchar date)//与写指令类似，这里lcd_rs设为1
  64. {
  65.         
  66.         lcd_rs=1;
  67.         lcd_rw=0;
  68.         P0=date;
  69.         delay(5);
  70.         lcd_en=1;
  71.         delay(5);
  72.         lcd_en=0;
  73. }
  74. /*****************************初使化1602液晶************************************/
  75. void init_1602()
  76. {
  77.         lcd_en=0;
  78.         nian=22;
  79.         yue=6;
  80.         ri=21;
  81.         zhou=5;
  82.         shi=13;
  83.         fen=59;
  84.         miao=59;
  85.         s1num=0;
  86.         s2num=0;
  87.         s4num=0;
  88.         lshi=7;
  89.         lfen=59;
  90.         write_com(0x38);//设置LCD为16*2显示、5*7点阵、8位数据接口模式
  91.         write_com(0x0c);//开显示、不显示光标
  92.         write_com(0x06);//写一个字符后，地址指针加1
  93.         write_com(0x01);//显示清0
  94. }
  95. /*******************************************************************************/
  96. void gudingtime_1602()
  97. {
  98.     uchar num;
  99.         write_com(0x80);//将指针指向初始位置
  100.         for(num=0;num<16;num++)//循环函数，用于将" 2022-  -     "写入液晶
  101.                         write_data(table[num]);
  102.         write_com(0x80+0x40);//将指针指向1602液晶的第二行
  103.         for(num=0;num<16;num++)//功能与上同，用于将"  :  :    T  :  "写入
  104.                         write_data(table1[num]);
  105. }
  106. /**************************显示欢迎界面函数*************************************/
  107. void displaystar(void)
  108. {
  109.          uchar i;
  110.          write_com(0x80);
  111.          for(i=0;i<16;i++)
  112.          write_data(table2[i]);
  113.          write_com(0x80+0x40);
  114.          for(i=0;i<16;i++)
  115.           write_data(table3[i]);
  116. }
  117. /***************************显示时间、日期子函数*********************************/
  118. void write_sfm(uchar add,uchar time)//用于在1602上显示年、月、日、时、分、秒。Add为显示位置，time为要显示的内容
  119. {                              
  120.         uchar shiwei,gewei;                                                
  121.         shiwei=time/16;   //将从DS1302中读取的BCD码数据转化成10进制个位和10
  122.         gewei=time%16;   //进制十位
  123.         write_com(add+0x80);//定义显示在液晶的什么位置
  124.         write_data(0x30+shiwei);//由1602液晶字库可知，0~9的数据码分别对应0x30~0x39
  125.         write_data(0x30+gewei);        //初使化中设定了写一个字符后，地址指针加1，因此这里
  126. }                     // 不用重新光标写位

  128. /**************************显示周子函数*****************************************/
  129. void write_zhou(uchar time1)//用于在1602上显示周信息，与显示
  130. {                        //时间日期子函数类似
  131.         uchar gewei;
  132.         gewei=time1%16;//一周七天，因此只需个位
  133.         write_com(0x80+14);//初始位置加13个
  134.         write_data(0x30+gewei);
  135. }
  136. /***************************写数据字节子函数************************************/
  137. void Input_1byte(uchar TD)//写一字节数据
  138. {
  139.     uchar i;
  140.     ACC=TD;
  141.     for(i=8;i>0;i--)
  142.     {
  143.        DS_io=ACC0;
  144.        DS_sck=1;
  145.        DS_sck=0;
  146.        ACC=ACC>>1; //右移一位
  147.     }
  148. }


  151. /*************************读数据字节子函数**************************************/
  152. uchar Output_1byte(void)//读一字节数据
  153. {
  154.     uchar i;
  155.     for(i=8;i>0;i--)
  156.      {
  157.          ACC=ACC>>1;
  158.          ACC7=DS_io;
  159.          DS_sck=1;
  160.          DS_sck=0;
  161.      }

  163.      return(ACC);

  165. }
  166. /***************************写DS1302数据函数***********************************/
  167. void write_1302(uchar DS_ADD,uchar DS_DAT)//写操作
  168. {   
  169.                  DS_rst=0;
  170.                  DS_sck=0;
  171.                  DS_rst=1;
  172.                  Input_1byte(DS_ADD);
  173.                  Input_1byte(DS_DAT);
  174.                  DS_sck=1;
  175.                  DS_rst=0;
  176. }

  178. /***************************读DS1302数据函数***********************************/
  179. uchar read_1302(uchar DS_ADD)//读操作
  180. {   
  181.           uchar DS_INF;
  182.                 DS_rst=0;
  183.           DS_sck=0;  
  184.           DS_rst=1;
  185.           Input_1byte(DS_ADD);
  186.           DS_INF=Output_1byte();
  187.           DS_sck=1;
  188.           DS_rst=0;
  189.           return(DS_INF);
  190. }

  192. /*************************初始化DS1302子函数***********************************/
  193. void inital_1302()
  194. {
  195.     write_1302(0x8e,0x00);//禁止写保护
  196.     write_1302(0x90,0xaa);//定义充电
  197.                 write_1302(0x80,0x53);//秒   
  198.     write_1302(0x84,0x13);//时     
  199.                 write_1302(0x82,0x43);//分
  200.                 write_1302(0x8c,0x12);//年
  201.                 write_1302(0x88,0x06);//月
  202.                 write_1302(0x86,0x03);//日
  203.                 write_1302(0x8a,0x06);//星期
  204.     write_1302(0xc0,0x08);//闹钟小时初始化
  205.                 write_1302(0xfc,0x00);//闹钟分钟初始化
  206.                 write_1302(0x8e,0x80);//开保护

  208. }
  209. /********************************************************************************
  210.                               扫描函数
  211. ********************************************************************************/

  213. void keyscan()
  214. {  
  215.         if(s1==0&&s4num==0)        //按键1按下且s4再次之前未曾按过
  216.         {
  217.                 delay(5);
  218.                 if(s1==0&&s4num==0)
  219.                 {   
  220. flag1=1;
  221.                     s1num++;
  222.                         while(!s1);didi();
  223.                         if(s1num==1)
  224.                         {                                
  225.                                         write_com(0x80+0x40+8);//光标移动到**位置
  226.                                         write_com(0x0f);//显示光标
  227.                         }

  229.                         if(s1num==2)
  230.                         {
  231.                                    write_1302(0x8e,0x00);//禁止写保护
  232.                                         write_1302(0x80,miao);//写入秒信息
  233.                                         write_1302(0x8e,0x80);//开写保护
  234.                                         write_com(0x80+0x40+5);
  235.                         }
  236.                         if(s1num==3)
  237.                         {
  238.                                    write_1302(0x8e,0x00);
  239.                                         write_1302(0x82,fen);
  240.                                         write_1302(0x8e,0x80);
  241.                                         write_com(0x80+0x40+2);                                                               
  242.                         }
  243.                         if(s1num==4)
  244.                         {
  245.                                         write_1302(0x8e,0x00);
  246.                                         write_1302(0x88,yue);
  247.                                         write_1302(0x8e,0x80);
  248.                             write_com(0x80+13);
  249.                         }
  250.                         if(s1num==5)
  251.                         {
  252.                                         write_1302(0x8e,0x00);
  253.                                         write_1302(0x84,shi);
  254.                                         write_1302(0x8e,0x80);
  255.                                         write_com(0x80+10);
  256.                         }
  257.                         if(s1num==6)
  258.                         {
  259.                                         write_1302(0x8e,0x00);
  260.                                         write_1302(0x86,ri);
  261.                                         write_1302(0x8e,0x80);
  262.                                         write_com(0x80+7);
  263.                         }
  264.                         if(s1num==7)
  265.                         {
  266.                                         write_1302(0x8e,0x00);
  267.                                         write_1302(0x8c,nian);
  268.                                         write_1302(0x8e,0x80);
  269.                                         write_com(0x80+4);
  270.                         }
  271.             if(s1num==8)
  272.                         {  
  273.                         flag1=0;
  274.                                         s1num=0;
  275.                                         write_1302(0x8e,0x00);
  276.                                         write_1302(0x8a,zhou);
  277.                                         write_1302(0x8e,0x80);
  278.                                         write_com(0x0c);//不显示光标
  279.                         }
  280.                 }
  281.         }        
  282. /*******************************************************************************/        
  283.         if(s1num!=0&&s4num==0)//按键1按下*次且s4再次之前未曾按过
  284.                 {
  285.                         if(s2==0)
  286.                         {
  287.                                 delay(5);
  288.                                 if(s2==0)
  289.                                 {   
  290.                                         while(!s2);didi();
  291.                                         if(s1num==1)
  292.                                         {
  293.                                                 int x1,x2;
  294.                                                 x1=miao%16;
  295.                                                 x2=miao/16;
  296.                                                 x1++;
  297.                                                 if(x1==10)
  298.                                                 {
  299.                                                         x1=0;
  300.                                                         x2++;
  301.                                                         if(x2>=6)
  302.                                                                 x2=0;
  303.                                                 }
  304.                                                 miao=x1+x2*16;
  305.                                                 write_sfm(7+0x40,miao);//将修改的数送到1602显示
  306.                                                 write_com(0x80+0x40+8);//挪回光标
  307.                                         }
  308.                                         if(s1num==2)
  309.                                         {
  310.                                                 int x3,x4;
  311.                                                 x3=fen%16;
  312.                                                 x4=fen/16;
  313.                                                 x3++;
  314.                                                 if(x3==10)
  315.                                                 {
  316.                                                         x3=0;
  317.                                                         x4++;
  318.                                                         if(x4>=6)
  319.                                                                 x4=0;
  320.                                                 }
  321.                                                 fen=x3+x4*16;
  322.                                                 write_sfm(4+0x40,fen);
  323.                                                 write_com(0x80+0x40+5);
  324.                                         }        
  325.                                         if(s1num==3)
  326.                                         {
  327.                                                 int x5,x6;
  328.                                                 x5=shi%16;
  329.                                                 x6=shi/16;
  330.                                                 x5++;
  331.                                                  if(x6>=2&&x5>=4)        
  332.                                                 {
  333.                                                         x5=0;
  334.                                                         x6=0;
  335.                                                 }
  336.                                                 if(x5==10)
  337.                                                 {
  338.                                                         x5=0;
  339.                                                         x6++;
  340.                                                 }
  341.                                                 shi=x5+x6*16;
  342.                                                 write_sfm(1+0x40,shi);
  343.                                                 write_com(0x80+0x40+2);
  344.                                         }
  345.                                         if(s1num==4)
  346.                                         {
  347.                                                  zhou++;
  348.                                                  if(zhou==8)
  349.                                                  zhou=1;
  350.                                                  write_zhou(zhou);
  351.                                                  write_com(0x80+13);
  352.                                                 
  353.                                 }
  354.                                         if(s1num==5)
  355.                                         {
  356.                                                 int x5,x6;
  357.                                                 x5=ri%16;
  358.                                                 x6=ri/16;
  359.                                                 x5++;
  360.                                                 if(x6>=3&&x5>=1)        
  361.                                                 {
  362.                                                         x5=1;
  363.                                                         x6=0;
  364.                                                 }
  365.                                                 if(x5==10)
  366.                                                 {
  367.                                                         x5=0;
  368.                                                         x6++;
  369.                                                 }
  370.                                                 ri=x5+x6*16;
  371.                                                 write_sfm(9,ri);
  372.                                                 write_com(0x80+10);
  373.                                         }
  374.                                         if(s1num==6)
  375.                                         {
  376.                                                 int x5,x6;
  377.                                                 x5=yue%16;
  378.                                                 x6=yue/16;
  379.                                                 x5++;
  380.                                                 if(x6>=1&&x5>=3)        
  381.                                                 {
  382.                                                         x5=1;
  383.                                                         x6=0;
  384.                                                 }
  385.                                                 if(x5==10)
  386.                                                 {
  387.                                                         x5=0;
  388.                                                         x6++;
  389.                                                 }
  390.                                                 yue=x5+x6*16;
  391.                                                 write_sfm(6,yue);
  392.                                                 write_com(0x80+7);
  393.                                 }
  394.                                         if(s1num==7)
  395.                                         {
  396.                                                 int x5,x6;
  397.                                                 x5=nian%16;
  398.                                                 x6=nian/16;
  399.                                                 x5++;
  400.                                                 if(x6>=2&&x5>=1)        
  401.                                                 {
  402.                                                         x5=1;
  403.                                                         x6=0;
  404.                                                 }
  405.                                                 if(x5==10)
  406.                                                 {
  407.                                                         x5=0;
  408.                                                         x6++;
  409.                                                 }
  410.                                                 nian=x5+x6*16;
  411.                                                 write_sfm(3,nian);
  412.                                                 write_com(0x80+4);
  413.                                 }
  414.                                 }
  415.                         }
  416.             }
  417. /*******************************************************************************/

  419.         if(s1num!=0||s4num!=0)// 在调整模式下
  420.                 {
  421.                         if(s3==0)//如果确定键按下
  422.                         {
  423.                                 delay(5);
  424.                                 if(s3==0) //延时并重新检测S3是否按下，用于差小误差
  425.                                 {
  426.                                    if(s1num!=0)
  427.                                    {
  428.                                     while(!s3);didi();//在松手时将调整后的时间、日期及周信息写入DS1302，退出调整模式并隐藏光标，按键次数清0
  429.                                                 write_1302(0x8e,0x00);
  430.                                            write_1302(0x80,miao);
  431.                                     write_1302(0x84,shi);
  432.                                                 write_1302(0x82,fen);
  433.                                                 write_1302(0x8a,zhou);
  434.                                                 write_1302(0x8c,nian);//年
  435.                                                 write_1302(0x88,yue);//月
  436.                                                 write_1302(0x86,ri);
  437.                                                 write_1302(0x8e,0x80);
  438.                                                 flag1=0;
  439.                                                 write_com(0x0c);
  440.                                                 s1num=0;
  441.                    }
  442.                                    if(s4num!=0)
  443.                                    {
  444.                                            while(!s3);didi();//在松手时将调整后的时间、日期及周信息写入DS1302，退出调整模式并隐藏光标，按键次数清0
  445.              write_1302(0x8e,0x00);
  446.                                       write_1302(0xc0,lshi);
  447.              write_1302(0xfc,lfen);
  448.                                                  write_1302(0x8e,0x80);
  449.                                                   flag2=0;
  450.                                                  s4num=0;
  451.                                                  write_com(0x0c);
  452.                    }

  454.                                 }
  455.                         }        
  456.         }

  458.    if(s4==0&&s1num==0)//按键4按下*次且s1再次之前未曾按过
  459.         {  
  460.                      
  461.               delay(5);
  462.                             if(s4==0&&s1num==0)
  463.                           {   
  464.                             s4num++;
  465.                                         flag2=1;
  466.             while(!s4);didi();
  467.                                       if(s4num==1)
  468.                                         {                                
  469.                                                                                 
  470.                                                         write_com(0x80+0x40+14);
  471.                                                         write_com(0x0f);
  472.                                         }
  473.                                              
  474.                                           if(s4num==2)
  475.                                         {
  476.                                                    write_1302(0x8e,0x00);//禁止写保护
  477.                                             write_1302(0xfc,lfen);//闹钟初始化
  478.                                                         write_1302(0x8e,0x80);//开写保护
  479.                                                         write_com(0x80+0x40+11);
  480.                                         }
  481.                                         if(s4num==3)
  482.                                         {   
  483.                                             s4num=0;
  484.                                                         flag2=0;
  485.                                                    write_1302(0x8e,0x00);//禁止写保护
  486.                                                         write_1302(0xc0,lshi);//闹钟初始化
  487.                                                         write_1302(0x8e,0x80);//开写保护
  488.                                                         write_com(0x0c);//不显示光标
  489.                                         }
  490.                           }
  491.                 }
  492.         
  493.                         if(s4num!=0&&s1num==0)
  494.                         {
  495.                                 if(s2==0)
  496.                                 {
  497.                                         delay(5);
  498.                                         if(s2==0)
  499.                                         {   
  500.                                                 while(!s2);didi();
  501.                                                 if(s4num==1)
  502.                                                 {
  503.                                                         int x1,x2;
  504.                                                         x1=lfen%16;
  505.                                                         x2=lfen/16;
  506.                                                         x1++;
  507.                                                         if(x1==10)
  508.                                                         {
  509.                                                                 x1=0;
  510.                                                                 x2++;
  511.                                                                 if(x2>=6)
  512.                                                                         x2=0;
  513.                                                         }
  514.                                                         lfen=x1+x2*16;
  515.                                                         write_sfm(13+0x40,lfen);
  516.                                                         write_com(0x80+0x40+14);
  517.                             }
  518.                                                 if(s4num==2)
  519.                                                 {
  520.                                                         int x5,x6;
  521.                                                         x5=lshi%16;
  522.                                                         x6=lshi/16;
  523.                                                         x5++;
  524.                                                          if(x6>=2&&x5>=4)        
  525.                                                         {
  526.                                                                 x5=0;
  527.                                                                 x6=0;
  528.                                                         }
  529.                                                         if(x5==10)
  530.                                                         {
  531.                                                                 x5=0;
  532.                                                                 x6++;
  533.                                                         }
  534.                                                         lshi=x5+x6*16;
  535.                                                         write_sfm(10+0x40,lshi);
  536.                                                         write_com(0x80+0x40+11);
  537.                                                 }
  538.                         }
  539.                     }
  540.                 }
  541. }
  542. void laba()
  543. {  
  544.    if((shi==lshi)&&(fen==lfen)&&(miao<=10&&miao>=0))//当闹钟的时和分分别与时钟的时和分相等时，闹钟时间到，蜂鸣器鸣响，鸣响10s
  545.    {
  546.        didi();
  547.    }
  548. }
  549. void main()
  550. {   
  551.     init_1602();
  552.                 delay(5);
  553.                 displaystar();//初始化1602后马上显示欢迎语句
  554.                 delay(5000);//让欢迎界面停留一段时间
  555.                 gudingtime_1602();//显示液晶固定不变部分
  556.     inital_1302();
  557.                 lshi=read_1302(0xc1);//从ds1302里面的RAM读取闹钟时，此处不放在while(1)大循环里面是因为ds1302里面的RAM里的数据是不变的只需读取一次
  558.     lfen=read_1302(0xfd);//从ds1302里面的RAM读取闹钟分
  559.     write_sfm(0x40+11,lshi);//将闹钟时送到1602显示
  560.     write_sfm(0x40+14,lfen);//将闹钟分送到1602显示
  561.         while(1)
  562.                 {      
  563.                         keyscan();
  564.                                 laba();
  565.                         if(flag1==0&&flag2==0)//只有当不在调整的时候才从DS1302里面读取数据并且送到1602上显示
  566.                             {
  567.                                     miao=read_1302(0x81);//先读出，再送到1602显示，不断循环操作，使1602动态显示时间的走动
  568.                                                 fen=read_1302(0x83);
  569.                                                 shi=read_1302(0x85);
  570.                                                 ri=read_1302(0x87);
  571.                                                 yue=read_1302(0x89);
  572.                                                 zhou=read_1302(0x8b);
  573.                         nian=read_1302(0x8d);
  574.                                                 
  575.                                     write_sfm(6+0x40,miao);
  576.                                                 write_sfm(3+0x40,fen);
  577.                                                 write_sfm(0+0x40,shi);
  578.                                                 write_sfm(9,ri);
  579.                                                 write_sfm(6,yue);
  580.                                                 write_sfm(3,nian);
  581.                                                 write_zhou(zhou);
  582.                         }
  583. }
  584. }
复制代码

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:123289 发表于 2023-4-20 15:43 | 只看该作者
读通显示屏的显示原理就清楚了，下次遇到任意显示就都能明白了。
仔细读手册吧。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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