串口通讯的串口类模块

本模块开发平台BCB，用于串口通讯的串口类模块，不需要使用系统或第三方带的串口Com 组件，不需要注册，直接加入到软件声明中即可使用。

Comm.h //头文件声明

//------------------------------------------------------------------

#ifndef CommH

#define CommH

//------------------------------------------------------------------

#include

#include

#include

#include

#include

#include

//类型定义

enum TBaudRate {br110=110, br300=300, br600=600, br1200=1200, br2400=2400,

br4800=4800, br9600=9600, br14400=14400, br19200=19200,

br38400=38400, br56000=56000, br57600=57600, br115200=115200};

enum TComPortNumber {pnCOM1, pnCOM2, pnCOM3, pnCOM4, pnCOM5, pnCOM6, pnCOM7, pnCOM8,

pnCOM9, pnCOM10, pnCOM11, pnCOM12, pnCOM13, pnCOM14, pnCOM15, pnCOM16};

enum TParity { None, Odd, Even, Mark, Space };

enum TStopBits { SB1, SB1_5, SB2 };

enum TDataBits { DB5, DB6, DB7, DB8 };

enum THwHandShaking{hhNone,hhNoneRTSON,hhRTSCTS};

enum TSwHandShaking{shNone,shXonXoff};

// 输入缓冲区的默认大小

const long INPUTBUFFERSIZE = 4096;

// Line Status位定义

const int ME_CTS = 1;

const int ME_DSR = 2;

const int ME_RING = 4;

const int ME_RLSD = 8;

//DCB 位定义

const long dcb_Binary = 0x00000001;

const long dcb_ParityCheck = 0x00000002;

const long dcb_OutxCtsFlow = 0x00000004;

const long dcb_OutxDsrFlow = 0x00000008;

const long dcb_DtrControlMask = 0x00000030;

const long dcb_DtrControlDisable = 0x00000000;

const long dcb_DtrControlEnable = 0x00000010;

const long dcb_DtrControlHandshake = 0x00000020;

const long dcb_DsrSensivity = 0x00000040;

const long dcb_TXContinueOnXoff = 0x00000080;

const long dcb_OutX = 0x00000100;

const long dcb_InX = 0x00000200;

const long dcb_ErrorChar = 0x00000400;

const long dcb_NullStrip = 0x00000800;

const long dcb_RtsControlMask = 0x00003000;

const long dcb_RtsControlDisable = 0x00000000;

const long dcb_RtsControlEnable = 0x00001000;

const long dcb_RtsControlHandShake = 0x00002000;

const long dcb_RtsControlToggle = 0x00003000;

const long dcb_AbortOnError = 0x00004000;

const long dcb_Reserveds = 0xFFFF8000;

//事件函数定位器声明

typedef void __fastcall (__closure *TReceiveDataEvent)(System::TObject *Sender);

typedef void __fastcall (__closure *TReceiveErrorEvent)(System::TObject *Sender,

DWORD EventMask);

typedef void __fastcall (__closure *TModemStateChangeEvent)(System::TObject *Sender,

DWORD ModemEvent);

//------------------------------------------------------------------

class PACKAGE TComm : public TComponent

{

private:

TTimer *CommTimer; //组件用的定时器

char szInputBuffer[INPUTBUFFERSIZE];

HANDLE hComm;

TComPortNumber FCommPort;

bool FPortOpen;

TBaudRate FBaudRate;

bool FParityCheck;

THwHandShaking FHwHandShaking;

TSwHandShaking FSwHandShaking;

TDataBits FDataBits;

TParity FParity;

TStopBits FStopBits;

int FInputLen; //每次执行Input时所读取的字符串长度

int FRThreshold; //设置引发接收事件的门坎

bool FDTR;

bool FRTS;

String FInputData;

DynamicArray FInputByteData;

// FInputByteData: array of Byte;

int FCommEvent;

int FCommError;

bool FCDHolding;

bool FCTSHolding;

bool FDSRHolding;

bool FRIHolding;

//设置函数

void __fastcall SetCommPort(TComPortNumber Port); //设置COMPort

void __fastcall SetBaudRate(TBaudRate Rate); //设置速率

void __fastcall SetHwHandShaking(THwHandShaking c ); //硬件交握

void __fastcall SetSwHandShaking(TSwHandShaking c ); //软件交握

THwHandShaking __fastcall GetHwHandShaking(void); //硬件交握

TSwHandShaking __fastcall GetSwHandShaking(void); //软件交握

void __fastcall SetDataBits(TDataBits Size); //数据位数

void __fastcall SetParity(TParity p); //奇偶校验

void __fastcall SetStopBits(TStopBits Bits); //停止位

void __fastcall SetInDataCount(DWORD StrNo); //设成0表示清除FInputData

void __fastcall SetRThreshold(int RTNo); //接收门坎

void __fastcall SetPortOpen(bool b); //打开通信端口

void _SetCommState(void); //设置通信参数

bool __fastcall GetRTSStatus();

bool __fastcall GetDTRStatus();

void __fastcall SetDTRStatus(bool b); //DTR 状态

void __fastcall SetRTSStatus(bool b); //RTS状态

void __fastcall ReadProcess(void); //读取数据函数

void __fastcall EventProcess(void); //事件检测函数

void __fastcall GetModemState(void); //线路状态检测函数

void OpenComm(void); //打开通讯端口函数

void __fastcall CloseComm(void); //开关通信端口函数

int __fastcall ReadCommEvent(void); //硬件线路状态值读取

int __fastcall ReadCommError(void); //错误状态值的读取

String __fastcall ReadInputData(void); //返回收到的数据

int __fastcall ReadInDataCount(void); //读取有多少数据

bool __fastcall ReadCDHolding(void); //取得CD线路状态

bool __fastcall ReadDSRHolding(void); //取得DSR线路状态

bool __fastcall ReadRIHolding(void); //取得RI线路状态

bool __fastcall ReadCTSHolding(void); //取得CTS线路状态

//事件

TReceiveDataEvent FOnReceiveData;

TReceiveErrorEvent FOnReceiveError;

TModemStateChangeEvent FOnModemStateChange;

protected:

void __fastcall ProcTimer(TObject *Sender);

void __fastcall ReceiveData(void);

void __fastcall ReceiveError(DWORD EvtMask);

void __fastcall ModemStateChange(DWORD ModemEvent);

public:

__fastcall TComm(TComponent* Owner); //构造函数

bool OutputString(String DataToWrite);

bool OutputByte(const DynamicArray ByteData);

DynamicArray ReadInputByte(void);

__property bool PortOpen ={read = FPortOpen, write=SetPortOpen,default=false};

__property DWORD DataCount = { read = ReadInDataCount , write = SetInDataCount};

__property bool DTREnabled = { read = GetDTRStatus, write = SetDTRStatus};

__property bool RTSEnabled = { read = GetRTSStatus, write = SetRTSStatus};

__published:

//以下加入属性

__property TComPortNumber CommPort =

{read = FCommPort, write = SetCommPort, default = pnCOM1};

__property TBaudRate BaudRate = {read = FBaudRate, write = SetBaudRate, default = br9600};

__property THwHandShaking HwHandShaking =

{read = GetHwHandShaking, write = SetHwHandShaking, default = hhNone};

__property TSwHandShaking SwHandShaking =

{read = GetSwHandShaking, write = SetSwHandShaking, default = shNone};

__property TDataBits DataBits ={ read = FDataBits ,write =SetDataBits,default = DB8} ;

__property TParity Parity = { read = FParity ,write = SetParity,default = None};

__property TStopBits StopBits ={ read = FStopBits ,write = SetStopBits,default =SB1};

__property DWORD CommEvent = { read = ReadCommEvent};

__property DWORD CommError = {read = ReadCommError};

__property String Input = { read = ReadInputData};

__property int InputLen = { read = FInputLen , write = FInputLen, default =0};

__property int RThreshold = { read = FRThreshold ,write = SetRThreshold, default =0 };

__property bool CDHolding = { read = ReadCDHolding};

__property bool DSRHolding = { read = ReadDSRHolding};

__property bool RIHolding = { read = ReadRIHolding};

__property bool CTSHolding = { read = ReadCTSHolding};

//事件

__property TReceiveDataEvent OnReceiveData =

{read = FOnReceiveData , write = FOnReceiveData};

__property TReceiveErrorEvent OnReceiveError =

{read = FOnReceiveError , write = FOnReceiveError};

__property TModemStateChangeEvent OnModemStateChange =

{read = FOnModemStateChange , write = FOnModemStateChange};

};

//------------------------------------------------------------------

#endif

Comm.cpp //主文件内容

//------------------------------------------------------------------

#include

#pragma hdrstop

#include "Comm.h"

#pragma package(smart_init)

//------------------------------------------------------------------

// ValidCtrCheck is used to assure that the components created do not have

// any pure virtual functions.

//

static inline void ValidCtrCheck(TComm *)

{

new TComm(NULL);

}

//------------------------------------------------------------------

__fastcall TComm::TComm(TComponent* Owner) : TComponent(Owner)

{

CommTimer = new TTimer(this);

CommTimer->Enabled = false;

CommTimer->Interval = 5;

CommTimer->OnTimer = ProcTimer;

hComm = 0; //通信端口Handle先清空

FPortOpen = False;

FCommPort = pnCOM1; //默认COM1

FBaudRate = br9600; //9600bps

FHwHandShaking = hhNone; //不启动硬件流量控制

FSwHandShaking = shNone; //不启动软件流量控制

FDataBits = DB8; //数据位数=8

FParity = None; //不作同位检查

FStopBits = SB1; //停止位数=1

FInputLen = 0; //默认是一次指令全部读取

FDTR = FRTS = false;

}

//------------------------------------------------------------------

namespace Comm

{

void __fastcall PACKAGE Register()

{

TComponentClass classes[1] = {__classid(TComm)};

RegisterComponents("System", classes, 0);

}

}

//------------------------------------------------------------------

void TComm::OpenComm(void)

{

HANDLE hNewCommFile;

String ComStr;

char *COMNo;

ComStr = "COM" + IntToStr(1+FCommPort);

hNewCommFile = CreateFile( ComStr.c_str(),

GENERIC_READ | GENERIC_WRITE,

0, //not shared

NULL, //no security

OPEN_EXISTING,

0, //No Overlapped

NULL //template

);

if (hNewCommFile == INV ALID_HANDLE_V ALUE)

throw "打开串口错误！";

//ShowMessage("Error opening serial port");

//raise Exception.Create( "Error opening serial port" );

if (!SetupComm(hNewCommFile, INPUTBUFFERSIZE, INPUTBUFFERSIZE))

{

CloseHandle(hComm);

throw "不能设置串口缓冲区！";

//ShowMessage("Cannot setup comm buffer");

}

// It is ok to continue.

hComm = hNewCommFile;

// 清除湲冲区

PurgeComm( hComm, PURGE_TXABORT | PURGE_RXABORT |

PURGE_TXCLEAR | PURGE_RXCLEAR ) ;

// 通信端口配置

_SetCommState();

FDTR = true;

SetDTRStatus(FDTR);

SetRTSStatus(FRTS);

FPortOpen = True;

CommTimer->Enabled = true;

}

//------------------------------------------------------------------

void TComm::_SetCommState(void)

{

DCB dcb;

DWORD tmpValue;

//取得串行端口设置

GetCommState(hComm, &dcb);

//更改传输速率

dcb.BaudRate = FBaudRate;

dcb.fBinary = 1; //必须指定为1

dcb.Parity = (unsigned char)FParity; //Parity的指定

FParityCheck = false;

if (FParity != 0)

FParityCheck = true;

if (FParityCheck)

dcb.fParity = (unsigned long)dcb_ParityCheck; // Enable parity check

// 设置硬件流量控制

switch (FHwHandShaking)

{

case hhNone:

dcb.fRtsControl=0;

break;

case hhNoneRTSON:

dcb.fRtsControl = RTS_CONTROL_ENABLE; //dcb_RtsControlEnable;

break;

case hhRTSCTS:

dcb.fRtsControl = RTS_CONTROL_HANDSHAKE; //dcb_RtsControlHandShake;

dcb.fOutxCtsFlow = 1; //dcb_OutxCtsFlow;

break;

}

//设置软件流量控制

if (FSwHandShaking!=shNone)

{

dcb.fOutX = 1; //dcb_OutX;

dcb.fInX = 1; //dcb_InX;

//设置数据位数

dcb.ByteSize = FDataBits + 5;

//设置停止位数

dcb.StopBits = FStopBits ;

//将设置写入

SetCommState(hComm, &dcb);

}

//---------- 组件用的定时器事件-----------------//

void __fastcall TComm::ProcTimer(TObject *Sender)

{

DWORD tmpValue;

DWORD dwCommError;

COMSTAT CS;

if (hComm == 0) return;

//若设置读取的字符数，检查并引发事件

ClearCommError(hComm,&dwCommError,&CS); //取得状态

FCommError = dwCommError; //错误数值

if (FRThreshold > 0)

if (CS.cbInQue >= (DWORD)FRThreshold) ReceiveData();

GetModemState();

// EventProcess();

Application->ProcessMessages(); //看有无其他的指令需执行，以免锁住//检查线路状态是否发生改变，若改变则引发事件

tmpValue = FCommEvent;

if (tmpValue != 0) ModemStateChange(tmpValue);

Application->ProcessMessages(); //看有无其他的指令需执行，以免锁住//若发生错误，则引发错误

tmpValue = FCommError;

if (tmpValue != 0) ReceiveError(tmpValue);

Application->ProcessMessages(); //看有无其他的指令需执行，以免锁住}

//------------------- 线路状态检测函数----------------//

void __fastcall TComm::GetModemState(void)

{

DWORD dwModemState;

if (hComm==0)

ShowMessage("串口打开错误!");

if (GetCommModemStatus(hComm, &dwModemState ))

{

if (dwModemState & MS_RLSD_ON)

if (!FCDHolding) FCommEvent=FCommEvent+EV_RLSD;

FCDHolding=true;

}

else

{

if (FCDHolding) FCommEvent=FCommEvent-EV_RLSD;

FCDHolding=false;

}

if (dwModemState & MS_DSR_ON)

{

if (!FDSRHolding) FCommEvent=FCommEvent+EV_DSR;

FDSRHolding=true;

}

else

{

if (FDSRHolding) FCommEvent=FCommEvent-EV_DSR;

FDSRHolding=false;

}

if (dwModemState & MS_RING_ON)

{

if (!FRIHolding) FCommEvent=FCommEvent+EV_RING;

FRIHolding=true;

}

else

{

if (FRIHolding) FCommEvent=FCommEvent-EV_RING;

FRIHolding=false;

}

if (dwModemState & MS_CTS_ON)

{

if (!FCTSHolding) FCommEvent=FCommEvent+EV_CTS;

FCTSHolding=true;

}

else

{

if (FCTSHolding) FCommEvent=FCommEvent-EV_CTS;

FCTSHolding=false;

}

} // GetCommModem Loop

}

//---------------- Receive Data ---------------------//

void __fastcall TComm::ReceiveData(void)

if (FOnReceiveData) FOnReceiveData(this);

}

//----------------- Modem State Change ------------//

void __fastcall TComm::ModemStateChange(DWORD ModemEvent)

{

if (FOnModemStateChange) FOnModemStateChange( this, ModemEvent ); }

//---------------- Receive Error ---------------//

void __fastcall TComm::ReceiveError(DWORD EvtMask)

{

if (FOnReceiveError) FOnReceiveError( this, EvtMask );

}

//----------------- Change Port --------------//

void __fastcall TComm::SetCommPort(TComPortNumber Port)

{

if (Port==FCommPort) return;

FCommPort = Port;

}

//---------------- 设置速率----------------//

void __fastcall TComm::SetBaudRate(TBaudRate Rate)

{

if (Rate == FBaudRate) return;

FBaudRate = Rate;

if (hComm != 0) _SetCommState();

}

//---------------- 硬件交握----------------//

THwHandShaking __fastcall TComm::GetHwHandShaking(void)

{

return(FHwHandShaking);

}

void __fastcall TComm::SetHwHandShaking(THwHandShaking c )

{

if (c == FHwHandShaking) return;

FHwHandShaking = c;

if (hComm != 0) _SetCommState();

}

//---------------- 软件交握----------------//

TSwHandShaking __fastcall TComm::GetSwHandShaking(void)

return(FSwHandShaking);

}

void __fastcall TComm::SetSwHandShaking(TSwHandShaking c ) {

if (c == FSwHandShaking) return;

FSwHandShaking = c;

if (hComm != 0) _SetCommState();

}

//---------------- 数据位数----------------//

void __fastcall TComm::SetDataBits(TDataBits Size )

{

if (Size == FDataBits) return;

FDataBits = Size;

if (hComm != 0) _SetCommState();

}

//---------------- 奇偶校验----------------//

void __fastcall TComm::SetParity(TParity p )

{

if (p == FParity) return;

FParity = p;

if (hComm != 0) _SetCommState();

}

//---------------- 停止位----------------//

void __fastcall TComm::SetStopBits(TStopBits Bits )

{

if (Bits == FStopBits) return;

FStopBits = Bits;

if (hComm != 0) _SetCommState();

}

//---------------- 用来清除Buffer ----------------//

void __fastcall TComm::SetInDataCount(DWORD StrNo)

{

if (StrNo!=0) return;

PurgeComm(hComm, PURGE_RXCLEAR); // 清除COM 资料}

//---------------- 接收阈值----------------//

void __fastcall TComm::SetRThreshold(int RTNo)

{

FRThreshold=RTNo;

}

//---------------- 开始通信端口----------------//

void __fastcall TComm::SetPortOpen(bool b)

CommTimer->Enabled=false;

if (b) //若指定打开通信端口，则……

{

if (FPortOpen)

{

ShowMessage("串口已经打开!");

return;

} //FportOpen loop

OpenComm(); //打开通信端口

return;

} //b loop

CloseComm();

}

//---------------- DTR状态----------------//

bool __fastcall TComm::GetDTRStatus()

{

return(FDTR);

}

void __fastcall TComm::SetDTRStatus(bool b)

{

FDTR=b;

if (hComm==0) return;

if (b)

EscapeCommFunction(hComm,SETDTR); //将DTR升至高电位else

EscapeCommFunction(hComm,CLRDTR);//将DTR降至低电位}

//---------------- RTS状态----------------//

bool __fastcall TComm::GetRTSStatus()

{

return(FRTS);

}

void __fastcall TComm::SetRTSStatus(bool b)

{

FRTS=b;

if (hComm==0) return;

if (b)

EscapeCommFunction(hComm,SETRTS); //将RTS升至高电位else

EscapeCommFunction(hComm,CLRRTS); //将RTS降至低电位}

//---------------- 读取数据函数----------------//

void __fastcall TComm::ReadProcess(void)

{

DWORD nBytesRead,dwCommError,i,ReadLen;

COMSTAT CS;

//使用ClearCommError得知有多少的数据在缓冲区中

//亦一并得知错误种类

ClearCommError(hComm,&dwCommError,&CS); // 取得状态

FCommError=dwCommError; //错误数值

if (CS.cbInQue !=0) //若缓冲区有数据，则读取

{

if (InputLen==0) //指定读取的数据数

ReadLen=CS.cbInQue;

else

ReadLen=InputLen;

if (CS.cbInQue > sizeof(szInputBuffer))

PurgeComm(hComm, PURGE_RXCLEAR); // 清除COM 资料

else

{

//读取数据

if (ReadFile(hComm, szInputBuffer,ReadLen,&nBytesRead,NULL)) // 接收COM 的数据

{

//取出数据

//FInputData=copy(szInputBuffer,1,ReadLen);

FInputData=AnsiString(szInputBuffer,(unsigned int)ReadLen);

//设置字节动态数组的长度

FInputByteData.Length =ReadLen;

//SetLength(FInputByteData,ReadLen);

//将数据搬到数组中

for (i=0 ;i

FInputByteData[i]=szInputBuffer[i];

} //ReadFile Loop

}//else Loop

} //cs.binQue Loop

}

//---------------- 事件检测----------------//

void __fastcall TComm::EventProcess(void)

{

}

//---------------- 关闭通信端口函数----------------//

void __fastcall TComm::CloseComm(void)

{

if (hComm == 0) return;

// 实际关闭通信端口

CloseHandle( hComm );

FPortOpen = false;

hComm = 0;

}

//---------------- 硬件线路状态值读取----------------//

int __fastcall TComm::ReadCommEvent(void)

{

return(FCommEvent);

}

//---------------- 错误状态值的读取----------------//

int __fastcall TComm::ReadCommError(void)

{

return(FCommError);

}

//---------------- 返回收到的数据----------------//

String __fastcall TComm::ReadInputData(void)

{

if (hComm==0)

ShowMessage("串口打开错误!");

//决定每一次的指令要返回多少的字符(以Byte为单位) ReadProcess();

return(FInputData);

}

//---------------- 读取已收到的数据数量----------------//

int __fastcall TComm::ReadInDataCount(void)

{

COMSTAT CS;

DWORD dwCommError;

ClearCommError(hComm,&dwCommError,&CS); //取得状态return(CS.cbInQue);

}

//---------------- 取得CD线路状态----------------//

bool __fastcall TComm::ReadCDHolding(void)

{

return(FCDHolding);

}

//---------------- 取得DSR线路状态----------------//

bool __fastcall TComm::ReadDSRHolding(void)

{

return(FDSRHolding);

}

//---------------- 取得RI线路状态----------------//

bool __fastcall TComm::ReadRIHolding(void)

{

return(FRIHolding);

}

//---------------- 取得CTS线路状态----------------//

bool __fastcall TComm::ReadCTSHolding(void)

{

return(FCTSHolding);

}

//--------------- 字符串指令输出-----------------//

bool TComm::OutputString(String DataToWrite)

{

DWORD lrc;

Char *tmpChar;

if (hComm==0)

{

ShowMessage("串口打开错误!");

return(false);

}

// 送出数据

tmpChar=DataToWrite.c_str();

if (WriteFile(hComm,tmpChar,DataToWrite.Length(), &lrc, NULL)) return(true);

return(false);

}

//--------------- 字符串字节输出---------------//

bool TComm::OutputByte(const DynamicArray ByteData) {

DWORD lrc,SendNum;

int i;

byte ch;

if (hComm==0)

{

ShowMessage("串口打开错误!");

return(false);

}

// 送出数据

for (i=ByteData.Low;i<=ByteData.High ;i++)

{

ch = ByteData[i];

WriteFile(hComm,&ch,1,&lrc,NULL);

}

return(true);

}

//--------------- 输入字节读取--------------// DynamicArray TComm::ReadInputByte(void) {

int i;

if (hComm==0)

ShowMessage("串口打开错误!"); ReadProcess();//执行读取函数

return(FInputByteData);//取得数据数组的最高索引值}