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