1
mkdir workspace_DDSHelloWorld && cd workspace_DDSHelloWorld
2
mkdir src build

1
source <path/to/Fast-DDS/workspace>/install/setup.bash

1
echo 'source <path/to/Fast-DDS/workspace>/install/setup.bash' >> ~/.bashrc

1
cmake_minimum_required(VERSION 3.20)
2

3
project(DDSHelloWorld)
4

5
# Find requirements
6
if(NOT fastcdr_FOUND)
7
    find_package(fastcdr 2 REQUIRED)
8
endif()
9

10
if(NOT fastdds_FOUND)
11
    find_package(fastdds 3 REQUIRED)
12
endif()
13

14
# Set C++11
15
include(CheckCXXCompilerFlag)
16
if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANG OR
17
        CMAKE_CXX_COMPILER_ID MATCHES "Clang")
18
    check_cxx_compiler_flag(-std=c++11 SUPPORTS_CXX11)
19
    if(SUPPORTS_CXX11)
20
        add_compile_options(-std=c++11)
21
    else()
22
        message(FATAL_ERROR "Compiler doesn't support C++11")
23
    endif()
24
endif()
25

26
message(STATUS "Configuring HelloWorld publisher/subscriber example...")
27
file(GLOB DDS_HELLOWORLD_SOURCES_CXX "src/*.cxx")

1
cd src && touch HelloWorld.idl

1
struct HelloWorld
2
{
3
    unsigned long index;
4
    string message;
5
};

1
<path/to/Fast DDS-Gen>/scripts/fastddsgen HelloWorld.idl

1
wget -O HelloWorldPublisher.cpp \
2
    https://raw.githubusercontent.com/eProsima/Fast-RTPS-docs/master/code/Examples/C++/DDSHelloWorld/src/HelloWorldPublisher.cpp

1
// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
/**
16
 * @file HelloWorldPublisher.cpp
17
 *
18
 */
19

20
#include "HelloWorldPubSubTypes.hpp"
21

22
#include <chrono>
23
#include <thread>
24

25
#include <fastdds/dds/domain/DomainParticipant.hpp>
26
#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
27
#include <fastdds/dds/publisher/DataWriter.hpp>
28
#include <fastdds/dds/publisher/DataWriterListener.hpp>
29
#include <fastdds/dds/publisher/Publisher.hpp>
30
#include <fastdds/dds/topic/TypeSupport.hpp>
31

32
using namespace eprosima::fastdds::dds;
33

34
class HelloWorldPublisher
35
{
36
private:
37

38
    HelloWorld hello_;
39

40
    DomainParticipant* participant_;
41

42
    Publisher* publisher_;
43

44
    Topic* topic_;
45

46
    DataWriter* writer_;
47

48
    TypeSupport type_;
49

50
    class PubListener : public DataWriterListener
51
    {
52
    public:
53

54
        PubListener()
55
            : matched_(0)
56
        {
57
        }
58

59
        ~PubListener() override
60
        {
61
        }
62

63
        void on_publication_matched(
64
                DataWriter*,
65
                const PublicationMatchedStatus& info) override
66
        {
67
            if (info.current_count_change == 1)
68
            {
69
                matched_ = info.total_count;
70
                std::cout << "Publisher matched." << std::endl;
71
            }
72
            else if (info.current_count_change == -1)
73
            {
74
                matched_ = info.total_count;
75
                std::cout << "Publisher unmatched." << std::endl;
76
            }
77
            else
78
            {
79
                std::cout << info.current_count_change
80
                        << " is not a valid value for PublicationMatchedStatus current count change." << std::endl;
81
            }
82
        }
83

84
        std::atomic_int matched_;
85

86
    } listener_;
87

88
public:
89

90
    HelloWorldPublisher()
91
        : participant_(nullptr)
92
        , publisher_(nullptr)
93
        , topic_(nullptr)
94
        , writer_(nullptr)
95
        , type_(new HelloWorldPubSubType())
96
    {
97
    }
98

99
    virtual ~HelloWorldPublisher()
100
    {
101
        if (writer_ != nullptr)
102
        {
103
            publisher_->delete_datawriter(writer_);
104
        }
105
        if (publisher_ != nullptr)
106
        {
107
            participant_->delete_publisher(publisher_);
108
        }
109
        if (topic_ != nullptr)
110
        {
111
            participant_->delete_topic(topic_);
112
        }
113
        DomainParticipantFactory::get_instance()->delete_participant(participant_);
114
    }
115

116
    //!Initialize the publisher
117
    bool init()
118
    {
119
        hello_.index(0);
120
        hello_.message("HelloWorld");
121

122
        DomainParticipantQos participantQos;
123
        participantQos.name("Participant_publisher");
124
        participant_ = DomainParticipantFactory::get_instance()->create_participant(0, participantQos);
125

126
        if (participant_ == nullptr)
127
        {
128
            return false;
129
        }
130

131
        // Register the Type
132
        type_.register_type(participant_);
133

134
        // Create the publications Topic
135
        topic_ = participant_->create_topic("HelloWorldTopic", "HelloWorld", TOPIC_QOS_DEFAULT);
136

137
        if (topic_ == nullptr)
138
        {
139
            return false;
140
        }
141

142
        // Create the Publisher
143
        publisher_ = participant_->create_publisher(PUBLISHER_QOS_DEFAULT, nullptr);
144

145
        if (publisher_ == nullptr)
146
        {
147
            return false;
148
        }
149

150
        // Create the DataWriter
151
        writer_ = publisher_->create_datawriter(topic_, DATAWRITER_QOS_DEFAULT, &listener_);
152

153
        if (writer_ == nullptr)
154
        {
155
            return false;
156
        }
157
        return true;
158
    }
159

160
    //!Send a publication
161
    bool publish()
162
    {
163
        if (listener_.matched_ > 0)
164
        {
165
            hello_.index(hello_.index() + 1);
166
            writer_->write(&hello_);
167
            return true;
168
        }
169
        return false;
170
    }
171

172
    //!Run the Publisher
173
    void run(
174
            uint32_t samples)
175
    {
176
        uint32_t samples_sent = 0;
177
        while (samples_sent < samples)
178
        {
179
            if (publish())
180
            {
181
                samples_sent++;
182
                std::cout << "Message: " << hello_.message() << " with index: " << hello_.index()
183
                            << " SENT" << std::endl;
184
            }
185
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
186
        }
187
    }
188
};
189

190
int main(
191
        int argc,
192
        char** argv)
193
{
194
    std::cout << "Starting publisher." << std::endl;
195
    uint32_t samples = 10;
196

197
    HelloWorldPublisher* mypub = new HelloWorldPublisher();
198
    if(mypub->init())
199
    {
200
        mypub->run(samples);
201
    }
202

203
    delete mypub;
204
    return 0;
205
}

1
add_executable(DDSHelloWorldPublisher src/HelloWorldPublisher.cpp ${DDS_HELLOWORLD_SOURCES_CXX})
2
target_link_libraries(DDSHelloWorldPublisher fastdds fastcdr)

1
cmake ..
2
cmake --build .
3
./DDSHelloWorldPublisher

1
wget -O HelloWorldSubscriber.cpp \
2
    https://raw.githubusercontent.com/eProsima/Fast-RTPS-docs/master/code/Examples/C++/DDSHelloWorld/src/HelloWorldSubscriber.cpp

1
// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
/**
16
 * @file HelloWorldSubscriber.cpp
17
 *
18
 */
19

20
#include "HelloWorldPubSubTypes.hpp"
21

22
#include <chrono>
23
#include <thread>
24

25
#include <fastdds/dds/domain/DomainParticipant.hpp>
26
#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
27
#include <fastdds/dds/subscriber/DataReader.hpp>
28
#include <fastdds/dds/subscriber/DataReaderListener.hpp>
29
#include <fastdds/dds/subscriber/qos/DataReaderQos.hpp>
30
#include <fastdds/dds/subscriber/SampleInfo.hpp>
31
#include <fastdds/dds/subscriber/Subscriber.hpp>
32
#include <fastdds/dds/topic/TypeSupport.hpp>
33

34
using namespace eprosima::fastdds::dds;
35

36
class HelloWorldSubscriber
37
{
38
private:
39

40
    DomainParticipant* participant_;
41

42
    Subscriber* subscriber_;
43

44
    DataReader* reader_;
45

46
    Topic* topic_;
47

48
    TypeSupport type_;
49

50
    class SubListener : public DataReaderListener
51
    {
52
    public:
53

54
        SubListener()
55
            : samples_(0)
56
        {
57
        }
58

59
        ~SubListener() override
60
        {
61
        }
62

63
        void on_subscription_matched(
64
                DataReader*,
65
                const SubscriptionMatchedStatus& info) override
66
        {
67
            if (info.current_count_change == 1)
68
            {
69
                std::cout << "Subscriber matched." << std::endl;
70
            }
71
            else if (info.current_count_change == -1)
72
            {
73
                std::cout << "Subscriber unmatched." << std::endl;
74
            }
75
            else
76
            {
77
                std::cout << info.current_count_change
78
                          << " is not a valid value for SubscriptionMatchedStatus current count change" << std::endl;
79
            }
80
        }
81

82
        void on_data_available(
83
                DataReader* reader) override
84
        {
85
            SampleInfo info;
86
            if (reader->take_next_sample(&hello_, &info) == eprosima::fastdds::dds::RETCODE_OK)
87
            {
88
                if (info.valid_data)
89
                {
90
                    samples_++;
91
                    std::cout << "Message: " << hello_.message() << " with index: " << hello_.index()
92
                              << " RECEIVED." << std::endl;
93
                }
94
            }
95
        }
96

97
        HelloWorld hello_;
98

99
        std::atomic_int samples_;
100

101
    }
102
    listener_;
103

104
public:
105

106
    HelloWorldSubscriber()
107
        : participant_(nullptr)
108
        , subscriber_(nullptr)
109
        , topic_(nullptr)
110
        , reader_(nullptr)
111
        , type_(new HelloWorldPubSubType())
112
    {
113
    }
114

115
    virtual ~HelloWorldSubscriber()
116
    {
117
        if (reader_ != nullptr)
118
        {
119
            subscriber_->delete_datareader(reader_);
120
        }
121
        if (topic_ != nullptr)
122
        {
123
            participant_->delete_topic(topic_);
124
        }
125
        if (subscriber_ != nullptr)
126
        {
127
            participant_->delete_subscriber(subscriber_);
128
        }
129
        DomainParticipantFactory::get_instance()->delete_participant(participant_);
130
    }
131

132
    //!Initialize the subscriber
133
    bool init()
134
    {
135
        DomainParticipantQos participantQos;
136
        participantQos.name("Participant_subscriber");
137
        participant_ = DomainParticipantFactory::get_instance()->create_participant(0, participantQos);
138

139
        if (participant_ == nullptr)
140
        {
141
            return false;
142
        }
143

144
        // Register the Type
145
        type_.register_type(participant_);
146

147
        // Create the subscriptions Topic
148
        topic_ = participant_->create_topic("HelloWorldTopic", "HelloWorld", TOPIC_QOS_DEFAULT);
149

150
        if (topic_ == nullptr)
151
        {
152
            return false;
153
        }
154

155
        // Create the Subscriber
156
        subscriber_ = participant_->create_subscriber(SUBSCRIBER_QOS_DEFAULT, nullptr);
157

158
        if (subscriber_ == nullptr)
159
        {
160
            return false;
161
        }
162

163
        // Create the DataReader
164
        reader_ = subscriber_->create_datareader(topic_, DATAREADER_QOS_DEFAULT, &listener_);
165

166
        if (reader_ == nullptr)
167
        {
168
            return false;
169
        }
170

171
        return true;
172
    }
173

174
    //!Run the Subscriber
175
    void run(
176
            uint32_t samples)
177
    {
178
        while (listener_.samples_ < samples)
179
        {
180
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
181
        }
182
    }
183

184
};
185

186
int main(
187
        int argc,
188
        char** argv)
189
{
190
    std::cout << "Starting subscriber." << std::endl;
191
    uint32_t samples = 10;
192

193
    HelloWorldSubscriber* mysub = new HelloWorldSubscriber();
194
    if (mysub->init())
195
    {
196
        mysub->run(samples);
197
    }
198

199
    delete mysub;
200
    return 0;
201
}

1
add_executable(DDSHelloWorldSubscriber src/HelloWorldSubscriber.cpp ${DDS_HELLOWORLD_SOURCES_CXX})
2
target_link_libraries(DDSHelloWorldSubscriber fastdds fastcdr)

1
cmake ..
2
cmake --build .
3
./DDSHelloWorldSubscriber