ngcbMODIO.hpp

Go to the documentation of this file.

#ifndef ngcbMODIO_H
#define ngcbMODIO_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
 
#include <ngc/core/ngcbDrv.h>
 
#ifdef _PTHREAD_H
#define ngcbMODIO_THR 1
#endif

class ngcbMODIO {
public:
  ngcbMODIO() {
    erms_[0] = '\0'; path_[0] = '\0'; ngcbModInit(&mod_);
  }

  explicit ngcbMODIO(const char *path) {
    erms_[0] = '\0'; path_[0] = '\0'; ngcbModInit(&mod_);
    if (path != NULL) strcpy(path_, path);
  }

  virtual ~ngcbMODIO() {
    if (mod_.fd >= 0) Close();
  }

  const char *ErrMsg() {return (erms_);}

  void Sim(int stat) {
    if (stat) mod_.flags |= 0x1;
    else mod_.flags &= ~0x1;
  }

  void Verbose(int stat) {
    if (stat) mod_.flags |= 0x2;
    else mod_.flags &= ~0x2;
  }

  void Period(unsigned int p) {mod_.period = p;}

  int Open() {return (Open(path_));}

  int Open(const char *path) {
    if (mod_.fd >= 0)
      {
      strcpy(erms_, "device is already open");
      return (-1);
      }
    else if (ngcbModOpen(path, &mod_, erms_) < 0)
      {
      return (-1);
      }
    else
      {
      char s[256];
      strcpy(s, path);
      strcpy(path_, s);
      return (0);
      }
  }

  int Close() {return (ngcbModClose(&mod_, erms_));}

  int Timeout(int seconds) {return (ngcbModTimeout(&mod_, seconds, erms_));}

  int Fifo(int size) {return (ngcbModFifo(&mod_, size, erms_));}

  int Read(int addr, int *buffer, int size) {
    return (ngcbModRead(&mod_, addr, buffer, size, erms_));    
  }

  int Write(int addr, const int *buffer, int size) {
    return (ngcbModWrite(&mod_, addr, buffer, size, erms_));    
  }

  int Wait(int addr, int mask, void *lock = NULL) {
    return (Wait(addr, mask, -1, lock));
  }

  int Wait(int addr, int mask, int timeout, void *lock = NULL) {
#ifdef ngcbMODIO_THR
    unsigned long int p = 1000 * mod_.period;     /* polling period */
    long int n = (timeout * 1000000) / p;         /* polling cycles */
    int reg = 0x0;                                /* register value */
    pthread_mutex_t *m = (pthread_mutex_t *)lock; /* mutex (locked) */
   
    /*
     * Read register once
     */
    if (Read(addr, &reg, 1) < 0)
      {
      return (-1);
      }
    
    while (((reg & mask) != mask) && (n != 0))
      {
      if (m != NULL)
    {
    /*
     * Unlock the mutex while sleeping
     */
    if (pthread_mutex_unlock(m) != 0)
      {
      sprintf(erms_, "mutex unlock failed - %s", strerror(errno));
      return (-1);
      }
    }
 
      /*
       * Sleep for polling interval...
       */
      MicroSleep_(p);
 
      if (m  != NULL)
    {
    /*
     * Lock the mutex before reading
     */
    if (pthread_mutex_lock(m) != 0)
      {
      sprintf(erms_, "mutex lock failed - %s", strerror(errno));
      return (-1);
      }
    }
     
      /*
       * ...and read again
       */
      if (Read(addr, &reg, 1) < 0)
    {
    return (-1);
    }
      
      if (n > 0) n--;
      }
    
    if ((reg & mask) != mask)
      {
      /*
       * If the bit-mask is not yet set then our timer has expired
       */
      strcpy(erms_, "timeout");
      return (-1);
      }
 
    return (0);
#else
    USE(lock);
    return (ngcbModWait(&mod_, addr, mask, timeout, erms_));
#endif
  }
 
protected: 
 
private:
  char erms_[256];

  char path_[256];
  
  ngcb_mod_t mod_;
 
#ifdef ngcbMODIO_THR
  void MicroSleep_(unsigned long int ms) { 
    if (ms > 0)
      {
      struct timeval t;
      t.tv_sec = ms / 1000000;
      ms -= t.tv_sec * 1000000;
      t.tv_usec = ms; 
      select(0, NULL, NULL, NULL, &t);
      }
  }
#endif
};
 
#endif