o22siomm.h

从linux系统opto移植到vxworks的网口通信代码

    //
    //           If the nAutoPUC flag in OpenEnet() or OpenEnet2() was set to TRUE, then this 
    //           function will attempt to read and clear the I/O unit's Powerup Clear (PUC) flag 
    //           after the connection has been made.
    //
    //  Input  : none
    //  Output : none
    //  Returns: SIOMM_ERROR_NOT_CONNECTED_YET if the connection process isn't completed yet.
    //           SIOMM_TIME_OUT if the connection process timed out
    //           SIOMM_OK if the connection process is completed
    //           Or possibly any other error
    //---------------------------------------------------------------------------------------------

    LONG Close();
    //---------------------------------------------------------------------------------------------
    //  Usage  : Close the connection to the I/O unit
    //  Input  : none
    //  Output : none
    //  Returns: SIOMM_OK if everything is OK, an error otherwise.
    //---------------------------------------------------------------------------------------------

    LONG SetCommOptions(LONG nTimeOutMS, LONG nReserved);
    //---------------------------------------------------------------------------------------------
    //  Usage  : Set communication options, such as the timeout period
    //  Input  : nTimeOutMS - The timeout period for normal communications. The connection process
    //           using OpenEnet() has a seperate timeout period
    //           nReserved   - not used at this time. Set to 0.
    //  Output : none
    //  Returns: SIOMM_OK if everything is OK, an error otherwise.
    //---------------------------------------------------------------------------------------------


    // The following functions are for building and unpacking read/write requests for the 
    // 1394-based protocol.
    LONG BuildWriteBlockRequest(BYTE  * pbyWriteBlockRequest,
                                BYTE    byTransactionLabel,
                                DWORD   dwDestinationOffset,
                                WORD    wDataLength,
                                BYTE  * pbyBlockData);

    LONG BuildWriteQuadletRequest(BYTE * pbyWriteQuadletRequest,
                                  BYTE  byTransactionLabel, 
                                  WORD  wSourceId,
                                  DWORD dwDestinationOffset,
                                  DWORD dwQuadletData);

    LONG UnpackWriteResponse(BYTE * pbyWriteQuadletResponse,
                             BYTE * pbyTransactionLabel, 
                             BYTE * pbyResponseCode);

    LONG BuildReadQuadletRequest(BYTE * pbyReadQuadletRequest,
                                 BYTE   byTransactionLabel, 
                                 DWORD  dwDestinationOffset);

    LONG UnpackReadQuadletResponse(BYTE  * pbyReadQuadletResponse,
                                   BYTE  * pbyTransactionLabel, 
                                   BYTE  * pbyResponseCode,
                                   DWORD * pdwQuadletData);

    LONG BuildReadBlockRequest(BYTE * pbyReadBlockRequest,
                               BYTE   byTransactionLabel, 
                               DWORD  dwDestinationOffset,
                               WORD   wDataLength);

    LONG UnpackReadBlockResponse(BYTE  * pbyReadBlockResponse,
                                 BYTE  * pbyTransactionLabel, 
                                 BYTE  * pbyResponseCode,
                                 WORD  * pwDataLength,
                                 BYTE  * pbyBlockData);

    // Functions for reading and writing quadlets (DWORDs) at an I/O unit memory map address.
    LONG ReadQuad(DWORD dwDestOffset, DWORD * pdwQuadlet);
    LONG WriteQuad(DWORD dwDestOffset, DWORD dwQuadlet);

    // Functions for reading and writing floats  at an I/O unit memory map address.
    LONG ReadFloat(DWORD dwDestOffset, float * pfValue);
    LONG WriteFloat(DWORD dwDestOffset, float fValue);

    // Functions for reading and writing blocks of bytes at an I/O unit memory map address.
    LONG ReadBlock(DWORD dwDestOffset, WORD wDataLength, BYTE * pbyData);
    LONG WriteBlock(DWORD dwDestOffset, WORD wDataLength, BYTE * pbyData);

    // Status read
    LONG GetStatusPUC(long *pnPUCFlag);
    LONG GetStatusLastError(long *pnErrorCode);
    LONG GetStatusBootpAlways(long *pnBootpAlways);
    LONG GetStatusDegrees(long *pnDegrees);
    LONG GetStatusWatchdogTime(long *pnTimeMS);
    LONG GetStatusVersionEx(SIOMM_StatusVersion *pVersionData);
    LONG GetStatusHardwareEx(SIOMM_StatusHardware *pHardwareData);
    LONG GetStatusHardwareEx2(SIOMM_StatusHardware2 *pHardwareData);
    LONG GetStatusNetworkEx(SIOMM_StatusNetwork *pNetworkData);
    LONG GetStatusNetworkEx2(SIOMM_StatusNetwork2 *pNetworkData);

    // Status write
    LONG SetStatusOperation(long nOpCode);
    LONG SetStatusBootpRequest(long nFlag);
    LONG SetStatusDegrees(long nDegFlag);
    LONG SetStatusWatchdogTime(long nTimeMS);

    // Date and time configuration
    LONG GetDateTime(char * pchDateTime);
    LONG SetDateTime(char * pchDateTime);

    // Serial Module Configuration
    LONG GetSerialModuleConfigurationEx(long nSerialPort, SIOMM_SerialModuleConfigArea * pConfigData);
    LONG SetSerialModuleConfigurationEx(long nSerialPort, SIOMM_SerialModuleConfigArea ConfigData);
    

    // Point configuration
    LONG ConfigurePoint(long nPoint, long nPointType);
    LONG GetModuleType(long nPoint, long * pnModuleType);
    LONG GetPtConfigurationEx2(long nPoint, SIOMM_PointConfigArea2 * pData);
    LONG GetPtConfigurationEx(long nPoint, SIOMM_PointConfigArea * pData);
    LONG SetPtConfigurationEx2(long nPoint, SIOMM_PointConfigArea2 Data);
    LONG SetPtConfigurationEx(long nPoint, SIOMM_PointConfigArea Data);
    LONG SetDigPtConfiguration(long nPoint, long nPointType, long nFeature);
    LONG SetAnaPtConfiguration(long nPoint, long nPointType, float fOffset, float fGain, 
                               float fHiScale, float fLoScale);
    LONG SetPtWatchdog(long nPoint, float fValue, long nEnabled);

    // Digital point read
    LONG GetDigPtState(long nPoint, long *pnState);
    LONG GetDigPtOnLatch(long nPoint, long *pnState);
    LONG GetDigPtOffLatch(long nPoint, long *pnState);
    LONG GetDigPtCounterState(long nPoint, long *pnState);
    LONG GetDigPtCounts(long nPoint, long *pnValue);
    LONG GetDigPtReadAreaEx(long nPoint, SIOMM_DigPointReadArea * pData);

    // Digital point write
    LONG SetDigPtState(long nPoint, long nState);
    LONG SetDigPtCounterState(long nPoint, long nState);

    // Digital point read and clear
    LONG ReadClearDigPtCounts(long nPoint, long * pnState);
    LONG ReadClearDigPtOnLatch(long nPoint, long * pnState);
    LONG ReadClearDigPtOffLatch(long nPoint, long * pnState);

    // Digital bank read
    LONG GetDigBankPointStates(long *pnPts63to32, long *pnPts31to0);
    LONG GetDigBankOnLatchStates(long *pnPts63to32, long *pnPts31to0);
    LONG GetDigBankOffLatchStates(long *pnPts63to32, long *pnPts31to0);
    LONG GetDigBankActCounterStates(long *pnPts63to32, long *pnPts31to0);
    LONG GetDigBankReadAreaEx(SIOMM_DigBankReadArea * pData);

    // Digital bank write
    LONG SetDigBankPointStates(long nPts63to32, long nPts31to0, long nMask63to32, long nMask31to0);
    LONG SetDigBankOnMask(long nPts63to32, long nPts31to0);
    LONG SetDigBankOffMask(long nPts63to32, long nPts31to0);
    LONG SetDigBankActCounterMask(long nPts63to32, long nPts31to0);
    LONG SetDigBankDeactCounterMask(long nPts63to32, long nPts31to0);

    // Analog point read
    LONG GetAnaPtValue(long nPoint, float *pfValue);
    LONG GetAnaPtCounts(long nPoint, float *pfValue);
    LONG GetAnaPtMinValue(long nPoint, float *pfValue);
    LONG GetAnaPtMaxValue(long nPoint, float *pfValue);
    LONG GetAnaPtTpoPeriod(long nPoint, float *pfValue);
    LONG GetAnaPtReadAreaEx(long nPoint, SIOMM_AnaPointReadArea * pData);

    // Analog point write
    LONG SetAnaPtValue(long nPoint, float fValue);
    LONG SetAnaPtCounts(long nPoint, float fValue);
    LONG SetAnaPtTpoPeriod(long nPoint, float fValue);

    // Analog point read and clear
    LONG ReadClearAnaPtMinValue(long nPoint, float *pfValue);
    LONG ReadClearAnaPtMaxValue(long nPoint, float *pfValue);

    // Analog bank read
    LONG GetAnaBankValuesEx(SIOMM_AnaBank * pBankData);
    LONG GetAnaBankCountsEx(SIOMM_AnaBank * pBankData);
    LONG GetAnaBankMinValuesEx(SIOMM_AnaBank * pBankData);
    LONG GetAnaBankMaxValuesEx(SIOMM_AnaBank * pBankData);

    // Analog bank write
    LONG SetAnaBankValuesEx(SIOMM_AnaBank BankData);
    LONG SetAnaBankCountsEx(SIOMM_AnaBank BankData);

    // Analog point calc and set
    LONG CalcSetAnaPtOffset(long nPoint, float *pfValue);
    LONG CalcSetAnaPtGain(long nPoint, float *pfValue);


    // Stream functions
    LONG GetStreamConfiguration(long * pnOnFlag, long * pnIntervalMS, long * pnPort,
                                long * pnIoMirroringEnabled, long * pnStartAddress, 
                                long * pnDataSize);
    LONG SetStreamConfiguration(long nOnFlag, long nIntervalMS, long nPort,
                                long nIoMirroringEnabled, long nStartAddress, 
                                long nDataSize);
    LONG GetStreamTarget(long nTarget, long * pnIpAddressArg);
    LONG SetStreamTarget(long nTarget, char * pchIpAddressArg);
    LONG GetStreamReadAreaEx (SIOMM_StreamStandardBlock *pStreamData);  

    // Scratch Pad area
    LONG GetScratchPadBitArea(long *pnBits63to32, long *pnBits31to0);
    LONG SetScratchPadBitArea(long   nBits63to32, long   nBits31to0);
    LONG SetScratchPadBitAreaMask(long nOnMask63to32,  long nOnMaskPts31to0, 
                                  long nOffMask63to32, long nOffMaskPts31to0);

    

    LONG GetScratchPadIntegerArea(long nStartIndex, long nLength, long * pnData);
    LONG SetScratchPadIntegerArea(long nStartIndex, long nLength, long * pnData);
    
    LONG GetScratchPadFloatArea  (long nStartIndex, long nLength, float * pfData);
    LONG SetScratchPadFloatArea  (long nStartIndex, long nLength, float * pfData);

    LONG GetScratchPadStringArea (long nStartIndex, long nLength, SIOMM_ScratchPadString * pStringData);
    LONG SetScratchPadStringArea (long nStartIndex, long nLength, SIOMM_ScratchPadString * pStringData);


  protected:
    // Protected data
    SOCKET m_Socket;
    sockaddr_in m_SocketAddress; // for connecting our socket
    long        m_nConnectionType; // TCP or UDP

    timeval m_tvTimeOut;      // Timeout structure for sockets
    LONG    m_nTimeOutMS;     // For holding the user's timeout
    DWORD   m_nOpenTimeOutMS; // For holding the open timeout
    DWORD   m_nOpenTime;      // For testing the open timeout
    LONG    m_nRetries;       // For holding the user's retries.
    
    LONG    m_nAutoPUCFlag;   // For holding the AutoPUC flag sent in OpenEnet()

    BYTE    m_byTransactionLabel; // The current transaction label

    // Protected Members

    // Open/Close sockets functions
    LONG OpenSockets(char * pchIpAddressArg, long nPort, long nOpenTimeOutMS);
    LONG CloseSockets();

    // Generic functions for getting/setting 64-bit bitmasks
    LONG GetBitmask64(DWORD dwDestOffset, long *pnPts63to32, long *pnPts31to0);
    LONG SetBitmask64(DWORD dwDestOffset, long nPts63to32, long nPts31to0);

    // Generic functions for getting/setting analog banks
    LONG GetAnaBank(DWORD dwDestOffset, SIOMM_AnaBank * pBankData);
    LONG SetAnaBank(DWORD dwDestOffset, SIOMM_AnaBank BankData);

    // Gets the next transaction label
    inline void UpdateTransactionLabel() {m_byTransactionLabel++; \
                                          if (m_byTransactionLabel>=64) m_byTransactionLabel=0;}

  private:
    // Private data

    // Private Members
};



#endif // __O22SIOMM_H_