run.cpp

Go to the documentation of this file.

// Copyright (c) 2024 anabrid GmbH
// Contact: https://www.anabrid.com/licensing/
// SPDX-License-Identifier: MIT OR GPL-2.0-or-later
 
#include <proto/main.pb.h>
#include "run/run.h"
 
#include "utils/logging.h"
#include <utility>
#include "protocol/protocol_oob.h"
 
uint64_t time2nanos(pb_Time time) {
  uint64_t prefix;
  switch (time.prefix) {
  case pb_Prefix_NONE:
    prefix = 1'000'000'000;
    break;
  case pb_Prefix_MILLI:
    prefix = 1'000'000;
    break;
  case pb_Prefix_MICRO:
    prefix = 1'000;
    break;
  default:
    prefix = 1;
    break;
  }
 
  return prefix * time.value;
}
 
run::RunConfig run::RunConfig::from_buf(const pb_RunConfig &config) {
  run::RunConfig run;
 
  run.ic_time = time2nanos(config.ic_time);
  run.op_time = time2nanos(config.op_time);
 
  // LOG_MEV("ic_time_ns = %lld, op_time_ns=%lld", run.ic_time, run.op_time);
 
  // default values for the following keys are given
  // in the RunConfig class definition.
 
  if (config.has_halt_on_overload)
    run.halt_on_overload = config.halt_on_overload;
 
  if (config.has_repetitive)
    run.streaming = config.streaming;
 
  if (config.has_repetitive)
    run.repetitive = config.repetitive;
 
  if (config.has_write_run_state_changes)
    run.write_run_state_changes = config.write_run_state_changes;
 
  return run;
}
 
run::CalibrationConfig run::CalibrationConfig::from(const pb_CalibrationConfig &cfg) {
  auto& carrier = carrier::Carrier::get();
  bool is_leader = cfg.has_leader && std::string(cfg.leader.path) == carrier.get_entity_id();
  return {cfg.enabled, is_leader};
}
 
 
run::Run::Run(
  std::string_view id,
  const RunConfig &config,
  std::unique_ptr<RunStateChangeHandler> state_change_handler,
  std::unique_ptr<RunDataHandler> data_handler,
  const daq::DAQConfig &daq_config,
  const mode::SyncConfig &sync_config,
  const CalibrationConfig &calibration_config
)
    : id(id),
      config(config),
      daq_config(daq_config),
      sync_config(sync_config),
      calibration_config(calibration_config),
      state_change_handler(std::move(state_change_handler)),
      data_handler(std::move(data_handler)) {
 
}
 
 
run::Run run::Run::decode(
  const pb_StartRunCommand& start_run_command,
  std::unique_ptr<RunStateChangeHandler> state_change_handler,
  std::unique_ptr<RunDataHandler> data_handler
) {
  auto run_config = RunConfig::from_buf(start_run_command.run_config);
  auto daq_config = daq::DAQConfig::from_buf(start_run_command.daq_config);
  auto sync_config = mode::SyncConfig::from_pb(start_run_command.sync_config);
  auto calibration_config = CalibrationConfig::from(start_run_command.calibration_config);
  return Run{
    start_run_command.run.id,
    run_config,
    std::move(state_change_handler),
    std::move(data_handler),
    daq_config,
    sync_config,
    calibration_config
  };
}
 
 
run::RunStateChange run::Run::to(run::RunState new_state, unsigned int t) {
  auto old = state;
  state = new_state;
  return {t, old, state};
}