pit_comm.cpp

Go to the documentation of this file.

#include <iostream>
#include <fstream>
#include <sstream>
#include "pit_comm.h"
#include "pit_comm_exception.h"


using namespace std;

#define MAX_PHYSMEM (1024*1024*8)

pit_comm::pit_comm(void)
{
    logCom = &(log4cpp::Category::getInstance("pitLog.comm")); 
    logCom->info("(pit_comm::pit_comm()): Starting communication layer");

    // Initializing data members
    rorcStatus = R_NOT_OPEN_ERR;
    DDLLinkStatus = FAILURE;
    controlFPGAAnswers = FAILURE;
    
    // Registering DIM service
    const string serviceCommunicationStatusName("COMMUNICATION_STATUS");
    serviceCommunicationStatus = new DimService(serviceCommunicationStatusName.c_str(), controlFPGAAnswers);
         
    rorc = get_channel(RORC_REVISION, RORC_SERIAL, RORC_CHANNEL);
    
    // if rorc handler is valid, reset siu and check access to the hardware
    if(rorc->status == R_OPEN) {
        rorcStatus = R_OPEN;
        logCom->info("(pit_comm::PITCheckCommStatus()): RORC handler valid");
        PITCheckCommStatus();
    } 
    else { 
        rorcStatus = rorc->err; 
        logCom->error("(pit_comm::pit_comm()): Could not open rorc device : minor=%i channel=%i err=%i", rorc->minor, rorc->channel, rorc->err);
    }/* end if */

}/* end pit_comm */


pit_comm::~pit_comm(void)
{
        // reset and close the fec2rorc channel if opened
         if(rorc->status == R_OPEN) {
                PITrorcReset();
                release_channel(rorc);
         } 
}/* end ~pit_comm */



/* let me see some more 
 function to check the comunication status */
bool pit_comm::PITCheckCommStatus()
{
        
        
        if (rorcStatus == R_OPEN) {
                PITrorcReset(); // resetting comm layer
                logCom->info("(pit_comm::PITCheckCommStatus()): Checking communication to PIT hardware");
                
                try{
                        int output;
                        
                        output = ddl_statusReadout(rorc, PIT_GET_VERSION); // try access the pit hardware by asking control firmware version
                        
                        if (output< 0) { // negative return value means some problem, analyze return value to help determining the problem
                            PITDecodeRORCError(output, "(PITCheckCommStatus) : ");
                        }/*end if */
                            
                        DDLLinkStatus = SUCCESS;
                        controlFPGAAnswers = true;
                        serviceCommunicationStatus->updateService();
                        
                        logCom->info("(pit_comm::PITCheckCommStatus()): Communication OK, RORC-SIU link OK, control FPGA answered with version number: %i", output);
                        return true;
                }
            catch(...){
                DDLLinkStatus = FAILURE;
                controlFPGAAnswers = FAILURE;
                serviceCommunicationStatus->updateService();
                logCom->error("(pit_comm::PITCheckCommStatus()): Communication to PIT failed. Check hardware and optical links" );
                return false;
            }
        }
        else {
                        DDLLinkStatus = FAILURE;
                        controlFPGAAnswers = FAILURE;
                        serviceCommunicationStatus->updateService();
                        logCom->error("(pit_comm::PITCheckCommStatus()): Can not access SIU and RORC, invalid RORC handler");
                        return false;           
                }
   

}// end PITCheckCommStatus;



// resets the rorc channel
int pit_comm::PITrorcReset(){
        
        if (rorcStatus == R_OPEN) {
                rorc_pci_dev_t * device = &rorc->rorc;

                // resets siu and the rorc
                rorcReset(device, RORC_RESET_SIU | RORC_RESET_RORC);
        
                this->logCom->info("(pit_comm::PITrorcReset()): Resetting SIU and RORC");
                return 0;
        }
        else {
                this->logCom->error("(pit_comm::PITrorcReset()): Can not reset SIU and RORC, invalid RORC handler");
                return -1;              
        }

        // this piece of code was build looking at the siu_reset.c, looks like it is easier in the rorcReset funtionality
                // number of trials to try to reset
//      int trials = 3;
//      int print = 1; // it will print the status to screen
//      long long int time = DDL_RESPONSE_TIME * device->loop_per_usec;
        
//      output =ddlResetSiu( device, print,trials,time  );
//      if (output < 0 ){
//              // error condition here cannot be the decode error can create a infinte loop
//              // another error condition as to be defined  
//              //PITDecodeComError(output, "(PITrorcReset)dllResetSiu : ");
//      }
}

 
void pit_comm::PITDecodeRORCError(int rorcError, const char *extraMsg) {
 
        string srcMsg(extraMsg);
        logCom->error(srcMsg); // log an error message containing the name of the failing function that called this one

        
        stringstream errorMsgStream;
        errorMsgStream  << "(pit_comm::PITDecodeRORCError) Communication problem, RORC returned DDL error number " 
                                    <<  rorcError << " : ";
        
        string errorMsg(errorMsgStream.str());
                
 switch ( rorcError ) {

  case RORC_LINK_NOT_ON :
    DDLLinkStatus = FAILURE;
    controlFPGAAnswers = FAILURE;
    errorMsg+="RORC-SIU Link DOWN. Check pit hardware powering and clocking.";
    break;

  case RORC_TIMEOUT : 
    DDLLinkStatus = SUCCESS;
    controlFPGAAnswers = FAILURE;
    errorMsg+="RORC timeout error, could not TRANSMIT command before timeout.";        
    break;

  case  RORC_TOO_MANY_REPLY : 
    DDLLinkStatus = SUCCESS;
    controlFPGAAnswers = FAILURE;
    errorMsg+="too many replies error. Check control FPGA configuration.";        
    break;

  case  RORC_NOT_ENOUGH_REPLY : 
    DDLLinkStatus = SUCCESS;
    controlFPGAAnswers = FAILURE;
    errorMsg+="not enough replies in timeout interval. Check control FPGA configuration.";
    break;

  default : 
    DDLLinkStatus = FAILURE;
    controlFPGAAnswers = FAILURE;
    errorMsg+="unknown error code. Ask DDL-RORC-SIU maintainers.";        
 }      
 
 logCom->error(errorMsg);       // log error message containing the number of the error and the decoding
 
 //PITrorcReset();                      // reset RORC and SIU                   
 
 throw pit_comm_exception( errorMsg);
 
}// end of PITDecodeRORCError


void pit_comm::PITDecodeComError(int comError, const char * extraMsg){
        string errorMsg(extraMsg);
        switch(comError){
                case ERROR_PROTOCOL_DATALENGTH:
                        errorMsg+="writeBlock: bad length comparison";
                        break;
                case ERROR_BAD_REGISTER_WRITE:
                        errorMsg+= "Bad register Write";
                        break;
                case ERROR_PARITY_CHECK:
                        errorMsg+= "parity error";
                        break;
                case ERROR_GENERIC_BUS_STATUS:
                        errorMsg+= "generic bus status error";
                        break;
                default:
                        stringstream str;
                        str << "Unknow pit_comm error code: " << comError; 
                        errorMsg+=str.str();
        }
        
        logCom->error(errorMsg);
        throw pit_comm_exception(errorMsg);
}

/******************************************************************************
* Name : PITGetRdA                                                            *
* Function : get read address from register                                   *
* Output : read address if >=0 else negative output on rorc error             *
* Revisions:                                                                                                                              *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/

int pit_comm::PITGetRdA()
{
unsigned int rd_a_lsb;
unsigned int rd_a_msb;
int output;

    output = ddl_statusReadout(rorc,  PIT_GET_RDA_LSB);
    if (output < 0){
        PITDecodeRORCError(output, "(PITGetRdA) PIT_GET_RDA_LSB :" );
        return output;
    }
    
    rd_a_lsb = output & 0x7ffff;           // rd_a[18..0]
    output = ddl_statusReadout(rorc,  PIT_GET_RDA_MSB);
    
    if (output< 0){
        PITDecodeRORCError(output, "(PITGetRdA) PIT_GET_RDA_MSB :" );
        return output;
    }
    
    rd_a_msb = output & 0x1ff;         // rd_a[27..19] 
    output = (rd_a_msb << 19) | rd_a_lsb;      // rd_a
    
    return(output);
}/* PITGetRdA */


/******************************************************************************
* Name : PITGetWrA                                                            *
* Function : get write address from register                                  *
* Output : write address if >=0 else negative output on rorc error            *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITGetWrA()
{
unsigned int wr_a_lsb;
unsigned int wr_a_msb;
int output;

    output = ddl_statusReadout(rorc, PIT_GET_WRA_LSB);
    if (output< 0){
        PITDecodeRORCError(output, "(PITGetWrA) PIT_GET_WRA_LSB :");
        return output;
    }
   
    wr_a_lsb = output & 0x7ffff;           // wr_a[18..0]
    output = ddl_statusReadout(rorc, PIT_GET_WRA_MSB);
    if (output< 0){
        PITDecodeRORCError(output,"(PITGetWrA) PIT_GET_WRA_MSB :");
        return output;
    }
    wr_a_msb = output & 0x1ff;         // wr_a[27..19] 
    output = (wr_a_msb << 19) | wr_a_lsb;      // wd_a

    return(output);
}/* end PITGetWrA */


/******************************************************************************
* Name : PITGetLen                                                            *
* Function : get length from register                                         *
* Output : length if >=0 else negative output on rorc error                   *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITGetLen()
{
int output;

    output = ddl_statusReadout(rorc, PIT_GET_LEN);
    if(output >= 0) output = output & 0x7ffff;    // len_[18..0] 
    else PITDecodeRORCError(output, "(PITGetLen):");
    return(output);
}/* end PITGetLen */


/******************************************************************************
* Name : PITGetRdLen                                                          *
* Function : get read length from register                                    *
* Output : read length if >=0 else negative output on rorc error              *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITGetRdLen()
{
int output;

    output = ddl_statusReadout(rorc, PIT_GET_RD_LEN);
    if(output >=0) output = output & 0x7ffff;
    else PITDecodeRORCError(output, "(PITGetRdLen)");
    return(output);
}/* end PITGetRdLen */


/******************************************************************************
* Name : PITGetWrLen                                                          *
* Function : get write length from register                                   *
* Output : write length if >=0 else negative output on rorc error             *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITGetWrLen()
{
int output;

    output = ddl_statusReadout(rorc, PIT_GET_WR_LEN);
    if(output >= 0) output = output & 0x7ffff;
    else PITDecodeRORCError(output, "(PITGetWrLen) : "); 
    return(output);
}/* end PITGetWrLen */


/******************************************************************************
* Name : PITGetControl0                                                       *
* Function : get control0 value from register                                 *
* Output : control0 value if >=0 else negative output on rorc error           *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITGetControl0()
{
int output;

    output = ddl_statusReadout(rorc, PIT_GET_CONTROL0);
    if(output >= 0) output = output & 0xff;
    else PITDecodeRORCError(output, "(PITGetControl0) : "); 
    return(output);
}/* end PITGetControl0 */


/******************************************************************************
* Name : PITGetControl1                                                       *
* Function : get control1 value from register                                 *
* Output : control1 value if >=0 else negative output on rorc error           *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITGetControl1()
{
int output;

    output = ddl_statusReadout(rorc, PIT_GET_CONTROL1);
    if(output >=0) output = output & 0xff;
    else PITDecodeRORCError(output,  "(PITGetControl1) : "); 
    return(output);
}/* end PITGetControl1 */


/******************************************************************************
* Name : PITGetVersion                                                        *
* Function : get firmware version  from register                              *
* Output : firmware version if >=0 else negative output on rorc error         *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITGetVersion()
{
int output;

    output = ddl_statusReadout(rorc, PIT_GET_VERSION);
    if(output >= 0) output = output & 0x3ffff;
        else PITDecodeRORCError(output, "(in pit_comm::PITGetVersion): "); 
    return(output);
}/* end PITGetVersion */


/******************************************************************************
* Name : PITGetBusStatus                                                      *
* Function : get bus status from register                                     *
* Output : bust status if >=0 else negative output on rorc error              *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITGetBusStatus()
{
int output;

    output = ddl_statusReadout(rorc, PIT_GET_BUS_STATUS);
    if(output >=0) output = output & 0xfff;
    else PITDecodeRORCError(output, "(PITGetBusStatus) : "); 
    return(output);
}/* end PITGetBusStatus */


/******************************************************************************
* Name : PITSetRdA                                                            *
* Functin : set read address to register                                      *
* Input : address : full address                                              *
* Output : 0 if read address was successfully written else                    *
*          -negative output on rorc error                                     *
*          -ERROR_BAD_REGISTER_WRITE                                          *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITSetRdA(UInt28 address)
{
unsigned int argument;
unsigned int addr_extract;
int output;
unsigned int rd_a_msb;

      // call the DDL library function for FECTRL with proper parameter to set the rd a[27:19] register bits 
    addr_extract = (address >> 19) & 0x1ff;  // extract of 9 msb of address
    argument = addr_extract | (0x3ff << 9);  // combining with address rd_a msb
    output = ddl_sendCommand(rorc, argument);
        // here it checks if it is different than zero instead of smaller than 
    if (output){
        PITDecodeRORCError(output, "(PITSetRdA) write rd [27:19] : ");
        return output;
    }
  
          // call the DDL library function for FESTRD with proper parameter to read back the rd a[27:19] value
    output = ddl_statusReadout(rorc, PIT_GET_RDA_MSB);
    
    if (output<0){
        PITDecodeRORCError(output, "(PITSetRdA) read rd [27:19] : ");
        return output;
    }
      // compare the value read back and flag possible error
    rd_a_msb = (output /*>> 12*/) & 0x1ff;             // rd_a[27..19]
    if(rd_a_msb == !addr_extract){ 
        output = ERROR_BAD_REGISTER_WRITE; 
        this->PITDecodeComError(output, "(PITSetRdA) read write comparison :");
        return output;
    }
    
   
  
    return(0);
}/* end PITSetRdA */


/******************************************************************************
* Name : PITSetWrA                                                            *
* Use : set write address to register                                         *
* Input : address : full address                                              *
* Output : 0 if write address was successfully written else                   *
*          -negative output on rorc error                                     *
*          -ERROR_BAD_REGISTER_WRITE                                          *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITSetWrA(UInt28 address)
{
unsigned int argument;
unsigned int addr_extract;
int output;
unsigned int wr_a_msb;

      // call the DDL library function for FECTRL with proper parameter to set the wr a[27:19] register bits
    addr_extract = (address >> 19) & 0x1ff;  // extract of 9 msb of address
    argument = addr_extract | (0x3fe << 9);  // combining with address rd_a msb
    output = ddl_sendCommand(rorc, argument);
    if (output< 0){
        PITDecodeRORCError(output, "(PITSetWrA)  setting the wr a[27:19] : ");
        return output;
    }
       
    
      // call the DDL library function for FESTRD with proper parameter to read back the wr a[27:19] value
    output = ddl_statusReadout(rorc, PIT_GET_WRA_MSB);
    if (output< 0){
        PITDecodeRORCError(output,  "(PITSetWrA)  reading the wr a[27:19] : ");
        return output;
    }
      

      // compare the value read back and flag possible error
    wr_a_msb = (output /*>> 12*/) & 0x1ff;             // wa_a[27..19]
    if(wr_a_msb != addr_extract){ 
        output = ERROR_BAD_REGISTER_WRITE; 
        PITDecodeComError(output, "(PITSetWrA)read write comparison : ");
        return output;
    }

    return(0); 
}/* end PITSetWrA */

/******************************************************************************
* Name : PITSetLen                                                            *
* Use : set length to register                                                *
* Input : length  : full length                                               *
* Output : 0 if length was successfully written else                          *
*          -negative output on rorc error                                     *
*          -ERROR_BAD_REGISTER_WRITE                                          *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITSetLen(UInt19 length)
{
unsigned int argument;
int output;
unsigned int len;

      // call the DDL library function for FECTRL with proper parameters to set the len[18:9] register bits
    argument = ((length & 0x7fe00) >> 9) | (0x1fc << 10); 
    output = ddl_sendCommand(rorc, argument);
    if (output < 0){
        PITDecodeRORCError(output,"(PITSetLen) setting len [18:9] : ");
        return output;
    }
      // call the the DDL library function for FECTRL with proper parameter to set the len[8:0] bits of the len register
    argument = (length & 0x1ff) | (0x3fb << 9); 
    output = ddl_sendCommand(rorc, argument);
    if (output<0){
        PITDecodeRORCError(output, "(PITSetLen) setting len [8:0] : ");
        return output;
    }
    
      // call the DDL library function for FESTRD with proper parameter to read back the len[18:0] value
    output = ddl_statusReadout(rorc, PIT_GET_LEN);
    if (output<0){
        PITDecodeRORCError(output, "(PITSetLen) reading len[18:0] : ");
        return output;
     }
      // compare the value read back and flag possible error
    len = (output/* >> 12*/) & 0x7ffff;             // wa_a[27..19]
    if(len != length){ 
        output = ERROR_BAD_REGISTER_WRITE; 
        PITDecodeComError(output, "(PITSetLen) read write comparison : ");
        return output;
    }
    
    return(0); 
}/* end PITSetLen */

/******************************************************************************
* Name : PITSetControl0                                                       *
* Use : set control0 register                                                 *
* Input : value  : value to put to register                                   *
* Output : 0 if value  was successfully written else                          *
*          -negative output on rorc error                                     *
*          -ERROR_BAD_REGISTER_WRITE                                          *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITSetControl0(UInt8 value)
{
unsigned int argument;
unsigned int control0;
int output;

      // call the DDL library function for FECTRL with proper parameters to set the control[7:0] register bits
    argument = value & 0xff; 
    output = ddl_sendCommand(rorc, argument);
    if(output){
        PITDecodeRORCError(output, "(PITSetControl0) setting register : ");
        return output;
    }

      // call the DDL library function for FESTRD with proper parameter to read back the control0[7:0] value
    output = ddl_statusReadout(rorc, PIT_GET_CONTROL0);
      // compare the value read back and flag possible error
    if(output < 0) {
        PITDecodeRORCError(output, "(PITSetControl0) reading register : ");
        return output;
    }
    control0 = (output /* >> 12*/) & 0xff;             // control0[7..0]
    if(control0 != value) { 
        output = ERROR_BAD_REGISTER_WRITE; 
        PITDecodeComError(output, "(PITSetControl0) read write comparison : ");
        return output;
    }
        
 
    return(0);
}/* end PITSetControl0 */

/******************************************************************************
* Name : PITSetControl1                                                       *
* Use : set control1 register                                                 *
* Input : value  : value to put to register                                   *
* Output : 0 if value  was successfully written else                          *
*          -negative output on rorc error                                     *
*          -ERROR_BAD_REGISTER_WRITE                                          *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITSetControl1(UInt8 value)
{
unsigned int argument;
unsigned int control1;
int output;

      // call the DDL library function for FECTRL with proper parameters to set the control[7:0] register bits
    argument = (value & 0xff) | 0x100; 
    output = ddl_sendCommand(rorc, argument);
    if (output){
        PITDecodeRORCError(output, "(PITSetControl1) writting register : ");
        return output;
    }
  
          // call the DDL library function for FESTRD with proper parameter to read back the control0[7:0] value
    output = ddl_statusReadout(rorc, PIT_GET_CONTROL1);
    if(output < 0){
        PITDecodeRORCError(output, "(PITSetControl1) reading register : ");
        return output;
    }
    

      // compare the value read back and flag possible error
    control1 = (output /* >> 12*/) & 0xff;             // control1[7..0]
    if(control1 != value) { 
        output = ERROR_BAD_REGISTER_WRITE; 
        PITDecodeComError(output, "(PITSetControl1) read write comparison : ");
        return output;
    }
    
    return(0);
}/* end PITSetControl1 */




/******************************************************************************
* Name : PITReadBlock                                                         *
* Use : read a block within FEE                                               *
* Input : address : base address (full) in FEE from which data is read        *
*         dalalength : number of data words to read                           *
* Output : data : output buffer where data are stored                         *
*          PITReadBlock: 0 if read operation was successfull else             *
*          -negative output from PITSetLen                                    *
*          -negative output from PITSetRdA                                    *
*          -negative output from rorc_receive                                 *
*          -ERROR_BAD_LENGTH_COMPARISON (<0)                                  *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITReadBlock(UInt28 address, UInt19 datalength, UInt32* data)
{
int rd_len;
int output;

      //call the PITSetLen function to set the requested data block length
    output = PITSetLen(datalength);
    
    if(output){
        
        PITDecodeRORCError(output, "(pit_comm::PITReadBlock): Problem encountered while setting length register");
        return output;
    }
          // call the PITSetRdA passing address to properly set the rd a[27:19] register bits
    output = PITSetRdA(address);
    if(output){
        PITDecodeRORCError(output, "(pit_comm::PITReadBlock): Problem encountered while setting the base address register");
        return output;
    }
          // call the DDL library function for STBRD with proper parameters (including address lower bits) to read back the data block and store it to data
    output = ddl_readBlock(rorc,0x7ffff & address, (u_long*)data, datalength);
    if(output<0){
        PITDecodeRORCError(output, "(pit_comm::PITReadBlock) Problem encountered while reading data");
        return output;
    }
      // call PITGetRdLen to verify the number of words actually read from the DDL and return
    rd_len = PITGetRdLen();
    if( rd_len != (int)datalength){
        output = ERROR_BAD_LENGTH_COMPARISON; 
        PITDecodeComError(output, "(pit_comm::PITReadBlock) Actual block read length mismatches requested block length");
        return output;
    }
    
    int statusReg = PITGetBusStatus();
        //checks the parity bit
    if (extractFromUInt32(0,1,statusReg) ){
        output= ERROR_PARITY_CHECK;
        PITDecodeComError(output, "(pit_comm::PITReadBlock)");
        return output;
        
    }
    if (statusReg){
        output= ERROR_GENERIC_BUS_STATUS;
        PITDecodeComError(output, "(pit_comm::PITReadBlock) ");
        return output;
    }
    
    
    return(0);
}/* end PITReadBlock */


/******************************************************************************
* Name : PITWriteBlock                                                        *
* Use : write a block within FEE                                              *
* Input : address : base address (full) in FEE from which data is read        *
*         dalalength : number of data words to read                           *
* Output : data : output buffer where data are stored                         *
*          PITReadBlock: 0 if read operation was successfull else             *
*          -negative output from PITSetWrA                                    *
*          -negative output from rorc_send                                    *
*          -ERROR_BAD_LENGTH_COMPARISON (<0)                                  *
* Revisions:                                                                  *
*  DATE     AUTHOR            NOTES                                           *
* 20070802  Fabrice Pancher   function output more detailled if errors        *
* 20071109  Fabrice Pancher   use fec2rorc library                            *
******************************************************************************/
int pit_comm::PITWriteBlock(UInt28 address, UInt19 datalength, UInt32* data)
{
unsigned int wr_len;
int output;

      // call the PITSetWrA function to set the wr a[27:19] bits
    output = PITSetWrA(address);
    
      // call the DDL library function for STBWR with proper parameters to write the data block from memory location *data with length datalength and starting writing at the location given by address
    if(output< 0) {
        PITDecodeRORCError(output, "(PITWriteBlock) setting address :");
        return output;
    }
        
    output = ddl_writeBlock(rorc, (u_long*)data, datalength, address & 0x7ffff);
    if(output<0) {
        PITDecodeRORCError(output,  "(PITWriteBlock) sending data :");
        return output;
    }
      // call PITGetWrLen to check the number of words actually written to memory
    wr_len = PITGetWrLen();
    if(wr_len != datalength){ 
        output = ERROR_BAD_LENGTH_COMPARISON; 
        PITDecodeComError(output, "(PITWriteBlock) length check : ");
        return output;
    }

    return(0);
}/* end PITWriteBlock */


// this is a sinple call of the PITWriteBlock with a size of one
int pit_comm::PITWriteWord(UInt28 address, const UInt32 & data){
        UInt32 dataOut = data;
        
        logCom->log(log4cpp::Priority::DEBUG, "(pit_comm::PITWriteWord): writing to address 0x%x value 0x%x", address, data);
        return PITWriteBlock(address,1,&dataOut);
        }

// this is a sinple call of the PITReadBlock with a size of one
int pit_comm::PITReadWord(UInt28 address, UInt32 *data){
        int return_value = PITReadBlock(address, 1 ,data);
        
        logCom->log(log4cpp::Priority::DEBUG, "(pit_comm::PITReadWord): read word from address 0x%x, value 0x%x", address, *data);
                
        return return_value;
        }

---