温度采集实时上报——服务端（多进程）

最新推荐文章于 2024-08-28 23:51:19 发布
最新推荐文章于 2024-08-28 23:51:19 发布
阅读量834 收藏 4
点赞数
分类专栏： Unix环境编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ternence_zq/article/details/104954716
版权

文章目录

1. 服务端要求

1， 服务器程序运行在Linux服务器或同一个树莓派上(远程登录)；
2， 通过命令行指定监听的端口；
3， 程序放到后台运行，并通过syslog记录程序的运行出错、调试日志；
4， 程序能够捕捉kill信号正常退出；
5， 服务器要支持多个客户端并发访问，可以选择多路复用、多进程或多线程任意一种实现；
6， 服务器收到每个客户端的数据都解析后保存到数据库中，接收到的数据格式为： SN/时间/温度，例如RPI0001/2019-01-05 11:40:30/30.0C。

该数据库要求一个客户端创建一个表，表名为客户端树莓派的ID，如RPI0001， 表里面有三个字段，分别为ID（自动增长的主键）、时间、温度值。

2. 服务端流程图

在这里插入图片描述

3. 功能分析

1、服务器端前几条功能要求与客户端基本一致，这里不再赘述；
2、服务器并发访问有多进程、多线程、IO多路复用(select、poll、epoll)，这里选择多进程进行socket编程；
这里关于多进程，多线程和多路复用的详细对比分析参考下面链接：
Linux下多进程/线程区别
Linux下select、poll和epoll区别
3、服务器将接收到的数据保存至数据库中，这里选择sqlite3这种轻型数据库(适用于嵌入式领域，占用资源很少)，关于数据库的具体使用方法可以参考下面链接：
sqlite数据库学习

4. 代码模块

这里只是一个server_mult-process.c文件实现服务器程序，包括数据的创建与插入。

/*********************************************************************************
 *      Copyright:  (C) 2019 Tang Zhiqiang<t_zhiqiang@163.com>
 *                  All rights reserved.
 *
 *       Filename:  server_mult-process.c
 *    Description:  This file is socket server RPI temperature
 *                 
 *        Version:  1.0.0(11/04/2019)
 *         Author:  Tang Zhiqiang <t_zhiqiang@163.com>
 *      ChangeLog:  1, Release initial version on "11/04/2019 08:15:46 PM"
 *                 
 ********************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include <pthread.h>
#include <getopt.h>
#include <libgen.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h> 
#include <sys/resource.h>
#include <signal.h>
#include <syslog.h>
#include <fcntl.h>
#include <sqlite3.h>
//#include "server_init.c"

#define MAX_EVENTS      512
#define ARRAY_SIZE(x)   (sizeof(x)/sizeof(x[0]))    //计算结构体数组大小

static inline void print_usage(char *programe);
//void set_socket_rlimit(void);

int     g_sigstop = 0;
void signal_stop(int signum)
{
    if(SIGTERM == signum)
    {
        printf("SIGTERM signal detected\n");
        g_sigstop = 1;
    }
}

int main(int argc, char *argv[])
{
    int     listenfd,connfd;
    int     serv_port = 0;
    char    *serv_ip=NULL;
    int     daemon_run = 0;
    char    *progname = NULL;
    int     opt;
    socklen_t    cliaddr_len=20;
    int     rv=0;
    int     log_fd;
    int     i;
    char    buf[1024];
    char    sql1[28];
    pid_t   pid;
    struct sockaddr_in  serv_addr;	//在main()中，用到该局部变量
    int     on=1;

    sqlite3  *db=NULL;
    char    *zErrMsg = NULL;
    int     rc;
    int     len;
    int     ret;
    char    *sql=NULL;
    char    delim[]="/";
    char    id[20];
    char    data_time[50];
    char    temper[10];
    char    *ptr=NULL;
    //char    *p=NULL;
    
    struct option long_options[]=
    {
        {"daemon", no_argument, NULL, 'd'},
        {"port", required_argument, NULL, 'p'},
        {"help", no_argument, NULL, 'h'},
        {NULL, 0, NULL, 0}
    };

    progname = basename(argv[0]);

    //Parser the command line parameters 
    while((opt = getopt_long(argc, argv, "dp:h", long_options, NULL)) != -1)
    {
        switch (opt) 
        {
            case 'd':
                daemon_run = 1;
                break;
            case 'p':
                serv_port = atoi(optarg);
                break;
            case 'h':
                print_usage(progname);
                break;
            default:
                break;
        }
    }
    if(!serv_port) 
    {
        print_usage(progname);
        return -1;
    }
    
    signal(SIGTERM, signal_stop);   //15号信号（SIGTERM）可被捕捉

    if(daemon_run)
    {
        printf("program %s running at the backgroud now\n", argv[0]);
        
        //建立日志系统
        log_fd=open("receive_temper.log", O_CREAT|O_RDWR, 0666);
        if(log_fd < 0) 
        {
            printf("Open the logfile failure: %s\n", strerror(errno));
            return 0;
        }
        //标准输出、标准出错重定向
        dup2(log_fd, STDOUT_FILENO);
        dup2(log_fd, STDERR_FILENO);

        //程序后台运行
        if(daemon(1, 1) <0 )
        {
            printf("Deamon failure: %s", strerror(errno));
            return 0;
        }
    }
        
   if((listenfd=socket(AF_INET, SOCK_STREAM, 0)) < 0 )
   {
	   printf("create socket failure: %s\n", strerror(errno));
	   return -1;
   }
   //Set socket port reuseable, fix 'Address already in use' bug when socket server restart
   //setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
   memset(&serv_addr, 0, sizeof(serv_addr));
   serv_addr.sin_family = AF_INET;
   serv_addr.sin_port = htons(serv_port);
   if(!serv_ip)
   {
	   /*  监听所有的客户端的IP地址 */
	   serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
   }
   else
   { 
	   if(inet_pton(AF_INET, serv_ip, &serv_addr.sin_addr) <= 0)
	   {
		   printf("inet_pton() set listen IP failure: %s\n", strerror(errno));
		   close(listenfd);
		   //goto Cleanup;
		   return -1;
	   }	   
   }
 
   //Set socket port reuseable, fix 'Address already in use' bug when socket server restart
   if((setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (void*)&on, sizeof(on))) < 0 )
   {
	   printf("setsockopt failure: %s\n", strerror(errno));
	   return -2;
   }

   if(bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
   {
	   printf("bind socket[%d] failure: %s\n", listenfd, strerror(errno));
	   close(listenfd);
	   return -3;	   
   }
   if(listen(listenfd, 64) < 0)
   {
	   //printf("listen() socket[%d] failure: %s\n", listenfd, strerror(errno));
	   printf("ERROR: %s server listen on port %d failure\n", argv[0], serv_port);
	   close(listenfd);
	   return -4;
    }
    printf("server socket[%d] start to listen on port %d\n", listenfd, serv_port);
    
     /*   Open database  若没有则创建*/
    len = sqlite3_open("temper.db", &db);
    if(len != SQLITE_OK)
    {
        sqlite3_close(db);
        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
        exit(1);
    }
    printf("Opened database successfully\n");
    
     /*   Create SQL statement */
    //sql ="create table if not exists temperature(ID char(10), datetime char(50), temperature  char(10))";
    sql ="create table temperature(ID char(10), datetime char(50), temperature  char(10))";

    /*   Execute SQL statement */
    rc = sqlite3_exec(db, sql, 0, 0, &zErrMsg);
    if( rc != SQLITE_OK )
    {
        sqlite3_close(db);
        fprintf(stderr, "Create table error: %s\n", zErrMsg);
        return -1;
    }
    printf("Table created successfully\n");
   
    //printf("programe will start running...\n");
    while(!g_sigstop)
    {   
        //program will blocked here
        printf("Start accept new cilent...\n");
        connfd=accept(listenfd, (struct sockaddr *)&serv_addr, &cliaddr_len);   //accepte() 第三个参数可以是siziof(struct sockaddr)
        if(connfd < 0)
        {
            printf("accept new client failure: %s\n", strerror(errno));
            continue;
        }
        printf("accept new client [%s:%d] sucessful.\n", inet_ntoa(serv_addr.sin_addr), ntohs(serv_port));
        
        pid=fork();
        if(pid < 0)
        {
            printf("fork() create child process failure: %s\n", strerror(errno));
            //close(connfd);
            continue;
        }
        else if(pid > 0)
        {
            /* parent process close client fd and goes to accept new cilent again */
            close(connfd);
            continue;
        }
        else if(pid == 0)
        {
            /* child process close the listen socket fd */
            close(listenfd);

            printf("Child process start to commuicate with socket client...\n");
            while(1)
			{
				memset(buf, 0, sizeof(buf));
				rv=read(connfd, buf, sizeof(buf));
				if(rv <= 0)
				{
					printf("read client [%d] data failure or socket disconnected: %s\n", connfd, strerror(errno));
					close(connfd);
					exit(0);
				}
				else if(rv > 0)
				{
					printf("socket[%d] read data: %s\n", connfd, buf);
					//读到数据之后需要处理并保存到数据库
					ptr = strtok(buf, delim);    
					while(ptr != NULL)
					{
						strncpy(id, ptr, sizeof(id));
						ptr=strtok(NULL, delim);
						strncpy(data_time, ptr, sizeof(data_time));
						ptr=strtok(NULL, delim);
						strncpy((char *)temper, ptr, sizeof(temper));
						ptr=strtok(NULL, delim);
					}
					memset(sql1, 0, sizeof(sql1));
					snprintf(sql1, 128, "insert into temperature values('%s', '%s', '%s');", id, data_time, temper);
					//保证了数组sql1的内容为字符串
					sql1[127] = '\0';    
					printf("%s\n", sql1); 
					//调用sqlite3_exec()；将数据存储至temperature表中
					ret = sqlite3_exec(db, sql1, 0 , 0, &zErrMsg);
					if (ret != SQLITE_OK)     //判断返回值，如果不等于SQLITE_OK，即插入记录失败            
					{
						sqlite3_close(db);
						printf("insert data failure ； %s!\n", zErrMsg);                                  
						return 0;
					}
					printf("insert data successfully!\n");
				}//else if(rv > 0)
			}//while(1)
        }//else if(pid == 0) 
    }//while(!g_sigstop)  
    close(listenfd);
    sqlite3_close(db);  //关闭数据库

    return 0;
}//main()


static inline void print_usage(char *progname)
{
	printf("Usage: %s [OPTION]...\n", progname);
	printf(" %s is a socket server program, which used to verify client and echo back string from it\n",progname);
	printf("\nMandatory arguments to long options are mandatory for short options too:\n");
	printf(" -b[daemon ] set program running on background\n");
	printf(" -p[port ] Socket server port address\n");
	printf(" -h[help ] Display this help information\n");
	printf("\nExample: %s -b -p 8900\n", progname);
	return ;
}

5. 服务器运行结果

服务器需要一直运行，通过参数解析方式，命令行需要指定服务器监听的端口，且最好大于1024，否则需要root权限。其运行结果为：
注意：直接指定服务器监听的端口就行，这里不传指定的IP，在程序中默认监听所有IP。
等服务器中：。。。。

6. 为了方便看，贴出客户端结果

也可以直接跳转到客户端详解

客户端详解
在这里插入图片描述

Tavi_
关注
专栏目录
微服务架构的优势及在可靠性: 基本概念及技术要素，如服务发现、健康检查、负载均衡、服务熔断、流量控制、日志聚合、监控告警、分布式跟踪
程序员光剑
07-28 1023
2021年，在疫情之下，全世界疯狂抗击新冠肺炎疫情的进程已经结束。随着IT行业的转型，越来越多的企业采用微服务架构的方式来部署自己的应用。微服务架构提升了应用的开发效率、敏捷性和可扩展性等优点，也带来了新的挑战——如何保证应用的高可用？在微服务架构中，每个服务都有自己的进程、资源以及数据存储，这意味着应用整体的可用性就会受限于这些服务的可用性。比如说，一个典型的微服务架构会由多个小的服务组成，服务之间通过API通信，并且这些服务可能部署在不同的主机上，如果其中某些服务宕机，其他服务还能正常运行吗？
数据中台架构原理与开发实战：数据中台的数据交换与共享
程序员光剑
11-10 156
在互联网时代，人们产生了海量的数据，数据的价值的发现，分析，处理，挖掘，应用和价值转化都是数据的核心价值之一。然而，对于数据的统一管理和价值共享来说，却依然是一个遥远的挑战。传统的数据中心模式，如中央数据仓库，集成商业智能系统等，已不能满足日益增长的数据量和复杂性需求。为了解决这个问题，各个企业开始从零开始搭建自己的自有数据平台，数据共享平台，或者叫做“数据中台”。这些数据中台以更高效，准确的方式整合不同源头的数据，同时提供实时的，精确的，即使面临重大危机也可靠的服务。
温湿度服务器系统软件,无线温湿度监测系统
weixin_33262687的博客
08-11 1552
系统介绍无线温湿度监测系统有无线温湿度采集器(监测终端)、无线温湿度接收管理主机(接收器)和本地软件、云服务器软件、手机APP组成，系统利用各类传输技术(433M、WIFI、TCP/IP、GPRS)，对环境温湿度实现轻松组网监测。软件功能强大丰富，用户使用方便。在有网络的地方随时随地地通过电脑或手机查看温湿度数据。应用领域冷链物流运输、大型冷库环境温湿度监测蔬菜大棚、畜牧业养殖基地、粮食仓储基地环...
温度采集实时上报——服务端（poll）
Ternence_zq的博客
03-24 453
文章目录1. 服务器要求和功能分析都类似，不再赘述，可参考下面链接：2. 代码模块分析create_database 创建数据库模块socket_server_init服务器端初始化server_poll主函数3. 服务器运行结果4. 客户端代码相同，方便查看直接贴出运行结果 1. 服务器要求和功能分析都类似，不再赘述，可参考下面链接： 温度采集实时上报——服务端（多进程） 2. 代码模块分析...
网络socket编程之温度实时监控上报项目（服务器端）
qq_42908042的博客
03-28 607
前言：前面讲了网络socket编程流程和温度上报的客户端，服务器端的功能和客户端有很多相同，我就不同的地方说明一下。 程序放到后台运行，并通过syslog记录程序的运行出错、调试日志；（服务器端） .程序能够捕捉kill信号正常退出；（服务器客户端都有） 服务器要支持多个客户端并发访问，可以选择多路复用、多进程或多线程任意一种实现；（我选择的是多线程，之后会有一篇博客讲解它们之间的区别） 服务器...
服务器基础操作-设备温度监测
m0_52390562的博客
06-21 265
linux，操作，温度监测
温度采集实时上报——服务端（epoll）
Ternence_zq的博客
03-31 897
文章目录1. Linux中提供的epoll相关函数如下：2. 服务器要求和功能分析都类似，不再赘述，可参考下面链接：3. 代码模块分析create_database 创建数据库模块socket_server_init服务器端初始化server_epoll主函数4. 服务器运行结果5. 客户端代码相同，方便查看直接贴出运行结果 在linux的网络编程中，很长的时间都在使用select来做事件触发。...
android——Seneor（获得数据值流程以及同时监听多个sensor）
CQU_LiuHC的博客
05-08 6322
Sensor数据的获取流程以及同时监听多个sensor
带你轻松过——SpringcloudNetflix微服务第一代
最新发布
qq_54354111的博客
08-28 936
带你轻松过——SpringcloudNetflix微服务第一代
从中心走向边缘——深度解析云原生边缘计算落地痛点
阿里云云栖号
04-14 1133
简介：边缘计算平台的建设，以 Kubernetes 为核心的云原生技术体系，无疑是当前最佳的选择与建设路径；但是云原生体系庞大，组件复杂，将体系下沉至边缘会面临很大的挑战与困难，同时充满巨大的机遇及想象空间。业务应用想要真正践行边缘的云原生体系，需要从理念、系统设计、架构设计等多方面来共同实现，才能充分发挥边缘的优势及价值。 作者：段嘉，新胜 云计算发展史，就是虚拟化技术的发展史。近 20 年来云计算与互联网相互促进高速发展，中心云技术成为全社会通用的基础设施。随着物联网、人工智能等技术的不断发展，尤其
C++实现数据采集系统有客户端和服务器
03-08
这是一个简单的数据采集系统，是某个部门内部的项目源代码。可以运行 正确编译的。有客户端和服务器。
用C++完成温度转换
07-21
这个程序的功能是：用C++完成华氏温度到摄氏温度的转换
温度采集实时上报——服务端（select）
Ternence_zq的博客
03-22 779
1. 服务器要求和功能分析都类似，不再赘述，可参考下面链接： 温度采集实时上报——服务端（多进程） 2. 代码模块分析 create_database 创建数据库模块 create_database.h 创建数据库的头文件 #ifndef CREATE_DATABASE_H #define CREATE_DATABASE_H int create_database(void); #endif...
温度实时监控上报（多线程实现客户端并发访问）
cknfighting的博客
05-29 693
温度实时监控上报 温度实时监控上报服务器端，采用多线程以及互斥锁来实现多个客户端并发访问。 服务器端功能 1 ,通过命令行指定监听的端口； 2，程序放到后台运行，并通过syslog记录程序的运行出错、调试日志； 3， 程序能够捕捉kill信号正常退出； 4， 服务器要支持多个客户端并发访问； 5， 服务器收到每个客户端的数据都解析后保存到数据库中，接收到的数据格式为： “ID/时间/温度”，如RPI0001/2019-0105 11:40:30/30.0C”; 多线程实现 #include <stdi
温度采集实时上报——服务端（多线程）
Ternence_zq的博客
03-18 487
要求和功能分析都一样 这里代码与多进行都很类似，只是创建子线程与创建子进程有些区别。 可以参考第一个客户端和多进程服务端里面写的比较完整： 文章审核中。。。。 代码如下： /********************************************************************************* * Copyright: (C) 2019 Ta...
网络socket编程之温度实时监控上报项目（客户端）
qq_42908042的博客
03-21 1180
前言：放寒假之前收到了老师布置的的这个项目实战，能够实现一个项目完整的功能。之前上课有学习一些socket网络编程，Linux下文件I/O，多进程、多线程、多路复用等知识，至于之后项目中用到的sqlite3数据库是之后自己通过网上了解到的。这些知识都是零零散散的，这个项目刚好拿来练习，可以把知识点都串联起来。其实寒假前就已经基本完成了所有的功能，一直没有写一篇博客，都快忘却了，所以得写一篇博客回忆...
基于互联网的温度采集系统
07-17 2576
1 绪论... 1 1.1 课题背景... 1 1.2 研究内容... 1 1.3 发展前景... 1 1.4 研究意义... 2 2. 开发平台介绍... 2 2.1 开发环境... 2 2.2 操作平台及开发软件介绍... 2 2.2.1 操作平台... 2 2.2.2 开发平台及相关软件介绍... 2 2.3 系统实现所需关键技术... 3 2.3
socket编程之温度实时监控上报(客户端)
qq_41812260的博客
02-29 689
一，首先是客户端需要实现的功能： 1， 树莓派上运行socket客户端程序，每隔30秒以字符串“ID/时间/温度”形式上报采样温度，其中ID为树莓派的编号，便于服 务器端区别是哪个树莓派客户端，如“RPI0001/2019-01-05 11:40:30/30.0C”; 2， 通过命令行参数指定服务器IP地址和端口以及间隔采样时间； 3， 程序放到后台运行，并通过syslog记录程序的运行出错、调...
Linux--socket温度上报练习
qq_42425882的博客
04-07 353
温度上报
python实现grpc客户端服务端多进程并发执行
06-09
下面是一个简单的Python代码示例，演示如何使用gRPC实现客户端和服务端的多进程并发执行： 服务端代码： ```python import grpc from concurrent import futures import time import hello_pb2 import hello_pb2_grpc class HelloService(hello_pb2_grpc.HelloServicer): def sayHello(self, request, context): print("Received message: ", request.message) return hello_pb2.HelloReply(message="Hello, %s!" % request.message) def serve(): server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) hello_pb2_grpc.add_HelloServicer_to_server(HelloService(), server) server.add_insecure_port("[::]:50051") server.start() print("Server started at [::]:50051") while True: time.sleep(86400) if __name__ == '__main__': serve() ``` 客户端代码： ```python import grpc import hello_pb2 import hello_pb2_grpc from concurrent import futures import multiprocessing def run_client(): channel = grpc.insecure_channel("localhost:50051") stub = hello_pb2_grpc.HelloStub(channel) response = stub.sayHello(hello_pb2.HelloRequest(message="world")) print("Response received from server: ", response.message) if __name__ == '__main__': pool = multiprocessing.Pool(processes=4) for i in range(4): pool.apply_async(run_client) pool.close() pool.join() ``` 在上面的示例中，服务端使用了Python的concurrent.futures模块创建了一个线程池，用于处理客户端的请求，同时使用了Python的multiprocessing模块创建了多个子进程，同时向服务端发起请求。客户端通过调用multiprocessing.Pool()方法创建进程池，并使用apply_async()方法异步调用run_client()方法，实现了多个客户端同时向服务端发起请求的并发执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值