智能家居项目详细思路整理(未完成)

main函数（所有的头文件都放到最后）

事先创建好一个管理线程的链表control_list，并且将mqd和control链表再封装一个结构体ctrl_info

1、初始化(链表、临时指针、累计数、wiringPi库)

2、获取消息队列描述符

3、将各个线程都放入链表中

4、遍历链表，初始化各个线程并且统计链表节点个数

5、遍历链表，创建各个线程

6、等待线程结束时回收资源

7、全部线程结束后释放所有资源、以及销毁消息队列的资源

6和7一般不会执行到，因为在各个线程里面都是死循环

整个项目的逻辑是，语音线程、网络线程、烟雾报警线程一直循环等待，在收到数据之后发送给消息处理线程，再去处理对应的逻辑，语音播报或者进行家具的控制或者OLED屏幕显示

整个项目开启4个监听线程， 分别是：

1.语音监听线程:用于监听语音指令， 当有语音指令过来后， 通过消息队列的方式给消息处理线程发送指令

2.网络监听线程：用于监听网络指令，当有网络指令过来后， 通过消息队列的方式给消息处理线程发送指令

3.火灾检测线程：当存在煤气泄漏或者火灾闲情时， 发送警报指令给消息处理线程

4.消息监听线程： 用于处理以上3个线程发过来的指令，并根据指令要求配置GPIO引脚状态， OLED屏显示、语音播报，还有人脸识别开门

上述四个线程采用统一个对外接口接口，同时添加到监听链表中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
//main.c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <wiringPi.h>

#include "control.h"
#include "msg_queue.h"
#include "voice_interface.h"
#include "global.h"
#include "socket_interface.h"
#include "smoke_interface.h"
#include "receive_interface.h"

int main(int argc,char *argv[])
{
    pthread_t thread_id;						//初始化(链表、临时指针、累计数、wiringPi库)
    struct control *control_phead = NULL;
    struct control *pointer = NULL;
    ctrl_info_t *ctrl_info = NULL;
	ctrl_info = (ctrl_info_t *)malloc(sizeof(ctrl_info_t));
	ctrl_info->ctrl_phead = NULL;
	ctrl_info->mqd = -1;

    int node_num = 0;

    wiringPiSetup();
    ctrl_info->mqd = msg_queue_create();	//获取消息队列描述符

    if(ctrl_info->mqd == -1)
    {
        printf("msg_queue_create failed \n");
        return -1;
    }

    //将各个线程都放入链表中
    ctrl_info->ctrl_phead = add_voice_to_ctrl_list(ctrl_info->ctrl_phead);
    ctrl_info->ctrl_phead = add_tcpsocket_to_ctrl_list(ctrl_info->ctrl_phead);
    ctrl_info->ctrl_phead = add_smoke_to_ctrl_list(ctrl_info->ctrl_phead);
    ctrl_info->ctrl_phead = add_receive_to_ctrl_list(ctrl_info->ctrl_phead);
	
    pointer = ctrl_info->ctrl_phead;		//将临时指针指向头节点
    //遍历链表，初始化各个线程并且统计链表节点个数
    while(pointer != NULL)
    {
        if(pointer->init != NULL)
        {
            pointer->init();
        }
        pointer = pointer->next;
        node_num ++;
    }
    
	//为线程ID申请内存空间
    pthread_t *tid = malloc(sizeof(int)*node_num);

    pointer = ctrl_info->ctrl_phead;
    
    //遍历链表，创建各个线程
    for(int i=0;i<node_num;i++)
    {
        if(pointer->get != NULL)
        pthread_create(&tid[i],NULL,(void*)pointer->get,(void*)ctrl_info);
        pointer = pointer->next;
    }
	
    //等待线程结束时回收资源
    for(int i=0;i<node_num;i++)
    {
        pthread_join(tid[i],NULL);
    }
	
    //全部线程结束后释放所有资源
    for(int i=0;i<node_num;i++)
    {
        if(pointer->final != NULL)
            pointer->final();
        pointer = pointer->next;
    }
	
    //销毁消息队列的资源
    msg_queue_final(ctrl_info->mqd);

    return 0;
}

人脸识别代码(C语言调用python函数并接收返回值)

1、初始化：python环境、路径、模块初始化

2、结束：释放所有引用的Python对象

3、人脸识别

​ 3.1将本地的人脸照片上传阿里云OCR

​ 3.2导入face.py模块

​ 3.3获取alibabacloud_face函数对象

​ 3.4调用alibabacloud_face函数并获取返回值

​ 3.5解析获取alibabacloud_face函数的返回值，转行为C语言格式

​ 3.6最后释放所有python资源并返回比对的结果数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
//face.c
#include <Python.h>
#include <stdio.h>

#include "face.h"

#define WEGET_CMD "wget http://192.168.1.6:8080/?action=snapshot -O /tmp/SearchFace.jpg"
#define SEARCHFACE_FILE "/tmp/SearchFace.jpg"

void face_initialize(void)
 {
    Py_Initialize();
    // 将当前路径添加到sys.path中
    PyObject *sys = PyImport_ImportModule("sys");
    PyObject *path = PyObject_GetAttrString(sys, "path");
    PyList_Append(path, PyUnicode_FromString("."));
 }

void face_final(void)
 {
    //释放所有引用的Python对象
    Py_Finalize();
 }

double face_category(void)
 {
    double result = 0.0;
	system(WEGET_CMD);			//将本地的人脸照片上传阿里云OCR

    if(access(SEARCHFACE_FILE,F_OK) != 0)
    {
        return result;
    }

    PyObject *pModule = PyImport_ImportModule("face");//导入face.py模块
    if (!pModule)
    {
        PyErr_Print();
        printf("Error: failed to load face.py\n");
        goto FAILED_MODULE;
    }
    
	//获取alibabacloud_face函数对象
    PyObject *pFunc = PyObject_GetAttrString(pModule, "alibaba_face");
    if (!pFunc)
    {
        PyErr_Print();
        printf("Error: failed to load alibaba_face\n");
        goto FAILED_FUNC;
    }

    PyObject *pValue = PyObject_CallObject(pFunc, NULL);//调用alibabacloud_face函数并获取返回值
    if (!pValue)
    {
        PyErr_Print();
        printf("Error: function call failed\n");
        goto FAILED_VALUE;
    }
    if  (!PyArg_Parse(pValue, "d", &result))//解析获取alibabacloud_face函数的返回值，转行为C语言格式
    {
        PyErr_Print();
        printf("Error: parse failed");
        goto FAILED_RESULT;
    }

    printf("result = %0.2lf\n",result);
    FAILED_RESULT:
        Py_DECREF(pValue);
    FAILED_VALUE:
        Py_DECREF(pFunc);
    FAILED_FUNC:
        Py_DECREF(pModule);
    FAILED_MODULE:

        return result;

}

人脸识别face.py

事先需引入依赖包，在阿里云创建AccessKey 并配置环境变量

并且创建并从环境变量中读取AccessKey ID和AccessKey Secret

1、读取本地的人脸照片

2、指定搜索的人脸库

3、#初始化，传入AccessKey

4、调用人脸识别API，并且返回比对结果

5、提取并处理比对结果（字典->浮点型）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
# 引入依赖包
# pip install alibabacloud_facebody20191230
# face.py
import os
import io
from urllib.request import urlopen
from alibabacloud_facebody20191230.client import Client
from alibabacloud_facebody20191230.models import SearchFaceAdvanceRequest
from alibabacloud_tea_openapi.models import Config
from alibabacloud_tea_util.models import RuntimeOptions
config = Config(
    # 创建AccessKey ID和AccessKey Secret，请参考https://help.aliyun.com/document_detail/175144.html。
    # 如果您用的是RAM用户的AccessKey，还需要为RAM用户授予权限AliyunVIAPIFullAccess，请参考https://help.aliyun.com/document_detail/145025.html。
    # 从环境变量读取配置的AccessKey ID和AccessKey Secret。运行代码示例前必须先配置环境变量。
    access_key_id=os.environ.get('ALIBABA_CLOUD_ACCESS_KEY_ID'),
    access_key_secret=os.environ.get('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
    # 访问的域名
    endpoint='facebody.cn-shanghai.aliyuncs.com',
    # 访问的域名对应的region
    region_id='cn-shanghai'
)
def alibaba_face():
  search_face_request = SearchFaceAdvanceRequest()
  #场景一：文件在本地
  stream0 = open(r'/tmp/SearchFace.jpg', 'rb')
  search_face_request.image_url_object = stream0
  #场景二：使用任意可访问的url
  #url = 'https://viapi-test-bj.oss-cn-beijing.aliyuncs.com/viapi3.0domepic/facebody/SearchFace1.png'
  #img = urlopen(url).read()
  #search_face_request.image_url_object = io.BytesIO(img)
  search_face_request.db_name = 'default'					#指定搜索的人脸库
  search_face_request.limit = 5
  #关闭流
  #stream0.close()
  runtime_option = RuntimeOptions()
  try:
    # 初始化Client
    client = Client(config)							#初始化，传入AccessKey
    response = client.search_face_advance(search_face_request, runtime_option)#调用人脸识别API，并且返回比对结果
    # 比对结果提取
    match_list = response.body.to_map()['Data']['MatchList']
    scores = [item['Score'] for item in match_list[0]['FaceItems']]  
    highest_score = max(scores)
    value = round(highest_score, 2)
    #print(value)
    return value
  except Exception as error:
    # 获取整体报错信息
    print(error)
    # 获取单个字段
    print(error.code)
    # tips: 可通过error.__dict__查看属性名称
    return 0.0

  #关闭流
  #stream0.close()
if __name__ =="__main__":
  alibaba_face()

语音线程

各种错误处理，然后接收串口发送来的数据，符合格式的话就发送数据到消息队列，再将缓冲区清空，等待下次数据到来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
//voice_interface.c
#include <pthread.h>
#include <stdio.h>

#include "voice_interface.h"
#include "uartTool.h"
#include "msg_queue.h"
#include "global.h"


static int serial_fd  = -1;

static int voice_init(void)								  //初始化语音线程
{
    serial_fd = myserialOpen (SERIAL_DEV, BAUD);			//打开串口，传入设备、波特率
    printf("%s|%s|%d:serial_fd=%d\n", __FILE__, __func__, __LINE__, serial_fd);

    return serial_fd;

}

static void voice_final(void)								//销毁串口描述符
{
    if (-1 != serial_fd)
    {
        close(serial_fd);
        serial_fd = -1;
    }
}

//接收语音指令
static void *voice_get(void *arg)  // mqd应该来自于arg传参
{
    unsigned char buffer[6] = {0x00, 0x00, 0x00, 0x00, 0X00, 0x00};
    int len = 0;
    mqd_t mqd = -1;
    ctrl_info_t *ctrl_info= NULL;
     if (NULL != arg)
        ctrl_info = (ctrl_info_t *)arg;

    if (-1 == serial_fd)
    {
        serial_fd = voice_init();				//初始化
        if (-1 == serial_fd)
        {
            pthread_exit(0);
        }
    }
     
    if(NULL != ctrl_info)
    {
        mqd =  ctrl_info->mqd;
    }

   if ((mqd_t)-1 == mqd)
   {
        pthread_exit(0);
   }

    pthread_detach(pthread_self());				//标记为分离状态，与创建它的线程分离，结束后自动释放资源
    
    printf("%s thread start\n", __func__);
    
    while(1)
    {
        len = serialGetstring(serial_fd, buffer);	//等待串口接收用户传来的数据，放到buffer中
        printf("%s|%s|%d:0x%x, 0x%x,0x%x, 0x%x, 0x%x,0x%x\n", __FILE__, __func__, __LINE__, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4],buffer[5]);
        printf("%s|%s|%d:len=%d\n", __FILE__, __func__, __LINE__, len);
        if (len > 0)
        {
            if(buffer[0] == 0xAA && buffer[1] == 0x55
             && buffer[5] == 0xAA && buffer[4] == 0x55)
             {
                printf("%s|%s|%d:send 0x%x, 0x%x,0x%x, 0x%x, 0x%x,0x%x\n", __FILE__, __func__, __LINE__, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4],buffer[5]);
                //发送接收来的数据到消息队列中
                send_message(mqd, buffer, len);//注意，不要用strlen去计算实际的长度
             }
             memset(buffer, 0, sizeof(buffer));		//将buffer重新置为0，等待下一次指令
        }
    }
    
    pthread_exit(0);

}


//语音播报
static void *voice_set(void *arg)
{
    pthread_detach(pthread_self());					//线程分离
    unsigned char *buffer = (unsigned char *)arg;
     if (-1 == serial_fd)
    {
        serial_fd = voice_init();
        if (-1 == serial_fd)
        {
            pthread_exit(0);
        }
    }
    
    if (NULL != buffer)
    {
        serialSendstring(serial_fd, buffer, 6);		//用串口发送给语音模块，语音播报
    }
    
    pthread_exit(0); 

}

struct control voice_control = {		//定义语音线程节点的数据
    .control_name = "voice",
    .init = voice_init,
    .final = voice_final,
    .get = voice_get,
    .set = voice_set,
    .next = NULL
};

struct control *add_voice_to_ctrl_list(struct control *phead)	//将语音线程传入链表
{//头插法

  return add_interface_to_ctrl_list(phead, &voice_control);

};

自己实现的串口初始化，收发数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 //uarTool.c
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdarg.h>
 #include <string.h>
 #include <termios.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <sys/stat.h>

 int myserialOpen (const char *device, const int baud)
 {
    struct termios options ;
    speed_t myBaud ;
    int  status, fd ;
    switch (baud)									//设置波特率
    {
        case 9600:   
            myBaud = B9600 ;
            break;
        case 115200:
            myBaud =  B115200 ;
            break;
    }
    if ((fd = open (device, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK)) == -1)//打开串口设备
    return -1 ;

    fcntl (fd, F_SETFL, O_RDWR) ;

    // Get and modify current options:
    tcgetattr (fd, &options) ;

    cfmakeraw   (&options) ;
    cfsetispeed (&options, myBaud) ;
    cfsetospeed (&options, myBaud) ;

     //设置控制标志，奇偶校验、数据位8位
    options.c_cflag |= (CLOCAL | CREAD) ;
    options.c_cflag &= ~PARENB ;
    options.c_cflag &= ~CSTOPB ;
    options.c_cflag &= ~CSIZE ;
    options.c_cflag |= CS8 ;
    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG) ;
    options.c_oflag &= ~OPOST ;
    options.c_cc [VMIN]  =   0 ;
    options.c_cc [VTIME] = 100 ; 

    // Ten seconds (100 deciseconds)
     //设置寄存器的状态
    tcsetattr (fd, TCSANOW, &options) ;
    ioctl (fd, TIOCMGET, &status);
    status |= TIOCM_DTR ;
    status |= TIOCM_RTS ;
    ioctl (fd, TIOCMSET, &status);
    usleep (10000) ;// 10mS   
    return fd ;
 }
 //会传递0XAA 0X55 0X46 0x00 0X55 0XAA类似的参数
void serialSendstring (const int fd, const unsigned char *s, int len)
{
    int ret;
    ret = write (fd, s, len);
    if (ret < 0)
    printf("Serial Puts Error\n");
}

int serialGetstring (const int fd, unsigned char *buffer)
{
    int n_read;
    n_read = read(fd, buffer,32);
    return n_read;
}

链表实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//control.c
#include <stdio.h>
#include "control.h"


struct control *add_interface_to_ctrl_list(struct control *phead, struct control *control_interface)
{//头插法

    if (NULL == phead)
    {
        phead = control_interface;
    }
    else
    {
        control_interface->next = phead;
        phead = control_interface;
    }
    
    return phead;

};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//control.h
#ifndef __CONTROL_H
#define __CONTROL_H
struct control
{
    char control_name[128]; //监听模块名称 
    int (*init)(void); //初始化函数
    void (*final)(void);//结束释放函数
    void *(*get)(void *arg);//监听函数，如语音监听
    void *(*set)(void *arg); //设置函数，如语音播报

    struct control *next;
};

struct control *add_interface_to_ctrl_list(struct control *phead, struct control *control_interface);

#endif

网络线程

1、init函数：创建socket描述符，传入IP地址和端口

2、close函数：关闭文件描述符

3、等待接收指令：

​ 3.1、启用TCP保活机制，故障时自动断开

​ 3.2、各种错误处理，线程、socket、消息队列描述符

​ 3.3、accept接收消息

​ 3.4、处理获取得到的消息，符合格式的消息后发送消息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
//socket_interface.c
#include <stdio.h>
#include <pthread.h>

#include "socket.h"
#include "control.h"
#include "global.h"
#include "socket_interface.h"
#include "msg_queue.h"

static int s_fd = -1;

static int tcpsocket_init(void)
{
    s_fd = socket_init(IPADDR,IPPORT);
    return -1;
}

static void tcpsocket_final(void)
{
    close(s_fd);
    s_fd = -1;
}

static void *tcpsocket_get(void *arg)
{
    int c_fd = -1;
    int ret = -1;
    struct sockaddr_in c_addr;
    unsigned char buffer[BUF_SIZE];
    mqd_t mqd = -1;
    ctrl_info_t *ctrl_info= NULL;
    int keepalive = 1; // 开启TCP_KEEPALIVE选项
    int keepidle = 10; // 设置探测时间间隔为10秒
    int keepinterval = 5; // 设置探测包发送间隔为5秒
    int keepcount = 3; // 设置探测包发送次数为3次

    pthread_detach(pthread_self());

    printf("%s|%s|%d: s_fd = %d\n", __FILE__, __func__, __LINE__,s_fd);

    if (-1 == s_fd)
    {
        s_fd = tcpsocket_init();
        if (-1 == s_fd)
        {
            printf("tcpsocket_init failed\n");
            pthread_exit(0);
        }
    }

    if (NULL != arg)
        ctrl_info = (ctrl_info_t *)arg;
    
    if(NULL != ctrl_info)
    {
        mqd =  ctrl_info->mqd;
      
    }

    if ((mqd_t)-1 == mqd)
    {
        pthread_exit(0);
    }
 
    memset(&c_addr,0,sizeof(struct sockaddr_in));

     //4. accept
    int clen = sizeof(struct sockaddr_in);
    printf("%s thread start\n", __func__);
    while (1)
    {
        c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);  
        if (-1 == c_fd)
        {
            continue;
        }
        ret = setsockopt(c_fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive)); // 设置TCP_KEEPALIVE选项
        if (ret == -1) { // 如果设置失败，打印错误信息并跳出循环
            perror("setsockopt");
            break;
        }
        ret = setsockopt(c_fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepidle, sizeof(keepidle)); // 设置探测时间间隔选项
        if (ret == -1) { // 如果设置失败，打印错误信息并跳出循环
            perror("setsockopt");
            break;
        }
        ret = setsockopt(c_fd, IPPROTO_TCP, TCP_KEEPINTVL, &keepinterval, sizeof(keepinterval)); // 设置探测包发送间隔选项
        if (ret == -1) { // 如果设置失败，打印错误信息并跳出循环
            perror("setsockopt");
            break;
        }
        ret = setsockopt(c_fd, IPPROTO_TCP, TCP_KEEPCNT, &keepcount, sizeof(keepcount)); // 设置探测包发送次数选项
        if (ret == -1) { // 如果设置失败，打印错误信息并跳出循环
            perror("setsockopt");
            break;
        }
        
        printf("Accepted a connection from %s:%d\n", inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port)); // 打印客户端的IP地址和端口号

        while (1) 
        {
            memset(buffer, 0, BUF_SIZE);
            ret = recv(c_fd, buffer, BUF_SIZE, 0);
            printf("ret = %d\n",ret);
            printf("%s|%s|%d: 0x%x, 0x%x,0x%x, 0x%x, 0x%x,0x%x\n", __FILE__, __func__, __LINE__, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4],buffer[5]);
            if (ret > 0)
            {
                
                if(buffer[0] == 0xAA && buffer[1] == 0x55 && buffer[5] == 0xAA && buffer[4] == 0x55)
                {
                    printf("%s|%s|%d:send 0x%x, 0x%x,0x%x, 0x%x, 0x%x,0x%x\n", __FILE__, __func__, __LINE__, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4],buffer[5]);
                    mq_send(mqd, buffer, ret,0);//注意，不要用strlen去计算实际的长度
                }
            }
                else if ( -1 == ret || 0 == ret)
                {
                    break;
                }
        }

    }

    pthread_exit(0);

 }
struct control tcpsocket_control = {
    .control_name = "tcpsocket",
    .init = tcpsocket_init,
    .final = tcpsocket_final,
    .get = tcpsocket_get,
    .set = NULL,
    .next = NULL
};

struct control *add_tcpsocket_to_ctrl_list(struct control *phead)
 {
    //头插法
    return add_interface_to_ctrl_list(phead, &tcpsocket_control);
 };

烟雾报警线程

初始化，各种错误处理，读取GPIO口的状态给标志位，当标志位持续为低时每五秒发出一个警告，当标志位为高且当前GPIO口状态为高时将标志位置低，未触发烟雾报警仅执行一次，后面就是常规的结束线程，一般不执行，因为前面死循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#include <stdio.h>
#include <pthread.h>
#include <wiringPi.h>

#include "control.h"
#include "global.h"
#include "smoke_interface.h"
#include "msg_queue.h"

#define SMOKE_PIN  6
#define SMOKE_MODE INPUT

static int smoke_init(void)
{
    pinMode(SMOKE_PIN,SMOKE_MODE);
    return -1;
}


static void *smoke_get(void *arg)
{
    unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};
    ctrl_info_t *ctrl_info = NULL;
    mqd_t mqd = -1;
    int smoke_signal = 0;
    int status = HIGH;
    int sendsize = -1;

    pthread_detach(pthread_self());
    printf("%s thread start\n", __func__);

    if(arg != NULL)
    {
        ctrl_info = (ctrl_info_t *)arg;
    }

    if(NULL != ctrl_info)
    {
        mqd =  ctrl_info->mqd;  
    }

    if ((mqd_t)-1 == mqd)
    {
        pthread_exit(0);
    }

    while(1)
    {
        status = digitalRead(SMOKE_PIN);
        if(status == LOW)
        {
            smoke_signal = 1;
            buffer[2] = 0x45;
            buffer[3] = 0x00;
            printf("%s|%s|%d:send 0x%x, 0x%x,0x%x, 0x%x, 0x%x,0x%x\n", __FILE__, __func__, __LINE__, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4],buffer[5]);
            sendsize = mq_send(mqd,buffer,6,0);
            if(sendsize == -1)
            {
                continue;
            }
        }
        else if(status == HIGH && smoke_signal == 1)
        {
            smoke_signal = 0;
            buffer[2] = 0x45;
            buffer[3] = 0x01;
            printf("%s|%s|%d:send 0x%x, 0x%x,0x%x, 0x%x, 0x%x,0x%x\n", __FILE__, __func__, __LINE__, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4],buffer[5]);
            sendsize = mq_send(mqd,buffer,6,0);
            if(sendsize == -1)
            {
                continue;
            }
        }
        sleep(5);
    }
    pthread_exit(0);
}


struct control smoke_control = {
    .control_name = "smoke",
    .init = smoke_init,
    .final = NULL,
    .get = smoke_get,
    .set = NULL,
    .next = NULL
};

struct control *add_smoke_to_ctrl_list(struct control *phead)
 {
    //头插法
    return add_interface_to_ctrl_list(phead, &smoke_control);
 };

消息队列线程

gdevice是灯、风扇、锁家具的管理链表

1、定义handler_gdevice函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
#include <pthread.h>
#include <mqueue.h>
#include <stdlib.h>
#include <stdio.h>

#include "wiringPi.h"
#include "control.h"
#include "receive_interface.h" 
#include "msg_queue.h"
#include "global.h"
#include "face.h"
#include "myoled.h"
#include "ini.h"
#include "gdevice.h"

typedef struct {
    int msg_len;
    unsigned char *buffer;
    ctrl_info_t *ctrl_info;
}recv_msg_t;


static int oled_fd = -1;
static struct gdevice *pdevhead = NULL;


#define MATCH(s, n) strcmp(section, s) == 0 && strcmp(name, n) == 0

static int handler_gdevice(void* user, const char* section, const char* name,
                   const char* value)
{
    struct gdevice *pdev = NULL;

    if (NULL == pdevhead)				//如果链表是空的，将设备放到头节点
    {
        pdevhead = (struct gdevice *)malloc(sizeof(struct gdevice));
        pdevhead->next = NULL;
        memset(pdevhead, 0, sizeof(struct gdevice));
        strcpy(pdevhead->dev_name, section);
    }
    else if (0 != strcmp(section, pdevhead->dev_name))//如果链表并不为空并且两个设备名字不同
    {
        pdev = (struct gdevice *)malloc(sizeof(struct gdevice));//为pdev链表申请内存
    	memset(pdev, 0, sizeof(struct gdevice));				//初始化为0
        strcpy(pdev->dev_name, section);						//复制section到dev_name
        pdev->next = pdevhead;									//将旧头节点放到新头节点后
        pdevhead = pdev;										//头节点放到pdevhead里
    }

    if (NULL != pdevhead)						//经过前面的分支后，头节点不再是空
    {
        if(MATCH(pdevhead->dev_name, "key")) 		//比对设备名字和key值是否匹配
        {
            sscanf(value, "%x", &pdevhead->key);
            printf("%d|pdevhead->key=%x\n",__LINE__, pdevhead->key);
        }
        else if(MATCH(pdevhead->dev_name, "gpio_pin"))
        { 
            pdevhead->gpio_pin = atoi(value);
            printf("%d|pdevhead->gpio_pin=%d\n",__LINE__, pdevhead->gpio_pin);
        }
        else if(MATCH(pdevhead->dev_name, "gpio_mode"))
        {
            if(strcmp(value, "OUTPUT") == 0)
            {
                pdevhead->gpio_mode = OUTPUT; //OUTPUT
                printf("%d|pdevhead->gpio_mode=%d\n",__LINE__, pdevhead->gpio_mode);
            }
            else if (strcmp(value, "INPUT") == 0)
            {
                pdevhead->gpio_mode = INPUT;
                printf("%d|pdevhead->gpio_mode=%d\n",__LINE__, pdevhead->gpio_mode);
            }
        }
        else if(MATCH(pdevhead->dev_name, "gpio_status"))
        {
            if(strcmp(value, "LOW") == 0)
            {
                pdevhead->gpio_mode = LOW; //OUTPUT
                printf("%d|pdevhead->gpio_status=%d\n",__LINE__, pdevhead->gpio_status);
            }
            else if (strcmp(value, "HIGH") == 0)
            {
                pdevhead->gpio_mode = HIGH;
                printf("%d|pdevhead->gpio_status=%d\n",__LINE__, pdevhead->gpio_status);
            }
        } 
        else if(MATCH(pdevhead->dev_name, "check_face_status")) 
        {
             pdevhead->check_face_status = atoi(value);  
             printf("%d|pdevhead->check_face_status=%d\n",__LINE__, pdevhead->check_face_status);        
        }
        else if(MATCH(pdevhead->dev_name, "voice_set_status")) 
        {
             pdevhead->voice_set_status = atoi(value);  
             printf("%d|pdevhead->voice_set_status=%d\n",__LINE__, pdevhead->voice_set_status);          
        }
    }
    return 1;
}


static int receive_init(void)
{
   
    if (ini_parse("./gdevice.ini", handler_gdevice, NULL) < 0) {
        printf("Can't load 'gdevice.ini'\n");
        return 1;
    }
 
    oled_fd = myoled_init();
    face_initialize();

    return oled_fd;
}

static void receive_final(void)
{
    face_final();
    if(oled_fd != -1)
    {
        close(oled_fd);
        oled_fd = -1;
    }
}

static void *handle_device(void *arg)
{
    recv_msg_t *recv_msg = NULL;
    struct gdevice *cur_gdev = NULL;
    char success_or_failed[20] = "success";
    int ret = -1;
    pthread_t tid = -1;
    int smoke_status = 0;
    double face_result = 0.0;

     pthread_detach(pthread_self());
    //do something
    if (NULL != arg)
    {
        recv_msg = (recv_msg_t *)arg;
        printf("recv_msg->msg_len = %d\n", recv_msg->msg_len);
        printf("%s|%s|%d:handle 0x%x, 0x%x,0x%x, 0x%x, 0x%x,0x%x\n", __FILE__, __func__, __LINE__, recv_msg->buffer[0], recv_msg->buffer[1], recv_msg->buffer[2], recv_msg->buffer[3], recv_msg->buffer[4],recv_msg->buffer[5]);
    }

    if (NULL != recv_msg && NULL != recv_msg->buffer)
    {
        cur_gdev = find_device_by_key(pdevhead, recv_msg->buffer[2]);
    }

    if (NULL != cur_gdev)
    {
        cur_gdev->gpio_status = recv_msg->buffer[3] == 0 ? LOW : HIGH;
        //special for lock
        printf("%s|%s|%d:cur_gdev->check_face_status=%d\n", __FILE__, __func__, __LINE__, cur_gdev->check_face_status);
        if (1 == cur_gdev->check_face_status)
        {
            face_result = face_category();
            printf("%s|%s|%d:face_result=%f\n", __FILE__, __func__, __LINE__, face_result);
            if (face_result > 0.6)
            {
                ret = set_gpio_gdevice_status(cur_gdev);
                recv_msg->buffer[2] = 0x47;
            }
            else
            {
                recv_msg->buffer[2] = 0x46;
                ret = -1;
            }
        }
        else if (0 == cur_gdev->check_face_status)
        {
            ret = set_gpio_gdevice_status(cur_gdev);
        }

        
        if(1 ==  cur_gdev->voice_set_status)
        {
        
            if (NULL != recv_msg && NULL != recv_msg->ctrl_info && NULL != recv_msg->ctrl_info->ctrl_phead)
            {
                struct control *pcontrol = recv_msg->ctrl_info->ctrl_phead;
                while (NULL != pcontrol)
                {  
                    
                    if (strstr(pcontrol->control_name, "voice"))
                    {
                        if (0x45 == recv_msg->buffer[2] && 0 == recv_msg->buffer[3])
                        {
                            smoke_status = 1;
                        
                        }
                        pthread_create(&tid, NULL, pcontrol->set, (void *)recv_msg->buffer);
                        break;
                    }
                    pcontrol = pcontrol->next;
                }
            }
        }


        if (-1 == ret)
        {
            memset(success_or_failed, '\0', sizeof(success_or_failed));
            strncpy(success_or_failed, "failed", 6);
        }

        //oled屏显示
        char oled_msg[512];
        memset(oled_msg, 0, sizeof(oled_msg));
        char *change_status = cur_gdev->gpio_status == LOW ? "Open" : "Close";
        sprintf(oled_msg, "%s %s %s!\n", change_status, cur_gdev->dev_name, success_or_failed);
        //special for smoke 
        if(smoke_status == 1)
        {
            memset(oled_msg, 0, sizeof(oled_msg));
            strcpy(oled_msg, "A risk of fire!\n");
        }

        printf("oled_msg=%s\n", oled_msg);
        oled_show(oled_msg);


        //special for lock, close lock
        if (1 == cur_gdev->check_face_status && 0 == ret && face_result > 0.6)
        {
            sleep(5);
            cur_gdev->gpio_status = HIGH;
            set_gpio_gdevice_status(cur_gdev);
        }

    }   


     pthread_exit(0);
}

static void* receive_get(void *arg)
{
    recv_msg_t *recv_msg = NULL;
    ssize_t read_len = -1;
    pthread_t tid = -1;
    char *buffer = NULL;
    struct mq_attr attr;

    if (NULL != arg)
    {
        recv_msg = (recv_msg_t *)malloc(sizeof(recv_msg_t));
        recv_msg->ctrl_info = (ctrl_info_t *)arg; //获取到mqd 和phead (struct control 链表的头结点)
        recv_msg->msg_len = -1;
        recv_msg->buffer = NULL;

    }
    else
    {
        pthread_exit(0);
    }


    if(mq_getattr(recv_msg->ctrl_info->mqd, &attr) == -1)
    {
        pthread_exit(0);
    }

    recv_msg->buffer = (unsigned char *)malloc(attr.mq_msgsize);
    buffer = (unsigned char *)malloc(attr.mq_msgsize);
    memset(recv_msg->buffer, 0, attr.mq_msgsize);
    memset(buffer, 0, attr.mq_msgsize);
    pthread_detach(pthread_self());
    while(1)
    {
        read_len = mq_receive(recv_msg->ctrl_info->mqd, buffer, attr.mq_msgsize, NULL);
        printf("%s|%s|%d:send 0x%x, 0x%x,0x%x, 0x%x, 0x%x,0x%x\n", __FILE__, __func__, __LINE__, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4],buffer[5]);
        printf("%s|%s|%d:read_len=%ld\n", __FILE__, __func__, __LINE__, read_len);
        if (-1 == read_len)
        {
            if(errno == EAGAIN)
            {
                printf("queue is empyt\n");
            }
            else
            {
                break;
            }
        }
        else if(buffer[0] == 0xAA && buffer[1] == 0x55
             && buffer[5] == 0xAA && buffer[4] == 0x55)
        {
            recv_msg->msg_len = read_len;
            memcpy(recv_msg->buffer, buffer, read_len);
            pthread_create(&(tid), NULL, handle_device, (void *)recv_msg);
        }
    }
    pthread_exit(0);

}


struct control receive_control = {
    .control_name = "receive",
    .init = receive_init,
    .final = receive_final,
    .get = receive_get,
    .set = NULL,
    .next = NULL
};

struct control *add_receive_to_ctrl_list(struct control *phead)
{//头插法
    return add_interface_to_ctrl_list(phead, &receive_control);
};
赏

路过，写太好了/加我微信请备注

支付宝
微信

扫一扫，分享到微信

微信分享二维码
# PV方式，单个用户连续点击 n 篇，记录 n 次记录值 本站总访问量次 # UV方式，单个用户连续点击 n 篇，记录 1 次记录值 本站访客数人次

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

不必着急，生命自会找到答案<br><br>联系我<br>yuansd525@163.com