FT_STATUS FT_SetVIDPID (DWORD dwVID, DWORD dwPID);

FT_STATUS FT_GetVIDPID (DWORD * pdwVID, DWORD * pdwPID);

FT_STATUS FT_CreateDeviceInfoList (LPDWORD lpdwNumDevs);

FT_STATUS ftStatus;
DWORD numDevs;
 

// Создание device information list:
ftStatus = FT_CreateDeviceInfoList(&numDevs);

if (ftStatus == FT_OK)
{
   printf("Количество устройств %d\n", numDevs);
}

else
{
   // Ошибка вызова FT_CreateDeviceInfoList
}

FT_STATUS FT_GetDeviceInfoList (FT_DEVICE_LIST_INFO_NODE *pDest,
                                LPDWORD lpdwNumDevs);

FT_STATUS ftStatus;
FT_DEVICE_LIST_INFO_NODE *devInfo;
DWORD numDevs;
 

// Создание device information list:
ftStatus = FT_CreateDeviceInfoList(&numDevs);
 

if (ftStatus == FT_OK)
{
   printf("Количество устройств %d\n", numDevs);
}
 

if (numDevs > 0)
{
   // Выделение памяти для списка на основе количества устройств numDevs:
   devInfo = (FT_DEVICE_LIST_INFO_NODE*)malloc(sizeof(FT_DEVICE_LIST_INFO_NODE)*numDevs);
   // Получение device information list:
   ftStatus = FT_GetDeviceInfoList(devInfo,&numDevs);
   if (ftStatus == FT_OK)
   {
      for (int i = 0; i < numDevs; i++)
      {
         printf("Dev %d:\n", i);
         printf(" Flags=0x%x\n",      devInfo[i].Flags);
         printf(" Type=0x%x\n",       devInfo[i].Type);
         printf(" ID=0x%x\n",         devInfo[i].ID);
         printf(" LocId=0x%x\n",      devInfo[i].LocId);
         printf(" SerialNumber=%s\n", devInfo[i].SerialNumber);
         printf(" Description=%s\n",  devInfo[i].Description);
         printf(" ftHandle=0x%x\n",   devInfo[i].ftHandle);
      }
   }
}

FT_STATUS FT_GetDeviceInfoDetail (DWORD dwIndex,
                                  LPDWORD lpdwFlags,
                                  LPDWORD lpdwType,
                                  LPDWORD lpdwID,
                                  LPDWORD lpdwLocId,
                                  PCHAR pcSerialNumber,
                                  PCHAR pcDescription,
                                  FT_HANDLE *ftHandle);

FT_STATUS ftStatus;
FT_HANDLE ftHandleTemp;
DWORD numDevs;
DWORD Flags;
DWORD ID;
DWORD Type;
DWORD LocId;

char SerialNumber[16];

char Description[64];

// Создание device information list:
ftStatus = FT_CreateDeviceInfoList(&numDevs);

if (ftStatus == FT_OK)
{
   printf("Количество устройств %d\n",numDevs);
}

if (numDevs > 0)
{
   // Получение информации об устройстве 0:
   ftStatus = FT_GetDeviceInfoDetail(0, &Flags, &Type, &ID, &LocId,
                                     SerialNumber, Description, &ftHandleTemp);
   if (ftStatus == FT_OK)
   {
   printf("Dev 0:\n");
   printf(" Flags=0x%x\n", Flags);
   printf(" Type=0x%x\n", Type);
   printf(" ID=0x%x\n", ID);
   printf(" LocId=0x%x\n", LocId);
   printf(" SerialNumber=%s\n", SerialNumber);
   printf(" Description=%s\n", Description);
   printf(" ftHandle=0x%x\n", ftHandleTemp);
   }
}

FT_STATUS FT_ListDevices (PVOID pvArg1, PVOID pvArg2, DWORD dwFlags);

FT_STATUS ftStatus;
DWORD numDevs;
  
ftStatus = FT_ListDevices(&numDevs, NULL, FT_LIST_NUMBER_ONLY);

if (ftStatus == FT_OK)
{
   // FT_ListDevices OK, в переменной numDevs содержится количество устройств.
}

else
{
   // функция FT_ListDevices завершилась с ошибкой
}

FT_STATUS ftStatus;
DWORD numDevs;
 
DWORD devIndex = 0;  // первое устройство

char Buffer[64];     // место под строку серийного номера ограничено!

ftStatus = FT_ListDevices((PVOID)devIndex, Buffer,
                          FT_LIST_BY_INDEX|FT_OPEN_BY_SERIAL_NUMBER);

if (ftStatus == FT_OK)
{
   // FT_ListDevices OK, в Buffer находится серийный номер
}

else
{
   // функция FT_ListDevices завершилась с ошибкой
}

FT_STATUS ftStatus;
DWORD numDevs;

char *BufPtrs[3];    // указатель на массив из 3 указателей

char Buffer1[64];    // буфер для описания первого устройства

char Buffer3[64];    // буфер для описания второго устройства

// Инициализация массива указателей:
BufPtrs[0] = Buffer1;
BufPtrs[1] = Buffer2;
BufPtrs[2] = NULL;    // последняя запись в массиве должна быть NULL

ftStatus = FT_ListDevices(BufPtrs, &numDevs, FT_LIST_ALL|FT_OPEN_BY_DESCRIPTION);

if (ftStatus == FT_OK)
{
   // FT_ListDevices OK, описание устройств находятся в буферах Buffer1 и Buffer2,
   // и numDevs содержит количество подключенных устройств
}

else
{
   // функция FT_ListDevices завершилась с ошибкой
}

FT_STATUS ftStatus;
DWORD numDevs;

long locIdBuf[16];

ftStatus = FT_ListDevices(locIdBuf, &numDevs, FT_LIST_ALL|FT_OPEN_BY_LOCATION);

if (ftStatus == FT_OK)
{
   // FT_ListDevices OK, идентификаторы location ID находятся в locIdBuf,
   // и в numDevs содержится количество подключенных устройств.
}

else
{
   // функция FT_ListDevices завершилась с ошибкой
}

FT_STATUS FT_Open (int iDevice, FT_HANDLE *ftHandle);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if (ftStatus == FT_OK)
{
   // FT_Open OK, используйте ftHandle для работы с устройством
}

else
{
   // FT_Open завершилась по ошибке
}

FT_STATUS FT_OpenEx (PVOID pvArg1, DWORD dwFlags, FT_HANDLE *ftHandle);

FT_STATUS ftStatus;
FT_HANDLE ftHandle1;

ftStatus = FT_OpenEx("FT000001", FT_OPEN_BY_SERIAL_NUMBER, &ftHandle1);

if (ftStatus == FT_OK)
{
   // устройство "FT000001" успешно открыто
}

else
{
   // открыть устройство не получилось
}

FT_STATUS ftStatus;
FT_HANDLE ftHandle1;

ftStatus = FT_OpenEx("USB Serial Converter", FT_OPEN_BY_DESCRIPTION, &ftHandle1);

if (ftStatus == FT_OK)
{
   // устройство успешно открыто
}

else
{
   // открыть устройство не получилось
}

FT_STATUS ftStatus;
FT_STATUS ftStatus2;
FT_HANDLE ftHandle1;
FT_HANDLE ftHandle2;

ftStatus = FT_OpenEx("FT000001", FT_OPEN_BY_SERIAL_NUMBER, &ftHandle1);
ftStatus2 = FT_OpenEx("FT999999", FT_OPEN_BY_SERIAL_NUMBER, &ftHandle2);

if (ftStatus == FT_OK && ftStatus2 == FT_OK)
{
   // оба устройства были успешно открыты
}

else
{
   // не получилось открыть одно или оба устройства
}

FT_STATUS ftStatus;
FT_STATUS ftStatus2;
FT_HANDLE ftHandle1;
FT_HANDLE ftHandle2;

ftStatus = FT_OpenEx("USB Serial Converter", FT_OPEN_BY_DESCRIPTION, &ftHandle1);
ftStatus2 = FT_OpenEx("USB Pump Controller", FT_OPEN_BY_DESCRIPTION, &ftHandle2);

if (ftStatus == FT_OK && ftStatus2 == FT_OK)
{
   // оба устройства были успешно открыты
}

else
{
   // не получилось открыть одно или оба устройства
}

FT_STATUS ftStatus;
FT_HANDLE ftHandle1;

long dwLoc;
dwLoc = 0x23;

ftStatus = FT_OpenEx(dwLoc, FT_OPEN_BY_LOCATION, &ftHandle1);

if (ftStatus == FT_OK)
{
   // устройство с location 23 успешно открыто
}

else
{
   // открыть устройство не получилось
}

FT_STATUS ftStatus;
FT_STATUS ftStatus2;
FT_HANDLE ftHandle1;
FT_HANDLE ftHandle2;

long dwLoc;

dwLoc = 0x23;
ftStatus = FT_OpenEx(dwLoc, FT_OPEN_BY_LOCATION, &ftHandle1);

dwLoc = 0x31;

ftStatus2 = FT_OpenEx(dwLoc, FT_OPEN_BY_LOCATION, &ftHandle2);

if (ftStatus == FT_OK && ftStatus2 == FT_OK)
{
   // оба устройства были успешно открыты
}

else
{
   // не получилось открыть одно или оба устройства
}

FT_STATUS FT_Close (FT_HANDLE ftHandle);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if (ftStatus == FT_OK)
{
   // FT_Open OK, используйте ftHandle для доступа к устройству
   ...
   // когда закончите, то вызовите FT_Close:
   FT_Close(ftHandle);
}

else
{
   // ошибка FT_Open
}

FT_STATUS FT_Read (FT_HANDLE ftHandle,
                   LPVOID lpBuffer,
                   DWORD dwBytesToRead,
                   LPDWORD lpdwBytesReturned);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
DWORD EventDWord;
DWORD TxBytes;
DWORD RxBytes;
DWORD BytesReceived;

char RxBuffer[256];

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
FT_GetStatus(ftHandle, &RxBytes, &TxBytes, &EventDWord);

if (RxBytes > 0)
{
   ftStatus = FT_Read(ftHandle, RxBuffer, RxBytes, &BytesReceived);
   if (ftStatus == FT_OK)
   {
      // FT_Read OK
   }
   else
   {
      // ошибка FT_Read
   }
}
FT_Close(ftHandle);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
DWORD RxBytes = 10;
DWORD BytesReceived;

char RxBuffer[256];

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
FT_SetTimeouts(ftHandle, 5000, 0);
ftStatus = FT_Read(ftHandle, RxBuffer, RxBytes, &BytesReceived);

if (ftStatus == FT_OK)
{
   if (BytesReceived == RxBytes)
   {
      // FT_Read OK
   }
   else
   {
      // таймаут FT_Read
   }
}

else
{
   // ошибка FT_Read
}
FT_Close(ftHandle);

FT_STATUS FT_Write (FT_HANDLE ftHandle,
                    LPVOID lpBuffer,
                    DWORD dwBytesToWrite,
                    LPDWORD lpdwBytesWritten);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
DWORD BytesWritten;

char TxBuffer[256]; // содержит данные для записи в устройство

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_Write(ftHandle, TxBuffer, sizeof(TxBuffer), &BytesWritten);

if (ftStatus == FT_OK)
{
   // FT_Write OK
}

else
{
   // ошибка FT_Write
}
FT_Close(ftHandle);

FT_STATUS FT_SetBaudRate (FT_HANDLE ftHandle, DWORD dwBaudRate);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_SetBaudRate(ftHandle, 115200); // установка скорости 115200 бод

if (ftStatus == FT_OK)
{
   // FT_SetBaudRate OK
}

else
{
   // ошибка FT_SetBaudRate
}
FT_Close(ftHandle);

FT_STATUS FT_SetDivisor (FT_HANDLE ftHandle, USHORT usDivisor);

FT_STATUS FT_SetDataCharacteristics (FT_HANDLE ftHandle,
                                     UCHAR uWordLength,
                                     UCHAR uStopBits,
                                     UCHAR uParity);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}

// Устанавливает 8 бит данных, 1 стоп-бит, без четности:
ftStatus = FT_SetDataCharacteristics(ftHandle, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE);

if (ftStatus == FT_OK)
{
   // FT_SetDataCharacteristics OK
}

else
{
   // ошибка FT_SetDataCharacteristics
}
FT_Close(ftHandle);

FT_STATUS FT_SetTimeouts (FT_HANDLE ftHandle,
                          DWORD dwReadTimeout,
                          DWORD dwWriteTimeout);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}

// Установка таймаута чтения 5 секунд, записи 1 секунда
ftStatus = FT_SetTimeouts(ftHandle, 5000, 1000);

if (ftStatus == FT_OK)
{
   // FT_SetTimeouts OK
}

else
{
   // ошибка FT_SetTimeouts
}
FT_Close(ftHandle);

FT_STATUS FT_SetFlowControl (FT_HANDLE ftHandle,
                             USHORT usFlowControl,
                             UCHAR uXon,
                             UCHAR uXoff);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}// Устанавливает тип управления потоком RTS/CTS:
ftStatus = FT_SetFlowControl(ftHandle, FT_FLOW_RTS_CTS, 0x11, 0x13);

if (ftStatus == FT_OK)
{
   // FT_SetFlowControl OK
}

else
{
   // ошибка FT_SetFlowControl
}
FT_Close(ftHandle);

FT_STATUS FT_SetDtr (FT_HANDLE ftHandle);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_SetDtr(ftHandle);

if (ftStatus == FT_OK)
{
   // FT_SetDtr OK
}

else
{
   // ошибка FT_SetDtr
}
FT_Close(ftHandle);

FT_STATUS FT_ClrDtr (FT_HANDLE ftHandle);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_ClrDtr(ftHandle);

if (ftStatus == FT_OK)
{
   // FT_ClrDtr OK
}

else
{
   // ошибка FT_ClrDtr
}
FT_Close(ftHandle);

FT_STATUS FT_SetRts (FT_HANDLE ftHandle);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_SetRts(ftHandle);

if (ftStatus == FT_OK)
{
   // FT_SetRts OK
}

else
{
   // ошибка FT_SetRts
}
FT_Close(ftHandle);

FT_STATUS FT_ClrRts (FT_HANDLE ftHandle);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_ClrRts(ftHandle);

if (ftStatus == FT_OK)
{
   // FT_ClrRts OK
}

else
{
   // ошибка FT_ClrRts
}
FT_Close(ftHandle);

FT_STATUS FT_GetModemStatus (FT_HANDLE ftHandle, LPDWORD lpdwModemStatus);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
DWORD dwModemStatus = 0;
DWORD dwLineStatus = 0;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_GetModemStatus(ftHandle, &dwModemStatus);

if (ftStatus == FT_OK)
{
   // FT_GetModemStatus OK
   // Состояние линии находится во втором байте dwModemStatus:
   dwLineStatus = ((dwModemStatus >> 8) & 0x000000FF);
   // Теперь маской выделим байт состояния модема:
   dwModemStatus = (dwModemStatus & 0x000000FF);
}

else
{
   // ошибка FT_GetModemStatus
}
FT_Close(ftHandle);

FT_STATUS FT_GetQueueStatus (FT_HANDLE ftHandle, LPDWORD lpdwAmountInRxQueue);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
DWORD RxBytes;
DWORD BytesReceived;

char RxBuffer[256];

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
FT_GetQueueStatus(ftHandle,&RxBytes);

if (RxBytes > 0)
{
   ftStatus = FT_Read(ftHandle, RxBuffer, RxBytes, &BytesReceived);
   if (ftStatus == FT_OK)
   {
      // FT_Read OK
   }
   else
   {
      // ошибка FT_Read
   }
}
FT_Close(ftHandle);

FT_STATUS FT_GetDeviceInfo (FT_HANDLE ftHandle,
                            FT_DEVICE *pftType,
                            LPDWORD lpdwID,
                            PCHAR pcSerialNumber,
                            PCHAR pcDescription,
                            PVOID pvDummy);

FT_HANDLE ftHandle;
FT_DEVICE ftDevice;
FT_STATUS ftStatus;
DWORD deviceID;

char SerialNumber[16];

char Description[64];

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // FT_Open failed
   return;
}
ftStatus = FT_GetDeviceInfo( ftHandle,
                             &ftDevice,
                             &deviceID,
                             SerialNumber,
                             Description,
                             NULL );

if (ftStatus == FT_OK)
{
   if (ftDevice == FT_DEVICE_232H)
      ; // это FT232H
   else if (ftDevice == FT_DEVICE_4232H)
      ; // это FT4232H
   else if (ftDevice == FT_DEVICE_2232H)
      ; // это FT2232H
   else if (ftDevice == FT_DEVICE_232R)
      ; // это FT232R
   else if (ftDevice == FT_DEVICE_2232C)
      ; // это FT2232C/L/D
   else if (ftDevice == FT_DEVICE_BM)
      ; // это FTU232BM
   else if (ftDevice == FT_DEVICE_AM)
      ; // это FT8U232AM
   else
      ; // неизвестное устройство (это не должно было случиться!)
   // deviceID содержит закодированный encoded device ID
   // SerialNumber, Description содержат 0-terminated строки
}

else
{
   // ошибка FT_GetDeviceType!
}
FT_Close(ftHandle);

FT_STATUS FT_GetDriverVersion (FT_HANDLE ftHandle, LPDWORD lpdwDriverVersion);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
DWORD dwDriverVer;

ftStatus = FT_Open(0,&ftHandle);

if (ftStatus == FT_OK)
{
   // Получение версии драйвера устройства:
   ftStatus = FT_GetDriverVersion(ftHandle, &dwDriverVer);
   if (ftStatus == FT_OK)
      printf("Версия драйвера = 0x%x\n", dwDriverVer);
   else
      printf("ошибка чтения версии драйвера\n");
   FT_Close(ftHandle);
}

FT_STATUS FT_GetLibraryVersion (LPDWORD lpdwDLLVersion);

FT_STATUS ftStatus;
DWORD dwLibraryVer;

// Получение версии DLL:
ftStatus = FT_GetLibraryVersion(&dwLibraryVer);

if (ftStatus == FT_OK)
   printf("Версия библиотеки = 0x%x\n",dwLibraryVer);

else
   printf("ошибка чтения версии библиотеки\n");

FT_STATUS FT_GetComPortNumber (FT_HANDLE ftHandle, LPLONG lplComPortNumber);

FT_HANDLE ftHandle; // допустимый хендл, который был получен вызовом FT_OpenEx
FT_STATUS ftStatus;
LONG lComPortNumber;

ftStatus = FT_GetComPortNumber(ftHandle, &lComPortNumber);

if (status == FT_OK)
{
   if (lComPortNumber == -1)
   {
      // Устройству не назначен COM-порт
   }
   else
   {
      // Назначенный COM-порт содержится в lComPortNumber
   }
}

else
{
   // ошибка FT_GetComPortNumber!
}
FT_Close(ftHandle);

FT_STATUS FT_GetStatus (FT_HANDLE ftHandle,
                        LPDWORD lpdwAmountInRxQueue,
                        LPDWORD lpdwAmountInTxQueue,
                        LPDWORD lpdwEventStatus);

FT_STATUS FT_SetEventNotification (FT_HANDLE ftHandle,
                                   DWORD dwEventMask,
                                   PVOID pvArg);

// Сначала нужно создать событие и вызвать FT_SetEventNotification.
FT_HANDLE ftHandle; // хендл для открытого устройства
FT_STATUS ftStatus;
HANDLE hEvent;
DWORD EventMask;

hEvent = CreateEvent( NULL,
                      false, // auto-reset event
                      false, // non-signalled state
                      "" );
EventMask = FT_EVENT_RXCHAR | FT_EVENT_MODEM_STATUS;
ftStatus = FT_SetEventNotification(ftHandle,EventMask,hEvent);

...

// Где-то позже поток приложения блокируется на ожидании события. Затем,

// когда событие произойдет, будет осуществлена проверка, какое произошло

// событие, и будет сделана подходящая обработка события.
WaitForSingleObject(hEvent, INFINITE);

//В этом месте поток приложение разблокировался событием.
DWORD EventDWord;
DWORD RxBytes;
DWORD TxBytes;

FT_GetStatus(ftHandle, &RxBytes, &TxBytes, &EventDWord);

if (EventDWord & FT_EVENT_MODEM_STATUS)
{
   // Детектировано событие изменения состояния модема,
   // получение текущего состояия модема:
   FT_GetModemStatus(ftHandle, &Status);
   if (Status & 0x00000010)
   {
      // CTS == 1
   }
   else
   {
      // CTS == 0
   }
   if (Status & 0x00000020)
   {
      // DSR == 1
   }
   else
   {
      // DSR == 0
   }
}

if (RxBytes > 0)
{
   // Обнаружено наличие данных в очереди приема, можно вызвать
   // FT_Read(), чтобы получить данные, принятые устройством.
}

// Сначала нужно создать событие и вызвать FT_SetEventNotification.
FT_HANDLE ftHandle;
FT_STATUS ftStatus;
EVENT_HANDLE eh;
DWORD EventMask;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // FT_Open failed
   return;
}
pthread_mutex_init(&eh.eMutex, NULL);
pthread_cond_init(&eh.eCondVar, NULL);
EventMask = FT_EVENT_RXCHAR | FT_EVENT_MODEM_STATUS;
ftStatus = FT_SetEventNotification(ftHandle, EventMask, (PVOID)&eh);

...

// Где-то позже поток приложения будет заблокирован на ожидании события,

// затем когда событие произойдет, будет проверено, какое событие произошло,

// и событие будет обработано подходящим образом.
pthread_mutex_lock(&eh.eMutex);
pthread_cond_wait(&eh.eCondVar, &eh.eMutex);
pthread_mutex_unlock(&eh.eMutex);

// В этом месте поток приложения возобновил работу, потому что произошло событие.
DWORD EventDWord;
DWORD RxBytes;
DWORD TxBytes;
DWORD Status;

FT_GetStatus(ftHandle, &RxBytes, &TxBytes, &EventDWord);

if (EventDWord & FT_EVENT_MODEM_STATUS)
{
   // Детектировано событие изменения состояния модема,
   // получение текущего состояия модема:
   FT_GetModemStatus(ftHandle, &Status);
   if (Status & 0x00000010)
   {
      // CTS == 1
   }
   else
   {
      // CTS == 0
   }
   if (Status & 0x00000020)
   {
      // DSR == 1
   }
   else
   {
      // DSR == 0
   }
}

if (RxBytes > 0)
{
   // Обнаружено наличие данных в очереди приема, можно вызвать
   // FT_Read(), чтобы получить данные, принятые устройством.
}

FT_STATUS FT_SetChars (FT_HANDLE ftHandle,
                       UCHAR uEventCh,
                       UCHAR uEventChEn,
                       UCHAR uErrorCh,
                       UCHAR uErrorChEn);

FT_STATUS FT_SetBreakOn (FT_HANDLE ftHandle);

FT_HANDLE ftHandle; // рабочий хендл, полученный вызовом FT_OpenEx
FT_STATUS ftStatus;

ftStatus = FT_SetBreakOn(ftHandle);

if (ftStatus == FT_OK)
{
   // FT_SetBreakOn OK
}

else
{
   // ошибка FT_SetBreakOn
}
FT_Close(ftHandle);

FT_STATUS FT_SetBreakOff (FT_HANDLE ftHandle);

FT_HANDLE ftHandle;  // рабочий хендл, полученный вызовом FT_OpenEx
FT_STATUS ftStatus;

ftStatus = FT_SetBreakOff(ftHandle);

if (ftStatus == FT_OK)
{
   // FT_SetBreakOff OK
}

else
{
   // ошибка FT_SetBreakOff
}
FT_Close(ftHandle);

FT_STATUS FT_Purge (FT_HANDLE ftHandle, DWORD dwMask);

FT_HANDLE ftHandle; // рабочий хендл, полученный вызовом FT_OpenEx
FT_STATUS ftStatus;// Сброс содержимого буферов Rx и Tx

ftStatus = FT_Purge(ftHandle, FT_PURGE_RX | FT_PURGE_TX);

if (ftStatus == FT_OK)
{
   // FT_Purge OK
}

else
{
   // ошибка FT_Purge
}
FT_Close(ftHandle);

FT_STATUS FT_ResetDevice (FT_HANDLE ftHandle);

FT_HANDLE ftHandle; // рабочий хендл, полученный вызовом FT_OpenEx
FT_STATUS ftStatus;

ftStatus = FT_ResetDevice(ftHandle);

if (ftStatus == FT_OK)
{
   // FT_ResetDevice OK
}

else
{
   // ошибка FT_ResetDevice
}
FT_Close(ftHandle);

FT_STATUS FT_ResetPort (FT_HANDLE ftHandle);

FT_HANDLE ftHandle; // рабочий хендл, полученный вызовом FT_OpenEx
FT_STATUS ftStatus;

ftStatus = FT_ResetPort(ftHandle);

if (ftStatus == FT_OK)
{
   // Порт был сброшен
}

else
{
   // ошибка FT_ResetPort!
}

FT_STATUS FT_CyclePort (FT_HANDLE ftHandle);

FT_HANDLE ftHandle; // рабочий хендл, полученный вызовом FT_OpenEx
FT_STATUS ftStatus;

ftStatus = FT_CyclePort(ftHandle);

if (ftStatus == FT_OK)
{
   // Успешно выполнена команда cycle.
   // Закрыть хендл, потому что он больше недействителен:
   ftStatus = FT_Close(ftHandle);
}

else
{
   // ошибка FT_CyclePort!
}

FT_STATUS FT_Rescan (void);

FT_STATUS ftstatus;

ftStatus = FT_Rescan();

if(ftStatus != FT_OK)
{
   // ошибка FT_Rescan!
   return;
}

FT_STATUS FT_Reload (WORD wVID, WORD wPID);

FT_STATUS ftstatus;
WORD wVID = 0x0403;
WORD wPID = 0x6001;

ftStatus = FT_Reload(wVID,wPID);

if(ftStatus != FT_OK)
{
   // ошибка FT_Reload!
   return;
}

FT_STATUS ftstatus;
WORD wVID = 0x0000;
WORD wPID = 0x0000;

ftStatus = FT_Reload(wVID,wPID);

if(ftStatus != FT_OK)
{
   // ошибка FT_Reload!
   return;
}

FT_STATUS FT_SetResetPipeRetryCount (FT_HANDLE ftHandle, DWORD dwCount);

FT_HANDLE ftHandle; // рабочий хендл, полученный вызовом FT_OpenEx
FT_STATUS ftStatus;
DWORD dwRetryCount;

dwRetryCount = 100;
ftStatus = FT_SetResetPipeRetryCount(ftHandle, dwRetryCount);

if (ftStatus == FT_OK)
{
   // ResetPipeRetryCount установлен на 100
}

else
{
   // ошибка FT_SetResetPipeRetryCount!
}

FT_STATUS FT_StopInTask (FT_HANDLE ftHandle);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}

do
{
   ftStatus = FT_StopInTask(ftHandle);
}while (ftStatus != FT_OK);

//

// Здесь делаем что-то, например операцию purge для устройства

//

do
{
   ftStatus = FT_RestartInTask(ftHandle);
}while (ftStatus != FT_OK);
FT_Close(ftHandle);

FT_STATUS FT_RestartInTask (FT_HANDLE ftHandle);

FT_STATUS FT_SetDeadmanTimeout (FT_HANDLE ftHandle, DWORD dwDeadmanTimeout);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;

DWORD dwDeadmanTimeout = 6000;
ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_SetDeadmanTimeout(ftHandle, dwDeadmanTimeout);

if (ftStatus == FT_OK)
{
   // Deadman Timer установлен на 6 секунд
}

else
{
   // ошибка FT_SetDeadmanTimeout!
}
FT_Close(ftHandle);

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

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

FT_STATUS FT_EraseEE (FT_HANDLE ftHandle);

FT_STATUS FT_EE_Read (FT_HANDLE ftHandle, PFT_PROGRAM_DATA pData);

FT_HANDLE ftHandle;
FT_STATUS ftStatus = FT_Open(0, &ftHandle);if (ftStatus != FT_OK)
{
   // ошибка FT_Open!
   return;
}

FT_PROGRAM_DATA ftData;

char ManufacturerBuf[32];

char ManufacturerIdBuf[16];

char DescriptionBuf[64];

char SerialNumberBuf[16];

ftData.Signature1 = 0x00000000;
ftData.Signature2 = 0xffffffff;
ftData.Version = 0x00000005; // структура EEPROM с расширениями FT232H
ftData.Manufacturer = ManufacturerBuf;
ftData.ManufacturerId = ManufacturerIdBuf;
ftData.Description = DescriptionBuf;
ftData.SerialNumber = SerialNumberBuf;

ftStatus = FT_EE_Read(ftHandle, &ftData);

if (ftStatus == FT_OK)
{
   // FT_EE_Read OK, данные доступны в ftData
}

else
{
   // ошибка FT_EE_Read!
}
FT_Close(ftHandle);

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

FT_STATUS FT_EE_Program (FT_HANDLE ftHandle, PFT_PROGRAM_DATA pData);

// Структура версии 4 для программирования устройства серии BM.

// Другие поля структуры должны содержать ненулевые значения для устройств FT2232, FT232R,

// FT245R, FT2232H или FT4232H.
FT_PROGRAM_DATA ftData =
{
   0x00000000,          // заголовок - тут должно быть значение 0x00000000 
   0xFFFFFFFF, // заголовок - тут должно быть значение 0xffffffff 
   0x00000004, // заголовок - тут должна быть версия FT_PROGRAM_DATA
   0x0403,     // VID 
   0x6001,     // PID 
   "FTDI",     // строка имени производителя (Manufacturer)
   "FT",       // идентификатор производителя (Manufacturer ID)
   "USB HS Serial Converter", // строка описания (Description)
   "FT000001", // серийный номер
   44,         // максимальная потребляемая мощьность от шины (MaxPower)
   1,          // PnP 
   0,          // если не 0, то устройство имеет свой источник питания (SelfPowered)
   1,          // есть ли функция удаленного пробуждения (RemoteWakeup)
   1,          // не 0, если чип Rev4, иначе 0
   0,          // не 0, если in endpoint изохронная
   0,          // не 0, если out endpoint изохронная
   0,          // не 0, если разрешен pull down
   1,          // не 0, если используется серийный номер
   0,          // не 0, если чип использует USBVersion 
   0x0110      // BCD (0x0200 => USB2)
   //
   // Расширения для FT2232C (разрешены, если Version = 1 или больше)
   //
   0,          // не 0, если чип Rev5, иначе 0
   0,          // не 0, если in endpoint изохронная 
   0,          // не 0, если in endpoint изохронная 
   0,          // не 0, если out endpoint изохронная 
   0,          // не 0, если out endpoint изохронная 
   0,          // не 0, если pull down разрешен
   0,          // не 0, если используется серийный номер 
   0,          // не 0, если чип использует USBVersion 
   0x0,        // BCD (0x0200 => USB2) 
   0,          // не 0, если интерфейс потребляет большой ток
   0,          // не 0, если интерфейс потребляет большой ток
   0,          // не 0, если интерфейс 245 FIFO 
   0,          // не 0, если интерфейс 245 FIFO CPU target 
   0,          // не 0, если интерфейс Fast serial 
   0,          // не 0, если интерфейс использует драйверы VCP 
   0,          // не 0, если интерфейс 245 FIFO 
   0,          // не 0, если интерфейс 245 FIFO CPU target 
   0,          // не 0, если интерфейс Fast serial 
   0,          // не 0, если интерфейс использует драйверы VCP 
   //
   // Расширения для FT232R (разрешены, если Version = 2 или больше) 
   //
   0,          // если не 0, то использовать внешний генератор
   0,          // если не 0, то I/O с повышенной нагрузочной способностью
   0,          // размер конечной точки 
   0,          // не 0, если разрешен pull down 
   0,          // не 0, если используется серийный номер 
   0,          // не 0, если инверсный TXD 
   0,          // не 0, если инверсный RXD 
   0,          // не 0, если инверсный RTS 
   0,          // не 0, если инверсный CTS 
   0,          // не 0, если инверсный DTR 
   0,          // не 0, если инверсный DSR
   0,          // не 0, если инверсный DCD 
   0,          // не 0, если инверсный RI 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // не 0, если используются драйверы D2XX
   //
   // Расширения Rev 7 (FT2232H, разрешены, если Version = 3 или больше)
   //
   0,          // не 0, если разрешен pull down 
   0,          // не 0, если используется серийный номер 
   0,          // не 0, если AL выводы имеют малую скорость изменения уровня 
   0,          // не 0, если AL выводы работают как входы с триггером Шмитта 
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // не 0, если AH выводы имеют малую скорость изменения уровня 
   0,          // не 0, если AH выводы работают как входы с триггером Шмитта 
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // не 0, если BL выводы имеют малую скорость изменения уровня 
   0,          // не 0, если BL выводы работают как входы с триггером Шмитта 
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // не 0, если BH выводы имеют малую скорость изменения уровня 
   0,          // не 0, если BH выводы работают как входы с триггером Шмитта 
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // не 0, если интерфейс 245 FIFO 
   0,          // не 0, если интерфейс 245 FIFO CPU target 
   0,          // не 0, если интерфейс Fast serial 
   0,          // не 0, если интерфейс использует драйверы VCP 
   0,          // не 0, если интерфейс 245 FIFO 
   0,          // не 0, если интерфейс 245 FIFO CPU target
   0,          // не 0, если интерфейс Fast serial 
   0,          // не 0, если интерфейс использует драйверы VCP 
   0,          // не 0, если BCBUS7 используется для экономии энергии в схемах
               // с собственным питанием (self-powered)
   //
   // Расширения Rev 8 (FT4232H, разрешены если Version = 4)
   // 
   0,          // не 0, если разрешен pull down 
   0,          // не 0, если используется серийный номер 
   0,          // не 0, если AL выводы имеют малую скорость изменения уровня 
   0,          // не 0, если AL выводы работают как входы с триггером Шмитта
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // не 0, если AH выводы имеют малую скорость изменения уровня 
   0,          // не 0, если AH выводы работают как входы с триггером Шмитта 
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // не 0, если BL выводы имеют малую скорость изменения уровня 
   0,          // не 0, если BL выводы работают как входы с триггером Шмитта 
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // не 0, если BH выводы имеют малую скорость изменения уровня 
   0,          // не 0, если BH выводы работают как входы с триггером Шмитта 
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // не 0, если port A использует RI как RS485 TXDEN 
   0,          // не 0, если port B использует RI как RS485 TXDEN 
   0,          // не 0, если port C использует RI как RS485 TXDEN 
   0,          // не 0, если port D использует RI как RS485 TXDEN 
   0,          // не 0, если интерфейс использует драйверы VCP 
   0,          // не 0, если интерфейс использует драйверы VCP 
   0,          // не 0, если интерфейс использует драйверы VCP 
   0,          // не 0, если интерфейс использует драйверы VCP
   //
   // Расширения Rev 9 (FT232H, разрешено если Version = 5)
   //
   0,          // не 0, если разрешен pull down 
   0,          // не 0, если используется серийный номер 
   0,          // не 0, если AC выводы имеют малую скорость изменения уровня 
   0,          // не 0, если AC выводы работают как входы с триггером Шмитта
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // не 0, если AD выводы имеют малую скорость изменения уровня 
   0,          // не 0, если AD выводы работают как входы с триггером Шмитта 
   0,          // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control))
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // Управление мультиплексором Cbus (управление мультиплексором CBUS (Cbus Mux control)) 
   0,          // не 0, если интерфейс 245 FIFO 
   0,          // не 0, если интерфейс 245 FIFO CPU target 
   0,          // не 0, если интерфейс Fast serial 
   0,          // не 0, если интерфейс FT1248 
   0,          // полярность тактов FT1248 - уровень ожидания тактов (clock idle) высокий (1)
               // или низкий (0)
   0,          // порядок следования данных FT1248, сначала LSB (1) или MSB (0) 
   0,          // разрешено ли управление потоком (flow control) FT1248
   0,          // не 0, если интерфейс использует драйверы VCP
   0           // не 0, если ACBUS7 используется для экономии энергии в схемах
               // с собственным питанием (self-powered)
FT_HANDLE ftHandle;

FT_STATUS ftStatus = FT_Open(0, &ftHandle);

if (ftStatus == FT_OK)
{
   ftStatus = FT_EE_Program(ftHandle, &ftData);
   if (ftStatus == FT_OK)
   {
      // FT_EE_Program OK!
   }
   else
   {
      // ошибка FT_EE_Program!
   }
   FT_Close(ftHandle);
}

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

FT_STATUS FT_EE_UASize (FT_HANDLE ftHandle, LPDWORD lpdwSize);

FT_HANDLE ftHandle;

FT_STATUS ftStatus = FT_Open(0, &ftHandle);

if (ftStatus != FT_OK)
{
   // ошибка FT_Open!
   return;
}

DWORD EEUA_Size;

ftStatus = FT_EE_UASize(ftHandle, &EEUA_Size);

if (ftStatus == FT_OK)
{
   // FT_EE_UASize OK
   // EEUA_Size содержит размер области EEUA в байтах
}

else
{
   // ошибка FT_EE_UASize!
}
FT_Close(ftHandle);

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

FT_HANDLE ftHandle;

FT_STATUS ftStatus = FT_Open(0, &ftHandle);

if (ftStatus != FT_OK)
{
   // ошибка FT_Open!
   return;
}

unsigned char Buffer[64];
DWORD BytesRead;

ftStatus = FT_EE_UARead(ftHandle, Buffer, 64, &BytesRead);

if (ftStatus == FT_OK)
{
   // FT_EE_UARead OK,
   // данные пользвателя сохранены в буфере Buffer,
   // количество прочитанных байт из EEUA сохранено в BytesRead
}

else
{
   // ошибка FT_EE_UARead!
}
FT_Close(ftHandle);

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

FT_HANDLE ftHandle;

FT_STATUS ftStatus = FT_Open(0, &ftHandle);

if (ftStatus != FT_OK)
{
   // ошибка FT_Open!
   return;
}

char *buffer = "Hello, World";
ftStatus = FT_EE_UAWrite(ftHandle, (unsigned char*)buffer, 12);

if(ftStatus == FT_OK)
{
   // FT_EE_UAWRITE OK
}

else
{
   // ошибка FT_EE_UAWRITE
}
FT_Close(ftHandle);

FT_STATUS FT_EEPROM_Read(FT_HANDLE ftHandle,
                         void *eepromData,
                         DWORD eepromDataSize,
                         char *Manufacturer,
                         char *ManufacturerId,
                         char *Description,
                         char *SerialNumber);

FT_HANDLE fthandle;
FT_STATUS status;

char Manufacturer[64];

char ManufacturerId[64];

char Description[64];

char SerialNumber[64];
FT_EEPROM_HEADER ft_eeprom_header;

// тип устройства, к которому осуществляется доступ:
ft_eeprom_header.deviceType = FT_DEVICE_2232H;

FT_EEPROM_2232H ft_eeprom_2232h;
ft_eeprom_2232h.common = ft_eeprom_header;
ft_eeprom_2232h.common.deviceType = FT_DEVICE_2232H;

status = FT_Open(0, &fthandle);

if(status != FT_OK)
{
   printf("Устройство не открыто на доступ, статус %d\n", status);
   return;
}

status = FT_EEPROM_Read(fthandle,
                        &ft_eeprom_2232h,
                        sizeof(ft_eeprom_2232h),
                        Manufacturer,
                        ManufacturerId,
                        Description,
                        SerialNumber);

if (status != FT_OK)
{
   printf("Ошибка EEPROM_Read, статус %d\n", status);
}

else
{
   printf("VendorID = 0x%04x\n", ft_eeprom_2232h.common.VendorId);
   printf("ProductID = 0x%04x\n", ft_eeprom_2232h.common.ProductId);
   ...
   ...
}
FT_Close(fthandle);

FT_STATUS FT_EEPROM_Program(FT_HANDLE ftHandle,
                            void *eepromData,
                            DWORD eepromDataSize,
                            char *Manufacturer,
                            char *ManufacturerId,
                            char *Description,
                            char *SerialNumber);

FT_HANDLE fthandle;
FT_STATUS status;

char Manufacturer[64];

char ManufacturerId[64];

char Description[64];

char SerialNumber[64];
FT_EEPROM_HEADER ft_eeprom_header;

// Тип устройства, к которому осуществляется доступ:
ft_eeprom_header.deviceType = FT_DEVICE_2232H;

FT_EEPROM_2232H ft_eeprom_2232h;

ft_eeprom_2232h.common = ft_eeprom_header;
ft_eeprom_2232h.common.deviceType = FT_DEVICE_2232H;
status = FT_Open(0, &fthandle);

if(status != FT_OK)
{
   printf("Ошибка открытия устройства, статус %d\n", status);
   return;
}
status = FT_EEPROM_Read(fthandle,
                        &ft_eeprom_2232h,
                        sizeof(ft_eeprom_2232h),
                        Manufacturer,
                        ManufacturerId,
                        Description,
                        SerialNumber);
strcpy(SerialNumber, "FT000001");
status = FT_EEPROM_Program(fthandle,
                           &ft_eeprom_2232h,
                           sizeof(ft_eeprom_2232h),
                           Manufacturer,
                           ManufacturerId,
                           Description,
                           SerialNumber);
FT_Close(fthandle);

FT_STATUS FT_SetLatencyTimer (FT_HANDLE ftHandle, UCHAR ucTimer);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
UCHAR LatencyTimer = 10;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}

ftStatus = FT_SetLatencyTimer(ftHandle, LatencyTimer);if (ftStatus == FT_OK)
{
   // LatencyTimer установлен на 10 миллисекунд
}

else
{
   // ошибка FT_SetLatencyTimer!
}
FT_Close(ftHandle);

FT_STATUS FT_GetLatencyTimer (FT_HANDLE ftHandle, PUCHAR pucTimer);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
UCHAR LatencyTimer;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_GetLatencyTimer(ftHandle, &LatencyTimer);

if (ftStatus == FT_OK)
{
   // LatencyTimer содержит текущее значение
}

else
{
   // ошибка FT_GetLatencyTimer!
}
FT_Close(ftHandle);

FT_STATUS FT_SetBitmode (FT_HANDLE ftHandle, UCHAR ucMask, UCHAR ucMode);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
UCHAR Mask = 0xff;
UCHAR Mode = 1;      // установить asynchronous bit-bang mode

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}

ftStatus = FT_SetBitMode(ftHandle, Mask, Mode);

if (ftStatus == FT_OK)
{
   // значение 0xff записано в устройство
}

else
{
   // ошибка FT_SetBitMode!
}
FT_Close(ftHandle);

FT_STATUS FT_GetBitmode (FT_HANDLE ftHandle, PUCHAR pucMode);

FT_HANDLE ftHandle;
UCHAR BitMode;
FT_STATUS ftStatus;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_GetBitMode(ftHandle, &BitMode);

if (ftStatus == FT_OK)
{
   // BitMode содержит текущее значение
}

else
{
   // ошибка FT_GetBitMode!
}
FT_Close(ftHandle);

FT_STATUS FT_SetUSBParameters (FT_HANDLE ftHandle,
                               DWORD dwInTransferSize,
                               DWORD dwOutTransferSize);

FT_HANDLE ftHandle;
FT_STATUS ftStatus;
DWORD InTransferSize = 16384;

ftStatus = FT_Open(0, &ftHandle);

if(ftStatus != FT_OK)
{
   // ошибка FT_Open
   return;
}
ftStatus = FT_SetUSBParameters(ftHandle, InTransferSize, 0);

if (ftStatus == FT_OK)
{
   // размер передачи IN установлен на 16 килобайт
}

else
{
   // ошибка FT_SetUSBParameters!
}
FT_Close(ftHandle);

FT_HANDLE FT_W32_CreateFile (PVOID pvArg1,
                             DWORD dwAccess,
                             DWORD dwShareMode,
                             LPSECURITY_ATTRIBUTES lpSecurityAttributes,
                             DWORD dwCreate,
                             DWORD dwAttrsAndFlags,
                             HANDLE hTemplate);

FT_STATUS ftStatus;
FT_HANDLE ftHandle;

char Buf[64];

ftStatus = FT_ListDevices(0, Buf, FT_LIST_BY_INDEX|FT_OPEN_BY_SERIAL_NUMBER);
ftHandle = FT_W32_CreateFile(Buf,GENERIC_READ|GENERIC_WRITE,
                             0,
                             0,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FT_OPEN_BY_SERIAL_NUMBER,
                             0);

if (ftHandle == INVALID_HANDLE_VALUE) 
   ; // ошибка FT_W32_CreateDevice

FT_STATUS ftStatus;
FT_HANDLE ftHandle;

char Buf[64];

ftStatus = FT_ListDevices(0, Buf, FT_LIST_BY_INDEX|FT_OPEN_BY_DESCRIPTION);
ftHandle = FT_W32_CreateFile(Buf,
                             GENERIC_READ|GENERIC_WRITE,
                             0,
                             0,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL | FT_OPEN_BY_DESCRIPTION,
                             0);

if (ftHandle == INVALID_HANDLE_VALUE)
   ; // ошибка FT_W32_CreateDevice

FT_STATUS ftStatus;
FT_HANDLE ftHandle;

char Buf[64];

long locID;

ftStatus = FT_ListDevices(0, &locID, FT_LIST_BY_INDEX|FT_OPEN_BY_LOCATION);
ftHandle = FT_W32_CreateFile((PVOID) locID,
                             GENERIC_READ|GENERIC_WRITE,
                             0,
                             0,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL | FT_OPEN_BY_LOCATION,
                             0);

if (ftHandle == INVALID_HANDLE_VALUE)
   ; // ошибка FT_W32_CreateDevice

BOOL FT_W32_CloseHandle (FT_HANDLE ftHandle);

FT_STATUS ftStatus;
FT_HANDLE ftHandle;char Buf[64];
ftStatus = FT_ListDevices(0, Buf, FT_LIST_BY_INDEX|FT_OPEN_BY_DESCRIPTION);
ftHandle = FT_W32_CreateFile(Buf,
                             GENERIC_READ|GENERIC_WRITE,
                             0,
                             0,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL | FT_OPEN_BY_DESCRIPTION,
                             0);if (ftHandle == INVALID_HANDLE_VALUE)
{
   // ошибка FT_W32_CreateDevice
}else
{
   // FT_W32_CreateFile OK, так что можно выполнить некую работу,
   // после чего можно закрыть устройство.
   ...
   FT_W32_CloseHandle(ftHandle);
}

BOOL FT_W32_ReadFile (FT_HANDLE ftHandle,
                      LPVOID lpBuffer,
                      DWORD dwBytesToRead,
                      LPDWORD lpdwBytesReturned,
                      LPOVERLAPPED lpOverlapped);

FT_HANDLE ftHandle;  // переменная настроена через FT_W32_CreateFile для non-overlapped I/O

char Buf[256];
DWORD dwToRead = 256;
DWORD dwRead;

if (FT_W32_ReadFile(ftHandle, Buf, dwToRead, &dwRead, &osRead))
{
   if (dwToRead == dwRead)
   {
      // FT_W32_ReadFile OK
   }
   else
   {
      // таймаут FT_W32_ReadFile
   }
}

else
{
   // ошибка FT_W32_ReadFile
}

FT_HANDLE ftHandle;  // переменная настроена через FT_W32_CreateFile для overlapped I/Ochar Buf[256];
DWORD dwToRead = 256;
DWORD dwRead;
OVERLAPPED osRead = { 0 };

osRead.hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);

if (!FT_W32_ReadFile(ftHandle, Buf, dwToRead, &dwRead, &osRead))
{
   if (FT_W32_GetLastError(ftHandle) == ERROR_IO_PENDING)
   {
      // чтение отложено, так что можно пока делать что-то еще
      ...
      if (!FT_W32_GetOverlappedResult(ftHandle, &osRead, &dwRead, FALSE))
      {
         // ошибка
      }
      else
      {
         if (dwToRead == dwRead)
         {
            // FT_W32_ReadFile OK
         }
         else
         {
            // таймаут FT_W32_ReadFile
         }
      }
   }
}

else
{
   // FT_W32_ReadFile OK
}
CloseHandle (osRead.hEvent);

BOOL FT_W32_WriteFile (FT_HANDLE ftHandle,
                       LPVOID lpBuffer,
                       DWORD dwBytesToWrite,
                       LPDWORD lpdwBytesWritten,
                       LPOVERLAPPED lpOverlapped);

FT_HANDLE ftHandle; // переменная настроена вызовом FT_W32_CreateFile для non-overlapped I/O

char Buf[128];      // содержит данные для записи в устройство
DWORD dwToWrite = 128;
DWORD dwWritten;

if (FT_W32_WriteFile(ftHandle, Buf, dwToWrite, &dwWritten, &osWrite))
{
   if (dwToWrite == dwWritten)
   {
      // FT_W32_WriteFile OK
   }
   else
   {
      // таймаут FT_W32_WriteFile
   }
}

else
{
   // ошибка FT_W32_WriteFile
}

FT_HANDLE ftHandle; // переменная настроена вызовом FT_W32_CreateFile для overlapped I/O

char Buf[128];      // содержит данные для записи в устройство
DWORD dwToWrite = 128;
DWORD dwWritten;
OVERLAPPED osWrite = { 0 };

if (!FT_W32_WriteFile(ftHandle, Buf, dwToWrite, &dwWritten, &osWrite))
{
   if (FT_W32_GetLastError(ftHandle) == ERROR_IO_PENDING)
   {
      // запись отложена так что можно пока делать другую работу
      ...
      if (!FT_W32_GetOverlappedResult(ftHandle, &osWrite, &dwWritten, FALSE))
      {
         // ошибка
      }
      else
      {
         if (dwToWrite == dwWritten)
         {
            // FT_W32_WriteFile OK
         }
         else
         {
            // таймаут FT_W32_WriteFile
         }
      }
   }
}

else
{
   // FT_W32_WriteFIle OK
}

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

BOOL FT_W32_EscapeCommFunction (FT_HANDLE ftHandle, DWORD dwFunc);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile

FT_W32_EscapeCommFunction(ftHandle, CLRDTS); // сброс DTR в лог. 0
FT_W32_EscapeCommFunction(ftHandle, SETRTS); // установка RTS в лог. 1

BOOL FT_W32_GetCommModemStatus (FT_HANDLE ftHandle, LPDWORD lpdwStat);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile
DWORD dwStatus;

if (FT_W32_GetCommModemStatus(ftHandle, &dwStatus))
{
   // FT_W32_GetCommModemStatus ok
   if (dwStatus & MS_CTS_ON) 
      ; // CTS == 1
   if (dwStatus & MS_DSR_ON)
      ; // DSR == 1
   if (dwStatus & MS_RI_ON)
      ; // RI == 1
   if (dwStatus & MS_RLSD_ON)
      ; // RLSD == 1
}

else
   ; // ошибка FT_W32_GetCommModemStatus

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

BOOL FT_W32_SetCommState (FT_HANDLE ftHandle, LPFTDCB lpftDcb);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile
FTDCB ftDCB;

if (FT_W32_GetCommState(ftHandle, &ftDCB))
{
   // FT_W32_GetCommState ok, состояние устройства находится в ftDCB
   ftDCB.BaudRate = 921600; // изменение скорости
   if (FT_W32_SetCommState(ftHandle,&ftDCB))
      ; // FT_W32_SetCommState ok
   else
      ; // ошибка FT_W32_SetCommState
}

else
   ; // ошибка FT_W32_GetCommState

BOOL FT_W32_GetCommState (FT_HANDLE ftHandle, LPFTDCB lpftDcb);

BOOL FT_W32_SetCommTimeouts (FT_HANDLE ftHandle, LPFTTIMEOUTS lpftTimeouts);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile
FTTIMEOUTS ftTS;

ftTS.ReadIntervalTimeout = 0;
ftTS.ReadTotalTimeoutMultiplier = 0;
ftTS.ReadTotalTimeoutConstant = 100;
ftTS.WriteTotalTimeoutMultiplier = 0;
ftTS.WriteTotalTimeoutConstant = 200;

if (FT_W32_SetCommTimeouts(ftHandle, &ftTS))
   ; // FT_W32_SetCommTimeouts OK

else
   ; // ошибка FT_W32_SetCommTimeouts

BOOL FT_W32_GetCommTimeouts (FT_HANDLE ftHandle, LPFTTIMEOUTS lpftTimeouts);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile
FTTIMEOUTS ftTS;

if (FT_W32_GetCommTimeouts(ftHandle, &ftTS))
   ; // FT_W32_GetCommTimeouts OK

else
   ; // ошибка FT_W32_GetCommTimeouts

BOOL FT_W32_SetCommBreak (FT_HANDLE ftHandle);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile

if (!FT_W32_SetCommBreak(ftHandle))
   ; // ошибка FT_W32_SetCommBreak

else
   ; // FT_W32_SetCommBreak OK

BOOL FT_W32_ClearCommBreak (FT_HANDLE ftHandle);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile

if (!FT_W32_ClearCommBreak(ftHandle))
   ; // ошибка FT_W32_ClearCommBreak

else
   ; // FT_W32_ClearCommBreak OK

BOOL FT_W32_SetCommMask (FT_HANDLE ftHandle, DWORD dwMask);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile
DWORD dwMask = EV_CTS | EV_DSR;

if (!FT_W32_SetCommMask(ftHandle, dwMask))
   ; // ошибка FT_W32_SetCommMask

else
   ; // FT_W32_SetCommMask OK

BOOL FT_W32_GetCommMask (FT_HANDLE ftHandle, LPDWORD lpdwEventMask);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile
DWORD dwMask;

if (!FT_W32_GetCommMask(ftHandle, &dwMask))
   ; // ошибка FT_W32_GetCommMask

else
   ; // FT_W32_GetCommMask OK

BOOL FT_W32_WaitCommEvent (FT_HANDLE ftHandle,
                           LPDWORD lpdwEvent,
                           LPOVERLAPPED lpOverlapped);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile для non-overlapped I/O
DWORD dwEvents;

if (FT_W32_WaitCommEvent(ftHandle, &dwEvents, NULL))
   ; // FT_W32_WaitCommEvents OK

else
   ; // ошибка FT_W32_WaitCommEvents

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile для overlapped I/O
DWORD dwEvents;
DWORD dwRes;
OVERLAPPED osWait = { 0 };

if (!FT_W32_WaitCommEvent(ftHandle, &dwEvents, &osWait))
{
   if (FT_W32_GetLastError(ftHandle == ERROR_IO_PENDING)
   {
      // запрос выставлен, но пока тне завершился, так что 
      // можно выполнять какую-то другую работу
      ...
      if (!FT_W32_GetOverlappedResult(ftHandle, &osWait, &dwRes, FALSE))
         ; // ошибка
      else
         ; // FT_W32_WaitCommEvent OK
      // События, которые произошли, сохранены как маска в dwEvents
   }
}

else
{
   // FT_W32_WaitCommEvent OK
   // События, которые произошли, сохранены как маска в dwEvents
}

BOOL FT_W32_PurgeComm (FT_HANDLE ftHandle, DWORD dwFlags);

FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile

if (FT_W32_PurgeComm(ftHandle, PURGE_TXCLEAR|PURGE_RXCLEAR))
   ; // FT_W32_PurgeComm OK

else
   ; // ошибка FT_W32_PurgeComm

DWORD FT_W32_GetLastError (FT_HANDLE ftHandle);

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

static COMSTAT oldCS = {0};

static DWORD dwOldErrors = 0;
FT_HANDLE ftHandle; // настроено вызовом FT_W32_CreateFile
COMSTAT newCS;
DWORD dwErrors;
BOOL bChanged = FALSE;

if (!FT_W32_ClearCommError(ftHandle, &dwErrors, (FTCOMSTAT *)&newCS))
   ; // ошибка FT_W32_ClearCommError

if (dwErrors != dwOldErrors)
{
   bChanged = TRUE;
   dwErrorsOld = dwErrors;
}

if (memcmp(&oldCS, &newCS, sizeof(FTCOMSTAT)))
{
   bChanged = TRUE;
   oldCS = newCS;
}

if (bChanged)
{
   if (dwErrors & CE_BREAK)
      ; // детектировано событие останова (BREAK condition)
   if (dwErrors & CE_FRAME)
      ; // детектирована ошибка фрейма
   if (dwErrors & CE_RXOVER)
      ; // переполнение буфера приема
   if (dwErrors & CE_TXFULL)
      ; // буфер передачи заполнен
   if (dwErrors & CE_OVERRUN)
      ; // переполнение буфера символа
   if (dwErrors & CE_RXPARITY)
      ; // детектирована ошибка четности
   if (newCS.fCtsHold)
      ; // передатчик ждет CTS
   if (newCS.fDsrHold)
      ; // передатчик ждет DSR
   if (newCS.fRlsdHold)
      ; // передатчик ждет RLSD
   if (newCS.fXoffHold)
      ; // передатчик ждет, потому что был принят XOFF
   if (newCS.fXoffSent)
      ; // был отправлен XOFF
   if (newCS.fEof)
      ; // принят символ конца файла (End of file, EOF)
   if (newCS.fTxim)
      ; // символ непосредственно поставлен в очередь передачи
   // newCS.cbInQue содержит количество байт в очереди приема
   // newCS.cbOutQue содержит количество байт в очереди передачи
}

   FT_OK                            = 0
   FT_INVALID_HANDLE                = 1
   FT_DEVICE_NOT_FOUND              = 2
   FT_DEVICE_NOT_OPENED             = 3
   FT_IO_ERROR                      = 4
   FT_INSUFFICIENT_RESOURCES        = 5
   FT_INVALID_PARAMETER             = 6
   FT_INVALID_BAUD_RATE             = 7
   FT_DEVICE_NOT_OPENED_FOR_ERASE   = 8
   FT_DEVICE_NOT_OPENED_FOR_WRITE   = 9
   FT_FAILED_TO_WRITE_DEVICE        = 10
   FT_EEPROM_READ_FAILED            = 11
   FT_EEPROM_WRITE_FAILED           = 12
   FT_EEPROM_ERASE_FAILED           = 13
   FT_EEPROM_NOT_PRESENT            = 14
   FT_EEPROM_NOT_PROGRAMMED         = 15
   FT_INVALID_ARGS                  = 16
   FT_NOT_SUPPORTED                 = 17
   FT_OTHER_ERROR                   = 18

   FT_LIST_NUMBER_ONLY              = 0x80000000
   FT_LIST_BY_INDEX                 = 0x40000000
   FT_LIST_ALL                      = 0x20000000

   FT_OPEN_BY_SERIAL_NUMBER         = 1
   FT_OPEN_BY_DESCRIPTION           = 2
   FT_OPEN_BY_LOCATION              = 4

   FT_DEVICE_232BM      = 0
   FT_DEVICE_232AM      = 1
   FT_DEVICE_100AX      = 2
   FT_DEVICE_UNKNOWN    = 3
   FT_DEVICE_2232C      = 4
   FT_DEVICE_232R       = 5
   FT_DEVICE_2232H      = 6
   FT_DEVICE_4232H      = 7
   FT_DEVICE_232H       = 8
   FT_DEVICE_X_SERIES   = 9

   FT_DRIVER_TYPE_D2XX  = 0
   FT_DRIVER_TYPE_VCP   = 1

   FT_BITS_8   = 8
   FT_BITS_7   = 7

   FT_STOP_BITS_1 = 0
   FT_STOP_BITS_2 = 2

   FT_PARITY_NONE    = 0
   FT_PARITY_ODD     = 1
   FT_PARITY_EVEN    = 2
   FT_PARITY_MARK    = 3
   FT_PARITY_SPACE   = 4

   FT_FLOW_NONE      = 0x0000
   FT_FLOW_RTS_CTS   = 0x0100
   FT_FLOW_DTR_DSR   = 0x0200
   FT_FLOW_XON_XOFF  = 0x0400

   FT_PURGE_RX = 1
   FT_PURGE_TX = 2

   FT_EVENT_RXCHAR         = 1
   FT_EVENT_MODEM_STATUS   = 2
   FT_EVENT_LINE_STATUS    = 4

   CTS   = 0x10
   DSR   = 0x20
   RI    = 0x40
   DCD   = 0x80

   OE    = 0x02
   PE    = 0x04
   FE    = 0x08
   BI    = 0x10

   FT_BITMODE_RESET           = 0x00
   FT_BITMODE_ASYNC_BITBANG   = 0x01
   FT_BITMODE_MPSSE           = 0x02
   FT_BITMODE_SYNC_BITBANG    = 0x04
   FT_BITMODE_MCU_HOST        = 0x08
   FT_BITMODE_FAST_SERIAL     = 0x10
   FT_BITMODE_CBUS_BITBANG    = 0x20
   FT_BITMODE_SYNC_FIFO       = 0x40

   FT_232R_CBUS_TXDEN      = 0x00
   FT_232R_CBUS_PWRON      = 0x01
   FT_232R_CBUS_RXLED      = 0x02
   FT_232R_CBUS_TXLED      = 0x03
   FT_232R_CBUS_TXRXLED    = 0x04
   FT_232R_CBUS_SLEEP      = 0x05
   FT_232R_CBUS_CLK48      = 0x06
   FT_232R_CBUS_CLK24      = 0x07
   FT_232R_CBUS_CLK12      = 0x08
   FT_232R_CBUS_CLK6       = 0x09
   FT_232R_CBUS_IOMODE     = 0x0A
   FT_232R_CBUS_BITBANG_WR = 0x0B
   FT_232R_CBUS_BITBANG_RD = 0x0C

   FT_232H_CBUS_TRISTATE   = 0x00
   FT_232H_CBUS_RXLED      = 0x01
   FT_232H_CBUS_TXLED      = 0x02
   FT_232H_CBUS_TXRXLED    = 0x03
   FT_232H_CBUS_PWREN      = 0x04
   FT_232H_CBUS_SLEEP      = 0x05
   FT_232H_CBUS_DRIVE_0    = 0x06
   FT_232H_CBUS_DRIVE_1    = 0x07
   FT_232H_CBUS_IOMODE     = 0x08
   FT_232H_CBUS_TXDEN      = 0x09
   FT_232H_CBUS_CLK30      = 0x0A
   FT_232H_CBUS_CLK15      = 0x0B
   FT_232H_CBUS_CLK7_5     = 0x0C

   FT_X_SERIES_CBUS_TRISTATE        = 0x00
   FT_X_SERIES_CBUS_RXLED           = 0x01
   FT_X_SERIES_CBUS_TXLED           = 0x02
   FT_X_SERIES_CBUS_TXRXLED         = 0x03
   FT_X_SERIES_CBUS_PWREN           = 0x04
   FT_X_SERIES_CBUS_SLEEP           = 0x05
   FT_X_SERIES_CBUS_DRIVE_0         = 0x06
   FT_X_SERIES_CBUS_DRIVE_1         = 0x07
   FT_X_SERIES_CBUS_IOMODE          = 0x08
   FT_X_SERIES_CBUS_TXDEN           = 0x09
   FT_X_SERIES_CBUS_CLK24           = 0x0A
   FT_X_SERIES_CBUS_CLK12           = 0x0B
   FT_X_SERIES_CBUS_CLK6            = 0x0C
   FT_X_SERIES_CBUS_BCD_CHARGER     = 0x0D
   FT_X_SERIES_CBUS_BCD_CHARGER_N   = 0x0E
   FT_X_SERIES_CBUS_I2C_TXE         = 0x0F
   FT_X_SERIES_CBUS_I2C_RXF         = 0x10
   FT_X_SERIES_CBUS_VBUS_SENSE      = 0x11
   FT_X_SERIES_CBUS_BITBANG_WR      = 0x12
   FT_X_SERIES_CBUS_BITBANG_RD      = 0x13
   FT_X_SERIES_CBUS_TIMESTAMP       = 0x14
   FT_X_SERIES_CBUS_KEEP_AWAKE      = 0x15

typedef struct _ft_device_list_info_node
{
   DWORD Flags;
   DWORD Type;
   DWORD ID;
   DWORD LocId;
   char SerialNumber[16];
   char Description[64];
   FT_HANDLE ftHandle;
} FT_DEVICE_LIST_INFO_NODE;

   FT_FLAGS_OPENED = 0x00000001

typedef struct ft_program_data
{
   DWORD Signature1;    // заголовок - тут должно быть 0x0000000
   DWORD Signature2;    // заголовок - тут должно быть 0xffffffff
   DWORD Version;       // заголовок - версия FT_PROGRAM_DATA 
                        // 0 = оригинальная версия (FT232B)
                        // 1 = расширения FT2232
                        // 2 = расширения FT232R
                        // 3 = расширения FT2232H
                        // 4 = расширения FT4232H
                        // 5 = расширения FT232H
   WORD VendorId;       // 0x0403
   WORD ProductId;      // 0x6001
   char *Manufacturer;  // "FTDI"
   char *ManufacturerId; // "FT"
   char *Description;   // "USB HS Serial Converter"
   char *SerialNumber;  // "FT000001" если фиксировано, или NULL
   WORD MaxPower;       // 0 < MaxPower < = 500
   WORD PnP;            // 0 = запрещено, 1 = разрешено
   WORD SelfPowered;    // 0 = питание от шины USB, 1 = свой источник питания
   WORD RemoteWakeup;   // 0 = не применимо, 1 = применимо
   //
   // Расширения для Rev4 (FT232B)
   //
   UCHAR Rev4;          // не 0, если чип Rev4, иначе 0
   UCHAR IsoIn;         // не 0, если IN endpoint изохронная
   UCHAR IsoOut;        // не 0, если OUT endpoint изохронная
   UCHAR PullDownEnable;// не 0, если разрешен pull down
   UCHAR SerNumEnable;  // не 0, если используется серийный номер
   UCHAR USBVersionEnable; // не 0, если чип использует USBVersion
   WORD USBVersion;     // BCD (0x0200 => USB2)
   //
   // Расшинения для Rev 5 (FT2232)
   //
   UCHAR Rev5;          // не 0, если чип Rev5, иначе 0
   UCHAR IsoInA;        // не 0, если IN endpoint изохронная
   UCHAR IsoInB;        // не 0, если IN endpoint изохронная
   UCHAR IsoOutA;       // не 0, если OUT endpoint изохронная
   UCHAR IsoOutB;       // не 0, если OUT endpoint изохронная
   UCHAR PullDownEnable5; // не 0, если разрешен pull down
   UCHAR SerNumEnable5; // не 0, если используется серийный номер
   UCHAR USBVersionEnable5; // не 0, если чип использует USBVersion
   WORD USBVersion5;    // BCD (0x0200 => USB2)
   UCHAR AIsHighCurrent; // не 0, если интерфейс с высокой нагрузочной способностью (high current)
   UCHAR BIsHighCurrent; // не 0, если интерфейс с высокой нагрузочной способностью (high current)
   UCHAR IFAIsFifo;     // не 0, если интерфейс 245 FIFO
   UCHAR IFAIsFifoTar;  // не 0, если интерфейс 245 FIFO CPU target
   UCHAR IFAIsFastSer;  // не 0, если интерфейс Fast serial
   UCHAR AIsVCP;        // не 0, если интерфейс использует драйверы VCP
   UCHAR IFBIsFifo;     // не 0, если интерфейс 245 FIFO
   UCHAR IFBIsFifoTar;  // не 0, если интерфейс 245 FIFO CPU target
   UCHAR IFBIsFastSer;  // не 0, если интерфейс Fast serial
   UCHAR BIsVCP;        // не 0, если интерфейс использует драйверы VCP
   //
   // Расшинения для Rev 6 (FT232R)
   //
   UCHAR UseExtOsc;     // используется внешний генератор
   UCHAR HighDriveIOs;  // ввод/вывод с высокой нагрузочной способностью (High Drive I/O)
   UCHAR EndpointSize;  // размер буфера конечной точки (endpoint size)
   UCHAR PullDownEnableR; // не 0, если разрешен pull down
   UCHAR SerNumEnableR; // не 0, если используется серийный номер
   UCHAR InvertTXD;     // не 0, если инверсия TXD
   UCHAR InvertRXD;     // не 0, если инверсия RXD
   UCHAR InvertRTS;     // не 0, если инверсия RTS
   UCHAR InvertCTS;     // не 0, если инверсия CTS
   UCHAR InvertDTR;     // не 0, если инверсия DTR
   UCHAR InvertDSR;     // не 0, если инверсия DSR
   UCHAR InvertDCD;     // не 0, если инверсия DCD
   UCHAR InvertRI;      // не 0, если инверсия RI
   UCHAR Cbus0;         // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus1;         // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus2;         // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus3;         // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus4;         // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR RIsD2XX;       // не 0, если используется драйвер D2XX
   //
   // Расширения для Rev 7 (FT2232H)
   //
   UCHAR PullDownEnable7; // не 0, если разрешен pull down
   UCHAR SerNumEnable7; // не 0, если используется серийный номер
   UCHAR ALSlowSlew;    // не 0, если AL выводы имеют низкую скорость переключения
   UCHAR ALSchmittInput;// не 0, если AL выводы имеют на входе триггер Шмитта
   UCHAR ALDriveCurrent;// допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR AHSlowSlew;    // не 0, если AH выводы имеют низкую скорость переключения
   UCHAR AHSchmittInput;// не 0, если AH выводы имеют на входе триггер Шмитта
   UCHAR AHDriveCurrent;// допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR BLSlowSlew;    // не 0, если BL выводы имеют низкую скорость переключения
   UCHAR BLSchmittInput;// не 0, если BL выводы имеют на входе триггер Шмитта
   UCHAR BLDriveCurrent;// допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR BHSlowSlew;    // не 0, если BH выводы имеют низкую скорость переключения
   UCHAR BHSchmittInput;// не 0, если BH выводы имеют на входе триггер Шмитта
   UCHAR BHDriveCurrent;// допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR IFAIsFifo7;    // не 0, если интерфейс 245 FIFO
   UCHAR IFAIsFifoTar7; // не 0, если интерфейс 245 FIFO CPU target
   UCHAR IFAIsFastSer7; // не 0, если интерфейс Fast serial
   UCHAR AIsVCP7;       // не 0, если интерфейс использует драйверы VCP
   UCHAR IFBIsFifo7;    // не 0, если интерфейс 245 FIFO
   UCHAR IFBIsFifoTar7; // не 0, если интерфейс 245 FIFO CPU target
   UCHAR IFBIsFastSer7; // не 0, если интерфейс Fast serial
   UCHAR BIsVCP7;       // не 0, если интерфейс использует драйверы VCP
   UCHAR PowerSaveEnable;  // не 0, если BCBUS7 используется для управления 
                           // энергопотреблением в случае своего питания
   //
   // Расширения для Rev 8 (FT4232H)
   //
   UCHAR PullDownEnable8; // не 0, если разрешен pull down
   UCHAR SerNumEnable8; // не 0, если используется серийный номер
   UCHAR ASlowSlew;     // не 0, если AL выводы имеют низкую скорость переключения
   UCHAR ASchmittInput; // не 0, если AL выводы имеют на входе триггер Шмитта
   UCHAR ADriveCurrent; // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR BSlowSlew;     // не 0, если AH выводы имеют низкую скорость переключения
   UCHAR BSchmittInput; // не 0, если AH выводы имеют на входе триггер Шмитта
   UCHAR BDriveCurrent; // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR CSlowSlew;     // не 0, если BL выводы имеют низкую скорость переключения
   UCHAR CSchmittInput; // не 0, если BL выводы имеют на входе триггер Шмитта
   UCHAR CDriveCurrent; // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR DSlowSlew;     // не 0, если BH выводы имеют низкую скорость переключения
   UCHAR DSchmittInput; // не 0, если BH выводы имеют на входе триггер Шмитта
   UCHAR DDriveCurrent; // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR ARIIsTXDEN;    // не 0, если port A использует RI как RS485 TXDEN
   UCHAR BRIIsTXDEN;    // не 0, если port B использует RI как RS485 TXDEN
   UCHAR CRIIsTXDEN;    // не 0, если port C использует RI как RS485 TXDEN
   UCHAR DRIIsTXDEN;    // не 0, если port D использует RI как RS485 TXDEN
   UCHAR AIsVCP8;       // не 0, если интерфейс использует драйверы VCP
   UCHAR BIsVCP8;       // не 0, если интерфейс использует драйверы VCP
   UCHAR CIsVCP8;       // не 0, если интерфейс использует драйверы VCP
   UCHAR DIsVCP8;       // не 0, если интерфейс использует драйверы VCP
   //
   // Расширения для Rev 9 (FT232H)
   //
   UCHAR PullDownEnableH; // не 0, если разрешен pull down
   UCHAR SerNumEnableH; // не 0, если используется серийный номер
   UCHAR ACSlowSlewH;   // не 0, если AC выводы имеют низкую скорость переключения
   UCHAR ACSchmittInputH; // не 0, если AC выводы имеют на входе триггер Шмитта
   UCHAR ACDriveCurrentH; // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR ADSlowSlewH;   // не 0, если AD выводы имеют низкую скорость переключения
   UCHAR ADSchmittInputH; // не 0, если AD выводы имеют на входе триггер Шмитта
   UCHAR ADDriveCurrentH; // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR Cbus0H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus1H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus2H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus3H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus4H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus5H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus6H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus7H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus8H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus9H;        // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR IsFifoH;       // не 0, если интерфейс 245 FIFO
   UCHAR IsFifoTarH;    // не 0, если интерфейс 245 FIFO CPU target
   UCHAR IsFastSerH;    // не 0, если интерфейс Fast serial
   UCHAR IsFT1248H;     // не 0, если интерфейс FT1248
   UCHAR FT1248CpolH;   // FT1248 полярность тактов - clock idle лог. 1 (1) или лог. 0 (0)
   UCHAR FT1248LsbH;    // FT1248 порядок следования данных, сначала LSB (1) или MSB (0)
   UCHAR FT1248FlowControlH; // FT1248 разрешение управлением потоком (flow control)
   UCHAR IsVCPH;           // не 0, если интерфейс использует драйверы VCP
   UCHAR PowerSaveEnableH; // не 0, если ACBUS7 используется для управления 
                           // энергопотреблением в случае своего питания
} FT_PROGRAM_DATA, *PFT_PROGRAM_DATA;

typedef struct ft_eeprom_header
{
   FT_DEVICE deviceType;// тип устройства FTxxxx для программирования
   // Опции дескриптора устройства
   WORD VendorId;       // 0x0403
   WORD ProductId;      // 0x6001
   UCHAR SerNumEnable;  // не 0, если используется серийный номер
   // Опции дескриптора конфигурации
   WORD MaxPower;       // 0 < MaxPower < = 500
   UCHAR SelfPowered;   // 0 = питание от шины USB, 1 = свой источник питания
   UCHAR RemoteWakeup;  // 0 = не применимо, 1 = применимо
   // Опции аппаратуры
   UCHAR PullDownEnable;// не 0, если в suspend (приостановка) разрешен pull down
} FT_EEPROM_HEADER, *PFT_EEPROM_HEADER;

typedef struct ft_eeprom_232b
{
   // Общий заголовок
   FT_EEPROM_HEADER common; // общие элементы EEPROM для всех устройств
} FT_EEPROM_232B, *PFT_EEPROM_232B;

typedef struct ft_eeprom_2232
{
   // Общий заголовок
   FT_EEPROM_HEADER common;// общие элементы EEPROM для всех устройств
   // Опции нагрузочной способности
   UCHAR AIsHighCurrent;   // не 0, если интерфейс с высокой нагрузочной способностью (high current)
   UCHAR BIsHighCurrent;   // не 0, если интерфейс с высокой нагрузочной способностью (high current)
   // Опции аппаратуры
   UCHAR AIsFifo;          // не 0, если интерфейс 245 FIFO
   UCHAR AIsFifoTar;       // не 0, если интерфейс 245 FIFO CPU target
   UCHAR AIsFastSer;       // не 0, если интерфейс Fast serial
   UCHAR BIsFifo;          // не 0, если интерфейс 245 FIFO
   UCHAR BIsFifoTar;       // не 0, если интерфейс 245 FIFO CPU target
   UCHAR BIsFastSer;       // не 0, если интерфейс Fast serial
   // Опции драйвера
   UCHAR ADriverType;
   UCHAR BDriverType;
} FT_EEPROM_2232, *PFT_EEPROM_2232;

typedef struct ft_eeprom_232r
{
   // Общий заголовок
   FT_EEPROM_HEADER common;// общие элементы EEPROM для всех устройств
   // Опции нагрузочной способности
   UCHAR IsHighCurrent;    // не 0, если интерфейс с высокой нагрузочной способностью (high current)
   // Опции аппаратуры
   UCHAR UseExtOsc;        // используется внешний генератор
   UCHAR InvertTXD;        // не 0, если инверсия TXD
   UCHAR InvertRXD;        // не 0, если инверсия RXD
   UCHAR InvertRTS;        // не 0, если инверсия RTS
   UCHAR InvertCTS;        // не 0, если инверсия CTS
   UCHAR InvertDTR;        // не 0, если инверсия DTR
   UCHAR InvertDSR;        // не 0, если инверсия DSR
   UCHAR InvertDCD;        // не 0, если инверсия DCD
   UCHAR InvertRI;         // не 0, если инверсия RI
   UCHAR Cbus0;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus1;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus2;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus3;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus4;            // управление мультиплексором CBUS (Cbus Mux control)
   // Опции драйвера
   UCHAR DriverType;
} FT_EEPROM_232R, *PFT_EEPROM_232R;

typedef struct ft_eeprom_2232h
{
   // Общий заголовок
   FT_EEPROM_HEADER common;// общие элементы EEPROM для всех устройств
   // Опции нагрузочной способности
   UCHAR ALSlowSlew;       // не 0, если AL выводы имеют низкую скорость переключения
   UCHAR ALSchmittInput;   // не 0, если AL выводы имеют на входе триггер Шмитта
   UCHAR ALDriveCurrent;   // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR AHSlowSlew;       // не 0, если AH выводы имеют низкую скорость переключения
   UCHAR AHSchmittInput;   // не 0, если AH выводы имеют на входе триггер Шмитта
   UCHAR AHDriveCurrent;   // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR BLSlowSlew;       // не 0, если BL выводы имеют низкую скорость переключения
   UCHAR BLSchmittInput;   // не 0, если BL выводы имеют на входе триггер Шмитта
   UCHAR BLDriveCurrent;   // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR BHSlowSlew;       // не 0, если BH выводы имеют низкую скорость переключения
   UCHAR BHSchmittInput;   // не 0, если BH выводы имеют на входе триггер Шмитта
   UCHAR BHDriveCurrent;   // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   // Опции аппаратуры
   UCHAR AIsFifo;          // не 0, если интерфейс 245 FIFO
   UCHAR AIsFifoTar;       // не 0, если интерфейс 245 FIFO CPU target
   UCHAR AIsFastSer;       // не 0, если интерфейс Fast serial
   UCHAR BIsFifo;          // не 0, если интерфейс 245 FIFO
   UCHAR BIsFifoTar;       // не 0, если интерфейс 245 FIFO CPU target
   UCHAR BIsFastSer;       // не 0, если интерфейс Fast serial
   UCHAR PowerSaveEnable;  // не 0, если BCBUS7 используется для управления 
                           // энергопотреблением в случае своего питания
   // Опции драйвера
   UCHAR ADriverType;
   UCHAR BDriverType;
} FT_EEPROM_2232H, *PFT_EEPROM_2232H;

typedef struct ft_eeprom_4232h
{
   // Общий заголовок
   FT_EEPROM_HEADER common;// общие элементы EEPROM для всех устройств
   // Опции нагрузочной способности
   UCHAR ASlowSlew;        // не 0, если A выводы имеют низкую скорость переключения
   UCHAR ASchmittInput;    // не 0, если A выводы имеют на входе триггер Шмитта
   UCHAR ADriveCurrent;    // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR BSlowSlew;        // не 0, если B выводы имеют низкую скорость переключения
   UCHAR BSchmittInput;    // не 0, если B выводы имеют на входе триггер Шмитта
   UCHAR BDriveCurrent;    // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR CSlowSlew;        // не 0, если C выводы имеют низкую скорость переключения
   UCHAR CSchmittInput;    // не 0, если C выводы имеют на входе триггер Шмитта
   UCHAR CDriveCurrent;    // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR DSlowSlew;        // не 0, если D выводы имеют низкую скорость переключения
   UCHAR DSchmittInput;    // не 0, если D выводы имеют на входе триггер Шмитта
   UCHAR DDriveCurrent;    // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   // Опции аппаратуры
   UCHAR ARIIsTXDEN;       // не 0, если port A использует RI как RS485 TXDEN
   UCHAR BRIIsTXDEN;       // не 0, если port B использует RI как RS485 TXDEN
   UCHAR CRIIsTXDEN;       // не 0, если port C использует RI как RS485 TXDEN
   UCHAR DRIIsTXDEN;       // не 0, если port D использует RI как RS485 TXDEN
   // Опции драйвера
   UCHAR ADriverType;
   UCHAR BDriverType;
   UCHAR CDriverType;
   UCHAR DDriverType;
} FT_EEPROM_4232H, *PFT_EEPROM_4232H;

typedef struct ft_eeprom_232h
{
   // Общий заголовок
   FT_EEPROM_HEADER common;// общие элементы EEPROM для всех устройств
   // Опции нагрузочной способности
   UCHAR ACSlowSlew;       // не 0, если AC bus выводы имеют низкую скорость переключения
   UCHAR ACSchmittInput;   // не 0, если AC bus выводы имеют на входе триггер Шмитта
   UCHAR ACDriveCurrent;   // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR ADSlowSlew;       // не 0, если AD bus выводы имеют низкую скорость переключения
   UCHAR ADSchmittInput;   // не 0, если AD bus выводы имеют на входе триггер Шмитта
   UCHAR ADDriveCurrent;   // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   // Опции CBUS
   UCHAR Cbus0;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus1;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus2;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus3;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus4;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus5;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus6;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus7;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus8;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus9;            // управление мультиплексором CBUS (Cbus Mux control)
   // FT1248 options
   UCHAR FT1248Cpol;       // FT1248 полярность тактов - clock idle лог. 1 (1) или лог. 0 (0)
   UCHAR FT1248Lsb;        // FT1248 порядок следования данных, сначала LSB (1) или MSB (0)
   UCHAR FT1248FlowControl;// FT1248 разрешение управлением потоком (flow control)
   // Опции аппаратуры
   UCHAR IsFifo;           // не 0, если интерфейс 245 FIFO
   UCHAR IsFifoTar;        // не 0, если интерфейс 245 FIFO CPU target
   UCHAR IsFastSer;        // не 0, если интерфейс Fast serial
   UCHAR IsFT1248          // не 0, если интерфейс FT1248
   UCHAR PowerSaveEnable;
   // Опции драйвера
   UCHAR DriverType;
} FT_EEPROM_232H, *PFT_EEPROM_232H;

typedef struct ft_eeprom_x_series
{
   // Общий заголовок
   FT_EEPROM_HEADER common;// общие элементы EEPROM для всех устройств
   // Опции нагрузочной способности
   UCHAR ACSlowSlew;       // не 0, если AC bus выводы имеют низкую скорость переключения
   UCHAR ACSchmittInput;   // не 0, если AC bus выводы имеют на входе триггер Шмитта
   UCHAR ACDriveCurrent;   // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   UCHAR ADSlowSlew;       // не 0, если AD bus выводы имеют низкую скорость переключения
   UCHAR ADSchmittInput;   // не 0, если AD bus выводы имеют на входе триггер Шмитта
   UCHAR ADDriveCurrent;   // допустимые значения 4 мА, 8 мА, 12 мА, 16 мА
   // Опции CBUS
   UCHAR Cbus0;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus1;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus2;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus3;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus4;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus5;            // управление мультиплексором CBUS (Cbus Mux control)
   UCHAR Cbus6;            // управление мультиплексором CBUS (Cbus Mux control)
   // Опции сигналов UART
   UCHAR InvertTXD;        // не 0, если инверсия TXD
   UCHAR InvertRXD;        // не 0, если инверсия RXD
   UCHAR InvertRTS;        // не 0, если инверсия RTS
   UCHAR InvertCTS;        // не 0, если инверсия CTS
   UCHAR InvertDTR;        // не 0, если инверсия DTR
   UCHAR InvertDSR;        // не 0, если инверсия DSR
   UCHAR InvertDCD;        // не 0, если инверсия DCD
   UCHAR InvertRI;         // не 0, если инверсия RI
   // Опции детектирования заряда батареи (Battery Charge Detect)
   UCHAR BCDEnable;        // разрешить Battery Charger Detection
   UCHAR BCDForceCbusPWREN;// выставляет сигнал power enable на CBUS, когда
                           // был детектирован порт зарядки
   UCHAR BCDDisableSleep;  // принудительно запрещает устройству переходить в sleep mode
   // Опции I2C
   WORD I2CSlaveAddress;   // Адрес подчиненного устройства на шине I2C (I2C slave device address)
   DWORD I2CDeviceId;      // Идентификатор устройства на шине I2C (I2C device ID)
   UCHAR I2CDisableSchmitt;// Запрет триггера Шмитта на шине I2C
   // FT1248 options
   UCHAR FT1248Cpol;       // FT1248 полярность тактов - clock idle лог. 1 (1),
                           // или лог. 0 (0)
   UCHAR FT1248Lsb;        // FT1248 порядок следования данных, сначала LSB (1) или MSB (0)
   UCHAR FT1248FlowControl;// FT1248 разрешение управлением потоком (flow control)
   // Опции аппаратуры
   UCHAR RS485EchoSuppress;
   UCHAR PowerSaveEnable;
   // Опции драйвера
   UCHAR DriverType;
} FT_EEPROM_X_SERIES, *PFT_EEPROM_X_SERIES;

OPEN_EXISTING = 3
FILE_ATTRIBUTE_NORMAL   = 0x00000080
FILE_FLAG_OVERLAPPED    = 0x40000000
GENERIC_READ            = 0x80000000
GENERIC_WRITE           = 0x40000000

typedef struct _OVERLAPPED
{
   ULONG_PTR Internal;
   ULONG_PTR InternalHigh;
   union
   {
      struct
      {
         DWORD Offset;
         DWORD OffsetHigh;
      };
      PVOID Pointer;
   };
   HANDLE hEvent;
} OVERLAPPED, *LPOVERLAPPED;

CLRDTR = 6           // Сброс сигнала DTR
CLRRTS = 4           // Сброс сигнала RTS
SETDTR = 5           // Установка сигнала DTR
SETRTS = 3           // Установка сигнала RTS
SETBREAK = 8         // Установка состояния останова (BREAK condition)
CLRBREAK = 9         // Сброс состояния останова (non-BREAK condition)
MS_CTS_ON   = 0x0010 // Сигнал Clear To Send (CTS) в лог. 1
MS_DSR_ON   = 0x0020 // Сигнал Data Set Ready (DSR) в лог. 1
MS_RING_ON  = 0x0040 // Сигнал Ring Indicator (RI) в лог. 1
MS_RLSD_ON  = 0x0080 // Receive Line Signal Detect (RLSD) в лог. 1

typedef struct _FTDCB
{
   DWORD DCBlength;     // sizeof(FTDCB)
   DWORD BaudRate;      // Скорость
   DWORD fBinary: 1;    // Binary Mode (пропуск проверки EOF)
   DWORD fParity: 1;    // Разрешение проверки на четность
   DWORD fOutxCtsFlow:1;// Управление выходом CTS handshaking
   DWORD fOutxDsrFlow:1;// Управление выходом DSR handshaking
   DWORD fDtrControl:2; // Управление потоком DTR
   DWORD fDsrSensitivity:1;   // Чувствительность DSR
   DWORD fTXContinueOnXoff: 1;// Продолжение TX, когда отправлен Xoff
   DWORD fOutX: 1;      // Разрешить на выходе X-ON/X-OFF
   DWORD fInX: 1;       // Разрешить на входе X-ON/X-OFF
   DWORD fErrorChar: 1; // Разрешить замену при ошибке (Err Replacement)
   DWORD fNull: 1;      // Разрешить Null stripping
   DWORD fRtsControl:2; // Управление потоком RTS
   DWORD fAbortOnError:1; // Оборвать все чтения и записи при ошибке
   DWORD fDummy2:17;    // Зарезервировано
   WORD wReserved;      // Пока не используется
   WORD XonLim;         // Порог передачи X-ON
   WORD XoffLim;        // Порог передачи X-OFF
   BYTE ByteSize;       // Размер фрейма (количество бит в байте), 7-8
   BYTE Parity;         // 0..4: None, Odd, Even, Mark, Space
   BYTE StopBits;       // 0, 2: 1, 2
   char XonChar;        // Символ X-ON для Tx и Rx 
   char XoffChar;       // Символ X-OFF для Tx и Rx 
   char ErrorChar;      // Символ замены при ошибке (Error replacement char)
   char EofChar;        // Символ окончания ввода (End of Input character)
   char EvtChar;        // Символ приема события (Received Event character)
   WORD wReserved1;     // Зарезервировано
} FTDCB, *LPFTDCB;

typedef struct _FTTIMEOUTS
{
   DWORD ReadIntervalTimeout;         // max время между читаемыми символами
   DWORD ReadTotalTimeoutMultiplier;  // множитель для символов
   DWORD ReadTotalTimeoutConstant;    // константа в миллисекундах
   DWORD WriteTotalTimeoutMultiplier; // множитель для символов
   DWORD WriteTotalTimeoutConstant;   // константа в миллисекундах
} FTTIMEOUTS, *LPFTTIMEOUTS;

EV_BREAK       = 0x0040 // детектировано BREAK condition
EV_CTS         = 0x0008 // изменился Clear To Send (CTS)
EV_DSR         = 0x0010 // изменился Data Set Ready (DSR)
EV_ERR         = 0x0080 // ошибка в состоянии линии
EV_RING        = 0x0100 // изменился Ring Indicator (RI)
EV_RLSD        = 0x0020 // изменился Receive Line Signal Detect (RLSD)
EV_RXCHAR      = 0x0001 // принят символ
EV_RXFLAG      = 0x0002 // событие приема символа
EV_TXEMPTY     = 0x0004 // передатчик пуст
PURGE_TXABORT  = 0x0001 // оборвать текущие overlapped-записи
PURGE_RXABORT  = 0x0002 // оборвать текущие overlapped-чтения
PURGE_TXCLEAR  = 0x0004 // очистка буфера передачи
PURGE_RXCLEAR  = 0x0008 // очистка буфера приема

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;