基于搜索协议实现工业设备升级

目录

1、背景引入

2、技术分析

 3、过程概述

4、服务器端流程

5、客户端流程

6、效果展示 

7、源码 

7.1 master(主控)

7.2 device(设备)

8、注意事项


1、背景引入

        在工业生产中,设备的升级和维护是非常重要的环节。随着技术的不断进步,工厂设备通常需要定期进行软件或固件的升级,以确保其性能、安全性和功能的持续改进。在这一过程中,文件传输是一个关键的步骤,因为升级文件的准确、高效地传输直接影响着设备升级的成功与否。

        在工业环境中,设备通常会连接到一个局域网中,并且可能分布在不同的位置。因此,为了实现设备升级,需要一种可靠的网络通信机制,能够让设备发现服务器上的升级文件,并将文件安全地传输到设备中进行应用。

        UDP(用户数据报协议)和TCP(传输控制协议)是两种常用的网络通信协议,它们分别适用于不同的场景。UDP适用于广播和简单的数据传输,而TCP适用于建立可靠的连接并进行大规模数据传输。

        因此,基于UDP和TCP模拟工厂设备升级过程中的文件传输,有助于理解和展示工业设备升级过程中的网络通信原理和流程。

2、技术分析

  • UDP:UDP(用户数据报协议)用于在局域网内广播消息,以便设备能够发现服务器并获取升级文件的信息。
  • TCP:TCP(传输控制协议)用于建立可靠的连接,并传输升级文件的数据。
  • 文件IO:通过文件I/O,程序能够从文件中读取数据,或者将数据写入文件。可以将程序中的数据持久化到文件中,以便在程序关闭后能够保存数据。
  • 并发服务:三种方法使得TCP具有并发处理的能力。分别是:多线程、多进程、IO多路复用(select、poll、epoll)。
  •  数据库:嵌入式常用的轻量级小型数据库(sqlite3),用来存储每次升级的设备信息以及每次升级的时间信息等,便于后期管理以及维护。

 3、过程概述

  1. 服务器端创建UDP套接字并设置允许广播;
  2. 服务器端发送广播消息,告知设备有升级文件可用;
  3. 客户端接收到广播消息后,提取服务器地址和端口信息,并使用TCP连接请求连接服务器;
  4. 服务器端并发接受客户端的连接请求,并开始传输文件;
  5. 客户端接收文件数据,并应用升级。
基于搜索协议实现工业设备升级_第1张图片 图3-1 过程简易描述

4、服务器端流程

  1. 创建UDP套接字并设置允许广播;
  2. 件可发送广播消息,告知设备有升级文用;
  3. 创建TCP套接字并绑定端口;
  4. 监听客户端连接请求;
  5. 接受客户端连接请求;
  6. 读取升级文件并发送给客户端;
  7. 关闭客户端连接(心跳包)。

5、客户端流程

  1. 创建UDP套接字并绑定端口;
  2. 接收广播消息;
  3. 创建TCP套接字并连接服务器;
  4. 接收文件数据并保存到本地文件;
  5. 关闭TCP连接。

6、效果展示 

基于搜索协议实现工业设备升级_第2张图片 图6-1 并发处理升级设备
基于搜索协议实现工业设备升级_第3张图片 图6-2 可视化数据库

7、源码 

7.1 master(主控)

#include 
#include 
#include 
#include 
#include  /* See NOTES */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

int data_base(char *);

//线程函数处理与每一台设备进行数据发送
void *handler(void *arg)
{
	//获取文件描述符
	int acceptfd = (int)arg;
	printf("acceptfd = %d\n", acceptfd);
	int fd;
	//打开要发送的文件,(要是想通过命令行传参,你可以给线程传入结构体)
	if ((fd = open("new.txt", O_RDONLY)) < 0)
	{
		perror("open:");
		return NULL;
	}
	char buf[64] = {0};
	while (1)
	{
		int n = read(fd, buf, 64);
		if (n < 0)
		{
			perror("read err");
			return NULL;
		}
		if (n == 0)
			break;
		//发送数据给设备
		if (send(acceptfd, buf, n, 0) < 0)
		{
			perror("send err");
			return NULL;
		}
	}
	printf("线程处理结束\n");
	close(acceptfd);
	close(fd);
	pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
	//UDP
	int sockfd;
	//搜索协议套接字
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
	{
		perror("socket err:");
		return -1;
	}
	int tv = 1;
	//发送方设置为发送广播
	if (setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &tv, sizeof(tv)) < 0)
	{
		perror("setsockopt err:");
		return -1;
	}
	struct sockaddr_in brandaddr;
	//填充结构体
	brandaddr.sin_family = AF_INET;
	brandaddr.sin_port = htons(8888);
	brandaddr.sin_addr.s_addr = inet_addr("192.168.0.255");
	int len_bra = sizeof(brandaddr);

	printf("我已经准备发送\n");
	int ret;
	//以广播的形式发送这条信息。
	ret = sendto(sockfd, "connect", 8, 0, (struct sockaddr *)&brandaddr, len_bra);
	if (ret < 0)
	{
		perror("sendto err:");
		return -1;
	}
	ssize_t num;
	printf("我已经发送完成\n");

	//TCP
	int decfd;
	//流式套接字
	if ((decfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{
		perror("socket err:");
		return -1;
	}
	int optval = 1;
	//设置地址重用
	setsockopt(decfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
	//绑定
	struct sockaddr_in ser_addr;
	//填充服务器的结构体
	ser_addr.sin_family = AF_INET;
	ser_addr.sin_port = htons(8888); //
	ser_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
	int len_ser = sizeof(ser_addr);

	//绑定
	if (bind(decfd, (struct sockaddr *)&ser_addr, len_ser) < 0)
	{
		perror("bind err is:");
		return -1;
	}
	//启动监听,变为被动打开
	if (listen(decfd, 5) < 0)
	{
		perror("listen err:");
		return -1;
	}
	int dat = data_base(argv[1]);
	if(dat)//判断数据库的操作
	{
		printf("database is err");
		return -1;
	}
	struct sockaddr_in dev_addr;
	while (1)
	{
		char buf[4] = {};
		//接收确认信息
		num = recvfrom(sockfd, buf, 4, 0, (struct sockaddr *)&dev_addr, &len_bra);
		if (strncmp(buf, "yes", 3) == 0)
		{
			printf("wait accept\n");
			int acceptfd;
			//链接建立之后的信息交互文件描述符
			if ((acceptfd = accept(decfd, (struct sockaddr *)&dev_addr, &len_ser)) < 0)
			{
				perror("accept err:");
				return -1;
			}
			printf("链接成功 %s %s %d %p\n", inet_ntoa(dev_addr.sin_addr), buf, acceptfd, &acceptfd);
			pthread_t tid;
			if (pthread_create(&tid, NULL, handler, (void *)acceptfd))
			{
				perror("pthread create err:");
				break;
			}
		}
	}
	close(sockfd);
	close(decfd);
	return 0;
}


int data_base(char *file)
{
	sqlite3 *db = NULL; //防止野指针
	if (sqlite3_open("./my.db", &db) != 0)
	{
		//不能用perror, perror只能打印操作系统级别的错误  sqlite是独立的
		//fprintf代表 格式化输出到流内
		fprintf(stderr, "sqlite_open is err: %s\n", sqlite3_errmsg(db));
		//printf("sqlite3_open is err: %s\n",sqlite3_errmsg(db);
		return -1;
	}
	printf("create is success\n");
	char *errmsg = NULL;
	if (sqlite3_exec(db, "create table version(time char,file_name char,size int);",
					 NULL, NULL, &errmsg) != SQLITE_OK)
	{
		fprintf(stderr, "create table is err: %s\n", errmsg);
	}
	printf("table is success\n");

	time_t tim;
	struct tm *localtim = NULL;
	tim = time(NULL);
	localtim = localtime(&tim);
	int year = localtim->tm_year + 1900;
	int mon = localtim->tm_mon;
	int day = localtim->tm_mday;
	int hour = localtim->tm_hour;
	int min = localtim->tm_min;
	int sec = localtim->tm_sec;
	char timebuf[32]={0};
	sprintf(timebuf, "%d-%02d-%02d %02d:%02d:%02d", year, mon, day, hour, min, sec);
	struct stat buf;
	stat(file, &buf);
	char sql[128] = {0};
	sprintf(sql, "insert into version values(\"%s\",\"%s\",%ld);", timebuf, file, buf.st_size);
	if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
	{
		fprintf(stderr, "create table is err: %s\n", errmsg);
		return -1;
	}
	return 0;
}

7.2 device(设备)

 #include 
#include 
#include  /* See NOTES */
#include 
#include 
#include  /* superset of previous */
#include 
#include 
#include 
#include 
#include 
#include 
 
int main(int argc, char *argv[])
{
	//当作搜索协议使用
	int sockfd;
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)//先打开数据包式套接字
	{
		perror("socket err:");
		return -1;
	}
    int optval = 1;
	//用于本地测试并发的。主要是设置地址重用
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
	
	struct sockaddr_in addr;
	//填充结构体
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = inet_addr("192.168.0.255");
	// addr.sin_addr.s_addr = INADDR_ANY;
	addr.sin_port = htons(8888);
	socklen_t addrlen = sizeof(addr);
	//绑定addr
	if (bind(sockfd, (struct sockaddr *)&addr, addrlen) < 0)
	{
		perror("bind err:");
		goto err;
	}
	ssize_t num;
	char buf[8] = {0};
	//接受对端ip、port等的结构体
	struct sockaddr_in clientaddr;
	//接受内容,之后比较接受到的内容
	num = recvfrom(sockfd, buf, 8, 0, (struct sockaddr *)&clientaddr, &addrlen);
    if(num <0)
    {
        perror("recvfrom err");
		goto err;
    }
	if (strncmp(buf, "connect", 7) != 0)
	{
		printf("quit\n");
		goto err;
	}
    
	sendto(sockfd, "yes", 4, 0, (struct sockaddr *)&clientaddr, addrlen);
	printf("回复完成\n");
	//搜索协议生命周期结束
    close(sockfd);

	int decfd;
	//新的流式套接字
	if ((decfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{
		perror("socket err:");
		return -1;
	}
    int optva = 1;
	//设置地址重用,为了测试并发
	setsockopt(decfd, SOL_SOCKET, SO_REUSEADDR, &optva, sizeof(optval));
	//定义结构体,用来接受服务器发送的文件信息等。保证可靠。
	struct sockaddr_in dev_addr;
	dev_addr.sin_family = AF_INET;
	dev_addr.sin_port = htons(8888); //
	dev_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	int len = sizeof(dev_addr);
    //请求链接服务器
	if (connect(decfd, (struct sockaddr *)&dev_addr, len) < 0)
	{
		perror("connect err:");
		close(decfd);
		return -1;
	}
	printf("connet success\n");
	int fd;
	//打开文件,用于后续接收数据
	if ((fd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0)
	{
		perror("open:");
		close(decfd);
		return -1;
	}
	char buff[64] = {0};
	while (1)
	{
		int ret;
		ret = recv(decfd, buff, 64, 0);
		if (ret < 0)
		{
			perror("recv err:");
			return -1;
		}
		else if (ret > 0)
		{
			//写入文件
			write(fd, buff, ret);
			memset(buff, 0, 64);
		}
		else
		{
			break;
		}
	}
	printf("Upgrade successful\n");
    close(decfd);
	close(fd);
	return 0;
err:
	close(sockfd);
	return 0;
}

8、注意事项

        使用多线程的时候,因为线程的特性,不得不使用线程栈保存文件描述符来保证并发的完成。但是线程传参的时候,传入地址导致传输的地址是同一个。这是因为变量的定义在局部中,结束之后销毁,再次创建变量,编译器可能会再次为变量分配这块内存地址。导致问题一直无法解决。

你可能感兴趣的:(网络)