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 <mode/mode.h>
#include <mode/teensy/mode.h>
#include <protocol/protocol_oob.h>
#include <run/run.h>
 
namespace run {
 
// NOT FLASHMEM
void run_next_flexio(Run &run, RunStateChangeHandler *state_change_handler, RunDataHandler *run_data_handler) {
  run_data_handler->prepare(run);
  bool daq_error = false;
 
  mode::FlexIOControl::reset();
  if (!mode::FlexIOControl::init(run.config.ic_time, run.config.op_time,
                                 run.config.halt_on_overload ? mode::OnOverload::HALT
                                                             : mode::OnOverload::IGNORE,
                                 mode::OnExtHalt::IGNORE)) {
    LOG_ERROR("Error while initializing state machine.")
    auto change = run.to(RunState::ERROR, 0);
    state_change_handler->handle(change, run);
    return;
  }
 
  auto data_stream = daq::stream::get(run, run_data_handler);
  run_data_handler->init();
 
  mode::FlexIOControl::force_start();
  delayMicroseconds(1);
 
  while (!mode::FlexIOControl::is_done()) {
    if (!data_stream.process()) {
      LOG_ERROR("Streaming error, most likely data overflow.");
      daq_error = true;
      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 (!data_stream.process(true)) {
    LOG_ERROR("Streaming error during final partial stream.");
    daq_error = true;
  }
 
  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 (daq_error) {
    auto change = run.to(RunState::ERROR, actual_op_time);
    state_change_handler->handle(change, run);
    return;
  }
 
  // DONE
  auto change = run.to(RunState::DONE, actual_op_time);
  state_change_handler->handle(change, run);
}
 
void RunManager::run_next_hal(Run &run, RunStateChangeHandler *state_change_handler,
                              RunDataHandler *run_data_handler,
                              client::StreamingRunDataNotificationHandler *alt_run_data_handler) {
 
  if (run.config.streaming)
    run_next_flexio(run, state_change_handler, run_data_handler);
  else
    run_next_traditional(run, state_change_handler, run_data_handler, alt_run_data_handler);
}
 
} // namespace run