使用socket多线程多客户端传输信号

最新推荐文章于 2023-12-07 20:38:09 发布
最新推荐文章于 2023-12-07 20:38:09 发布
阅读量637 收藏 2
点赞数 1
文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zk_ken/article/details/130027126
版权

一、需求

        需要将一个c++可执行文件中的两个信号实时传送给两个不同的C++可执行文件

服务端： 

#include <stdlib.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/socket.h>
//#include <string.h>
#include <signal.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include<signal.h>
#include<iostream>
#include <cstring>

//服务器端
 
void *fun_thrReceiveHandler(void *socketInfo);
void *fun_thrAcceptHandler(void *socketListen);
//1:是 0：否
int checkThrIsKill(pthread_t thr);
 
typedef struct MySocketInfo{
    int socketCon;
    char *ipaddr;
    uint16_t port;
}_MySocketInfo;
 
// 客户端数组
struct MySocketInfo arrConSocket[10];
int conClientCount = 0;
 
// 接受客户端线程列表
pthread_t arrThrReceiveClient[10];
int thrReceiveClientCount = 0;
 
int main()
{
    //初始化全局变量
    //memset(arrConSocket,0,sizeof(struct MySocketInfo)*10);
 
    printf("开始socket\n");
    /* 创建TCP连接的Socket套接字 */
    int socketListen = socket(AF_INET, SOCK_STREAM, 0);
    if(socketListen < 0){
        printf("创建TCP套接字失败\n");
        exit(-1);
    }else{
        printf("创建套接字成功\n");
    }
    /* 填充服务器端口地址信息，以便下面使用此地址和端口监听 */
    struct sockaddr_in server_addr;
    bzero(&server_addr,sizeof(struct sockaddr_in));
    server_addr.sin_family=AF_INET;
    server_addr.sin_addr.s_addr=htonl(INADDR_ANY); /* 这里地址使用全0，即所有 */
    server_addr.sin_port=htons(2000);
    if(bind(socketListen, (struct sockaddr *)&server_addr,sizeof(struct sockaddr)) != 0){
        perror("绑定ip地址、端口号失败\n");
        exit(-1);
    }else{
        printf("绑定ip地址,端口号\n");
    }
    /* 开始监听相应的端口 */
    if(listen(socketListen, 10) != 0){
        printf("开启监听失败\n");
        exit(-1);
    }else{
        printf("开启监听成功\n");
    }
    /* 接受连接套接字 */
    pthread_t thrAccept;
    pthread_create(&thrAccept,NULL,fun_thrAcceptHandler,&socketListen);
 
    /* 实时发送数据 */
    while(1){
        //判断线程存活多少
        int i;
        for(i=0;i<thrReceiveClientCount;i++){
            if(checkThrIsKill(arrThrReceiveClient[i]) == 1){
                printf("有个线程被杀了\n");
                thrReceiveClientCount--;
            }
        }
        printf("当前有接受数据线程多少个：%d\n",thrReceiveClientCount);
 
        // 可以录入用户操作选项，并进行相应操作
        char userStr[30] = {'0'};
        scanf("%s",userStr);
        if(strcmp(userStr,"q") == 0){
            printf("用户选择退出！\n");
            break;
        }
        // 发送消息
        if(conClientCount <= 0){
            printf("没有客户端连接\n");
        }else{
            int i;
            for(i=0; i<conClientCount; i++){
                //int sendMsg_len = send(arrConSocket[i].socketCon, userStr, 30, 0);
				std::cout << "arrConSocket[i].socketCon" << arrConSocket[i].socketCon << std::endl;
                int sendMsg_len = write(arrConSocket[i].socketCon,userStr,30);
                if(sendMsg_len > 0){
                    printf("向%s:%d发送成功\n",arrConSocket[i].ipaddr,arrConSocket[i].port);
					std::cout << "arrConSocket[i].ipaddr" << arrConSocket[i].ipaddr << std::endl;
					std::cout << "arrConSocket[i].port" << arrConSocket[i].port << std::endl;
                }else{
                    printf("向%s:%d发送失败\n",arrConSocket[i].ipaddr,arrConSocket[i].port);
                }
            }
        }
 
        sleep(0.5);
    }
 
    // 等待子进程退出
    printf("等待子线程退出，即将退出！\n");
    //char *message;
	void * a;
    pthread_join(thrAccept,&a);
    printf("%s\n",a);
 
    return 0;
}
 
void *fun_thrAcceptHandler(void *socketListen){
    while(1){
        int sockaddr_in_size = sizeof(struct sockaddr_in);
        struct sockaddr_in client_addr;
        int _socketListen = *((int *)socketListen);
        int socketCon = accept(_socketListen, (struct sockaddr *)(&client_addr), (socklen_t *)(&sockaddr_in_size));
        if(socketCon < 0){
            printf("连接失败\n");
        }else{
            printf("连接成功 ip: %s:%d\r\n",inet_ntoa(client_addr.sin_addr),client_addr.sin_port);
        }
        printf("连接套接字为：%d\n",socketCon);
        //开启新的通讯线程，负责同连接上来的客户端进行通讯
        _MySocketInfo socketInfo;
        socketInfo.socketCon = socketCon;
        socketInfo.ipaddr = inet_ntoa(client_addr.sin_addr);
        socketInfo.port = client_addr.sin_port;
        arrConSocket[conClientCount] = socketInfo;
        conClientCount++;
        printf("连接了%d个用户\n",conClientCount);
 
        pthread_t thrReceive = 0;
        pthread_create(&thrReceive,NULL,fun_thrReceiveHandler,&socketInfo);
        arrThrReceiveClient[thrReceiveClientCount] = thrReceive;
        thrReceiveClientCount++;
 
        //让进程休息1秒
        sleep(0.5);
    }
 
    char *s = "安全退出接受进程";
    pthread_exit(s);
}
 
void *fun_thrReceiveHandler(void *socketInfo){
	char buffer[30];
	int aa;
	int cc;
	int buffer_length;
	_MySocketInfo _socketInfo = *((_MySocketInfo *)socketInfo);
    while(1){
    	//添加对buffer清零
    	bzero(&buffer,sizeof(buffer));
 
        buffer_length = read(_socketInfo.socketCon,buffer,30);
        if(buffer_length == 0){
            printf("%s:%d 客户端关闭\n",_socketInfo.ipaddr,_socketInfo.port);
            conClientCount--;
            break;
        }else if(buffer_length < 0){
            printf("接受客户端数据失败\n");
            break;
        }
        buffer[buffer_length] = '\0';
        printf("%s:%d 说：%s\n",_socketInfo.ipaddr,_socketInfo.port,buffer);
		std::string message1 = "Hello, client11111!";
		std::string message2 = "Hello, client22222!";
		std::cout << "buffer = " << buffer << std::endl;
		cc = atoi(buffer);
		//sprintf(buffer,"%f",aa);
		std::cout << "cc = " << cc << std::endl; 
		
		if(cc == 1)
			buffer_length = write(_socketInfo.socketCon, message1.c_str(), message1.length() + 1);
		if(cc == 2)
			buffer_length = write(_socketInfo.socketCon, message2.c_str(), message2.length() + 1);
 
        sleep(0.2);
    }
    printf("接受数据线程结束了\n");
    return NULL;
}
 
int checkThrIsKill(pthread_t thr){
    int res = 1;
    int res_kill = pthread_kill(thr,0);
    if(res_kill == 0){
        res = 0;
    }
    return res;
}

 客户端1：

#include <stdlib.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include<signal.h>
 
typedef struct MySocketInfo{
    int socketCon;
    unsigned long ipaddr;
    unsigned short port;
}_MySocketInfo;
 
void *fun_thrReceiveHandler(void *socketCon);
int checkThrIsKill(pthread_t thr);
 
int main()
{
    printf("开始socket\n");
    /* 创建TCP连接的Socket套接字 */
    int socketCon = socket(AF_INET, SOCK_STREAM, 0);
    if(socketCon < 0){
        printf("创建TCP连接套接字失败\n");
        exit(-1);
    }
    /* 填充客户端端口地址信息，以便下面使用此地址和端口监听 */
    struct sockaddr_in server_addr;
    bzero(&server_addr,sizeof(struct sockaddr_in));
    server_addr.sin_family=AF_INET;
    server_addr.sin_addr.s_addr=inet_addr("127.0.0.1"); /* 这里地址使用全0，即所有 */
    server_addr.sin_port=htons(2000);
    /* 连接服务器 */
    int res_con = connect(socketCon,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr));
    if(res_con != 0){
        printf("连接失败\n");
        exit(-1);
    }
    printf("连接成功,连接结果为：%d\n",res_con);
    //开启新的实时接受数据线程
    pthread_t thrReceive;
    pthread_create(&thrReceive,NULL,fun_thrReceiveHandler,&socketCon);
 
    /* 实时发送数据 */
    while(1){
        //检测接受服务器数据线程是否被杀死
 	sleep(2);
 
        char userStr[30] = {'2'};
        // 可以录入用户操作选项，并进行相应操作
        //scanf("%s",userStr);
        if(strcmp(userStr,"q") == 0){
            printf("用户选择退出！\n");
            break;
        }
        // 发送消息
        //int sendMsg_len = send(socketCon, userStr, 30, 0);
        int sendMsg_len = write(socketCon,userStr,30);
        if(sendMsg_len > 0){
            printf("发送成功,服务端套接字句柄:%d\n",socketCon);
        }else{
            printf("发送失败\n");
        }
 
        //if(checkThrIsKill(thrReceive) == 1){
            //printf("接受服务器数据的线程已被关闭，退出程序\n");
            //break;
        //}
    }
    // 关闭套接字
    close(socketCon);
    return 0;
}
 
void *fun_thrReceiveHandler(void *socketCon){
    while(1){
        char buffer[30];
        int _socketCon = *((int *)socketCon);
        //int buffer_length = recv(_socketCon,buffer,30,0);
        int buffer_length = read(_socketCon,buffer,30);
        if(buffer_length == 0){
            printf("服务器端异常关闭\n");
            exit(-1);
        }else if(buffer_length < 0){
            printf("接受客户端数据失败\n");
            break;
        }
        buffer[buffer_length] = '\0';
        printf("服务器说：%s\n",buffer);
    }
    printf("退出接受服务器数据线程\n");
    return NULL;
}
 
int checkThrIsKill(pthread_t thr){
    int res = 1;
    int res_kill = pthread_kill(thr,0);
    if(res_kill == 0){
        res = 0;
    }
    return res;
}

客户端2：

#include <stdlib.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>

#include<signal.h>
 
typedef struct MySocketInfo{
    int socketCon;
    unsigned long ipaddr;
    unsigned short port;
}_MySocketInfo;
 
void *fun_thrReceiveHandler(void *socketCon);
int checkThrIsKill(pthread_t thr);
 
int main()
{
    printf("开始socket\n");
    /* 创建TCP连接的Socket套接字 */
    int socketCon = socket(AF_INET, SOCK_STREAM, 0);
    if(socketCon < 0){
        printf("创建TCP连接套接字失败\n");
        exit(-1);
    }
    /* 填充客户端端口地址信息，以便下面使用此地址和端口监听 */
    struct sockaddr_in server_addr;
    bzero(&server_addr,sizeof(struct sockaddr_in));
    server_addr.sin_family=AF_INET;
    server_addr.sin_addr.s_addr=inet_addr("127.0.0.1"); /* 这里地址使用全0，即所有 */
    server_addr.sin_port=htons(2000);
    /* 连接服务器 */
    int res_con = connect(socketCon,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr));
    if(res_con != 0){
        printf("连接失败\n");
        exit(-1);
    }
    printf("连接成功,连接结果为：%d\n",res_con);
    //开启新的实时接受数据线程
    pthread_t thrReceive;
    pthread_create(&thrReceive,NULL,fun_thrReceiveHandler,&socketCon);
 
    /* 实时发送数据 */
    while(1){
        //检测接受服务器数据线程是否被杀死
	sleep(2);
 
        char userStr[30] = {'1'};
        // 可以录入用户操作选项，并进行相应操作
        //scanf("%s",userStr);
        if(strcmp(userStr,"q") == 0){
            printf("用户选择退出！\n");
            break;
        }
        // 发送消息
        //int sendMsg_len = send(socketCon, userStr, 30, 0);
        int sendMsg_len = write(socketCon,userStr,30);
        if(sendMsg_len > 0){
            printf("发送成功,服务端套接字句柄:%d\n",socketCon);
        }else{
            printf("发送失败\n");
        }
 
        //if(checkThrIsKill(thrReceive) == 1){
            //printf("接受服务器数据的线程已被关闭，退出程序\n");
            //break;
        //}
    }
    // 关闭套接字
    close(socketCon);
    return 0;
}
 
void *fun_thrReceiveHandler(void *socketCon){
    while(1){
        char buffer[30];
        int _socketCon = *((int *)socketCon);
        //int buffer_length = recv(_socketCon,buffer,30,0);
        int buffer_length = read(_socketCon,buffer,30);
        if(buffer_length == 0){
            printf("服务器端异常关闭\n");
            exit(-1);
        }else if(buffer_length < 0){
            printf("接受客户端数据失败\n");
            break;
        }
        buffer[buffer_length] = '\0';
        printf("服务器说：%s\n",buffer);
    }
    printf("退出接受服务器数据线程\n");
    return NULL;
}
 
int checkThrIsKill(pthread_t thr){
    int res = 1;
    int res_kill = pthread_kill(thr,0);
    if(res_kill == 0){
        res = 0;
    }
    return res;
}

 将上述代码中服务端有两个信号需要传送给上述两个客户端，所以需要客户端传送信号给服务端，让服务端知道是哪个信号传输给哪个客户端。比如客户端1传输信号"1"给服务端，服务端就知道是客户端进行请求，所以传输相应的信号给客户端1，同样的，传输客户端2想要的信号给客户端2

关键代码如下：

服务端

    std::string message1 = "Hello, client11111!";
    std::string message2 = "Hello, client22222!";
	std::cout << "buffer = " << buffer << std::endl;
	cc = atoi(buffer);
	//sprintf(buffer,"%f",aa);
	std::cout << "cc = " << cc << std::endl; 
		
	if(cc == 1)
		buffer_length = write(_socketInfo.socketCon, message1.c_str(), message1.length() + 1);
	if(cc == 2)
		buffer_length = write(_socketInfo.socketCon, message2.c_str(), message2.length() + 1);

客户端1：

    char userStr[30] = {'1'};
    // 可以录入用户操作选项，并进行相应操作
    //scanf("%s",userStr);
    if(strcmp(userStr,"q") == 0){
         printf("用户选择退出！\n");
         break;
     }
     // 发送消息
     //int sendMsg_len = send(socketCon, userStr, 30, 0);
     int sendMsg_len = write(socketCon,userStr,30);

 客户端2：

    char userStr[30] = {'2'};
    // 可以录入用户操作选项，并进行相应操作
    //scanf("%s",userStr);
    if(strcmp(userStr,"q") == 0){
         printf("用户选择退出！\n");
         break;
     }
     // 发送消息
     //int sendMsg_len = send(socketCon, userStr, 30, 0);
     int sendMsg_len = write(socketCon,userStr,30);

在实际应用中服务端还需要创建一个线程，用来生成客户端想要的信号。然后实时传输给客户端。

实列如下：

#include "httplib.h"

#include "HCNetSDK.h"
#include <unistd.h>
#include "LinuxPlayM4.h"
// #include "benchmark.h"
#include "TiltSensor.h"
#include <X11/Xlib.h>

#include "base64.h"
#include "ImgInfo.h"
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <vector>
#include <time.h>
#include <json.h>

#include <functional>
#include <queue>
#include <chrono>


#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>


//using namespace cv;
using namespace std;
using namespace std::chrono; // calc fps
#include "httplib.h"

float angle;
float result_cam_angle_31;
float result_cam_angle_32;

//服务器端
 
void *fun_thrReceiveHandler(void *socketInfo);
void *fun_thrAcceptHandler(void *socketListen);
//1:是 0：否
int checkThrIsKill(pthread_t thr);
 
typedef struct MySocketInfo{
    int socketCon;
    char *ipaddr;
    uint16_t port;
}_MySocketInfo;
 
// 客户端数组
struct MySocketInfo arrConSocket[10];
int conClientCount = 0;
 
// 接受客户端线程列表
pthread_t arrThrReceiveClient[10];
int thrReceiveClientCount = 0;



void *fun_thrAcceptHandler(void *socketListen){
    while(1){
        int sockaddr_in_size = sizeof(struct sockaddr_in);
        struct sockaddr_in client_addr;
        int _socketListen = *((int *)socketListen);
        int socketCon = accept(_socketListen, (struct sockaddr *)(&client_addr), (socklen_t *)(&sockaddr_in_size));
        if(socketCon < 0){
            printf("连接失败\n");
        }else{
            printf("连接成功 ip: %s:%d\r\n",inet_ntoa(client_addr.sin_addr),client_addr.sin_port);
        }
        printf("连接套接字为：%d\n",socketCon);
        //开启新的通讯线程，负责同连接上来的客户端进行通讯
        _MySocketInfo socketInfo;
        socketInfo.socketCon = socketCon;
        socketInfo.ipaddr = inet_ntoa(client_addr.sin_addr);
        socketInfo.port = client_addr.sin_port;
        arrConSocket[conClientCount] = socketInfo;
        conClientCount++;
        printf("连接了%d个用户\n",conClientCount);
 
        pthread_t thrReceive = 0;
        pthread_create(&thrReceive,NULL,fun_thrReceiveHandler,&socketInfo);
        arrThrReceiveClient[thrReceiveClientCount] = thrReceive;
        thrReceiveClientCount++;
 
        //让进程休息1秒
        sleep(0.5);
    }
 
    char *s = "安全退出接受进程";
    pthread_exit(s);
}



void *fun_thrReceiveHandler(void *socketInfo){
	char buffer[30];
	int aa;
	int cc;
	int buffer_length;
	_MySocketInfo _socketInfo = *((_MySocketInfo *)socketInfo);
    while(1){
    	//添加对buffer清零
    	bzero(&buffer,sizeof(buffer));
 
        buffer_length = read(_socketInfo.socketCon,buffer,30);
        if(buffer_length == 0){
            printf("%s:%d 客户端关闭\n",_socketInfo.ipaddr,_socketInfo.port);
            conClientCount--;
            break;
        }else if(buffer_length < 0){
            printf("接受客户端数据失败\n");
            break;
        }
        buffer[buffer_length] = '\0';
        printf("%s:%d 说：%s\n",_socketInfo.ipaddr,_socketInfo.port,buffer);
		std::string message1 = std::to_string(angle);
		std::string message2 = std::to_string(result_cam_angle_32);
		std::cout << "buffer = " << buffer << std::endl;
		cc = atoi(buffer);
		//sprintf(buffer,"%f",aa);
		std::cout << "cc = " << cc << std::endl; 
		
		if(cc == 1)
			buffer_length = write(_socketInfo.socketCon, message1.c_str(), message1.length() + 1);
		if(cc == 2)
			buffer_length = write(_socketInfo.socketCon, message2.c_str(), message2.length() + 1);
 
        sleep(0.2);
    }
    printf("接受数据线程结束了\n");
    return NULL;
}

int checkThrIsKill(pthread_t thr){
    int res = 1;
    int res_kill = pthread_kill(thr,0);
    if(res_kill == 0){
        res = 0;
    }
    return res;
}




int  HexToDecMa(int wHex)//ʮ������תʮ����
{
    return (wHex / 4096) * 1000 + ((wHex % 4096) / 256) * 100 + ((wHex % 256) / 16) * 10 + (wHex % 16);
}

int DEC2HEX_doc(int x)//ʮ����תʮ������
{
    return (x / 1000) * 4096 + ((x % 1000) / 100) * 256 + ((x % 100) / 10) * 16 + x % 10;
}

void contral_cam(LONG lUserID, int wPanPos1, int wTiltPos1, int wZoomPos1, DWORD dwtmp, NET_DVR_PTZPOS m_ptzPosCurrent){

    bool a = NET_DVR_GetDVRConfig(lUserID, NET_DVR_GET_PTZPOS, 0, &m_ptzPosCurrent, sizeof(NET_DVR_PTZPOS), &dwtmp);
    //转换相机信息到十进制
    int m_iPara1 = HexToDecMa(m_ptzPosCurrent.wPanPos);
    int m_iPara2 = HexToDecMa(m_ptzPosCurrent.wTiltPos);
    int m_iPara3 = HexToDecMa(m_ptzPosCurrent.wZoomPos);
    std::vector<int> TempPosture(3);
    TempPosture[0] = m_iPara1 / 10 ;    //P水平方向
    TempPosture[1] = m_iPara2 / 10 ;    //T仰角
    TempPosture[2] = m_iPara3 / 10 ;    //Z焦距
    
	std::cout << "TempPosture[2] = " << TempPosture[2] << std::endl;
    
    //如果大于1将焦距调到1
    //将俯仰角调到90°
    m_ptzPosCurrent.wPanPos = DEC2HEX_doc(wPanPos1*10);
    m_ptzPosCurrent.wTiltPos = DEC2HEX_doc(wTiltPos1*10);
    m_ptzPosCurrent.wZoomPos = DEC2HEX_doc(wZoomPos1*10);
    
    bool b = NET_DVR_SetDVRConfig(lUserID, NET_DVR_SET_PTZPOS, 0, &m_ptzPosCurrent, sizeof(NET_DVR_PTZPOS));
    sleep(2);
}

//#include "httplib.h"
/*!
 * 通过http请求请教传感器数据
 * x: 倾角传感器数据; 传出参数;
 * y: 倾角传感器数据; 传出参数;
 * return : false, 请求失败或参数解析失败;
 * */
bool function_GetAngle(float &x, float &y) {
    std::cout << "222222222" << std::endl;

    static auto client = httplib::Client("127.0.0.1", 18080);
    auto result = client.Get("/TiltSensor");
    if (!result || result->status != 200) {
        return false;
    }

    auto body = result->body;

    cJSON *root = cJSON_Parse(body.c_str());
    if(!root) {
        return false;
    }

    if(cJSON_GetObjectItem(root, "tilt_x")){
        x = std::abs((float)cJSON_GetObjectItem(root, "tilt_x")->valuedouble);
    } else {
        return false;
    }


    if(cJSON_GetObjectItem(root, "tilt_y")){
        y = (float)cJSON_GetObjectItem(root, "tilt_y")->valuedouble;
    }else {
        return false;
    }

    return true;
}

#include <chrono>
#include <thread>
void gets_angle(){
	//球机信息
    char IP[] = "192.168.8.31";   //����������������ͷ��ip
    char IP_32[] = "192.168.8.32";
    char UName[] = "admin";                 //����������������ͷ���û���
    char PSW[] = "a123456789";

	NET_DVR_Init();
    NET_DVR_SetConnectTime(2000, 1);
    NET_DVR_SetReconnect(1000, true);
    NET_DVR_SetLogToFile(3, "./sdkLog1");
    NET_DVR_DEVICEINFO_V30 struDeviceInfo = { 0 };
    NET_DVR_SetRecvTimeOut(5000);

	LONG lUserID_31 = NET_DVR_Login_V30(IP, 8000, UName, PSW, &struDeviceInfo);
    LONG lUserID_32 = NET_DVR_Login_V30(IP_32, 8000, UName, PSW, &struDeviceInfo);


	//***************************************************************
    //***************************************************************
    //读取配置文件
    Json::Reader reader;
	Json::Value root;
    std::ifstream in("./output.json", std::ios::binary);
    if (!in.is_open())
	{
		std::cout << "Error opening file\n";
	}

    int Pans_31 = 73;
    int Tilts_31 = 90;
    int Zooms_31 = 5;

	int Pans_32 = 48;
    int Tilts_32 = 90;
    int Zooms_32 = 1;

    float standard_bijia_angles_31 = 61.6;  //臂架 Tilt
    float standard_cam_angle_31 = 90; //俯仰角 Tilt
    int standard_cam_Pans_31 = 73; //旋转角  Pan

	float standard_bijia_angles_32 = 61.6;  //臂架 Tilt
    float standard_cam_angle_32 = 89; //俯仰角 Tilt
    int standard_cam_Pans_32 = 48; //旋转角  Pan

    float distance_angle_threshold = 1.0;


    if (reader.parse(in, root))
	{
		Pans_31 = root["Pan_31"].asInt();
        Tilts_31 = root["Tilt_31"].asInt();
        Zooms_31 = root["Zoom_31"].asInt();

		Pans_32 = root["Pan_32"].asInt();
        Tilts_32 = root["Tilt_32"].asInt();
        Zooms_32 = root["Zoom_32"].asInt();

        standard_bijia_angles_31 = root["Tilt_sensor"]["standard_bijia_angles_31"].asFloat();
        standard_cam_angle_31 = root["Tilt_sensor"]["standard_cam_angle_31"].asFloat();
        standard_cam_Pans_31 = root["Tilt_sensor"]["standard_cam_Pans_31"].asInt();

        standard_bijia_angles_32 = root["Tilt_sensor"]["standard_bijia_angles_32"].asFloat();
        standard_cam_angle_32 = root["Tilt_sensor"]["standard_cam_angle_32"].asFloat();
        standard_cam_Pans_32 = root["Tilt_sensor"]["standard_cam_Pans_32"].asInt();


        //const char* net_params = net_para.c_str();
        //const char* net_bins = net_bin.c_str();

		// std::cout << "Pan_31 =  " << Pans_31 << std::endl;
        // std::cout << "Tilt_31 =  " << Tilts_31 << std::endl;
		// std::cout << "Zoom_31 =  " << Zooms_31 << std::endl;

		// std::cout << "Pan_32 =  " << Pans_32 << std::endl;
        // std::cout << "Tilt_32 =  " << Tilts_32 << std::endl;
		// std::cout << "Zoom_32 =  " << Zooms_32 << std::endl;

		// std::cout << "standard_bijia_angles_31 =  " << standard_bijia_angles_31 << std::endl;
		// std::cout << "standard_cam_angle_31 =  " << standard_cam_angle_31 << std::endl;
		// std::cout << "standard_cam_Pans_31 =  " << standard_cam_Pans_31 << std::endl;

		// std::cout << "standard_bijia_angles_32 =  " << standard_bijia_angles_32 << std::endl;
		// std::cout << "standard_cam_angle_32 =  " << standard_cam_angle_32 << std::endl;
		// std::cout << "standard_cam_Pans_32 =  " << standard_cam_Pans_32 << std::endl;

    }
    DWORD dwtmp;
    NET_DVR_PTZPOS m_ptzPosCurrent;

	contral_cam(lUserID_31, standard_cam_Pans_31, Tilts_31, Zooms_31, dwtmp, m_ptzPosCurrent);
    contral_cam(lUserID_32, standard_cam_Pans_32, Tilts_32, Zooms_32, dwtmp, m_ptzPosCurrent);

	//**************************
    //创建倾角传感器
    void* p_TiltSensor_class;
    p_TiltSensor_class = (void*)(new TiltSensor());
    TiltSensor* get_TiltSensor_data = (TiltSensor*)(p_TiltSensor_class);
    get_TiltSensor_data->StartTiltSensor();

	//float angle = 0.0f;
    float angle_y = 0.0f;
    float distance_angle_31;
    float distance_angle_32;

    // float result_cam_angle_31;
    // float result_cam_angle_32;
    float origin_bijia_angles_31 = standard_bijia_angles_31;
    float origin_bijia_angles_32 = standard_bijia_angles_32;

	while(1){

    	sleep(2);
        get_TiltSensor_data->GetTiltData(angle, angle_y);

		std::cout << "angle_x = " << angle << std::endl;
        std::cout << "angle_y = " << angle_y << std::endl;

        result_cam_angle_31 = standard_cam_angle_31 + angle - standard_bijia_angles_31;
        result_cam_angle_32 = standard_cam_angle_32 + angle - standard_bijia_angles_32;

        distance_angle_31 = origin_bijia_angles_31 - angle;
        distance_angle_32 = origin_bijia_angles_32 - angle;
        std::cout << "distance_angle_31 = " << distance_angle_31 << std::endl;
        std::cout << "distance_angle_32 = " << distance_angle_32 << std::endl;
		if(std::abs(distance_angle_31) > distance_angle_threshold){
            origin_bijia_angles_31 = angle;
            origin_bijia_angles_32 = angle;

            std::cout <<"##########change cam angle############";
            //result_cam_angle_31 = standard_cam_angle_31 + angle - standard_bijia_angles_31;
            // result_cam_angle_32 = standard_cam_angle_32 + angle - standard_bijia_angles_32;

            std::cout << "result_cam_angle_31 = " << result_cam_angle_31 << std::endl;
            std::cout << "result_cam_angle_32 = " << result_cam_angle_32 << std::endl;

            //**********************************************
            // sprintf(buffer,"%f",result_cam_angle_31);
            // int n = write(sockfd, buffer, strlen(buffer));
            // if (n < 0) {
            //     perror("Error writing to socket");
            //     break;
            // }
            // memset(buffer, 0, sizeof(buffer));
            // n = read(sockfd, buffer, 1024);
            // if (n < 0) {
            //     perror("Error reading from socket");
            //     break;
            // }
            // cout << "Received message: " << buffer << endl;
            //************************************************
			if (result_cam_angle_31 <= 90){
				contral_cam(lUserID_31, standard_cam_Pans_31, result_cam_angle_31, Zooms_31, dwtmp, m_ptzPosCurrent);
			}
			else{
				contral_cam(lUserID_31, 180 + standard_cam_Pans_31, 180 - result_cam_angle_31, Zooms_31, dwtmp, m_ptzPosCurrent);
			}
			if (result_cam_angle_32 <= 90){
    			contral_cam(lUserID_32, standard_cam_Pans_32, result_cam_angle_32, Zooms_32, dwtmp, m_ptzPosCurrent);
			}
			else{
    			contral_cam(lUserID_32, 180 + standard_cam_Pans_32, 180 - result_cam_angle_32, Zooms_32, dwtmp, m_ptzPosCurrent);
			}
		}

	}

}

int main()
{
    //初始化全局变量
    //memset(arrConSocket,0,sizeof(struct MySocketInfo)*10);
 
    printf("开始socket\n");
    /* 创建TCP连接的Socket套接字 */
    int socketListen = socket(AF_INET, SOCK_STREAM, 0);
    if(socketListen < 0){
        printf("创建TCP套接字失败\n");
        exit(-1);
    }else{
        printf("创建套接字成功\n");
    }
    /* 填充服务器端口地址信息，以便下面使用此地址和端口监听 */
    struct sockaddr_in server_addr;
    bzero(&server_addr,sizeof(struct sockaddr_in));
    server_addr.sin_family=AF_INET;
    server_addr.sin_addr.s_addr=htonl(INADDR_ANY); /* 这里地址使用全0，即所有 */
    server_addr.sin_port=htons(2000);
    if(bind(socketListen, (struct sockaddr *)&server_addr,sizeof(struct sockaddr)) != 0){
        perror("绑定ip地址、端口号失败\n");
        exit(-1);
    }else{
        printf("绑定ip地址,端口号\n");
    }
    /* 开始监听相应的端口 */
    if(listen(socketListen, 10) != 0){
        printf("开启监听失败\n");
        exit(-1);
    }else{
        printf("开启监听成功\n");
    }
    /* 接受连接套接字 */
    pthread_t thrAccept;
    pthread_create(&thrAccept,NULL,fun_thrAcceptHandler,&socketListen);
    std::thread tw(gets_angle);
    
 
    /* 实时发送数据 */
    while(1){
        //判断线程存活多少
        int i;
        for(i=0;i<thrReceiveClientCount;i++){
            if(checkThrIsKill(arrThrReceiveClient[i]) == 1){
                printf("有个线程被杀了\n");
                thrReceiveClientCount--;
            }
        }
        printf("当前有接受数据线程多少个：%d\n",thrReceiveClientCount);
 
        // 可以录入用户操作选项，并进行相应操作
        char userStr[30] = {'0'};
        scanf("%s",userStr);
        if(strcmp(userStr,"q") == 0){
            printf("用户选择退出！\n");
            break;
        }
        // 发送消息
        if(conClientCount <= 0){
            printf("没有客户端连接\n");
        }else{
            int i;
            for(i=0; i<conClientCount; i++){
                //int sendMsg_len = send(arrConSocket[i].socketCon, userStr, 30, 0);
				std::cout << "arrConSocket[i].socketCon" << arrConSocket[i].socketCon << std::endl;
                int sendMsg_len = write(arrConSocket[i].socketCon,userStr,30);
                if(sendMsg_len > 0){
                    printf("向%s:%d发送成功\n",arrConSocket[i].ipaddr,arrConSocket[i].port);
					std::cout << "arrConSocket[i].ipaddr" << arrConSocket[i].ipaddr << std::endl;
					std::cout << "arrConSocket[i].port" << arrConSocket[i].port << std::endl;
                }else{
                    printf("向%s:%d发送失败\n",arrConSocket[i].ipaddr,arrConSocket[i].port);
                }
            }
        }
 
        sleep(0.5);
    }
 
    // 等待子进程退出
    printf("等待子线程退出，即将退出！\n");
    //char *message;
	void * a;
    pthread_join(thrAccept,&a);
    tw.join();
    return 0;
}

 上述代码中gets_angle()函数是获取客户端所需要的信息

通过设定全局变量

float result_cam_angle_31;
float result_cam_angle_32;

创建新的线程

std::thread tw(gets_angle);
tw.join();

来实时获取客户端所需要的信息。

zk_ken
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
VC++ 多线程socket文件传输
04-11
在VC++环境中实现多线程Socket文件传输是一个涉及网络编程、多线程处理以及文件操作的重要技术主题。这里，我们将深入探讨如何利用C++和Socket API进行多线程的文件传输。 首先，让我们理解什么是Socket。Socket是...
【一】【socket聊天室】-多线程，socket编程
杨的博客
03-08 5847
（1）多用户聊天：一个服务器多个客户端，客户端信息显示在公共的服务端窗口，利用多线程实现； ——客户端双线程：一个接受线程一个发送线程（主线程）； ——服务器单线程：接收线程； （2）多用户广播界面：将信息显示到所有用户界面和服务器界面，同时服务器也能发言，利用多线程实现； ——客户端双线程：一个接受线程一个发送线程（主线程）； ——服务器单线程：一个接收线程（主线程）一个发送线程；其中接受线程为每个连接开了单独的线程；
用多线程实现多用户同时收发的简单socket服务端
AN195的博客
06-11 8723
简单的socket代码和多线程练习用socket服务端和多线程实现可以连接多个客户端并同时收发的功能。这里要用到socket 和 threading所以，记得：import socket, threading一、创建socket服务端首先，按正常操作，创建一个socket，选择ipv4和数据流：socketServer = socket.socket(socket.AF_INET, socket....
多线程&socket
大数据同盟会的博客
04-06 1056
进程&线程 进程：正在执行的程序，每个进程都是由程序代码组成； 线程：代码在进程中执行的流程； 比如打开的迅雷就是一个进程，下载的任务就是线程，所以一个进程可以有多个线程。 ...
Java-Socket聊天功能之多线程实现发送与接受消息
y_h123的博客
05-22 2355
服务端与客户端代码几乎一样，区别与serverSocket与 clientSocket的获取；聊天场景：分别设置了服务端、客户端，两端均可接受消息及发送消息，输入空换行则结束聊天。总结：聊天功能简单实现，后续还需针对业务进行优化。客户端发分别发送两条信息给服务端。先启动服务端，再启动客户端。客户端输入空换行结束聊天。服务端发送信息给客户端。
如何在Java实现TCP方式发送和接收Socket消息（多线程模式）
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
08-19 7774
详细叙述了如何在Java实现TCP方式发送和接收Socket消息（多线程模式）。欢迎点赞收藏。
C# socket多线程通讯 含客户端
08-05
本资源“C# socket多线程通讯 含客户端”提供了一个实例，用于演示如何在C#中使用Socket进行多线程通信，这对于理解和掌握网络编程具有很高的价值。 1. **Socket基础** Socket在C#中被封装在System.Net.Sockets...
python使用多线程编写tcp客户端程序
09-18
本篇将介绍如何在Python中利用多线程编写一个TCP客户端程序，以便实现这一功能。 首先，我们需要导入必要的模块，`socket`用于创建TCP连接，而`threading`则是处理多线程的核心模块。下面的代码展示了基础的TCP...
java socket多线程文件传输实例项目
08-10
Java Socket多线程文件传输实例项目是一个典型的网络编程应用场景，主要涉及了Socket编程、多线程处理以及文件I/O操作等关键知识点。在这个项目中，开发者利用Java的Socket API实现了一个能够支持多个客户端同时进行...
Socket多线程文件传输
04-10
用Delphi XE5 编写的 Socket多线程文件传输 客户端是单线程 服务器端是多线程 记录类型与文件流联合传输，通过记录类型传递信息给服务器 传输速度快 与网络拷贝相同 服务器端会通过MD5码验证接收到文件的正确性 并...
多线程实现TCP的服务器，客户端随时收发信息
qq_44849419的博客
01-07 962
完成TCP的服务器，客户端，上交。服务器，客户端需要做到随时收发：多进程多线程实现。
关于socket收发信息与多线程，多进程问题总结（后续补充）
最新发布
lkxd194257的博客
12-07 604
在关闭套接字后可以对list1中的套接字进行删除，同时因为对list1进行修改，对应的list_name中数据也需要进行修改（list_name中以字典形式存放了用户IP，name，和 list1中的对应的编号），这用就不会出现上述错误了。当客户端申请关闭后，服务器同意关闭，双方结束通讯，但套接字仍保留在list1中未被删除，当有人在发送消息的时候，服务器就会遍历列表，向列表中的每个客户端发送消息，当发送到已经断开连接的套接字时就会产生。
C++多线程通信（线程池）
qq1186351245的博客
05-03 678
【代码】C++多线程通信（线程池）
socket多线程实现客户端与服务端多次通信，TCP/UDP，select,poll,epoll
weixin_49497024的博客
07-19 2297
虚拟机要改成多线程才行，不然单独测试多线程可能没问题，但是吧多线程运用到处理socket的收发信息时，就会出问题。如果把accept装进线程，实现服务器多线程处理客户端，这个我更加没办法测试。所以只是实现了聊天功能。可以看到，服务器端一直在accept，这里打开了两个客户端，服务器都响应了，端口是不一样的。换成线程之后，两边都将收、发放入线程，就可以实现两端聊天功能。大概思路将收、发两个分别抽离成函数，然后在主函数中去用线程的形式进行调用。简单的实现一次客户端和通信端连接的时候，是服务器是可以支持。....
TCP服务器客户端1对1收发多线程实现支持断开、重连机制
大牛攻城狮的专栏
09-02 2726
嵌入式Linux应用过程中，使用TCP服务器连接客户端，实现1对1传输。网上找了一大堆参考资料，感觉都没有找到想要的，主要是对断开、重连没有详细的步骤，数据收发都是在单线程中完成。这里提供一种收发多线程的处理方式，支持断开、重连机制，供参考。
多线程socket服务器(c语言)
YanPan12的博客
11-30 3557
文章目录一.线程的基本概念二,进程与线程的关系和区别三.创建线程四.多线程服务器流程五.代码实例 一.线程的基本概念 线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位. 所有的线程都是在同一进程空间运行，这也意味着多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境（register context)，自己的线程本地存储(thread-local storage)
Linux SocketCAN 编程（C++，启用多线程接收）
热门推荐
Flag_ing的博客
08-18 1万+
SocketCAN 采用常用的 Socket 网络编程接口来封装 CAN 协议，可以使开发人员几乎无压力地使用 CAN。SocketCAN 编程的思路与 Socket 网络编程几乎一样。socket() 函数返回一个 socketcan 的句柄，后续的操作都是基于这个句柄的。第一个参数第二个参数指定了 socket 的类型。常用的有第三个参数表示指定的协议。常用的协议有。......
C++基于TCP的SOCKET通信
lijingheng66的博客
09-03 3747
C++基于TCP的SOCK通信，从原理出发，理论与代码相结合，清晰易懂
linux c 多线程 socket编程,关于LINUX下C语言多线程并发Socket服务器的例子
weixin_39705435的博客
05-06 134
好久没有写这边的文章了, 作为一个IT界的新人. 最近因为升职的原因, 一直都好忙. 因为没有做过管理, 忽然到了这个位置上. 不适应是肯定的! 因为更喜欢钻研技术, 管理上欠缺的太多. 呵呵, 废话太多了. 切入正题.最近需要计划做一个服务器的程序. 和我们用VC++开发的客户端程序做对接, 我在LINUX服务器下用C写了一段简单的服务器, 代码如下:首先是头文件: CCServer.h...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值