tcommpkg.cpp

简单实用, 功能强大的 C++ Builder 串口控件! 本控件是免费的, 不需要注册, 有关授权及许可协议详见 license.txt 文件。 1.支持二进制数据和文本数据的收发 2.支

      {
        CallNotify(UserNotify);
      }
   }

  if(lpOldCommNotify)
   {
     lpOldCommNotify(Sender, NotifyType);
   }
}
//---------------------------------------------------------------------------
void __fastcall TCommPackage::CallNotify(int NotifyType)
{
  if(lpUserCommNotify)
   {
     lpUserCommNotify(this, NotifyType);
   }
}
//---------------------------------------------------------------------------
void _USERENTRY TCommPackage::_fnTimerThread(void *pm)
{
  TCommPackage *lpPkg = (TCommPackage *)pm;
  if(lpPkg)lpPkg->_TimerThread();
}
//---------------------------------------------------------------------------
unsigned long __fastcall TCommPackage::ReadPackage(void *lpPkg, unsigned long BufSize)
{
  if(_bActive)
   {
     if(_PackageType==cptCompatiblePkg)
      {
        return _QueueRead->Out(lpPkg);
      }
     else
      {
        unsigned long n = 0;
        char *Buf = new char[_QueueRead->PkgSize];
        try
         {
           if(BufSize && lpPkg)
            {
              if(_QueueRead->Out(Buf))
               {
                 n = ((TCommPackageHead*)Buf)->Length;
                 if(n>BufSize)n=BufSize;
                 memcpy(lpPkg, ((TCommPackageHead*)Buf)->Data, n);
               }
            }
           else //只返回数据包的数据字节数
            {
              if(_QueueRead->Read(Buf,0))
                n = ((TCommPackageHead*)Buf)->Length;
            }
         }
        __finally
         {
           delete[] Buf;
         }
        return n;
      }
   }
  return 0;
}
//---------------------------------------------------------------------------
unsigned long __fastcall TCommPackage::WritePackage(const void *lpPkg, unsigned long nBytes)
{
  if(_bActive)
   {
     if(_PackageType==cptCompatiblePkg)
      {
        if(_QueueWrite->In(lpPkg))
         {
           _WritePackage();
           return 1;
         }
      }
     else
      {
        unsigned long n = 0;
        char *Buf = new char[_QueueWrite->PkgSize];
        try
         {
           if(nBytes && lpPkg)
            {
              ((TCommPackageHead*)Buf)->Length = nBytes<_PackageDataSize ? nBytes : _PackageDataSize;
              memcpy(((TCommPackageHead*)Buf)->Data, lpPkg, ((TCommPackageHead*)Buf)->Length);
              if(_QueueWrite->In(Buf))
               {
                 _WritePackage();
                 n = ((TCommPackageHead*)Buf)->Length;
               }
            }
         }
        __finally
         {
           delete[] Buf;
         }
        return n;
      }
   }
  return 0;
}
//---------------------------------------------------------------------------
void __fastcall TCommPackage::PurgeRead(void)
{
  if(_bActive)
   {
     _Comm32->PurgeRead();
     _QueueRead->Clear();
   }
}
//---------------------------------------------------------------------------
void __fastcall TCommPackage::PurgeWrite(void)
{
  if(_bActive)
   {
     _QueueWrite->Clear();
     _Comm32->PurgeWrite();
   }
}
//---------------------------------------------------------------------------
void __fastcall TCommPackage::_TimerThread(void)
{
  DWORD dwWait;
  try
   {
     _bTimerThreadRunning = true;
     while(_bRunTimerThread)
      {
        dwWait = (_PackageType==cptFrameTimeout)?_dwTimerInterval:(-1);
        WaitForSingleObject(_hTimerEvent,dwWait);

        if((_bRunTimerThread) && (_PackageType==cptFrameTimeout))
         {
           if((!_ReadTimeoutPackage()) && (_BufferRead->Length>0))
            {
              _QueueRead->In(_BufferRead);
              _BufferRead->Length=0;
              CallNotify(EV_RXCHAR);
            }
         }
      }
   }
  __finally
   {
     _bTimerThreadRunning = false;
   }
}
//---------------------------------------------------------------------------
unsigned long __fastcall TCommPackage::_EncodePackage(TCommPackageHead *lpEncoded, TCommPackageHead *lpPackage) //编码，目标包括头、尾
{
  unsigned long w = 0;
  unsigned long sn = lpPackage->Length < _PackageDataSize ? lpPackage->Length : _PackageDataSize;

  if(_bDoubleFrameMark)
    lpEncoded->Data[w++] = _FRAMEHEAD;
  lpEncoded->Data[w++] = _FRAMEHEAD;

  for(unsigned long r=0; r<sn; r++)
   {
     if((lpPackage->Data[r] == _FRAMEHEAD)
      ||(lpPackage->Data[r] == _FRAMETAIL)
      ||(lpPackage->Data[r] == _FRAMECTRL))
      {
        lpEncoded->Data[w++] = _FRAMECTRL;
      }
     lpEncoded->Data[w++] = lpPackage->Data[r];
   }

  if(_bDoubleFrameMark)
    lpEncoded->Data[w++] = _FRAMETAIL;
  lpEncoded->Data[w++] = _FRAMETAIL;

  lpEncoded->Length = w;
  return lpEncoded->Length;
}
//---------------------------------------------------------------------------
void __fastcall TCommPackage::_ReadHeadTailPackage(void)
{
  const BufSize = 2048;
  unsigned char Buf[BufSize];
  int n;

  while((n=_Comm32->Read(Buf,BufSize)) > 0)
   {
     for(int i=0; i<n; i++)
      {
        if((!_bControlDetected) && (Buf[i]==_FRAMEHEAD)) //Synchronize
         {
           _BufferRead->Length = 0;
           _bFrameHeadDetected = true;
         }
        else if(_bFrameHeadDetected) //Store Package Data
         {
           if(_bControlDetected)
            {
              if(_BufferRead->Length<_PackageDataSize)
                _BufferRead->Data[_BufferRead->Length++] = Buf[i];
              _bControlDetected = false;
            }
           else if(Buf[i]==_FRAMECTRL)
            {
              _bControlDetected = true;
            }
           else if(Buf[i]==_FRAMETAIL)
            {
              _QueueRead->In(_BufferRead);
              _BufferRead->Length = 0;
              _bFrameHeadDetected = false;
            }
           else
            {
              if(_BufferRead->Length<_PackageDataSize)
                _BufferRead->Data[_BufferRead->Length++] = Buf[i];
              _bControlDetected = false;
            }
         }
        else //Detect & Ignore Data
         {
           if((!_bControlDetected) && (Buf[i]==_FRAMECTRL))
             _bControlDetected = true;
           else //Ignore data
             _bControlDetected = false;
         }
      }
   }
}
//---------------------------------------------------------------------------
bool __fastcall TCommPackage::_ReadTimeoutPackage(void)
{
  const BufSize = 2048;
  unsigned char Buf[BufSize];
  int nRead, nFree;
  bool bReceived = false;

  while((nRead=_Comm32->Read(Buf,BufSize)) > 0)
   {
     nFree = _PackageDataSize - _BufferRead->Length;
     if(nRead>nFree)nRead=nFree;
     memcpy(_BufferRead->Data+_BufferRead->Length, Buf, nRead);
     _BufferRead->Length+=nRead;
     bReceived = true;
   }
  return bReceived;
}
//---------------------------------------------------------------------------
void __fastcall TCommPackage::_WritePackage(void)
{
  if(_BufferBytesWrite < _BufferWrite->Length)
   {
     _BufferBytesWrite += _Comm32->Write(_BufferWrite->Data + _BufferBytesWrite, _BufferWrite->Length - _BufferBytesWrite);
   }
  else if(_QueueWrite->Count)
   {
     if(_PackageType!=cptFrameTimeout)
      {
        _QueueWrite->Out(_BufferTemp);
        _EncodePackage(_BufferWrite, _BufferTemp);
      }
     else
      {
        _QueueWrite->Out(_BufferWrite);
      }
     _BufferBytesWrite = _Comm32->Write(_BufferWrite->Data, _BufferWrite->Length);
   }
}
//---------------------------------------------------------------------------
} //namespace VictorComm32
//---------------------------------------------------------------------------