modlink.hpp

ModLink VCL component 组件以及代码。版本是shareware edition of ModLink 2.10

	void __fastcall SetTransmissionMode(TTransmissionMode Value);
	void __fastcall SetTurnaroundDelay(unsigned Value);
	void __fastcall UpdateDCB(void);
	void __fastcall UpdateRealSilentInterval(void);
	void __fastcall WaitForIdleState(void);
	
protected:
	Byte __fastcall AcquireModbusCommand(TModbusBuffer* Buffer);
	Byte __fastcall AcquireServerAddress(TModbusBuffer* Buffer);
	void __fastcall AcquireServerException(TModbusBuffer* Buffer, TServerException &Exception, Byte &ExceptionCode);
	void __fastcall CheckClosed(void);
	void __fastcall CheckFlowControl(TFlowControls AFlowControls);
	void __fastcall CheckOpened(void);
	void __fastcall ClearDeviceBuffers(bool RX, bool TX);
	bool __fastcall CommandsMatch(TModbusBuffer* QueryBuffer, TModbusBuffer* ReplyBuffer);
	void __fastcall DecodeFrame(const void *Source, TModbusBuffer* Dest, int SourceSize);
	int __fastcall DetermineErrorCheckSize(void);
	int __fastcall DetermineHeaderSize(void);
	int __fastcall DetermineInterimBufferSize(void);
	int __fastcall DetermineMaximumFrameSize(void);
	int __fastcall DetermineMinimumQuerySize(void);
	int __fastcall DetermineMinimumReplySize(void);
	DYNAMIC void __fastcall DoAfterClose(void);
	DYNAMIC void __fastcall DoAfterFrameSendAsync(void);
	DYNAMIC void __fastcall DoAfterOpen(void);
	DYNAMIC void __fastcall DoBeforeClose(void);
	DYNAMIC void __fastcall DoBeforeFrameSendAsync(void);
	DYNAMIC void __fastcall DoBeforeOpen(void);
	DYNAMIC void __fastcall DoFrameReceive(const TFrameData Data);
	DYNAMIC void __fastcall DoFrameSend(const TFrameData Data);
	DYNAMIC unsigned __fastcall DoGetHookedPortHandle(void);
	int __fastcall EncodeFrame(TModbusBuffer* Source, void *Dest, int DestCapacity);
	bool __fastcall ErrorChecksEqual(TModbusBuffer* Buffer);
	bool __fastcall ExamineInputBuffer(/* out */ int &UnreadCount);
	bool __fastcall HeadersMatch(TModbusBuffer* QueryBuffer, TModbusBuffer* ReplyBuffer);
	void __fastcall InternalClose(void);
	void __fastcall InternalOpen(void);
	bool __fastcall InternalReceiveFrame(void *Buffer, int Size);
	bool __fastcall IsEcho(TModbusBuffer* QueryBuffer, TModbusBuffer* ReplyBuffer);
	bool __fastcall IsExceptionReply(TModbusBuffer* Buffer);
	bool __fastcall IsExpectedReply(TModbusBuffer* QueryBuffer, TModbusBuffer* ReplyBuffer, bool PromiscuousMode);
	bool __fastcall IsValidFrame(TModbusBuffer* Buffer);
	virtual void __fastcall Loaded(void);
	int __fastcall ReceiveFrame(void *Buffer, int Capacity, unsigned &Timeout);
	bool __fastcall SendFrame(const void *Buffer, int Size, unsigned Timeout);
	bool __fastcall WaitForData(unsigned Timeout);
	
public:
	__fastcall virtual TModbusConnection(Classes::TComponent* AOwner);
	__fastcall virtual ~TModbusConnection(void);
	void __fastcall ChangeDTR(bool AValue);
	void __fastcall ChangeRTS(bool AValue);
	void __fastcall Close(void);
	int __fastcall CountPendingTransactions(TModbusClient* Client = (TModbusClient*)(0x0));
	void __fastcall DiscardPendingTransactions(TModbusClient* Client = (TModbusClient*)(0x0));
	void __fastcall EmitErrorCheck(TModbusBuffer* Buffer);
	void __fastcall EmitHeader(TModbusClient* Client, TModbusBuffer* Buffer)/* overload */;
	void __fastcall EmitHeader(TModbusServer* Server, TModbusBuffer* Buffer)/* overload */;
	void __fastcall EnqueueTransaction(TModbusTransaction* Transaction, TModbusClient* AOriginator);
	unsigned __fastcall GetNextUniqueID(void);
	void __fastcall Open(void);
	void __fastcall ProcessRemoteTransaction(TModbusTransaction* Transaction);
	void __fastcall RegisterClient(TModbusClient* Client);
	void __fastcall RegisterServer(TModbusServer* Server);
	void __fastcall UnregisterClient(TModbusClient* Client);
	void __fastcall UnregisterServer(TModbusServer* Server);
	unsigned __fastcall WriteMultipleCoils(Word StartBit, bool const * BitValues, const int BitValues_Size, void * UserData = (void *)(0x0));
	unsigned __fastcall WriteMultipleRegisters(Word StartReg, Word const * RegValues, const int RegValues_Size, void * UserData = (void *)(0x0));
	unsigned __fastcall WriteSingleCoil(Word BitAddr, bool BitValue, void * UserData = (void *)(0x0));
	unsigned __fastcall WriteSingleRegister(Word RegAddr, Word RegValue, void * UserData = (void *)(0x0));
	__property int ClientCount = {read=GetClientCount, nodefault};
	__property TModbusClient* Clients[int Index] = {read=GetClient};
	__property unsigned RealSilentInterval = {read=GetRealSilentInterval, nodefault};
	__property int ServerCount = {read=GetServerCount, nodefault};
	__property TModbusServer* Servers[int Index] = {read=GetServer};
	
__published:
	__property bool Active = {read=FActive, write=SetActive, default=0};
	__property TBaudRate BaudRate = {read=FBaudRate, write=SetBaudRate, default=8};
	__property TConnectionMode ConnectionMode = {read=FConnectionMode, write=SetConnectionMode, default=0};
	__property unsigned CustomBaudRate = {read=FCustomBaudRate, write=SetCustomBaudRate, default=19200};
	__property TDataBits DataBits = {read=FDataBits, write=SetDataBits, default=1};
	__property bool DTREnabled = {read=FDTREnabled, write=SetDTREnabled, default=1};
	__property bool EchoQueryBeforeReply = {read=FEchoQueryBeforeReply, write=SetEchoQueryBeforeReply, default=0};
	__property TFlowControl FlowControl = {read=FFlowControl, write=SetFlowControl, default=0};
	__property bool HookExistingPort = {read=FHookExistingPort, write=SetHookExistingPort, default=0};
	__property int InputBufferSize = {read=FInputBufferSize, write=SetInputBufferSize, default=1024};
	__property TMaxRetries MaxRetries = {read=GetMaxRetries, write=SetMaxRetries, default=1};
	__property Classes::TNotifyEvent OnAfterClose = {read=FOnAfterClose, write=FOnAfterClose};
	__property Classes::TNotifyEvent OnAfterFrameSendAsync = {read=FOnAfterFrameSendAsync, write=FOnAfterFrameSendAsync};
	__property Classes::TNotifyEvent OnAfterOpen = {read=FOnAfterOpen, write=FOnAfterOpen};
	__property Classes::TNotifyEvent OnBeforeClose = {read=FOnBeforeClose, write=FOnBeforeClose};
	__property Classes::TNotifyEvent OnBeforeFrameSendAsync = {read=FOnBeforeFrameSendAsync, write=FOnBeforeFrameSendAsync};
	__property Classes::TNotifyEvent OnBeforeOpen = {read=FOnBeforeOpen, write=FOnBeforeOpen};
	__property TFrameDataEvent OnFrameReceive = {read=FOnFrameReceive, write=FOnFrameReceive};
	__property TFrameDataEvent OnFrameSend = {read=FOnFrameSend, write=FOnFrameSend};
	__property TGetHookedPortHandleEvent OnGetHookedPortHandle = {read=FOnGetHookedPortHandle, write=FOnGetHookedPortHandle};
	__property int OutputBufferSize = {read=FOutputBufferSize, write=SetOutputBufferSize, default=1024};
	__property TParityScheme Parity = {read=FParity, write=SetParity, default=2};
	__property AnsiString Port = {read=FPort, write=SetPort, stored=IsPortStored};
	__property unsigned ReceiveTimeout = {read=GetReceiveTimeout, write=SetReceiveTimeout, default=1000};
	__property unsigned RefetchDelay = {read=GetRefetchDelay, write=SetRefetchDelay, default=0};
	__property bool RTSEnabled = {read=FRTSEnabled, write=SetRTSEnabled, default=1};
	__property unsigned SendTimeout = {read=GetSendTimeout, write=SetSendTimeout, default=1000};
	__property unsigned SilentInterval = {read=FSilentInterval, write=SetSilentInterval, default=4};
	__property TStopBits StopBits = {read=FStopBits, write=SetStopBits, default=0};
	__property Classes::TThreadPriority ThreadPriority = {read=FThreadPriority, write=SetThreadPriority, default=3};
	__property TTransmissionMode TransmissionMode = {read=FTransmissionMode, write=SetTransmissionMode, default=0};
	__property unsigned TurnaroundDelay = {read=GetTurnaroundDelay, write=SetTurnaroundDelay, default=100};
};


typedef DynamicArray<bool >  TBitValues;

typedef void __fastcall (__closure *TMultipleBitsAccessEvent)(TModbusClient* Sender, const TTransactionInfo &Info, Word StartBit, Word BitCount, const TBitValues BitValues);

typedef void __fastcall (__closure *TModbusClientNotifyEvent)(TModbusClient* Sender);

typedef void __fastcall (__closure *TCustomTransactionCompleteEvent)(TModbusClient* Sender, const TTransactionInfo &Info, Byte Command, const AnsiString RequestData, const AnsiString ResponseData);

#pragma option push -b-
enum TDiagnosticAction { daReturnQueryData, daRestartCommsOption, daRestartCommsOptionAndClearEventLog, daReturnDiagnosticRegister, daForceListenOnlyMode, daClearCountersAndDiagnosticRegister, daReturnBusMessageCount, daReturnBusCommErrorCount, daReturnBusExceptionErrorCount, daReturnServerMessageCount, daReturnServerNoReplyCount, daReturnServerNegativeAcknowledgeCount, daReturnServerBusyCount, daReturnBusCharacterOverrunCount, daClearOverrunCounterAndFlag };
#pragma option pop

typedef void __fastcall (__closure *TDiagnosticsEvent)(TModbusClient* Sender, const TTransactionInfo &Info, TDiagnosticAction Action, Word Result);

typedef DynamicArray<bool >  TExceptionStatusValues;

typedef void __fastcall (__closure *TExceptionStatusReadEvent)(TModbusClient* Sender, const TTransactionInfo &Info, const TExceptionStatusValues StatusValues);

class DELPHICLASS TModbusFileRecordList;
typedef void __fastcall (__closure *TFileRecordAccessEvent)(TModbusClient* Sender, const TTransactionInfo &Info, TModbusFileRecordList* FileRecList);

typedef DynamicArray<Word >  TRegValues;

typedef void __fastcall (__closure *TMultipleRegistersAccessEvent)(TModbusClient* Sender, const TTransactionInfo &Info, Word StartReg, Word RegCount, const TRegValues RegValues);

typedef void __fastcall (__closure *TMultipleRegistersReadWriteEvent)(TModbusClient* Sender, const TTransactionInfo &Info, Word StartRegToRead, Word RegCountToRead, const TRegValues RegValuesToRead, Word StartRegToWrite, Word RegCountToWrite, const TRegValues RegValuesToWrite);

typedef DynamicArray<Byte >  TServerIdentificationData;

typedef void __fastcall (__closure *TServerIdentificationReportEvent)(TModbusClient* Sender, const TTransactionInfo &Info, int Count, const TServerIdentificationData Data);

typedef void __fastcall (__closure *TSingleCoilWriteEvent)(TModbusClient* Sender, const TTransactionInfo &Info, Word BitAddr, bool BitValue);

typedef void __fastcall (__closure *TSingleRegisterMaskWriteEvent)(TModbusClient* Sender, const TTransactionInfo &Info, Word RegAddr, Word AndMask, Word OrMask);

typedef void __fastcall (__closure *TSingleRegisterWriteEvent)(TModbusClient* Sender, const TTransactionInfo &Info, Word RegAddr, Word RegValue);

typedef void __fastcall (__closure *TTransactionProcessedEvent)(TModbusClient* Sender, const TTransactionInfo &Info, Byte Command, bool Custom);

typedef void __fastcall (__closure *TTranslateExceptionCodeEvent)(TModbusClient* Sender, Byte ExceptionCode, AnsiString &Description);

class PASCALIMPLEMENTATION TModbusClient : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	TModbusConnection* FConnection;
	unsigned FConsecutiveTimeoutCount;
	int FMaxConsecutiveTimeouts;
	TMultipleBitsAccessEvent FOnCoilsRead;
	TModbusClientNotifyEvent FOnConsecutiveTimeoutLimitExceed;
	TCustomTransactionCompleteEvent FOnCustomTransactionComplete;
	TDiagnosticsEvent FOnDiagnostics;
	TMultipleBitsAccessEvent FOnDiscreteInputsRead;
	TExceptionStatusReadEvent FOnExceptionStatusRead;
	TFileRecordAccessEvent FOnFileRecordRead;
	TFileRecordAccessEvent FOnFileRecordWrite;
	TMultipleRegistersAccessEvent FOnHoldingRegistersRead;
	TMultipleRegistersAccessEvent FOnInputRegistersRead;
	TMultipleBitsAccessEvent FOnMultipleCoilsWrite;
	TMultipleRegistersReadWriteEvent FOnMultipleRegistersReadWrite;
	TMultipleRegistersAccessEvent FOnMultipleRegistersWrite;
	TServerIdentificationReportEvent FOnServerIdentificationReport;
	TSingleCoilWriteEvent FOnSingleCoilWrite;
	TSingleRegisterMaskWriteEvent FOnSingleRegisterMaskWrite;
	TSingleRegisterWriteEvent FOnSingleRegisterWrite;
	TTransactionProcessedEvent FOnTransactionProcessed;
	TTranslateExceptionCodeEvent FOnTranslateExceptionCode;
	Byte FServerAddress;
	void __fastcall DoneCustomTransaction(TModbusTransaction* Transaction, Byte Command);
	void __fastcall DoneDiagnostics(TModbusTransaction* Transaction);
	void __fastcall DoneReadDiscreteBits(TModbusTransaction* Transaction, bool Coils);
	void __fastcall DoneReadExceptionStatus(TModbusTransaction* Transaction);
	void __fastcall DoneReadFileRecord(TModbusTransaction* Transaction);
	void __fastcall DoneReadModbusRegisters(TModbusTransaction* Transaction, bool HoldingRegisters);
	void __fastcall DoneReadWriteMultipleRegisters(TModbusTransaction* Transaction);
	void __fastcall DoneReportServerID(TModbusTransaction* Transaction);
	void __fastcall DoneMaskWriteSingleRegister(TModbusTransaction* Transaction);
	void __fastcall DonePublicTransaction(TModbusTransaction* Transaction, Byte Command);
	void __fastcall DoneWriteFileRecord(TModbusTransaction* Transaction);
	void __fastcall DoneWriteMultipleCoils(TModbusTransaction* Transaction);
	void __fastcall DoneWriteMultipleRegisters(TModbusTransaction* Transaction);
	void __fastcall DoneWriteSingleCoil(TModbusTransaction* Transaction);
	void __fastcall DoneWriteSingleRegister(TModbusTransaction* Transaction);
	void __fastcall KeepTrackOfConsecutiveTimeouts(const TTransactionInfo &Info);
	void __fastcall SetConnection(TModbusConnection* Value);
	void __fastcall SetMaxConsecutiveTimeouts(int Value);
	void __fastcall SetServerAddress(Byte Value);
	
protected:
	DYNAMIC void __fastcall DoCoilsRead(const TTransactionInfo &Info, Word StartBit, Word BitCount, const TBitValues BitValues);
	DYNAMIC void __fastcall DoConsecutiveTimeoutLimitExceed(void);
	DYNAMIC void __fastcall DoCustomTransactionComplete(const TTransactionInfo &Info, Byte Command, const AnsiString RequestData, const AnsiString ResponseData);
	DYNAMIC void __fastcall DoDiagnostics(const TTransactionInfo &Info, TDiagnosticAction Action, Word Result);
	DYNAMIC void __fastcall DoDiscreteInputsRead(const TTransactionInfo &Info, Word StartBit, Word BitCount, const TBitValues BitValues);
	DYNAMIC void __fastcall DoExceptionStatusRead(const TTransactionInfo &Info, const TExceptionStatusValues StatusValues);
	DYNAMIC void __fastcall DoFileRecordRead(const TTransactionInfo &Info, TModbusFileRecordList* FileRecList);
	DYNAMIC void __fastcall DoFileRecordWrite(const TTransactionInfo &Info, TModbusFileRecordList* FileRecList);
	DYNAMIC void __fastcall DoHoldingRegistersRead(const TTransactionInfo &Info, Word StartReg, Word RegCount, const TRegValues RegValues);
	DYNAMIC void __fastcall DoInputRegistersRead(const TTransactionInfo &Info, Word StartReg, Word RegCount, const TRegValues RegValues);
	DYNAMIC void __fastcall DoMultipleCoilsWrite(const TTransactionInfo &Info, Word StartBit, Word BitCount, const TBitValues BitValues);
	DYNAMIC void __fastcall DoMultipleRegistersReadWrite(const TTransactionInfo &Info, Word StartRegToRead, Word RegCountToRead, const TRegValues RegValuesToRead, Word StartRegToWrite, Word RegCountToWrite, const TRegValues RegValuesToWrite);
	DYNAMIC void __fastcall DoMultipleRegistersWrite(const TTransactionInfo &Info, Word StartReg, Word RegCount, const TRegValues RegValues);
	DYNAMIC void __fastcall DoServerIdentificationReport(const TTransactionInfo &Info, int Count, const TServerIdentificationData Data);
	DYNAMIC void __fastcall DoSingleCoilWrite(const TTransactionInfo &Info, Word BitAddr, bool BitValue);
	DYNAMIC void __fastcall DoSingleRegisterMaskWrite(const TTransactionInfo &Info, Word RegAddr, Word AndMask, Word OrMask);
	DYNAMIC void __fastcall DoSingleRegisterWrite(const TTransactionInfo &Info, Word RegAddr, Word RegValue);
	DYNAMIC void __fastcall DoTransactionProcessed(const TTransactionInfo &Info, Byte Command, bool Custom);
	DYNAMIC void __fastcall DoTranslateExceptionCode(Byte ExceptionCode, AnsiString &Description);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	
public:
	__fastcall virtual TModbusClient(Classes::TComponent* AOwner);
	__fastcall virtual ~TModbusClient(void);
	void __fastcall CheckConnected(void);
	void __fastcall CheckDisconnected(void);
	void __fastcall ClearConsecutiveTimeoutCounter(void);
	unsigned __fastcall Diagnostics(TDiagnosticAction Action, void * UserData = (void *)(0x0));
	void __fastcall DoneTransaction(TModbusTransaction* Transaction);
	AnsiString __fastcall ExceptionCodeToStr(Byte ExceptionCode);
	unsigned __fastcall InitCustomTransaction(Byte Command, const AnsiString RequestData, bool PromiscuousMode, void * UserData = (void *)(0x0));
	unsigned __fastcall MaskWriteSingleRegister(Word RegAddr, Word AndMask, Word OrMask, void * UserData = (void *)(0x0));
	unsigned __fastcall ReadCoils(Word StartBit, Word BitCount, void * UserData = (void *)(0x0));
	unsigned __fastcall ReadDiscreteInputs(Word StartBit, Word BitCount, void * UserData = (void *)(0x0));
	unsigned __fastcall ReadExceptionStatus(void * UserData = (void *)(0x0));
	unsigned __fastcall ReadFileRecord(TModbusFileRecordList* FileRecList, void * UserData = (void *)(0x0));
	unsigned __fastcall ReadHoldingRegisters(Word StartReg, Word RegCount, void * UserData = (void *)(0x0));
	unsigned __fastcall ReadInputRegisters(Word StartReg, Word RegCount, void * UserData = (void *)(0x0));
	unsigned __fastcall ReadWriteMultipleRegisters(Word StartRegToRead, Word RegCountToRead, Word StartRegToWrite, Word const * RegValuesToWrite, const int RegValuesToWrite_Size, void * UserData = (void *)(0x0));
	unsigned __fastcall ReportServerID(void * UserData = (void *)(0x0));
	unsigned __fastcall WriteFileRecord(TModbusFileRecordList* FileRecList, void * UserData = (void *)(0x0));
	unsigned __fastcall WriteMultipleCoils(Word StartBit, bool const * BitValues, const int BitValues_Size, void * UserData = (void *)(0x0));
	unsigned __fastcall WriteMultipleRegisters(Word StartReg, Word const * RegValues, const int RegValues_Size, void * UserData = (void *)(0x0));
	unsigned __fastcall WriteSingleCoil(Word BitAddr, bool BitValue, void * UserData = (void *)(0x0));
	unsigned __fastcall WriteSingleRegister(Word RegAddr, Word RegValue, void * UserData = (void *)(0x0));
	__property unsigned ConsecutiveTimeoutCount = {read=FConsecutiveTimeoutCount, nodefault};
	
__published:
	__property TModbusConnection* Connection = {read=FConnection, write=SetConnection};
	__property int MaxConsecutiveTimeouts = {read=FMaxConsecutiveTimeouts, write=SetMaxConsecutiveTimeouts, default=-1};
	__property TMultipleBitsAccessEvent OnCoilsRead = {read=FOnCoilsRead, write=FOnCoilsRead};
	__property TModbusClientNotifyEvent OnConsecutiveTimeoutLimitExceed = {read=FOnConsecutiveTimeoutLimitExceed, write=FOnConsecutiveTimeoutLimitExceed};
	__property TCustomTransactionCompleteEvent OnCustomTransactionComplete = {read=FOnCustomTransactionComplete, write=FOnCustomTransactionComplete};
	__property TDiagnosticsEvent OnDiagnostics = {read=FOnDiagnostics, write=FOnDiagnostics};