---

/var/pcce/usera/hill/rcc_1.2/RodDaq/RodCrate/BocCard.h

Go to the documentation of this file.

// File: BocModule.h

#ifndef SCTPIXELROD_BOCCARD_H
#define SCTPIXELROD_BOCCARD_H

#include <iostream>

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

namespace SctPixelRod {

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

//! BocCard: A class for setting-up etc. the BOC.

/*! @class BocCard
 *
 * @brief This class contains the methods to set up a BOC. The name
 * BocCard was chosen because the possibly more obvious "BocModule"
 * implies that this class is derived from VmeModule. In fact it relies on
 * RodModule for the interface to the BOC.  

 @author John Hill (hill@hep.phy.cam.ac.uk) - originator
*/

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;};

/*! initialize() sets the BOC into a well-defined state. Power-on should
 *  set the BOC into much the same state, but we may wish to do this to
 *  recover that state without power cycling.

 *  Activities:
 *     Reset the BOC
 *     Read the read-only registers
 *     Set clock registers
 *     Initialize the I2C busses by writing to each in turn
 *     Set 0xFF into the Rx thresholds
 *     Set 0x00 into the data delays, strobe delays and laser current DACs
 *     Reset the BPM12 chips
 *     Set the defaults values for the BPM12 chips (including the test
 *     structures).
*/
        void initialize();


/*! reset() issues a BOC reset
*/
        void reset();


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


/*! getLaserCurrent() reads the contents of one or more Tx laser current
 * DACs. The method is overloaded to return either a number of consecutive
 * channels from a starting channel number in a buffer, or a single channel
 * via the method return value.
*/
        void getLaserCurrent(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels);
        UINT32 getLaserCurrent(const UINT32 channel);


/*! setLaserCurrent() writes the contents of one or more Tx laser current
 * DACs. The method is overloaded to write either a number of consecutive
 * channels from a starting channel number, or a single channel.
*/
        void setLaserCurrent(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels);
        void setLaserCurrent(const UINT32 channel, const UINT32 value);


/*! getRxThreshold() reads the contents of one or more Rx threshold
 * DACs. The method is overloaded to return either a number of consecutive
 * channels from a starting channel number in a buffer, or a single channel
 * via the method return value.
*/
        void getRxThreshold(const UINT32 channel, UINT32 buffer[], 
                const UINT32 numChannels);
        UINT32 getRxThreshold(const UINT32 channel);


/*! setRxThreshold() writes the contents of one or more Rx threshold
 * DACs. The method is overloaded to write either a number of consecutive
 * channels from a starting channel number, or a single channel.
*/
        void setRxThreshold(const UINT32 channel, const UINT32 buffer[], 
                const UINT32 numChannels);
        void setRxThreshold(const UINT32 channel, const UINT32 value);


/*! getRxDataDelay() reads the contents of one or more Rx data delay
 * registers. The method is overloaded to return either a number of consecutive
 * channels from a starting channel number in a buffer, or a single channel
 * via the method return value.
*/
        void getRxDataDelay(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels);
        UINT32 getRxDataDelay(const UINT32 channel);


/*! setRxDataDelay() writes the contents of one or more Rx data delay
 * registers. The method is overloaded to write either a number of consecutive
 * channels from a starting channel number, or a single channel.
*/
        void setRxDataDelay(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels);
        void setRxDataDelay(const UINT32 channel, const UINT32 value);


/*! getRxStrobeDelay() reads the contents of one or more Rx strobe delay
 * registers. The method is overloaded to return either a number of consecutive
 * channels from a starting channel number in a buffer, or a single channel
 * via the method return value.
*/
        void getStrobeDelay(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels);
        UINT32 getStrobeDelay(const UINT32 channel);


/*! setRxStrobeDelay() writes the contents of one or more Rx strobe delay
 * registers. The method is overloaded to write either a number of consecutive
 * channels from a starting channel number, or a single channel.
*/
        void setStrobeDelay(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels);
        void setStrobeDelay(const UINT32 channel, const UINT32 value);


/*! getBpmStreamInhibit() reads the contents of one or more BPM stream inhibit
 * registers. The method is overloaded to return either a number of consecutive
 * channels from a starting channel number in a buffer, or a single channel
 * via the method return value. "Channel" refers to the BOC channel number -
 * the BPM stream number mapping is dealt with internally.
*/
        void getBpmStreamInhibit(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels);
        UINT32 getBpmStreamInhibit(const UINT32 channel);


/*! setBpmStreamInhibit() writes the contents of one or more BPM stream inhibit
 * registers. The method is overloaded to write either a number of consecutive
 * channels from a starting channel number, or a single channel.
 * "Channel" refers to the BOC channel number - the BPM stream number mapping
 * is dealt with internally.
*/
        void setBpmStreamInhibit(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels);
        void setBpmStreamInhibit(const UINT32 channel, const UINT32 value);


/*! getBpmMarkSpace() reads the contents of one or more BPM mark/space
 * registers. The method is overloaded to return either a number of consecutive
 * channels from a starting channel number in a buffer, or a single channel
 * via the method return value. "Channel" refers to the BOC channel number -
 * the BPM stream number mapping is dealt with internally.
*/
        void getBpmMarkSpace(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels);
        UINT32 getBpmMarkSpace(const UINT32 channel);


/*! setBpmMarkSpace() writes the contents of one or more BPM mark/space
 * registers. The method is overloaded to write either a number of consecutive
 * channels from a starting channel number, or a single channel.
 * "Channel" refers to the BOC channel number - the BPM stream number mapping
 * is dealt with internally.
*/
        void setBpmMarkSpace(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels);
        void setBpmMarkSpace(const UINT32 channel, const UINT32 value);


/*! getBpmCoarseDelay() reads the contents of one or more BPM coarse delay
 * registers. The method is overloaded to return either a number of consecutive
 * channels from a starting channel number in a buffer, or a single channel
 * via the method return value. "Channel" refers to the BOC channel number -
 * the BPM stream number mapping is dealt with internally.
*/
        void getBpmCoarseDelay(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels);
        UINT32 getBpmCoarseDelay(const UINT32 channel);


/*! setBpmCoarseDelay() writes the contents of one or more BPM coarse delay
 * registers. The method is overloaded to write either a number of consecutive
 * channels from a starting channel number, or a single channel.
 * "Channel" refers to the BOC channel number - the BPM stream number mapping
 * is dealt with internally.
*/
        void setBpmCoarseDelay(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels);
        void setBpmCoarseDelay(const UINT32 channel, const UINT32 value);


/*! getBpmFineDelay() reads the contents of one or more BPM fine delay
 * registers. The method is overloaded to return either a number of consecutive
 * channels from a starting channel number in a buffer, or a single channel
 * via the method return value. "Channel" refers to the BOC channel number -
 * the BPM stream number mapping is dealt with internally.
*/
        void getBpmFineDelay(const UINT32 channel, UINT32 buffer[],
                const UINT32 numChannels);
        UINT32 getBpmFineDelay(const UINT32 channel);


/*! setBpmFineDelay() writes the contents of one or more BPM fine delay
 * registers. The method is overloaded to write either a number of consecutive
 * channels from a starting channel number, or a single channel.
 * "Channel" refers to the BOC channel number - the BPM stream number mapping
 * is dealt with internally.
*/
        void setBpmFineDelay(const UINT32 channel, const UINT32 buffer[],
                const UINT32 numChannels);
        void setBpmFineDelay(const UINT32 channel, const UINT32 value);


/*! getClockControl() reads the contents of the Clock Control register.
*/
        UINT32 getClockControl();


/*! setClockControl() writes the contents of the Clock Control register.
*/
        void setClockControl(const UINT32 value);


/*! getRxDataMode() reads the contents of the Data Mode register.
*/
        UINT32 getRxDataMode();


/*! setRxDataMode() writes the contents of the Data Mode register.
*/
        void setRxDataMode(const UINT32 value);


/*! getRxDacClear() reads the contents of the Rx Dac Clear register.
*/
        UINT32 getRxDacClear();


/*! clearRxDac() clears the Rx Dac register by writing 1 followed by
 *  0 to the register. A method to write a specific value to the register
 *  is not provided, as this is not a meaningful operation for the user.
*/
        void clearRxDac();


/*! getTxDacClear() reads the contents of the Tx Dac Clear register.
*/
        UINT32 getTxDacClear();


/*! clearTxDac() clears the Tx Dac register by writing 1 followed by
 *  0 to the register. A method to write a specific value to the register
 *  is not provided, as this is not a meaningful operation for the user.
*/
        void clearTxDac();


/*! getVernierFinePhase() reads the contents of the Vernier Fine Phase
 * register.
*/
        UINT32 getVernierFinePhase();


/*! setVernierFinePhase() writes the contents of the Vernier Fine Phase
 * register.
*/
        void setVernierFinePhase(const UINT32 value);


/*! getVernierClockPhase0() reads the contents of the Vernier Clock Phase
 * register 0. This is one of two clock phase registers allowing the user
 * to set a delay of up to 50 nsec.
*/
        UINT32 getVernierClockPhase0();


/*! setVernierClockPhase0() writes the contents of the Vernier Clock Phase
 * register 0. This is one of two clock phase registers allowing the user
 * to set a delay of up to 50 nsec.
*/
        void setVernierClockPhase0(const UINT32 value);


/*! getVernierClockPhase1() reads the contents of the Vernier Clock Phase
 * register 1. This is one of two clock phase registers allowing the user
 * to set a delay of up to 50 nsec.
*/
        UINT32 getVernierClockPhase1();


/*! setVernierClockPhase1() writes the contents of the Vernier Clock Phase
 * register 1. This is one of two clock phase registers allowing the user
 * to set a delay of up to 50 nsec.
*/
        void setVernierClockPhase1(const UINT32 value);


/*! getBpmClockPhase() reads the contents of the BPM Clock Phase register.
*/
        UINT32 getBpmClockPhase();


/*! setBpmClockPhase() writes the contents of the BPM Clock Phase register.
*/
        void setBpmClockPhase(const UINT32 value);


/*! getBregClockPhase() reads the contents of the BREG Clock Phase register.
*/
        UINT32 getBregClockPhase();


/*! setBregClockPhase() writes the contents of the BREG Clock Phase register.
*/
        void setBregClockPhase(const UINT32 value);


/*! getBocReset() reads the contents of the BOC Reset register.
*/
        UINT32 getBocReset();


/*! resetBoc() resets the BOC by writing 1 followed by 0 to the Reset register.
 *  A method to write a specific value to the register is not provided as
 *  this would not be a useful operation.
*/
        void resetBoc();


/*! getBpmReset() reads the contents of the BPM Reset register.
*/
        UINT32 getBpmReset();


/*! resetBpm() resets the BPM registers on the BOC by writing 1 followed by 0 
 *  to the BPM Reset register. A method to write a specific value to the
 *  register is not provided as this would not be a useful operation.
*/
        void resetBpm();


/*! getBocStatusRegister() reads the contents of the BOC Status register.
 *  This is a readonly register, hence there is no "set" method provided.
*/

        UINT32 getBocStatusRegister();          //Read-only register

private: 


//! Read and write to single BOC registers
        UINT32 singleRead(const UINT32 bocAddress);
        void singleWrite(const UINT32 bocAddress, const UINT32 value);


//! Read and write to a block of BOC registers
        void blockRead(const UINT32 bocAddress,  UINT32 buffer[],
                const INT32 length);
        void blockWrite(const UINT32 bocAddress,  const UINT32 buffer[],
                const INT32 length);


//! Read and write to BPM streams
        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);


//! Handle for the ROD through which this BOC is accessed.
        RodModule* m_myrod;


//! BOC serial number (read in initialize method). Set on a pair of hex switches.
        UINT32 m_serialNumber;


//! BOC manufacturer (read in initialize method). Should be 0xCB.
        UINT32 m_manufacturer;


//! BOC module type (read in initialize method). Should be 0x2C.
        UINT32 m_moduleType;


//! BOC hardware revision (read in initialize method).
        UINT32 m_hardwareRevision;


//! BOC firmware revision (read in initialize method).
        UINT32 m_firmwareRevision;


  }; // End of class BocCard declaration


}; // End namespace SctPixelRod

#endif  // SCTPIXELROD_BOCCARD_H

---