Linux nanomsg tcp sub pub

一、安装

下载：Releases · nanomsg/nanomsg · GitHub
安装：https://github.com/nanomsg/nanomsg

tar xvf nanomsg-1.1.4.tar.gz
cd nanomsg-1.1.4
mkdir build
cd build
cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local
cmake --build .
ctest .
sudo cmake --build . --target install
sudo ldconfig

 二、简单sub pub

程序一

//进程一 文件pubsub.c
#include <assert.h>
#include <nanomsg/nn.h>
#include <nanomsg/pubsub.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>

#define SOCKET_ADDRESS_A "inproc://A" //线程A的消息队列的地址
#define SOCKET_ADDRESS_B "inproc://B" //线程B的消息队列的地址
#define SOCKET_ADDRESS_IPC_A "ipc:///tmp/a.ipc" //用于进程间通讯的消息队列的地址
#define SOCKET_ADDRESS_C "inproc://c" //线程C的消息队列的地址，这里没有用到

//线程A用于发布消息的线程
void* A_pub_thread(void* arg){
    time_t now; //获取本地时间（描数）
    int flag = 0; 
    struct tm* p;
    char msg[100]; //发送消息的长度
    int rc = 0;	//
    int ret = 0;
    int sock_pub = nn_socket(AF_SP, NN_PUB); //创建一个套接字模式为发布套接字
    assert(sock_pub >= 0); //确保创建成功
    //绑定本地地址
    assert(nn_bind(sock_pub, SOCKET_ADDRESS_A) >= 0);//绑定本地消息队列的地址
    assert(nn_bind(sock_pub, SOCKET_ADDRESS_IPC_A) >= 0);//绑定用于进程间消息接收的消息队列的地址
    //pub使用来发送的
    while (1) {
        now = time(NULL); //获取本地时间
        rc = 0;
        ret = 0;
        //如果满足 10 的发送条件
        if ((now % 10 == 0) && (flag == 0)) {
            flag = 1;
            p = gmtime(&now);
            memset(&msg, 0, sizeof(msg)); //清空发送缓存
            sprintf(msg, "10|%04d-%02d-%02d %02d:%02d:%02d from A", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
            //将发送字符串写入缓存，注意格式必须是 类型|内容 这里的类型就是10 内容就是当前时间 +from A
            ret = nn_send(sock_pub, msg, sizeof(msg), NN_DONTWAIT);//发送消息
            //判断消息是否发送成功
            if (ret < 0) {
                printf("A pub send msg failed\n");
            }
        }
        //如果满足 05 的发送条件
        if ((now % 5 == 0) && (now % 10 != 0) && (flag == 1)) {
            //和上面一样，注释就不写了
            flag = 0;
            p = gmtime(&now);
            memset(&msg, 0, sizeof(msg));
            sprintf(msg, "05|%04d-%02d-%02d %02d:%02d:%02d from A", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
            ret = nn_send(sock_pub, msg, sizeof(msg), NN_DONTWAIT);
            if (ret < 0) {
                printf("A pub send msg failed\n");
            }
        }
        //一秒循环一次
        sleep(1);
    }
}

//线程A用于订阅消息的线程
void* A_sub_thread(void* arg){
    time_t now; //用于获取当前时间
    int flag = 0;
    struct tm* p; //时间结构体
    char rcvmsg[100]; //用于接收消息
    int rc = 0; //判断接收长度
    int sock_sub = nn_socket(AF_SP, NN_SUB); //创建用于接收消息的套接字
    assert(sock_sub >= 0);//确保创建套接字成功
    //绑定本地地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_A) >= 0);//连接要接收消息的地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_B) >= 0);//可以同时连接多个
    //sub是用来订阅的
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "05", 2);//订阅 05 的消息（包括两上面连接的容器的消息）
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "10", 2);//订阅 10 的消息（包括两上面连接的容器的消息）
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "03", 2);//订阅 03 的消息（包括两上面连接的容器的消息）
    //pub使用来发送的
    while (1) {
        // 清空缓存
        memset(&rcvmsg, 0, sizeof(rcvmsg));
        //接收消息 第四个参数为0时表示租售接收
        rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), 0);
        if (rc > 0) {
            printf("A sub rcv: %s\n", rcvmsg);
            rc = 0;
            memset(&rcvmsg, 0, sizeof(rcvmsg));
            rc = nn_recv(sock_sub, &rcvmsg, NN_MSG, NN_DONTWAIT);
        }
    }
}

//线程A
void* A_thread(void* arg){
    pthread_t thread_A_1, thread_A_2;

    pthread_create(&thread_A_1, NULL, A_pub_thread, NULL);
    pthread_create(&thread_A_2, NULL, A_sub_thread, NULL);

    pthread_join(thread_A_1, NULL);
    pthread_join(thread_A_2, NULL);
}

void* B_pub_thread(void* arg){
    time_t now;
    int flag = 0;
    struct tm* p;
    char msg[100];
    int rc = 0;
    int ret = 0;
    int sock_pub = nn_socket(AF_SP, NN_PUB);
    assert(sock_pub >= 0);
    //绑定本地地址
    assert(nn_bind(sock_pub, SOCKET_ADDRESS_B) >= 0);
    //pub使用来发送的
    while (1) {
        now = time(NULL);
        rc = 0;
        ret = 0;
        if ((now % 3 == 0) && (now % 2 != 0) && (flag == 0)) {
            flag = 1;
            p = gmtime(&now);
            memset(&msg, 0, sizeof(msg));
            sprintf(msg, "03|%04d-%02d-%02d %02d:%02d:%02d from B", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
            ret = nn_send(sock_pub, msg, sizeof(msg), NN_DONTWAIT);
            if (ret < 0) {
                printf("A pub send msg failed\n");
            }
        }
        if ((now % 2 == 0) && (flag == 1)){
            flag = 0;
        }
        sleep(1);
    }
}

void* B_sub_thread(void* arg){
    time_t now;
    int flag = 0;
    struct tm* p;
    char msg[100];
    char rcvmsg[100];
    int rc = 0;
    int ret = 0;
    int sock_sub = nn_socket(AF_SP, NN_SUB);
    assert(sock_sub >= 0);
    //绑定本地地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_A) >= 0);
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_B) >= 0);
    //sub是用来订阅的
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "03", 2);
    while (1) {
        memset(&rcvmsg, 0, sizeof(rcvmsg));
        rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), 0);
        if (rc > 0) {
            printf("B sub rcv: %s\n", rcvmsg);
            rc = 0;
            memset(&rcvmsg, 0, sizeof(rcvmsg));
            rc = nn_recv(sock_sub, &rcvmsg, NN_MSG, NN_DONTWAIT);
        }
    }
}

void* B_thread(void* arg){
    pthread_t thread_B_1, thread_B_2;

    pthread_create(&thread_B_1, NULL, B_pub_thread, NULL);
    pthread_create(&thread_B_2, NULL, B_sub_thread, NULL);

    pthread_join(thread_B_1, NULL);
    pthread_join(thread_B_2, NULL);
}

void* C_thread(void* arg){
    int flag = 0;
    struct tm* p;
    char rcvmsg[100];
    int rc = 0;
    int ret = 0;
    int sock_sub = nn_socket(AF_SP, NN_SUB);
    assert(sock_sub >= 0);
    //绑定本地地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_A) >= 0);
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "10", 2);
    while (1) {
        memset(&rcvmsg, 0, sizeof(rcvmsg));
        rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), 0);
        while (rc > 0) {
            printf("C sub rcv: %s\n", rcvmsg);
            rc = 0;
            memset(&rcvmsg, 0, sizeof(rcvmsg));
            rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), NN_DONTWAIT);
        }
    }
}

int main(int argc, char** argv)
{
    pthread_t thread_A, thread_B, thread_C;

    pthread_create(&thread_A, NULL, A_thread, NULL);
    pthread_create(&thread_B, NULL, B_thread, NULL);
    pthread_create(&thread_C, NULL, C_thread, NULL);

    pthread_join(thread_A, NULL);
    pthread_join(thread_B, NULL);
    pthread_join(thread_C, NULL);

    exit(EXIT_SUCCESS);
}

 程序二

//进程二
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <assert.h>
#include <unistd.h>

#define SOCKET_ADDRESS_IPC_A "ipc:///tmp/a.ipc"


int main(){
    time_t now;
    int flag = 0;
    struct tm* p;
    char rcvmsg[100];
    int rc = 0;
    int sock_sub = nn_socket(AF_SP, NN_SUB);
    assert(sock_sub >= 0);
    //绑定本地地址
    assert(nn_connect(sock_sub, SOCKET_ADDRESS_IPC_DASS) >= 0);
    //sub是用来订阅和接收的
    nn_setsockopt(sock_sub, NN_SUB, NN_SUB_SUBSCRIBE, "10", 2);
    while (1) {
        memset(&rcvmsg, 0, sizeof(rcvmsg));
        rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), 0);
        while (rc > 0) {
            printf("2 sub rcv: %s\n", rcvmsg);
            rc = 0;
            memset(&rcvmsg, 0, sizeof(rcvmsg));
            rc = nn_recv(sock_sub, &rcvmsg, sizeof(rcvmsg), NN_DONTWAIT);
        }
    }
    return 0;
}

三、封装sub pub

nanomsg实现进程间通讯，将nanomsg进行封装

#ifndef __NANO_ROS_H
#define __NANO_ROS_H
#include <string>
#include <cstring>
#include <assert.h>
#include <nanomsg/nn.h>
#include <nanomsg/pubsub.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include <thread> //线程头文件
#include <functional>
#include <vector>
#include <stdint.h>
using namespace std;
const int data_size=3000000;

namespace nano
{
    using MyFunction = std::function<void(char*)>;  
    std::vector <MyFunction> numericalFunctions;
    auto& fct_save = numericalFunctions;
    typedef void (*pf_char)(char*);
    void B_sub_thread(void);
    int rc = 0;
    int ret = 0;
    vector <int> sock_pub;
    vector <int> sock_sub;
    int all_pub=0;
    int all_sub=0;
    std::string address_node;
    std::string node_name;
    vector <std::string> sub_topic;
    vector <std::string> pub_topic;
    vector <bool> msg_update;
    char Rcvmsg[10][data_size];
    vector <int> msg_size;
    std::thread t_ros{B_sub_thread};
    bool thread_bit=false;
    int sleep_time=1;
    void init(std::string node){}
    void init(int a,char **argv,std::string node){}
    bool ok(void)
    {
        return true;
    }
    
    void spinOnce()
    {
        for(int i=0;i<msg_update.size();i++)
        {
            if(msg_update[i])
                fct_save[i](Rcvmsg[i]);//将接收的数据返回到回调函数
            msg_update[i]=false;
        }
    }
    class Publisher
    {
        public:
        int pub_num;
        Publisher()
        {
            pub_num=all_pub;
        }
        template <typename T>
        void publish(const T &msg)//
        {
            ret = 0;     
            ret = nn_send(sock_pub[pub_num],&msg,msg_size[pub_num], NN_DONTWAIT);
            if (ret < 0) {
                printf("A pub send msg failed\n");
            }      
        };
        template <typename T>
        void publish(const T &msg,int num)
        {
            ret = 0;     
            ret = nn_send(sock_pub[pub_num],&msg,num, NN_DONTWAIT);
            if (ret < 0) {
                printf("A pub send msg failed\n");
            }
        }
    };
    class Subscriber
    {
        public:
        int sub_num;
        Subscriber()
        {
            sub_num=all_sub;
        }
    };
    class NodeHandle
    {
        public:
        template <typename T>
        Publisher  advertise(std::string pub_topic_name,int num)
        {
            msg_size.push_back(sizeof(T)/sizeof(char));
            Publisher PubNum;
            sock_pub.push_back(nn_socket(AF_SP, NN_PUB));
            assert( sock_pub.back()>= 0);           
            //绑定本地地址
            std::string  PubAddress;
            char ip_check[150];
            strcpy(ip_check,pub_topic_name.c_str());
            if(ip_check[0]>'0'&&ip_check[0]<'9')
            {
                printf("This pub is tcp,device between\n");
                PubAddress="tcp://"+pub_topic_name;                  
            }
            else
            {
                printf("This pub is ipc\n");
                PubAddress="ipc:///tmp/"+pub_topic_name+".ipc";
            }
            pub_topic.push_back(PubAddress);
            const char *SOCKET_ADDRESS_IPC_B=PubAddress.c_str();
            assert(nn_bind(sock_pub.back(), SOCKET_ADDRESS_IPC_B) >= 0);//绑定用于进程间消息接收的消息队列的地址
            all_pub++;
	        printf("all_pub is %d\n",all_pub);
            return PubNum;
        }
        Subscriber subscribe(std::string sub_topic_name, int num,const pf_char &sub_fun)
        {//将回调函数作为形参加载到线程中运行
            Subscriber SubNum;
            msg_update.push_back(false);
            sub_topic.push_back(sub_topic_name);
            sock_sub.push_back(nn_socket(AF_SP, NN_SUB));
            assert(sock_sub.back() >= 0);
            std::string  SubAddress;
            char ip_check[150];
            strcpy(ip_check,sub_topic_name.c_str());
            if(ip_check[0]>'0'&&ip_check[0]<'9')
                {
                    printf("This sub is tcp,device between\n");
                    SubAddress="tcp://"+sub_topic.back();                  
                }
            else
                {
                    printf("This sub is ipc\n");
                    SubAddress="ipc:///tmp/"+sub_topic.back()+".ipc";
                }
            const char *SOCKET_ADDRESS_IPC_A=SubAddress.c_str();
            //绑定本地地址
            assert(nn_connect(sock_sub.back(), SOCKET_ADDRESS_IPC_A) >= 0);
            //sub是用来订阅的
            nn_setsockopt(sock_sub.back(), NN_SUB, NN_SUB_SUBSCRIBE, "", 0);
            fct_save.push_back(sub_fun);
            if(!thread_bit)
              {t_ros.detach();thread_bit=true;}
            all_sub++;     
            return SubNum;
        };
        int node_num;
    };
    class Rate
    {
        public:
        Rate(int time)
        {
            sleep_time=time;
        }
        void sleep(void)
        {
            usleep(1000*1000/sleep_time);
        };
    };

    void B_sub_thread(void){
        char rcvmsg[data_size];
        while (1) 
        {       
            memset(&rcvmsg, 0, sizeof(rcvmsg));
            for(int bbb=0;bbb<sock_sub.size();bbb++)
            {
                    rc = nn_recv(sock_sub[bbb], &rcvmsg, sizeof(rcvmsg),NN_DONTWAIT);
                    
                    if (rc > 0) {
                        rc = 0;
                        msg_update[bbb]=true;
                        memcpy(&Rcvmsg[bbb],&rcvmsg[0], sizeof(rcvmsg));
                    }
            }
            usleep(1000*1000/sleep_time);
        }
    }
}
void NANO_INFO_STREAM(std::string msg)
{
    timeval now;
    char msg_s[100];
    gettimeofday(&now, NULL);
    memset(&msg_s, 0, sizeof(msg_s));
    sprintf(msg_s, "%ld.%06ld:%s", now.tv_sec, now.tv_usec,msg.c_str());
    printf("%s\n",msg_s);
}
void NANO_INFO_STREAM(std::string msg_a,float msg)
{
    timeval now;
    char msg_s[100];
    gettimeofday(&now, NULL);
    memset(&msg_s, 0, sizeof(msg_s));
    sprintf(msg_s, "%ld.%06ld:%s %f", now.tv_sec, now.tv_usec,msg_a.c_str(),msg);
    printf("%s\n",msg_s);
}
void NANO_INFO(std::string msg_a,float msg)
{
    timeval now;
    char msg_s[100];
    gettimeofday(&now, NULL);
    memset(&msg_s, 0, sizeof(msg_s));
    sprintf(msg_s, "%ld.%06ld:%s %f", now.tv_sec, now.tv_usec,msg_a.c_str(),msg);
    printf("%s\n",msg_s);
}
#endif

 以camera为例，封装消息类型

#ifndef __SENSOR_MSGS_CAM_H
#define __SENSOR_MSGS_CAM_H
#include <sys/time.h>
#include <stdint.h>
#include <string>
using namespace std;
const int CAMERA_SIZE=921656;

struct Header_cam{
  string frame_id;
  uint32_t seq; 
  timeval stamp;   // 时间戳
};

struct camera_data
{
	unsigned char data[921600];
};
struct sensor_msgs_cam{
    Header_cam header;
    camera_data Data;
};
#endif

订阅发布函数

#include "m_nano.hpp"
#include <string>
#include "sensor_msgs_cam.hpp"
#include "readconfig.hpp"
#include "package_path.h"
#include  <opencv2/core/core.hpp>
#include  <opencv2/highgui/highgui.hpp>
#include  <opencv2/imgcodecs.hpp>
using namespace std;
sensor_msgs_cam CamData;
int main(int argc, char **argv)
{
    nano::init(argc, argv, "node_b");    //初始化ROS，节点命名为node_b，节点名必须唯一。
    nano::NodeHandle nh;    //节点句柄实例化
    nano::Publisher pub_camera=nh.advertise<sensor_msgs_cam>("100.100.100.99:5555",10);
    nano::Publisher pub_camera_t=nh.advertise<sensor_msgs_cam>("camera",10);
    nano::Rate loop_rate(10);    //设置发送数据的频率为10Hz
    std::string yaml_path=PROJECT_PATH;
    yaml_path+="/config/cam.yaml";
    int num_cam = readConfigInt(yaml_path,"cam_num",0);
    int show_video = readConfigInt(yaml_path,"show_video",0);
    static cv::VideoCapture cap;
    if(cap.open(num_cam) == 0)
    {
        perror("Open dev error!");
    }
    cv::Mat frame(480, 640, CV_8UC3, cv::Scalar(255,0,0));
    timeval now;
    while(nano::ok())
    {   
        cap.read(frame);  
    	memcpy(CamData.Data.data,frame.data,sizeof(camera_data)/sizeof(char));
        gettimeofday(&now, NULL);
        CamData.header.stamp=now;
        if(show_video)
        {
            imshow("video show",frame);
            cv::waitKey(1);
        }
        pub_camera.publish(CamData);
        pub_camera_t.publish(CamData);
        nano::spinOnce();      //不是必须，若程序中订阅话题则必须，否则回掉函数不起作用。
        loop_rate.sleep();    //按前面设置的10Hz频率将程序挂起
    }
    return 0;
}

订阅发布函数2

#include "m_nano.hpp"
#include <string>
#include "sensor_msgs_cam.hpp"
#include "readconfig.hpp"
#include "package_path.h"
#include  <opencv2/core/core.hpp>
#include  <opencv2/highgui/highgui.hpp>
#include  <opencv2/imgcodecs.hpp>
using namespace std;
int show_video=0;
sensor_msgs_cam CamData,CamData_t;
cv::Mat dst_mat(480, 640, CV_8UC3, cv::Scalar(255,0,0));
cv::Mat dst_mat_t(480, 640, CV_8UC3, cv::Scalar(255,0,0));

void camera_callback(char *msg)
{
    memcpy(&CamData,&msg[0],CAMERA_SIZE);
    memcpy(dst_mat.data,CamData.Data.data,sizeof(camera_data)/sizeof(char));
    if(show_video)
    {
        imshow("video recive",dst_mat);
        cv::waitKey(1);
    }
}

void camera_callback_t(char *msg)
{
    memcpy(&CamData_t,&msg[0],CAMERA_SIZE);
    memcpy(dst_mat_t.data,CamData_t.Data.data,sizeof(camera_data)/sizeof(char));
    if(show_video)
    {
        imshow("video recive",dst_mat_t);
        cv::waitKey(1);
    }
}

int main(int argc, char **argv)
{
    nano::init(argc, argv, "node_b");    //初始化ROS，节点命名为node_b，节点名必须唯一。
    nano::NodeHandle nh;    //节点句柄实例化
    nano::Subscriber sub = nh.subscribe("camera",50,camera_callback);
    nano::Subscriber sub_t = nh.subscribe("100.100.100.99:5555",50,camera_callback_t);
    nano::Rate loop_rate(10);    //设置发送数据的频率为10Hz
    std::string yaml_path=PROJECT_PATH;
    yaml_path+="/config/cam.yaml";
    show_video = readConfigInt(yaml_path,"show_video",0);
    while(nano::ok())
    {     
        nano::spinOnce();    //不是必须，若程序中订阅话题则必须，否则回掉函数不起作用。
        loop_rate.sleep();    //按前面设置的10Hz频率将程序挂起
    }
    return 0;
}

可实现设备内进程间通讯，及设备间通讯。