pixelmanDriver.h

Go to the documentation of this file.

#ifndef PIXELMANDRIVER_H
#define PIXELMANDRIVER_H


#include "ADDriver.h"

class pixelmanDriver : public ADDriver 
{
public:
    enum PixelmanCBEvent { MPX_UNKNOWN=0x0, MPX_ACQPRESTART=0x1, MPX_ACQSTART=0x2, MPX_SINGLEACQCOMP=0x3, MPX_SERIESACQCOMP=0x4, MPX_FRAMENEW=0x5 };
private:
        struct HwInfo
        {
                HwInfoItem* item;
                int index;
                int dataSize;
                HwInfo() : item(NULL), index(-1), dataSize(0) { }
                HwInfo(HwInfoItem* item_, int index_, int dataSize_) : item(item_), index(index_), dataSize(dataSize_) { }
        };
        struct eventCBInfo
        {
                PixelmanCBEvent type;
                CBPARAM par;
                INTPTR userData;
                eventCBInfo(PixelmanCBEvent type_ = MPX_UNKNOWN, CBPARAM par_ = 0, INTPTR userData_ = 0) : type(type_), par(par_), userData(userData_) { }
        };
        struct RunEndInfo
        {
            char fileName[512];
                int fileIndex;
        };
        struct FrameInfo
        {
                FRAMEID fID; 
                ITEMID iID;
                INTPTR userData;
                FrameInfo(FRAMEID fID_ = 0, ITEMID iID_ = 0, INTPTR userData_ = 0) : fID(fID_), iID(iID_), userData(userData_) { }
        };
        epicsMessageQueue m_eventCBQueue;
        epicsMessageQueue m_runEndQueue;
        epicsMessageQueue m_frameQueue;
        std::map<std::string,HwInfo> m_hwInfo;
        std::map<int,std::string> m_paramInfo;
        epicsTimeStamp m_cmd_time;
        epicsTimeStamp m_start_time;
        epicsTimeStamp m_abort_time;

        epicsMutex m_acq_start_mutex;
        epicsMutex m_acq_abort_mutex;

        DEVID m_devId;
        FRAMEID m_currentFrameID;
        DevInfo m_devInfo;
        int m_autoRestart;
        double m_autoRestartDelay;
        bool m_cmd_running;
        bool m_start_running;
        bool m_abort_running;
        void cmdStart() { epicsTimeGetCurrent(&m_cmd_time); m_cmd_running = true; }
        void cmdEnd() { m_cmd_running = false; }

        bool m_acqRunning;

        void getHwInfo(std::ostream& os);
        void getHwItem(const std::string& name, int param);
        void getAllHwItems();
        void setHwItem(const std::string& name, int param);
        void saveFinished(int fileIndex);

public:
    enum PixelmanAcqType { ACQ_FRAME=0x1,    
                               ACQ_INTEGRAL=0x2,  
                               ACQ_ABORT=0x3  
                                                   };
        enum CameraStatus { STATUS_IDLE=0x0, 
                            STATUS_ACQUIRING=0x1,  
                                                STATUS_SAVING=0x2 
                                                };
        void pixelmanEventCB(PixelmanCBEvent e, CBPARAM par, INTPTR userData);

    pixelmanDriver(const char* portName, const char* devName);
        int getDevId() const;
        static void pollerThreadC(void* arg);
        static void saverThreadC(void* arg);
        static void pixelmanDriverRestarterC(void* arg);
        struct AcquisitionThreadArgs
        {
            pixelmanDriver* driver;
                int acq_type; 
                int numberOfAcq;
                double timeOfEachAcq;
                u32 fileFlags;
                char fileName[512];
                AcquisitionThreadArgs(pixelmanDriver* d, int at) : driver(d), acq_type(at), numberOfAcq(0), timeOfEachAcq(0.0), fileFlags(0) { fileName[0] = '\0'; }
        };
        AcquisitionThreadArgs* createAcquisitionThreadArgs(int at);
        static void acquisitionThreadC(void* arg);
        void pixelmanEventCBProcess();
        static void pixelmanEventCBProcessC(void* arg);
        void frameFilter(FRAMEID fID, ITEMID iID, INTPTR userData);
        void readFrame();
        void processFrame(u32* buffer, u32 width, u32 height);
        void acquisitionThread(AcquisitionThreadArgs* args);
    virtual asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value);
//      virtual asynStatus readInt32(asynUser *pasynUser, epicsInt32 *value);
    virtual asynStatus writeFloat64(asynUser *pasynUser, epicsFloat64 value);
//  virtual asynStatus readFloat64(asynUser *pasynUser, epicsFloat64 *value);
//      virtual asynStatus readOctet(asynUser *pasynUser, char *value, size_t maxChars, size_t *nActual, int *eomReason);
        virtual asynStatus writeOctet(asynUser *pasynUser, const char *value, size_t maxChars, size_t *nActual);
//    virtual asynStatus readFloat64Array(asynUser *pasynUser, epicsFloat64 *value, size_t nElements, size_t *nIn);
//    virtual asynStatus readInt32Array(asynUser *pasynUser, epicsInt32 *value, size_t nElements, size_t *nIn);
    virtual void setShutter(int open);
    int computeImage(epicsUInt32 *value, u32 width, u32 height);
    template <typename epicsType> 
        int computeArray(epicsUInt32* value, size_t nelements, int sizeX, int sizeY);
            
private:
        
#define FIRST_MCP_PARAM P_acqAbort

    int P_acqAbort; 
    int P_acqStart; 
    int P_trigAcqStart; 
    int P_trigAcqStop; 
    
        // these parameters control the acquisiton requested by P_startAcquisition
    int P_numberOfAcq; 
    int P_timeOfEachAcq;  // double
    int P_fileFlags; 
//    int P_fileName;  ///< string
        
    // these are status paramters from reguisteed pixelman callbacks
        int P_acqSActive; 
    int P_acqActive; 

        // these four parameters are read from pixelman using mpxCtrlGetAcqInfo() in a polling loop an reflect acuuisition status
        int P_acqType; 
        int P_acqTypeReq; 
        int P_frameFilled; 
        int P_acqTotalCount; 
        int P_acqNumber; 
    int P_frameID; 
    int P_acqMode; 
        int P_extShutMode; 
    int P_burstMode; 

        int P_hwTimer; 
        int P_saveConfig; // string
        int P_loadConfig; // string
        int P_saveDefConfig; // int
        int P_loadDefConfig; // int
        int P_acqHang; // int
        int P_hangTime; // double
        int P_autoRestart; // int
        int P_autoRestartDelay; // double
        
        int P_dataFileName; 
        int P_shutrCLKShift; 
    int P_tpxCubeBin; 
    int P_dataAcqMode; 
    int P_fileIndex; 
    int P_saveRawData; 
        int P_nShuttersPerBurst; 
        int P_nTrigsBurstRefresh; 
        int P_setPixelMode; 
        int P_cameraStatus; 
        int P_nTrigSavSub; 

    int P_devId; 

#define LAST_MCP_PARAM P_devId
                
    NDArray* m_pRaw;

        void pollerThread();
        void saverThread();
        void pixelmanDriverRestarter();
        static void printDevInfo(DevInfo* devInfo, std::ostream& os);
        void setPixelMode(unsigned mode);       
        void setADAcquire(int acquire);
        void frameProcess();

};

#define NUM_MCP_PARAMS (&LAST_MCP_PARAM - &FIRST_MCP_PARAM + 1)
 
#define P_acqAbortString                        "ABORT"
#define P_acqStartString                        "START" 
#define P_trigAcqStartString            "TRIGSTART" 
#define P_trigAcqStopString             "TRIGSTOP" 
#define P_numberOfAcqString             "NUMACQ"
#define P_timeOfEachAcqString           "ACQTIME"
#define P_fileFlagsString                       "FILEFLAGS"
//#define P_fileNameString                      "FILENAME"
#define P_acqSActiveString                      "ACQSACTIVE"
#define P_acqActiveString                       "ACQACTIVE"
#define P_acqTypeString                         "ACQTYPE"
#define P_acqTypeReqString                      "ACQTYPEREQ"
#define P_frameFilledString                     "FRAMEFILLED"
#define P_acqTotalCountString           "ACQTOTCNT"
#define P_acqNumberString                       "ACQNUM"
#define P_acqModeString                         "ACQMODE"
#define P_burstModeString                       "BURSTMODE"
#define P_extShutModeString                     "EXTSHUTMODE"
#define P_hwTimerString                         "HWTIMER"
#define P_devIdString                           "DEVID"
#define P_frameIDString                         "FRAMEID"

#define P_saveConfigString                      "SAVECONFIG"
#define P_loadConfigString                      "LOADCONFIG"
#define P_saveDefConfigString           "SAVEDEFCONFIG"
#define P_loadDefConfigString           "LOADDEFCONFIG"

#define P_acqHangString                         "ACQHANG"
#define P_hangTimeString                        "HANGTIME"
#define P_autoRestartString                     "AUTORESTART"
#define P_autoRestartDelayString        "AUTORESTARTDELAY"

#define P_dataFileNameString            "DATAFILENAME"
#define P_shutrCLKShiftString           "SHTRCLKSHIFT"
#define P_tpxCubeBinString                      "TPXCUBEBIN"
#define P_dataAcqModeString                     "DATAACQMODE"
#define P_fileIndexString                       "FILEINDEX"
#define P_saveRawDataString                     "SAVERAWDATA"
#define P_nShuttersPerBurstString       "NSHUTTERSPERBURST"
#define P_nTrigsBurstRefreshString      "NTRIGSBURSTREFRESH"
#define P_setPixelModeString            "SETPIXELMODE"
#define P_cameraStatusString            "CAMERASTATUS"

#define P_nTrigSavSubString                     "NTRIGSAVSUB"
#endif /* PIXELMANDRIVER_H */