AcqSys.h

Go to the documentation of this file.

 
#ifndef ACQPROC_ACQSYS_H_
#define ACQPROC_ACQSYS_H_
 
#include <vector>
#include <string>
 
#include <string.h>
 
using namespace std;
 
int getenv(const char* key, int def, int (*cvt)(const char* key) = atoi);
 
 
struct VI {
    int len(void) const;
    VI& operator+= (const VI& right);
    VI offsets(void) const;
    int AI16;       
    int AI32;       
    int DI32;       
    int SP32;       
    VI();
};
 
enum SPIX {
    TLATCH = 0,         
    USECS = 1,          
    POLLCOUNT = 2,          
};
 
#define PW32LEN  32
typedef unsigned PW32V[PW32LEN];
 
struct VO {
    int len(void) const;
    int hwlen(void) const;
    VO& operator+= (const VO& right);
    VO offsets(void) const;
    int AO16;       
    int DO32;       
    int PW32;       
    int CC32;       
    VO();
};
 
 
struct SystemInterface;
 
class IO {
 
    string name;
    string* _string;
public:
    const VI vi;
    const VO vo;
 
    IO(string _name, VI _vi, VO _vo);
    virtual ~IO();
    virtual string toString();
    string getName() {
        return name;
    }
};
 
 
class ACQ: public IO
{
protected:
    ACQ(int devnum, string _name, VI _vi, VO _vo, VI _vi_offsets, VO _vo_offsets, VI& sys_vi_cursor, VO& sys_vo_cursor);
        virtual ~ACQ();
 
    bool nowait;            
    unsigned wd_mask;       
    int pollcount;
    int devnum;             
public:
    const VI vi_offsets;    
    const VO vo_offsets;    
    const VI vi_cursor;     
    const VO vo_cursor;     
    virtual string toString();
 
    virtual bool newSample(int sample);
    /*< checks host buffer for new sample, if so copies to lbuf and reports true */
    virtual void action(SystemInterface& systemInterface) {}
    /*< early stage action */
    virtual void action2(SystemInterface& systemInterface) {}
    /*< second stage action */
    virtual unsigned tlatch(void);
    virtual void arm(int nsamples);
    static ACQ* factory(int devnum, string _name, VI _vi, VO _vo, VI _vi_offsets,
            VO _vo_offsets, VI& sys_vi_cursor, VO& sys_vo_cursor);
 
    friend class HBA;
};
 
struct Dev;
 
 
 
class HBA: public IO
{
    HBA(vector <ACQ*> _uuts, VI _vi, VO _vo);
    static HBA* the_hba;    
public:
    virtual ~HBA();
    int devnum;
    vector<ACQ*> uuts;  
    vector<int> devs;   
    const VI vi;        
    const VO vo;        
    static int maxsam;  
    static HBA& create(const char* json_def, int _maxsam);
    static HBA& instance() { return *the_hba; }
 
    virtual void start_shot();
    virtual void processSample(SystemInterface& systemInterface, int sample);
    void dump_config();
    void dump_data(const char* basename);
    virtual string toString();
};
 
namespace G {
    extern int nsamples;
    extern int verbose;
    extern int dummy_first_loop;
    extern int samples_buffer;
    extern int maxpoll;
};
 
struct SystemInterface {
private:
    const HBA& hba;
 
public:
    struct Inputs {
        short *AI16;
        int *AI32;
        unsigned *DI32;
        unsigned *SP32;
    } IN;
    struct Outputs {
        short* AO16;
        unsigned *DO32;
        PW32V *PW32;            
        unsigned *CC32;         
    } OUT;
 
    SystemInterface(const HBA& _hba);
    virtual ~SystemInterface();
    virtual void trigger()
    {}
    virtual void ringDoorbell(int sample)
    {}
 
    static SystemInterface& factory(const HBA&);
 
    unsigned tlatch() {
        return IN.SP32[0];
    }
    unsigned AI16_count() const {
        return hba.vi.AI16;
    }
    unsigned AI32_count() const {
        return hba.vi.AI32;
    }
    unsigned DI32_count() const {
        return hba.vi.DI32;
    }
    unsigned SP32_count() const {
        return hba.vi.SP32;
    }
    unsigned AO16_count() const {
        return hba.vo.AO16;
    }
    unsigned DO32_count() const {
        return hba.vo.DO32;
    }
    unsigned PW32_count() const {
        return hba.vo.PW32;
    }
    unsigned CC32_count() const {
        return hba.vo.CC32;
    }
};
 
template <class T>
T* new_zarray(int nelems)
{
    T* nz_array = new T[nelems];
    memset(nz_array, 0, nelems*sizeof(T));
    return nz_array;
}
 
#define PFN __PRETTY_FUNCTION__
 
 
#endif /* ACQPROC_ACQSYS_H_ */