Особенности работы с COM-портом

 #include <vcl.h>
 #pragma hdrstop
 #include "MainForm.h"
// ---------------------------------------------------------------------------
 #pragma package(smart_init)
 #pragma resource "*.dfm"
 TForm1 *Form1;
 
// Ёмкость буфера
 #define BUFSIZE 1023
// Приёмный буфер
 unsigned char bufrd[BUFSIZE];
// Передающий буфер
 unsigned char bufwr[BUFSIZE];
// Дескриптор порта
 HANDLE COMport;
/* Флаг, указывающий на успешность операций записи:
 * 1 - успешно, 0 - не успешно. */
 bool fl = 0;
 
// Функция открыть порт
 void COMOpen(void);
// функция закрыть порт
 void COMClose(void);
 
/* Поток для чтения последовательности
 * байтов из COM-порта в буфер.   */
 class ReadThread : public TThread
  {
  // Вывод принятых байтов на экран и в файл
    private:
     void __fastcall Printing();
  // Основная функция потока
    protected:
     void __fastcall Execute();
  // Конструктор потока
    public:
     __fastcall ReadThread(bool CreateSuspended);
  };
 
/* Поток для записи последовательности байтов
 * из буфера в COM-порт. */
 class WriteThread : public TThread
  {
  // Основная функция потока
    protected:
     void __fastcall Execute();
  // Конструктор потока
    public:
     __fastcall WriteThread(bool CreateSuspended);
  };
 
// Объект потока чтения данных ReadThread
   ReadThread *reader;
// Объект потока передачи данных WriteThread
   WriteThread *writer;
   
// ------------------------------------------------------------------
// Конструктор формы, инициализация элементов формы
 __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
   {
   // Инициализация элементов формы при запуске программы
      Button1 -> Enabled = false;
   }
// -------------------------------------------------------------------
 
 
// НАЖАТИЕ НА КНОПКУ "ОТКРЫТЬ ПОРТ" 
 void __fastcall TForm1::SpeedButton1Click(TObject *Sender)
  {
   if(SpeedButton1->Down)
    {
    
    // Если кнопка нажата - вызываем функцию открытия порта
       COMOpen();
    
    // Показать/спрятать элементы на форме
       Form1 -> ComboBox1 -> Enabled = false;
       Form1 -> ComboBox2 -> Enabled = false;
       Form1 -> Button1 -> Enabled = true;
    // Изменить надпись на кнопке
       Form1 -> SpeedButton1 -> Caption = "Закрыть порт";
    }
  // Иначе: кнопка отжата - закрываем порт
   else
    {
    // Если кнопка отжата - вызов функции закрытия порта
       COMClose();
    // **************  Сервисные операции  ***************
    // Сменить надпись на кнопке
       Form1 -> SpeedButton1 -> Caption = "Открыть порт";
    // Показать/спрятать элементы на форме
       Form1 -> ComboBox1 -> Enabled = true;
       Form1 -> ComboBox2 -> Enabled = true;
       Form1 -> Button1 -> Enabled = false;
    }
  }
// --------------------------------------------------------
// НАЖАТИЕ НА КНОПКУ "ПЕРЕДАТЬ"
 void __fastcall TForm1::Button1Click(TObject *Sender)
  {
  // Передача данных
  /* Очистить программный передающий буфер, чтобы данные
   * не накладывались друг на друга.  */
     memset(bufwr, 0, BUFSIZE);
  // Очистить передающий буфер порта
     PurgeComm(COMport, PURGE_TXCLEAR);
  // Занести в программный передающий буфер строку из Edit1
     strcpy(bufwr, Form1-> Edit1->Text.c_str());
  // Активировать поток записи в порт
     writer -> Resume();
 }
//---------------------------------------------------------------------------
// ЗАКРЫТЬ ФОРМУ
 void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
  {
  /* Завершить поток чтения из порта. При этом проверка
   * "if(reader)" обязательна, иначе возникают ошибки. */
    if(reader)
     {
        reader -> Terminate();
     // Возможно, добавить очистку буфера
     }
  // ------------------------------------------------------
  /* Завершить поток записи в порт, при этом проверка
   * "if(writer)" обязательна, иначе возникает ошибка. */
    if(writer)
     {
        writer -> Terminate();
     // Возможно надо добавить очистку буфера
     }
  // ------------------------------------------------------
  // Проверить открыт ли порт
    if(COMport)
     {
     // Если открыт - вызываем функцию закрытия порта
        CloseHandle(COMport);
     }
  }
// ------------------------------------------------------------------
 
// Конструктор потока ReadThread, по умолчанию пустой
 __fastcall ReadThread::ReadThread(bool CreateSuspended) : TThread(CreateSuspended)
   {
   }
//---------------------------------------------------------------------------
/* Главная функция потока, реализующая приём байтов из COM-порта.  */
 void __fastcall ReadThread::Execute()
  {
  /* Структура текущего состояния порта, в данной программе используется
   * для определения количества принятых в порт байтов. */
     COMSTAT comstat;
  // Переменная "temp" используется в качестве заглушки
     DWORD btr, temp;
  // Пока поток не будет прерван, выполняем цикл
    while(!Terminated)
     {
     /* Нужно заполнить структуру "COMSTAT" и
      * получить из неё количество принятых байтов. */
        ClearCommError(COMport, &temp, &comstat);
        btr = comstat.cbInQue;
     // Если действительно есть байты для чтения
       if(btr)
        {
        // Прочитать байты из порта в буфер программы
           ReadFile(COMport, bufrd, btr, &temp, NULL);
        // Вызываем функцию для вывода данных на экран и в файл
           Synchronize(Printing);
        }
     }
  }
//---------------------------------------------------------------------------
// ***********  Функция вывода принятых байтов  **********
 void __fastcall ReadThread::Printing()
  {
  // Выводим принятую строку в Memo
     Form1 -> Memo1 -> Lines -> Add((char*)bufrd);
  // Очистить буфер (чтобы данные не накладывались друг на друга)
     memset(bufrd, 0, BUFSIZE);
  }
// ---------------------------------------------------------------
 
// ***********  ЗАПУСК ПОТОКА ПЕРЕДАЧИ ДАННЫХ  ***********
// -------------------------------------------------------------------
// Конструктор потока WriteThread, по умолчанию пустой
 __fastcall WriteThread::WriteThread(bool CreateSuspended) : TThread(CreateSuspended)
   {
   }
// ---------------------------------------------------------------------
 
/* Главная функция потока, реализующая передачу байтов из буфера в COM-порт. */
 void __fastcall WriteThread::Execute()
  {
  // temp - переменная-заглушка
     DWORD temp, signal;
  // Пока поток не будет завершён, выполнять цикл
    while(!Terminated)
     {
     // Записать байты в порт (перекрываемая операция!)
        WriteFile(COMport, bufwr, strlen(bufwr), &temp, NULL);
     /* Приостановить поток записи в порт,
      * пока он не потребуется снова  */
        writer -> Suspend();
   }
 }
// ---------------------------------------------------------------------------
 
// ИНДЕКСАЦИЯ И ОТКРЫТИЕ ПОРТА
 void COMOpen()
  {
  // Имя порта: "COM1", "COM2" и т. д.
     String portname;
  // Структура для общей инициализации порта DCB
     DCB dcb;
  // Структура для установки таймаутов
     COMMTIMEOUTS timeouts;
  // Получить имя выбранного порта
     portname = Form1 -> ComboBox1 -> Text;
  // Открыть порт синхронных операций
     COMport = CreateFile(portname.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  // -------------------------------------------------------------
  /* Здесь:
   * - portname.c_str() - имя порта в качестве имени файла,
   * c_str() преобразует строку типа String в строку в
   * виде массива типа char, иначе функция не примет;
   * - GENERIC_READ | GENERIC_WRITE - доступ к порту
   * на чтение/записть;
   * - 0 - порт не может быть общедоступным (shared);
   * - NULL - дескриптор порта не наследуется,
   * используется дескриптор безопасности по умолчанию;
   * - OPEN_EXISTING - порт должен открываться как уже
   * существующий файл;
   * - 0 - этот флаг указывает на использование
   * синхронных операций;
   * - NULL - указатель на файл шаблона не используется
   * при работе с портами.       */
  // ------------------------------------------------------
  // Проверка открытия порта
    if(COMport == INVALID_HANDLE_VALUE)
     {
     // Если ошибка открытия порта
     // Отжать кнопку
        Form1 -> SpeedButton1 -> Down = false;
     // Вывести сообщение
        ShowMessage("Не удалось открыть порт!");
       return;
     }
  // -------------------------------------------------
  // Инициализация порта
  // Определить размер и выделить память для структуры "DCB"
     dcb.DCBlength = sizeof(DCB);
  // ---------------------------------------------------
  /* В первое поле структуры DCB необходимо занести её
   * длину, она будет использоваться функциями настройки
   * порта для контроля корректности структуры. */
  // ---------------------------------------------------
  // Считать структуру DCB из порта
    if(!GetCommState(COMport, &dcb))
     {
     /* Если прочитать не удалось - закрыть порт и
      * вывести сообщение об ошибке в строке состояния. */
     // Вызов функции закрытия порта
        COMClose();
     // Вывод сообщения
        ShowMessage("Не удалось считать DCB!");
       return;
     }
  // --------------------------------------------------------
  // Инициализация структуры DCB
  // Задаём скорость передачи
     dcb.BaudRate = StrToInt(Form1 -> ComboBox2 -> Text);
  // Включаем двоичный режим обмена
     dcb.fBinary = TRUE;
  // Выключаем режим слежения за сигналом CTS
     dcb.fOutxCtsFlow = FALSE;
  // Выключаем режим слежения за сигналом DSR
     dcb.fOutxDsrFlow = FALSE;
  // Отключаем использование линии DTR
     dcb.fDtrControl = DTR_CONTROL_DISABLE;
  /* Отключаем восприимчивость драйвера
   * к состоянию линии DSR. */
     dcb.fDsrSensitivity = FALSE;
  // Разрешить приём нулевых байтов
     dcb.fNull = FALSE;
  // Отключаем использование линии RTS
     dcb.fRtsControl = RTS_CONTROL_DISABLE;
  /* Отключаем остановку всех операций
   * чтения/записи при ошибке.  */
     dcb.fAbortOnError = FALSE;
  // Задаём 8 бит в байте
     dcb.ByteSize = 8;
  // Отключаем проверку чётности
     dcb.Parity = 0;
  // Задаём один стоп-бит
     dcb.StopBits = 0;
  // Загрузить структуру DCB в порт
    if(!SetCommState(COMport, &dcb))
     {
     /* Если не удалось - закрыть порт и вывести
      * сообщение об ошибке в строке состояния. */
     // Вызов функции закрытия порта
        COMClose();
     // Вывод сообщения
        ShowMessage("Не удалось установить DCB!");
       return;
     }
  // ------------------------------------------------------
  // Установка таймаутов
  // Таймаут между двумя символами
     timeouts.ReadIntervalTimeout = 0;
  // Общий таймаут операции чтения
     timeouts.ReadTotalTimeoutMultiplier = 0;
  // Константа для общего таймаута операции чтения
     timeouts.ReadTotalTimeoutConstant = 0;
  // Общий таймаут операции записи
     timeouts.WriteTotalTimeoutMultiplier = 0;
  // Константа для общего таймаута операции записи
     timeouts.WriteTotalTimeoutConstant = 0;
  // Записать структуру таймаутов в порт
    if(!SetCommTimeouts(COMport, &timeouts))
     {
     /* Если не удалось - закрыть порт и вывести
      * сообщение об ошибке в строке состояния. */
     // Вызов функции закрытия порта
        COMClose();
     // Вывод сообщения
        ShowMessage("Не удалось установить тайм-ауты!");
       return;
     }
  // -------------------------------------------------------
  // Установка размеров очередей приёма и передачи
     SetupComm(COMport,2000,2000);
  // Очистить принимающий буфер порта
     PurgeComm(COMport, PURGE_RXCLEAR);
  // Создать поток чтения байтов
     reader = new ReadThread(false);
  /* Установить свойство "FreeOnTerminate" для потока
   * "reader", чтобы он автоматически уничтожался после
   * завершения чтения данных. */
     reader -> FreeOnTerminate = true;
  // Создать поток записи данных в порт
     writer = new WriteThread(true);
  /* Установить свойство "FreeOnTerminate", чтобы поток
   * "writer" автоматически уничтожался после завершения
   * передачи данных. */
     writer -> FreeOnTerminate = true;
  }
//--------------------------------------------------------------
 
// ФУНКЦИЯ ЗАКРЫТИЯ ПОРТА
 void COMClose()
  {
  /* Если поток записи существует, подать ему команду на
   * завершение и запустить его, чтобы он выполнил
   * завершение. При этом проверка "if(writer)"
   * обязательна, иначе возникает ошибка. */
    if(writer)
     {
        writer -> Terminate();
        writer -> Resume();
     // Здесь, возможно добавить очистку буфера
     }
  // -----------------------------------------------------
 /* Если поток чтения работает, завершить его; проверка
  * if(reader) обязательна, иначе возникают ошибки. */
   if(reader)
    {
       reader -> Terminate();
    // Здесь, возможно добавить очистку буфера
    // Закрыть порт
       CloseHandle(COMport);
    // Обнулить переменную для дескриптора порта
       COMport = 0;
    }
 }
// --------------------------------------------------------

void __fastcall ReadThread::Execute()
  {
  /* Структура текущего состояния порта, в данной программе используется
   * для определения количества принятых в порт байтов. */
     COMSTAT comstat;
  // Переменная "temp" используется в качестве заглушки
     DWORD btr, temp;
  // Пока поток не будет прерван, выполняем цикл
    while(!Terminated)
     {
     /* Нужно заполнить структуру "COMSTAT" и
      * получить из неё количество принятых байтов. */
        ClearCommError(COMport, &temp, &comstat);
        btr = comstat.cbInQue;
     // Если действительно есть байты для чтения
       if(btr)
        {
        // Прочитать байты из порта в буфер программы
           ReadFile(COMport, bufrd, btr, &temp, NULL);
        // Вызываем функцию для вывода данных на экран и в файл
           Synchronize(Printing);
        } 
       else
        {
           Sleep(10);
        }
     }
  }