BocCard.h

// File: BocCard.h

#ifndef SCTPIXELROD_BOCCARD_H
#define SCTPIXELROD_BOCCARD_H

#include <iostream>
#include <cmath>

#include "BocAddresses.h"
#include "RodModule.h"


namespace SctPixelRod {

    const unsigned int PRE_PRODUCTION_BOC  = 0x0;
    const unsigned int PRODUCTION_REVA_BOC = 0x1;
        const unsigned int PRODUCTION_REVB_BOC = 0x2;
        const unsigned int PRODUCTION_REVC_BOC = 0x3;


    const unsigned int MONITOR_CURRENT  = 1;
    const unsigned int MONITOR_VOLTAGE  = 2;
    const unsigned int MONITOR_TEMP     = 3;
    const unsigned int MONITOR_CHANNEL_TYPE[BOC_MONITOR_CHANNELS] = {
        MONITOR_CURRENT,
        MONITOR_CURRENT,
        MONITOR_CURRENT,
        MONITOR_CURRENT,
        MONITOR_CURRENT,
        MONITOR_CURRENT,
        MONITOR_CURRENT,
        MONITOR_CURRENT,
        MONITOR_VOLTAGE,
        MONITOR_VOLTAGE,
        MONITOR_TEMP,
        MONITOR_TEMP};

        const double iArevA = -0.04051;
        const double iBrevA = 41.52;
        const double vArevA = 0.011106;
        const double vBrevA = 0.0;
        const double tArevA = 10000.0;
        const double tBrevA = 1023.0;
        const double tC0revA = 7.4717e-4;
        const double tC1revA = 2.7726e-4;
        const double tC2revA = 6.8388e-8;

        const double iArevB = 0.02383;
        const double iBrevB = 0.0;
        const double vArevB = 0.014492;
        const double vBrevB = 0.0;
        const double tArevB = 10000.0;
        const double tBrevB = 1023.0;
        const double tC0revB = 7.4717e-4;
        const double tC1revB = 2.7726e-4;
        const double tC2revB = 6.8388e-8;

        const double iArevC = 0.02383;
        const double iBrevC = 0.0;
        const double vArevC = 0.014492;
        const double vBrevC = 0.0;
        const double tArevC = 10000.0;
        const double tBrevC = 1023.0;
        const double tC0revC = 7.4717e-4;
        const double tC1revC = 2.7726e-4;
        const double tC2revC = 6.8388e-8;


//------------------------------------------------------------------------


class BocException : public BaseException {

public:

  BocException( std::string descriptor);
  BocException( std::string descriptor, INT32 value1, INT32 value2);
  INT32 getNumData() {return m_numValue; };
  INT32 getData1() {return m_value1; };
  INT32 getData2() {return m_value2; };
  virtual void what(std::ostream&);

private:

// Number of data items
  INT32 m_numValue;
// 1st data value returned by exception
  INT32 m_value1;

// 2nd data value returned by exception
  INT32 m_value2;

// End of BocException declarations

};


//------------------------------------------------------------------------


class BocCard
{
public:

// Constructor and destructor
    BocCard(RodModule & rod );                     // Constructor
    ~BocCard();                                    // Destructor


// Accessor methods

    UINT32 getSerialNumber() {return m_serialNumber;};
    UINT32 getManufacturer() {return m_manufacturer;};
    UINT32 getModuleType() {return m_moduleType;};
    UINT32 getHardwareRevision() {return m_hardwareRevision;};
    UINT32 getFirmwareRevision() {return m_firmwareRevision;};
    RodModule* getRod() {return m_myrod;};

        void initialize();


        void reset();


/* status() reports the status of the BOC.
 * This initial version just prints the information to standard output.
 */
        void status();


        void getLaserCurrent(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
    UINT32 getLaserCurrent(const UINT32 channel) throw (BocException&);


        void setLaserCurrent(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
    void setLaserCurrent(const UINT32 channel, const UINT32 value)
                throw (BocException&);


    void getRxThreshold(const UINT32 channel, UINT32 buffer[], 
                const UINT32 numChannels) throw (BocException&);
    UINT32 getRxThreshold(const UINT32 channel) throw (BocException&);


    void setRxThreshold(const UINT32 channel, const UINT32 buffer[], 
                const UINT32 numChannels) throw (BocException&);
        void setRxThreshold(const UINT32 channel, const UINT32 value)
                throw (BocException&);


        void getRxDataDelay(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
    UINT32 getRxDataDelay(const UINT32 channel) throw (BocException&);


        void setRxDataDelay(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
        void setRxDataDelay(const UINT32 channel, const UINT32 value)
                throw (BocException&);


        void getStrobeDelay(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
    UINT32 getStrobeDelay(const UINT32 channel) throw (BocException&);


        void setStrobeDelay(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
        void setStrobeDelay(const UINT32 channel, const UINT32 value)
                throw (BocException&);


        void getBpmStreamInhibit(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
    UINT32 getBpmStreamInhibit(const UINT32 channel) throw (BocException&);


        void setBpmStreamInhibit(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&); 
        void setBpmStreamInhibit(const UINT32 channel, const UINT32 value)
                throw (BocException&);


        void getBpmMarkSpace(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
    UINT32 getBpmMarkSpace(const UINT32 channel) throw (BocException&);


        void setBpmMarkSpace(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
        void setBpmMarkSpace(const UINT32 channel, const UINT32 value)
                throw (BocException&);


        void getBpmCoarseDelay(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
    UINT32 getBpmCoarseDelay(const UINT32 channel) throw (BocException&);


        void setBpmCoarseDelay(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
        void setBpmCoarseDelay(const UINT32 channel, const UINT32 value)
                throw (BocException&);


        void getBpmFineDelay(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
    UINT32 getBpmFineDelay(const UINT32 channel) throw (BocException&);


        void setBpmFineDelay(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels) throw (BocException&);
        void setBpmFineDelay(const UINT32 channel, const UINT32 value) 
                throw (BocException&);


        UINT32 getClockControl();


        void setClockControl(const UINT32 value) throw (BocException&);


        UINT32 getRxDataMode();


        void setRxDataMode(const UINT32 value) throw (BocException&);


        UINT32 getRxDacClear();


        void clearRxDac();


        UINT32 getTxDacClear();


        void clearTxDac();


    UINT32 getVernierFinePhase();


    void setVernierFinePhase(const UINT32 value) throw (BocException&);


        UINT32 getVernierClockPhase0();


        void setVernierClockPhase0(const UINT32 value) throw (BocException&);


        UINT32 getVernierClockPhase1();


        void setVernierClockPhase1(const UINT32 value) throw (BocException&);


    UINT32 getBpmClockPhase();


    void setBpmClockPhase(const UINT32 value) throw (BocException&);


        UINT32 getBregClockPhase();


        void setBregClockPhase(const UINT32 value) throw (BocException&);


    UINT32 getBocReset();


    void resetBoc();


        UINT32 getBpmReset();


        void resetBpm();


        UINT32 getVpinReset();


        void resetVpin();


        UINT32 getBocOkReset();


        void resetBocOk();


    UINT32 getBocStatusRegister();      //Read-only register


    double getMonitorAdc(const UINT32 channel, std::string &units, 
                             std::string &type) throw (BocException&);
    double getMonitorAdc(const UINT32 channel) throw (BocException&);


    std::string getMonitorAdcUnits(const UINT32 channel) 
                                       throw (BocException&);


        std::string getMonitorAdcType(const UINT32 channel) 
                                      throw (BocException&);


    void resetMonitorAdc();

    UINT32 getInterlockStatus(UINT32 *localEnable, UINT32 *remoteEnable);
    UINT32 getInterlockStatus();

private: 


        UINT32 singleRead(const UINT32 bocAddress) throw (BocException&);
        void singleWrite(const UINT32 bocAddress, const UINT32 value) throw (BocException&);


        void blockRead(const UINT32 bocAddress,  UINT32 buffer[],
                const INT32 length);
        void blockWrite(const UINT32 bocAddress,  const UINT32 buffer[],
                const INT32 length);


    UINT32 bpmRead(const UINT32 bpm, const UINT32 stream, 
                const UINT32 offset);
    void bpmWrite(const UINT32 bpm, const UINT32 stream, 
                const UINT32 offset, const UINT32 value);


    RodModule* m_myrod;


    UINT32 m_serialNumber;


    UINT32 m_manufacturer;


    UINT32 m_moduleType;


    UINT32 m_hardwareRevision;


    UINT32 m_firmwareRevision;

    UINT32 m_bocType;

    UINT32 m_bocMask;

  }; // End of class BocCard declaration


}; // End namespace SctPixelRod

#endif  // SCTPIXELROD_BOCCARD_H

---