TimingIssues.hpp

Go to the documentation of this file.

 
#ifndef TIMING_INCLUDE_TIMING_TIMINGISSUES_HPP_
#define TIMING_INCLUDE_TIMING_TIMINGISSUES_HPP_
 
#include "ers/Issue.hpp"
#include "logging/Logging.hpp" // NOTE: if ISSUES ARE DECLARED BEFORE include logging/Logging.hpp, TLOG_DEBUG<<issue wont work.
 
#include <string>
 
namespace dunedaq {
 
// Generic exceptions
ERS_DECLARE_ISSUE(timing,                          
                  FileNotFound,                    
                  file_path << " does not exist!", 
                  ((std::string)file_path)         
)
ERS_DECLARE_ISSUE(timing,                    
                  CorruptedFile,             
                  file_path << " corrupted", 
                  ((std::string)file_path)   
)
ERS_DECLARE_ISSUE_BASE(timing,                         
                       FileIsDirectory,                
                       CorruptedFile,                  
                       file_path << " is a directory", 
                       ((std::string)file_path),       
                       ERS_EMPTY                       
)
 
ERS_DECLARE_ISSUE(timing,                                            
                  EnvironmentVariableNotSet,                         
                  "Environment variable: " << env_var << " not set", 
                  ((std::string)env_var)                             
)
 
// I2C related issues
ERS_DECLARE_ISSUE(timing,                             
                  I2CException,                       
                  " I2CException on bus: " << bus_id, 
                  ((std::string)bus_id)               
)
 
ERS_DECLARE_ISSUE_BASE(timing,                                                          
                       I2CDeviceNotFound,                                               
                       I2CException,                                                    
                       " I2C device: " << device_id << " not found on bus: " << bus_id, 
                       ((std::string)bus_id),                                           
                       ((std::string)device_id)                                         
)
 
ERS_DECLARE_ISSUE_BASE(
  timing,                                                                         
  I2CBusArbitrationLost,                                                          
  I2CException,                                                                   
  " I2C bus: " << bus_id << " arbitration lost. Is another application running?", 
  ((std::string)bus_id),                                                          
  ERS_EMPTY                                                                       
)
 
ERS_DECLARE_ISSUE_BASE(
  timing,                
  I2CTransactionTimeout, 
  I2CException,          
  " I2C bus: "
    << bus_id
    << " error. Transaction timeout - the 'Transfer in Progress' bit remained high for too long", 
  ((std::string)bus_id), 
  ERS_EMPTY              
)
 
ERS_DECLARE_ISSUE_BASE(timing,                                                      
                       I2CNoAcknowledgeReceived,                                    
                       I2CException,                                                
                       " I2C bus: " << bus_id << " error. No acknowledge received", 
                       ((std::string)bus_id),                                       
                       ERS_EMPTY                                                    
)
 
ERS_DECLARE_ISSUE_BASE(timing,                          
                       I2CTransferFinishedBusStillBusy, 
                       I2CException,                    
                       " I2C bus: " << bus_id
                                    << " error. Transfer finished but bus still busy", 
                       ((std::string)bus_id),                                          
                       ERS_EMPTY                                                       
)
 
ERS_DECLARE_ISSUE(timing,                                
                  UnknownBoardType,                      
                  " Unknown board type: " << board_type, 
                  ((std::string)board_type)              
)
 
ERS_DECLARE_ISSUE(timing,                                    
                  UnknownCarrierType,                        
                  " Unknown carrier type: " << carrier_type, 
                  ((std::string)carrier_type)                
)
 
ERS_DECLARE_ISSUE(timing,                                  
                  UnknownDesignType,                       
                  " Unknown design type: " << design_type, 
                  ((std::string)design_type)               
)
 
ERS_DECLARE_ISSUE(timing,                                               
                  UnknownBoardUID,                                      
                  " Unknown UID-board revision mapping: " << board_uid, 
                  ((std::string)board_uid)                              
)
 
ERS_DECLARE_ISSUE(timing,                                                              
                  UnknownFirmwareClockFrequency,                                       
                  frequency << " Hz is not a known timing firmwaare clock frequency!", 
                  ((std::uint32_t)frequency)                                           // NOLINT(build/unsigned) /< Message parameters 
)
 
ERS_DECLARE_ISSUE(timing,                                              
                  MissingBoardTypeMapEntry,                            
                  " Board type not in board type map: " << board_type, 
                  ((std::string)board_type)                            
)
 
ERS_DECLARE_ISSUE(timing,                                                     
                  MissingBoardRevisionMapEntry,                               
                  " Board revision not in board revision map: " << board_rev, 
                  ((std::string)board_rev)                                    
)
 
ERS_DECLARE_ISSUE(timing,                                                    
                  MissingCarrierTypeMapEntry,                                
                  " Carrier type not in carrier type map: " << carrier_type, 
                  ((std::string)carrier_type)                                
)
 
ERS_DECLARE_ISSUE(timing,                                                 
                  MissingDesignTypeMapEntry,                              
                  " Design type not in design type map: " << design_type, 
                  ((std::string)design_type)                              
)
 
ERS_DECLARE_ISSUE(timing,                                                 
                  MissingClockSourceMapEntry,                              
                  " Clock source not in clock source map: " << clock_source, 
                  ((std::string)clock_source)                              
)
 
ERS_DECLARE_ISSUE(timing,                                                
                  ClockConfigNotFound,                                   
                  " Clock config file not found for key: " << clock_key, 
                  ((std::string)clock_key)                               
)
 
ERS_DECLARE_ISSUE(timing,                        
                  InvalidDACId,                  
                  " Invalid DAC ID: " << dac_id, 
                  ((std::string)dac_id)          
)
 
ERS_DECLARE_ISSUE(timing,                                    
                  EchoReplyTimeout,                          
                  " Timeout whilst waiting for echo reply.", 
                  ERS_EMPTY                                  
)
 
ERS_DECLARE_ISSUE(timing,                                                                                   
                  EchoFlagTimeout,                                                                          
                  " Timeout whilst waiting for echo reply flag. Timeout (ms): " << std::to_string(timeout), 
                  ((uint)timeout)                                                                           
)
 
ERS_DECLARE_ISSUE(timing,                                                               
                  VLCommandReplyTimeout,                                                
                  " Timeout whilst waiting for variable length (async) command reply.", 
                  ERS_EMPTY                                                             
)
 
ERS_DECLARE_ISSUE(timing,                                                                                                                          
                  VLCommandReplyBufferFlagTimeout,                                                                                                 
                  " Timeout whilst waiting for variable length (async) reply buffer response flag set. Timeout (ms): " << std::to_string(timeout), 
                   ((uint)timeout)                                                                                                                 
)
 
ERS_DECLARE_ISSUE(timing,                                                                                                                                      
                  InvalidVLCommandReplyPacket,                                                                                                                 
                  " Variable length (async) command reply packet invalid. byte 0,1,2: " << std::hex << "0x" << byte_0 << ", 0x" << byte_1 << ", 0x" << byte_2, 
                  ((uint32_t)byte_0)((uint32_t)byte_1)((uint32_t)byte_2)                                                                                       
)
 
ERS_DECLARE_ISSUE(timing,                                               
                  FormatCountersTableNodesTitlesMismatch,               
                  " Mismatch between number counters nodes and titles", 
                  ERS_EMPTY                                             
)
 
// SFP related issues
ERS_DECLARE_ISSUE(timing,                        
                  InvalidSFPId,                  
                  " Invalid SFP ID: " << sfp_id, 
                  ((std::string)sfp_id)          
)
 
ERS_DECLARE_ISSUE(timing,                                        
                  SFPUnreachable,                                
                  " Failed to reach SFP on I2C bus: " << bus_id, 
                  ((std::string)bus_id)                          
)
 
ERS_DECLARE_ISSUE(timing,                                                   
                  SFPDDMUnsupported,                                        
                  " SFP on I2C bus: " << bus_id << " does not support DDM", 
                  ((std::string)bus_id)                                     
)
 
ERS_DECLARE_ISSUE(timing,                                                                
                  SFPDDMI2CAddressSwapUnsupported,                                       
                  " SFP DDM I2C address swap not supported. SFP on I2C bus: " << bus_id, 
                  ((std::string)bus_id)                                                  
)
 
ERS_DECLARE_ISSUE(timing,                                                                     
                  SoftTxLaserControlUnsupported,                                              
                  " SFP on I2C bus: " << bus_id << " does not support soft tx laser control", 
                  ((std::string)bus_id)                                                       
)
 
ERS_DECLARE_ISSUE(timing,                
                  UnsupportedFunction,   
                  message,               
                  ((std::string)message) 
)
ERS_DECLARE_ISSUE(timing,                      
                  BadRequestedFakeTriggerRate, 
                  " Requested trigger rate: " << std::to_string(trig_rate) << ", ps: " << std::to_string(ps)
                                              << ", out of range.", 
                  ((double)trig_rate)((uint)ps)                     
)
 
ERS_DECLARE_ISSUE(timing,                                                                 
                  EndpointNotReady,                                                       
                  ept_description << " endpoint not ready. Current state: 0x" << std::hex << ept_state, 
                  ((std::string)ept_description)((uint32_t)ept_state)                  
)
 
ERS_DECLARE_ISSUE(timing,                                                                 
                  ReceiverNotReady,                                                       
                  " Receiver not ready. CDR locked: " << cdr_locked << ", Rx ready: " << rx_ready, 
                  ((uint32_t)cdr_locked)((uint32_t)rx_ready)                                    
)
 
ERS_DECLARE_ISSUE(timing,                                  
                  ClocksNotReady,                          //< Issue class name
                  clocks_description << " clocks not ready.", 
                  ((std::string)clocks_description)        
)
 
ERS_DECLARE_ISSUE(timing, HSIBufferIssue, "HSI buffer in state: " << buffer_state, ((std::string)buffer_state))
 
ERS_DECLARE_ISSUE(timing,                                                                       
                  EnclustraSwitchFailure,                                                       
                  " Failed to program Enclustra I2C IO expander. FMC I2C access may not work.", 
                  ERS_EMPTY)                                                                    
 
ERS_DECLARE_ISSUE(timing,                                                                                                                            
                  IncompatibleMajorMasterFirmwareVersion,                                                                                            
                  " Incompatible major master firmware version; found: " << found_firmware_version << ", required: " << required_firmware_version, 
                  ((int)found_firmware_version)((int)required_firmware_version)                                                                      
)
 
ERS_DECLARE_ISSUE(timing,                                                                                                                            
                  IncompatibleMinorMasterFirmwareVersion,                                                                                            
                  " Incompatible minor master firmware version; found: " << found_firmware_version << ", required: " << required_firmware_version, 
                  ((int)found_firmware_version)((int)required_firmware_version)                                                                      
)
 
ERS_DECLARE_ISSUE(timing,                                                                                                                            
                  IncompatiblePatchMasterFirmwareVersion,                                                                                            
                  " Incompatible patch master firmware version; found: " << found_firmware_version << ", required: " << required_firmware_version, 
                  ((int)found_firmware_version)((int)required_firmware_version)                                                                      
)
 
ERS_DECLARE_ISSUE(timing,                                                                                                                            
                  IncompatibleMajorEndpointFirmwareVersion,                                                                                          
                  " Incompatible major endpoint firmware version; found: " << found_firmware_version << ", required: " << required_firmware_version, 
                  ((int)found_firmware_version)((int)required_firmware_version)                                                                      
)
 
ERS_DECLARE_ISSUE(timing,                                                                                                                            
                  IncompatibleMinorEndpointFirmwareVersion,                                                                                          
                  " Incompatible minor endpoint firmware version; found: " << found_firmware_version << ", required: " << required_firmware_version, 
                  ((int)found_firmware_version)((int)required_firmware_version)                                                                      
)
 
ERS_DECLARE_ISSUE(timing,                                                                                                                            
                  IncompatiblePatchEndpointFirmwareVersion,                                                                                          
                  " Incompatible patch endpoint firmware version; found: " << found_firmware_version << ", required: " << required_firmware_version, 
                  ((int)found_firmware_version)((int)required_firmware_version)                                                                      
)
 
ERS_DECLARE_ISSUE(timing,                                                                       
                  FailedToUpdateHSIRandomRate,                                                  
                  "  Random bit 0 trigger rate for HSI not updated!",                           
                  ERS_EMPTY)                                                                    //< Message parameters
 
ERS_DECLARE_ISSUE(timing,                          
                  InvalidAMCSlot,                  
                  " Invalid AMC slot: " << amc_slot, 
                  ((std::string)amc_slot)          
)
 
ERS_DECLARE_ISSUE(timing,                                                                                    
                  InvalidFixedLatencyCommand,                                                                
                  " Supplied fixed-latency broadcast command, 0x" << std::hex <<  command << " is invalid" , 
                   ((uint)command)                                                                           
)
 
ERS_DECLARE_ISSUE(timing,                                                                                    
                  InvalidFixedLatencyCommandChannel,                                                                
                  " Supplied fixed-latency broadcast command channel, 0x" << std::hex <<  channel << " is invalid" , 
                   ((uint)channel)                                                                           
)
 
ERS_DECLARE_ISSUE(timing,                                                                              
                  MonitoredEndpointDead,                                                               
                  " Monitored endpoint at address 0x" << std::hex << ept_address << " did not respond", 
                  ((uint16_t)ept_address)                                                              
)
 
ERS_DECLARE_ISSUE(timing,                                                                                                         
                  MonitoredEndpointUnexpectedState,                                                                               
                  " Monitored endpoint at address 0x" << std::hex << ept_address << " is in an unexpected state: 0x" << ept_state, 
                  ((uint16_t)ept_address)((uint32_t)ept_state)                                                                    
)
 
ERS_DECLARE_ISSUE(timing,                                               //< Namespace
                  EndpointBroadcastMessageCountersNotReady,             
                  " Endpoint broadcast message counters are not ready!", 
                  ERS_EMPTY                                             
)
 
ERS_DECLARE_ISSUE(timing,                                                                                                             
                  MonitoredEndpointDelaySet,                                                                                          
                  " Applied delay " << delay << " to endpoint at address " << address << ", in state: " << state, 
                  ((uint32_t)delay)((uint16_t)address)((uint16_t)state)                                                               
)
 
ERS_DECLARE_ISSUE(timing,                       
  UnknownTimestampSource,                       
  " Unknown timestamp source: " << ts_source, 
  ((uint)ts_source)                             
)
} // namespace dunedaq
 
#endif // TIMING_INCLUDE_TIMING_TIMINGISSUES_HPP_