Hello World (C++)

Hello World example using the CreOS SDK client library.

This example demonstrates how to use the CreOS SDK client library to interact with an Avular robot. Below you can find the full source code, including a CMakeLists.txt file that links the necessary libraries. You can also find a more detailed explanation of the code.

Source code

CMakeLists.txt

# Copyright (C) 2024 Avular Holding B.V. - All Rights Reserved
# You may use this code under the terms of the Avular
# Software End-User License Agreement.
#
# You should have received a copy of the Avular
# Software End-User License Agreement license with
# this file, or download it from: avular.com/eula
 
# Make the creos_client package available
find_package(creos_client REQUIRED)
# Create the hello_world executable target
add_executable(creos_hello_world main.cpp)
# Link the creos::client library to the hello_world executable
target_link_libraries(creos_hello_world PRIVATE creos::client)

main.cpp

// Copyright (C) 2024 Avular Holding B.V. - All Rights Reserved
// You may use this code under the terms of the Avular
// Software End-User License Agreement.
//
// You should have received a copy of the Avular
// Software End-User License Agreement license with
// this file, or download it from: avular.com/eula
//
/*****************************************************************************
 * Simple hello world example for the CreOS client library.
 ****************************************************************************/
#include <creos/client.hpp>
#include <iostream>
 
 
int main() {
    try {
        // Connect to the robot
        creos::Client client{};
 
        // Register a callback function for the GNSS messages
        if (auto sensors_interface = client.sensors()) {
            try {
                sensors_interface->subscribeToGnss([](creos_messages::Gnss message) {
                    std::cout << "Received GNSS message: " << message.augmentation << std::endl;
                });
            } catch (creos::UnsupportedError& e) {
                std::cerr << "The robot does not provide GNSS messages: " << e.what() << std::endl;
            } catch (creos::SubscriptionError& e) {
                std::cerr << "Failed to subscribe to GNSS messages: " << e.what() << std::endl;
            }
        }
 
        if (auto power_management_interface = client.power_management()) {
            try {
                power_management_interface->enterLowPowerMode();
            } catch (creos::Exception& e) {
                std::cerr << "Failed to enter low power mode: " << e.what() << std::endl;
            }
        } else {
            std::cerr << "The robot does not support power management" << std::endl;
        }
 
        if (auto setpoint_control_interface = client.setpoint_control()) {
            // Loop forever
            while (true) {
                // Send a command velocity message
                creos_messages::Twist message;
                message.linear.x = 0.5;
                message.angular.z = 0.5;
                setpoint_control_interface->publishVelocityCommand(message);
                std::cout << "Sent command velocity message" << std::endl;
 
                // Sleep for 1 second
                usleep(1000000);
            }
        } else {
            std::cerr << "The robot does not support setpoint control" << std::endl;
 
            // Sleep until stopped
            while (true) {
                usleep(1000000);
            }
        }
    } catch (creos::ConnectionError& e) {
        std::cerr << "Failed to connect to the robot: " << e.what() << std::endl;
    }
 
    return 0;
}

Explanation

At the top of the main.cpp file, we include the necessary headers for the example. Once the creos::client library is linked to the executable, we can simply include the creos/client.hpp header to start using the library. Our example also includes iostream to print messages to the console.

#include <creos/client.hpp>
#include <iostream>
 

In the main function, we create a creos::Client object. This object is the main entry point for the CreOS SDK. Once created, the object immediately connects to the robot at the specified address. If the client fails to connect, it will throw a creos::ConnectionError.

int main() {
    try {
        // Connect to the robot
        creos::Client client{};

Once the client is connected, we can start interacting with the robot. In this example, we subscribe to the GNSS data source, we call a callable to put the robot in low-power mode, and we publish velocity commands to a data sink.

First, we subscribe to the GNSS data source. This data source is available through the sensors interface, using the subscribeToGnss() function. We first check whether the sensors interface is available, and then subscribe to the GNSS data source. Possible creos::UnsupportedErrors and creos::SubscriptionErrors thrown by the subscription call are printed to the console. We provide a callback function that will be called whenever new data is available. In this example, we simply print the received data to the console.

        // Register a callback function for the GNSS messages
        if (auto sensors_interface = client.sensors()) {
            try {
                sensors_interface->subscribeToGnss([](creos_messages::Gnss message) {
                    std::cout << "Received GNSS message: " << message.augmentation << std::endl;
                });
            } catch (creos::UnsupportedError& e) {
                std::cerr << "The robot does not provide GNSS messages: " << e.what() << std::endl;
            } catch (creos::SubscriptionError& e) {
                std::cerr << "Failed to subscribe to GNSS messages: " << e.what() << std::endl;
            }
        }

Next, we call a callable to put the robot in low-power mode. This callable is available through the power management interface as enterLowPowerMode(). Before we call the callable, we first check whether the power management interface is available. This callable does not return a value, but throws a creos::Exception if the transition to low-power mode fails. Here, we simply print the exception message to the console.

        if (auto power_management_interface = client.power_management()) {
            try {
                power_management_interface->enterLowPowerMode();
            } catch (creos::Exception& e) {
                std::cerr << "Failed to enter low power mode: " << e.what() << std::endl;
            }
        } else {
            std::cerr << "The robot does not support power management" << std::endl;
        }

After the low-power mode request completes (or fails), we check whether the setpoint control interface is available. If it is, we start publishing velocity commands to the robot in an infinite loop. This data sink is available through the setpoint control interface, using the publishVelocityCommand() function. This data sink accepts creos_messages::Twist messages. We first create a message with a linear velocity of 0.5 m/s along the x-axis, as well as an angular velocity of 0.5 rad/s around the z-axis. Then we publish this message to the robot, print a message to the console, and sleep for 1 second.

        if (auto setpoint_control_interface = client.setpoint_control()) {
            // Loop forever
            while (true) {
                // Send a command velocity message
                creos_messages::Twist message;
                message.linear.x = 0.5;
                message.angular.z = 0.5;
                setpoint_control_interface->publishVelocityCommand(message);
                std::cout << "Sent command velocity message" << std::endl;
 
                // Sleep for 1 second
                usleep(1000000);
            }
        } else {
            std::cerr << "The robot does not support setpoint control" << std::endl;
 
            // Sleep until stopped
            while (true) {
                usleep(1000000);
            }
        }