pit_driver_procFpga.cpp

Go to the documentation of this file.

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

#include "pit_driver_procFpga.h"
//_________________________________________________________________________________
pit_driver_procFpga::pit_driver_procFpga( pit_comm *comm_engine){

        // for the moment gets the same logger as the reat of the driver
        logProcFpga = &(log4cpp::Category::getInstance("pitLog.driver"));
        // assignes the comunication engine
        commFEE = comm_engine;


}

//_________________________________________________________________________________
pit_driver_procFpga::~pit_driver_procFpga(){

}

//_________________________________________________________________________________
UInt32 pit_driver_procFpga::readReg(UInt28 offset ){
        UInt32 reg;

        if (offset > PROC_FPGA_ADDRESS_SPACE){
                logProcFpga->error("(procFpga::readReg) address 0x%x is out of the processing fpga address space", offset);
                throw out_of_range("(procFpga::readReg) error: address out of the processing fpga address space");
        }
        commFEE->PITReadWord( PROC_FPGA_BASE_ADRESS + offset ,&reg);

        //logProcFpga->info("(procFpga::readReg) register 0x%x read value 0x%x", PROC_FPGA_BASE_ADRESS + offset, reg);
        return reg;
}

//_________________________________________________________________________________
// writes one register in the address space of the processing fpga
void pit_driver_procFpga::writeReg(UInt28 offset, UInt32 value){

        if (offset > PROC_FPGA_ADDRESS_SPACE){
                logProcFpga->error("(procFpga::writedReg) address 0x%x is out of the processing fpga address space", offset);
                throw out_of_range("(procFpga::writeReg) error: address out of the processing fpga address space");
        }

        commFEE->PITWriteWord( PROC_FPGA_BASE_ADRESS + offset , value);

}
//_________________________________________________________________________________
// sets the timer enabled
void pit_driver_procFpga::setTimerEnable(bool value){

        // this will shift the bit value to the most significante value and or it with the current timer period 
        UInt32 newValue= (value << 31) | this->readTimerPeriod();
        writeReg(PROC_FPGA_TIMER_ENABLE_OFFSET, newValue);
}
//______________________________________________________________________________________________________________
// checks if the timer is enabled
bool pit_driver_procFpga::isTimerEnabled(){

        UInt32 registerValue = readReg(PROC_FPGA_TIMER_ENABLE_OFFSET);
        return (registerValue & 0x40000000) >> 31;

}
//______________________________________________________________________________________________________________
//writes the timer period
void pit_driver_procFpga::writeTimerPeriod(UInt32 period){

        //reads the old timer enable value
        UInt32 timerEnValue = readReg(PROC_FPGA_TIMER_ENABLE_OFFSET) & 0xC0000000;

        //like this is cleans also the input period
        UInt32 registerValue = timerEnValue | (period & 0x3fffffff);
        writeReg(PROC_FPGA_TIMER_ENABLE_OFFSET, registerValue);

}
//______________________________________________________________________________________________________________
// reads one time stamp
UInt32 pit_driver_procFpga::readTimeStamp(unsigned int channel,unsigned int timeStamp){

        UInt28 address = PROC_FPGA_TIME_STAMP_OFFSET + channel*PROC_FPGA_TIME_STAMP_REG_NUMBER + timeStamp;

        return readReg(address);
}
//______________________________________________________________________________________________________________
//reads a generic counter
UInt32 pit_driver_procFpga::readCounterInGroup(unsigned int group,unsigned int counter ){

        if ( (group >= NUMBER_OPTIN) || (counter >= PROC_FPGA_N_GEN_COUNTERS) ){
                logProcFpga->error("(procFpga::readCounterInGroup) out of range: group and counter %d,%d have to be smaller than %d,%d", 
                                group, counter, NUMBER_OPTIN, PROC_FPGA_N_GEN_COUNTERS);
                throw out_of_range("(procFpga::readCounterInGroup) counter out of range");
        }

        UInt28 address = PROC_FPGA_COUNTER_GROUP_OFFSET+ group*PROC_FPGA_COUNTER_GROUP_REGISTERS + counter;

        return readReg(address);
}
//______________________________________________________________________________________________________________
void pit_driver_procFpga::writeMaxCounter(unsigned int counter, UInt32 value){ 
        if (counter >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::writeMaxCounter) out of range: max counter %d has to be smaller than %d", counter, NUMBER_OPTIN);
                throw out_of_range("(procFpga::writeMaxCounter) counter out of range");
        }
        writeReg(PROC_FPGA_MAX_COUNTER_OFFSET+counter, value);
}
//______________________________________________________________________________________________________________
//reads one status register
UInt32 pit_driver_procFpga::readStatusRegister(unsigned int regNumber){
        if (regNumber >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::readStatusRegister) out of range: status register  %d has to be smaller than %d", regNumber, NUMBER_OPTIN);
                throw out_of_range("(procFpga::readStatusRegister) status register out of range");
        }
        return readReg( PROC_FPGA_STATUS_OFFSET+regNumber);
}
//______________________________________________________________________________________________________________
//reads the settings register of one output
UInt32 pit_driver_procFpga::readSettingRegister(unsigned int regNumber){
        if (regNumber >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::readSettingRegister) out of range: settings register %d has to be smaller than %d", regNumber, NUMBER_OPTIN);
                throw out_of_range("(procFpga::readSettingRegister) settings register out of range");
        }
        return readReg( PROC_FPGA_SETTING_OFFSET+regNumber);
}
//______________________________________________________________________________________________________________
//writes the settings register of one output
void pit_driver_procFpga::writeSettingRegister(unsigned int regNumber, UInt32 value){ 
        if (regNumber >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::writeSettingRegister) out of range: settings register %d has to be smaller than %d", regNumber, NUMBER_OPTIN);
                throw out_of_range("(procFpga::writeSettingRegister) settings register out of range");
        }
        writeReg(PROC_FPGA_SETTING_OFFSET+regNumber, value);    
}
//______________________________________________________________________________________________________________
//writes the signature of one output
void pit_driver_procFpga::writeSignature(unsigned int signature, UInt32 value){
        if (signature >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::writeSignature) out of range: signature register %d has to be smaller than %d", signature, NUMBER_OPTIN);
                throw out_of_range("(procFpga::writeSignature) signature register out of range");
        }
        writeReg(PROC_FPGA_SIGNATURE_OFFSET+signature, value);
}
//______________________________________________________________________________________________________________
//reads one signature 
UInt32 pit_driver_procFpga::readSignature(unsigned int signature){

        if (signature >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::readSignature) out of range: signature register %d has to be smaller than %d", signature, NUMBER_OPTIN);
                throw out_of_range("(procFpga::readSignature) signature register out of range");
        }

        return readReg(PROC_FPGA_SIGNATURE_OFFSET+signature);
}
//______________________________________________________________________________________________________________
//writes the random perios set to one output
void pit_driver_procFpga::writeRandomPeriod(unsigned int period, UInt32 value){
        if (period >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::writeRandomPeriod) out of range: random period register %d has to be smaller than %d", period, NUMBER_OPTIN);
                throw out_of_range("(procFpga::writeRandomPeriod) random period register out of range");
        }

        writeReg(PROC_FPGA_RANDOM_PERIOD_OFFSET+period, value);
}
//______________________________________________________________________________________________________________
//reads the random period set for one output
UInt32 pit_driver_procFpga::readRandomPeriod(unsigned int period){
        if (period >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::readRandomPeriod) out of range: random period register %d has to be smaller than %d", period, NUMBER_OPTIN);
                throw out_of_range("(procFpga::readRandomPeriod) random period register out of range");
        }
        
        return readReg(PROC_FPGA_RANDOM_PERIOD_OFFSET + period);
}
//______________________________________________________________________________________________________________
//reads an output counter
UInt32 pit_driver_procFpga::readCounter(unsigned int counter){
        if (counter >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::readCounter) out of range: output counter register %d has to be smaller than %d", counter, NUMBER_OPTIN);
                throw out_of_range("(procFpga::readCounter) output counter register register out of range");
        }

        return readReg(PROC_FPGA_COUNTER_OUTPUT_OFFSET + counter);
}
//______________________________________________________________________________________________________________
// writes an output counter
void pit_driver_procFpga::writeCounter(unsigned int counter, UInt32 value){
        if (counter >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::writeCounter) out of range: output counter register %d has to be smaller than %d", counter, NUMBER_OPTIN);
                throw out_of_range("(procFpga::writeCounter) output counter register register out of range");
        }

        writeReg(PROC_FPGA_COUNTER_OUTPUT_OFFSET+counter, value);
}

//______________________________________________________________________________________________________________
// writes the minimum counter of one output
void pit_driver_procFpga::writeMinCounter(unsigned int counter, UInt32 value){ 
        
        if (counter >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::writeMinCounter) out of range: min counter register %d has to be smaller than %d", counter, NUMBER_OPTIN);
                throw out_of_range("(procFpga::writeMinCounter) min counter register register out of range");
        }
        writeReg(PROC_FPGA_MIN_COUNTER_OFFSET+counter, value);
}
//______________________________________________________________________________________________________________
//reads the minimum counter of one output
UInt32 pit_driver_procFpga::readMinCountert(unsigned int counter){
        if (counter >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::readMinCountert) out of range: min counter register %d has to be smaller than %d", counter, NUMBER_OPTIN);
                throw out_of_range("(procFpga::readMinCountert) min counter register register out of range");
        }
        return readReg(PROC_FPGA_MIN_COUNTER_OFFSET + counter);
}
//______________________________________________________________________________________________________________
//reads the max counter of one output
UInt32 pit_driver_procFpga::readMaxCounter(unsigned int counter){
        if (counter >= NUMBER_OPTIN){
                logProcFpga->error("(procFpga::readMaxCounter) out of range: max counter register %d has to be smaller than %d", counter, NUMBER_OPTIN);
                throw out_of_range("(procFpga::readMaxCounter) max counter register register out of range");
        }
        return readReg(PROC_FPGA_MAX_COUNTER_OFFSET + counter);
}
//______________________________________________________________________________________________________________
// reads the mode of one output
pit_trigger_mode pit_driver_procFpga::readTriggerMode(unsigned int output){
        if (output >= NUMBER_FO_CHANNELS){
                logProcFpga->error("(procFpga::readTriggerMode)error output index as to be smaller than 10");
                throw out_of_range ("(procFpga::readTriggerMode)error output index as to be smaller than 10");
        }
        
                // reads the modes register
        UInt32 modes= readReg(PROC_FPGA_OUTPUT_MODE_OFFSET);
                // extracts the 2 bits of this mode
        pit_trigger_mode out= (pit_trigger_mode)extractFromUInt32(2*output,2,modes);
        return out;
}
//______________________________________________________________________________________________________________
// writes the mode of one output
void pit_driver_procFpga::writeTriggerMode(unsigned int output, pit_trigger_mode value){
        
        if (output >= NUMBER_FO_CHANNELS){
                logProcFpga->error("(procFpga::writeTriggerMode)error output index as to be smaller than 10");
                throw out_of_range ("(procFpga::writeTriggerMode)error output index as to be smaller than 10");
        }
                // reads the modes register
        UInt32 modes= readReg(PROC_FPGA_OUTPUT_MODE_OFFSET);
                // inserts the bits generating a new value
        UInt32 newValue=insertIntoUInt32( 2*output,2,value,modes);
        writeReg(PROC_FPGA_OUTPUT_MODE_OFFSET, newValue);
        
}

//______________________________________________________________________________________________________________
// writes the mode of one output using a string as an input
void pit_driver_procFpga::writeTriggerMode(unsigned int output, const string &mode){
        pit_trigger_mode outMode;
        
        if (mode=="normal")             outMode = Trigger_Normal;
        else if (mode=="toggle")        outMode = Trigger_Toggle;
        else if (mode=="signature") outMode = Trigger_Signature;
        else if (mode=="random")        outMode = Trigger_Random;
        else {
                logProcFpga->error("(procFpga::writeTriggerMode)error: mode as to be normal, toggle, signature or random");
                throw out_of_range("(procFpga::writeTriggerMode)error: mode as to be normal, toggle, signature or random");
        }
        
        writeTriggerMode(output, outMode);
}
//______________________________________________________________________________________________________________
// reads the mode of one output
std::string pit_driver_procFpga::readStrTriggerMode(unsigned int output){
        
                // reads the modes register
        pit_trigger_mode mode = readTriggerMode(output);

        switch(mode){
        case Trigger_Normal: return "normal";
        case Trigger_Toggle: return "toggle";
        case Trigger_Signature: return "signature";
        case Trigger_Random: return "random";
                        
        }
        return "";
}

---