当前位置：首页 > article >正文

【全志H616】【开源】 ARM-Linux 智能分拣项目：阿里云、网络编程、图像识别

article 2024/11/16 13:26:19

【全志H616】【开源】 ARM-Linux 智能分拣项目：阿里云、网络编程、图像识

文章目录

【全志H616】【开源】 ARM-Linux 智能分拣项目：阿里云、网络编程、图像识
- 1、实现功能
- 2、软件及所需环境
- 3、逻辑流程图及简述
- - 3.1 完整逻辑流程图
  - 3.2 硬件接线
  - 3.3 功能简述
  - - 3.3.1 main()
    - 3.3.2 main函数中打开的语音、网络、阿里云交互线程
    - - 3.3.2.1 **语音线程**
      - 3.3.2.2 网络线程
      - 3.3.2.3 阿里云交互线程
      - 3.3.2.4 阿里云交互线程`pcategory`开的3个线程
- 4、实验程序
- - 4.1 `uartTool` 串口
  - 4.2 `socket` 网络
  - 4.3 阿里云 `garbage` 识别
  - 4.4 `PWM` sg90舵机
  - 4.5 OLED` 显示
  - 4.6 `main.c`
- 5、实验流程和执行结果
- - 5.1 配置客户端和`mjpg_Stream`
  - 5.2 调试和运行
  - 5.3 开始识别
- 6、总结

1、实现功能

语音接入控制垃圾分类识别并触发垃圾桶的开关盖，并根据垃圾类型开关不同类型垃圾桶
利用TCP的Socket编程，实现Sockect发送指令远程控制垃圾分类识别，引入心跳包来检测客户端状态，防止客户端异常关闭导致进程堵塞
为什么要用 TCP的socket编程通过网络来控制呢？
是为了可以通过远程PC来实现对硬件的控制
调用阿里云接口实现物品的动态识别服务，将识别到的物品类型返回，并最终通过语音模块播报
语音播报垃圾物品类型
OLED显示垃圾物品类型
多线程编程使用多线程编程来解决多并发的问题

看下面的流程图会更清晰

2、软件及所需环境

Ubantu-22.04、MoberXterm、arach64-linux-gnu、VCS-ssh、全志开发板、SU-03T语音模块、OLED显示屏、USB摄像头、SG90舵机

语音烧入软件&SU-03T语音模块的配置文件：

链接: https://pan.baidu.com/s/1SfNVrNmBR02YqE7lU2LiVQ?pwd=2222 提取码: 2222 复制这段内容后打开百度网盘手机App，操作更方便哦

网络调试助手

链接: https://pan.baidu.com/s/1HkVjyYVYZ9NdhQNwx-qTGQ?pwd=2222 提取码: 2222 复制这段内容后打开百度网盘手机App，操作更方便哦

3、逻辑流程图及简述

3.1 完整逻辑流程图

在这里插入图片描述

3.2 硬件接线

命令gpio readall 显示针脚的状态和配置信息。

在这里插入图片描述

3.3 功能简述

3.3.1 main()

我们先通过main函数来了解一下整个程序的概况

定义线程在被创造 pthread_create后，需要的tid 参数；

是一个指向 pthread_t 类型变量的指针，用于存储新创建线程的标识符。
先进行初始化，wiringPiSetup() & garbage_init();
- 对于witingPi库和阿里云接口初始化
判断mjpg_streamer这个进程是否存在；detect_process("mjpg_streamer"); 这个函数是我们自己写的，在后文会提供；
- mjpg_streamer 是一款开源的流媒体服务器软件，它能够从一系列输入插件（如USB摄像头）捕获视频数据，并通过网络以MJPG（Motion JPEG）格式实时传输
打开串行接口 serial_fd = myserialOpen(SERIAL_DEV,BAUD);//可代替设备节点 & 波特率返回值fd；判断是否打开成功
打开语音、网络、阿里云交互线程 pthread_create()
等待指定的线程结束其执行 pthread_join()
销毁互斥锁(mutex)和条件变量(cond) pthread_mutex_destroy(&mutex); pthread_cond_destroy(&cond);
关闭串口 close(serial_fd);

//main()
int main(int argc, char *argv[])
{
    printf("adsfasdf\n");
    int len = 0;
    int ret = -1;//标识
    char *category = NULL;
    unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
    pthread_t get_voice_tid, category_tid,get_socket_tid;

    //初始化
    wiringPiSetup();//初始化wiringPi库
    garbage_init(); //初始化阿里云接口
    
    // 用于检测特定进程是否在运行。
    // 它通过调用系统命令ps -ax | grep process_name|grep -v grep来查找包含指定进程名的进程，并返回相应的进程号  
    // mjpg_streamer 是一款开源的流媒体服务器软件，它能够从一系列输入插件（如USB摄像头）捕获视频数据，并通过网络以MJPG（Motion JPEG）格式实时传输
    ret = detect_process("mjpg_streamer");
    if(-1 == ret)
    {
        printf("detect process failed\n");
        goto END;
    }

    //打开设备
    serial_fd = myserialOpen(SERIAL_DEV,BAUD);//可代替设备节点 & 波特率   返回值fd
    if(serial_fd == -1)//是否打开成功
    {
        goto END;    
    }//*pget_voice(void *arg)里面判断
    

    //printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);
    //开语音的线程
    pthread_create(&get_voice_tid,NULL,pget_voice,NULL);
    //开网络线程
    pthread_create(&get_socket_tid,NULL,pget_socket,NULL);
    //开阿里云交互线程
    pthread_create(&category_tid,NULL,pcategory,NULL);
        //get_voice_tid获取语音模块的数据
        //pthread_join用于等待指定的线程结束其执行
    pthread_join(get_voice_tid,NULL);
    pthread_join(category_tid,NULL);
    pthread_join(get_socket_tid,NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    close(serial_fd);
END:
    garbage_final; //释放所有引用的Python对象
    return 0;
}

3.3.2 main函数中打开的语音、网络、阿里云交互线程

3.3.2.1 语音线程

在main()函数中，用 pthread_create(&get_voice_tid,NULL,pget_voice,NULL);来开启语音线程

判断该串口是否已经打开，用输入文件|函数|行号的形式来当调试信息
开一个 while(1) 循环
- 利用串口接收函数serialGetstring(serial_fd,buffer); //P8 & P10 ==> TXD.5 & RXD.5 //获取（读）传过来的数据
  
  这个函数来自 uartTool.c & uartTool.h 文件
- 读取的数据buffer[2] 是否是我先要的；
  
  0x46命令表示：语音播报了“识别垃圾类型” 可以在语音模块的配置文件里面修改；
  - 得到的信号是我想要的话，便执行上锁pthread_mutex_lock(&mutex)–buffer[2]复位–发信号(利用条件变量) pthread_cond_signal(&cond)–关锁pthread_mutex_unlock(&mutex)
    
    互斥锁（mutex）和条件变量（cond）是多线程编程中常用的同步机制，用于控制对共享资源的访问和线程间的通信。
进程退出pthread_exit(0);
main.c里面的函数

//获得 语音线程 pget_voice()
void *pget_voice(void *arg)
{
    unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
    int len = 0;
    if(serial_fd == -1)//是否打开成功
    { 
        printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
        pthread_exit(0);
    }
    printf("%s|%s|%d\n", __FILE__, __func__, __LINE__);
    while(1) 
    {
        //获取（读）传过来的数据
        len = serialGetstring(serial_fd,buffer); //P8 & P10 ==> TXD.5 & RXD.5
        printf("%s|%s|%d, len=%d\n", __FILE__, __func__, __LINE__,len);
        if(len>0 && buffer[2]==0x46) //0x46命令：识别垃圾类型
        {
            printf("%s|%s|%d\n", __FILE__, __func__, __LINE__);
            
            //利用 互斥锁（mutex）和条件变量（condition variable）
            //互斥锁（mutex）和条件变量（cond）是多线程编程中常用的同步机制，用于控制对共享资源的访问和线程间的通信。
            //上锁
            pthread_mutex_lock(&mutex);
            buffer[2] = 0x00;
            //给阿里云发信号
            pthread_cond_signal(&cond);//发信号
            pthread_mutex_unlock(&mutex);
        } 
    } 
    pthread_exit(0);
}

uartTool.h

//uartTool.h
#ifndef __UARTTOOL_H
#define __UARTTOOL_H
int myserialOpen (const char *device, const int baud);
void serialSendstring (const int fd, unsigned const char *s, int len); //写数据
int serialGetstring (const int fd, unsigned char *buffer); //读数据

#define SERIAL_DEV "/dev/ttyS5" // 可代替设备节点
#define BAUD 115200             // 代替波特率

#endif
//防止头文件中的声明反复区声明

uartTool.c

//uartTool.c 中的一个函数
int serialGetstring (const int fd, unsigned char *buffer)
{
	int n_read;
    //read() 用于从文件描述符（file descriptor）读取数据的 POSIX 标准函数之一
	n_read = read(fd,buffer,6);
    //printf("fd = %d\n",fd); 
    printf("BUFFER = %x,%x,%x\n",buffer[0],buffer[1],buffer[2]); 
	return n_read;
}

3.3.2.2 网络线程

main函数中利用 pthread_create(&get_socket_tid,NULL,pget_socket,NULL);来开启socket网络线程

初始化socket，这个就不详细讲解了，在前面的文章，socket网络编程有详细讲解

Linux系统编程8–网络编程-CSDN博客
在网络编程文件的基础上，这边还添加了心跳包功能，
- Socket客户端得断开有两种情况：
  - 1.客户端能够发送状态给服务器；正常断开，强制关闭客户端等，客户端能够做出反应。
  - 2.客户端不能发送状态给服务器；突然断网，断电，客户端卡死等，客户端根本没机会做出反应，服务器更不了解客户端状态，导致服务器异常等待。
- 因此，为了解决上述问题，引入TCP心跳包机制：心跳包的实现，心跳包就是服务器定时向客户端发送查询信息，如果客户端有回应就代表连接正常，类似于linux系统的看门狗机制。心跳包的机制有一种方法就是采用TCP_KEEPALIVE机制，它是一种用于检测TCP连接是否存活的机制，它的原理是在一定时间内没有数据往来时，发送探测包给对方，如果对方没有响应，就认为连接已经断开。TCP_KEEPALIVE机制可以通过设置一些参数来调整，如探测时间间隔、探测次数等。
- 查看当前系统的TCP KeepAlive参数
```
sysctl net.ipv4.tcp_keepalive_time
sysctl net.ipv4.tcp_keepalive_probes
sysctl net.ipv4.tcp_keepalive_intvl
```

在这里插入图片描述

默认等待时间为7200s，查询9次，每次间隔75s

我们把它修改了，见 main.c 文件里的 void *pget_socket(void *fd) 函数

while(1)循环
- 引入心跳包
- 连接成功后，输出调试信息
- while(1)
  - 读数据，如果读取成功，判断读取的数值是否是 “open”
    - 读取到"open" 便执行上锁、给阿里云发信号、关锁的操作（和前文语音模块一样）
  - 没有读取到，或者读取错误，就break；
关闭s_fd (ivp4 TCP)
进程退出 pthread_exit(0);
main.c中的pget_socket函数

void *pget_socket(void *fd)
{
    int s_fd = -1;
    int c_fd = -1;
    char buffer[6];
    int nread = -1;
    struct sockaddr_in c_addr;//用于accept

    memset(&c_addr,0,sizeof(struct sockaddr_in));//清零
    s_fd = socket_init(IPADDR,IPPORT);
    printf("%s|%s|%d: s_fd=%d\n",__FILE__,__func__,__LINE__,s_fd);
    if(-1 == s_fd)
    {
        pthread_exit(0);
    }
    sleep(3);
    int clen = sizeof(struct sockaddr_in);

    while(1)
	{
        //accep第三个参数要求是指针//不连接，便堵塞，直到与客户端连接
		c_fd = accept(s_fd, (struct sockaddr *)&c_addr,&clen);
        // 心包跳
        int keepalive = 1; // 开启TCP KeepAlive功能
        int keepidle = 5; // tcp_keepalive_time 3s内没收到数据开始发送心跳包
        int keepcnt = 3; // tcp_keepalive_probes 每次发送心跳包的时间间隔,单位秒
        int keepintvl = 3; // tcp_keepalive_intvl 每3s发送一次心跳包
        setsockopt(c_fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive,
        sizeof(keepalive));
        setsockopt(c_fd, SOL_TCP, TCP_KEEPIDLE, (void *) &keepidle, sizeof
        (keepidle));
        setsockopt(c_fd, SOL_TCP, TCP_KEEPCNT, (void *)&keepcnt, sizeof
        (keepcnt));
        setsockopt(c_fd, SOL_TCP, TCP_KEEPINTVL, (void *)&keepintvl, sizeof
        (keepintvl));
		//
		
        //连接成功后，输出调试信息
        printf("--------ok?--------\n");
        printf("%s|%s|%d: Accept a connection from %s:%d\n", __FILE__, __func__,__LINE__, inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port));//最后两个window主机的ip和端口号，可以在网络调试助手设置查看，
        printf("-----------ok!-----\n");
        if(c_fd == -1)
		{
			perror("accept");//终端打出错误：accept:---
            continue;
		}

        while(1)
        {
            memset(buffer,0,sizeof(buffer));
            nread = recv(c_fd,buffer,sizeof(buffer),0);// == n_read = read(c_fd,readBuf,sizeof(buffer));
            printf("%s|%s|%d:nread=%d,buffer=%s\n",__FILE__,__func__,__LINE__,nread,buffer);
            if(nread > 0)
            {
                if(strstr(buffer,"open"))
                {
                    //上锁
                    pthread_mutex_lock(&mutex);
                    //给阿里云发信号
                    pthread_cond_signal(&cond);//发信号
                    pthread_mutex_unlock(&mutex);
                }
            }
            else if(0==nread || -1==nread)
            {
                break;
            }
        }
        close(c_fd);
    }
    pthread_exit(0);
}

socket.h socket初始化

//socket.h
#ifndef __SOCKET_H
#define __SOCKET_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h> //memset包含头文件
#include <sys/socket.h>
#include <sys/types.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h> //该头文件会与 #include <linux/in.h> 冲突
#include <arpa/inet.h>
#include <unistd.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <errno.h>
int socket_init(const char *ipaddr,const char *ipport);
#endif

socket.c socket的初始化

#include "socket.h"
int socket_init(const char *ipaddr,const char *ipport)
{
    int s_fd;
    int ret = -1;
	//sockaddr_in 是一个结构体，包含本机子ip地址和端口号等信息
	struct sockaddr_in s_addr;//用于bind
    memset(&s_addr,0,sizeof(struct sockaddr_in));//进行清空 


	//1、socket
	s_fd = socket(AF_INET,SOCK_STREAM,0);  //ivp4,TCP
	if(-1 == s_fd)
	{
		perror("socket");//将上一个函数错误的原因输出
		return -1;
	}

	s_addr.sin_family = AF_INET;//ivp4
	s_addr.sin_port = htons(atoi(ipport));//htons() 返回网络字节的端口号 //ipport是第二个参数,端口号
	inet_aton(ipaddr,&s_addr.sin_addr);//字符串类型形式的“192.0.0.1”转换为网络能识别的格式//字符串-指针

	//2、bind
	ret = bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in));
    if(-1 == ret)
	{
		perror("bind");//将上一个函数错误的原因输出
		return -1;
	}
	//3、listen
	ret = listen(s_fd,1);//同时允许一个监听
    if(-1 == ret)
	{
		perror("listen");//将上一个函数错误的原因输出
		return -1;
	}
    return s_fd;
}

3.3.2.3 阿里云交互线程

main()函数中，利用 pthread_create(&category_tid,NULL,pcategory,NULL); 来开阿里云交互线程

定义线程在被创造 pthread_create后，需要的tid 参数；

是一个指向 pthread_t 类型变量的指针，用于存储新创建线程的标识符。
while(1)循环
- 线程上锁、等待信号 //cond 会合、关锁
- buffer[2]复位
- 拍照指令 system(WGET_CMD) 宏定义WGET_CMD：拍照命令，garbage.h 文件中
- 识别垃圾图片是否存在，也就是是否拍摄成功access(GARBAGE_FILE, F_OK) GARBAGE_FILE 文件位置宏定义
- 调用阿里云接口判断垃圾类型 category = garbage_category(category); 函数见 garbage.c & garbage.py
- 判断对应的垃圾类型，并对buffer[2] 赋不同的值
- 再开三个线程
  - 开垃圾桶开盖线程：pthread_create(&trash_tid,NULL,psend_voice,(void*)buffer);
  - 开语音播报线程： pthread_create(&send_void_tid,NULL,popen_trash_can,(void*)buffer)；
  - 开oled显示线程：pthread_create(&oled_tid,NULL,poled_show,(void*)buffer);
- 把识别到的垃圾的图片清除掉 remove(GARBAGE_FILE); GARBAGE_FILE 文件文章宏定义，见garbage.h
退出进程 pthread_exit(0);

void *pcategory(void *arg)
{
    unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
    char *category = NULL;
    pthread_t send_void_tid,trash_tid,oled_tid;

    printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
    while(1)
    {
        printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
        pthread_mutex_lock(&mutex);// 锁住
        //给阿里云发信号
        pthread_cond_wait(&cond,&mutex);//等待信号
        pthread_mutex_unlock(&mutex);
        printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号

        buffer[2] = 0x00;
        //define WGET_CMD "wget http://127.0.0.1:8080/?action=snapshot -O /tmp/garbage.jpg" //抓拍命令
        system(WGET_CMD);//宏定义：拍照命令，garbage.h 文件中
        // access函数是一个用于测试文件访问权限的函数，它通常用于检查某个文件是否可以被当前用户读取、写入或执行。
        // 包括F_OK（检查文件是否存在）、R_OK（检查读权限）、W_OK（检查写权限）和X_OK（检查执行权限）
        // 该函数返回值为0表示有权限，-1表示无权限或发生错误。
        if(0 == access(GARBAGE_FILE, F_OK))//GARBAGE_FILE 宏定义 识别到的垃圾图片是否存在
        {
            category = garbage_category(category);//调用阿里云接口判断垃圾类型
            if(strstr(category,"干垃圾"))
            {
                buffer[2] = 0x41;//赋值
            }
            else if(strstr(category,"湿垃圾"))
            {
                buffer[2] = 0x42;
            }
            else if(strstr(category,"可回收垃圾"))
            {
                buffer[2] = 0x43;
            }
            else if(strstr(category,"有害垃圾"))
            {
                buffer[2] = 0x44;
            }
            else
            {
                buffer[2] = 0x45;
            }
        }
        else
        {
            buffer[2] = 0x45;
        }
        //开三个线程

        //垃圾桶开盖线程
        pthread_create(&trash_tid,NULL,psend_voice,(void*)buffer); 
        //开语音播报线程
        pthread_create(&send_void_tid,NULL,popen_trash_can,(void*)buffer);
        //开oled显示线程
        pthread_create(&oled_tid,NULL,poled_show,(void*)buffer);

        // buffer[2]=0x00;//将buffer[2]清零
        remove(GARBAGE_FILE);//garbage.h 的宏定义 把识别到的垃圾的图片清除掉
    }
    pthread_exit(0);
}

3.3.2.4 阿里云交互线程`pcategory`开的3个线程

void *psend_voice(void *arg) //写数据，回传给语音模块
{   
    pthread_detach(pthread_self());
    unsigned char *buffer = (unsigned char *)arg;
    if(serial_fd == -1)//是否打开成功
    { 
        printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
        pthread_exit(0);
    }

    if(NULL != buffer)
    {
        serialSendstring(serial_fd,buffer,6);//写数据，回传给语音模块
    }
    pthread_exit(0);
}

void *popen_trash_can(void *arg)//满足条件就开舵机
{
    pthread_detach(pthread_self());
    unsigned char *buffer = (unsigned char *)arg;
    //这意味着线程结束时会自动释放其资源，
    //而不需要其他线程调用 pthread_join() 来等待其结束并回收资源
   
    if(buffer[2] == 0x41)
    {
        pwm_write(PWM_RECOVERABLE_GARBAGE); //对应wPi 5口，接着一个舵机
        printf("---------%x---------\n",buffer[2]);
        delay(2000);
        pwm_stop(PWM_RECOVERABLE_GARBAGE);
    }
    else if(buffer[2] != 0x45) 
    {
        printf("%s|%s|%d: buffer[2]=0x%x\n", __FILE__, __func__, __LINE__,buffer[2]);
        printf("start\n");
        pwm_write(PWM_GARBAGE);  //对应wPi 7口，接着另一个舵机
        delay(2000);
        pwm_stop(PWM_GARBAGE);
    }
    pthread_exit(0);
}

void *poled_show(void *arg)//oled显示当前识别的垃圾类型
{
    pthread_detach(pthread_self()); //这意味着线程结束时会自动释放其资源，
    myoled_init();
    oled_show(arg); //buffer

    pthread_exit(0);
}

4、实验程序

4.1 `uartTool` 串口

串口的打开；发送、接收串口信息

//uartTool.h
#ifndef __UARTTOOL_H
#define __UARTTOOL_H
int myserialOpen (const char *device, const int baud);
void serialSendstring (const int fd, unsigned const char *s, int len); //写数据
int serialGetstring (const int fd, unsigned char *buffer); //读数据

#define SERIAL_DEV "/dev/ttyS5" // 可代替设备节点
#define BAUD 115200             // 代替波特率

#endif
//防止头文件中的声明反复区声明

//uartTool.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>
#include "uartTool.h"//先到当前文件夹查看
#include "wiringSerial.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 ;
  	default:
  }
  
  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) ;//get

  //标准化的操作 一般都是固定的
  cfmakeraw   (&options) ;
  cfsetispeed (&options, myBaud) ;
  cfsetospeed (&options, myBaud) ;//波特率的设置 

  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);//获得整型控制字TIOCMGET get出来
  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 Putchar Error\n");
}

int serialGetstring (const int fd, unsigned char *buffer)
{
	int n_read;
  //read() 用于从文件描述符（file descriptor）读取数据的 POSIX 标准函数之一
	n_read = read(fd,buffer,6);
  //printf("fd = %d\n",fd); 
  printf("BUFFER = %x,%x,%x\n",buffer[0],buffer[1],buffer[2]); 
	return n_read;
}

4.2 `socket` 网络

socket网络线程 + 心跳包

//socket.h
#ifndef __SOCKET_H
#define __SOCKET_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h> //memset包含头文件
#include <sys/socket.h>
#include <sys/types.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h> //该头文件会与 #include <linux/in.h> 冲突
#include <arpa/inet.h>
#include <unistd.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <errno.h>
int socket_init(const char *ipaddr,const char *ipport);
#endif

//socket.c
#include "socket.h"
int socket_init(const char *ipaddr,const char *ipport)
{
    int s_fd;
    int ret = -1;
	//sockaddr_in 是一个结构体，包含本机子ip地址和端口号等信息
	struct sockaddr_in s_addr;//用于bind
    memset(&s_addr,0,sizeof(struct sockaddr_in));//进行清空 

	//1、socket
	s_fd = socket(AF_INET,SOCK_STREAM,0);  //ivp4,TCP
	if(-1 == s_fd)
	{
		perror("socket");//将上一个函数错误的原因输出
		return -1;
	}

	s_addr.sin_family = AF_INET;//ivp4
	s_addr.sin_port = htons(atoi(ipport));//htons() 返回网络字节的端口号 //ipport是第二个参数,端口号
	inet_aton(ipaddr,&s_addr.sin_addr);//字符串类型形式的“192.0.0.1”转换为网络能识别的格式//字符串-指针

	//2、bind
	ret = bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in));
    if(-1 == ret)
	{
		perror("bind");//将上一个函数错误的原因输出
		return -1;
	}
	//3、listen
	ret = listen(s_fd,1);//同时允许一个监听
    if(-1 == ret)
	{
		perror("listen");//将上一个函数错误的原因输出
		return -1;
	}

    return s_fd;
}

4.3 阿里云 `garbage` 识别

# garbage.py
# -*- coding: utf-8 -*-
# 引入依赖包
# pip install alibabacloud_imagerecog20190930
   
import os
import io
from urllib.request import urlopen
from alibabacloud_imagerecog20190930.client import Client
from alibabacloud_imagerecog20190930.models import ClassifyingRubbishAdvanceRequest
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='imagerecog.cn-shanghai.aliyuncs.com',
  # 访问的域名对应的region
  region_id='cn-shanghai'
)

def alibaba_garbage(): # 封装成一个函数，方便其他文件调用
  #场景一：文件在本地
  # img = open(r'/home/orangepi/garbage/lj/test2.jpg','rb')
  img = open(r'/tmp/garbage.jpg','rb')
  #场景二：使用任意可访问的url
  # url = 'https://viapi-test-bj.oss-cn-beijing.aliyuncs.com/viapi-3.0domepic/imagerecog/ClassifyingRubbish/ClassifyingRubbish1.jpg'
  # img = io.BytesIO(urlopen(url).read())
  classifying_rubbish_request = ClassifyingRubbishAdvanceRequest()
  classifying_rubbish_request.image_urlobject = img
  runtime = RuntimeOptions()
  try:
    # 初始化Client
    client = Client(config)
    response = client.classifying_rubbish_advance(classifying_rubbish_request, runtime)
    # 获取整体结果
    # print(response.body) # 默认
    # print(response.body.to_map()) # 打印出body的类型
    print(response.body.to_map()['Data']['Elements'][0]['Category']) # 打印出body的类型
    return response.body.to_map()['Data']['Elements'][0]['Category']
    # 提供调用方便
  except Exception as error:
    # 获取整体报错信息
    # print(error)
    # 获取单个字段
    # print(error.code)
    print("shibai")
    return '获取失败'

if __name__== "__main__":
  alibaba_garbage()

// garbage.h
#ifndef __GARBAGE__H
#define __GARBAGE__H
void garbage_init(void);//第一步做初始化，初始python的编译器包括导入当前路劲到sys.path里面
void garbage_final(void);
char *garbage_category(char *category);

//127.0.0.1
//通常被称为"本地回环地址"或"localhost"；
//这个地址经常用于测试网络应用程序和诊断网络问题
//因为它确保数据能够在同一台计算机上进行循环传输，而无需真正通过网络传输。

#define WGET_CMD "wget http://127.0.0.1:8080/?action=snapshot -O /tmp/garbage.jpg" //抓拍命令
#define GARBAGE_FILE "/tmp/garbage.jpg"

#endif

//garbage.c
// C语言引用Python文件
#if 0
1、包含Python.h头文件，以便使用Python API。
2、使用void Py_Initialize()初始化Python解释器，
3、使用PyObject *PyImport_ImportModule(const char *name)和PyObject
*PyObject_GetAttrString(PyObject *o, const char *attr_name)获取sys.path对象，并利用
int PyList_Append(PyObject *list, PyObject *item)将当前路径.添加到sys.path中，以便加载
当前的Python模块(Python文件即python模块)。
4、使用PyObject *PyImport_ImportModule(const char *name)函数导入Python模块，并检查是否
有错误。
5、使用PyObject *PyObject_GetAttrString(PyObject *o, const char *attr_name)函数获取
Python函数对象，并检查是否可调用。
+6、使用PyObject *Py_BuildValue(const char *format, ...)函数将C类型的数据结构转换成
Python对象，作为Python函数的参数,没有参数不需要调用
7、使用PyObject *PyObject_CallObject(PyObject *callable, PyObject *args)函数调用
Python函数，并获取返回值。
+8、使用int PyArg_Parse(PyObject *args, const char *format, ...)函数将返回值转换为C类
型，并检查是否有错误,没有返回值时不需要调用。
9、使用void Py_DECREF(PyObject *o)函数释放所有引用的Python对象。
10、结束时调用void Py_Finalize()函数关闭Python解释器。
相关的函数参数说明参考网站（网站左上角输入函数名即可开始搜索）：
https://docs.python.org/zh-cn/3/c-api/import.html
#endif

#include <Python.h>
#include "garbage.h"


void garbage_init(void)
{
    Py_Initialize();
    // 将当前路径添加到sys.path中
    PyObject *sys = PyImport_ImportModule("sys");//初始化python解释器
    PyObject *path = PyObject_GetAttrString(sys, "path");
    PyList_Append(path, PyUnicode_FromString("."));
}

void garbage_final(void)
{
    //释放所有引用的Python对象
    Py_Finalize();
}
char *garbage_category(char *category)
{
    // 导入para模块
    PyObject *pModule = PyImport_ImportModule("garbage");//引用的是本目录底下的garbage.py文件
    if (!pModule)
    {
        PyErr_Print();
        printf("Error: failed to load para.py\n");
        goto FAILED_MODULE;
    }
    //获取 alibaba_garbage 函数对象
    PyObject *pFunc = PyObject_GetAttrString(pModule, "alibaba_garbage");//garbage.py文件里的这个函数 alibaba_garbage
    if (!pFunc)
    {
        PyErr_Print();
        printf("Error: failed to load say_funny\n");
        goto FAILED_FUNC;
    }

    //调用alibaba_garbage函数并获取返回值
    PyObject *pValue = PyObject_CallObject(pFunc, NULL);
    if (!pValue)
    {
        PyErr_Print();
        printf("Error: function call failed\n");
        goto FAILED_VALUE;
    } 
    //将返回值转换为C类型
    char *result = NULL;  //pValue(py) --> result(c)
    if (!PyArg_Parse(pValue, "s", &result))//PyArg_Parse根据指定的格式字符串将 Python 对象转换为 C 变量
    {
        PyErr_Print();
        printf("Error: parse failed\n");
        goto FAILED_RESULT;
    }
    //打印返回值
    printf("pValue=%s\n", result);
    category = (char*)malloc(sizeof(char)*(strlen(result)+1));//要留一个字节给 \0
    memset(category, 0, (strlen(result)+1));
    strncpy(category, result,(strlen(result)+1));//复制字符串
    
//会用来标识某个测试案例、任务或计划未能通过或达到预期的标准或目标;失败后跳转
FAILED_RESULT:
    Py_DECREF(pValue);
FAILED_VALUE:
    Py_DECREF(pFunc);
FAILED_FUNC:
    Py_DECREF(pModule);
FAILED_MODULE:

    return category;
}

4.4 `PWM` sg90舵机

//pwm.h
#ifndef __PWM__H
#define __PWM__H

#define PWM_GARBAGE 7
#define PWM_RECOVERABLE_GARBAGE 5

void pwm_write(int pwm_pin); // 控制PWM ==> 开盖
void pwm_stop(int pwm_pin);  // 控制PWM ==> 关盖

#endif

//pwm.c
#include <wiringPi.h>
#include <softPwm.h>
// 根据公式PWMfreq = (1 × 10^6 )/(100 × range)    1000000/20000=50 Hz  ==> 周期为 1/50 = 0.02s = 20ms
// 要得到PWM频率为50Hz，则range为200，即周期为200步，控制精度相比硬件PWM较低

void pwm_write(int pwm_pin)
{
    pinMode(pwm_pin, OUTPUT);//把引脚设置为输出
    // 软件模拟PWM函数
    softPwmCreate(pwm_pin,0,200);// range设置周期分为200步，周期为20ms
    softPwmWrite(pwm_pin,15); // 200步里面有多少步是高电平 10/200 = 0.05
                              //  15/200 = 0.075
                              // 1.0ms--------------45度； 5.0% 占空比
                              // 1.5ms------------90度； 7.5% 占空比
    delay(1000); //延时1s
    softPwmStop(pwm_pin);//停止，不输出PWM波了
}

void pwm_stop(int pwm_pin)
{
    pinMode(pwm_pin, OUTPUT);
    softPwmCreate(pwm_pin,0,200);
    softPwmWrite(pwm_pin,5);// 200步里面有多少步是高电平 5/200 = 0.025
                            // 0.5ms-------------0度； 2.5% 占空比
    delay(1000);
    softPwmStop(pwm_pin);
}

4.5 OLED` 显示

//myoled.h
#ifndef __MYOLED__H
#define __MYOLED__H
int myoled_init(void);
int oled_show(void *arg);
#endif

//myoled.c
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdint.h>
#include "oled.h"
#include "font.h"
//包含头文件
#include "myoled.h"
#define FILENAME "/dev/i2c-3"
static struct display_info disp;

int oled_show(void *arg)
{
    unsigned char *buffer = (unsigned char *)arg;
    oled_putstrto(&disp, 0, 9+1, "This garbage is:");
    disp.font = font2; //设置字体
    switch(buffer[2])
    {
        case 0x41:
            oled_putstrto(&disp, 0, 20, "dry waste");
        break;
        case 0x42:
            oled_putstrto(&disp, 0, 20, "wet waste");
        break;
        case 0x43:
            oled_putstrto(&disp, 0, 20, "recyclable waste");
        break;
        case 0x44:
            oled_putstrto(&disp, 0, 20, "hazardous waste");
        break;
        case 0x45:
            oled_putstrto(&disp, 0, 20, "recognition failed");
        break;
    }
    disp.font = font2;
    oled_send_buffer(&disp);
    return 0;
}

int myoled_init(void)
{
    int e;
    disp.address = OLED_I2C_ADDR;
    disp.font = font2;
    e = oled_open(&disp, FILENAME);
    e = oled_init(&disp);
    return e;
}

4.6 `main.c`

定义 mutex(互斥锁) & cond(条件变量)

//main.c 中包含的函数
detect_process(const char *);//用于检测特定进程是否在运行。
pget_voice(void *);			 //获取（读）串口中的数据  0x46 //P8 & P10 ==> TXD.5 & RXD.5
psend_voice(void *);		 //发送数据（写），回传给串口（语音模块） TX RX
popen_trash_can(void *);     //通过 buffer[2]的数据，控制舵机，从而开盖
poled_show(void *);		     //调用 myoled 模块，通过buffer[2]的数据在oled上显示不同数据
pcategory(void *);           //调用阿里云进行识别、通过返回值来对buffer[2] 进行赋值；并且创造3个线程
							 //开垃圾桶开盖popen_trash_can、语音播报psend_voice、`oled`显示线程poled_show  
pget_socket(void *);         //开启socket网络线程 和 心跳包
main(int, char*[]);

main.c

//main.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <wiringPi.h>
#include <pthread.h>

#include "uartTool.h"
#include "garbage.h"
#include "pwm.h"
#include "myoled.h"
#include "socket.h"

#define IPADDR "192.168.1.76"
#define IPPORT "8000"//一定不能是8080，摄像头服务已经使用

int serial_fd = -1;//全局变量
pthread_cond_t cond;
pthread_mutex_t mutex;
// 用于检测特定进程是否在运行。
// 它通过调用系统命令ps -ax | grep process_name|grep -v grep来查找包含指定进程名的进程，并返回相应的进程号。
static int detect_process(const char *process_name)
{
    int n = -1; // 初始化进程号为-1
    FILE *strm; // 文件流指针
    char buf[128] = {0}; // 缓冲区

    // 构建命令字符串，查找特定进程名的进程
    sprintf(buf, "ps -ax | grep %s|grep -v grep", process_name);

    // 执行系统命令，并返回文件指针用于读取命令输出
    if ((strm = popen(buf, "r")) != NULL) 
    {
        // 读取命令输出到缓冲区中
        if (fgets(buf, sizeof(buf), strm) != NULL)
        {
            printf("buf = %s\n", buf); // 输出读取到的内容
            n = atoi(buf); // 将读取到的内容转换为整数，这里假设内容是进程号
            printf("n=%d\n", n); // 输出转换后的进程号
        }
    }
    else
    {
        return -1; // 如果执行popen失败，则返回-1
    }

    pclose(strm); // 关闭文件流
    return n; // 返回进程号，可能为-1（未找到进程或出现错误）
}


void *pget_voice(void *arg)
{
    unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
    int len = 0;
    if(serial_fd == -1)//是否打开成功
    { 
        printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
        pthread_exit(0);
    }
    printf("%s|%s|%d\n", __FILE__, __func__, __LINE__);
    while(1) 
    {
        //获取（读）传过来的数据
        len = serialGetstring(serial_fd,buffer); //P8 & P10 ==> TXD.5 & RXD.5
        printf("%s|%s|%d, len=%d\n", __FILE__, __func__, __LINE__,len);
        if(len>0 && buffer[2]==0x46) //0x46命令：识别垃圾类型
        {
            printf("%s|%s|%d\n", __FILE__, __func__, __LINE__);
            //上锁
            pthread_mutex_lock(&mutex);
            buffer[2] = 0x00;
            //给阿里云发信号
            pthread_cond_signal(&cond);//发信号
            pthread_mutex_unlock(&mutex);
        } 
    } 
    pthread_exit(0);
}

void *psend_voice(void *arg)
{   
    pthread_detach(pthread_self());
    unsigned char *buffer = (unsigned char *)arg;
    if(serial_fd == -1)//是否打开成功
    { 
        printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
        pthread_exit(0);
    }

    if(NULL != buffer)
    {
        serialSendstring(serial_fd,buffer,6);//写数据，回传给语音模块
    }
    pthread_exit(0);
}

void *popen_trash_can(void *arg)
{
    pthread_detach(pthread_self());
    unsigned char *buffer = (unsigned char *)arg;
    //这意味着线程结束时会自动释放其资源，
    //而不需要其他线程调用 pthread_join() 来等待其结束并回收资源
   
    if(buffer[2] == 0x41)
    {
        pwm_write(PWM_RECOVERABLE_GARBAGE); //对应wPi 5口，接着一个舵机
        printf("---------%x---------\n",buffer[2]);
        delay(2000);
        pwm_stop(PWM_RECOVERABLE_GARBAGE);
    }
    else if(buffer[2] != 0x45) 
    {
        printf("%s|%s|%d: buffer[2]=0x%x\n", __FILE__, __func__, __LINE__,buffer[2]);
        printf("start\n");
        pwm_write(PWM_GARBAGE);  //对应wPi 7口，接着另一个舵机
        delay(2000);
        pwm_stop(PWM_GARBAGE);
    }
    pthread_exit(0);
}

void *poled_show(void *arg)
{
    pthread_detach(pthread_self()); //这意味着线程结束时会自动释放其资源，
    myoled_init();
    oled_show(arg); //buffer

    pthread_exit(0);
}

void *pcategory(void *arg)
{
    unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
    char *category = NULL;
    pthread_t send_void_tid,trash_tid,oled_tid;

    printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
    while(1)
    {
        printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
        pthread_mutex_lock(&mutex);// 锁住
        //给阿里云发信号
        pthread_cond_wait(&cond,&mutex);//等待信号
        pthread_mutex_unlock(&mutex);
        printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号

        buffer[2] = 0x00;
        //define WGET_CMD "wget http://127.0.0.1:8080/?action=snapshot -O /tmp/garbage.jpg" //抓拍命令
        system(WGET_CMD);//宏定义：拍照命令，garbage.h 文件中
        // access函数是一个用于测试文件访问权限的函数，它通常用于检查某个文件是否可以被当前用户读取、写入或执行。
        // 包括F_OK（检查文件是否存在）、R_OK（检查读权限）、W_OK（检查写权限）和X_OK（检查执行权限）
        // 该函数返回值为0表示有权限，-1表示无权限或发生错误。
        if(0 == access(GARBAGE_FILE, F_OK))//GARBAGE_FILE 宏定义 识别到的垃圾图片是否存在
        {
            category = garbage_category(category);//调用阿里云接口判断垃圾类型
            if(strstr(category,"干垃圾"))
            {
                buffer[2] = 0x41;//赋值
            }
            else if(strstr(category,"湿垃圾"))
            {
                buffer[2] = 0x42;
            }
            else if(strstr(category,"可回收垃圾"))
            {
                buffer[2] = 0x43;
            }
            else if(strstr(category,"有害垃圾"))
            {
                buffer[2] = 0x44;
            }
            else
            {
                buffer[2] = 0x45;
            }
        }
        else
        {
            buffer[2] = 0x45;
        }
        //开三个线程

        //垃圾桶开盖线程
        pthread_create(&trash_tid,NULL,psend_voice,(void*)buffer); 
        //开语音播报线程
        pthread_create(&send_void_tid,NULL,popen_trash_can,(void*)buffer);
        
        pthread_create(&oled_tid,NULL,poled_show,(void*)buffer);

        // buffer[2]=0x00;//将buffer[2]清零
        remove(GARBAGE_FILE);//garbage.h 的宏定义 把识别到的垃圾的图片清除掉
    }
    pthread_exit(0);
} 

void *pget_socket(void *fd)
{
    int s_fd = -1;
    int c_fd = -1;
    char buffer[6];
    int nread = -1;
    struct sockaddr_in c_addr;//用于accept

    memset(&c_addr,0,sizeof(struct sockaddr_in));//清零
    s_fd = socket_init(IPADDR,IPPORT);
    printf("%s|%s|%d: s_fd=%d\n",__FILE__,__func__,__LINE__,s_fd);
    if(-1 == s_fd)
    {
        pthread_exit(0);
    }
    sleep(3);
    int clen = sizeof(struct sockaddr_in);

    while(1)
	{
        //accep第三个参数要求是指针//不连接，便堵塞，直到与客户端连接
		c_fd = accept(s_fd, (struct sockaddr *)&c_addr,&clen);
        // 心包跳
        int keepalive = 1; // 开启TCP KeepAlive功能
        int keepidle = 5; // tcp_keepalive_time 3s内没收到数据开始发送心跳包
        int keepcnt = 3; // tcp_keepalive_probes 每次发送心跳包的时间间隔,单位秒
        int keepintvl = 3; // tcp_keepalive_intvl 每3s发送一次心跳包
        setsockopt(c_fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive,
        sizeof(keepalive));
        setsockopt(c_fd, SOL_TCP, TCP_KEEPIDLE, (void *) &keepidle, sizeof
        (keepidle));
        setsockopt(c_fd, SOL_TCP, TCP_KEEPCNT, (void *)&keepcnt, sizeof
        (keepcnt));
        setsockopt(c_fd, SOL_TCP, TCP_KEEPINTVL, (void *)&keepintvl, sizeof
        (keepintvl));


        printf("--------ok?--------\n");
        printf("%s|%s|%d: Accept a connection from %s:%d\n", __FILE__, __func__,__LINE__, inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port));
        printf("-----------ok!-----\n");
        if(c_fd == -1)
		{
			perror("accept");//终端打出错误：accept:---
            continue;
		}

        while(1)
        {
            memset(buffer,0,sizeof(buffer));
            nread = recv(c_fd,buffer,sizeof(buffer),0);// == n_read = read(c_fd,readBuf,sizeof(buffer));
            printf("%s|%s|%d:nread=%d,buffer=%s\n",__FILE__,__func__,__LINE__,nread,buffer);
            if(nread > 0)
            {
                if(strstr(buffer,"open"))
                {
                    //上锁
                    pthread_mutex_lock(&mutex);
                    //给阿里云发信号
                    pthread_cond_signal(&cond);//发信号
                    pthread_mutex_unlock(&mutex);
                }
            }
            else if(0==nread || -1==nread)
            {
                break;
            }
        }
        close(c_fd);
    }
    pthread_exit(0);
}

int main(int argc, char *argv[])
{
    printf("adsfasdf\n");
    int len = 0;
    int ret = -1;//标识
    char *category = NULL;
    unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
    pthread_t get_voice_tid, category_tid,get_socket_tid;

    //初始化
    wiringPiSetup();//初始化wiringPi库
    garbage_init(); //初始化阿里云接口
    
    // 用于检测特定进程是否在运行。
    // 它通过调用系统命令ps -ax | grep process_name|grep -v grep来查找包含指定进程名的进程，并返回相应的进程号  
    // mjpg_streamer 是一款开源的流媒体服务器软件，它能够从一系列输入插件（如USB摄像头）捕获视频数据，并通过网络以MJPG（Motion JPEG）格式实时传输
    ret = detect_process("mjpg_streamer");
    if(-1 == ret)
    {
        printf("detect process failed\n");
        goto END;
    }

    //打开设备
    serial_fd = myserialOpen(SERIAL_DEV,BAUD);//可代替设备节点 & 波特率   返回值fd
    if(serial_fd == -1)//是否打开成功
    {
        goto END;    
    }//*pget_voice(void *arg)里面判断
    

    //printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);
    //开语音的线程
    pthread_create(&get_voice_tid,NULL,pget_voice,NULL);
    //开网络线程
    pthread_create(&get_socket_tid,NULL,pget_socket,NULL);
    //开阿里云交互线程
    pthread_create(&category_tid,NULL,pcategory,NULL);
        //get_voice_tid获取语音模块的数据
        //pthread_join用于等待指定的线程结束其执行
    pthread_join(get_voice_tid,NULL);
    pthread_join(category_tid,NULL);
    pthread_join(get_socket_tid,NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    close(serial_fd);
END:
    garbage_final; //释放所有引用的Python对象
    return 0;
}

5、实验流程和执行结果

5.1 配置客户端和`mjpg_Stream`

利用网络调试助手

在这里插入图片描述

查看Window & linux主机ip

window IP 查询方法
Linux orangepi IP 查询方法

5.2 调试和运行

>>> gcc -o category *.c *.h -I /usr/include/python3.10/ -lpython3.10 -lwiringPi
//得到 category 可执行文件

输入命令sudo -E ./category

1


2

5.3 开始识别

一切都准备好了，现在可以开始实验了
识别干垃圾（纸巾）
识别结果
识别可回收垃圾
识别结果
识别湿垃圾(一个橘子)
识别结果

6、总结

在这个基于全志H616 ARM-Linux 的智能分拣项目中，我们利用的是网络调试助手来进行pc与orangepi通信，也就是说，我们可以在实现基于 TCP的socket编程的远程PC控制；只要orangepi 与PC机的ip是互通的，便可以进行远程操控；
当然我们也可以通过蓝牙模块使得移动端与orangepi进行通信，从而实现移动设备对硬件的控制；但是相比网络通信，蓝牙通信就显得太局限了，无法做到远距离控制；
我们也可以不用阿里云端识别服务，自己来训练自己的模型，然后写入orangpi里面，从而实现自己想要的智能识别功能；