pit_driver_opticalLink.cpp

Go to the documentation of this file.

#include <iostream>
#include <fstream>
#include <sstream>
#include <exception>


#include "pit_driver_opticalLink.h"
#include "pit_driver_optinBoard.h"
#include "pit_driver_foChannel.h"
#include "pit_configuration.h"


const int maxSrvNameLength=256;

pit_driver_opticalLink::pit_driver_opticalLink(unsigned int p_linkNumber, pit_comm *comm_engine, pit_driver_optinBoard *OptinBoard)
{
unsigned int i;
    
    linkNumber = p_linkNumber;
    motherOptinBoard = OptinBoard;
    commFEE = comm_engine;
      
    logDriverOpticalLink = &(log4cpp::Category::getInstance("pitLog.driver")); 
    //logDriverOpticalLink->info("Constructor of pit_driver_opticalLink %d, OPTIN board %d",linkNumber,motherOptinBoard->getBoardNumber());



    // Create 10 instances of pit_driver_foChannel for the 10 pixel chips of this link
        for(i = 0; i < NUMBER_FO_CHANNELS; i++) {
              // create 10 instances of pit_driver_foChannels to model the 10 fast-or channels on each optical links
            foChannel[i] = new pit_driver_foChannel(i, commFEE, this);
        }/* end for */
        
                        // refreshes the detector coordinates to generate the services with the right name
        this->refreshDetectorCoordinates();
                        
        
    //***************** will initialize the dim services ********************************************************
        // uses the string stream class to format the values inside the srings
        char charSide;
        if (side == A) charSide = 'A';
        else charSide='C';
        
    stringstream halfStaveName;
    halfStaveName << "PIT/SIDE_"<< charSide<<"/SECTOR_"<<sector<<"/HALF_STAVE_"<<half_stave<<"/";
    
        // initializes these strings already with the halfstave name in them

    const string linkRequiredName(halfStaveName.str()+ "REQUIRED");
    const string linkLockedName(halfStaveName.str()+"LOCKED");
    const string linkActiveName( halfStaveName.str()+"ACTIVE");
    
         
                // starts the services here
                // we will see if this casting from bool to int & reference will work
        // also writes an info in the log stating the name of the services
    logDriverOpticalLink->info("creating service %s",linkLockedName.c_str());
    serviceLinkLocked = new DimService(linkLockedName.c_str(), linkLocked);     
    logDriverOpticalLink->info("creating service %s",linkActiveName.c_str());
    serviceLinkActive = new DimService(linkActiveName.c_str(), linkActive);
    logDriverOpticalLink->info("creating service %s",linkRequiredName.c_str());
    serviceLinkRequired = new DimService(linkRequiredName.c_str(), linkRequired);

    if (motherOptinBoard->IsBoardPlugged()){
                // reads the link status to update the services
        this->readLinkStatus();
        this->refreshLinkSetting();
        
    }
    else{
                // if the optin board is un plugged marks the link as not active and as not locked
        this->linkLocked=0;
        this->linkActive=0;
    }
 
        // checks if the link is required
    this->refreshLinkRequired();
        // updates all services connected with this link
    this->refreshStatusServices();
    
}// end  pit_driver_opticalLink


pit_driver_opticalLink::~pit_driver_opticalLink()
{

 
  for(unsigned int i = 0; i <  NUMBER_FO_CHANNELS; i++) delete foChannel[i];
  
  // deletes the dim services also
  delete serviceLinkActive;
  delete serviceLinkLocked;
  delete serviceLinkRequired;
  
}// end  pit_driver_opticalLink


pit_driver_foChannel& pit_driver_opticalLink::getFoChannel(unsigned int channelNum) {

     if (channelNum >= NUMBER_FO_CHANNELS ){
       logDriverOpticalLink->crit("(getFoChannel), channelNum %d out of range, opticalLink %d, board %d", channelNum, linkNumber, getBoardNumber());
       throw out_of_range("Exception from pit_driver_opticalLink::getFoChannel, channelNum out of range");
     }
     else{
       return *foChannel[channelNum];
     }

}


int pit_driver_opticalLink::refresh(){
        this->refreshLinkRequired();
        this->refreshLinkStatus();
        this->refreshLinkSetting();
        
        // now call the rfresh method of all children
        for (int foCh = 0 ; foCh < NUMBER_FO_CHANNELS; foCh ++){
                                // it does the argument as false so to not force the parent to refresh the link setting and status 10 times
                this->getFoChannel(foCh).refresh(false);
        }
        return 0;
}

void pit_driver_opticalLink::refreshDetectorCoordinates(){
                // gets the reference of the only instance
        pit_configuration &pitConf = pit_configuration::getInstance();
        
                // gets the board number from the parent
        unsigned int boardNumber = motherOptinBoard->getBoardNumber();
        sector =pitConf.getSector(boardNumber, linkNumber);
        side = pitConf.getSide(boardNumber, linkNumber);
        half_stave=pitConf.getHalfStave(boardNumber, linkNumber);
        
}

bool pit_driver_opticalLink::refreshLinkRequired(){
        pit_configuration &pitConf = pit_configuration::getInstance();
        this->linkRequired = pitConf.getLinkRequired(this->getBoardNumber(), this->getLinkNumber());
                // updates service
        this->serviceLinkRequired->updateService();
        return this->linkRequired;
}

void pit_driver_opticalLink::decodeLinkSetting(UInt32 linkSetting){
         
        logDriverOpticalLink->log(log4cpp::Priority::DEBUG, "(pit_driver_opticalLink::decodeLinkSetting): Decoding link setting register value 0x%x", linkSetting);
                        
        foMask = extractFromUInt32(0,10,linkSetting);
        udfFoPattern=extractFromUInt32(10,10,linkSetting);
        //selfMaskingEnable=extractFromUInt32(20,10,linkSetting);
        udfEnable = extractFromUInt32(20,1,linkSetting );
        linkDelay=extractFromUInt32(30,2,linkSetting);
        
        
}

/************************************************************
 * function to write the link setting register
 * used by writeFoMask, writeLinkDelay, writeUdfFoPattern
 * uses pit_comm->PITWriteRegister
***********************************************************/
int pit_driver_opticalLink::writeLinkSetting(UInt32 p_linkSetting)throw(std::exception){
        
                // address of the settings register
        UInt28 address = motherOptinBoard->getBaseAddress() + LINK_SETTING_OFFSET + linkNumber;
        
        commFEE->PITWriteWord(address,p_linkSetting);
        //if everything went fine then decodes this valus updating the internal data members 
        this->decodeLinkSetting(p_linkSetting);
                

        return 0;
}


UInt32 pit_driver_opticalLink::readLinkStatus()throw (std::exception){
        UInt32 status;
        
        UInt28 address= motherOptinBoard->getBaseAddress() + LINK_STATUS_OFFSET +linkNumber;
        commFEE->PITReadWord( address,&status);
        return status;
}

//decodes a status register into the internal data members
void pit_driver_opticalLink::decodeLinkStatus(UInt32 status){
        
        linkLocked= extractFromUInt32(0,1,status)?true:false;
        linkActive= extractFromUInt32(1,1,status)?true:false;
        
                // there is no internal method for link error, gianluca forgot or its not needed?
        //linkError== extractFromUInt32(2,1,status)?true:false; 
        
        linkPhase=extractFromUInt32(3,2,status);
        
        

}

// updates link status related services
// for the moment only two
void pit_driver_opticalLink::refreshStatusServices(void){
                // updates services
        serviceLinkActive->updateService();
        serviceLinkLocked->updateService();

                        // refreshes also the link required service
        this->refreshLinkRequired();
        
}
//updates the services connected with the status register
UInt32 pit_driver_opticalLink::refreshLinkStatus(void){
        
        UInt32 linkStatus=this->readLinkStatus();
        this->decodeLinkStatus(linkStatus);
        this->refreshStatusServices();
        return linkStatus;
        

}


UInt32 pit_driver_opticalLink::readLinkSetting()throw (std::exception){
        
        UInt32 linkSetting;
        
                // address of the settings register
        UInt28 address = motherOptinBoard->getBaseAddress() + LINK_SETTING_OFFSET + linkNumber;
        
        commFEE->PITReadWord(address,&linkSetting);
                
        return linkSetting;     
}

UInt32 pit_driver_opticalLink::refreshLinkSetting(){
        
        UInt32 linkSetting = this->readLinkSetting();
        this->decodeLinkSetting(linkSetting);
        return linkSetting;
}
bool pit_driver_opticalLink::readLinkLocked()throw(std::exception){

        this->refreshLinkStatus();
        return linkLocked;

}
        //function to get the link active
bool pit_driver_opticalLink::readLinkActive() throw(std::exception){
        this->refreshLinkStatus();
        return linkActive;
}

//function to get the link measured phase
int pit_driver_opticalLink::readLinkPhase() throw(std::exception){
this->refreshLinkStatus();
return linkPhase;
}


int pit_driver_opticalLink::readFoMask()throw(std::exception){
        
        this->refreshLinkSetting();
        return foMask;
}

//int pit_driver_opticalLink::readSelfMaskingEnable() throw(std::exception){
//      
//      this->refreshLinkSetting();
//      return selfMaskingEnable;
//}

int pit_driver_opticalLink::readUdfFoPattern()throw(std::exception){
        this->refreshLinkSetting();
        return udfFoPattern;
}

int pit_driver_opticalLink::readLinkDelay()throw(std::exception){

this->refreshLinkSetting();
return linkDelay;
}



int pit_driver_opticalLink::writeFoMask(int p_foMask)throw(std::exception){
                // read the old setting register
        UInt32 oldSetting = this->readLinkSetting();
        UInt32 newSetting = insertIntoUInt32(0,10,p_foMask, oldSetting); 
        
        this->writeLinkSetting(newSetting);
        return 0;
}

int pit_driver_opticalLink::writeUdfFoPattern(int p_udfFoPattern)throw(std::exception){
                // read the old setting register
        UInt32 oldSetting = this->readLinkSetting();
        UInt32 newSetting = insertIntoUInt32(10,10,p_udfFoPattern, oldSetting); 
        
        this->writeLinkSetting(newSetting);
        return 0;
}


int pit_driver_opticalLink::writeSelfMaskingEnable(int p_selfMaskingEnable)throw(std::exception){
        UInt32 oldSetting =this->readLinkSetting();
        UInt32 newSetting = insertIntoUInt32(20,10,p_selfMaskingEnable,oldSetting);
        
        this->writeLinkSetting(newSetting);
        return 0;
}


int pit_driver_opticalLink::writeLinkDelay(int p_linkDelay)throw(std::exception){
        UInt32 oldSetting =this->readLinkSetting();
        UInt32 newSetting = insertIntoUInt32(30,2, p_linkDelay, oldSetting);
        logDriverOpticalLink->log(log4cpp::Priority::DEBUG, "(pit_driver_opticalLink::writeLinkDelay): p_linkDelay = 0x%x, oldSetting = 0x%x, newSetting = 0x%x", p_linkDelay, oldSetting, newSetting);
                                        
        this->writeLinkSetting(newSetting);
                
        return 0;
}

int pit_driver_opticalLink::readTimeStamp(int timeStampNumber)throw(std::exception){
        // address of the timeStamp register
        UInt28 address = motherOptinBoard->getBaseAddress() + LINK_TIMESTAMP_OFFSET +linkNumber*NumberTimeStamps;
        
        UInt32 timeStamp;
        
        commFEE->PITReadWord(address,&timeStamp);
        return timeStamp;
}

int pit_driver_opticalLink::readErrorCounter()throw(std::exception){
        UInt28 address = motherOptinBoard->getBaseAddress() + LINK_ERROR_COUNTER_OFFSET +linkNumber;
                
        UInt32 errorCounter;
                
        commFEE->PITReadWord(address,&errorCounter);
        return errorCounter;
}

bool pit_driver_opticalLink::isInnerLayer()const{
        
        if (half_stave < NUMBER_HSTAVE_INNER) { return true;}
        else{ return false;     }
        
}

unsigned int pit_driver_opticalLink::getBoardNumber()const {return motherOptinBoard->getBoardNumber();}
UInt28 pit_driver_opticalLink::getBoardBaseAdress()const {return motherOptinBoard->getBaseAddress();}

int pit_driver_opticalLink::writeEnUdFastors(bool enable){
        
        UInt32 linksetting = readLinkSetting();
        UInt32 newLinkSetting = insertIntoUInt32(20,1,enable,linksetting);
        writeLinkSetting(newLinkSetting);
        //decodeLinkSetting(newLinkSetting);
        return 0;
}

bool pit_driver_opticalLink::readEnUdFastors(){
        refreshLinkSetting();
        return udfEnable;
}

---