modlink.hpp

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

	__property TMultipleBitsAccessEvent OnDiscreteInputsRead = {read=FOnDiscreteInputsRead, write=FOnDiscreteInputsRead};
	__property TExceptionStatusReadEvent OnExceptionStatusRead = {read=FOnExceptionStatusRead, write=FOnExceptionStatusRead};
	__property TFileRecordAccessEvent OnFileRecordRead = {read=FOnFileRecordRead, write=FOnFileRecordRead};
	__property TFileRecordAccessEvent OnFileRecordWrite = {read=FOnFileRecordWrite, write=FOnFileRecordWrite};
	__property TMultipleRegistersAccessEvent OnHoldingRegistersRead = {read=FOnHoldingRegistersRead, write=FOnHoldingRegistersRead};
	__property TMultipleRegistersAccessEvent OnInputRegistersRead = {read=FOnInputRegistersRead, write=FOnInputRegistersRead};
	__property TMultipleBitsAccessEvent OnMultipleCoilsWrite = {read=FOnMultipleCoilsWrite, write=FOnMultipleCoilsWrite};
	__property TMultipleRegistersReadWriteEvent OnMultipleRegistersReadWrite = {read=FOnMultipleRegistersReadWrite, write=FOnMultipleRegistersReadWrite};
	__property TMultipleRegistersAccessEvent OnMultipleRegistersWrite = {read=FOnMultipleRegistersWrite, write=FOnMultipleRegistersWrite};
	__property TServerIdentificationReportEvent OnServerIdentificationReport = {read=FOnServerIdentificationReport, write=FOnServerIdentificationReport};
	__property TSingleCoilWriteEvent OnSingleCoilWrite = {read=FOnSingleCoilWrite, write=FOnSingleCoilWrite};
	__property TSingleRegisterMaskWriteEvent OnSingleRegisterMaskWrite = {read=FOnSingleRegisterMaskWrite, write=FOnSingleRegisterMaskWrite};
	__property TSingleRegisterWriteEvent OnSingleRegisterWrite = {read=FOnSingleRegisterWrite, write=FOnSingleRegisterWrite};
	__property TTransactionProcessedEvent OnTransactionProcessed = {read=FOnTransactionProcessed, write=FOnTransactionProcessed};
	__property TTranslateExceptionCodeEvent OnTranslateExceptionCode = {read=FOnTranslateExceptionCode, write=FOnTranslateExceptionCode};
	__property Byte ServerAddress = {read=FServerAddress, write=SetServerAddress, default=1};
};


class PASCALIMPLEMENTATION TModbusTransaction : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	TModbusBuffer* FQueryBuffer;
	TModbusBuffer* FReplyBuffer;
	
public:
	bool Custom;
	TTransactionInfo Info;
	TModbusClient* Originator;
	bool Promiscuous;
	__fastcall TModbusTransaction(unsigned BufCapacity);
	__fastcall virtual ~TModbusTransaction(void);
	__property TModbusBuffer* QueryBuffer = {read=FQueryBuffer};
	__property TModbusBuffer* ReplyBuffer = {read=FReplyBuffer};
};


class DELPHICLASS TModbusFileRecord;
class PASCALIMPLEMENTATION TModbusFileRecord : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	Word operator[](int Index) { return RegValues[Index]; }
	
private:
	Word FFileID;
	DynamicArray<Word >  FRegValues;
	Word FStartReg;
	int __fastcall GetRegCount(void);
	Word __fastcall GetRegValue(int Index);
	void __fastcall SetRegCount(int Value);
	void __fastcall SetRegValue(int Index, Word Value);
	void __fastcall SetStartReg(Word Value);
	
public:
	__fastcall TModbusFileRecord(Word AFileID, Word AStartReg, int ARegCount);
	__fastcall virtual ~TModbusFileRecord(void);
	void __fastcall AdjustRange(Word AStartReg, int ARegCount);
	__property Word FileID = {read=FFileID, write=FFileID, nodefault};
	__property int RegCount = {read=GetRegCount, write=SetRegCount, nodefault};
	__property Word RegValues[int Index] = {read=GetRegValue, write=SetRegValue/*, default*/};
	__property Word StartReg = {read=FStartReg, write=SetStartReg, nodefault};
};


class PASCALIMPLEMENTATION TModbusFileRecordList : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	TModbusFileRecord* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TList* FList;
	int __fastcall GetCount(void);
	TModbusFileRecord* __fastcall GetItem(int Index);
	
public:
	__fastcall TModbusFileRecordList(void);
	__fastcall virtual ~TModbusFileRecordList(void);
	TModbusFileRecord* __fastcall Add(Word AFileID, Word AStartReg, int ARegCount)/* overload */;
	TModbusFileRecord* __fastcall Add(Word AFileID, Word AStartReg, Word const * ARegValues, const int ARegValues_Size)/* overload */;
	void __fastcall Clear(void);
	void __fastcall Delete(int Index);
	int __fastcall Remove(TModbusFileRecord* FileRecord);
	__property int Count = {read=GetCount, nodefault};
	__property TModbusFileRecord* Items[int Index] = {read=GetItem/*, default*/};
};


typedef void __fastcall (__closure *TAcceptCommandEvent)(TModbusServer* Sender, Byte Command, bool &Accept);

#pragma option push -b-
enum TItemWriteStatus { iwsIllegalAddress, iwsIllegalValue, iwsAllowWrite };
#pragma option pop

typedef void __fastcall (__closure *TCanReadDiscreteBitEvent)(TModbusServer* Sender, Word BitAddr, bool &Allow);

typedef void __fastcall (__closure *TCanWriteCoilEvent)(TModbusServer* Sender, Word BitAddr, bool BitValue, TItemWriteStatus &Status);

typedef void __fastcall (__closure *TGetDiscreteBitValueEvent)(TModbusServer* Sender, Word BitAddr, bool &BitValue);

typedef void __fastcall (__closure *TSetCoilValueEvent)(TModbusServer* Sender, Word BitAddr, bool BitValue);

typedef void __fastcall (__closure *TCanReadRegisterEvent)(TModbusServer* Sender, Word RegAddr, bool &Allow);

typedef void __fastcall (__closure *TCanWriteRegisterEvent)(TModbusServer* Sender, Word RegAddr, Word RegValue, TItemWriteStatus &Status);

typedef void __fastcall (__closure *TGetRegisterValueEvent)(TModbusServer* Sender, Word RegAddr, Word &RegValue);

typedef void __fastcall (__closure *TSetRegisterValueEvent)(TModbusServer* Sender, Word RegAddr, Word RegValue);

class PASCALIMPLEMENTATION TModbusServer : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	TModbusTransaction* FActiveTransaction;
	Byte FAddress;
	TModbusConnection* FConnection;
	TAcceptCommandEvent FOnAcceptCommand;
	TCanReadDiscreteBitEvent FOnCanReadCoil;
	TCanReadDiscreteBitEvent FOnCanReadDiscreteInput;
	TCanReadRegisterEvent FOnCanReadHoldingRegister;
	TCanReadRegisterEvent FOnCanReadInputRegister;
	TCanWriteCoilEvent FOnCanWriteCoil;
	TCanWriteRegisterEvent FOnCanWriteHoldingRegister;
	TGetDiscreteBitValueEvent FOnGetCoilValue;
	TGetDiscreteBitValueEvent FOnGetDiscreteInputValue;
	TGetRegisterValueEvent FOnGetHoldingRegisterValue;
	TGetRegisterValueEvent FOnGetInputRegisterValue;
	TSetCoilValueEvent FOnSetCoilValue;
	TSetRegisterValueEvent FOnSetHoldingRegisterValue;
	void __fastcall BuildExceptionReply(TModbusBuffer* Buffer, Byte Command, TServerException Exception);
	void __fastcall ProcessReadDiscreteBits(TModbusTransaction* Transaction, bool Coils);
	void __fastcall ProcessReadModbusRegisters(TModbusTransaction* Transaction, bool HoldingRegisters);
	void __fastcall ProcessWriteMultipleCoils(TModbusTransaction* Transaction);
	void __fastcall ProcessWriteMultipleRegisters(TModbusTransaction* Transaction);
	void __fastcall ProcessWriteSingleCoil(TModbusTransaction* Transaction);
	void __fastcall ProcessWriteSingleRegister(TModbusTransaction* Transaction);
	void __fastcall SetAddress(Byte Value);
	void __fastcall SetConnection(TModbusConnection* Value);
	
protected:
	DYNAMIC bool __fastcall DoAcceptCommand(Byte Command);
	DYNAMIC bool __fastcall DoCanReadCoil(Word BitAddr);
	DYNAMIC bool __fastcall DoCanReadDiscreteInput(Word BitAddr);
	DYNAMIC bool __fastcall DoCanReadHoldingRegister(Word RegAddr);
	DYNAMIC bool __fastcall DoCanReadInputRegister(Word RegAddr);
	DYNAMIC TItemWriteStatus __fastcall DoCanWriteCoil(Word BitAddr, bool BitValue);
	DYNAMIC TItemWriteStatus __fastcall DoCanWriteHoldingRegister(Word RegAddr, Word RegValue);
	DYNAMIC bool __fastcall DoGetCoilValue(Word BitAddr);
	DYNAMIC bool __fastcall DoGetDiscreteInputValue(Word BitAddr);
	DYNAMIC Word __fastcall DoGetHoldingRegisterValue(Word RegAddr);
	DYNAMIC Word __fastcall DoGetInputRegisterValue(Word RegAddr);
	DYNAMIC void __fastcall DoSetCoilValue(Word BitAddr, bool BitValue);
	DYNAMIC void __fastcall DoSetHoldingRegisterValue(Word RegAddr, Word RegValue);
	
public:
	__fastcall virtual TModbusServer(Classes::TComponent* AOwner);
	__fastcall virtual ~TModbusServer(void);
	void __fastcall CheckActiveTransaction(void);
	void __fastcall CheckConnected(void);
	void __fastcall EmitExceptionReply(TServerException Exception);
	void __fastcall ProcessTransaction(TModbusTransaction* Transaction);
	
__published:
	__property Byte Address = {read=FAddress, write=SetAddress, default=1};
	__property TModbusConnection* Connection = {read=FConnection, write=SetConnection};
	__property TAcceptCommandEvent OnAcceptCommand = {read=FOnAcceptCommand, write=FOnAcceptCommand};
	__property TCanReadDiscreteBitEvent OnCanReadCoil = {read=FOnCanReadCoil, write=FOnCanReadCoil};
	__property TCanReadDiscreteBitEvent OnCanReadDiscreteInput = {read=FOnCanReadDiscreteInput, write=FOnCanReadDiscreteInput};
	__property TCanReadRegisterEvent OnCanReadHoldingRegister = {read=FOnCanReadHoldingRegister, write=FOnCanReadHoldingRegister};
	__property TCanReadRegisterEvent OnCanReadInputRegister = {read=FOnCanReadInputRegister, write=FOnCanReadInputRegister};
	__property TCanWriteCoilEvent OnCanWriteCoil = {read=FOnCanWriteCoil, write=FOnCanWriteCoil};
	__property TCanWriteRegisterEvent OnCanWriteHoldingRegister = {read=FOnCanWriteHoldingRegister, write=FOnCanWriteHoldingRegister};
	__property TGetDiscreteBitValueEvent OnGetCoilValue = {read=FOnGetCoilValue, write=FOnGetCoilValue};
	__property TGetDiscreteBitValueEvent OnGetDiscreteInputValue = {read=FOnGetDiscreteInputValue, write=FOnGetDiscreteInputValue};
	__property TGetRegisterValueEvent OnGetHoldingRegisterValue = {read=FOnGetHoldingRegisterValue, write=FOnGetHoldingRegisterValue};
	__property TGetRegisterValueEvent OnGetInputRegisterValue = {read=FOnGetInputRegisterValue, write=FOnGetInputRegisterValue};
	__property TSetCoilValueEvent OnSetCoilValue = {read=FOnSetCoilValue, write=FOnSetCoilValue};
	__property TSetRegisterValueEvent OnSetHoldingRegisterValue = {read=FOnSetHoldingRegisterValue, write=FOnSetHoldingRegisterValue};
};


typedef TFrameData *PFrameData;

//-- var, const, procedure ---------------------------------------------------
#define ModLinkVersion "2.10 (June 03, 2007)"
static const Shortint MinQueryPDUSize = 0x1;
static const Shortint MinReplyPDUSize = 0x2;
static const Byte MaxFramePDUSize = 0xfd;
static const Shortint MinQueryADUSizeRTU = 0x4;
static const Shortint MinReplyADUSizeRTU = 0x5;
static const Word MaxFrameADUSizeRTU = 0x100;
static const Shortint MinQueryADUSizeASCII = 0x3;
static const Shortint MinReplyADUSizeASCII = 0x4;
static const Byte MaxFrameADUSizeASCII = 0xff;
static const Shortint Cmd_ReadCoils = 0x1;
static const Shortint Cmd_ReadDiscreteInputs = 0x2;
static const Shortint Cmd_ReadHoldingRegisters = 0x3;
static const Shortint Cmd_ReadInputRegisters = 0x4;
static const Shortint Cmd_WriteSingleCoil = 0x5;
static const Shortint Cmd_WriteSingleRegister = 0x6;
static const Shortint Cmd_ReadExceptionStatus = 0x7;
static const Shortint Cmd_Diagnostics = 0x8;
static const Shortint Cmd_WriteMultipleCoils = 0xf;
static const Shortint Cmd_WriteMultipleRegisters = 0x10;
static const Shortint Cmd_ReportServerID = 0x11;
static const Shortint Cmd_ReadFileRecord = 0x14;
static const Shortint Cmd_WriteFileRecord = 0x15;
static const Shortint Cmd_MaskWriteRegister = 0x16;
static const Shortint Cmd_ReadWriteMultipleRegisters = 0x17;
static const Shortint Subcmd_Diagnostics_ReturnQueryData = 0x0;
static const Shortint Subcmd_Diagnostics_RestartCommsOption = 0x1;
static const Shortint Subcmd_Diagnostics_RestartCommsOptionAndClearEventLog = 0x1;
static const Shortint Subcmd_Diagnostics_ReturnDiagnosticRegister = 0x2;
static const Shortint Subcmd_Diagnostics_ForceListenOnlyMode = 0x4;
static const Shortint Subcmd_Diagnostics_ClearCountersAndDiagnosticRegister = 0xa;
static const Shortint Subcmd_Diagnostics_ReturnBusMessageCount = 0xb;
static const Shortint Subcmd_Diagnostics_ReturnBusCommErrorCount = 0xc;
static const Shortint Subcmd_Diagnostics_ReturnBusExceptionErrorCount = 0xd;
static const Shortint Subcmd_Diagnostics_ReturnServerMessageCount = 0xe;
static const Shortint Subcmd_Diagnostics_ReturnServerNoReplyCount = 0xf;
static const Shortint Subcmd_Diagnostics_ReturnServerNegativeAcknowledgeCount = 0x10;
static const Shortint Subcmd_Diagnostics_ReturnServerBusyCount = 0x11;
static const Shortint Subcmd_Diagnostics_ReturnBusCharacterOverrunCount = 0x12;
static const Shortint Subcmd_Diagnostics_ClearOverrunCounterAndFlag = 0x14;
extern PACKAGE void __fastcall EnumSerialPorts(Classes::TStrings* Dest);
extern PACKAGE Word __fastcall SmallInt2Mod(short Number);
extern PACKAGE void __fastcall LongInt2Mod(int Number, Word &RegValue1, Word &RegValue2, bool BigEndian = false);
extern PACKAGE void __fastcall LongWord2Mod(unsigned Number, Word &RegValue1, Word &RegValue2, bool BigEndian = false);
extern PACKAGE Word __fastcall ScaledFloat2Mod(const float Number, int Decimals);
extern PACKAGE void __fastcall Single2Mod(const float Number, Word &RegValue1, Word &RegValue2, bool BigEndian = false);
extern PACKAGE void __fastcall Double2Mod(const double Number, Word &RegValue1, Word &RegValue2, Word &RegValue3, Word &RegValue4, bool BigEndian = false);
extern PACKAGE short __fastcall Mod2SmallInt(Word RegValue);
extern PACKAGE int __fastcall Mod2LongInt(Word RegValue1, Word RegValue2, bool BigEndian = false);
extern PACKAGE unsigned __fastcall Mod2LongWord(Word RegValue1, Word RegValue2, bool BigEndian = false);
extern PACKAGE float __fastcall Mod2ScaledFloat(Word RegValue, int Decimals);
extern PACKAGE float __fastcall Mod2Single(Word RegValue1, Word RegValue2, bool BigEndian = false);
extern PACKAGE double __fastcall Mod2Double(Word RegValue1, Word RegValue2, Word RegValue3, Word RegValue4, bool BigEndian = false);

}	/* namespace Modlink */
using namespace Modlink;
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Modlink