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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › 懒人专用智能房间控制器设计(单片机源码+蓝牙APP+原理图 ...
返回列表 发新帖
查看: 9085|回复: 8
收起左侧

懒人专用智能房间控制器设计(单片机源码+蓝牙APP+原理图PCB)

  [复制链接]
ID:238191 发表于 2018-9-2 14:51 | 显示全部楼层 |阅读模式
作者：落叶风的作品
先看下硬件设计，使用的是单片机STC12C5A60S2，共有8路输入，其中4路是隔离的，低电平为开，输出也是8路，4个继电器，4个可控硅，为了简化可控硅的控制电路，采用5V的隔离电源隔开，有6个开关，开关1-5分别对应的4个可控硅及1个继电器输出，开关6是用于显示翻页及设置用，短按为翻页，长按为进入当前页的设置，再短按为改变设置项目，再长按为保存设置，开关5当处于设置时，就为调整参数，如不处于设置状态时，为继电器1控制。继电器2设置有一组定时开关功能，是采用触发方式的。显示用0.96寸的OLED显示器，温度湿度用DHT11模块。带有无线遥控功能，控制开关1-4，由于是测试板，所以输入输出元件没有装齐，只装部份进行测试，但单片机及手机软件并没偷工减料，所想到的都写上去了，但由于没实际环境中使用过，可能有BUG。
0.jpg
必须为开源者落叶风大神点赞，这技术绝对牛哄哄。
捕获.PNG
电路原理图如下：
0.png

制作出来的pcb实物图如下：
0.jpg

手机软件方面，是第一次写手机软件，自己有用中文编程软件易语言写过小软件，所以看了几天易安卓的教程，就写这手机软件，由于还不熟悉这编程软件，特别是它的数组操作搞不清楚，所以手机软件源代码上基本上是变量以文本型为主，软件的基本功能齐全，有显示控制窗口口、设置窗口及定时设置窗，能直接操作控制单片机的开关及参数的修改。
当手机软件正常开启后，会把手机当前时间发送个授时命令给单片机，根据单片机设置情况，进行授时操作。

OLED显示屏用来显示一些数据，和进行相关设置显示。
0.png
蓝牙转串口模块，是HC-06从机蓝牙模块，已用命令把它的波特率改为19200。采用引线引出来，方便测试。
0.png

315无线模块
0.png

单片机源程序如下:
  1. //蓝牙房间控制器
  2. //编写时间为2015-6-2
  3. //时钟用22.1M,cpu用STC12C5A60

  5. #include <STC12C5A60S2.h>
  6. #include <intrins.h>
  7. unsigned char oldkey,keyval,pagevol,bbtemp;
  8. unsigned int keyjixu ,jisu,tempxidu;
  9. bit BBkongvol,readtimekong,time05s,dingkong,timeauto,rscRSkong;
  10. unsigned char t_sec,t_min,t_hour,t_1224ji;
  11. unsigned char timetao,settao,RSzhuantai2,recRSjisu;
  12. unsigned char dingon_hour,dingon_min,dingoff_hour,dingoff_min;
  13. unsigned char recRSvol[6];
  14. extern void OLED_Init(void);
  15. extern void OLED_Clear(void);
  16. extern void OLED_ShowCHinese(unsigned char x,unsigned char y,unsigned char no);
  17. extern void OLED_ShowString(unsigned char x,unsigned char y, unsigned char *p);
  18. extern void OLED_ShowChar(unsigned char x,unsigned char y,unsigned char chr);
  19. extern void OLED_32X16(unsigned char x,unsigned char y,unsigned char c);
  20. //外部引用DS1302子程序
  21. extern void write_time(unsigned char temp1,temp2);
  22. extern unsigned char read_time(unsigned char hangmu);
  23. extern void DS1302ini();
  24. sbit KEY1=P1^0;
  25. sbit KEY2=P1^1;
  26. sbit KEY3=P1^4;
  27. sbit KEY4=P1^5;
  28. sbit KEY5=P1^6;
  29. sbit KEY6=P1^7;
  30. sbit BB=P4^7;
  31. sbit OUT1=P2^7;
  32. sbit OUT2=P2^6;
  33. sbit OUT3=P2^5;
  34. sbit OUT4=P2^4;
  35. sbit OUT5=P2^3;
  36. sbit OUT6=P2^2;
  37. sbit OUT7=P2^1;
  38. sbit OUT8=P2^0;
  39. sbit DHT11DA=P3^6;
  40. void delay(unsigned int t) //长延时程序,延时t毫秒，STC 1T单片机11.0592M晶振I值为648，22.1I值为1298，12MI值为705。
  41. {
  42.          unsigned int i;
  43.          while(t--)
  44.            {
  45.                 for(i=1298;i>0;i--);
  46.            }
  47. }
  48.   
  49. void delay10us() //延时10us,STC 1T单片机11.0592M晶振J值为23，22。1MJ值为51。
  50. {

  52.    unsigned char j;
  53.    for(j=51;j>0;j--);
  54. }

  56. //======================EEPROW偏程==============================
  57. //写字节时，可以将原有数据中的1改为0，无法将0改为1，只能使用擦除命令将0改为1
  58. //应注意，擦除命令会将整个扇区擦除
  59. //由于擦除会将整个扇区擦除，为了方便写，所以这里用第二扇区存第一屏的状态，
  60. //第三扇区存定时1的5个时间，每个时间有启用、开时间、关时间、星期（8b）
  61. //第四扇区存定时6-10，第5扇区存温度值，
  62. // 第二扇区地址0x0200-0x03ff,0x0400-0x05ff,0x0600-0x07ff,0x0800-0x09ff.
  63. void IAPIDLE()
  64. {
  65.     IAP_CMD = 0;      //关闭令，保护
  66.     IAP_CONTR = 0;    //关EEPROM，保护
  67.     IAP_TRIG = 0;
  68.     IAP_ADDRL = 0; //设置读取地址的低字节，地址改变才需要设置
  69.     IAP_ADDRH = 0X80; //设置读取地址的高字节，地址改变才需要设置
  70. }
  71. unsigned char readEEP(unsigned int adddata)
  72. {        //读取
  73.         unsigned char eerdata;
  74.         IAP_CONTR=0X83;//设置等待时间，1MHz以下取7，2M以下取6，3M取5，6M取4，12M取3，20M取2，24M取1，30M取0，前导1表示许档IAP
  75.         IAP_CMD = 1;      //读取值1，写取2，擦除取3，擦除时按所在字节整个扇区撺除
  76.         IAP_ADDRL = adddata;    //设置读取地址的低字节，地址改变才需要设置
  77.     IAP_ADDRH = adddata>>8; //设置读取地址的高字节，地址改变才需要设置
  78.         IAP_TRIG = 0x5A;  //先送5A
  79.     IAP_TRIG = 0xA5;  //先送5A再送A5立即触发
  80.         _nop_();
  81.         eerdata=IAP_DATA;
  82.         IAPIDLE();
  83.         return eerdata;
  84. }
  85. void writeEEP(unsigned int adddata, unsigned char eerdata)
  86. {//写入
  87.   IAP_CONTR=0X83;//设置等待时间，
  88.   IAP_CMD = 2;      //读取值1，写取2，擦除取3，擦除时按所在字节整个扇区撺除
  89.   IAP_ADDRL = adddata;    //设置读取地址的低字节，地址改变才需要设置
  90.   IAP_ADDRH = adddata>>8; //设置读取地址的高字节，地址改变才需要设置
  91.   IAP_DATA=        eerdata;//传入数据
  92.   IAP_TRIG = 0x5A;  //先送5A
  93.   IAP_TRIG = 0xA5;  //先送5A再送A5立即触发
  94.   _nop_();
  95.   IAPIDLE();
  96. }
  97. void eraseEEP(unsigned int adddata)
  98. { //擦除
  99.    IAP_CONTR=0X83;//设置等待时间，
  100.   IAP_CMD = 3;      //读取值1，写取2，擦除取3，擦除时按所在字节整个扇区撺除
  101.   IAP_ADDRL = adddata;    //设置读取地址的低字节，地址改变才需要设置
  102.   IAP_ADDRH = adddata>>8; //设置读取地址的高字节，地址改变才需要设置
  103.   IAP_TRIG = 0x5A;  //先送5A
  104.   IAP_TRIG = 0xA5;  //先送5A再送A5立即触发
  105.   _nop_();
  106.   IAPIDLE();
  107. }
  108. void writeDAT()
  109. {
  110.         eraseEEP(0x0200);
  111. writeEEP(0x0200, dingkong);//定时状态
  112. writeEEP(0x0201, dingon_hour); // 开时
  113. writeEEP(0x0202, dingon_min);//开分
  114. writeEEP(0x0203, dingoff_hour);//关时
  115. writeEEP(0x0204, dingoff_min);//关分
  116. writeEEP(0x0205, BBkongvol);//按键不发声
  117. writeEEP(0x0206, timeauto);//自动校时
  118. }
  119. void timedisp()   //时间提取。这里只读时分秒及星期，时采用24小时制。
  120. {
  121.   unsigned char        i,j,times,timeg;
  122.           i =read_time(0x84);//读时，这里还要判断是24小时制还是12小时制。
  123.      if(i>=0x80)
  124.                                   {           //12小时
  125.                                              //只是小时的数值是最后5位为小时值，所以时的取法先置高3位为0，再除法及求余法。
  126.                                          
  127.                                          times=(i&0x1f)/16;//取高4位的数值给十分。
  128.                                      timeg=i%16;//取低4位数值，把高4位置0。
  129.                                      t_hour=times*10+timeg;
  130.                                          j=i<<2;
  131.                                          if(j>=0x80)
  132.                                          {
  133.                        t_1224ji=1;//12小时制，0为24小时制。
  134.                        if(t_hour!=12){t_hour=t_hour+12;}//转为24小时，方便计算。
  135.                                          }
  136.                                          else
  137.                                          {
  138.                                          t_1224ji=1;        //2为上午。
  139.                      if(t_hour==12)t_hour=0;//转为24小时，方便计算。
  140.                                          }
  141.                                   }
  142.                                   else
  143.                                   {                //24小时
  144.                                          times=i/16;//取高4位的数值给十分。
  145.                                     timeg=i%16;//取低4位数值，把高4位置0。
  146.                                         t_hour=times*10+timeg;
  147.                                         t_1224ji=0;//24小时制

  149.                                   }

  151.   i=read_time(0x82);//读分
  152.   times=i/16;
  153.   timeg=i%16;
  154.   t_min=times*10+timeg;
  155.   i =read_time(0x80);//读秒
  156.   times=i/16;
  157.   timeg=i%16;
  158.   t_sec=times*10+timeg;//算出当前秒数。

  160. }
  161. void disppage0(bit xaxin)
  162. {//当为0时，全屏更新，为1只刷新部份
  163.         unsigned int kaka;
  164.         
  165.         if(xaxin==0)
  166.         {
  167.         OLED_Clear();
  168. //        蓝牙房间控制
  169.         OLED_ShowCHinese(16,0,0);
  170.         OLED_ShowCHinese(32,0,1);
  171.         OLED_ShowCHinese(48,0,2);
  172.         OLED_ShowCHinese(64,0,3);
  173.         OLED_ShowCHinese(80,0,4);
  174.         OLED_ShowCHinese(96,0,5);
  175.         }
  176. //18:55:23 36C 75%
  177.         if(timetao==1&&time05s!=0)
  178.         {
  179.                 OLED_ShowChar(0,2,13);
  180.         OLED_ShowChar(8,2,13);
  181.         }
  182.         else
  183.         {
  184.   OLED_ShowChar(0,2,t_hour/10);
  185.         OLED_ShowChar(8,2,t_hour%10);
  186.         }
  187.         if(time05s!=0&&timetao==0)
  188.         {
  189.         OLED_ShowChar(16,2,13);
  190.                 OLED_ShowChar(40,2,13);
  191.         }
  192.         else
  193.         {
  194.                 OLED_ShowChar(16,2,10);
  195.                 OLED_ShowChar(40,2,10);
  196.         }
  197.         if(timetao==2&&time05s!=0)
  198.         {
  199.                 OLED_ShowChar(24,2,13);
  200.           OLED_ShowChar(32,2,13);
  201.         }
  202.         else
  203.         {
  204.         OLED_ShowChar(24,2,t_min/10);
  205.         OLED_ShowChar(32,2,t_min%10);
  206.         }
  207.         if(timetao==3&&time05s!=0)
  208.         {
  209.                 OLED_ShowChar(48,2,13);
  210.          OLED_ShowChar(56,2,13);
  211.         }
  212.         else
  213.         {
  214.         OLED_ShowChar(48,2,t_sec/10);
  215.         OLED_ShowChar(56,2,t_sec%10);
  216.         }
  217.         kaka=tempxidu%256;
  218.         OLED_ShowChar(72,2,kaka/10);
  219.         OLED_ShowChar(80,2,kaka%10);
  220.         OLED_ShowChar(88,2,11);
  221.         kaka=tempxidu/256;
  222.         OLED_ShowChar(104,2,kaka/10);
  223.         OLED_ShowChar(112,2,kaka%10);
  224.         OLED_ShowChar(120,2,12);
  225. //开关状态        
  226. //读P0值，低电平为开，
  227.         if((P0&0x01)==0)
  228.         {        
  229.          OLED_ShowCHinese(0,4,7);
  230.         }
  231.         else
  232.         {
  233.                 OLED_ShowCHinese(0,4,15);
  234.         }
  235.         if((P0&0x02)==0)
  236.         {
  237. OLED_ShowCHinese(16,4,8);
  238.         }
  239.         else
  240.         {
  241.                 OLED_ShowCHinese(16,4,16);
  242.         }
  243.         if((P0&0x04)==0)
  244.         {
  245. OLED_ShowCHinese(32,4,9);
  246.         }
  247.         else
  248.         {
  249.                 OLED_ShowCHinese(32,4,17);
  250.         }
  251.         if((P0&0x08)==0)
  252.         {
  253. OLED_ShowCHinese(48,4,10);
  254.         }
  255.         else
  256.         {
  257.                  OLED_ShowCHinese(48,4,18);
  258.         }
  259.         if((P0&0x10)==0)
  260.         {
  261. OLED_ShowCHinese(64,4,11);
  262.         }
  263.         else
  264.         {
  265.                 OLED_ShowCHinese(64,4,19);
  266.         }
  267.         if((P0&0x20)==0)
  268.         {
  269.                 OLED_ShowCHinese(80,4,12);
  270.         }
  271.         else
  272.         {
  273. OLED_ShowCHinese(80,4,20);
  274.         }
  275.         if((P0&0x40)==0)
  276.         {
  277. OLED_ShowCHinese(96,4,13);
  278.         }
  279.         else
  280.         {
  281.                  OLED_ShowCHinese(96,4,21);
  282.         }
  283.         if((P0&0x80)==0)
  284.         {
  285. OLED_ShowCHinese(112,4,14);
  286.         }
  287.         else
  288.         {
  289.                 OLED_ShowCHinese(112,4,22);
  290.         }
  291. //灯及插座工作状态
  292. if(OUT1==0)
  293. {//低电平为开
  294. OLED_ShowCHinese(0,6,27);
  295. }
  296. else
  297. {
  298.          OLED_ShowCHinese(0,6,23);
  299. }
  300. if(OUT2==0)
  301. {//低电平为开
  302. OLED_ShowCHinese(16,6,28);
  303. }
  304. else
  305. {
  306.          OLED_ShowCHinese(16,6,24);
  307. }
  308. if(OUT3==0)
  309. {//低电平为开
  310. OLED_ShowCHinese(32,6,29);
  311. }
  312. else
  313. {
  314.          OLED_ShowCHinese(32,6,25);
  315. }
  316. if(OUT4==0)
  317. {//低电平为开
  318. OLED_ShowCHinese(48,6,30);
  319. }
  320. else
  321. {
  322.          OLED_ShowCHinese(48,6,26);
  323. }
  324. if(OUT5==0)
  325. {//低电平为开
  326. OLED_ShowCHinese(64,6,35);
  327. }
  328. else
  329. {
  330.          OLED_ShowCHinese(64,6,31);
  331. }
  332. if(OUT6==0)
  333. {//低电平为开
  334. OLED_ShowCHinese(80,6,36);
  335. }
  336. else
  337. {
  338.          OLED_ShowCHinese(80,6,32);
  339. }
  340. if(OUT7==0)
  341. {//低电平为开
  342.   OLED_ShowCHinese(96,6,37);
  343. }
  344. else
  345. {
  346.          OLED_ShowCHinese(96,6,33);
  347. }
  348. if(OUT8==0)
  349. {//低电平为开
  350. OLED_ShowCHinese(112,6,38);
  351. }
  352. else
  353. {
  354.          OLED_ShowCHinese(112,6,34);
  355. }
  356. }
  357. void disppage1(bit xaxin)
  358. {//当为0时，全屏更新，为1只刷新部份
  359.         if(xaxin==0)
  360.         {
  361.         OLED_Clear();
  362.         //插座2定时设置
  363.         OLED_ShowCHinese(0,0,41);
  364.         OLED_ShowCHinese(16,0,42);
  365.         OLED_ShowChar(32,0,2);
  366.         OLED_ShowCHinese(40,0,43);
  367.         OLED_ShowCHinese(56,0,44);
  368.         OLED_ShowCHinese(72,0,45);
  369.         OLED_ShowCHinese(88,0,46);
  370.    }
  371.         //选中  22：10-23：55
  372.          if(settao==1&&time05s!=0)
  373.          {
  374.           OLED_ShowCHinese(0,2,6);
  375.          }
  376.          else
  377.          {
  378.                  if(dingkong==0)
  379.                  {//当为0时不定时
  380.                  OLED_ShowCHinese(0,2,40);
  381.                  }
  382.                  else
  383.                  {
  384.                          OLED_ShowCHinese(0,2,39);
  385.                  }
  386.          }
  387.           if(settao==2&&time05s!=0)
  388.                 {
  389.            OLED_ShowChar(16,2,13);
  390.            OLED_ShowChar(24,2,13);
  391.                 }
  392.                 else
  393.                 {
  394.                  OLED_ShowChar(16,2,dingon_hour/10);
  395.            OLED_ShowChar(24,2,dingon_hour%10);
  396.                 }
  397.         OLED_ShowChar(32,2,10);
  398.         if(settao==3&&time05s!=0)
  399.         {
  400.   OLED_ShowChar(40,2,13);
  401.         OLED_ShowChar(48,2,13);
  402.         }
  403.   else
  404.   {        
  405.         OLED_ShowChar(40,2,dingon_min/10);
  406.         OLED_ShowChar(48,2,dingon_min%10);
  407.   }
  408.         OLED_ShowChar(56,2,14);
  409.         if(settao==4&&time05s!=0)
  410.         {
  411.   OLED_ShowChar(64,2,13);
  412.         OLED_ShowChar(72,2,13);
  413.         }
  414.   else
  415.   {        
  416.         OLED_ShowChar(64,2,dingoff_hour/10);
  417.         OLED_ShowChar(72,2,dingoff_hour%10);
  418.         }
  419.         OLED_ShowChar(80,2,10);
  420.         if(settao==5&&time05s!=0)
  421.         {
  422.   OLED_ShowChar(88,2,13);
  423.         OLED_ShowChar(96,2,13);
  424.         }
  425.   else
  426.   {        
  427.         OLED_ShowChar(88,2,dingoff_min/10);
  428.         OLED_ShowChar(96,2,dingoff_min%10);
  429.         }
  430.         
  431. //不选中 按键发声
  432. if(settao==6&&time05s!=0)
  433.         {         
  434. OLED_ShowCHinese(0,4,6);
  435.         }
  436.         else
  437.         {
  438.                 if(BBkongvol==0)
  439.                 {
  440.                 OLED_ShowCHinese(0,4,40);
  441.                 }
  442.                 else
  443.                 {
  444.                         OLED_ShowCHinese(0,4,39);
  445.                 }
  446.         }
  447.          if(xaxin==0)
  448.          {
  449.         OLED_ShowCHinese(16,4,47);
  450. OLED_ShowCHinese(32,4,48);
  451. OLED_ShowCHinese(48,4,52);
  452. OLED_ShowCHinese(64,4,53);
  453. //OLED_ShowCHinese(80,4,53);
  454.          }
  455. //不选中 自动效时
  456. if(settao==7&&time05s!=0)
  457.         {         
  458. OLED_ShowCHinese(0,6,6);
  459.         }
  460.         else
  461.         {
  462.                 if(timeauto==0)
  463.                 {
  464.                 OLED_ShowCHinese(0,6,40);
  465.                 }
  466.                 else
  467.                 {
  468.                         OLED_ShowCHinese(0,6,39);
  469.                 }
  470.         }
  471.          if(xaxin==0)
  472.          {
  473.         OLED_ShowCHinese(16,6,49);
  474. OLED_ShowCHinese(32,6,50);
  475. OLED_ShowCHinese(48,6,54);
  476. OLED_ShowCHinese(64,6,55);
  477.          }
  478. }

  480. //***********************键盘扫描子程序。******************
  481. //*********************************************************
  482. unsigned char keyboard()//键盘扫描
  483. {
  484.       unsigned char keyboardj;
  485.      keyboardj=0;
  486.     if(KEY1==0)
  487.           {
  488.         delay(10);
  489.                   if(KEY1==0)
  490.                   {
  491.                           keyboardj=1;
  492.                   }
  493.       }
  494.     if(KEY2==0)
  495.            {
  496.         delay(10);
  497.                   if(KEY2==0)
  498.                   {
  499.                           keyboardj=2;
  500.                   }
  501.       }
  502.          if(KEY3==0)
  503.            {
  504.         delay(10);
  505.                   if(KEY3==0)
  506.                   {
  507.                           keyboardj=3;
  508.                   }
  509.       }
  510.            if(KEY4==0)
  511.           {
  512.         delay(10);
  513.                   if(KEY4==0)
  514.                   {
  515.                           keyboardj=4;
  516.                   }
  517.       }
  518.     if(KEY5==0)
  519.            {
  520.         delay(10);
  521.                   if(KEY5==0)
  522.                   {
  523.                           keyboardj=5;
  524.                   }
  525.       }
  526.          if(KEY6==0)
  527.            {
  528.         delay(10);
  529.                   if(KEY6==0)
  530.                   {
  531.                           keyboardj=6;
  532.                   }
  533.       }
  534.    return  keyboardj;
  535. }
  536. //************键盘控制子程序***************
  537. //K2短按为开电源，关机显----,正常显铬铁实际温度，长按为调铬铁温度，最后个C闪，表示调温，再长按为存储并退出调温。
  538. //K3K1分别为向上向下，短按为慢速增加减少，长按为快速。调节范围为200-480度。
  539. //******************************************
  540. void keydisphong()//主要功能是
  541. {
  542.    unsigned char keyyy;
  543.    keyyy=keyboard();
  544.   if (keyyy!=oldkey)
  545.         {
  546.                 if(keyyy==0)//
  547.       {        
  548.                                 if(keyjixu>0)
  549.                                 {
  550.                                         if(keyjixu<80)
  551.                                         {
  552.                                                 
  553.                                                 if(oldkey==6)
  554.                                                 {
  555.                                                         keyval=6;
  556.                                                 }
  557.                                                 if(oldkey==5)
  558.                                                 {
  559.                                                         keyval=5;
  560.                                                 }
  561.                                         }
  562.                                         else
  563.                                         {
  564.                                                 //keyval=11;
  565.                                                 keyjixu=0;
  566.                                         }
  567.                                 }
  568.                                 else
  569.                                 {
  570.                                         keyval=0;
  571.                                   keyjixu=0;
  572.                                 }
  573.                         }
  574.                 if(keyyy==1)
  575.                 {
  576.                         if(OUT1==0)
  577.                         {
  578.                                 OUT1=1;
  579.                         }
  580.                         else
  581.                         {
  582.                                 OUT1=0;
  583.                         }
  584.                         
  585.                 }
  586.                 if(keyyy==2)
  587.                 {
  588.                         if(OUT2==0)
  589.                         {
  590.                                 OUT2=1;
  591.                         }
  592.                         else
  593.                         {
  594.                                 OUT2=0;
  595.                         }
  596.                 }
  597.                 if(keyyy==3)
  598.                 {
  599.                         if(OUT3==0)
  600.                         {
  601.                                 OUT3=1;
  602.                         }
  603.                         else
  604.                         {
  605.                                 OUT3=0;
  606.                         }
  607.                 }
  608.                 if(keyyy==4)
  609.                 {
  610.                         if(OUT4==0)
  611.                         {
  612.                                 OUT4=1;
  613.                         }
  614.                         else
  615.                         {
  616.                                 OUT4=0;
  617.                         }
  618.                 }
  619.                 if(keyyy!=0)
  620.                 {        
  621.                         //刷新
  622.                         if(pagevol==0&&keyval!=6)disppage0(1);
  623.                         if(BBkongvol==1)
  624.                         {//当BB可以发声，就
  625.                           BB=1;//发响声。
  626.                     bbtemp=15;//
  627.                         }
  628.                 }
  629.         }
  630.   oldkey=keyyy;
  631.    if(keyyy==5)//
  632.       {
  633.                                 keyjixu++;
  634.                                 if(keyjixu>=80)
  635.                                 {
  636.                                         if((keyjixu%6)==0)
  637.                                         {
  638.                                         keyval=15;
  639.                                         }
  640.                                 }
  641.                         }        
  642.         if(keyyy==6)//
  643.       {
  644.                                 keyjixu++;
  645.                                 if(keyjixu==80)keyval=16;
  646.                         }
  647.                  
  648.          //键盘处理完成。
  649. //以下为功能子程序        
  650. if(keyval==5)
  651.                 {
  652.                  keyval=0;//这步必须的，清键值。
  653.                         keyjixu=0;//清计数值，这两步是必要的。        
  654.     if(timetao==0&&settao==0)
  655.                         {
  656.                         //当不处于调整时，就控电器5
  657.                         if(OUT5==0)
  658.                         {
  659.                                 OUT5=1;
  660.                         }
  661.                         else
  662.                         {
  663.                                 OUT5=0;
  664.                         }
  665.                  }
  666.                  else
  667.                  {
  668.                         if(pagevol==0)
  669.                         {
  670.                                 if(timetao==1)
  671.                                 {//调时
  672.                                         t_hour++;
  673.                                         if(t_hour>23)t_hour=0;
  674.                                         OLED_ShowChar(0,2,t_hour/10);
  675.                 OLED_ShowChar(8,2,t_hour%10);
  676.                                 }
  677.                                 if(timetao==2)
  678.                                 {//调分
  679.                                         t_min++;
  680.                                         if(t_min>59)t_min=0;
  681.                                         OLED_ShowChar(24,2,t_min/10);
  682.                 OLED_ShowChar(32,2,t_min%10);
  683.                                 }
  684.                                 if(timetao==3)
  685.                                 {//调秒
  686.                                         t_sec++;
  687.                                         if(t_sec>59)t_sec=0;
  688.                                         OLED_ShowChar(48,2,t_sec/10);
  689.                 OLED_ShowChar(56,2,t_sec%10);
  690.                                 }
  691.                                 
  692.                         }
  693.                         else
  694.                         {
  695.                                 if(settao==1)
  696.                                 {//调定时
  697.                                         if(dingkong==0)
  698.                                         {
  699.                                                 dingkong=1;
  700.                                         }
  701.                                         else
  702.                                         {
  703.                                                 dingkong=0;
  704.                                         }
  705.                                 }
  706.                                 if(settao==2)
  707.                                 {//调开时
  708.                                         dingon_hour++;
  709.                                         if(dingon_hour>23)dingon_hour=0;
  710.                                         OLED_ShowChar(16,2,dingon_hour/10);
  711.                OLED_ShowChar(24,2,dingon_hour%10);
  712.                                 }
  713.                                 if(settao==3)
  714.                                 {//调开分
  715.                                         dingon_min++;
  716.                                         if(dingon_min>59)dingon_min=0;
  717.                                         OLED_ShowChar(40,2,dingon_min/10);
  718.                 OLED_ShowChar(48,2,dingon_min%10);
  719.                                 }
  720.                                 if(settao==4)
  721.                                 {//调关时
  722.                                         dingoff_hour++;
  723.                                         if(dingoff_hour>23)dingoff_hour=0;
  724.                                         OLED_ShowChar(64,2,dingoff_hour/10);
  725.                OLED_ShowChar(72,2,dingoff_hour%10);
  726.                                 }
  727.                                 if(settao==5)
  728.                                 {//调关分
  729.                                         dingoff_min++;
  730.                                         if(dingoff_min>59)dingoff_min=0;
  731.                                         OLED_ShowChar(88,2,dingoff_min/10);
  732.                 OLED_ShowChar(96,2,dingoff_min%10);
  733.                                 }
  734.                                 if(settao==6)
  735.                                 {//调发声
  736.                                         if(BBkongvol==0)
  737.                                         {
  738.                                                 BBkongvol=1;
  739.                                         }
  740.                                         else
  741.                                         {
  742.                                                 BBkongvol=0;
  743.                                         }
  744.                                 }
  745.                                 if(settao==7)
  746.                                 {//调自动校时
  747.                                         if(timeauto==0)
  748.                                         {
  749.                                                 timeauto=1;
  750.                                         }
  751.                                         else
  752.                                         {
  753.                                                 timeauto=0;
  754.                                         }
  755.                                 }
  756.                         }
  757.                         
  758.                  }
  759.                 }                        
  760.                 if(keyval==6)
  761.                 {
  762.                  keyval=0;//这步必须的，清键值。
  763.                         keyjixu=0;//清计数值，这两步是必要的。
  764.                         if(timetao==0&&settao==0)
  765.                         {
  766.                         if(pagevol==0)
  767.                         {
  768.                                 pagevol=1;
  769.                                 disppage1(0);
  770.                         }
  771.                         else
  772.                         {
  773.                                 pagevol=0;
  774.                                 disppage0(0);
  775.                         }
  776.                  }
  777.                  else
  778.                  {
  779.                          if(pagevol==0)
  780.                          {
  781.                                  timetao++;
  782.                                  if(timetao==4)
  783.                                  {
  784.                                          timetao=1;
  785.                                          
  786.                                  }
  787.                    }
  788.                          else
  789.                          {
  790.                                  settao++;
  791.                                  if(settao==8)
  792.                                  {
  793.                                          settao=1;
  794.                                        
  795.                                  }
  796.                          }
  797.                  }
  798.                 }        
  799.                         if(keyval==15)
  800.                 {
  801.                  keyval=0;//这步必须的，清键值。
  802.                         //keyjixu=0;//清计数值，这两步是必要的。
  803.                         if(pagevol==0)
  804.                         {
  805.                                 if(timetao==1)
  806.                                 {//调时
  807.                                         t_hour++;
  808.                                         if(t_hour>23)t_hour=0;
  809.                                         OLED_ShowChar(0,2,t_hour/10);
  810.                 OLED_ShowChar(8,2,t_hour%10);
  811.                                 }
  812.                                 if(timetao==2)
  813.                                 {//调分
  814.                                         t_min++;
  815.                                         if(t_min>59)t_min=0;
  816.                                         OLED_ShowChar(24,2,t_min/10);
  817.                 OLED_ShowChar(32,2,t_min%10);
  818.                                 }
  819.                                 if(timetao==3)
  820.                                 {//调秒
  821.                                         t_sec++;
  822.                                         if(t_sec>59)t_sec=0;
  823.                                         OLED_ShowChar(48,2,t_sec/10);
  824.                 OLED_ShowChar(56,2,t_sec%10);
  825.                                 }
  826.                                 
  827.                         }
  828.                         else
  829.                         {
  830.                                 if(settao==2)
  831.                                 {//调开时
  832.                                         dingon_hour++;
  833.                                         if(dingon_hour>23)dingon_hour=0;
  834.                                         OLED_ShowChar(16,2,dingon_hour/10);
  835.                OLED_ShowChar(24,2,dingon_hour%10);
  836.                                 }
  837.                                 if(settao==3)
  838.                                 {//调开分
  839.                                         dingon_min++;
  840.                                         if(dingon_min>59)dingon_min=0;
  841.                                         OLED_ShowChar(40,2,dingon_min/10);
  842.                 OLED_ShowChar(48,2,dingon_min%10);
  843.                                 }
  844.                                 if(settao==4)
  845.                                 {//调关时
  846.                                         dingoff_hour++;
  847.                                         if(dingoff_hour>23)dingoff_hour=0;
  848.                                         OLED_ShowChar(64,2,dingoff_hour/10);
  849.                OLED_ShowChar(72,2,dingoff_hour%10);
  850.                                 }
  851.                                 if(settao==5)
  852.                                 {//调关分
  853.                                         dingoff_min++;
  854.                                         if(dingoff_min>59)dingoff_min=0;
  855.                                         OLED_ShowChar(88,2,dingoff_min/10);
  856.                 OLED_ShowChar(96,2,dingoff_min%10);
  857.                                 }
  858.                                 
  859.                         }
  860.                 }
  861.                 if(keyval==16)
  862.                 {//长按进入设置及退出设置
  863.                  keyval=0;//这步必须的，清键值。
  864.                         //keyjixu=0;//清计数值，这两步是必要的。
  865.                         if(pagevol==0)
  866.                         {
  867.                                 if(timetao==0)
  868.                                 {
  869.                            timetao=1;
  870.                                 }
  871.                                 else
  872.                                 {//保存数据
  873.                                         timetao=0;
  874.                                         write_time(0X84,(t_hour/10)*16+t_hour%10);//时
  875.                                         write_time(0X82,(t_min/10)*16+t_min%10);//写分
  876.                                         write_time(0X80,(t_sec/10)*16+t_sec%10);//写秒
  877.                                 }
  878.                         }
  879.                         else
  880.                         {
  881.                                 if(settao==0)
  882.                                 {
  883.                          settao=1;
  884.                                 }
  885.                                 else
  886.                                 {//保存数据
  887.                                         settao=0;
  888.                                         writeDAT();
  889.                                 }
  890.                         }
  891.                 }
  892.                
  893. }

  895. void dingtimekong()
  896. {//定时控制，采用触发式。每0.5S比较一次
  897.         if(dingkong==1)
  898.         {
  899.            if(dingon_hour==t_hour&&dingon_min==t_min)OUT6=0;
  900.                  if(dingoff_hour==t_hour&&dingoff_min==t_min)OUT6=1;
  901.         }
  902. }

  904. unsigned char DHT11readbit()
  905. {
  906.   unsigned char i,temp,dataDHT,caoxi;
  907.   for(i=0;i<8;i++)           
  908.         {
  909.          //数据时序先低电平50us，再高电平，当26-28us为0、70us为1。        
  910.          caoxi=2;
  911.          while((!DHT11DA)&&caoxi++);//检测50us低电平是否过去。
  912.          delay10us();delay10us();delay10us();//延时30us，再判断，如还是高电平就数据为1，如低电平为0。         
  913.          temp=0;   //先置0
  914.          if(DHT11DA)temp=1;        //超过30us还是高电平的就置1。         
  915.          caoxi=2;
  916.          while((DHT11DA)&&caoxi++);//如还是高电平就等它为低电平，如超时就跳出循环.         
  917.          //超时则跳出for循环                  
  918.          if(caoxi==1)break;
  919.                    //合成数据
  920.           dataDHT<<=1;
  921.           dataDHT|=temp;           
  922.    }
  923.    return(dataDHT);
  924. }
  925. unsigned int DHT11read() //由于返回的温度及湿度只有2个8b，所以用个16b的来存贮，前8位为湿度，后8位为温度。
  926. {
  927.   unsigned char temp1,temp2,temp3,temp4,temp5,caoxi;
  928.   unsigned int DHTdata ;
  929.   //主机拉低大于18ms
  930.   DHT11DA=0;
  931.   delay(20);
  932.   DHT11DA=1;
  933.   //主机放开总线，由上拉电阻拉高 主机延时20us-40us.
  934.   delay10us();delay10us();delay10us();delay10us();
  935.   //判断从机是否有低电平响应信号 如不响应则跳出，响应则向下读数。
  936.   if(DHT11DA==0)
  937.     {
  938.           caoxi=2;//初始化超时值，对于22M晶振为175us，主要是防止DHT不动作引起程序进入死循环，超时就跳出来。
  939.           while((!DHT11DA)&&caoxi++);
  940.          //判断从机是否发出 80us 的高电平，如发出则进入数据接收状态
  941.           caoxi=2;
  942.           while((DHT11DA)&&caoxi++);         
  943.          //数据接收状态                           
  944.           temp1=DHT11readbit();         
  945.           temp2=DHT11readbit();         
  946.           temp3=DHT11readbit();         
  947.           temp4=DHT11readbit();         
  948.           temp5=DHT11readbit();
  949.          //数据校验
  950.           DHT11DA=1;
  951.           if(temp5=(temp1+temp2+temp3+temp4)) //如校对正确就组合数据，并返回。
  952.             {
  953.                  DHTdata=temp1*256+temp3;
  954.                 }
  955.                 else
  956.                 {
  957.                  DHTdata=0;//当数据不正确时，就送0值，当然这一步看情况来决定是否用它。
  958.                 }
  959.         }
  960.    return(DHTdata); //返回数据

  962. }
  963. void rs2232tx(unsigned char txdata)//串口2发送程序
  964. {         
  965. S2BUF=txdata;//把数据传给串口寄存器SBUF。
  966. while(!(S2CON & 0x02));//检测是否发完。
  967. //S2TI=0;//重置初值。
  968.         S2CON=S2CON & 0xfd;
  969. }
  970. void senddata()
  971. {//串口数据发送，命令格式EF，EE，P0（低7位开关状态），P2（低7位输出状态），P0P2第8位（主要是防止与引导码冲突），温度，湿度，定时状态，开时，开分，关时，关分，FF 不进行校验数据。
  972.         //为方便手机编程，传送的数据用BCD码
  973.         unsigned char kkkkk,hhhh;
  974.         rs2232tx(0xef);
  975.         rs2232tx(0xee);
  976.         rs2232tx(P0&0x7f);
  977.         rs2232tx(P2&0x7f);
  978.         kkkkk=0;
  979.         if((P0&0x80)!=0)
  980.         {
  981.                 kkkkk=kkkkk+2;
  982.         }
  983.         if((P2&0x80)!=0)
  984.         {
  985.                 kkkkk=kkkkk+1;
  986.         }
  987.         rs2232tx(kkkkk);
  988.         kkkkk=tempxidu%256;
  989.         hhhh=(kkkkk/10)*16+kkkkk%10;
  990.         rs2232tx(hhhh);
  991.         kkkkk=tempxidu/256;
  992.         hhhh=(kkkkk/10)*16+kkkkk%10;
  993.         rs2232tx(hhhh);
  994.         rs2232tx(dingkong);
  995.         kkkkk=dingon_hour;
  996.         hhhh=(kkkkk/10)*16+kkkkk%10;
  997.         rs2232tx(hhhh);
  998.         kkkkk=dingon_min;
  999.         hhhh=(kkkkk/10)*16+kkkkk%10;
  1000.         rs2232tx(hhhh);
  1001.         kkkkk=dingoff_hour;
  1002.         hhhh=(kkkkk/10)*16+kkkkk%10;
  1003.         rs2232tx(hhhh);
  1004.         kkkkk=dingoff_min;
  1005.         hhhh=(kkkkk/10)*16+kkkkk%10;
  1006.         rs2232tx(hhhh);
  1007.         rs2232tx(0xff);
  1008. }
  1009. void rscRSkongji()
  1010. {//串口数据接收后处理子程序
  1011.         //开关控制 命令 01 受控值，00,00，00，00
  1012.         //校时控制 命令 02  时 分 秒 00 00
  1013.         //定时控制 命令 03 受控值 开时 开分 关时 关分
  1014.         if(rscRSkong==1)
  1015.         {//收到处理的数据
  1016.                
  1017.                 switch(recRSvol[0])
  1018.                 {
  1019.                         case 1:     
  1020.                                 if((recRSvol[1]&0x01)!=0)
  1021.                                 {//当手机开关1按下
  1022.                                         if(OUT1==0)
  1023.                                         {
  1024.                                         OUT1=1;
  1025.                                   }
  1026.                                         else
  1027.                                         {
  1028.                                                 OUT1=0;
  1029.                                         }
  1030.                                 }
  1031.                                 if((recRSvol[1]&0x02)!=0)
  1032.                                 {//当手机开关1按下
  1033.                                         if(OUT2==0)
  1034.                                         {
  1035.                                         OUT2=1;
  1036.                                   }
  1037.                                         else
  1038.                                         {
  1039.                                                 OUT2=0;
  1040.                                         }
  1041.                                 }
  1042.        if((recRSvol[1]&0x04)!=0)
  1043.                                 {//当手机开关1按下
  1044.                                         if(OUT3==0)
  1045.                                         {
  1046.                                         OUT3=1;
  1047.                                   }
  1048.                                         else
  1049.                                         {
  1050.                                                 OUT3=0;
  1051.                                         }
  1052.                                 }
  1053.        if((recRSvol[1]&0x08)!=0)
  1054.                                 {//当手机开关1按下
  1055.                                         if(OUT4==0)
  1056.                                         {
  1057.                                         OUT4=1;
  1058.                                   }
  1059.                                         else
  1060.                                         {
  1061.                                                 OUT4=0;
  1062.                                         }
  1063.                                 }
  1064.        if((recRSvol[1]&0x10)!=0)
  1065.                                 {//当手机开关1按下
  1066.                                         if(OUT5==0)
  1067.                                         {
  1068.                                         OUT5=1;
  1069.                                   }
  1070.                                         else
  1071.                                         {
  1072.                                                 OUT5=0;
  1073.                                         }
  1074.                                 }
  1075.        if((recRSvol[1]&0x20)!=0)
  1076.                                 {//当手机开关1按下
  1077.                                         if(OUT6==0)
  1078.                                         {
  1079.                                         OUT6=1;
  1080.                                   }
  1081.                                         else
  1082.                                         {
  1083.                                                 OUT6=0;
  1084.                                         }
  1085.                                 }
  1086.       if((recRSvol[1]&0x40)!=0)
  1087.                                 {//当手机开关1按下
  1088.                                         if(OUT7==0)
  1089.                                         {
  1090.                                         OUT7=1;
  1091.                                   }
  1092.                                         else
  1093.                                         {
  1094.                                                 OUT7=0;
  1095.                                         }
  1096.                                 }
  1097.        if((recRSvol[1]&0x80)!=0)
  1098.                                 {//当手机开关1按下
  1099.                                         if(OUT8==0)
  1100.                                         {
  1101.                                         OUT8=1;
  1102.                                   }
  1103.                                         else
  1104.                                         {
  1105.                                                 OUT8=0;
  1106.                                         }
  1107.                                 }                                
  1108.                                 break;
  1109.                         case 2:
  1110.                                 //手机自动校时,当手机建立连接时，如需自动校时，就启用。这是在串口中断程序内执行。
  1111.                                 if(timeauto==1)
  1112.                                 {
  1113.           write_time(0X84,(recRSvol[1]/10)*16+recRSvol[1]%10);//时
  1114.                                         write_time(0X82,(recRSvol[2]/10)*16+recRSvol[2]%10);//写分
  1115.                                         write_time(0X80,(recRSvol[3]/10)*16+recRSvol[3]%10);//写秒                                                
  1116.                                 }
  1117.                                 break;
  1118.                         case 3: //需BCD码转16进
  1119.                                  dingkong=recRSvol[1];
  1120.                            dingon_hour=(recRSvol[2]/16)*10+recRSvol[2]%16;
  1121.                            dingon_min=(recRSvol[3]/16)*10+recRSvol[3]%16;
  1122.                            dingoff_hour=(recRSvol[4]/16)*10+recRSvol[4]%16;
  1123.                            dingoff_min=(recRSvol[5]/16)*10+recRSvol[5]%16;
  1124.                             writeDAT();
  1125.                                 break;
  1126.                          default:   break;
  1127.                 }
  1128.                
  1129.                 rscRSkong=0;
  1130.         }
  1131.         
  1132. }
  1133. void sysintEEP()
  1134. {
  1135.         dingkong=readEEP(0x0200);//定时状态
  1136.         dingon_hour=readEEP(0x0201); // 开时
  1137.         
  1138. ……………………

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

所有资料51hei提供下载:
蓝牙手机控制的懒人专用智能房间控制器设计资料.rar (1.11 MB, 下载次数: 244)

评分

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

查看全部评分

回复

使用道具 举报

ID:89072 发表于 2018-9-2 18:44 | 显示全部楼层
很实用，wifi模块还没搞明白，谢谢楼主
回复

使用道具 举报

ID:104477 发表于 2018-9-8 19:29 来自手机 | 显示全部楼层
蓝牙有源码吗
回复

使用道具 举报

ID:459616 发表于 2019-1-1 22:37 | 显示全部楼层
谢谢楼主，学习了
回复

使用道具 举报

ID:238191 发表于 2019-7-27 15:41 | 显示全部楼层
hs88 发表于 2018-9-8 19:29
蓝牙有源码吗

文件里有APP的
回复

使用道具 举报

ID:400515 发表于 2019-10-24 16:03 | 显示全部楼层
来学习了
回复

使用道具 举报

ID:440637 发表于 2019-11-13 17:07 | 显示全部楼层
有APP吗？
回复

使用道具 举报

ID:250820 发表于 2020-3-4 21:56 | 显示全部楼层

谢谢楼主，学习了
回复

使用道具 举报

ID:517951 发表于 2020-11-15 16:29 | 显示全部楼层
不错，值得学习。51hei有你更精彩！！
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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