run_manager.cpp

Go to the documentation of this file.

#include "run/run_manager.h"
#include "mode/counters.h"
 
#include <Arduino.h>
#include <cmath>
#include <cstdlib>
 
#include <daq/daq.h>
#include <utils/logging.h>
 
// This is an interim hacky solution to introduce another kind of RunDataHandler
#include "QNEthernet.h"
#include "net/ethernet.h"
 
#include <mode/mode.h>
#include <mode/teensy/mode.h>
#include <protocol/protocol_oob.h>
#include <run/run.h>
 
namespace run {
 
using Result = ::Result<std::monostate, std::string>;
 
FASTRUN run::Result run_flexio_raw(carrier::Carrier &carrier_, Run &run) {
  auto state_change_handler = run.state_change_handler.get();
  auto run_data_handler = run.data_handler.get();
 
  run.daq_config.num_channels = carrier_.get_active_adc_channel_range();
 
  if (!run_data_handler) {
    return Result::err("Can not start run without RunDataHandler.");
  }
 
  mode::FlexIOControl::reset();
  auto on_overload = run.config.halt_on_overload
    ? mode::OnOverload::HALT
    : mode::OnOverload::IGNORE;
 
  if (!mode::FlexIOControl::init(run.config.ic_time, run.config.op_time,
                                 on_overload,
                                 mode::OnExtHalt::IGNORE, run.sync_config)) {
    return Result::err("Error while initializing state machine");
  }
 
  // Start a data stream if data acquisition is active
  auto data_stream = daq::stream::get(run, run_data_handler, false);
  if (run.daq_config) {
    auto success = data_stream.start();
    if (!success) {
      return Result::err_fmt("Error starting data stream: %s", success.msg.c_str());
    }
  }
 
  // Start run immediately or wait for SYNC signal
  state_change_handler->handle(run.to(RunState::TAKE_OFF, millis()), run);
  if (!run.sync_config.enabled) {
    mode::FlexIOControl::force_start();
  }else {
    if (run.sync_config.is_master) {
      // wait for others beeing ready
      delay(100);
      // Generate the SYNC signal ourselves
      // This will be received by us and will be broadcast to other carriers
      if (!carrier_.ctrl_block->send_sync(run.sync_config.id)) {
        return Result::err("Error sending SYNC as master.");
      }
    }
 
    elapsedMillis since_takeoff;
    while (mode::FlexIOControl::is_idle()) {
      if (since_takeoff > 5000) {
        return Result::err("Timeout while waiting for SYNC signal.");
      }
    }
  }
 
  Result result = Result::ok({});
  while (!mode::FlexIOControl::is_done()) {
    result = data_stream.process();
    if (result.is_err()) break;
  }
  mode::FlexIOControl::to_end();
 
  // When a data sample must be gathered very close to the end of OP duration,
  // it takes a few microseconds for it to end up in the DMA buffer.
  // This is hard to check for, since the DMA active flag is only set once the DMA
  // is triggered by the last CLK pulse.
  // Easiest solution is to wait for it.
  delayMicroseconds(20);
  // Stream out remaining partially filled buffer
  if (result.is_ok())
    result = data_stream.process(true);
 
  // Explicitly stop data_stream, even though going out of scope should do it
  if (!data_stream.stop())
    result = Result::err("Error while stopping data stream.");
 
  // Capture all signals on carrier when requested
  if (run.daq_config.sample_op_end) {
    std::array<std::array<float, 8>, 6> data_op_end;
    if (carrier_.measure_all_signals(data_op_end)) {
      run_data_handler->handle_op_end(run, data_op_end);
    }else {
      result = Result::err("Error while measuring OP_END data.");
    }
  }
 
  auto actual_op_time = mode::FlexIOControl::get_actual_op_time();
 
  auto &perf = mode::PerformanceCounter::get();
  perf.add(mode::Mode::IC, run.config.ic_time / 1000);
  perf.add(mode::Mode::OP, actual_op_time / 1000);
  perf.increase_run();
 
  if (result.is_err())
    return result;
 
  // DONE
  auto change = run.to(RunState::DONE, actual_op_time);
  state_change_handler->handle(change, run);
 
  return result;
}
 
FASTRUN void run_flexio(carrier::Carrier &carrier_, Run &run) {
  auto state_change_handler = run.state_change_handler.get();
 
  if (!state_change_handler) {
    LOG_ERROR("Can not start run without RunStateChangeHandler");
    return;
  }
 
  auto result = run_flexio_raw(carrier_, run);
  if (auto msg = result.if_err()) {
    auto change = run.to(RunState::ERROR, millis());
    LOG_ERROR(msg->c_str());
    state_change_handler->handle(change, run, msg->c_str());
  }
}
 
void Run::run(carrier::Carrier &carrier_) {
  run_flexio(carrier_, *this);
}
 
} // namespace run