Subversion Repositories miniuart2

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
 
#include <stdlib.h>
#include "Thread.h"
 
#pragma package(smart_init)
 
//static AnsiString asBuf = "";
static char sBuf[205];
static stErr stErr1;
HANDLE hComm;
 
//---------------------------------------------------------------------------
//   Important: Methods and properties of objects in VCL can only be
//   used in a method called using Synchronize, for example:
//
//      Synchronize(UpdateCaption);
//
//   where UpdateCaption could look like:
//
//      void __fastcall Thread_Com::UpdateCaption()
//      {
//        Form1->Caption = "Updated in a thread";
//      }
//---------------------------------------------------------------------------
__fastcall Thread_Com::Thread_Com(bool CreateSuspended,
   int NumPortD, int BaudRateD) : TThread(CreateSuspended)
{
   NumPort = NumPortD;
   BaudRate = BaudRateD;
   Priority = tpHigher;
}
 
//---------------------------------------------------------------------------
void __fastcall Thread_Com::AfterConstruction()
{
   DCB dcb;
   BOOL fSuccess;
   char str[5] = "COM0\x0";
 
   str[3] = NumPort + 0x30;
   hComm = CreateFile(str, GENERIC_READ | GENERIC_WRITE, 0, 0,
                      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 
   if (hComm == INVALID_HANDLE_VALUE)
   {
      sLastErr = "Impossible d'ouvrir COM"+AnsiString(NumPort);
   	dwLastErr = CANT_OPEN_COM;
      return;
   }
   fSuccess = GetCommState(hComm, &dcb);
   dcb.BaudRate = BaudRate;
   dcb.ByteSize = 8;
   dcb.Parity = NOPARITY;
   dcb.StopBits = ONESTOPBIT;
   fSuccess |= SetCommState(hComm, &dcb);
 
   if (!fSuccess)
   {
      sLastErr = "Impossible de configurer COM"+AnsiString(NumPort);
   	dwLastErr = CANT_CONFIG_COM;
      CloseHandle(hComm);
      return;
   }
 
   Resume();
}
 
 
//---------------------------------------------------------------------------
void __fastcall Thread_Com::Execute()
{
   LPSTR lpBuf;
   DWORD dwNumByteRead;
   DWORD dwRes;
   BOOL fWaitingOnRead = false;
   OVERLAPPED osReader = {0};
   lpBuf = (char *)malloc(2);
 
// Interdire l'execution si le port serie n'a pu être ouvert
   if (hComm == INVALID_HANDLE_VALUE)return;
 
// Definition d'un évènement
   osReader.hEvent = CreateEvent(NULL, true, false, NULL);
   if (osReader.hEvent == NULL)   // Error creating overlapped event; abort.
   {
      sLastErr = "Erreur lors de la creation d'evènement";
   	dwLastErr = CREATE_EV_ERROR;
   }
 
   while (Terminated == false)
   {
	// Procedure pour lire sur le port hComm
      if (!fWaitingOnRead)
      {
         // Issue the operation
         if (!ReadFile(hComm, lpBuf, 1, &dwNumByteRead, &osReader))
         {
            if (GetLastError() != ERROR_IO_PENDING)   // Read not delayed ?
            {  // Error in communications ; report it
      			sLastErr = "Erreur de lecture sur COM"+AnsiString(NumPort);
			   	dwLastErr = ERR_READ_COM;
            }
            else fWaitingOnRead = true;
         }
         else // read completed immediately
            HandleASuccessfulRead(*lpBuf);
      }
 
      if (fWaitingOnRead)
      {
         dwRes = WaitForSingleObject(osReader.hEvent, READ_TIMEOUT);
         switch(dwRes)
         {
            // Read completed
            case WAIT_OBJECT_0:
               if (!GetOverlappedResult(hComm, &osReader, &dwNumByteRead, FALSE))
               {   // Error in communications ; report it
   	   			sLastErr = "Erreur de fin de lecture sur COM"+AnsiString(NumPort);
				   	dwLastErr = ERR_READOVER_COM;
               }
               else // Read completed successfully.
               {
               	dwLastErr = 0;
                  HandleASuccessfulRead(*lpBuf);
                  // Reset flag so that another operation can be issued
                  fWaitingOnRead = false;
               }
               break;
            case WAIT_TIMEOUT:
               // possible background work
               break;
            default:
               // Error in the WaitforSingleObject; abort.
  	   			sLastErr = "Erreur d'attente de lecture sur COM"+AnsiString(NumPort);
			   	dwLastErr = ERR_READWAIT_COM;
               break;
         }
      }
   }
   free(lpBuf);
   CloseHandle(osReader.hEvent);
   CloseHandle(hComm);
}
//---------------------------------------------------------------------------
BOOL __fastcall Thread_Com::WriteToComPort(AnsiString ASbuf)
{
   OVERLAPPED osWrite = {0};
   DWORD dwToWrite;
   DWORD dwNumByteWritten;
   BOOL fRes;
 
// Si le port serie n'a pu être ouvert, Sortir
   if (hComm == INVALID_HANDLE_VALUE)return false;
 
   dwToWrite = ASbuf.Length();
   char *lpBuf = ASbuf.c_str();
 
	// Create this write operation's OVERLAPPED structure's hEvent.
   osWrite.hEvent = CreateEvent(NULL, true, false, NULL);
   if (osWrite.hEvent == NULL)
      // Error creating overlapped event handle
      return false;
 
   // Issue write.
   if (!WriteFile(hComm, lpBuf, dwToWrite, &dwNumByteWritten, &osWrite))
   {
      if (GetLastError() != ERROR_IO_PENDING)
      {
         // WriteFile failed, but isn't delayed. Report error and abort.
  			sLastErr = "Erreur d'écriture sur COM"+AnsiString(NumPort);
	   	dwLastErr = ERR_WRITE_COM;
         fRes = false;
      }
      else
      {
         // Write is pending.
         if (!GetOverlappedResult(hComm, &osWrite, &dwNumByteWritten, true))
            fRes = false;
         else
         // Write operation completed successfully.
            fRes = true;
      }
   }
   else //WriteFile completed immediately.
   dwLastErr = 0;
   fRes = true;
 
   CloseHandle(osWrite.hEvent);
   return fRes;
}
 
 
//---------------------------------------------------------------------------
extern void ReceiveCallBack(char *c);
 
void __fastcall Thread_Com::HandleASuccessfulRead(char c)
{
	ReceiveCallBack(&c);
}