daq.h

Go to the documentation of this file.

/*
 The Real-Time eXperiment Interface (RTXI)
 Copyright (C) 2011 Georgia Institute of Technology, University of Utah, Weill 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 <io.h>
#include <map>
#include <rt.h>


namespace DAQ
{

enum type_t
{
 AI,
 AO,
 DIO,
 DI,
 DO,
};
typedef unsigned long index_t;
static const index_t INVALID = (0-1);
enum direction_t
{
 INPUT,
 OUTPUT,
};

class Device;
class Driver;

class Manager
{

 friend class Device;
 friend class Driver;

public:

 static Manager *getInstance(void);

 void foreachDevice(void (*callback)(Device *,void *),void *param);

 Device *loadDevice(const std::string &driver,const std::list<std::string> &params);

private:

 Manager(void) : mutex(Mutex::RECURSIVE) {};
 ~Manager(void) {};
 Manager(const Manager &) {};
 Manager &operator=(const Manager &)
 {
 return *getInstance();
 };

 static Manager *instance;

 void insertDevice(Device *);
 void removeDevice(Device *);

 void registerDriver(Driver *,const std::string &);
 void unregisterDriver(const std::string &);

 Mutex mutex;
 std::list<Device *> devices;
 std::map<std::string,Driver *> driverMap;

}; // class Manager

class Device : public RT::Device, public IO::Block
{

public:

 Device(std::string,IO::channel_t *,size_t);
 virtual ~Device(void);

 virtual size_t getChannelCount(type_t type) const=0;
 virtual bool getChannelActive(type_t type,index_t index) const=0;
 virtual int setChannelActive(type_t type,index_t index,bool state)=0;
 virtual size_t getAnalogRangeCount(type_t type,index_t index) const=0;
 virtual size_t getAnalogReferenceCount(type_t type,index_t index) const=0;
 virtual size_t getAnalogUnitsCount(type_t type,index_t index) const=0;
 virtual size_t getAnalogDownsample(type_t type,index_t index) const=0;
 virtual std::string getAnalogRangeString(type_t type,index_t index,index_t range) const=0;
 virtual std::string getAnalogReferenceString(type_t type,index_t index,index_t reference) const=0;
 virtual std::string getAnalogUnitsString(type_t type,index_t index,index_t units) const=0;
 virtual double getAnalogGain(type_t type,index_t index) const=0;
 virtual double getAnalogZeroOffset(type_t type,index_t index) const=0;
 virtual index_t getAnalogRange(type_t type,index_t index) const=0;
 virtual index_t getAnalogReference(type_t type,index_t index) const=0;
 virtual index_t getAnalogUnits(type_t type,index_t index) const=0;
 virtual index_t getAnalogOffsetUnits(type_t type,index_t index) const=0;
 virtual int setAnalogGain(type_t type,index_t index,double gain)=0;
 virtual int setAnalogRange(type_t type,index_t index,index_t range)=0;
 virtual int setAnalogZeroOffset(type_t type,index_t index,double offset)=0;
 virtual int setAnalogReference(type_t type,index_t index,index_t reference)=0;
 virtual int setAnalogUnits(type_t type,index_t index,index_t units)=0;
 virtual int setAnalogOffsetUnits(type_t type,index_t index,index_t units)=0;
 virtual int setAnalogDownsample(type_t type, index_t index, size_t downsample)=0;
 virtual int setAnalogCounter(type_t type, index_t index)=0;
 virtual int setAnalogCalibrationValue(type_t type,index_t index, double value)=0;
 virtual double getAnalogCalibrationValue(type_t type,index_t index) const=0;
 virtual int setAnalogCalibrationActive(type_t type,index_t index, bool state)=0;
 virtual bool getAnalogCalibrationActive(type_t type,index_t index) const=0;
 virtual bool getAnalogCalibrationState(type_t type,index_t index) const=0;
 virtual direction_t getDigitalDirection(index_t index) const=0;
 virtual int setDigitalDirection(index_t index,direction_t direction)=0;


}; // class Device

class Driver
{

public:

 Driver(const std::string &name);
 virtual ~Driver(void);

 virtual Device *createDevice(const std::list<std::string> &args)=0;

private:

 std::string name;

}; // class Driver

}; // namespace DAQ

#endif // DAQ_DEVICE_H