CLPort.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//  (c) 2008 by Basler Vision Technologies
//  Section: Vision Components
//  Project: GenApi
//  Author:  Fritz Dierks
//  $Header$
//
//  License: This file is published under the license of the EMVA GenICam  Standard Group. 
//  A text file describing the legal terms is included in  your installation as 'GenICam_license.pdf'. 
//  If for some reason you are missing  this file please contact the EMVA or visit the website
//  (http://www.genicam.org) for a full copy.
// 
//  THIS SOFTWARE IS PROVIDED BY THE EMVA GENICAM STANDARD GROUP "AS IS"
//  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,  
//  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR  
//  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE EMVA GENICAM STANDARD  GROUP 
//  OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,  SPECIAL, 
//  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT  LIMITED TO, 
//  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,  DATA, OR PROFITS; 
//  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY  THEORY OF LIABILITY, 
//  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT  (INCLUDING NEGLIGENCE OR OTHERWISE) 
//  ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
//  POSSIBILITY OF SUCH DAMAGE.
//-----------------------------------------------------------------------------
#ifndef CLPROTOCOL_CLPORT_H
#define CLPROTOCOL_CLPORT_H
 
#include <Base/GCBase.h>
#include <GenApi/PortImpl.h>
#include <CLProtocol/CLException.h>
#include <CLProtocol/CLAutoBuffer.h>
#include <CLProtocol/CLProtocol.h>
#include <CLProtocol/ISerial.h>
#include <CLProtocol/ISerialAdapter.h>
#include <CLProtocol/CLAllAdapter.h>
#include <CLProtocol/DeviceID.h>
#include <CLProtocol/CVersion.h>
#include <CLProtocol/XMLID.h>
#include <iostream>
#include <fstream>
#include <list>
#include <algorithm>
 
 
namespace CLProtocol
{
 
#   define CLPORT_PERSISTENCE_MAGIC   "{3DFD485D-0ADB-4d84-9956-C3766504A2DD}"
 
 
#ifdef _MSC_VER
#   pragma warning (push )
#   pragma warning( disable:4275)  // warning C4275: non dll-interface class 'GenApi::CPortImpl' used as base for dll-interface class 'CLProtocol::CCLPort'
#endif
   
    class CLPROTOCOL_DECL CCLPort : public GENAPI_NAMESPACE::CPortImpl, public ISerial
    {
    public:
 
 
        static void GetPortIDs( GENAPI_NAMESPACE::StringList_t &PortIDs );
 
        static ISerialAdapter *GetPort( const GENICAM_NAMESPACE::gcstring &PortID );
 
        static void GetDeviceIDTemplates( GENICAM_NAMESPACE::gcstring_vector &DeviceIDTemplates );
 
        static GENICAM_NAMESPACE::gcstring ProbeDevice(const GENICAM_NAMESPACE::gcstring &PortID, const GENICAM_NAMESPACE::gcstring &strDeviceIDTemplate, const CLUINT32 SerialTimeout = 500);
 
        static void StopProbing(CLUINT32 toStop);
 
        static GENICAM_NAMESPACE::gcstring RegisterSerial( const GENICAM_NAMESPACE::gcstring &PortName, ISerialAdapter *pSerialAdapter);
 
        static void UnRegisterSerials( );
 
        static void Terminate( );
 
        static void UnRegisterSerial( const GENICAM_NAMESPACE::gcstring &PortID );
 
        void Connect( const GENICAM_NAMESPACE::gcstring &PortID, const GENICAM_NAMESPACE::gcstring &strDeviceID );
 
        bool Connect( const GENICAM_NAMESPACE::gcstring &PortID );
 
        void GetXMLIDs( GENICAM_NAMESPACE::gcstring_vector &XMLIDs );
 
        GENICAM_NAMESPACE::gcstring GetXML( GENICAM_NAMESPACE::gcstring XMLID, const bool UseMaxBaudrate = true );
 
        void DeleteXMLDownload( GENICAM_NAMESPACE::gcstring XMLID );
 
        GENICAM_NAMESPACE::gcstring GetXML( const bool UseMaxBaudrate = true );
 
        GENICAM_NAMESPACE::gcstring MakeURLfromXMLID( GENICAM_NAMESPACE::gcstring &XMLID );
 
 
 
        CCLPort();
 
        virtual ~CCLPort();
 
 
        void SetSerialTimeOut(const CLUINT32 Timeout);
 
        CLUINT32 GetSerialTimeOut() const;
 
        GENICAM_NAMESPACE::gcstring GetDeviceID() const;
        
        void SetProtocolLogLevel( const CLP_LOG_LEVEL_VALUE logLever);
 
        void SetDeviceBauderate( const CLUINT32 baudrate);
 
        CLUINT32 GetDeviceBauderate( );
 
        CLUINT32 SupportedBaudrates();
 
        static void SetDefaultLogLevel( const CLP_LOG_LEVEL_VALUE logLever);
 
        static void StorePortIDDeviceIDPairs( GENICAM_NAMESPACE::gcstring_vector &PortIDs, GENICAM_NAMESPACE::gcstring_vector &DeviceIDs );
 
        static void RetrievePortIDDeviceIDPairs( GENICAM_NAMESPACE::gcstring_vector &PortIDs, GENICAM_NAMESPACE::gcstring_vector &DeviceIDs );
 
 
 
 
        virtual GENAPI_NAMESPACE::EAccessMode GetAccessMode() const;
 
        virtual void Read(void * pBuffer, int64_t Address, int64_t Length);
 
        virtual void Write(const void * pBuffer, int64_t Address, int64_t Length);
 
        virtual GENAPI_NAMESPACE::EInterfaceType GetPrinicipalInterfaceType() const;
 
        CLINT32 GetEvent(
            void * buffer,      
            CLUINT32 * bufferSize 
            );
 
 
 
        virtual CLINT32 CLPROTOCOL clSerialRead(
            CLINT8* buffer,     
            CLUINT32* bufferSize,   
            CLUINT32  serialTimeOut 
            );
 
        virtual CLINT32 CLPROTOCOL clSerialWrite(
            CLINT8* buffer, 
            CLUINT32* bufferSize,  
            CLUINT32 serialTimeOut 
            );
 
        virtual CLINT32 CLPROTOCOL clGetSupportedBaudRates(
            CLUINT32 *baudRates 
                                );
 
    private:
        static void InitPortIDs(void);
 
        virtual CLINT32 CLPROTOCOL clSetBaudRate( 
            CLUINT32 baudRate   
                                );
 
        void CheckError( CLINT32 ErrorCode ) const;
 
        static void CheckLastError();
 
        void LoadProtocolDriver( const GENICAM_NAMESPACE::gcstring &PortDriverDLLPath );
 
        void UnLoadProtocolDriver( );
 
        void CreatePort( const GENICAM_NAMESPACE::gcstring &PortID, const GENICAM_NAMESPACE::gcstring &PortDriverDLLPath );
 
        static void UpdateCache( const GENICAM_NAMESPACE::gcstring &PortID, const GENICAM_NAMESPACE::gcstring &DeviceID );
 
        ISerialAdapter *m_pSerialAdapter;
 
        static SerialPortMap *s_pSerialList;
 
        static SerialPortMap *s_pPrivateSerialList;
 
        static bool s_IsSerialListInitialized;
 
 
        lib_handle_t m_hPortDriverDLL;
 
        CLUINT32 m_SerialTimeOut;
        
        GENICAM_NAMESPACE::gcstring m_DeviceID;
 
        GENICAM_NAMESPACE::gcstring m_PortID;
 
        CLUINT32 m_Cookie;
 
        /*------------------------------------------------*/
        // functions of the CL protocol DLL
        /*------------------------------------------------*/
        CLINT32 (__cdecl *m_clpInitLib)( clp_logger_t logger, CLP_LOG_LEVEL_VALUE logLevel);
 
        CLINT32 (__cdecl *m_clpCloseLib)( void );
 
        CLINT32 (__cdecl *m_clpGetShortDeviceIDTemplates) (CLINT8* pDeviceTemplates, CLUINT32* pBufferSize );
 
        CLINT32 (__cdecl *m_clpProbeDevice) (ISerial *pSerial, const CLINT8* pDeviceIDTemplate, CLINT8* pDeviceID, CLUINT32 *pBufferSize, CLUINT32 *pCookie, const CLUINT32 TimeOut );
 
        CLINT32 (__cdecl *m_clpGetXMLIDs) ( ISerial *pSerial, const CLUINT32 Cookie ,CLINT8* pXMLIDs, CLUINT32* pBufferSize, const CLUINT32 TimeOut );
 
        CLINT32 (__cdecl *m_clpGetXMLDescription) (ISerial *pSerial, const CLUINT32 Cookie, const CLINT8* pDeviceID, CLINT8* pXMLBuffer, CLUINT32* pBufferSize, const CLUINT32 TimeOut );
 
        CLINT32 (__cdecl *m_clpReadRegister) (ISerial *pSerial, const CLUINT32 Cookie, const CLINT64 Address, CLINT8* pBuffer, const CLINT64 BufferSize, const CLUINT32  TimeOut );
 
        CLINT32 (__cdecl *m_clpWriteRegister) (ISerial *pSerial, const CLUINT32 Cookie, const CLINT64 Address, const CLINT8* pBuffer, const CLINT64 BufferSize, const CLUINT32  TimeOut );
 
        CLINT32 (__cdecl *m_clpContinueWriteRegister) (ISerial *pSerial, const CLUINT32 Cookie, const BOOL8 ContinueWaiting, const CLUINT32  TimeOut );
 
        CLINT32 (__cdecl *m_clpGetErrorText) (const CLINT32 errorCode, CLINT8* errorText, CLUINT32* errorTextSize, const CLUINT32 Cookie );
 
        CLINT32 (__cdecl *m_clpDisconnect) (const CLUINT32 Cookie );
 
        CLINT32 (__cdecl *m_clpGetCLProtocolVersion) (CLUINT32 *pVersionMajor, CLUINT32 *pVersionMinor );
 
        CLINT32 (__cdecl *m_clpGetParam) (ISerial *pSerial, CLP_PARAMS param, const CLUINT32 Cookie, const CLINT8* pBuffer, const CLINT64 BufferSize, const CLUINT32  TimeOut);
 
        CLINT32 (__cdecl *m_clpSetParam) (ISerial *pSerial, CLP_PARAMS param, const CLUINT32 Cookie, const CLINT8* pBuffer, const CLINT64 BufferSize, const CLUINT32  TimeOut);
 
        CLINT32 (__cdecl *m_clpIsParamSupported) (CLP_PARAMS param);
 
        CLINT32 (__cdecl *m_clpGetEventData) (const CLUINT32 Cookie, CLINT8* pBuffer, CLUINT32* pBufferSize);
 
        // What 1.1 feature are supported by the device protocol?
        bool m_protocolHasBaudratePrms;
 
        bool m_protocolHasLogLevelPrm;
 
        bool m_protocolHasLoggerPrm;
 
        bool m_protocolHasStopProbeDevice;
 
        static CLP_LOG_LEVEL_VALUE m_defaultloglevel;
 
        static CLUINT32 m_stopProbing;
    private:
        CCLPort( CCLPort& );
 
        CCLPort& operator=( CCLPort& );
    };
 
#ifdef _MSC_VER
#   pragma warning(pop)
#endif
 
}
#endif // CLPROTOCOL_CLPORT_H