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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于51单片机的智能家居系统程序设计
返回列表 发新帖
查看: 4293|回复: 1
打印 上一主题 下一主题
收起左侧

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

  [复制链接]
跳转到指定楼层
楼主
ID:761907 发表于 2020-5-26 20:37 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
这是我的设计，全原创。附件是完整程序
内容：
本课题基于单片机技术, 研究一典型的智能家居系统设计. 系统拟采用控制器,监控器和控制终端的框架结构, 主要设计对家居中的时间、温度、湿度和光照等信息的检测, 以及照明系统, 窗帘和家用电器的自动控制. 具体设计要求如下:
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"

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



  20. bit key1_flag=0;
  21. bit key2_flag=0;
  22. bit key3_flag=0;
  23. bit key4_flag=0;
  24. bit key5_flag=0;
  25. bit key6_flag=0;
  26. bit key7_flag=0;

  28. uchar sec=0;
  29. uchar sec1=0;
  30. uchar rh_h=0;
  31. uchar ms=0;
  32. uchar state=0;


  35. bit mode =0;  //mode 是控制电机的 自动手动标志位
  36. bit mode1=0;  //mode1是控制灯的 自动手动标志位
  37. bit s0;
  38. bit star_stop=1;



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

  46. uchar fz[]=                                   //正转数据
  47. {
  48.         0x01,0x03,0x02,0x06,0x04,0x0c,0x08,0x09
  49. };


  52. uchar zz[]=                                   //反转数据
  53. {
  54.         0x09,0x08,0x0c,0x04,0x06,0x02,0x03,0x01
  55. };

  57. uchar loop=0;

  59. uint DJ_dat=0;

  61. void memory()
  62. {        ///pm_URV
  63.    SectorErase(0x2000);
  64.    byte_write(0x2000,rh_h);
  65.    byte_write(0x2001,pm_URV/256);
  66.    byte_write(0x2002,pm_URV%256);
  67. }
  68. void read_memory()
  69. {
  70.    rh_h=byte_read(0x2000);
  71.    pm_URV=byte_read(0x2001)*256+byte_read(0x2002);
  72.    if(rh_h>99||pm_URV>9999)         
  73.     {
  74.           rh_h=30;
  75.           pm_URV=500;
  76.         }
  77. }
  78. void display_dispose()
  79. {
  80.         if(state==0)         // U8RH_data_H  U8T_data_H
  81.          {
  82.                    LCD1602_write(0,0x80);
  83.                    LCD1602_writebyte("R:");
  84.                    LCD1602_write(1,0x30+U8RH_data_H/10);
  85.                    LCD1602_write(1,0x30+U8RH_data_H%10);
  86.                    LCD1602_writebyte("% ");
  87.                
  88.                    LCD1602_writebyte("T:");
  89.                    LCD1602_write(1,0x30+U8T_data_H/10);
  90.                    LCD1602_write(1,0x30+U8T_data_H%10);
  91.                    LCD1602_write(1,0xdf);
  92.                    LCD1602_writebyte("C ");
  93.                    if(mode1) LCD1602_writebyte("A ");
  94.                    else          LCD1602_writebyte("M ");

  96.                    if(mode) LCD1602_writebyte("A ");
  97.                    else         LCD1602_writebyte("M ");



  101.                
  102.                    LCD1602_write(0,0xC0);
  103.                    LCD1602_writebyte("P:");           //pm_density
  104.                    LCD1602_write(1,0x30+pm_density/1000%10);
  105.                    LCD1602_write(1,0x30+pm_density/100%10);
  106.                    LCD1602_write(1,0x30+pm_density/10%10);
  107.                    LCD1602_writebyte(".");
  108.                    LCD1602_write(1,0x30+pm_density%10);
  109.                    LCD1602_writebyte("ug/m3 ");        
  110.                    if(LED==0) LCD1602_writebyte("K ");
  111.                    else           LCD1602_writebyte("G ");

  113.                    if(star_stop==0) LCD1602_writebyte("K ");
  114.                    else                 LCD1602_writebyte("G ");

  116.                      
  117.          }
  118.         else
  119.          {
  120.                    LCD1602_write(0,0x80);
  121.                    LCD1602_writebyte("RH_H:");
  122.                    if(state==1&&s0)   LCD1602_writebyte("  ");
  123.                    else
  124.                     {
  125.                            LCD1602_write(1,0x30+rh_h/10);
  126.                            LCD1602_write(1,0x30+rh_h%10);                          
  127.                         }
  128.                    LCD1602_writebyte("%              ");

  130.                    LCD1602_write(0,0xC0);
  131.                    LCD1602_writebyte("PM2.5:");           //pm_density
  132.                    if(state==2&&s0)   LCD1602_writebyte("     ");
  133.                    else
  134.                     {
  135.                            LCD1602_write(1,0x30+pm_URV/1000%10);
  136.                            LCD1602_write(1,0x30+pm_URV/100%10);
  137.                            LCD1602_write(1,0x30+pm_URV/10%10);
  138.                            LCD1602_writebyte(".");
  139.                            LCD1602_write(1,0x30+pm_URV%10);                  
  140.                         }
  141.                    LCD1602_writebyte("ug/m3 ");            
  142.          }                                 
  143. }
  144. void key()
  145. {
  146.    if(!key1||ircode[2]==0x0c)
  147.     {  ircode[2]=0;
  148.           if(key1_flag)
  149.            {
  150.              key1_flag=0;
  151.                  state=(state+1)%3;
  152.            }
  153.         }
  154.         else
  155.          {
  156.            if(ircode[2]!=0x0c) key1_flag=1;
  157.          }

  159.          
  160.    if(!key2||ircode[2]==0x18)
  161.     {  ircode[2]=0;
  162.           if(key2_flag)
  163.            {
  164.              key2_flag=0;
  165.                  if(state==1)
  166.                   {
  167.                     if(rh_h<99) rh_h++;        
  168.                      memory();
  169.                   }
  170.                   else if(state==2)         
  171.                    {
  172.                     if(pm_URV<9999) pm_URV++;        
  173.                      memory();
  174.                    }
  175.            }

  177.            if(sec==0)
  178.             {
  179.                          if(state==1)
  180.                           {
  181.                             if(rh_h<99) rh_h++;        
  182.                              memory();
  183.                           }
  184.                           else if(state==2)         
  185.                            {
  186.                             if(pm_URV<9999) pm_URV++;        
  187.                              memory();
  188.                            }
  189.                 }

  191.         }
  192.         else
  193.          {
  194.            if(ircode[2]!=0x18)
  195.             {
  196.                          key2_flag=1;
  197.                      sec=2;
  198.                 }
  199.          }
  200.          

  202.         

  204.    if(!key3||ircode[2]==0x5E)
  205.     {  ircode[2]=0;
  206.           if(key3_flag)
  207.            {
  208.              key3_flag=0;
  209.                  if(state==1)
  210.                   {
  211.                     if(rh_h>0) rh_h--;        
  212.                      memory();
  213.                   }
  214.                   else if(state==2)         
  215.                    {
  216.                     if(pm_URV>0) pm_URV--;        
  217.                      memory();
  218.                    }
  219.            }
  220.            if(sec1==0)
  221.             {
  222.                          if(state==1)
  223.                           {
  224.                             if(rh_h>0) rh_h--;        
  225.                              memory();
  226.                           }
  227.                           else if(state==2)         
  228.                            {
  229.                             if(pm_URV>0) pm_URV--;        
  230.                              memory();
  231.                            }
  232.                 }
  233.         }
  234.         else
  235.          {
  236.            if(ircode[2]!=0x5E)
  237.             {
  238.                    key3_flag=1;
  239.                    sec1=2;
  240.                 }
  241.          }





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


  265.    if(!key5||ircode[2]==0x1C)
  266.     { ircode[2]=0;
  267.           if(key5_flag)
  268.            {
  269.              key5_flag=0;
  270.                  mode=~mode;
  271.            }
  272.         }
  273.         else  
  274.          {
  275.            if(ircode[2]!=0x1C)
  276.             {
  277.                  key5_flag=1;
  278.                 }
  279.          }


  282.          

  284.    if(!key6||ircode[2]==0x5A)
  285.     { ircode[2]=0;
  286.           if(key6_flag)
  287.            {
  288.              key6_flag=0;
  289.                  if(mode1==0)
  290.                   {
  291.                     LED=~LED;
  292.                   }
  293.            }
  294.         }
  295.         else  
  296.          {
  297.            if(ircode[2]!=0x5A)
  298.             {
  299.                   key6_flag=1;
  300.                 }
  301.          }




  306.    if(!key7||ircode[2]==0x42)
  307.     {  ircode[2]=0;
  308.           if(key7_flag)
  309.            {
  310.              key7_flag=0;
  311.                  if(mode==0)
  312.                   {
  313.                     star_stop=~star_stop;
  314.                   }
  315.            }
  316.         }
  317.         else  
  318.          {
  319.            if(ircode[2]!=0x42)
  320.             {
  321.                   key7_flag=1;
  322.                 }
  323.          }
  324.         
  325.          
  326. }

  328. void interrupt_int()
  329. {
  330.           EX0=1;                   //打开外部中断0
  331.           IT0=1;                   //设置为边沿触发
  332.          
  333.           TMOD=0x12;           //设置定时器0工作模式2  8位自动重装 256
  334.           TH0=0;
  335.           TL0=0;               //装入初值
  336.           ET0=1;                   //打开定时器中断

  338.           TH1=0x3C;
  339.           TL1=0xb0;               //装入初值
  340.           ET1=1;                   //打开定时器中断

  342.           EA=1;                           //打开总中断开关
  343.           TR0=1;                   //打开定时器，开始计时
  344.           TR1=1;
  345. }

  347. void UART_Init(void)
  348. {
  349. T2CON = 0x34;
  350. RCAP2H = 0xFF;
  351. RCAP2L = 0xDC;
  352. TH2 = 0xFF;
  353. TL2 = 0xDC;
  354. TR2 = 1;      
  355. SCON = 0x50;
  356. ES = 1;  
  357. }

  359. void mode_dispose()         //mode 是控制电机的   mode1是控制灯的自动手动标志
  360. {
  361.    if(mode1)          //mode1==0  手动   mode1==1  自动   
  362.     {
  363.      if(light)
  364.           {
  365.                    if(RSD)
  366.                     {
  367.                           LED=0;
  368.                         }
  369.                         else  LED=1;            
  370.           }
  371.           else           LED=1;

  373.         }  

  375.    if(mode)          //mode1==0  手动   mode1==1  自动   
  376.     {
  377.            if(light==0)
  378.             {
  379.                   if((rh_h<U8RH_data_H)||(pm_URV<pm_density)) star_stop=0;
  380.                   else          star_stop=1;
  381.                 }
  382.                 else  star_stop=1;
  383.         }  

  385.             if(DJ_dat==0) loop=0;
  386.          while(DJ_dat<520&&star_stop==0)
  387.                         {
  388.                                 P1=P1&0xf0|zz[loop];                                                        
  389.                                 loop=(loop+1)%8;

  391.                                 if(loop==0) DJ_dat++;
  392.                                 LCD1602_delay(100);                                       
  393.                         }                              

  395.                while(DJ_dat!=0&&star_stop==1)
  396.                         {
  397.                                 P1=P1&0xf0|fz[loop];
  398.                                 loop=(loop+1)%8;
  399.                         
  400.                                 if(loop==0) DJ_dat--;
  401.                                 LCD1602_delay(100);
  402.                         }
  403.            
  404.                               P1=0x00;
  405.          
  406.    


  409. }


  412. void main()
  413. {
  414.    LCD1602_cls();
  415.    interrupt_int();        
  416.    UART_Init();        
  417.    read_memory();        
  418.    while(1)
  419.     {
  420.           mode_dispose();
  421.           display_dispose();
  422.         
  423.         }
  424. }





  430. void int0() interrupt 0
  431. {
  432.   if(starflag)
  433.     {
  434.              if(irtime>32)  //引导码时间除以0.256，是31.多毫秒
  435.                   {
  436.                          bitnum=0; //此时确定接收到引导码，清零变量，接收数据
  437.                   }
  438.                  irdata[bitnum]=irtime;        //将数据接收送入irdata
  439.                  irtime=0;                //每接收一位数据，清零一次，使下次接受的数据准确
  440.                  bitnum++;                //数组变量增加
  441.                  if(bitnum==33)        //当变量增加到33时，说明一帧数据接收完毕
  442.                   {
  443.                     bitnum=0;        //清零数组变量
  444.                         irreceok=1;        //接收完一帧数据标志位
  445.                         
  446.                   }
  447.     }
  448.   else
  449.     {
  450.           starflag=1;        //为接收一帧数据的第一位做准备
  451.           irtime=0;                //清零定时变量
  452.         }



  456.   
  457. }

  459. void time0() interrupt 1
  460. {
  461. irtime++;  //因为是模式2，那么变量每加一一次，就是定时了256um,也就是0.256毫秒
  462. }
  463. void time1() interrupt 3
  464. {
  465.           TH1=0x3C;
  466.           TL1=0xb0;            
  467.           ms++;         
  468.           key();           
  469.           ir_ok();
  470.           if(ms%10==0)        s0=~s0;
  471.           if(ms>=20)
  472.            { RH();
  473.              ms=0;
  474.                  if(sec!=0)sec--;
  475.                  if(sec1!=0)sec1--;
  476.            }
  477. }


  480. void uart () interrupt 4
  481. {
  482.         uchar temp_pM;
  483.         if(RI==1)
  484.         {
  485.                 RI=0;
  486.                 UART_Upload[accord]=SBUF; //串口接收一个数据
  487.                 accord++;
  488.                 if(UART_Upload[0]!=0xff)  //判断接收到的第一个数据为oxff  数据错误 数组指针清零
  489.                 {
  490.                         accord=0;
  491.                 }
  492.                 if(UART_Upload[1]!=0x18)//判断接收到的第2个为0x18  数据错误 数组指针清零
  493.                 {
  494.                         accord=0;
  495.                 }
  496.                 if(accord>8)                 //九个数据为一组
  497.                 {
  498.                         accord=0; //接收完一组数据的标志，置0 校验         
  499.                 }               
  500.                 if(accord==0)                //接收一组数据后进行一次校验和
  501.                 {                                         //校验7为数据位的和取反加一等于校验值
  502.                         if((UART_Upload[0]==0xff)&&(UART_Upload[1]=0x18)&&(UART_Upload[2]==0x00))//判断前三位数据是否正确 是进行校验
  503.                         {        
  504.                                 temp_pM=~(UART_Upload[1]+UART_Upload[2]+UART_Upload[3]+UART_Upload[4]+UART_Upload[5]+UART_Upload[6]+UART_Upload[7])+1;        //校验和
  505.                                   if(temp_pM=UART_Upload[8])
  506.                                 {
  507.                                         pm_rateH=UART_Upload[3];
  508.                                         pm_rateL=UART_Upload[4];
  509.                                         pm_density=(UART_Upload[3]*100+UART_Upload[4])*1.014705; //浓度数据处理          数据扩大了十倍
  510.                                         /*我们绘出一个检验报告，比如在345ug/m3的情况下，zph01输出占空比34%。我们理论认为在0-34%对应的0-345ug/m3。他们是 线性比例关系*/                        
  511.                                 }
  512.                         }
  513.         
  514.                 }

  516.         }
  517. }

复制代码

全部程序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 | 只看该作者
这个代码的子程序不全，大佬能不能发个完整的代码给我谢谢
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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