Введение

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

Если вы ещё не работали с COM-портом в Windows, то рекомендуем сначала прочитать раздел "Описание программы", в котором приводится описание инициализации порта и работы с ним.

Основные определения

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

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

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

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

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

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

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

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

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

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

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

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

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

#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); //перед выходом из потока закрыть объект-событие
}

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

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

Чтобы с портом можно было выполнять асинхронные операции, порт должен быть открыт (функцией CreateFile) с флагом FILE_FLAG_OVERLAPPED. Это действие выполняется в функции открытия порта COMOpen() (описание функции см. ниже).

HANDLE COMport;
COMport = CreateFile(cnum.c_str(),GENERIC_READ | GENERIC_WRITE, 0,
 NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);

Кроме того, для этого необходима структура типа OVERLAPPED, которая используется для управления перекрываемыми асинхронными операциями ввода/вывода. В данном случае она объявлена статически.

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

OVERLAPPED overlapped;

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

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

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

overlapped.hEvent = CreateEvent(NULL, true, true, NULL);

Так как работа с портом будет выполняться в асинхронном режиме, для создаваемого события в функции CreateEvent нужно задать следующие значения передаваемых параметров: NULL, true, true, NULL.

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

Второй параметр, равный true, задаёт тип объекта-события с ручным переключением в несигнальное состояние (переключение в несигнальное состояние в случае необходимости можно осуществить с помощью функции ResetEvent). Это необходимо, если мы хотим использовать функцию ожидания, такую как WaitForSingleObject (см. пояснения к параметрам функции CreateEvent).

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

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

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

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

SetCommMask(COMport, EV_RXCHAR);

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

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

WaitCommEvent(COMport, &mask, &overlapped);

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

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

signal = WaitForSingleObject(overlapped.hEvent, INFINITE);

Эта функция будет ждать, пока объект-событие, связанный со структурой OVERLAPPED, из несигнального состояния не перейдёт в сигнальное. Как только объект перейдёт в сигнальное состояние, WaitForSingleObject вернёт значение WAIT_OBJECT_0 и активирует поток.

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

if(signal == WAIT_OBJECT_0)

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

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

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

if(GetOverlappedResult(COMport, &overlapped, &temp, true))

Последний параметр функции GetOverlappedResult, равный true, заставляет её дожидаться, пока перекрываемая операция не завершится полностью.

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

if((mask&EV_RXCHAR)!=0)

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

Теперь, когда известно, что байты получены, нужно выяснить, какое их количество находится в буфере. Для этого используем функцию ClearCommError, которая заполняет поля структуры COMSTAT. Одно из полей этой структуры, cbInQue, содержит количество байтов данных, содержащихся в буфере, но ещё не считанных функцией ReadFile.

ClearCommError(COMport, &temp, &curstat);
btr = curstat.cbInQue;

Это количество байтов и будем считывать функцией ReadFile.

ReadFile(COMport, buf, btr, &temp, &overlapped);

Краткое описание алгоритма цикла чтения байтов

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

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

CreateEvent(NULL, true, true, NULL);

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

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

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

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

Параметры функции SetCommMask

SetCommMask(comport, EV_RXCHAR);

Первый параметр - дескриптор открытого порта.

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

Параметры функции WaitCommEvent

WaitCommEvent(comport, &mask, &overlapped);

Первый параметр - дескриптор порта.

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

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