Работа с COM-портом с помощью потоков

Работа с COM-портом с помощью потоков

ReadThread *reader;

//объект потока ReadThread

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

2) Теперь нужно создать поток:

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

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

Следует отметить, что потоки создаются только динамическим образом, то есть используя указатель

(*reader) и оператор new (new ReadThread(false)).

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

То есть в целом создание потока будет выглядеть так:

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

После того, как поток больше не нужен, его следует завершить, используя метод Terminate(). Как говорилось выше, этот метод устанавливает флаг потока Terminated в true, сообщая потоку, что он должен завершиться.

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

if(reader)reader->Terminate();

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

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

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

Полностью код потока чтения выглядит так:

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

//поток для чтения последовательности байтов из COM-порта в буфер class ReadThread : public TThread

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

http://piclist.ru/

11

© PIClist RUS, 2007

Работа с COM-портом с помощью потоков

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

//конструктор потока ReadThread, по умолчанию пустой

__fastcall ReadThread::ReadThread(bool CreateSuspended) : TThread(CreateSuspended) {}

//---------------------------------------------------------------------------
//главная функция потока, реализует приём байтов из COM-порта
void __fastcall ReadThread::Execute()
{	//структура текущего состояния порта, в данной программе используется для определения
COMSTAT comstat;
количества принятых в порт байтов		//переменная temp используется в качестве заглушки
DWORD btr, temp, mask, signal;
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)
{		//нужно заполнить структуру COMSTAT
ClearCommError(COMport, &temp, &comstat);
btr = comstat.cbInQue;	//и получить из неё количество принятых байтов
if(btr)	//если действительно есть байты для чтения
{		//прочитать байты из порта в буфер программы
ReadFile(COMport, bufrd, btr, &temp, &overlapped);
counter+=btr;		//увеличиваем счётчик байтов
Synchronize(Printing);		//вызываем функцию для вывода данных на экран и в
файл
}
}
}
}	//перед выходом из потока закрыть объект-событие
CloseHandle(overlapped.hEvent);
}

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

//выводим принятые байты на экран и в файл (если включено) void __fastcall ReadThread::Printing()

{

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);

}

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

Поток записи в порт

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

Точно так же как и для потока чтения, нужно создать объявление класса и для потока записи.

http://piclist.ru/

12

© PIClist RUS, 2007

Работа с COM-портом с помощью потоков

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

//поток для записи последовательности байтов из буфера в COM-порт

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

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

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

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

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

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

void __fastcall WriteThread::Execute()
{	//temp - переменная-заглушка
DWORD temp, signal;
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;
Synchronize(Printing);	//вывести состояние операции в строке состояния
CloseHandle(overlappedwr.hEvent);		//перед выходом из потока закрыть объект-событие

}

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

Функция Printing() выполняет вывод состояния операции в строке состояния:

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

//вывод состояния передачи данных на экран void __fastcall WriteThread::Printing()

{

if(!fl) //проверяем состояние флажка

{

Form1->StatusBar1->Panels->Items[0]->Text = "Ошибка передачи"; return;

}

Form1->StatusBar1->Panels->Items[0]->Text = "Передача прошла успешно";

}

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

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

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

WriteThread *writer;

//объект потока WriteThread

Этот объект также должен быть объявлен глобально. 2) создать объект класса с помощью оператора new:

http://piclist.ru/

13

© PIClist RUS, 2007

Работа с COM-портом с помощью потоков

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

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

В программе поток создаётся при необходимости отправки данных – в обработчике нажатия кнопки "Передать":

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

//кнопка "Передать"

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;	//установить это свойство, чтобы поток автоматически
уничтожался после завершения
}
//---------------------------------------------------------------------------

Когда поток больше не нужен, он также уничтожается вызовом метода Terminate():

if(writer)writer->Terminate();	//если поток записи работает, завершить его; проверка if(writer)
обязательна, иначе возникают ошибки

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

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

//поток для записи последовательности байтов из буфера в 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 - переменная-заглушка

http://piclist.ru/

14

© PIClist RUS, 2007

Работа с COM-портом с помощью потоков

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;
Synchronize(Printing);		//вывести состояние операции в строке состояния
CloseHandle(overlappedwr.hEvent);			//перед выходом из потока закрыть объект-событие
}
//---------------------------------------------------------------------------
//вывод состояния передачи данных на экран
void __fastcall WriteThread::Printing()
{	//проверяем состояние флажка
if(!fl)
{				= "Ошибка передачи";
Form1->StatusBar1->Panels->Items[0]->Text
return;
}				= "Передача прошла успешно";
Form1->StatusBar1->Panels->Items[0]->Text
}

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

Использование методов Resume() и Suspend()

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

1) В данном случае поток записи создаётся непосредственно в функции открытия порта COMOpen() после всех действий по открытию и инициализации порта (в конце функции), вместе с потоком чтения. При этом в конструктор потока чтения ReadThread(), как и в первой версии программы, передаётся параметр false, чтобы запустить поток чтения сразу после создания. А вот в конструктор потока записи WriteThread() передаётся параметр true, чтобы поток создался в остановленном состоянии. Будем запускать его по мере необходимости.

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

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

Таким образом, поток записи writer будем включать, когда необходимо передать данные, то есть при нажатии кнопки "Передать". Для этого используется метод Resume() (переводится с английского как "возобновить"):

//кнопка "Передать"

void __fastcall TForm1::Button1Click(TObject *Sender)

{

memset(bufwr,0,BUFSIZE);		//очистить программный передающий буфер, чтобы данные не
накладывались друг на друга		//очистить передающий буфер порта
PurgeComm(COMport, PURGE_TXCLEAR);
strcpy(bufwr,Form1->Edit1->Text.c_str());		//занести в программный передающий буфер строку из
Edit1	//активировать поток записи в порт
writer->Resume();

http://piclist.ru/

15

© PIClist RUS, 2007

Работа с COM-портом с помощью потоков

}

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

Для этого построим код потока следующим образом:

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

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

void __fastcall WriteThread::Execute()
{	//temp - переменная-заглушка
DWORD temp, signal;
overlappedwr.hEvent = CreateEvent(NULL, true, true, NULL);		//создать событие
while(!Terminated)	//пока поток не будет завершён, выполнять цикл
{		//записать байты в порт (перекрываемая
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;

Synchronize(Printing); //вывести состояние операции в строке состояния

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

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

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

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

//вывод состояния передачи данных на экран void __fastcall WriteThread::Printing()

{

if(!fl) //проверяем состояние флажка

{

Form1->StatusBar1->Panels->Items[0]->Text = "Ошибка передачи"; return;

}

Form1->StatusBar1->Panels->Items[0]->Text = "Передача прошла успешно";

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

}

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

http://piclist.ru/

16

© PIClist RUS, 2007

Работа с COM-портом с помощью потоков

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

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

Была обнаружена интересная особенность – если метод Suspend() для потока записи вызывался в функции Printing, то информация о результате операции, а также введённая в функцию в самом конце тестовая строка выводились независимо от того, в каком месте находился вызов метода. То есть работало даже так:

//вывод состояния передачи данных на экран 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("Тест!");

}

и так тоже:

//вывод состояния передачи данных на экран 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("Тест!");

}

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

Но вот если поставить вызов метода Suspend в главной функции потока следующим образом:

while(!Terminated)	//пока поток не будет завершён, выполнять цикл
{
............	//приостановить поток записи в порт, пока он не потребуется снова
writer->Suspend();
Synchronize(Printing);		//вывести состояние операции в строке состояния
}

то в данном случае функция Printing выполнялась только после повторного запуска потока, что доказывает, что после вызова метода Resume() поток продолжает своё выполнение с точки останова.

Аналогичный эффект можно достичь следующим образом: в функции Printing вызвать метод Suspend()

//вывод состояния передачи данных на экран void __fastcall WriteThread::Printing()

{

if(!fl) //проверяем состояние флажка

{

Form1->StatusBar1->Panels->Items[0]->Text = "Ошибка передачи";

http://piclist.ru/

17

© PIClist RUS, 2007

Работа с COM-портом с помощью потоков

return;

}

Form1->StatusBar1->Panels->Items[0]->Text = "Передача прошла успешно";

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

}

а в главной функции потока добавить тестовую строку после вызова функции Printing:

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

{

while(!Terminated)	//пока поток не будет завершён, выполнять цикл
{
..........	//вывести состояние операции в строке состояния
Synchronize(Printing);
Form1->Memo1->Lines->Add("Тест!");
}		//перед выходом из потока закрыть объект-событие
CloseHandle(overlappedwr.hEvent);

}

В этом случае информация о состоянии операции выведется в панель состояния, а вот тестовая строка появится только при следующем запуске потока.

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

И всё же лучше всего вызов метода Suspend() поместить в конце цикла в главной функции, после вызова функции Printing:

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

{

while(!Terminated)		//пока поток не будет завершён, выполнять цикл
{
..........		//вывести состояние операции в строке состояния
Synchronize(Printing);
writer->Suspend();	//приостановить поток записи в порт, пока он не потребуется снова
}			//перед выходом из потока закрыть объект-событие
CloseHandle(overlappedwr.hEvent);

}

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

3) Интересный момент – это уничтожение потока методом Terminate(). Вот как выглядит код завершения потока в случае использования данных методов:

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

if(writer) //проверка if(writer) обязательна, иначе возникают ошибки

{

writer->Terminate(); writer->Resume();

}

Так как поток записи активируется только когда необходимо передать данные, велика вероятность, что когда потребуется его завершить, поток будет находиться в остановленном состоянии и не сможет выполнить завершение. Тогда после вызова метода Terminate(), который установит в true свойство потока Terminated, необходимо вызвать метод Resume(), чтобы активировать поток. В этом случае поток сможет выполнить проверку на значение Terminated=true (в цикле while(!Terminated)) и завершиться.

http://piclist.ru/

18

© PIClist RUS, 2007

Работа с COM-портом с помощью потоков

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

Создание потока средствами WinAPI

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

Создание потока чтения

Перед тем как создать поток, используя средства WinAPI, необходимо объявить и создать функцию, которая будет выполняться потоком. Эта функция имеет прототип

DWORD WINAPI ThreadFunc(LPVOID);

где ThreadFunc – имя функции, задаваемое пользователем. Например:

DWORD WINAPI ReadThread(LPVOID);

В эту функцию и запишем основной код потока чтения:

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

if(GetOverlappedResult(COMport, &overlapped, &temp, true)) //проверяем, успешно ли завершилась перекрываемая

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

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

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

http://piclist.ru/

19

© PIClist RUS, 2007

Работа с COM-портом с помощью потоков

разве только использования дополнительных функций (наподобие Printing() в TThread, об этом подробнее сказано ниже).

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

HANDLE reader;

reader = CreateThread(NULL, 0, ReadThread, NULL, 0, NULL);

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

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

CreateEvent).

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

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

это функция ReadThread. Следует заметить, что функция должна быть объявлена с соглашением вызова WINAPI* и возвращать 32-битный код выхода (параметр типа DWORD). Прототип функции см. выше.

-четвёртый параметр, равный NULL, - это 32-битное значение параметра, передаваемого в поток. В данном случае этот параметр не используется, поэтому равен NULL.

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

-шестой параметр представляет собой указатель на 32-битную переменную (типа DWORD), в которую будет помещён идентификатор создаваемого потока. Так как нам идентификатор потока не нужен, в качестве этого параметра указываем NULL.

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

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

ивызывается также как и обычная функция.

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);

}

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

После того как поток больше не нужен, его следует завершить. Поток чтения завершается при закрытии порта, в функции COMClose(). Для этого используется функция TerminateThread().

* К сожалению, авторы данной статьи не знают, что это такое.

http://piclist.ru/

20

© PIClist RUS, 2007