---

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

Go to the documentation of this file.

// File: BocModule.cxx


#include "BocCard.h"

//! Namespace for the common routines for SCT and PIXEL ROD software.
namespace SctPixelRod {


//****************************class BocCard**************************
//
// Description:
//  This class provides the software interface to the BOC module.
//
// Author(s):
//  John Hill (hill@hep.phy.cam.ac.uk) - originator
//
//-------------------------------Constructor-------------------------

/*
This is the only constructor to use.
*/


BocCard::BocCard(RodModule & rod) {
  m_myrod = &rod;
  m_serialNumber = 0xFFFFFFFF;  //initialize overwrites this
}


//-------------------------------Destructor--------------------------

/*
Just remove reference to ROD. The RodModule class is not deleted, as
BocCard did not create it.
*/


BocCard::~BocCard() {
  m_myrod = 0;
}


//  Member methods


//------------------------initialize--------------------------------
/*! Initialize (sic!) the BOC - set to a well-defined state. A lot
 * of the settings in this method will be power-on defaults, but it
 * is helpful to do this explicitly.
 */

void BocCard::initialize() {


// Reset the BOC

  resetBoc();

// Get all the readonly identification information into the private
// variables

  m_serialNumber = singleRead(BOC_SERIAL_NUMBER);
  m_manufacturer = singleRead(BOC_MANUFACTURER);
  m_moduleType = singleRead(BOC_MODULE_TYPE);
  m_hardwareRevision = singleRead(BOC_HW_REV);
  m_firmwareRevision = singleRead(BOC_FW_REV);

// Initialise the two I2C streams (Rx data delays), by writing to the first
// channel in each stream (data written is not relevant)

  setRxDataDelay(0,0);          //I2C0
  setRxDataDelay(0x40,0);               //I2C1

//Set the clocks

  setClockControl(0);           //Clock Control register
  setVernierClockPhase0(0);
  setVernierClockPhase1(0);             //Two vernier clocks...
  setVernierFinePhase(0);       //...and the vernier fine phase
  setBpmClockPhase(0);          //BPM Clock Phase
  setBregClockPhase(0xC);       //Breg Clock Phase (note non-zero).

//Clear the RX and TX DACs

  clearRxDac();
  clearTxDac();

// Set all the receiver thresholds to 0xFF (ie. off!) and the data delays
// to zero.

  for(unsigned int i=0;i<BOC_RECEIVE_CHANNELS;i++) {
    setRxThreshold(i,0xFF);
    setRxDataDelay(i,0);

  }

// Set all the laser currents to 0

  for(unsigned int i=0;i<BOC_TRANSMIT_CHANNELS;i++) {
    setLaserCurrent(i,0);
  }

// Set all the strobe delays to 0. These are no longer used, so
// this is probably unnecessary, but for completeness...

  for(unsigned int i=0;i<BOC_STROBE_CHANNELS;i++) {
    setStrobeDelay(i,0);
  }
  
// Make sure the BPMs are reset before trying to set them.
 
  resetBpm();

// Now set the BPMs for all channels. The first 12 channels
// of a BPM are used by the "real" control fibres. Channels
// 12 and 13 of a BPM are used for test structures, and these
// also have to be set correctly.

  for(unsigned int i=0;i<BOC_TRANSMIT_CHANNELS;i++) {
    setBpmStreamInhibit(i,0);   //Enable all channels
    setBpmMarkSpace(i,0x13);            //Approved starting value
    setBpmCoarseDelay(i,0);
    setBpmFineDelay(i,0);
  }

//Use the private bpmWrite method for writing to BPM channels 12 and 13

  for(unsigned int i=0;i<(BOC_TRANSMIT_CHANNELS/12);i++) {
    bpmWrite(i,12,0,0x20);              //0x20 into channel 12
    bpmWrite(i,13,0,0x40);              //0x40 into channel 13
  }

//Now set the Rx Data Mode, and we should be done.

  setRxDataMode(0);

}
  
//------------------------reset-------------------------------------
/*! Reset the BOC. For now, this just issues BOC and BPM resets, until
 * it is clear what is needed to achieve a true reset.
 */

void BocCard::reset() {

  resetBoc();
  resetBpm();

}

//------------------------status------------------------------------

/*! This method reports the status of the BOC.
 *  For now, it simply prints to standard output.
 */

void BocCard::status() {

  std::cout << "status" << endl;

  std::cout << dec << " Module Type: " << m_moduleType;
  std::cout << " Serial Number: " << m_serialNumber;
  std::cout << endl;
  std::cout << " Hardware Version: " << m_hardwareRevision;
  std::cout << " Firmware Version: " << m_firmwareRevision;
  std::cout << endl;
  std::cout << hex << " Manufacturer: "   << m_manufacturer; 
  std::cout << " Status Register: " << getBocStatusRegister();
  std::cout << dec << endl;
}

//------------------------getLaserCurrent---------------------------

/*! Read one or more TX laser current settings from the BOC
 */

void BocCard::getLaserCurrent(const UINT32 channel, UINT32 buffer[],
        const UINT32 numChannels) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_LASER_DAC + (channel<<2);

  if(numChannels <= 1) {
// Use the single read method
    buffer[0] = singleRead(address);
  }
  else {
// Use the block read method
    blockRead(address, buffer, numChannels);
  }

}

UINT32 BocCard::getLaserCurrent(const UINT32 channel) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_LASER_DAC + (channel<<2);

// Use the single read method
  return singleRead(address);

}

//------------------------setLaserCurrent---------------------------

/*! Write one or more TX laser current settings to the BOC
 */

void BocCard::setLaserCurrent(const UINT32 channel, const UINT32 buffer[],
        const UINT32 numChannels) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_LASER_DAC + (channel<<2);

  if(numChannels <= 1) {
// Use the single write method
    singleWrite(address,buffer[0]);
  }
  else {
// Use the block write method
    blockWrite(address, buffer, numChannels);
  }

}

void BocCard::setLaserCurrent(const UINT32 channel, const UINT32 value) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_LASER_DAC + (channel<<2);

// Use the single write method
  singleWrite(address,value);

}

//------------------------getThreshold---------------------------

/*! Read one or more RX threshold settings from the BOC
 */

void BocCard::getRxThreshold(const UINT32 channel, UINT32 buffer[],
        const UINT32 numChannels) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_THRESHOLD_DAC + (channel<<2);

  if(numChannels <= 1) {
// Use the single read method
    buffer[0] = singleRead(address);
  }
  else {
// Use the block read method
    blockRead(address, buffer, numChannels);
  }

}

UINT32 BocCard::getRxThreshold(const UINT32 channel) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_THRESHOLD_DAC + (channel<<2);

// Use the single read method
  return singleRead(address);

}

//------------------------setThreshold---------------------------

/*! Write one or more RX threshold settings to the BOC
 */

void BocCard::setRxThreshold(const UINT32 channel, const UINT32 buffer[],
        const UINT32 numChannels) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_THRESHOLD_DAC + (channel<<2);

  if(numChannels <= 1) {
// Use the single write method
    singleWrite(address,buffer[0]);
  }
  else {
// Use the block write method
    blockWrite(address, buffer, numChannels);
  }

}

void BocCard::setRxThreshold(const UINT32 channel, const UINT32 value) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_THRESHOLD_DAC + (channel<<2);

// Use the single write method
  singleWrite(address,value);

}

//------------------------getRxDataDelay---------------------------

/*! Read one or more RX data delay settings from the BOC
 */

void BocCard::getRxDataDelay(const UINT32 channel, UINT32 buffer[],
        const UINT32 numChannels) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_DATA_DELAY + (channel<<2);

  if(numChannels <= 1) {
// Use the single read method
    buffer[0] = singleRead(address);
  }
  else {
// Use the block read method
    blockRead(address, buffer, numChannels);
  }

}

UINT32 BocCard::getRxDataDelay(const UINT32 channel) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_DATA_DELAY + (channel<<2);

  return singleRead(address);

}

//------------------------setRxDataDelay---------------------------

/*! Write one or more RX data delay settings to the BOC
 */

void BocCard::setRxDataDelay(const UINT32 channel, const UINT32 buffer[],
        const UINT32 numChannels) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_DATA_DELAY + (channel<<2);

  if(numChannels <= 1) {
// Use the single write method
    singleWrite(address,buffer[0]);
  }
  else {
// Use the block write method
    blockWrite(address, buffer, numChannels);
  }

}

void BocCard::setRxDataDelay(const UINT32 channel, const UINT32 value) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_DATA_DELAY + (channel<<2);

// Use the single write method
  singleWrite(address,value);

}

//------------------------getStrobeDelay---------------------------

/*! Read one or more strobe delay settings from the BOC. These delays
 * are probably not used in BOC1, but the registers exist...
 */

void BocCard::getStrobeDelay(const UINT32 channel, UINT32 buffer[],
        const UINT32 numChannels) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_STROBE_DELAY + (channel<<2);

  if(numChannels <= 1) {
// Use the single read method
    buffer[0] = singleRead(address);
  }
  else {
// Use the block read method
    blockRead(address, buffer, numChannels);
  }

}

UINT32 BocCard::getStrobeDelay(const UINT32 channel) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_STROBE_DELAY + (channel<<2);

// Use the single read method
  return singleRead(address);

}

//------------------------setStrobeDelay---------------------------

/*! Write one or more strobe delay settings to the BOC. These delays
 * are probably not used in BOC1, but the registers exist...
 */

void BocCard::setStrobeDelay(const UINT32 channel, const UINT32 buffer[],
        const UINT32 numChannels) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_STROBE_DELAY + (channel<<2);

  if(numChannels <= 1) {
// Use the single write method
    singleWrite(address,buffer[0]);
  }
  else {
// Use the block write method
    blockWrite(address, buffer, numChannels);
  }

}

void BocCard::setStrobeDelay(const UINT32 channel, const UINT32 value) {
//
  UINT32 address;
//
// Get the start address (relative to start of BOC window)
//
  address = BOC_STROBE_DELAY + (channel<<2);

// Use the single write method
    singleWrite(address,value);

}

//BPM public methods. Private methods are provided to access channel n on
//BPM m. The following methods hide the details of BPM channel number -
//the BPM functionality is accessed via Tx stream number. 

//------------------------getBpmStreamInhibit----------------------

/*! Read one or more BPM stream inhibits from the BOC. 
 */

void BocCard::getBpmStreamInhibit(const UINT32 channel, UINT32 buffer[],
        const UINT32 numChannels) {
//
// Use bpmRead to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  for(unsigned int i=0;i<numChannels;i++) {
    buffer[i] = bpmRead((channel+i)/12,(channel+i)%12,BOC_BPM_INHIBIT);
  }

}

UINT32 BocCard::getBpmStreamInhibit(const UINT32 channel) {
//
// Use bpmRead to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
    return bpmRead(channel/12,channel%12,BOC_BPM_INHIBIT);

}

//------------------------setBpmStreamInhibit----------------------

/*! Write one or more BPM stream inhibits to the BOC.
 */

void BocCard::setBpmStreamInhibit(const UINT32 channel, const UINT32 buffer[],
        const UINT32 numChannels) {
//
// Use bpmWrite to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  for(unsigned int i=0;i<numChannels;i++) {
    bpmWrite((channel+i)/12,(channel+i)%12,BOC_BPM_INHIBIT,buffer[i]);
  }

}

void BocCard::setBpmStreamInhibit(const UINT32 channel, const UINT32 value) {
//
// Use bpmWrite to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  bpmWrite(channel/12,channel%12,BOC_BPM_INHIBIT,value);

}

//------------------------getBpmMarkSpace--------------------------

/*! Read one or more BPM mark/space settings from the BOC.
 */

void BocCard::getBpmMarkSpace(const UINT32 channel, UINT32 buffer[],
        const UINT32 numChannels) {
//
// Use bpmRead to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  for(unsigned int i=0;i<numChannels;i++) {
    buffer[i] = bpmRead((channel+i)/12,(channel+i)%12,BOC_BPM_MARK_SPACE);
  }

}

UINT32 BocCard::getBpmMarkSpace(const UINT32 channel) {
//
// Use bpmRead to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  return bpmRead(channel/12,channel%12,BOC_BPM_MARK_SPACE);

}

//------------------------setBpmMarkSpace--------------------------

/*! Write one or more BPM mark/space settings to the BOC.
 */

void BocCard::setBpmMarkSpace(const UINT32 channel, const UINT32 buffer[],
        const UINT32 numChannels) {
//
// Use bpmWrite to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  for(unsigned int i=0;i<numChannels;i++) {
    bpmWrite((channel+i)/12,(channel+i)%12,BOC_BPM_MARK_SPACE,buffer[i]);
  }

}

void BocCard::setBpmMarkSpace(const UINT32 channel, const UINT32 value) {
//
// Use bpmWrite to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  bpmWrite(channel/12,channel%12,BOC_BPM_MARK_SPACE,value);

}

//------------------------getBpmCoarseDelay------------------------

/*! Read one or more BPM coarse delay settings from the BOC.
 */

void BocCard::getBpmCoarseDelay(const UINT32 channel, UINT32 buffer[],
        const UINT32 numChannels) {
//
// Use bpmRead to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  for(unsigned int i=0;i<numChannels;i++) {
    buffer[i] = bpmRead((channel+i)/12,(channel+i)%12,BOC_BPM_COARSE);
  }

}

UINT32 BocCard::getBpmCoarseDelay(const UINT32 channel) {
//
// Use bpmRead to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  return bpmRead(channel/12,channel%12,BOC_BPM_COARSE);

}

//------------------------setBpmCoarseDelay----------------------

/*! Write one or more BPM coarse delay settings to the BOC.
 */

void BocCard::setBpmCoarseDelay(const UINT32 channel, const UINT32 buffer[],
        const UINT32 numChannels) {
//
// Use bpmWrite to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  for(unsigned int i=0;i<numChannels;i++) {
    bpmWrite((channel+i)/12,(channel+i)%12,BOC_BPM_COARSE,buffer[i]);
  }

}

void BocCard::setBpmCoarseDelay(const UINT32 channel, const UINT32 value) {
//
// Use bpmWrite to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  bpmWrite(channel/12,channel%12,BOC_BPM_COARSE,value);

}

//------------------------getBpmFineDelay--------------------------

/*! Read one or more BPM fine delay settings from the BOC.
 */

void BocCard::getBpmFineDelay(const UINT32 channel, UINT32 buffer[],
        const UINT32 numChannels) {
//
// Use bpmRead to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  for(unsigned int i=0;i<numChannels;i++) {
    buffer[i] = bpmRead((channel+i)/12,(channel+i)%12,BOC_BPM_FINE);
  }

}

UINT32 BocCard::getBpmFineDelay(const UINT32 channel) {
//
// Use bpmRead to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  return bpmRead(channel/12,channel%12,BOC_BPM_FINE);

}

//------------------------setBpmFineDelay--------------------------

/*! Write one or more BPM fine delay settings to the BOC.
 */

void BocCard::setBpmFineDelay(const UINT32 channel, const UINT32 buffer[],
        const UINT32 numChannels) {
//
// Use bpmWrite to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  for(unsigned int i=0;i<numChannels;i++) {
    bpmWrite((channel+i)/12,(channel+i)%12,BOC_BPM_FINE,buffer[i]);
  }

}

void BocCard::setBpmFineDelay(const UINT32 channel, const UINT32 value) {
//
// Use bpmWrite to access the registers. Streams 0-11 on the BPM are used
// for "real" channels.
//
  bpmWrite(channel/12,channel%12,BOC_BPM_FINE,value);

}

// Methods to access individual registers. Whether it is the best solution
// to have a series of trivial methods is open to debate...

//------------------------getClockControl------------------------

/*! Read the Clock Control register
 */

UINT32 BocCard::getClockControl() {
//

  return singleRead(BOC_CLK_CONTROL);

}

//------------------------setClockControl------------------------

/*! Write to the Clock Control register
 */

void BocCard::setClockControl(const UINT32 value) {
//

  singleWrite(BOC_CLK_CONTROL,value);

}

//------------------------getRxDataMode--------------------------

/*! Read the Rx Data Mode register
 */

UINT32 BocCard::getRxDataMode() {
//

  return singleRead(BOC_RX_DATA_MODE);

}

//------------------------setRxDataMode--------------------------

/*! Write to the Rx Data Mode register
 */

void BocCard::setRxDataMode(const UINT32 value) {
//

  singleWrite(BOC_RX_DATA_MODE,value);

}

//------------------------getRxDacClear--------------------------

/*! Read the Rx DAC Clear register
 */

UINT32 BocCard::getRxDacClear() {
//

  return singleRead(BOC_RXDAC_CLEAR);

}

//------------------------clearRxDac-----------------------------

/*! Clear the Rx DAC. This involves writing 1 followed by 0 to
 *  the RXDAC register. A method to do a single write does not seem
 *  to be necessary, and so is not provided. 
 */

void BocCard::clearRxDac() {
//

  singleWrite(BOC_RXDAC_CLEAR,1);
  singleWrite(BOC_RXDAC_CLEAR,0);

}

//------------------------getTxDacClear--------------------------

/*! Read the Tx DAC Clear register
 */

UINT32 BocCard::getTxDacClear() {
//

  return singleRead(BOC_TXDAC_CLEAR);

}

//------------------------clearTxDac-----------------------------

/*! Clear the Tx DAC. This involves writing 1 followed by 0 to
 *  the TXDAC register. A method to do a single write does not seem
 *  to be necessary, and so is not provided.
 */

void BocCard::clearTxDac() {
//

  singleWrite(BOC_TXDAC_CLEAR,1);
  singleWrite(BOC_TXDAC_CLEAR,0);

}

//------------------------getVernierFinePhase--------------------

/*! Read the Vernier Fine Phase register
 */

UINT32 BocCard::getVernierFinePhase() {
//

  return singleRead(BOC_VERNIER_FINE_PHASE);

}

//------------------------setVernierFinePhase--------------------

/*! Write to the VernierFinePhase register
 */

void BocCard::setVernierFinePhase(const UINT32 value) {
//

  singleWrite(BOC_VERNIER_FINE_PHASE,value);

}

//------------------------getVernierClockPhase0-------------------

/*! Read the Vernier Clock Phase register 0. There are two registers
 * (0 and 1) which act in series to give a clock range of 50nsec in
 * 1 nsec steps.  
 */

UINT32 BocCard::getVernierClockPhase0() {
//

  return singleRead(BOC_VERNIER_CLK0_PHASE);

}

//------------------------setVernierClockPhase0-------------------

/*! Write to the Vernier Clock Phase register 0. There are two registers
 * (0 and 1) which act in series to give a clock range of 50nsec in
 * 1 nsec steps.
 */

void BocCard::setVernierClockPhase0(const UINT32 value) {
//

  singleWrite(BOC_VERNIER_CLK0_PHASE,value);

}

//------------------------getVernierClockPhase1-------------------

/*! Read the Vernier Clock Phase register 1. There are two registers
 * (0 and 1) which act in series to give a clock range of 50nsec in
 * 1 nsec steps.
 */

UINT32 BocCard::getVernierClockPhase1() {
//

  return singleRead(BOC_VERNIER_CLK1_PHASE);

}

//------------------------setVernierClockPhase1-------------------

/*! Write to the Vernier Clock Phase register 1. There are two registers
 * (0 and 1) which act in series to give a clock range of 50nsec in
 * 1 nsec steps.
 */

void BocCard::setVernierClockPhase1(const UINT32 value) {
//

  singleWrite(BOC_VERNIER_CLK1_PHASE,value);

}

//------------------------getBpmClockPhase-------------------

/*! Read the BPM Clock Phase register.
 */

UINT32 BocCard::getBpmClockPhase() {
//

  return singleRead(BOC_BPM_CLK_PHASE);

}

//------------------------setBpmClockPhase-------------------

/*! Write to the BPM Clock Phase register.
 */

void BocCard::setBpmClockPhase(const UINT32 value) {
//

  singleWrite(BOC_BPM_CLK_PHASE,value);

}

//------------------------getBregClockPhase-------------------

/*! Read the Breg Clock Phase register.
 */

UINT32 BocCard::getBregClockPhase() {
//

  return singleRead(BOC_BREG_CLK_PHASE);

}

//------------------------setBregClockPhase-------------------

/*! Write to the Breg Clock Phase register.
 */

void BocCard::setBregClockPhase(const UINT32 value) {
//

  singleWrite(BOC_BREG_CLK_PHASE,value);

}

//------------------------getBocReset-------------------------

/*! Read the BOC Reset register.
 */

UINT32 BocCard::getBocReset() {
//

  return singleRead(BOC_RESET);

}

//------------------------resetBoc-----------------------------

/*! Reset the BOC by writing 1 followed by 0 to the BOC Reset 
 * register. A method to write a specific value to this register
 * is not provided, as it doesn't seem to be necessary.
 */

void BocCard::resetBoc() {
//

  singleWrite(BOC_RESET,1);
  singleWrite(BOC_RESET,0);

}

//------------------------getBpmReset-------------------------

/*! Read the BPM Reset register.
 */

UINT32 BocCard::getBpmReset() {
//

  return singleRead(BOC_BPM_RESET);

}

//------------------------resetBpm-----------------------------

/*! Reset the BPMs by writing 1 followed by 0 to the BPM Reset
 * register. A method to write a specific value to this register
 * is not provided, as it doesn't seem to be necessary.
 */

void BocCard::resetBpm() {
//

  singleWrite(BOC_BPM_RESET,1);
  singleWrite(BOC_BPM_RESET,0);

}

//------------------------getBocStatusRegister----------------

/*! Read the BOC Status Register (readonly).
 */

UINT32 BocCard::getBocStatusRegister() {
//

  return singleRead(BOC_STATUS);

}


//Private methods follow

//Read/write access methods. Block read and write methods are provided,
// though in fact they use the single read and write methods. I have made
// these methods private, as the user shouldn't need to see them.
//
//------------------------singleRead-----------------------------

/*! This method reads a single 32-bit word from a BOC address
 */

UINT32 BocCard::singleRead(const UINT32 address) {
//
  UINT32 bocAddress;
  UINT32 value;
//
  bocAddress = address + BOC_ADDRESS_BASE;
  value = m_myrod->mdspSingleRead(bocAddress);
//
//Check if the BOC is busy and wait until it isn't.
//
    while(m_myrod->mdspSingleRead(RRIF_STATUS_1)&BOC_BUSY_0) {}

//
  return value;
}

//------------------------singleWrite-----------------------------

/*! This method writes a single 32-bit word to a BOC address.
 */

void BocCard::singleWrite(const UINT32 address, const UINT32 value) {
//
  UINT32 bocAddress;
//
  bocAddress = address + BOC_ADDRESS_BASE;
  m_myrod->mdspSingleWrite(bocAddress, value);
//
//Check if the BOC is busy and wait until it isn't.
//
    while(m_myrod->mdspSingleRead(RRIF_STATUS_1)&BOC_BUSY_0) {}

//

}

//------------------------blockRead-----------------------------

/*! This method reads a block of 32-bit words from a BOC. Because
 *  the setup bus is slow, we have to wait after each read until
 *  the BOC_BUSY_0 bit is cleared. Hence we use the singleRead
 *  method in a loop. 
 */

void BocCard::blockRead(const UINT32 address, UINT32 buffer[],
         const INT32 wordCount) {
//
//
  for(int i=0;i<wordCount;i++) {
    buffer[i] = singleRead(address+4*i);
  }
//

}

//------------------------blockWrite-----------------------------

/*! This method writes a block of 32-bit words to a BOC. Because
 *  the setup bus is slow, we have to wait after each read until
 *  the BOC_BUSY_0 bit is cleared. Hence we use the singleWrite
 *  method in a loop. 
 */

void BocCard::blockWrite(const UINT32 address, const UINT32 buffer[],
         const INT32 wordCount) {
//
//
  for(int i=0;i<wordCount;i++) {
    singleWrite(address+4*i,buffer[i]);
  }
//

}

//Read and write routines for BPM. These methods access a BPM via its
//internal channel numbers, and shouldn't be needed by users. They are
//useful mainly for access to the channels not used for "normal" BPM
//operations (channels 12-15 have special uses and are not mapped to
//by the Tx streams).

//------------------------bpmRead---------------------------------

/*! This method reads from a BPM location, identified by BPM #, stream #
 *  and offset.
 */

UINT32 BocCard::bpmRead(const UINT32 bpm, const UINT32 stream, 
        const UINT32 offset) {
//
  UINT32 address;
  UINT32 value;
//
// Get the address (relative to start of BOC window)
//
  address = BOC_BPM_BASE + (bpm<<8) + (stream<<4) + offset;

  value = singleRead(address);

  return value;

}

//------------------------bpmWrite--------------------------------

/*! This method writes to a BPM location, identified by BPM #, stream #
 *  and offset.
 */

void BocCard::bpmWrite(const UINT32 bpm, const UINT32 stream,
        const UINT32 offset, const UINT32 value) {
//
  UINT32 address;
//
// Get the address (relative to start of BOC window)
//
  address = BOC_BPM_BASE + (bpm<<8) + (stream<<4) + offset;

  singleWrite(address, value);

}

} // End namespace SctPixelRod

---