lasp_daq.h

Go to the documentation of this file.

#pragma once
#include "lasp_config.h"
#include "lasp_daqdata.h"
#include "lasp_deviceinfo.h"
#include "lasp_types.h"
#include <functional>
#include <memory>
#include <mutex>
#include <atomic>
 
using InDaqCallback = std::function<void(const DaqData &)>;
 
using OutDaqCallback = std::function<void(DaqData &)>;
 
class Daq : public DaqConfiguration, public DeviceInfo {
 
protected:
  Daq(const DeviceInfo &devinfo, const DaqConfiguration &config);
  Daq(const Daq &) = delete;
 
public:
  class StreamStatus {
  public:
    enum class StreamError {
      noError,
      inputXRun,
      outputXRun,
      driverError,
      systemError,
      threadError,
      logicError,
    };
 
    inline static const std::map<StreamError, std::string> errorMessages{
        {StreamError::noError, "No error"},
        {StreamError::inputXRun, "Input buffer overrun"},
        {StreamError::outputXRun, "Output buffer underrun"},
        {StreamError::driverError, "Driver error"},
        {StreamError::systemError, "System error"},
        {StreamError::threadError, "Thread error"},
        {StreamError::logicError, "Logic error (probably a bug)"},
    };
 
    bool isRunning = false;
    bool error() const { return errorType != StreamError::noError; };
 
    StreamError errorType{StreamError::noError};
 
    std::string errorMsg() const { return errorMessages.at(errorType); }
 
    bool runningOK() const { return isRunning && !error(); }
 
  }; // End of class StreamStatus
 
  using rte = std::runtime_error;
  class StreamException : public rte {
    using StreamError = StreamStatus::StreamError;
 
  public:
    StreamStatus::StreamError e;
    StreamException(const StreamStatus::StreamError e)
        : rte(StreamStatus::errorMessages.at(e)), e(e) {}
    StreamException(const StreamStatus::StreamError e,
                    const std::string &additional_info)
        : rte(StreamStatus::errorMessages.at(e) + ": " + additional_info),
          e(e) {}
    operator StreamError() { return e; }
  };
 
  static std::unique_ptr<Daq> createDaq(const DeviceInfo &devinfo,
                                        const DaqConfiguration &config);
 
  virtual void start(InDaqCallback inCallback, OutDaqCallback outCallback) = 0;
 
  virtual void stop() = 0;
 
  virtual ~Daq() = 0;
 
  us neninchannels(bool include_monitorchannels = true) const;
 
  us nenoutchannels() const;
 
  boolvec eninchannels(const bool include_monitor = true) const;
 
  boolvec enoutchannels() const;
 
  double samplerate() const;
 
  dvec inputRangeForEnabledChannels(const bool include_monitor = true) const;
 
  DataTypeDescriptor::DataType dataType() const;
 
  const DataTypeDescriptor &dtypeDescr() const;
 
  us framesPerBlock() const {
    return availableFramesPerBlock.at(framesPerBlockIndex);
  }
 
  virtual StreamStatus getStreamStatus() const = 0;
 
  bool duplexMode() const {
    return (neninchannels() > 0 && nenoutchannels() > 0);
  }
};