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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 单片机数字温度计，高低两路限温控制可在0~100范围内独 ...
返回列表 发新帖
查看: 1869|回复: 0
打印 上一主题 下一主题
收起左侧

单片机数字温度计，高低两路限温控制可在0~100范围内独立设计

[复制链接]
跳转到指定楼层
楼主
ID:353914 发表于 2018-6-19 09:58 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
1.基本要求
（1）能数字显示被测温度，测量温度范围0~100
（2）分辨率不低于0.5度
（3）带有计时和时间显示功能
（4）有高低两路限温控制输出接口控制外部电路。实际制作时可以用发光二极管模拟现实
（5）高低两路限温控制可在0~100范围内独立设计
（6）当温度达高低两限控制点声光报警

单片机源程序如下:
  1. /*预处理命令*/
  2. #include<reg52.h>    //包含单片机寄存器的头文件
  3. #include<intrins.h> //包含_nop_()函数定义的头文件
  4. #define uchar unsigned char
  5. #define uint  unsigned int
  6. #define delayNOP(); {_nop_();_nop_();_nop_();_nop_();};

  8. sbit IRIN=P3^2;           //红外接收器数据线
  9. sbit sclk = P1^0;                        //时钟
  10. sbit dio = P1^1;
  11. sbit ce = P1^2;
  12. sbit wela = P2^7;
  13. sbit dula = P2^6;
  14. sbit beep=P2^3;

  16. //sbit mscl = P2^1;                                    // 24c02
  17. //sbit msda = P2^0;
  18. sbit msda=P2^0;                          //IO口定义
  19. sbit mscl=P2^1;
  20. sbit DS=P2^2;
  21. sbit DS1=P2^4;
  22. sbit led1=P3^0;
  23. sbit led2=P3^1;
  24. sbit led3=P3^3;
  25. sbit led4=P3^4;

  27. uint p;
  28. uint wendu=0,wendu1=0;
  29. uchar flag,h1,h2,m1,m2,h3,h4,m3,m4;

  31. uint htemp = 30;       //高温限
  32. uint ltemp = 5 ;        // 低温限
  33. uint htemp1 = 30;       //高温限
  34. uint ltemp1 = 5 ;        // 低温限
  35. bit hmodel ;                        // 高温设置
  36. bit lmodel ;            // 低温设置
  37. bit hmodel1 ;                        // 高温设置
  38. bit lmodel1 ;            // 低温设置
  39. unsigned char code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,
  40.                         0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00};
  41. unsigned char code table1[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,                          //加点的数码管
  42.                              0x87,0xff,0xef};
  43. uchar IRCOM[7];
  44. uchar pin=0,pinjian;

  46. void dsreset(void);
  47. void tmpwritebyte(uchar dat);
  48. uint tmp();
  49. void dsreset1(void);
  50. void tmpwritebyte1(uchar dat);
  51. uint tmp1();

  53. void write_1302(uchar add,dat);
  54. uchar read_1302(uchar add);
  55. void display(uchar a,uchar b,uchar c,uchar d,uchar e,uchar f,uchar g,uchar h);
  56. void delay1ms();
  57. void delay(unsigned char x) ;
  58. void delayds(uint z);
  59. void delay1(int ms);
  60. void display1(uchar a,uchar b);

  62. void fanhui(); //7号
  63. void displayall();//2号
  64. void displayall1();//3号
  65. void huicha();//4号
  66. /*******************************************************************/

  68. /*24c02 初始化程序*/
  69. void delay_24c02()
  70. {
  71.     uchar i;
  72.     for(i=10;i--;i>0);
  73. }
  74. /*地址 A2A1A0 = 000*/
  75. /* 0x00 ,0x01 存放 第一路的高低温限
  76.    0x02,0x03    存放 第二路的高低温限
  77.    以后每两个相邻单元分别存放测试时间和温度值 （时间在前）*/
  78. void init_24c02()
  79. {
  80.   msda = 1;
  81.   delay_24c02();
  82.   mscl =  1;
  83.   delay_24c02();

  85. }
  86. /*24c02启动程序*/
  87. void start_24c02()
  88. {
  89.    msda = 1;
  90.    delay_24c02();
  91.    mscl = 1;
  92.    delay_24c02();
  93.    msda = 0;
  94.    delay_24c02();
  95. }
  96. /*24c02停止程序*/
  97. void stop_24c02()
  98. {
  99.    msda = 0;
  100.    delay_24c02();
  101.    mscl = 1;
  102.    delay_24c02();
  103.    msda = 1;
  104.     delay_24c02();
  105. }
  106. /*24c02的回应函数*/
  107. void respons()  //回应信号
  108. {
  109.         uchar i=0;
  110.         mscl=1;
  111.         delay_24c02();
  112.         while((msda==1)&&(i<250))i++;
  113.         mscl=0;
  114.         delay_24c02();
  115. }
  116. void writebyte(uchar date)// 写一个字节
  117. {
  118. uchar i,temp;
  119. temp=date;
  120. for(i=0;i<8;i++)
  121. {
  122.   temp=temp<<1;
  123.   mscl=0;
  124.   delay_24c02();
  125.   msda=CY;
  126.   delay_24c02();
  127.   mscl=1;
  128.   delay_24c02();
  129. }
  130. mscl=0;
  131. delay_24c02();
  132. msda=1;
  133. delay_24c02();
  134. }
  135. uchar readbyte()  //读一个字节
  136. {
  137. uchar i,j,k;
  138. mscl=0;
  139. delay_24c02();
  140. msda=1;
  141. for(i=0;i<8;i++)
  142. {
  143.   mscl=1;
  144.   delay_24c02();
  145.   if(msda==1)
  146.     j=1;
  147.   else
  148.     j=0;
  149.   k=(k<<1)|j;
  150.   mscl=0;
  151.   delay_24c02();
  152. }
  153. delay_24c02();
  154. return k;
  155. }
  156. //指定地址写一个字节数据
  157. void write_add(uchar address,uchar info)
  158. {
  159. start_24c02();
  160. writebyte(0xa0);
  161. respons();
  162. writebyte(address);
  163. respons();
  164. writebyte(info);
  165. respons();
  166. stop_24c02();
  167. }
  168. //指定地址读一个字节数据
  169. uchar read_add(uchar address)  
  170. {
  171. uchar dd;
  172. start_24c02();
  173. writebyte(0xa0);
  174. respons();
  175. writebyte(address);
  176. respons();
  177. start_24c02();
  178. writebyte(0xa1);
  179. respons();
  180. dd=readbyte();
  181. stop_24c02();
  182. return dd;
  183. }





  189. void main()
  190. {
  191.          unsigned int  a;
  192.          uchar A1,A2,A3;
  193.          uint  A2t;
  194.          uchar hour,minute,second;
  195.          uchar ho,min,h01,h02,m01,m02;
  196.          led1=0;led2=0;led3=0;led4=0;
  197.         IRIN=1;                    //I/O口初始化       
  198.         IE=0x81;                 //允许总中断中断,使能 INT0 外部中断
  199.         TCON=TCON|0x01;               //触发方式为脉冲负边沿触发
  200.        
  201.          while(1)
  202.          {
  203. //            write_1302(0x8e,0x00);
  204. //            write_1302(0xc0,0xfe);
  205. //            write_1302(0xc2,0xff);       
  206. //            write_1302(0x80,0x00);           //sec
  207. //            write_1302(0x82,0x00);           //min
  208. //            write_1302(0x84,0x16);            //hour
  209. //            write_1302(0x8e,0x80);       
  210.                
  211. //            for(a=100;a>0;a--)

  213.      if(hmodel==1)
  214.      {display1(htemp/10,htemp%10);
  215.           }
  216.          if(lmodel==1)
  217.          {display1(ltemp/10,ltemp%10);
  218.      }
  219.          
  220.          if(flag==1)
  221.           {
  222.             write_1302(0x8e,0x00);
  223.                 hour=read_1302(0x85);               
  224.                 minute=read_1302(0x83);               
  225.                 second=read_1302(0x81);
  226.                 write_1302(0x8e,0x80);       
  227.                 h1=hour/10;h2=hour%10;
  228.                 m1=minute/10;m2=minute%10;
  229.            
  230.                 TR0=0;                                                          
  231.            dsreset();                         //温度开始转换
  232.        delayds(1);
  233.        tmpwritebyte(0xcc);  // address all drivers on bus
  234.        tmpwritebyte(0x44);  //  initiates a single temperature conversion
  235.            for(a=10;a>0;a--)
  236.               {          
  237.             wendu=tmp();
  238.                 A1=wendu/100;
  239.         A2t=wendu%100;
  240.         A2=A2t/10;
  241.         A3=A2t%10;
  242.                 display(h1,h2,m1,m2,16,A1,A2,A3);

  244. //
  245. //            TMOD=0x01;                          //定时器工作在方式1
  246. //            ET0=1;
  247. //            EA=1;
  248. //            TH0=(65536-50000)/256; //对TH0 TL0赋值
  249. //            TL0=(65536-50000)%256; //使定时器0.05秒中断一次
  250. //             TR0=1;                                           //开始计时
  251. //
  252. //
  253. //              if(wendu>=htemp*10)
  254. //                     {
  255. //                        beep=0;
  256. //                        led1=0;
  257. //                   }
  258. //                if(wendu<=ltemp*10)
  259. //                   {
  260. //                        beep=0;
  261. //                        led2=0;
  262. //                    }
  263. //               
  264.             }
  265.                                   
  266.             TMOD=0x01;                          //定时器工作在方式1
  267.             ET0=1;
  268.             EA=1;
  269.             TH0=(65536-50000)/256; //对TH0 TL0赋值
  270.             TL0=(65536-50000)%256; //使定时器0.05秒中断一次
  271.              TR0=1;                                           //开始计时


  274.               if(wendu>=htemp*10)
  275.                      {
  276.                         beep=0;
  277.                         led1=0;
  278.                    }
  279.                 if(wendu<=ltemp*10)
  280.                    {
  281.                         beep=0;
  282.                         led2=0;
  283.                     }
  284.                
  285.                 }
  286.           
  287.            if(flag==2)       
  288.          {write_1302(0x8e,0x00);
  289.                 hour=read_1302(0x85);               
  290.                 minute=read_1302(0x83);               
  291.                 second=read_1302(0x81);
  292.                 write_1302(0x8e,0x80);       
  293.                 h3=hour/10;
  294.                 h4=hour%10;
  295.                 m3=minute/10;
  296.                 m4=minute%10;
  297.             TR0=0;                                                          
  298.            dsreset1();                         //温度开始转换
  299.        delayds(1);
  300.        tmpwritebyte1(0xcc);  // address all drivers on bus
  301.        tmpwritebyte1(0x44);  //  initiates a single temperature conversion
  302.            for(a=10;a>0;a--)
  303.             {          
  304.             wendu1=tmp1();
  305.                 A1=wendu1/100;
  306.         A2t=wendu1%100;
  307.         A2=A2t/10;
  308.         A3=A2t%10;
  309.                 display(h3,h4,m3,m4,16,A1,A2,A3);
  310. //              if(wendu1>=htemp1*10)
  311. //                   {
  312. //                        beep=0;
  313. //                        led3=0;
  314. //                }
  315. //                if(wendu1<=ltemp1*10)
  316. //                {
  317. //                        beep=0;
  318. //                        led4=0;
  319. //                }
  320.              }
  321.                 TR0=1;
  322.                         if(wendu1>=htemp1*10)
  323.                    {
  324.                         beep=0;
  325.                         led3=0;
  326.                 }
  327.                 if(wendu1<=ltemp1*10)
  328.                 {
  329.                         beep=0;
  330.                         led4=0;
  331.                 }
  332.           }
  333.           if(flag==3)
  334.           {
  335.             ho=read_add(pinjian-4);
  336.                 min=read_add(pinjian-3);
  337.                 h01=ho/10;h02=ho%10;
  338.                 m01=min/10;m02=min%10;
  339.                                                                                                          
  340.                 A2t=read_add(pinjian-2)*256+read_add(pinjian-1);
  341.                 A1=A2t/100;
  342.                 A2=A2t/10%10;
  343.                 A3=        A2t%10;                          
  344.                 display(h01,h02,m01,m02,16,A1,A2,A3);


  347.          }

  349.                                    
  350.   }
  351. }
  352. /**********************************************************/
  353. void IR_IN() interrupt 0 using 0
  354. {
  355.         unsigned char j,k,N=0;
  356.         unsigned char q=0;
  357.         EX0 = 0;   
  358.         delay(15);
  359.         if (IRIN==1)
  360.         {
  361.                 EX0 =1;
  362.                 return;
  363.         }
  364.                    //确认IR信号出现
  365.         while (!IRIN)            //等IR变为高电平，跳过9ms的前导低电平信号。
  366.                 delay(1);
  367.        
  368.         for (j=0;j<4;j++)            //收集四组数据
  369.         {
  370.                 for (k=0;k<8;k++)        //每组数据有8位
  371.                 {
  372.                         while (IRIN)            //等 IR 变为低电平，跳过4.5ms的前导高电平信号。
  373.                         { delay(1);}
  374.                         while (!IRIN)          //等 IR 变为高电平
  375.                                 delay(1);
  376.                         while (IRIN)           //计算IR高电平时长
  377.                         {
  378.                                 delay(1);
  379.                                 N++;           
  380.                                 if (N>=30)
  381.                                 {
  382.                                         EX0=1;
  383.                                         return;
  384.                                 }                  //0.14ms计数过长自动离开。
  385.                         }                        //高电平计数完毕               
  386.                         IRCOM[j]=IRCOM[j] >> 1;     //数据最高位补“0”
  387.                         if(N>=8)
  388.                         {
  389.                                 IRCOM[j] = IRCOM[j] | 0x80;                  //数据最高位补“1”
  390.                         }  
  391.                         N=0;
  392.                 }
  393.         }
  394.        
  395.         if(IRCOM[2]!=~IRCOM[3])                 // 数据出错
  396.         {
  397.                 EX0=1;
  398.                 return;
  399.         }
  400.        
  401.         IRCOM[5]=IRCOM[2] & 0x0F;     //取键码的低四位
  402.         IRCOM[6]=IRCOM[2] >> 4;       //右移4次，高四位变为低四位
  403.        
  404.         if(IRCOM[5]>9)
  405.         {
  406.                 IRCOM[5]=IRCOM[5]+0x37;
  407.         }
  408.         else
  409.         IRCOM[5]=IRCOM[5]+0x30;
  410.        
  411.         if(IRCOM[6]>9)
  412.         {
  413.                 IRCOM[6]=IRCOM[6]+0x37;
  414.         }
  415.         else
  416.         IRCOM[6]=IRCOM[6]+0x30;

  418.         q= (((IRCOM[6]&0x0f)<<4) + (IRCOM[5]&0x0f));
  419.    

  421.         switch(q)      //判断按键键码值
  422.         {
  423.         /*0: 设置高温限，1：设置低温限*/
  424.         /* 8: +1 ，9： -1            */
  425.                 case 0x16:
  426.                     hmodel =1;lmodel =0;     // 进入高温限设置
  427.                  break;              //串口发送0
  428.                 case 0x03:
  429.                    hmodel=0;  lmodel=1 ; // 进入低温限设置
  430.                    break;             //串口发送01
  431.                 case 0x18: displayall() ;break;  //串口发送02
  432.                 case 0x55: displayall1();break;  //串口发送03
  433.                 case 0x08: huicha();break;  //串口发送04
  434.                 case 0x13: TR0=0;pinjian-=4;if(pinjian==0){pinjian=4;};
  435.                                          break;  //串口发送05
  436.                 case 0x51:  flag=6;
  437.                             break;  //串口发送06
  438.                 case 0x42: fanhui() ;TR0=1; ;break;  //串口发送07
  439.                 case 0x52:                         // 加高低温限值
  440.                   if(hmodel==1)           // 设置高温限
  441.                   {
  442.                     htemp++;
  443.                    }
  444.                    else ltemp++;

  446.                  break;               //串口发送08
  447.                 case 0x41:
  448.                   if(hmodel==1)
  449.                   {
  450.                     htemp--;
  451.                    }
  452.                    else ltemp--;

  454.                   break;  //串口发送09       
  455.                 default :break;
  456.         }

  458.          EX0 = 1;
  459. }

  461. /********各种子程序*****************************/
  462. void fanhui()
  463. {
  464.   hmodel=0;
  465.   lmodel=0;
  466.   flag=0;
  467.   beep=1;
  468. }
  469. void displayall()
  470. {       
  471.            flag=1;                                  
  472. }
  473. void displayall1()
  474. {       
  475.        flag=2;                       
  476. }
  477. void huicha()
  478. {
  479.   flag=3;
  480. }

  482. /***************ds18b20*****************************/
  483. void dsreset(void)       //send reset and initialization command
  484. {
  485.   uint i;
  486.   DS=0;
  487.   i=103;
  488.   while(i>0)i--;
  489.   DS=1;
  490.   i=4;
  491.   while(i>0)i--;
  492. }

  494. bit tmpreadbit(void)       //read a bit
  495. {
  496.    uint i;
  497.    bit dat;
  498.    DS=0;i++;          //i++ for delay
  499.    DS=1;i++;i++;
  500.    dat=DS;
  501.    i=8;while(i>0)i--;
  502.    return (dat);
  503. }

  505. uchar tmpread(void)   //read a byte date
  506. {
  507.   uchar i,j,dat;
  508.   dat=0;
  509.   for(i=1;i<=8;i++)
  510.   {
  511.     j=tmpreadbit();
  512.     dat=(j<<7)|(dat>>1);   //读出的数据最低位在最前面，这样刚好一个字节在DAT里
  513.   }
  514.   return(dat);
  515. }

  517. void tmpwritebyte(uchar dat)   //write a byte to ds18b20
  518. {
  519.   uint i;
  520.   uchar j;
  521.   bit testb;
  522.   for(j=1;j<=8;j++)
  523.   {
  524.     testb=dat&0x01;
  525.     dat=dat>>1;
  526.     if(testb)     //write 1
  527.     {
  528.       DS=0;
  529.       i++;i++;
  530.       DS=1;
  531.       i=8;while(i>0)i--;
  532.     }
  533.     else
  534.     {
  535.       DS=0;       //write 0
  536.       i=8;while(i>0)i--;
  537.       DS=1;
  538.       i++;i++;
  539.     }

  541.   }
  542. }

  544. uint tmp()               //get the temperature
  545. {
  546.   float tt;
  547.   uchar a,b;
  548.   dsreset();
  549.   delay(1);
  550.   tmpwritebyte(0xcc);
  551.   tmpwritebyte(0xbe);
  552.   a=tmpread();
  553.   b=tmpread();
  554.   wendu=b;
  555.   wendu<<=8;             //two byte  compose a int variable
  556.   wendu=wendu|a;
  557.   tt=wendu*0.0625;
  558.   wendu=tt*10+0.5;
  559.   return wendu;
  560. }


  563. /***************ds18b20*****************************/
  564. void dsreset1(void)       //send reset and initialization command
  565. {
  566.   uint i;
  567.   DS1=0;
  568.   i=103;
  569.   while(i>0)i--;
  570.   DS1=1;
  571.   i=4;
  572.   while(i>0)i--;
  573. }

  575. bit tmpreadbit1(void)       //read a bit
  576. {
  577.    uint i;
  578.    bit dat;
  579.    DS1=0;i++;          //i++ for delay
  580.    DS1=1;i++;i++;
  581.    dat=DS1;
  582.    i=8;while(i>0)i--;
  583.    return (dat);
  584. }

  586. uchar tmpread1(void)   //read a byte date
  587. {
  588.   uchar i,j,dat;
  589.   dat=0;
  590.   for(i=1;i<=8;i++)
  591.   {
  592.     j=tmpreadbit1();
  593.     dat=(j<<7)|(dat>>1);   //读出的数据最低位在最前面，这样刚好一个字节在DAT里
  594.   }
  595.   return(dat);
  596. }

  598. void tmpwritebyte1(uchar dat)   //write a byte to ds18b20
  599. {
  600.   uint i;
  601.   uchar j;
  602.   bit testb;
  603.   for(j=1;j<=8;j++)
  604.   {
  605.     testb=dat&0x01;
  606.     dat=dat>>1;
  607.     if(testb)     //write 1
  608.     {
  609.       DS1=0;
  610.       i++;i++;
  611.       DS1=1;
  612.       i=8;while(i>0)i--;
  613.     }
  614.     else
  615.     {
  616.       DS1=0;       //write 0
  617.       i=8;while(i>0)i--;
  618.       DS1=1;
  619.       i++;i++;
  620.     }

  622.   }
  623. }

  625. uint tmp1()               //get the temperature
  626. {
  627.   float tt;
  628.   uchar a,b;
  629.   dsreset1();
  630.   delay(1);
  631.   tmpwritebyte1(0xcc);
  632.   tmpwritebyte1(0xbe);
  633.   a=tmpread1();
  634.   b=tmpread1();
  635.   wendu1=b;
  636.   wendu1<<=8;             //two byte  compose a int variable
  637.   wendu1=wendu1|a;
  638.   tt=wendu1*0.0625;
  639.   wendu1=tt*10+0.5;
  640.   return wendu1;
  641. }

  643. /***************ds1302*****************************/
  644. void write_1302(uchar add,dat)
  645. {
  646.         uchar i,temp;
  647.         temp=add;
  648.         ce=0;
  649.         _nop_();
  650.         sclk=0;
  651.         _nop_();
  652.         ce=1;
  653.         _nop_();
  654.         for(i=0;i<8;i++)
  655.         {
  656.                 sclk=0;
  657.                 _nop_();
  658.                 if((temp&0x01)==0x01)
  659.                         dio=1;
  660.                         else
  661.                         dio=0;
  662.                 temp>>=1;
  663.                 sclk=1;
  664.                 _nop_();
  665.         }
  666.         temp=dat;
  667.         for(i=0;i<8;i++)
  668.         {
  669.                 sclk=0;
  670.                 _nop_();
  671.                 if((temp&0x01)==0x01)
  672.                         dio=1;
  673.                         else
  674.                         dio=0;
  675.                 temp>>=1;
  676.                 sclk=1;
  677.                 _nop_();
  678.         }
  679.         ce=0;
  680.         sclk=0;
  681. }
  682. //读出1302的时间
  683. uchar read_1302(uchar add)
  684. {
  685.         uchar dat,dat1,i,temp;
  686.         temp=add;
  687.         ce=0;
  688.         _nop_();
  689.         sclk=0;
  690.         _nop_();
  691.         ce=1;
  692.         for(i=0;i<8;i++)
  693.         {
  694.                 sclk=0;
  695.                 _nop_();
  696.                 if((temp&0x01)==0x01)
  697.                         dio=1;
  698.                         else
  699.                         dio=0;
  700.                 temp>>=1;
  701.                 sclk=1;
  702.                 _nop_();
  703.         }
  704.         for(i=0;i<8;i++)
  705.         {
  706.                 sclk=0;
  707.                 _nop_();
  708.                 if(dio)
  709.                     dat|=0x80;
  710.                 if(i<7)
  711.                         dat>>=1;
  712.                 sclk=1;
  713.         }
  714.         dat1=dat/16;
  715.         dat=dat%16;
  716.         dat=dat1*10+dat;  
  717.         ce=0;
  718.         sclk=0;
  719.         return dat;
  720. }





  726. /***************延时函数*****************************/
  727. void delay(unsigned char x)    //x*0.14MS
  728. {
  729.         unsigned char i;
  730.         while(x--)
  731.         {
  732.                 for (i = 0; i<13; i++) {}
  733.         }
  734. }


  737. void display(uchar a,uchar b,uchar c,uchar d,uchar e,uchar f,uchar g,uchar h)
  738. {
  739. //   P0=table[a];
  740. //   dula=1;
  741. //   dula=0;
  742. //   
  743. //   P0=0xfe;
  744. //   wela=1;
  745. //   wela=0;
  746. //   delay(1);
  747. //   
  748. //   P0=table1[b];
  749. //   dula=1;
  750. //   dula=0;
  751. //   
  752. //   P0=0xfd;
  753. //   wela=1;
  754. //   wela=0;
  755. //   delay(1);
  756. //
  757. //   P0=table[c];
  758. //   dula=1;
  759. //   dula=0;
  760. //   
  761. //   P0=0xfb;
  762. //   wela=1;
  763. //   wela=0;
  764. //   delay(1);
  765. //   
  766. //   P0=table[d];
  767. //   dula=1;
  768. //   dula=0;
  769. //   
  770. //   P0=0xf7;
  771. //   wela=1;
  772. //   wela=0;
  773. //   delay(1);
  774. //   
  775. //   P0=table[e];
  776. //   dula=1;
  777. //   dula=0;
  778. //   
  779. //   P0=0xef;
  780. //   wela=1;
  781. //   wela=0;
  782. //   delay(1);
  783. //   
  784. //   P0=table[f];
  785. //   dula=1;
  786. //   dula=0;
  787. //   
  788. //   P0=0xdf;
  789. //   wela=1;
  790. //   wela=0;
  791. //   delay(1);
  792. //
  793. //   P0=table1[g];
  794. //   dula=1;
  795. //   dula=0;
  796. //
  797. //   P0=0xbf;
  798. //   wela=1;
  799. //   wela=0;
  800. //   delay(1);
  801. //
  802. //   P0=table[h];
  803. //   dula=1;
  804. //   dula=0;
  805. //
  806. //   P0=0x7f;
  807. //   wela=1;
  808. //   wela=0;
  809. //   delay(1);

  811.         
  812.     P0=table[a];
  813.     dula=1;
  814.     dula=0;

  816.     P0=0xfe;
  817.     wela=1;
  818.     wela=0;
  819.     delay(3);

  821.     P0=table1[b];
  822.     dula=1;
  823.     dula=0;

  825.     P0=0xfd;
  826.     wela=1;
  827.     wela=0;
  828.     delay(3);

  830.     P0=table[c];
  831.     dula=1;
  832.     dula=0;

  834.     P0=0xfb;
  835.     wela=1;
  836.     wela=0;
  837.     delay(3);

  839.     P0=table[d];
  840.     dula=1;
  841.     dula=0;

  843.     P0=0xf7;
  844.     wela=1;
  845.     wela=0;
  846.     delay(5);

  848.     P0=table[e];
  849.     dula=1;
  850.     dula=0;

  852.     P0=0xef;
  853.     wela=1;
  854.     wela=0;
  855.     delay(3);

  857.     P0=table[f];
  858.     dula=1;
  859.     dula=0;

  861.     P0=0xdf;
  862.     wela=1;
  863.     wela=0;
  864.     delay(3);

  866.     P0=table1[g];
  867.     dula=1;
  868.     dula=0;

  870.     P0=0xbf;
  871.     wela=1;
  872.     wela=0;
  873.     delay(3);

  875.     P0=table[h];
  876.     dula=1;
  877.     dula=0;

  879.     P0=0x7f;
  880.     wela=1;

  882.     wela=0;
  883.     delay(3);

  885.         //
  886.     P0=0x00;
  887.     dula=1;
  888.     dula=0;

  890.     P0=0x7f;
  891.     wela=1;

  893.     wela=0;
  894.     delay(3);
  895. }

  897. void display1(uchar a,uchar b)
  898. {
  899.    P0=table[a];
  900.    dula=1;
  901.    dula=0;
  902.    
  903.    P0=0xfe;
  904.    wela=1;
  905.    wela=0;
  906.    delay(1);
  907.    
  908.    P0=table1[b];
  909.    dula=1;
  910.    dula=0;
  911.    
  912.    P0=0xfd;
  913.    wela=1;
  914.    wela=0;
  915.    delay(1);

  917.    P0=0xff;
  918.    wela=1;
  919.    wela=0;
  920.    delay(1);
  921. }

  923. void delay1(int ms)
  924. {
  925.         unsigned char y;
  926.         while(ms--)
  927.         {
  928.                 for(y = 0; y<250; y++)
  929.                 {
  930.                         _nop_();
  931.                         _nop_();
  932.                         _nop_();
  933.                         _nop_();
  934.                 }
  935.         }
  936. }


  939. void time0() interrupt 1
  940. {   unsigned i=255;
  941.         TH0=(65536-50000)/256; //对TH0 TL0赋值
  942.         TL0=(65536-50000)%256; //重装计数初值
  943.         p++;
  944.         if(p==20)                  //10s存一次
  945.         {
  946.            p=0;
  947.            init_24c02();
  948.            write_add(pin,h1*10+h2);
  949.            while(i--);i=255;
  950.            write_add(pin+1,m1*10+m2);
  951.                 while(i--);i=255;
  952.            write_add(pin+2,wendu/256);
  953.            while(i--);i=255;
  954.            write_add(pin+3,wendu%256);
  955.            while(i--);i=255;
  956.            pin+=4;
  957.            pinjian=pin;         
  958.            if(pin==255)
  959.             {
  960.                   pin=0;
  961.                   }


  964.         }        
  965.        
  966. }

  968. //************************************************************
  969. void delay1ms()
  970. {
  971. unsigned int i;
  972. for(i=8024;i>0;i--);  //延时124*8+10=1002us
  973. }

  975. void delayds(uint z)
  976. {
  977.         uint x,y;
  978.         for(x=z;x>0;x--)
  979.                 for(y=120;y>0;y--);
  980. }
复制代码

所有资料51hei提供下载:
新红外.zip (71.95 KB, 下载次数: 12)


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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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