Работа с Com портом

//---------------------------------------------------------------------------
#ifndef ClassComPortH
#define ClassComPortH
#include <Classes.hpp>
//---------------------------------------------------------------------------
#define BUFSIZE 255 //ёмкость буфера
HANDLE COMport;
OVERLAPPED overlapped;                          //будем использовать для операций чтения (см. поток ReadThread)
OVERLAPPED overlappedwr;                        //будем использовать для операций записи (см. поток WriteThread)
unsigned char bufrd[BUFSIZE], bufwr[BUFSIZE];
unsigned long counter;
bool fl=0;                                      //флаг, указывающий на успешность операций записи (1 - успешно, 0 - не успешно)
//---------------------------------------------------------------------------
class TComPort
{
private:
    void __fastcall ComClose();
protected:
public:
    void __fastcall ComOpen(String NamePort, String SpeedPort, String Appointment);
    void __fastcall SendCommand(String ATComand);
    __fastcall TComPort();
    int PhoneEvents;                            //соятояние телефона
                                                //0 - мониторинг входящих вызовов
                                                //1 - мониторинг исходящих вызов
    String PhoneEvantsStr;
    String Phone;
};
//---------------------------------------------------------------------------
//клас потока отсылки сообщений
class SendThread : public TThread
{
private:
    void __fastcall SendPrinting();
protected:
    void __fastcall Execute();
public:
    __fastcall SendThread(bool CreateSuspended);
};
SendThread *SendMessages;
//---------------------------------------------------------------------------
//клас потока приема сообщений
class GetThread : public TThread
{
private:
    void __fastcall GetPrinting();
//  void __fastcall ClearPrinting();
protected:
    void __fastcall Execute();
public:
    __fastcall GetThread(bool CreateSuspended);
};
GetThread *GetMessages; //объект потока GetThread
//---------------------------------------------------------------------------
//клас потока приема сообщений
class ClearThread : public TThread
{
private:
    void __fastcall ClearPrinting();
protected:
    void __fastcall Execute();
public:
    __fastcall ClearThread(bool CreateSuspended);
};
ClearThread *ClearMessages; //объект потока ClearThread
//---------------------------------------------------------------------------
#endif

//---------------------------------------------------------------------------
#pragma hdrstop
#include "ClassComPort.h"
#include "MainUnit.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
//конструктор класса
__fastcall TComPort::TComPort()
{
}
//---------------------------------------------------------------------------
//конструктор потока отправки сообщений
__fastcall SendThread::SendThread(bool CreateSuspended) : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
//потоки приема сообщений
__fastcall GetThread::GetThread(bool CreateSuspended) : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
//потоки очистки сообщений
__fastcall ClearThread::ClearThread(bool CreateSuspended) : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
void __fastcall TComPort::ComOpen(String NamePort, String SpeedPort, String Appointment)
{
    DCB dcb;                                                                    //структура для общей инициализации порта DCB
    COMMTIMEOUTS timeouts;                                                      //структура для установки таймаутов
    //открыть порт, для асинхронных операций обязательно  нужно указать флаг FILE_FLAG_OVERLAPPED
    COMport = CreateFile(NamePort.t_str(),GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
    //здесь:
    // - NamePort.t_str() - имя порта в качестве имени файла, t_str() преобразует строку типа String в строку в виде массива типа char, иначе функция не примет
    // - GENERIC_READ | GENERIC_WRITE - доступ к порту на чтение/записть
    // - 0 - порт не может быть общедоступным (shared)
    // - NULL - дескриптор порта не наследуется, используется дескриптор безопасности по умолчанию
    // - OPEN_EXISTING - порт должен открываться как уже существующий файл
    // - FILE_FLAG_OVERLAPPED - этот флаг указывает на использование асинхронных операций
    // - NULL - указатель на файл шаблона не используется при работе с портами
    if(COMport == INVALID_HANDLE_VALUE) //если ошибка открытия порта
    {
        //обработать ошибку открытия порта
        return;
    }
    //инициализация порта
    dcb.DCBlength = sizeof(DCB);                                                //в первое поле структуры DCB необходимо занести её длину, она будет использоваться функциями настройки порта для контроля корректности структуры
    //считать структуру DCB из порта
    if(!GetCommState(COMport, &dcb))                                            //если не удалось - закрыть порт и вывести сообщение об ошибке в строке состояния
    {
        ComClose();
        //обработать ошибку считывания DBC
        return;
    }
    //инициализация структуры DCB
    dcb.BaudRate = StrToInt(SpeedPort);                                         //задаём скорость передачи 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();
        //обработать ошибку установку DBC
        return;
    }
    //установить таймауты
    timeouts.ReadIntervalTimeout = 0;                                           //таймаут между двумя символами
    timeouts.ReadTotalTimeoutMultiplier = 0;                                    //общий таймаут операции чтения
    timeouts.ReadTotalTimeoutConstant = 0;                                      //константа для общего таймаута операции чтения
    timeouts.WriteTotalTimeoutMultiplier = 0;                                   //общий таймаут операции записи
    timeouts.WriteTotalTimeoutConstant = 0;                                     //константа для общего таймаута операции записи
    //записать структуру таймаутов в порт
    if(!SetCommTimeouts(COMport, &timeouts))                                    //если не удалось - закрыть порт и вывести сообщение об ошибке в строке состояния
    {
        ComClose();
        //обработать ошибку установки тайм - аутов
        return;
    }
    //установить размеры очередей приёма и передачи
    SetupComm(COMport,2000,2000);
    PurgeComm(COMport, PURGE_RXCLEAR);                                          //очистить принимающий буфер порта
    GetMessages = new GetThread(false);                                         //создать и запустить поток чтения байтов
    GetMessages->FreeOnTerminate = true;                                         //установить это свойство потока, чтобы он автоматически уничтожался после завершения
}
//---------------------------------------------------------------------------
void __fastcall TComPort::ComClose()
{
    if(SendMessages) SendMessages->Terminate();                                 //если поток записи работает, завершить его; проверка    if(writer) обязательна, иначе возникают ошибки
    if(GetMessages) GetMessages->Terminate();                                   //если поток чтения работает, завершить его; проверка    if(reader) обязательна, иначе возникают ошибки
    CloseHandle(COMport); //закрыть порт
    COMport=0; //обнулить переменную для дескриптора порта
}
//---------------------------------------------------------------------------
//отправка команд
void __fastcall TComPort::SendCommand(String ATComand)
{
    char *Commandbuf = ATComand.t_str();
    memset(bufwr,0,BUFSIZE);                                                    //очистить программный передающий буфер, чтобы данные не накладывались друг на друга
    PurgeComm(COMport, PURGE_TXCLEAR);                                          //очистить передающий буфер порта
    strcpy(bufwr,Commandbuf);                                                   //занести в программный передающий буфер строку
    SendMessages = new SendThread(false);                                       //создать и активировать поток записи данных в порт
    SendMessages->FreeOnTerminate = true;
}
//---------------------------------------------------------------------------
//главная функция потока отправки команд
void __fastcall SendThread::Execute()
{
    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;
    Synchronize(SendPrinting); //вывести состояние операции в строке состояния
    CloseHandle(overlappedwr.hEvent); //перед выходом из потока закрыть объект-событие
}
//---------------------------------------------------------------------------
//вывод состояния передачи данных на экран
void __fastcall SendThread::SendPrinting()
{
    if(!fl)                                                                     //проверяем состояние флажка
    {
        //обработать ошибку передачи сообщения
        return;
    }
}
//---------------------------------------------------------------------------
//главная функция потока получения сообщений
void __fastcall GetThread::Execute()
{
    COMSTAT comstat;                                                            //структура текущего состояния порта, в данной программе используется для определения  количества принятых в порт байтов
    DWORD btr, temp, mask, signal;                                              //переменная temp используется в качестве заглушки
    overlapped.hEvent = CreateEvent(NULL, true, true, NULL);                    //создать сигнальный объект-событие для асинхронных операций
    SetCommMask(COMport, EV_RXCHAR);                                            //установить маску на срабатывание по событию приёма байта в порт
    while(!Terminated)                                                          //пока поток не будет прерван, выполняем цикл
    {
        if(ClearMessages) ClearMessages->Terminate();
        ClearMessages = new ClearThread(false);                                 //создать и активировать поток очистки данных в порту
        ClearMessages->FreeOnTerminate = true;
        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(GetPrinting);                                   //вызываем функцию для вывода данных на экран и в файл
                }
            }
        }
    }
    CloseHandle(overlapped.hEvent);                                             //перед выходом из потока закрыть объект-событие
}
//---------------------------------------------------------------------------
//вывод состояния получения данных на экран
void __fastcall GetThread::GetPrinting()
{
    MainForm->ThisPort->PhoneEvantsStr = "Свободен";
    String TextMessages = (char*)bufrd;                                         //выводим принятую строку (char*)bufrd
    int PositionIn = TextMessages.Pos("\"");
    if (PositionIn!= 0)
    {
        TextMessages = TextMessages.SubString(PositionIn + 1,TextMessages.Length() - PositionIn +1);
        TextMessages = "8" + TextMessages.SubString(3,TextMessages.Pos("\"")-3);
        MainForm->ThisPort->PhoneEvantsStr = "Входящий звонок";
        MainForm->Edit1->Text = TextMessages;
        MainForm->Label1->Caption = MainForm->ThisPort->PhoneEvantsStr;
        MainForm->ThisPort->PhoneEvents = 0;
    }
    PositionIn = TextMessages.Pos("+CLCC:");
    if (PositionIn!= 0)
    {
        int StatusPhone = StrToInt(TextMessages.SubString(14,1));
        //0     Соединение активно
        //1     Соединение удерживается
        //2     Осуществляется набор
        //3     Вызывается абонент
        //4     Входящее соединение
        //5     Ожидающее входящее соединение
        switch (StatusPhone)
        {
            case 0 :
                MainForm->ThisPort->PhoneEvantsStr = "Соединение активно";
                MainForm->Edit1->Text = MainForm->ThisPort->Phone;
                MainForm->Label1->Caption = MainForm->ThisPort->PhoneEvantsStr;
                MainForm->ThisPort->PhoneEvents = 1;
            break;
            case 1 :
                MainForm->ThisPort->PhoneEvantsStr = "Соединение удерживается";
                MainForm->Edit1->Text = MainForm->ThisPort->Phone;
                MainForm->Label1->Caption = MainForm->ThisPort->PhoneEvantsStr;
                MainForm->ThisPort->PhoneEvents = 1;
            break;
            case 2 :
                MainForm->ThisPort->PhoneEvantsStr = "Осуществляется набор";
                MainForm->Edit1->Text = MainForm->ThisPort->Phone;
                MainForm->Label1->Caption = MainForm->ThisPort->PhoneEvantsStr;
                MainForm->ThisPort->PhoneEvents = 1;
            break;
            case 3 :
                MainForm->ThisPort->PhoneEvantsStr = "Вызывается абонент";
                MainForm->Edit1->Text = MainForm->ThisPort->Phone;
                MainForm->Label1->Caption = MainForm->ThisPort->PhoneEvantsStr;
                MainForm->ThisPort->PhoneEvents = 1;
            break;
            default :
                MainForm->ThisPort->PhoneEvents = 0;
            break;
        }
//      MainForm->Memo1->Lines->Add(IntToStr(StatusPhone));                     //не требуется пока
    }
    else
    {
        MainForm->ThisPort->PhoneEvents = 0;
    }
    MainForm->Memo1->Lines->Add(TextMessages);
    memset(bufrd, 0, BUFSIZE);                                                  //очистить буфер (чтобы данные не накладывались друг на друга)
}
//---------------------------------------------------------------------------
//главная функция потока очистки сообщений
void __fastcall ClearThread::Execute()
{
    Sleep(5000);                                                                //самый оптимальный вариант засекал моргания почти нет
    if (!Terminated)
    {
        Synchronize(ClearPrinting);
    }
}
//---------------------------------------------------------------------------
//очистка выведенных данных
void __fastcall ClearThread::ClearPrinting()
{
    switch (MainForm->ThisPort->PhoneEvents)
    {
        case 0 :                                                                //если нет исходящего вызова
            MainForm->Edit1->Text = "";
            MainForm->Label1->Caption = "Свободен";
        break;
        case 1 :                                                                //если есть исходящий вызов
            MainForm->ThisPort->SendCommand("AT+CLCC;\r");                      //посылаем команду на проверку состояния
        break;
    }
}

//---------------------------------------------------------------------------
__fastcall TMainForm::TMainForm(TComponent* Owner)
    : TForm(Owner)
{
    ThisPort = new TComPort();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::Button1Click(TObject *Sender)
{
    ThisPort->ComOpen("COM4", "19200", "");
    ThisPort->PhoneEvents = 0;
    ThisPort->SendCommand("AT+CLIP=1;\r");                 //команда для того чтобы телефон нам присылал в ответе номер входящего вызова
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::Button2Click(TObject *Sender)
{
    ThisPort->Phone = Edit2->Text;
    ThisPort->PhoneEvents = 1;
    ThisPort->SendCommand("ATD"+Edit2->Text+";\r");
    Sleep(500);                                                         //пауза нужна чтобы телефон уже начал набор номера а потом мы отправляем команду для проверки состояния
    ThisPort->SendCommand("AT+CLCC;\r");
}
//---------------------------------------------------------------------------