drivers.cpp

Go to the documentation of this file.

#include "run/manager.h"
#include "mode/counters.h"
 
#include <Arduino.h>
#include <cmath>
#include <cstdlib>
 
#include <daq/daq.h>
#include <utils/logging.h>
 
#include <mode/mode.h>
#include <mode/teensy/mode.h>
#include <run/handlers.h>
#include <run/run.h>
 
#include "run/teensy/drivers.h"
 
 
FLASHMEM void run::drivers::SleepRun::run() {
  auto run = *this; // leftover
  // run_data_handler->prepare(run);
 
  // here, one sample is one data aquisition which always yields all channels.
  constexpr uint32_t max_num_samples = 16'384;
  const int num_channels = run.daq_config.get_num_channels();
  const uint32_t optime_us = run.config.op_time / 1000;
 
  uint32_t sampling_time_us = 0;
  if (num_channels > 0 && run.daq_config.get_sample_rate() != 0) {
    // measure how long an single ADC sampling takes with the current implementation.
    // This is right now around 15us.
    elapsedMicros sampling_time_us_counter; // class from teensy elpasedMillis.h
    volatile auto hopefully_not_optimized_out = daq::sample_raw();
    sampling_time_us = sampling_time_us_counter;
    // TODO: There is a slight dither around 15us -- 16us, could do the averaging call to
    //       improve the statistics.
  }
 
  /*
    The guiding principle of the following math is this:
 
       sampling_total_us == sampling_time_us + sampling_sleep_us // for up to full 8 channels
       optime_us == num_samples*num_channels*sampling_total_us
 
    We precompute all busy waits (sleeps) in order to match the requested optime as precise
    as possible, with this means. Without interrupts.
 
    We ignore run.daq_config.get_sample_rate() because it is much simpler to just always
    fill up the buffer. Furthermore the manual DAQ is pretty slow (about 15us per sample).
 
    There are two main scenarios:
 
    - asked for fast sampling = short runtime. This is where sampling_time_us dominates.
      This code does it's job when optime_us > sampling_time_us but it's not great, of
      course.
    - asked for slow sampling = long runtime. This is where this code shines, because there
      is no limit in runtime or similar, compared to the FlexIO code.
 
    Of course, the overall code is still an order of magnitude simpler then the FlexIO/DMA
    code. And in the same way less precise for short runtimes and fast sampling times.
 
    Given the unit of time basically measured in sampling_time_us, there is no need to
    compute in nanoseconds here. Therefore the code computes in microseconds.
  */
 
  uint32_t sampling_total_us = optime_us / max_num_samples;
 
  // either no sleep at all or sleep the difference between total time and aquisition time.
  uint32_t sampling_sleep_us =
      (sampling_total_us < sampling_time_us) ? 0 : (sampling_total_us - sampling_time_us);
 
  uint32_t num_samples = optime_us / (sampling_sleep_us + sampling_time_us);
  uint32_t optime_left_us = optime_us % (sampling_sleep_us + sampling_time_us);
 
  // This situation actually should not happen at all.
  if (num_samples > max_num_samples)
    num_samples = max_num_samples;
 
  const int num_buffer_entries = num_samples * num_channels;
  if (num_channels > 0)
    LOGMEV("optime_us=%d, sampling_time_us=%d, sampling_sleep_us=%d, num_samples=%d, num_channels=%d",
           optime_us, sampling_time_us, sampling_sleep_us, num_samples, num_channels);
 
  // This would not be necessary anymore
  // just to be able to use daq.sample_raw(uint16_t*) instead of copying over to an intermediate buffer
  // of size std::vector, we add a bit safety padding to the right for the last datum obtained.
  // Actually needed only if num_samples < daq::NUM_CHANNELS = 8.
  constexpr int padding = daq::NUM_CHANNELS;
 
  // we use malloc because new[] raises an exception if allocation fails but we cannot catch it with
  // -fno-exception. we don't use the stack because we expect the heap to have more memory left...
  int16_t *buffer = nullptr;
  if (num_channels > 0) {
    // allocate only if any data aquisition was asked for
    buffer = (int16_t *)malloc((num_buffer_entries + padding) * sizeof(int16_t));
    if (!buffer) {
      LOG_ERROR("Could not allocated a large run buffer for a traditional Run.");
    }
  }
 
  mode::RealManualControl::enable();
 
  LOGMEV("IC TIME: %lld", run.config.ic_time);
  LOGMEV("OP TIME: %lld", run.config.op_time);
 
  mode::RealManualControl::to_ic();
  // 32bit nanosecond delay can sleep maximum 4sec, however
  // an overlap will happen instead.
  /*if (run.config.ic_time > 100'000'000)    // 100ms
    delay(run.config.ic_time / 1'000'000); // milisecond resolution sleep
  else if (run.config.ic_time > 65'000)    // 16bit nanoseconds
    delayMicroseconds(run.config.ic_time / 1000);
  else*/
  delayNanoseconds(run.config.ic_time);
  mode::RealManualControl::to_op();
  elapsedMicros actual_op_time_timer;
 
  if (buffer) {
    for (uint32_t sample = 0; sample < num_samples; sample++) {
      // Assumption: Passing the next line requires the amount of time "sampling_time_us"
      // It's no longer possible to directly sample into a buffer, since we always need to copy out of the
      // flexIO shift buffers
      auto data = daq::sample_raw();
      memcpy(buffer + sample * num_channels, data.data(), num_channels);
      // if (sampling_sleep_us)
      delayMicroseconds(sampling_sleep_us);
    }
    // if (optime_left_us)
    delayMicroseconds(optime_left_us);
  } else {
    /*if (run.config.op_time > 100'000'000)    // 100ms
      delay(run.config.op_time / 1'000'000); // millisecond resolution sleep
    else if (run.config.op_time > 65'000)    // 16bit nanoseconds
      delayMicroseconds(run.config.op_time / 1000);
    else*/
    delayNanoseconds(run.config.op_time);
  }
 
  uint32_t actual_op_time_us = actual_op_time_timer;
  mode::RealManualControl::to_halt();
 
  if (buffer) {
    if(alt_data_handler)
      alt_data_handler->handle((uint16_t *)buffer, num_samples, num_channels, run);
    free(buffer);
  }
 
  // untested option
  if(run.daq_config.should_sample_op_end() && alt_data_handler) {
    auto singlebuf = daq::sample_raw();
    // assert: singlebuf.size() <= num_channels ...
    alt_data_handler->handle(singlebuf.data(), 1, num_channels, run);
  }
 
  auto res = (num_channels && !buffer) ? RunState::ERROR : RunState::DONE;
  auto result = run.to(res, actual_op_time_us * 1000);
  if (run.config.write_run_state_changes && state_change_handler)
    state_change_handler->handle(result, run);
}
 
FLASHMEM void run::drivers::FlexIORun::run() {
  auto run = *this; // leftover
  if(data_handler)
    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);
    if(state_change_handler)
      state_change_handler->handle(change, run);
    return;
  }
 
  auto data_stream = daq::stream::get(run, data_handler);
  if(data_handler)
    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);
    if(state_change_handler)
      state_change_handler->handle(change, run);
    return;
  }
 
  // DONE
  auto change = run.to(RunState::DONE, actual_op_time);
  if(state_change_handler)
    state_change_handler->handle(change, run);
}
 
FLASHMEM void run::drivers::SeriesRun::run() {
  const int num_channels = daq_config.get_num_channels();
  int16_t* raw_results = nullptr;
  if(alt_data_handler) {
    raw_results = (int16_t*) malloc(num_channels * series_length * sizeof(int16_t));
    if(!raw_results) {
      LOG_ERROR("Could not allocate a large run buffer for Series Run.");
    }
  }
 
  elapsedMicros timer_us;
 
  mode::RealManualControl::enable();
  int16_t* raw_results_cur = raw_results;
  for(size_t cur_series = 0; cur_series < series_length; cur_series++) {
    mode::RealManualControl::to_ic();
    delayNanoseconds(config.ic_time);
    mode::RealManualControl::to_op();
    delayNanoseconds(config.op_time);
    mode::RealManualControl::to_halt();
 
    if(raw_results) {
      auto samples = daq::sample_raw();
      for(size_t channel=0; channel<num_channels; channel++)
        *(raw_results_cur++) = samples[channel];
    }
  }
 
  auto result = to(RunState::DONE, timer_us*1000);
  if(state_change_handler)
    state_change_handler->handle(result, *this);
 
  if(raw_results && data_handler)
    alt_data_handler->handle((uint16_t *)raw_results, series_length, num_channels, *this);
 
  if(raw_results)
    free(raw_results);
}