Wiki

Эта страница только для чтения. Вы можете посмотреть её исходный текст, но не можете его изменить. Сообщите администратору, если считаете, что это неправильно.
[[:start|На главную]],  [[interfaces:start|Интерфейсы]]

----

====== Работа с COM-портом с помощью потоков ======
{{tag>Интерфейсы Com-порт WinAPI}}
Источник: [[http://piclist.ru/S-COM-THREAD-RUS/S-COM-THREAD-RUS.html|Работа с COM-портом с помощью потоков]]

Статья написана авторами сайта PIClist-RUS © [[http://piclist.ru/|piclist.ru]]

Скачать [[http://piclist.ru/S-COM-THREAD-RUS/COM_port_potoki_TThread_WINAPI.pdf|"COM-порт, работа с COM-портом с помощью потоков TThread и WINAPI"]] в формате **PDF** //(с сайта piclist.ru)//

Скачать [[http://piclist.ru/S-COM-THREAD-RUS/comprogs.rar|все три версии программы с исходными кодами]]. //(с сайта piclist.ru)//

===== Введение =====

Данная статья посвящена работе с COM-портом с помощью потоков под ОС Windows. Все приведённые здесь программы написаны в С++Builder 6 с использованием Windows-интерфейса, объектных классов и функций WINAPI.

Если вы ещё не работали с COM-портом в Windows, то рекомендуем сначала прочитать раздел [[interfaces:s-com-thread-rus#описание_программы|"Описание программы"]], в котором приводится описание инициализации порта и работы с ним.
===== Основные определения =====

//Перекрываемая операция (overlapped operation)// - асинхронная операция, называется перекрываемой, так как функция, которая её активировала, сразу возвращает управление программе, и та может продолжить выполнение других операций как бы поверх запущенной, не дожидаясь её завершения.

//Поток (thread)// - часть процесса. Потоки представляют собой как бы несколько параллельных нитей выполнения процесса. У процесса всегда есть как минимум один поток - главный.

//Функция ожидания// - функция, которая на некоторое время переводит поток в режим ожидания события. Благодаря этому поток не занимает процессорное время.

//Объект-событие (event)// - сигнальный объект, который имеет два состояние: сигнальное состояние (событие наступило) и несигнальное состояние (событие не наступило). Используется для управления и синхронизации потоков, ресурсов и т.п.

//Событие// - в данном случае - некоторое событие, связанное с портом. Например, ожидание поступления байта.

//Маска// - в данном случае битовая комбинация, показывающая, какие события учитывать, а какие нет.

===== Шаблоны потоков =====

Для работы с COM-портом необходимы, как минимум, два потока - для чтения байтов из порта и для записи их в порт.

==== Цикл чтения байтов внутри потока ====

Наибольшую сложность представляет собой именно чтение байтов из порта, так как данные поступают извне в большинстве случаев асинхронно.

Ниже приведён шаблон кода, который используется в главной функции потока чтения байтов, а также подробное его пояснение. Поправки, которые необходимо внести при создании потока с помощью класса TThread или функций WinAPI, приводятся в соответствующих разделах.

Кроме функции потока приведены объявления используемых в ней переменных.

<sxh cpp>
//---------------------------------------------------------------------------

#define BUFSIZE 255     //ёмкость буфера

unsigned char bufrd[BUFSIZE], bufwr[BUFSIZE]; //приёмный и передающий буферы

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

HANDLE COMport;		//дескриптор порта

//структура OVERLAPPED необходима для асинхронных операций, при этом для операции чтения и записи
//нужно объявить разные структуры
//эти структуры необходимо объявить глобально, иначе программа не будет работать правильно
OVERLAPPED overlapped;		//будем использовать для операций чтения (см. поток ReadThread)
OVERLAPPED overlappedwr;       	//будем использовать для операций записи (см. поток WriteThread)
//---------------------------------------------------------------------------

//главная функция потока, реализует приём байтов из COM-порта
{
 COMSTAT comstat;		//структура текущего состояния порта, в данной программе используется
                                //для определения количества принятых в порт байтов
 DWORD btr, temp, mask, signal;	//переменная temp используется в качестве заглушки

 //создать сигнальный объект-событие для асинхронных операций
 overlapped.hEvent = CreateEvent(NULL, true, true, NULL);

 //установить маску на срабатывание по событию приёма байта в порт
 SetCommMask(COMport, EV_RXCHAR);           		
 while(условие)	//пока поток не будет прерван, выполняем цикл
  {
   //ожидать события приёма байта (это и есть перекрываемая операция)
   WaitCommEvent(COMport, &mask, &overlapped);

   signal = WaitForSingleObject(overlapped.hEvent, INFINITE);	//приостановить поток до прихода байта
   if(signal == WAIT_OBJECT_0)				        //если событие прихода байта произошло
    {
     if(GetOverlappedResult(COMport, &overlapped, &temp, true)) //проверяем, успешно ли завершилась
								//перекрываемая операция WaitCommEvent
      if((mask & EV_RXCHAR)!=0)	                                //если произошло именно событие прихода байта
       {
        ClearCommError(COMport, &temp, &comstat);               //нужно заполнить структуру COMSTAT
        btr = comstat.cbInQue;                                  //и получить из неё количество принятых байтов
        if(btr)                                                 //если действительно есть байты для чтения
        {
         ReadFile(COMport, bufrd, btr, &temp, &overlapped);     //прочитать байты из порта в буфер программы
        }
       }
    }
  }
 CloseHandle(overlapped.hEvent);                                //перед выходом из потока закрыть объект-событие
}

//---------------------------------------------------------------------------
</sxh>
Теперь подробно объясним приведённый код.

Чтобы с портом можно было выполнять асинхронные операции, порт должен быть открыт (функцией **CreateFile()**) с флагом **FILE_FLAG_OVERLAPPED**. Это действие выполняется в функции открытия порта //COMOpen()// (описание функции см. [[interfaces:s-com-thread-rus#функция_открытия_и_инициализации_порта_comopen|ниже]]).

<sxh cpp>
HANDLE COMport;
COMport = CreateFile(cnum.c_str(),GENERIC_READ | GENERIC_WRITE, 0,
		     NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
</sxh>
Кроме того, для этого необходима структура типа **OVERLAPPED**, которая используется для управления перекрываемыми асинхронными операциями ввода/вывода. В данном случае она объявлена статически.

Важное замечание: структуру OVERLAPPED необходимо объявлять **глобально**, а не внутри потока, иначе программа будет работать некорректно (это проверено).

<code>OVERLAPPED overlapped; </code>

В этой структуре будем использовать только поле **hEvent**. Другие поля либо зарезервированы для операционной системы, либо не используются при работе с коммуникационными портами, и поэтому нас не интересуют.

Асинхронная операция подразумевает работу по событию, поэтому необходимо создать **сигнальный объект-событие**, который будет устанавливаться в сигнальное состояние по завершении операции, таким образом указывая программе, что перекрываемая операция завершена. Кроме того, этот объект-событие будет указывать функциям ожидания, используемым для приостановки потока, когда следует пробудить поток для обработки полученной информации.

Объект-событие создаётся с помощью функции **CreateEvent**. Эта функция возвращает дескриптор объекта, который и заносится в структуру типа OVERLAPPED:

<code>overlapped.hEvent = CreateEvent(NULL, true, true, NULL);</code>
Так как работа с портом будет выполняться в асинхронном режиме, для создаваемого события в функции CreateEvent нужно задать следующие значения передаваемых параметров: NULL, true, true, NULL.

Первый параметр, равный **NULL**, означает, что дескриптор создаваемого события не будет наследоваться дочерними процессами и будет использоваться дескриптор безопасности, заданный по умолчанию (к сожалению, авторы данной статьи не знают, что представляет собой дескриптор безопасности).

Второй параметр, равный **true**, задаёт тип объекта-события с **ручным переключением** в несигнальное состояние (переключение в несигнальное состояние в случае необходимости можно осуществить с помощью функции //ResetEvent//). Это необходимо, если мы хотим использовать функцию ожидания, такую как //WaitForSingleObject// (см. [[interfaces:s-com-thread-rus#Параметры функции CreateEvent|пояснения к параметрам функции CreateEvent]]).

Значение **true** третьего параметра указывает на то, что объект создаётся **в сигнальном состоянии**. Это нужно для того, чтобы предотвратить зависание программы в случае, если событие, ожидаемое функцией WaitCommEvent, произойдёт сразу после вызова функции.

Четвёртый параметр, равный **NULL**, означает, что объект создаётся без имени. Имя здесь не нужно, так как данный объект-событие используется внутри только одного процесса.

Создаваемый объект-событие связывается с дескриптором **hEvent** в структуре //OVERLAPPED//. Таким образом, перекрываемые операции могут использовать его, чтобы сообщать о своём завершении, установив его в сигнальное состояние, в то время как запустившая их функция может сразу возвратить управление программе, не дожидаясь завершения операции.

Чтобы отслеживать момент, когда в COM-порт пришёл байт, с помощью функции //SetCommMask// связываем с дескриптором порта маску события прихода байта //EV_RXCHAR//.

<code>SetCommMask(COMport, EV_RXCHAR);</code>
Функции, запускающие перекрываемые операции (такие как //ReadFile//, //WriteFile//, //WaitCommEvent// и т.п.), не дожидаются их завершения и сразу возвращают управление в программу. Если при этом операция не может быть завершена немедленно, функция вернёт FALSE, и система установит объект-событие в несигнальное состояние. Объект установится в сигнальное состояние только по завершении перекрываемой операции.

В данном случае перекрываемую операцию активирует функция **WaitCommEvent**. Она запускает ожидание события порта, заданного маской, и, если событие не наступает немедленно, передаёт управление обратно программе и возвращает FALSE, а система устанавливает объект-событие в **несигнальное** состояние.

<code>WaitCommEvent(COMport, &mask, &overlapped);</code>
Это позволяет запустить функцию ожидания, которая приостановит поток до того момента, пока перекрываемая операция не завершится, чтобы ожидающий событие поток не занимал процессорное время.

В качестве такой функции в данном случае выступает **WaitForSingleObject**.

<code>signal = WaitForSingleObject(overlapped.hEvent, INFINITE);</code>
Эта функция будет ждать, пока объект-событие, связанный со структурой OVERLAPPED, из несигнального состояния не перейдёт в сигнальное. Как только объект перейдёт в **сигнальное** состояние, //WaitForSingleObject// вернёт значение //WAIT_OBJECT_0// и активирует поток.

Кроме WAIT_OBJECT_0 эта функция может вернуть WAIT_FAILED (функция завершилась с ошибкой), WAIT_ABANDONED (связано с передачей не освобожденных мьютексов от завершившегося потока-владельца вызывающему потоку), WAIT_TIMEOUT (время ожидания завершено, а объект не установился в сигнальное состояние). Возникновение третьего случая предотвращаем установкой времени (таймаута) ожидания в INFINITE (переводится с английского как "бесконечно"). Второй случай нас не интересует (так как наш объект не является мьютексом, и такое значение не появится). А от первого случая ограждаемся проверкой возвращаемого значения на соответствие WAIT_OBJECT_0.

<code>if(signal == WAIT_OBJECT_0)</code>
Таким образом, как только произойдёт установленное маской событие, объект-событие перейдёт в сигнальное состояние и активирует приостановленный поток, который сможет продолжить своё выполнение.

Обратите внимание, что если объект-событие будет создан в **несигнальном** состоянии, а событие произойдёт сразу после запуска операции, объект не будет установлен в сигнальное состояние, и функция //WaitForSingleObject// будет вечно ждать его установки.

Как только поток активирован, функцией **GetOverlappedResult** нужно считать результат операции, запущенной //WaitCommEvent//. Функция //GetOverlappedResult// возвращает результат выполнения перекрываемой операции и в параметр mask, переданный в //WaitCommEvent//, заносит маску произошедших событий.

<code>if(GetOverlappedResult(COMport, &overlapped, &temp, true))</code>
Последний параметр функции //GetOverlappedResult//, равный **true**, заставляет её дожидаться, пока перекрываемая операция не завершится полностью.

После вызова //GetOverlappedResult// с помощью параметра //mask// следует выполнить проверку, произошло ли именно событие прихода байта.

<code>if((mask&EV_RXCHAR)!=0)</code>
Но так как в нашем случае отслеживается только одно событие, выполнять такую проверку не обязательно. Поэтому используем GetOverlappedResult только для определения успешности выполнения операции WaitCommEvent, чтобы выполнить чтение байтов только в случае успешного её завершения.

Теперь, когда известно, что байты получены, нужно выяснить, какое их количество находится в буфере. Для этого используем функцию **ClearCommError**, которая заполняет поля структуры //COMSTAT//. Одно из полей этой структуры, //cbInQue//, содержит количество байтов данных, содержащихся в буфере, но ещё не считанных функцией //ReadFile//.
<code>
ClearCommError(COMport, &temp, &curstat);
btr = curstat.cbInQue; </code>
Это количество байтов и будем считывать функцией ReadFile.
<code>
ReadFile(COMport, buf, btr, &temp, &overlapped);
</code>

=== Краткое описание алгоритма цикла чтения байтов ===
Таким образом, должна выполняться следующая последовательность действий:

**0)** при открытии порта для асинхронных операций функцией //CreateFile// нужно использовать флаг //FILE_FLAG_OVERLAPPED//, а также необходима структура //OVERLAPPED//;

**1)** функцией //CreateEvent// создаём сигнальный объект-событие с ручным сбросом в несигнальное состояние;

**2)** функцией SetCommMask устанавливаем маску ожидаемого события для открытого порта;

**3)** запускаем цикл, который буде работать все время существования потока;

**4)** функцией WaitCommEvent запускаем перекрываемую операцию ожидания этого события, при этом сигнальный объект-событие перейдёт в несигнальное состояние;

**5)** функцией //WaitForSingleObject// помещаем поток в состояние эффективного ожидания (приостанавливаем) до тех пор, пока не произойдет событие, и объект-событие не установится в сигнальное состояние;

**6)** когда событие произошло (объект-событие установился в сигнальное состояние), и поток активировался, функцией //GetOverlappedResult// проверяем результат операции //WaitCommEvent//. Если результат успешный, выполняем следующие шаги (7, 8 и 9), иначе - переходим на начало цикла (шаг 4);

**7)** по маске событий, которая передавалась в функцию WaitCommEvent, проверяем, что произошло именно событие прихода байта. Если маска в функции SetCommMask указывала только на одно это событие, проверку можно не выполнять.

**8)** функцией //ClearCommError// заполняем структуру //COMSTAT// и из её поля //cbInQue// считываем количество доступных для чтения байтов.

**9)** функцией //ReadFile// считываем эти байты.

**10)** переходим на начало цикла


==== Пояснение параметров функций ====

=== Параметры функции CreateEvent ===
<code>CreateEvent(NULL, true, true, NULL);</code>
Первый параметр, равный **NULL**, означает, что дескриптор создаваемого события не будет наследоваться дочерними процессами и будет использоваться дескриптор безопасности, заданный по умолчанию (к сожалению, авторы данной статьи не знают, что представляет собой дескриптор безопасности).

Второй параметр, равный **true**, означает, что тип объекта-события - объект с ручным переключением в несигнальное состояние (при использовании объектов такого типа переключение объекта в несигнальное состояние осуществляется с помощью функции //ResetEvent//). Если поставить //false//, то есть задать тип объекта как объект с автопереключением в несигнальное состояние, то этот объект нельзя будет использовать в функциях ожидания (таких как //WaitForSingleObject//), находящихся **между перекрываемой операцией и функцией //GetOverlappedResult//**. Если объект настроить как автопереключаемый, то //WaitForSingleObject// по завершении сбросит его в несигнальное состояние, и функция //GetOverlappedResult// заблокируется. Это произойдёт потому, что последний её параметр, установленный в //true//, заставляет её ждать до тех пор, пока перекрываемая операция не завершится, то есть сигнальный объект-событие не установится в сигнальное состояние, чего в данном случае не произойдёт. Установка последнего параметра функции //GetOverlappedResult// в //true// необходима, чтобы она дождалась завершения операции. Если этот параметр задать //false//, то если при вызове этой функции операция ещё не завершилась, она вернёт //false//, а функция //GetLastError// вернёт код ошибки //ERROR_IO_PENDING// (операция не завершена). В данном же случае нужно именно дождаться завершения операции, чтобы узнать её результат.

Значение **true** третьего параметра указывает на то, что объект создаётся в сигнальном состоянии. Это необходимо для предотвращения зависания программы, если событие, ожидаемое функцией //WaitCommEvent//, произойдёт немедленно после её вызова. В таком случае перекрываемая операция завершится сразу и не изменит состояние объекта-события. Это означает, что если он был создан в несигнальном состоянии, то в сигнальное состояние он не установится, и функция //WaitForSingleObject// будет ждать вечно его установки (то есть программа "зависнет"). А если объект-событие создан в сигнальном состоянии, то при немедленном завершении перекрываемой операции он не будет сброшен, и функция //WaitForSingleObject// выполнится и активирует поток.

Четвёртый параметр, равный **NULL**, означает, что объект создаётся без имени. Имя не нужно, так как объект-событие используется внутри только одного процесса.

=== Параметры функции SetCommMask ===
<code>SetCommMask(comport, EV_RXCHAR);</code>
Первый параметр - дескриптор открытого порта.

Второй параметр задаёт маску отслеживаемых событий. Может представлять комбинацию из нескольких значений (более подробно см. Builder Help). В данном случае отслеживается только одно событие - событие прихода байта (значение //EV_RXCHAR//).

=== Параметры функции WaitCommEvent ===
<code>WaitCommEvent(comport, &mask, &overlapped);</code>
Первый параметр - дескриптор порта.

Второй параметр - адрес переменной, в которую будет возвращена маска произошедших событий, если после завершения перекрываемой операции //WaitCommEvent// будет вызвана функция //GetOverlappedResult//. Причём маска будет содержать только те события, отслеживание которых было разрешено установкой маски функцией //SetCommMask//, и которые произошли.

Третий параметр - адрес структуры //OVERLAPPED//. В данном случае он задан, так как функция //WaitCommEvent// используется как асинхронная перекрываемая операция.


==== Поток записи байтов ====
Поток записи байтов в порт немного проще, чем поток чтения. Это связано с тем, что записью в порт мы можем управлять.

Ниже приведён шаблон потока записи в порт, поправки на TThread и WinAPI даны в соответствующих разделах.

<sxh cpp>
//---------------------------------------------------------------------------

//главная функция потока, выполняет передачу байтов из буфера в COM-порт

{
 DWORD temp, signal;	//temp - переменная-заглушка

 overlappedwr.hEvent = CreateEvent(NULL, true, true, NULL);     //создать событие

 //записать байты в порт (перекрываемая операция!)
 WriteFile(COMport, bufwr, strlen(bufwr), &temp, &overlappedwr);

 signal = WaitForSingleObject(overlappedwr.hEvent, INFINITE);   //приостановить поток, пока не завершится
                                                                //перекрываемая операция WriteFile
 //если операция завершилась успешно, установить соответствующий флажок
 if((signal == WAIT_OBJECT_0) && (GetOverlappedResult(COMport, &overlappedwr, &temp, true))) 
         fl = true;
 else 
         fl = false;

}

//---------------------------------------------------------------------------
</sxh>

Так как здесь тоже используется асинхронная перекрываемая операция (запись в порт функцией //WriteFile//), то в этом случае структура //OVERLAPPED// также необходима. Так как операции чтения и записи в данном примере могут выполняться параллельно, для операции записи необходимо создать свою структуру **OVERLAPPED**:
<code>OVERLAPPED overlappedwr;</code>
Её также необходимо объявить глобально.

Как и в потоке чтения, для асинхронной операции записи необходимо создать сигнальный объект-событие с помощью функции **CreateEvent**:

<code>overlappedwr.hEvent = CreateEvent(NULL, true, true, NULL);</code>

Параметры используются такие же: NULL, true, true, NULL.

Далее запускаем перекрываемую операцию записи функцией **WriteFile**:

<code>WriteFile(COMport, bufwr, strlen(bufwr), &temp, &overlappedwr);</code>

Здесь в функцию передаются следующие параметры:

//COMport// - дескриптор порта;

//bufwr// - указатель на передающий программный буфер, содержащий данные, которые нужно записать в порт;

//strlen(bufwr)// - количество байтов передаваемых данных, в данном случае - длина строки в буфере;

//&temp// - адрес переменной, в которую будет помещено число фактически записанных байтов;

//&overlappedwr// - адрес структуры //OVERLAPPED//, содержащей дескриптор сигнального объекта-события, используемого перекрываемой функцией //WriteFile//.

Чтобы поток не занимал процессорное время, ожидая, пока запущенная перекрываемая операция записи байтов в порт не завершится, его следует приостановить. Для этого также используется функция **WaitForSingleObject**:

<code>signal = WaitForSingleObject(overlappedwr.hEvent, INFINITE);</code>

Как только перекрываемая операция записи в порт завершится, сигнальный объект-событие с дескриптором //overlappedwr.hEvent// установится в сигнальное состояние и функция //WaitForSingleObject// активирует поток. При этом она должна вернуть значение //WAIT_OBJECT_0//, которое свидетельствует о том, что асинхронная перекрываемая операция завершилась. Любое другое значение, как и в случае с потоком чтения, будет свидетельствовать об ошибке. Если все-таки возвращено значение //WAIT_OBJECT_0//, то функцией **GetOverlappedResult** проверяем, успешно ли завершилась операция.

<code>if((signal == WAIT_OBJECT_0)&&(GetOverlappedResult(COMport, &overlappedwr, &temp, true))) fl = true;
else fl = false;</code>
Если успешно, то **GetOverlappedResult** вернёт true, тогда устанавливаем флажок //fl// в //true//. Если же операция завершилась неуспешно (//WaitForSingleObject// вернула значение, отличное от //WAIT_OBJECT_0//, либо //GetOverlappedResult// вернула //false//, либо оба случая сразу), флажок //fl// сбрасываем в //false//. По этому флажку потом можно будет определить, завершилась операция чтения успешно или нет.

На этом поток записи в порт завершается.
===== Создание потока =====
Для создания потоков можно использовать любой из двух способов:

**1)** создание потока с помощью класса **TThread**. В данном случае вы получаете возможность работы с потоком как с объектом - создавать, разрушать, выполнять инициализацию при создании, задавать для него дополнительные методы и свойства и тому подобное.

**2)** создание потока с помощью функций **WinAPI**. В этом случае поток создаётся в виде функции. То есть при создании потока ему передаётся функция, которую он будет исполнять.

Выбор способа создания потока зависит от конкретной задачи и пожеланий разработчика. В пределах одной программы даже (теоретически) возможно создание разных потоков, используя и первый, и второй способ.

В данном же примере описывается создание всех потоков программы либо только первым, либо только вторым способами.


==== Создание потока с помощью класса TThread ====

Сначала рассмотрим создание потока чтения, а затем по аналогии создадим поток записи.

=== Поток чтения из порта ===

В программе C++ Builder это можно сделать следующим образом: открыть меню //File->New->вкладка New->ThreadObject//. Затем в появившейся форме нужно задать имя нового класса-потока: //ReadThread//.

Появится новый файл с названием Unit2.cpp (или другой порядковый номер в зависимости от количества модулей). Если наличие нескольких модулей приемлемо, то этот файл просто нужно включить в проект через #include.

Если же нужно включить всё в один модуль (как и сделано в демонстрационной программе), то необходимо выполнить следующие действия:

**1)** Активировать вкладку с Unit2.cpp, если она еще не активирована.

**2)** Нажав на имя вкладки Unit2.cpp правой кнопкой мыши, выбрать пункт меню "Open Source/Header file" (Ctrl+F6). Затем скопировать из открывшегося файла Unit2.h следующее:

<code>//---------------------------------------------------------------------------
class ReadThread : public TThread
{
private:
protected:
        void __fastcall Execute();	//главная функция потока
public:
        __fastcall ReadThread(bool CreateSuspended);	//конструктор потока
};

//---------------------------------------------------------------------------
</code>
и добавить в главный модуль программы желательно вверху, там, где объявлены переменные и функции (то есть до того, как пользоваться потоком).

Это объявление класса //ReadThread//. В данном объявлении указывается защищённая функция //Execute()//, которая является основной исполняемой функцией класса потока, которая используется только этим классом и не видна извне (является закрытой). Открытая функция //ReadThread(bool CreateSuspended)// - это конструктор класса. О нём сказано ниже.

**3)** из файла Unit2.cpp скопировать следующее (поместить тоже до использования потоков):
<code>//---------------------------------------------------------------------------
__fastcall ReadThread::ReadThread(bool CreateSuspended)	//конструктор потока, по умолчанию - пустой
        : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
</code>
Это конструктор класса //ReadThread//. По умолчанию он является пустым, но при необходимости в него можно добавить какие-либо действия, которые будут выполняться при создании потока. (Создаваемый поток является объектом класса). Параметр //CreateSuspended// (создать в остановленном состоянии) определяет, будет ли запущен поток сразу после создания //(CreateSuspended = false)//, либо только после вызова метода //Resume()// (если //CreateSuspended = true//).
<code>
//---------------------------------------------------------------------------
void __fastcall ReadThread::Execute()
{
 //здесь вставляется код, который будет исполняться потоком
}
//---------------------------------------------------------------------------
</code>
Это - главная функция потока. Она начинает выполняться, когда поток запускается. В эту функцию и нужно добавить основной рабочий код потока. В данном случае - считывание данных из COM-порта:
<sxh cpp>
//---------------------------------------------------------------------------
void __fastcall ReadThread::Execute()
{
 OVERLAPPED over;
 COMSTAT curstat;
 DWORD btr, temp, temp, mask, signal;	//переменная temp используется в качестве заглушки

 over.hEvent = CreateEvent(NULL, true, true, NULL);  //создать событие; true,true - для асинхронных операций
 SetCommMask(comport, EV_RXCHAR);                    //маска = если принят байт
 while(!Terminated)					//пока поток не будет прерван, выполняем цикл
  {WaitCommEvent(comport, &mask, &over);                	//ожидать события принятия байта
   signal = WaitForSingleObject(over.hEvent, INFINITE); 	//усыпить поток до прихода байта
   if(signal == WAIT_OBJECT_0)					//если событие прихода байта произошло
    {if(GetOverlappedResult(comport, &over, &temp, true))	// проверяем, успешно ли завершилась
								// перекрываемая операция WaitCommEvent
      if((mask&EV_RXCHAR)!=0)					//если произошло именно событие прихода байта
       {ClearCommError(comport, &temp, &curstat);		//нужно заполнить структуру COMSTAT
        btr = curstat.cbInQue;                          	//получить количество принятых байтов
        if(btr) 						//если в буфере порта есть непрочитанные байты
          ReadFile(comport, buf, btr, &temp, &over);  		//прочитать байты из порта в буфер программы
       }
    }
  }
 CloseHandle(over.hEvent);		//закрыть объект-событие
}

//---------------------------------------------------------------------------
</sxh>
В случае использования потоков //TThread// в качестве условия в цикле ожидания и чтения байтов используется (**!Terminated**). Это означает, что данный цикл будет выполняться, пока поток не будет прерван с помощью метода **Terminate()**. Этот метод устанавливает свойство потока //Terminated// в //true//, таким образом сообщая потоку, что он должен завершиться как только это возможно. Проверяя этот флаг, поток может определить, когда он должен завершиться, и выполнить перед завершением какие-нибудь действия. В данном случае, получив запрос на завершение, поток выходит из цикла чтения байта (так как //Terminated// становится равен //true//) и освобождает дескриптор события //hEvent// в структуре типа //OVERLAPPED//, которая использовалась при асинхронных операциях. (Напомним, что этот объект событие был создан с помощью функции //CreateEvent//). После чего поток прекращает выполнение.

=== Использование метода Synchronize ===
В случае, когда поток делит графические компоненты и файлы с другими потоками, обращение к ним может привести к конфликту между потоками. Во избежание этих конфликтов используется метод **Synchronize(TThreadMethod &Method)**, который использует для обращения к компонентам очередь сообщений главного потока. Он выполняет переданный в него метод в главном потоке (этот поток отвечает за работу с графическими компонентами), причём поток, вызвавший метод Synchronize, приостанавливается на время выполнения этого метода.

Чтобы обратиться к графическим компонентам или файлу, сначала нужно создать отдельный метод потока и объявить его в объявлении класса:
<sxh cpp>
//---------------------------------------------------------------------------

class ReadThread : public TThread
{
private:
protected:
        void __fastcall Execute();
        void __fastcall Printing();  //добавлено вручную для использования в Synchronize
public:
        __fastcall ReadThread(bool CreateSuspended);
};

//---------------------------------------------------------------------------
</sxh>
И написать соответствующую функцию. Например:
<sxh cpp>
//---------------------------------------------------------------------------

//выводим принятые байты на экран и в файл (если включено)
void __fastcall ReadThread::Printing()
{
 //выводим принятую строку в Memo
 Form1->Memo1->Lines->Add((char*)bufrd);

 //выводим счётчик в строке состояния
 Form1->StatusBar1->Panels->Items[2]->Text = "Всего принято " + IntToStr(counter) + " байт";

 if(Form1->CheckBox3->Checked == true)  //если включен режим вывода в файл
  {
   write(handle, bufrd, strlen(bufrd)); //записать в файл данные из приёмного буфера
  }
 memset(bufrd, 0, BUFSIZE);		//очистить буфер (чтобы данные не накладывались друг на друга)
}

//---------------------------------------------------------------------------
</sxh>
Эта функция выполняет вывод текущего состояния на форму и запись принимаемых данных в файл.

После этого в функции Execute() потока добавить метод Synchronize(функция) в месте, где требуется вызвать функцию, работающую с графическими компонентами или файлами. Например:
<sxh cpp>
//---------------------------------------------------------------------------
void __fastcall ReadThread::Execute()
{

...

Synchronize(Printing);
}
//---------------------------------------------------------------------------
</sxh>

=== Как использовать поток ===

**1)** //Класс// - это тип данных, определяемый пользователем. //Объект// - конкретный экземпляр данного класса. Это аналогично типу данных (например, int) и переменной данного типа (например, i).

То есть перед тем, как можно будет создать и запустить поток, необходимо объявить объект класса, то есть некую переменную типа //ReadThread//, например:

<code>ReadThread *reader;     //объект потока ReadThread </code>

Нужно сделать ее глобальной, чтобы иметь возможность доступа к ней из других функций. Сам класс //ReadThread// должен быть объявлен раньше.

**2)** Теперь нужно создать поток:
<sxh cpp>
reader = new ReadThread(false);	//создать и запустить поток чтения байтов
reader->FreeOnTerminate = true; //установить это свойство потока,
				//чтобы он автоматически уничтожался после завершения
</sxh>

В первой строке мы создаём объект класса //ReadThread//. Для этого вызывается конструктор потока //ReadThread()//, которому в качестве аргумента передаётся значение //false//. Это означает, что поток начинает работать сразу после создания (см. __описание конструктора выше__). Почему так сделано? Потому что в данной версии программы поток создаётся в функции открытия порта //COMOpen()//, то есть когда нужно начинать считывать байты (сразу после открытия порта).

Следует отметить, что потоки создаются только динамическим образом, то есть используя указатель //(*reader)// и оператор //new (new ReadThread(false))//.

Далее установим свойство потока **FreeOnTerminate** в //true//, чтобы объект потока освобождался после завершения его работы, так как здесь нам не нужно освобождать его вручную.

То есть в целом создание потока будет выглядеть так:
<sxh cpp>
ReadThread *reader;     	//объект потока ReadThread
reader = new ReadThread(false);	//создать и запустить поток чтения байтов
reader->FreeOnTerminate = true; //установить это свойство потока,
				//чтобы он автоматически уничтожался после завершения
</sxh>
После того, как поток больше не нужен, его следует завершить, используя метод Terminate(). Как говорилось выше, этот метод устанавливает флаг потока Terminated в true, сообщая потоку, что он должен завершиться.

То есть, вызываем завершение потока таким образом:

<code>if(reader)reader->Terminate();</code>

Проверка if(reader) необходима, если её не делать, будут возникать ошибки (это проверено).

Уничтожение потока в первой версии программы производится в функции закрытия порта //COMClose()//. Таким образом, при открытии порта необходимо создавать поток заново, как и было реализовано в функции //COMOpen()// в этой версии программы (см. ниже).

Для обработки завершения потока можно определить обработчик события //OnTerminate//, который вызывается между окончанием выполнения потока (когда он выполнил //return//) и его разрушением. В этом обработчике можно свободно работать с графическими компонентами, так как он исполняется в контексте основного потока программы. То есть в этом обработчике можно определить некоторый код, который, например, будет освобождать объект потока или выводить на форму какое-то сообщение.

Полностью код потока чтения выглядит так:
<sxh cpp>
//---------------------------------------------------------------------------

//поток для чтения последовательности байтов из COM-порта в буфер
class ReadThread : public TThread
{
 private:
        void __fastcall Printing();	//вывод принятых байтов на экран и в файл
 protected:
        void __fastcall Execute();	//основная функция потока
 public:
        __fastcall ReadThread(bool CreateSuspended);	//конструктор потока
};

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

//-----------------------------------------------------------------------------
//............................... поток ReadThead .............................
//-----------------------------------------------------------------------------

ReadThread *reader;     //объект потока ReadThread

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

//конструктор потока ReadThread, по умолчанию пустой
__fastcall ReadThread::ReadThread(bool CreateSuspended) : TThread(CreateSuspended)
{}

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

//главная функция потока, реализует приём байтов из COM-порта
void __fastcall ReadThread::Execute()
{
 COMSTAT comstat;		//структура текущего состояния порта, в данной программе используется
				//для определения количества принятых в порт байтов
 DWORD btr, temp, mask, signal;	//переменная temp используется в качестве заглушки

 //создать сигнальный объект-событие для асинхронных операций
 overlapped.hEvent = CreateEvent(NULL, true, true, NULL);

 SetCommMask(COMport, EV_RXCHAR);                   	   // установить маску на срабатывание по событию
							   // приёма байта в порт
 while(!Terminated)					   //пока поток не будет прерван, выполняем цикл
  {
   WaitCommEvent(COMport, &mask, &overlapped);               	// ожидать события приёма байта
								// (это и есть перекрываемая операция)
   signal = WaitForSingleObject(overlapped.hEvent, INFINITE);	//приостановить поток до прихода байта
   if(signal == WAIT_OBJECT_0)				        //если событие прихода байта произошло
    {
     if(GetOverlappedResult(COMport, &overlapped, &temp, true)) // проверяем, успешно ли завершилась
								// перекрываемая операция WaitCommEvent
      if((mask & EV_RXCHAR)!=0)					//если произошло именно событие прихода байта
       {
        ClearCommError(COMport, &temp, &comstat);		//нужно заполнить структуру COMSTAT
        btr = comstat.cbInQue;                          	//и получить из неё количество принятых байтов
        if(btr)                         			//если действительно есть байты для чтения
        {
         ReadFile(COMport, bufrd, btr, &temp, &overlapped);     //прочитать байты из порта в буфер программы
         counter+=btr;                                          //увеличиваем счётчик байтов
         Synchronize(Printing);                      //вызываем функцию для вывода данных на экран и в файл
        }
       }
    }
  }
 CloseHandle(overlapped.hEvent);		//перед выходом из потока закрыть объект-событие
}

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

//выводим принятые байты на экран и в файл (если включено)
void __fastcall ReadThread::Printing()
{
 //выводим принятую строку в Memo
 Form1->Memo1->Lines->Add((char*)bufrd);

 /выводим счётчик в строке состояния
 Form1->StatusBar1->Panels->Items[2]->Text = "Всего принято " + IntToStr(counter) + " байт";

 if(Form1->CheckBox3->Checked == true) //если включен режим вывода в файл
  {
   write(handle, bufrd, strlen(bufrd)); //записать в файл данные из приёмного буфера
  }
 memset(bufrd, 0, BUFSIZE); //очистить буфер (чтобы данные не накладывались друг на друга)
}

//---------------------------------------------------------------------------
</sxh>

=== Поток записи в порт ===
Поток записи в порт создаётся аналогично потоку чтения.

Точно так же как и для потока чтения, нужно создать объявление класса и для потока записи.
<sxh cpp>
//---------------------------------------------------------------------------

//поток для записи последовательности байтов из буфера в COM-порт
class WriteThread : public TThread
{
private:
 	void __fastcall Printing();	//вывод состояния на экран
protected:
        void __fastcall Execute();      //основная функция потока
public:
        __fastcall WriteThread(bool CreateSuspended);	//конструктор потока
};

//---------------------------------------------------------------------------
</sxh>
Здесь точно так же присутствуют конструктор класса потока записи //WriteThread(bool CreateSuspended)//, главная функция потока //Execute()// и дополнительная функция //Printing()//, которая используется для вывода результатов операции в строке состояния.

Основная функция потока //Execute()// выполняет передачу данных в порт:
<sxh cpp>
//---------------------------------------------------------------------------

//главная функция потока, выполняет передачу байтов из буфера в COM-порт
void __fastcall WriteThread::Execute()
{
 DWORD temp, signal;	//temp - переменная-заглушка

 overlappedwr.hEvent = CreateEvent(NULL, true, true, NULL);  //создать событие

 //записать байты в порт (перекрываемая операция!)
 WriteFile(COMport, bufwr, strlen(bufwr), &temp, &overlappedwr);

 //приостановить поток, пока не завершится перекрываемая операция WriteFile
 signal = WaitForSingleObject(overlappedwr.hEvent, INFINITE);

 //если операция завершилась успешно, установить соответствующий флажок
 if((signal == WAIT_OBJECT_0) && (GetOverlappedResult(COMport, &overlappedwr, &temp, true))) fl = true;
 else fl = false;

 Synchronize(Printing);	//вывести состояние операции в строке состояния
 CloseHandle(overlappedwr.hEvent);	//перед выходом из потока закрыть объект-событие
}

//---------------------------------------------------------------------------
</sxh>
Функция Printing() выполняет вывод состояния операции в строке состояния:
<sxh cpp>
//---------------------------------------------------------------------------

//вывод состояния передачи данных на экран
void __fastcall WriteThread::Printing()
{
 if(!fl)	//проверяем состояние флажка
  {
   Form1->StatusBar1->Panels->Items[0]->Text  = "Ошибка передачи";
   return;
  }
 Form1->StatusBar1->Panels->Items[0]->Text  = "Передача прошла успешно";
}

//---------------------------------------------------------------------------
<sxh>
Как и в случае с потоком чтения, для работы с потоком записи его сначала нужно создать.

Для этого выполняется следующее:

**1)** после объявления класса потока записи объявляется объект потока записи:

<code>WriteThread *writer;     //объект потока WriteThread</code>

Этот объект также должен быть объявлен глобально.

**2)** создать объект класса с помощью оператора new:
<sxh cpp>
writer = new WriteThread(false); //активировать поток записи данных в порт
writer->FreeOnTerminate = true;  //установить это свойство,
				 //чтобы поток автоматически уничтожался после завершения
</sxh>
Здесь также после создания потока устанавливается в true свойство FreeOnTerminate, чтобы поток автоматически уничтожался после завершения.

В программе поток создаётся при необходимости отправки данных - в обработчике нажатия кнопки "Передать":
<sxh cpp>
//---------------------------------------------------------------------------

//кнопка "Передать"
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 memset(bufwr,0,BUFSIZE);	    //очистить программный передающий буфер,
				    //чтобы данные не накладывались друг на друга
 PurgeComm(COMport, PURGE_TXCLEAR); //очистить передающий буфер порта
 strcpy(bufwr,Form1->Edit1->Text.c_str());//занести в программный передающий буфер строку из Edit1

 writer = new WriteThread(false);   //создать и активировать поток записи данных в порт
 writer->FreeOnTerminate = true;    //установить это свойство,
				    //чтобы поток автоматически уничтожался после завершения

}

//---------------------------------------------------------------------------
</sxh>
Когда поток больше не нужен, он также уничтожается вызовом метода Terminate():
<code>
//если поток записи работает, завершить его; проверка if(writer) обязательна, иначе возникают ошибки
if(writer)writer->Terminate();
</code>

А полностью код потока записи в порт выглядит так:

<sxh cpp>
//---------------------------------------------------------------------------

//поток для записи последовательности байтов из буфера в COM-порт
class WriteThread : public TThread
{
private:
 	void __fastcall Printing();	//вывод состояния на экран
protected:
        void __fastcall Execute();      //основная функция потока
public:
        __fastcall WriteThread(bool CreateSuspended);	//конструктор потока
};

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

//-----------------------------------------------------------------------------
//............................... поток WriteThead ............................
//-----------------------------------------------------------------------------

WriteThread *writer;     //объект потока WriteThread

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

//конструктор потока WriteThread, по умолчанию пустой
__fastcall WriteThread::WriteThread(bool CreateSuspended) : TThread(CreateSuspended)
{}

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

//главная функция потока, выполняет передачу байтов из буфера в COM-порт
void __fastcall WriteThread::Execute()
{
 DWORD temp, signal;	//temp - переменная-заглушка

 overlappedwr.hEvent = CreateEvent(NULL, true, true, NULL);   	  //создать событие

 //записать байты в порт (перекрываемая операция!)
 WriteFile(COMport, bufwr, strlen(bufwr), &temp, &overlappedwr);

 //приостановить поток, пока не завершится перекрываемая операция WriteFile
 signal = WaitForSingleObject(overlappedwr.hEvent, INFINITE);

 //если операция завершилась успешно, установить соответствующий флажок
 if((signal == WAIT_OBJECT_0) && (GetOverlappedResult(COMport, &overlappedwr, &temp, true))) fl = true;
 else fl = false;

 Synchronize(Printing);	//вывести состояние операции в строке состояния
 CloseHandle(overlappedwr.hEvent);	//перед выходом из потока закрыть объект-событие
}

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

//вывод состояния передачи данных на экран
void __fastcall WriteThread::Printing()
{
 if(!fl)	//проверяем состояние флажка
  {
   Form1->StatusBar1->Panels->Items[0]->Text  = "Ошибка передачи";
   return;
  }
 Form1->StatusBar1->Panels->Items[0]->Text  = "Передача прошла успешно";
}

//---------------------------------------------------------------------------
</sxh>

=== Использование методов Resume() и Suspend() ===
Вторая версия программы с использованием //TThread// демонстрирует использование методов **Resume()** и **Suspend()** для запуска и остановки потоков. В целом эта версия программы практически аналогична первой, все отличия связаны с использованием этих методов для управления потоком записи. Рассмотрим эти отличия:

**1)** В данном случае поток записи создаётся непосредственно в функции открытия порта //COMOpen()// после всех действий по открытию и инициализации порта (в конце функции), вместе с потоком чтения. При этом в конструктор потока чтения //ReadThread()//, как и в первой версии программы, передаётся параметр //false//, чтобы запустить поток чтения сразу после создания. А вот в конструктор потока записи //WriteThread()// передаётся параметр //true//, чтобы поток создался в остановленном состоянии. Будем запускать его по мере необходимости.
<sxh cpp>
reader = new ReadThread(false);	//создать и запустить поток чтения байтов
reader->FreeOnTerminate = true; //установить это свойство потока,
				//чтобы он автоматически уничтожался после завершения

writer = new WriteThread(true);  //создать поток записи данных в порт
writer->FreeOnTerminate = true; //установить это свойство,
				//чтобы поток автоматически уничтожался после завершения
</sxh>
**2)** Главное отличие этой версии в том, что поток записи не разрушается после отправки данных, а существует в течение всего времени, пока открыт порт. Благодаря этому не нужно создавать новый поток, а затем разрушать его, каждый раз, когда требуется отправить данные. Вместо этого поток приостанавливается на то время, пока он не нужен, и активируется, когда необходимо передать данные.

Таким образом, поток записи //writer// будем включать, когда необходимо передать данные, то есть при нажатии кнопки "Передать". Для этого используется метод **Resume()** (переводится с английского как "возобновить"):
<sxh cpp>
//кнопка "Передать"
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 memset(bufwr,0,BUFSIZE); //очистить программный передающий буфер,
			  //чтобы данные не накладывались друг на друга
 PurgeComm(COMport, PURGE_TXCLEAR);         //очистить передающий буфер порта
 strcpy(bufwr,Form1->Edit1->Text.c_str());  //занести в программный передающий буфер строку из Edit1
 writer->Resume();	//активировать поток записи в порт
}
</sxh>
Но каким-то образом нужно выключить поток, когда он больше не нужен. Самый лучший способ - поручить это самому потоку. То есть поток после выполнения передачи данных будет останавливать сам себя. Это поможет избежать повторной передачи одних и тех же данных.

Для этого построим код потока следующим образом:
<sxh cpp>
//---------------------------------------------------------------------------

//главная функция потока, выполняет передачу байтов из буфера в COM-порт
void __fastcall WriteThread::Execute()
{
 DWORD temp, signal;	//temp - переменная-заглушка

 overlappedwr.hEvent = CreateEvent(NULL, true, true, NULL);   	  //создать событие

 while(!Terminated)     //пока поток не будет завершён, выполнять цикл
 {
  //записать байты в порт (перекрываемая операция!)
  WriteFile(COMport, bufwr, strlen(bufwr), &temp, &overlappedwr);

  //приостановить поток, ппока не завершится перекрываемая операция WriteFile
  signal = WaitForSingleObject(overlappedwr.hEvent, INFINITE);

  //если операция завершилась успешно, установить соответствующий флажок
  if((signal == WAIT_OBJECT_0) && (GetOverlappedResult(COMport, &overlappedwr, &temp, true))) fl = true;
  else fl = false;

  Synchronize(Printing);	//вывести состояние операции в строке состояния
 }
 CloseHandle(overlappedwr.hEvent);	//перед выходом из потока закрыть объект-событие
}

//---------------------------------------------------------------------------
</sxh>
В данном случае используется бесконечный цикл //while(!Terminated)//, который будет выполняться, пока потоку не будет передана команда завершения (с помощью метода потока //Terminate()//). Это сделано для того, чтобы поток сам по себе не завершился после отправки данных, как это было сделано в первой версии программы. В первой версии поток просто последовательно выполнял все команды и завершался, когда они заканчивались. И каждый раз при необходимости отправить данные создавался новый поток. В этой же версии нам нужно, чтобы поток существовал всё время, пока открыт порт. Поэтому в нём создаётся бесконечный цикл.

В цикле, как и в первой версии программы, выполняются операции по передаче данных в порт, после чего вызывается функция потока //Printing// для вывода результата операции в строке состояния //(Synchronize(Printing))//. Именно в этой функции мы и будем останавливать поток, так как если мы остановим его сразу после записи данных в порт, но перед вызовом функции //Printing//, то мы сможем увидеть результат операции в строке состояния только при следующем запуске потока, так как поток запустится с точки останова. Поэтому и делаем останов потока в функции //Printing// следующим образом (для этого используем метод потока **Suspend()** (переводится с английского как "приостановить")):
<sxh cpp>
//---------------------------------------------------------------------------

//вывод состояния передачи данных на экран
void __fastcall WriteThread::Printing()
{
 if(!fl)	//проверяем состояние флажка
  {
   Form1->StatusBar1->Panels->Items[0]->Text  = "Ошибка передачи";
   return;
  }
 Form1->StatusBar1->Panels->Items[0]->Text  = "Передача прошла успешно";

 writer->Suspend();	//приостановить поток записи в порт, пока он не потребуется снова
 
}

//---------------------------------------------------------------------------
</sxh>
Метод //Suspend()// останавливает выполнение потока на некоторое время, пока не понадобится возобновить его работу с помощью метода //Resume()//.

Когда после остановки мы снова возобновим поток с помощью метода //Resume()//, он продолжит выполнение с точки останова, то есть перейдёт на следующий оператор после //writer->Suspend()//, то есть вернёт управление функции //Execute()// и перейдёт на начало цикла //while(!Terminated)//, после чего выполнит запись данных в порт, вывод результата в строке состояния и снова остановится.

Была обнаружена интересная особенность - если метод //Suspend()// для потока записи вызывался в функции //Printing//, то информация о результате операции, а также введённая в функцию в самом конце тестовая строка выводились независимо от того, в каком месте находился вызов метода. То есть работало даже так:
<sxh cpp>
//вывод состояния передачи данных на экран
void __fastcall WriteThread::Printing()
{
 writer->Suspend();	//приостановить поток записи в порт, пока он не потребуется снова
 if(!fl)		//проверяем состояние флажка
  {
   Form1->StatusBar1->Panels->Items[0]->Text  = "Ошибка передачи";
   return;
  }
 Form1->StatusBar1->Panels->Items[0]->Text  = "Передача прошла успешно";
 Form1->Memo1->Lines->Add("Тест!");
}
</sxh>
и так тоже:
<sxh cpp>
//вывод состояния передачи данных на экран
void __fastcall WriteThread::Printing()
{
 if(!fl)	//проверяем состояние флажка
  {
   Form1->StatusBar1->Panels->Items[0]->Text  = "Ошибка передачи";
   return;
  }
 Form1->StatusBar1->Panels->Items[0]->Text  = "Передача прошла успешно";
 writer->Suspend();	//приостановить поток записи в порт, пока он не потребуется снова
 Form1->Memo1->Lines->Add("Тест!");
}
</sxh>
Это связано с тем, что метод Synchronize выполняет переданный ему метод **в контексте главного потока** приложения, а поток, вызвавший //Synchronize//, на это время **приостанавливается**. Поэтому и не имеет значения, в каком месте функции выполнять останов потока, если функция вызывается с помощью метода Synchronize.

Но вот если поставить вызов метода Suspend в **главной** функции потока следующим образом:
<sxh cpp>
while(!Terminated)     //пока поток не будет завершён, выполнять цикл
 {
  ............
  writer->Suspend();	 //приостановить поток записи в порт, пока он не потребуется снова
  Synchronize(Printing); //вывести состояние операции в строке состояния
 }
</sxh>
то в данном случае функция Printing выполнялась только после повторного запуска потока, что доказывает, что после вызова метода Resume() поток продолжает своё выполнение с точки останова.

Аналогичный эффект можно достичь следующим образом: в функции Printing вызвать метод Suspend()
<sxh cpp>
//вывод состояния передачи данных на экран
void __fastcall WriteThread::Printing()
{
 if(!fl)	//проверяем состояние флажка
  {
   Form1->StatusBar1->Panels->Items[0]->Text  = "Ошибка передачи";
   return;
  }
 Form1->StatusBar1->Panels->Items[0]->Text  = "Передача прошла успешно";

 writer->Suspend();	//приостановить поток записи в порт, пока он не потребуется снова
}
</sxh>

а в главной функции потока добавить тестовую строку после вызова функции Printing:
<sxh cpp>
//главная функция потока, выполняет передачу байтов из буфера в COM-порт
void __fastcall WriteThread::Execute()
{
 while(!Terminated)     //пока поток не будет завершён, выполнять цикл
 {
  ..........
  Synchronize(Printing);	//вывести состояние операции в строке состояния
  Form1->Memo1->Lines->Add("Тест!");
 }
 CloseHandle(overlappedwr.hEvent);		//перед выходом из потока закрыть объект-событие
}
</sxh>
В этом случае информация о состоянии операции выведется в панель состояния, а вот тестовая строка появится только при следующем запуске потока.

Поэтому вызов метода Suspend лучше поместить так, чтобы поток выполнил всю необходимую работу (передача данных и вывод результата операции в строке состояния), и только потом был остановлен, чтобы при последующем запуске сразу перейти на начало цикла и выполнить такую же работу.

И всё же лучше всего вызов метода //Suspend()// поместить в конце цикла в главной функции, после вызова функции //Printing//:
<sxh cpp>
//главная функция потока, выполняет передачу байтов из буфера в COM-порт
void __fastcall WriteThread::Execute()
{
 while(!Terminated)     //пока поток не будет завершён, выполнять цикл
 {
  ..........
  Synchronize(Printing);	//вывести состояние операции в строке состояния
  writer->Suspend();		//приостановить поток записи в порт, пока он не потребуется снова
 }
 CloseHandle(overlappedwr.hEvent);		//перед выходом из потока закрыть объект-событие
}
</sxh>
Вы можете сами сделать так, как вам удобнее. Этот случай лучше, потому что здесь останов потока происходит именно в конце цикла, а не в функции. Иначе, если вам понадобится добавить ещё какую-нибудь функцию после функции Printing, то вызов этого метода вам придётся переносить в новую функцию. Это не очень удобно и вносит некоторую путаницу.

**3)** Интересный момент - это уничтожение потока методом //Terminate()//. Вот как выглядит код завершения потока в случае использования данных методов:
<sxh cpp>
//если поток записи существует, подать ему команду на завершение и запустить его,
//чтобы он выполнил завершение
 if(writer) //проверка if(writer) обязательна, иначе возникают ошибки
  {
   writer->Terminate();
   writer->Resume();
  }
</sxh>
Так как поток записи активируется только когда необходимо передать данные, велика вероятность, что когда потребуется его завершить, поток будет находиться в остановленном состоянии и не сможет выполнить завершение. Тогда после вызова метода //Terminate()//, который установит в //true// свойство потока //Terminated//, необходимо вызвать метод //Resume()//, чтобы активировать поток. В этом случае поток сможет выполнить проверку на значение //Terminated=true// (в цикле //while(!Terminated))// и завершиться.

В качестве особенностей описанных здесь методов можно отметить, что они имеют свойство накладываться. То есть если вы вызвали метод //Suspend()// несколько раз, то чтобы возобновить работу потока, вам нужно будет столько же раз вызвать метод //Resume()//.
==== Создание потока средствами WinAPI ====
Сначала рассмотрим создание потока средствами WINAPI на примере потока чтения данных из порта, а потом по аналогии создадим поток записи.
=== Создание потока чтения ===
Перед тем как создать поток, используя средства WinAPI, необходимо объявить и создать функцию, которая будет выполняться потоком. Эта функция имеет прототип

<code c>DWORD WINAPI ThreadFunc(LPVOID);</code>
где ThreadFunc - имя функции, задаваемое пользователем. Например:

<code c>DWORD WINAPI ReadThread(LPVOID);</code>
В эту функцию и запишем основной код потока чтения:
<sxh cpp>
//---------------------------------------------------------------------------

//главная функция потока, реализует приём байтов из COM-порта
DWORD WINAPI ReadThread(LPVOID)
{
 COMSTAT comstat;		//структура текущего состояния порта, в данной программе
				//используется для определения количества принятых в порт байтов
 DWORD btr, temp, mask, signal;	//переменная temp используется в качестве заглушки

 overlapped.hEvent = CreateEvent(NULL, true, true, NULL); // создать сигнальный объект-событие
							  // для асинхронных операций
 SetCommMask(COMport, EV_RXCHAR);           //установить маску на срабатывание по событию приёма байта в порт
 while(1)				    //пока поток не будет прерван, выполняем цикл
  {
   WaitCommEvent(COMport, &mask, &overlapped);               	// ожидать события приёма байта
								// (это и есть перекрываемая операция)
   signal = WaitForSingleObject(overlapped.hEvent, INFINITE);	//приостановить поток до прихода байта
   if(signal == WAIT_OBJECT_0)				        //если событие прихода байта произошло
    {
     //проверяем, успешно ли завершилась перекрываемая операция WaitCommEvent
     if(GetOverlappedResult(COMport, &overlapped, &temp, true))
      if((mask & EV_RXCHAR)!=0)					//если произошло именно событие прихода байта
       {
        ClearCommError(COMport, &temp, &comstat);		//нужно заполнить структуру COMSTAT
        btr = comstat.cbInQue;                          	//и получить из неё количество принятых байтов
        if(btr)                         			//если действительно есть байты для чтения
        {
         ReadFile(COMport, bufrd, btr, &temp, &overlapped);     //прочитать байты из порта в буфер программы
         counter+=btr;                                          //увеличиваем счётчик байтов
         ReadPrinting();                      		//вызываем функцию для вывода данных на экран и в файл
        }
       }
    }
  }
}

//---------------------------------------------------------------------------
</sxh>
Здесь цикл реализуется как while(1), то есть бесконечный цикл. Это связано с особенностями завершения потоков, которые будут рассмотрены ниже. Сам же алгоритм потока чтения при использовании WINAPI в целом практически больше ничем не отличается от алгоритма, реализованного на TThread, за исключением разве только использования дополнительных функций (наподобие Printing() в TThread, об этом подробнее сказано ниже).

Сам поток создаётся функцией **CreateThread**. При успешном завершении эта функция возвращает дескриптор потока, который необходимо запомнить в переменную типа **HANDLE**. Например:

<code c>HANDLE reader;
reader = CreateThread(NULL, 0, ReadThread, NULL, 0, NULL);</code>
В вызове функции используются следующие параметры:
  * первый параметр, равный NULL означает, что возвращаемый дескриптор не наследуется и используется дескриптор безопасности по умолчанию (то есть аналогично первому параметру функции CreateEvent).
  * второй параметр, равный 0, представляет собой размер стека потока в байтах. Нулевая величина стека означает, что используется величина стека по умолчанию, в качестве которой выступает размер стека главного потока процесса.
  * третий параметр является указателем на функцию, которую будет выполнять поток. В данном случае это функция ReadThread. Следует заметить, что функция должна быть объявлена с соглашением вызова WINAPI (к сожалению, авторы данной статьи не знают, что это такое) и возвращать 32-битный код выхода (параметр типа DWORD). Прототип функции см. выше.
  * четвёртый параметр, равный NULL, - это 32-битное значение параметра, передаваемого в поток. В данном случае этот параметр не используется, поэтому равен NULL.
  * пятый параметр, равный 0, означает, что поток запускается сразу после создания.
  * шестой параметр представляет собой указатель на 32-битную переменную (типа DWORD), в которую будет помещён идентификатор создаваемого потока. Так как нам идентификатор потока не нужен, в качестве этого параметра указываем NULL.

Поток чтения создаётся в функции открытия порта COMOpen.

Теперь обратим внимание на использование дополнительной функции для вывода принятых байтов в файл, а результатов операции - в строку состояния. Основное отличие WINAPI состоит в том, что в этом случае можно работать с графическими компонентами и файлами сразу в главной функции потока, так как при использовании WINAPI все сообщения поступают в очередь главного потока программы и им же обрабатываются. Поэтому вывод в файл и в строку состояния можно включить прямо в цикл чтения байтов потока чтения. Но в данном случае мы оформили вывод в отдельную функцию ReadPrinting(), чтобы сохранить наглядность кода потока чтения и сделать его отличие от кода потока чтения, использующего TThread, наименьшим. Функция ReadPrinting() представляет собой обычную функцию, которая объявляется и вызывается также как и обычная функция.
<sxh cpp>
void ReadPrinting(void);

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

//выводим принятые байты на экран и в файл (если включено)
void ReadPrinting()
{
 Form1->Memo1->Lines->Add((char*)bufrd);	 //выводим принятую строку в Memo

 //выводим счётчик в строке состояния
 Form1->StatusBar1->Panels->Items[2]->Text = "Всего принято " + IntToStr(counter) + " байт";

 if(Form1->CheckBox3->Checked == true)  //если включен режим вывода в файл
  {
   write(handle, bufrd, strlen(bufrd)); //записать в файл данные из приёмного буфера
  }
 memset(bufrd, 0, BUFSIZE);	        //очистить буфер (чтобы данные не накладывались друг на друга)
}
//---------------------------------------------------------------------------
</sxh>
После того как поток больше не нужен, его следует завершить. Поток чтения завершается при закрытии порта, в функции COMClose(). Для этого используется функция TerminateThread().
<code c>BOOL TerminateThread(HANDLE hThread, DWORD dwExitCode);</code>
Первый её параметр - дескриптор завершаемого потока, второй параметр - 32-х битный код завершения (выхода) потока.

Например:
<code c>TerminateThread(reader,0);</code>
Прерывание потока не обязательно удалит объект потока. Для того чтобы объект потока был удалён, необходимо, чтобы все дескрипторы потока были освобождены.

Следует отметить, что при прерывании потока, созданного средствами WINAPI, поток прерывается жёстко, и это может произойти в любом месте его выполнения, а значит, освобождать дескриптор сигнального объекта-события внутри кода потока, как это сделано в программе, использующей класс TThread, в данном случае не очень надёжный способ. (К тому же внутри потока используется бесконечный цикл while(1).) Поэтому, используя функцию TerminateThread(), после неё нужно дополнительно освобождать дескриптор объекта события, находящийся в структуре типа OVERLAPPED, связанной с потоком, а также ещё вручную освобождать и дескриптор потока.
<code c>
//если поток чтения работает, завершить его; проверка if(reader) обязательна, иначе возникают ошибки
if(reader)
  {TerminateThread(reader,0);
   CloseHandle(overlapped.hEvent);	//нужно закрыть объект-событие
   CloseHandle(reader);
  }
</code>
По этой причине внутри потока используется бесконечный цикл while(1), а не цикл с условием проверки, прерван поток или нет, как это делается при использовании класса потоков TThread.

В принципе использование функции TerminateThread() - это грубый метод завершения потока. Здесь его можно применить, так как поток выполняет простую работу, не связанную с критическими секциями, ядром (kernel32) или динамическими библиотеками (DLL). Но для серьёзных проектов, использующих именно эти методы работы, TerminateThread не подойдёт.

Теоретически можно сделать по аналогии со свойством Terminated потоков TThread. То есть создать глобальную переменную-флаг (например, flag), которую устанавливать в единицу, когда нужно выполнить завершение потока, а в цикле самого потока поставить вместо while(1) условие while(!flag). Тогда получится мягкое завершение потока, как и в случае с TThread и Terminated, то есть можно будет выполнить какой-нибудь код перед завершением потока (например, освобождение дескриптора сигнального объекта-события). Но в этом случае после установки флага в единицу, нужно дождаться, когда поток завершиться, чтобы затем освободить его дескриптор. Например, для этих целей можно сделать второй флаг flag2 и с помощью while(!флаг2) ждать, когда поток установит его в единицу, что будет означать, что поток завершился.

То есть примерно код будет выглядеть так (например, для потока reader класса ReadThread):

<sxh cpp>
//пример кода завершения потока WinAPI "мягким" способом
flag=1;
while(!flag2){}
flag=0; flag2=0;
CloseHandle(reader);

//как для этого нужно изменить код потока:
//главная функция потока, реализует приём байтов из COM-порта
DWORD WINAPI ReadThread(LPVOID)
{
 ..........

 while(!flag)	//пока поток не будет прерван, выполняем цикл
  {
   .........
  }
CloseHandle(overlapped.hEvent);
flag2=1;
}
</sxh>
Можно сделать и без второго флага: сделать так, чтобы поток просто сбрасывал flag в ноль:
<sxh cpp>
//пример кода завершения потока WinAPI "мягким" способом
flag=1;
while(!flag){}
CloseHandle(reader);

//как для этого нужно изменить код потока:
//главная функция потока, реализует приём байтов из COM-порта
DWORD WINAPI ReadThread(LPVOID)
{
 .......
 CloseHandle(overlapped.hEvent);
 flag=0;
}
</sxh>
Следует отметить, что данный случай подходит, если в программе реализован только один поток. Попробуйте изменить код так, чтобы он работал для двух потоков. Может, вы сможете придумать и более удобный способ. Например, для управления потоками WINAPI можно использовать сигнальные объекты-события и другие подобные объекты.

В нашем же случае используется именно функция TerminateThread.

Полностью поток чтения выглядит так:
<sxh cpp>
HANDLE reader;	//дескриптор потока чтения из порта

DWORD WINAPI ReadThread(LPVOID);

//-----------------------------------------------------------------------------
//............................... поток ReadThead .............................
//-----------------------------------------------------------------------------

void ReadPrinting(void);

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

//главная функция потока, реализует приём байтов из COM-порта
DWORD WINAPI ReadThread(LPVOID)
{
 COMSTAT comstat;		//структура текущего состояния порта, в данной программе
				//используется для определения количества принятых в порт байтов
 DWORD btr, temp, mask, signal;	//переменная temp используется в качестве заглушки

 //создать сигнальный объект-событие для асинхронных операций
 overlapped.hEvent = CreateEvent(NULL, true, true, NULL);

 SetCommMask(COMport, EV_RXCHAR);           //установить маску на срабатывание по событию приёма байта в порт
 while(1)				    //пока поток не будет прерван, выполняем цикл
  {
   WaitCommEvent(COMport, &mask, &overlapped);               	// ожидать события приёма байта
								// (это и есть перекрываемая операция)
   signal = WaitForSingleObject(overlapped.hEvent, INFINITE);	//приостановить поток до прихода байта
   if(signal == WAIT_OBJECT_0)				        //если событие прихода байта произошло
    {
     //проверяем, успешно ли завершилась перекрываемая операция WaitCommEvent
     if(GetOverlappedResult(COMport, &overlapped, &temp, true))
      if((mask & EV_RXCHAR)!=0)					//если произошло именно событие прихода байта
       {
        ClearCommError(COMport, &temp, &comstat);		//нужно заполнить структуру COMSTAT
        btr = comstat.cbInQue;                          	//и получить из неё количество принятых байтов
        if(btr)                         			//если действительно есть байты для чтения
        {
         ReadFile(COMport, bufrd, btr, &temp, &overlapped);     //прочитать байты из порта в буфер программы
         counter+=btr;                                          //увеличиваем счётчик байтов
         ReadPrinting();                      		//вызываем функцию для вывода данных на экран и в файл
        }
       }
    }
  }
}

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

//выводим принятые байты на экран и в файл (если включено)
void ReadPrinting()
{
 Form1->Memo1->Lines->Add((char*)bufrd);	 //выводим принятую строку в Memo

 //выводим счётчик в строке состояния
 Form1->StatusBar1->Panels->Items[2]->Text = "Всего принято " + IntToStr(counter) + " байт";

 if(Form1->CheckBox3->Checked == true)  //если включен режим вывода в файл
  {
   write(handle, bufrd, strlen(bufrd)); //записать в файл данные из приёмного буфера
  }
 memset(bufrd, 0, BUFSIZE);	        //очистить буфер (чтобы данные не накладывались друг на друга)
}

//---------------------------------------------------------------------------
</sxh>
=== Создание потока записи. Использование функций ResumeThread() и SuspendThread() ===
ля демонстрации потоков на WINAPI была сделана только одна версия программы, в которой для потока записи сразу реализована демонстрация использования запуска и останова потока.

В целом реализация останова и запуска потоков на средствах WINAPI аналогична использованию останова и запуска потоков на TThread с помощью методов Resume() и Suspend(), только в данном случае используются функции ResumeThread() и SuspendThread().

Прототипы этих функций:

<code c>DWORD ResumeThread(HANDLE hThread);	

DWORD SuspendThread(HANDLE hThread); </code>
Эти функции получают в качестве аргумента дескриптор потока, который нужно запустить (ResumeThread()) или остановить (SuspendThread()). Рассмотрим последовательно создание потока и использование этих функций.

Поток записи создаётся аналогично потоку чтения с помощью функции CreateThread().

Для этого сначала объявляем и создаём рабочую функцию потока:
<sxh cpp>
//---------------------------------------------------------------------------

//главная функция потока, выполняет передачу байтов из буфера в COM-порт
DWORD WINAPI WriteThread(LPVOID)
{
 DWORD temp, signal;	//temp - переменная-заглушка

 overlappedwr.hEvent = CreateEvent(NULL, true, true, NULL);   	  //создать событие
 while(1)
  {
   //записать байты в порт (перекрываемая операция!)
   WriteFile(COMport, bufwr, strlen(bufwr), &temp, &overlappedwr);

   //приостановить поток, пока не завершится перекрываемая операция WriteFile
   signal = WaitForSingleObject(overlappedwr.hEvent, INFINITE);

   //если операция завершилась успешно
   if((signal == WAIT_OBJECT_0) && (GetOverlappedResult(COMport, &overlappedwr, &temp, true)))
     {
      //вывести сообщение об этом в строке состояния
      Form1->StatusBar1->Panels->Items[0]->Text  = "Передача прошла успешно";
     }
   //иначе вывести в строке состояния сообщение об ошибке
   else {Form1->StatusBar1->Panels->Items[0]->Text  = "Ошибка передачи";}

   SuspendThread(writer);
  }
}

//---------------------------------------------------------------------------
</sxh>
Как вы можете заметить, здесь вывод состояния операции в панель состояния осуществляется сразу в главной функции потока. То есть в отличие от программы с TThread в версии с WINAPI поток записи состоит только из одной функции.

Кроме того, вы должны обратить внимание, что здесь также как и в потоке чтения на WINAPI используется бесконечный цикл while(1) из-за той же особенности завершения работы потока.

Самая последняя операция внутри цикла потока - это останов потока с помощью функции SuspendThread(), который аналогичен использованию метода Suspend() в потоке записи на TThread. То есть здесь поток также останавливает сам себя.

После того как создана функция потока, необходимо создать сам поток:
<code c>
HANDLE writer;
writer = CreateThread(NULL, 0, WriteThread, NULL, CREATE_SUSPENDED, NULL);</code>
Поток записи, как и поток чтения, создаётся в функции открытия порта COMOpen().

Обратите внимание, что при создании потока записи в порт в качестве пятого параметра указывается CREATE_SUSPENDED, это означает, что поток будет создан в остановленном состоянии, и для его запуска необходимо будет использовать функцию ResumeThread().

Эта функция вызывается, когда требуется отправить данные в порт. Подготовка к отправке данных и активирование потока осуществляется в обработчике нажатия кнопки "Передать":
<sxh cpp>
//---------------------------------------------------------------------------

//кнопка "Передать"
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 memset(bufwr,0,BUFSIZE); //очистить программный передающий буфер,
			  //чтобы данные не накладывались друг на друга
 PurgeComm(COMport, PURGE_TXCLEAR);            //очистить передающий буфер порта
 strcpy(bufwr,Form1->Edit1->Text.c_str());     //занести в программный передающий буфер строку из Edit1

 ResumeThread(writer);               //активировать поток записи данных в порт

}

//---------------------------------------------------------------------------
</sxh>
Здесь всё аналогично обработчику кнопки "Передать" в программе с TThread второй версии (где используются останов и запуск потоков), за тем лишь исключением, что для запуска потока используется WINAPI функция ResumeThread().

Когда поток заканчивает передачу данных, он останавливает сам себя функцией SuspendThread() (см. выше).

Поток записи, как и поток чтения, существует всё время, пока открыт COM-порт. Когда порт закрывается, и поток записи больше не нужен, он уничтожается (в функции COMClose()) таким же образом, как и поток чтения:
<sxh cpp>
//если поток записи работает, завершить его; проверка if(writer) обязательна, иначе возникают ошибки
if(writer)
  {TerminateThread(writer,0);
   CloseHandle(overlappedwr.hEvent);	//нужно закрыть объект-событие
   CloseHandle(writer);
  }</sxh>
Здесь следует отметить отличие от кода уничтожения потока записи для TThread (вторая версия программы), которое заключается в том, что здесь не нужно активировать поток для его уничтожения, так как функция TerminateThread уничтожает поток без проверки каких-либо условий. Зато если вы будете использовать "мягкое" уничтожение потока (как описывалось выше), то в этом случае вам необходимо будет также использовать пробуждение потока для его завершения.

Функцию TerminateThread также можно использовать и для немедленного принудительного завершения потоков TThread, для этого в неё передаётся дескриптор потока (свойство Handle), например:

<code c>TerminateThread((*void)reader->Handle, 0);</code>
Если завершить поток записи writer на TThread с помощью этой функции, а не с помощью метода Terminate(), то активировать поток методом Resume() для уничтожения не требуется.

Приведём полный код потока записи в порт на WINAPI.
<sxh cpp>
HANDLE writer;	//дескриптор потока записи в порт

DWORD WINAPI WriteThread(LPVOID);

//-----------------------------------------------------------------------------
//............................... поток WriteThead ............................
//-----------------------------------------------------------------------------

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

//главная функция потока, выполняет передачу байтов из буфера в COM-порт
DWORD WINAPI WriteThread(LPVOID)
{
 DWORD temp, signal;	//temp - переменная-заглушка

 overlappedwr.hEvent = CreateEvent(NULL, true, true, NULL);   	  //создать событие
 while(1)
  {
   //записать байты в порт (перекрываемая операция!)
   WriteFile(COMport, bufwr, strlen(bufwr), &temp, &overlappedwr);

   //приостановить поток, пока не завершится перекрываемая операция WriteFile
   signal = WaitForSingleObject(overlappedwr.hEvent, INFINITE);

   //если операция завершилась успешно
   if((signal == WAIT_OBJECT_0) && (GetOverlappedResult(COMport, &overlappedwr, &temp, true)))
     {
      //вывести сообщение об этом в строке состояния
      Form1->StatusBar1->Panels->Items[0]->Text  = "Передача прошла успешно";
     }
   //иначе вывести в строке состояния сообщение об ошибке
   else {Form1->StatusBar1->Panels->Items[0]->Text  = "Ошибка передачи";}

   SuspendThread(writer);
  }
}

//---------------------------------------------------------------------------
</sxh>
==== Сравнение использования класса TThread и средств WINAPI ====
Одно из отличий заключается в том, что в потоках WINAPI можно использовать обращение к графическим компонентам и файлам, так как сообщения потоков WINAPI ставятся в очередь сообщений главного потока процесса. Таким образом избегаются конфликты между потоками при обращении к разделяемым компонентам или файлам. А вот в TThread для этого используется метод Synchronize(), который выполняет то же самое - ставит сообщения в очередь главного потока процесса, за счёт чего можно избежать конфликтов между потоками.

Второе отличие - это наличие у потоков TThread возможности "мягкого" завершения с использованием метода Terminate() и свойства Terminated, об этом подробно рассказывалось выше. Для потоков WINAPI организовать "мягкое" завершение сложнее, поэтому используется принудительное завершение потоков с помощью функции TerminateThread. (По крайней мере, авторам данной статьи способ завершения потока WINAPI, аналогичный "мягкому" завершению потока TThread, за исключением примера с использованием флагов, не известен.)

Самое же главное отличие состоит в том, что потоки TThread строятся на основе классов, а потоки WINAPI - на основе функций.

===== Описание программы =====
Так как все три версии программ отличаются только в плане использования потоков, остальные функции программ являются общими.

Кроме потоков в программе используются функции открытия и закрытия порта, а также обработчики событий для элементов формы. Рассмотрим их по порядку.

При запуске программы вызывается конструктор формы, в котором происходит начальная инициализация элементов формы. Здесь отключаются некоторые элементы формы.
<sxh cpp>
//конструктор формы, обычно в нём выполняется инициализация элементов формы
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
{
 //инициализация элементов формы при запуске программы
 Form1->Label5->Enabled = false;
 Form1->Label6->Enabled = false;
 Form1->Button1->Enabled = false;
 Form1->CheckBox1->Enabled = false;
 Form1->CheckBox2->Enabled = false;
}</sxh>
Кроме функций потоков главными при работе с портом являются функции открытия и закрытия порта. Эти функции должны быть объявлены до их использования, поэтому мы объявляем их сразу после объявлений переменных.
<sxh cpp>
void COMOpen(void);      //открыть порт
void COMClose(void);     //закрыть порт </sxh>
==== Функция открытия и инициализации порта COMOpen() ====
Сначала приведём код этой функции, а затем подробно её рассмотрим. В коде жирным шрифтом выделены основные моменты, на которые нужно обратить внимание.
<sxh cpp>
//---------------------------------------------------------------------------

//функция открытия и инициализации порта
void COMOpen()
{
 String portname;     	//имя порта (например, "COM1", "COM2" и т.д.)
 DCB dcb;           	//структура для общей инициализации порта DCB
 COMMTIMEOUTS timeouts;  	//структура для установки таймаутов
 
 portname = Form1->ComboBox1->Text;	//получить имя выбранного порта

 //открыть порт, для асинхронных операций обязательно нужно указать флаг FILE_FLAG_OVERLAPPED
 COMport = CreateFile(portname.c_str(),GENERIC_READ | GENERIC_WRITE, 0,
		      NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 //здесь:
 // - portname.c_str() - имя порта в качестве имени файла,
 //   c_str() преобразует строку типа String в строку в виде массива типа char, иначе функция не примет
 // - GENERIC_READ | GENERIC_WRITE - доступ к порту на чтение/записть
 // - 0 - порт не может быть общедоступным (shared)
 // - NULL - дескриптор порта не наследуется, используется дескриптор безопасности по умолчанию
 // - OPEN_EXISTING - порт должен открываться как уже существующий файл
 // - FILE_FLAG_OVERLAPPED - этот флаг указывает на использование асинхронных операций
 // - NULL - указатель на файл шаблона не используется при работе с портами

 if(COMport == INVALID_HANDLE_VALUE)            //если ошибка открытия порта
  {
   Form1->SpeedButton1->Down = false;           //отжать кнопку
   //вывести сообщение в строке состояния
   Form1->StatusBar1->Panels->Items[0]->Text = "Не удалось открыть порт";
   return;
  }

 //инициализация порта

 dcb.DCBlength = sizeof(DCB); 	//в первое поле структуры DCB необходимо занести её длину,
				//она будет использоваться функциями настройки порта
				//для контроля корректности структуры

 //считать структуру DCB из порта
 if(!GetCommState(COMport, &dcb))
  {
   //если не удалось - закрыть порт и вывести сообщение об ошибке в строке состояния
   COMClose();
   Form1->StatusBar1->Panels->Items[0]->Text  = "Не удалось считать DCB";
   return;
  }

 //инициализация структуры DCB
 dcb.BaudRate = StrToInt(Form1->ComboBox2->Text); //задаём скорость передачи 115200 бод
 dcb.fBinary = TRUE;                              //включаем двоичный режим обмена
 dcb.fOutxCtsFlow = FALSE;                        //выключаем режим слежения за сигналом CTS
 dcb.fOutxDsrFlow = FALSE;                        //выключаем режим слежения за сигналом DSR
 dcb.fDtrControl = DTR_CONTROL_DISABLE;           //отключаем использование линии DTR
 dcb.fDsrSensitivity = FALSE;                     //отключаем восприимчивость драйвера к состоянию линии DSR
 dcb.fNull = FALSE;                               //разрешить приём нулевых байтов
 dcb.fRtsControl = RTS_CONTROL_DISABLE;           //отключаем использование линии RTS
 dcb.fAbortOnError = FALSE;                       //отключаем остановку всех операций чтения/записи при ошибке
 dcb.ByteSize = 8;                                //задаём 8 бит в байте
 dcb.Parity = 0;                                  //отключаем проверку чётности
 dcb.StopBits = 0;                                //задаём один стоп-бит

 //загрузить структуру DCB в порт
 if(!SetCommState(COMport, &dcb))
  {
   //если не удалось - закрыть порт и вывести сообщение об ошибке в строке состояния
   COMClose();
   Form1->StatusBar1->Panels->Items[0]->Text  = "Не удалось установить DCB";
   return;
  }

 //установить таймауты
 timeouts.ReadIntervalTimeout = 0;	 	//таймаут между двумя символами
 timeouts.ReadTotalTimeoutMultiplier = 0;	//общий таймаут операции чтения
 timeouts.ReadTotalTimeoutConstant = 0;       //константа для общего таймаута операции чтения
 timeouts.WriteTotalTimeoutMultiplier = 0;    //общий таймаут операции записи
 timeouts.WriteTotalTimeoutConstant = 0;      //константа для общего таймаута операции записи

 //записать структуру таймаутов в порт
 //если не удалось - закрыть порт и вывести сообщение об ошибке в строке состояния
 if(!SetCommTimeouts(COMport, &timeouts))
  {
   COMClose();
   Form1->StatusBar1->Panels->Items[0]->Text  = "Не удалось установить тайм-ауты";
   return;
  }

 //установить размеры очередей приёма и передачи
 SetupComm(COMport,2000,2000);

 //создать или открыть существующий файл для записи принимаемых данных
 handle = open("test.txt", O_CREAT | O_APPEND | O_BINARY | O_WRONLY, S_IREAD | S_IWRITE);

 if(handle==-1)		//если произошла ошибка открытия файла
  {
   //вывести сообщение об этом в командной строке
   Form1->StatusBar1->Panels->Items[1]->Text = "Ошибка открытия файла";
   Form1->Label6->Hide();                                               //спрятать надпись с именем файла
   Form1->CheckBox3->Checked = false;                                   //сбросить и отключить галочку
   Form1->CheckBox3->Enabled = false;
  }
 //иначе вывести в строке состояния сообщение об успешном открытии файла
 else { Form1->StatusBar1->Panels->Items[0]->Text = "Файл открыт успешно"; }

 PurgeComm(COMport, PURGE_RXCLEAR);	//очистить принимающий буфер порта

 reader = new ReadThread(false);  //создать и запустить поток чтения байтов
 reader->FreeOnTerminate = true;  //установить это свойство потока,
				  //чтобы он автоматически уничтожался после завершения

}

//---------------------------------------------------------------------------
</sxh>
Итак, для того, чтобы можно было работать с портом, его нужно открыть и правильно проинициализировать. Какие действия нужно для этого выполнить:
    - Сначала объявляются необходимые переменные: строковая переменная для имени порта, а также структуры типа **DCB** и **COMMTIMEOUTS**, которые понадобятся для инициализации порта. <code c> String portname;     	//имя порта (например, "COM1", "COM2" и т.д.)
DCB dcb;                	//структура для общей инициализации порта DCB
COMMTIMEOUTS timeouts;  	//структура для установки таймаутов </code>
    - из выпадающего списка с именами портов получаем имя порта. Для этого необходимо, чтобы свойство Style выпадающего списка (ComboBox) было установлено в csDropDownList, чтобы исключить возможность его редактирования. При этом имена портов должны быть записаны именно так, как они будут использоваться в функции CreateFile, иначе такой способ не сработает. <code c> portname = Form1->ComboBox1->Text;	//получить имя выбранного порта</code>
    - теперь с помощью функции CreateFile открываем порт. <code c>
//открыть порт, для асинхронных операций обязательно нужно указать флаг FILE_FLAG_OVERLAPPED
 COMport = CreateFile(portname.c_str(),GENERIC_READ | GENERIC_WRITE, 0,
		      NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 //здесь:
 // - portname.c_str() - имя порта в качестве имени файла,
 //   c_str() преобразует строку типа String в строку в виде массива типа char, иначе функция не примет
 // - GENERIC_READ | GENERIC_WRITE - доступ к порту на чтение/записть
 // - 0 - порт не может быть общедоступным (shared)
 // - NULL - дескриптор порта не наследуется, используется дескриптор безопасности по умолчанию
 // - OPEN_EXISTING - порт должен открываться как уже существующий файл
 // - FILE_FLAG_OVERLAPPED - этот флаг указывает на использование асинхронных операций
 // - NULL - указатель на файл шаблона не используется при работе с портами </code> Функция открывает порт как файл. Она возвращает дескриптор открытого порта. 
В функцию передаются следующие параметры:                           
1) portname.c_str() - это имя порта. c_str() - метод класса TString, который преобразует строковую переменную в массив типа char, так как функция принимает имя порта только в виде массива char.  \\
2) GENERIC_READ | GENERIC_WRITE - этот параметр означает, что доступ к порту будет осуществляться на чтение/запись.  \\
3) 0 - означает, что порт не может быть общедоступным (shared) - этот параметр для порта всегда должен иметь такое значение.   \\
4) NULL - дескриптор порта не наследуется, используется дескриптор безопасности по умолчанию.  \\
5) OPEN_EXISTING - порт обязательно должен открываться как уже существующий файл.    \\
6) FILE_FLAG_OVERLAPPED - этот флаг указывает на то, что с портом будут выполняться асинхронные перекрываемые операции.   \\
7) NULL - означает, что указатель на файл шаблона не используется - это обязательно для работы с портами.    \\
В переменную COMport типа HANDLE запоминается возвращаемый дескриптор порта. Далее работа с портом будет осуществляться именно через него.    \\
Затем проверяем, удалось ли открыть порт. Если попытка была неудачной, функция CreateFile вернёт значение INVALID_HANDLE_VALUE. Тогда отжимаем кнопку "Открыть-Закрыть порт", выводим соответствующее сообщение об ошибке и выходим из функции. Если порт открыт успешно, переходим к его инициализации. <code c>
if(COMport == INVALID_HANDLE_VALUE)            //если ошибка открытия порта
  {
   Form1->SpeedButton1->Down = false;           //отжать кнопку
   //вывести сообщение в строке состояния
   Form1->StatusBar1->Panels->Items[0]->Text = "Не удалось открыть порт";
   return;
  }</code>
  
==== Функция закрытия порта COMClose() ====
==== Конструктор формы и обработчики событий формы и её элементов ====
==== Переменные, используемые в программе ====
===== Описание интерфейса =====

===== Работа с программой =====
===== Как протестировать программу =====
==== Диспетчер задач ====

==== Заглушка для COM-порта ====

===== Список литературы =====






----

[[:start|На главную]],  [[interfaces:start|Интерфейсы]]