pit_driver.cpp

Go to the documentation of this file.

#include <iostream>
#include <fstream>
#include <sstream>
#include <log4cpp/BasicConfigurator.hh>
#include <log4cpp/Category.hh>
#include <log4cpp/CategoryStream.hh>


#include "pit_driver.h"
#include "pit_def.h"
#include "pit_comm.h"
#include "pit_driver_optinBoard.h"
#include "pit_driver_opticalLink.h"
#include "pit_configuration.h"
#include "pit_comm_exception.h"


using namespace std;

pit_driver::pit_driver(){

    logDriver = &(log4cpp::Category::getInstance("pitLog.driver")); 
    logDriver->info("*************************** Starting DRIVER layer *****************************");

      // creates an instance of commlayer object    
    commFEE = new pit_comm();

    
    // Query hardware for version number, if no answer then hardware comm problem!
    //logDriver->info("pit_driver::pit_driver() - Reading the brain card firmware version ");
    try { 
        readFpgaFirmwareVersion(); 
        logDriver->log(log4cpp::Priority::INFO, "pit_driver::pit_driver() - Firmware version read,hardware accessible." );
       
    }
    catch(...)  {       
        logDriver->error("pit_driver::pit_driver() - Hardware access problem, check the hardware ");  
    }

    procFPGA =  new pit_driver_procFpga( commFEE); 
    // creates all instances for optin boards (12 instances)
    for(unsigned int i = 0; i < NUMBER_OPTIN; i++) { 
        optinBoard[i] = new pit_driver_optinBoard(i, commFEE); 
    }/* end for */
   
    
    
    // ************** will start dim services and commands here*************************************
                // starts the general command, for the moment this will parse a string getting all the parameters 
    cmdReturn = -1;
    commandGenericCmd = new DimCommand(GENERIC_CMD_NAME, "C");
                // the return is always a integer, not an array or anything like it
    serviceCmdAnswer= new DimService( GENERIC_CMD_SERVICE, cmdReturn);
    serviceCmdStatus= new DimService(GENERIC_CMD_STATUS_SERVICE,  "NO_COMMAND");
    
    
}// end pit_driver

//____________________________________________________________________________________________
pit_driver::~pit_driver(void){
unsigned int i;


      // delete all instances of optin boards (12 instances)
    for(i = 0; i < NUMBER_OPTIN; i++) { 
        delete optinBoard[i]; 
    }/* end for */
    logDriver->info("(pit_driver::~pit_driver()) optinBoard instances deleted");

    // delete communication object
    delete commFEE;
    logDriver->info("(pit_driver::~pit_driver()) communication ojbject instance deleted");

        // deletes commands and services
    delete commandGenericCmd;
    delete serviceCmdAnswer;
    delete serviceCmdStatus;
    logDriver->info("(pit_driver::~pit_driver()) General DIM commands and services deleted");

    logDriver->info("(pit_driver::~pit_driver()) PIT DRIVER down ***************************");

}// end ~pit_driver

unsigned int pit_driver::readFpgaFirmwareVersion(){
        
        fpgaFirmwareVersion = commFEE->PITGetVersion();
        return fpgaFirmwareVersion;
        
}

//____________________________________________________________________________________________
// returns the optin board object
pit_driver_optinBoard & pit_driver::getOptinBoard(unsigned int optinBoardNumber){
        if (optinBoardNumber >= NUMBER_OPTIN){
                logDriver->crit("(getOptinBoard):out of range, optinBoardNumber %d", optinBoardNumber);
                        // for the moment lets leave the exception here , later we will check with gianluca
                throw out_of_range("Exception from pit_driver::getOptinBoard, optinBoardNumber out of range");
        }
        
        else return *optinBoard[optinBoardNumber];
}
//____________________________________________________________________________________________
// refreshes al internal menbers and status bits calls also the refresh method of all children
int pit_driver::refresh(){
        
        logDriver->info("refreshing the status of the driver");
        
                        // checks the stats of the comm layer
        this->statusSIULink = commFEE->PITCheckCommStatus();
        
        for (int optin = 0 ; optin< NUMBER_OPTIN ; optin ++){
                this->getOptinBoard(optin).refresh();
        }
        
        return 0;
}


//____________________________________________________________________________________________
// parses and executes a command 
int pit_driver::executeCommand(const char *inStr ){
        
        string command;
        cmdReturn=0;
        
        try{
                //this->logDriver->info("received command: %s", inStr);
                // what kind of name is this, I should change it did not remember anything better :(
                stringstream inputStream(inStr);

                // parses the first white space separated argument in this case the command
                inputStream>> command;

                // tell that it is currently executing a command
                serviceCmdStatus->updateService(CMD_STATUS_EXECUTING);

                //****************************** commands for the global pit driver instance ************************
                if (command == CMD_REFRESH_GLOBAL_STATUS){
                        this->refresh();
                }
                else if (command==CMD_READ_WORD){

                        // now will parse the input acording to the type of command 
                        // read word command only has one argument which is the adress 
                        UInt32 address,dataIn;
                        inputStream>> hex >> address;

                        commFEE->PITReadBlock( address,1 ,&dataIn );
                        cmdReturn = (int) dataIn;
                        logDriver->log(log4cpp::Priority::DEBUG,"(pit_driver::executeCommand()): Address read 0x%x, value 0x%x", address, cmdReturn);
                }
                else if (command==CMD_WRITE_WORD){
                        UInt32 address, dataOut;
                        inputStream >>hex >>address>> dataOut;

                        commFEE->PITWriteBlock(address,1 ,&dataOut);
                        logDriver->log(log4cpp::Priority::DEBUG,"(pit_driver::executeCommand()): Address write 0x%x, value 0x%x", address, dataOut);

                }
                // maybe tis command will be usefull
                else if (command == CMD_CHECK_BOARD_PLUGGED){
                        int boardNumber;
                        inputStream>>dec >> boardNumber;
                        pit_driver_optinBoard optinBoard = this->getOptinBoard(boardNumber);
                        cmdReturn = optinBoard.IsBoardPlugged();
                }
                else if (command == CMD_LOAD_REQUIRED_CHANNELS_FILE){
                        string filename;
                        inputStream>> filename;

                        pit_configuration &conf =  pit_configuration::getInstance();
                        conf.openRequiredChannelsFile(filename.c_str());

                        this->refresh();
                }
                else if (command == CMD_RESET_SIU){

                        this->commFEE->PITrorcReset();  
                }
                
                else if (command == CMD_MEMORY_ACCESS_TEST ){
                        unsigned int blockLength, initialAddress, finalAddres, repetitions, addressIncrement;
                        
                        inputStream>>dec >> blockLength>>hex >>initialAddress>>hex >>finalAddres>> dec >>addressIncrement >> dec >> repetitions ;

                        cmdReturn = this->pitMemoryAccessTest(blockLength, initialAddress, finalAddres, repetitions, addressIncrement); 
                }
                /**************************************** Processing FPGA Area *******************************/
                else if (command == CMD_PROC_START_COUNTER){
                        this->procFPGA->startCounter();
                        
                }
                else if(command ==CMD_PROC_STOP_COUNTER ){
                        this->procFPGA->stopCounter();
                }
                else if (command == CMD_WRITE_PROC_CMD_REG){
                        UInt32 value;
                        inputStream >>hex >>value;
                        this->procFPGA->writeCmdReg(value);
                }
                else if (command == CMD_READ_PROC_CMD_REG){
                        cmdReturn = this->procFPGA->readCmdReg();
                }
                else if (command == CMD_READ_PROC_STATUS){
                        int channel;
                        inputStream >> channel;
                        cmdReturn=this->procFPGA->readStatusRegister(channel);
                }
                else if (command == CMD_READ_PROC_SETTINGS_REGISTER){
                        int channel;
                        inputStream >> channel;
                        cmdReturn=this->procFPGA->readSettingRegister( channel);
                }
                else if (command == CMD_WRITE_PROC_SETTINGS_REGISTER){
                        int channel;
                        UInt32 value;
                        inputStream >> channel>> hex>>value;
                        this->procFPGA->writeSettingRegister( channel, value);
                        
                }
                else if (command == CMD_READ_PROC_COUNTER){
                        int channel;
                        inputStream >> channel;
                        cmdReturn=this->procFPGA->readCounter( channel);
                }
                else if (command == CMD_SET_PROC_TIMER_ENABLE){
                        bool value;
                        inputStream >> value;
                        this->procFPGA->setTimerEnable( value);
                }
                else if (command==CDM_READ_PROC_TIMER_PERIOD){
                        
                        cmdReturn = this->procFPGA->readTimerPeriod();
                }
                else if (command == CMD_WRITE_PROC_TIMER_PERIOD){
                        UInt32 value;
                        inputStream>>hex>>value;
                        this->procFPGA->writeTimerPeriod(value);
                        
                }
                else if(command == CMD_READ_PROC_GEN_COUNTER){
                        int counter, group;
                        inputStream >>group>>counter;
                        cmdReturn=this->procFPGA->readCounterInGroup(group, counter);
                }
                else if (command == CMD_READ_PROC_TIME_STAMP){
                        int optin, timeStamp;
                        inputStream>>optin>>timeStamp;
                        cmdReturn=this->procFPGA->readTimeStamp(optin,timeStamp);
                }
                else if (command == CMD_READ_PROC_SIGNATURE){
                        int signatureIndex;
                        inputStream>> signatureIndex;
                        cmdReturn=this->procFPGA->readSignature(signatureIndex);
                }
                else if (command == CMD_WRITE_PROC_SIGNATURE){
                        int signatureIndex;
                        UInt32 value;
                        inputStream>> signatureIndex>>hex>> value;
                        this->procFPGA->writeSignature(signatureIndex, value);
                        
                }
                else if (command == CMD_WRITE_PROC_TRIGGER_MODE){
                        unsigned int output;
                        string mode;

                        inputStream>> output>> mode;

                        this->procFPGA->writeTriggerMode(output, mode);
                }
                else if (command == CMD_READ_PROC_TRIGGER_MODE){
                        unsigned int output;
                        inputStream>> output;

                        cmdReturn = this->procFPGA->readTriggerMode(output);
                }
                
                /**************************************** Optin board link area ******************************/
                else if (command == CMD_REFRESH_OPTIN_STATUS){
                        pit_driver_optinBoard & optinBoard = this->getOptinBoardFromStream(inputStream);
                        optinBoard.refresh();
                }

                else if (command == CMD_READ_TIME_STAMP){
                        pit_driver_optinBoard & optinBoard = this->getOptinBoardFromStream(inputStream);
                        unsigned int timeStampNumber;
                        inputStream>>timeStampNumber;
                        cmdReturn =optinBoard.readTimeStamp(timeStampNumber);
                }
                else if (command == CMD_READ_MAX_FASTOR_COUNTS ){
                        pit_driver_optinBoard & optinBoard = this->getOptinBoardFromStream(inputStream);
                        unsigned int chip, layer;
                        inputStream>>layer>> chip;
                        cmdReturn=optinBoard.readMaxFastorCounts( layer, chip);

                }
                else if (command == CMD_READ_MIN_FASTOR_COUNTS ){
                        pit_driver_optinBoard & optinBoard = this->getOptinBoardFromStream(inputStream);
                        unsigned int chip, layer;
                        inputStream>> layer>> chip;
                        cmdReturn=optinBoard.readMinFastorCounts(layer, chip);

                }
                else if (command == CMD_WRITE_MAX_FASTOR_COUNTS ){
                        pit_driver_optinBoard & optinBoard = this->getOptinBoardFromStream(inputStream);
                        unsigned int chip, layer, value;
                        inputStream>> layer>> chip>>value;
                        cmdReturn=optinBoard.writeMaxFastorCounts(layer, chip, value);

                }
                else if (command == CMD_WRITE_MIN_FASTOR_COUNTS){
                        pit_driver_optinBoard & optinBoard = this->getOptinBoardFromStream(inputStream);
                        unsigned int chip, layer, value;
                        inputStream>> layer>> chip>>value;
                        cmdReturn=optinBoard.writeMinFastorCounts(layer, chip, value);

                }
                //**************************************** Optical link area ******************************
                else if (command == CMD_REFRESH_LINK_STATUS){
                        pit_driver_opticalLink &opticalLink=getLinkFromStream(inputStream);
                        opticalLink.refreshLinkStatus();

                }

                else if (command == CMD_READ_FO_MASK){
                        pit_driver_opticalLink &opticalLink=getLinkFromStream(inputStream);
                        cmdReturn = opticalLink.readFoMask();

                }
                else if (command == CMD_READ_LINK_DELAY){               
                        pit_driver_opticalLink &opticalLink=getLinkFromStream(inputStream);
                        cmdReturn= opticalLink.readLinkDelay();
                }
                else if (command == CMD_WRITE_LINK_DELAY) {
                        int p_linkDelay = 0;

                        pit_driver_opticalLink &opticalLink=getLinkFromStream(inputStream);

                        inputStream >> p_linkDelay;
                        cmdReturn = opticalLink.writeLinkDelay(p_linkDelay);
                }
                else if (command == CMD_READ_LINK_PHASE){               
                        pit_driver_opticalLink &opticalLink=getLinkFromStream(inputStream);
                        cmdReturn= opticalLink.readLinkPhase();
                }
                else if (command == CMD_READ_ERROR_COUNTER){    
                        pit_driver_opticalLink &opticalLink=getLinkFromStream(inputStream);
                        cmdReturn = opticalLink.readErrorCounter();

                }
                //              else if (command == CMD_READ_SELF_MASKING_ENABLE){
                //                      //pit_driver_opticalLink &opticalLink=getLinkFromStream(inputStream);
                //                      //cmdReturn = opticalLink.readSelfMaskingEnable();
                //              }
                else if (command == CMD_READ_UDF_ENABLE){
                        pit_driver_opticalLink &opticalLink=getLinkFromStream(inputStream);
                        cmdReturn = opticalLink.readEnUdFastors();
                }
                else if (command == CMD_WRITE_UDF_ENABLE){

                        bool udfEnable;
                        pit_driver_opticalLink &opticalLink=getLinkFromStream(inputStream);

                        inputStream>> udfEnable;
                        cmdReturn = opticalLink.writeEnUdFastors(udfEnable);
                }
                //************************************ fastor channel Area *********************************************
                else if (command == CMD_READ_FO_COUNTER){
                        pit_driver_foChannel & foChannel=getFoChannelFromStream(inputStream);
                        cmdReturn =(int)foChannel.readCounter();
                }

                else if (command == CMD_ASSIGN_CHIP_FOMASK){
                        pit_driver_foChannel & foChannel=getFoChannelFromStream(inputStream);
                        bool chipMaskValue = false;
                        inputStream >> chipMaskValue;
                        foChannel.setMask(chipMaskValue); 
                }
                else if (command == CMD_CLEAR_CHIP_FOMASK){
                        pit_driver_foChannel & foChannel=getFoChannelFromStream(inputStream);
                        foChannel.setMask(false);
                }               

                else if (command == CMD_FORCE_FO_CHANNEL){

                        pit_driver_foChannel & foChannel=getFoChannelFromStream(inputStream);
                        bool force;
                        inputStream >>force;
                        foChannel.forceHigh(force);
                }
                else if (command == CMD_RELEASE_FO_CHANNEL){
                        pit_driver_foChannel & foChannel=getFoChannelFromStream(inputStream);
                        foChannel.forceHigh(false);
                }                                               

                // command was not recognized
                else{
                        serviceCmdStatus->updateService(CMD_STATUS_FAILED);
                        logDriver->error("(pit_driver::executeCommand()): unrecognized command %s", command.c_str());
                        return -1;
                }

                serviceCmdAnswer->updateService();
                serviceCmdStatus->updateService(CMD_STATUS_FINISHED);
                logDriver->info("(pit_driver::executeCommand()): executed command %s, last command answer: 0x%x", command.c_str(),cmdReturn);
        }
        catch(pit_comm_exception &commError){  // this exception is generated by the hardware comm layer
                serviceCmdStatus->updateService(CMD_STATUS_FAILED);
                logDriver->error("(pit_driver::executeCommand()): execution failed for command %s. pit_comm_exception: %s", command.c_str(), commError.what());

                // calling method to reset and refresh communication status and services
                commFEE->PITCheckCommStatus();

                return -1;
        }

        catch(exception &commError){  // this exception is generated by stg else than comm layer
                serviceCmdStatus->updateService(CMD_STATUS_FAILED);
                logDriver->error("(pit_driver::executeCommand()): execution failed for command %s, default exception: %s", command.c_str(), commError.what());

                // calling method to reset and refresh communication status and services
                //commFEE->PITCheckCommStatus();

                return -1;
        }

        catch(string & errorString){
                serviceCmdStatus->updateService(CMD_STATUS_FAILED);
                logDriver->error("(pit_driver::executeCommand()): execution failed for command %s, string exception: %s", command.c_str(), errorString.c_str());                
                return -1;
        }

        catch(...){ // unexpected exception
                serviceCmdStatus->updateService(CMD_STATUS_FAILED);
                logDriver->crit("(pit_driver::executeCommand()): execution failed for command %s, unknown exception", command.c_str());

                // calling method to reset and refresh communication status and services
                //commFEE->PITCheckCommStatus();

                return -1;
        }

        return 0;
}

int pit_driver::checkDimCommands(){
        
                // if there is a generic command 
        if (commandGenericCmd->getNext()){
                
                 char *cmd= commandGenericCmd->getString();
                this->executeCommand(cmd);
        }
        
        //************************** we can add here the checking of the other dim commands *********
        
        return 0;
}

pit_driver_foChannel & pit_driver::getFoChannelFromStream(stringstream & str){
        
        

        int sector, channel, foNumber;
        char side ;
        unsigned int boardNumber, linkNumber;
        
        str>> dec>> sector>>side>>channel>>foNumber;
                        //gets the corresponding link number and board number from the configuration object
        pit_configuration &conf =  pit_configuration::getInstance();
        
        boardNumber= conf.getBoardNumber(side,sector,channel);
        linkNumber= conf.getLinkNumber(side,sector,channel);
        
        pit_driver_opticalLink & opticalLink = this->getOptinBoard(boardNumber).getOpticalLink(linkNumber);
                //returns the fastor channel
        return opticalLink.getFoChannel(foNumber);

        
}

pit_driver_opticalLink & pit_driver::getLinkFromStream(stringstream & str){
        
        

        int sector, channel;
        char side ;
        unsigned int boardNumber, linkNumber;
        
        str>> dec>> sector>>side>>channel;
        
                        //gets the corresponding link number and board number from the configuration object
        pit_configuration &conf =  pit_configuration::getInstance();
        
        boardNumber= conf.getBoardNumber(side,sector,channel);
        linkNumber= conf.getLinkNumber(side,sector,channel);
        
                //return the optical link
        return this->getOptinBoard(boardNumber).getOpticalLink(linkNumber);
        
        
}

pit_driver_optinBoard & pit_driver::getOptinBoardFromStream(stringstream & str){
        
        

        int sector, channel;
        char side ;
        
        str>> dec>> sector>>side>>channel;
        unsigned int boardNumber, linkNumber;
        
                        //gets the corresponding link number and board number from the configuration object
        pit_configuration &conf =  pit_configuration::getInstance();
        
        boardNumber= conf.getBoardNumber(side,sector,channel);
        linkNumber = conf.getLinkNumber(side,sector,channel);
                //return the optical link
        return this->getOptinBoard(boardNumber);
        
        
}

// pit memory acess tests does a loop of tests ans returns the total amount of bit errors
unsigned int pit_driver::pitMemoryAccessTest(unsigned int blockLength,
                                                                unsigned int initialAddress,
                                                                unsigned int finalAddress,
                                                                unsigned int repetitions,
                                                                unsigned int addressIncrement){
        
        unsigned int bitErrors = 0;
        unsigned int readingErrors = 0;
        unsigned int writingErrors = 0;
        unsigned int undeterminedErrors = 0;
                
        
        
        unsigned int bitErrorPositionHistogram[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
        
        unsigned int* wordErrorPositionHistogram = new unsigned int[blockLength];
                // Initialize previous array
                for (unsigned int i= 0; i< blockLength; i ++) {
                        wordErrorPositionHistogram[i] = 0;
                }
        
        
                                // if this is zero then the address increment will be the block size
        if (addressIncrement == 0) addressIncrement=blockLength;
        
        //unsigned int nReads = totalLength /addressIncrement;
        UInt32 *writeData = new UInt32 [blockLength];
        UInt32 *readData = new UInt32 [blockLength];
        UInt32 tempData = 0;
        
        float numberOfWords=0;
        
        
        this->logDriver->info("(pitMemoryAccessTest) starting memory access test: block length %d, initial address 0x%x, final address 0x%x, repetitions %d, address increment 0x%x", blockLength, initialAddress, finalAddress, repetitions, addressIncrement);
        
        
        try{

                UInt32 testLength;

                // wiil do here the number of repetitions 
                // I was thinking of putting the test in a separated function, 
                // that is my taste for small functions, you know, I left it here just because :)
                for (unsigned int n = 0 ; n < repetitions ; n ++){

                        for (UInt28 address = initialAddress ; address <= finalAddress; address += addressIncrement){

                                //checks if we are getting outside the end of the test block  
                                if ( (address + blockLength) <= finalAddress + 1) testLength = blockLength;
                                // if we are reads till the end of the test block
                                else testLength = finalAddress-address + 1;

                                numberOfWords += 1.0*testLength;
                                // initializes the data with ramdon numbers
                                initializeWithRandom( writeData , testLength);

                                // writes the data and then reads it back
                                commFEE->PITWriteBlock(address, testLength, writeData);
                                commFEE->PITReadBlock(address, testLength, readData);

                                for(unsigned int index = 0 ; index < testLength ; index ++){

                                        if (writeData[index] != readData[index]){
                                                //  mismatch between words is found

                                                // increment wordErrorPositionHistogram
                                                wordErrorPositionHistogram[index]++;

                                                // counts the number of bit errors found and fill in the bitErrorPosition histogram 
                                                bitErrors += chekBitErrorsNumber(writeData[index], readData[index], bitErrorPositionHistogram);

                                                // read again the location where there was a problem
                                                commFEE->PITReadBlock(address+index, 1, &tempData);

                                                // Logging info
                                                stringstream logMsg("");
                                                logMsg << "(pitMemoryAccessTest) word mismatch in block write/read operation, " << 
                                                "offset: " <<   index << ", " <<
                                                "written: " << hex <<  writeData[index] << ", " <<
                                                "read: "        << hex <<       readData[index] << ", " <<
                                                "re-read: " << hex <<   tempData << ". ";

                                                if (tempData == readData[index]) {
                                                        logMsg << " Writing phase error." << endl;
                                                        writingErrors++;
                                                }
                                                else if (tempData == writeData[index]) {
                                                        logMsg << " Reading phase error." << endl;
                                                        readingErrors++;
                                                }
                                                else {
                                                        logMsg << " Undetermined error." << endl;
                                                        undeterminedErrors++;
                                                }

                                                this->logDriver->warn("%s", logMsg.str().c_str());
                                        }
                                }
                        }
                }

                
                
                
                this->logDriver->infoStream() << "(pitMemoryAccessTest)"                <<
                                "finished memory access test. "                                                 << 
                                "Total number of words written/read = "                                 <<  numberOfWords               <<
                                ", reading errors = "                                                                   <<      readingErrors           <<
                                ", writing errors = "                                                                   <<      writingErrors           <<
                                ", undetermined errors = "                                                              <<      undeterminedErrors      <<
                                ", total amount of bits written/read = "                                << 2*32*numberOfWords   <<
                                ", bit errors = "                                                                               << bitErrors                    << "\n";
                                //log4cpp::CategoryStream::ENDLINE;
                
                // log the wordErrorPosition histogram
                
                stringstream wordErrorPositionLog;
                wordErrorPositionLog << "********* Histogram of word error position\n";
                wordErrorPositionLog << "| Word position\t| Errors\n";
                for (unsigned int i =0; i < blockLength ; i++) {
                        wordErrorPositionLog << "| " << i << "\t| " <<  wordErrorPositionHistogram[i] <<"\t|\n";
                }
                wordErrorPositionLog << "********************************************";
                this->logDriver->info("%s", wordErrorPositionLog.str().c_str());
                

                stringstream histogramOutput;
                histogramOutput << endl << "********* Histogram of bit errors versus position" << endl << "| Position\t| Errors\t|" << endl;
                for (int i =0; i<32; i++) {
                        histogramOutput << "| " << i << "\t| " <<  bitErrorPositionHistogram[i] <<"\t|" << endl;
                }
                this->logDriver->info("(pitMemoryAccessTest)\n%s", histogramOutput.str().c_str());

        }

        catch(pit_comm_exception &commError){
                delete [] writeData;
                delete [] readData;
                delete [] wordErrorPositionHistogram;
                                
                this->logDriver->error("(pitMemoryAccessTest) comunication problems encountered during the test, test not finalized");
                this->logDriver->warn("(pitMemoryAccessTest) test not completed");
                                // rethrows the exception so that the command handler knows
                throw (commError);
        }
        catch(exception & error){
                delete [] writeData;
                delete [] readData;
                delete [] wordErrorPositionHistogram;
                                
                this->logDriver->error("(pitMemoryAccessTest) exception encountered : %s", error.what());
                this->logDriver->warn("(pitMemoryAccessTest) test not completed");
                throw (error);
        }
        catch(...){
                delete [] writeData;
                delete [] readData;
                delete [] wordErrorPositionHistogram;
                                
                runtime_error  error("(pitMemoryAccessTest) unknown problems encountered during the test, test not finalized");
                
                this->logDriver->error("(pitMemoryAccessTest) unknow problems encountered during the test, test not finalized");
                this->logDriver->warn("test not finalized");
                throw(error);
        }
        
        delete [] writeData;
        delete [] readData;
        delete [] wordErrorPositionHistogram;
                        
        return bitErrors;
        
        
}


void pit_driver::initializeWithRandom(UInt32 *dataBlock, unsigned int size){
                        // starts the randomization with the current time of the processor;
        srand(time (0) );
        
        for (unsigned int address = 0 ; address < size ; address ++){
                dataBlock[address] = (unsigned int)rand();
        }
}



UInt32 pit_driver::chekBitErrorsNumber( UInt32 data1, UInt32 data2, unsigned int* bitErrorPositionHistogram) {

        unsigned int bitErrors = 0;
                
                        // loops throw all bits incrementing the number of errors
                        
        for (int bit = 0 ; bit < 32 ; bit++){
                if ( ((data1>> bit) & 0x1) != ((data2>> bit) & 0x1) )   {
                        bitErrors ++;
                        bitErrorPositionHistogram[bit]++;
                }

        }
        
        return bitErrors;
}

---