devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

linux项目—基于树莓派的智能家居系统_智能家居全屋智能系统linux困难

作者：weixin_40725706 | 2024-03-14 03:28:02

赞

踩

智能家居全屋智能系统linux困难

1、项目简介

        项目采用工厂设计模式。所有控制以及外设的设备都做成一个个对象（java思想），分别将命令控制的连成一个控制链表，外设设备做成一个外设设备的链表，这样做是为了方便以后功能模块的添加。其中为了能分别做好控制，我们采用多线程来实现。

 工厂模式详解：

 最通俗易懂的讲解工厂模式_晴夏。的博客-CSDN博客https://blog.csdn.net/weixin_43757333/article/details/126294625

实现功能：

        树莓派通过摄像头将图像上传到翔云平台进行人脸识别开锁。使用串口连接语音模块，实现语音对浴室灯、卧室灯、餐厅灯、锁、风扇等的控制。通过socket连接全志，将全志作为客户端，通过接收全志发来的指令控制家居，同时将温度、湿度、报警器、红外等检测状态通过socket发送给全志，实时掌握家居情况。

智能家居功能拆分图：

2、代码示例

2.1树莓派代码：

contrlDevices.h(外设头文件)

  1. #include <wiringPi.h>
  2. #include <stdio.h>
  3. #include <curl/curl.h>
  4.  
  5. typedef unsigned int bool;
  6.  
  7. struct Devices
  8. {
  9.     char deviceName[128]; //设备名
  10.     int status;           //读取到的数据
  11.     int pinNum;           //引脚号
  12.  
  13.     int (*open)(int pinNum);       //打开设备函数指针
  14.     int (*close)(int pinNum);      //关闭设备函数指针
  15.     int (*deviceInit)(int pinNum); //设备初始化函数指针
  16.  
  17.     int (*readStatus)(int pinNum);  //读取数据函数指针
  18.     int (*changStatus)(int status); //改变数据函数指针
  19.  
  20.     //摄像头相关的
  21.     void (*justDoOnce)();           
  22.     char *(*getFace)();             
  23.     char *(*getPicFromOCRBase64)(); 
  24.     size_t (*readData)();           
  25.  
  26.     CURL *curl;
  27.     char *key;
  28.     char *secret;
  29.     int typeId;
  30.     char *format;
  31.     bool (*cameraInit)(struct Devices *camera);
  32.     int yesNum;
  33.     int noNum;
  34.  
  35.     struct Devices *next;
  36. };
  37.  
  38.  
  39.

inputCommand.h(控制头文件)

  1. #include <wiringPi.h>
  2. #include <stdio.h>
  3.  
  4. struct InputCommander
  5. {
  6.     char commandName[128]; // socket名
  7.     char deviceName[128];  //串口名
  8.     char comand[32];       //控制命令
  9.  
  10.     int (*Init)(struct InputCommander *voicer, char *ipAdress, char *port); // socket初始化
  11.     int (*getCommand)(struct InputCommander *voicer);                       //读取数据
  12.  
  13.     char log[1024];
  14.     int fd;
  15.     char port[12];     //端口号
  16.     char ipAdress[32]; // IP地址
  17.     int sfd;
  18.     int cfd;
  19.  
  20.     struct InputCommander *next;
  21. };

start_web_video.sh(监控脚本)

  1. cd ../mjpg-streamer/mjpg-streamer-experimental/
  2.  
  3. ./mjpg_streamer -i "./input_raspicam.so" -o "./output_http.so -w ./www"

mainPro(主函数)

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <pthread.h>
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <arpa/inet.h>
  9. #include <netinet/in.h>
  10. #include <arpa/inet.h>
  11. #include <unistd.h>
  12. #include <sys/stat.h>
  13. #include <fcntl.h>
  14.  
  15. #include "contrlDevices.h"
  16. #include "inputCommand.h"
  17.  
  18. //控制添加到控制链表的函数声明
  19. struct InputCommander *addVoiceContrlToInputCommanderLink(struct InputCommander *phead);
  20. struct InputCommander *addsocketContrlToInputCommanderLink(struct InputCommander *phead);
  21.  
  22. //设备加到设备链表函数的声明
  23. struct Devices *addBathroomLightToDeviceLink(struct Devices *phead);
  24. struct Devices *addupStairLightToDeviceLink(struct Devices *phead);
  25. struct Devices *addlivingroomLightToDeviceLink(struct Devices *phead);
  26. struct Devices *addrestaurantLightToDeviceLink(struct Devices *phead);
  27. struct Devices *addDoorLockToDeviceLink(struct Devices *phead);
  28. struct Devices *addFanToDeviceLink(struct Devices *phead);
  29. struct Devices *addFireToDeviceLink(struct Devices *phead);
  30. struct Devices *addInfraredToDeviceLink(struct Devices *phead);
  31. struct Devices *addBuzzerToDeviceLink(struct Devices *phead);
  32. struct Devices *addcameraToDeviceLink(struct Devices *phead);
  33. struct Devices *addVibrateToDeviceLink(struct Devices *phead);
  34. #define HIGH_TIME 32
  35.  
  36.  
  37.  
  38. #define key 6 //拍照按键
  39.  
  40. pthread_t voiceThread;       //语音识别线程
  41. pthread_t socketThread;      //服务器线程
  42. pthread_t writeThread;       //通知线程：向客服端发送消息
  43. pthread_t fireThread;        //火灾检测线程
  44. pthread_t vibrateThread;       //震动检测线程
  45. pthread_t infraredThread;       //人体红外检测线程
  46. pthread_t remoteThread;      //遥控线程
  47. pthread_t keyThread;         //按键检测线程
  48. pthread_t cameraThread;      //人脸识别线程
  49. pthread_t monitoringThread;  //视频监控线程
  50. pthread_t clientWemosThread; //客服端线程
  51. pthread_t dht11Thread;       //温湿度线程
  52.  
  53. struct InputCommander *pCommandHead = NULL;
  54. struct Devices *pdeviceHead = NULL;
  55. struct InputCommander *socketHandler = NULL;
  56.  
  57. pthread_mutex_t mutex; //定义互斥量（锁）
  58.  
  59. unsigned long databuf;
  60.  
  61. int c_fd; //注意：涉及到多线程不要轻易的去传参
  62.  
  63. int beep = 0; //蜂鸣器标志位   0：未被使用   1：被火灾传感器使用    2：被震动传感器使用
  64. //摄像头相关，改变返回值命名，因为C语言中没有这样的返回值
  65. #define true 1
  66. #define false 0
  67. typedef unsigned int bool;
  68. char buf[1024] = {'\0'};
  69.  
  70. /* [0]:温度   [1]:湿度   [2]:火灾监控   [3]:震动监控   [4]:人体红外监控*/
  71. char Message[5][100] = {"温度未启用!", "湿度未启用!", "火灾未启用!", "震动未启用!", "红外未启用!"};
  72. int write_flag = 0; //标记位，标记通知线程是否打开     1：打开   0：关闭
  73.  
  74. int infrared_flag = 0; //红外检测标志位     1：打开   0：关闭
  75.  
  76. struct Devices *findDeviceByName(char *name, struct Devices *phead) //查询设备
  77. {
  78.     if (phead == NULL)
  79.     {
  80.         return NULL;
  81.     }
  82.  
  83.     while (phead != NULL)
  84.     {
  85.         // printf("phead:%s  name:%s\n", phead->deviceName, name);
  86.         if (strstr(phead->deviceName, name) != NULL)
  87.         {
  88.             return phead;
  89.         }
  90.         phead = phead->next;
  91.     }
  92.  
  93.     return NULL;
  94. }
  95.  
  96. struct InputCommander *findCommandByName(char *name, struct InputCommander *phead) //查询控制
  97. {
  98.     if (phead == NULL)
  99.     {
  100.         return NULL;
  101.     }
  102.     while (phead != NULL)
  103.     {
  104.         if (strcmp(phead->commandName, name) == 0)
  105.         {
  106.             return phead;
  107.         }
  108.         phead = phead->next;
  109.     }
  110.     return NULL;
  111. }
  112.  
  113. void *cameraThread_func(void *data) //起线程的函数有格式要求
  114. {
  115.     struct Devices *cameraTemp;
  116.  
  117.     cameraTemp = findDeviceByName("camera", pdeviceHead); 
  118.  
  119.     if (cameraTemp == NULL)
  120.     { 
  121.         printf("find camera error\n");
  122.         pthread_exit(NULL); 
  123.     }
  124.  
  125.     cameraTemp->justDoOnce(); //调用postUrl函数
  126. }
  127.  
  128. unsigned char readSensorData(void) //温湿度初始化
  129. {
  130.     char crc;
  131.     char i;
  132.  
  133.     pinMode(6, OUTPUT);   // 将模式设置为输出
  134.     digitalWrite(6, LOW); // 输出高电平
  135.     delay(25);
  136.     digitalWrite(6, HIGH); // 输出低电平
  137.     pinMode(6, INPUT);     // 将模式设置为输入
  138.     pullUpDnControl(6, PUD_UP);
  139.  
  140.     delayMicroseconds(27);
  141.     if (digitalRead(6) == 0) 
  142.     {
  143.         while (!digitalRead(6)); 
  144.  
  145.         for (i = 0; i < 32; i++)
  146.         {
  147.             while (digitalRead(6)); // 数据时钟启动
  148.             while (!digitalRead(6)); //数据开始
  149.             delayMicroseconds(HIGH_TIME);
  150.             databuf *= 2;
  151.             if (digitalRead(6) == 1) // 1
  152.             {
  153.                 databuf++;
  154.             }
  155.         }
  156.  
  157.         for (i = 0; i < 8; i++)
  158.         {
  159.             while (digitalRead(6)); // 数据时钟启动
  160.             while (!digitalRead(6)); // 数据开始
  161.             delayMicroseconds(HIGH_TIME);
  162.             crc *= 2;
  163.             if (digitalRead(6) == 1) // 1
  164.             {
  165.                 crc++;
  166.             }
  167.         }
  168.         return 1;
  169.     }
  170.     else
  171.     {
  172.         return 0;
  173.     }
  174. }
  175.  
  176. void *dht11_thread(void *datas) //温湿度线程
  177. {
  178.     int W = 0, w = 0;
  179.     int S = 0, s = 0;
  180.     // int count = 0;
  181.     int temp = 0;
  182.  
  183.     if (-1 == wiringPiSetup())
  184.     {
  185.         printf("获取wiringpi库失败!");
  186.     }
  187. 	printf("温湿度线程开启\n");
  188.     pinMode(6, OUTPUT);    
  189.     digitalWrite(6, HIGH); 
  190.  
  191.     printf("温湿度开始读取-------\n");
  192.     while (1)
  193.     {
  194.         pinMode(6, OUTPUT);    
  195.         digitalWrite(6, HIGH); 
  196.         delay(3000);
  197.  
  198.         if (readSensorData())
  199.         {
  200.  
  201.             W = (databuf >> 8) & 0xff;
  202.             w = databuf & 0xff;
  203.             S = (databuf >> 24) & 0xff;
  204.             s = (databuf >> 16) & 0xff;
  205.             printf("传感器数据读取正常!\n");
  206.             if (temp == 0)
  207.             {
  208.                 w++;
  209.                 s++;
  210.                 temp++;
  211.             }
  212.             else if (temp == 1)
  213.             {
  214.                 if (w >= 1)
  215.                 {
  216.                     w--;
  217.                 }
  218.                 if (s >= 1)
  219.                 {
  220.                     w--;
  221.                 }
  222.                 temp--;
  223.             }
  224.  
  225.             if ((W >= 15) && (W <= 35) && (S <= 95))
  226.             {
  227.                 memset(Message[0], 0, sizeof Message[0]); //清空数组
  228.                 memset(Message[1], 0, sizeof Message[1]);
  229.                 sprintf(Message[0], "%d.%d C", W, w); //温度
  230.                 sprintf(Message[1], "%d.%d", S, s);   //湿度
  231.             }
  232.  
  233.             databuf = 0;
  234.         }
  235.         else
  236.         {
  237.             printf("温湿度检测失败!\n");
  238.             databuf = 0;
  239.         }
  240.  
  241.     }
  242. }
  243.  
  244. void *fire_thread(void *datas) //火灾线程
  245. {
  246.     char msg[100];
  247.     int status;
  248.     struct Devices *fireDeviceTmp = NULL;
  249.     struct Devices *buzzerDeviceTmp = NULL;
  250.  
  251.     fireDeviceTmp = findDeviceByName("fire", pdeviceHead); //在设备工厂找到火灾模块
  252.     buzzerDeviceTmp = findDeviceByName("buzzser", pdeviceHead);
  253.  
  254.     fireDeviceTmp->deviceInit(fireDeviceTmp->pinNum); //火灾模块初始化
  255.     buzzerDeviceTmp->deviceInit(buzzerDeviceTmp->pinNum);
  256.     printf("火灾线程初始化成功\n");
  257.  
  258.     while (1)
  259.     {
  260.         delay(10);
  261.         status = fireDeviceTmp->readStatus(fireDeviceTmp->pinNum); //读取火灾模块实时数据
  262.         if (status == 0)
  263.         {
  264.             beep = 1;                                       //火灾传感器使用蜂鸣器
  265.             buzzerDeviceTmp->open(buzzerDeviceTmp->pinNum); //蜂鸣器报警
  266.             memset(Message[2], 0, sizeof Message[2]);       //清空数组
  267.             sprintf(Message[2], "警报:发生火灾!");       //更新火灾信息
  268.             delay(200);                                     //蜂鸣器报警延时
  269.         }
  270.         else if ((beep != 2) && (beep != 3)) //未被震动传感器和人体红外传感器使用
  271.         {
  272.             buzzerDeviceTmp->close(buzzerDeviceTmp->pinNum); //关闭蜂鸣器
  273.             memset(Message[2], 0, sizeof Message[2]);        //清空数组
  274.             sprintf(Message[2], "正常");                     //更新火灾信息
  275.             beep = 0;                                        //蜂鸣器未被使用
  276.         }
  277.     }
  278. }
  279.  
  280. void *vibrate_thread(void *datas) //震动线程
  281. {
  282.     char msg[100];
  283.     int status;
  284.     struct Devices *vibrateDeviceTmp = NULL;
  285.     struct Devices *buzzerDeviceTmp = NULL;
  286.  
  287.     vibrateDeviceTmp = findDeviceByName("vibrate", pdeviceHead); //在设备工厂找到火灾模块
  288.     buzzerDeviceTmp = findDeviceByName("buzzser", pdeviceHead);
  289.  
  290.     vibrateDeviceTmp->deviceInit(vibrateDeviceTmp->pinNum); //震动模块初始化
  291.     buzzerDeviceTmp->deviceInit(buzzerDeviceTmp->pinNum);
  292.     printf("震动线程初始化成功\n");
  293.     while (1)
  294.     {
  295.         delay(5);
  296.         status = vibrateDeviceTmp->readStatus(vibrateDeviceTmp->pinNum); //读取震动模块实时数据
  297.  
  298.         if (status == 0)
  299.         {
  300.             beep = 2; //震动传感器使用蜂鸣器
  301.             buzzerDeviceTmp->open(buzzerDeviceTmp->pinNum);
  302.             memset(Message[3], 0, sizeof Message[3]); //清空数组
  303.             sprintf(Message[3], "警报:发生震动!");
  304.  
  305.             delay(300);
  306.         }
  307.         else if ((beep != 1) && (beep != 3)) //蜂鸣器未被火焰传感器和人体红外传感器使用
  308.         {
  309.             memset(Message[3], 0, sizeof Message[3]); //清空数组
  310.             sprintf(Message[3], "正常");
  311.             buzzerDeviceTmp->close(buzzerDeviceTmp->pinNum);
  312.             beep = 0; //蜂鸣器未被使用
  313.         }
  314.     }
  315. }
  316.  
  317. void *infrared_thread(void *datas) // 人体红外检测线程
  318. {
  319.     char msg[100];
  320.     int status;
  321.     struct Devices *infraredDeviceTmp = NULL;
  322.     struct Devices *buzzerDeviceTmp = NULL;
  323.  
  324.     infraredDeviceTmp = findDeviceByName("infrared", pdeviceHead); //在设备工厂找到火灾模块
  325.     buzzerDeviceTmp = findDeviceByName("buzzser", pdeviceHead);
  326.  
  327.     infraredDeviceTmp->deviceInit(infraredDeviceTmp->pinNum); //红外模块初始化
  328.     buzzerDeviceTmp->deviceInit(buzzerDeviceTmp->pinNum);
  329.     printf("人体红外检测初始化\n");
  330.  
  331.     while (1)
  332.     {
  333.         delay(10);
  334.         status = infraredDeviceTmp->readStatus(infraredDeviceTmp->pinNum); //读取人体感应模块实时数据
  335.  
  336.         if (status == 1)
  337.         {
  338.             beep = 3;                                 //人体红外使用蜂鸣器
  339.             memset(Message[4], 0, sizeof Message[4]); //清空数组
  340.             sprintf(Message[4], "警报:有人进入!");
  341.             buzzerDeviceTmp->open(buzzerDeviceTmp->pinNum);
  342.             delay(200);
  343.             buzzerDeviceTmp->close(buzzerDeviceTmp->pinNum);
  344.             delay(100);
  345.         }
  346.         else if ((beep != 1) && (beep != 2)) //未被火焰传感器和震动传感器使用
  347.         {
  348.             memset(Message[4], 0, sizeof Message[4]); //清空数组
  349.             sprintf(Message[4], "正常");
  350.             buzzerDeviceTmp->close(buzzerDeviceTmp->pinNum);
  351.             beep = 0; //蜂鸣器未被使用
  352.         }
  353.     }
  354. }
  355.  
  356. void *monitoring_thread(void *datas) //视频监控线程
  357. {
  358.     system("./start_web_video.sh"); //执行脚本，打开视频监控
  359.     pthread_exit(NULL);             //退出线程
  360. }
  361.  
  362. void *voice_thread(void *arg) //语音线程
  363. {
  364.     int i = 0;
  365.     int nread;
  366.     struct InputCommander *voiceHandler = NULL;
  367.     struct Devices *deviceTmp = NULL;
  368.  
  369.     voiceHandler = findCommandByName("voice", pCommandHead); //在控制工厂找到语音模块
  370.  
  371.     if (voiceHandler == NULL)
  372.     {
  373.         printf("查找语音处理程序错误\n");
  374.         pthread_exit(NULL);
  375.     }
  376.     else
  377.     {
  378.         if (voiceHandler->Init(voiceHandler, NULL, NULL) < 0)
  379.         { //语音模块初始化
  380.             printf("语音初始化错误\n");
  381.             pthread_exit(NULL); //退出线程
  382.         }
  383.         else
  384.         {
  385.             printf("%s 初始化成功\n", voiceHandler->commandName);
  386.         } //语音初始化完成
  387.  
  388.         pthread_mutex_lock(&mutex); //加锁
  389.                                     //语音读取一级指令的时候，为了避免其它线程对于 紧接着读取二级指令的干扰
  390.         while (1)
  391.         {
  392.             memset(voiceHandler->comand, '\0', sizeof(voiceHandler->comand));
  393.  
  394.             nread = voiceHandler->getCommand(voiceHandler); //读取来自语音模块的串口数据
  395.             printf("get voice command:%s\n", voiceHandler->comand);
  396.             if (nread == 0)
  397.             {
  398.                 printf("没有来自语音的数据，请再说一遍\n");
  399.             }
  400.             else if (strstr(voiceHandler->comand, "kwsd") != NULL) //打开卧室灯命令
  401.             {
  402.                 printf("打开卧室灯光\n");
  403.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead); //查找卧室灯设备
  404.                 deviceTmp->deviceInit(deviceTmp->pinNum);          //卧室灯设备初始化
  405.                 deviceTmp->open(deviceTmp->pinNum);                //打开卧室灯
  406.             }
  407.             else if (strstr(voiceHandler->comand, "gwsd") != NULL)
  408.             {
  409.                 printf("关闭卧室灯光\n");
  410.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead);
  411.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  412.                 deviceTmp->close(deviceTmp->pinNum);
  413.             }
  414.             else if (strstr(voiceHandler->comand, "kysd") != NULL)
  415.             {
  416.                 printf("打开浴室灯光\n");
  417.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  418.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  419.                 deviceTmp->open(deviceTmp->pinNum);
  420.             }
  421.             else if (strstr(voiceHandler->comand, "gysd") != NULL)
  422.             {
  423.                 printf("关闭浴室灯光\n");
  424.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  425.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  426.                 deviceTmp->close(deviceTmp->pinNum);
  427.             }
  428.             else if (strstr(voiceHandler->comand, "kktd") != NULL)
  429.             {
  430.                 printf("打开客厅灯光\n");
  431.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  432.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  433.                 deviceTmp->open(deviceTmp->pinNum);
  434.             }
  435.             else if (strstr(voiceHandler->comand, "gktd") != NULL)
  436.             {
  437.                 printf("关闭客厅灯光\n");
  438.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  439.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  440.                 deviceTmp->close(deviceTmp->pinNum);
  441.             }
  442.             else if (strstr(voiceHandler->comand, "kctd") != NULL)
  443.             {
  444.                 printf("打开餐厅灯光\n");
  445.                 deviceTmp = findDeviceByName("restaurantLight", pdeviceHead);
  446.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  447.                 deviceTmp->open(deviceTmp->pinNum);
  448.             }
  449.             else if (strstr(voiceHandler->comand, "gctd") != NULL)
  450.             {
  451.                 printf("关闭餐厅灯光\n");
  452.                 deviceTmp = findDeviceByName("restaurantLight", pdeviceHead);
  453.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  454.                 deviceTmp->close(deviceTmp->pinNum);
  455.             }
  456.             else if (strstr(voiceHandler->comand, "kycd") != NULL) //开泳灯指令
  457.             {
  458.                 printf("打开泳池灯光\n");
  459.                 deviceTmp = findDeviceByName("yong", pdeviceHead);
  460.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  461.                 deviceTmp->open(deviceTmp->pinNum);
  462.             }
  463.             else if (strstr(voiceHandler->comand, "gqbd") != NULL) //关闭全部灯指令
  464.             {
  465.                 printf("关闭所有灯光\n");
  466.                 deviceTmp = findDeviceByName("chu", pdeviceHead);
  467.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  468.                 deviceTmp->close(deviceTmp->pinNum); //关闭餐厅灯
  469.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  470.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  471.                 deviceTmp->close(deviceTmp->pinNum); //关闭浴室灯
  472.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  473.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  474.                 deviceTmp->close(deviceTmp->pinNum); //关闭客厅灯
  475.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead);
  476.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  477.                 deviceTmp->close(deviceTmp->pinNum); //关闭卧室灯
  478.             }
  479.             else if (strstr(voiceHandler->comand, "kqbd") != NULL)
  480.             {
  481.                 printf("打开所有灯光\n");
  482.                 deviceTmp = findDeviceByName("restaurantLight", pdeviceHead);
  483.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  484.                 deviceTmp->open(deviceTmp->pinNum);
  485.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  486.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  487.                 deviceTmp->open(deviceTmp->pinNum);
  488.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  489.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  490.                 deviceTmp->open(deviceTmp->pinNum);
  491.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead);
  492.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  493.                 deviceTmp->open(deviceTmp->pinNum);
  494.             }
  495.             else if (strstr(voiceHandler->comand, "gycd") != NULL) //关泳池灯指令
  496.             {
  497.                 printf("关闭泳池灯光\n");
  498.                 deviceTmp = findDeviceByName("yong", pdeviceHead); //搜索泳池灯设备
  499.                 deviceTmp->deviceInit(deviceTmp->pinNum);          //泳池灯设备初始化
  500.                 deviceTmp->close(deviceTmp->pinNum);               //关泳池灯
  501.             }
  502.             else if (strstr(voiceHandler->comand, "kdfs") != NULL) //开电风扇指令
  503.             {
  504.                 printf("打开电风扇\n");
  505.                 deviceTmp = findDeviceByName("fan", pdeviceHead);
  506.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  507.                 deviceTmp->open(deviceTmp->pinNum);
  508.             }
  509.             else if (strstr(voiceHandler->comand, "gdfs") != NULL) //关电风扇指令
  510.             {
  511.                 printf("关闭电风扇\n");
  512.                 deviceTmp = findDeviceByName("fan", pdeviceHead);
  513.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  514.                 deviceTmp->close(deviceTmp->pinNum);
  515.             }
  516.             else if (strstr(voiceHandler->comand, "ks") != NULL) //开锁指令
  517.             {
  518.                 printf("打开门锁\n");
  519.                 deviceTmp = findDeviceByName("lock", pdeviceHead);
  520.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  521.                 deviceTmp->open(deviceTmp->pinNum);
  522.                 delay(3000);
  523.                 deviceTmp->close(deviceTmp->pinNum);
  524.             }
  525.  
  526.         }
  527.  
  528.         pthread_mutex_unlock(&mutex); //解锁
  529.     }
  530. }
  531.  
  532. void *write_thread(void *datas) //通知线程，向客服端发送消息
  533. {
  534.     while (1)
  535.     {
  536.         delay(500);
  537.         write(c_fd, Message, 500);
  538.     }
  539. }
  540.  
  541. void *read_thread(void *datas) //通过socket读取客户端发来的数据
  542. {
  543.  
  544.     int n_read;
  545.     struct Devices *deviceTmp = NULL;
  546.  
  547.     while (1)
  548.     {
  549.         memset(socketHandler->comand, '\0', sizeof(socketHandler->comand));
  550.  
  551.         n_read = read(c_fd, socketHandler->comand, sizeof(socketHandler->comand)); //读取客户端发来的数据
  552.         if (n_read == -1)
  553.         {
  554.             perror("read_thread");
  555.         }
  556.         else if (n_read > 0)
  557.         {
  558.             printf("客户端指令:%s\n", socketHandler->comand);
  559.             //处理客户端读到的命令
  560.             if (strstr(socketHandler->comand, "kws") != NULL) //开卧室灯
  561.             {
  562.                 printf("开卧室灯\n");
  563.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead); //查找卧室灯设备
  564.                 deviceTmp->deviceInit(deviceTmp->pinNum);          //卧室灯设备初始化
  565.                 deviceTmp->open(deviceTmp->pinNum);                //打开卧室灯
  566.             }
  567.             else if (strstr(socketHandler->comand, "gws") != NULL) //关卧室灯
  568.             {
  569.                 printf("关卧室灯\n");
  570.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead);
  571.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  572.                 deviceTmp->close(deviceTmp->pinNum);
  573.             }
  574.             else if (strstr(socketHandler->comand, "kys") != NULL) //开浴室灯
  575.             {
  576.                 printf("开浴室灯\n");
  577.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  578.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  579.                 deviceTmp->open(deviceTmp->pinNum);
  580.             }
  581.             else if (strstr(socketHandler->comand, "gys") != NULL) //关浴室灯
  582.             {
  583.                 printf("关浴室灯\n");
  584.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  585.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  586.                 deviceTmp->close(deviceTmp->pinNum);
  587.             }
  588.             else if (strstr(socketHandler->comand, "kkt") != NULL) //开客厅灯
  589.             {
  590.                 printf("开客厅灯\n");
  591.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  592.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  593.                 deviceTmp->open(deviceTmp->pinNum);
  594.             }
  595.             else if (strstr(socketHandler->comand, "gkt") != NULL) //关客厅灯
  596.             {
  597.                 printf("关客厅灯\n");
  598.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  599.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  600.                 deviceTmp->close(deviceTmp->pinNum);
  601.             }
  602.             else if (strstr(socketHandler->comand, "kct") != NULL) //开餐厅灯
  603.             {
  604.                 printf("开餐厅灯\n");
  605.                 deviceTmp = findDeviceByName("chu", pdeviceHead);
  606.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  607.                 deviceTmp->open(deviceTmp->pinNum);
  608.             }
  609.             else if (strstr(socketHandler->comand, "gct") != NULL) //关餐厅灯
  610.             {
  611.                 printf("关餐厅灯\n");
  612.                 deviceTmp = findDeviceByName("restaurantLight", pdeviceHead);
  613.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  614.                 deviceTmp->close(deviceTmp->pinNum);
  615.             }
  616.  
  617.             else if (strstr(socketHandler->comand, "kfs") != NULL) //开风扇
  618.             {
  619.                 printf("开电风扇\n");
  620.                 deviceTmp = findDeviceByName("fan", pdeviceHead);
  621.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  622.                 deviceTmp->open(deviceTmp->pinNum);
  623.             }
  624.             else if (strstr(socketHandler->comand, "gfs") != NULL) //关风扇
  625.             {
  626.                 printf("关电风扇\n");
  627.                 deviceTmp = findDeviceByName("fan", pdeviceHead);
  628.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  629.                 deviceTmp->close(deviceTmp->pinNum);
  630.             }
  631.             else if (strstr(socketHandler->comand, "kqb") != NULL) //开室内全部灯
  632.             {
  633.                 printf("开室内全部灯\n");
  634.                 deviceTmp = findDeviceByName("restaurantLight", pdeviceHead);
  635.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  636.                 deviceTmp->open(deviceTmp->pinNum);
  637.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  638.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  639.                 deviceTmp->open(deviceTmp->pinNum);
  640.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  641.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  642.                 deviceTmp->open(deviceTmp->pinNum);
  643.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead);
  644.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  645.                 deviceTmp->open(deviceTmp->pinNum);
  646.             }
  647.             else if (strstr(socketHandler->comand, "gqb") != NULL) //关室内全部灯
  648.             {
  649.                 printf("关室内全部灯\n");
  650.                 deviceTmp = findDeviceByName("restaurantLight", pdeviceHead);
  651.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  652.                 deviceTmp->close(deviceTmp->pinNum);
  653.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  654.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  655.                 deviceTmp->close(deviceTmp->pinNum);
  656.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  657.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  658.                 deviceTmp->close(deviceTmp->pinNum);
  659.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead);
  660.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  661.                 deviceTmp->close(deviceTmp->pinNum);
  662.             }
  663.             else if (strstr(socketHandler->comand, "ks") != NULL) //开锁
  664.             {
  665.                 printf("开锁\n");
  666.                 deviceTmp = findDeviceByName("lock", pdeviceHead);
  667.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  668.                 deviceTmp->open(deviceTmp->pinNum);
  669.             }
  670.             else if (strstr(socketHandler->comand, "gs") != NULL) //关锁
  671.             {
  672.                 deviceTmp = findDeviceByName("lock", pdeviceHead);
  673.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  674.                 deviceTmp->close(deviceTmp->pinNum);
  675.             }
  676.             else if (strstr(socketHandler->comand, "kjk") != NULL) //开监控
  677.             {
  678.                 printf("打开监控\n");
  679.                 pthread_create(&monitoringThread, NULL, monitoring_thread, NULL); //启动视频监控线程
  680.             }
  681.             else if (strstr(socketHandler->comand, "gjk") != NULL) //关监控
  682.             {
  683.                 printf("关闭监控\n");
  684.                 // pthread_cancel(monitoringThread);
  685.                 system("killall -TERM mjpg_streamer"); //关闭摄像头监控功能
  686.             }
  687.             else if (strstr(socketHandler->comand, "khw") != NULL) //打开人体红外检测
  688.             {
  689.                 printf("启动人体红外检测线程\n");
  690.                 beep = 3; //人体红外使用蜂鸣器
  691.                 deviceTmp = findDeviceByName("buzzser", pdeviceHead);
  692.                 deviceTmp->open(deviceTmp->pinNum);
  693.                 delay(700);
  694.                 deviceTmp->close(deviceTmp->pinNum);
  695.                 if (infrared_flag == 0)
  696.                 {
  697.                     pthread_create(&infraredThread, NULL, infrared_thread, NULL);
  698.                     infrared_flag = 1;
  699.                 }
  700.             }
  701.             else if (strstr(socketHandler->comand, "ghw") != NULL) //关闭人体红外检测
  702.             {
  703.                 printf("关闭人体红外检测\n");
  704.                 memset(Message[4], 0, sizeof Message[4]); //清空数组
  705.                 sprintf(Message[4], "未启用！");
  706.  
  707.                 if (infrared_flag == 1)
  708.                 {
  709.                     pthread_cancel(infraredThread); //停止人体红外线程
  710.                     infrared_flag = 0;
  711.                 }
  712.  
  713.                 beep = 3; //人体红外使用蜂鸣器
  714.                 deviceTmp = findDeviceByName("buzzser", pdeviceHead);
  715.                 deviceTmp->open(deviceTmp->pinNum);
  716.                 delay(400);
  717.                 deviceTmp->close(deviceTmp->pinNum);
  718.                 delay(300);
  719.                 deviceTmp->open(deviceTmp->pinNum);
  720.                 delay(400);
  721.                 deviceTmp->close(deviceTmp->pinNum);
  722.             }
  723.             else if (strstr(socketHandler->comand, "gjms") != NULL) //归家模式
  724.             {
  725.                 printf("开室内全部灯\n");
  726.                 deviceTmp = findDeviceByName("restaurantLight", pdeviceHead);
  727.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  728.                 deviceTmp->open(deviceTmp->pinNum);
  729.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  730.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  731.                 deviceTmp->open(deviceTmp->pinNum);
  732.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  733.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  734.                 deviceTmp->open(deviceTmp->pinNum);
  735.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead);
  736.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  737.                 deviceTmp->open(deviceTmp->pinNum);
  738.  
  739.                 printf("关闭人体红外检测\n");
  740.                 memset(Message[4], 0, sizeof Message[4]); //清空数组
  741.                 sprintf(Message[4], "未启用！");
  742.  
  743.                 if (infrared_flag == 1)
  744.                 {
  745.                     pthread_cancel(infraredThread); //停止人体红外线程
  746.                     infrared_flag = 0;
  747.                 }
  748.  
  749.                 beep = 3; //人体红外使用蜂鸣器
  750.                 deviceTmp = findDeviceByName("buzzser", pdeviceHead);
  751.                 deviceTmp->open(deviceTmp->pinNum);
  752.                 delay(400);
  753.                 deviceTmp->close(deviceTmp->pinNum);
  754.                 delay(300);
  755.                 deviceTmp->open(deviceTmp->pinNum);
  756.                 delay(400);
  757.                 deviceTmp->close(deviceTmp->pinNum);
  758.                 beep = 0;
  759.             }
  760.             else if (strstr(socketHandler->comand, "ljms") != NULL) //离家模式
  761.             {
  762.                 printf("关全部灯\n");
  763.                 deviceTmp = findDeviceByName("restaurantLight", pdeviceHead);
  764.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  765.                 deviceTmp->close(deviceTmp->pinNum);
  766.                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  767.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  768.                 deviceTmp->close(deviceTmp->pinNum);
  769.                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  770.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  771.                 deviceTmp->close(deviceTmp->pinNum);
  772.                 deviceTmp = findDeviceByName("livingroomLight", pdeviceHead);
  773.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  774.                 deviceTmp->close(deviceTmp->pinNum);
  775.  
  776.                 printf("关电风扇\n");
  777.                 deviceTmp = findDeviceByName("fan", pdeviceHead);
  778.                 deviceTmp->deviceInit(deviceTmp->pinNum);
  779.                 deviceTmp->close(deviceTmp->pinNum);
  780.  
  781.                 printf("启动人体红外检测线程\n");
  782.                 beep = 3; //人体红外使用蜂鸣器
  783.                 deviceTmp = findDeviceByName("buzzser", pdeviceHead);
  784.                 deviceTmp->open(deviceTmp->pinNum);
  785.                 delay(700);
  786.                 deviceTmp->close(deviceTmp->pinNum);
  787.                 beep = 0;
  788.                 if (infrared_flag == 0)
  789.                 {
  790.                     pthread_create(&infraredThread, NULL, infrared_thread, NULL);
  791.                     infrared_flag = 1;
  792.                 }
  793.             }
  794.             else if (strstr(socketHandler->comand, "face") != NULL)
  795.             {
  796.                 //启动人脸识别线程
  797.                 printf("进行人脸识别开锁\n");
  798.                 pthread_create(&cameraThread, NULL, cameraThread_func, NULL);
  799.             }
  800.         }
  801.         else
  802.         {
  803.             printf("客户端退出\n");
  804.             pthread_cancel(writeThread); //停止通知线程
  805.             write_flag = 0;              //通知线程标志位置0，通知线程关闭
  806.             pthread_exit(NULL);          //退出本线程
  807.         }
  808.     }
  809. }
  810.  
  811. void *socket_thread(void *datas) //开启socket服务端，并将socket服务端初始化
  812. {
  813.  
  814.     int n_read = 0;
  815.     pthread_t readPthread;
  816.  
  817.     struct sockaddr_in c_addr;
  818.     memset(&c_addr, 0, sizeof(struct sockaddr_in));
  819.     int clen = sizeof(struct sockaddr_in);
  820.  
  821.     socketHandler = findCommandByName("socketServer", pCommandHead); //在控制工厂找到socket
  822.     if (socketHandler == NULL)
  823.     {
  824.         printf("查找套接字处理程序错误\n");
  825.         pthread_exit(NULL);
  826.     }
  827.     else
  828.     {
  829.         printf("%s 初始化成功\n", socketHandler->commandName);
  830.     }
  831.  
  832.     socketHandler->Init(socketHandler, NULL, NULL); //初始化socket
  833.  
  834.     while (1)
  835.     {
  836.  
  837.         c_fd = accept(socketHandler->sfd, (struct sockaddr *)&c_addr, &clen);
  838.         printf("c_fd = %d\n", c_fd);
  839.         if (write_flag == 0) //通知线程处于关闭状态
  840.         {
  841.             write_flag = 1;
  842.             pthread_create(&writeThread, NULL, write_thread, NULL); //打开通知线程
  843.         }
  844.         pthread_create(&readPthread, NULL, read_thread, NULL);
  845.     }
  846. }
  847.  
  848. //检测按键状态
  849. void *key_thread()
  850. {
  851.     int val;
  852.     while (1)
  853.     {
  854.         val = digitalRead(key);//获取key引脚状态给val
  855.         if (val == 0) //防止重复检测
  856.         {
  857.             delay(500);
  858.             val = digitalRead(key);
  859.             if (val == 1) //按键按下，启动人脸识别线程
  860.             {
  861.                 pthread_create(&cameraThread, NULL, cameraThread_func, NULL);
  862.             }
  863.         }
  864.     }
  865. }
  866.  
  867. int main()
  868. {
  869.     char name[32] = {'\0'};
  870.  
  871.     //树莓派库初始化
  872.     if (wiringPiSetup() == -1)
  873.     {
  874.         printf("硬件接口初始化失败\n");
  875.         return -1;
  876.     }
  877.  
  878.     pthread_mutex_init(&mutex, NULL); //初始化互斥量（锁）
  879.  
  880.     // 1、指令工厂初始化
  881.     pCommandHead = addVoiceContrlToInputCommanderLink(pCommandHead);  //语音识别初始化
  882.     pCommandHead = addsocketContrlToInputCommanderLink(pCommandHead); //服务器初始化
  883.  
  884.     // 2、设备控制工程初始化
  885.     pdeviceHead = addBathroomLightToDeviceLink(pdeviceHead);   //浴室灯光初始化
  886.     pdeviceHead = addupStairLightToDeviceLink(pdeviceHead);    //卧室灯光初始化
  887.     pdeviceHead = addlivingroomLightToDeviceLink(pdeviceHead); //客厅灯光初始化
  888.     pdeviceHead = addrestaurantLightToDeviceLink(pdeviceHead); //餐厅灯光初始化
  889.     pdeviceHead = addDoorLockToDeviceLink(pdeviceHead);        //门锁初始化
  890.     pdeviceHead = addFanToDeviceLink(pdeviceHead);             //电风扇初始化
  891.     pdeviceHead = addBuzzerToDeviceLink(pdeviceHead);          //蜂鸣器初始化
  892.     pdeviceHead = addFireToDeviceLink(pdeviceHead);            //火焰传感器初始化
  893.     pdeviceHead = addVibrateToDeviceLink(pdeviceHead);           //震动传感器初始化
  894.     pdeviceHead = addcameraToDeviceLink(pdeviceHead);          //摄像头模块初始化
  895.     pdeviceHead = addInfraredToDeviceLink(pdeviceHead);           //人体感应传感器初始化
  896.  
  897.     pthread_create(&voiceThread, NULL, voice_thread, NULL);   // 语音线程启动
  898.     pthread_create(&socketThread, NULL, socket_thread, NULL); // socket服务器线程启动
  899.     pthread_create(&fireThread, NULL, fire_thread, NULL);     //火灾报警线程启动
  900.     pthread_create(&vibrateThread, NULL, vibrate_thread, NULL);   //震动报警线程启动
  901.     pthread_create(&keyThread, NULL, key_thread, NULL);       //按键检测线程启动
  902.     pthread_create(&dht11Thread, NULL, dht11_thread, NULL);   // 温湿度检测线程启动
  903.  
  904.     pthread_join(voiceThread, NULL);
  905.     pthread_join(socketThread, NULL);
  906.     pthread_join(fireThread, NULL);
  907.     pthread_join(vibrateThread, NULL);
  908.     pthread_join(infraredThread, NULL);
  909.     pthread_join(keyThread, NULL);
  910.     pthread_join(cameraThread, NULL);
  911.     pthread_join(monitoringThread, NULL);
  912.     pthread_join(clientWemosThread, NULL);
  913.     pthread_join(dht11Thread, NULL);
  914.     pthread_join(writeThread, NULL);
  915.  
  916.     pthread_mutex_destroy(&mutex); //销毁互斥量
  917.  
  918.     return 0;
  919. }

bathroomLight.c(浴室灯)

  1. #include "contrlDevices.h"
  2.  
  3. int bathroomLightOpen(int pinNum)
  4. {
  5.     digitalWrite(pinNum, HIGH);
  6. }
  7.  
  8. int bathroomLightClose(int pinNum)
  9. {
  10.     digitalWrite(pinNum, LOW);
  11. }
  12.  
  13. int bathroomLightCloseInit(int pinNum)
  14. {
  15.     pinMode(pinNum, OUTPUT);
  16.     digitalWrite(pinNum, LOW);
  17.   //  printf("浴室灯初始化成功\n");
  18. }
  19.  
  20. int bathroomLightCloseStatus(int status)
  21. {
  22. }
  23.  
  24. struct Devices bathroomLight = {
  25.     .deviceName = "bathroomLight",
  26.     .pinNum = 24,
  27.     .open = bathroomLightOpen,
  28.     .close = bathroomLightClose,
  29.     .deviceInit = bathroomLightCloseInit,
  30.     .changStatus = bathroomLightCloseStatus};
  31.  
  32. struct Devices *addBathroomLightToDeviceLink(struct Devices *phead)
  33. {
  34.     if (phead == NULL)
  35.     {
  36.         return &bathroomLight;
  37.     }
  38.     else
  39.     {
  40.         bathroomLight.next = phead;
  41.         phead = &bathroomLight;
  42.     }
  43.     return phead;
  44. }

buzzer.c(蜂鸣器)

  1. #include "contrlDevices.h"
  2.  
  3. int buzzerOpen(int pinNum)
  4. {
  5.     digitalWrite(pinNum, LOW);
  6. }
  7.  
  8. int buzzerClose(int pinNum)
  9. {
  10.     digitalWrite(pinNum, HIGH);
  11. }
  12.  
  13. int buzzerInit(int pinNum)
  14. {
  15.     pinMode(pinNum, OUTPUT);
  16.     digitalWrite(pinNum, HIGH);
  17. }
  18.  
  19. struct Devices buzzer = {
  20.     .deviceName = "buzzser",
  21.     .pinNum = 7,
  22.     .open = buzzerOpen,
  23.     .close = buzzerClose,
  24.     .deviceInit = buzzerInit};
  25.  
  26. struct Devices *addBuzzerToDeviceLink(struct Devices *phead)
  27. {
  28.     if (phead == NULL)
  29.     {
  30.         return &buzzer;
  31.     }
  32.     else
  33.     {
  34.         buzzer.next = phead;
  35.         phead = &buzzer;
  36.     }
  37.     return phead;
  38. }

camera.c(监控)

  1. #include "contrlDevices.h"
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6. #include <curl/curl.h>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <fcntl.h>
  10. #include <sys/types.h>
  11. #include <unistd.h>
  12. #define door_lock 29 //门锁
  13. void postUrl();
  14. size_t readData1(void *ptr, size_t size, size_t nmemb, void *stream);
  15. char *getFace1();
  16. char *getPicFromOCRBase641(char *Filepath);
  17. struct Devices *addcameraToDeviceLink(struct Devices *phead);
  18.  
  19. char ocrRetBuf[1024] = {'\0'}; //全局变量，用来接收对比两张照片结果的数据
  20.  
  21. size_t readData1(void *ptr, size_t size, size_t nmemb, void *stream)
  22. //回调函数，把从后台的数据拷贝给ocrRetBuf
  23. {
  24.     strncpy(ocrRetBuf, ptr, 1024);
  25. }
  26.  
  27. char *getFace1()
  28. {
  29.     printf("拍照中...\n");
  30.     system("raspistill -q 5 -t 1 -o image.jpg"); //-q 是图片质量，在0~100之间，我们调成5，压缩图片质量,生成的照片名字为imag.jpg
  31.                                                  //-t 是拍照延时，设定1s后拍照
  32.  
  33.     while (access("./image.jpg", F_OK) != 0);    //判断是否拍照完毕
  34.  
  35.     printf("拍照完成\n");
  36.  
  37.     char *base64BufFaceRec = getPicFromOCRBase641("./image.jpg");
  38.     // system("rm image.jpg");
  39.  
  40.     return base64BufFaceRec; //返回刚才拍照的base64
  41. }
  42.  
  43. char *getPicFromOCRBase641(char *Filepath)
  44. {
  45.     int fd;
  46.     int filelen;
  47.     char cmd[128] = {'\0'};
  48.  
  49.     sprintf(cmd, "base64 %s > tmpFile", Filepath);//拼凑字符 执行base64+照片名 结果存放在tmpFile
  50.     system(cmd);                                  //执行
  51.     fd = open("./tmpFile", O_RDWR);               
  52.     filelen = lseek(fd, 0, SEEK_END);             //计算指针偏移量 就是数据大小
  53.     lseek(fd, 0, SEEK_SET);                       //移动光标
  54.     char *bufpic = (char *)malloc(filelen + 2);
  55.     memset(bufpic, '\0', filelen + 2);
  56.     read(fd, bufpic, filelen + 128);              //读到bufpic中
  57.     system("rm -rf tmpFile"); 
  58.     close(fd);
  59.  
  60.     return bufpic;                                //返回读的内容
  61. }
  62.  
  63. void postUrl()
  64. {
  65.     CURL *curl;
  66.     CURLcode res;
  67.  
  68.     struct Devices *deviceTmp = NULL;
  69.  
  70.     //分开定义，然后字符串拼接
  71.     char *key = "*******************";                  
  72.     char *secret = "********************"; 
  73.     int typeId = 21;
  74.     char *format = "xml";
  75.  
  76.     char *base64BufPic1 = getFace1();                      //摄像头拍的  
  77.     char *base64BufPic2 = getPicFromOCRBase641("nb.jpg");//房主照片
  78.  
  79.     int len = strlen(key) + strlen(secret) + strlen(base64BufPic1) + strlen(base64BufPic2) + 128; //分配空间不够会导致栈溢出
  80.     char *postString = (char *)malloc(len);
  81.     memset(postString, '\0', len); //因为postString是一个指针，不能用sizeof来计算其指向的大小
  82.  
  83.     sprintf(postString, "img1=%s&img2=%s&key=%s&secret=%s&typeId=%d&format=%s", base64BufPic1, base64BufPic2, key, secret, typeId, format); //根据平台的传参格式编写
  84.  
  85.     curl = curl_easy_init();
  86.  
  87.     if (curl)
  88.     {
  89.         curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postString);                   //指定post内容，传入参数
  90.         curl_easy_setopt(curl, CURLOPT_URL, "https://netocr.com/api/faceliu.do"); // 指定url
  91.         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, readData1);                 //回调函数readDate读取返回值
  92.         res = curl_easy_perform(curl);                                            //类似于状态码
  93.         printf("OK:%d\n", res);
  94.  
  95.         if (strstr(ocrRetBuf, "是") != NULL)
  96.         { //判断翔云后台返回的字符串中有没有“是”
  97.             printf("是同一个人\n");
  98.             digitalWrite(door_lock, LOW);  //打开门锁
  99.             delay(3000);                   //等待3s
  100.             digitalWrite(door_lock, HIGH); //关闭门锁
  101.         }
  102.         else
  103.         {
  104.             printf("不是同一个人\n");
  105.         }
  106.         curl_easy_cleanup(curl);
  107.     }
  108. }
  109.  
  110. struct Devices camera = {
  111.  
  112.     .deviceName = "camera",
  113.     .justDoOnce = postUrl,
  114.     .getFace = getFace1,
  115.     .getPicFromOCRBase64 = getPicFromOCRBase641,
  116.     .readData = readData1
  117.  
  118. };
  119.  
  120. struct Devices *addcameraToDeviceLink(struct Devices *phead)
  121. {
  122.     if (phead == NULL)
  123.     {
  124.         return &camera;
  125.     }
  126.     else
  127.     {
  128.         camera.next = phead;
  129.         phead = &camera;
  130.     }
  131. }

doorLock.c(门锁)

  1. #include "contrlDevices.h"
  2.  
  3. int doorLockOpen(int pinNum)
  4. {
  5.     //digitalWrite(pinNum, LOW);
  6. 	for(int i=0;i<20;i++)
  7. 	{	
  8. 		digitalWrite(pinNum,HIGH);
  9. 		delay(2);
  10. 		digitalWrite(pinNum,LOW);
  11. 		delay(18);
  12. 	}
  13. 	pinMode(pinNum,INPUT);
  14. 	pinMode(pinNum,OUTPUT);
  15. }
  16.  
  17. int doorLockClose(int pinNum)
  18. {
  19.     digitalWrite(pinNum, HIGH);
  20. }
  21.  
  22. int doorLockCloseInit(int pinNum)
  23. {
  24.     pinMode(pinNum, OUTPUT);
  25.     digitalWrite(pinNum, HIGH);
  26. }
  27.  
  28. int doorLockCloseStatus(int status)
  29. {
  30. }
  31. //门锁
  32. struct Devices doorLock = {
  33.     .deviceName = "lock",
  34.     .pinNum = 28,
  35.     .open = doorLockOpen,
  36.     .close = doorLockClose,
  37.     .deviceInit = doorLockCloseInit,
  38.     .changStatus = doorLockCloseStatus};
  39.  
  40. struct Devices *addDoorLockToDeviceLink(struct Devices *phead)
  41. {
  42.     if (phead == NULL)
  43.     {
  44.         return &doorLock;
  45.     }
  46.     else
  47.     {
  48.         doorLock.next = phead;
  49.         phead = &doorLock;
  50.     }
  51.     return phead;
  52. }

fan.c(风扇)

  1. #include "contrlDevices.h"
  2.  
  3. int fanOpen(int pinNum)
  4. {
  5.     pinMode(pinNum, OUTPUT);
  6. }
  7.  
  8. int fanClose(int pinNum)
  9. {
  10.     pinMode(pinNum, INPUT);
  11. }
  12.  
  13. int fanCloseInit(int pinNum) //风扇有问题 设为输出就转 输入就停 高低电平影响不了
  14. {
  15.     pinMode(pinNum, INPUT);
  16.     printf("电风扇初始化成功\n");
  17. }
  18.  
  19. int fanCloseStatus(int status)
  20. {
  21. }
  22.  
  23. struct Devices fan = {
  24.     .deviceName = "fan",
  25.     .pinNum = 26,
  26.     .open = fanOpen,
  27.     .close = fanClose,
  28.     .deviceInit = fanCloseInit,
  29.     .changStatus = fanCloseStatus
  30. };
  31.  
  32. struct Devices *addFanToDeviceLink(struct Devices *phead)
  33. {
  34.     if (phead == NULL)
  35.     {
  36.         return &fan;
  37.     }
  38.     else
  39.     {
  40.         fan.next = phead;
  41.         phead = &fan;
  42.     }
  43.     return phead;
  44. }

fire.c(火焰传感)

  1. #include "contrlDevices.h"
  2.  
  3. int fireInit(int pinNum)
  4. {
  5.     pinMode(pinNum, INPUT);
  6.     digitalWrite(pinNum, HIGH);
  7. }
  8.  
  9. int readFireStatus(int pinNum)
  10. {
  11.     return digitalRead(pinNum);
  12. }
  13.  
  14. struct Devices fire = {
  15.     .deviceName = "fire",
  16.     .pinNum = 25,
  17.     .deviceInit = fireInit,
  18.     .readStatus = readFireStatus
  19. };
  20.  
  21. struct Devices *addFireToDeviceLink(struct Devices *phead)
  22. {
  23.     if (phead == NULL)
  24.     {
  25.         return &fire;
  26.     }
  27.     else
  28.     {
  29.         fire.next = phead;
  30.         phead = &fire;
  31.     }
  32.  
  33.     return phead;
  34. }

infrared.c(人体红外)

  1. #include "contrlDevices.h"
  2.  
  3. int infraredInit(int pinNum)
  4. {
  5.     pinMode(pinNum, INPUT);
  6.     digitalWrite(pinNum, HIGH);
  7.    // printf("人体感应传感器初始化成功\n");
  8. }
  9.  
  10. int readinfraredStatus(int pinNum)
  11. {
  12.     return digitalRead(pinNum);
  13. }
  14.  
  15. struct Devices infrared = {
  16.     .deviceName = "infrared",
  17.     .pinNum = 5,
  18.     .deviceInit = infraredInit,
  19.     .readStatus = readinfraredStatus};
  20.  
  21. struct Devices *addInfraredToDeviceLink(struct Devices *phead)
  22. {
  23.     if (phead == NULL)
  24.     {
  25.         return &infrared;
  26.     }
  27.     else
  28.     {
  29.         infrared.next = phead;
  30.         phead = &infrared;
  31.     }
  32.     return phead;
  33. }
  34.  
  35.

livingroomLight.c(卧室灯)

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

restaurantLight.c(餐厅灯)

  1. #include "contrlDevices.h"
  2.  
  3. int restaurantLightOpen(int pinNum)
  4. {
  5.     digitalWrite(pinNum, HIGH);
  6. }
  7.  
  8. int restaurantLightClose(int pinNum)
  9. {
  10.     digitalWrite(pinNum, LOW);
  11. }
  12.  
  13. int restaurantLightCloseInit(int pinNum)
  14. {
  15.     pinMode(pinNum, OUTPUT);
  16.     digitalWrite(pinNum, LOW);
  17. }
  18.  
  19. int restaurantLightCloseStatus(int status)
  20. {
  21. }
  22.  
  23. struct Devices restaurantLight = {
  24.     .deviceName = "restaurantLight",
  25.     .pinNum = 23,
  26.     .open = restaurantLightOpen,
  27.     .close = restaurantLightClose,
  28.     .deviceInit = restaurantLightCloseInit,
  29.     .changStatus = restaurantLightCloseStatus};
  30.  
  31. struct Devices *addrestaurantLightToDeviceLink(struct Devices *phead)
  32. {
  33.     if (phead == NULL)
  34.     {
  35.         return &restaurantLight;
  36.     }
  37.     else
  38.     {
  39.         restaurantLight.next = phead;
  40.         phead = &restaurantLight;
  41.     }
  42.     return phead;
  43. }
  44.  
  45.

socketContrl.c(socket控制)

  1. #include <wiringPi.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <wiringSerial.h>
  5. #include <unistd.h>
  6.  
  7. #include <sys/types.h>
  8. #include <sys/socket.h>
  9. #include <arpa/inet.h>
  10. #include <netinet/in.h>
  11. #include <arpa/inet.h>
  12. #include <string.h>
  13. #include <sys/types.h>
  14. #include <sys/stat.h>
  15. #include <fcntl.h>
  16.  
  17. #include "inputCommand.h"
  18.  
  19. int socketgetCommand(struct InputCommander *socketMes)
  20. {
  21.     int c_fd;
  22.     int n_read;
  23.  
  24.     struct sockaddr_in c_addr;
  25.     memset(&c_addr, 0, sizeof(struct sockaddr_in));
  26.     int clen = sizeof(struct sockaddr_in);
  27.  
  28.     // 4.accept
  29.     c_fd = accept(socketMes->sfd, (struct sockaddr *)&c_addr, &clen);
  30.  
  31.     n_read = read(c_fd, socketMes->comand, sizeof(socketMes->comand));
  32.     if (n_read == -1)
  33.     {
  34.         perror("读");
  35.     }
  36.     else if (n_read > 0)
  37.     {
  38.         printf("\n获取:%d\n", n_read);
  39.     }
  40.     else
  41.     {
  42.         printf("客户端退出\n");
  43.     }
  44.  
  45.  
  46.     return n_read;
  47. }
  48.  
  49. int socketInit(struct InputCommander *socketMes, char *ipAdress, char *port)
  50. {
  51.  
  52.     int s_fd;
  53.     struct sockaddr_in s_addr;
  54.  
  55.     memset(&s_addr, 0, sizeof(struct sockaddr_in));
  56.  
  57.     // 1.socket
  58.     s_fd = socket(AF_INET, SOCK_STREAM, 0);
  59.     if (s_fd == -1)
  60.     {
  61.         perror("socket");
  62.         exit(-1);
  63.     }
  64.  
  65.     s_addr.sin_family = AF_INET;
  66.     s_addr.sin_port = htons(atoi(socketMes->port));
  67.     inet_aton(socketMes->ipAdress, &s_addr.sin_addr);
  68.  
  69.     //解决服务器程序结束后端口被占用的情况
  70.     int opt = 1;
  71.     setsockopt(s_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
  72.  
  73.     // 2.bind
  74.     bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in));
  75.  
  76.     // 3.listen
  77.     listen(s_fd, 10);
  78.     printf("套接字服务器侦听......\n");
  79.     socketMes->sfd = s_fd;
  80.  
  81.     return s_fd;
  82. }
  83.  
  84. struct InputCommander socketContrl = {
  85.     .commandName = "socketServer",
  86.     .comand = {'\0'},
  87.     .port = "8088",
  88.     .ipAdress = "192.168.137.167",
  89.     .Init = socketInit,
  90.     .getCommand = socketgetCommand,
  91.     .log = {'\0'},
  92.     .next = NULL};
  93.  
  94. struct InputCommander *addsocketContrlToInputCommanderLink(struct InputCommander *phead)
  95. {
  96.     if (phead == NULL)
  97.     {
  98.         return &socketContrl;
  99.     }
  100.     else
  101.     {
  102.         socketContrl.next = phead;
  103.         phead = &socketContrl;
  104.     }
  105.  
  106.     return phead;
  107. }
  108.  
  109.

upstairLight.c(客厅灯)

  1. #include <stdlib.h>
  2. #include <fcntl.h>
  3. #include "contrlDevices.h"
  4.  
  5. int upstairLightOpen(int pinNum) //打开客厅灯函数
  6. {
  7.     digitalWrite(pinNum, HIGH);
  8. }
  9.  
  10. int upstairLightClose(int pinNum) //关闭客厅灯函数
  11. {
  12.     digitalWrite(pinNum, LOW);
  13. }
  14.  
  15. int upstairLightCloseInit(int pinNum) //初始化函数
  16. {
  17.     pinMode(pinNum, OUTPUT);    //配置引脚为输出引脚
  18.     digitalWrite(pinNum, LOW); //引脚输出高电平，即默认为关闭状态
  19. }
  20.  
  21. int upstairLightCloseStatus(int status)
  22. {
  23. }
  24.  
  25. struct Devices upstairLight = { //客厅灯设备链表节点
  26.     .deviceName = "upstairLight",
  27.     .pinNum = 22,
  28.     .open = upstairLightOpen,
  29.     .close = upstairLightClose,
  30.     .deviceInit = upstairLightCloseInit,
  31.     .changStatus = upstairLightCloseStatus
  32. };
  33.  
  34. struct Devices *addupStairLightToDeviceLink(struct Devices *phead) //头插法将设备节点加入设备工厂链表函数
  35. {
  36.     if (phead == NULL)
  37.     {
  38.         return &upstairLight;
  39.     }
  40.     else
  41.     {
  42.         upstairLight.next = phead;
  43.         phead = &upstairLight;
  44.     }
  45. }

vibrate.c(震动传感器)

  1. #include "contrlDevices.h"
  2.  
  3. int vibrateInit(int pinNum)
  4. {
  5.     pinMode(pinNum, INPUT);
  6.     digitalWrite(pinNum, HIGH);
  7. }
  8.  
  9. int readvibrateStatus(int pinNum)
  10. {
  11.     return digitalRead(pinNum);
  12. }
  13.  
  14. struct Devices vibrate = {
  15.     .deviceName = "vibrate",
  16.     .pinNum = 1,
  17.     .deviceInit = vibrateInit,
  18.     .readStatus = readvibrateStatus};
  19.  
  20. struct Devices *addVibrateToDeviceLink(struct Devices *phead)
  21. {
  22.     if (phead == NULL)
  23.     {
  24.         return &vibrate;
  25.     }
  26.     else
  27.     {
  28.         vibrate.next = phead;
  29.         phead = &vibrate;
  30.     }
  31.     return phead;
  32. }
  33.  
  34.

voiceContrl.c(语音模块)

  1. #include <wiringPi.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <wiringSerial.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7.  
  8. #include "inputCommand.h"
  9.  
  10. int getCommand(struct InputCommander *voicer) //获取语音指令
  11. {
  12.     int nread = 0;
  13.     memset(voicer->comand, '\0', sizeof(voicer->comand));
  14.     nread = read(voicer->fd, voicer->comand, sizeof(voicer->comand));//将语音模块返回的数据存放在缓冲区comand
  15.     return nread;
  16. }
  17. //语音模块初始化
  18. int voiceInit(struct InputCommander *voicer, char *ipAdress, char *port)
  19. {
  20.     int fd;
  21.     if ((fd = serialOpen(voicer->deviceName, 9600)) == -1)
  22.     {
  23.         printf("语音初始化失败\n");
  24.         exit(-1);
  25.     }
  26.     voicer->fd = fd;
  27.     printf("语音初始化结束\n");
  28.     return fd;
  29. }
  30. //语音模块结构体
  31. struct InputCommander voiceContrl = {
  32.     .commandName = "voice",
  33.     .deviceName = "/dev/ttyAMA0",//此文件用于存放语音模块返回的数据
  34.     .comand = {'\0'},
  35.     .Init = voiceInit,
  36.     .getCommand = getCommand,
  37.     .log = {'\0'},
  38.     .next = NULL
  39. };
  40. struct InputCommander *addVoiceContrlToInputCommanderLink(struct InputCommander *phead)
  41. {
  42.     if (phead == NULL)
  43.     {
  44.         return &voiceContrl;
  45.     }
  46.     else
  47.     {
  48.         voiceContrl.next = phead;
  49.         phead = &voiceContrl;
  50.     }
  51.     return phead;
  52. }
  53.  
  54.

2.2全志代码

  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <unistd.h>
  5. #include <netinet/in.h>
  6. #include <arpa/inet.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <wiringPi.h>
  10. int main(int argc, char **argv)
  11. {
  12. 	int c_fd;
  13. 	int n_read;
  14. 	int a = 0;
  15. 	char msg[24] = {};
  16. 	char readBuf[128];
  17. 	struct sockaddr_in c_addr;
  18.  
  19. 	memset(&c_addr,0,sizeof(struct sockaddr_in));
  20.  
  21. 	c_fd = socket(AF_INET, SOCK_STREAM, 0);
  22. 	if(c_fd == -1){
  23. 		perror("socket");
  24. 		exit(-1);
  25. 	}
  26.  
  27. 	c_addr.sin_family = AF_INET;
  28. 	c_addr.sin_port = htons(atoi(argv[2]));
  29. 	inet_aton(argv[1],&c_addr.sin_addr);
  30.  
  31. 	if(connect(c_fd, (struct sockaddr *)&c_addr,sizeof(struct sockaddr)) == -1){
  32. 		perror("connect");
  33. 		exit(-1);
  34. 	}
  35. 	while(1)
  36. 	{
  37. 		if(fork() == 0)
  38. 		{
  39. 			memset(msg,0,sizeof(msg));
  40.  
  41. 			scanf("%s",msg);
  42.  
  43. 			write(c_fd,msg,strlen(msg));
  44. 		}
  45. 		n_read = read(c_fd, readBuf, 128);
  46. 		if(n_read == -1){
  47. 			perror("read");
  48. 		}else{
  49. 			printf("服务端消息%d,%s\n",n_read,readBuf);
  50. 		}
  51. 		delay(4000);
  52. 	}
  53. 	return 0;
  54. }
  55.

3、编译运行效果

树莓派端编译

gcc camera.c doorLock.c vibrate.c livingroomLight.c upstairLight.c bathroomLight.c fan.c lock.c restaurantLight.c socketContrl.c voiceContrl.c buzzer.c fire.c mainPro.c infrared.c -lwiringPi -lpthread -lcurl

全志端编译：

  1. gcc client.c -lwiringPi
  2.  
  3. ./a.out 192.168.137.167 8088

运行效果：

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/232180
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号