dunedaq::sspmodules::DeviceManager Class Reference

#include <DeviceManager.hpp>

Public Member Functions
Device *	OpenDevice (unsigned int deviceId, bool slowControlOnly=false)
void	RefreshDevices ()

Static Public Member Functions
static DeviceManager &	Get ()

Private Member Functions
	DeviceManager ()
	DeviceManager (DeviceManager const &)
void	operator= (DeviceManager const &)

Private Attributes
std::map< unsigned long, std::unique_ptr< EthernetDevice > >	fEthernetDevices
bool	fHaveLookedForDevices

Detailed Description

Definition at line 29 of file DeviceManager.hpp.

Constructor & Destructor Documentation

DeviceManager() [1/2]

dunedaq::sspmodules::DeviceManager::DeviceManager ( )

private

Definition at line 35 of file DeviceManager.cxx.

{}

DeviceManager() [2/2]

dunedaq::sspmodules::DeviceManager::DeviceManager ( DeviceManager const & )

private

Member Function Documentation

Get()

dunedaq::sspmodules::DeviceManager & dunedaq::sspmodules::DeviceManager::Get ( )

static

Definition at line 29 of file DeviceManager.cxx.

{
  static dunedaq::sspmodules::DeviceManager instance;
  return instance;
}

OpenDevice()

dunedaq::sspmodules::Device * dunedaq::sspmodules::DeviceManager::OpenDevice	(	unsigned int	deviceId,
		bool	slowControlOnly = false )

Definition at line 161 of file DeviceManager.cxx.

{
 
  Device* device = 0;
  if (fEthernetDevices.find(deviceNum) == fEthernetDevices.end()) {
    fEthernetDevices[deviceNum] = (std::move(
      std::unique_ptr<dunedaq::sspmodules::EthernetDevice>(new dunedaq::sspmodules::EthernetDevice(deviceNum))));
  }
  if (fEthernetDevices[deviceNum]->IsOpen()) {
    // dune::DAQLogger::LogError("SSP_DeviceManager")<<"Attempt to open already open device!"<<std::endl;
    throw(EDeviceAlreadyOpen());
  } else {
    device = fEthernetDevices[deviceNum].get();
    device->Open(slowControlOnly);
  }
  return device;
}

operator=()

void dunedaq::sspmodules::DeviceManager::operator= ( DeviceManager const & )

private

RefreshDevices()

void dunedaq::sspmodules::DeviceManager::RefreshDevices

(

)

Definition at line 47 of file DeviceManager.cxx.

{
  for (auto device = fEthernetDevices.begin(); device != fEthernetDevices.end(); ++device) {
    if ((device->second)->IsOpen()) {
      // dune::DAQLogger::LogWarning("SSP_DeviceManager")<<"Device manager refused request to refresh device list"
      //<<"due to ethernet devices still open"<<std::endl;
    }
  }
 
  // Clear Device List
  // fUSBDevices.clear();
  fEthernetDevices.clear();
 
  //
  //  //===========================//
  //  //==Find USB devices=========//
  //  //===========================//
  //
  //  unsigned int ftNumDevs;
  //
  //  std::map<std::string,FT_DEVICE_LIST_INFO_NODE*> dataChannels;
  //  std::map<std::string,FT_DEVICE_LIST_INFO_NODE*> commChannels;
  //
  //  // This code uses FTDI's D2XX driver to determine the available devices
  //  if(FT_CreateDeviceInfoList(&ftNumDevs)!=FT_OK){
  //    try {
  //      //dune::DAQLogger::LogError("SSP_DeviceManager")<<"Failed to create FTDI device info list"<<std::endl;
  //    } catch (...) {}
  //    throw(EFTDIError("Error in FT_CreateDeviceInfoList"));
  //  }
  //
  //  FT_DEVICE_LIST_INFO_NODE* deviceInfoNodes=new FT_DEVICE_LIST_INFO_NODE[ftNumDevs];
  //
  //  if(FT_GetDeviceInfoList(deviceInfoNodes,&ftNumDevs)!=FT_OK){
  //    delete deviceInfoNodes;
  //    try {
  //      //dune::DAQLogger::LogError("SSP_DeviceManager")<<"Failed to get FTDI device info list"<<std::endl;
  //    } catch (...) {}
  //    throw(EFTDIError("Error in FT_GetDeviceInfoList"));
  //  }
  //
  //  //Search through all devices for compatible interfaces
  //  for (unsigned int i = 0; i < ftNumDevs; i++) {
  //      // NOTE 1: Each device is actually 2 FTDI devices. Device with "A" at the end of serial number is the
  //      // data channel. "B" is the comms channel. Need to associate FTDI devices with the same base
  //      // number together to get a "whole" board.
  //      //
  //      // NOTE 2: There is a rare error in which the FTDI driver returns FT_OK but the device info is incorrect
  //      // In this case, the check on ftType and/or length of ftSerial will fail
  //      // The discover code will therefore fail to find any useable devices but will not return an error
  //      // The calling code should check numDevices and rerun FindDevices if it equals zero
  //
  //      // Search only for devices we can use (skip any others)
  //      if (deviceInfoNodes[i].Type != FT_DEVICE_2232H) {
  //    continue;   // Skip to next device
  //      }
  //
  //      // Add FTDI device to Device List using Serial number
  //      //If length is zero, then device is probably open in another process (though maybe we don't get type then
  //      either...)
  //      //===TODO: Should check flags for open devices and report the number open in other processes to cout
  //      unsigned int length = strlen(deviceInfoNodes[i].SerialNumber);    // Find length of serial number
  //      (including 'A' or 'B') if (length == 0) {
  //    continue;   // Skip to next device
  //      }
  //
  //      char serial[16];
  //
  //      strncpy(serial, deviceInfoNodes[i].SerialNumber, length - 1); // Copy base serial number
  //      serial[length-1] = 0;                 // Append NULL because strncpy() didn't!
  //
  //      // Update device list with FTDI device number
  //      switch (deviceInfoNodes[i].SerialNumber[length -1]) {
  //      case 'A':
  //    dataChannels[serial]=&(deviceInfoNodes[i]);
  //    break;
  //      case 'B':
  //    commChannels[serial]=&(deviceInfoNodes[i]);
  //    break;
  //      default:
  //    break;
  //      }
  //  }
  //
  //  //Check that device list is as expected, then construct USB device objects for each board
  //  if(dataChannels.size()!=commChannels.size()){
  //    try {
  //      //dune::DAQLogger::LogError("SSP_DeviceManager")<<"Different number of data and comm channels on
  //      FTDI!"<<std::endl;
  //    } catch (...) {}
  //    delete deviceInfoNodes;
  //    throw(EBadDeviceList());
  //  }
  //  std::map<std::string,FT_DEVICE_LIST_INFO_NODE*>::iterator dIter=dataChannels.begin();
  //  std::map<std::string,FT_DEVICE_LIST_INFO_NODE*>::iterator cIter=commChannels.begin();
  //
  //  for(;dIter!=dataChannels.end();++dIter,++cIter){
  //    if(dIter->first!=cIter->first){
  //      try {
  //    //dune::DAQLogger::LogError("SSP_DeviceManager")<<"Non-matching serial numbers for data and comm channels on
  // FTDI!"<<std::endl;
  //      } catch (...) {}
  //      delete deviceInfoNodes;
  //      throw(EBadDeviceList());
  //    }
  //    fUSBDevices.push_back(USBDevice(dIter->second,cIter->second));
  //    //dune::DAQLogger::LogInfo("SSP_DeviceManager")<<"Found a device with serial "<<dIter->first<<std::endl;
  //  }
  //
  //  delete[] deviceInfoNodes;
  //
}

Member Data Documentation

fEthernetDevices

std::map<unsigned long, std::unique_ptr<EthernetDevice> > dunedaq::sspmodules::DeviceManager::fEthernetDevices

private

Definition at line 56 of file DeviceManager.hpp.

fHaveLookedForDevices

bool dunedaq::sspmodules::DeviceManager::fHaveLookedForDevices

private

Definition at line 58 of file DeviceManager.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/sspmodules/src/anlBoard/DeviceManager.hpp
• /github/workspace/dunedaq/sourcecode/sspmodules/src/anlBoard/DeviceManager.cxx