Refactor CMakeLists.txt. (#28)

* Addapt to Dashing Diademata rosidl generation.

* Use new Micro XRCE-DDS agent library API.

* main.cpp update (#22)

* Update main.cpp according to the new version of Micro-XRCE-DDS-Agent.

* Apply suggestions from code review

Co-Authored-By: Borja Outerelo <borjaouterelo@gmail.com>

Co-authored-by: Borja Outerelo <borjaouterelo@gmail.com>

Co-authored-by: Julián Bermúdez Ortega <julianbermudez@eprosima.com>

micro_ros_agent/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright 2018 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+# Copyright 2018-present Proyectos y Sistemas de Mantenimiento SL (eProsima).
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,161 +12,159 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
-# Set CMake version 
 cmake_minimum_required(VERSION 3.5)
 
-# Set proyect name
+option(UROSAGENT_GENERATE_PROFILE
-project(micro_ros_agent)
+  "Generates agent.refs according to the .msgs provided in the .repos" OFF
-
+  )
-
 set(CMAKE_C_CLANG_TIDY clang-tidy -checks=*)
 
-# Default to C++14
+project(micro_ros_agent LANGUAGES CXX)
-if(NOT CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 14)
-endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  add_compile_options(-Wall -Wextra -Wpedantic)
-endif()
-
-
-# Find packages depencences
-find_package(rosidl_cmake REQUIRED)
 find_package(ament_cmake REQUIRED)
-find_package(fastcdr REQUIRED CONFIG)
+find_package(microxrcedds_agent REQUIRED)
-find_package(fastrtps REQUIRED CONFIG)
-find_package(microxrcedds_agent REQUIRED CONFIG)
-find_package(ament_cmake_python REQUIRED)
 
+add_executable(${PROJECT_NAME} src/main.cpp)
+
+target_link_libraries(${PROJECT_NAME}
+  PRIVATE
+    microxrcedds_agent
+    $<$<BOOL:$<PLATFORM_ID:Linux>>:rt>
+    $<$<BOOL:$<PLATFORM_ID:Linux>>:dl>
+  )
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+  CXX_STANDARD
+    11
+  CXX_STANDARD_REQUIRED
+    YES
+  )
+
+target_compile_options(${PROJECT_NAME}
+  PRIVATE
+    $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wall>
+    $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wextra>
+    $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wpedantic>
+  )
 
-# Export dependencies to downstream packages
-ament_export_dependencies(fastcdr)
-ament_export_dependencies(fastrtps)
 ament_export_dependencies(microxrcedds_agent)
 
+ament_package()
 
-# Set variables
+install(
-set(_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}/python")
+  TARGETS
+    ${PROJECT_NAME}
+  DESTINATION
+    lib/${PROJECT_NAME}
+  )
 
-set(_XML_INTERFACE_GEN_BIN "${_OUTPUT_PATH}/bin/Xml_interface_gen.py")
+if(UROSAGENT_GENERATE_PROFILE)
-normalize_path(_XML_INTERFACE_GEN_BIN "${_XML_INTERFACE_GEN_BIN}")
+  set(_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}/python")
 
-set(_XML_DEFAULT_READ_BIN "${_OUTPUT_PATH}/bin/Xml_read_default_profiles.py")
+  set(_XML_INTERFACE_GEN_BIN "${_OUTPUT_PATH}/bin/Xml_interface_gen.py")
-normalize_path(_XML_DEFAULT_READ_BIN "${_XML_DEFAULT_READ_BIN}")
+  normalize_path(_XML_INTERFACE_GEN_BIN "${_XML_INTERFACE_GEN_BIN}")
 
-set(_PYTHON_PKG_TOOL ${PROJECT_NAME})
+  set(_XML_DEFAULT_READ_BIN "${_OUTPUT_PATH}/bin/Xml_read_default_profiles.py")
+  normalize_path(_XML_DEFAULT_READ_BIN "${_XML_DEFAULT_READ_BIN}")
 
-set(_RESOURCE_DIR "${_OUTPUT_PATH}/resource")
+  set(_PYTHON_PKG_TOOL ${PROJECT_NAME})
-normalize_path(_RESOURCE_DIR "${_RESOURCE_DIR}")
 
+  set(_RESOURCE_DIR "${_OUTPUT_PATH}/resource")
+  normalize_path(_RESOURCE_DIR "${_RESOURCE_DIR}")
 
-set(_DEFAULT_FASTRTPS_PROFILES_PATH "${_OUTPUT_PATH}/gen/DEFAULT_FASTRTPS_PROFILES.xml")
+  set(_DEFAULT_FASTRTPS_PROFILES_PATH "${_OUTPUT_PATH}/gen/DEFAULT_FASTRTPS_PROFILES.xml")
-normalize_path(_DEFAULT_FASTRTPS_PROFILES_PATH "${_DEFAULT_FASTRTPS_PROFILES_PATH}")
+  normalize_path(_DEFAULT_FASTRTPS_PROFILES_PATH "${_DEFAULT_FASTRTPS_PROFILES_PATH}")
 
+  get_filename_component(_COLCON_CALL_DIR "${PROJECT_BINARY_DIR}" DIRECTORY)
+  get_filename_component(_COLCON_CALL_DIR "${_COLCON_CALL_DIR}" DIRECTORY)
 
-# Get colcon call dir
+  set(_PYTHON_SCRIPT_HEAD
-get_filename_component(_COLCON_CALL_DIR "${PROJECT_BINARY_DIR}" DIRECTORY)
+    "
-get_filename_component(_COLCON_CALL_DIR "${_COLCON_CALL_DIR}" DIRECTORY)
+    import os\n
+    import sys\n
+    sys.path.append('${_OUTPUT_PATH}')\n
+    from ${_PYTHON_PKG_TOOL} import *\n
+    "
+    )
 
+  file(
+    COPY
+      "bin" "${_PYTHON_PKG_TOOL}" "resource"
+    DESTINATION
+      "${CMAKE_CURRENT_BINARY_DIR}/python"
+    )
 
-# Generate python header
+  execute_process(
-set(
-_PYTHON_SCRIPT_HEAD
-"
-import os\n
-import sys\n
-sys.path.append('${_OUTPUT_PATH}')\n
-from ${_PYTHON_PKG_TOOL} import *\n
-"
-)
-
-
-# Copy pyton files  
-file(COPY "bin" "${_PYTHON_PKG_TOOL}" "resource" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/python")
-
-
-# Extract all packages and manifiest paths
-execute_process(
     COMMAND
       "${PYTHON_EXECUTABLE}"
       "-c"
       "${_PYTHON_SCRIPT_HEAD}for package in GetInterfacePackages(GetPackageList('${_COLCON_CALL_DIR}')): print ('%s,%s' % (package, GetPackageName(package)))"
-  OUTPUT_VARIABLE _packages
+    OUTPUT_VARIABLE
-  RESULT_VARIABLE _result
+      _packages
+    RESULT_VARIABLE
+      _result
     OUTPUT_STRIP_TRAILING_WHITESPACE
-)
+    )
-if(NOT _result EQUAL 0)
-  message(FATAL_ERROR "Error finding xml packages")
-endif()
 
+  if(NOT _result EQUAL 0)
+    message(FATAL_ERROR "Error finding XML packages")
+  endif()
 
-# Convert output to list
+  string(REPLACE "\n" ";" _packages ${_packages})
-string(REPLACE "\n" ";" _packages ${_packages})
 
+  set(ALL_MSG_FILES "")
+  foreach(package ${_packages})
 
-# Extract all msg from each package (stored in ${package}_MSG_FILES)
-set(ALL_MSG_FILES "")
-foreach(package ${_packages})
-  
-  # Extract info
     string(REPLACE "," ";" package ${package})
     list(GET package 0 package_file)
     list(GET package 1 package)
 
-
-  # Get all msg files
     execute_process(
       COMMAND
         "${PYTHON_EXECUTABLE}"
         "-c"
         "${_PYTHON_SCRIPT_HEAD}for msg in GetInterfacePackageMsgs('${package_file}'): print ('%s' % msg)"
-  OUTPUT_VARIABLE ${package}_MSG_FILES
+      OUTPUT_VARIABLE
-  RESULT_VARIABLE _result
+        ${package}_MSG_FILES
+      RESULT_VARIABLE
+        _result
       OUTPUT_STRIP_TRAILING_WHITESPACE
       )
+
     if(NOT _result EQUAL 0)
       message(FATAL_ERROR "Error finding .msg files")
     endif()
 
-  # Skip if there are no msgs to create
     if(${package}_MSG_FILES STREQUAL "")
       continue()
     endif()
 
-  # Generate list
     string(REPLACE "\n" ";" ${package}_MSG_FILES ${${package}_MSG_FILES})
 
-endforeach()
+  endforeach()
 
-
+  execute_process(
-# Append defaul xml profiles
+    COMMAND 
-execute_process(
+      "${PYTHON_EXECUTABLE}" "${_XML_DEFAULT_READ_BIN}" "--default-xml-path" "${_RESOURCE_DIR}"
-  COMMAND "${PYTHON_EXECUTABLE}" "${_XML_DEFAULT_READ_BIN}" "--default-xml-path" "${_RESOURCE_DIR}"
+    OUTPUT_VARIABLE
-  OUTPUT_VARIABLE _XmlDoc
+      _XmlDoc
-  RESULT_VARIABLE _result
+    RESULT_VARIABLE
+      _result
     )
-if(NOT _result EQUAL 0)
+
+  if(NOT _result EQUAL 0)
     message(FATAL_ERROR "Error in typesuppor generation") 
-endif()
+  endif()
 
-
+  foreach(package ${_packages})
-# Create one xml for each message
-foreach(package ${_packages})
     string(REPLACE "," ";" package ${package})
     list(GET package 0 package_file)
     list(GET package 1 package)
 
-
-  # Skip this generation if there are no msgs to process
     if(${package}_MSG_FILES STREQUAL "")
       continue()
     endif()
 
-
-
-  # generate script argument file 
     set(generator_arguments_file "${_OUTPUT_PATH}/XML_ArgFiles/${package}_Args.json")
     rosidl_write_generator_arguments(
       "${generator_arguments_file}"
@@ -179,79 +177,24 @@ foreach(package ${_packages})
       ADDITIONAL_FILES ""
     )
 
-
-   # execute python script
      execute_process(
-    COMMAND "${PYTHON_EXECUTABLE}" "${_XML_INTERFACE_GEN_BIN}" --generator-arguments-file "${generator_arguments_file}"
+      COMMAND
-    OUTPUT_VARIABLE _XmlGen
+        "${PYTHON_EXECUTABLE}" "${_XML_INTERFACE_GEN_BIN}" --generator-arguments-file "${generator_arguments_file}"
-    RESULT_VARIABLE _result
+      OUTPUT_VARIABLE
+        _XmlGen
+      RESULT_VARIABLE
+        _result
       )
+
     if(NOT _result EQUAL 0)
       message(FATAL_ERROR "Error in typesuppor generation") 
     endif()
 
-
-  # Strore xml
     set(_XmlDoc "${_XmlDoc}${_XmlGen}")
 
-endforeach()
+  endforeach()
 
+  set (_XmlDoc "<profiles>\n${_XmlDoc}</profiles>\n")
 
-# Close profile 
+  file(WRITE "${_DEFAULT_FASTRTPS_PROFILES_PATH}" "${_XmlDoc}")
-set (_XmlDoc "<profiles>\n${_XmlDoc}</profiles>\n")
-
-
-# Save 
-file(WRITE "${_DEFAULT_FASTRTPS_PROFILES_PATH}" "${_XmlDoc}")
-
-
-# Only compile uROS agent if rclcpp is found
-find_package(rclcpp QUIET)
-if (rclcpp_FOUND)
-  find_package(microxrcedds_agent REQUIRED)
-
-  add_executable(${PROJECT_NAME} src/main.cpp)
-  ament_target_dependencies(
-    ${PROJECT_NAME} 
-    rclcpp
-    microxrcedds_agent
-  )
-
-  # TODO(Javier) Temporal until thread error is solver
-  target_link_libraries(
-    ${PROJECT_NAME}
-    microxrcedds_agent
-  )
-  
-else()
-  message("uROS agent node will be not build")
 endif()
-
-
-
-
-# Install the package.xml file, and generate code for ``find_package`` so that other packages can get information about this package.
-ament_package()
-
-
-# Only install if uROS_Agent is comiled
-if (rclcpp_FOUND)
-  install(TARGETS
-    ${PROJECT_NAME}
-    DESTINATION lib/${PROJECT_NAME}
-  )
-endif()
-
-
-#Install
-install(
-  FILES "${_DEFAULT_FASTRTPS_PROFILES_PATH}"
-  DESTINATION lib/${PROJECT_NAME}
-)
-
-
-# Install package
-#install(
-#  DIRECTORY cmake resource
-#  DESTINATION share/${PROJECT_NAME}
-#)

micro_ros_agent/bin/Xml_interface_gen.py

@@ -7,7 +7,7 @@ import sys
 sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)),'..'))
 
 from rosidl_cmake import read_generator_arguments
-from rosidl_parser import UnknownMessageType
+from rosidl_adapter.parser import UnknownMessageType
 from micro_ros_agent import generate_XML
 
 

micro_ros_agent/micro_ros_agent/__init__.py

@@ -18,12 +18,12 @@ import xml.etree.ElementTree
 
 from rosidl_cmake import convert_camel_case_to_lower_case_underscore
 from rosidl_cmake import expand_template
-from rosidl_cmake import extract_message_types
 from rosidl_cmake import get_newest_modification_time
-from rosidl_parser import parse_message_file
+from rosidl_adapter.parser import parse_message_file
-from rosidl_parser import parse_service_file
+from rosidl_adapter.parser import parse_service_file
-from rosidl_parser import validate_field_types
+from rosidl_adapter.parser import validate_field_types
 
+from rosidl_cmake import generate_files
 
 def GetPackage(Dir):
     

micro_ros_agent/package.xml

@@ -10,22 +10,11 @@
   <buildtool_depend>ament_cmake</buildtool_depend>
   <buildtool_export_depend>ament_cmake</buildtool_export_depend>
 
-  <exec_depend>rosidl_parser</exec_depend>
-
-  <depend>fastcdr</depend>
-  <depend>fastrtps</depend>
   <depend>microxrcedds_agent</depend>
-  <depend>rosidl_cmake</depend>
-  
-  <build_depend>rclcpp</build_depend>
-
-  <exec_depend>rclcpp</exec_depend>
   
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>ament_lint_common</test_depend>
 
-  <group_depend>rosidl_interface_packages</group_depend>
-
   <export>
     <build_type>ament_cmake</build_type>
   </export>

micro_ros_agent/src/main.cpp

@@ -1,5 +1,4 @@
-
+// Copyright 2017-present Proyectos y Sistemas de Mantenimiento SL (eProsima).
-// Copyright 2018 Proyectos y Sistemas de Mantenimiento SL (eProsima).
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,225 +12,76 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifdef _WIN32
+#include <uxr/agent/utils/CLI.hpp>
-#include <uxr/agent/transport/udp/UDPServerWindows.hpp>
+#include <csignal>
-#include <uxr/agent/transport/tcp/TCPServerWindows.hpp>
-
-#elif __unix__
-#include <unistd.h>
-#include <libgen.h>
-
-#include <uxr/agent/transport/serial/SerialServerLinux.hpp>
-#include <uxr/agent/transport/udp/UDPServerLinux.hpp>
-#include <uxr/agent/transport/tcp/TCPServerLinux.hpp>
-#include <termios.h>
-#include <fcntl.h>
-#endif
-
-#include <iterator>
-#include <iostream>
-#include <string>
-#include <limits>
-#include "rclcpp/rclcpp.hpp"
-
-void showHelp()
-{
-    std::cout << "Usage: program <command>" << std::endl;
-    std::cout << "List of commands:" << std::endl;
-#ifdef _WIN32
-    std::cout << "    udp <local_port>" << std::endl;
-    std::cout << "    tcp <local_port>" << std::endl;
-#else
-    std::cout << "    serial <device_name>" << std::endl;
-    std::cout << "    pseudo-serial" << std::endl;
-    std::cout << "    udp <local_port> [<discovery_port>]" << std::endl;
-    std::cout << "    tcp <local_port> [<discovery_port>]" << std::endl;
-#endif
-}
-
-void initializationError()
-{
-    std::cout << "Error: Invalid arguments." << std::endl;
-    showHelp();
-    std::exit(EXIT_FAILURE);
-}
-
-uint16_t parsePort(const std::string& str_port)
-{
-    uint16_t valid_port = 0;
-    try
-    {
-        int port = std::stoi(str_port);
-        if(port > (std::numeric_limits<uint16_t>::max)())
-        {
-            std::cout << "Error: port number '" << port << "out of range." << std::endl;
-            initializationError();
-        }
-        valid_port = uint16_t(port);
-    }
-    catch (const std::invalid_argument& )
-    {
-        initializationError();
-    }
-    return valid_port;
-}
 
 int main(int argc, char** argv)
 {
-    eprosima::uxr::Server* server = nullptr;
+#ifndef _WIN32
-    std::vector<std::string> cl(0);
+    sigset_t signals;
-
+    sigemptyset(&signals);
-    if (1 == argc)
+    if(sigaddset(&signals, SIGINT) && sigaddset(&signals, SIGTERM))
     {
-        showHelp();
+        std::cerr << "Wrong signalset" << std::endl;
-        std::cout << std::endl;
+        std::exit(EXIT_FAILURE);
-        std::cout << "Enter command: ";
-
-        std::string raw_cl;
-        std::getline(std::cin, raw_cl);
-        std::istringstream iss(raw_cl);
-        cl.insert(cl.begin(), std::istream_iterator<std::string>(iss), std::istream_iterator<std::string>());
-        std::cout << raw_cl << std::endl;
     }
-    else
+    sigprocmask( SIG_BLOCK, &signals, nullptr );
-    {
+#endif
+
+
+    /* CLI application. */
+    CLI::App app("micro-ROS Agent");
+    app.require_subcommand(1, 1);
+    app.get_formatter()->column_width(42);
+
+    /* CLI subcommands. */
+    eprosima::uxr::cli::UDPv4Subcommand udpv4_subcommand(app);
+    eprosima::uxr::cli::UDPv6Subcommand udpv6_subcommand(app);
+    eprosima::uxr::cli::TCPv4Subcommand tcpv4_subcommand(app);
+    eprosima::uxr::cli::TCPv6Subcommand tcpv6_subcommand(app);
+#ifndef _WIN32
+    eprosima::uxr::cli::TermiosSubcommand serial_subcommand(app);
+    eprosima::uxr::cli::PseudoTerminalSubcommand pseudo_serial_subcommand(app);
+#endif
+    eprosima::uxr::cli::ExitSubcommand exit_subcommand(app);
+
+    /* CLI parse. */
+    std::string cli_input{};
     for (int i = 1; i < argc; ++i)
     {
-            cl.push_back(argv[i]);
+        cli_input.append(argv[i]);
+        cli_input.append(" ");
+    }
+
+    while (true)
+    {
+        try
+        {
+            app.parse(cli_input);
+            break;
+        }
+        catch (const CLI::ParseError& e)
+        {
+            app.exit(e);
+            std::cin.clear();
+            std::cout << std::endl;
+            std::cout << "Enter command: ";
+            std::getline(std::cin, cli_input);
         }
     }
 
-    if((1 == cl.size()) && (("-h" == cl[0]) || ("--help" == cl[0])))
-    {
-        showHelp();
-    }
-    else if((2 <= cl.size()) && ("udp" == cl[0]))
-    {
-        std::cout << "UDP agent initialization... ";
-        uint16_t port = parsePort(cl[1]);
 #ifdef  _WIN32
-        server = new eprosima::uxr::UDPServer(port);
+    /* Waiting until exit. */
-#else
-        server = (3 == cl.size()) //discovery port
-                 ? new eprosima::uxr::UDPServer(port, parsePort(cl[2]))
-                 : new eprosima::uxr::UDPServer(port);
-#endif
-    }
-    else if((2 <= cl.size()) && ("tcp" == cl[0]))
-    {
-        std::cout << "TCP agent initialization... ";
-        uint16_t port = parsePort(cl[1]);
-#ifdef _WIN32
-        server = new eprosima::uxr::TCPServer(port);
-#else
-        server = (3 == cl.size()) //discovery port
-                 ? new eprosima::uxr::TCPServer(port, parsePort(cl[2]))
-                 : new eprosima::uxr::TCPServer(port);
-#endif
-    }
-#ifndef _WIN32
-    else if((2 == cl.size()) && ("serial" == cl[0]))
-    {
-        std::cout << "Serial agent initialization... ";
-
-        /* Open serial device. */
-        int fd = open(cl[1].c_str(), O_RDWR | O_NOCTTY);
-        if (0 < fd)
-        {
-            struct termios tty_config;
-            memset(&tty_config, 0, sizeof(tty_config));
-            if (0 == tcgetattr(fd, &tty_config))
-            {
-                /* Setting CONTROL OPTIONS. */
-                tty_config.c_cflag |= CREAD;    // Enable read.
-                tty_config.c_cflag |= CLOCAL;   // Set local mode.
-                tty_config.c_cflag &= ~PARENB;  // Disable parity.
-                tty_config.c_cflag &= ~CSTOPB;  // Set one stop bit.
-                tty_config.c_cflag &= ~CSIZE;   // Mask the character size bits.
-                tty_config.c_cflag |= CS8;      // Set 8 data bits.
-                tty_config.c_cflag &= ~CRTSCTS; // Disable hardware flow control.
-
-                /* Setting LOCAL OPTIONS. */
-                tty_config.c_lflag &= ~ICANON;  // Set non-canonical input.
-                tty_config.c_lflag &= ~ECHO;    // Disable echoing of input characters.
-                tty_config.c_lflag &= ~ECHOE;   // Disable echoing the erase character.
-                tty_config.c_lflag &= ~ISIG;    // Disable SIGINTR, SIGSUSP, SIGDSUSP and SIGQUIT signals.
-
-                /* Setting INPUT OPTIONS. */
-                tty_config.c_iflag &= ~IXON;    // Disable output software flow control.
-                tty_config.c_iflag &= ~IXOFF;   // Disable input software flow control.
-                tty_config.c_iflag &= ~INPCK;   // Disable parity check.
-                tty_config.c_iflag &= ~ISTRIP;  // Disable strip parity bits.
-                tty_config.c_iflag &= ~IGNBRK;  // No ignore break condition.
-                tty_config.c_iflag &= ~IGNCR;   // No ignore carrier return.
-                tty_config.c_iflag &= ~INLCR;   // No map NL to CR.
-                tty_config.c_iflag &= ~ICRNL;   // No map CR to NL.
-
-                /* Setting OUTPUT OPTIONS. */
-                tty_config.c_oflag &= ~OPOST;   // Set raw output.
-
-                /* Setting OUTPUT CHARACTERS. */
-                tty_config.c_cc[VMIN] = 10;
-                tty_config.c_cc[VTIME] = 1;
-
-                /* Setting BAUD RATE. */
-                cfsetispeed(&tty_config, B115200);
-                cfsetospeed(&tty_config, B115200);
-
-                if (0 == tcsetattr(fd, TCSANOW, &tty_config))
-                {
-                    server = new eprosima::uxr::SerialServer(fd, 0);
-                }
-            }
-        }
-    }
-    else if ((1 == cl.size()) && ("pseudo-serial" == cl[0]))
-    {
-        std::cout << "Pseudo-Serial initialization... ";
-
-        /* Open pseudo-terminal. */
-        char* dev = NULL;
-        int fd = posix_openpt(O_RDWR | O_NOCTTY);
-        if (-1 != fd)
-        {
-            if (grantpt(fd) == 0 && unlockpt(fd) == 0 && (dev = ptsname(fd)))
-            {
-                struct termios attr;
-                tcgetattr(fd, &attr);
-                cfmakeraw(&attr);
-                tcflush(fd, TCIOFLUSH);
-                tcsetattr(fd, TCSANOW, &attr);
-                std::cout << "Device: " << dev << std::endl;
-            }
-        }
-        server = new eprosima::uxr::SerialServer(fd, 0x00);
-    }
-#endif
-    else
-    {
-        initializationError();
-    }
-
-    if (nullptr != server)
-    {
-        /* Launch server. */
-        if (server->run())
-        {
-            std::cout << "OK" << std::endl;
     std::cin.clear();
     char exit_flag = 0;
     while ('q' != exit_flag)
     {
-                std::cout << "Enter 'q' for exit" << std::endl;
         std::cin >> exit_flag;
     }
-            server->stop();
+#else
-        }
+    /* Wait for SIGTERM/SIGINT instead, as reading from stdin may be redirected to /dev/null. */
-        else
+    int n_signal = 0;
-        {
+    sigwait(&signals, &n_signal);
-            std::cout << "ERROR" << std::endl;
+#endif
-        }
-    }
-
     return 0;
 }