lasp_daqconfig.h

Go to the documentation of this file.

#pragma once
#include "lasp_config.h"
#include "lasp_types.h"
#include <map>
#include <vector>
 
using std::string;
using std::to_string;
 
using boolvec = std::vector<bool>;
using dvec = std::vector<double>;
using usvec = std::vector<us>;
 
class DataTypeDescriptor {
public:
  enum class DataType {
    dtype_fl32 = 0,
    dtype_fl64 = 1,
    dtype_int8 = 2,
    dtype_int16 = 3,
    dtype_int32 = 4
  };
 
  string name;
  unsigned sw;
  bool is_floating;
 
  DataType dtype;
 
  operator DataType() { return dtype; }
 
  bool operator==(const DataTypeDescriptor &o) noexcept {
    return dtype == o.dtype;
  }
};
 
const DataTypeDescriptor dtype_desc_fl32 = {
    .name = "32-bits floating point",
    .sw = 4,
    .is_floating = true,
    .dtype = DataTypeDescriptor::DataType::dtype_fl32};
const DataTypeDescriptor dtype_desc_fl64 = {
    .name = "64-bits floating point",
    .sw = 8,
    .is_floating = true,
    .dtype = DataTypeDescriptor::DataType::dtype_fl64};
const DataTypeDescriptor dtype_desc_int8 = {
    .name = "8-bits integer",
    .sw = 1,
    .is_floating = false,
    .dtype = DataTypeDescriptor::DataType::dtype_int8};
const DataTypeDescriptor dtype_desc_int16 = {
    .name = "16-bits integer",
    .sw = 2,
    .is_floating = false,
    .dtype = DataTypeDescriptor::DataType::dtype_int16};
const DataTypeDescriptor dtype_desc_int32 = {
    .name = "32-bits integer",
    .sw = 4,
    .is_floating = false,
    .dtype = DataTypeDescriptor::DataType::dtype_int32};
 
const std::map<DataTypeDescriptor::DataType, const DataTypeDescriptor>
    dtype_map = {
        {DataTypeDescriptor::DataType::dtype_fl32, dtype_desc_fl32},
        {DataTypeDescriptor::DataType::dtype_fl64, dtype_desc_fl64},
        {DataTypeDescriptor::DataType::dtype_int8, dtype_desc_int8},
        {DataTypeDescriptor::DataType::dtype_int16, dtype_desc_int16},
        {DataTypeDescriptor::DataType::dtype_int32, dtype_desc_int32},
};
 
class DaqApi {
public:
  string apiname = "Invalid API";
  int apicode = -1;
  unsigned api_specific_subcode = 0;
 
  DaqApi(string apiname, unsigned apicode, unsigned api_specific_subcode = 0)
      : apiname(apiname), apicode(apicode),
        api_specific_subcode(api_specific_subcode) {}
  DaqApi() {}
  bool operator==(const DaqApi &other) const {
    return (apiname == other.apiname && apicode == other.apicode &&
            api_specific_subcode == other.api_specific_subcode);
  }
  operator string() const { return apiname; }
  static std::vector<DaqApi> getAvailableApis();
};
 
#if LASP_HAS_ULDAQ == 1
const us LASP_ULDAQ_APICODE = 0;
const DaqApi uldaqapi("UlDaq", 0);
#endif
#if LASP_HAS_RTAUDIO == 1
#include "RtAudio.h"
const us LASP_RTAUDIO_APICODE = 1;
const DaqApi rtaudioAlsaApi("RtAudio Linux ALSA", 1, RtAudio::Api::LINUX_ALSA);
const DaqApi rtaudioPulseaudioApi("RtAudio Linux Pulseaudio", LASP_RTAUDIO_APICODE,
                                  RtAudio::Api::LINUX_PULSE);
const DaqApi rtaudioWasapiApi("RtAudio Windows Wasapi", LASP_RTAUDIO_APICODE,
                              RtAudio::Api::WINDOWS_WASAPI);
const DaqApi rtaudioDsApi("RtAudio Windows DirectSound", LASP_RTAUDIO_APICODE,
                          RtAudio::Api::WINDOWS_DS);
const DaqApi rtaudioAsioApi("RtAudio Windows ASIO", LASP_RTAUDIO_APICODE,
                            RtAudio::Api::WINDOWS_ASIO);
#endif
#if LASP_HAS_PORTAUDIO == 1
const us LASP_PORTAUDIO_APICODE = 2;
const DaqApi portaudioApi("PortAudio Linux ALSA", LASP_PORTAUDIO_APICODE, 0);
#endif
 
class DeviceInfo;
 
class DaqChannel {
 
public:
  enum class Qty { Number, AcousticPressure, Voltage, UserDefined };
 
  DaqChannel() {}
 
  bool enabled = false;
 
  string name = "";
  double sensitivity = 1;
  bool IEPEEnabled = false;
  bool ACCouplingMode = false;
  int rangeIndex = 0;
  Qty qty = Qty::Number;
 
  double digitalHighPassCutOn = -1;
 
  bool operator==(const DaqChannel &other) const {
    return other.name == name && other.sensitivity == sensitivity &&
           other.qty == qty;
  }
};
 
class DaqConfiguration {
public:
  std::string toTOML() const;
 
  static DaqConfiguration fromTOML(const std::string &toml);
 
  DaqApi api;
  string device_name;
 
  std::vector<DaqChannel> inchannel_config;
 
  std::vector<DaqChannel>
  enabledInChannels(const bool include_monitor = true) const;
 
  std::vector<DaqChannel> outchannel_config;
 
  int sampleRateIndex = 0; //
 
  int dataTypeIndex = 0;
 
  int framesPerBlockIndex = 0;
 
  bool monitorOutput = false;
 
  DaqConfiguration(const DeviceInfo &deviceinfo);
 
  DaqConfiguration() {}
 
  bool match(const DeviceInfo &devinfo) const;
 
  int getHighestEnabledInChannel() const;
  int getHighestEnabledOutChannel() const;
 
  int getLowestEnabledInChannel() const;
  int getLowestEnabledOutChannel() const;
 
  void setAllInputEnabled(bool val) {
    for (auto &ch : inchannel_config) {
      ch.enabled = val;
    }
  }
 
  void setAllOutputEnabled(bool val) {
    for (auto &ch : outchannel_config) {
      ch.enabled = val;
    }
  }
};