Баг в работе с COM портом

void COMOpen()
{
 char* portname;         //имя порта (например, "COM1", "COM2" и т.д.)
 DCB dcb;                //структура для общей инициализации порта DCB
 COMMTIMEOUTS timeouts;  //структура для установки таймаутов
 
 portname = Form1->ComboBox1->Text.t_str(); //получить имя выбранного порта
 
 //открыть порт, для асинхронных операций обязательно нужно указать флаг FILE_FLAG_OVERLAPPED
 COMport = CreateFile(portname,GENERIC_READ | GENERIC_WRITE,0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 
 if(COMport == INVALID_HANDLE_VALUE)            //если ошибка открытия порта
  {
   Form1->Memo1->Lines->Add("Не удалось открыть порт");       //вывести сообщение в строке состояния
   return;
  }
 
 //инициализация порта
 
 dcb.DCBlength = sizeof(DCB);   //в первое поле структуры DCB необходимо занести её длину, она будет использоваться функциями настройки порта для контроля корректности структуры
 
 //считать структуру DCB из порта
 if(!GetCommState(COMport, &dcb))   //если не удалось - закрыть порт и вывести сообщение об ошибке в строке состояния
  {
   COMClose();
   Form1->Memo1->Lines->Add("Не удалось считать DCB");
   return;
  }
 
 //инициализация структуры DCB
 dcb.BaudRate = StrToInt(Form1->ComboBox2->Text);       //задаём скорость передачи
 dcb.fBinary = TRUE;                                    //включаем двоичный режим обмена
 dcb.fOutxCtsFlow = FALSE;                              //выключаем режим слежения за сигналом CTS
 dcb.fOutxDsrFlow = FALSE;                              //выключаем режим слежения за сигналом DSR
 dcb.fDtrControl = DTR_CONTROL_ENABLE;                 //отключаем использование линии DTR
 dcb.fDsrSensitivity = FALSE;                           //отключаем восприимчивость драйвера к состоянию линии DSR
 dcb.fNull = FALSE;                                     //разрешить приём нулевых байтов
 dcb.fRtsControl = RTS_CONTROL_DISABLE;                 //отключаем использование линии RTS
 dcb.fAbortOnError = TRUE;                             //отключаем остановку всех операций чтения/записи при ошибке
 dcb.ByteSize = 8;                                      //задаём число бит в байте
 dcb.Parity = 0;                                        //отключаем проверку чётности
 dcb.StopBits = 0;                                      //задаём один стоп-бит
 
 //загрузить структуру DCB в порт
 if(!SetCommState(COMport, &dcb))   //если не удалось - закрыть порт и вывести сообщение об ошибке в строке состояния
  {
   COMClose();
   Form1->Memo1->Lines->Add("Не удалось установить DCB");
   return;
  }
 
 //установить таймауты
 timeouts.ReadIntervalTimeout = 10;     //таймаут между двумя символами
 timeouts.ReadTotalTimeoutMultiplier = 10;  //общий таймаут операции чтения
 timeouts.ReadTotalTimeoutConstant = 10;         //константа для общего таймаута операции чтения
 timeouts.WriteTotalTimeoutMultiplier = 10;      //общий таймаут операции записи
 timeouts.WriteTotalTimeoutConstant = 10;        //константа для общего таймаута операции записи
 
 //записать структуру таймаутов в порт
 if(!SetCommTimeouts(COMport, &timeouts))   //если не удалось - закрыть порт и вывести сообщение об ошибке в строке состояния
  {
   COMClose();
   Form1->Memo1->Lines->Add("Не удалось установить тайм-ауты");
   return;
  }
 
 //установить размеры очередей приёма и передачи
 SetupComm(COMport,4000,4000);
 
 PurgeComm(COMport, PURGE_RXCLEAR); //очистить принимающий буфер порта
 
 reader = CreateThread(NULL, 0, ReadThread, NULL, 0, NULL);     //создаём поток чтения, который сразу начнёт выполняться (предпоследний параметр = 0)
 
 Form1->Memo1->Lines->Add("Порт открыт");
 
}

void ReadPrinting()
{
 AnsiString answer = AnsiString((char *)bufrd);
 Form1->Memo1->Lines->Add("Ответ: " + answer);
 
 memset(bufrd, 0, BUFSIZE);                  //очистить буфер (чтобы данные не накладывались друг на друга)
 PurgeComm(COMport, PURGE_RXCLEAR);
 }
//---------------------------------------------------------------------------
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)                                  //если событие прихода байта произошло
    {
     if(GetOverlappedResult(COMport, &overlapped, &temp, true)) //проверяем, успешно ли завершилась перекрываемая операция WaitCommEvent
      if((mask & EV_RXCHAR)!=0)                                 //если произошло именно событие прихода байта
       {
        ClearCommError(COMport, &temp, &comstat);               //нужно заполнить структуру COMSTAT
        btr = comstat.cbInQue;                                  //и получить из неё количество принятых байтов
        if(btr)                                                 //если действительно есть байты для чтения
        {
         memset(bufrd, 0, BUFSIZE);
         ReadFile(COMport, bufrd, btr, &temp, &overlapped);     //прочитать байты из порта в буфер программы
         counter+=btr;                                          //увеличиваем счётчик байтов
         ReadPrinting();                                        //вызываем функцию для вывода данных на экран и в файл
        }
       }
    }
  }
}

Ответ: я!0117010D00000000570400570400D0070000000000000ADE2

Ответ: я!0117010D0000000057040057040 Ответ: 0D0070000000000000ADE2

while(!Terminated)                     //пока поток не будет прерван, выполняем цикл

bufrd_TMP+=(char*)bufrd;

                if(btr)                                     //если действительно есть байты для чтения
                {
                    ReadFile(COMport, bufrd, btr, &temp, &overlapped);     //прочитать байты из порта в буфер программы
                    counter+=btr;                                          //увеличиваем счётчик байтов
                    Synchronize(Printing);                              //вызываем функцию для вывода данных на экран и в файл
                }

void Getis(int as)
{
 char a[2];
 memset(bufwr,0,BUFSIZE);
 PurgeComm(COMport, PURGE_TXCLEAR);         
 a[0] = as + '0';
 a[1] = 0;
 strcpy(bufwr,a);                             
 writer->Resume();                          //а здесь возникает ошибка
 }

 if(as == 1) static char a = '1';
 if(as == 2) static char a = '2';

#pragma hdrstop
#include <vcl.h>
#include "Formas.h"
#include <vcl/dstring.h>
#include <io.h>         //äëÿ ðàáîòû ñ ôàéëàìè
#include <fcntl.h>      //äëÿ ðàáîòû ñ ôàéëàìè
#include <sys\stat.h>   //äëÿ ðàáîòû ñ ôàéëàìè
#include <windows.h>
//---------------------------------------------------------------------------
 
#pragma package(smart_init)
//=============================================================================
//..................... îáúÿâëåíèÿ ãëîáàëüíûõ ïåðåìåííûõ ......................
//=============================================================================
extern int Status;
extern int fuseH;
extern int fuseL;
extern int fuseS;
#define BUFSIZE 128     //¸ìêîñòü áóôåðà
 
extern unsigned char bufrd[BUFSIZE], bufwr[BUFSIZE]; //ïðè¸ìíûé è ïåðåäàþùèé áóôåðû
AnsiString CompletePackage="",bufrd_TMP="";//ñòðîêè äëÿ ïàðñåðà ïðèíèìàåìûõ äàííûõ
 char a[2];
//---------------------------------------------------------------------------
 
extern HANDLE COMport;      //äåñêðèïòîð ïîðòà
 
//ñòðóêòóðà OVERLAPPED íåîáõîäèìà äëÿ àñèíõðîííûõ îïåðàöèé, ïðè ýòîì äëÿ îïåðàöèè ÷òåíèÿ è çàïèñè íóæíî îáúÿâèòü ðàçíûå ñòðóêòóðû
//ýòè ñòðóêòóðû íåîáõîäèìî îáúÿâèòü ãëîáàëüíî, èíà÷å ïðîãðàììà íå áóäåò ðàáîòàòü ïðàâèëüíî
extern OVERLAPPED overlapped;       //áóäåì èñïîëüçîâàòü äëÿ îïåðàöèé ÷òåíèÿ (ñì. ïîòîê ReadThread)
extern OVERLAPPED overlappedwr;         //áóäåì èñïîëüçîâàòü äëÿ îïåðàöèé çàïèñè (ñì. ïîòîê WriteThread)
//---------------------------------------------------------------------------
//extern int handle;                //äåñêðèïòîð äëÿ ðàáîòû ñ ôàéëîì ñ ïîìîùüþ áèáëèîòåêè <io.h>
//---------------------------------------------------------------------------
 
extern bool fl=0;   //ôëàã, óêàçûâàþùèé íà óñïåøíîñòü îïåðàöèé çàïèñè (1 - óñïåøíî, 0 - íå óñïåøíî)
 
extern unsigned long counter;   //ñ÷¸ò÷èê ïðèíÿòûõ áàéòîâ, îáíóëÿåòñÿ ïðè êàæäîì îòêðûòèè ïîðòà
 
//=============================================================================
//.............................. îáúÿâëåíèÿ ôóíêöèé ...........................
//=============================================================================
 
//extern void COMOpen(void);             //îòêðûòü ïîðò
//extern void COMClose(void);            //çàêðûòü ïîðò
 
//=============================================================================
//.............................. ðåàëèçàöèÿ ïîòîêîâ ...........................
//=============================================================================
 //ïîòîê äëÿ ÷òåíèÿ ïîñëåäîâàòåëüíîñòè áàéòîâ èç COM-ïîðòà â áóôåð
class ReadThread : public TThread
{
 private:
        void __fastcall Printing(); //âûâîä ïðèíÿòûõ áàéòîâ íà ýêðàí è â ôàéë
 protected:
        void __fastcall Execute();  //îñíîâíàÿ ôóíêöèÿ ïîòîêà
        //void __fastcall Synchronize();
 public:
        __fastcall ReadThread(bool CreateSuspended);    //êîíñòðóêòîð ïîòîêà
};
//---------------------------------------------------------------------------
 
//ïîòîê äëÿ çàïèñè ïîñëåäîâàòåëüíîñòè áàéòîâ èç áóôåðà â COM-ïîðò
class WriteThread : public TThread
{
private:
    void __fastcall Printing(); //âûâîä ñîñòîÿíèÿ íà ýêðàí
protected:
        void __fastcall Execute();      //îñíîâíàÿ ôóíêöèÿ ïîòîêà
        //void __fastcall Synchronize();
public:
        __fastcall WriteThread(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()
{
bufrd_TMP+=(char*)bufrd;
for (int j=1;j<bufrd_TMP.Length();j++)
    if (bufrd_TMP.SubString(j,1)=="$")
    {
        CompletePackage=bufrd_TMP.SubString(1,j-1);//???????? ?????? ?????
        bufrd_TMP=bufrd_TMP.SubString(j,bufrd_TMP.Length());//??????? ???????????? ? bufrd_TMP
        break;
    }
 Form1->Memo1->Lines->Add((char*)bufrd);    //âûâîäèì ïðèíÿòóþ ñòðîêó â Memo
 Form1->StatusBar1->Panels->Items[2]->Text = "Âñåãî ïðèíÿòî " + IntToStr(counter) + " áàéò";    //âûâîäèì ñ÷¸ò÷èê â ñòðîêå ñîñòîÿíèÿ
 memset(bufrd, 0, BUFSIZE);         //î÷èñòèòü áóôåð (÷òîáû äàííûå íå íàêëàäûâàëèñü äðóã íà äðóãà)
}
 
//---------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
//............................... ïîòîê 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);       //ñîçäàòü ñîáûòèå
 
 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);    //âûâåñòè ñîñòîÿíèå îïåðàöèè â ñòðîêå ñîñòîÿíèÿ
  writer->Suspend();        //ïðèîñòàíîâèòü ïîòîê çàïèñè â ïîðò, ïîêà îí íå ïîòðåáóåòñÿ ñíîâà
 }
 CloseHandle(overlappedwr.hEvent);      //ïåðåä âûõîäîì èç ïîòîêà çàêðûòü îáúåêò-ñîáûòèå
}
 
//---------------------------------------------------------------------------
 
//âûâîä ñîñòîÿíèÿ ïåðåäà÷è äàííûõ íà ýêðàí
void __fastcall WriteThread::Printing()
{
 if(!fl)    //ïðîâåðÿåì ñîñòîÿíèå ôëàæêà
  {
   Form1->StatusBar1->Panels->Items[0]->Text  = "Îøèáêà ïåðåäà÷è";
   return;
  }
 Form1->StatusBar1->Panels->Items[0]->Text  = "Ïåðåäà÷à ïðîøëà óñïåøíî";
 
}
 
//---------------------------------------------------------------------------
 
/*/îáðàáîò÷èê íàæàòèÿ íà êíîïêó "Îòêðûòü ïîðò"
void __fastcall TForm1::SpeedButton1Click(TObject *Sender)
{
 if(SpeedButton1->Down)
  {
   COMOpen();                   //åñëè êíîïêà íàæàòà - îòêðûòü ïîðò
   counter = 0; //ñáðàñûâàåì ñ÷¸ò÷èê áàéòîâ
  }
 
 else
  {
   COMClose();                  //åñëè êíîïêà îòæàòà - çàêðûòü ïîðò
  }
} //*/
 
//---------------------------------------------------------------------------
 
//îáðàáîò÷èê çàêðûòèÿ ôîðìû
void CloseFormas(void)
{
 if(reader)reader->Terminate();     //çàâåðøèòü ïîòîê ÷òåíèÿ èç ïîðòà, ïðîâåðêà if(reader) îáÿçàòåëüíà, èíà÷å âîçíèêàþò îøèáêè
 if(writer)writer->Terminate();         //çàâåðøèòü ïîòîê çàïèñè â ïîðò, ïðîâåðêà if(writer) îáÿçàòåëüíà, èíà÷å âîçíèêàþò îøèáêè
 if(COMport)CloseHandle(COMport);       //çàêðûòü ïîðò
} //*/
 
//=============================================================================
//........................... ðåàëèçàöèè ôóíêöèé ..............................
//=============================================================================
 
//---------------------------------------------------------------------------
 
//ôóíêöèÿ îòêðûòèÿ è èíèöèàëèçàöèè ïîðòà
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->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 = 9600;                                   //çàäà¸ì ñêîðîñòü ïåðåäà÷è 9600 áîä
 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;
  }
}
 
//---------------------------------------------------------------------------
 
//ôóíêöèÿ çàêðûòèÿ ïîðòà
void COMClose()
{
 //åñëè ïîòîê çàïèñè ñóùåñòâóåò, ïîäàòü åìó êîìàíäó íà çàâåðøåíèå è çàïóñòèòü åãî, ÷òîáû îí âûïîëíèë çàâåðøåíèå;
 if(writer) //ïðîâåðêà if(writer) îáÿçàòåëüíà, èíà÷å âîçíèêàþò îøèáêè;
  {
   writer->Terminate();
   writer->Resume();
  }
 
 if(reader)reader->Terminate();         //åñëè ïîòîê ÷òåíèÿ ðàáîòàåò, çàâåðøèòü åãî; ïðîâåðêà if(reader) îáÿçàòåëüíà, èíà÷å âîçíèêàþò îøèáêè
 CloseHandle(COMport);                  //çàêðûòü ïîðò
 COMport=0;             //îáíóëèòü ïåðåìåííóþ äëÿ äåñêðèïòîðà ïîðòà
}
 
//---------------------------------------------------------------------------
void Getis(int as)
{
 memset(bufwr,0,BUFSIZE);           //î÷èñòèòü ïðîãðàììíûé ïåðåäàþùèé áóôåð, ÷òîáû äàííûå íå íàêëàäûâàëèñü äðóã íà äðóãà
 PurgeComm(COMport, PURGE_TXCLEAR);             //î÷èñòèòü ïåðåäàþùèé áóôåð ïîðòà
 if(as == 1) static char a = '1';
 if(as == 2) static char a = '2';
 //a[0] = as + '0';
 //a[1] = 0;
 strcpy(bufwr,a);                              //çàíåñòè â ïðîãðàììíûé ïåðåäàþùèé áóôåð ñòðîêó êîìàííäó
 writer->Resume();                          //àêòèâèðîâàòü ïîòîê çàïèñè â ïîðò
 }
//---------------------------------------------------------------------------

while(!Terminated)

//главная функция потока, выполняет передачу байтов из буфера в 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);  //записать байты в порт (перекрываемая операция!)
   signal = WaitForSingleObject(overlappedwr.hEvent, INFINITE);   //приостановить поток, пока не завершится перекрываемая операция WriteFile
 
   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);
   
  }
}