Runtime configuration

eCAL provides an interface to access and modify its options before initialization. The corresponding structure reflects the configuration file (ecal.yaml).

Custom types

In order to rule out configuration errors, a custom datatype for IP addresses (IpAddressV4) is introduced.

IpAddressV4: For assigning an IP address simply assign a string with the desired address. Decimal and hexadecimal format is supported. In case the IP address is not valid, the type will throw a std::invalid_argument exception.

The IP address can be used like a normal string object. For example:

eCAL::Types::IpAddressV4 ip_address = "192.168.7.1"; // in hex: "C0.A8.7.1"
std::cout << ip_address << "\n";

Global configuration initialization

To get the configuration, create the object by using the function in the init namespace:

auto custom_config = eCAL::Init::Configuration();

The configuration will be first initialized with the values specified by your ecal.yaml.

It is also possible to specify the .yaml by calling the function

custom_config.InitFromFile("path/to/your/ecal.yaml");

• main.cpp:

  #include <ecal/ecal.h>
  #include <ecal/config.h>
  #include <string>
  #include <stdexcept>
  
  int main(int argc, char** argv)
  {
    // Create a initial configuration object.
    // By default, this object is initialized with a configuration based on an ecal.yaml file.
    auto custom_config = eCAL::Init::Configuration();
  
    // Furthermore you can adapt the configuration by overwriting values from the file, e.g.
    // set the communication mode to network
    custom_config.communication_mode = eCAL::eCommunicationMode::network;
  
    // Increase the send buffer, size increase in 1024 bytes steps
    custom_config.transport_layer.udp.send_buffer = (5242880 + 10 * 1024);
    
    // Set the network addresses in a try/catch block, as wrong configuration 
    // leads to exceptions
    try
    {
      // Set a custom udp multicast group, correct IP address necessary
      custom_config.transport_layer.udp.network.group = std::string("239.0.1.1"); 
    }
    catch (std::invalid_argument& e)
    {
      // Continue with the program, but let the user of the exception and the used network group
      std::cout << "Error while configuring network group: " + std::string(e.what()) << "\n";
      std::cout << "Using default network group: " << custom_config.transport_layer.udp.network.group.Get() << "\n";
    }
  
    // Initialize eCAL with the prepared configuration object
    eCAL::Initialize(custom_config, "UserConfigExample", eCAL::Init::Default);
  
    // ...
    // Use eCAL for your needs
    // ...
  
    while (eCAL::Ok())
    {
      // ...
    }
  
    // Finalize eCAL API
    eCAL::Finalize();
  
    return 0;
  }
  

Individual publisher/subscriber configuration

Like a global configuration to pass at initialization, it is also possible to create indiviual configurations for publisher and subscriber. That means it is possible to, e.g., create two publisher which send on different transport layers:

• main.cpp:

  #include <ecal/ecal.h>
  #include <ecal/msg/string/publisher.h>
  #include <string>
  #include <stdexcept>
  #include <thread>
  #include <chrono>
  
  int main(int argc, char** argv)
  {
    // initialize eCAL API
    eCAL::Initialize("PublisherConfig", eCAL::Init::All);
  
    // create publisher config
    eCAL::Publisher::Configuration pub_config;
  
    // disable all layers except for SHM
    pub_config.layer.shm.enable = true;
    pub_config.layer.udp.enable = false;
    pub_config.layer.tcp.enable = false;
  
    // create publisher 1
    eCAL::string::CPublisher pub_1("topic_1", pub_config);
  
    // enable for the second publisher also tcp
    pub_config.layer.tcp.enable = true;
  
    // create publisher 2
    eCAL::string::CPublisher pub_2("topic_2", pub_config);
  
    int counter {0};
    while (eCAL::Ok())
    {
      std::string msg = "Send message number: " + std::to_string(counter++);
      
      // send message
      pub_1.Send(msg);
      pub_2.Send(msg);
  
      std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
  
    // finalize eCAL API
    eCAL::Finalize();
  }