O22SIOMM.h

//-----------------------------------------------------------------------------
//
// O22SIOMM.h
// Copyright (c) 1999 - 2004 by Opto 22
//
// Header for the O22SnapIoMemMap C++ class.  
// 
// The O22SnapIoMemMap C++ class is used to communicate from a computer to an
// Opto 22 SNAP Ethernet I/O unit.
//
// The basic procedure for using this class is:
//
//   1. Create an instance of the O22SnapIoMemMap class
//   2. Call OpenEnet() or OpenEnet2() to start connecting to an I/O unit
//   3. Call IsOpenDone() to complete the connection  process
//   4. Call SetCommOptions() to set the desired timeout value
//   5. Call any of the memory map functions, such as ConfigurePt(),
//      GetAnaPtValue(), SetDigBankPointStates(), and ReadBlock(), to 
//      communicate with the I/O unit.  Repeat as neccessary.
//   6. Call Close() when done.
//
// While this code was developed on Microsoft Windows 32-bit operating 
// systems, it is intended to be as generic as possible.  For Windows specific
// code, search for "_WIN32".  For Linux specific code, search for "_LINUX".
//-----------------------------------------------------------------------------

#ifndef __O22SIOMM_H_
#define __O22SIOMM_H_


#ifndef __O22SIOUT_H
#include "O22SIOUT.h"
#endif


#ifndef __O22STRCT_H
#include "O22STRCT.h"
#endif

#pragma pack(push)
#pragma pack(1)

typedef struct SERIAL_HEADER_X_T // x for x-mit 
{
  unsigned char  m_u8Address;    
  unsigned char  m_u8Type;       
  unsigned short m_u16Crc;       
  unsigned short m_u16Length;    
  // data payload bytes follow
} SERIAL_HEADER_X_T;

typedef struct SERIAL_HEADER_R_T // r for receive
{ 
  unsigned char  m_u8Type;       
  unsigned short m_u16Crc;       
  unsigned short m_u16Length;    
  // data payload bytes follow
} SERIAL_HEADER_R_T;

#pragma pack(pop)


typedef struct SERIAL_PASS_THRU_CONFIG
{
  uint32_t Enable;   
  uint32_t Bps;      
  uint32_t DataBits; 
  uint32_t Parity;   
  uint32_t StopBits; 
  uint32_t Duplex;   
  uint32_t Timeout;  
} SERIAL_PASS_THRU_CONFIG;

typedef struct SERIAL_PASS_THRU_RW
// follow this header with the data bytes.
{
  uint32_t Address;  
  uint32_t Type;     
  uint32_t Length;   
} SERIAL_PASS_THRU_RW;

enum ConnectionMethod
{
  ethernet,             
  serial,               
  passthru              
};

class O22SnapIoMemMap {

  public:
    O22SnapIoMemMap();
    ~O22SnapIoMemMap();

    // Connection functions

    int OpenEnet (char * pchIpAddressArg, int nPort, int nOpenTimeOutMS, 
                   int nAutoPUC);

    int OpenEnet2(char * pchIpAddressArg, int nPort, int nOpenTimeOutMS,
                   int nAutoPUC, int nConnectionType);


    int OpenSerial(int nPort, uint8_t nAddress, int nBaudRate, int nOpenTimeOutMS,
                    int nAutoPUC);

    int OpenSerialPassThru(char * pchIpAddressArg, int nPort, 
                            int nSerialPort, uint8_t nSerialAddress, int nSerialBaudRate, bool bTwoWire,
                            int nOpenTimeOutMS, int nAutoPUC, int nConnectionType = SIOMM_TCP);

    int IsOpenDone();

    int Close();

    int SetCommOptions(int nTimeOutMS, int nReserved);

    int GetCommTimeout() {return m_nTimeOutMS;}


    // The following functions are for building and unpacking read/write 
    // requests for the 1394-based protocol.

    int BuildWriteBlockRequest(uint8_t  * pbyWriteBlockRequest,
                                uint8_t    byTransactionLabel,
                                uint32_t   dwDestinationOffset,
                                uint16_t    wDataLength,
                                uint8_t  * pbyBlockData);

    int UnpackWriteResponse(uint8_t * pbyWriteQuadletResponse,
                             uint8_t * pbyTransactionLabel, 
                             uint8_t * pbyResponseCode);

    int BuildReadBlockRequest(uint8_t * pbyReadBlockRequest,
                               uint8_t   byTransactionLabel, 
                               uint32_t  dwDestinationOffset,
                               uint16_t   wDataLength);

    int UnpackReadBlockResponse(uint8_t  * pbyReadBlockResponse,
                                 uint8_t  * pbyTransactionLabel, 
                                 uint8_t  * pbyResponseCode,
                                 uint16_t  * pwDataLength,
                                 uint8_t  * pbyBlockData);

    int ReadQuad(uint32_t dwDestOffset, uint32_t * pdwQuadlet);

    int WriteQuad(uint32_t dwDestOffset, uint32_t dwQuadlet);

    int ReadFloat(uint32_t dwDestOffset, float * pfValue);

    int WriteFloat(uint32_t dwDestOffset, float fValue);

    int ReadBlock (const uint32_t dwDestOffset, const uint16_t wDataLength, 
                    uint8_t * pbyData);

    int WriteBlock(const uint32_t dwDestOffset, const uint16_t wDataLength,
                    uint8_t * pbyData);

    int ReadBlockAsIntegers(uint32_t dwDestOffset, uint16_t wDataLength,
                             int  * pnData);

    int WriteBlockAsIntegers(uint32_t dwDestOffset, uint16_t wDataLength,
                              int  * pnData);

    int ReadBlockAsFloats  (uint32_t dwDestOffset, uint16_t wDataLength,
                             float * pfData);

    int WriteBlockAsFloats  (uint32_t dwDestOffset, uint16_t wDataLength,
                              float * pfData);

    int GetStatusPUC(int *pnPUCFlag);

    int GetStatusLastError(int *pnErrorCode);

    int GetStatusBootpAlways(int *pnBootpAlways);

    int GetStatusDegrees(int *pnDegrees);

    int GetStatusWatchdogTime(int *pnTimeMS);

    int GetStatusVersionEx(SIOMM_StatusVersion *pVersionData);

    int GetStatusHardwareEx(SIOMM_StatusHardware *pHardwareData);

    int GetStatusHardwareEx2(SIOMM_StatusHardware2 *pHardwareData);

    int GetStatusNetworkEx(SIOMM_StatusNetwork *pNetworkData);

    int GetStatusNetworkEx2(SIOMM_StatusNetwork2 *pNetworkData);

    int GetStatusWriteEx(SIOMM_StatusWrite * pStatusWriteData);

    int SetStatusWriteEx(SIOMM_StatusWrite    StatusWriteData);

    int SetStatusOperation(int nOpCode);

    int SetStatusBootpRequest(int nFlag);

    int SetStatusDegrees(int nDegFlag);

    int SetStatusWatchdogTime(int nTimeMS);

    int GetDateTime(char * pchDateTime);

    int SetDateTime(char * pchDateTime);

    int GetSerialModuleConfigurationEx(int nSerialPort, 
           SIOMM_SerialModuleConfigArea * pConfigData);

    int SetSerialModuleConfigurationEx(int nSerialPort,
           SIOMM_SerialModuleConfigArea ConfigData);

    int ConfigurePoint(int nPoint, int nPointType);

    int GetModuleType(int nPoint, int * pnModuleType);

    int GetPtConfigurationEx3(int nPoint, SIOMM_PointConfigArea3 * pData);

    int GetPtConfigurationEx2(int nPoint, SIOMM_PointConfigArea2 * pData);

    int GetPtConfigurationEx(int nPoint, SIOMM_PointConfigArea * pData);

    int SetPtConfigurationEx3(int nPoint, SIOMM_PointConfigArea3 Data);

    int SetPtConfigurationEx2(int nPoint, SIOMM_PointConfigArea2 Data);

    int SetPtConfigurationEx(int nPoint, SIOMM_PointConfigArea Data);

    int SetDigPtConfiguration(int nPoint, int nPointType, int nFeature);

    int SetAnaPtConfiguration(int nPoint, int nPointType, float fOffset,
                               float fGain, float fHiScale, float fLoScale);

    int SetPtWatchdog(int nPoint, float fValue, int nEnabled);

    /* Standard density digital point methods. See the Digital Point sections
     * in Appendix A of the OptoMMP Protocol Guide for details.
     *
     * NOTE: These methods work only for standard density digital points.
     * High-Density digital points must use the HDDigital methods defined
     * below this section.
     */
    // Digital point read

    int GetDigPtState(int nPoint, int *pnState);

    int GetDigPtOnLatch(int nPoint, int *pnState);

    int GetDigPtOffLatch(int nPoint, int *pnState);

    int GetDigPtCounterState(int nPoint, int *pnState);

    int GetDigPtCounts(int nPoint, int *pnValue);

    int GetDigPtReadAreaEx(int nPoint, SIOMM_DigPointReadArea * pData);

    int SetDigPtState(int nPoint, int nState);

    int SetDigPtCounterState(int nPoint, int nState);

    int ReadClearDigPtCounts(int nPoint, int * pnState);

    int ReadClearDigPtOnLatch(int nPoint, int * pnState);

    int ReadClearDigPtOffLatch(int nPoint, int * pnState);

    int GetDigBankPointStates(int *pnPts63to32, int *pnPts31to0);

    int GetDigBankOnLatchStates(int *pnPts63to32, int *pnPts31to0);

    int GetDigBankOffLatchStates(int *pnPts63to32, int *pnPts31to0);

    int GetDigBankActCounterStates(int *pnPts63to32, int *pnPts31to0);

    int GetDigBankReadAreaEx(SIOMM_DigBankReadArea * pData);

    int SetDigBankPointStates(int nPts63to32,  int nPts31to0,
                               int nMask63to32, int nMask31to0);

    int SetDigBankOnMask(int nPts63to32, int nPts31to0);

    int SetDigBankOffMask(int nPts63to32, int nPts31to0);

    int SetDigBankActCounterMask(int nPts63to32, int nPts31to0);

    int SetDigBankDeactCounterMask(int nPts63to32, int nPts31to0);

    /* High density digital point reads. See Appendix A - SNAP High-Density
     * Digital sections in the OptoMMP Protocol Guide for details.
     *
     * NOTE: These methods work only for High Density digital modules; standard
     * digital modules must use the standard density methods defined above.
     */

    int GetHDDigitalPointState(int nModule, int nPoint, int * pnState);

    int GetHDDigitalPointOnLatch(int nModule, int nPoint, int * pnState);

    int GetHDDigitalPointOffLatch(int nModule, int nPoint, int * pnState);

    int GetHDDigitalPointCounts(int nModule, int nPoint, int * pnCounts);

    int SetHDDigitalPointState(int nModule, int nPoint, int nState);

    int ReadClearHDDigitalPointCounts(int nModule, int nPoint, int * pnCounts);

    int ReadClearHDDigitalPointOnLatch(int nModule, int nPoint, int * pnState);

    int ReadClearHDDigitalPointOffLatch(int nModule, int nPoint, int * pnState);

    /* Expanded Analog point methods. Supported on I/O units using firmware 8.0 or
     * greater, these methods allow access to a greater number of modules and points.
     */
    // Analog point read

    int GetAnalogPointValueEx(int nModule, int nPoint, float *pfValue);

    int GetAnalogPointCountsEx(int nModule, int nPoint, float *pfValue);

    int GetAnalogPointMinValueEx(int nModule, int nPoint, float *pfValue);

    int GetAnalogPointMaxValueEx(int nModule, int nPoint, float *pfValue);

    int GetAnalogPointTpoPeriodEx(int nModule, int nPoint, float *pfValue);

    int GetAnalogPointReadAreaEx(int nModule, int nPoint, SIOMM_AnaPointReadArea *pData);

    int SetAnalogPointValueEx(int nModule, int nPoint, float fValue);

    int SetAnalogPointCountsEx(int nModule, int nPoint, float fValue);

    int SetAnalogPointTpoPeriodEx(int nModule, int nPoint, float fValue);

    int ReadClearAnalogPointMinValueEx(int nModule, int nPoint, float *pfValue);

    int ReadClearAnalogPointMaxValueEx(int nModule, int nPoint, float *pfValue);

    /* Legacy Analog point methods. If you're using firmware 8.0 or newer on your
     * I/O units, it is recommended that you use the newer (Expanded) methods
     * defined above. If you're using a firmware older than 8.0, use these methods.
     */

    int GetAnaPtValue(int nPoint, float *pfValue);

    int GetAnaPtCounts(int nPoint, float *pfValue);

    int GetAnaPtMinValue(int nPoint, float *pfValue);

    int GetAnaPtMaxValue(int nPoint, float *pfValue);

    int GetAnaPtTpoPeriod(int nPoint, float *pfValue);

    int GetAnaPtReadAreaEx(int nPoint, SIOMM_AnaPointReadArea * pData);

    int SetAnaPtValue(int nPoint, float fValue);

    int SetAnaPtCounts(int nPoint, float fValue);

    int SetAnaPtTpoPeriod(int nPoint, float fValue);

    int ReadClearAnaPtMinValue(int nPoint, float *pfValue);

    int ReadClearAnaPtMaxValue(int nPoint, float *pfValue);

    int GetAnaBankValuesEx(SIOMM_AnaBank * pBankData);

    int GetAnaBankCountsEx(SIOMM_AnaBank * pBankData);

    int GetAnaBankMinValuesEx(SIOMM_AnaBank * pBankData);

    int GetAnaBankMaxValuesEx(SIOMM_AnaBank * pBankData);

    int GetAnaBanksEx(SIOMM_AnaBanks * pBankData);

    int SetAnaBankValuesEx(SIOMM_AnaBank BankData);

    int SetAnaBankCountsEx(SIOMM_AnaBank BankData);

    int CalcSetAnaPtOffset(int nPoint, float *pfValue);

    int CalcSetAnaPtGain(int nPoint, float *pfValue);

    int SetPidLoopConfigurationEx(int nPid, SIOMM_PidLoopConfigArea Data);

    // TPO (Pulsed Output)
    int SetTpoConfigurationEx(int nTpo, SIOMM_TpoConfigArea Data);
    int GetTpoConfigurationEx(int nTpo, SIOMM_TpoConfigArea * pTpoData);

    int SetEventMsgConfigurationEx(int nMsg, SIOMM_EventMsgConfigArea Data);

    int SetDigitalEventConfigurationEx(int nEvent, SIOMM_DigitalEventConfigArea Data);

    int SetAlarmEventConfigurationEx(int nEvent, SIOMM_AlarmEventConfigArea Data);

    int SetSerialEventConfigurationEx(int nEvent, SIOMM_SerialEventConfigArea Data);

    int SetTimerEventConfigurationEx(int nEvent, SIOMM_TimerEventConfigArea Data);


    // Stream functions
    int GetStreamConfiguration(int * pnOnFlag, int * pnIntervalMS, 
                                int * pnPort,
                                int * pnIoMirroringEnabled, 
                                int * pnStartAddress, 
                                int * pnDataSize);

    int SetStreamConfiguration(int nOnFlag, int nIntervalMS, int nPort,
                                int nIoMirroringEnabled, int nStartAddress,
                                int nDataSize);

    int GetStreamTarget(int nTarget, int * pnIpAddressArg);

    int SetStreamTarget(int nTarget, char * pchIpAddressArg);

    int GetStreamReadAreaEx (SIOMM_StreamStandardBlock *pStreamData);  


    int GetScratchPadBitArea(int *pnBits63to32, int *pnBits31to0);

    int SetScratchPadBitArea(int   nBits63to32, int   nBits31to0);

    int SetScratchPadBitAreaMask(int nOnMask63to32,  int nOnMask31to0,
                                  int nOffMask63to32, int nOffMask31to0);

    int GetScratchPadIntegerArea(int nStartIndex, int nLength, 
                                  int * pnData);

    int SetScratchPadIntegerArea(int nStartIndex, int nLength, 
                                  int * pnData);

    int GetScratchPadFloatArea  (int nStartIndex, int nLength, 
                                  float * pfData);

    int SetScratchPadFloatArea  (int nStartIndex, int nLength, 
                                  float * pfData);

    int GetScratchPadStringArea (int nStartIndex, int nLength,
                                  SIOMM_ScratchPadString * pStringData);

    int SetScratchPadStringArea (int nStartIndex, int nLength, 
                                  SIOMM_ScratchPadString * pStringData);

    int GetScratchPadInteger64Area(int nStartIndex, int nLength,
                                    int * pnData);

    int SetScratchPadInteger64Area(int nStartIndex, int nLength,
                                    int * pnData);

    int GetDataLoggingSamplesEx(int nStartIndex, int nLength, 
                                 SIOMM_DataLogSample * pDataSamples);

    int ConfigurePoint          (int nModule, int nPoint, int nPointType);

    int GetModuleType           (int nModule, int nPoint, int *pnModuleType);

    int GetPointConfigurationEx4(int nModule, int nPoint, SIOMM_PointConfigArea4 *pData);

    int GetPointGain            (int nModule, int nPoint, float *pfGain);

    int GetPointOffset          (int nModule, int nPoint, float *pfOffset);

    int SetPointConfigurationEx4(int nModule, int nPoint, SIOMM_PointConfigArea4 PtConfigData);

    int SetPointFilterWeight    (int nModule, int nPoint, float fFilterWeight);

    int SetPointGain            (int nModule, int nPoint, float fGain);

    int SetPointOffset          (int nModule, int nPoint, float fOffset);

    int SetPointScale           (int nModule, int nPoint, float fHiScale, float fLoScale);

    int SetPointWatchdog        (int nModule, int nPoint, float fValue, int nEnabled);

    int SetPointName            (int nModule, int nPoint, char *pchPointName);
    
    int GetDigitalPointReadAreaEx(int nModule, int nPoint, SIOMM_DigPointReadArea *pData);

    int CalcSetAnalogPointOffsetEx(int nModule, int nPoint, float *pfValue);

    int CalcSetAnalogPointGainEx(int nModule, int nPoint, float *pfValue);

    // Analog output clamping
    
    int SetAnalogOutputClamp(int nModule, int nPoint, float fLowClamp, float fHighClamp);

    int GetAnalogOutputClamp(int nModule, int nPoint, float * pfLowClamp, float * pfHighClamp);

    int SetAnalogOutputClamp(int nPoint, float fLowClamp, float fHighClamp);

    int GetAnalogOutputClamp(int nPoint, float * pfLowClamp, float * pfHighClamp);

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

#ifdef _WIN32
    HANDLE      m_serialHandle;    // handle to our open serial port
#else
    int         m_serialHandle;
#endif

    uint8_t        m_serialAddress;   // Address on the serial brain
    int        m_serialBaudRate;
    int        m_serialPort;
    bool        m_serialTwoWire;   // Two-wire mode or Four-wire mode (half or full duplex)

    ConnectionMethod m_method;     // ethernet, serial, or passthru

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

    uint8_t    m_byTransactionLabel;  // The current transaction label

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

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

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

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

    inline uint32_t GetTickCount(); // Generic way of getting the time as a 
                                 // tick count.

  private:
    // Private data

    // Private Members
    int ReadBlockEthernet (const uint32_t dwDestOffset, const uint16_t wDataLength, 
                            uint8_t * pbyData);
    int WriteBlockEthernet(const uint32_t dwDestOffset, const uint16_t wDataLength, 
                            uint8_t * pbyData);
    int ReadBlockSerial (const uint32_t dwDestOffset, const uint16_t wDataLength, 
                          uint8_t * pbyData);
    int WriteBlockSerial(const uint32_t dwDestOffset, const uint16_t wDataLength, 
                          uint8_t * pbyData);
    int ReadBlockPassThru(const uint32_t dwDestOffset, const uint16_t wDataLength, 
                           uint8_t * pbyData);
    int WriteBlockPassThru(const uint32_t dwDestOffset, const uint16_t wDataLength,
                            uint8_t * pbyData);

    int BaudRateToSleepTime(int baudRate);
    int SendSerialMessage(uint8_t * pMessage, const uint16_t wMessageLength);
};



#endif // __O22SIOMM_H_