t_titan.cpp

FTDI FT2232C 應用程式與測試程式

//---------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include <windows.h>
#include <winioctl.h>
#include "t_titan.h"
#include "ftd2xx.h"
//---------------------------------------------------------------------
#define IOCTL_SERIAL_SET_DTR        CTL_CODE(\
                                        FILE_DEVICE_SERIAL_PORT,\
                                        9,\
                                        METHOD_BUFFERED,\
                                        FILE_ANY_ACCESS)
#define IOCTL_SERIAL_CLR_DTR        CTL_CODE(\
                                        FILE_DEVICE_SERIAL_PORT,\
                                        10,\
                                        METHOD_BUFFERED,\
                                        FILE_ANY_ACCESS)
#define IOCTL_SERIAL_SET_RTS		CTL_CODE(\
                                        FILE_DEVICE_SERIAL_PORT,\
										12,\
                                        METHOD_BUFFERED,\
                                        FILE_ANY_ACCESS)
#define IOCTL_SERIAL_CLR_RTS		CTL_CODE(\
                                        FILE_DEVICE_SERIAL_PORT,\
										13,\
                                        METHOD_BUFFERED,\
                                        FILE_ANY_ACCESS)
//---------------------------------------------------------------------
__fastcall TTitanTester::TTitanTester(int ChannelA)
{
	Running = FALSE;
    Dev1 = Dev2 = NULL;
    Client = Server = NULL;
    Flags = 0;

    //
    // open the COM port
    //
	hCom = CreateFile(
                "\\\\.\\COM1",
    			GENERIC_READ|GENERIC_WRITE,
                0,
                0,
                OPEN_EXISTING,
                0,
                0
                );

	if (hCom == INVALID_HANDLE_VALUE)
        return;

    Flags |= FTDI_TITAN_COM1_OPEN;

    //
    // open the Device
    //

    if ((Dev1 = new TFtUsbDev) == NULL)
        return;

    if (!Dev1->Open(0))
        return;

    Flags |= FTDI_TITAN_DEV1_OPEN;

    if ((Dev2 = new TFtUsbDev) == NULL)
        return;

    if (!Dev2->Open(1))
        return;

    Flags |= FTDI_TITAN_DEV2_OPEN;

    if (ChannelA == 0) {
        Client = Dev1;
        Server = Dev2;
    }
    else {
        Client = Dev2;
        Server = Dev1;
    }

    WaitStatusTime = 50;
    Status = 0;
    Running = TRUE;
}

__fastcall TTitanTester::~TTitanTester(void)
{
	if (Running) {
#if 0
    	DeactCTS();
        DeactDSR();
        DeactCD();
        DeactRI();
#endif
        Running = FALSE;
    }

    if (Flags & FTDI_TITAN_DEV1_OPEN)
        Dev1->Close();

    if (Flags & FTDI_TITAN_DEV2_OPEN)
        Dev2->Close();

    if (hCom != INVALID_HANDLE_VALUE)
        CloseHandle(hCom);

    if (Dev1)
        delete Dev1;

    if (Dev2)
        delete Dev2;
}


BOOL TTitanTester::IsRunning(void)
{
	return Running;
}


void TTitanTester::Reset(void)
{
	//
    // Deactivate CTS, DSR, CD, RI
    //
#if 0
    DeactCTS();
    DeactDSR();
    DeactCD();
    DeactRI();
#endif
}


void TTitanTester::ActCTS(void)
{
	//
    // Activate CTS - Set RTS
    //
    FT_SetRts(Server->ftdiHandle);
}


void TTitanTester::DeactCTS(void)
{
	//
    // Deactivate CTS - Clear RTS
    //
    FT_ClrRts(Server->ftdiHandle);
}


void TTitanTester::ActDSR(void)
{
	//
    // Activate DSR - Set DTR
    //
    FT_SetDtr(Server->ftdiHandle);
}


void TTitanTester::DeactDSR(void)
{
	//
    // Deactivate DSR - Clear DSR
    //
    FT_ClrDtr(Server->ftdiHandle);
}


void TTitanTester::ActCD(void)
{
	//
    // Activate CD - Set DTR in COM1
    //

    unsigned long bytes;

    DeviceIoControl(hCom,
       				IOCTL_SERIAL_SET_DTR,
   	                0,0,
       	            0,0,
           	        &bytes,0);
}


void TTitanTester::DeactCD(void)
{
	//
    // Deactivate CD - Clear DTR in COM1
    //

    unsigned long bytes;

    DeviceIoControl(hCom,
       				IOCTL_SERIAL_CLR_DTR,
   	                0,0,
       	            0,0,
           	        &bytes,0);
}


void TTitanTester::ActRI(void)
{
	//
    // Activate RI - Set RTS in COM1
    //

    unsigned long bytes;

    DeviceIoControl(hCom,
       				IOCTL_SERIAL_SET_RTS,
   	                0,0,
       	            0,0,
           	        &bytes,0);
}


void TTitanTester::DeactRI(void)
{
	//
    // Deactivate RI - Clear RTS in COM1
    //

    unsigned long bytes;

    DeviceIoControl(hCom,
       				IOCTL_SERIAL_CLR_RTS,
   	                0,0,
       	            0,0,
           	        &bytes,0);
}


DWORD TTitanTester::ReadStatus(void)
{
	DWORD dw;

    FT_GetModemStatus(Client->ftdiHandle,&dw);
	return dw;
}


DWORD TTitanTester::WaitStatus(void)
{
   	Sleep(WaitStatusTime);
    return ReadStatus();
}


BOOL TTitanTester::Set300(void)
{
	//
    // Setup for 300 baud 8N1 communications
    //

    FT_SetBaudRate(Client->ftdiHandle,FT_BAUD_300);
    FT_SetDataCharacteristics(Client->ftdiHandle,FT_BITS_8,FT_STOP_BITS_1,FT_PARITY_NONE);
    FT_SetTimeouts(Client->ftdiHandle,300,300);
    FT_SetBaudRate(Server->ftdiHandle,FT_BAUD_300);
    FT_SetDataCharacteristics(Server->ftdiHandle,FT_BITS_8,FT_STOP_BITS_1,FT_PARITY_NONE);
    FT_SetTimeouts(Server->ftdiHandle,300,300);

    return TRUE;
}


BOOL TTitanTester::Set115K(void)
{
	//
    // Setup for 115200 baud 8N1 communications
    //

    FT_SetBaudRate(Client->ftdiHandle,FT_BAUD_115200);
    FT_SetDataCharacteristics(Client->ftdiHandle,FT_BITS_8,FT_STOP_BITS_1,FT_PARITY_NONE);
    FT_SetTimeouts(Client->ftdiHandle,300,300);
    FT_SetBaudRate(Server->ftdiHandle,FT_BAUD_115200);
    FT_SetDataCharacteristics(Server->ftdiHandle,FT_BITS_8,FT_STOP_BITS_1,FT_PARITY_NONE);
    FT_SetTimeouts(Server->ftdiHandle,300,300);

    return TRUE;
}


BOOL TTitanTester::DoRxTest(unsigned char *WriteBuffer,
					   unsigned char *ReadBuffer,
                       DWORD BufLen)
{
/*++
    Device receive test
    ===================

    Transmit data from COM2 and read the device. If the read and write buffers
    are the same, the test is successful.

    Device read failures and timeouts are supported.
--*/

    unsigned char *source = WriteBuffer;
    DWORD len = BufLen;

    for (DWORD i = 0; i < BufLen; i++)
   	  	WriteBuffer[i] = (unsigned char) i;

    for (;;) {

	    DWORD dwWritten;

        if (!Server->Write(source,len,&dwWritten))
            return FALSE;    // Write failed

        if (dwWritten == len)
            break;           // Finished

        if (dwWritten == 0)
            return FALSE;    // Write timeout

        if (dwWritten != len) { // Written part of data
            len -= dwWritten;
            source += dwWritten;
        }

    }

    unsigned char *dest = ReadBuffer;
    len = BufLen;

    memset(ReadBuffer,0,BufLen);

    for (;;) {

        DWORD dwRead;

        if (!Client->Read(dest,len,&dwRead))
            return FALSE;    // Read failed

        if (dwRead == len)
            break;           // Finished

#if 1
        if (dwRead == 0)
            return FALSE;    // Read timeout
#endif

        if (dwRead != len) { // Read part of data
            len -= dwRead;
            dest += dwRead;
        }

    }

	return memcmp(WriteBuffer,ReadBuffer,BufLen) == 0;
}


BOOL TTitanTester::DoTxTest(unsigned char *WriteBuffer,
					   unsigned char *ReadBuffer,
                       DWORD BufLen)
{
/*++
    Device transmit test
    ====================

    Transmit data from device and read COM2. If the read and write buffers
    are the same, the test is successful.

    Device write failures and timeouts are supported.
--*/

#if 0
    BOOL fStatus;

    ActCTS();
    fStatus = MS_CTS_ON & WaitStatus();
    if (!fStatus)
        return FALSE;

    ActDSR();
    fStatus = MS_DSR_ON & WaitStatus();
    if (!fStatus)
        return FALSE;
#endif

    unsigned char *source = WriteBuffer;
    DWORD len = BufLen;

    for (;;) {

	    DWORD dwWritten;

        if (!Client->Write(source,len,&dwWritten))
            return FALSE;    // Write failed

        if (dwWritten == len)
            break;           // Finished

        if (dwWritten == 0)
            return FALSE;    // Write timeout

        if (dwWritten != len) { // Written part of data
            len -= dwWritten;
            source += dwWritten;
        }

    }

    unsigned char *dest = ReadBuffer;
    len = BufLen;

    memset(ReadBuffer,0,BufLen);

    for (;;) {

	    DWORD dwRead;

        if (!Server->Read(dest,len,&dwRead))
            return FALSE;    // Read failed

        if (dwRead == len)
            break;           // Finished

        if (dwRead == 0)
            return FALSE;    // Read timeout

        if (dwRead != len) { // Read part of data
            len -= dwRead;
            dest += dwRead;
        }

    }

	return memcmp(WriteBuffer,ReadBuffer,BufLen) == 0;
}


//---------------------------------------------------------------------