ftdi device.h

#ifndef _CPL_FTDI_DEVICE_H_
#define _CPL_FTDI_DEVICE_H_

#include "base classses.h"
#include "cpl queue.h"
#include "misc tools.h"
#include "ftd2xx.h"

class CChannelFTDI;
class CPeriphFTDI;


#define FTDI_MAN_STR    _T("FTDIMan")
class CManagerFTDI : public CManager
{
public:
    CManagerFTDI(CComm* pcComm, const TCHAR szPipe[], int nChan, int &nError);
    virtual ~CManagerFTDI();
    void ProcessData(const void *pHead, DWORD dwSize, __int64 llId);
    void Result(void *pHead, bool bPass) {if (m_pcMemPool) m_pcMemPool->PoolRelease(pHead);}
    virtual DWORD GetInfo(void* pHead, DWORD dwSize);
private:
    std::vector<CChannelFTDI*>      m_acFTDevices;  // holds all the FTDI channels

    DWORD                           m_dwNumDevs;    // number of devices discovered (including not ours)
    std::vector<FT_DEVICE_LIST_INFO_NODE> m_asFTChanInfo;   // holds the device info for all the devices discovered
};


// struct used by ftdi thread to repond to user updates commands
typedef struct SFTUpdates
{
    SData sData;
    __int64 llId;
} SFTUpdates;

/*  Defines a FTDI channel. Note, each channel correponds to a single channel on a physical device. But
    each channel can hold multiple virutal devices defined below. */
#define FTDI_CHAN_STR   _T("FTChann")
class CChannelFTDI : public CDevice
{
public:
    CChannelFTDI(SChanInitFTDI &sChanInit, SBase* pInit, DWORD dwSize, FT_DEVICE_LIST_INFO_NODE &FTInfo, 
        const TCHAR szPipe[], int nChan, int &nError, LARGE_INTEGER &llStart);
    virtual ~CChannelFTDI();
    void ProcessData(const void *pHead, DWORD dwSize, __int64 llId);
    void Result(void *pHead, bool bPass) {if (m_pcMemPool) m_pcMemPool->PoolRelease(pHead);}
    DWORD GetInfo(void* pHead, DWORD dwSize);

    DWORD ThreadProc(); // thread that reads/writes to physical device

    // channles init data
    const FT_DEVICE_LIST_INFO_NODE  m_FTInfo;
    const std::tstring              m_csPipeName;
    const int                       m_nChan;
private:
    FT_HANDLE                       m_ftHandle; // ft_handle to the channel
    std::vector<CPeriphFTDI*>       m_aDevices; // list of all the subdevices. index is channel number
    SChanInitFTDI                   m_sChanInit;


    HANDLE                  m_hStop;    // stops the thread
    HANDLE                  m_hNext;    // tells the thread to do another read/write
    HANDLE                  m_hUpdate;  // tells the thread updates are pending for a device
    std::vector<HANDLE>     m_ahEvents; // events for all the devices
    HANDLE                  m_hThread;  // thread handle
    CQueue<SFTUpdates>      m_asUpdates;    // queue which holds the updates, MUST only be valid


    unsigned char*          m_aucTx;    // buffer used to write to device
    CMemRing*               m_pcMemRing; // provides the buffers for reading

    CTimer                  m_cTimer;   // timer for this channel
};



// see the Do work function in CPeriphFTDI for the use of this enum.
enum EStateFTDI
{
    eActive= 1,
    eInactive,
    eActivateState,
    eInactivateState,
    ePreWrite,
    ePostWrite,
    ePostRead,
    eRecover,
};

/*  following are the devices that FTDI channels recognize
    they must be derived from CPeriphFTDI. Channel is initialized with list
    of devices. Every device is initialized with a const struct of the init info. */
class CPeriphFTDI : public CDevice
{
friend class CChannelFTDI;
public:
    CPeriphFTDI(const TCHAR szName[], const SInitPeriphFT &sInitFT) : CDevice(szName), m_sInitFT(sInitFT),
        m_ucBitOutput(sInitFT.ucBitOutput){};
    virtual ~CPeriphFTDI(){};
    virtual bool DoWork(void *pHead, DWORD dwSize, FT_HANDLE ftHandle, EStateFTDI eReason, int nError)= 0;
    virtual void ProcessData(const void *pHead, DWORD dwSize, __int64 llId)= 0;
    virtual void Result(void *pHead, bool bPass)= 0;
    virtual EStateFTDI GetState()= 0;   // returns if we're active/inactive etc.
    virtual DWORD GetInfo(void* pHead, DWORD dwSize)= 0;
    void SetOutputBits(unsigned char ucBitOutput) {m_ucBitOutput = ucBitOutput;}
    unsigned char GetOutputBits() {return m_ucBitOutput;}

    const SInitPeriphFT     m_sInitFT;
protected:
    EStateFTDI      m_eState;   // current device state
    CTimer*         m_pcTimer;  // timer of device.
    unsigned char   m_ucBitOutput;  // current bits set as output
    CMemRing*       m_pcMemRing;    // the class that provides the reading buffers
};


#define ADC_P   _T("ADCBrd")
#define ADC_RESET_DELAY 2500
enum EHandshakeADC {
    eConfigStart,
    eConfigTO,
    eConfigClkToggle,
    eConfigWrite,
    eConfigDone,
};

typedef struct STimedRead
{
    double  dTime;
    int     nIdx;
    void*   pHead;
} STimedRead;

class CADCPeriph : public CPeriphFTDI
{
public:
    CADCPeriph(const SADCInit &sADCInit, CComm *pcComm, const SInitPeriphFT &sInitFT, 
        HANDLE hNewData, int &nError, CTimer* pcTimer);
    virtual ~CADCPeriph();
    bool DoWork(void *pHead, DWORD dwSize, FT_HANDLE ftHandle, EStateFTDI eReason, int nError);
    void ProcessData(const void *pHead, DWORD dwSize, __int64 llId);
    void Result(void *pHead, bool bPass) {if (m_pcMemPool) m_pcMemPool->PoolRelease(pHead);}
    EStateFTDI GetState();
    DWORD GetInfo(void* pHead, DWORD dwSize);

    DWORD ThreadProc();

    const SADCInit          m_sInit;
    const unsigned char     m_ucMask;   // flipped
    const unsigned char     m_ucConfigWriteBit;
    const unsigned char     m_ucConfigReadBit;
    const unsigned char     m_ucReverse;    // 1 if reverse, 0 otherwise
    const unsigned char     m_ucDefault;    // default state of the pins (high/low)
    const unsigned short    m_usConfigWord;
    const unsigned char     m_ucTransPerByte;
    const unsigned char     m_ucNGroups;    // number of transections it takes to get a data set (cycle)
    const unsigned char     m_ucNBytes;     // number of bytes sent in a data set
private:
    void ExtractData(STimedRead *psRead);
    DWORD                   m_dwRestartE;
    EHandshakeADC           m_eConfigState;
    SData                   m_sData;

    HANDLE                  m_hThread;
    HANDLE                  m_hThreadClose;
    HANDLE                  m_hProcessData;
    HANDLE                  m_hReset;
    HANDLE                  m_hNext;

    CQueue<STimedRead *>    m_apsReadIdx;
    CRITICAL_SECTION        m_hStateSafe;
    __int64                 m_llId;

    DWORD                   m_dwDataCount;  // count of packets since start of now transection cycle
    char                    m_cDataOffset;  // number of cycles into m_aucBuff multiplied my m_ucNBytes
    char                    m_cBuffSize;
    unsigned char*          m_aucBuff;
    unsigned short          (*m_aucDecoded)[256];
    unsigned char           m_aucGroups[16];    // sending 2 bits at a time w/ 4 bytes per ADC point = max 16 groups
    unsigned char           m_ucFlags;
    unsigned short          m_usBadRead;
    unsigned short          m_usOverflow;
    DWORD                   m_dwTempData;
    DWORD                   m_dwAmountRead;

    SADCData*               m_psDataHeader;
    DWORD*                  m_adwData;
    bool                    m_bSecond;
    DWORD                   m_dwPos;
    DWORD                   m_dwSpaceUsed;
    float                   m_fTimeWorked;
    DWORD                   m_dwStartRead;
    double                  m_dTimeTemp;

    //unsigned char         m_ucLastByte;
};

#define MULTI_W_P   _T("MltWBrd")
class CMultiWPeriph : public CPeriphFTDI
{
public:
    CMultiWPeriph(const SValveInit &sValveInit, CComm *pcComm, const SInitPeriphFT &sInitFT, 
        int &nError, HANDLE hNewData, CTimer* pcTimer);
    virtual ~CMultiWPeriph();
    bool DoWork(void *pHead, DWORD dwSize, FT_HANDLE ftHandle, EStateFTDI eReason, int nError);
    void ProcessData(const void *pHead, DWORD dwSize, __int64 llId);
    void Result(void *pHead, bool bPass) {if (m_pcMemPool) m_pcMemPool->PoolRelease(pHead);}
    EStateFTDI GetState();
    DWORD GetInfo(void* pHead, DWORD dwSize);

    const SValveInit        m_sInit;
    const unsigned char     m_ucMask;
    const unsigned char     m_ucDefault;
private:
    bool                    m_bUpdated;
    bool                    m_bChanged;
    int                     m_nProcessed;
    double                  m_dInitial;
    std::vector<bool>       m_abData;
    CRITICAL_SECTION        m_hDataSafe;
    CQueue<__int64>         m_allIds;
    HANDLE                  m_hNext;
};

#define MULTI_R_P   _T("MltRBrd")
class CMultiRPeriph : public CPeriphFTDI
{
public:
    CMultiRPeriph(const SValveInit &sValveInit, CComm *pcComm, const SInitPeriphFT &sInitFT, 
        int &nError, HANDLE hNewData, CTimer* pcTimer);
    virtual ~CMultiRPeriph();
    bool DoWork(void *pHead, DWORD dwSize, FT_HANDLE ftHandle, EStateFTDI eReason, int nError);
    void ProcessData(const void *pHead, DWORD dwSize, __int64 llId);
    void Result(void *pHead, bool bPass) {if (m_pcMemPool) m_pcMemPool->PoolRelease(pHead);}
    EStateFTDI GetState();
    DWORD GetInfo(void* pHead, DWORD dwSize);

    const SValveInit        m_sInit;
    const unsigned char     m_ucMask;
    const unsigned char     m_ucDefault;
private:
    bool                    m_bRead;
    int                     m_nProcessed;
    double                  m_dInitial;
    CRITICAL_SECTION        m_hDataSafe;
    std::vector<__int64>    m_allIds;
    HANDLE                  m_hNext;
};

#define PIN_W_P _T("PinWBrd")
class CPinWPeriph : public CPeriphFTDI
{
public:
    CPinWPeriph(const SPinInit &sPinInit, CComm *pcComm, const SInitPeriphFT &sInitFT, 
        int &nError, HANDLE hNewData, CTimer* pcTimer);
    virtual ~CPinWPeriph();
    bool DoWork(void *pHead, DWORD dwSize, FT_HANDLE ftHandle, EStateFTDI eReason, int nError);
    void ProcessData(const void *pHead, DWORD dwSize, __int64 llId);
    void Result(void *pHead, bool bPass) {if (m_pcMemPool) m_pcMemPool->PoolRelease(pHead);}
    EStateFTDI GetState();
    DWORD GetInfo(void* pHead, DWORD dwSize);

    const SPinInit          m_sInit;
    const unsigned char     m_ucMask;
private:
    unsigned char           m_ucLast;
    bool                    m_bUpdated;
    bool                    m_bChanged;
    int                     m_nProcessed;
    double                  m_dInitial;
    std::vector<unsigned char>  m_aucData;
    CRITICAL_SECTION        m_hDataSafe;
    CQueue<__int64>         m_allIds;
    HANDLE                  m_hNext;
};

#define PIN_R_P _T("PinRBrd")
class CPinRPeriph : public CPeriphFTDI
{
public:
    CPinRPeriph(const SPinInit &sPinInit, CComm *pcComm, const SInitPeriphFT &sInitFT, 
        int &nError, HANDLE hNewData, CTimer* pcTimer);
    virtual ~CPinRPeriph();
    bool DoWork(void *pHead, DWORD dwSize, FT_HANDLE ftHandle, EStateFTDI eReason, int nError);
    void ProcessData(const void *pHead, DWORD dwSize, __int64 llId);
    void Result(void *pHead, bool bPass) {if (m_pcMemPool) m_pcMemPool->PoolRelease(pHead);}
    EStateFTDI GetState();
    DWORD GetInfo(void* pHead, DWORD dwSize);

    const SPinInit          m_sInit;
    const unsigned char     m_ucMask;
private:
    bool                    m_bRead;
    int                     m_nProcessed;
    double                  m_dInitial;
    CRITICAL_SECTION        m_hDataSafe;
    std::vector<__int64>    m_allIds;
    HANDLE                  m_hNext;
};

#endif