daq.h

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
 
#pragma once
 
#include <array>
 
#include <ArduinoJson.h>
 
#ifdef ARDUINO
#include <DMAChannel.h>
#include <FlexIO_t4.h>
#endif
 
#include "daq/base.h"
#include "run/run.h"
#include "utils/error.h"
#include "utils/running_avg.h"
 
namespace carrier {
 
// Forward declaration for calibration
class Carrier;
 
} // namespace carrier
 
using status = utils::status;
 
namespace daq {
 
status init();
 
status calibrate(carrier::Carrier &carrier);
 
float raw_to_float(const uint16_t raw, const int16_t raw_zero_offset);
std::array<float, daq::NUM_CHANNELS> raw_to_float(std::array<uint16_t, daq::NUM_CHANNELS> raw);
std::array<uint16_t, 8> raw_to_offset_corrected(std::array<uint16_t, NUM_CHANNELS> raw);
size_t raw_to_normalized(uint16_t raw);
const char *raw_to_str(uint16_t raw);
 
void enable();
void disable();
void reset();
 
std::array<uint16_t, NUM_CHANNELS> sample_raw();
std::array<float, NUM_CHANNELS> sample();
 
template <typename T>
std::array<T, NUM_CHANNELS> average(std::array<T, NUM_CHANNELS> (*sample_function)(), size_t samples = 100,
                                    unsigned int delay_us = 33) {
  // Prevent overflows when using raw values
  using T_larger = typename std::conditional<std::is_same<T, uint16_t>::value, uint32_t, T>::type;
 
  utils::RunningAverage<std::array<T_larger, daq::NUM_CHANNELS>> avg;
  for (size_t i = 0; i < samples; i++) {
    avg.add(utils::convert<T_larger>(sample_function()));
    delayMicroseconds(delay_us);
  }
  return utils::convert<T>(avg.get_average());
}
 
std::array<float, NUM_CHANNELS> average(size_t samples = 100, unsigned int delay_us = 10);
 
namespace stream {
 
status start(const run::Run &run, run::RunDataHandler *const data_handler);
status stop(const run::Run &run);
status process(const run::Run &run, run::RunDataHandler *const data_handler, bool partial = false);
 
class Scope {
public:
  const run::Run &run;
  run::RunDataHandler *const run_data_handler;
 
public:
  Scope(const run::Run &run, run::RunDataHandler *data_handler, bool start_ = true)
      : run(run), run_data_handler(data_handler) {
    if (start_)
      (void)start(run, run_data_handler);
  }
 
  virtual ~Scope() { (void)stop(run); }
 
  /*
   * Process incoming data during a continuous acquisition.
   *
   * Continuous acquisition fills a ring buffer, which contents are processed with this function.
   * Data is processed in fixed-size chunks equal to half the size of the internal buffer.
   *
   * If enough data for one chunk is available, the process function calls the data handler's handle
   * function with the appropriate memory destination and size. See run::RunDataHandler::handle for more
   * details.
   *
   * If not enough data is available, the function does nothing and returns immediately,
   * unless \p partial is set. If \p partial is set, any amount of data currently available is processed
   * and the ring buffer write position is reset to its beginning.
   *
   * You should call process() regularly and call process(partial=true) once at the end.
   */
  status process(bool partial = false) { return stream::process(run, run_data_handler, partial); }
};
 
Scope get(const run::Run &run, run::RunDataHandler *const data_handler);
 
namespace details {
 
// BUFFER_SIZE *must* be a power-of-two number of bytes
constexpr size_t BUFFER_SIZE = 32 * NUM_CHANNELS;
 
std::array<volatile uint32_t, BUFFER_SIZE> get_buffer();
 
unsigned int get_number_of_data_vectors_in_buffer();
 
} // namespace details
 
} // namespace stream
 
namespace details {
 
static constexpr uint16_t RAW_MINUS_ONE_POINT_TWO_FIVE = 0;
static constexpr uint16_t RAW_ZERO_IDEAL = 8192;
static constexpr uint16_t RAW_PLUS_ONE_POINT_TWO_FIVE = 16383;
static constexpr uint16_t RAW_SUSPICIOUS_VALUE = 11111;
 
extern std::array<int16_t, NUM_CHANNELS> raw_zero_offsets;
 
constexpr uint8_t PIN_CNVST = 7;
constexpr uint8_t PIN_CLK = 6;
constexpr uint8_t PIN_GATE = 32;
constexpr std::array<uint8_t, NUM_CHANNELS> PINS_MISO = {34, 35, 36, 37, 11, 10, 9, 8};
 
namespace flexio {
 
static constexpr uint8_t _gated_timer_idx = 0;
static constexpr uint8_t _sample_timer_idx = 1;
static constexpr uint8_t _cnvst_timer_idx = 2;
static constexpr uint8_t _delay_timer_idx = 3;
static constexpr uint8_t _clk_timer_idx = 4;
 
inline FlexIOHandler *get_flexio() { return FlexIOHandler::flexIOHandler_list[1]; }
 
status _init_once();
void _init_timers();
void _init_shifters();
 
} // namespace flexio
 
} // namespace details
 
} // namespace daq