设为首页收藏本站
切换到宽版

极客工坊

 找回密码
 注册

QQ登录

只需一步，快速开始

极客工坊»首页 › Aduino与它的朋友们 › DIY作品展示区 › 机器人制作开源方案 | 智能家居窗户机器人 ...
返回列表 发新帖
查看: 1631|回复: 0

机器人制作开源方案 | 智能家居窗户机器人

[复制链接]
机器谱
发表于 2023-11-29 08:52:48 | 显示全部楼层 |阅读模式
本帖最后由 机器谱 于 2023-11-29 08:52 编辑

作者：曹洋 邱邦彦 姚磊 刘童 靳晨曦
单位：泰州学院
指导老师：宋向前 李杨

1. 场景调研
       随着科技的进步，我国经济水平也有了快速的发展，智能门窗的发展与我国建筑行业的发展有着密切的关系。近些年来我国房地产行业的持续升温、基础设施建设投入力度的不断加大，使得我国建筑业每年以20%以上的速度递增，全行业进入了一个高速发展的黄金时期。我国每年约有21亿平方米的房屋建筑工程，相当于欧洲和美国的总和。通常在房屋总建筑面积中，门与窗的建设面积约占25%-30%，也就是说，我国每年约有6亿多平方米的门窗建设任务。现阶段，我国门窗需求量现已达到每年2.5亿套，成为全球范围内最主要的门窗消费市场之一，智能门窗行业面临着巨大的市场发展空间。
       随着人民生活水平的不断提高以及智能门窗宣传推广力度的加大，未来这种智能化、自动化的智能门窗将得到越来越多消费者的认可。预计未来5年内，我国智能门窗将凭借其极良好的性能，逐步扩大市场份额，成为未来门窗行业发展的趋势之一，占据着市场的重要地位。所以在这个背景下设计一款智能窗户是十分具有意义的。目前我们平时使用的窗户在特殊环境（如阳光、下雨、烟雾等）下是不可以智能主动地作出应对的，这给我们的生活带来了许多不便利，当然有时会给我们带来健康、经济上的损失。在这种背景下选择一款智能窗在很大程度上就会让我们不再让这些问题成为困扰我们生活上的烦恼。同时随着社会进步和发展，智能窗户取代现在日常家庭中的普通窗户将会成为一种不可阻挡的趋势。

2. 技术路线说明
2.1 窗帘模拟结构说明
       窗帘运行结构由一个电动机和一条履带组成，负责控制窗帘的开关与停止功能，如下图所示：
窗帘运行结构

        通过霍尔传感器对窗帘位置进行定位，达到指定位置时发送信号停止，如下图所示：
霍尔传感器检测结构

2.2 窗户结构说明
       窗户的结构由两个舵机连接两扇窗框组成，通过舵机的转动角度实现窗户的开关（0°、90°）和半开（45°），如下图所示：
窗户结构

2.3 系统设计
       本设计采用光敏传感器、近红外传感器、触碰传感器、雨滴传感器、烟雾传感器、蓝牙传感器、霍尔传感器结合Arduino单片机开发板实现对外界光强、红外线、雨滴、烟雾数据的监测，通过编程设定对环境感知还有认为蓝牙远程链接完成对窗户的关闭或打开。如下图所示为整体结构图：
整体结构图

2.4 硬件设计
       使用的Basra是一款基于Arduino开源方案设计的一款开发板。微控制器可以在 Arduino、eclipse、VisualStudio等IDE中通过c/c++语言来编写程序，编译成二进制文件，烧录进微控制器。Basra是一款核心板，大部分时间需要配合外围电路使用。同时装载了BigFish扩展板为核心板提供外围电路，可连接传感器、电机、输出模块、通信模块等，可靠稳定。如下图所示为单片机及扩展板实物图：
单片机及扩展板

2.4.1 光强传感器模块
       光强传感器（如下图所示）实质是利用光强元件将光信号转换为电信号的器件，敏感波长在可见光波长附近。通过光敏三极管在采集外界环境的光照强度，然后将采集光信号转换为电信号，进而通过LM385芯片对所信号进行放大处理，当光照强度达到所设定的阈值时，光照传感器输出端将输出一个低电平，代表传感器已经被触发。主要用于检测环境的光强进而控制窗户和窗帘的开和关。在本设计中自动模式下当光照增强时，窗户打开、窗帘打开，移走光源窗户重新关闭。
光强传感器

2.4.2 近红外传感器模块
       近红外传感器（如下图所示）是一种开关量传感器，它可以检测到前方是否有物体存在，当检测到有物体存在时，传感器输出口会输出低电平；相反在未检测到前方有物体时，传感器输出口会输出一个高电平。主控芯片可根据传感器采集的电平高低做出相应的动作指令。
近红外传感器

2.4.3 雨滴传感器模块
       如下图所示，雨滴传感器是一个模拟（数字）输入模块，也叫雨水、雨量传感器。可用于各种天气状况的监测，检测是否下雨及雨量的大小，转成数字信号（DO）和模拟信号（AO）输出，并广泛应用于Arduino 机器人套件，雨滴，下雨传感器，可用于各种天气状况的监测，并转成数定信号和 AO 输出。本设计中在自动模式下，滴上雨滴时，输出低电平，窗帘不动，步进电机旋转90°完成关窗动作，无雨滴时，再次根据其他条件判断是否打开窗户。
雨滴传感器

2.4.4 烟雾传感器模块
       MQ-2型烟雾传感器（如下所示）属于二氧化锡半导体气敏材料，属于表面离子式N型半导体。当与烟雾接触时，如果晶粒间界处的势垒收到烟雾的调至面变化，就会引起表面导电率的变化。利用这一点就可以获得这种烟雾存在的信息烟雾浓度越大导电率越大，输出电阻越低，则输出的模拟信号就越大。本设计中在自动模式下，当有烟雾或者有害气体时，窗户打开、窗帘打开。


烟雾传感器

2.4.5触碰传感器模块
       触碰传感器（如下图所示）是一种开关量传感器，它的检测元件是一个微动开关（小行程限位开关），可以检测物体对开关的有效触碰，开关行程距离约2mm，接触式触发。触发触碰传感器后，该传感器会在其输出端输出数字量0，即低电平信号，未触发时输出数字量1，即高电平信号。本设计中主要利用其作为开关触碰切换“自动、语音、蓝牙”三种模式。
触碰传感器

2.4.6 霍尔传感器模块
       霍尔传感器（如下图所示）主要利用霍尔效应。磁场中有一个霍尔半导体片，恒定电流 I 从 A 到 B 通过该片。在洛仑兹力的作用下，I 的电子流在通过霍尔半导体时向一侧偏移，使该片在 CD 方向上产生电位差，这就是所谓的霍尔电压。
       当磁性物件移近霍尔开关时，开关检测面上的霍尔元件因产生霍尔效应而使开关内部电路状态发生变化，由此识别附近有磁性物体存在，进而控制开关的通或断。本设计中主要利用其作为限位开关，用来控制窗帘停止的位置。
霍尔传感器

2.4.7 语音模块
       语音识别模块及语音输出模块如上图9所示，该模块采用了基于helios-adsp新一代中大词汇语音识别协处理方案的语音识别专用芯片HBR640，非特定人语音识别技术可对用户的语音进行识别，支持中文音素识别，可任意指定中文识别词条（小于8个汉字），单次识别可支持1000 条以上的语音命令，安静环境下，标准普通话，识别率大于95%，可自动检测环境噪声，噪声环境下也能保证较好的识别率。语音输出模块它的功能是播放声音，我们需要通过软件把自己想要播放的文字转成16进制，然后添加到代码里就好。SYN6288这个模块可以播报中英文，它和单片机的连接走的是串口通信，串口发送包含声音内容的GB2312编码，模块播放声音。
       在语音模式下，可用普通话进行开关窗、开关窗帘等操作。同时切换三种模式时，喇叭会发出提示音，在语音模式下，开关窗户、窗帘时会有相应提示音。
语音识别模块及语音输出模块
2.4.8 蓝牙传感器模块
     蓝牙串口模块（如下图所示）具有两种工作模式：命令响应工作模式和自动连接工作模式，在自动连接工作模式下模块又可分为主（Master）、从（Slave）和回环（Loopback）三种工作角色。
蓝牙串口模块

       当模块处于自动连接工作模式时，将自动根据事先设定的方式连接的数据传输；当模块处于命令响应工作模式时能执行下述所有AT命令，用户可向模块发送各种AT指令，为模块设定控制参数或发布控制命令。通过控制模块外部引脚（PIO11）输入电平，可以实现模块工作状态的动态转换。当模块处于自动连接工作模式时，将自动根据事先设定的方式连接的数据传输；当模块处于命令响应工作模式时能执行下述所有AT命令，用户可向模块发送各种AT指令，为模块设定控制参数或发布控制命令。蓝牙模式下，可以用手机app控制系统的动作和状态。
APP制作逻辑设计

2.5 软件设计
       主要采用Arduino ide环境进行相应功能编程，主要功能如下：
在自动模式下：
       ① 当光强高于某一值时（白天），打开窗户、窗帘；当光强低于某个值（即夜晚），关闭窗户、窗帘。
       ② 当检测到外面下雨时，立即关闭窗户，如果雨停了，打开窗户。
       ③ 当家里检测到烟雾时，打开窗户、窗帘。

在语音模式下：
       语音模式下，可用普通话进行开关窗、开关窗帘等操作。同时切换三种模式时，喇叭会发出提示音，在语音模式下，开关窗户、窗帘时会有相应提示音。
在蓝牙模式下：
       可以用手机app远程遥控窗户和窗帘的开关，还可实现窗户的半开、窗帘拉动时随时停止等功能。

3. 示例程序
① shiyan10_voice.ino
  1. #include <Servo.h>

  3. byte value;

  5. int left_angle=160;

  7. int right_angle=20;

  9. #define la left_angle

  11. #define ra right_angle

  13. int i;

  15. #define Left_Pos A0

  17. #define Right_Pos A1

  19. #define Light A2

  21. #define Raindrop A3

  23. #define Smoke A4

  25. #define Choise A5

  27. #define Humen 13

  29. boolean pattern;

  31. boolean flag1=0;

  33. boolean flag2=0;

  35. boolean flag3=0;

  37. boolean flag4=0;

  39. boolean flag5=0;

  41. boolean flag6=0;

  43. boolean flag7=0;

  45. boolean flag8=0;

  47. boolean flag9=0;

  49. int pin[4]={Smoke,Raindrop,Light,Humen};

  51. int voice[3]={12,8,3};

  53. int voice1;

  55. char buttonState;

  57. Servo Left_Window;

  59. Servo Right_Window;

  61. void setup()

  63. {

  65.   Serial.begin(9600);

  67.   Left_Window.attach(4);

  69.   Right_Window.attach(7);

  71.   Left_Window.write( left_angle );

  73.   Right_Window.write( right_angle );

  75.   pinMode( 5 , OUTPUT);

  77.   pinMode( 6 , OUTPUT);

  79.   pinMode( 11 , INPUT);

  81.   pinMode( 3 , INPUT);

  83.   pinMode( 8 , INPUT);

  85.   pinMode( 12 , INPUT);

  87.   pinMode( 9 , OUTPUT);

  89.   pinMode( 10 , OUTPUT);

  91.   pinMode( 13 , INPUT);

  93. }

  95. void loop()

  97. {

  99.   if(digitalRead(Humen)==0)

  101.   close_window();

  103.   if(digitalRead(Choise)==0)

  105.   {   

  107.     delay(50);

  109.       while(digitalRead(Choise)==0);

  111.       delay(50);

  113.       if(digitalRead(Choise)==1)

  115.      {

  117.      pattern=pattern+1;

  119.      if(pattern>=3)

  121.         pattern=0;

  123.      

  125.         flag1=1;

  127.         flag2=1;

  129.         flag7=1;

  131.      }

  133.   }

  135.   if(pattern==0)

  137.   {

  139.      //Serial.println("automatic control");

  141.      digitalWrite(9, HIGH);

  143.      digitalWrite(10, LOW);//绿灯自动控制

  145.      if(flag1==1)

  147.      {

  149.        speech5();flag1=0;

  151.      }

  153.   }

  155.   else if(pattern==1)

  157.   {   

  159.     //Serial.println("voice control");

  161.      digitalWrite(10, HIGH);

  163.      digitalWrite(9, LOW);//红灯语音控制

  165.      if(flag2==1)

  167.      {

  169.        speech6();flag2=0;

  171.      }

  173.   }

  175.   else

  177.   {

  179.     digitalWrite(10, 0);

  181.      digitalWrite(9, 0);//APP控制

  183.      if(flag7==1)

  185.      {

  187.        speech7();flag7=0;

  189.      }

  191.   }

  193.   if(pattern==0)

  195.   {

  197.     digitalWrite(11,0);

  199.     delay(50);

  201.     digitalWrite(11,1);

  203.     value=0;

  205.      for(int j=0;j<=3;j++)

  207.         value|=(digitalRead(pin[j])<<j);

  209.      Serial.println(value);

  211.      switch (value)

  213.     {

  215.        case 0: close_window();open_curtain();break;

  217.        case 1: close_window();close_curtain();break;

  219.        case 2: close_window();open_curtain();break;

  221.        case 3: close_window();close_curtain();break;

  223.        case 4: close_window();open_curtain();break;

  225.        case 5: close_window();open_curtain();break;

  227.        case 6: close_window();open_curtain();break;

  229.        case 7: close_window();open_curtain();break;

  231.        case 8: open_window();open_curtain();break;

  233.        case 9: close_window();close_curtain();break;

  235.        case 10: open_window();open_curtain();break;

  237.        case 11: close_window();close_curtain();break;

  239.        case 12: open_window();open_curtain();break;

  241.        case 13: close_window();open_curtain();break;

  243.        case 14: open_window();open_curtain();break;

  245.        case 15: open_window();open_curtain();break;

  247.        default:break;

  249.     }  

  251.   }

  253.    if(pattern==1)

  255.   {

  257.      value=0;

  259.      for(int j=0;j<=2;j++)

  261.         value|=(digitalRead(voice[j])<<j);

  263.       

  265.         if(value==voice1)

  267.          {

  269.             flag3=0;

  271.             flag4=0;

  273.             flag5=0;

  275.             flag6=0;         

  277.           }

  279.         else

  281.           {

  283.             flag3=1;

  285.             flag4=1;

  287.             flag5=1;

  289.             flag6=1;

  291.           }

  293.            

  295.       voice1=value;

  297.     // Serial.println(value);

  299.      switch (value)

  301.     {

  303.       case 0:

  305.       {close_window();

  307.        if(flag3==1)

  309.        {

  311.          speech2();flag3=0;

  313.        }

  315.            digitalWrite(11,0);

  317.    delay(50);

  319.    digitalWrite(11,1);

  321.          break;}

  323.        case 1:

  325.        {open_window();

  327.        if(flag4==1)

  329.         {

  331.           speech1();flag4=0;

  333.         }

  335.             digitalWrite(11,0);

  337.    delay(50);

  339.    digitalWrite(11,1);

  341.        break;}

  343.        case 2:

  345.        {close_curtain();

  347.        if(flag5==1)

  349.         {

  351.           speech4();flag5=0;

  353.         }

  355.            digitalWrite(11,0);

  357.    delay(50);

  359.    digitalWrite(11,1);

  361.      break;}

  363.        case 3:

  365.        {open_curtain();

  367.        if(flag6==1)

  369.         {

  371.           speech3();flag6=0;

  373.         }

  375.             digitalWrite(11,0);

  377.    delay(50);

  379.    digitalWrite(11,1);

  381.        break;}

  383.       

  385.        default:break;

  387.     }

  389.   }

  391.      

  393.    if(pattern==2)

  395.    {


  398. if(Serial.available()>0)//串口接受到的数据个数

  400.      buttonState =   Serial.read();

  402.   switch (buttonState)

  404.   {

  406.      case '1': open_window();buttonState='0'; break;

  408.      case '2': close_window();buttonState='0';break;

  410.      case '3': open_curtain();buttonState='0';break;

  412.      case '4': close_curtain();buttonState='0';break;

  414.      case '5': Stop();buttonState='0';break;

  416.      case '6': half_open_window();buttonState='0';break;

  418.      default:break;

  420.   }   

  422.    }

  424.    if(digitalRead(Right_Pos)==0&&flag8==1)

  426.       {Stop( );flag8=0;}

  428.    if(digitalRead(Left_Pos)==0&&flag9==1)

  430.       {Stop( );flag9=0;}

  432. }

  434. void Stop()

  436. {

  438.   digitalWrite( 5 , LOW );

  440.   digitalWrite( 6 , LOW );

  442. }

  444. void Open()

  446. {

  448.   analogWrite( 5 , 150 );

  450.   digitalWrite( 6 , LOW );

  452. }

  454. void Close()

  456. {

  458.   digitalWrite( 5 , LOW );

  460.   analogWrite( 6 , 150 );

  462. }

  464. void close_curtain()

  466. {

  468.    if(digitalRead(Right_Pos)==1)

  470.       {Close( );flag8=1;}

  472.    else

  474.       {Stop( );flag8=0;}

  476. }

  478. void open_curtain()

  480. {

  482.    if(digitalRead(Left_Pos)==1)

  484.       {Open( );flag9=1;}

  486.    else

  488.       {Stop( );flag9=0;}

  490. }

  492. void close_window()

  494. {

  496.   for(la,ra;la<=160,ra>=20;la++,ra--)

  498.   {

  500.     Left_Window.write(la);delay(5);

  502.     Right_Window.write(ra);delay(5);

  504.   }

  506. }

  508. void open_window()

  510. {

  512.   for(la,ra;la>=70,ra<=110;la--,ra++)

  514.   {

  516.     Left_Window.write(la);delay(5);

  518.     Right_Window.write(ra);delay(5);

  520.   }



  524. }

  526. void half_open_window()

  528. {

  530.   if (la>=65&&la<=75)

  532.   {

  534.     for(la,ra;la<=115,ra>=65;la++,ra--)

  536.   {

  538.     Left_Window.write(la);delay(5);

  540.     Right_Window.write(ra);delay(5);

  542.   }

  544.   }

  546.   if (la>=155&&la<=165)

  548.   {

  550.     for(la,ra;la>=115,ra<=65;la--,ra++)

  552.   {

  554.     Left_Window.write(la);delay(5);

  556.     Right_Window.write(ra);delay(5);

  558.   }

  560. }

  562. }

  564. //好的，窗户已打开

  566. void speech1(){

  568.   unsigned char i = 0;

  570.   unsigned char head[22];

  572.   head[0] = 0xFD;

  574.   head[1] = 0x00;

  576.   head[2] = 0x13;

  578.   head[3] = 0x01;

  580.   head[4] = 0x00;

  582.   head[5] = 0xBA;

  584.   head[6] = 0xC3;

  586.   head[7] = 0xB5;

  588.   head[8] = 0xC4;

  590.   head[9] = 0xA3;

  592.   head[10] = 0xAC;

  594.   head[11] = 0xB4;

  596.   head[12] = 0xB0;

  598.   head[13] = 0xBB;

  600.   head[14] = 0xA7;

  602.   head[15] = 0xD2;

  604.   head[16] = 0xD1;

  606.   head[17] = 0xB4;

  608.   head[18] = 0xF2;

  610.   head[19] = 0xBF;

  612.   head[20] = 0xAA;

  614.   head[21] = 0xA0;

  616.   for(i=0; i<22; i++){

  618.     Serial.write(head[i]);

  620.   }

  622. }

  624. //好的，窗户已关闭

  626. void speech2(){

  628.   unsigned char i = 0;

  630.   unsigned char head[22];

  632.   head[0] = 0xFD;

  634.   head[1] = 0x00;

  636.   head[2] = 0x13;

  638.   head[3] = 0x01;

  640.   head[4] = 0x00;

  642.   head[5] = 0xBA;

  644.   head[6] = 0xC3;

  646.   head[7] = 0xB5;

  648.   head[8] = 0xC4;

  650.   head[9] = 0xA3;

  652.   head[10] = 0xAC;

  654.   head[11] = 0xB4;

  656.   head[12] = 0xB0;

  658.   head[13] = 0xBB;

  660.   head[14] = 0xA7;

  662.   head[15] = 0xD2;

  664.   head[16] = 0xD1;

  666.   head[17] = 0xB9;

  668.   head[18] = 0xD8;

  670.   head[19] = 0xB1;

  672.   head[20] = 0xD5;

  674.   head[21] = 0xF6;

  676.   for(i=0; i<22; i++){

  678.     Serial.write(head[i]);

  680.   }

  682. }

  684. //好的，窗帘已打开

  686. void speech3()

  688. {

  690.   unsigned char i = 0;

  692.   unsigned char head[22];

  694.   head[0] = 0xFD;

  696.   head[1] = 0x00;

  698.   head[2] = 0x13;

  700.   head[3] = 0x01;

  702.   head[4] = 0x00;

  704.   head[5] = 0xBA;

  706.   head[6] = 0xC3;

  708.   head[7] = 0xB5;

  710.   head[8] = 0xC4;

  712.   head[9] = 0xA3;

  714.   head[10] = 0xAC;

  716.   head[11] = 0xB4;

  718.   head[12] = 0xB0;

  720.   head[13] = 0xC1;

  722.   head[14] = 0xB1;

  724.   head[15] = 0xD2;

  726.   head[16] = 0xD1;

  728. head[17] = 0xB4;

  730.   head[18] = 0xF2;

  732.   head[19] = 0xBF;

  734.   head[20] = 0xAA;

  736.   head[21] = 0xCC;

  738.   for(i=0; i<22; i++){

  740.     Serial.write(head[i]);

  742.   }

  744. }

  746. //好的，窗帘已关闭

  748. void speech4()

  750. {

  752.   unsigned char i = 0;

  754.   unsigned char head[22];

  756.   head[0] = 0xFD;

  758.   head[1] = 0x00;

  760.   head[2] = 0x13;

  762.   head[3] = 0x01;

  764.   head[4] = 0x00;

  766.   head[5] = 0xBA;

  768.   head[6] = 0xC3;

  770.   head[7] = 0xB5;

  772.   head[8] = 0xC4;

  774.   head[9] = 0xA3;

  776.   head[10] = 0xAC;

  778.   head[11] = 0xB4;

  780.   head[12] = 0xB0;

  782.   head[13] = 0xC1;

  784.   head[14] = 0xB1;

  786.   head[15] = 0xD2;

  788.   head[16] = 0xD1;

  790.   head[17] = 0xB9;

  792.   head[18] = 0xD8;

  794.   head[19] = 0xB1;

  796.   head[20] = 0xD5;

  798.   head[21] = 0x9A;

  800.   for(i=0; i<22; i++)

  802.   {

  804.     Serial.write(head[i]);

  806.   }

  808. }

  810. //已切换到自动模式

  812. void speech5()

  814. {

  816.   unsigned char i = 0;

  818.   unsigned char head[22];

  820.   head[0] = 0xFD;

  822.   head[1] = 0x00;

  824.   head[2] = 0x13;

  826.   head[3] = 0x01;

  828.   head[4] = 0x00;

  830.   head[5] = 0xD2;

  832.   head[6] = 0xD1;

  834.   head[7] = 0xC7;

  836.   head[8] = 0xD0;

  838.   head[9] = 0xBB;

  840.   head[10] = 0xBB;

  842.   head[11] = 0xB5;

  844.   head[12] = 0xBD;

  846.   head[13] = 0xD7;

  848.   head[14] = 0xD4;

  850.   head[15] = 0xB6;

  852.   head[16] = 0xAF;

  854.   head[17] = 0xC4;

  856.   head[18] = 0xA3;

  858.   head[19] = 0xCA;

  860.   head[20] = 0xBD;

  862.   head[21] = 0xF9;

  864.   for(i=0; i<22; i++){

  866.     Serial.write(head[i]);

  868.   }

  870. }

  872. //已切换到语音模式

  874. void speech6()

  876. {

  878.   unsigned char i = 0;

  880.   unsigned char head[22];

  882.   head[0] = 0xFD;

  884.   head[1] = 0x00;

  886. head[2] = 0x13;

  888.   head[3] = 0x01;

  890.   head[4] = 0x00;

  892.   head[5] = 0xD2;

  894.   head[6] = 0xD1;

  896.   head[7] = 0xC7;

  898.   head[8] = 0xD0;

  900.   head[9] = 0xBB;

  902.   head[10] = 0xBB;

  904.   head[11] = 0xB5;

  906.   head[12] = 0xBD;

  908.   head[13] = 0xD3;

  910.   head[14] = 0xEF;

  912.   head[15] = 0xD2;

  914.   head[16] = 0xF4;

  916.   head[17] = 0xC4;

  918.   head[18] = 0xA3;

  920.   head[19] = 0xCA;

  922.   head[20] = 0xBD;

  924.   head[21] = 0xF9;

  926.   for(i=0; i<22; i++){

  928.     Serial.write(head[i]);

  930.   }

  932. }

  934. //已切换到APP模式

  936. void speech7(){

  938.   unsigned char i = 0;

  940.   unsigned char head[21];

  942.   head[0] = 0xFD;

  944.   head[1] = 0x00;

  946.   head[2] = 0x12;

  948.   head[3] = 0x01;

  950.   head[4] = 0x00;

  952.   head[5] = 0xD2;

  954.   head[6] = 0xD1;

  956.   head[7] = 0xC7;

  958.   head[8] = 0xD0;

  960.   head[9] = 0xBB;

  962.   head[10] = 0xBB;

  964.   head[11] = 0xB5;

  966.   head[12] = 0xBD;

  968.   head[13] = 0x41;

  970.   head[14] = 0x50;

  972.   head[15] = 0x50;

  974.   head[16] = 0xC4;

  976.   head[17] = 0xA3;

  978.   head[18] = 0xCA;

  980.   head[19] = 0xBD;

  982.   head[20] = 0xA3;

  984.   for(i=0; i<21; i++){

  986.     Serial.write(head[i]);

  988.   }

  990. }
复制代码
② voice.ino
  1. #include "HBR740.h"

  3. boolean flag=0;

  5. HBR740 hbr740; //实例化一个语音识别模块

  7. void setup()

  9. {

  11.   hbr740.open(); //开始进行语音识别

  13.   pinMode( 3 , OUTPUT);

  15.   pinMode( 8 , OUTPUT);

  17.   pinMode( 11 , INPUT);

  19.   pinMode( 12 , OUTPUT);

  21. }

  23. void loop()

  25. {

  27.   while(flag==0)

  29.   {  

  31.     initial();

  33.     flag=1;

  35.   }

  37.   if(digitalRead(11)==0)

  39.      initial();

  41.   if(hbr740.isHeard()) //如果监测到识别语句

  43.   {

  45.      int value = hbr740.getSentence(); //获得识别语句的序号

  47.      switch (value)

  49.     {

  51.       case 0: close_window();break;

  53.       case 1: open_window();break;

  55.       case 2: close_curtain();break;

  57.       case 3: open_curtain();break;

  59.       default:;break;

  61.     }   

  63.   }

  65. }

  67. void serialEvent()

  69. {

  71.   hbr740.lisen(); //在串口接收事件中调用语音识别的监听指令

  73. }

  75. void initial()

  77. {

  79.   digitalWrite(3,1);digitalWrite(8,1);digitalWrite(12,1);

  81. }

  83. void close_window()

  85. {

  87.   digitalWrite(3,0);digitalWrite(8,0);digitalWrite(12,0);

  89. }

  91. void open_window()

  93. {

  95.   digitalWrite(3,0);digitalWrite(8,0);digitalWrite(12,1);

  97. }

  99. void close_curtain()

  101. {

  103.   digitalWrite(3,0);digitalWrite(8,1);digitalWrite(12,0);

  105. }

  107. void open_curtain()

  109. {

  111.   digitalWrite(3,0);digitalWrite(8,1);digitalWrite(12,1);

  113. }
复制代码

4. 作品创新点
       红外扫描模块--防止小孩坠落：采用的红外传感器凭借高可靠性，高性能，低功耗，价格便宜而广受欢迎，应用非常普遍。它是通过接收到人体发出的红外线而引起的电荷失常来工作的，当有人在红外传感器的检测范围时，红外传感器会将检测到的信号转换成电信号，传输给单片机，从而控制舵机实现窗户的关闭。
       手机APP控制模块：利用蓝牙连接实现远程对窗户进行控制，当连接时，可进入远程控制操作模式，当人为观察到需要特殊开合窗户的情况时，通过手机与APP的连接，可使用手机软件，然后便可以进行远程控制。
APP效果图

5. 作品难点及解决方案
5.1难点
       ① 如何实现各个模块之间在互不干扰情况下的合成以及各个模块之间的优先级问题。
       ② 蓝牙模块调试及手机APP设计问题。
5.2解决方案
       ① 增加一个按钮用于切换三种模式 设置好各个模块的优先级后接下来用switch函数设置不同情况下的动作。
       ② 利用蓝牙串口助手逐步运行调试蓝牙模块，向其发送信号后能得到接收回应，之后将程序烧录主板，发送信号测试舵机、发动机的运行状态并调试。接着登陆APP INVENTOR设计手机APP，完成组件设计和逻辑设计后打包apk，下载到手机调试几次，最后成功。

* 本项目更多详情请查看 https://www.robotway.com/h-col-290.html
回复

使用道具 举报

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

本版积分规则 需要先绑定手机号

Archiver|联系我们|极客工坊

GMT+8, 2024-4-30 10:23 , Processed in 0.038547 second(s), 17 queries .

Powered by Discuz! X3.4 Licensed

Copyright © 2001-2021, Tencent Cloud.

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