0
0

基于ARM树莓派实现智能家居：语音识别控制，Socket网络控制，火灾报警检测，实时监控

一 项目说明

① 设计框架

● 项目架构采用简单工厂模式来设计，将语音识别，TCP服务器设计成链表的每个节点，形成控制工厂。

● 将餐厅灯，卧室灯，二楼灯，泳池灯，蜂鸣器，火焰检测模块，也设计成链表的每个节点，形成设备端工厂。

● 基于这种架构保证项目的稳定性和功能拓展性，在添加新功能的时候，只需要添加一个链表节点文件文件就可以。

● 不管是设备端还是控制端，在实际调试过程中又涉及到临界资源的竞争，所以采用多线程来解决这个问题。

● 语音处理用的是SU-03T模块的二次开发，对串口数据进行修改并整合到树莓派的串口通信中去。

② 功能说明

● 语音模块识别语音来控制各个灯的开关，基于串口通信来配置语音命令的内容。

● 搭建TCP服务器，用socket网络通信的方式控制各个灯的开关，手机客户端发送指令到电脑服务器端来实现控制功能。

● 火灾报警，火焰检测模块结合蜂鸣器开发。接收火焰状态，检测有火源靠近时，蜂鸣器输出低电平发出警报声响，并在终端显示火灾危险提示，检测没有火源时，蜂鸣器输出高电平，停止报警声。

● 实时监控，将摄像头模块安装于树莓并配置树莓派摄像头的接口参数，打开摄像头，写入树莓ip地址及端口即可。

③ 硬件说明

树莓派开发板(3B)，继电器组，房屋模型，蜂鸣器，语音模块，火焰检测模块，电池盒，摄像头，杜邦线，灯具，USB-TTL模块(串口调试)

④ 软件说明

SecureCRT8.0(树莓派终端)，sourceinsight(代码编辑)，filezilla(文件传输)，AiThinker Serial Tool(串口调试)，NetAssist(网络调试)。

二 项目代码

<1> mainPro.c 主函数

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <unistd.h>
  4. #include <pthread.h>
  5. #include <sys/types.h>    
  6. #include <sys/socket.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  10. #include "contrlDevices.h"//外接设备
  11. #include "InputCommand.h"//控制
  13. struct InputCommander *pCommandHead = NULL;
  14. struct Devices *pdeviceHead = NULL;
  15. struct InputCommander *socketHandler = NULL;
  16. int c_fd;
  18. //外设的设备查询
  19. struct Devices *findDeviceByName(char *name,struct Devices *phead)
  20. {
  21.     struct Devices *tmp = phead;
  22.     
  23.     if(phead == NULL){
  24.         return NULL;
  25.     }else{
  26.         while(tmp != NULL){
  27.             if(strcmp(tmp->deviceName,name) == 0){
  28.                 return tmp;
  29.             }
  30.             tmp = tmp->next;
  31.         }    
  32.         return NULL;
  33.     }
  34. };
  36. //控制设备查询
  37. struct InputCommander *findCommandByName(char *name,struct InputCommander *phead)
  38. {
  39.     struct InputCommander *tmp = phead;
  40.     
  41.     if(phead == NULL){
  42.         return NULL;
  43.     }else{
  44.         while(tmp != NULL){
  45.             if(strcmp(tmp->commandName,name) == 0){
  46.                 return tmp;
  47.             }
  48.             tmp = tmp->next;
  49.         }    
  50.         return NULL;
  51.     }
  52. };
  54. //控制灯函数，用于语音线程    
  55. void Command(struct InputCommander *CmdHandler)
  56. {
  57.         struct Devices *tmp =NULL;
  58.      
  59.         if(strcmp("yo",CmdHandler->command) == 0){
  60.             tmp = findDeviceByName("bathroomLight",pdeviceHead);
  61.             if(tmp != NULL){
  62.                 tmp->open(tmp->pinNum);
  63.                 printf("已打开泳池灯\n");
  64.             }
  65.         }
  66.         
  67.         if(strcmp("yc",CmdHandler->command) == 0){    
  68.             tmp = findDeviceByName("bathroomLight",pdeviceHead);   
  69.             if(tmp != NULL){      
  70.                 tmp->close(tmp->pinNum);      
  71.                 printf("已关闭泳池灯\n");   
  72.             }    
  73.         }  
  75.         if(strcmp("eo",CmdHandler->command) == 0){
  76.             tmp = findDeviceByName("upstairLight",pdeviceHead);
  77.             if(tmp != NULL){
  78.                 tmp->open(tmp->pinNum);
  79.                 printf("已打开二楼灯\n");
  80.             }
  81.         }
  82.         if(strcmp("ec",CmdHandler->command) == 0){    
  83.             tmp = findDeviceByName("upstairLight",pdeviceHead);   
  84.             if(tmp != NULL){      
  85.                 tmp->close(tmp->pinNum);      
  86.                 printf("已关闭二楼灯\n");   
  87.             }    
  88.         }
  89.         if(strcmp("co",CmdHandler->command) == 0){
  90.             tmp = findDeviceByName("restauranLight",pdeviceHead);
  91.             if(tmp != NULL){
  92.                 tmp->open(tmp->pinNum);
  93.                 printf("已打开餐厅灯\n");
  94.             }
  95.         }
  96.         if(strcmp("cc",CmdHandler->command) == 0){    
  97.             tmp = findDeviceByName("restauranLight",pdeviceHead);   
  98.             if(tmp != NULL){      
  99.                 tmp->close(tmp->pinNum);      
  100.                 printf("已关闭餐厅灯\n");   
  101.             }    
  102.         }
  103.         if(strcmp("wo",CmdHandler->command) == 0){
  104.             tmp = findDeviceByName("livingroomLight",pdeviceHead);
  105.             if(tmp != NULL){
  106.                 tmp->open(tmp->pinNum);
  107.                 printf("已打开卧室灯\n");
  108.             }
  109.         }
  110.         if(strcmp("wc",CmdHandler->command) == 0){    
  111.             tmp = findDeviceByName("livingroomLight",pdeviceHead);   
  112.             if(tmp != NULL){      
  113.                 tmp->close(tmp->pinNum);      
  114.                 printf("已关闭卧室灯\n");   
  115.             }    
  116.         }
  117.     if(strcmp("ao",CmdHandler->command) == 0){    
  118.             tmp = findDeviceByName("bathroomLight",pdeviceHead);        
  119.         if(tmp != NULL)  tmp->open(tmp->pinNum);    
  120.             tmp = findDeviceByName("upstairLight",pdeviceHead);    
  121.         if(tmp != NULL)  tmp->open(tmp->pinNum);        
  122.             tmp = findDeviceByName("restauranLight",pdeviceHead);    
  123.         if(tmp != NULL)  tmp->open(tmp->pinNum);        
  124.             tmp = findDeviceByName("livingroomLight",pdeviceHead);    
  125.         if(tmp != NULL)  tmp->open(tmp->pinNum);       
  126.             printf("已打开所有灯\n");    
  127.     }    
  128.     if(strcmp("ac",CmdHandler->command) == 0){    
  129.             tmp = findDeviceByName("bathroomLight",pdeviceHead);        
  130.         if(tmp != NULL)  tmp->close(tmp->pinNum);    
  131.             tmp = findDeviceByName("upstairLight",pdeviceHead);    
  132.         if(tmp != NULL)  tmp->close(tmp->pinNum);    
  133.             tmp = findDeviceByName("restauranLight",pdeviceHead);    
  134.         if(tmp != NULL)  tmp->close(tmp->pinNum);        
  135.             tmp = findDeviceByName("livingroomLight",pdeviceHead);    
  136.         if(tmp != NULL)  tmp->close(tmp->pinNum);      
  137.             printf("已关闭所有灯\n");    
  138.     }
  140. }
  142. //语音线程
  143. void *voice_thread(void *datas)
  144. {    
  145.     struct InputCommander *voiceHandler;
  146.     //struct Devices *tmp =NULL;
  147.     
  148.     int nread;
  149.     
  150.     voiceHandler = findCommandByName("voice",pCommandHead);
  151.     if(voiceHandler == NULL){
  152.         printf("find voiceHandler error\n");
  153.         pthread_exit(NULL);
  154.     }else{    
  155.        if(voiceHandler->Init(voiceHandler,NULL,NULL) < 0){
  156.             printf("voice init error\n");
  157.             pthread_exit(NULL);        
  158.        }else{
  159.             printf("%s init success\n",voiceHandler->commandName);
  160.        while(1){
  161.            nread = voiceHandler->getCommand(voiceHandler);
  162.            if(nread == 0){
  163.                 printf("nodata form voice\n");
  164.            }else{
  165.                    
  166.                 printf("do device contrl --> %s\n",voiceHandler->command);    
  167.                 Command(voiceHandler);
  168.                }               
  169.            }                      
  170.            }
  171.      }       
  172. }
  174. //接收客户端指令
  175. void *read_thread(void *datas)
  176. {
  177.     int n_read;
  178.     struct Devices *tmp =NULL;
  179.     memset(socketHandler->command,'\0',sizeof(socketHandler->command));
  180.     n_read = read(c_fd,socketHandler->command,sizeof(socketHandler->command));
  181.     if(n_read == -1){
  182.             perror("read");
  183.     }else if(n_read>0){
  184.             printf("\nget: %d,%s\n",n_read,socketHandler->command);    
  185.        
  186.             if(strcmp("yo",socketHandler->command) == 0){
  187.                 tmp = findDeviceByName("bathroomLight",pdeviceHead);
  188.                 if(tmp != NULL){
  189.                     tmp->open(tmp->pinNum);
  190.                     printf("已打开泳池灯\n");
  191.                 }
  192.             }
  193.                    
  194.             if(strcmp("yc",socketHandler->command) == 0){  
  195.                 tmp = findDeviceByName("bathroomLight",pdeviceHead);   
  196.                 if(tmp != NULL){      
  197.                     tmp->close(tmp->pinNum);      
  198.                     printf("已关闭泳池灯\n");     
  199.                 }   
  200.             }  
  201.            
  202.             if(strcmp("eo",socketHandler->command) == 0){
  203.                 tmp = findDeviceByName("upstairLight",pdeviceHead);
  204.                 if(tmp != NULL){
  205.                     tmp->open(tmp->pinNum);
  206.                     printf("已打开二楼灯\n");
  207.                 }
  208.             }
  209.             if(strcmp("ec",socketHandler->command) == 0){  
  210.                 tmp = findDeviceByName("upstairLight",pdeviceHead);     
  211.                 if(tmp != NULL){      
  212.                     tmp->close(tmp->pinNum);      
  213.                     printf("已关闭二楼灯\n");     
  214.                 }   
  215.             }
  216.             if(strcmp("co",socketHandler->command) == 0){
  217.                 tmp = findDeviceByName("restauranLight",pdeviceHead);
  218.                 if(tmp != NULL){
  219.                     tmp->open(tmp->pinNum);
  220.                     printf("已打开餐厅灯\n");
  221.                 }
  222.             }
  223.             if(strcmp("cc",socketHandler->command) == 0){  
  224.                 tmp = findDeviceByName("restauranLight",pdeviceHead);   
  225.                 if(tmp != NULL){      
  226.                     tmp->close(tmp->pinNum);      
  227.                     printf("已关闭餐厅灯\n");     
  228.                 }   
  229.             }
  230.             if(strcmp("wo",socketHandler->command) == 0){
  231.                 tmp = findDeviceByName("livingroomLight",pdeviceHead);
  232.                 if(tmp != NULL){
  233.                     tmp->open(tmp->pinNum);
  234.                     printf("已打开卧室灯\n");
  235.                 }
  236.             }
  237.             if(strcmp("wc",socketHandler->command) == 0){  
  238.                 tmp = findDeviceByName("livingroomLight",pdeviceHead);    
  239.                 if(tmp != NULL){      
  240.                     tmp->close(tmp->pinNum);      
  241.                     printf("已关闭卧室灯\n");     
  242.                 }   
  243.             }
  244.             if(strcmp("ao",socketHandler->command) == 0){  
  245.                     tmp = findDeviceByName("bathroomLight",pdeviceHead);        
  246.                 if(tmp != NULL)    tmp->open(tmp->pinNum);    
  247.                     tmp = findDeviceByName("upstairLight",pdeviceHead); 
  248.                 if(tmp != NULL)    tmp->open(tmp->pinNum);        
  249.                     tmp = findDeviceByName("restauranLight",pdeviceHead);   
  250.                 if(tmp != NULL)    tmp->open(tmp->pinNum);        
  251.                     tmp = findDeviceByName("livingroomLight",pdeviceHead);  
  252.                 if(tmp != NULL)    tmp->open(tmp->pinNum);       
  253.                     printf("已打开所有灯\n");      
  254.             }    
  255.             if(strcmp("ac",socketHandler->command) == 0){  
  256.                      tmp = findDeviceByName("bathroomLight",pdeviceHead);        
  257.                  if(tmp != NULL)    tmp->close(tmp->pinNum);   
  258.                      tmp = findDeviceByName("upstairLight",pdeviceHead); 
  259.                  if(tmp != NULL)    tmp->close(tmp->pinNum);   
  260.                      tmp = findDeviceByName("restauranLight",pdeviceHead);   
  261.                  if(tmp != NULL)    tmp->close(tmp->pinNum);       
  262.                      tmp = findDeviceByName("livingroomLight",pdeviceHead);  
  263.                  if(tmp != NULL)    tmp->close(tmp->pinNum);      
  264.                      printf("已关闭所有灯\n"); 
  265.             }
  266.     }else{
  267.            printf("client quit\n");
  268.     }
  269. }
  271. //网络线程
  272. void *socket_thread(void *datas)
  273. {
  274.     int n_read = 0;
  275.     pthread_t readThread;
  276.     
  277.     struct sockaddr_in c_addr;
  278.     memset(&c_addr,0,sizeof(struct sockaddr_in));
  279.     int clen = sizeof(struct sockaddr_in);
  280.     
  281.     socketHandler = findCommandByName("socketServer",pCommandHead);
  282.     if(socketHandler == NULL){
  283.         printf("find socketHandler error\n");
  284.         pthread_exit(NULL);
  285.     }else{
  286.         printf("%s init success\n",socketHandler->commandName);
  287.     }
  288.     socketHandler->Init(socketHandler,NULL,NULL);
  289.     while(1){
  290.         c_fd = accept(socketHandler->sfd,(struct sockaddr *)&c_addr,&clen);
  291.         pthread_create(&readThread,NULL,read_thread,NULL);
  292.         
  293.     }
  294. }
  296. //火焰线程
  297. void *fire_thread(void *datas)
  298. {
  299.     int status;
  300.     struct Devices *fireDeviceTmp = NULL;
  301.     struct Devices *beepDeviceTmp = NULL;
  303.     fireDeviceTmp = findDeviceByName("fireIfOrNot",pdeviceHead);
  304.     beepDeviceTmp = findDeviceByName("beep",pdeviceHead);
  305.     
  306.     fireDeviceTmp->deviceInit(fireDeviceTmp->pinNum);
  307.     beepDeviceTmp->deviceInit(beepDeviceTmp->pinNum);
  308.     
  309.     while(1){
  310.         status = fireDeviceTmp->changeStatus(fireDeviceTmp->pinNum);  //读取“火焰传感器”状态
  311.         if(status == 0){                                              //检测到火焰或强光源 
  312.             printf("fire danger warning!!!\n");                               
  313.             beepDeviceTmp->open(beepDeviceTmp->pinNum);     //打开蜂鸣器
  314.             delay(1000);
  315.         }else{                        
  316.             beepDeviceTmp->close(beepDeviceTmp->pinNum); //关闭蜂鸣器
  317.         }
  318.     }      
  319. }
  320. int main()
  321. {
  322.     int status;
  323.     char name[128];
  324.     struct Devices *tmp = NULL;
  325.     
  326.     pthread_t voiceThread;
  327.     pthread_t socketThread;
  328.     pthread_t fireThread;
  330.     if(-1 == wiringPiSetup()){  //初始化wiringPi库
  331.         return -1;
  332.     }
  333.     
  334.     //1.指令工厂
  335.     pCommandHead = addvoiceContrlToInputCommandLink(pCommandHead);//语音
  336.     pCommandHead = addSocketContrlToInputCommandLink(pCommandHead);//网络
  337.     
  338.     //2.设备控制工厂初始化
  339.     pdeviceHead = addBathroomLightToDeviceLink(pdeviceHead);//泳池灯
  340.     pdeviceHead = addUpstairLightToDeviceLink(pdeviceHead);//二楼灯
  341.     pdeviceHead = addLivingroomLightToDeviceLink(pdeviceHead);//卧室灯
  342.     pdeviceHead = addRestauranLightToDeviceLink(pdeviceHead);//餐厅灯
  343.     pdeviceHead = addFireToDeviceLink(pdeviceHead);//火灾检测
  344.     pdeviceHead = addBeepToDeviceLink(pdeviceHead);//蜂鸣器
  346.     //int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
  347.     //3.线程池建立
  348.     //3.1 语音线程
  349.     pthread_create(&voiceThread,NULL,voice_thread,NULL);
  350.     
  351.     //3.2 socket线程
  352.     pthread_create(&socketThread,NULL,socket_thread,NULL);
  353.     
  354.     //3.3 火灾线程
  355.     pthread_create(&fireThread,NULL,fire_thread,NULL);
  357.     /*while(1){  //用于四盏灯的调试
  358.         printf("input:\n");
  359.         scanf("%s",name);
  360.         tmp = findDeviceByName(name,pdeviceHead);
  362.         if(tmp != NULL){
  363.             tmp->deviceInit(tmp->pinNum);
  364.             tmp->open(tmp->pinNum);
  365.         }
  366.     }*/ 
  367.     
  368.     pthread_join(voiceThread,NULL);
  369.     pthread_join(socketThread,NULL);
  370.     pthread_join(fireThread,NULL);
  371.     
  372.     return 0;
  373. }

<2> InputCommand.h 控制设备头文件

  1. #include <wiringPi.h>
  2. #include <stdlib.h>
  4. struct InputCommander{
  5.     char commandName[128];
  6.     char deviceName[128];
  7.     char command[32];
  8.     int (*Init)(struct InputCommander *voicer,char *ipAdress,char *port);
  9.     int (*getCommand)(struct InputCommander *voicer);
  10.     char log[1024];
  11.     int fd;
  12.     char port[12];
  13.     char ipAddress[32];
  14.     int sfd;
  15.     
  16.     struct InputCommander *next;
  17. };
  19. struct InputCommander *addvoiceContrlToInputCommandLink(struct InputCommander *phead);
  20. struct InputCommander *addSocketContrlToInputCommandLink(struct InputCommander *phead);

<3> contrlDevices.h 外接设备头文件

  1. #include <wiringPi.h>
  2. #include <stdlib.h>
  4. struct Devices{
  5.     char deviceName[128];
  6.     int status;
  7.     int pinNum;
  8.     
  9.     int (*open)(int pinNum);
  10.     int (*close)(int pinNum);
  11.     int (*deviceInit)(int pinNum);
  12.     
  13.     int (*changeStatus)(int status);
  15.     struct Devices *next;
  16. };
  18. struct Devices *addBathroomLightToDeviceLink(struct Devices *phead);
  19. struct Devices *addUpstairLightToDeviceLink(struct Devices *phead);
  20. struct Devices *addLivingroomLightToDeviceLink(struct Devices *phead);
  21. struct Devices *addRestauranLightToDeviceLink(struct Devices *phead);
  22. struct Devices *addFireToDeviceLink(struct Devices *phead);
  23. struct Devices *addBeepToDeviceLink(struct Devices *phead);

<4> bathroomLight.c 泳池灯

  1. #include "contrlDevices.h"
  3. int bathroomLightOpen(int pinNum)
  4. {
  5.     digitalWrite(pinNum,LOW);
  6. }
  7. int bathroomLightClose(int pinNum)
  8. {
  9.     digitalWrite(pinNum,HIGH);
  10. }
  12. int bathroomLightCloseInit(int pinNum)
  13. {
  14.     pinMode(pinNum,OUTPUT);
  15.     digitalWrite(pinNum,HIGH);
  16. }
  18. int bathroomLightCloseStatus(int status)
  19. {
  21. }
  22. struct Devices bathroomLight = {
  24.     .deviceName = "bathroomLight",
  25.     .pinNum = 21,
  26.     .open = bathroomLightOpen,
  27.     .close = bathroomLightClose,
  28.     .deviceInit = bathroomLightCloseInit,
  29.     .changeStatus = bathroomLightCloseStatus
  30. };
  32. struct Devices *addBathroomLightToDeviceLink(struct Devices *phead)
  33. {
  34.     if(phead == NULL){
  35.         return &bathroomLight;
  36.     }else{
  37.         bathroomLight.next = phead;
  38.         phead = &bathroomLight;
  39.     }
  40. }

<5> livingroomLight.c 卧室灯

  1. #include "contrlDevices.h"
  3. int livingroomLightOpen(int pinNum)
  4. {
  5.     digitalWrite(pinNum,LOW);
  6. }
  7. int livingroomLightClose(int pinNum)
  8. {
  9.     digitalWrite(pinNum,HIGH);
  10. }
  12. int livingroomLightCloseInit(int pinNum)
  13. {
  14.     pinMode(pinNum,OUTPUT);
  15.     digitalWrite(pinNum,HIGH);
  16. }
  18. int livingroomLightCloseStatus(int status)
  19. {
  21. }
  22. struct Devices livingroomLight = {
  24.     .deviceName = "livingroomLight",
  25.     .pinNum = 24,
  26.     .open = livingroomLightOpen,
  27.     .close = livingroomLightClose,
  28.     .deviceInit = livingroomLightCloseInit,
  29.     .changeStatus = livingroomLightCloseStatus
  30. };
  32. struct Devices *addLivingroomLightToDeviceLink(struct Devices *phead)
  33. {
  34.     if(phead == NULL){
  35.         return &livingroomLight;
  36.     }else{
  37.         livingroomLight.next = phead;
  38.         phead = &livingroomLight;
  39.     }
  40. }

<6> restaurantLight.c 餐厅灯

  1. #include "contrlDevices.h"
  3. int restauranLightOpen(int pinNum)
  4. {
  5.     digitalWrite(pinNum,LOW);
  6. }
  7. int restauranLightClose(int pinNum)
  8. {
  9.     digitalWrite(pinNum,HIGH);
  10. }
  12. int restauranLightCloseInit(int pinNum)
  13. {
  14.     pinMode(pinNum,OUTPUT);
  15.     digitalWrite(pinNum,HIGH);
  16. }
  18. int restauranLightCloseStatus(int status)
  19. {
  21. }
  22. struct Devices restauranLight = {
  24.     .deviceName = "restauranLight",
  25.     .pinNum = 23,
  26.     .open = restauranLightOpen,
  27.     .close = restauranLightClose,
  28.     .deviceInit = restauranLightCloseInit,
  29.     .changeStatus = restauranLightCloseStatus
  30. };
  32. struct Devices *addRestauranLightToDeviceLink(struct Devices *phead)
  33. {
  34.     if(phead == NULL){
  35.         return &restauranLight;
  36.     }else{
  37.         restauranLight.next = phead;
  38.         phead = &restauranLight;
  39.     }
  40. }

<7> upstairLight.c 二楼灯

  1. #include "contrlDevices.h"
  3. int upstairLightOpen(int pinNum)
  4. {
  5.     digitalWrite(pinNum,LOW);
  6. }
  7. int upstairLightClose(int pinNum)
  8. {
  9.     digitalWrite(pinNum,HIGH);
  10. }
  12. int upstairLightCloseInit(int pinNum)
  13. {
  14.     pinMode(pinNum,OUTPUT);
  15.     digitalWrite(pinNum,HIGH);
  16. }
  18. int upstairLightCloseStatus(int status)
  19. {
  21. }
  22. struct Devices upstairLight = {
  24.     .deviceName = "upstairLight",
  25.     .pinNum = 22,
  26.     .open = upstairLightOpen,
  27.     .close = upstairLightClose,
  28.     .deviceInit = upstairLightCloseInit,
  29.     .changeStatus = upstairLightCloseStatus
  30. };
  32. struct Devices *addUpstairLightToDeviceLink(struct Devices *phead)
  33. {
  34.     if(phead == NULL){
  35.         return &upstairLight;
  36.     }else{
  37.         upstairLight.next = phead;
  38.         phead = &upstairLight;
  39.     }
  40. }

<8> fire.c 火焰传感器

  1. #include "contrlDevices.h"
  3. int fireIfOrNotInit(int pinNum)
  4. {
  5.     pinMode(pinNum,INPUT);
  6.     digitalWrite(pinNum,HIGH);
  7. }
  9. int fireStatusRead(int pinNum)
  10. {
  11.     return digitalRead(pinNum);
  12. }
  13. struct Devices fireIfOrNot = {
  14.     .deviceName = "fireIfOrNot",
  15.     .pinNum = 25,
  16.     .deviceInit = fireIfOrNotInit,
  17.     .changeStatus = fireStatusRead
  18. };
  19. struct Devices *addFireToDeviceLink(struct Devices *phead)
  20. {
  21.     if(phead == NULL)
  22.     {
  23.         return &fireIfOrNot;
  24.     }else{
  25.         fireIfOrNot.next = phead;
  26.         phead = &fireIfOrNot;
  27.         //return phead;
  28.     }
  29. }

<9> beep.c 蜂鸣器

  1. #include "contrlDevices.h"
  3. //struct Devices *addBeepToDeviceLink(struct Devices *phead);
  5. int beepInit(int pinNum)              //初始化函数
  6. {
  7.         pinMode(pinNum,OUTPUT);       //配置引脚为输出引脚
  8.         digitalWrite(pinNum,HIGH);    //引脚输出高电平，即默认为关闭状态
  9. }
  11. int beepOpen(int pinNum)             //打开蜂鸣器函数
  12. {
  13.         digitalWrite(pinNum,LOW);
  14. }
  16. int beepClose(int pinNum)             //关闭蜂鸣器函数
  17. {
  18.         digitalWrite(pinNum,HIGH);
  19. }
  21. struct Devices beep = {             //蜂鸣器设备链表节点
  22.         .deviceName = "beep",
  23.         .pinNum = 29,                   
  24.         .deviceInit = beepInit,
  25.         .open = beepOpen,
  26.         .close = beepClose,
  27.         //.next = NULL
  28. };
  30. struct Devices* addBeepToDeviceLink(struct Devices *phead)  //头插法将设备节点加入设备工厂链表函数
  31. {
  32.         if(phead == NULL){
  33.                 return &beep;
  34.         }else{
  35.                 beep.next = phead;
  36.                 phead = &beep;
  37.         }
  38. }

<10> voiceContrl.c 语音模块

  1. #include <wiringPi.h>
  2. #include <stdio.h>
  3. #include <wiringSerial.h>
  4. #include <unistd.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  8. #include "InputCommand.h"
  10. int voiceGetCommand(struct InputCommander *voicer)//获取指令函数
  11. {
  12.     int nread = 0;
  14.     memset(voicer->command,'\0',sizeof(voicer->command));
  15.     nread = read(voicer->fd,voicer->command,sizeof(voicer->command));//将串口的指令读到voicer->command中
  16.     return nread;
  18. }
  19. int voiceInit(struct InputCommander *voicer,char *ipAdress,char *port)
  20. {
  21.     int fd;
  22.     
  23.     if((fd = serialOpen(voicer->deviceName,9600))==-1){        //初始化树莓派串口
  24.             perror("serialOpen");
  25.             return -1;
  26.     }
  27.     voicer->fd = fd;    //打开串口文件成功，返回“文件描述符”到“语音控制”链表节点中
  28.     
  29.     return fd;
  30. }
  32. struct InputCommander voiceContrl = {  //语音控制链表节点
  33.     .commandName = "voice",
  34.     .deviceName = "/dev/ttyAMA0",    
  35.     .command = {'\0'},
  36.     .Init = voiceInit,
  37.     .getCommand = voiceGetCommand,
  38.     .log = {'\0'},
  39.     .next = NULL
  40. };
  42. struct InputCommander *addvoiceContrlToInputCommandLink(struct InputCommander *phead)//头插法将“语音控制”链表节点加入指令控制工厂链表函数
  43. {
  44.     if(phead == NULL){
  45.         return &voiceContrl;
  46.     }else{
  47.         voiceContrl.next = phead;
  48.         phead = &voiceContrl;
  49.         return phead;
  50.     }
  51. }

<11> socketContrl.c 服务器

  1. #include <wiringPi.h>
  2. #include <stdio.h>
  3. #include <wiringSerial.h>
  4. #include <unistd.h>
  5. #include <stdlib.h>
  6. #include <sys/types.h>    
  7. #include <sys/socket.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  10. #include <string.h>
  11. #include "InputCommand.h"
  13. int socketGetCommand(struct InputCommander *socketMes)
  14. {
  15.     int c_fd;
  16.     int n_read = 0;
  17.     
  18.     struct sockaddr_in c_addr;
  19.     memset(&c_addr,0,sizeof(struct sockaddr_in));
  20.     
  21.     int clen = sizeof(struct sockaddr_in);
  22.     c_fd = accept(socketMes->sfd,(struct sockaddr *)&c_addr,&clen);
  24.     n_read = read(c_fd,socketMes->command,sizeof(socketMes->command));
  25.     if(n_read == -1){
  26.            perror("read");
  27.     }else if(n_read>0){
  28.            printf("\nget: %d\n",n_read);
  29.     }else{
  30.            printf("client quit\n");
  31.     }
  32.     return n_read;
  33. }
  34. int socketInit(struct InputCommander *socketMes,char *ipAdress,char *port) //socket初始化
  35. {
  36.     int s_fd;
  38.     struct sockaddr_in s_addr;
  39.   
  40.     memset(&s_addr,0,sizeof(struct sockaddr_in));
  41.  
  42.     //1. socket创建
  43.     s_fd = socket(AF_INET, SOCK_STREAM, 0); 
  44.     if(s_fd == -1){
  45.            perror("socket");
  46.            exit(-1);
  47.      }
  49.     s_addr.sin_family = AF_INET;
  50.     s_addr.sin_port = htons(atoi(socketMes->port));
  51.     inet_aton(socketMes->ipAddress,&s_addr.sin_addr);
  53.     //2. bind
  54.     bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));
  56.     //3. listen
  57.     listen(s_fd,10);
  58.     printf("socker Server listening ......\n");    
  59.     socketMes->sfd = s_fd;
  60.     
  61.     return s_fd;  //套接字描述符返回到网络控制链表节点
  62. }
  64. struct InputCommander socketContrl = {
  65.     .commandName = "socketServer",
  66.     .command = {'\0'},
  67.     .port = "8080",
  68.     .ipAddress = "192.168.1.7",
  69.     .Init = socketInit,
  70.     .getCommand = socketGetCommand,
  71.     .log = {'\0'},
  72.     .next = NULL
  73. };
  75. struct InputCommander *addSocketContrlToInputCommandLink(struct InputCommander *phead)//头插法将设备节点加入设备工厂链表函数
  76. {
  77.     if(phead == NULL){
  78.         return &socketContrl;
  79.     }else{
  80.         socketContrl.next = phead;
  81.         phead = &socketContrl;
  82.     }
  83. }

三 项目演示

四 项目问题总结

通过这个项目，我对于简单工厂模式，Linux操作系统的文件，进程，线程，网络以及Linux字符设备开发都有了比较大的收获。整个项目的逻辑还算简单明了，但在实际开发调试过程中也会遇到一些问题，还好都逐一发现并解决。

问题一

语音控制不了灯

分析解决：串口测试语音能通过，串口命令测试灯也能通过，代码没有任何报错，逻辑也没有任何问题，唯独语音控制不了灯。我的语音逻辑是通过if来判断收到的控制指令从而实现对灯的控制。既然其他方面没有问题，那就是if判断不了收到的控制指令，所以把问题锁定于此。我将语音SDK重新生成配置，将判断条件修改成和语音SDK一致的内容后，继续先用串口测语音，再用串口测灯，最后实现语音控制灯，顺利实现。总结就是：语音配置的参数内容必须和判断条件的内容一致，才能准确判断并执行。之前做过语音控制刷抖音，因为太简单，中间没有任何报错，所以也就没有发现这个问题。笔记于此，当是提醒。

问题二

段错误

分析解决：做火灾检测报警这一块，因为是蜂鸣器和火焰传感器的结合，所以须将蜂鸣器整合在火焰线程中，编译后直接提示段错误，没有其他任何报错。我先检查了火焰，蜂鸣器，外接设备头文件以及火焰线程部分的代码，没有问题，至少肉眼可见的逻辑是没有问题的，然后在检查火焰传感器和蜂鸣器的IO口接线方面，也没有问题。捣鼓了很长时间无果，还好心理素质过硬，面向百度，依然无果。在最后，尝试用printf的方法将问题锁定在火焰线程中蜂鸣器的初始化部分。最后的最后才发现，在主函数int main()中设备控制工厂初始化没有添加蜂鸣器部分代码。

问题三

连接服务器超时

其实这不算什么问题，只是记录下来。通过手机客户端发送指令到服务器端实现控制灯，那么就需要连接服务器，如果出现连接超时或连接错误，首先排查是否能ping通网络，然后检查代码，ip，端口，如果都没问题，就可以考虑端口号是否被占用，修改下端口，多尝试连接几次。

问题四

线材和模块布局凌乱

前期没注意这个问题，只管接线并测试各模块的功能，到后期快完结时，走线杂乱已无力回天。后面的开发中值得注意！

五 项目相关知识点整理

该项目所涉及到的知识点，我将往期相关的博文都归纳在此：

C语言设计模式：实现简单工厂模式和工程创建

树莓派编程控制继电器及继电器组

通过Linux串口实现树莓派与电脑通信

树莓派+摄像头：mjpg-streamer实现监控功能的配置及调试

基于Linux串口实现语音控制刷抖音

C语言数据结构：链表的增删改查及动态创建

Linux网络编程：Socket服务器和客户端实现双方通信

Linux线程：创建(pthread_create)，等待(pthread_join)，退出(pthread_exit)

Orangepi Zero2 全志H616：蜂鸣器，链接库，shell脚本

标签： 语音识别 智能家居 人工智能
本文转载自: https://blog.csdn.net/m0_74985965/article/details/130407389
版权归原作者 AsheHero 所有， 如有侵权，请联系我们删除。
登录后发布评论

“基于ARM树莓派实现智能家居：语音识别控制，Socket网络控制，火灾报警检测，实时监控”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？