香橙派增加网络控制功能

最新推荐文章于 2024-05-20 20:42:03 发布
最新推荐文章于 2024-05-20 20:42:03 发布
阅读量286 收藏 4
点赞数 3
分类专栏： ARM+Linux 文章标签： 网络 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47944751/article/details/136184228
版权

香橙派增加网络控制功能

1.TCP心跳机制解决Socket异常断开问题

1.客户端能够发送状态给服务器；正常断开，强制关闭客户端等，客户端能够做出反应。

2.客户端不能发送状态给服务器；突然断网，断电，客户端卡死等，客户端根本没机会做出反应，

服务器更不了解客户端状态，导致服务器异常等待。

为了解决上述问题，引入TCP心跳包机制

心跳包的实现，心跳包就是服务器定时向客户端发送查询信息，如果客户端有回应就代表连接正常，

类似于linux系统的看门狗机制。心跳包的机制有一种方法就是采用TCP_KEEPALIVE机制，它是一种用于

检测TCP连接是否存活的机制，它的原理是在一定时间内没有数据往来时，发送探测包给对方，如果对方

没有响应，就认为连接已经断开。TCP_KEEPALIVE机制可以通过设置一些参数来调整，如探测时间间

隔、探测次数等。

Linux内核提供了通过sysctl命令查看和配置TCP KeepAlive参数的方法。

  • 查看当前系统的TCP KeepAlive参数
sysctl net.ipv4.tcp_keepalive_time
sysctl net.ipv4.tcp_keepalive_probes
sysctl net.ipv4.tcp_keepalive_intvl
  • 修改TCP KeepAlive参数
sysctl net.ipv4.tcp_keepalive_time=3600

2.c语言实现TCP KeepAlive功能

对于Socket而言，可以在程序中通过socket选项开启TCP KeepAlive功能，并配置参数。对应的Socket选

项分别为 SO_KEEPALIVE 、 TCP_KEEPIDLE 、 TCP_KEEPCNT 、 TCP_KEEPINTVL 。

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(client_socketfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive,
sizeof(keepalive));
setsockopt(client_socketfd, SOL_TCP, TCP_KEEPIDLE, (void *) &keepidle, sizeof
(keepidle));
setsockopt(client_socketfd, SOL_TCP, TCP_KEEPCNT, (void *)&keepcnt, sizeof
(keepcnt));
setsockopt(client_socketfd, SOL_TCP, TCP_KEEPINTVL, (void *)&keepintvl, sizeof
(keepintvl));

3.代码实现

socket.c

#include "socket.h"

int socket_init(const char *ipaddr,const char *ipport)
{
    int s_fd=-1;
    int ret=-1;
    struct sockaddr_in s_addr;
    memset(&s_addr,0,sizeof(struct sockaddr_in));
    //1. socket
	s_fd = socket(AF_INET, SOCK_STREAM, 0);
	if(-1==s_fd)
    {
		perror("socket");
		return -1;
	}
	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(ipport));
	inet_aton(ipaddr,&s_addr.sin_addr);
	//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;
}

socket.h

#ifndef _SOCKET_H_
#define _SOCKET_H_
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>

#define IPADDR "192.168.1.103"
#define IPPORT "8192" //不要用8080，摄像头已经用了8080#define IPADDR "192.168.1.103"

int socket_init(const char* ipaddr,const char* ipport);


#endif

main.c

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<unistd.h>
    #include<errno.h>
    #include<wiringPi.h>
    #include<pthread.h>
    #include "pwm.h"
    #include "uartTool.h"
    #include "garbage.h"
    #include "myoled.h"
    #include "socket.h"

    static int detect_process(const char * process_name) //判断进程是否在运行
    {
        int n = -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) //获取pid
            {
                n = atoi(buf);  //转换为数字
            }
        }
        else
        {
            return -1;
        }
        pclose(strm);
        return n;
    }

    #if  0
    int main(int argc,char* argv[])
    {
        int serial_fd=-1;
        int len=0;
        int ret=-1;
        char* category=NULL;
        unsigned char buffer[6]={0xAA,0x55,0x00,0x00,0x55,0xAA};

        wiringPiSetup(); //初始化wiringPi库
        garbage_init(); //初始化阿里云接口

        ret=detect_process("mjpg_streamer"); //简称mjpg_streamer是否打开
        if(-1==ret)
        {
            printf("detect process failed\n");
            goto END;
        }

        serial_fd=myserialOpen(SERIAL_DEV,BAUD); //初始化串口
        if(-1==serial_fd) //串口打开失败
        {
            printf("open serial failed\n");
            goto END;
        }

        //进行垃圾分类识别
        while(1)
        {
            len=serialGetstring(serial_fd,buffer); //获取串口的数据
            if(len>0&&buffer[2]==0x46) //识别垃圾类型
            {
                buffer[2]=0x00; //对buffer[2]进行清空
                system(WGET_CMD); //进行拍照
                if(0==access(GARBAGE_FILE,F_OK)) //文件存在
                {
                    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;
                }

                serialSendstring(serial_fd,buffer,6); //将识别的垃圾类型回传给语音模块
                if(buffer[2]==0x43)
                {
                    pwm_write(PWM_RECOVERALE_GARBAGE); //开盖
                    delay(5000);//开盖5s
                    pwm_stop(PWM_RECOVERALE_GARBAGE);//关盖
                }
                else if(buffer[2]==0x41)
                {
                    pwm_write(PWM_GARBAGE); //开盖
                    delay(5000);//开盖5s
                    pwm_stop(PWM_GARBAGE);//关盖
                }
                else if(buffer[2]==0x42)
                {
                    pwm_write(PWM_WET_GARBAGE); //开盖
                    delay(5000);//开盖5s
                    pwm_stop(PWM_WET_GARBAGE);//关盖
                }
                else if(buffer[2]==0x44)
                {
                    pwm_write(PWM_HARMFUL_GARBAGE); //开盖
                    delay(5000);//开盖5s
                    pwm_stop(PWM_HARMFUL_GARBAGE);//关盖
                }
                buffer[2]=0x00;//清空是为了下一次识别
                remove(GARBAGE_FILE); //清理缓存
            }
        }

        close(serial_fd);
        END:
        garbage_final(); //释放python解析器   
        return 0;
    }
    #endif


    int serial_fd=-1;

    pthread_cond_t cond;//条件变量
    pthread_mutex_t mutex; //互斥锁

    //获取语音数据线程
    void* get_voice(void *arg)
    {
        unsigned char buffer[6]={0xAA,0x55,0x00,0x00,0x55,0xAA};
        int len=0;
        printf("%s|%s|%d\n",__FILE__,__func__,__LINE__);
        if(-1==serial_fd)
        {
            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);
            printf("%s|%s|%d,len=%d\n",__FILE__,__func__,__LINE__,len);
            if(len>0&&buffer[2]==0x46)
            {
                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(-1==serial_fd)
        {
            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; 
        if(buffer[2]==0x43)
        {
            printf("%s|%s|%d,buffer[2]=0x%x\n",__FILE__,__func__,__LINE__,buffer[2]);
            pwm_write(PWM_RECOVERALE_GARBAGE); //开盖
            delay(2000);//开盖5s
            pwm_stop(PWM_RECOVERALE_GARBAGE);//关盖
        }
        else if(buffer[2]!=0x45)
        {
            printf("%s|%s|%d,buffer[2]=0x%x\n",__FILE__,__func__,__LINE__,buffer[2]);
            pwm_write(PWM_GARBAGE); //开盖
            delay(2000);//开盖5s
            pwm_stop(PWM_GARBAGE);//关盖
        }

        pthread_exit(0);
    }

    //oled显示线程
    void* poled_show(void* arg)
    {
        pthread_detach(pthread_self());

        myoled_init();
        oled_show(arg);

        pthread_exit(0);
    }

    //垃圾分类识别线程
    void* pcategory(void *arg)
    {
        unsigned char buffer[6]={0xAA,0x55,0x00,0x00,0x55,0xAA};
        char* category=NULL;
        pthread_t send_voice_tid;
        pthread_t trash_tid;
        pthread_t 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;//清空是为了下一次识别
            system(WGET_CMD); //进行拍照
            if(0==access(GARBAGE_FILE,F_OK)) //文件存在
            {
                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,popen_trash_can,(void*)buffer);
            //发送语音播报线程
            pthread_create(&send_voice_tid,NULL,psend_voice,(void*)buffer);
            //oled显示线程
            pthread_create(&oled_tid,NULL,poled_show,(void*)buffer);


            remove(GARBAGE_FILE); //清理缓存
        }

        pthread_exit(0);
    }

    //网络线程
    void* pget_socket(void *arg)
    {
        int s_fd=-1;
        int c_fd=-1;
        int n_read=-1;
        char buffer[6];
        struct sockaddr_in c_addr;
        memset(&c_addr,0,sizeof(struct sockaddr_in));

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

        while(1)
        {
            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("%s|%s|%d:Accept a connection from %s:%d\n",__FILE__,__func__,__LINE__, inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port));
            if(-1==c_fd)
            {
                perror("accept");
                continue;
            }
            while(1)
            {
                memset(buffer,0,sizeof(buffer));
                n_read=recv(c_fd,buffer,sizeof(buffer),0);
                printf("%s|%s|%d:n_read=%d,buffer=%s\n",__FILE__,__func__,__LINE__,n_read,buffer);
                if(n_read>0)
                {
                    if(strstr(buffer,"open")) //给阿里云交互线程发信号
                    {
                        pthread_mutex_lock(&mutex);
                        pthread_cond_signal(&cond);
                        pthread_mutex_unlock(&mutex);
                    }
                }
                else if(0==n_read||-1==n_read)
                {
                    break;
                } 
            }
            close(c_fd);
        }

        pthread_exit(0);
    }

    int main(int argc,char* argv[])
    {
        int len=0;
        int ret=-1;
        char* category=NULL;
        pthread_t get_voice_tid;
        pthread_t category_tid;
        pthread_t get_socket_tid;

        wiringPiSetup(); //初始化wiringPi库
        garbage_init(); //初始化阿里云接口

        ret=detect_process("mjpg_streamer"); //简称mjpg_streamer是否打开
        if(-1==ret)
        {
            printf("detect process failed\n");
            goto END;
        }

        serial_fd=myserialOpen(SERIAL_DEV,BAUD); //初始化串口
        if(-1==serial_fd) //串口打开失败
        {
            printf("open serial failed\n");
            goto END;
        }

        //开语音线程
        printf("%s|%s|%d\n",__FILE__,__func__,__LINE__);
        pthread_create(&get_voice_tid,NULL,get_voice,NULL);
        //开阿里云交互线程
        printf("%s|%s|%d\n",__FILE__,__func__,__LINE__);
        pthread_create(&category_tid,NULL,pcategory,NULL);
        //开网络线程
        printf("%s|%s|%d\n",__FILE__,__func__,__LINE__);
        pthread_create(&get_socket_tid,NULL,pget_socket,NULL);

        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;
    }
my hope !
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络编程知识预备(3) —— TCP流量控制(滑动窗口)、拥塞控制
Zy_1213的博客
09-09 803
网络编程知识预备(3) ——TCP流量控制(滑动窗口)、拥塞控制 一、TCP流量控制(滑动窗口) 二、TCP拥塞控制 TCP的四种拥塞控制算法 1.慢开始 2.拥塞避免 3.快重传
网络编程知识预备(5) —— 了解应用层的HTTP协议与HTTPS协议
Zy_1213的博客
09-10 1251
网络编程知识预备(5) —— 了解应用层的HTTP协议与HTTPS协议 一、HTTP协议 http协议的特性、请求 请求行、请求头、请求主体、响应 GET请求、POST 请求(人脸识别方案)、两个请求的区别 响应行、响应头、响应主体 二、HTTPS协议 1、简介与原理 2、密码学基础 明文与密文、密钥 对称加密(私钥+私钥)、非对称加密(公钥+私钥) 三、HTTPS相对于HTTP优缺点 优点：正确率更高，安全性更强 缺点：效率低，成本高
使用树莓派(香橙派)搭建文件共享服务器-samba服务器
meihualing的专栏
10-20 2227
文件共享服务器
使用香橙派并基于Linux实现最终版智能垃圾桶项目 --- 下
mjmmm的博客
10-24 1471
在上节已经完成了对于前7个功能的编写，本节完成最后一个需求，使用第三方库结合python实现图像识别垃圾分类功能！
Linux-ARM架构，全志H616香橙派开发笔记
weixin_44531081的博客
11-13 4961
Linux-ARM架构，全志H616香橙派开发笔记
如何基于香橙派AIpro对视频/图像数据进行预处理？
华为云官方博客
04-19 641
昇腾CANN提供了两种专门用于数据预处理的方式：AIPP和DVPP。
OrangePi ZERO 2 新手配置教程（保姆级新手教程）
qq_42417071的博客
10-06 1846
香橙派（OrangePi）是一款国产开源的单板卡片电脑，可以运行 AndroidTV 10、Ubuntu 和 Debian 等操作系统。作为树莓派（RaspberryPi）的平替产品，香橙派的资料也非常多。同时作为国产产品，它的很多手册也对大多数初次接触 Linux 系统开发和英文水平不高的新手特别友好，很多手册资料都有具有中文版。虽然资料和社区资源非常丰富，但是因为大多数资料都比较零散，对刚入门的新手不够友好。所以结合自己玩 OrangePi ZERO 2 的经验，以及各个社群资料整理这篇新手教程。
基于EPICS stream模块的直流电源的IOC控制程序实例
yuyuyuliang00的博客
11-02 979
基于EPICS stream模块的IOC控制程序实例
香橙派 zero3 用户手册
04-08
香橙派 zero3 用户手册
香橙派显示系统信息到OLED显示屏
02-02
内容概述：将香橙派的IP地址，soc、gpu温度，CPU用户使用率和CPU系统使用率显示在OLED显示屏上，并每隔10s自动切换一下页面。 适用人群：香橙派Pi3、Pi3 zero、Pi4、Pi5 使用方法：将文件下载到香橙派中，然后使用...
香橙派OrangePi Zero2镜像文件
02-11
搬运自香橙派官网的固件，文件名为：Orangepizero2_3.0.6_ubuntu_jammy_server_linux5.16.17，基于Linux5.16内核，适配香橙派Zero2开发板，官网为百度网盘，下载慢，目前搬运至CSDN，下载速度较快
香橙派zero镜像及烧写工具.zip
05-14
香橙派zero镜像及烧写工具.zip 香橙派zero 两个镜像包，一个格式化工具，一个烧写工具 下面镜像测试过 Armbian_20.02.1_Orangepizero_bionic_current_5.4.20.7z
香橙派机械模型Plus和Lite版本dxf模型
07-01
香橙派机械模型Plus和Lite版本dxf模型
Linux网络编程：网络基础
最新发布
weixin_73234157的博客
05-20 493
当我们形成计算机网络后，小明要给他的暗恋对象小红发一句“我喜欢你”，结果发给了小芳……，在计算机网络中会出现许许多多的主机，当我们进行网络通信时，我们要通过协议来找到指定的接收方。同理在单台主机中，数据从键盘中读入再转载到当前网卡也是需要协议的。简单来说：协议就是一种约定当计算机在读取数据时，发现数据中存在向网卡输送的标志（协议）时，就往网卡输送。当网卡读取到输送给小红，网卡就不会发送给小芳。
使用MPLS解决BGP的路由黑洞（详解）
qq_64302290的博客
05-18 232
我们知道在MPLS中数据的转发不再依靠路由表而是靠标签（注意：标签是在路由的基础上形成的）。所以在BGP中，我们依靠的就是这个特性来解决BGP的路由黑洞。BGP路由黑洞的解释：BGP的路由黑洞其实就是路由层面可达，数据层面不可达。（你可以收到对方的路由，但是不能和对方通讯。
云服务器遇到攻击怎么办，有哪些安全措施
dexunyun的博客
05-18 546
DDoS攻击对云服务器安全构成了严重威胁，但通过采取合适的防护策略，我们可以有效地降低攻击的影响。选择可靠的云服务提供商、部署DDoS防护服务是保护云服务器免受DDoS攻击的有效措施。德迅云安全提供了多种防护解决方案，可以帮助企业有效防止DDoS攻击，保护云服务器的安全，保障业务稳定。
香橙派 opencv
10-18
好的，关于“香橙派 opencv”，我可以为您提供一些帮助。首先，您需要在香橙派上安装OpenCV库，可以通过以下命令进行安装： ``` sudo apt-get install libopencv-dev python-opencv ``` 安装完成后，您可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值