基于树莓派的智能家居控制系统设计

@小高同学

已于 2023-04-25 02:16:44 修改

阅读量9.1k

点赞数 26

分类专栏： C语言网络通信链表文章标签： c语言 linux 物联网

于 2022-06-27 21:48:43 首次发布

本文链接：https://blog.csdn.net/G1842965496/article/details/125491350

版权

C语言同时被 3 个专栏收录

7 篇文章 0 订阅

订阅专栏

链表

4 篇文章 0 订阅

订阅专栏

网络通信

2 篇文章 0 订阅

订阅专栏

基于树莓派的智能家居控制系统设计

完整文件下载
在这里插入图片描述

基于树莓派的智能家居控制系统设计
https://download.csdn.net/download/G1842965496/85802405

论文参考：基于树莓派的智能家居控制系统论文参考
https://blog.csdn.net/G1842965496/article/details/130071066

项目面试问题
C/C++/嵌入式—面试题汇总

一、功能介绍

1.通过手机APP、语音识别等控制家电，对门锁，灯光、电风扇等设备进行控制，开发回家模式，睡觉模式等应用场景。
2.通过视频监控、火灾报警、震动报警和人体感应报警保证家居的安全。
3.将温湿度检测数据和家居安防状况实时同步到用户的手机APP进行显示。
4.遥控控制可以保证在没有网络的情况下也可以对家居进行控制。
5.通过翔云平台提供的人脸对比服务完成人脸识别开锁

二、实物展示

1.家居模型实物
在这里插入图片描述

2.部分功能展示
手机APP

火灾测试
火灾报警
视频监控
温湿度检测
人脸识别按钮在这里插入图片描述
人脸识别开锁

三、程序（手机APP程序过多不展示）

在这里插入图片描述

1.主程序mainPro.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "contrlDevices.h"
#include "inputCommand.h"
#define HIGH_TIME 32

// 433m端口
#define D0 4
#define D1 3
#define D2 2
#define D3 0

#define key 28 //拍照按键
// #define door_Lock 29 //门锁

//注意：定义线程不使用指针以免空指针异常
//注意：不建议线程传参（链表头）所以定为全局变量
pthread_t voiceThread;       //语音识别线程
pthread_t socketThread;      //服务器线程
pthread_t writeThread;       //通知线程：向客服端发送消息
pthread_t fireThread;        //火灾检测线程
pthread_t shakeThread;       //震动检测线程
pthread_t humanThread;       //人体红外检测线程
pthread_t remoteThread;      //遥控线程
pthread_t keyThread;         //按键检测线程
pthread_t cameraThread;      //人脸识别线程
pthread_t monitoringThread;  //视频监控线程
pthread_t clientWemosThread; //客服端线程
pthread_t dht11Thread;       //温湿度线程

struct InputCommander *pCommandHead = NULL;
struct Devices *pdeviceHead = NULL;
struct InputCommander *socketHandler = NULL;
// struct InputCommander *clientHandler = NULL;

pthread_mutex_t mutex; //定义互斥量（锁）
// pthread_cond_t  cond;   //条件

unsigned long databuf;

int c_fd; //注意：涉及到多线程不要轻易的去传参

int beep = 0; //蜂鸣器标志位   0：未被使用   1：被火灾传感器使用    2：被震动传感器使用
//摄像头相关，改变返回值命名，因为C语言中没有这样的返回值
#define true 1
#define false 0
typedef unsigned int bool;
char buf[1024] = {'\0'};

/*通知app [0]:温度   [1]:湿度   [2]:火灾监控   [3]:震动监控   [4]:人体红外监控*/
char Message[5][100] = {"未启用！", "未启用！", "未启用！", "未启用！", "未启用！"};
int write_flag = 0; //标记位，标记通知线程是否打开     1：打开   0：关闭

int human_flag = 0; //红外检测标志位     1：打开   0：关闭

struct Devices *findDeviceByName(char *name, struct Devices *phead) //查询设备
{
    if (phead == NULL)
    {
        return NULL;
    }

    while (phead != NULL)
    {
        // printf("phead:%s  name:%s\n", phead->deviceName, name);
        if (strstr(phead->deviceName, name) != NULL)
        {
            return phead;
        }
        phead = phead->next;
    }

    return NULL;
}

struct InputCommander *findCommandByName(char *name, struct InputCommander *phead) //查询控制
{
    if (phead == NULL)
    {
        return NULL;
    }
    while (phead != NULL)
    {
        if (strcmp(phead->commandName, name) == 0)
        {
            return phead;
        }
        phead = phead->next;
    }
    return NULL;
}

//查找设备
void *cameraThread_func(void *data) //起线程的函数有格式要求
{
    struct Devices *cameraTemp;

    cameraTemp = findDeviceByName("camera", pdeviceHead); //设备都要从工厂里面取出来

    if (cameraTemp == NULL)
    { //防止段错误的必需判断，当给指针赋值是，一定要考虑NULL的情况，否则后续操作都是空谈
        printf("find camera error\n");
        pthread_exit(NULL); //在线程中不用return
    }

    cameraTemp->justDoOnce(); //调用postUrl函数
}

unsigned char readSensorData(void) //温湿度初始化
{
    char crc;
    char i;

    pinMode(6, OUTPUT);   // 将模式设置为输出
    digitalWrite(6, LOW); // 输出高电平
    delay(25);
    digitalWrite(6, HIGH); // 输出低电平
    pinMode(6, INPUT);     // 将模式设置为输入
    pullUpDnControl(6, PUD_UP);

    delayMicroseconds(27);
    if (digitalRead(6) == 0) // SENSOR ANS
    {
        while (!digitalRead(6))
            ; // wait to high

        for (i = 0; i < 32; i++)
        {
            while (digitalRead(6))
                ; // 数据时钟启动
            while (!digitalRead(6))
                ; //数据开始
            delayMicroseconds(HIGH_TIME);
            databuf *= 2;
            if (digitalRead(6) == 1) // 1
            {
                databuf++;
            }
        }

        for (i = 0; i < 8; i++)
        {
            while (digitalRead(6))
                ; // 数据时钟启动
            while (!digitalRead(6))
                ; // 数据开始
            delayMicroseconds(HIGH_TIME);
            crc *= 2;
            if (digitalRead(6) == 1) // 1
            {
                crc++;
            }
        }
        return 1;
    }
    else
    {
        return 0;
    }
}

void *dht11_thread(void *datas) //温湿度线程
{
    int W = 0, w = 0;
    int S = 0, s = 0;
    // int count = 0;
    int temp = 0;
    printf("Use GPIO4 to read data!\n");

    if (-1 == wiringPiSetup())
    {
        printf("Setup wiringPi failed!");
        // return 1;
    }

    pinMode(6, OUTPUT);    // set mode to output
    digitalWrite(6, HIGH); // output a high level

    printf("Enter OS-------\n");
    while (1)
    {
        pinMode(6, OUTPUT);    // set mode to output
        digitalWrite(6, HIGH); // output a high level
        delay(3000);

        if (readSensorData())
        {

            W = (databuf >> 8) & 0xff;
            w = databuf & 0xff;
            S = (databuf >> 24) & 0xff;
            s = (databuf >> 16) & 0xff;
            // printf("传感器数据读取正常!\n");
            if (temp == 0)
            {
                w++;
                s++;
                temp++;
            }
            else if (temp == 1)
            {
                if (w >= 1)
                {
                    w--;
                }
                if (s >= 1)
                {
                    w--;
                }

                temp--;
            }

            if ((W >= 15) && (W <= 35) && (S <= 95))
            {
                memset(Message[0], 0, sizeof Message[0]); //清空数组
                memset(Message[1], 0, sizeof Message[1]);
                // printf("温度：%d.%d    湿度：%d.%d\n", W, w, S, s); //清空数组
                sprintf(Message[0], "%d.%d C", W, w); //温度
                sprintf(Message[1], "%d.%d", S, s);   //湿度
                                                      //  printf("温度：%d.%d C", (databuf >> 8) & 0xff, databuf & 0xff);               //温度
            }                                         //   printf("   湿度：%d.%d %\n", (databuf >> 24) & 0xff, (databuf >> 16) & 0xff); //湿度

            databuf = 0;
        }
        else
        {
            //  count++;
            //  memset(Message[0], 0, sizeof Message[0]); //清空数组
            //  memset(Message[1], 0, sizeof Message[1]); //清空数组
            // sprintf(Message[0], "监测错误！");        //温度
            //  sprintf(Message[1], "监测错误！");        //湿度
            printf("Sorry! Sensor dosent ans!\n");
            databuf = 0;
        }

        // if (count >= 3)
        // {
        //     pthread_create(&dht11Thread, NULL, dht11_thread, NULL);
        // }
    }
}

void *fire_thread(void *datas) //火灾线程
{
    char msg[100];
    int status;
    struct Devices *fireDeviceTmp = NULL;
    struct Devices *buzzerDeviceTmp = NULL;

    fireDeviceTmp = findDeviceByName("fire", pdeviceHead); //在设备工厂找到火灾模块
    buzzerDeviceTmp = findDeviceByName("buzzser", pdeviceHead);

    fireDeviceTmp->deviceInit(fireDeviceTmp->pinNum); //火灾模块初始化
    buzzerDeviceTmp->deviceInit(buzzerDeviceTmp->pinNum);
    printf("火灾线程初始化成功\n");

    while (1)
    {
        delay(10);
        status = fireDeviceTmp->readStatus(fireDeviceTmp->pinNum); //读取火灾模块实时数据
        if (status == 0)
        {
            beep = 1;                                       //火灾传感器使用蜂鸣器
            buzzerDeviceTmp->open(buzzerDeviceTmp->pinNum); //蜂鸣器报警
            memset(Message[2], 0, sizeof Message[2]);       //清空数组
            sprintf(Message[2], "警报：发生火灾 ！");       //更新火灾信息
            delay(200);                                     //蜂鸣器报警延时
        }
        else if ((beep != 2) && (beep != 3)) //未被震动传感器和人体红外传感器使用
        {
            buzzerDeviceTmp->close(buzzerDeviceTmp->pinNum); //关闭蜂鸣器
            memset(Message[2], 0, sizeof Message[2]);        //清空数组
            sprintf(Message[2], "正常");                     //更新火灾信息
            beep = 0;                                        //蜂鸣器未被使用
        }
    }
}

void *shake_thread(void *datas) //震动线程
{
    char msg[100];
    int status;
    struct Devices *shakeDeviceTmp = NULL;
    struct Devices *buzzerDeviceTmp = NULL;

    shakeDeviceTmp = findDeviceByName("shake", pdeviceHead); //在设备工厂找到火灾模块
    buzzerDeviceTmp = findDeviceByName("buzzser", pdeviceHead);

    shakeDeviceTmp->deviceInit(shakeDeviceTmp->pinNum); //震动模块初始化
    buzzerDeviceTmp->deviceInit(buzzerDeviceTmp->pinNum);
    printf("震动线程初始化成功\n");
    while (1)
    {
        delay(5);
        status = shakeDeviceTmp->readStatus(shakeDeviceTmp->pinNum); //读取震动模块实时数据

        if (status == 0)
        {
            beep = 2; //震动传感器使用蜂鸣器
            buzzerDeviceTmp->open(buzzerDeviceTmp->pinNum);
            memset(Message[3], 0, sizeof Message[3]); //清空数组
            sprintf(Message[3], "警报：发生震动 ！");

            delay(300);
        }
        else if ((beep != 1) && (beep != 3)) //蜂鸣器未被火焰传感器和人体红外传感器使用
        {
            memset(Message[3], 0, sizeof Message[3]); //清空数组
            sprintf(Message[3], "正常");
            buzzerDeviceTmp->close(buzzerDeviceTmp->pinNum);
            beep = 0; //蜂鸣器未被使用
        }
    }
}

void *human_thread(void *datas) // 人体红外检测线程
{
    char msg[100];
    int status;
    struct Devices *humanDeviceTmp = NULL;
    struct Devices *buzzerDeviceTmp = NULL;

    humanDeviceTmp = findDeviceByName("human", pdeviceHead); //在设备工厂找到火灾模块
    buzzerDeviceTmp = findDeviceByName("buzzser", pdeviceHead);

    humanDeviceTmp->deviceInit(humanDeviceTmp->pinNum); //红外模块初始化
    buzzerDeviceTmp->deviceInit(buzzerDeviceTmp->pinNum);
    printf("人体红外检测初始化\n");

    while (1)
    {
        delay(10);
        status = humanDeviceTmp->readStatus(humanDeviceTmp->pinNum); //读取人体感应模块实时数据

        if (status == 1)
        {
            beep = 3;                                 //人体红外使用蜂鸣器
            memset(Message[4], 0, sizeof Message[4]); //清空数组
            sprintf(Message[4], "警报：有人进入 ！");
            buzzerDeviceTmp->open(buzzerDeviceTmp->pinNum);
            delay(200);
            buzzerDeviceTmp->close(buzzerDeviceTmp->pinNum);
            delay(100);
        }
        else if ((beep != 1) && (beep != 2)) //未被火焰传感器和震动传感器使用
        {
            memset(Message[4], 0, sizeof Message[4]); //清空数组
            sprintf(Message[4], "正常");
            buzzerDeviceTmp->close(buzzerDeviceTmp->pinNum);
            beep = 0; //蜂鸣器未被使用
        }
    }
}

void *monitoring_thread(void *datas) //视频监控线程
{
    system("./start_web_video.sh"); //执行脚本，打开视频监控
    pthread_exit(NULL);             //退出线程
}

void *voice_thread(void *arg) //语音线程
{
    int i = 0;
    int nread;
    struct InputCommander *voiceHandler = NULL;
    struct Devices *deviceTmp = NULL;

    voiceHandler = findCommandByName("voice", pCommandHead); //在控制工厂找到语音模块

    if (voiceHandler == NULL)
    {
        printf("查找语音处理程序错误\n");
        pthread_exit(NULL);
    }
    else
    {
        if (voiceHandler->Init(voiceHandler, NULL, NULL) < 0)
        { //语音模块初始化
            printf("语音初始化错误\n");
            pthread_exit(NULL); //退出线程
        }
        else
        {
            printf("%s 初始化成功\n", voiceHandler->commandName);
        } //语音初始化完成

        pthread_mutex_lock(&mutex); //加锁
                                    //语音读取一级指令的时候，为了避免其它线程对于 紧接着读取二级指令的干扰
        while (1)
        {
            memset(voiceHandler->comand, '\0', sizeof(voiceHandler->comand));

            nread = voiceHandler->getCommand(voiceHandler); //读取来自语音模块的串口数据
            printf("get voice command:%s\n", voiceHandler->comand);
            if (nread == 0)
            {
                printf("没有来自语音的数据，请再说一遍\n");
            }
            else if (strstr(voiceHandler->comand, "kwsd") != NULL) //打开卧室灯命令
            {
                printf("打开卧室灯光\n");
                deviceTmp = findDeviceByName("shui", pdeviceHead); //查找卧室灯设备
                deviceTmp->deviceInit(deviceTmp->pinNum);          //卧室灯设备初始化
                deviceTmp->open(deviceTmp->pinNum);                //打开卧室灯
            }
            else if (strstr(voiceHandler->comand, "gwsd") != NULL)
            {
                printf("关闭卧室灯光\n");
                deviceTmp = findDeviceByName("shui", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "kysd") != NULL)
            {
                printf("打开浴室灯光\n");
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "gysd") != NULL)
            {
                printf("关闭浴室灯光\n");
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "kktd") != NULL)
            {
                printf("打开客厅灯光\n");
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "gktd") != NULL)
            {
                printf("关闭客厅灯光\n");
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "kctd") != NULL)
            {
                printf("打开餐厅灯光\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "gctd") != NULL)
            {
                printf("关闭餐厅灯光\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "kycd") != NULL) //开泳灯指令
            {
                printf("打开泳池灯光\n");
                deviceTmp = findDeviceByName("yong", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "gqbd") != NULL) //关闭全部灯指令
            {
                printf("关闭所有灯光\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum); //关闭餐厅灯
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum); //关闭浴室灯
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum); //关闭客厅灯
                deviceTmp = findDeviceByName("shui", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum); //关闭卧室灯
            }
            else if (strstr(voiceHandler->comand, "kqbd") != NULL)
            {
                printf("打开所有灯光\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("shui", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "gycd") != NULL) //关泳池灯指令
            {
                printf("关闭泳池灯光\n");
                deviceTmp = findDeviceByName("yong", pdeviceHead); //搜索泳池灯设备
                deviceTmp->deviceInit(deviceTmp->pinNum);          //泳池灯设备初始化
                deviceTmp->close(deviceTmp->pinNum);               //关泳池灯
            }
            else if (strstr(voiceHandler->comand, "kdfs") != NULL) //开电风扇指令
            {
                printf("打开电风扇\n");
                deviceTmp = findDeviceByName("fan", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "gdfs") != NULL) //关电风扇指令
            {
                printf("关闭电风扇\n");
                deviceTmp = findDeviceByName("fan", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(voiceHandler->comand, "ks") != NULL) //开锁指令
            {
                printf("打开门锁\n");
                deviceTmp = findDeviceByName("lock", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                delay(3000);
                deviceTmp->close(deviceTmp->pinNum);
            }
            /*else
            {
                deviceTmp = findDeviceByName(voiceHandler->comand, pdeviceHead);
                if (deviceTmp == NULL)
                {
                    printf("查找设备按名称错误\n");
                }
                else
                {
                    printf("查找设备 = %s\n", deviceTmp->deviceName);
                    deviceTmp->deviceInit(deviceTmp->pinNum);
                    deviceTmp->open(deviceTmp->pinNum);
                }
            }*/
        }

        pthread_mutex_unlock(&mutex); //解锁
    }
}

void *write_thread(void *datas) //通知线程，向客服端发送消息
{
    while (1)
    {
        delay(500);
        write(c_fd, Message, 500);
    }
}

void *read_thread(void *datas) //通过socket读取客户端发来的数据
{

    int n_read;
    struct Devices *deviceTmp = NULL;

    while (1)
    {
        memset(socketHandler->comand, '\0', sizeof(socketHandler->comand));

        n_read = read(c_fd, socketHandler->comand, sizeof(socketHandler->comand)); //读取客户端发来的数据
        if (n_read == -1)
        {
            perror("read_thread");
        }
        else if (n_read > 0)
        {
            printf("APP客户端指令:%s\n", socketHandler->comand);
            //处理客户端读到的命令
            if (strstr(socketHandler->comand, "kws") != NULL) //开卧室灯
            {
                printf("开卧室灯\n");
                deviceTmp = findDeviceByName("shui", pdeviceHead); //查找卧室灯设备
                deviceTmp->deviceInit(deviceTmp->pinNum);          //卧室灯设备初始化
                deviceTmp->open(deviceTmp->pinNum);                //打开卧室灯
            }
            else if (strstr(socketHandler->comand, "gws") != NULL) //关卧室灯
            {
                printf("关卧室灯\n");
                deviceTmp = findDeviceByName("shui", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "kys") != NULL) //开浴室灯
            {
                printf("开浴室灯\n");
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "gys") != NULL) //关浴室灯
            {
                printf("关浴室灯\n");
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "kkt") != NULL) //开客厅灯
            {
                printf("开客厅灯\n");
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "gkt") != NULL) //关客厅灯
            {
                printf("关客厅灯\n");
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "kct") != NULL) //开餐厅灯
            {
                printf("开餐厅灯\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "gct") != NULL) //关餐厅灯
            {
                printf("关餐厅灯\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "kyc") != NULL) //开泳池灯
            {
                printf("开泳池灯\n");
                deviceTmp = findDeviceByName("yong", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "gyc") != NULL) //关泳池灯
            {
                printf("关泳池灯\n");
                deviceTmp = findDeviceByName("yong", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "kfs") != NULL) //开风扇
            {
                printf("开电风扇\n");
                deviceTmp = findDeviceByName("fan", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "gfs") != NULL) //关风扇
            {
                printf("关电风扇\n");
                deviceTmp = findDeviceByName("fan", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "kqb") != NULL) //开室内全部灯
            {
                printf("开室内全部灯\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("shui", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "gqb") != NULL) //关室内全部灯
            {
                printf("关室内全部灯\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("shui", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "ks") != NULL) //开锁
            {
                printf("开锁\n");
                deviceTmp = findDeviceByName("lock", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "gs") != NULL) //关锁
            {
                deviceTmp = findDeviceByName("lock", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "kjk") != NULL) //开监控
            {
                printf("打开监控\n");
                pthread_create(&monitoringThread, NULL, monitoring_thread, NULL); //启动视频监控线程
            }
            else if (strstr(socketHandler->comand, "gjk") != NULL) //关监控
            {
                printf("关闭监控\n");
                // pthread_cancel(monitoringThread);
                system("killall -TERM mjpg_streamer"); //关闭摄像头监控功能
            }
            else if (strstr(socketHandler->comand, "khw") != NULL) //打开人体红外检测
            {
                printf("启动人体红外检测线程\n");
                beep = 3; //人体红外使用蜂鸣器
                deviceTmp = findDeviceByName("buzzser", pdeviceHead);
                deviceTmp->open(deviceTmp->pinNum);
                delay(700);
                deviceTmp->close(deviceTmp->pinNum);
                if (human_flag == 0)
                {
                    pthread_create(&humanThread, NULL, human_thread, NULL);
                    human_flag = 1;
                }
            }
            else if (strstr(socketHandler->comand, "ghw") != NULL) //关闭人体红外检测
            {
                printf("关闭人体红外检测\n");
                memset(Message[4], 0, sizeof Message[4]); //清空数组
                sprintf(Message[4], "未启用！");

                if (human_flag == 1)
                {
                    pthread_cancel(humanThread); //停止人体红外线程
                    human_flag = 0;
                }

                beep = 3; //人体红外使用蜂鸣器
                deviceTmp = findDeviceByName("buzzser", pdeviceHead);
                deviceTmp->open(deviceTmp->pinNum);
                delay(400);
                deviceTmp->close(deviceTmp->pinNum);
                delay(300);
                deviceTmp->open(deviceTmp->pinNum);
                delay(400);
                deviceTmp->close(deviceTmp->pinNum);
            }
            else if (strstr(socketHandler->comand, "gjms") != NULL) //归家模式
            {
                printf("开室内全部灯\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("shui", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->open(deviceTmp->pinNum);

                printf("关闭人体红外检测\n");
                memset(Message[4], 0, sizeof Message[4]); //清空数组
                sprintf(Message[4], "未启用！");

                if (human_flag == 1)
                {
                    pthread_cancel(humanThread); //停止人体红外线程
                    human_flag = 0;
                }

                beep = 3; //人体红外使用蜂鸣器
                deviceTmp = findDeviceByName("buzzser", pdeviceHead);
                deviceTmp->open(deviceTmp->pinNum);
                delay(400);
                deviceTmp->close(deviceTmp->pinNum);
                delay(300);
                deviceTmp->open(deviceTmp->pinNum);
                delay(400);
                deviceTmp->close(deviceTmp->pinNum);
                beep = 0;
            }
            else if (strstr(socketHandler->comand, "ljms") != NULL) //离家模式
            {
                printf("关全部灯\n");
                deviceTmp = findDeviceByName("chu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("yu", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("kt", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("shui", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);
                deviceTmp = findDeviceByName("yong", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);

                printf("关电风扇\n");
                deviceTmp = findDeviceByName("fan", pdeviceHead);
                deviceTmp->deviceInit(deviceTmp->pinNum);
                deviceTmp->close(deviceTmp->pinNum);

                printf("启动人体红外检测线程\n");
                beep = 3; //人体红外使用蜂鸣器
                deviceTmp = findDeviceByName("buzzser", pdeviceHead);
                deviceTmp->open(deviceTmp->pinNum);
                delay(700);
                deviceTmp->close(deviceTmp->pinNum);
                beep = 0;
                if (human_flag == 0)
                {
                    pthread_create(&humanThread, NULL, human_thread, NULL);
                    human_flag = 1;
                }
            }
            else if (strstr(socketHandler->comand, "face") != NULL)
            {
                //启动人脸识别线程
                printf("进行人脸识别开锁\n");
                pthread_create(&cameraThread, NULL, cameraThread_func, NULL);
            }
        }
        else
        {
            printf("客户端退出\n");
            // exit(-1); //客户端退出，服务器程序退出
            pthread_cancel(writeThread); //停止通知线程
            write_flag = 0;              //通知线程标志位置0，通知线程关闭
            pthread_exit(NULL);          //退出本线程
        }
    }
}

void *socket_thread(void *datas) //开启socket服务端，并将socket服务端初始化
{

    int n_read = 0;
    pthread_t readPthread;

    struct sockaddr_in c_addr;
    memset(&c_addr, 0, sizeof(struct sockaddr_in));
    int clen = sizeof(struct sockaddr_in);

    socketHandler = findCommandByName("socketServer", pCommandHead); //在控制工厂找到socket
    if (socketHandler == NULL)
    {
        printf("查找套接字处理程序错误\n");
        pthread_exit(NULL);
    }
    else
    {
        printf("%s 初始化成功\n", socketHandler->commandName);
    }

    socketHandler->Init(socketHandler, NULL, NULL); //初始化socket

    while (1)
    {

        c_fd = accept(socketHandler->sfd, (struct sockaddr *)&c_addr, &clen);
        printf("c_fd = %d\n", c_fd);
        if (write_flag == 0) //通知线程处于关闭状态
        {
            write_flag = 1;
            pthread_create(&writeThread, NULL, write_thread, NULL); //打开通知线程
        }
        pthread_create(&readPthread, NULL, read_thread, NULL);
    }
}

void *remote_thread(void *datas) // 433m遥控线程
{
    int val = 0, val1 = 0, val2 = 0, val3 = 0;
    int count = 0, count1 = 0, count2 = 0, count3 = 0;
    int temp = 0, temp1 = 0, temp2 = 0, temp3 = 0;

    struct Devices *deviceTmp = NULL;

    wiringPiSetup();
    pinMode(D0, INPUT);
    pinMode(D1, INPUT);
    pinMode(D2, INPUT);
    pinMode(D3, INPUT);

    digitalWrite(D0, LOW);
    digitalWrite(D1, LOW);
    digitalWrite(D2, LOW);
    digitalWrite(D3, LOW);

    printf("遥控模块初始化成功\n");

    while (1)
    {

        delay(10);

        val = digitalRead(D0);
        val1 = digitalRead(D1);
        val2 = digitalRead(D2);
        val3 = digitalRead(D3);
        if (val == 1) //电风扇遥控信号
        {
            if (count == 0) //电风扇遥控按键被按下
            {
                if (temp == 0) //打开电风扇
                {
                    printf("433M：打开电风扇\n");
                    temp = 1;
                    deviceTmp = findDeviceByName("fan", pdeviceHead); //查找电风扇设备
                    deviceTmp->deviceInit(deviceTmp->pinNum);         //电风扇设备初始化
                    deviceTmp->open(deviceTmp->pinNum);               //打开电风扇
                }
                else if (temp == 1) //关闭电风扇
                {
                    printf("433M：关闭电风扇\n");
                    temp = 0;
                    deviceTmp = findDeviceByName("fan", pdeviceHead); //查找电风扇设备
                    deviceTmp->deviceInit(deviceTmp->pinNum);         //电风扇设备初始化
                    deviceTmp->close(deviceTmp->pinNum);              //关闭电风扇
                }

                count = 1;
            }
        }
        else if (val == 0)
        {
            count = 0;
        }

        if (val1 == 1) //门锁遥控
        {
            if (count1 == 0)
            {
                if (temp1 == 0)
                {
                    printf("433M：打开门锁\n");
                    temp1 = 1;
                    deviceTmp = findDeviceByName("lock", pdeviceHead);
                    deviceTmp->deviceInit(deviceTmp->pinNum);
                    deviceTmp->open(deviceTmp->pinNum);
                    delay(3000);
                    deviceTmp->close(deviceTmp->pinNum);
                }
                else if (temp1 == 1)
                {
                    printf("433M：关闭门锁\n");
                    temp1 = 0;
                    deviceTmp = findDeviceByName("lock", pdeviceHead);
                    deviceTmp->deviceInit(deviceTmp->pinNum);
                    deviceTmp->close(deviceTmp->pinNum);
                }

                count1 = 1;
            }
        }
        else if (val1 == 0)
        {
            count1 = 0;
        }

        if (val2 == 1) //泳池灯遥控
        {
            if (count2 == 0)
            {
                if (temp2 == 0)
                {
                    printf("433M：开泳池灯\n");
                    temp2 = 1;

                    deviceTmp = findDeviceByName("yong", pdeviceHead);
                    deviceTmp->deviceInit(deviceTmp->pinNum);
                    deviceTmp->open(deviceTmp->pinNum);
                }
                else if (temp2 == 1)
                {
                    printf("433M：关泳池灯\n");
                    temp2 = 0;
                    deviceTmp = findDeviceByName("yong", pdeviceHead);
                    deviceTmp->deviceInit(deviceTmp->pinNum);
                    deviceTmp->close(deviceTmp->pinNum);
                }

                count2 = 1;
            }
        }
        else if (val2 == 0)
        {
            count2 = 0;
        }

        if (val3 == 1) //人体红外线程控制
        {
            if (count3 == 0)
            {
                if (temp3 == 0) // 启动人体红外检测线程
                {
                    printf("433M：启动人体红外\n");
                    temp3 = 1;
                    printf("启动人体红外检测线程\n");
                    beep = 3; //人体红外使用蜂鸣器
                    deviceTmp = findDeviceByName("buzzser", pdeviceHead);
                    // deviceTmp->deviceInit(deviceTmp->pinNum);
                    deviceTmp->open(deviceTmp->pinNum);
                    delay(700);
                    deviceTmp->close(deviceTmp->pinNum);
                    beep = 0;
                    if (human_flag == 0)
                    {
                        pthread_create(&humanThread, NULL, human_thread, NULL);
                        human_flag = 1;
                    }
                }
                else if (temp3 == 1)
                {
                    printf("433M：关闭人体红外\n");
                    memset(Message[4], 0, sizeof Message[4]); //清空数组
                    sprintf(Message[4], "未启用！");
                    temp3 = 0;
                    printf("关闭人体红外检测线程\n");
                    beep = 3; //人体红外使用蜂鸣器
                              // TerminateThread(human_thread, -1 );  // 中止人体红外检测线程
                              // CloseHandle(human_thread); //清楚人体红外线程堆栈
                    // _beginthread(human_thread,0, NULL);
                    if (human_flag == 1)
                    {
                        pthread_cancel(humanThread); //停止人体红外线程
                        human_flag = 0;
                    }

                    deviceTmp = findDeviceByName("buzzser", pdeviceHead);
                    // deviceTmp->deviceInit(deviceTmp->pinNum);
                    deviceTmp->open(deviceTmp->pinNum);
                    delay(400);
                    deviceTmp->close(deviceTmp->pinNum);
                    delay(300);
                    deviceTmp->open(deviceTmp->pinNum);
                    delay(400);
                    deviceTmp->close(deviceTmp->pinNum);
                    beep = 0;
                }

                count3 = 1;
            }
        }
        else if (val3 == 0)
        {
            count3 = 0;
        }
    }
}

//检测按键状态
void *key_thread()
{
    // pinMode(door_Lock, OUTPUT); //将门锁端口置为输出
    int val;
    while (1)
    {
        val = digitalRead(key);
        // printf("key = %d\n", val);
        if (val == 0) //防止重复检测
        {
            delay(500);
            val = digitalRead(key);
            // printf("key = %d\n", val);
            if (val == 1) //按键按下，启动人脸识别线程
            {
                pthread_create(&cameraThread, NULL, cameraThread_func, NULL);
            }
        }
    }
}

int main()
{
    char name[32] = {'\0'};

    //树莓派库初始化
    if (wiringPiSetup() == -1)
    {
        printf("硬件接口初始化失败\n");
        return -1;
    }

    pthread_mutex_init(&mutex, NULL); //初始化互斥量（锁）

    // 1、指令工厂初始化
    pCommandHead = addVoiceContrlToInputCommanderLink(pCommandHead);  //语音识别初始化
    pCommandHead = addsocketContrlToInputCommanderLink(pCommandHead); //服务器初始化

    // 2、设备控制工程初始化
    pdeviceHead = addBathroomLightToDeviceLink(pdeviceHead);   //浴室灯光初始化
    pdeviceHead = addupStairLightToDeviceLink(pdeviceHead);    //卧室灯光初始化
    pdeviceHead = addlivingroomLightToDeviceLink(pdeviceHead); //客厅灯光初始化
    pdeviceHead = addrestaurantLightToDeviceLink(pdeviceHead); //餐厅灯光初始化
    pdeviceHead = addpoolLightToDeviceLink(pdeviceHead);       //泳池灯光初始化
    pdeviceHead = addDoorLockToDeviceLink(pdeviceHead);        //门锁初始化
    pdeviceHead = addFanToDeviceLink(pdeviceHead);             //电风扇初始化
    pdeviceHead = addBuzzerToDeviceLink(pdeviceHead);          //蜂鸣器初始化
    pdeviceHead = addFireToDeviceLink(pdeviceHead);            //火焰传感器初始化
    pdeviceHead = addShakeToDeviceLink(pdeviceHead);           //震动传感器初始化
    pdeviceHead = addcameraToDeviceLink(pdeviceHead);          //摄像头模块初始化
    pdeviceHead = addHumanToDeviceLink(pdeviceHead);           //人体感应传感器初始化

    //参数2：线程属性，一般设置为NULL，参数3：线程干活的函数，参数4：往voice_thread线程里面传送数据。
    pthread_create(&voiceThread, NULL, voice_thread, NULL);   // 语音线程启动
    pthread_create(&socketThread, NULL, socket_thread, NULL); // socket服务器线程启动
    pthread_create(&fireThread, NULL, fire_thread, NULL);     //火灾报警线程启动
    pthread_create(&shakeThread, NULL, shake_thread, NULL);   //震动报警线程启动
    pthread_create(&keyThread, NULL, key_thread, NULL);       //按键检测线程启动
    pthread_create(&remoteThread, NULL, remote_thread, NULL); // 遥控线程启动
    pthread_create(&dht11Thread, NULL, dht11_thread, NULL);   // 温湿度检测线程启动

    //等待线程
    pthread_join(voiceThread, NULL);
    pthread_join(socketThread, NULL);
    pthread_join(fireThread, NULL);
    pthread_join(shakeThread, NULL);
    pthread_join(humanThread, NULL);
    pthread_join(keyThread, NULL);
    pthread_join(remoteThread, NULL);
    pthread_join(cameraThread, NULL);
    pthread_join(monitoringThread, NULL);
    pthread_join(clientWemosThread, NULL);
    pthread_join(dht11Thread, NULL);
    pthread_join(writeThread, NULL);

    pthread_mutex_destroy(&mutex); //销毁互斥量
                                   // pthread_cond_destroy(&cond);        //条件的销毁

    return 0;
}

2.摄像头camera.c

//摄像头
#include "contrlDevices.h"
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <curl/curl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#define door_lock 29 //门锁
void postUrl();
size_t readData1(void *ptr, size_t size, size_t nmemb, void *stream);
char *getFace1();
char *getPicFromOCRBase641(char *Filepath);
struct Devices *addcameraToDeviceLink(struct Devices *phead);

char ocrRetBuf[1024] = {'\0'}; //全局变量，用来接收从OCR后台返回的数据

size_t readData1(void *ptr, size_t size, size_t nmemb, void *stream)
//回调函数，把从后台的数据拷贝给ocrRetBuf
{
    strncpy(ocrRetBuf, ptr, 1024);
}

char *getFace1()
{
    printf("拍照中...\n");
    system("raspistill -q 5 -t 1 -o image.jpg"); //-q 是图片质量，在0~100之间，我们调成5，压缩图片质量,生成的照片名字为imag.jpg
                                                 //-t 是拍照延时，设定1s后拍照

    while (access("./image.jpg", F_OK) != 0)
        ; //判断是否拍照完毕

    printf("拍照完成\n");

    char *base64BufFaceRec = getPicFromOCRBase641("./image.jpg");
    // system("rm image.jpg");

    return base64BufFaceRec; //返回刚才拍照的base64
}

char *getPicFromOCRBase641(char *Filepath)
{
    int fd;
    int filelen;
    char cmd[128] = {'\0'};

    sprintf(cmd, "base64 %s > tmpFile", Filepath);
    system(cmd);
    fd = open("./tmpFile", O_RDWR);
    filelen = lseek(fd, 0, SEEK_END);
    lseek(fd, 0, SEEK_SET);
    char *bufpic = (char *)malloc(filelen + 2);
    memset(bufpic, '\0', filelen + 2);
    read(fd, bufpic, filelen + 128);
    system("rm -rf tmpFile");
    close(fd);

    return bufpic;
}

void postUrl()
{
    CURL *curl;
    CURLcode res;

    struct Devices *deviceTmp = NULL;

    //分开定义，然后字符串拼接
    char *key = "XXXXejLCjAKZUN2D63XXXX";                  //用自己的
    char *secret = "XXXXXXXXadca46859adXXXX69092XXXXXXXX"; //用自己的
    int typeId = 21;
    char *format = "xml";

    char *base64BufPic1 = getFace1();
    char *base64BufPic2 = getPicFromOCRBase641("gyf1.jpg");

    int len = strlen(key) + strlen(secret) + strlen(base64BufPic1) + strlen(base64BufPic2) + 128; //分配空间不够会导致栈溢出
    char *postString = (char *)malloc(len);
    memset(postString, '\0', len); //因为postString是一个指针，不能用sizeof来计算其指向的大小

    sprintf(postString, "img1=%s&img2=%s&key=%s&secret=%s&typeId=%d&format=%s", base64BufPic1, base64BufPic2, key, secret, typeId, format); //根据平台的传参格式编写

    curl = curl_easy_init();

    if (curl)
    {
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postString);                   //指定post内容，传入参数
        curl_easy_setopt(curl, CURLOPT_URL, "https://netocr.com/api/faceliu.do"); // 指定url
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, readData1);                 //回调函数readDate读取返回值
        res = curl_easy_perform(curl);                                            //类似于状态码
        printf("OK:%d\n", res);

        if (strstr(ocrRetBuf, "是") != NULL)
        { //判断翔云后台返回的字符串中有没有“是”
            printf("是同一个人\n");
            digitalWrite(door_lock, LOW);  //打开门锁
            delay(3000);                   //等待3s
            digitalWrite(door_lock, HIGH); //关闭门锁
        }
        else
        {
            printf("不是同一个人\n");
        }
        curl_easy_cleanup(curl);
    }
}

int cameraInit(int pinNum) //该函数无用
{
    pinMode(pinNum, OUTPUT);
    digitalWrite(pinNum, HIGH);
    //  printf("摄像头模块初始化成功\n");
}

struct Devices camera = {

    .deviceName = "camera",
    .deviceInit = cameraInit,
    .pinNum = 6, //此引脚号无用
    .justDoOnce = postUrl,
    .getFace = getFace1,
    .getPicFromOCRBase64 = getPicFromOCRBase641,
    .readData = readData1

};

struct Devices *addcameraToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &camera;
    }
    else
    {
        camera.next = phead;
        phead = &camera;
    }
}

3.外设设备的头文件contrlDevices.h

//外设设备的头文件
#include <wiringPi.h>
#include <stdio.h>
#include <curl/curl.h>

typedef unsigned int bool;

struct Devices
{
    char deviceName[128]; //设备名
    int status;           //读取到的数据
    int pinNum;           //引脚号

    int (*open)(int pinNum);       //打开设备函数指针
    int (*close)(int pinNum);      //关闭设备函数指针
    int (*deviceInit)(int pinNum); //设备初始化函数指针

    int (*readStatus)(int pinNum);  //读取数据函数指针
    int (*changStatus)(int status); //改变数据函数指针

    //摄像头相关的
    void (*justDoOnce)();           //用于摄像头
    char *(*getFace)();             //用于摄像头
    char *(*getPicFromOCRBase64)(); //用于摄像头
    size_t (*readData)();           //用于摄像头

    CURL *curl;
    char *key;
    char *secret;
    int typeId;
    char *format;
    bool (*cameraInit)(struct Devices *camera);
    int yesNum;
    int noNum;

    struct Devices *next;
};

//每个设备加到链表函数的声明
struct Devices *addBathroomLightToDeviceLink(struct Devices *phead);
struct Devices *addupStairLightToDeviceLink(struct Devices *phead);
struct Devices *addlivingroomLightToDeviceLink(struct Devices *phead);
struct Devices *addrestaurantLightToDeviceLink(struct Devices *phead);
struct Devices *addpoolLightToDeviceLink(struct Devices *phead);
struct Devices *addDoorLockToDeviceLink(struct Devices *phead);
struct Devices *addFanToDeviceLink(struct Devices *phead);
struct Devices *addFireToDeviceLink(struct Devices *phead);
struct Devices *addShakeToDeviceLink(struct Devices *phead);
struct Devices *addHumanToDeviceLink(struct Devices *phead) ;
struct Devices *addBuzzerToDeviceLink(struct Devices *phead);

// struct Devices *addcameraContrlToDeviceLink(struct Devices *phead);
struct Devices *addcameraToDeviceLink(struct Devices *phead);

4.控制的头文件inputCommand.h

//控制的头文件
#include <wiringPi.h>
#include <stdio.h>

struct InputCommander
{
    char commandName[128]; // socket名
    char deviceName[128];  //串口名
    char comand[32];       //控制命令

    int (*Init)(struct InputCommander *voicer, char *ipAdress, char *port); // socket初始化
    int (*getCommand)(struct InputCommander *voicer);                       //读取数据

    char log[1024];
    int fd;
    char port[12];     //端口号
    char ipAdress[32]; // IP地址
    int sfd;
    int cfd;

    struct InputCommander *next;
};

//每个控制添加到控制链表的函数声明
struct InputCommander *addVoiceContrlToInputCommanderLink(struct InputCommander *phead);
struct InputCommander *addsocketContrlToInputCommanderLink(struct InputCommander *phead);
struct InputCommander *addclientContrlToInputCommanderLink(struct InputCommander *phead);

5.语音模块voiceContrl.c

//语音控制设备
#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include <wiringSerial.h>
#include <unistd.h>
#include <string.h>

#include "inputCommand.h"

int getCommand(struct InputCommander *voicer) //获取语音指令
{
    int nread = 0;
    memset(voicer->comand, '\0', sizeof(voicer->comand));
    nread = read(voicer->fd, voicer->comand, sizeof(voicer->comand));
    return nread;
}
//语音模块初始化
int voiceInit(struct InputCommander *voicer, char *ipAdress, char *port)
{
    int fd;
    if ((fd = serialOpen(voicer->deviceName, 9600)) == -1)
    {
        printf("语音初始化失败\n");
        exit(-1);
    }
    voicer->fd = fd;
    printf("语音初始化结束\n");
    return fd;
}
//语音模块结构体
struct InputCommander voiceContrl = {
    .commandName = "voice",
    .deviceName = "/dev/ttyAMA0",
    .comand = {'\0'},
    .Init = voiceInit,
    .getCommand = getCommand,
    .log = {'\0'},
    .next = NULL};

struct InputCommander *addVoiceContrlToInputCommanderLink(struct InputCommander *phead)
{
    if (phead == NULL)
    {
        return &voiceContrl;
    }
    else
    {
        voiceContrl.next = phead;
        phead = &voiceContrl;
    }
    return phead;
}

6.蜂鸣器buzzser.c

//蜂鸣器
#include "contrlDevices.h"

int buzzerOpen(int pinNum)
{
    digitalWrite(pinNum, LOW);
}

int buzzerClose(int pinNum)
{
    digitalWrite(pinNum, HIGH);
}

int buzzerInit(int pinNum)
{
    pinMode(pinNum, OUTPUT);
    digitalWrite(pinNum, HIGH);
    printf("蜂鸣器初始化成功\n");
}

struct Devices buzzer = {
    .deviceName = "buzzser",
    .pinNum = 7,
    .open = buzzerOpen,
    .close = buzzerClose,
    .deviceInit = buzzerInit};

struct Devices *addBuzzerToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &buzzer;
    }
    else
    {
        buzzer.next = phead;
        phead = &buzzer;
    }
    return phead;
}

7.电风扇fan.c

//电风扇
#include "contrlDevices.h"

int fanOpen(int pinNum)
{
    // pinMode(pinNum, OUTPUT);
    digitalWrite(pinNum, LOW);
}

int fanClose(int pinNum)
{
    // pinMode(pinNum, INPUT);
    digitalWrite(pinNum, HIGH);
}

int fanCloseInit(int pinNum)
{
    //  pinMode(pinNum, INPUT);
    pinMode(pinNum, OUTPUT);
    digitalWrite(pinNum, HIGH);
    //printf("电风扇初始化成功\n");
}

int fanCloseStatus(int status)
{
}

struct Devices fan = {
    //.deviceName = "fan",
    .deviceName = "fan",
    .pinNum = 26,
    .open = fanOpen,
    .close = fanClose,
    .deviceInit = fanCloseInit,
    .changStatus = fanCloseStatus};

struct Devices *addFanToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &fan;
    }
    else
    {
        fan.next = phead;
        phead = &fan;
    }
    return phead;
}

8.人体红外检测human.c

//人体红外检测
#include "contrlDevices.h"

int humanInit(int pinNum)
{
    pinMode(pinNum, INPUT);
    digitalWrite(pinNum, HIGH);
   // printf("人体感应传感器初始化成功\n");
}

int readhumanStatus(int pinNum)
{
    return digitalRead(pinNum);
}

struct Devices human = {
    .deviceName = "human",
    .pinNum = 5,
    .deviceInit = humanInit,
    .readStatus = readhumanStatus};

struct Devices *addHumanToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &human;
    }
    else
    {
        human.next = phead;
        phead = &human;
    }
    return phead;
}

9.火焰传感器fire.c

//火焰传感器
#include "contrlDevices.h"

int fireInit(int pinNum)
{
    pinMode(pinNum, INPUT);
    digitalWrite(pinNum, HIGH);
}

int readFireStatus(int pinNum)
{
    return digitalRead(pinNum);
}

struct Devices fire = {
    .deviceName = "fire",
    .pinNum = 25,
    .deviceInit = fireInit,
    .readStatus = readFireStatus};

struct Devices *addFireToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &fire;
    }
    else
    {
        fire.next = phead;
        phead = &fire;
    }

    return phead;
}

10.震动传感器shake.c

//震动传感器
#include "contrlDevices.h"

int shakeInit(int pinNum)
{
    pinMode(pinNum, INPUT);
    digitalWrite(pinNum, HIGH);
}

int readShakeStatus(int pinNum)
{
    return digitalRead(pinNum);
}

struct Devices shake = {
    .deviceName = "shake",
    .pinNum = 1,
    .deviceInit = shakeInit,
    .readStatus = readShakeStatus};

struct Devices *addShakeToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &shake;
    }
    else
    {
        shake.next = phead;
        phead = &shake;
    }
    return phead;
}

11.服务器socketContrl.c

// socket控制
#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include <wiringSerial.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "inputCommand.h"

int socketgetCommand(struct InputCommander *socketMes)
{
    int c_fd;
    int n_read;

    struct sockaddr_in c_addr;
    memset(&c_addr, 0, sizeof(struct sockaddr_in));
    int clen = sizeof(struct sockaddr_in);

    // 4.accept
    c_fd = accept(socketMes->sfd, (struct sockaddr *)&c_addr, &clen);

    n_read = read(c_fd, socketMes->comand, sizeof(socketMes->comand));
    if (n_read == -1)
    {
        perror("读");
    }
    else if (n_read > 0)
    {
        printf("\n获取:%d\n", n_read);
    }
    else
    {
        printf("客户端退出\n");
    }

    return n_read;
}

int socketInit(struct InputCommander *socketMes, char *ipAdress, char *port)
{
    /*形参虽然定多了，用不上，咱不管*/

    int s_fd;
    struct sockaddr_in s_addr;

    memset(&s_addr, 0, sizeof(struct sockaddr_in));

    // 1.socket
    s_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (s_fd == -1)
    {
        perror("socket");
        exit(-1);
    }

    s_addr.sin_family = AF_INET;
    s_addr.sin_port = htons(atoi(socketMes->port));
    inet_aton(socketMes->ipAdress, &s_addr.sin_addr);

    //解决服务器程序结束后端口被占用的情况
    int opt = 1;
    setsockopt(s_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 2.bind
    bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in));

    // 3.listen
    listen(s_fd, 10);
    printf("套接字服务器侦听......\n");
    socketMes->sfd = s_fd;

    return s_fd;
}

struct InputCommander socketContrl = {
    .commandName = "socketServer",
    .comand = {'\0'},
    .port = "8083",
    .ipAdress = "172.26.183.9",
    //  .ipAdress = "192.168.245.9",
    .Init = socketInit,
    .getCommand = socketgetCommand,
    .log = {'\0'},
    .next = NULL};

struct InputCommander *addsocketContrlToInputCommanderLink(struct InputCommander *phead)
{
    if (phead == NULL)
    {

        return &socketContrl;
    }
    else
    {
        socketContrl.next = phead;
        phead = &socketContrl;
    }

    return phead;
}

12.客服端（wemos做服务器）client_wemos.c

//树莓派作为客服端  连接wemos D1服务器
#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include <wiringSerial.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "inputCommand.h"

int clientInit(struct InputCommander *client, char *ipAdress, char *port)
{
    struct sockaddr_in addr;

    memset(&addr, 0, sizeof(struct sockaddr_in));

    // 1.socket 创建套接字
    int s_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (s_fd == -1)
    {
        perror("socket");
        exit(-1);
    }

    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(client->port));
    inet_aton(client->ipAdress, &addr.sin_addr);

    // 2.connect 连接服务器
    if (connect(s_fd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) == -1) //这里是连接wemosD1
    {
        perror("connect");
        exit(-1);
    }
    printf("客户端 wemosD1 连接....\n");

    client->sfd = s_fd;
    return s_fd;
}

struct InputCommander clientContrl = {
    .commandName = "client",     //加入到控制链表的名字
    .comand = {'\0'},            //命令
    .port = "8888",              // wemosD1 端口号
    .ipAdress = "192.168.1.103", // wemosD1 IP地址
    .Init = clientInit,          //树莓派客户端初始化
    .next = NULL};

struct InputCommander *addclientContrlToInputCommanderLink(struct InputCommander *phead)
{
    if (phead == NULL)
    {
        return &clientContrl;
    }
    else
    {
        clientContrl.next = phead;
        phead = &clientContrl;
    }
    return phead;
}

13.浴室灯bathroomLight.c

//浴室灯
#include "contrlDevices.h"

int bathroomLightOpen(int pinNum)
{
    digitalWrite(pinNum, LOW);
}

int bathroomLightClose(int pinNum)
{
    digitalWrite(pinNum, HIGH);
}

int bathroomLightCloseInit(int pinNum)
{
    pinMode(pinNum, OUTPUT);
    digitalWrite(pinNum, HIGH);
  //  printf("浴室灯初始化成功\n");
}

int bathroomLightCloseStatus(int status)
{
}

struct Devices bathroomLight = {
    //.deviceName = "bathroomLight",
    .deviceName = "yu",
    .pinNum = 24,
    .open = bathroomLightOpen,
    .close = bathroomLightClose,
    .deviceInit = bathroomLightCloseInit,
    .changStatus = bathroomLightCloseStatus};

struct Devices *addBathroomLightToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &bathroomLight;
    }
    else
    {
        bathroomLight.next = phead;
        phead = &bathroomLight;
    }
    return phead;
}

14.门锁doorLock.c

//门锁
#include "contrlDevices.h"

int doorLockOpen(int pinNum)
{
    digitalWrite(pinNum, LOW);
}

int doorLockClose(int pinNum)
{
    digitalWrite(pinNum, HIGH);
}

int doorLockCloseInit(int pinNum)
{
    pinMode(pinNum, OUTPUT);
    digitalWrite(pinNum, HIGH);
   // printf("门锁初始化成功\n");
}

int doorLockCloseStatus(int status)
{
}

struct Devices doorLock = {
    //.deviceName = "doorLock",
    .deviceName = "lock",
    .pinNum = 29,
    .open = doorLockOpen,
    .close = doorLockClose,
    .deviceInit = doorLockCloseInit,
    .changStatus = doorLockCloseStatus};

struct Devices *addDoorLockToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &doorLock;
    }
    else
    {
        doorLock.next = phead;
        phead = &doorLock;
    }
    return phead;
}

15.卧室灯livingroomLigth.c

//卧室灯
#include "contrlDevices.h"

int livingroomLightOpen(int pinNum)
{
    digitalWrite(pinNum, LOW);
}

int livingroomLightClose(int pinNum)
{
    digitalWrite(pinNum, HIGH);
}

int livingroomLightCloseInit(int pinNum)
{
    pinMode(pinNum, OUTPUT);
    digitalWrite(pinNum, HIGH);
  //  printf("卧室灯初始化成功\n");
}

int livingroomLightCloseStatus(int status)
{
}

struct Devices livingroomLight = {
    //.deviceName = "livingroomLight",
    .deviceName = "shui",
    .pinNum = 21,
    .open = livingroomLightOpen,
    .close = livingroomLightClose,
    .deviceInit = livingroomLightCloseInit,
    .changStatus = livingroomLightCloseStatus};

struct Devices *addlivingroomLightToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &livingroomLight;
    }
    else
    {
        livingroomLight.next = phead;
        phead = &livingroomLight;
    }
    return phead;
}

16.泳池灯poolLight.c

//泳池灯
#include "contrlDevices.h"

int poolLightOpen(int pinNum)
{
    digitalWrite(pinNum, LOW);
}

int poolLightClose(int pinNum)
{
    digitalWrite(pinNum, HIGH);
}

int poolLightCloseInit(int pinNum)
{
    pinMode(pinNum, OUTPUT);
    digitalWrite(pinNum, HIGH);
   // printf("泳池灯初始化成功\n");
}

int poolLightCloseStatus(int status)
{
}

struct Devices poolLight = {
    //.deviceName = "poolLight",
    .deviceName = "yong",
    .pinNum = 27,
    .open = poolLightOpen,
    .close = poolLightClose,
    .deviceInit = poolLightCloseInit,
    .changStatus = poolLightCloseStatus};

struct Devices *addpoolLightToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &poolLight;
    }
    else
    {
        poolLight.next = phead;
        phead = &poolLight;
    }
    return phead;
}

17.餐厅灯restaurantLight.c

//餐厅灯
#include "contrlDevices.h"

int restaurantLightOpen(int pinNum)
{
    digitalWrite(pinNum, LOW);
}

int restaurantLightClose(int pinNum)
{
    digitalWrite(pinNum, HIGH);
}

int restaurantLightCloseInit(int pinNum)
{
    pinMode(pinNum, OUTPUT);
    digitalWrite(pinNum, HIGH);
  //  printf("餐厅灯初始化成功\n");
}

int restaurantLightCloseStatus(int status)
{
}

struct Devices restaurantLight = {
    //.deviceName = "restaurantLight",
    .deviceName = "chu",
    .pinNum = 23,
    .open = restaurantLightOpen,
    .close = restaurantLightClose,
    .deviceInit = restaurantLightCloseInit,
    .changStatus = restaurantLightCloseStatus};

struct Devices *addrestaurantLightToDeviceLink(struct Devices *phead)
{
    if (phead == NULL)
    {
        return &restaurantLight;
    }
    else
    {
        restaurantLight.next = phead;
        phead = &restaurantLight;
    }
    return phead;
}

18.客厅灯upstairLight.c

//客厅灯
#include <stdlib.h>
#include <fcntl.h>
#include "contrlDevices.h"

int upstairLightOpen(int pinNum) //打开客厅灯函数
{
    digitalWrite(pinNum, LOW);
}

int upstairLightClose(int pinNum) //关闭客厅灯函数
{
    digitalWrite(pinNum, HIGH);
}

int upstairLightCloseInit(int pinNum) //初始化函数
{
    pinMode(pinNum, OUTPUT);    //配置引脚为输出引脚
    digitalWrite(pinNum, HIGH); //引脚输出高电平，即默认为关闭状态
   // printf("客厅灯初始化成功\n");
}

int upstairLightCloseStatus(int status)
{
}

struct Devices upstairLight = { //客厅灯设备链表节点
    .deviceName = "kt",
    .pinNum = 22,
    .open = upstairLightOpen,
    .close = upstairLightClose,
    .deviceInit = upstairLightCloseInit,
    .changStatus = upstairLightCloseStatus

};

struct Devices *addupStairLightToDeviceLink(struct Devices *phead) //头插法将设备节点加入设备工厂链表函数
{
    if (phead == NULL)
    {
        return &upstairLight;
    }
    else
    {
        upstairLight.next = phead;
        phead = &upstairLight;
    }
}

19.视频监控脚本start_web_video.sh

cd ../mjpg-streamer/mjpg-streamer-experimental/

./mjpg_streamer -i "./input_raspicam.so" -o "./output_http.so -w ./www"

@小高同学

关注

26
点赞
踩
205

收藏

觉得还不错? 一键收藏
打赏
22
评论
基于树莓派的智能家居控制系统设计

1.通过手机APP、语音识别等控制家电，对门锁，灯光、电风扇等设备进行控制，开发回家模式，睡觉模式等应用场景。2.通过视频监控、火灾报警、震动报警和人体感应报警保证家居的安全。3.将温湿度检测数据和家居安防状况实时同步到用户的手机APP进行显示。4.遥控控制可以保证在没有网络的情况下也可以对家居进行控制。5.通过翔云平台提供的人脸对比服务完成人脸识别开锁1.家居模型实物2.部分功能展示火灾测试火灾报警视频监控温湿度检测人脸识别按钮人脸识别开锁1.主程序mainPro.c2.摄像
复制链接

扫一扫