vtd_conf.hpp

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <chrono>  // for duration<>
#include <map>     // for map<>
#include <memory>  // for shared_ptr<>
#include <string>  // for string
 
#include <cloe/core.hpp>                            // for Conf, Schema
#include <cloe/utility/osi_message_handler.hpp>     // for SensorMockLevel
#include <cloe/utility/tcp_transceiver_config.hpp>  // for TcpTransceiverConfiguration, ...
 
// Connection / Initialization
#define VTD_DEFAULT_SCP_PORT 48179
#define VTD_PARAMSERVER_PORT 54345
#define VTD_INIT_SYNC_SLEEP_MS 3000
#define VTD_INIT_WAIT_SLEEP_MS 200
 
namespace vtd {
 
enum class LabelConfiguration { Off, Text, Human, Symbol, Unicode };
 
// clang-format off
ENUM_SERIALIZATION(LabelConfiguration, ({
  {LabelConfiguration::Off, "off"},
  {LabelConfiguration::Text, "text"},
  {LabelConfiguration::Human, "human"},
  {LabelConfiguration::Symbol, "symbol"},
  {LabelConfiguration::Unicode, "unicode"},
}))
// clang-format on
 
 
enum class ProtocolConfiguration { Rdb, Osi };
 
// clang-format off
ENUM_SERIALIZATION(ProtocolConfiguration, ({
  {ProtocolConfiguration::Rdb, "rdb"},
  {ProtocolConfiguration::Osi, "osi"},
}))
// clang-format on
 
 
struct VtdSensorConfig : public cloe::Confable {
  std::string xml = "";
 
  ProtocolConfiguration protocol = ProtocolConfiguration::Rdb;
 
  std::shared_ptr<cloe::utility::SensorMockConf> sensor_mock_conf =
      std::make_shared<cloe::utility::SensorMockConf>();
 
 public:
  CONFABLE_SCHEMA(VtdSensorConfig) {
    // clang-format off
    return cloe::Schema{
        {"xml",         cloe::Schema(&xml, "VTD module manager sensor configuration")},
        {"protocol",    cloe::Schema(&protocol, "VTD module manager sensor connection protocol ( rdb | osi )")},
        {"mock_level",  cloe::Schema(sensor_mock_conf.get(), "Sensor data mock level")},
    };
    // clang-format on
  }
};
 
struct VtdComponentConfig : public cloe::Confable {
  std::string from;
 
  std::string type;
 
  bool override = false;
 
 public:
  CONFABLE_SCHEMA(VtdComponentConfig) {
    return cloe::Schema{
        {"from", cloe::Schema(&from, "VTD sensor to retrieve the component data from")},
        {"type", cloe::Schema(&type, "Component type to register")},
        {"override", cloe::Schema(&override, "Override an existing component with the same name")},
    };
  };
};
 
struct VtdVehicleConfig : public cloe::Confable {
  std::map<std::string, VtdSensorConfig> sensors;
 
  std::map<std::string, VtdComponentConfig> components;
 
 public:
  CONFABLE_SCHEMA(VtdVehicleConfig) {
    return cloe::Schema{
        {"sensors", cloe::Schema(&sensors, "sensor definitions")},
        {"components", cloe::Schema(&components, "component definitions")},
    };
  }
};
 
struct VtdConfiguration : public cloe::Confable {
  cloe::utility::TcpTransceiverFullConfiguration paramserver{"localhost", VTD_PARAMSERVER_PORT};
 
  cloe::utility::TcpTransceiverFullConfiguration connection{"localhost", VTD_DEFAULT_SCP_PORT};
 
  cloe::utility::TcpTransceiverConfiguration task_control_params{60,
                                                                 std::chrono::duration<float>{0.5}};
 
  cloe::utility::TcpTransceiverConfiguration rdb_params{60, std::chrono::duration<float>{0.5}};
 
  uint16_t configuration_retry_attempts{10};
 
  uint16_t sensor_initial_port{48196};
 
  std::map<std::string, VtdVehicleConfig> vehicles;
 
  std::string setup = "Cloe.Default";
 
  std::string scenario = "";
  std::string project = "";
 
  bool image_generator = true;
 
  bool camera_third_person = true;
 
  std::string camera_focus_on = "";
 
  LabelConfiguration label_vehicle = LabelConfiguration::Text;
 
  std::string dat_file = "";
 
  std::map<std::string, std::string> scp_actions{};
 
 public:
  CONFABLE_SCHEMA(VtdConfiguration) {
    // clang-format off
    using namespace cloe;  // NOLINT(build/namespaces)
    return Schema{
        {"connection",          Schema(&connection, "scp connection parameters")},
        {"paramserver",         Schema(&paramserver, "parameter sever connection parameters")},
        {"task_control_params", Schema(&task_control_params, "task control connection parameters")},
        {"rdb_params",          Schema(&rdb_params, "rdb connection parameters")},
        {"sensor_initial_port", Schema(&sensor_initial_port, "initial port for sensor communication")},
        {"vehicles",            Schema(&vehicles, "vehicle configuration like sensors and component mapping")},
        {"configuration_retry_attempts", Schema(&configuration_retry_attempts, "attempts to retry connection on broken pipe")},
        {"setup",               Schema(&setup, "indicate which setup you are using")},
        {"image_generator",     Schema(&image_generator, "switch whether VTD should use image generator")},
        {"scenario",            Schema(&scenario, "VTD scenario to use (project must already be loaded)")},
        {"project",             Schema(&project, "indicate which project to find the scenario in (informative)")},
        {"label_vehicle",       Schema(&label_vehicle, "how to label vehicle modes in VTD [off,text,human,symbol,unicode]")},
        {"dat_file",            Schema(&dat_file, "filepath to write VTD data output to")},
        {"scp_actions",         Schema(&scp_actions, "predefined SCP actions for use by action trigger")},
        {"camera",              Schema({
                                      {"third_person",Schema(&camera_third_person, "whether to use third person camera")},
                                      {"focus_on",    Schema(&camera_focus_on, "player to focus on")},
                                })},
    };
    // clang-format on
  }
};
 
}  // namespace vtd