plux.h

Go to the documentation of this file.

 
#ifndef _PLUXHEADER_
#define _PLUXHEADER_
 
#include <map>
#include <string>
#include <vector>
#include <time.h>
 
#define PLUX_API_VERSION      "1.11"                        
#define PLUX_API_BUILD_DATE   __DATE__                      
//const char *PLUX_API_BUILD_DATE = __DATE__ " "  __TIME__; ///< Compile API timedate
 
#define DEBUG_MSG(msg) \
    fprintf(stderr, "[DEBUG]>> %s (%s:%d - %s)\n", msg, \
                                                   __FILE__, \
                                                   __LINE__, \
                                                   __FUNCTION__);
 
#define DEBUG_PRINT(fmt, ...) \
    fprintf(stderr, "[DEBUG]>> " fmt " (%s:%d %s())\n", ##__VA_ARGS__, \
                                                         __FILE__, \
                                                         __LINE__, \
                                                         __FUNCTION__);
 
namespace Plux
{
   typedef std::string        String;  
   typedef std::vector<int>   Ints;    
   typedef std::vector<bool>  Bools;   
   
   struct DevInfo
   {
      String   path;
      
      String   description;
   };
   typedef std::vector<DevInfo>  DevInfos;   
   
   class Variant
   {
   public:
      enum Type
      {
         TypeNone,   
         TypeBool,   
         TypeInt,    
         TypeFloat,  
         TypeString, 
      };
      
      const Type type;  
      
      union
      {
         bool   b;
         int    i;
         float  f;
         String *s;
      }; 
      
      Variant(void)     : type(TypeNone) , i(0) {}    
      Variant(bool  _b) : type(TypeBool) , b(_b) {}   
      Variant(int   _i) : type(TypeInt)  , i(_i) {}   
      Variant(float _f) : type(TypeFloat), f(_f) {}   
      Variant(const char *_s) : type(TypeString), s(new String(_s)) {}     
      Variant(const String &_s) : type(TypeString), s(new String(_s)) {}   
      
      Variant(const Variant &v) : type(v.type)
      {
         if (v.type == TypeString)
            s = new String(*v.s);
         else
            i = v.i;
      }
      
      ~Variant(void) {if (type==TypeString) delete s;}
   };
   
   typedef std::map<String, Variant>  Properties;
 
   class Exception
   {
   public:
      String dbgInfo;
 
      Exception(const String &_info) : dbgInfo(_info) {}
 
      virtual String getDescription(void) const
      {
         return "Generic PLUX exception.";
      }
   };
   
   class NotifException : public Exception
   {
   public:
      NotifException(const String &_info) : Exception(_info) {}
   };
 
   namespace Notification
   {
      class OpeningPort : public NotifException
      {
      public:
         OpeningPort(const String &_info) : NotifException(_info) {}
 
         String getDescription(void) const
         {
            return "The communication port does not exist or it is already being used.";
         }
      };
      
      class InitializingPort : public NotifException
      {
      public:
         InitializingPort(const String &_info) : NotifException(_info) {}
 
         String getDescription(void) const
         {
            return "The communication port could not be initialized.";
         }
      };
      
      class AdapterNotFound : public NotifException
      {
      public:
         AdapterNotFound(const String &_info) : NotifException(_info) {}
 
         String getDescription(void) const
         {
            return "No Bluetooth adapter was found.";
         }
      };
      
      class DeviceNotFound : public NotifException
      {
      public:
         DeviceNotFound(const String &_info) : NotifException(_info) {}
 
         String getDescription(void) const
         {
            return "The device could not be found.";
         }
      };
      
      class ContactingDevice : public NotifException
      {
      public:
         ContactingDevice(const String &_info) : NotifException(_info) {}
 
         String getDescription(void) const
         {
            return "The communication with the device was lost.";
         }
      };
   };
   
   class ErrorException : public Exception
   {
   public:
      ErrorException(const String &_info) : Exception(_info) {}
   };
   
   namespace Error
   {
      class InvalidParameter : public ErrorException
      {
      public:
         InvalidParameter(const String &_info) : ErrorException(_info) {}
 
         String getDescription(void) const
         {
            return "Invalid parameter.";
         }
      };
      
      class InvalidOperation : public ErrorException
      {
      public:
         const int code;
         InvalidOperation(const String &_info, int _code = 0) : ErrorException(_info), code(_code) {}
         
         String getDescription(void) const
         {
            return "Invalid operation on current device state (code " + std::to_string(code) + ").";
         }
      };
      
      class NotSupported : public ErrorException
      {
      public:
         NotSupported(const String &_info) : ErrorException(_info) {}
 
         String getDescription(void) const
         {
            return "Operation not supported by the device.";
         }
      };
      
      class InvalidInstance : public ErrorException
      {
      public:
         InvalidInstance(const String &_info) : ErrorException(_info) {}
 
         String getDescription(void) const
         {
            return "The object instance is invalid.";
         }
      };
      
      class MissingModule : public ErrorException
      {
      public:
         const String module; 
         MissingModule(const String &_info, const String &_module = "") :
            ErrorException(_info), module(_module) {} 
 
         String getDescription(void) const
         {
            return "The API module " + module + " is missing or invalid.";
         }
      };
   };
 
   struct Clock
   {
      enum Source
      {
         None,       
         RTC,        
         FrameCount, 
         Bluetooth,  
         //DigAccel,
      };
      
      Source source; 
      int value;     
   };
   
   struct Event
   {
      enum Type
      {
         // BaseDev events
         
         // SignalsDev events
         TypeDigInUpdate = 3,       
         TypeSchedChange = 4,       
         TypeSync = 5,              
         TypeGestFeatures = 7,      
         TypeDisconnect = 8,        
         TypeSignalGood = 9,        
         TypeBattery = 10,          
         TypeSensorTrack = 11,      
         TypeFrameData = 12,        
         TypeDeviceState = 13,      
         TypeCalibrationData = 14,  
 
         
         // internal use only
         TypeTest = 0x70,           
      };
      
      Type type;  
   };
   
   // BaseDev events
   
   // SignalsDev events
   struct EvtDigInUpdate : public Event
   {
      Clock timestamp;  
      int   channel;    
      bool  state;      
   };
   
   struct EvtSchedChange : public Event
   {
      enum Action
      {
         SchedStarted = 0,       
         SchedEnded = 1,         
         SchedCannotStart = 2,   
      };
      
      Action   action;           
      time_t   schedStartTime;   
   };
   
   struct EvtSync : public Event
   {
      std::vector<Clock> timestamps;   
   };
   
   struct EvtGestFeatures : public Event
   {
      int seq, length, zcrossht, macc, mean90hb, acczorientation;
   };
   
   struct EvtDisconnect : public Event
   {
      enum Reason
      {
         Timeout = 1,         
         ButtonPressed = 2,   
         BatDischarged = 4,   
      };
      
      Reason   reason;  
   };
   
   struct EvtSignalGood : public Event
   {
      int   port;    
      bool  isGood;  
   };
   
   struct EvtBattery : public Event
   {
      float voltage,    
      percentage;       
   };
 
   struct EvtSensorTrack : public Event
   {
       int port;        
       bool connect;    
       bool idChanged;  
   };
 
   // Acquisition send data frames event class
   struct EvtFrameData : public Event
   {
      int len;
      const void *data;
   };
 
   struct EvtDeviceState : public Event
   {
      enum State
      {
         PowerDown         = 0,
         SensorUnplugged   = 1,
         SensorPlugged     = 2,
         LeadsOn           = 3,
         Biocal            = 4,
         Ready             = 5,
         Acquiring         = 6,
         Stop              = 7,
         BiocalStop        = 8,
      };
      
      State   state;          
   };
 
   // Calibration send data frames event class
   struct EvtCalibrationData : public Event
   {
      int len;
      const void *data;
   };
 
   // internal use only
   struct EvtTest : public Event
   {
      int subtype, len;
      const void *data;
   };
   
   class BaseDev
   {
   public:
      enum ProductId
      {
         PID_BioPlux           = 0x0101,   
         PID_BiosignalsPlux    = 0x0201,   
         PID_BiosignalsPluxPRO = 0x0205,   
         PID_MotionPlux        = 0x020A,   
         PID_OpenBan           = 0x0214,   
         PID_OpenBanV2_DDME    = 0x0215,   
         PID_OpenBanV2         = 0x0216,   
         PID_fNIRS             = 0x021E,   
         PID_StimPlux          = 0x0301,   
         PID_MuscleBan         = 0x0502,   
         PID_BITalino          = 0x0601,   
         PID_BITalinoRev       = 0x0602,   
         PID_scoliosis         = 0x0701,   
         PID_MuscleBanWearable = 0x0801,   
         PID_CardioBanWearable = 0x0802,   
         PID_RespiBanWearable  = 0x0803,   
      };
 
      static DevInfos findDevices(const String &domain = "");
 
       virtual void onFoundDevice(const char* path, const char* description);
       DevInfos findDevicesWithCallback(void);
 
       BaseDev();
      
      BaseDev(const String &path);
      
      virtual ~BaseDev(void);
      
      Properties getProperties(void);
      
      void setParameter(int port, int index, const void *data, int dataLen);
 
      int  getParameter(int port, int index, void *data, int maxLen);
      
      void reset(void);
      
      float getBattery(void);
      
      void setTimeout(int timeout = -1);
      
      void loop(void);
      
      void interrupt(void *param = NULL);
      
      virtual bool onEvent(const Event &evt) {return false;}
      
      virtual bool onTimeout(void) {return false;}
      
      virtual bool onInterrupt(void *param) {return false;}
      
      
      // internal use only
      struct X;
      X *x;
      
   protected:
      BaseDev(BaseDev &original);
      
   private:
      BaseDev& operator=(const BaseDev&); // assignments are not allowed
   };
 
   struct Sensor
   {
      enum Class
      {
         UNKNOWN_CLASS = 0,
         EMG = 1,
         ECG = 2,
         LIGHT = 3,
         EDA = 4,
         BVP = 5,
         RESP = 6,
         XYZ = 7,
         SYNC = 8,
         EEG = 9,
         SYNC_ADAP = 10,
         SYNC_LED = 11,
         SYNC_SW = 12,
         USB = 13,
         FORCE = 14,
         TEMP = 15,
         VPROBE = 16,
         BREAKOUT = 17,
         OXIMETER = 18,
         GONI = 19,
         ACT = 20,
         EOG = 21,
         EGG = 22,
         ANSA = 23,
         OSL = 26
      };
 
      enum Color
      {
         UNKNOWN_COLOR,
         BLACK,
         GRAY,
         WHITE,
         DARKBLUE,
         LIGHTBLUE,
         RED,
         GREEN,
         YELLOW,
         ORANGE
      };
 
      uint64_t    uid;             
      Class       clas;            
      int         serialNum;       
      int         hwVersion;       
      int         type;            
      time_t      productionTime;  
      Color       color;           
      Properties  characteristics; 
      Properties  measurCalib;     
   };
 
   typedef std::map<int, Sensor> Sensors;
 
   struct Source
   {
      int   port;          
      int   freqDivisor;   
      int   nBits;         
      int   chMask;        
      
      Source(int _port=0, int _freqDivisor=1, int _nBits=16, int _chMask=0x01) :
         port(_port), freqDivisor(_freqDivisor), nBits(_nBits), chMask(_chMask) {}
   };
   
   typedef std::vector<Source> Sources;
   
   class SignalsDev : public BaseDev
   {
   public:
      SignalsDev(const String &path);
      
      SignalsDev(BaseDev &baseDev);
      
      void getSensors(Sensors &sensors);
 
      void start(float freq, int portMask, int nBits);
      
      void start(float freq, const Ints &ports, int nBits);
      
      void start(float baseFreq, const Sources &sources);
      
      void stop(void);
      
      int getNumChannels(void);
      
      void setDOut(bool state);
      
      virtual bool onRawFrame(int nSeq, const int data[]) {return false;}
   };
 
   struct Schedule
   {
      time_t   startTime;
      
      int      duration;
      int      nSessions;     
      int      repeatPeriod;  
      float    baseFreq;      
      Sources  sources;       
      String   text;          
      
      Schedule(void) : startTime(1), duration(0), baseFreq(1000), nSessions(1), repeatPeriod(0) {}
   };
   typedef std::vector<Schedule> Schedules;  
   
   struct SessionSource : public Source
   {
      Sensor     sensor;      
      Properties properties;  
   };
   typedef std::vector<SessionSource> SessionSources;  
   
   struct Session
   {
      time_t      startTime;
      
      time_t         schedStartTime;
      int            nFrames;       
      float          baseFreq;      
      SessionSources sources;       
      String         text;          
      Properties     properties;    
   };
   typedef std::vector<Session> Sessions;  
   
   class MemoryDev : public SignalsDev
   {
   public:
      MemoryDev(const String &path);
      
      MemoryDev(BaseDev &baseDev);
      
      void setTime(time_t t=0);
      
      time_t getTime(void);
      
      int  getSchedules(Schedules &schs);
     
      void addSchedule(const Schedule &sch);
     
      void deleteSchedule(time_t startTime);
      
      void deleteAllSchedules(void);
      
      void stopSessionAcq(void);
      
      void getSessions(Sessions &sessions);
      
      void replaySession(time_t startTime, int iniFrame=0);
      
      void deleteAllSessions(void);
      
      int  getMemoryUsed(void);
      
      virtual bool onSessionRawFrame(int nSeq, const int data[]) {return false;}
      
      virtual bool onSessionEvent(const Event &evt) {return false;}
 
   private:
      int  getSchedules_ext(Schedules &schs);
 
      void addSchedule_ext(const Schedule &sch);
   };
 
   class BITalinoDev : public SignalsDev
   {
   public:
      struct State
      {
         int   analog[6],     
         battery,       
         batThreshold;  
         bool  digital[4];
      };
      
      BITalinoDev(const String &path);
      
      BITalinoDev(BaseDev &baseDev);
      
      void setDOut(const Bools &output);
      
      void setBatThreshold(int threshold);
      
      void setPWM(int value);
      
      State getState(void);
   };
 
   class StimDev : public BaseDev
   {
   public:
      StimDev(const String &path);
      StimDev(BaseDev &baseDev);
      
      void  startSession(int stateChanges = 0);
      void  stop(void);
      void  startMode(int mode, float time = 0);
      void  setWaveOnMode(const float *wave, int mode, bool isVoltage = false);
      void  setFrequencyOnMode(int freq, int mode);
      void  setTimeOnState(float time, int state);
      void  setModeOnState(int state, int mode);
      void  setMaxStateChanges(int maxChanges);
      void  setNextStateOnState(int state, int nextState);
      void  assignTriggerToMode(int mode);
      void  outputUnitPulse(int mode);
      void  setHVoltageState(bool HV);
      void  setCalib(int comID, int dacID, int calibVal);
   };
}
 
#endif // _PLUXHEADER_