cpl defs.h

#ifndef _CPL_DEFS_H_
#define _CPL_DEFS_H_

#include <tchar.h>
#include <string>
#include <Windows.h>    // we need to include windows to include ftd2xx.h

#define BARST_VERSION       22000   // it's 2.20.00

#define MIN_PIPE_BUF_SIZE   20  // smallest named pipe buffer possible
#define DEVICE_NAME_SIZE    8   // size of the unique internal name given for all devices/managers
#define MIN_BUFF_IN         256 // smallest server read (clients write) buffer for named pipe communicator
#define MIN_BUFF_OUT        256 // smallest server write (clients read) buffer for named pipe communicator
#define MIN_FTDI_LIB_VER    0x00030204  // the lowest FTDI version we accept for FTDI lib driver
#define MIN_RTV_LIB_VER     1080    // the lowest RTV version we accept for RTV dll lib driver
#define FTDI_MAX_BUFF_H     (510*128)   // max buffer that FTDI can r/w on high speed devices.
#define FTDI_MAX_BUFF_L     (62*1024) // max buffer that FTDI can r/w on low speed devices.
#define FTDI_BAUD_2232H     200000  // clock rate is actually 1MHz = 200000*5
#define FTDI_BAUD_DEFAULT   62500   // clock rate is actually 1MHz = 62500*16
#define SERIAL_MAX_LENGTH   24      // maximum length serial comports can be (e.g. com4)


#define BAD_INPUT_PARAMS    1
#define NO_SYS_RESOURCE     2   // out of memory, etc.
#define ALREADY_OPEN        3   // tried to open device etc. that was already opened. or made request already pending
#define SIZE_MISSMATCH      4   // size of massage doesn't match expected size.
#define INVALID_CHANN       5   // channel requested is not set, out of range etc.
#define UNKWN_ERROR         6
#define DRIVER_ERROR        7
#define DEVICE_CLOSING      8   // device is closing so no data can be read/sent
#define INVALID_DEVICE      9   // the device you tried to create (e.g. ADC) isn't recognized
#define INACTIVE_DEVICE     10  // tried to do something with inactive device
#define INVALID_COMMAND     11  // didn't understand what you wanted, or command is invalid in this state/stage
#define UNEXPECTED_READ     12  // when the packet read doesn't match anything
#define NO_CHAN             13  // channel wasn't created as requested because something went wrong. Or no channel was provided
#define BUFF_TOO_SMALL      14  // provided buffer was too small, or wanted to write more than the buffer can take
#define NOT_FOUND           15  // library or object wasn't found
#define TIMED_OUT           16  // timed out while waiting for something
#define INVALID_MAN         17  // the manager (e.g. rtv, ftdi) you wanted to communicate with is not recognized
#define RW_FAILED           18
#define LIBRARY_ERROR       19

#define FT_ERROR(x, nTemp) (((nTemp= x)!=0)?(nTemp + 100):0)    // 101 + 1-19 = (101 to 200)
#define RTV_ERROR(x, nTemp) (((nTemp= -x)!=0)?(nTemp + 200):0)  // 201 + 1-201 = (201 to 500)
#define MCDAQ_ERROR(x, nTemp) (((nTemp= x)!=0)?(nTemp + 500):0) // 101 + 1-19 = (501 to 1601)
#define WIN_ERROR(x, nTemp) (((nTemp= x)!=0)?(nTemp + 10000):0) // 10001 + ? = (10001 to ?)


#ifdef _UNICODE
#define tstring wstring
#define tostringstream wostringstream
#define tstringstream wstringstream
#else
#define tstring string
#define tostringstream ostringstream
#define tstringstream stringstream
#endif


enum EQueryType
{
    /*** Everything sent to Barst starts with SBaseIn, optionally followed by other structs (each of which is prefaced
    by SBase). Response by Barst is also SBaseIn or SBaseOut, optionally followed by other structs (each of which is prefaced
    by SBase). The eType parameter of these structs are defined in this enum and determines the reason/type of the clients/server's
    communication. The response eType of SBaseIn is typically the same eType as the eType sent, except in case of error it might be
    eResponse or anything else, or if the response is a SBaseOut eType would be on of the eResponseExX. 
    
    If data is sent to multiple layers, the lowest layer responds, and each layer needs
    its own SBaseIn header. For instance, if you send data to the main manager which then passes it on to a manager
    you have to provide two SBaseIn struct for each manager. The response would then come from the manager. ***/

    eNone= 0,   // invalid
    eQuery,     // Requests info, response is typically eResponseEx with other stuff following
    eSet,       // Sets something, typically sends target specific info following SBaseIn
    eDelete,    // Deletes a channel or manager
    ePassOn,    // Tells upper layer to passs data on to next layer
    eData,      // SBaseIn followed by SBase and data, or just SBaseIn if that's the data
    eTrigger,   // Used to make a device do something
    eResponse,  // General response
    eVersion,   // dwInfo parameter is the version #
    eActivate,  // Tells server to activate a device
    eInactivate,    // Tells server to de-activate a device
    /*** Cat B - SBaseOut ***/
    eResponseEx,    // szName
    eResponseExL,   // llLargeInteger
    eResponseExD,   // dDouble
    /*** Cat C ***/
    // ftdi struct info
    eFTDIChan,      // SBase followed by FT_DEVICE_LIST_INFO_NODE
    eFTDIChanInit,  // SBase followed by SChanInitFTDI
    eFTDIPeriphInit,    // SBase followed by SInitPeriphFT
    eFTDIMultiWriteInit,    // SBase followed by SValveInit
    eFTDIADCInit,   // SBase followed by SADCInit
    eFTDIMultiReadInit, // SBase followed by SValveInit
    eFTDIPinReadInit,   // SBase followed by SPinInit
    eFTDIPinWriteInit,  // SBase followed by SPinInit
    eRTVChanInit,       // SBase followed by SChanInitRTV
    eSerialChanInit,    //  SBase followed by SChanInitSerial
    // possible buffer types
    eFTDIMultiWriteData,    // SBase followed by array of multi write data in the form of SValveData
    eADCData,                   // SADCData struct (only from sBase ahead, sDataBase has its own eType)
    eFTDIMultiReadData,         // SBase followed by multi read pin data in form of bool array
    eFTDIPinWDataArray,         // SBase followed by pin data in form of SPinWData array
    eFTDIPinWDataBufArray,      // SBase followed by a SPinWData followed by pin data in form of unsigned char array
    eFTDIPinRDataArray,         // SBase followed by pin data read in form of unsigned char array
    eRTVImageBuf,               // SBase followed by a RTV image buffer.
    eSerialWriteData,           // SBase followed by SSerialData followed by data to be written
    eSerialReadData,            
    eMCDAQChanInit,     // SBase followed by SChanInitMCDAQ
    eMCDAQWriteData,    // SBase followed by SMCDAQWData
    eCancelReadRequest, // SBaseIn indicating that a previous read request by the pipe should be canceld
    eServerTime,        // SBaseIn followed by SBase followed by SPerfTime


    // managers - the values that eType2 can take
    eFTDIMan= 1000,
    eRTVMan,
    eSerialMan,
    eMCDAQMan,
};




// Simplest struct that can be sent on its own from/to user.
typedef struct SBaseIn
{
    DWORD       dwSize; // the size of the SBaseIn struct (16)
    EQueryType  eType;  // the reason this was sent
    // one knows which of the three types was used based on eType
    union {
    int         nChan;  // the channel number
    EQueryType  eType2; // a secondary reason for sending
    DWORD       dwInfo; // When a DWORD is required
    };
    int         nError; // an error code.
} SBaseIn;

// struct used to preface other structs.
typedef struct SBase
{
    DWORD       dwSize; // the size of SBase + the size of the struct following
    EQueryType  eType;  // the struct following
} SBase;

// Alternative to SBaseIn so we can send a it more info. Typically used when we send info on a channel.
typedef struct SBaseOut
{
    // SBaseIn with sBaseIn.eType one of the eResponseExX types. sBaseIn.dwSize is 32 bytes.
    SBaseIn     sBaseIn;
    union {
    TCHAR       szName[DEVICE_NAME_SIZE];   // eResponseEx
    double      dDouble;                    // eResponseExD
    LARGE_INTEGER   llLargeInteger;         // eResponseExL
    };
    bool        bActive;                    // if the channels this was sent for is active.
} SBaseOut;




typedef struct SPerfTime
{
    double      dRelativeTime;
    double      dUTCTime;
} SPerfTime;




/******************** FTDI ************************/

typedef struct SChanInitFTDI
{
    // sizes must be larger than what we'll ever write/read
    DWORD       dwBuffIn;   // Size of the max buffer that client writes to server
    DWORD       dwBuffOut;  // Size of the max buffer that client reads from server
    DWORD       dwBaud;     // The baud rate used by the channel. We disregard the value supplied by the user.
} SChanInitFTDI;


typedef struct SInitPeriphFT
{
    int             nChan;  // the channel number of this device within the FTDI channel.
    // Holds the max buffer length that the write buffer will EVER be.
    // The actual length of buffer written can vary depending on which devices are active
    // but you can safley write to buffer for this length. For instance, if multi write and adc
    // devices are active, say multi write needs only 18 bytes and adc needs 4000 bytes to be written. Then 4000
    // bytes will be written, but the multi write device will have to initialize the full 4000 bytes, not just the 18 bytes
    // with the default values. This is typically done when inactivating, the state in which each device starts.
    // This size is the max of all devices, including padding if needed.
    DWORD           dwBuff;
    // min buffer THIS device needs, actual buffer written/read might be larger (dwBuff) but not smaller
    // while this device is active we are guaranteed to write/read dwMinSizeR/W
    DWORD           dwMinSizeR;
    DWORD           dwMinSizeW;
    DWORD           dwMaxBaud;  // the baud rate this device needs. We use the min of all devices.
    // the bit output mode (FT_xx), sync/async bit bang. If both are availible for all devices we use async.
    // We and all the bit modes of all the devices so we find mode supported by all devices.
    unsigned char   ucBitMode;
    unsigned char   ucBitOutput;    // the bits of the USB bus that are outputs for this device.
} SInitPeriphFT;



typedef struct SValveInit
{
    DWORD           dwBoards;   // the number of boards connected (each has 8 bits).
    // the number of clock cycles to use for each tick (i.e. actual baud rate will be bausrate/dwClkPerData)
    DWORD           dwClkPerData;   
    unsigned char   ucClk;  // the bit number (0-7) that is the clock line
    unsigned char   ucData; // the bit number (0-7) that is the data line
    unsigned char   ucLatch;    // the bit number (0-7) that is the latch (Sa on MC74HC165A) signal
    // if reading device, and if true than we will continuosly read and send the data read to the
    // client that initially triggered this device. This ensures we read as much data as possible.
    // If it's a writing device we ignore this parameter. 
    bool            bContinuous;
} SValveInit;


typedef struct SValveData
{
    unsigned short  usIndex;
    bool            bValue;     // true to set bit high, false to set low.
} SValveData;



typedef struct SPinInit
{
    unsigned short  usBytesUsed;
    unsigned char   ucActivePins;
    unsigned char   ucInitialVal;
    bool            bContinuous;
} SPinInit;

typedef struct SPinWData
{
    // how many times this byte will be repeated in the output buffer.
    unsigned short  usRepeat;
    // the the byte to output usRepeat times.
    unsigned char   ucValue;
    /*  Which of the output bytes to update. This lets you update only some of the output bytes
        while not changing the others. For instance, if the pins for this device were selected as bits 
        3 and 7, i.e. ucActivePins was set to 0x88. But you only want to update bit 3 with this struct,
        then you set ucPinSelect to 0x08 and only bit 3 will be changed. The other bit will remain as is.*/
    unsigned char   ucPinSelect;
} SPinWData;



typedef struct SADCInit
{
    float           fUSBBuffToUse;
    DWORD           dwDataPerTrans;
    unsigned char   ucClk;
    unsigned char   ucLowestDataBit;
    unsigned char   ucDataBits;
    unsigned char   ucRateFilter;
    bool            bChop;
    bool            bChan1;
    bool            bChan2;
    unsigned char   ucInputRange;
    unsigned char   ucBitsPerData;
    bool            bStatusReg; 
    bool            bReverseBytes;
    bool            bConfigureADC;
} SADCInit;


typedef struct SADCData
{
    SBaseIn     sDataBase;
    SBase       sBase;
    DWORD       dwPos;
    DWORD       dwCount1;
    DWORD       dwChan2Start;
    DWORD       dwCount2;
    DWORD       dwChan1S;
    DWORD       dwChan2S;
    float       fSpaceFull;
    float       fTimeWorked;
    float       fDataRate;
    unsigned char   ucError;
    double      dStartTime;
} SADCData;






/************* RTV ****************/

typedef struct SChanInitRTV
{
    unsigned char       ucBrightness;
    unsigned char       ucHue;
    unsigned char       ucUSat;
    unsigned char       ucVSat;
    unsigned char       ucLumaContrast;
    unsigned char       ucLumaFilt;
    unsigned char       ucColorFmt;
    unsigned char       ucVideoFmt;
    bool                bLossless;
    unsigned char       ucBpp;
    int                 nWidth;
    int                 nHeight;
    DWORD               dwBuffSize;
} SChanInitRTV;






/************* CommPort****************/

typedef struct SChanInitSerial
{
    TCHAR   szPortName[SERIAL_MAX_LENGTH];  // The name of the port, e.g. COM1
    DWORD   dwMaxStrWrite;                  // max size of any data to be written
    DWORD   dwMaxStrRead;                   // max size of any data to be read
    DWORD   dwBaudRate;                     // baud rate with which to open the channel
    // The number of stop bits to use. Can be one of 0, 1, or 2. 0 means 1 bit,
    // 1, means 1.5 bits, and 2 means 2 bit.
    unsigned char   ucStopBits;
    unsigned char   ucParity;
    // The number of bits in the bytes transmitted and received. Can be between
    // 4 and 8, including 4 and 8.
    unsigned char   ucByteSize;
} SChanInitSerial;

typedef struct SSerialData
{
    DWORD   dwSize;     // size of data to read/write
    DWORD   dwTimeout;  // 0 means infinite wait
    char    cStop;      // when reading, the character on which to stop
    bool    bStop;      // if cStop is used, when reading
} SSerialData;



// FT_DEVICE_LIST_INFO_NODE_OS is simmalr to FT_DEVICE_LIST_INFO_NODE, 
// except the last item instead of being a FT_HANDLE which is a void*
// so size is either 4 or 8 bytes, is instead always 8 bytes. The _OS struct is
// always used when sending to clients to ensure x64, x86 comaptibility.
typedef struct _ft_device_list_info_node_os {
    ULONG Flags;
    ULONG Type;
    ULONG ID;
    DWORD LocId;
    char SerialNumber[16];
    char Description[64];
    unsigned __int64 ftHandle;
} FT_DEVICE_LIST_INFO_NODE_OS;





/************* MCDAQ device****************/


typedef struct SChanInitMCDAQ
{
    unsigned char   ucDirection;    // 0 for reading, 1 for writing, 2 for read/write
    unsigned short  usInitialVal;   // the initial value to set the port to, when writing
    bool            bContinuous;    // when reading, whether it occurs continuously
} SChanInitMCDAQ;


typedef struct SMCDAQWData
{
    unsigned short  usValue;    // the value to output.
    /*  Which of the output bits to update. This lets you update only some of the output bits
        while not changing the others. For instance, if you only want to update bit 3 with this
        struct, then you set usBitSelect to 0x0008 and only bit 3 will be changed. The other
        bits will remain as is.*/
    unsigned short  usBitSelect;
} SMCDAQWData;



#endif