Обработка событий элементами формы

//=============================================================================
// Программа предназначена для работы с микроконтроллером
// через COM-порт(usb) с использованием асинхронных операций
// Используются потоки WINAPI с функциями ResumeThread() и SuspendThread()
//=============================================================================
 
#include <vcl.h>
#pragma hdrstop
#include <fstream.h>
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//=============================================================================
//..................... объявления глобальных переменных ......................
//=============================================================================
 
#define BUFSIZE 256         //ёмкость буфера
#define ACCOUNTSIZE 32      //длина пакета
unsigned char bufrd[BUFSIZE], bufwr[BUFSIZE]; //приёмный и передающий буферы
unsigned char errorload;
 
   unsigned char b, s, r, sort[ACCOUNTSIZE];
   unsigned short int His, Los, summa;
   unsigned char str, data, data1;    //команды и данные для Atmega
 
//---------------------------------------------------------------------------
 
HANDLE COMport;     //дескриптор порта
 
//структура OVERLAPPED необходима для асинхронных операций, при этом для операции чтения и записи нужно объявить разные структуры
//эти структуры необходимо объявить глобально, иначе программа не будет работать правильно
OVERLAPPED overlapped;      //будем использовать для операций чтения (поток ReadThread)
OVERLAPPED overlappedwr;    //будем использовать для операций записи (поток WriteThread)
 
//---------------------------------------------------------------------------
 
bool fl=0;  //флаг, указывающий на успешность операций записи (1 - успешно, 0 - не успешно)
bool waitl=0;
unsigned long counter;  //счётчик принятых байтов, обнуляется при каждом открытии порта
 
//=============================================================================
//.............................. объявления функций ...........................
//=============================================================================
 
void COMOpen(void);             //открыть порт
void COMClose(void);            //закрыть порт
void ReadAccountEnd(void);      //обработка пакета от интерфейса
void WriteToAtmega(unsigned char str, unsigned char data,
                   unsigned char data1
                   );//передать пакет интерфейсу
void ReceiveAccount(void);      //запрос пакета от интерфейса
void WriteToAtmegaOutPort(void);//инвертирование состояния линии выходного порта
//=============================================================================
//.............................. объявления потоков ...........................
//=============================================================================
 
HANDLE reader;  //дескриптор потока чтения из порта
HANDLE writer;  //дескриптор потока записи в порт
 
DWORD WINAPI ReadThread(LPVOID);
DWORD WINAPI WriteThread(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)                      //если событие прихода байта произошло
    {
     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;                            //увеличиваем счётчик байтов
         ReadPrinting();                            //вызываем функцию для вывода данных на экран и в файл
        }
       }
    }
  }
}
 
//---------------------------------------------------------------------------
//выводим принятые байты на экран и в файл (если включено)
//---------------------------------------------------------------------------
 
void ReadPrinting()
{
 Form1->StatusBar1->Panels->Items[2]->Text = "Всего принято " + IntToStr(counter) + " байт";    //выводим счётчик в строке состояния
 if(Form1->CheckBox3->Checked == true)//если включен режим вывода в файл
 {
 //Если считано заданное количетво байт
 if(counter == 32) ReadAccountEnd();
 }
 memset(bufrd, 0, BUFSIZE); //очистить буфер (чтобы данные не накладывались друг на друга)
}
//-----------------------------------------------------------------------------
//............................... поток 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(COMport, bufwr, 32, &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);
  }
}
 
//---------------------------------------------------------------------------
 
 
//=============================================================================
//............................. элементы формы ................................
//=============================================================================
 
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
{
 Form1->Label5->Enabled = false;
 Form1->Label6->Enabled = false;
 Form1->Button1->Enabled = false;
 
}
 
//---------------------------------------------------------------------------
//обработчик нажатия на кнопку "Открыть порт"
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton1Click(TObject *Sender)
{
 if(SpeedButton1->Down)             //если кнопка нажата - открыть порт
  {
   COMOpen();
 
   Form1->ComboBox1->Enabled = false;
   Form1->ComboBox2->Enabled = false;
   Form1->Button1->Enabled = true;
   Form1->Button2->Enabled = true;
   Form1->SpeedButton1->Caption = "Закрыть порт";//сменить надпись на кнопке
 
   counter = 0; //сбрасываем счётчик байтов
  }
 
 else           //если кнопка отжата - закрыть порт
  {
   COMClose();
   Form1->SpeedButton1->Caption = "Открыть порт"; //сменить надпись на кнопке
   Form1->StatusBar1->Panels->Items[0]->Text = "";//очистить первую колонку строки состояния
 
   Form1->ComboBox1->Enabled = true;
   Form1->ComboBox2->Enabled = true;
   Form1->Button1->Enabled = false;
   Form1->Button2->Enabled = false;
  } 
}
 
//---------------------------------------------------------------------------
//обработчик закрытия формы
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
 COMClose();
}
//---------------------------------------------------------------------------
//галочка "Сохранить в файл"
//---------------------------------------------------------------------------
void __fastcall TForm1::CheckBox3Click(TObject *Sender)
{
 if(Form1->CheckBox3->Checked)      //если галочка включена
  {
   //активировать соответствующие элементы на форме
   Form1->Label5->Enabled = true;
   Form1->Label6->Enabled = true;
   //вывести индикатор записи в файл в строке состояния
   Form1->StatusBar1->Panels->Items[1]->Text = "Вывод в файл!";
  }
 else                   //если галочка выключена
  {
   //отключить соответствующие элементы на форме
   Form1->Label5->Enabled = false;
   Form1->Label6->Enabled = false;
   //убрать индикатор записи в файл из строки состояния
   Form1->StatusBar1->Panels->Items[1]->Text = "";
  }
}
//---------------------------------------------------------------------------
//кнопка "Передать-Принять"
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
WriteToAtmegaOutPort();
ReceiveAccount();
}
 //---------------------------------------------------------------------------
//функция запрос состояния интерфейса
//---------------------------------------------------------------------------
 
void ReceiveAccount(void)
{
Form1->Memo1->Clear();  //очистить Memo1
Form1->Memo2->Clear();  //очистить Memo1
Form1->Memo3->Clear();  //очистить Memo1
counter = 0;            //сбрасываем счётчик байтов
data=0;
memset(bufwr,0,BUFSIZE);//очистить программный передающий буфер, чтобы данные не накладывались друг на друга
PurgeComm(COMport, PURGE_TXCLEAR);    //очистить передающий буфер порта
bufwr[0]=0x55;
bufwr[1]=0xAA;
bufwr[2]=0x02;
bufwr[30]=0x01;
bufwr[31]=0x01;
ResumeThread(writer);        //активировать поток записи данных в порт
}
 
//---------------------------------------------------------------------------
//=============================================================================
//........................... реализации функций ..............................
//=============================================================================
 
//---------------------------------------------------------------------------
//функция открытия и инициализации порта
//---------------------------------------------------------------------------
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;
  }
 
 PurgeComm(COMport, PURGE_RXCLEAR);         //очистить принимающий буфер порта
 
 //создаём поток чтения, который сразу начнёт выполняться (предпоследний параметр = 0)
 reader = CreateThread(NULL, 0, ReadThread, NULL, 0, NULL);
 //создаём поток записи в остановленном состоянии (предпоследний параметр = CREATE_SUSPENDED)
 writer = CreateThread(NULL, 0, WriteThread, NULL, CREATE_SUSPENDED, NULL);
}
 
//---------------------------------------------------------------------------
//функция закрытия порта
//---------------------------------------------------------------------------
void COMClose()
{
//так как при прерывании потоков, созданных с помощью функций WinAPI, функцией TerminateThread
//поток может быть прерван жёстко, в любом месте своего выполнения, то освобождать дескриптор
//сигнального объекта-события, находящегося в структуре типа OVERLAPPED, связанной с потоком,
//следует не внутри кода потока, а отдельно, после вызова функции TerminateThread.
//После чего нужно освободить и сам дескриптор потока.
 
 if(writer)     //если поток записи работает, завершить его; проверка if(writer) обязательна, иначе возникают ошибки
  {TerminateThread(writer,0);
   CloseHandle(overlappedwr.hEvent);    //нужно закрыть объект-событие
   CloseHandle(writer);
  }
 if(reader)        //если поток чтения работает, завершить его; проверка if(reader) обязательна, иначе возникают ошибки
  {TerminateThread(reader,0);
   CloseHandle(overlapped.hEvent);      //нужно закрыть объект-событие
   CloseHandle(reader);
  }
 
 CloseHandle(COMport);                  //закрыть порт
 COMport=0;                 //обнулить переменную для дескриптора порта
}
 
//---------------------------------------------------------------------------
//функция окончания приёма пакета и его обработка
//---------------------------------------------------------------------------
 
void ReadAccountEnd(void)
{    unsigned short int outport=0;
     unsigned short int inpport=0;
     errorload=0;
     summa=0;
 
     //ищю стартовые байты пакета
     for(s=0; s<ACCOUNTSIZE; s++)  sort[s]=bufrd[s];
     //получаю смещение от начала  =r, ищу начало пакета если оно есть
      if( sort[0] != 0x55 & sort[1]!=0xAA)
      {for(s=0; s<32; s++){if(sort[s]==0x55 & sort[s+1]==0xAA) r=s;}}
       //а если 0xAA в конце файла те r=31 или вообще отсутствует те r=0xFF
       if(r==31 | r==0xFF) {errorload=1;}
 
     if(errorload==0)
     {
     //сортирую
     for(s=r,b=0; s<32; s++,b++)  bufrd[b]=sort[s];
       for(s=0,b=32-r; s<r; s++,b++)  bufrd[b]=sort[s];
     for(s=0; s<ACCOUNTSIZE; s++)  sort[s]=bufrd[s];
         //считаю и проверяю контрольную сумму
         for(s = 0; s < (ACCOUNTSIZE-3); s++) summa=summa + sort[s];
         His=summa >> 8;
         Los=summa & 0x00FF;
         if(His != sort[ACCOUNTSIZE-2] | Los != sort[ACCOUNTSIZE-1])
         {errorload=1;}
     }
 
    if(errorload == 0)
    {
    //вывожу в окно принятую информацию  с AD
    unsigned short int AD=0;
    Form1->Memo1->Clear();  //очистить Memo1
    AD=((AD+sort[6]) << 8) + sort[7];
    Form1->Memo1->Lines->Add("0=" + IntToStr(AD));
    AD=0;
    AD=((AD+sort[8]) << 8) + sort[9];
    Form1->Memo1->Lines->Add("1=" + IntToStr(AD));
    AD=0;
    AD=((AD+sort[10]) << 8) + sort[11];
    Form1->Memo1->Lines->Add("2=" + IntToStr(AD));
    AD=0;
    AD=((AD+sort[12]) << 8) + sort[13];
    Form1->Memo1->Lines->Add("3=" + IntToStr(AD));
    AD=0;
    AD=((AD+sort[14]) << 8) + sort[15];
    Form1->Memo1->Lines->Add("4=" + IntToStr(AD));
    AD=0;
    AD=((AD+sort[16]) << 8) + sort[17];
    Form1->Memo1->Lines->Add("5=" + IntToStr(AD));
    AD=0;
    AD=((AD+sort[18]) << 8) + sort[19];
    Form1->Memo1->Lines->Add("6=" + IntToStr(AD));
    AD=0;
    AD=((AD+sort[20]) << 8) + sort[21];
    Form1->Memo1->Lines->Strings[7]=("7=" + IntToStr(AD));
    //AD=((AD+sort[22]) << 8) + sort[23];      ????????????????
    //вывожу принятую информацию  с цифровых входов
    //unsigned short int inpport=0;
    inpport=sort[5] & 0x01;
    Form1->Memo2->Clear();  //очистить Memo1
    Form1->Memo2->Lines->Add("0=" + IntToStr(inpport));
    inpport=(sort[5] >> 1) & 0x01;
    Form1->Memo2->Lines->Add("1=" + IntToStr(inpport));
    inpport=(sort[5] >> 2) & 0x01;
    Form1->Memo2->Lines->Add("2=" + IntToStr(inpport));
    inpport=(sort[5] >> 3) & 0x01;
    Form1->Memo2->Lines->Add("3=" + IntToStr(inpport));
    inpport=(sort[5] >> 4) & 0x01;
    Form1->Memo2->Lines->Add("4=" + IntToStr(inpport));
    inpport=(sort[5] >> 5) & 0x01;
    Form1->Memo2->Lines->Add("5=" + IntToStr(inpport));
    inpport=(sort[5] >> 6) & 0x01;
    Form1->Memo2->Lines->Add("6=" + IntToStr(inpport));
    inpport=(sort[5] >> 7) & 0x01;
    Form1->Memo2->Lines->Strings[7]=("7=" + IntToStr(inpport));
    //вывожу принятую информацию  с цифровых выходов
    //unsigned short int outport=0;
    Form1->Memo3->Clear();                                 //очистить Memo1
    outport=sort[28] & 0x01;
    Form1->Memo3->Lines->Add("0=" + IntToStr(outport));
    if(outport > 0) Form1->Button3->Caption="0=1";
    if(outport == 0) Form1->Button3->Caption="0=0";
 
    outport=(sort[28] >> 1) & 0x01;
    Form1->Memo3->Lines->Add("1=" + IntToStr(outport));
    if(outport > 0) Form1->Button4->Caption="1";
    if(outport == 0) Form1->Button4->Caption="0";
 
    outport=(sort[28] >> 2) & 0x01;
    Form1->Memo3->Lines->Add("2=" + IntToStr(outport));
    if(outport > 0) Form1->Button5->Caption="1";
    if(outport == 0) Form1->Button5->Caption="0";
 
    outport=(sort[28] >> 3) & 0x01;
    Form1->Memo3->Lines->Add("3=" + IntToStr(outport));
    if(outport > 0) Form1->Button6->Caption="1";
    if(outport == 0) Form1->Button6->Caption="0";
 
    outport=(sort[28] >> 4) & 0x01;
    Form1->Memo3->Lines->Add("4=" + IntToStr(outport));
    if(outport > 0) Form1->Button7->Caption="1";
    if(outport == 0) Form1->Button7->Caption="0";
 
    outport=(sort[28] >> 5) & 0x01;
    Form1->Memo3->Lines->Add("5=" + IntToStr(outport));
    if(outport > 0) Form1->Button8->Caption="1";
    if(outport == 0) Form1->Button8->Caption="0";
 
    outport=(sort[28] >> 6) & 0x01;
    Form1->Memo3->Lines->Add("6=" + IntToStr(outport));
    if(outport > 0) Form1->Button9->Caption="1";
    if(outport == 0) Form1->Button9->Caption="0";
 
    outport=(sort[28] >> 7) & 0x01;
    Form1->Memo3->Lines->Strings[7]=("7=" + IntToStr(outport));
    if(outport > 0) Form1->Button10->Caption="1";
    if(outport == 0) Form1->Button10->Caption="0";
 
     Form1->StatusBar1->Panels->Items[0]->Text  = "Пакет успешно принят";
     //контрольная сумма совпала пишу файл
     ofstream out("Account.bin",ios::out | ios::binary | ios::ate);
     out.write(sort,ACCOUNTSIZE);
     out.close();
     }
}
//---------------------------------------------------------------------------
////функция пакета атмеге
//---------------------------------------------------------------------------
 
void WriteToAtmega(unsigned char str, unsigned char data, unsigned char data1)
{
for(s=0; s<ACCOUNTSIZE; s++)  bufwr[s]=sort[s];
bufwr[0]=0x55;
bufwr[1]=0xAA;
bufwr[str]=data;    //команда
bufwr[str+1]=data1; //данные
//считаю контрольную сумму
summa=0;
for(s = 0; s < (ACCOUNTSIZE-3); s++) summa=summa + sort[s];
His=summa >> 8;
Los=summa & 0x00FF;
bufwr[29]=His;
bufwr[31]=Los;
ResumeThread(writer);        //активировать поток записи данных в порт
}
 
 
//кнопка запрос состояния интерфейса
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{ReceiveAccount();
 ReceiveAccount();
}
 
//---------------------------------------------------------------------------
//Управление 0-м логическим выходом
//---------------------------------------------------------------------------
void WriteToAtmegaOutPort()
{
    data=sort[28] & 0x01;
    if(data == 1){
       bufwr[28]=sort[28] &  0xFE;
       WriteToAtmega(2, 9, bufwr[28]);
      }
    if(data == 0){
       bufwr[28]=sort[28] | 0x01;
       WriteToAtmega(2, 9, bufwr[28]);
      }
 }
 
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
 WriteToAtmegaOutPort();
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::CheckBox1Click(TObject *Sender)
{
Form1->Memo3->Lines->Add(":(");
Form1->Edit1->Text=":(";
WriteToAtmegaOutPort();
ReceiveAccount();
}
//---------------------------------------------------------------------------

WriteToAtmegaOutPort();
ReceiveAccount();