Wrapper around the Camera Link serial port API. More...

#include <CLAllSerial.hpp>

Classes
struct	PrivateData

Public Member Functions
	CLAllSerial (BFVOID)

	~CLAllSerial (BFVOID)

BFVOID	serialInit (const CLUINT32 SerialIndex)

BFVOID	bfSerialInit (const CLUINT32 BoardIndex)

BFVOID	bfSWConnectorSerialInit (const CLUINT32 Switch, const CLUINT32 Connector)

BFVOID	serialClose (BFVOID)

BFBOOL	hasInit (BFVOID) const

BFBOOL	hasBFSerial (BFVOID) const

CLUINT32	getSerialIndex (void) const

CLUINT32	getBoardNumber (void) const

void	getSWConnector (CLUINT32 &Switch, CLUINT32 &Connector) const

CLUINT32	serialWrite (std::string const &Message, const CLUINT32 SerialTimeout)

CLUINT32	serialWrite (std::vector< CLINT8 > const &Buffer, const CLUINT32 SerialTimeout)

CLUINT32	serialWrite (const CLINT8 *const Buffer, const BFSIZET BufferLen, const CLUINT32 SerialTimeout)

std::string	serialRead (const CLUINT32 NumBytesToRead, const CLUINT32 SerialTimeout)

CLUINT32	serialRead (std::vector< CLINT8 > &Buffer, const CLUINT32 ReadLen, const CLUINT32 SerialTimeout) const

CLUINT32	serialRead (CLINT8 *const Buffer, const CLUINT32 BufferSize, const CLUINT32 SerialTimeout) const

BFVOID	flushPort (BFVOID)

CLUINT32	getNumBytesAvail (BFVOID) const

CLUINT32	getSupportedBaudRates (BFVOID) const

BFVOID	setBaudRate (const CLUINT32 BaudRate)

BFVOID	bfSerialSettings (const CLUINT32 BaudRate, const DataBits dataBits, const Parity parity, const StopBits stopBits)

std::string	bfSerialRead (const CLUINT32 MaxBytesToRead) const

CLUINT32	bfSerialRead (std::vector< BFCHAR > &Buffer, const CLUINT32 MaxBytesToRead) const

CLUINT32	bfSerialRead (PBFCHAR Buffer, const CLUINT32 MaxBytesToRead) const

BFVOID	bfSerialCancelRead (BFVOID)

CLUINT32	bfGetBaudRate (BFVOID) const

Static Public Member Functions
static std::string	getErrorText (const CLINT32 ErrorCode)

static BFBOOL	getErrorText (const CLINT32 ErrorCode, BFCHAR const hBuf, BFSIZET const pSize)

static CLUINT32	getNumPorts (BFVOID)

static BFVOID	getPortInfo (const CLUINT32 SerialIndex, std::string &ManufacturerName, std::string &PortID, CLUINT32 &Version)

static BFBOOL	getPortInfo (const CLUINT32 SerialIndex, BFCHAR const ManufacturerName, BFSIZET const pManNameSize, BFCHAR const PortID, BFSIZET const pPortIdSize, CLUINT32 &Version)

static BFVOID	bfsVersion (CLUINT32 &majorVersionRef, CLUINT32 &minorVersionRef)

Detailed Description

Wrapper around the Camera Link serial port API.

Both the CLAllSerial.h and BFSerial.h interfaces are exposed, although the BitFlow serial functions will only be operable for ports on BitFlow boards.

Constructor & Destructor Documentation

CLAllSerial::CLAllSerial ( BFVOID )

Initialize a new CLComm::CLAllSerial instance.

39 : m_pd (*new PrivateData)

40 { }

CLAllSerial::~CLAllSerial ( BFVOID )

Clean up the CLAllSerial instance and its resources.

References serialClose().

 {
     serialClose();
     delete &m_pd;
 }

Member Function Documentation

CLUINT32 CLAllSerial::bfGetBaudRate ( BFVOID ) const

Return the current baud-rate of the CLSerial port.

Returns

The current port baud rate, of the following options:

Exceptions

BFCLException - Thrown if an error occurs while retrieving the baud rate.

References BFCL_ERROR_SERNOTFOUND, CLComm::BFCLException::check(), clBFGetBaudRate(), and hasBFSerial().

 {
     if (!hasBFSerial())
         BFCLException::check(BFCL_ERROR_SERNOTFOUND);
 
     unsigned int baudRate;
     BFCLException::check( clBFGetBaudRate(m_pd.bfSerRef, &baudRate) );
     return baudRate;
 }

BFVOID CLAllSerial::bfSerialCancelRead ( BFVOID )

Cancel the active call to clBFSerialRead.

Exceptions

BFCLException - Thrown if an error occurs while canceling the read.

References BFCL_ERROR_SERNOTFOUND, CLComm::BFCLException::check(), clBFSerialCancelRead(), and hasBFSerial().

 {
     if (!hasBFSerial())
         BFCLException::check(BFCL_ERROR_SERNOTFOUND);
 
     BFCLException::check( clBFSerialCancelRead(m_pd.bfSerRef) );
 }

BFVOID CLAllSerial::bfSerialInit ( const CLUINT32 BoardIndex )

Alternate initializer, initializing from a BitFlow board index, rather than from the CLSerial port index, which may or may not directly correspond.

Parameters

[in] BoardIndex - The index of the BitFlow board whos Camera Link serial port should be opened.

Exceptions

BiException	- Thrown if an error occurs opening the frame grabber.
BFCLException	- Thrown if an error occurs initializing the port.

References BiTypeAny, BrdOpenOptions, BiException::check(), CLComm::BFCLException::check(), CL_ERR_NO_ERR, clBFGetSerialRefFromBoardHandle(), clBFSerialInitFromBoardHandle(), clSerialClose(), and serialClose().

 {
     serialClose();
 
     // Open the BitFlow board.
     Bd hBoard;
     BiException::check(0, BiBrdOpenEx(BiTypeAny, BoardIndex, &hBoard, BrdOpenOptions) );
 
     // Initialize the CL serial port.
     hSerRef clSerRef;
     CLINT32 rc = clBFSerialInitFromBoardHandle(hBoard, &clSerRef);
     if (CL_ERR_NO_ERR != rc)
     {
         BiBrdClose(hBoard);
         BFCLException::check(rc);
     }
 
     // Get the serial reference.
     BFVOID *bfSerRef;
     rc = clBFGetSerialRefFromBoardHandle(hBoard, &bfSerRef);
     if (BF_OK != rc)
     {
         clSerialClose(clSerRef);
         BiBrdClose(hBoard);
         BFCLException::check(rc);
     }
 
     // Store the CLSerial handles.
     m_pd.clSerRef = clSerRef;
     m_pd.bfSerRef = bfSerRef;
     m_pd.hBoard = hBoard;
 
     m_pd.boardNumber = BoardIndex;
 }

std::string CLAllSerial::bfSerialRead ( const CLUINT32 MaxBytesToRead ) const

Reads data from the serial device. This method will wait efficiently for data to become available on the port, then return that length of data. No more than MaxBytesToRead will be read at a time, but the length read may be less than that.

Parameters

[in] MaxBytesToRead - The maximum number of bytes to be read.

Returns: The data read, formatted as a null-terminated string.

Exceptions

BFCLException - Thrown if an error occurs while reading the data.

References BFCL_ERROR_SERNOTFOUND, CLComm::BFCLException::check(), and hasBFSerial().

Referenced by bfSerialRead().

 {
     if (!hasBFSerial())
         BFCLException::check(BFCL_ERROR_SERNOTFOUND);
 
     std::vector<BFCHAR> buf (MaxBytesToRead);
     const CLUINT32 bytesRead = bfSerialRead(buf.data(), MaxBytesToRead);
     return std::string (buf.data(), bytesRead);
 }

CLUINT32 CLAllSerial::bfSerialRead	(	std::vector< BFCHAR > &	Buffer,
		const CLUINT32	MaxBytesToRead
	)		const

Reads data from the serial device. This method will wait efficiently for data to become available on the port, then return that length of data. Returns the number of bytes read.

Parameters

[out]	Buffer	- Output buffer for the data read, This will be resized to fit the data read, if necessary.
[in]	MaxBytesToRead	- The maximum number of bytes to be read.

Returns: The number of bytes read from the serial port.

Exceptions

BFCLException - Thrown if an error occurs while reading the data.

References BFCL_ERROR_SERNOTFOUND, bfSerialRead(), CLComm::BFCLException::check(), and hasBFSerial().

 {
     if (!hasBFSerial())
         BFCLException::check(BFCL_ERROR_SERNOTFOUND);
 
     if (MaxBytesToRead > Buffer.size())
         Buffer.resize(MaxBytesToRead);
 
     return bfSerialRead(Buffer.data(), MaxBytesToRead);
 }

CLUINT32 CLAllSerial::bfSerialRead	(	PBFCHAR	Buffer,
		const CLUINT32	MaxBytesToRead
	)		const

Reads data from the serial device. This method will wait efficiently for data to become available on the port, then return that length of data. Returns the number of bytes read.

Parameters

[out]	Buffer	- Output buffer for the data read.
[in]	MaxBytesToRead	- The maximum number of bytes to be read. Buffer should be no smaller than this byte size.

Returns: The number of bytes read from the serial port.

Exceptions

BFCLException - Thrown if an error occurs while reading the data.

References BFCL_ERROR_SERNOTFOUND, CLComm::BFCLException::check(), clBFSerialRead(), and hasBFSerial().

 {
     if (!hasBFSerial())
         BFCLException::check(BFCL_ERROR_SERNOTFOUND);
 
     unsigned int bufferSize = MaxBytesToRead;
     BFCLException::check( clBFSerialRead(m_pd.bfSerRef, Buffer, &bufferSize) );
     return bufferSize;
 }

BFVOID CLAllSerial::bfSerialSettings	(	const CLUINT32	BaudRate,
		const DataBits	dataBits,
		const Parity	parity,
		const StopBits	stopBits
	)

Set the BF CLSerial settings.

Parameters

[in]	BaudRate	- The baud rate to set, of the following options: CL_BAUDRATE_9600 CL_BAUDRATE_19200 CL_BAUDRATE_38400 CL_BAUDRATE_57600 CL_BAUDRATE_115200 CL_BAUDRATE_230400 CL_BAUDRATE_460800 CL_BAUDRATE_921600
[in]	dataBits	- The serial port data bits to use, of the following options: DataBits_5 DataBits_6 DataBits_7 DataBits_8
[in]	parity	- The serial port parity to use, of the following options: ParityEven ParityOdd ParityNone
[in]	stopBits	- The serial port stop bits to use, of the following options: StopBits_1 StopBits_15 StopBits_2

Exceptions

BFCLException - Thrown if an error occurs while setting the settings.

References BFCL_ERROR_SERNOTFOUND, CLComm::BFCLException::check(), clBFSerialSettings(), and hasBFSerial().

 {
     if (!hasBFSerial())
         BFCLException::check(BFCL_ERROR_SERNOTFOUND);
 
     BFCLException::check( clBFSerialSettings(m_pd.bfSerRef, BaudRate, dataBits, parity, stopBits) );
 }

BFVOID CLAllSerial::bfsVersion	(	CLUINT32 &	majorVersionRef,
		CLUINT32 &	minorVersionRef
	)

static

Retrieve the version of the loaded BFS library.

Parameters

[out]	majorVersionRef	- Ouput integer for the major part of the version number.
[out]	minorVersionRef	- Ouput integer for the minor part of the version number.

Exceptions

BFCLException - Thrown if an error occurs retrieving the version number.

References BFSVersion(), and CLComm::BFCLException::check().

 {
     BFCLException::check( BFSVersion(&majorVersionRef, &minorVersionRef) );
 }

BFVOID CLAllSerial::bfSWConnectorSerialInit	(	const CLUINT32	Switch,
		const CLUINT32	Connector
	)

Alternate initializer, initializing from a BitFlow board swith and connector, rather than from the CLSerial port index, which may or may not directly correspond.

Parameters

[in]	Switch	- The switch setting on the BitFlow board whos Camera Link serial port should be opened.
[in]	Connector	- The connector index to open on the board.

Exceptions

BiException	- Thrown if an error occurs opening the frame grabber.
BFCLException	- Thrown if an error occurs initializing the port.

References BI_CIERROR_CIBRDOPEN, BI_CIERROR_CISYSBOARDFINDSWCONNECTOR, BrdOpenOptions, BiException::check(), CLComm::BFCLException::check(), CL_ERR_NO_ERR, clBFGetSerialRefFromBoardHandle(), clBFSerialInitFromBoardHandle(), clSerialClose(), and serialClose().

 {
     serialClose();
 
     // Open the BitFlow board.
     CiENTRY entry;
     BFRC rc = CiSysBoardFindSWConnector(CISYS_TYPE_ANY, Switch, Connector, &entry);
     if (BF_OK != rc)
         BiException::check(0, BI_CIERROR_CISYSBOARDFINDSWCONNECTOR);
 
     Bd hBoard;
     rc = CiBrdOpen(&entry, &hBoard, BrdOpenOptions);
     if (BF_OK != rc)
         BiException::check(0, BI_CIERROR_CIBRDOPEN);
 
     // Initialize the CL serial port.
     hSerRef clSerRef;
     rc = clBFSerialInitFromBoardHandle(hBoard, &clSerRef);
     if (CL_ERR_NO_ERR != rc)
     {
         CiBrdClose(hBoard);
         BFCLException::check(rc);
     }
 
     // Get the serial reference.
     BFVOID *bfSerRef;
     rc = clBFGetSerialRefFromBoardHandle(hBoard, &bfSerRef);
     if (BF_OK != rc)
     {
         clSerialClose(clSerRef);
         CiBrdClose(hBoard);
         BFCLException::check(rc);
     }
 
     // Store the CLSerial handles.
     m_pd.clSerRef = clSerRef;
     m_pd.bfSerRef = bfSerRef;
     m_pd.hBoard = hBoard;
     
     m_pd.bfSwitch = Switch;
     m_pd.bfConnector = Connector;
 }

BFVOID CLAllSerial::flushPort ( BFVOID )

Discards any bytes that are available in the input buffer.

Exceptions

BFCLException - Thrown if an error occurs while flushing the serial port.

References CLComm::BFCLException::check(), and clFlushPort().

 {
     BFCLException::check( clFlushPort(m_pd.clSerRef) );
 }

CLUINT32 CLAllSerial::getBoardNumber ( void ) const

Retrieve the BitFlow board number initialized, or ~CLUINT32(0), if not open or not initialized by the BitFlow board nubmer.

Returns: The BitFlow board number initialized, or ~CLUINT32(0), if not open or not initialized by the serial index.

 {
     return m_pd.boardNumber;
 }

std::string CLAllSerial::getErrorText ( const CLINT32 ErrorCode )

static

Converts an error code to error text which can be displayed in a dialog box or in the standard I/O window.

Parameters

[in] ErrorCode - The code of the error text to retrieve.

Returns: The error text message.

Exceptions

BFCLException - Thrown if an error occurs retrieving the error text.

References BFCL_ERROR_15STOP5DATA, BFCL_ERROR_2STOP5DATA, BFCL_ERROR_BAUDRATE, BFCL_ERROR_BRDNOTFOUND, BFCL_ERROR_BRDOPEN, BFCL_ERROR_BYTES_AVAIL, BFCL_ERROR_DATA_IN, BFCL_ERROR_DATABITS, BFCL_ERROR_FIFO_EN, BFCL_ERROR_FLUSH_PORT, BFCL_ERROR_NOSIGNAL, BFCL_ERROR_NOSTRUC, BFCL_ERROR_NULLPTR, BFCL_ERROR_PARITY, BFCL_ERROR_RCVRFIFO, BFCL_ERROR_SERNOTFOUND, BFCL_ERROR_STOPBITS, BFCL_ERROR_TEMT, BFCL_ERROR_THRE, BFCL_WARN_SIG_CANCEL, CLComm::BFCLException::check(), CL_ERR_BUFFER_TOO_SMALL, clGetErrorText(), and MAX_STRING.

Referenced by getErrorText().

 {
     // Check the BitFlow CL error codes, first.
     switch (ErrorCode)
     {
     case BFCL_ERROR_SERNOTFOUND:                return "BFSerial error: The serial device was not found.";
     case BFCL_ERROR_BRDNOTFOUND:                return "BFSerial error: There are no R2 boards installed.";
     case BFCL_ERROR_BRDOPEN:                    return "BFSerial error: Error opening board.";
     case BFCL_ERROR_THRE:                       return "BFSerial error: Transmitter Holding Register not empty (THRE).";
     case BFCL_ERROR_TEMT:                       return "BFSerial error: Transmitter not empty (TEMT).";
     case BFCL_ERROR_FIFO_EN:                    return "BFSerial error: FIFO's are not enabled.";
     case BFCL_ERROR_RCVRFIFO:                   return "BFSerial error: Error in RCVR FIFO.";
     case BFCL_ERROR_BAUDRATE:                   return "BFSerial error: Invalid Buad Rate.";
     case BFCL_ERROR_DATABITS:                   return "BFSerial error: Invalid number of data bits.";
     case BFCL_ERROR_PARITY:                     return "BFSerial error: Invalid parity parameter.";
     case BFCL_ERROR_15STOP5DATA:                return "BFSerial error: To use 1.5 number of stop bits, 5 data bits must be used..";
     case BFCL_ERROR_2STOP5DATA:                 return "BFSerial error: Can't use 5 data bits with 2 stop bits.";
     case BFCL_ERROR_STOPBITS:                   return "BFSerial error: Invalid number of stop bits.";
     case BFCL_ERROR_NOSIGNAL:                   return "BFSerial error: Can't create signal.";
     case BFCL_ERROR_NOSTRUC:                    return "BFSerial error: Can't create ref structure.";
     case BFCL_ERROR_NULLPTR:                    return "BFSerial error: BFNULL pointer.";
     case BFCL_ERROR_BYTES_AVAIL:                return "BFSerial error: Error getting the number of bytes available in the buffer.";
     case BFCL_ERROR_FLUSH_PORT:                 return "BFSerial error: Error flushing the port.";
     case BFCL_ERROR_DATA_IN:                    return "BFSerial error: The receive buffer could not be emptied.";
     case BFCL_WARN_SIG_CANCEL:                  return "BFSerial warning: BFSerialRead signal was cancelled.";
     }
 
     // Check the CLAllSerial error text function.
     const char *const manuName = "BitFlow, Inc.";
 
     std::vector<CLINT8> buf (MAX_STRING);
     CLUINT32 bufLen = CLUINT32(buf.size());
 
     CLINT32 rc = clGetErrorText(manuName, ErrorCode, buf.data(), &bufLen);
     if (CL_ERR_BUFFER_TOO_SMALL == rc)
     {
         buf.resize(++bufLen);
         rc = clGetErrorText(manuName, ErrorCode, buf.data(), &bufLen);
     }
 
     BFCLException::check(rc);
 
     buf.push_back(0);
     return buf.data();
 }

BFBOOL CLAllSerial::getErrorText	(	const CLINT32	ErrorCode,
		BFCHAR *const	hBuf,
		BFSIZET *const	pSize
	)

static

Converts an error code to error text which can be displayed in a dialog box or in the standard I/O window.

Parameters

[in]	ErrorCode	- The code of the error text to retrieve.
[out]	hBuf	- The string buffer pointer, filled with as much data as is possible. May be nullptr.
[in,out]	pSize	- As input, the size of hBuf. As output, the buffer size requried.

Returns: True on success, false otherwise.

Exceptions

BFCLException - Thrown if an error occurs retrieving the error text.

References getErrorText().

 {
     return BufInHelpers::set_str(getErrorText(ErrorCode), hBuf, pSize);
 }

CLUINT32 CLAllSerial::getNumBytesAvail ( BFVOID ) const

Returns the number of bytes that are received, but not yet read out of the the serial device.

Returns: The number of bytes that have been received, but net yet read out of the serial device.

Exceptions

BFCLException - Thrown if an error occurs while retrieving the number of bytes available.

References CLComm::BFCLException::check(), and clGetNumBytesAvail().

 {
     CLUINT32 numBytes;
     BFCLException::check( clGetNumBytesAvail(m_pd.clSerRef, &numBytes) );
     return numBytes;
 }

CLUINT32 CLAllSerial::getNumPorts ( BFVOID )

static

Returns the number of Camera Link serial ports in this machine that are supported by clallserial.dll.

Returns: The number of Camera Link serial ports installed on this system.

Exceptions

BFCLException - Thrown if an error occurs retrieving port count.

References CLComm::BFCLException::check(), and clGetNumPorts().

 {
     CLUINT32 numPorts;
     BFCLException::check( clGetNumPorts(&numPorts) );
     return numPorts;
 }

BFVOID CLAllSerial::getPortInfo	(	const CLUINT32	SerialIndex,
		std::string &	ManufacturerName,
		std::string &	PortID,
		CLUINT32 &	Version
	)

static

Provides information about the port specified by the serial index.

Parameters

[in]	SerialIndex	- The index of the serial port who's info we are retrieving.
[out]	ManufacturerName	- Output string for the manufacturer.
[out]	PortID	- Output string for the port ID.
[out]	Version	- Output integer for the CLAllSerial version.

Exceptions

BFCLException - Thrown if an error occurs retrieving the port information.

References CLComm::BFCLException::check(), CL_ERR_BUFFER_TOO_SMALL, clGetPortInfo(), and MAX_STRING.

Referenced by getPortInfo().

 {
     std::vector<CLINT8> manuName (MAX_STRING);
     CLUINT32 manuNameLen = CLUINT32(manuName.size());
 
     std::vector<CLINT8> pidName (MAX_STRING);
     CLUINT32 pidNameLen = CLUINT32(pidName.size());
 
     CLINT32 rc = clGetPortInfo(SerialIndex, manuName.data(), &manuNameLen, pidName.data(), &pidNameLen, &Version);
     if (CL_ERR_BUFFER_TOO_SMALL == rc)
     {
         manuName.resize(++manuNameLen);
         pidName.resize(++pidNameLen);
         rc = clGetPortInfo(SerialIndex, manuName.data(), &manuNameLen, pidName.data(), &pidNameLen, &Version);
     }
 
     BFCLException::check(rc);
 
     manuName.push_back(0);
     ManufacturerName = manuName.data();
 
     pidName.push_back(0);
     PortID = pidName.data();
 }

BFBOOL CLAllSerial::getPortInfo	(	const CLUINT32	SerialIndex,
		BFCHAR *const	ManufacturerName,
		BFSIZET *const	pManNameSize,
		BFCHAR *const	PortID,
		BFSIZET *const	pPortIdSize,
		CLUINT32 &	Version
	)

static

Provides information about the port specified by the serial index.

Parameters

[in]	SerialIndex	- The index of the serial port who's info we are retrieving.
[out]	ManufacturerName	- Output string buffer for the manufacturer. This may be nullptr.
[in,out]	pManNameSize	- As input, the ManufacturerName buffer size. As output, the required ManufacturerName buffer length, including null terminator.
[out]	PortID	- Output string buffer for the port ID. This may be nullptr.
[in,out]	pPortIdSize	- As input, the PortID buffer size. As output, the required PortID buffer length, including null terminator.
[out]	Version	- Output integer for the CLAllSerial version.

Returns: True on success, false otherwise.

Exceptions

BFCLException - Thrown if an error occurs retrieving the port information.

References getPortInfo().

 {
     std::string cppManufacturerName, cppPortID;
     getPortInfo(SerialIndex, cppManufacturerName, cppPortID, Version);
 
     if (!BufInHelpers::set_str(cppManufacturerName, ManufacturerName, pManNameSize))
         return false;
     
     if (!BufInHelpers::set_str(cppPortID, PortID, pPortIdSize))
         return false;
 
     return true;
 }

CLUINT32 CLAllSerial::getSerialIndex ( void ) const

Retrieve the serial index initialized, or ~CLUINT32(0), if not open or not initialized by the serial index.

Returns: The index of the opened Camera Link serial port, or ~CLUINT32(0), if not open or not initialized by the serial index.

 {
     return m_pd.serialIndex;
 }

CLUINT32 CLAllSerial::getSupportedBaudRates ( BFVOID ) const

Returns the valid baud rates of the interface.

Returns

The valid baud rates of the interface, ORd together. The known flags are:

Exceptions

BFCLException - Thrown if an error occurs while retrieving the supported baud rates.

References CLComm::BFCLException::check(), and clGetSupportedBaudRates().

 {
     CLUINT32 baudRates;
     BFCLException::check( clGetSupportedBaudRates(m_pd.clSerRef, &baudRates) );
     return baudRates;
 }

void CLAllSerial::getSWConnector	(	CLUINT32 &	Switch,
		CLUINT32 &	Connector
	)		const

Retrieve the BitFlow Switch and Connector initialized, or ~CLUINT32(0), if not open or not initialized by Switch and Connector.

Parameters

[out]	Switch	- Ouput integer reference set to the open board's switch setting, or ~CLUINT32(0), if not open or not initialized by Switch and Connector.
[out]	Connector	- Output integer reference set to the open board's connector index, or ~CLUINT32(0), if not open or not initialized by Switch and Connector.

 {
     Switch = m_pd.bfSwitch;
     Connector = m_pd.bfConnector;
 }

BFBOOL CLAllSerial::hasBFSerial ( BFVOID ) const

Return whether or not the opened port supports the BitFlow CLSerial extensions.

Returns: The BFSerial port initialization status.

Referenced by bfGetBaudRate(), bfSerialCancelRead(), bfSerialRead(), and bfSerialSettings().

 {
     return !!m_pd.bfSerRef;
 }

BFBOOL CLAllSerial::hasInit ( BFVOID ) const

Return whether or not a port has been initialized.

Returns: The CLAllSerial port initialization status.

 {
     return !!m_pd.clSerRef;
 }

BFVOID CLAllSerial::serialClose ( BFVOID )

Closes the serial device and cleans up resources associated with it. Does nothing, if the device is not Initialized.

References clSerialClose().

Referenced by bfSerialInit(), bfSWConnectorSerialInit(), serialInit(), and ~CLAllSerial().

 {
     if (m_pd.clSerRef)
         clSerialClose(m_pd.clSerRef);
 
     if (m_pd.hBoard)
         CiBrdClose(m_pd.hBoard);
 
     m_pd.clSerRef = nullptr;
     m_pd.bfSerRef = nullptr;
     m_pd.hBoard = nullptr;
     
     m_pd.serialIndex = ~CLUINT32(0);
     m_pd.boardNumber = ~CLUINT32(0);
     m_pd.bfSwitch    = ~CLUINT32(0);
     m_pd.bfConnector = ~CLUINT32(0);
 }

BFVOID CLAllSerial::serialInit ( const CLUINT32 SerialIndex )

Initializes the device referred to by serialIndex. Only CL boards are considered a serial device. If the underlying CLSerial device is not a BitFlow device, the BFSerial extensions will not be enabled, and hasBFSerial will return false.

Parameters

[in] SerialIndex - The index of the Camera Link serial port to initialize.

Exceptions

BFCLException - Thrown if an error occurs initializing the port.

References CLComm::BFCLException::check(), clBFGetSerialRef(), clSerialInit(), and serialClose().

 {
     serialClose();
 
     // Open the CLAllSerial port.
     hSerRef clSerRef;
     BFCLException::check( clSerialInit(SerialIndex, &clSerRef) );
 
     // Determine if BFSerial support is available for this serial port.
     BFVOID *bfSerRef;
     CLINT32 rc = clBFGetSerialRef(SerialIndex, &bfSerRef);
     if (BF_OK != rc)
         bfSerRef = nullptr;
     
     // Store the CLSerial handles.
     m_pd.clSerRef = clSerRef;
     m_pd.bfSerRef = bfSerRef;
 
     m_pd.serialIndex = SerialIndex;
 }

std::string CLAllSerial::serialRead	(	const CLUINT32	NumBytesToRead,
		const CLUINT32	SerialTimeout
	)

Reads data from the serial device.

Parameters

[in]	NumBytesToRead	- The number of bytes to be read.
[in]	SerialTimeout	- Timeout after which the read should abort.

Returns: The data read, formatted as a null-terminated string.

Exceptions

BFCLException - Thrown if an error occurs reading from the serial port, including timeout.

Referenced by serialRead().

 {
     std::vector<CLINT8> buf (NumBytesToRead);
     const CLUINT32 bytesRead = serialRead(buf, NumBytesToRead, SerialTimeout);
     return std::string (buf.data(), bytesRead);
 }

CLUINT32 CLAllSerial::serialRead	(	std::vector< CLINT8 > &	Buffer,
		const CLUINT32	ReadLen,
		const CLUINT32	SerialTimeout
	)		const

Reads data from the serial device, returning the number of bytes read.

Parameters

[out]	Buffer	- Output buffer for the data read. This will be resized to fit the data read, if necessary.
[in]	ReadLen	- The number of bytes to be read.
[in]	SerialTimeout	- Timeout after which the read should abort.

Returns: The number of bytes read from the port.

Exceptions

BFCLException - Thrown if an error occurs reading from the serial port, including timeout.

References serialRead().

 {
     if (Buffer.size() < ReadLen)
         Buffer.resize(ReadLen);
     return serialRead(Buffer.data(), CLUINT32(Buffer.size()), SerialTimeout);
 }

CLUINT32 CLAllSerial::serialRead	(	CLINT8 *const	Buffer,
		const CLUINT32	BufferSize,
		const CLUINT32	SerialTimeout
	)		const

Reads data from the serial device, returning the number of bytes read.

Parameters

[out]	Buffer	- Output buffer for the data read.
[in]	BufferSize	- Size of the output Buffer.
[in]	SerialTimeout	- Timeout after which the read should abort.

Returns: The number of bytes read from the port.

Exceptions

BFCLException - Thrown if an error occurs reading from the serial port, including timeout.

References CLComm::BFCLException::check(), and clSerialRead().

 {
     CLUINT32 readSize = BufferSize;
     BFCLException::check( clSerialRead(m_pd.clSerRef, Buffer, &readSize, SerialTimeout) );
     return readSize;
 }

CLUINT32 CLAllSerial::serialWrite	(	std::string const &	Message,
		const CLUINT32	SerialTimeout
	)

This method writes a string of characters to the serial device, returning the number of bytes written.

Parameters

[in]	Message	- A string message to write to the port (null terminator excluded).
[in]	SerialTimeout	- Timeout after which the write should abort.

Returns: The number of bytes written to the serial port.

Exceptions

BFCLException - Thrown if an error occurs writing to the serial port, including timeout.

Referenced by serialWrite().

 {
     return serialWrite(Message.c_str(), Message.size(), SerialTimeout);
 }

CLUINT32 CLAllSerial::serialWrite	(	std::vector< CLINT8 > const &	Buffer,
		const CLUINT32	SerialTimeout
	)

This method writes data to the serial device, returning the number of bytes written.

Parameters

[in]	Buffer	- Buffer of data to be written to the serial port.
[in]	SerialTimeout	- Timeout after which the write should abort.

Returns: The number of bytes written to the serial port.

Exceptions

BFCLException - Thrown if an error occurs writing to the serial port, including timeout.

References serialWrite().

 {
     return serialWrite(Buffer.data(), Buffer.size(), SerialTimeout);
 }

CLUINT32 CLAllSerial::serialWrite	(	const CLINT8 *const	Buffer,
		const BFSIZET	BufferLen,
		const CLUINT32	SerialTimeout
	)

This method writes data to the serial device, returning the number of bytes written.

Parameters

[in]	Buffer	- Buffer of data to be written to the serial port.
[in]	BufferLen	- Byte size of the data to be written.
[in]	SerialTimeout	- Timeout after which the write should abort.

Returns: The number of bytes written to the serial port.

Exceptions

BFCLException - Thrown if an error occurs writing to the serial port, including timeout.

References CLComm::BFCLException::check(), and clSerialWrite().

 {
     // Make the buffer mutable the "proper" and expensive way.
     std::vector<CLINT8> mBuffer (Buffer, Buffer + BufferLen);
 
     CLUINT32 bufferSize = CLUINT32(mBuffer.size());
     BFCLException::check( clSerialWrite(m_pd.clSerRef, mBuffer.data(), &bufferSize, SerialTimeout) );
     return bufferSize;
 }

BFVOID CLAllSerial::setBaudRate ( const CLUINT32 BaudRate )

Sets the Baud Rate for the serial port.

Parameters

[in]

BaudRate

- The baud rate to set, of the following options:

Exceptions

BFCLException - Thrown if an error occurs while setting the baud rate.

References CLComm::BFCLException::check(), and clSetBaudRate().

 {
     BFCLException::check( clSetBaudRate(m_pd.clSerRef, BaudRate) );
 }

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

Classes

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation