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

张春  金牌会员 | 2024-9-11 08:57:00 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 683|帖子 683|积分 2049

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


  
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);
  1. //main()
  2. int main(int argc, char *argv[])
  3. {
  4.     printf("adsfasdf\n");
  5.     int len = 0;
  6.     int ret = -1;//标识
  7.     char *category = NULL;
  8.     unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
  9.     pthread_t get_voice_tid, category_tid,get_socket_tid;
  11.     //初始化
  12.     wiringPiSetup();//初始化wiringPi库
  13.     garbage_init(); //初始化阿里云接口
  14.    
  15.     // 用于检测特定进程是否在运行。
  16.     // 它通过调用系统命令ps -ax | grep process_name|grep -v grep来查找包含指定进程名的进程，并返回相应的进程号  
  17.     // mjpg_streamer 是一款开源的流媒体服务器软件，它能够从一系列输入插件（如USB摄像头）捕获视频数据，并通过网络以MJPG（Motion JPEG）格式实时传输
  18.     ret = detect_process("mjpg_streamer");
  19.     if(-1 == ret)
  20.     {
  21.         printf("detect process failed\n");
  22.         goto END;
  23.     }
  25.     //打开设备
  26.     serial_fd = myserialOpen(SERIAL_DEV,BAUD);//可代替设备节点 & 波特率   返回值fd
  27.     if(serial_fd == -1)//是否打开成功
  28.     {
  29.         goto END;   
  30.     }//*pget_voice(void *arg)里面判断
  31.    
  33.     //printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);
  34.     //开语音的线程
  35.     pthread_create(&get_voice_tid,NULL,pget_voice,NULL);
  36.     //开网络线程
  37.     pthread_create(&get_socket_tid,NULL,pget_socket,NULL);
  38.     //开阿里云交互线程
  39.     pthread_create(&category_tid,NULL,pcategory,NULL);
  40.         //get_voice_tid获取语音模块的数据
  41.         //pthread_join用于等待指定的线程结束其执行
  42.     pthread_join(get_voice_tid,NULL);
  43.     pthread_join(category_tid,NULL);
  44.     pthread_join(get_socket_tid,NULL);
  46.     pthread_mutex_destroy(&mutex);
  47.     pthread_cond_destroy(&cond);
  49.     close(serial_fd);
  50. END:
  51.     garbage_final; //释放所有引用的Python对象
  52.     return 0;
  53. }
复制代码
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里面的函数
  1. //获得 语音线程 pget_voice()
  2. void *pget_voice(void *arg)
  3. {
  4.     unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
  5.     int len = 0;
  6.     if(serial_fd == -1)//是否打开成功
  7.     {
  8.         printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  9.         pthread_exit(0);
  10.     }
  11.     printf("%s|%s|%d\n", __FILE__, __func__, __LINE__);
  12.     while(1)
  13.     {
  14.         //获取（读）传过来的数据
  15.         len = serialGetstring(serial_fd,buffer); //P8 & P10 ==> TXD.5 & RXD.5
  16.         printf("%s|%s|%d, len=%d\n", __FILE__, __func__, __LINE__,len);
  17.         if(len>0 && buffer[2]==0x46) //0x46命令：识别垃圾类型
  18.         {
  19.             printf("%s|%s|%d\n", __FILE__, __func__, __LINE__);
  20.             
  21.             //利用 互斥锁（mutex）和条件变量（condition variable）
  22.             //互斥锁（mutex）和条件变量（cond）是多线程编程中常用的同步机制，用于控制对共享资源的访问和线程间的通信。
  23.             //上锁
  24.             pthread_mutex_lock(&mutex);
  25.             buffer[2] = 0x00;
  26.             //给阿里云发信号
  27.             pthread_cond_signal(&cond);//发信号
  28.             pthread_mutex_unlock(&mutex);
  29.         }
  30.     }
  31.     pthread_exit(0);
  32. }
复制代码


  • uartTool.h
  1. //uartTool.h
  2. #ifndef __UARTTOOL_H
  3. #define __UARTTOOL_H
  4. int myserialOpen (const char *device, const int baud);
  5. void serialSendstring (const int fd, unsigned const char *s, int len); //写数据
  6. int serialGetstring (const int fd, unsigned char *buffer); //读数据
  8. #define SERIAL_DEV "/dev/ttyS5" // 可代替设备节点
  9. #define BAUD 115200             // 代替波特率
  11. #endif
  12. //防止头文件中的声明反复区声明
复制代码


  • uartTool.c
  1. //uartTool.c 中的一个函数
  2. int serialGetstring (const int fd, unsigned char *buffer)
  3. {
  4.         int n_read;
  5.     //read() 用于从文件描述符（file descriptor）读取数据的 POSIX 标准函数之一
  6.         n_read = read(fd,buffer,6);
  7.     //printf("fd = %d\n",fd);
  8.     printf("BUFFER = %x,%x,%x\n",buffer[0],buffer[1],buffer[2]);
  9.         return n_read;
  10. }
复制代码
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参数
      1. sysctl net.ipv4.tcp_keepalive_time
      2. sysctl net.ipv4.tcp_keepalive_probes
      3. 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函数
  1. void *pget_socket(void *fd)
  2. {
  3.     int s_fd = -1;
  4.     int c_fd = -1;
  5.     char buffer[6];
  6.     int nread = -1;
  7.     struct sockaddr_in c_addr;//用于accept
  9.     memset(&c_addr,0,sizeof(struct sockaddr_in));//清零
  10.     s_fd = socket_init(IPADDR,IPPORT);
  11.     printf("%s|%s|%d: s_fd=%d\n",__FILE__,__func__,__LINE__,s_fd);
  12.     if(-1 == s_fd)
  13.     {
  14.         pthread_exit(0);
  15.     }
  16.     sleep(3);
  17.     int clen = sizeof(struct sockaddr_in);
  19.     while(1)
  20.         {
  21.         //accep第三个参数要求是指针//不连接，便堵塞，直到与客户端连接
  22.                 c_fd = accept(s_fd, (struct sockaddr *)&c_addr,&clen);
  23.         // 心包跳
  24.         int keepalive = 1; // 开启TCP KeepAlive功能
  25.         int keepidle = 5; // tcp_keepalive_time 3s内没收到数据开始发送心跳包
  26.         int keepcnt = 3; // tcp_keepalive_probes 每次发送心跳包的时间间隔,单位秒
  27.         int keepintvl = 3; // tcp_keepalive_intvl 每3s发送一次心跳包
  28.         setsockopt(c_fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive,
  29.         sizeof(keepalive));
  30.         setsockopt(c_fd, SOL_TCP, TCP_KEEPIDLE, (void *) &keepidle, sizeof
  31.         (keepidle));
  32.         setsockopt(c_fd, SOL_TCP, TCP_KEEPCNT, (void *)&keepcnt, sizeof
  33.         (keepcnt));
  34.         setsockopt(c_fd, SOL_TCP, TCP_KEEPINTVL, (void *)&keepintvl, sizeof
  35.         (keepintvl));
  36.                 //
  37.                
  38.         //连接成功后，输出调试信息
  39.         printf("--------ok?--------\n");
  40.         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和端口号，可以在网络调试助手设置查看，
  41.         printf("-----------ok!-----\n");
  42.         if(c_fd == -1)
  43.                 {
  44.                         perror("accept");//终端打出错误：accept:---
  45.             continue;
  46.                 }
  48.         while(1)
  49.         {
  50.             memset(buffer,0,sizeof(buffer));
  51.             nread = recv(c_fd,buffer,sizeof(buffer),0);// == n_read = read(c_fd,readBuf,sizeof(buffer));
  52.             printf("%s|%s|%d:nread=%d,buffer=%s\n",__FILE__,__func__,__LINE__,nread,buffer);
  53.             if(nread > 0)
  54.             {
  55.                 if(strstr(buffer,"open"))
  56.                 {
  57.                     //上锁
  58.                     pthread_mutex_lock(&mutex);
  59.                     //给阿里云发信号
  60.                     pthread_cond_signal(&cond);//发信号
  61.                     pthread_mutex_unlock(&mutex);
  62.                 }
  63.             }
  64.             else if(0==nread || -1==nread)
  65.             {
  66.                 break;
  67.             }
  68.         }
  69.         close(c_fd);
  70.     }
  71.     pthread_exit(0);
  72. }
复制代码


  • socket.h socket初始化
  1. //socket.h
  2. #ifndef __SOCKET_H
  3. #define __SOCKET_H
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h> //memset包含头文件
  7. #include <sys/socket.h>
  8. #include <sys/types.h>
  9. //#include <linux/in.h>
  10. #include <arpa/inet.h>
  11. #include <netinet/in.h> //该头文件会与 #include <linux/in.h> 冲突
  12. #include <arpa/inet.h>
  13. #include <unistd.h>
  14. #include <netinet/in.h>
  15. #include <netinet/tcp.h>
  16. #include <arpa/inet.h>
  17. #include <errno.h>
  18. int socket_init(const char *ipaddr,const char *ipport);
  19. #endif
复制代码


  • socket.c socket的初始化
  1. #include "socket.h"
  2. int socket_init(const char *ipaddr,const char *ipport)
  3. {
  4.     int s_fd;
  5.     int ret = -1;
  6.         //sockaddr_in 是一个结构体，包含本机子ip地址和端口号等信息
  7.         struct sockaddr_in s_addr;//用于bind
  8.     memset(&s_addr,0,sizeof(struct sockaddr_in));//进行清空
  11.         //1、socket
  12.         s_fd = socket(AF_INET,SOCK_STREAM,0);  //ivp4,TCP
  13.         if(-1 == s_fd)
  14.         {
  15.                 perror("socket");//将上一个函数错误的原因输出
  16.                 return -1;
  17.         }
  19.         s_addr.sin_family = AF_INET;//ivp4
  20.         s_addr.sin_port = htons(atoi(ipport));//htons() 返回网络字节的端口号 //ipport是第二个参数,端口号
  21.         inet_aton(ipaddr,&s_addr.sin_addr);//字符串类型形式的“192.0.0.1”转换为网络能识别的格式//字符串-指针
  23.         //2、bind
  24.         ret = bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in));
  25.     if(-1 == ret)
  26.         {
  27.                 perror("bind");//将上一个函数错误的原因输出
  28.                 return -1;
  29.         }
  30.         //3、listen
  31.         ret = listen(s_fd,1);//同时允许一个监听
  32.     if(-1 == ret)
  33.         {
  34.                 perror("listen");//将上一个函数错误的原因输出
  35.                 return -1;
  36.         }
  37.     return s_fd;
  38. }
复制代码
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);
  1. void *pcategory(void *arg)
  2. {
  3.     unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
  4.     char *category = NULL;
  5.     pthread_t send_void_tid,trash_tid,oled_tid;
  7.     printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  8.     while(1)
  9.     {
  10.         printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  11.         pthread_mutex_lock(&mutex);// 锁住
  12.         //给阿里云发信号
  13.         pthread_cond_wait(&cond,&mutex);//等待信号
  14.         pthread_mutex_unlock(&mutex);
  15.         printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  17.         buffer[2] = 0x00;
  18.         //define WGET_CMD "wget http://127.0.0.1:8080/?action=snapshot -O /tmp/garbage.jpg" //抓拍命令
  19.         system(WGET_CMD);//宏定义：拍照命令，garbage.h 文件中
  20.         // access函数是一个用于测试文件访问权限的函数，它通常用于检查某个文件是否可以被当前用户读取、写入或执行。
  21.         // 包括F_OK（检查文件是否存在）、R_OK（检查读权限）、W_OK（检查写权限）和X_OK（检查执行权限）
  22.         // 该函数返回值为0表示有权限，-1表示无权限或发生错误。
  23.         if(0 == access(GARBAGE_FILE, F_OK))//GARBAGE_FILE 宏定义 识别到的垃圾图片是否存在
  24.         {
  25.             category = garbage_category(category);//调用阿里云接口判断垃圾类型
  26.             if(strstr(category,"干垃圾"))
  27.             {
  28.                 buffer[2] = 0x41;//赋值
  29.             }
  30.             else if(strstr(category,"湿垃圾"))
  31.             {
  32.                 buffer[2] = 0x42;
  33.             }
  34.             else if(strstr(category,"可回收垃圾"))
  35.             {
  36.                 buffer[2] = 0x43;
  37.             }
  38.             else if(strstr(category,"有害垃圾"))
  39.             {
  40.                 buffer[2] = 0x44;
  41.             }
  42.             else
  43.             {
  44.                 buffer[2] = 0x45;
  45.             }
  46.         }
  47.         else
  48.         {
  49.             buffer[2] = 0x45;
  50.         }
  51.         //开三个线程
  53.         //垃圾桶开盖线程
  54.         pthread_create(&trash_tid,NULL,psend_voice,(void*)buffer);
  55.         //开语音播报线程
  56.         pthread_create(&send_void_tid,NULL,popen_trash_can,(void*)buffer);
  57.         //开oled显示线程
  58.         pthread_create(&oled_tid,NULL,poled_show,(void*)buffer);
  60.         // buffer[2]=0x00;//将buffer[2]清零
  61.         remove(GARBAGE_FILE);//garbage.h 的宏定义 把识别到的垃圾的图片清除掉
  62.     }
  63.     pthread_exit(0);
  64. }
复制代码
3.3.2.4 阿里云交互线程pcategory开的3个线程

  1. void *psend_voice(void *arg) //写数据，回传给语音模块
  2. {   
  3.     pthread_detach(pthread_self());
  4.     unsigned char *buffer = (unsigned char *)arg;
  5.     if(serial_fd == -1)//是否打开成功
  6.     {
  7.         printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  8.         pthread_exit(0);
  9.     }
  11.     if(NULL != buffer)
  12.     {
  13.         serialSendstring(serial_fd,buffer,6);//写数据，回传给语音模块
  14.     }
  15.     pthread_exit(0);
  16. }
  18. void *popen_trash_can(void *arg)//满足条件就开舵机
  19. {
  20.     pthread_detach(pthread_self());
  21.     unsigned char *buffer = (unsigned char *)arg;
  22.     //这意味着线程结束时会自动释放其资源，
  23.     //而不需要其他线程调用 pthread_join() 来等待其结束并回收资源
  24.    
  25.     if(buffer[2] == 0x41)
  26.     {
  27.         pwm_write(PWM_RECOVERABLE_GARBAGE); //对应wPi 5口，接着一个舵机
  28.         printf("---------%x---------\n",buffer[2]);
  29.         delay(2000);
  30.         pwm_stop(PWM_RECOVERABLE_GARBAGE);
  31.     }
  32.     else if(buffer[2] != 0x45)
  33.     {
  34.         printf("%s|%s|%d: buffer[2]=0x%x\n", __FILE__, __func__, __LINE__,buffer[2]);
  35.         printf("start\n");
  36.         pwm_write(PWM_GARBAGE);  //对应wPi 7口，接着另一个舵机
  37.         delay(2000);
  38.         pwm_stop(PWM_GARBAGE);
  39.     }
  40.     pthread_exit(0);
  41. }
  43. void *poled_show(void *arg)//oled显示当前识别的垃圾类型
  44. {
  45.     pthread_detach(pthread_self()); //这意味着线程结束时会自动释放其资源，
  46.     myoled_init();
  47.     oled_show(arg); //buffer
  49.     pthread_exit(0);
  50. }
复制代码
4、实行程序

4.1 uartTool 串口



  • 串口的打开；发送、吸收串口信息
  1. //uartTool.h
  2. #ifndef __UARTTOOL_H
  3. #define __UARTTOOL_H
  4. int myserialOpen (const char *device, const int baud);
  5. void serialSendstring (const int fd, unsigned const char *s, int len); //写数据
  6. int serialGetstring (const int fd, unsigned char *buffer); //读数据
  8. #define SERIAL_DEV "/dev/ttyS5" // 可代替设备节点
  9. #define BAUD 115200             // 代替波特率
  11. #endif
  12. //防止头文件中的声明反复区声明
复制代码
  1. //uartTool.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <stdint.h>
  5. #include <stdarg.h>
  6. #include <string.h>
  7. #include <termios.h>
  8. #include <unistd.h>
  9. #include <fcntl.h>
  10. #include <sys/ioctl.h>
  11. #include <sys/types.h>
  12. #include <sys/stat.h>
  13. #include "uartTool.h"//先到当前文件夹查看
  14. #include "wiringSerial.h"
  16. int myserialOpen (const char *device, const int baud)
  17. {
  18.         struct termios options ;//这个结构体
  19.   speed_t myBaud ;
  20.   int status, fd ;
  21.   
  22.   switch (baud)
  23.   {
  24.           case    9600:        myBaud =    B9600 ; break ;
  25.           case  115200:        myBaud =  B115200 ; break ;
  26.           default:
  27.   }
  28.   
  29.   if ((fd = open (device, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK)) == -1)
  30.   return -1 ;
  31.   
  32.   fcntl (fd, F_SETFL, O_RDWR) ;
  34. // Get and modify current options:
  36.   tcgetattr (fd, &options) ;//get
  38.   //标准化的操作 一般都是固定的
  39.   cfmakeraw   (&options) ;
  40.   cfsetispeed (&options, myBaud) ;
  41.   cfsetospeed (&options, myBaud) ;//波特率的设置
  43.   options.c_cflag |= (CLOCAL | CREAD) ;
  44.   options.c_cflag &= ~PARENB ;//奇偶校验位
  45.   options.c_cflag &= ~CSTOPB ;//ͣ停止位 一般都是一位的
  46.   options.c_cflag &= ~CSIZE ;
  47.   options.c_cflag |= CS8 ;//数据位 基本都是八位的
  48.   options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG) ;
  49.   options.c_oflag &= ~OPOST ;
  51.   options.c_cc [VMIN]  =   0 ;
  52.   options.c_cc [VTIME] = 100 ;        // Ten seconds (100 deciseconds)
  53.   //标准化的操作
  54.   tcsetattr (fd, TCSANOW, &options) ;//写入内核
  57.   ioctl (fd, TIOCMGET, &status);//获得整型控制字TIOCMGET get出来
  58.   status |= TIOCM_DTR ;
  59.   status |= TIOCM_RTS ;//控制字加上标志位
  60.   ioctl (fd, TIOCMSET, &status);//写入内核
  62.   usleep (10000) ;        // 10mS
  63.   return fd ;
  64. }
  66. //0XAA 0X55 0X46 0X00 0X55 0XAA
  67. void serialSendstring (const int fd, const unsigned char *s, int len)//去写数据
  68. {
  69.         int ret;
  70.   ret = write (fd, s, len);
  71.   if (ret < 0)
  72.                 printf("Serial Putchar Error\n");
  73. }
  75. int serialGetstring (const int fd, unsigned char *buffer)
  76. {
  77.         int n_read;
  78.   //read() 用于从文件描述符（file descriptor）读取数据的 POSIX 标准函数之一
  79.         n_read = read(fd,buffer,6);
  80.   //printf("fd = %d\n",fd);
  81.   printf("BUFFER = %x,%x,%x\n",buffer[0],buffer[1],buffer[2]);
  82.         return n_read;
  83. }
复制代码
4.2 socket 网络



  • socket网络线程 + 心跳包
  1. //socket.h
  2. #ifndef __SOCKET_H
  3. #define __SOCKET_H
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h> //memset包含头文件
  7. #include <sys/socket.h>
  8. #include <sys/types.h>
  9. //#include <linux/in.h>
  10. #include <arpa/inet.h>
  11. #include <netinet/in.h> //该头文件会与 #include <linux/in.h> 冲突
  12. #include <arpa/inet.h>
  13. #include <unistd.h>
  14. #include <netinet/in.h>
  15. #include <netinet/tcp.h>
  16. #include <arpa/inet.h>
  17. #include <errno.h>
  18. int socket_init(const char *ipaddr,const char *ipport);
  19. #endif
复制代码
  1. //socket.c#include "socket.h"
  2. int socket_init(const char *ipaddr,const char *ipport)
  3. {
  4.     int s_fd;
  5.     int ret = -1;
  6.         //sockaddr_in 是一个结构体，包含本机子ip地址和端口号等信息
  7.         struct sockaddr_in s_addr;//用于bind
  8.     memset(&s_addr,0,sizeof(struct sockaddr_in));//进行清空
  11.         //1、socket
  12.         s_fd = socket(AF_INET,SOCK_STREAM,0);  //ivp4,TCP
  13.         if(-1 == s_fd)
  14.         {
  15.                 perror("socket");//将上一个函数错误的原因输出
  16.                 return -1;
  17.         }
  19.         s_addr.sin_family = AF_INET;//ivp4
  20.         s_addr.sin_port = htons(atoi(ipport));//htons() 返回网络字节的端口号 //ipport是第二个参数,端口号
  21.         inet_aton(ipaddr,&s_addr.sin_addr);//字符串类型形式的“192.0.0.1”转换为网络能识别的格式//字符串-指针
  23.         //2、bind
  24.         ret = bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in));
  25.     if(-1 == ret)
  26.         {
  27.                 perror("bind");//将上一个函数错误的原因输出
  28.                 return -1;
  29.         }
  30.         //3、listen
  31.         ret = listen(s_fd,1);//同时允许一个监听
  32.     if(-1 == ret)
  33.         {
  34.                 perror("listen");//将上一个函数错误的原因输出
  35.                 return -1;
  36.         }
  37.     return s_fd;
  38. }
复制代码
4.3 阿里云 garbage 识别

  1. # garbage.py
  2. # -*- coding: utf-8 -*-
  3. # 引入依赖包
  4. # pip install alibabacloud_imagerecog20190930
  5.    
  6. import os
  7. import io
  8. from urllib.request import urlopen
  9. from alibabacloud_imagerecog20190930.client import Client
  10. from alibabacloud_imagerecog20190930.models import ClassifyingRubbishAdvanceRequest
  11. from alibabacloud_tea_openapi.models import Config
  12. from alibabacloud_tea_util.models import RuntimeOptions
  14. config = Config(
  15.   # 创建AccessKey ID和AccessKey Secret，请参考https://help.aliyun.com/document_detail/175144.html。
  16.   # 如果您用的是RAM用户的AccessKey，还需要为RAM用户授予权限AliyunVIAPIFullAccess，请参考https://help.aliyun.com/document_detail/145025.html
  17.   # 从环境变量读取配置的AccessKey ID和AccessKey Secret。运行代码示例前必须先配置环境变量。
  18.   access_key_id=os.environ.get('ALIBABA_CLOUD_ACCESS_KEY_ID'),
  19.   access_key_secret=os.environ.get('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
  20.   # 访问的域名
  21.   endpoint='imagerecog.cn-shanghai.aliyuncs.com',
  22.   # 访问的域名对应的region
  23.   region_id='cn-shanghai'
  24. )
  26. def alibaba_garbage(): # 封装成一个函数，方便其他文件调用
  27.   #场景一：文件在本地
  28.   # img = open(r'/home/orangepi/garbage/lj/test2.jpg','rb')
  29.   img = open(r'/tmp/garbage.jpg','rb')
  30.   #场景二：使用任意可访问的url
  31.   # url = 'https://viapi-test-bj.oss-cn-beijing.aliyuncs.com/viapi-3.0domepic/imagerecog/ClassifyingRubbish/ClassifyingRubbish1.jpg'
  32.   # img = io.BytesIO(urlopen(url).read())
  33.   classifying_rubbish_request = ClassifyingRubbishAdvanceRequest()
  34.   classifying_rubbish_request.image_urlobject = img
  35.   runtime = RuntimeOptions()
  36.   try:
  37.     # 初始化Client
  38.     client = Client(config)
  39.     response = client.classifying_rubbish_advance(classifying_rubbish_request, runtime)
  40.     # 获取整体结果
  41.     # print(response.body) # 默认
  42.     # print(response.body.to_map()) # 打印出body的类型
  43.     print(response.body.to_map()['Data']['Elements'][0]['Category']) # 打印出body的类型
  44.     return response.body.to_map()['Data']['Elements'][0]['Category']
  45.     # 提供调用方便
  46.   except Exception as error:
  47.     # 获取整体报错信息
  48.     # print(error)
  49.     # 获取单个字段
  50.     # print(error.code)
  51.     print("shibai")
  52.     return '获取失败'
  54. if __name__== "__main__":
  55.   alibaba_garbage()
复制代码
  1. // garbage.h
  2. #ifndef __GARBAGE__H
  3. #define __GARBAGE__H
  4. void garbage_init(void);//第一步做初始化，初始python的编译器包括导入当前路劲到sys.path里面
  5. void garbage_final(void);
  6. char *garbage_category(char *category);
  8. //127.0.0.1
  9. //通常被称为"本地回环地址"或"localhost"；
  10. //这个地址经常用于测试网络应用程序和诊断网络问题
  11. //因为它确保数据能够在同一台计算机上进行循环传输，而无需真正通过网络传输。
  13. #define WGET_CMD "wget http://127.0.0.1:8080/?action=snapshot -O /tmp/garbage.jpg" //抓拍命令
  14. #define GARBAGE_FILE "/tmp/garbage.jpg"
  16. #endif
复制代码
  1. //garbage.c
  2. // C语言引用Python文件
  3. #if 0
  4. 1、包含Python.h头文件，以便使用Python API。
  5. 2、使用void Py_Initialize()初始化Python解释器，
  6. 3、使用PyObject *PyImport_ImportModule(const char *name)和PyObject
  7. *PyObject_GetAttrString(PyObject *o, const char *attr_name)获取sys.path对象，并利用
  8. int PyList_Append(PyObject *list, PyObject *item)将当前路径.添加到sys.path中，以便加载
  9. 当前的Python模块(Python文件即python模块)。
  10. 4、使用PyObject *PyImport_ImportModule(const char *name)函数导入Python模块，并检查是否
  11. 有错误。
  12. 5、使用PyObject *PyObject_GetAttrString(PyObject *o, const char *attr_name)函数获取
  13. Python函数对象，并检查是否可调用。
  14. +6、使用PyObject *Py_BuildValue(const char *format, ...)函数将C类型的数据结构转换成
  15. Python对象，作为Python函数的参数,没有参数不需要调用
  16. 7、使用PyObject *PyObject_CallObject(PyObject *callable, PyObject *args)函数调用
  17. Python函数，并获取返回值。
  18. +8、使用int PyArg_Parse(PyObject *args, const char *format, ...)函数将返回值转换为C类
  19. 型，并检查是否有错误,没有返回值时不需要调用。
  20. 9、使用void Py_DECREF(PyObject *o)函数释放所有引用的Python对象。
  21. 10、结束时调用void Py_Finalize()函数关闭Python解释器。
  22. 相关的函数参数说明参考网站（网站左上角输入函数名即可开始搜索）：
  23. https://docs.python.org/zh-cn/3/c-api/import.html
  24. #endif
  26. #include <Python.h>
  27. #include "garbage.h"
  30. void garbage_init(void)
  31. {
  32.     Py_Initialize();
  33.     // 将当前路径添加到sys.path中
  34.     PyObject *sys = PyImport_ImportModule("sys");//初始化python解释器
  35.     PyObject *path = PyObject_GetAttrString(sys, "path");
  36.     PyList_Append(path, PyUnicode_FromString("."));
  37. }
  39. void garbage_final(void)
  40. {
  41.     //释放所有引用的Python对象
  42.     Py_Finalize();
  43. }
  44. char *garbage_category(char *category)
  45. {
  46.     // 导入para模块
  47.     PyObject *pModule = PyImport_ImportModule("garbage");//引用的是本目录底下的garbage.py文件
  48.     if (!pModule)
  49.     {
  50.         PyErr_Print();
  51.         printf("Error: failed to load para.py\n");
  52.         goto FAILED_MODULE;
  53.     }
  54.     //获取 alibaba_garbage 函数对象
  55.     PyObject *pFunc = PyObject_GetAttrString(pModule, "alibaba_garbage");//garbage.py文件里的这个函数 alibaba_garbage
  56.     if (!pFunc)
  57.     {
  58.         PyErr_Print();
  59.         printf("Error: failed to load say_funny\n");
  60.         goto FAILED_FUNC;
  61.     }
  63.     //调用alibaba_garbage函数并获取返回值
  64.     PyObject *pValue = PyObject_CallObject(pFunc, NULL);
  65.     if (!pValue)
  66.     {
  67.         PyErr_Print();
  68.         printf("Error: function call failed\n");
  69.         goto FAILED_VALUE;
  70.     }
  71.     //将返回值转换为C类型
  72.     char *result = NULL;  //pValue(py) --> result(c)
  73.     if (!PyArg_Parse(pValue, "s", &result))//PyArg_Parse根据指定的格式字符串将 Python 对象转换为 C 变量
  74.     {
  75.         PyErr_Print();
  76.         printf("Error: parse failed\n");
  77.         goto FAILED_RESULT;
  78.     }
  79.     //打印返回值
  80.     printf("pValue=%s\n", result);
  81.     category = (char*)malloc(sizeof(char)*(strlen(result)+1));//要留一个字节给 \0
  82.     memset(category, 0, (strlen(result)+1));
  83.     strncpy(category, result,(strlen(result)+1));//复制字符串
  84.    
  85. //会用来标识某个测试案例、任务或计划未能通过或达到预期的标准或目标;失败后跳转
  86. FAILED_RESULT:
  87.     Py_DECREF(pValue);
  88. FAILED_VALUE:
  89.     Py_DECREF(pFunc);
  90. FAILED_FUNC:
  91.     Py_DECREF(pModule);
  92. FAILED_MODULE:
  94.     return category;
  95. }
复制代码
4.4 PWM sg90舵机

  1. //pwm.h
  2. #ifndef __PWM__H
  3. #define __PWM__H
  5. #define PWM_GARBAGE 7
  6. #define PWM_RECOVERABLE_GARBAGE 5
  8. void pwm_write(int pwm_pin); // 控制PWM ==> 开盖
  9. void pwm_stop(int pwm_pin);  // 控制PWM ==> 关盖
  11. #endif
复制代码
  1. //pwm.c
  2. #include <wiringPi.h>
  3. #include <softPwm.h>
  4. // 根据公式PWMfreq = (1 × 10^6 )/(100 × range)    1000000/20000=50 Hz  ==> 周期为 1/50 = 0.02s = 20ms
  5. // 要得到PWM频率为50Hz，则range为200，即周期为200步，控制精度相比硬件PWM较低
  7. void pwm_write(int pwm_pin)
  8. {
  9.     pinMode(pwm_pin, OUTPUT);//把引脚设置为输出
  10.     // 软件模拟PWM函数
  11.     softPwmCreate(pwm_pin,0,200);// range设置周期分为200步，周期为20ms
  12.     softPwmWrite(pwm_pin,15); // 200步里面有多少步是高电平 10/200 = 0.05
  13.                               //  15/200 = 0.075
  14.                               // 1.0ms--------------45度； 5.0% 占空比
  15.                               // 1.5ms------------90度； 7.5% 占空比
  16.     delay(1000); //延时1s
  17.     softPwmStop(pwm_pin);//停止，不输出PWM波了
  18. }
  20. void pwm_stop(int pwm_pin)
  21. {
  22.     pinMode(pwm_pin, OUTPUT);
  23.     softPwmCreate(pwm_pin,0,200);
  24.     softPwmWrite(pwm_pin,5);// 200步里面有多少步是高电平 5/200 = 0.025
  25.                             // 0.5ms-------------0度； 2.5% 占空比
  26.     delay(1000);
  27.     softPwmStop(pwm_pin);
  28. }
复制代码
4.5 OLED` 显示

  1. //myoled.h
  2. #ifndef __MYOLED__H
  3. #define __MYOLED__H
  4. int myoled_init(void);
  5. int oled_show(void *arg);
  6. #endif
复制代码
  1. //myoled.c
  2. #include <errno.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <time.h>
  7. #include <stdint.h>
  8. #include "oled.h"
  9. #include "font.h"
  10. //包含头文件
  11. #include "myoled.h"
  12. #define FILENAME "/dev/i2c-3"
  13. static struct display_info disp;
  15. int oled_show(void *arg)
  16. {
  17.     unsigned char *buffer = (unsigned char *)arg;
  18.     oled_putstrto(&disp, 0, 9+1, "This garbage is:");
  19.     disp.font = font2; //设置字体
  20.     switch(buffer[2])
  21.     {
  22.         case 0x41:
  23.             oled_putstrto(&disp, 0, 20, "dry waste");
  24.         break;
  25.         case 0x42:
  26.             oled_putstrto(&disp, 0, 20, "wet waste");
  27.         break;
  28.         case 0x43:
  29.             oled_putstrto(&disp, 0, 20, "recyclable waste");
  30.         break;
  31.         case 0x44:
  32.             oled_putstrto(&disp, 0, 20, "hazardous waste");
  33.         break;
  34.         case 0x45:
  35.             oled_putstrto(&disp, 0, 20, "recognition failed");
  36.         break;
  37.     }
  38.     disp.font = font2;
  39.     oled_send_buffer(&disp);
  40.     return 0;
  41. }
  43. int myoled_init(void)
  44. {
  45.     int e;
  46.     disp.address = OLED_I2C_ADDR;
  47.     disp.font = font2;
  48.     e = oled_open(&disp, FILENAME);
  49.     e = oled_init(&disp);
  50.     return e;
  51. }
复制代码
4.6 main.c



  • 定义 mutex(互斥锁) & cond(条件变量)
    1. //main.c 中包含的函数
    2. detect_process(const char *);//用于检测特定进程是否在运行。
    3. pget_voice(void *);                         //获取（读）串口中的数据  0x46 //P8 & P10 ==> TXD.5 & RXD.5
    4. psend_voice(void *);                 //发送数据（写），回传给串口（语音模块） TX RX
    5. popen_trash_can(void *);     //通过 buffer[2]的数据，控制舵机，从而开盖
    6. poled_show(void *);                     //调用 myoled 模块，通过buffer[2]的数据在oled上显示不同数据
    7. pcategory(void *);           //调用阿里云进行识别、通过返回值来对buffer[2] 进行赋值；并且创造3个线程
    8.                                                          //开垃圾桶开盖popen_trash_can、语音播报psend_voice、`oled`显示线程poled_show  
    9. pget_socket(void *);         //开启socket网络线程 和 心跳包
    10. main(int, char*[]);
    复制代码
  • main.c
  1. //main.c
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include <unistd.h>
  6. #include <errno.h>
  7. #include <wiringPi.h>
  8. #include <pthread.h>
  10. #include "uartTool.h"
  11. #include "garbage.h"
  12. #include "pwm.h"
  13. #include "myoled.h"
  14. #include "socket.h"
  16. #define IPADDR "192.168.1.76"
  17. #define IPPORT "8000"//一定不能是8080，摄像头服务已经使用
  19. int serial_fd = -1;//全局变量
  20. pthread_cond_t cond;
  21. pthread_mutex_t mutex;
  22. // 用于检测特定进程是否在运行。
  23. // 它通过调用系统命令ps -ax | grep process_name|grep -v grep来查找包含指定进程名的进程，并返回相应的进程号。
  24. static int detect_process(const char *process_name)
  25. {
  26.     int n = -1; // 初始化进程号为-1
  27.     FILE *strm; // 文件流指针
  28.     char buf[128] = {0}; // 缓冲区
  30.     // 构建命令字符串，查找特定进程名的进程
  31.     sprintf(buf, "ps -ax | grep %s|grep -v grep", process_name);
  33.     // 执行系统命令，并返回文件指针用于读取命令输出
  34.     if ((strm = popen(buf, "r")) != NULL)
  35.     {
  36.         // 读取命令输出到缓冲区中
  37.         if (fgets(buf, sizeof(buf), strm) != NULL)
  38.         {
  39.             printf("buf = %s\n", buf); // 输出读取到的内容
  40.             n = atoi(buf); // 将读取到的内容转换为整数，这里假设内容是进程号
  41.             printf("n=%d\n", n); // 输出转换后的进程号
  42.         }
  43.     }
  44.     else
  45.     {
  46.         return -1; // 如果执行popen失败，则返回-1
  47.     }
  49.     pclose(strm); // 关闭文件流
  50.     return n; // 返回进程号，可能为-1（未找到进程或出现错误）
  51. }
  54. void *pget_voice(void *arg)
  55. {
  56.     unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
  57.     int len = 0;
  58.     if(serial_fd == -1)//是否打开成功
  59.     {
  60.         printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  61.         pthread_exit(0);
  62.     }
  63.     printf("%s|%s|%d\n", __FILE__, __func__, __LINE__);
  64.     while(1)
  65.     {
  66.         //获取（读）传过来的数据
  67.         len = serialGetstring(serial_fd,buffer); //P8 & P10 ==> TXD.5 & RXD.5
  68.         printf("%s|%s|%d, len=%d\n", __FILE__, __func__, __LINE__,len);
  69.         if(len>0 && buffer[2]==0x46) //0x46命令：识别垃圾类型
  70.         {
  71.             printf("%s|%s|%d\n", __FILE__, __func__, __LINE__);
  72.             //上锁
  73.             pthread_mutex_lock(&mutex);
  74.             buffer[2] = 0x00;
  75.             //给阿里云发信号
  76.             pthread_cond_signal(&cond);//发信号
  77.             pthread_mutex_unlock(&mutex);
  78.         }
  79.     }
  80.     pthread_exit(0);
  81. }
  83. void *psend_voice(void *arg)
  84. {   
  85.     pthread_detach(pthread_self());
  86.     unsigned char *buffer = (unsigned char *)arg;
  87.     if(serial_fd == -1)//是否打开成功
  88.     {
  89.         printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  90.         pthread_exit(0);
  91.     }
  93.     if(NULL != buffer)
  94.     {
  95.         serialSendstring(serial_fd,buffer,6);//写数据，回传给语音模块
  96.     }
  97.     pthread_exit(0);
  98. }
  100. void *popen_trash_can(void *arg)
  101. {
  102.     pthread_detach(pthread_self());
  103.     unsigned char *buffer = (unsigned char *)arg;
  104.     //这意味着线程结束时会自动释放其资源，
  105.     //而不需要其他线程调用 pthread_join() 来等待其结束并回收资源
  106.    
  107.     if(buffer[2] == 0x41)
  108.     {
  109.         pwm_write(PWM_RECOVERABLE_GARBAGE); //对应wPi 5口，接着一个舵机
  110.         printf("---------%x---------\n",buffer[2]);
  111.         delay(2000);
  112.         pwm_stop(PWM_RECOVERABLE_GARBAGE);
  113.     }
  114.     else if(buffer[2] != 0x45)
  115.     {
  116.         printf("%s|%s|%d: buffer[2]=0x%x\n", __FILE__, __func__, __LINE__,buffer[2]);
  117.         printf("start\n");
  118.         pwm_write(PWM_GARBAGE);  //对应wPi 7口，接着另一个舵机
  119.         delay(2000);
  120.         pwm_stop(PWM_GARBAGE);
  121.     }
  122.     pthread_exit(0);
  123. }
  125. void *poled_show(void *arg)
  126. {
  127.     pthread_detach(pthread_self()); //这意味着线程结束时会自动释放其资源，
  128.     myoled_init();
  129.     oled_show(arg); //buffer
  131.     pthread_exit(0);
  132. }
  134. void *pcategory(void *arg)
  135. {
  136.     unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
  137.     char *category = NULL;
  138.     pthread_t send_void_tid,trash_tid,oled_tid;
  140.     printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  141.     while(1)
  142.     {
  143.         printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  144.         pthread_mutex_lock(&mutex);// 锁住
  145.         //给阿里云发信号
  146.         pthread_cond_wait(&cond,&mutex);//等待信号
  147.         pthread_mutex_unlock(&mutex);
  148.         printf("%s|%s|%d:\n",__FILE__,__func__,__LINE__);//文件名-函数名-行号
  150.         buffer[2] = 0x00;
  151.         //define WGET_CMD "wget http://127.0.0.1:8080/?action=snapshot -O /tmp/garbage.jpg" //抓拍命令
  152.         system(WGET_CMD);//宏定义：拍照命令，garbage.h 文件中
  153.         // access函数是一个用于测试文件访问权限的函数，它通常用于检查某个文件是否可以被当前用户读取、写入或执行。
  154.         // 包括F_OK（检查文件是否存在）、R_OK（检查读权限）、W_OK（检查写权限）和X_OK（检查执行权限）
  155.         // 该函数返回值为0表示有权限，-1表示无权限或发生错误。
  156.         if(0 == access(GARBAGE_FILE, F_OK))//GARBAGE_FILE 宏定义 识别到的垃圾图片是否存在
  157.         {
  158.             category = garbage_category(category);//调用阿里云接口判断垃圾类型
  159.             if(strstr(category,"干垃圾"))
  160.             {
  161.                 buffer[2] = 0x41;//赋值
  162.             }
  163.             else if(strstr(category,"湿垃圾"))
  164.             {
  165.                 buffer[2] = 0x42;
  166.             }
  167.             else if(strstr(category,"可回收垃圾"))
  168.             {
  169.                 buffer[2] = 0x43;
  170.             }
  171.             else if(strstr(category,"有害垃圾"))
  172.             {
  173.                 buffer[2] = 0x44;
  174.             }
  175.             else
  176.             {
  177.                 buffer[2] = 0x45;
  178.             }
  179.         }
  180.         else
  181.         {
  182.             buffer[2] = 0x45;
  183.         }
  184.         //开三个线程
  186.         //垃圾桶开盖线程
  187.         pthread_create(&trash_tid,NULL,psend_voice,(void*)buffer);
  188.         //开语音播报线程
  189.         pthread_create(&send_void_tid,NULL,popen_trash_can,(void*)buffer);
  190.         
  191.         pthread_create(&oled_tid,NULL,poled_show,(void*)buffer);
  193.         // buffer[2]=0x00;//将buffer[2]清零
  194.         remove(GARBAGE_FILE);//garbage.h 的宏定义 把识别到的垃圾的图片清除掉
  195.     }
  196.     pthread_exit(0);
  197. }
  199. void *pget_socket(void *fd)
  200. {
  201.     int s_fd = -1;
  202.     int c_fd = -1;
  203.     char buffer[6];
  204.     int nread = -1;
  205.     struct sockaddr_in c_addr;//用于accept
  207.     memset(&c_addr,0,sizeof(struct sockaddr_in));//清零
  208.     s_fd = socket_init(IPADDR,IPPORT);
  209.     printf("%s|%s|%d: s_fd=%d\n",__FILE__,__func__,__LINE__,s_fd);
  210.     if(-1 == s_fd)
  211.     {
  212.         pthread_exit(0);
  213.     }
  214.     sleep(3);
  215.     int clen = sizeof(struct sockaddr_in);
  217.     while(1)
  218.         {
  219.         //accep第三个参数要求是指针//不连接，便堵塞，直到与客户端连接
  220.                 c_fd = accept(s_fd, (struct sockaddr *)&c_addr,&clen);
  221.         // 心包跳
  222.         int keepalive = 1; // 开启TCP KeepAlive功能
  223.         int keepidle = 5; // tcp_keepalive_time 3s内没收到数据开始发送心跳包
  224.         int keepcnt = 3; // tcp_keepalive_probes 每次发送心跳包的时间间隔,单位秒
  225.         int keepintvl = 3; // tcp_keepalive_intvl 每3s发送一次心跳包
  226.         setsockopt(c_fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive,
  227.         sizeof(keepalive));
  228.         setsockopt(c_fd, SOL_TCP, TCP_KEEPIDLE, (void *) &keepidle, sizeof
  229.         (keepidle));
  230.         setsockopt(c_fd, SOL_TCP, TCP_KEEPCNT, (void *)&keepcnt, sizeof
  231.         (keepcnt));
  232.         setsockopt(c_fd, SOL_TCP, TCP_KEEPINTVL, (void *)&keepintvl, sizeof
  233.         (keepintvl));
  236.         printf("--------ok?--------\n");
  237.         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));
  238.         printf("-----------ok!-----\n");
  239.         if(c_fd == -1)
  240.                 {
  241.                         perror("accept");//终端打出错误：accept:---
  242.             continue;
  243.                 }
  245.         while(1)
  246.         {
  247.             memset(buffer,0,sizeof(buffer));
  248.             nread = recv(c_fd,buffer,sizeof(buffer),0);// == n_read = read(c_fd,readBuf,sizeof(buffer));
  249.             printf("%s|%s|%d:nread=%d,buffer=%s\n",__FILE__,__func__,__LINE__,nread,buffer);
  250.             if(nread > 0)
  251.             {
  252.                 if(strstr(buffer,"open"))
  253.                 {
  254.                     //上锁
  255.                     pthread_mutex_lock(&mutex);
  256.                     //给阿里云发信号
  257.                     pthread_cond_signal(&cond);//发信号
  258.                     pthread_mutex_unlock(&mutex);
  259.                 }
  260.             }
  261.             else if(0==nread || -1==nread)
  262.             {
  263.                 break;
  264.             }
  265.         }
  266.         close(c_fd);
  267.     }
  268.     pthread_exit(0);
  269. }
  271. int main(int argc, char *argv[])
  272. {
  273.     printf("adsfasdf\n");
  274.     int len = 0;
  275.     int ret = -1;//标识
  276.     char *category = NULL;
  277.     unsigned char buffer[6] = {0xAA,0x55,0x00,0x00,0x55,0xAA};//AA 55 ** 00 55 AA
  278.     pthread_t get_voice_tid, category_tid,get_socket_tid;
  280.     //初始化
  281.     wiringPiSetup();//初始化wiringPi库
  282.     garbage_init(); //初始化阿里云接口
  283.    
  284.     // 用于检测特定进程是否在运行。
  285.     // 它通过调用系统命令ps -ax | grep process_name|grep -v grep来查找包含指定进程名的进程，并返回相应的进程号  
  286.     // mjpg_streamer 是一款开源的流媒体服务器软件，它能够从一系列输入插件（如USB摄像头）捕获视频数据，并通过网络以MJPG（Motion JPEG）格式实时传输
  287.     ret = detect_process("mjpg_streamer");
  288.     if(-1 == ret)
  289.     {
  290.         printf("detect process failed\n");
  291.         goto END;
  292.     }
  294.     //打开设备
  295.     serial_fd = myserialOpen(SERIAL_DEV,BAUD);//可代替设备节点 & 波特率   返回值fd
  296.     if(serial_fd == -1)//是否打开成功
  297.     {
  298.         goto END;   
  299.     }//*pget_voice(void *arg)里面判断
  300.    
  302.     //printf("%s|%s|%d:open serial failed\n",__FILE__,__func__,__LINE__);
  303.     //开语音的线程
  304.     pthread_create(&get_voice_tid,NULL,pget_voice,NULL);
  305.     //开网络线程
  306.     pthread_create(&get_socket_tid,NULL,pget_socket,NULL);
  307.     //开阿里云交互线程
  308.     pthread_create(&category_tid,NULL,pcategory,NULL);
  309.         //get_voice_tid获取语音模块的数据
  310.         //pthread_join用于等待指定的线程结束其执行
  311.     pthread_join(get_voice_tid,NULL);
  312.     pthread_join(category_tid,NULL);
  313.     pthread_join(get_socket_tid,NULL);
  315.     pthread_mutex_destroy(&mutex);
  316.     pthread_cond_destroy(&cond);
  318.     close(serial_fd);
  319. END:
  320.     garbage_final; //释放所有引用的Python对象
  321.     return 0;
  322. }
复制代码
5、实行流程和执行结果

5.1 配置客户端和mjpg_Stream



  • 利用网络调试助手



  • 查看Window & linux主机ip
       window IP 查询方法
    Linux orangepi IP 查询方法

5.2 调试和运行

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


  • 输入下令sudo -E ./category
1
2
5.3 开始识别



  • 一切都预备好了，如今可以开始实行了
  •    识别干垃圾（纸巾）
    识别结果


  •    识别可接纳垃圾
    识别结果


  •    识别湿垃圾(一个橘子)
    识别结果

6、总结



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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

正序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

张春

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表