找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 4360|回复: 1
打印 上一主题 下一主题
收起左侧

基于51单片机的智能家居系统程序设计

  [复制链接]
跳转到指定楼层
楼主
这是我的设计,全原创。附件是完整程序
内容:
本课题基于单片机技术, 研究一典型的智能家居系统设计. 系统拟采用控制器,监控器和控制终端的框架结构, 主要设计对家居中的时间、温度、湿度和光照等信息的检测, 以及照明系统, 窗帘和家用电器的自动控制. 具体设计要求如下:
1)温度以及室外湿度,PM2.5的自动监测与显示.
2)照明系统的自动控制与手动控制, 如离开家时关闭所有照明.
3)窗帘与窗户的自动控制与手动控制,如睡眠时自动关闭窗帘, 当室外湿度和PM2.5超出预警值时自动关闭窗户.
      4)实现窗帘窗户以及家用电器的远程控制.

电路原理图如下:


单片机源程序如下:
  1. #include <REGX52.H>
  2. #include "LCd1602.h"
  3. #include "dht11.c"
  4. #include "eeprom52.h"        
  5. #include "hong_wai.h"

  6. sbit key1=P2^3;
  7. sbit key2=P3^1;
  8. sbit key3=P3^3;
  9. sbit key4=P3^4;
  10. sbit key5=P3^5;
  11. sbit key6=P3^6;
  12. sbit key7=P3^7;
  13. sbit LED=P2^4;
  14. sbit RSD=P2^2;
  15. sbit light=P2^1;



  16. bit key1_flag=0;
  17. bit key2_flag=0;
  18. bit key3_flag=0;
  19. bit key4_flag=0;
  20. bit key5_flag=0;
  21. bit key6_flag=0;
  22. bit key7_flag=0;

  23. uchar sec=0;
  24. uchar sec1=0;
  25. uchar rh_h=0;
  26. uchar ms=0;
  27. uchar state=0;


  28. bit mode =0;  //mode 是控制电机的 自动手动标志位
  29. bit mode1=0;  //mode1是控制灯的 自动手动标志位
  30. bit s0;
  31. bit star_stop=1;



  32. uchar UART_Upload[9];  // Upload上传  accord主动
  33. uint pm_rateH,pm_rateL,pm_particle,pm_density,pm_URV;//低脉冲率高位。低脉冲率低位, 比率,颗粒,浓度  PM_URV  pm上限值
  34. uchar  accord=0;

  35. uchar fz[]=                                   //正转数据
  36. {
  37.         0x01,0x03,0x02,0x06,0x04,0x0c,0x08,0x09
  38. };


  39. uchar zz[]=                                   //反转数据
  40. {
  41.         0x09,0x08,0x0c,0x04,0x06,0x02,0x03,0x01
  42. };

  43. uchar loop=0;

  44. uint DJ_dat=0;

  45. void memory()
  46. {        ///pm_URV
  47.    SectorErase(0x2000);
  48.    byte_write(0x2000,rh_h);
  49.    byte_write(0x2001,pm_URV/256);
  50.    byte_write(0x2002,pm_URV%256);
  51. }
  52. void read_memory()
  53. {
  54.    rh_h=byte_read(0x2000);
  55.    pm_URV=byte_read(0x2001)*256+byte_read(0x2002);
  56.    if(rh_h>99||pm_URV>9999)         
  57.     {
  58.           rh_h=30;
  59.           pm_URV=500;
  60.         }
  61. }
  62. void display_dispose()
  63. {
  64.         if(state==0)         // U8RH_data_H  U8T_data_H
  65.          {
  66.                    LCD1602_write(0,0x80);
  67.                    LCD1602_writebyte("R:");
  68.                    LCD1602_write(1,0x30+U8RH_data_H/10);
  69.                    LCD1602_write(1,0x30+U8RH_data_H%10);
  70.                    LCD1602_writebyte("% ");
  71.                
  72.                    LCD1602_writebyte("T:");
  73.                    LCD1602_write(1,0x30+U8T_data_H/10);
  74.                    LCD1602_write(1,0x30+U8T_data_H%10);
  75.                    LCD1602_write(1,0xdf);
  76.                    LCD1602_writebyte("C ");
  77.                    if(mode1) LCD1602_writebyte("A ");
  78.                    else          LCD1602_writebyte("M ");

  79.                    if(mode) LCD1602_writebyte("A ");
  80.                    else         LCD1602_writebyte("M ");



  81.                
  82.                    LCD1602_write(0,0xC0);
  83.                    LCD1602_writebyte("P:");           //pm_density
  84.                    LCD1602_write(1,0x30+pm_density/1000%10);
  85.                    LCD1602_write(1,0x30+pm_density/100%10);
  86.                    LCD1602_write(1,0x30+pm_density/10%10);
  87.                    LCD1602_writebyte(".");
  88.                    LCD1602_write(1,0x30+pm_density%10);
  89.                    LCD1602_writebyte("ug/m3 ");        
  90.                    if(LED==0) LCD1602_writebyte("K ");
  91.                    else           LCD1602_writebyte("G ");

  92.                    if(star_stop==0) LCD1602_writebyte("K ");
  93.                    else                 LCD1602_writebyte("G ");

  94.                      
  95.          }
  96.         else
  97.          {
  98.                    LCD1602_write(0,0x80);
  99.                    LCD1602_writebyte("RH_H:");
  100.                    if(state==1&&s0)   LCD1602_writebyte("  ");
  101.                    else
  102.                     {
  103.                            LCD1602_write(1,0x30+rh_h/10);
  104.                            LCD1602_write(1,0x30+rh_h%10);                          
  105.                         }
  106.                    LCD1602_writebyte("%              ");

  107.                    LCD1602_write(0,0xC0);
  108.                    LCD1602_writebyte("PM2.5:");           //pm_density
  109.                    if(state==2&&s0)   LCD1602_writebyte("     ");
  110.                    else
  111.                     {
  112.                            LCD1602_write(1,0x30+pm_URV/1000%10);
  113.                            LCD1602_write(1,0x30+pm_URV/100%10);
  114.                            LCD1602_write(1,0x30+pm_URV/10%10);
  115.                            LCD1602_writebyte(".");
  116.                            LCD1602_write(1,0x30+pm_URV%10);                  
  117.                         }
  118.                    LCD1602_writebyte("ug/m3 ");            
  119.          }                                 
  120. }
  121. void key()
  122. {
  123.    if(!key1||ircode[2]==0x0c)
  124.     {  ircode[2]=0;
  125.           if(key1_flag)
  126.            {
  127.              key1_flag=0;
  128.                  state=(state+1)%3;
  129.            }
  130.         }
  131.         else
  132.          {
  133.            if(ircode[2]!=0x0c) key1_flag=1;
  134.          }

  135.          
  136.    if(!key2||ircode[2]==0x18)
  137.     {  ircode[2]=0;
  138.           if(key2_flag)
  139.            {
  140.              key2_flag=0;
  141.                  if(state==1)
  142.                   {
  143.                     if(rh_h<99) rh_h++;        
  144.                      memory();
  145.                   }
  146.                   else if(state==2)         
  147.                    {
  148.                     if(pm_URV<9999) pm_URV++;        
  149.                      memory();
  150.                    }
  151.            }

  152.            if(sec==0)
  153.             {
  154.                          if(state==1)
  155.                           {
  156.                             if(rh_h<99) rh_h++;        
  157.                              memory();
  158.                           }
  159.                           else if(state==2)         
  160.                            {
  161.                             if(pm_URV<9999) pm_URV++;        
  162.                              memory();
  163.                            }
  164.                 }

  165.         }
  166.         else
  167.          {
  168.            if(ircode[2]!=0x18)
  169.             {
  170.                          key2_flag=1;
  171.                      sec=2;
  172.                 }
  173.          }
  174.          

  175.         

  176.    if(!key3||ircode[2]==0x5E)
  177.     {  ircode[2]=0;
  178.           if(key3_flag)
  179.            {
  180.              key3_flag=0;
  181.                  if(state==1)
  182.                   {
  183.                     if(rh_h>0) rh_h--;        
  184.                      memory();
  185.                   }
  186.                   else if(state==2)         
  187.                    {
  188.                     if(pm_URV>0) pm_URV--;        
  189.                      memory();
  190.                    }
  191.            }
  192.            if(sec1==0)
  193.             {
  194.                          if(state==1)
  195.                           {
  196.                             if(rh_h>0) rh_h--;        
  197.                              memory();
  198.                           }
  199.                           else if(state==2)         
  200.                            {
  201.                             if(pm_URV>0) pm_URV--;        
  202.                              memory();
  203.                            }
  204.                 }
  205.         }
  206.         else
  207.          {
  208.            if(ircode[2]!=0x5E)
  209.             {
  210.                    key3_flag=1;
  211.                    sec1=2;
  212.                 }
  213.          }





  214.    if(!key4||ircode[2]==0x08)
  215.     { ircode[2]=0;
  216.           if(key4_flag)
  217.            {
  218.              key4_flag=0;
  219.                  mode1=~mode1;
  220.                  LED=1;
  221.            }
  222.         }
  223.         else  
  224.          {
  225.            if(ircode[2]!=0x08)
  226.             {
  227.                  key4_flag=1;
  228.                 }
  229.          }


  230.    if(!key5||ircode[2]==0x1C)
  231.     { ircode[2]=0;
  232.           if(key5_flag)
  233.            {
  234.              key5_flag=0;
  235.                  mode=~mode;
  236.            }
  237.         }
  238.         else  
  239.          {
  240.            if(ircode[2]!=0x1C)
  241.             {
  242.                  key5_flag=1;
  243.                 }
  244.          }


  245.          

  246.    if(!key6||ircode[2]==0x5A)
  247.     { ircode[2]=0;
  248.           if(key6_flag)
  249.            {
  250.              key6_flag=0;
  251.                  if(mode1==0)
  252.                   {
  253.                     LED=~LED;
  254.                   }
  255.            }
  256.         }
  257.         else  
  258.          {
  259.            if(ircode[2]!=0x5A)
  260.             {
  261.                   key6_flag=1;
  262.                 }
  263.          }




  264.    if(!key7||ircode[2]==0x42)
  265.     {  ircode[2]=0;
  266.           if(key7_flag)
  267.            {
  268.              key7_flag=0;
  269.                  if(mode==0)
  270.                   {
  271.                     star_stop=~star_stop;
  272.                   }
  273.            }
  274.         }
  275.         else  
  276.          {
  277.            if(ircode[2]!=0x42)
  278.             {
  279.                   key7_flag=1;
  280.                 }
  281.          }
  282.         
  283.          
  284. }

  285. void interrupt_int()
  286. {
  287.           EX0=1;                   //打开外部中断0
  288.           IT0=1;                   //设置为边沿触发
  289.          
  290.           TMOD=0x12;           //设置定时器0工作模式2  8位自动重装 256
  291.           TH0=0;
  292.           TL0=0;               //装入初值
  293.           ET0=1;                   //打开定时器中断

  294.           TH1=0x3C;
  295.           TL1=0xb0;               //装入初值
  296.           ET1=1;                   //打开定时器中断

  297.           EA=1;                           //打开总中断开关
  298.           TR0=1;                   //打开定时器,开始计时
  299.           TR1=1;
  300. }

  301. void UART_Init(void)
  302. {
  303. T2CON = 0x34;
  304. RCAP2H = 0xFF;
  305. RCAP2L = 0xDC;
  306. TH2 = 0xFF;
  307. TL2 = 0xDC;
  308. TR2 = 1;      
  309. SCON = 0x50;
  310. ES = 1;  
  311. }

  312. void mode_dispose()         //mode 是控制电机的   mode1是控制灯的自动手动标志
  313. {
  314.    if(mode1)          //mode1==0  手动   mode1==1  自动   
  315.     {
  316.      if(light)
  317.           {
  318.                    if(RSD)
  319.                     {
  320.                           LED=0;
  321.                         }
  322.                         else  LED=1;            
  323.           }
  324.           else           LED=1;

  325.         }  

  326.    if(mode)          //mode1==0  手动   mode1==1  自动   
  327.     {
  328.            if(light==0)
  329.             {
  330.                   if((rh_h<U8RH_data_H)||(pm_URV<pm_density)) star_stop=0;
  331.                   else          star_stop=1;
  332.                 }
  333.                 else  star_stop=1;
  334.         }  

  335.             if(DJ_dat==0) loop=0;
  336.          while(DJ_dat<520&&star_stop==0)
  337.                         {
  338.                                 P1=P1&0xf0|zz[loop];                                                        
  339.                                 loop=(loop+1)%8;

  340.                                 if(loop==0) DJ_dat++;
  341.                                 LCD1602_delay(100);                                       
  342.                         }                              

  343.                while(DJ_dat!=0&&star_stop==1)
  344.                         {
  345.                                 P1=P1&0xf0|fz[loop];
  346.                                 loop=(loop+1)%8;
  347.                         
  348.                                 if(loop==0) DJ_dat--;
  349.                                 LCD1602_delay(100);
  350.                         }
  351.            
  352.                               P1=0x00;
  353.          
  354.    


  355. }


  356. void main()
  357. {
  358.    LCD1602_cls();
  359.    interrupt_int();        
  360.    UART_Init();        
  361.    read_memory();        
  362.    while(1)
  363.     {
  364.           mode_dispose();
  365.           display_dispose();
  366.         
  367.         }
  368. }





  369. void int0() interrupt 0
  370. {
  371.   if(starflag)
  372.     {
  373.              if(irtime>32)  //引导码时间除以0.256,是31.多毫秒
  374.                   {
  375.                          bitnum=0; //此时确定接收到引导码,清零变量,接收数据
  376.                   }
  377.                  irdata[bitnum]=irtime;        //将数据接收送入irdata
  378.                  irtime=0;                //每接收一位数据,清零一次,使下次接受的数据准确
  379.                  bitnum++;                //数组变量增加
  380.                  if(bitnum==33)        //当变量增加到33时,说明一帧数据接收完毕
  381.                   {
  382.                     bitnum=0;        //清零数组变量
  383.                         irreceok=1;        //接收完一帧数据标志位
  384.                         
  385.                   }
  386.     }
  387.   else
  388.     {
  389.           starflag=1;        //为接收一帧数据的第一位做准备
  390.           irtime=0;                //清零定时变量
  391.         }



  392.   
  393. }

  394. void time0() interrupt 1
  395. {
  396. irtime++;  //因为是模式2,那么变量每加一一次,就是定时了256um,也就是0.256毫秒
  397. }
  398. void time1() interrupt 3
  399. {
  400.           TH1=0x3C;
  401.           TL1=0xb0;            
  402.           ms++;         
  403.           key();           
  404.           ir_ok();
  405.           if(ms%10==0)        s0=~s0;
  406.           if(ms>=20)
  407.            { RH();
  408.              ms=0;
  409.                  if(sec!=0)sec--;
  410.                  if(sec1!=0)sec1--;
  411.            }
  412. }


  413. void uart () interrupt 4
  414. {
  415.         uchar temp_pM;
  416.         if(RI==1)
  417.         {
  418.                 RI=0;
  419.                 UART_Upload[accord]=SBUF; //串口接收一个数据
  420.                 accord++;
  421.                 if(UART_Upload[0]!=0xff)  //判断接收到的第一个数据为oxff  数据错误 数组指针清零
  422.                 {
  423.                         accord=0;
  424.                 }
  425.                 if(UART_Upload[1]!=0x18)//判断接收到的第2个为0x18  数据错误 数组指针清零
  426.                 {
  427.                         accord=0;
  428.                 }
  429.                 if(accord>8)                 //九个数据为一组
  430.                 {
  431.                         accord=0; //接收完一组数据的标志,置0 校验         
  432.                 }               
  433.                 if(accord==0)                //接收一组数据后进行一次校验和
  434.                 {                                         //校验7为数据位的和取反加一等于校验值
  435.                         if((UART_Upload[0]==0xff)&&(UART_Upload[1]=0x18)&&(UART_Upload[2]==0x00))//判断前三位数据是否正确 是进行校验
  436.                         {        
  437.                                 temp_pM=~(UART_Upload[1]+UART_Upload[2]+UART_Upload[3]+UART_Upload[4]+UART_Upload[5]+UART_Upload[6]+UART_Upload[7])+1;        //校验和
  438.                                   if(temp_pM=UART_Upload[8])
  439.                                 {
  440.                                         pm_rateH=UART_Upload[3];
  441.                                         pm_rateL=UART_Upload[4];
  442.                                         pm_density=(UART_Upload[3]*100+UART_Upload[4])*1.014705; //浓度数据处理          数据扩大了十倍
  443.                                         /*我们绘出一个检验报告,比如在345ug/m3的情况下,zph01输出占空比34%。我们理论认为在0-34%对应的0-345ug/m3。他们是 线性比例关系*/                        
  444.                                 }
  445.                         }
  446.         
  447.                 }

  448.         }
  449. }

复制代码

全部程序51hei下载地址:
xtr.c.zip (35.08 KB, 下载次数: 143)



评分

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

查看全部评分

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

使用道具 举报

沙发
ID:832960 发表于 2020-10-22 23:24 | 只看该作者
这个代码的子程序不全,大佬能不能发个完整的代码给我谢谢
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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