Some examples

Table of Contents

• Simple port example
  • simple_sender
  • simple_receiver
  • Running the example
• Buffered port example

There are many code examples available in the example/ subdirectory of YARP.

If you're reading this online, click on the examples link to see many of them.

Simple port example

Here we work through an example of using YARP communication between programs. We will have two programs, a sender and receiver, simple_sender and simple_receiver

simple_sender

Here's simple_sender/simple_sender.cpp:

#include <yarp/os/Bottle.h>
#include <yarp/os/Network.h>
#include <yarp/os/Port.h>
#include <yarp/os/Time.h>
 
#include <cstdio>
 
using yarp::os::Bottle;
using yarp::os::Network;
using yarp::os::Port;
 
constexpr double loop_delay = 1.0;
constexpr size_t top = 100;
 
int main(int argc, char* argv[])
{
    YARP_UNUSED(argc);
    YARP_UNUSED(argv);
 
    Network yarp;
    Port output;
    output.open("/sender");
    for (size_t i = 1; i <= top; i++) {
        // prepare a message
        Bottle bot;
        bot.addString("testing");
        bot.addInt32(i);
        bot.addString("of");
        bot.addInt32(top);
        // send the message
        output.write(bot);
        printf("Sent message: %s\n", bot.toString().c_str());
        // wait a while
        yarp::os::Time::delay(loop_delay);
    }
    output.close();
    return 0;
}

simple_sender/CMakeLists.txt

if(NOT DEFINED CMAKE_MINIMUM_REQUIRED_VERSION)
  cmake_minimum_required(VERSION 3.12)
  project(simple_sender)
  find_package(YARP REQUIRED COMPONENTS os)
endif()
 
add_executable(simple_sender)
target_sources(simple_sender PRIVATE simple_sender.cpp)
target_link_libraries(simple_sender PRIVATE YARP::YARP_os
                                            YARP::YARP_init)

simple_receiver

Here's simple_receiver/simple_receiver.cpp:

#include <yarp/os/Bottle.h>
#include <yarp/os/Network.h>
#include <yarp/os/Port.h>
 
#include <cstdio>
 
using yarp::os::Bottle;
using yarp::os::Network;
using yarp::os::Port;
 
int main(int argc, char* argv[])
{
    YARP_UNUSED(argc);
    YARP_UNUSED(argv);
 
    Network yarp;
    Bottle bot;
    Port input;
    input.open("/receiver");
    // usually, we create connections externally, but just for this example...
    Network::connect("/sender", "/receiver");
    input.read(bot);
    printf("Got message: %s\n", bot.toString().c_str());
    input.close();
    return 0;
}

simple_receiver/CMakeLists.txt

if(NOT DEFINED CMAKE_MINIMUM_REQUIRED_VERSION)
  cmake_minimum_required(VERSION 3.12)
  project(simple_receiver)
  find_package(YARP REQUIRED COMPONENTS os)
endif()
 
add_executable(simple_receiver)
target_sources(simple_receiver PRIVATE simple_receiver.cpp)
target_link_libraries(simple_receiver PRIVATE YARP::YARP_os
                                              YARP::YARP_init)

Running the example

After compiling, on three separate consoles, do:

yarp server               # this starts the YARP name server
./simple_sender           # this runs the sender
./simple_receiver         # this runs the receiver

Or in windows that would be:

yarp.exe server           # this starts the YARP name server
simple_sender.exe         # this runs the sender
simple_receiver.exe       # this runs the receiver

You'll need to be in the right directories to run the executables, or have them in your path.

Here's what you should see on the terminal for the sender:

Sent message: testing 1 of 100
Sent message: testing 2 of 100
Sent message: testing 3 of 100
Sent message: testing 4 of 100
...

Here's what you should see on the terminal for the receiver:

yarp: Receiving input from /sender to /receiver using tcp
Got message: testing 7 of 100
yarp: Removing input from /sender to /receiver

You can run the receiver many times to connect and reconnect.

Buffered port example

#include <yarp/os/Bottle.h>
#include <yarp/os/BufferedPort.h>
#include <yarp/os/Network.h>
 
#include <cstdio>
 
using yarp::os::Bottle;
using yarp::os::BufferedPort;
using yarp::os::Network;
 
int main(int argc, char* argv[])
{
    YARP_UNUSED(argc);
    YARP_UNUSED(argv);
 
    // Initialize YARP - some OSes need network and time service initialization
    Network yarp;
 
    // Work locally - don't rely on name server (just for this example).
    // If you have a YARP name server running, you can remove this line.
    Network::setLocalMode(true);
 
    // Create two ports that we'll be using to transmit "Bottle" objects.
    // The ports are buffered, so that sending and receiving can happen
    // in the background.
    BufferedPort<Bottle> in;
    BufferedPort<Bottle> out;
 
    // we will want to read every message, with no skipping of "old" messages
    // when new ones come in
    in.setStrict();
 
    // Name the ports
    in.open("/in");
    out.open("/out");
 
    // Connect the ports so that anything written from /out arrives to /in
    Network::connect("/out", "/in");
 
    // Send one "Bottle" object.  The port is responsible for creating
    // and reusing/destroying that object, since it needs to be sure
    // it exists until communication to all recipients (just one in
    // this case) is complete.
    Bottle& outBot1 = out.prepare();   // Get the object
    outBot1.fromString("hello world"); // Set it up the way we want
    printf("Writing bottle 1 (%s)\n", outBot1.toString().c_str());
    out.write(); // Now send it on its way
 
    // Send another "Bottle" object
    Bottle& outBot2 = out.prepare();
    outBot2.fromString("2 3 5 7 11");
    printf("Writing bottle 2 (%s)\n", outBot2.toString().c_str());
    out.writeStrict(); // writeStrict() will wait for any
                       // previous communication to finish;
                       // write() would skip sending if
                       // there was something being sent
 
    // Read the first object
    Bottle* inBot1 = in.read();
    printf("Bottle 1 is: %s\n", inBot1->toString().c_str());
 
    // Read the second object
    Bottle* inBot2 = in.read();
    printf("Bottle 2 is: %s\n", inBot2->toString().c_str());
 
    return 0;
}

if(NOT DEFINED CMAKE_MINIMUM_REQUIRED_VERSION)
  cmake_minimum_required(VERSION 3.12)
  project(buffered_port)
  find_package(YARP REQUIRED COMPONENTS os)
endif()
 
add_executable(buffered_port)
target_sources(buffered_port PRIVATE buffered_port.cpp)
target_link_libraries(buffered_port PRIVATE YARP::YARP_os
                                            YARP::YARP_init)