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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机温度控制报警和时间显示程序+Proteus仿真
返回列表 发新帖
查看: 9283|回复: 4
打印 上一主题 下一主题
收起左侧

51单片机温度控制报警和时间显示程序+Proteus仿真

[复制链接]
跳转到指定楼层
楼主
ID:291815 发表于 2019-4-9 19:03 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
本系统由AT89C51单片机、DS18B20温度检测部分、DS1302日期时间记录部分、数码管显示部分、按键输入部分和蜂鸣器报警部分组成。该系统通过按键一来调整模式，共五个模式。模式一是DS18B20采集环境温度并保存在存储器中通过单片机将温度显示在数码管上，当温度低于下限或高于上限时蜂鸣器报警；模式二是利用按键二和按键三调整报警的最高温度加减；模式三是利用按键二和按键三调整报警的最低温度加减；模式四是DS1302记录的日期通过单片机显示在数码管上；模式五是DS1302记录的时间通过单片机显示在数码管上。

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:
  1. #include <reg52.h>
  2. #include"intrins.h"
  3. #define uchar unsigned char
  4. #define uint  unsigned int
  5. sbit dula  = P2^0;        //数码管引脚定义
  6. sbit wela = P2^1;

  8. sbit DQ = P2^2;         //

  10. sbit key1 = P2^5;
  11. sbit key2 = P2^6;
  12. sbit key3 = P2^7;

  14. sbit buzz = P2^3;
  15. sbit led = P3^7;

  17. sbit RST=P1^0;                        
  18. sbit DSIO=P1^1;                        
  19. sbit SCLK=P1^2;                         //定义ds1302使用的IO口

  21. int bai,shi,ge;
  22. uchar fuhao,flag;
  23. uint ff,Hff=50,Lff=10;

  25. uchar count=0,t100ms=0,t500ms,t1s,t2s;
  26. uchar cishu=0;
  27. uchar jiange=0;
  28. uchar biaozhi1=0;  //由低于下限到高于下限标志
  29. uchar biaozhi2=0;  //有高于上限到低于上限标志
  30. uchar biaozhi3=0;  //2s长鸣标志
  31. uchar biaozhi4=0;

  33. uchar TIMEBCD[7] = {0x00, 0x00, 0x12, 0x1, 0x01, 0x01, 0x18};
  34. //存储顺序是秒分时日月周年,存储格式是用BCD码
  35. uchar TIME[7] = {0}; //十进制时间
  36. //DS1302时钟初始化2018年1月1日星期一12点00分00秒。

  38. uchar code READ_RTC_ADDR[7] = {0x81, 0x83, 0x85, 0x87, 0x89, 0x8b, 0x8d};
  39. uchar code WRITE_RTC_ADDR[7] = {0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c};
  40. //DS1302写入和读取时分秒的地址命令（最低位控制读写）

  42. unsigned char code table[]={
  43. 0x3f,0x06,0x5b,0x4f,
  44. 0x66,0x6d,0x7d,0x07,
  45. 0x7f, 0x6f};
  46. unsigned char code table1[]={
  47. 0xbf,0x86,0xdb,0xcf,
  48. 0xe6,0xed,0xfd,0x87,
  49. 0xff, 0xef};
  50. unsigned char code tablefu[]={
  51. 0x40, 0x76 , 0x38 , 0x39
  52. };                        //数码管符号 - H L C
  53. /*延时函数*/
  54. void delayms(uint xms)
  55. {
  56.         uint i,j;
  57.         for(i=xms;i>0;i--)
  58.         for(j=114;j>0;j--);
  59. }
  60. /*****温度延时*****/
  61. void Delaywendu(int num)
  62. {
  63.         while(num--) ;
  64. }
  65. /*****初始化DS18B20*****/
  66. void Init_DS18B20()
  67. {
  68.         DQ = 1;         //DQ复位
  69.         Delaywendu(8);    //稍做延时
  70.         DQ = 0;         //单片机将DQ拉低
  71.         Delaywendu(80);   //精确延时，大于480us
  72.         DQ = 1;         //拉高总线
  73.         Delaywendu(40);
  74. }
  75. /*****读一个字节*****/
  76. uchar ReadOneChar()
  77. {
  78.         uchar i=0;
  79.         uchar dat = 0;
  80.         for (i=8;i>0;i--)
  81.         {
  82.                 DQ = 0;     // 给脉冲信号
  83.                 dat>>=1;
  84.                 DQ = 1;     // 给脉冲信号
  85.                 if(DQ)
  86.                 dat|=0x80;
  87.                 Delaywendu(4);
  88.         }
  89.         return(dat);
  90. }
  91. /*****写一个字节*****/
  92. void WriteOneChar(uchar dat)
  93. {
  94.         uchar i=0;
  95.         for (i=8; i>0; i--)
  96.         {
  97.                 DQ = 0;
  98.                 DQ = dat&0x01;
  99.                 Delaywendu(5);
  100.                 DQ = 1;
  101.                 dat>>=1;
  102.         }
  103. }
  104. /*****读取温度*****/
  105. uint ReadTemperature()
  106. {
  107.   uint a=0,b=0;
  108.   int temp=0;
  109.   float tt=0;
  110.   Init_DS18B20();
  111.   WriteOneChar(0xCC);  //跳过读序号列号的操作  1100 1100
  112.   WriteOneChar(0x44);  //启动温度转换     0100 0100
  113.   Init_DS18B20();
  114.   WriteOneChar(0xCC);  //跳过读序号列号的操作
  115.   WriteOneChar(0xBE);  //读取温度寄存器  1011 1110
  116.   a=ReadOneChar();     //读低8位
  117.   b=ReadOneChar();    //读高8位
  118.   temp=b;
  119.   temp<<=8;
  120.   temp=temp|a;
  121.   if(temp&0xf800)
  122.   {
  123.         temp=~temp+1;
  124.         fuhao=1;
  125.   }
  126.   else
  127.   fuhao=0;
  128.   tt=temp*0.0625;
  129.   temp=tt*10+0.5;     //放大10倍输出并四舍五入
  130.   return(temp);
  131. }

  133. /*****读取温度*****/
  134. void check_wendu()
  135. {
  136.         uint f;
  137.         f=ReadTemperature();                          //获取温度值并减去DS18B20的温漂误差
  138.         ff=f;
  139.         bai=f/100;
  140.     shi=f %100/10;
  141.         ge= f%10;                                       
  142. }
  143. /****读设定值*****/
  144. void check_v_set(int v_set)
  145. {
  146.         int bb;
  147.         bb=v_set*10;   
  148.         bai=bb/100;
  149.     shi=bb %100/10;
  150.         ge= bb %10;                                                               
  151. }
  152. /*****显示温度子程序*****/
  153. void display()
  154. {     

  156.         P0=0xff;
  157.         wela=1;
  158.         P0=0xfb;
  159.         wela=0;
  160.         dula=1;
  161.         P0=table[bai];
  162.         dula=0;
  163.         delayms(5);

  165.         P0=0xff;
  166.         wela=1;
  167.         P0=0xf7;
  168.         wela=0;
  169.         dula=1;
  170.         P0=table1[shi];
  171.         dula=0;
  172.         delayms(5);
  173.         
  174.         P0=0xff;
  175.         wela=1;
  176.         P0=0xef;
  177.         wela=0;
  178.         dula=1;
  179.         P0=table[ge];
  180.         dula=0;
  181.         delayms(5);
  182.                
  183.         P0=0xff;
  184.         wela=1;
  185.         P0=0xdf;
  186.         wela=0;
  187.         dula=1;
  188.         P0=tablefu[3];
  189.         dula=0;
  190.         delayms(5);
  191. }
  192. void keyscan()
  193. {
  194.         if(key1==0)
  195.         {
  196.                 delayms(5);
  197.                 if(key1==0)
  198.                 {
  199.                         flag++;
  200.                         if(flag==5)
  201.                                 flag=0;
  202.                         while(!key1);
  203.                 }
  204.         }
  205. }
  206. int keyad(int num)
  207. {
  208.         if(flag!=0)
  209.         {
  210.                 if(key2==0)
  211.                 {
  212.                         delayms(5);
  213.                         if(key2==0)
  214.                         {
  215.                                 num++;
  216.                                 while(!key2);
  217.                         }
  218.                 }
  219.                 if(key3==0)
  220.                 {
  221.                         delayms(5);
  222.                         if(key3==0)
  223.                         {
  224.                                 num--;
  225.                                 while(!key3);
  226.                         }
  227.                 }        
  228.         }
  229.         return num;
  230. }
  231. /**************************************************************/
  232. /**************************日历计时部分************************/
  233. void Ds1302Write(uchar addr, uchar dat) //向DS1302发送命令（地址+数据）
  234. {
  235.         uchar n;
  236.         RST = 0;
  237.         _nop_();
  238.         SCLK = 0;//先将SCLK置低电平。
  239.         _nop_();
  240.         RST = 1; //然后将RST(CE)置高电平。
  241.         _nop_();

  243.         for (n=0; n<8; n++)//开始传送八位地址命令
  244.         {
  245.                 DSIO = addr & 0x01;//数据从低位开始传送
  246.                 addr >>= 1;
  247.                 SCLK = 1;//数据在上升沿时，DS1302读取数据
  248.                 _nop_();
  249.                 SCLK = 0;
  250.                 _nop_();
  251.         }
  252.         for (n=0; n<8; n++)//写入8位数据
  253.         {
  254.                 DSIO = dat & 0x01;
  255.                 dat >>= 1;
  256.                 SCLK = 1;//数据在上升沿时，DS1302读取数据
  257.                 _nop_();
  258.                 SCLK = 0;
  259.                 _nop_();        
  260.         }        
  261.                  
  262.         RST = 0;//传送数据结束
  263.         _nop_();
  264. }

  266. uchar Ds1302Read(uchar addr) //读取一个地址的数据
  267. {
  268.         uchar n,dat,dat1;
  269.         RST = 0;
  270.         _nop_();

  272.         SCLK = 0;//先将SCLK置低电平。
  273.         _nop_();
  274.         RST = 1;//然后将RST(CE)置高电平。
  275.         _nop_();

  277.         for(n=0; n<8; n++)//开始传送八位地址命令
  278.         {
  279.                 DSIO = addr & 0x01;//数据从低位开始传送
  280.                 addr >>= 1;
  281.                 SCLK = 1;//数据在上升沿时，DS1302读取数据
  282.                 _nop_();
  283.                 SCLK = 0;//DS1302下降沿时，放置数据
  284.                 _nop_();
  285.         }
  286.         _nop_();
  287.         for(n=0; n<8; n++)//读取8位数据
  288.         {
  289.                 dat1 = DSIO;//从最低位开始接收
  290.                 dat = (dat>>1) | (dat1<<7);
  291.                 SCLK = 1;
  292.                 _nop_();
  293.                 SCLK = 0;//DS1302下降沿时，放置数据
  294.                 _nop_();
  295.         }

  297.         RST = 0;
  298.         _nop_();        //以下为DS1302复位的稳定时间
  299.         SCLK = 1;
  300.         _nop_();
  301.         DSIO = 0;
  302.         _nop_();
  303.         DSIO = 1;
  304.         _nop_();
  305.         return dat;        
  306. }

  308. void Ds1302ReadTime()  //读取时钟信息
  309. {
  310.         uchar n;
  311.         for (n=0; n<7; n++)//读取7个字节的时钟信号：分秒时日月周年
  312.         {
  313.                 TIMEBCD[n] = Ds1302Read(READ_RTC_ADDR[n]);
  314.                 TIME[n] = TIMEBCD[n]/16*10+TIMEBCD[n]%16;
  315.         }
  316. }

  318. void Ds1302Init() // 初始化DS1302
  319. {        
  320.         uchar n;
  321.         Ds1302ReadTime();                           //首次读取时间
  322.         if(TIME[5]==0)                                   //判断时间值是否有效
  323.         {
  324.                 Ds1302Write(0x8E,0X00);                 //禁止写保护，就是关闭写保护功能
  325.                 for (n=0; n<7; n++)//写入7个字节的时钟信号：分秒时日月周年
  326.                 {
  327.                         Ds1302Write(WRITE_RTC_ADDR[n],TIMEBCD[n]);        
  328.                 }
  329.                 Ds1302Write(0x8E,0x80);                 //打开写保护功能
  330.         }
  331. }
  332. void displaytime()
  333. {     

  335.         P0=0xff;
  336.         wela=1;
  337.         P0=0xfe;
  338.         wela=0;
  339.         dula=1;
  340.         P0=table[TIME[2]/10];
  341.         dula=0;
  342.         delayms(5);

  344.         P0=0xff;
  345.         wela=1;
  346.         P0=0xfd;
  347.         wela=0;
  348.         dula=1;
  349.         P0=table1[TIME[2]%10];
  350.         dula=0;
  351.         delayms(5);
  352.         
  353.         P0=0xff;
  354.         wela=1;
  355.         P0=0xfb;
  356.         wela=0;
  357.         dula=1;
  358.         P0=table[TIME[1]/10];
  359.         dula=0;
  360.         delayms(5);
  361.                
  362.         P0=0xff;
  363.         wela=1;
  364.         P0=0xf7;
  365.         wela=0;
  366.         dula=1;
  367.         P0=table1[TIME[1]%10];
  368.         dula=0;
  369.         delayms(5);

  371.         P0=0xff;
  372.         wela=1;
  373.         P0=0xef;
  374.         wela=0;
  375.         dula=1;
  376.         P0=table[TIME[0]/10];
  377.         dula=0;
  378.         delayms(5);

  380.         P0=0xff;
  381.         wela=1;
  382.         P0=0xdf;
  383.         wela=0;
  384.         dula=1;
  385.         P0=table1[TIME[0]%10];
  386.         dula=0;
  387.         delayms(5);
  388. }
  389. void displaydate()
  390. {     

  392.         P0=0xff;
  393.         wela=1;
  394.         P0=0xfe;
  395.         wela=0;
  396.         dula=1;
  397.         P0=table[TIME[6]/10];
  398.         dula=0;
  399.         delayms(5);

  401.         P0=0xff;
  402.         wela=1;
  403.         P0=0xfd;
  404.         wela=0;
  405.         dula=1;
  406.         P0=table1[TIME[6]%10];
  407.         dula=0;
  408.         delayms(5);
  409.         
  410.         P0=0xff;
  411.         wela=1;
  412.         P0=0xfb;
  413.         wela=0;
  414.         dula=1;
  415.         P0=table[TIME[4]/10];
  416.         dula=0;
  417.         delayms(5);
  418.                
  419.         P0=0xff;
  420.         wela=1;
  421.         P0=0xf7;
  422.         wela=0;
  423.         dula=1;
  424.         P0=table1[TIME[4]%10];
  425.         dula=0;
  426.         delayms(5);

  428.         P0=0xff;
  429.         wela=1;
  430.         P0=0xef;
  431.         wela=0;
  432.         dula=1;
  433.         P0=table[TIME[3]/10];
  434.         dula=0;
  435.         delayms(5);

  437.         P0=0xff;
  438.         wela=1;
  439.         P0=0xdf;
  440.         wela=0;
  441.         dula=1;
  442.         P0=table1[TIME[3]%10];
  443.         dula=0;
  444.         delayms(5);
  445. }
  446. /*主函数*/
  447. void main()
  448. {
  449.         
  450.         int z;
  451.         buzz=1;         //低电平响，
  452.         led=0;
  453.         TMOD=0x01;//设置定时器0工作模式1
  454.         TH0=(65536-50000)/256;//定时器装初值
  455.         TL0=(65536-50000)%256;
  456.         EA=1; //开总中断
  457.         ET0=1; //开定时器0中断

  459.         Ds1302Init( );
  460.         for(z=0;z<100;z++)
  461.         {
  462.         check_wendu();
  463.         }               
  464.         TR0=1;
  465.         while(1)
  466.         {
  467.                 keyscan();
  468.                 if(flag==0)
  469.                 {
  470.                         check_wendu();
  471.                         if(fuhao==1)                                //当温度值为负数
  472.                           {
  473.                                 P0=0xff;
  474.                                 wela=1;
  475.                                 P0=0xfd;
  476.                                 wela=0;
  477.                                 dula=1;
  478.                                 P0=tablefu[0];
  479.                                 dula=0;
  480.                                 delayms(5);                //显示负
  481.                           }
  482.                          else
  483.                           {                        
  484.                                   P0=0xff;
  485.                                 wela=1;
  486.                                 P0=0xfd;
  487.                                 wela=0;
  488.                                 dula=1;
  489.                                 P0=0x00;
  490.                                 dula=0;
  491.                                 delayms(5);                        //显示正
  492.                         }
  493.                         display();
  494.                 }
  495.                 else if(flag==1)
  496.                 {
  497.                         Hff=keyad(Hff);
  498.                         check_v_set(Hff);
  499.                         
  500.                         P0=0xff;
  501.                         wela=1;
  502.                         P0=0xfe;
  503.                         wela=0;
  504.                         dula=1;
  505.                         P0=tablefu[1];
  506.                         dula=0;
  507.                         delayms(5);                //显示H

  509.                         display();        
  510.                 }
  511.                 else if(flag==2)
  512.                 {
  513.                          Lff=keyad(Lff);
  514.                         check_v_set(Lff);

  516.                         P0=0xff;
  517.                         wela=1;
  518.                         P0=0xfe;
  519.                         wela=0;
  520.                         dula=1;
  521.                         P0=tablefu[2];
  522.                         dula=0;
  523.                         delayms(5);                //显示L

  525.                         display();
  526.                 }
  527.                 else if(flag==3)
  528.                 {
  529.                         Ds1302ReadTime();
  530.                     delayms(10);
  531.                         displaydate();
  532.                 }
  533.                 else if(flag==4)
  534.                 {
  535.                         Ds1302ReadTime();
  536.                     delayms(10);
  537.                         displaytime();
  538.                         
  539.                 }
  540.         }
  541. }
  542. /*中断函数*/
  543. void timer0() interrupt 1//定时器0中断服务程序
  544. {
  545.         TH0=(65536-50000)/256;//再次装定时器初值
  546.         TL0=(65536-50000)%256;
  547.         count++; //中断次数累加         //50毫秒
  548. //        ff=ReadTemperature();
  549.         if(count%2==0)
  550.         {        
  551.                 t100ms = 1;                        
  552.         }
  553.         if(count%10==0)
  554.         {        
  555.                 t500ms = 1;                        
  556.         }
  557.         if(count%20==0)
  558.         {        
  559. ……………………

  561. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
test1.zip (156.81 KB, 下载次数: 173)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

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

使用道具 举报

沙发
ID:496609 发表于 2019-11-7 15:41 来自手机 | 只看该作者
感谢      
回复

使用道具 举报

板凳
ID:649621 发表于 2019-11-26 09:04 | 只看该作者
感谢！
回复

使用道具 举报

地板
ID:649921 发表于 2019-12-3 15:21 | 只看该作者
。。。。我怎么打不开 仿真图片？？？
回复

使用道具 举报

5#
ID:651767 发表于 2019-12-4 12:33 | 只看该作者
为啥程序导进去后 仿真数码管会不亮 端口也是灰色 连着数码管的两个 端口也是灰色的
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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