How to program the USB IO 24 R from Elexol

USB IO 24 R
using the FTD2XX.LIB library, and C++ Builder.  (ToDo - make a TFtDevice class with all data and functions)

CONTENTS
What's needed
Command Set
My First Working Program
Writing to port
Reading from port

What's needed...

  1. the USB IO 24 R board and cable that connects to the PC's USB port
  2. software to send and receive signals between the two devices
The board was purchased from Elexol for A$125 in Nov 2011.  ( www.elexol.com.au )  It comes just as above - no extras.
Then you need to download drivers from the chip supplier FTDI .  You need the FTD2XX.LIB  (2.50 KB) file.  If the incorrect
library file is used, you get strange linker errors from C++ Builder.  The commands to control the board are very simple and straightforward.
However I am using very few of the routines in the library - essentially the open, write and read functions.  These will allow me to program
the board to drive pins high or low, or use them as inputs to sense high or low signals.  There is no analog sensing, or ADC functions used.
In addition I am not using the board to send data to or from another device.  The C++ example from FTDI does some of this on a basic level.

Command Set

USB IO 24 R command set

The following pages contain my first program, using the C++ Builder example from FTDI as a knowledge base.

My first working program

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "USBIO24R_Testv1.h"
#include "uUSBIO24R_Routines.h"
#include "FTD2xx.H"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmMain *frmMain;
char portID = 'A';  // three ports A,B, and C
int portValue = 0;  // initially all outputs LOW

TFtDevice Devices[NUMBER_OF_DEVICES];
TFtDevice *CurDev;
//---------------------------------------------------------------------------
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
        : TForm(Owner)
{
 // setup variables for mOutput memo display
 CurRow = 0;
 CurCol = 0;
 // set rgPortID, rgPortDirection
 rgPortID->ItemIndex = 0;
 rgPortDirection->ItemIndex = 0;
 // now set char portID from rgPortID
 SetPortID();
 // now mark Devices[0] as closed
 for (int i=0; i<NUMBER_OF_DEVICES; i++)
      Devices[i].IsOpen = false;   // signals all devices are closed to start
 // now show Device status in eDeviceStatus
 UpdateDeviceStatus();

 SetupUSBIO24R();    // set rgPortDirection to Output
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::UpdateDeviceStatus()
{
 // shows the device status from ->IsOpen
 if (!CurDev)
   eDeviceStatus->Text = "Device is CLOSED";
 else if (CurDev->IsOpen)
         eDeviceStatus->Text = "Device is OPEN";
      else
         eDeviceStatus->Text = "Device is CLOSED";
}
//--------------------------------------------
void __fastcall TfrmMain::SetPortID()
{
 // sets portID to A,B or C depending on radioGroup rgPortID
 switch (rgPortID->ItemIndex) {
   case 0 : portID = 'A'; break;
   case 1 : portID = 'B'; break;
   case 2 : portID = 'C'; break;
   default : rgPortID->ItemIndex = 0;portID = 'A';
  }
}
//----------------------------------------------------------------------------
bool __fastcall TfrmMain::SetupUSBIO24R()
{
 // set rgPortDirection to Output
 bool returnValue = true;
 rgPortDirection->ItemIndex = 0;

 return returnValue;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::CalculatePortValue()
{
 // calculate the value 0 - 255 from state of the 8 checkboxes
 portValue = 0;
 if (cb0->Checked) portValue = 1;
 if (cb1->Checked) portValue += 2;
 if (cb2->Checked) portValue += 4;
 if (cb3->Checked) portValue += 8;
 if (cb4->Checked) portValue += 16;
 if (cb5->Checked) portValue += 32;
 if (cb6->Checked) portValue += 64;
 if (cb7->Checked) portValue += 128;
}
//---------------------------------------------------------------------------
bool __fastcall TfrmMain::WriteToPort()
{
 char buffer[10];
 ULONG  BytesWritten;

 // check that Device is open
 if (!CurDev) {
     // ErrorForm->Display("Device[0] is not OPEN");
     eDeviceStatus->Text = "DEVICE NOT OPEN";
     return false;
    }
 // check that port is set to OUTPUT
 if (rgPortDirection->ItemIndex != 0) {
     ErrorForm->Display("Port is not set as OUTPUT");
     return false;
    }

 // writes portValue to portID
 bool returnValue = true;
 // first calculate the portValue
 CalculatePortValue();
 ePortValue->Text = "Port value is " + IntToStr(portValue);
 buffer[0] = portID;   // 'A' or 'B' or 'C'
 buffer[1] = char(portValue);
 FT_Write(CurDev->Handle,&buffer,2,&BytesWritten);
 return returnValue;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::WriteQueryNameToPort()
{
 char buffer[2];
 ULONG  BytesWritten;

 // check that Device is open
 if (!CurDev) {
     // ErrorForm->Display("Device[0] is not OPEN");
     eDeviceStatus->Text = "DEVICE NOT OPEN";
     return;
    }

 buffer[0] = '?';
 FT_Write(CurDev->Handle,&buffer,1,&BytesWritten);
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::SetLEDsState(bool state)
{
  cb0->Checked = state;
  cb1->Checked = state;
  cb2->Checked = state;
  cb3->Checked = state;
  cb4->Checked = state;
  cb5->Checked = state;
  cb6->Checked = state;
  cb7->Checked = state;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::SetLEDEnabled(bool state)
{
  cb0->Enabled = state;
  cb1->Enabled = state;
  cb2->Enabled = state;
  cb3->Enabled = state;
  cb4->Enabled = state;
  cb5->Enabled = state;
  cb6->Enabled = state;
  cb7->Enabled = state;
}
//----------------------------------------------------------
void __fastcall TfrmMain::btnAllOffClick(TObject *Sender)
{
 // turn all check boxes off
 SetLEDsState(false);
 WriteToPort();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnAllOnClick(TObject *Sender)
{
 // turn all LEDs ON
 SetLEDsState(true);
 WriteToPort();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::cb0Click(TObject *Sender)
{
 // the checkbox state may have changed, so update the port
 WriteToPort();       
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::rgPortIDClick(TObject *Sender)
{
 SetPortID();  // update portID from rgPortID
 CalculatePortValue();
 rgPortDirectionClick(NULL);
 WriteToPort();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnConfigureClick(TObject *Sender)
{
 if (!CurDev) return;
 // open the Configure window
 ConfigForm->Init(&CurDev->Data);
 if (ConfigForm->ShowModal() == mrOk)  {
     ConfigForm->Get(&CurDev->Data);
     SetPort(CurDev->Handle,&CurDev->Data);
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnOpenDeviceClick(TObject *Sender)
{
 // try to open the device attached to USB port
 if (!OpenPort())  {
     ErrorForm->Display("Can't open Device[0]");
     return;
    }
 else  {
     CurDev = &Devices[0];
     UpdateDeviceStatus();
     ShowDeviceName();
     rgPortDirection->ItemIndex=0;  // set to output
     rgPortDirectionClick(NULL);  // set port direction
     SetLEDsState(false);   // turn off all LEDs
     SetLEDEnabled(true);   // enable all checkboxes
     // now write current LED sequence to port
     WriteToPort();
    }
}
//---------------------------------------------------------------------
void __fastcall TfrmMain::ShowDeviceName()
{
 eCmd->Text="?";
 btnH4Click(NULL);
}
//-------------------------------------------
bool __fastcall TfrmMain::OpenPort()
{
 // returns true if open is successful

 FT_HANDLE ftHandle;
 FT_STATUS ftStatus;
 ULONG Status;

 int DevNum = 0;     // only 1 device in this program

 TFtDevice *Dev = &Devices[DevNum];
 if (Dev->IsOpen)
        return false;     // device already open

 ftStatus = FT_Open(DevNum,&ftHandle);
 if (!FT_SUCCESS(ftStatus))
     return false;

 // first set all checkboxes off
 SetLEDsState(false);
    
    Dev->Data.BaudRate = FT_INDEX_BAUD_115200;
    Dev->Data.DataBits = FT_INDEX_DATA_BITS_8;
    Dev->Data.StopBits = FT_INDEX_STOP_BITS_1;
    Dev->Data.Parity = FT_INDEX_PARITY_NONE;
    Dev->Data.FlowControl = FT_INDEX_FLOW_NONE;
    Dev->Data.RtsHi = true;
    Dev->Data.DtrHi = true;
    Dev->Data.Xon = 0x11;
    Dev->Data.Xoff = 0x13;
    Dev->Data.EventChar = 0;
    Dev->Data.ErrorChar = 0;
    Dev->Data.EventCharEnabled = false;
    Dev->Data.ErrorCharEnabled = false;
    Dev->Data.CtsHi = false;
    Dev->Data.DsrHi = false;
    Dev->Data.DcdHi = false;
    Dev->Data.RingHi = false;
    Dev->Data.RxTimeout = FT_DEFAULT_RX_TIMEOUT;
    Dev->Data.TxTimeout = FT_DEFAULT_TX_TIMEOUT;
    Dev->Data.EventMask = 0;

    if (!SetPort(ftHandle,&Dev->Data))
        goto close;

    ftStatus = FT_GetModemStatus(ftHandle,&Status);
    if (!FT_SUCCESS(ftStatus)) {
        goto close;
    }

    if (Status & 0x00000010)
        Dev->Data.CtsHi = true;
    else
        Dev->Data.CtsHi = false;

    if (Status & 0x00000020)
        Dev->Data.DsrHi = true;
    else
        Dev->Data.DsrHi = false;

    Dev->Handle = ftHandle;
    Dev->IsOpen = true;     // signals device is now open
    return true;

close:
    FT_Close(ftHandle);

    return false;
}

//----------------------------------------  SetPort  ----------

bool __fastcall TfrmMain::SetPort(FT_HANDLE ftHandle,TFtConfigData *ftData)

{
    ULONG BaudRate;
    UCHAR WordLength;
    UCHAR StopBits;
    USHORT FlowControl;
    UCHAR XonChar;
    UCHAR XoffChar;
    FT_STATUS ftStatus;

    ftStatus = FT_ResetDevice(ftHandle);
    if (!FT_SUCCESS(ftStatus)) {
        goto close;
    }

    switch (ftData->BaudRate) {
    case 0 :
        BaudRate = 300;
        break;
    case 1 :
        BaudRate = 600;
        break;
    case 2 :
        BaudRate = 1200;
        break;
    case 3 :
        BaudRate = 2400;
        break;
    case 4 :
        BaudRate = 4800;
        break;
    case 5 :
        BaudRate = 9600;
        break;
    case 6 :
        BaudRate = 14400;
        break;
    case 7 :
        BaudRate = 19200;
        break;
    case 8 :
        BaudRate = 38400;
        break;
    case 9 :
        BaudRate = 57600;
        break;
    case 10 :
        BaudRate = 115200;
        break;
    case 11 :
        BaudRate = 230400;
        break;
    case 12 :
        BaudRate = 460800;
        break;
    case 13 :
        BaudRate = 921600;
        break;
    default :
        BaudRate = 115200;
        break;
    }

    ftStatus = FT_SetBaudRate(ftHandle,BaudRate);
    if (!FT_SUCCESS(ftStatus)) {
        goto close;
    }

    WordLength = (UCHAR) (ftData->DataBits + FT_BITS_7);

    switch (ftData->StopBits) {
    default :
        StopBits = FT_STOP_BITS_1;
        break;
    case 1 :
        StopBits = FT_STOP_BITS_2;
        break;
    }

    ftStatus = FT_SetDataCharacteristics(
                    ftHandle,
                    WordLength,
                    StopBits,
                    (UCHAR) ftData->Parity
                    );
    if (!FT_SUCCESS(ftStatus)) {
        goto close;
    }

    FlowControl = FT_FLOW_NONE;
    XonChar = 0;
    XoffChar = 0;

    switch (ftData->FlowControl) {

    case 0 :    // NONE
    default :
        break;

    case 1 :    // RTS
        FlowControl = FT_FLOW_RTS_CTS;
        break;

    case 2 :    // DTR
        FlowControl = FT_FLOW_DTR_DSR;
        break;

    case 3 :    // XON/XOFF
        FlowControl = FT_FLOW_XON_XOFF;
        XonChar = ftData->Xon;
        XoffChar = ftData->Xoff;
        break;

    }

    ftStatus = FT_SetFlowControl(
                    ftHandle,
                    FlowControl,
                    XonChar,
                    XoffChar
                    );
    if (!FT_SUCCESS(ftStatus)) {
        goto close;
    }

    ftStatus = FT_SetChars(
                    ftHandle,
                    ftData->EventChar,
                    ftData->EventCharEnabled ? (UCHAR) 1 : (UCHAR) 0,
                    ftData->ErrorChar,
                    ftData->ErrorCharEnabled ? (UCHAR) 1 : (UCHAR) 0
                    );
    if (!FT_SUCCESS(ftStatus)) {
        goto close;
    }

    FT_SetEventNotification(ftHandle,ftData->EventMask,NULL);

    if (ftData->DtrHi) {
        FT_SetDtr(ftHandle);
    }
    else {
        FT_ClrDtr(ftHandle);
    }

    if (ftData->RtsHi) {
        FT_SetRts(ftHandle);
    }
    else {
        FT_ClrRts(ftHandle);
    }

    FT_SetTimeouts(ftHandle,ftData->RxTimeout,ftData->TxTimeout);

    FT_Purge(ftHandle,FT_PURGE_TX | FT_PURGE_RX);

    return true;

close:

    return false;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::rgPortDirectionClick(TObject *Sender)
{
 ULONG BytesWritten;
 char  buffer[10];

 // write to device depending on ItemIndex
 // if ItemIndex == 0 then output ie !A(0)
 // if ItemIndex == 1 then input  ie !A(255)
 if (!CurDev)
   {
    SetLEDEnabled(false);
    return;  // can't write if not open
   }
 buffer[0] = '!';
 buffer[1] = portID;
 if (rgPortDirection->ItemIndex==0)
   {
    buffer[2] = char(0);  // output
    // now enable all 8 checkboxes
    SetLEDEnabled(true);
   }
 else
   {
    buffer[2] = char(255);  // input
    // now set all 8 checkboxes to Enabled = false
    SetLEDEnabled(false);
   }
 FT_Write(CurDev->Handle,&buffer,3,&BytesWritten);
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::inputTimerTimer(TObject *Sender)
{
 // This keeps looking for signals from the device
 // RxBytes signals how many bytes are ready for receiving
 char buffer[256];
 ULONG BytesWritten;
 ULONG BytesRead;
 DWORD RxBytes = 0;
 DWORD EventDWord = 0;
 DWORD TxBytes = 0;
 DWORD Status = 0;
 int   pins;

 // time to read port and show value in ePortValue and checkboxes
 // ePortValue->Text = "Input Port value is "+IntToStr(portReadValue);
 // check that device is open
 if (!CurDev) return;
 //
 FT_GetStatus(CurDev->Handle,&RxBytes,&TxBytes,&EventDWord);
 FT_GetModemStatus(CurDev->Handle,&Status);
 if (Status & 0x000000010) CurDev->Data.CtsHi = true;
 else                      CurDev->Data.CtsHi = false;
 if (Status & 0x00000020)  CurDev->Data.DsrHi = true;
 else                      CurDev->Data.DsrHi = false;

 while (RxBytes > 0) {
   FT_Read(CurDev->Handle,buffer,RxBytes<256 ? RxBytes : 256,&BytesRead);
   RxBytes -= BytesRead;
   eDeviceName->Text = "'"+(AnsiString)buffer+"'";
   // if you are reading a port value
   if (eCmd->Text=="a" || eCmd->Text=="b" || eCmd->Text=="c") {
       pins = (int)(buffer[0]);   // pins gives the values 0 to 255
       ePortValue->Text = "Port value = "+IntToStr(pins);
   }
   PutStr(buffer,BytesRead);
   Flush();
 }

}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::PutStr(char *s,DWORD length)
{
 // this and Flush are dealing with writing to the mOutput Memo
 char c;
 memoBufferIndex = 0;
 while (length--) {
   c = *s++;
   if (c==13) CurCol = NUMBER_OF_COLUMNS-1;
   else if (c<0x20)  continue;
   else memoBuffer[memoBufferIndex++] = c;
   //
   if (++CurCol == NUMBER_OF_COLUMNS) {
     memoBuffer[memoBufferIndex] = 0;
     mOutput->Text = mOutput->Text + memoBuffer;
     memoBufferIndex = 0;
     ++CurCol;
     mOutput->Lines->Add("");
     mOutput->SelStart = CurRow*NUMBER_OF_COLUMNS + CurCol + 1;
     mOutput->SelLength = 1;
   }

 }
}
//------------------------------------------------------
void __fastcall TfrmMain::Flush()
{
 memoBuffer[memoBufferIndex] = 0;
 mOutput->Text = mOutput->Text + memoBuffer;
 mOutput->SelStart = CurRow*NUMBER_OF_COLUMNS + CurCol + 1;
 mOutput->SelLength = 1;
 memoBufferIndex = 0;
}
//-----------------------------------------------------
void __fastcall TfrmMain::btnH4Click(TObject *Sender)
{
 char buffer[10];
 int  numBytes = 0;

 // send the  command in eCmd if not blank
 // and device open
 if (!CurDev) return;
 if (eCmd->Text.IsEmpty()) return;

 strcpy(buffer,eCmd->Text.c_str());  // copy cmd into buffer
 numBytes = strlen(buffer);  // get the next open position in buffer
 if (!eValue->Text.IsEmpty())
   {
    buffer[numBytes] = char(atoi(eValue->Text.c_str()));
    numBytes++;
   }

 SendToPort(buffer,numBytes);
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::SendToPort(char* buf,int bytes)
{
 ULONG BytesWritten;
 // send the command to the port
 if (!CurDev)
   {
    eCmd->Text = "FAIL";
    return;
   }
  FT_Write(CurDev->Handle,buf,bytes,&BytesWritten);
}
//---------------------------------------------------------------		 //---------------------------------------------------------------------------
#ifndef USBIO24R_Testv1H
#define USBIO24R_Testv1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include "FTD2XX.h"
#include "config.h"
#include "error.h"
#include <jpeg.hpp>
#define  NUMBER_OF_DEVICES 1
#define  NUMBER_OF_COLUMNS 30
#define  NUMBER_OF_ROWS    30
//---------------------------------------------------------------------------
typedef struct _TFtDevice {
  TFtConfigData Data;
  FT_HANDLE     Handle;
  bool          IsOpen;   // flag to signal device has been opened
} TFtDevice;
extern TFtDevice Devices[];
extern TFtDevice *CurDev;
//-------------------------------------------
class TfrmMain : public TForm
{
__published:    // IDE-managed Components
        TPanel *Panel1;
        TCheckBox *cb0;
        TCheckBox *cb1;
        TCheckBox *cb2;
        TCheckBox *cb3;
        TCheckBox *cb4;
        TCheckBox *cb5;
        TCheckBox *cb6;
        TCheckBox *cb7;
        TButton *btnAllOff;
        TButton *btnAllOn;
        TEdit *ePortValue;
        TRadioGroup *rgPortID;
        TRadioGroup *rgPortDirection;
        TButton *btnConfigure;
        TButton *btnOpenDevice;
        TEdit *eDeviceStatus;
        TTimer *inputTimer;
        TEdit *eDeviceName;
        TButton *btnH4;
        TEdit *eCmd;
        TEdit *eValue;
        TLabel *Label1;
        TMemo *Memo1;
        TImage *Image1;
        TMemo *mOutput;
        void __fastcall btnAllOffClick(TObject *Sender);
        void __fastcall btnAllOnClick(TObject *Sender);
        void __fastcall cb0Click(TObject *Sender);
        void __fastcall rgPortIDClick(TObject *Sender);
        void __fastcall btnConfigureClick(TObject *Sender);
        void __fastcall btnOpenDeviceClick(TObject *Sender);
        void __fastcall rgPortDirectionClick(TObject *Sender);
        void __fastcall inputTimerTimer(TObject *Sender);
        void __fastcall btnH4Click(TObject *Sender);
private:    // User declarations
        void __fastcall SetLEDsState(bool state);
        void __fastcall TfrmMain::SetLEDEnabled(bool state);
        bool __fastcall TfrmMain::WriteToPort();
        void __fastcall TfrmMain::WriteQueryNameToPort();
        bool __fastcall TfrmMain::SetupUSBIO24R();
        void __fastcall TfrmMain::CalculatePortValue();
        bool __fastcall TfrmMain::OpenPort();
        bool __fastcall TfrmMain::SetPort(FT_HANDLE ftHandle,TFtConfigData *ftData);
        void __fastcall TfrmMain::SetPortID();
        void __fastcall TfrmMain::UpdateDeviceStatus();
        void __fastcall TfrmMain::SendToPort(char* buf,int bytes);
        void __fastcall TfrmMain::PutStr(char *s,DWORD length);
        void __fastcall TfrmMain::Flush();
        void __fastcall TfrmMain::ShowDeviceName();
        int  CurRow;
        int  CurCol;
        int  memoBufferIndex;
        char memoBuffer[256];
public:        // User declarations
        __fastcall TfrmMain(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TfrmMain *frmMain;
//---------------------------------------------------------------------------
#endif
//-------------  The Configuration cpp and h files --------------------------------
#include <vcl.h>
#pragma hdrstop
#include <stdio.h>
#include "Config.h"
#include "FTD2XX.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TConfigForm *ConfigForm;
//---------------------------------------------------------------------------
__fastcall TConfigForm::TConfigForm(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TConfigForm::Init(TFtConfigData *Data)
{
    BaudRateCB->ItemIndex = Data->BaudRate;
    DataBitsCB->ItemIndex = Data->DataBits;
    StopBitsCB->ItemIndex = Data->StopBits;
    ParityCB->ItemIndex = Data->Parity;
    FlowControlCB->ItemIndex = Data->FlowControl;

    RtsCB->Checked = Data->RtsHi;
    DtrCB->Checked = Data->DtrHi;

    EventCharCB->Checked = Data->EventCharEnabled;
    EventCharME->Enabled = EventCharCB->Checked;
    EventCharLabel->Enabled = EventCharCB->Checked;

    ErrorCharCB->Checked = Data->ErrorCharEnabled;
    ErrorCharME->Enabled = ErrorCharCB->Checked;
    ErrorCharLabel->Enabled = ErrorCharCB->Checked;

    char Buf[16];

    wsprintf(Buf,"%02.2X",Data->Xon);
    XonME->Text = Buf;

    wsprintf(Buf,"%02.2X",Data->Xoff);
    XoffME->Text = Buf;

    wsprintf(Buf,"%02.2X",Data->EventChar);
    EventCharME->Text = Buf;

    wsprintf(Buf,"%02.2X",Data->ErrorChar);
    ErrorCharME->Text = Buf;

    wsprintf(Buf,"%d",Data->RxTimeout);
    RxTimeoutME->Text = Buf;

    wsprintf(Buf,"%d",Data->TxTimeout);
    TxTimeoutME->Text = Buf;

    RxCharCB->Checked = Data->EventMask & FT_EVENT_RXCHAR;
    ModemStatCB->Checked = Data->EventMask & FT_EVENT_MODEM_STATUS;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TConfigForm::Get(TFtConfigData *Data)
{
    Data->BaudRate = BaudRateCB->ItemIndex;
    Data->DataBits = DataBitsCB->ItemIndex;
    Data->StopBits = StopBitsCB->ItemIndex;
    Data->Parity = ParityCB->ItemIndex;
    Data->FlowControl = FlowControlCB->ItemIndex;

    Data->RtsHi = RtsCB->Checked;
    Data->DtrHi = DtrCB->Checked;

    Data->EventCharEnabled = EventCharCB->Checked;
    Data->ErrorCharEnabled = ErrorCharCB->Checked;

    int c;

    sscanf(EventCharME->Text.c_str(),"%x",&c);
    Data->EventChar = (UCHAR) c;

    sscanf(ErrorCharME->Text.c_str(),"%x",&c);
    Data->ErrorChar = (UCHAR) c;

    DWORD dw;

    sscanf(RxTimeoutME->Text.c_str(),"%d",&dw);
    Data->RxTimeout = dw;

    sscanf(TxTimeoutME->Text.c_str(),"%d",&dw);
    Data->TxTimeout = dw;

    dw = 0;

    if (RxCharCB->Checked)
        dw |= FT_EVENT_RXCHAR;

    if (ModemStatCB->Checked)
        dw |= FT_EVENT_MODEM_STATUS;

    Data->EventMask = dw;
}
//---------------------------------------------------------------------------
void __fastcall TConfigForm::EventCharCBClick(TObject *Sender)
{
    EventCharME->Enabled = EventCharCB->Checked;
    EventCharLabel->Enabled = EventCharCB->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TConfigForm::ErrorCharCBClick(TObject *Sender)
{
    ErrorCharME->Enabled = ErrorCharCB->Checked;
    ErrorCharLabel->Enabled = ErrorCharCB->Checked;
}
//---------------------------------------------------------------------------
 //---------------------------------------------------------------------------
#ifndef ConfigH
#define ConfigH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Mask.hpp>
//---------------------------------------------------------------------------
typedef struct _TFtConfigData {
    int BaudRate;
    int DataBits;
    int StopBits;
    int Parity;
    int FlowControl;
    UCHAR Xon;
    UCHAR Xoff;
    UCHAR EventChar;
    UCHAR ErrorChar;
    BOOL EventCharEnabled;
    BOOL ErrorCharEnabled;
    BOOL RtsHi;
    BOOL DtrHi;
    BOOL CtsHi;
    BOOL DsrHi;
    BOOL DcdHi;
    BOOL RingHi;
    DWORD RxTimeout;
    DWORD TxTimeout;
    DWORD EventMask;
} TFtConfigData;
//---------------------------------------------------------------------------
enum {
    FT_INDEX_BAUD_300 = 0,
    FT_INDEX_BAUD_600,
    FT_INDEX_BAUD_1200,
    FT_INDEX_BAUD_2400,
    FT_INDEX_BAUD_4800,
    FT_INDEX_BAUD_9600,
    FT_INDEX_BAUD_14400,
    FT_INDEX_BAUD_19200,
    FT_INDEX_BAUD_38400,
    FT_INDEX_BAUD_57600,
    FT_INDEX_BAUD_115200,
    FT_INDEX_BAUD_230400,
    FT_INDEX_BAUD_460800,
    FT_INDEX_BAUD_921600,

    FT_INDEX_DATA_BITS_7 = 0,
    FT_INDEX_DATA_BITS_8,

    FT_INDEX_STOP_BITS_1 = 0,
    FT_INDEX_STOP_BITS_2,

    FT_INDEX_PARITY_NONE = 0,
    FT_INDEX_PARITY_ODD,
    FT_INDEX_PARITY_EVEN,
    FT_INDEX_PARITY_MARK,
    FT_INDEX_PARITY_SPACE,

    FT_INDEX_FLOW_NONE = 0,
    FT_INDEX_FLOW_RTS_CTS,
    FT_INDEX_FLOW_DTR_DSR,
    FT_INDEX_FLOW_XON_XOFF
};

//---------------------------------------------------------------------------
class TConfigForm : public TForm
{
__published:    // IDE-managed Components
    TGroupBox *OptionsGB;
    TComboBox *BaudRateCB;
    TComboBox *DataBitsCB;
    TComboBox *StopBitsCB;
    TComboBox *ParityCB;
    TLabel *Label1;
    TLabel *Label2;
    TLabel *Label3;
    TLabel *Label4;
    TGroupBox *FlowControlGB;
    TComboBox *FlowControlCB;
    TLabel *Label5;
    TCheckBox *RtsCB;
    TCheckBox *DtrCB;
    TGroupBox *SpecialCharsCB;
    TMaskEdit *XonME;
    TMaskEdit *XoffME;
    TLabel *Label6;
    TLabel *Label7;
    TMaskEdit *EventCharME;
    TMaskEdit *ErrorCharME;
    TLabel *EventCharLabel;
    TLabel *ErrorCharLabel;
    TCheckBox *EventCharCB;
    TCheckBox *ErrorCharCB;
    TButton *Button1;
    TButton *Button2;
    TGroupBox *TimeoutsGB;
    TMaskEdit *RxTimeoutME;
    TMaskEdit *TxTimeoutME;
    TLabel *Label8;
    TLabel *Label9;
    TGroupBox *EventsGB;
    TCheckBox *RxCharCB;
    TCheckBox *ModemStatCB;
    void __fastcall EventCharCBClick(TObject *Sender);
    void __fastcall ErrorCharCBClick(TObject *Sender);
private:    // User declarations
public:        // User declarations
    __fastcall TConfigForm(TComponent* Owner);
    void __fastcall Init(TFtConfigData *Data);
    void __fastcall Get(TFtConfigData *Data);
};
//---------------------------------------------------------------------------
extern PACKAGE TConfigForm *ConfigForm;
//---------------------------------------------------------------------------
#endif
/*++
Copyright (c) 2001-2005  Future Technology Devices International Ltd.
Module Name:    ftd2xx.h
Abstract:
    Native USB device driver for FTDI FT8U232/245
    FTD2XX library definitions
Environment:    kernel & user mode
Revision History:
    13/03/01    awm     Created.
    13/01/03    awm        Added device information support.
    19/03/03    awm        Added FT_W32_CancelIo.
    12/06/03    awm        Added FT_StopInTask and FT_RestartInTask.
    18/09/03    awm        Added FT_SetResetPipeRetryCount.
    10/10/03    awm        Added FT_ResetPort.
    23/01/04    awm        Added support for open-by-location.
    16/03/04    awm        Added support for FT2232C.
    23/09/04    awm        Added support for FT232R.
    20/10/04    awm        Added FT_CyclePort.
    18/01/05    awm        Added FT_DEVICE_LIST_INFO_NODE type.
    11/02/05    awm        Added LocId to FT_DEVICE_LIST_INFO_NODE.
    25/08/05    awm        Added FT_SetDeadmanTimeout.
    02/12/05    awm        Removed obsolete references.
    05/12/05    awm        Added FT_GetVersion, FT_GetVersionEx.
  --*/
#ifndef FTD2XX_H
#define FTD2XX_H
// The following ifdef block is the standard way of creating macros
// which make exporting from a DLL simpler.  All files within this DLL
// are compiled with the FTD2XX_EXPORTS symbol defined on the command line.
// This symbol should not be defined on any project that uses this DLL.
// This way any other project whose source files include this file see
// FTD2XX_API functions as being imported from a DLL, whereas this DLL
// sees symbols defined with this macro as being exported.

#ifdef FTD2XX_EXPORTS
#define FTD2XX_API __declspec(dllexport)
#else
#define FTD2XX_API __declspec(dllimport)
#endif
typedef PVOID    FT_HANDLE;
typedef ULONG    FT_STATUS;
//
// Device status
//
enum {
    FT_OK,
    FT_INVALID_HANDLE,
    FT_DEVICE_NOT_FOUND,
    FT_DEVICE_NOT_OPENED,
    FT_IO_ERROR,
    FT_INSUFFICIENT_RESOURCES,
    FT_INVALID_PARAMETER,
    FT_INVALID_BAUD_RATE,

    FT_DEVICE_NOT_OPENED_FOR_ERASE,
    FT_DEVICE_NOT_OPENED_FOR_WRITE,
    FT_FAILED_TO_WRITE_DEVICE,
    FT_EEPROM_READ_FAILED,
    FT_EEPROM_WRITE_FAILED,
    FT_EEPROM_ERASE_FAILED,
    FT_EEPROM_NOT_PRESENT,
    FT_EEPROM_NOT_PROGRAMMED,
    FT_INVALID_ARGS,
    FT_NOT_SUPPORTED,
    FT_OTHER_ERROR
};
#define FT_SUCCESS(status) ((status) == FT_OK)
//
// FT_OpenEx Flags
//
#define FT_OPEN_BY_SERIAL_NUMBER    1
#define FT_OPEN_BY_DESCRIPTION      2
#define FT_OPEN_BY_LOCATION            4
//
// FT_ListDevices Flags (used in conjunction with FT_OpenEx Flags
//
#define FT_LIST_NUMBER_ONLY            0x80000000
#define FT_LIST_BY_INDEX            0x40000000
#define FT_LIST_ALL                    0x20000000
#define FT_LIST_MASK (FT_LIST_NUMBER_ONLY|FT_LIST_BY_INDEX|FT_LIST_ALL)
//
// Baud Rates
//
#define FT_BAUD_300            300
#define FT_BAUD_600            600
#define FT_BAUD_1200        1200
#define FT_BAUD_2400        2400
#define FT_BAUD_4800        4800
#define FT_BAUD_9600        9600
#define FT_BAUD_14400        14400
#define FT_BAUD_19200        19200
#define FT_BAUD_38400        38400
#define FT_BAUD_57600        57600
#define FT_BAUD_115200        115200
#define FT_BAUD_230400        230400
#define FT_BAUD_460800        460800
#define FT_BAUD_921600        921600
//
// Word Lengths
//
#define FT_BITS_8            (UCHAR) 8
#define FT_BITS_7            (UCHAR) 7
#define FT_BITS_6            (UCHAR) 6
#define FT_BITS_5            (UCHAR) 5
//
// Stop Bits
//
#define FT_STOP_BITS_1        (UCHAR) 0
#define FT_STOP_BITS_1_5    (UCHAR) 1
#define FT_STOP_BITS_2        (UCHAR) 2
//
// Parity
//
#define FT_PARITY_NONE        (UCHAR) 0
#define FT_PARITY_ODD        (UCHAR) 1
#define FT_PARITY_EVEN        (UCHAR) 2
#define FT_PARITY_MARK        (UCHAR) 3
#define FT_PARITY_SPACE        (UCHAR) 4
//
// Flow Control
//
#define FT_FLOW_NONE        0x0000
#define FT_FLOW_RTS_CTS     0x0100
#define FT_FLOW_DTR_DSR     0x0200
#define FT_FLOW_XON_XOFF    0x0400
//
// Purge rx and tx buffers
//
#define FT_PURGE_RX         1
#define FT_PURGE_TX         2
//
// Events
//
typedef void (*PFT_EVENT_HANDLER)(DWORD,DWORD);
#define FT_EVENT_RXCHAR            1
#define FT_EVENT_MODEM_STATUS   2
//
// Timeouts
//
#define FT_DEFAULT_RX_TIMEOUT   300
#define FT_DEFAULT_TX_TIMEOUT   300
//
// Device types
//
typedef ULONG    FT_DEVICE;
enum {
    FT_DEVICE_BM,
    FT_DEVICE_AM,
    FT_DEVICE_100AX,
    FT_DEVICE_UNKNOWN,
    FT_DEVICE_2232C,
    FT_DEVICE_232R
};
#ifdef __cplusplus
extern "C" {
#endif
FTD2XX_API
FT_STATUS WINAPI FT_Open(
    int deviceNumber,
    FT_HANDLE *pHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_OpenEx(
    PVOID pArg1,
    DWORD Flags,
    FT_HANDLE *pHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_ListDevices(
    PVOID pArg1,
    PVOID pArg2,
    DWORD Flags
    );

FTD2XX_API
FT_STATUS WINAPI FT_Close(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_Read(
    FT_HANDLE ftHandle,
    LPVOID lpBuffer,
    DWORD nBufferSize,
    LPDWORD lpBytesReturned
    );

FTD2XX_API
FT_STATUS WINAPI FT_Write(
    FT_HANDLE ftHandle,
    LPVOID lpBuffer,
    DWORD nBufferSize,
    LPDWORD lpBytesWritten
    );

FTD2XX_API
FT_STATUS WINAPI FT_IoCtl(
    FT_HANDLE ftHandle,
    DWORD dwIoControlCode,
    LPVOID lpInBuf,
    DWORD nInBufSize,
    LPVOID lpOutBuf,
    DWORD nOutBufSize,
    LPDWORD lpBytesReturned,
    LPOVERLAPPED lpOverlapped
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetBaudRate(
    FT_HANDLE ftHandle,
    ULONG BaudRate
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetDivisor(
    FT_HANDLE ftHandle,
    USHORT Divisor
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetDataCharacteristics(
    FT_HANDLE ftHandle,
    UCHAR WordLength,
    UCHAR StopBits,
    UCHAR Parity
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetFlowControl(
    FT_HANDLE ftHandle,
    USHORT FlowControl,
    UCHAR XonChar,
    UCHAR XoffChar
    );

FTD2XX_API
FT_STATUS WINAPI FT_ResetDevice(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetDtr(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_ClrDtr(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetRts(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_ClrRts(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetModemStatus(
    FT_HANDLE ftHandle,
    ULONG *pModemStatus
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetChars(
    FT_HANDLE ftHandle,
    UCHAR EventChar,
    UCHAR EventCharEnabled,
    UCHAR ErrorChar,
    UCHAR ErrorCharEnabled
    );

FTD2XX_API
FT_STATUS WINAPI FT_Purge(
    FT_HANDLE ftHandle,
    ULONG Mask
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetTimeouts(
    FT_HANDLE ftHandle,
    ULONG ReadTimeout,
    ULONG WriteTimeout
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetQueueStatus(
    FT_HANDLE ftHandle,
    DWORD *dwRxBytes
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetEventNotification(
    FT_HANDLE ftHandle,
    DWORD Mask,
    PVOID Param
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetStatus(
    FT_HANDLE ftHandle,
    DWORD *dwRxBytes,
    DWORD *dwTxBytes,
    DWORD *dwEventDWord
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetBreakOn(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetBreakOff(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetWaitMask(
    FT_HANDLE ftHandle,
    DWORD Mask
    );

FTD2XX_API
FT_STATUS WINAPI FT_WaitOnMask(
    FT_HANDLE ftHandle,
    DWORD *Mask
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetEventStatus(
    FT_HANDLE ftHandle,
    DWORD *dwEventDWord
    );

FTD2XX_API
FT_STATUS WINAPI FT_ReadEE(
    FT_HANDLE ftHandle,
    DWORD dwWordOffset,
    LPWORD lpwValue
    );

FTD2XX_API
FT_STATUS WINAPI FT_WriteEE(
    FT_HANDLE ftHandle,
    DWORD dwWordOffset,
    WORD wValue
    );

FTD2XX_API
FT_STATUS WINAPI FT_EraseEE(
    FT_HANDLE ftHandle
    );

//
// structure to hold program data for FT_Program function
//
typedef struct ft_program_data {

    DWORD Signature1;            // Header - must be 0x00000000
    DWORD Signature2;            // Header - must be 0xffffffff
    DWORD Version;                // Header - FT_PROGRAM_DATA version
                                //          0 = original
                                //          1 = FT2232C extensions
                                //            2 = FT232R extensions

    WORD VendorId;                // 0x0403
    WORD ProductId;                // 0x6001
    char *Manufacturer;            // "FTDI"
    char *ManufacturerId;        // "FT"
    char *Description;            // "USB HS Serial Converter"
    char *SerialNumber;            // "FT000001" if fixed, or NULL
    WORD MaxPower;                // 0 < MaxPower <= 500
    WORD PnP;                    // 0 = disabled, 1 = enabled
    WORD SelfPowered;            // 0 = bus powered, 1 = self powered
    WORD RemoteWakeup;            // 0 = not capable, 1 = capable
    //
    // Rev4 extensions
    //
    UCHAR Rev4;                    // non-zero if Rev4 chip, zero otherwise
    UCHAR IsoIn;                // non-zero if in endpoint is isochronous
    UCHAR IsoOut;                // non-zero if out endpoint is isochronous
    UCHAR PullDownEnable;        // non-zero if pull down enabled
    UCHAR SerNumEnable;            // non-zero if serial number to be used
    UCHAR USBVersionEnable;        // non-zero if chip uses USBVersion
    WORD USBVersion;            // BCD (0x0200 => USB2)
    //
    // FT2232C extensions
    //
    UCHAR Rev5;                    // non-zero if Rev5 chip, zero otherwise
    UCHAR IsoInA;                // non-zero if in endpoint is isochronous
    UCHAR IsoInB;                // non-zero if in endpoint is isochronous
    UCHAR IsoOutA;                // non-zero if out endpoint is isochronous
    UCHAR IsoOutB;                // non-zero if out endpoint is isochronous
    UCHAR PullDownEnable5;        // non-zero if pull down enabled
    UCHAR SerNumEnable5;        // non-zero if serial number to be used
    UCHAR USBVersionEnable5;    // non-zero if chip uses USBVersion
    WORD USBVersion5;            // BCD (0x0200 => USB2)
    UCHAR AIsHighCurrent;        // non-zero if interface is high current
    UCHAR BIsHighCurrent;        // non-zero if interface is high current
    UCHAR IFAIsFifo;            // non-zero if interface is 245 FIFO
    UCHAR IFAIsFifoTar;            // non-zero if interface is 245 FIFO CPU target
    UCHAR IFAIsFastSer;            // non-zero if interface is Fast serial
    UCHAR AIsVCP;                // non-zero if interface is to use VCP drivers
    UCHAR IFBIsFifo;            // non-zero if interface is 245 FIFO
    UCHAR IFBIsFifoTar;            // non-zero if interface is 245 FIFO CPU target
    UCHAR IFBIsFastSer;            // non-zero if interface is Fast serial
    UCHAR BIsVCP;                // non-zero if interface is to use VCP drivers
    //
    // FT232R extensions
    //
    UCHAR UseExtOsc;            // Use External Oscillator
    UCHAR HighDriveIOs;            // High Drive I/Os
    UCHAR EndpointSize;            // Endpoint size

    UCHAR PullDownEnableR;        // non-zero if pull down enabled
    UCHAR SerNumEnableR;        // non-zero if serial number to be used

    UCHAR InvertTXD;            // non-zero if invert TXD
    UCHAR InvertRXD;            // non-zero if invert RXD
    UCHAR InvertRTS;            // non-zero if invert RTS
    UCHAR InvertCTS;            // non-zero if invert CTS
    UCHAR InvertDTR;            // non-zero if invert DTR
    UCHAR InvertDSR;            // non-zero if invert DSR
    UCHAR InvertDCD;            // non-zero if invert DCD
    UCHAR InvertRI;                // non-zero if invert RI

    UCHAR Cbus0;                // Cbus Mux control
    UCHAR Cbus1;                // Cbus Mux control
    UCHAR Cbus2;                // Cbus Mux control
    UCHAR Cbus3;                // Cbus Mux control
    UCHAR Cbus4;                // Cbus Mux control

    UCHAR RIsVCP;                // non-zero if using VCP drivers

} FT_PROGRAM_DATA, *PFT_PROGRAM_DATA;

FTD2XX_API
FT_STATUS WINAPI FT_EE_Program(
    FT_HANDLE ftHandle,
    PFT_PROGRAM_DATA pData
    );

FTD2XX_API
FT_STATUS WINAPI FT_EE_ProgramEx(
    FT_HANDLE ftHandle,
    PFT_PROGRAM_DATA pData,
    char *Manufacturer,
    char *ManufacturerId,
    char *Description,
    char *SerialNumber
    );

FTD2XX_API
FT_STATUS WINAPI FT_EE_Read(
    FT_HANDLE ftHandle,
    PFT_PROGRAM_DATA pData
    );

FTD2XX_API
FT_STATUS WINAPI FT_EE_ReadEx(
    FT_HANDLE ftHandle,
    PFT_PROGRAM_DATA pData,
    char *Manufacturer,
    char *ManufacturerId,
    char *Description,
    char *SerialNumber
    );

FTD2XX_API
FT_STATUS WINAPI FT_EE_UASize(
    FT_HANDLE ftHandle,
    LPDWORD lpdwSize
    );

FTD2XX_API
FT_STATUS WINAPI FT_EE_UAWrite(
    FT_HANDLE ftHandle,
    PUCHAR pucData,
    DWORD dwDataLen
    );

FTD2XX_API
FT_STATUS WINAPI FT_EE_UARead(
    FT_HANDLE ftHandle,
    PUCHAR pucData,
    DWORD dwDataLen,
    LPDWORD lpdwBytesRead
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetLatencyTimer(
    FT_HANDLE ftHandle,
    UCHAR ucLatency
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetLatencyTimer(
    FT_HANDLE ftHandle,
    PUCHAR pucLatency
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetBitMode(
    FT_HANDLE ftHandle,
    UCHAR ucMask,
    UCHAR ucEnable
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetBitMode(
    FT_HANDLE ftHandle,
    PUCHAR pucMode
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetUSBParameters(
    FT_HANDLE ftHandle,
    ULONG ulInTransferSize,
    ULONG ulOutTransferSize
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetDeadmanTimeout(
    FT_HANDLE ftHandle,
    ULONG ulDeadmanTimeout
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetDeviceInfo(
    FT_HANDLE ftHandle,
    FT_DEVICE *lpftDevice,
    LPDWORD lpdwID,
    PCHAR SerialNumber,
    PCHAR Description,
    LPVOID Dummy
    );

FTD2XX_API
FT_STATUS WINAPI FT_StopInTask(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_RestartInTask(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_SetResetPipeRetryCount(
    FT_HANDLE ftHandle,
    DWORD dwCount
    );

FTD2XX_API
FT_STATUS WINAPI FT_ResetPort(
    FT_HANDLE ftHandle
    );

FTD2XX_API
FT_STATUS WINAPI FT_CyclePort(
    FT_HANDLE ftHandle
    );
//
// Win32-type functions
//
FTD2XX_API
FT_HANDLE WINAPI FT_W32_CreateFile(
    LPCSTR                    lpszName,
    DWORD                    dwAccess,
    DWORD                    dwShareMode,
    LPSECURITY_ATTRIBUTES    lpSecurityAttributes,
    DWORD                    dwCreate,
    DWORD                    dwAttrsAndFlags,
    HANDLE                    hTemplate
    );

FTD2XX_API
BOOL WINAPI FT_W32_CloseHandle(
    FT_HANDLE ftHandle
    );

FTD2XX_API
BOOL WINAPI FT_W32_ReadFile(
    FT_HANDLE ftHandle,
    LPVOID lpBuffer,
    DWORD nBufferSize,
    LPDWORD lpBytesReturned,
    LPOVERLAPPED lpOverlapped
    );

FTD2XX_API
BOOL WINAPI FT_W32_WriteFile(
    FT_HANDLE ftHandle,
    LPVOID lpBuffer,
    DWORD nBufferSize,
    LPDWORD lpBytesWritten,
    LPOVERLAPPED lpOverlapped
    );

FTD2XX_API
DWORD WINAPI FT_W32_GetLastError(
    FT_HANDLE ftHandle
    );

FTD2XX_API
BOOL WINAPI FT_W32_GetOverlappedResult(
    FT_HANDLE ftHandle,
    LPOVERLAPPED lpOverlapped,
    LPDWORD lpdwBytesTransferred,
    BOOL bWait
    );

FTD2XX_API
BOOL WINAPI FT_W32_CancelIo(
    FT_HANDLE ftHandle
    );
//
// Win32 COMM API type functions
//
typedef struct _FTCOMSTAT {
    DWORD fCtsHold : 1;
    DWORD fDsrHold : 1;
    DWORD fRlsdHold : 1;
    DWORD fXoffHold : 1;
    DWORD fXoffSent : 1;
    DWORD fEof : 1;
    DWORD fTxim : 1;
    DWORD fReserved : 25;
    DWORD cbInQue;
    DWORD cbOutQue;
} FTCOMSTAT, *LPFTCOMSTAT;

typedef struct _FTDCB {
    DWORD DCBlength;      /* sizeof(FTDCB)                   */
    DWORD BaudRate;       /* Baudrate at which running       */
    DWORD fBinary: 1;     /* Binary Mode (skip EOF check)    */
    DWORD fParity: 1;     /* Enable parity checking          */
    DWORD fOutxCtsFlow:1; /* CTS handshaking on output       */
    DWORD fOutxDsrFlow:1; /* DSR handshaking on output       */
    DWORD fDtrControl:2;  /* DTR Flow control                */
    DWORD fDsrSensitivity:1; /* DSR Sensitivity              */
    DWORD fTXContinueOnXoff: 1; /* Continue TX when Xoff sent */
    DWORD fOutX: 1;       /* Enable output X-ON/X-OFF        */
    DWORD fInX: 1;        /* Enable input X-ON/X-OFF         */
    DWORD fErrorChar: 1;  /* Enable Err Replacement          */
    DWORD fNull: 1;       /* Enable Null stripping           */
    DWORD fRtsControl:2;  /* Rts Flow control                */
    DWORD fAbortOnError:1; /* Abort all reads and writes on Error */
    DWORD fDummy2:17;     /* Reserved                        */
    WORD wReserved;       /* Not currently used              */
    WORD XonLim;          /* Transmit X-ON threshold         */
    WORD XoffLim;         /* Transmit X-OFF threshold        */
    BYTE ByteSize;        /* Number of bits/byte, 4-8        */
    BYTE Parity;          /* 0-4=None,Odd,Even,Mark,Space    */
    BYTE StopBits;        /* 0,1,2 = 1, 1.5, 2               */
    char XonChar;         /* Tx and Rx X-ON character        */
    char XoffChar;        /* Tx and Rx X-OFF character       */
    char ErrorChar;       /* Error replacement char          */
    char EofChar;         /* End of Input character          */
    char EvtChar;         /* Received Event character        */
    WORD wReserved1;      /* Fill for now.                   */
} FTDCB, *LPFTDCB;

typedef struct _FTTIMEOUTS {
    DWORD ReadIntervalTimeout;          /* Maximum time between read chars. */
    DWORD ReadTotalTimeoutMultiplier;   /* Multiplier of characters.        */
    DWORD ReadTotalTimeoutConstant;     /* Constant in milliseconds.        */
    DWORD WriteTotalTimeoutMultiplier;  /* Multiplier of characters.        */
    DWORD WriteTotalTimeoutConstant;    /* Constant in milliseconds.        */
} FTTIMEOUTS,*LPFTTIMEOUTS;

FTD2XX_API
BOOL WINAPI FT_W32_ClearCommBreak(
    FT_HANDLE ftHandle
    );

FTD2XX_API
BOOL WINAPI FT_W32_ClearCommError(
    FT_HANDLE ftHandle,
    LPDWORD lpdwErrors,
    LPFTCOMSTAT lpftComstat
    );

FTD2XX_API
BOOL WINAPI FT_W32_EscapeCommFunction(
    FT_HANDLE ftHandle,
    DWORD dwFunc
    );

FTD2XX_API
BOOL WINAPI FT_W32_GetCommModemStatus(
    FT_HANDLE ftHandle,
    LPDWORD lpdwModemStatus
    );

FTD2XX_API
BOOL WINAPI FT_W32_GetCommState(
    FT_HANDLE ftHandle,
    LPFTDCB lpftDcb
    );

FTD2XX_API
BOOL WINAPI FT_W32_GetCommTimeouts(
    FT_HANDLE ftHandle,
    FTTIMEOUTS *pTimeouts
    );

FTD2XX_API
BOOL WINAPI FT_W32_PurgeComm(
    FT_HANDLE ftHandle,
    DWORD dwMask
    );

FTD2XX_API
BOOL WINAPI FT_W32_SetCommBreak(
    FT_HANDLE ftHandle
    );

FTD2XX_API
BOOL WINAPI FT_W32_SetCommMask(
    FT_HANDLE ftHandle,
    ULONG ulEventMask
    );

FTD2XX_API
BOOL WINAPI FT_W32_SetCommState(
    FT_HANDLE ftHandle,
    LPFTDCB lpftDcb
    );

FTD2XX_API
BOOL WINAPI FT_W32_SetCommTimeouts(
    FT_HANDLE ftHandle,
    FTTIMEOUTS *pTimeouts
    );

FTD2XX_API
BOOL WINAPI FT_W32_SetupComm(
    FT_HANDLE ftHandle,
    DWORD dwReadBufferSize,
    DWORD dwWriteBufferSize
    );

FTD2XX_API
BOOL WINAPI FT_W32_WaitCommEvent(
    FT_HANDLE ftHandle,
    PULONG pulEvent,
    LPOVERLAPPED lpOverlapped
    );
//
// Device information
//
typedef struct _ft_device_list_info_node {
    ULONG Flags;
    ULONG Type;
    ULONG ID;
    DWORD LocId;
    char SerialNumber[16];
    char Description[64];
    FT_HANDLE ftHandle;
} FT_DEVICE_LIST_INFO_NODE;

FTD2XX_API
FT_STATUS WINAPI FT_CreateDeviceInfoList(
    LPDWORD lpdwNumDevs
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetDeviceInfoList(
    FT_DEVICE_LIST_INFO_NODE *pDest,
    LPDWORD lpdwNumDevs
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetDeviceInfoDetail(
    DWORD dwIndex,
    LPDWORD lpdwFlags,
    LPDWORD lpdwType,
    LPDWORD lpdwID,
    LPDWORD lpdwLocId,
    LPVOID lpSerialNumber,
    LPVOID lpDescription,
    FT_HANDLE *pftHandle
    );
//
// Version information
//
FTD2XX_API
FT_STATUS WINAPI FT_GetDriverVersion(
    FT_HANDLE ftHandle,
    LPDWORD lpdwVersion
    );

FTD2XX_API
FT_STATUS WINAPI FT_GetLibraryVersion(
    LPDWORD lpdwVersion
    );
#ifdef __cplusplus
}
#endif
#endif  /* FTD2XX_H */
 This is the header file that connects into the FTD2XX library file.
 

How the program works ...

OpenPort()      FT_Open     SetPort     FT_GetModemStatus    FT_Close  
Set Port A to output    FT_Write    
You need to instantiate a 'Device'
that contains the necessary data to configure the connection , and a handle to the connection.  When you first run the program you make a TFtDevice object.  At this point the connection is NOT opened.  So the first task is to try and open a connection....

 if (!OpenPort())  {
     ErrorForm->Display("Can't open Device[0]");
     return;
    }

where OpenPort() should be used as is ...

bool __fastcall TfrmMain::OpenPort()

{
 // returns true if open is successful
 FT_HANDLE ftHandle;
 FT_STATUS ftStatus;
 ULONG Status;
 int DevNum = 0;     // only 1 device in this program
 TFtDevice *Dev = &Devices[DevNum];
 if (Dev->IsOpen)
        return false;     // device already open

 ftStatus = FT_Open(DevNum,&ftHandle);  // where Handle defined

 if (!FT_SUCCESS(ftStatus))
     return false;
// define the initial connection protocol    
    Dev->Data.BaudRate = FT_INDEX_BAUD_115200;
    Dev->Data.DataBits = FT_INDEX_DATA_BITS_8;
    Dev->Data.StopBits = FT_INDEX_STOP_BITS_1;
    Dev->Data.Parity = FT_INDEX_PARITY_NONE;
    Dev->Data.FlowControl = FT_INDEX_FLOW_NONE;
    Dev->Data.RtsHi = true;
    Dev->Data.DtrHi = true;
    Dev->Data.Xon = 0x11;
    Dev->Data.Xoff = 0x13;
    Dev->Data.EventChar = 0;
    Dev->Data.ErrorChar = 0;
    Dev->Data.EventCharEnabled = false;
    Dev->Data.ErrorCharEnabled = false;
    Dev->Data.CtsHi = false;
    Dev->Data.DsrHi = false;
    Dev->Data.DcdHi = false;
    Dev->Data.RingHi = false;
    Dev->Data.RxTimeout = FT_DEFAULT_RX_TIMEOUT;
    Dev->Data.TxTimeout = FT_DEFAULT_TX_TIMEOUT;
    Dev->Data.EventMask = 0;

  // now try and set the port's connection protocol to above setup

    if (!SetPort(ftHandle,&Dev->Data))

        goto close;
  // and check the modem status

    ftStatus = FT_GetModemStatus(ftHandle,&Status);

    if (!FT_SUCCESS(ftStatus)) {
        goto close;
    }
    if (Status & 0x00000010)     Dev->Data.CtsHi = true;
    else        Dev->Data.CtsHi = false;
    if (Status & 0x00000020)     Dev->Data.DsrHi = true;
    else        Dev->Data.DsrHi = false;
    Dev->Handle = ftHandle;
    Dev->IsOpen = true;     // signals device is now open
    return true;

close:   // error state

    FT_Close(ftHandle);

    return false;
}

So now you have a Device, opened it, and set it's connection protocol to a default set.  A failure is signaled by the return of a bool false.

Set Port A to all output or input

The command is  !A0 or !A255  where the 0 or 255 is the 1 byte ASCII
void __fastcall TfrmMain::rgPortDirectionClick(TObject *Sender)
{
 ULONG BytesWritten;
 char  buffer[10];

 // write to device depending on ItemIndex
 // if ItemIndex == 0 then output ie !A(0)
 // if ItemIndex == 1 then input  ie !A(255)
 if (!CurDev)   // CurDev is a pointer to the TFtDevice object
   {
    SetLEDEnabled(false);
    return;  // can't write if not open
   }
 buffer[0] = '!';
 buffer[1] = portID;   // eg  !A
 if (rgPortDirection->ItemIndex==0)
   {
    buffer[2] = char(0);  // output   !A0
    SetLEDEnabled(true);
   }
 else
   {
    buffer[2] = char(255);  // all 8 pins as  input
    SetLEDEnabled(false);
   }

 FT_Write(CurDev->Handle,&buffer,3,&BytesWritten);

}

The key is to encode the third byte as ASCII.  You can also set individual bits to input and others as outputs. eg first 4 to input and last 4 as output would encode to !A char(15).

Now to switch a pin high you write  Hchar(Pin number) or Lchar(Pin number) to turn it off.  You can also write to the whole port eg  Achar(255) would turn all pins ON.  Achar(128) would turn on Pin 7 only.		typedef struct _TFtDevice {
    TFtConfigData Data;
    FT_HANDLE     Handle;
    bool          IsOpen;   // flag to signal device has been opened
} TFtDevice;

where Data is another structure ...
typedef struct _TFtConfigData {
    int BaudRate;
    int DataBits;
    int StopBits;
    int Parity;
    int FlowControl;
    UCHAR Xon;
    UCHAR Xoff;
    UCHAR EventChar;
    UCHAR ErrorChar;
    BOOL EventCharEnabled;
    BOOL ErrorCharEnabled;
    BOOL RtsHi;
    BOOL DtrHi;
    BOOL CtsHi;
    BOOL DsrHi;
    BOOL DcdHi;
    BOOL RingHi;
    DWORD RxTimeout;
    DWORD TxTimeout;
    DWORD EventMask;
} TFtConfigData;

Reading a Port Value