daq.hpp

Go to the documentation of this file.

/*
 The Real-Time eXperiment Interface (RTXI)
 Copyright (C) 2011 Georgia Institute of Technology, University of Utah,
 Will Cornell Medical College

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef DAQ_DEVICE_H
#define DAQ_DEVICE_H

#include <cmath>
#include <cstddef>
#include <map>

#include "io.hpp"
#include "rt.hpp"


namespace DAQ
{

using analog_range_t = std::pair<double, double>;

namespace ChannelType
{
enum type_t : size_t
{
 AI = 0,
 AO,
 DI,
 DO,
 UNKNOWN
};

inline std::string type2string(type_t type)
{
 std::string result;
 switch (type) {
 case AI:
 result = "Analog Input";
 break;
 case AO:
 result = "Analog Output";
 break;
 case DI:
 result = "Digital Input";
 break;
 case DO:
 result = "Digital Output";
 break;
 default:
 ERROR_MSG("DAQ::ChannelType::type2string : Unknown type used");
 break;
 }
 return result;
}
} // namespace ChannelType

typedef uint64_t index_t;

static const index_t INVALID = static_cast<index_t>(-1);

enum direction_t
{
 INPUT,
 OUTPUT,
};

namespace Reference
{
enum reference_t : size_t
{
 GROUND = 0,
 COMMON,
 DIFFERENTIAL,
 OTHER,
 UNKNOWN
};
} // namespace Reference

inline std::array<analog_range_t, 7> get_default_ranges()
{
 return {
 std::pair(-10.0, 10.0),
 std::pair(-5.0, 5.0),
 std::pair(-1.0, 1.0),
 std::pair(-0.5, 0.5),
 std::pair(-0.2, 0.2),
 std::pair(-0.1, 0.1),
 };
}

inline std::array<std::string, 2> get_default_units()
{
 return {"volts", "amps"};
}

class Device : public RT::Device
{
public:
 Device(const std::string& dev_name,
 const std::vector<IO::channel_t>& channels)
 : RT::Device(dev_name, channels)
 {
 }

 virtual size_t getChannelCount(ChannelType::type_t type) const = 0;

 virtual bool getChannelActive(ChannelType::type_t type,
 index_t index) const = 0;

 virtual int setChannelActive(ChannelType::type_t type,
 index_t index,
 bool state) = 0;

 virtual size_t getAnalogRangeCount(index_t index) const = 0;

 virtual size_t getAnalogReferenceCount(index_t index) const = 0;

 virtual size_t getAnalogUnitsCount(index_t index) const = 0;
 virtual size_t getAnalogDownsample(ChannelType::type_t type,
 index_t index) const = 0;

 virtual std::string getAnalogRangeString(ChannelType::type_t type,
 index_t index,
 index_t range) const = 0;

 virtual std::string getAnalogReferenceString(ChannelType::type_t type,
 index_t index,
 index_t reference) const = 0;

 virtual std::string getAnalogUnitsString(ChannelType::type_t type,
 index_t index,
 index_t units) const = 0;

 virtual double getAnalogGain(ChannelType::type_t type,
 index_t index) const = 0;

 virtual double getAnalogZeroOffset(ChannelType::type_t type,
 index_t index) const = 0;

 virtual index_t getAnalogRange(ChannelType::type_t type,
 index_t index) const = 0;

 virtual index_t getAnalogReference(ChannelType::type_t type,
 index_t index) const = 0;

 virtual index_t getAnalogUnits(ChannelType::type_t type,
 index_t index) const = 0;

 virtual index_t getAnalogOffsetUnits(ChannelType::type_t type,
 index_t index) const = 0;

 virtual int setAnalogGain(ChannelType::type_t type,
 index_t index,
 double gain) = 0;

 virtual int setAnalogRange(ChannelType::type_t type,
 index_t index,
 index_t range) = 0;

 virtual int setAnalogZeroOffset(ChannelType::type_t type,
 index_t index,
 double offset) = 0;

 virtual int setAnalogReference(ChannelType::type_t type,
 index_t index,
 index_t reference) = 0;

 virtual int setAnalogUnits(ChannelType::type_t type,
 index_t index,
 index_t units) = 0;

 virtual int setAnalogOffsetUnits(ChannelType::type_t type,
 index_t index,
 index_t units) = 0;
 virtual int setAnalogDownsample(ChannelType::type_t type,
 index_t index,
 size_t downsample) = 0;
 virtual int setAnalogCounter(ChannelType::type_t type, index_t index) = 0;

 virtual int setAnalogCalibrationValue(ChannelType::type_t type,
 index_t index,
 double value) = 0;

 virtual double getAnalogCalibrationValue(ChannelType::type_t type,
 index_t index) const = 0;

 virtual int setAnalogCalibrationActive(ChannelType::type_t type,
 index_t index,
 bool state) = 0;

 virtual bool getAnalogCalibrationActive(ChannelType::type_t type,
 index_t index) const = 0;

 virtual bool getAnalogCalibrationState(ChannelType::type_t type,
 index_t index) const = 0;

 virtual int setDigitalDirection(index_t index, direction_t direction) = 0;

}; // class Device

class Driver
{
public:
 explicit Driver(std::string dev_name)
 : name(std::move(dev_name))
 {
 }
 Driver(const Driver&) = default; // copy constructor
 Driver& operator=(const Driver&) = default; // copy assignment operator
 Driver(Driver&&) = default; // move constructor
 Driver& operator=(Driver&&) = default; // move assignment operator
 virtual ~Driver() = default;

 virtual void loadDevices() = 0;
 virtual void unloadDevices() = 0;

 virtual std::vector<DAQ::Device*> getDevices() = 0;
 std::string getDriverName() { return this->name; }

private:
 std::string name;
}; // class Driver

} // namespace DAQ

#endif // DAQ_DEVICE_H