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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 关于第七届蓝桥杯单片机温度记录器程序问题
返回列表 发新帖
查看: 3081|回复: 0
打印 上一主题 下一主题
收起左侧

关于第七届蓝桥杯单片机温度记录器程序问题

[复制链接]
跳转到指定楼层
楼主
ID:439660 发表于 2018-12-4 22:54 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
最近我在蓝桥杯第七届温度记录器的程序时，到最后一步是采集温度，程序出现问题调试不了。温度值一直显示为0，我想把读到的十个温度数据放到一个数组内，然后要用时从数组内调出来，但是貌似数据没录入数组内，跪求各位大神帮忙看看程序。我是用郭天祥的开发板调的程序，跟大赛的板子稍微不一样。

我用郭天祥单片机开发板写的温度记录器程序，发现程序前两个功能可以实现。但是到最后温度采集上一直采集不了温度数据，我是将十个温度数据放到一个数组内，然后在从数组内调用出来给显示函数的。但是发现温度显示一直为00，再者就是8.5的显示异常现象。之前我单独测试温度程序时是单个温度值采集发现程序可行，然后我就直接加下去大程序里，发现功能不能实现。多个温度值采集如何实现呢？跪求各位大佬解答


单片机源码：
  1. #include<reg52.h>
  2. #include <stdio.h>
  3. #define uchar unsigned char
  4. #define unit unsigned int
  5. #define key_input P3
  6. sbit ds=P2^2;     //温度传感器信号线
  7. sbit wela=P2^7;
  8. sbit dula=P2^6;
  9. sbit dscs=P1^4;
  10. sbit dsas=P1^5;
  11. sbit dsrw=P1^6;
  12. sbit dsrd=P1^7;
  13. sbit beep=P2^3;
  14. bit flag;
  15. unit temp;

  17. float f_temp;
  18. uchar jiange[]={1,5,30,60};
  19. uchar code table_wela1[]={0xf7,0xef,0xdf};
  20. uchar code table_wela[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf};
  21. unsigned char code smg[]={
  22. 0x3f,0x06,0x5b,0x4f,
  23. 0x66,0x6d,0x7d,0x07,
  24. 0x7f,0x6f};
  25. uchar key1,key2,key_press,key_number,addr,i;

  27. uchar key_scan(key_number)
  28. {
  29.         static uchar key_state=0;
  30.         key_input=0xf0;
  31.         key1=key_input&0xf0;
  32.         key_input=0x0f;
  33.         key2=key_input&0x0f;
  34.         key_press=key1|key2;
  35.         switch(key_state)
  36.         {
  37.                 case 0:
  38.                                 if(key_press!=0xff)
  39.                                 {
  40.                                         key_state=1;
  41.                                 }
  42.                                 break;
  43.                                 
  44.                 case 1:
  45.                                 if(key_press!=0xff)
  46.                                 {
  47.                                         switch(key_press)
  48.                                         {
  49.                                                 case 0x77:  key_number=2;
  50.                                                                         break;
  51.                                                 case 0x7b:  key_number=3;
  52.                                                                         break;
  53.                                                 case 0x7d:  key_number=4;
  54.                                                                         break;
  55.                                                 case 0x7e:  key_number=5;
  56.                                                                         break;
  57.                                         }
  58.                                         key_state=2;
  59.                                 }
  60.                                 else
  61.                                 {
  62.                                         key_state=0;
  63.                                 }
  64.                                 break;
  65.                 case 2:
  66.                                 if(key_press==0xff)
  67.                                 {
  68.                                         key_state=0;
  69.                                 }
  70.                                 break;        
  71.         }
  72.         return key_number;
  73. }



  77. void Timer1Init(void)                //1毫秒@11.0592MHz
  78. {
  79.         /*AUXR |= 0x40;        */        //定时器时钟1T模式
  80.         TMOD &= 0x0F;                //设置定时器模式
  81.         TMOD |= 0x10;                //设置定时器模式
  82.         TL1 = 0xCD;                //设置定时初值
  83.         TH1 = 0xD4;                //设置定时初值
  84.         TF1 = 0;                //清除TF1标志
  85.         TR1 = 1;                //定时器1开始计时
  86.         EA=1;
  87.         ET1=1;
  88. }






  95. ////////////
  96. //DS18B20函数//
  97. /////////
  98. void delay(unit z)//延时函数
  99. {
  100.         unit x,y;
  101.         for(x=z;x>0;x--)
  102.                 for(y=110;y>0;y--);
  103. }



  107. void dsreset(void)    //18B20复位，初始化函数
  108. {
  109.   unit i;
  110.   ds=0;
  111.   i=103;
  112.   while(i>0)i--;
  113.   ds=1;
  114.   i=4;
  115.   while(i>0)i--;
  116. }

  118. bit tempreadbit(void)   //读1位函数
  119. {
  120.    unit i;
  121.    bit dat;
  122.    ds=0;i++;          //i++ 起延时作用
  123.    ds=1;i++;i++;
  124.    dat=ds;
  125.    i=8;while(i>0)i--;
  126.    return (dat);
  127. }

  129. uchar tempread(void)   //读1个字节
  130. {
  131.   uchar i,j,dat;
  132.   dat=0;
  133.   for(i=1;i<=8;i++)
  134.   {
  135.     j=tempreadbit();
  136.     dat=(j<<7)|(dat>>1);   //读出的数据最低位在最前面，这样刚好一个字节在DAT里
  137.   }
  138.   return(dat);
  139. }

  141. void tempwritebyte(uchar dat)   //向18B20写一个字节数据
  142. {
  143.   unit i;
  144.   uchar j;
  145.   bit testb;
  146.   for(j=1;j<=8;j++)
  147.   {
  148.     testb=dat&0x01;
  149.     dat=dat>>1;
  150.     if(testb)     //写 1
  151.     {
  152.       ds=0;
  153.       i++;i++;
  154.       ds=1;
  155.       i=8;while(i>0)i--;
  156.     }
  157.     else
  158.     {
  159.       ds=0;       //写 0
  160.       i=8;while(i>0)i--;
  161.       ds=1;
  162.       i++;i++;
  163.     }

  165.   }
  166. }

  168. void tempchange(void)  //DS18B20 开始获取温度并转换
  169. {
  170.   dsreset();
  171.   delay(1);
  172.   tempwritebyte(0xcc);  // 写跳过读ROM指令
  173.   tempwritebyte(0x44);  // 写温度转换指令
  174. }

  176. unit get_temp()         //读取寄存器中存储的温度数据
  177. {
  178.   uchar a,b;

  180.   dsreset();
  181.   delay(1);
  182.   tempwritebyte(0xcc);
  183.   tempwritebyte(0xbe);
  184.   a=tempread();         //读低8位
  185.   b=tempread();         //读高8位
  186.   temp=b;
  187.   temp<<=8;            //两个字节组合为1个字
  188.   temp=temp|a;
  189.   f_temp=temp*0.0625;      //温度在寄存器中为12位 分辨率位0.0625°
  190.   temp=f_temp*10+0.5;    //乘以10表示小数点后面只取1位，加0.5是四舍五入
  191.   f_temp=f_temp+0.05;
  192.   return temp;         //temp是整型
  193. }

  195. /////////////
  196. //DS18B20函数//
  197. //////////


  200. /////////
  201. //DS12C887函数//
  202. ////////
  203. void write_ds(uchar addr,uchar date)
  204. {
  205.         P0=0xff;
  206.         dsas=1;
  207.         dsrd=1;
  208.         dsrw=1;
  209.         dscs=0;
  210.         P0=addr;
  211.         dsas=0;
  212.         dsrw=0;
  213.         P0=date;
  214.         dsas=1;
  215.         dsrw=1;
  216.         dscs=1;
  217. }

  219. uchar read_ds(uchar addr)
  220. {
  221.         uchar ds_date;
  222.         P0=0xff;
  223.         dscs=0;
  224.         dsas=1;
  225.         dsrd=1;
  226.         dsrw=1;
  227.         P0=addr;
  228.         dsas=0;
  229.         dsrd=0;
  230.         P0=0xff;
  231.         ds_date=P0;
  232.         dsas=1;
  233.         dsrd=1;
  234.         dscs=1;
  235.         return ds_date;
  236. }
  237. ///////////
  238. //DS12C887函数//
  239. //////////

  241. unit cishu,wenshi,wenge;
  242. unit caiyang_time;
  243. bit temp_flag;

  245. uchar wendu[2];
  246. char miaoshi,miaoge,fenshi,fenge,shishi,shige,shi,fen,miao,realjiange;
  247. uchar munu;
  248. uchar munu1[8];
  249. uchar munu2[6];
  250. uchar munu3[6];
  251. unit temperature[10];
  252. void main()
  253. {        
  254.         uchar display_cishu=0;
  255.         uchar temp,jiange_count;
  256.         Timer1Init();
  257.         while(1)
  258.         {
  259.                 miao=read_ds(0);
  260.                 miaoshi=miao/10;
  261.                 miaoge=miao%10;
  262.                 munu2[4]=smg[miaoshi];
  263.                 munu2[5]=smg[miaoge];        
  264.                 fen=read_ds(2);
  265.                 fenshi=fen/10;
  266.                 fenge=fen%10;
  267.                 munu2[2]=smg[fenshi];
  268.                 munu2[3]=smg[fenge];
  269.                 shi=read_ds(4);
  270.                 shishi=shi/10;
  271.                 shige=shi%10;
  272.                 munu2[0]=smg[shishi];
  273.                 munu2[1]=smg[shige];


  276.                 munu1[0]=0x40;
  277.                 munu1[1]=smg[jiange[jiange_count]/10];
  278.                 munu1[2]=smg[jiange[jiange_count]%10];

  280.                
  281.                 if(flag==1)
  282.                 {
  283.                         temp=key_scan(key_number);
  284.                         flag=0;
  285.                         switch(temp)
  286.                         {
  287.                                 case 2:        
  288.                                                 jiange_count++;
  289.                                                 i=0;
  290.                                                 if(jiange_count==4)
  291.                                                 {
  292.                                                         jiange_count=0;
  293.                                                 }
  294.                                                 break;

  296.                                 case 3:        
  297.                                                 munu=1;
  298.                                                 i=0;
  299.                                                 write_ds(0,55);
  300.                                                 write_ds(2,59);
  301.                                                 write_ds(4,23);
  302.                                                 realjiange=jiange[jiange_count];
  303.                                                 break;

  305.                                 case 4:        
  306.                                                 display_cishu++;
  307.                                                 if(display_cishu==10)
  308.                                                 {
  309.                                                         display_cishu=0;
  310.                                                 }
  311.                                                 break;               
  312.                                 case 5:                        break;
  313.                         }
  314.                 }

  316.                
  317.                 if(temp_flag==1)
  318.                 {
  319.                
  320.                         temp_flag=0;
  321.                         if(caiyang_time<<10)
  322.                         {
  323.                                 EA=0;
  324.                                 switch(caiyang_time)
  325.                                 {
  326.                                         case 0:
  327.                                                         tempchange();
  328.                                                     temperature[0]=get_temp();
  329.                                                         break;

  331.                                         case 1:        tempchange();
  332.                                                     temperature[1]=get_temp();
  333.                                                         break;

  335.                                         case 2:        tempchange();
  336.                                                     temperature[2]=get_temp();
  337.                                                         break;

  339.                                         case 3:        tempchange();
  340.                                                     temperature[3]=get_temp();
  341.                                                         break;

  343.                                         case 4:        tempchange();
  344.                                                     temperature[4]=get_temp();
  345.                                                         break;

  347.                                         case 5:        tempchange();
  348.                                                     temperature[5]=get_temp();
  349.                                                         break;

  351.                                         case 6:        tempchange();
  352.                                                     temperature[6]=get_temp();
  353.                                                         break;

  355.                                         case 7:        tempchange();
  356.                                                     temperature[7]=get_temp();
  357.                                                         break;

  359.                                         case 8:        tempchange();
  360.                                                     temperature[8]=get_temp();
  361.                                                         break;

  363.                                         case 9:        tempchange();
  364.                                                     temperature[9]=get_temp();
  365.                                                         break;
  366.                                 }
  367.                                 delay(1);
  368.                                 EA=1;
  369.                                 caiyang_time++;
  370.                         }
  371.                         else
  372.                         {
  373.                                 munu++;
  374.                         }
  375.                 }
  376.                
  377.                 if(munu==2)
  378.                 {
  379.                         switch(display_cishu)
  380.                         {
  381.                                 case 0:        munu3[0]=0x40;
  382.                                                 munu3[1]=smg[0/10];
  383.                                                 munu3[2]=smg[0%10];
  384.                                                 munu3[3]=0x40;
  385.                                                 wenshi=temperature[0]/10;
  386.                                                 wenge=temperature[0]%10;
  387.                                                 munu3[4]=smg[wenshi];
  388.                                                 munu3[5]=smg[wenge];
  389.                                                 break;

  391.                                 case 1:        munu3[0]=0x40;
  392.                                                 munu3[1]=smg[1/10];
  393.                                                 munu3[2]=smg[1%10];
  394.                                                 munu3[3]=0x40;
  395.                                                 wenshi=temperature[1]/10;
  396.                                                 wenge=temperature[1]%10;
  397.                                                 munu3[4]=smg[wenshi];
  398.                                                 munu3[5]=smg[wenge];
  399.                                                 break;

  401.                                 case 2:        munu3[0]=0x40;
  402.                                                 munu3[1]=smg[2/10];
  403.                                                 munu3[2]=smg[2%10];
  404.                                                 munu3[3]=0x40;
  405.                                                 wenshi=temperature[2]/10;
  406.                                                 wenge=temperature[2]%10;
  407.                                                 munu3[4]=smg[wenshi];
  408.                                                 munu3[5]=smg[wenge];
  409.                                                 break;

  411.                                 case 3:munu3[0]=0x40;
  412.                                                 munu3[1]=smg[3/10];
  413.                                                 munu3[2]=smg[3%10];
  414.                                                 munu3[3]=0x40;
  415.                                                 wenshi=temperature[3]/10;
  416.                                                 wenge=temperature[3]%10;
  417.                                                 munu3[4]=smg[wenshi];
  418.                                                 munu3[5]=smg[wenge];
  419.                                                 break;

  421.                                 case 4:        munu3[0]=0x40;
  422.                                                 munu3[1]=smg[4/10];
  423.                                                 munu3[2]=smg[4%10];
  424.                                                 munu3[3]=0x40;
  425.                                                 wenshi=temperature[4]/10;
  426.                                                 wenge=temperature[4]%10;
  427.                                                 munu3[4]=smg[wenshi];
  428.                                                 munu3[5]=smg[wenge];
  429.                                                 break;

  431.                                 case 5:        munu3[0]=0x40;
  432.                                                 munu3[1]=smg[5/10];
  433.                                                 munu3[2]=smg[5%10];
  434.                                                 munu3[3]=0x40;
  435.                                                 wenshi=temperature[5]/10;
  436.                                                 wenge=temperature[5]%10;
  437.                                                 munu3[4]=smg[wenshi];
  438.                                                 munu3[5]=smg[wenge];
  439.                                                 break;

  441.                                 case 6:        munu3[0]=0x40;
  442.                                                 munu3[1]=smg[6/10];
  443.                                                 munu3[2]=smg[6%10];
  444.                                                 munu3[3]=0x40;
  445.                                                 wenshi=temperature[6]/10;
  446.                                                 wenge=temperature[6]%10;
  447.                                                 munu3[4]=smg[wenshi];
  448.                                                 munu3[5]=smg[wenge];
  449.                                                 break;

  451.                                 case 7:        munu3[0]=0x40;
  452.                                                 munu3[1]=smg[7/10];
  453.                                                 munu3[2]=smg[7%10];
  454.                                                 munu3[3]=0x40;
  455.                                                 wenshi=temperature[7]/10;
  456.                                                 wenge=temperature[7]%10;
  457.                                                 munu3[4]=smg[wenshi];
  458.                                                 munu3[5]=smg[wenge];
  459.                                                 break;

  461.                                 case 8:        munu3[0]=0x40;
  462.                                                 munu3[1]=smg[8/10];
  463.                                                 munu3[2]=smg[8%10];
  464.                                                 munu3[3]=0x40;
  465.                                                 wenshi=temperature[8]/10;
  466.                                                 wenge=temperature[8]%10;
  467.                                                 munu3[4]=smg[wenshi];
  468.                                                 munu3[5]=smg[wenge];
  469.                                                 break;

  471.                                 case 9:        munu3[0]=0x40;
  472.                                                 munu3[1]=smg[9/10];
  473.                                                 munu3[2]=smg[9%10];
  474.                                                 munu3[3]=0x40;
  475.                                                 wenshi=temperature[9]/10;
  476.                                                 wenge=temperature[9]%10;
  477.                                                 munu3[4]=smg[wenshi];
  478.                                                 munu3[5]=smg[wenge];
  479.                                                 break;
  480.                         }
  481.                 }

  483.                
  484.         }
  485. }


  488. void timer1() interrupt 3
  489. {
  490.         static uchar key_count=0,smg_count=0;
  491.         static unit caiyang_time=0;
  492.         TL1 = 0xCD;                //设置定时初值
  493.         TH1 = 0xD4;                //设置定时初值
  494.         smg_count++;
  495.         key_count++;
  496.         if(key_count==1)
  497.         {
  498.                 key_count=0;
  499.                 flag=1;
  500.         }
  501.         if(smg_count==1)
  502.         {
  503.                 smg_count=0;
  504.                 P0=0XFF;

  506.                 if(munu==0)
  507.                 {
  508.                         P0=0XFF;
  509.                         dula=1;
  510.                         P0=munu1[i];
  511.                         dula=0;
  512.                         P0=0xff;
  513.                         P0=0XFF;
  514.                         wela=1;
  515.                         P0=table_wela1[i];
  516.                         wela=0;
  517.                         P0=0XFF;
  518.                         
  519.                         i++;
  520.                         if(i==3)
  521.                         {
  522.                                 i=0;
  523.                         }                        
  524.                 }
  525.                
  526.                 if(munu==1)
  527.                 {
  528.                         P0=0XFF;
  529.                         dula=0;
  530.                         dula=1;
  531.                         P0=munu2[i];
  532.                         dula=0;
  533.                         P0=0xff;
  534.                         wela=0;
  535.                         P0=0XFF;
  536.                         wela=1;
  537.                         P0=table_wela[i];
  538.                         wela=0;
  539.                         P0=0XFF;
  540.                         
  541.                         i++;
  542.                         if(i==6)
  543.                         {
  544.                                 i=0;
  545.                         }               
  546.                 }
  547.         
  548.                 if(munu==2)
  549.                 {
  550.                         P0=0XFF;
  551.                         dula=0;
  552.                           P0=munu3[i];
  553.                           dula=1;
  554.                           dula=0;
  555.                         P0=0xff;
  556.                           wela=0;
  557.                           P0=table_wela[i];
  558.                           wela=1;
  559.                           wela=0;
  560.                         i++;
  561.                         if(i==6)
  562.                         {
  563.                                 i=0;
  564.                         }         
  565.                 }

  567.                
  568.         }
  569.         if(munu==1)
  570.         {        
  571.                 caiyang_time++;
  572.                 if(caiyang_time==(realjiange*4000))//1s
  573.                 {
  574.                         caiyang_time=0;
  575.                         temp_flag=1;        
  576.                 }
  577.         }
  578. }
复制代码

全部资料51hei下载地址：
蓝桥杯实验-温度记录器.zip (2.7 KB, 下载次数: 49)


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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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