Interface to access and modify features on a Gen<i>Cam device. More...

#include <BFGTLUtilities.hpp>

Public Member Functions
	Device (BFVOID)

	~Device (BFVOID)

BFVOID	open (BufferAcquisition::BufferInterface const &bufin)

BFVOID	open (Bd hBoard)

BFVOID	open (const BFU32 brdNum)

BFVOID	openSWConnector (const BFU32 Switch, const BFU32 Connector)

BFVOID	close (BFVOID)

BFBOOL	isOpen (BFVOID) const

bool	operator! (BFVOID) const

	operator bool (BFVOID) const

Bd	getBoardHandle (BFVOID) const

BFU32	getBoardNumber (BFVOID) const

BFVOID	getBoardSWConnector (BFU32 &Switch, BFU32 &Connector) const

std::vector< std::string >	getNodeNames (BFVOID) const

BFBOOL	enumerateNodeName (const BFSIZET index, BFCHAR const nameBuf, BFSIZET const pNameSize) const

BFBOOL	nodeExists (std::string const &name) const

BFBOOL	nodeExists (const BFCHAR *const name) const

BaseNode	getNode (std::string const &name) const

BaseNode	getNode (const BFCHAR *const name) const

Static Public Member Functions
static BFU32	boardCount (BFVOID)

Detailed Description

Interface to access and modify features on a Gen<i>Cam device.

The BFGTLUtilities::Device class provides an independent interface to Gen<i>Cam devices, as exposed by BitFlow frame grabbers through the BFGTL Gen<i>Cam producer. This may be used simultaneously with the BufferAcquisition classes, or completely independently. BufferAcquisition::BufferInterface implements its own CXP register methods.

Constructor & Destructor Documentation

Device::Device ( BFVOID )

Construct an unopened BFGTLUtilities Device.

35 : m_pd (new PrivateData)

36 { }

Device::~Device ( BFVOID )

Deallocate the BFGTLUtilities Device.

References close().

 {
     close();
     delete m_pd;
 }

Member Function Documentation

BFU32 Device::boardCount ( BFVOID )

static

Return the number of BitFlow boards installed on the system.

Returns: The number of BitFlow boards installed on the system.

Exceptions

BiException - Thrown if the BitFlow boards cannot be enumerated.

References BI_CIERROR_CISYSBRDENUM, and BiException::check().

 {
     BFU32 count;
     if (BF_OK != CiSysBrdEnum(CISYS_TYPE_ANY, &count))
         BiException::check(0, BI_CIERROR_CISYSBRDENUM);
     return count;
 }

BFVOID Device::close ( BFVOID )

Close the BFGTL Camera Device.

Exceptions

BFCiException - Thrown if the Device cannot be closed.

References BFCiException::check().

Referenced by open(), openSWConnector(), and ~Device().

 {
     if (m_pd->m_dev)
         BFCiException::check(m_pd->m_hBoard, BFGTLDevClose(m_pd->m_dev) );
 
     if (m_pd->m_hBoardLcl)
         CiBrdClose(m_pd->m_hBoardLcl);
 
     m_pd->m_hBoard = nullptr;
     m_pd->m_hBoardLcl = nullptr;
     m_pd->m_dev = nullptr;
     m_pd->m_boardNumber = ~BFU32(0);
     m_pd->m_switch = ~BFU32(0);
     m_pd->m_connector = ~BFU32(0);
 }

BFBOOL Device::enumerateNodeName	(	const BFSIZET	index,
		BFCHAR *const	nameBuf,
		BFSIZET *const	pNameSize
	)		const

Retrieve a list of all available Camera Device node names.

Parameters

[in]	index	- The node index to enumerate.
[out]	nameBuf	- The node name string buffer, filled with as much data as is possible. This may be nullptr.
[in,out]	pNameSize	- As input, the size of nameBuf. As output, the buffer size required to read the entire name string.

Returns: True if the node at index exists.

Exceptions

BFCiException - Thrown if a Device access error occurs.

References BFCiException::check().

 {
     size_t nodeCnt;
     BFCiException::check(m_pd->m_hBoard, BFGTLDevNodeEnum(m_pd->m_dev, &nodeCnt) );
 
     if (index >= nodeCnt)
         return false;
     
     BFCiException::check(m_pd->m_hBoard, BFGTLDevNodeName(m_pd->m_dev, index, nameBuf, pNameSize) );
 
     return true;
 }

Bd Device::getBoardHandle ( BFVOID ) const

Return the opened board handle. If opened by board number or switch connector, this is an internally allocated handle. If opened by Bd handle, this is the externally supplied handle. If closed, returns nullptr.

Returns: The corresponding board handle, if opened. nullptr, if closed.

 {
     return m_pd->m_hBoard;
 }

BFU32 Device::getBoardNumber ( BFVOID ) const

Return the opened board number. Returns ~BFU32(0), if the board isn't open, or wasn't opened with a board number (see getBoardSWConnector).

Returns: The current board number, if opened by board number. ~BFU32(0), otherwise.

 {
     return m_pd->m_boardNumber;
 }

BFVOID Device::getBoardSWConnector	(	BFU32 &	Switch,
		BFU32 &	Connector
	)		const

Retrieve the opened board switch and connector. Retrieves ~BFU32(0), if the board isn't open, or wasn't opened with openSWConnector (see getBoardNumber).

 {
     Switch = m_pd->m_switch;
     Connector = m_pd->m_connector;
 }

BaseNode Device::getNode ( std::string const & name ) const

Retrieve a Camera Device node from a given node name.

Returns: A Camera Device node from a given node name.

Exceptions

BFCiException - Thrown if no node could be opened on this Device with the given name.

References BFCiException::check().

 {
     BFGTLNode hNode;
     BFCiException::check(m_pd->m_hBoard, BFGTLNodeOpen(m_pd->m_dev, name.c_str(), &hNode) );
     
     return BaseNode (m_pd->m_hBoard, *this, hNode);
 }

BaseNode Device::getNode ( const BFCHAR *const name ) const

Retrieve a Camera Device node from a given node name.

Returns: A Camera Device node from a given node name.

Exceptions

BFCiException - Thrown if no node could be opened on this Device with the given name.

References BFCiException::check().

 {
     BFGTLNode hNode;
     BFCiException::check(m_pd->m_hBoard, BFGTLNodeOpen(m_pd->m_dev, name, &hNode) );
     
     return BaseNode (m_pd->m_hBoard, *this, hNode);
 }

std::vector< std::string > Device::getNodeNames ( BFVOID ) const

Retrieve a list of all available Camera Device node names.

Returns: A list of all available Camera Device node names.

Exceptions

BFCiException - Thrown if a Device access error occurs.

References BFCiException::check().

 {
     size_t nodeCnt;
     BFCiException::check(m_pd->m_hBoard, BFGTLDevNodeEnum(m_pd->m_dev, &nodeCnt) );
     
     std::vector<std::string> nodeNames (nodeCnt);
     for (size_t i = 0; i < nodeCnt; i++)
     {
         size_t nameSize;
         BFCiException::check(m_pd->m_hBoard, BFGTLDevNodeName(m_pd->m_dev, i, nullptr, &nameSize) );
 
         std::vector<char> nameStr (nameSize);
         BFCiException::check(m_pd->m_hBoard, BFGTLDevNodeName(m_pd->m_dev, i, nameStr.data(), &nameSize) );
         nameStr.back() = 0;
 
         nodeNames[i] = nameStr.data();
     }
 
     return std::move(nodeNames);
 }

BFBOOL Device::isOpen ( BFVOID ) const

Return whether or not a BFGTL Camera Device has been opened or not.

Returns: Whether or not a BFGTL Camera Device has been opened or not.

Referenced by operator!().

 {
     return !!m_pd->m_dev;
 }

BFBOOL Device::nodeExists ( std::string const & name ) const

Query whether or not the named node exists.

Returns: True or false, whether or not the named node exists for this device.

 {
     return BFGTLDevNodeExists(m_pd->m_dev, name.c_str());
 }

BFBOOL Device::nodeExists ( const BFCHAR *const name ) const

Query whether or not the named node exists.

Returns: True or false, whether or not the named node exists for this device.

 {
     return BFGTLDevNodeExists(m_pd->m_dev, name);
 }

BFVOID Device::open ( BufferAcquisition::BufferInterface const & bufin )

Open the Device corresponding to specified BufferInterface. The Device must be closed prior to closing the BufferInterface. Closes the current Device first, if necessary.

Exceptions

BFCiException - Thrown if the Device cannot be opened.

References BufferAcquisition::BufferInterface::getBoardHandle().

 {
     open(bufin.getBoardHandle());
 }

BFVOID Device::open ( Bd hBoard )

Open the BFGTL Camera Device corresponding to the given board handle. The Device must be closed prior to closing the board handle. Closes the current Device first, if necessary.

Exceptions

BFCiException - Thrown if the Device cannot be opened.

References BFCiException::check(), and close().

 {
     close();
 
     BFGTLDev hDev;
     BFCiException::check(hBoard, BFGTLDevOpen(hBoard, &hDev) );
 
     m_pd->m_hBoard = hBoard;
     m_pd->m_dev = hDev;
 }

BFVOID Device::open ( const BFU32 brdNum )

Open a BFGTL Camera Device for the given board number. Closes the current Device first, if necessary.

Exceptions

BiException	- Thrown if the specified board couldn't be accessed.
BFCiException	- Thrown if the Device cannot be opened.

References BiTypeAny, BFCiException::check(), BiException::check(), and close().

 {
     close();
 
     Bd hBoard;
     BiException::check(0, BiBrdOpenEx(BiTypeAny, brdNum, &hBoard, BFSysSecondProcessOpen|BFSysAllowTwoOpens|BFSysNoIntThread|BFSysNoCameraOpen) );
 
     BFGTLDev hDev;
     try
     {
         BFCiException::check(hBoard, BFGTLDevOpen(hBoard, &hDev) );
     }
     catch (BFExceptionBase const&)
     {
         BiBrdClose(hBoard);
         throw;
     }
     
     m_pd->m_hBoard = hBoard;
     m_pd->m_hBoardLcl = hBoard;
     m_pd->m_dev = hDev;
     m_pd->m_boardNumber = brdNum;
 }

BFVOID Device::openSWConnector	(	const BFU32	Switch,
		const BFU32	Connector
	)

Open a BFGTL Camera Device for the given Board switch and Connector. Closes the current Device first, if necessary.

Exceptions

BiException	- Thrown if the specified board couldn't be accessed.
BFCiException	- Thrown if the Device cannot be opened.

References BI_CIERROR_CIBRDOPEN, BI_CIERROR_CISYSBOARDFINDSWCONNECTOR, BFCiException::check(), BiException::check(), and close().

 {
     BFRC rc;
     close();
 
     CiENTRY entry;
     rc = CiSysBoardFindSWConnector(CISYS_TYPE_ANY, Switch, Connector, &entry);
     if (BF_OK != rc)
         BiException::check(0, BI_CIERROR_CISYSBOARDFINDSWCONNECTOR);
 
     Bd hBoard;
     rc = CiBrdOpen(&entry, &hBoard, BFSysSecondProcessOpen|BFSysAllowTwoOpens);
     if (BF_OK != rc)
         BiException::check(0, BI_CIERROR_CIBRDOPEN);
 
     BFGTLDev hDev;
     try
     {
         BFCiException::check(hBoard, BFGTLDevOpen(hBoard, &hDev) );
     }
     catch (BFExceptionBase const&)
     {
         CiBrdClose(hBoard);
         throw;
     }
 
     m_pd->m_hBoard = hBoard;
     m_pd->m_hBoardLcl = hBoard;
     m_pd->m_dev = hDev;
     m_pd->m_switch = Switch;
     m_pd->m_connector = Connector;
 }

Device::operator bool ( BFVOID ) const

Equivalent to isOpen.

Returns: Whether or not a BFGTL Camera Device has been opened or not.

 {
     return !!isOpen();
 }

bool Device::operator! ( BFVOID ) const

Inverse of isOpen.

Returns: Whether or not a BFGTL Camera Device is closed.

References isOpen().

 {
     return !isOpen();
 }

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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation