【FastDDS学习笔记】HelloWorld示例程序编译和运行

Bynull

已于 2022-11-12 13:12:35 修改

阅读量5.4k

点赞数 10

分类专栏： DDS学习笔记文章标签：学习 c++ 开发语言

于 2022-05-11 17:47:30 首次发布

本文链接：https://blog.csdn.net/u012739527/article/details/124705821

版权

DDS学习笔记专栏收录该内容

5 篇文章 22 订阅

订阅专栏

在这里插入图片描述

设置相应的环境变量

因为上一章节中，我们编译的库并没有放到系统中，而是放在了一个文件夹中，所以这里我们要先设定以下对应的环境变量：

export LD_LIBRARY_PATH=/home/xiaoqing/Fast-DDS/install/lib

这里的路径就是编译时候，填写的路径。

如果想要永久生效，执行以下命令：

echo 'export LD_LIBRARY_PATH=/home/xiaoqing/Fast-DDS/install/lib' >> ~/.bashrc

这里我是用的是永久生效的。

编译HelloWorld

在ubuntu中执行以下命令：

mkdir build && cd build
cmake .. -DCMAKE_PREFIX_PATH=~/Fast-DDS/install/

运行效果：

在这里插入图片描述

继续编译：

make

生成运行实例：
在这里插入图片描述

运行HelloWorld

接下来我们来运行HelloWorld，看一下效果。

新开一个终端，运行一个publisher：

./HelloWorldExample publisher

再新开一个终端，运行一个subscriber：

./HelloWorldExample subscriber

执行效果：
publisher:
在这里插入图片描述
subscriber:

源码分析

源码的文件目录：

HelloWorldExample
├── build
│  ├── CMakeCache.txt
│  ├── CMakeFiles
│  ├── cmake_install.cmake
│  ├── HelloWorldExample
│  └── Makefile
├── CMakeLists.txt
├── HelloWorld.cxx // 由idl生成
├── HelloWorld.h // 由idl生成
├── HelloWorld.idl      //idl 文件
├── HelloWorld_main.cpp
├── HelloWorldPublisher.cpp
├── HelloWorldPublisher.h
├── HelloWorldPubSubTypes.cxx // 由idl生成
├── HelloWorldPubSubTypes.h // 由idl生成
├── HelloWorldSubscriber.cpp
├── HelloWorldSubscriber.h
└── README.txt

代码中
HelloWorld.idl 定义payload，会生成HelloWorld.h，HelloWorld.cxx，HelloWorldPubSubTypes.h与HelloWorldPubSubTypes.cxx四个文件，包含了序列化与反序列化的逻辑。

先来看一下HelloWorld.idl:

struct HelloWorld
{
	unsigned long index;
	string message;
};

只是简单地定义了下数据传输的结构体。

结构体包含一个id和一个字符串类型的message。

而这，也就是DDS概念模型中，TopicDataType的定义。

主题在概念上适合发布和订阅。

从OMG的DDS官网我们可以知道，IDL（DDS基于的是IDL4 v4.2标准）是一种不依赖于编程语言的，用于定义数据类型和接口的描述性语言。他同时也是OMG组织制定的标准。Fast DDS-Gen作为一个Java应用程序，就是用来解析idl文件，生成数据类型定义的（即HelloWorld.h，HelloWorld.cxx，HelloWorldPubSubTypes.h，HelloWorldPubSubTypes.cxx）。

生成的文件HelloWorld.h，HelloWorld.cxx`中会根据这个结构体生成类，并添加一些序列化使用的函数：

class HelloWorld
{
public:
    eProsima_user_DllExport HelloWorld& operator =(

            const HelloWorld& x);

    eProsima_user_DllExport HelloWorld& operator =(

            HelloWorld&& x);

    eProsima_user_DllExport bool operator ==(

            const HelloWorld& x) const;

    eProsima_user_DllExport bool operator !=(

            const HelloWorld& x) const;

    eProsima_user_DllExport void index(

            uint32_t _index);

    eProsima_user_DllExport uint32_t index() const;

    eProsima_user_DllExport uint32_t& index();

    eProsima_user_DllExport void message(

            const std::string& _message);

    eProsima_user_DllExport void message(

            std::string&& _message);

    eProsima_user_DllExport const std::string& message() const;

    eProsima_user_DllExport std::string& message();

    eProsima_user_DllExport static size_t getMaxCdrSerializedSize(

            size_t current_alignment = 0);

    eProsima_user_DllExport static size_t getCdrSerializedSize(

            const HelloWorld& data,

            size_t current_alignment = 0);

    eProsima_user_DllExport void deserialize(

            eprosima::fastcdr::Cdr& cdr);
    eProsima_user_DllExport static size_t getKeyMaxCdrSerializedSize(

            size_t current_alignment = 0);
    eProsima_user_DllExport static bool isKeyDefined();
    eProsima_user_DllExport void serializeKey(
            eprosima::fastcdr::Cdr& cdr) const;
private:
    uint32_t m_index;
    std::string m_message;
};

在main函数中主要是根据参数创建相应的对象：

int main(int argc, char** argv)
{
    std::cout << "Starting "<< std::endl;
    int type = 1;
    int count = 10;
    long sleep = 100;
    if(argc > 1)
    {
        if(strcmp(argv[1],"publisher")==0)
        {
            type = 1;
            if (argc >= 3)
            {
                count = atoi(argv[2]);
                if (argc == 4)
                {
                    sleep = atoi(argv[3]);
                }
            }
        }
        else if(strcmp(argv[1],"subscriber")==0)
            type = 2;
    }
    else
    {
        std::cout << "publisher OR subscriber argument needed" << std::endl;
        Log::Reset();
        return 0;
    }
    switch(type)
    {
        case 1:
            {
                //创建publisher对象
                HelloWorldPublisher mypub;
                //初始化
                if(mypub.init())
                {
                    //运行publisher,发布10次
                    mypub.run(count, sleep);
                }
                break;
            }
        case 2:
            {
                //创建subscriber对象
                HelloWorldSubscriber mysub;
                //初始化
                if(mysub.init())
                {
                    //运行subscriber
                    mysub.run();
                }
                break;
            }
    }
    Domain::stopAll();
    Log::Reset();
    return 0;
}

真正的逻辑实现放在了HelloWorldPublisher和HelloWorldSubscriber的实现中。

来看一下初始化部分。

HelloWorldPublisher流程分析

HelloWorldPublisherc初始化基本步骤：

初始化m_Hello的内容，m_Hello即为需要发送的data
初始化参与者的参数对象
创建participant
初始化writer
创建publisher

代码分析如下：
publisher

bool HelloWorldPublisher::init()
{
    /*1. Init m_Hello */
    // 设置初始的index = 0
    m_Hello.index(0);
    // 设置初始值message
    m_Hello.message("HelloWorld");
    /*2. 初始化参与者的参数对象 */
    // 创建参与者的相关属性
    ParticipantAttributes PParam;
    PParam.rtps.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol_t::SIMPLE;
    PParam.rtps.builtin.discovery_config.use_SIMPLE_EndpointDiscoveryProtocol = true;
    PParam.rtps.builtin.discovery_config.m_simpleEDP.use_PublicationReaderANDSubscriptionWriter = true;
    PParam.rtps.builtin.discovery_config.m_simpleEDP.use_PublicationWriterANDSubscriptionReader = true;
    PParam.rtps.builtin.discovery_config.leaseDuration = c_TimeInfinite;
    PParam.rtps.setName("Participant_pub");

    /*3. 创建participant */
    mp_participant = Domain::createParticipant(PParam);

    if (mp_participant == nullptr)
    {
        return false;

    }
；
    /*4. 注册数据类型 */
    Domain::registerType(mp_participant, &m_type);

    /*5. 初始化writer */
    PublisherAttributes Wparam;
    Wparam.topic.topicKind = NO_KEY;
    Wparam.topic.topicDataType = "HelloWorld";
    Wparam.topic.topicName = "HelloWorldTopic";
    Wparam.topic.historyQos.kind = KEEP_LAST_HISTORY_QOS;
    Wparam.topic.historyQos.depth = 30;
    Wparam.topic.resourceLimitsQos.max_samples = 50;
    Wparam.topic.resourceLimitsQos.allocated_samples = 20;
    Wparam.times.heartbeatPeriod.seconds = 2;
    Wparam.times.heartbeatPeriod.nanosec = 200 * 1000 * 1000;
    Wparam.qos.m_reliability.kind = RELIABLE_RELIABILITY_QOS;

    /*6. 创建publisher */
    mp_publisher = Domain::createPublisher(mp_participant, Wparam, (PublisherListener*)&m_listener);

    if (mp_publisher == nullptr)
    {
        return false;
    }
    return true;
}

其中m_Hello类型维HelloWorld, 调用index是设置其值:

void HelloWorld::index(uint32_t _index)
{
    m_index = _index;
}

然后开始执行其run函数：

void HelloWorldPublisher::run(uint32_t samples,uint32_t sleep)
{
    stop = false;
    /* 启动线程 */
    std::thread thread(&HelloWorldPublisher::runThread, this, samples, sleep);

    if (samples == 0)
    {
        std::cout << "Publisher running. Please press enter to stop the Publisher at any time." << std::endl;
        std::cin.ignore();
        stop = true;
    }
    else
    {
        std::cout << "Publisher running " << samples << " samples." << std::endl;
    }
    thread.join();
}

可以看出run函数中只是启动了个线程，接着便进入线程中：

void HelloWorldPublisher::runThread(uint32_t samples,uint32_t sleep)
{
    /* 这里samples传入值为10 */
    if (samples == 0)
    {
        while (!stop)
        {
            /* 执行函数publish */
            if (publish(false))
            {
                std::cout << "Message: " << m_Hello.message() << " with index: " << m_Hello.index() << " SENT" <<std::endl;

            }
            std::this_thread::sleep_for(std::chrono::milliseconds(sleep));
        }
    }
    else
    {
        for (uint32_t i = 0; i < samples; ++i)
        {
            if (!publish())
            {
                --i;
            }
            else
            {
                std::cout << "Message: " << m_Hello.message() << " with index: " << m_Hello.index() << " SENT" <<std::endl;

            }
            std::this_thread::sleep_for(std::chrono::milliseconds(sleep));
        }
    }
}

进入线程后主要是去执行了publish函数：

bool HelloWorldPublisher::publish(bool waitForListener)
{
    /* waitForListener传入为false */
    if (m_listener.firstConnected || !waitForListener || m_listener.n_matched > 0)
    {
        // 设定index的值，index初始化为0
        m_Hello.index(m_Hello.index() + 1);
        // 发布数据m_Hello
        mp_publisher->write((void*)&m_Hello);
        return true;
    }
    return false;
}

其中mp_publisher的类型是eprosima::fastrtps::Publisher.(头文件路径：Fast-DDS/include/fastrtps/publisher/Publisher.h)

write函数实现部分在代码：Fast-DDS/src/cpp/fastrtps_deprecated/publisher/Publisher.cpp

bool Publisher::write(void* Data)
{
    logInfo(PUBLISHER, "Writing new data");
    return mp_impl->create_new_change(ALIVE, Data);
}

HelloWorldsubscriber流程分析

HelloWorldSubscriber初始化基本步骤：

初始化参与者的参数对象
创建participant
初始化reader
创建publisher

代码分析如下

bool HelloWorldSubscriber::init()
{
    /*1. 初始化参与者的参数对象 */
    ParticipantAttributes PParam;
    PParam.rtps.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol_t::SIMPLE;
    PParam.rtps.builtin.discovery_config.use_SIMPLE_EndpointDiscoveryProtocol = true;
    PParam.rtps.builtin.discovery_config.m_simpleEDP.use_PublicationReaderANDSubscriptionWriter = true;
    PParam.rtps.builtin.discovery_config.m_simpleEDP.use_PublicationWriterANDSubscriptionReader = true;
    PParam.rtps.builtin.discovery_config.leaseDuration = c_TimeInfinite;
    PParam.rtps.setName("Participant_sub");
    /*2. 创建参与者 */
    mp_participant = Domain::createParticipant(PParam);

    if (mp_participant == nullptr)
    {
        return false;
    }

    /*3. 注册数据类型 */
    Domain::registerType(mp_participant, &m_type);

    /*4. 初始化reader */
    SubscriberAttributes Rparam;
    Rparam.topic.topicKind = NO_KEY;
    Rparam.topic.topicDataType = "HelloWorld";
    Rparam.topic.topicName = "HelloWorldTopic";
    Rparam.topic.historyQos.kind = KEEP_LAST_HISTORY_QOS;
    Rparam.topic.historyQos.depth = 30;
    Rparam.topic.resourceLimitsQos.max_samples = 50;
    Rparam.topic.resourceLimitsQos.allocated_samples = 20;
    Rparam.qos.m_reliability.kind = RELIABLE_RELIABILITY_QOS;
    Rparam.qos.m_durability.kind = TRANSIENT_LOCAL_DURABILITY_QOS;
    /*4. 创建subscriber */
    mp_subscriber = Domain::createSubscriber(mp_participant, Rparam, (SubscriberListener*)&m_listener);
    if (mp_subscriber == nullptr)
    {
        return false;
    }
    return true;
}

继续看一下run函数：

void HelloWorldSubscriber::run()
{
    std::cout << "Subscriber running. Please press enter to stop the Subscriber" << std::endl;
    std::cin.ignore();
}

可以看出HelloWorldSubscriber的run函数中几乎什么都没做，只是等待一个按键后退出。

这里的主要读取数据的操作是由init函数中注册的&m_listener来完成的。

m_listener的相关代码：

   class SubListener : public eprosima::fastrtps::SubscriberListener
    {
    public:
        SubListener(): n_matched(0), n_samples(0)
        {
        }
        ~SubListener()
        {
        }
        void onSubscriptionMatched(eprosima::fastrtps::Subscriber* sub, eprosima::fastrtps::rtps::MatchingInfo& info);
        void onNewDataMessage(eprosima::fastrtps::Subscriber* sub);
        HelloWorld m_Hello;
        eprosima::fastrtps::SampleInfo_t m_info;
        int n_matched;
        uint32_t n_samples;
    } m_listener;

SubscriberListener的代码路径是Fast-DDS/include/fastrtps/subscriber/SubscriberListener.h

class RTPS_DllAPI SubscriberListener
{
    public:
        SubscriberListener(){}
        virtual ~SubscriberListener(){}
        /**
         * 由用户实现的功能，包含接收到新数据消息时要执行的操作。
         */
        virtual void onNewDataMessage(Subscriber* sub)
        {
            (void)sub;
        }
        /**
         * Virtual 当订阅者与新的 Writer 匹配（或不匹配）时调用的方法。
         */
        virtual void onSubscriptionMatched(Subscriber* sub,rtps::MatchingInfo& info)
        {
            (void)sub;
            (void)info;
        }
        /**
         * 当主题错过最后期限时调用的方法
         */
        virtual void on_requested_deadline_missed(Subscriber* sub,const RequestedDeadlineMissedStatus& status)
        {
            (void)sub;
            (void)status;
        }
        /**
         * 当与订阅服务器关联的活动状态更改时调用的方法
         */
        virtual void on_liveliness_changed(Subscriber* sub,const LivelinessChangedStatus& status){

            (void)sub;
            (void)status;
        }
};

可以看出onNewDataMessage函数是消息相应的函数：

void HelloWorldSubscriber::SubListener::onNewDataMessage(Subscriber* sub)
{
    if (sub->takeNextData((void*)&m_Hello, &m_info))
    {
        if (m_info.sampleKind == ALIVE)
        {
            this->n_samples++;
            // Print your structure data here.
            std::cout << "Message " << m_Hello.message() << " " << m_Hello.index() << " RECEIVED" << std::endl;
        }
    }
}

这里的实现就是获取数据后并打印。

sub的类型为eprosima::fastrtps::Subscriber*(头文件路径：Fast-DDS/include/fastrtps/subscriber/Subscriber.h).

其中定义了``函数：

    /**
      * @brief 从订阅者处获取下一个样本。 从订户中删除样本。
      * @param sample 指向您希望存储样本的对象的指针。
      * @param info 指向 SampleInfo_t 结构的指针，该结构通知您有关您的样本。
      * @return 如果取样则为真。
      * @note 该方法被阻塞一段时间。
      * SubscriberAttributes 上的 ReliabilityQosPolicy.max_blocking_time 定义了这段时间。
      */
    bool takeNextData(void* sample,SampleInfo_t* info);

好了今天的分享就到这里，明天继续。^_

在这里插入图片描述