MODBUS Messaging on TCP/IP Implementation Guide V1.

0b Modbus Organization

The MODBUS Backend service will use the appropriate interface to the user
application :
Either a physical interface based on a serial link, or a dual-port RAM scheme, or
a simple I/O line, or a logical interface based on messaging services provided by
an operating system.
The interface to the User Application may be synchronous or asynchronous.

The MODBUS Backend service will also use the appropriate design pattern to get/set
objects attributes or to trigger services. In some cases, a simple "gateway pattern" will
be adequate. In some other cases, the designer will have to implement a "proxy
pattern" with a corresponding caching strategy, from a simple exchange table history to
more sophisticated replication mechanisms.

The MODBUS Backend service has the responsibility to implement the protocol
transcription in order to interact with the User Application. Therefore, it can have to
implement mechanisms for packet fragmentation/reconstruction, data consistency
guarantee, and synchronization whatever is required.

4.4.2.5 MODBUS Response building

Once the request has been processed, the MODBUS server has to build the response
using the adequate MODBUS server transaction and has to send it to the TCP
management component.
Depending on the result of the processing two types of response can be built :
A positive MODBUS response :
The response function code = The request function code

A MODBUS Exception response :

The objective is to provide to the client relevant information concerning the
error detected during the processing ;
The response function code = the request function code + 0x80 ;
The exception code is provided to indicate the reason of the error.

Exception MODBUS name Comments

Code
01 Illegal Function The function code is unknown by the server
Code
02 Illegal Data Dependant on the request
Address
03 Illegal Data Value Dependant on the request
04 Server Failure The server failed during the execution
05 Acknowledge The server accepted the service invocation but the
service requires a relatively long time to execute. The
server therefore returns only an acknowledgement of the
service invocation receipt.
06 Server Busy The server was unable to accept the MB Request PDU.
The client application has the responsibility of deciding if
and when to re-send the request.
0A Gateway problem Gateway paths not available.
0B Gateway problem The targeted device failed to respond. The gateway
generates this exception

The MODBUS response PDU must be prefixed with the MBAP header which is built
using data memorized in the transaction context.
• Unit Identifier
The Unit Identifier is copied as it was given within the received MODBUS request
and memorized in the transaction context.

October 24, 2006 http://www.Modbus.org 31/46

MODBUS Messaging on TCP/IP Implementation Guide V1.0b Modbus Organization

• Length
The server calculates the size of the MODBUS PDU plus the Unit Identifier byte.
This value is set in the "Length" field.
• Protocol Identifier
The Protocol Identifier field is set to 0x0000 (MODBUS protocol), as it was given
within the received MODBUS request.
• Transaction Identifier
This field is set to the "Transaction Identifier" value that was associated with the
original request and memorized in the transaction context.

Then the MODBUS response must be returned to the right MODBUS Client using the
TCP connection memorized in the transaction context. When the response is sent, the
transaction context must be free.

5 IMPLEMENTATION GUIDELINE
The objective of this section is to propose an example of a messaging service
implementation.
The model describes below can be used as a guideline during a client or a server
implementation of a MODBUS messaging service.

Informative Note: The messaging service implementation is the responsibility of the

User.

5.1 OBJECT MODEL DIAGRAM

User Application

InterfaceUserApplication

Communication application layer

Configuration layer

InterfaceIndicationMsg InterfaceResponseMsg

TCP management

Figure 18: MODBUS Messaging Service Object Model Diagram

October 24, 2006 http://www.Modbus.org 32/46
MODBUS Messaging on TCP/IP Implementation Guide V1.0b Modbus Organization

Four main packages compose the Object Model Diagram:

• The Configuration layer which configures and manages operating modes of
components of other packages
• The TCP Management which interfaces the TCP/IP stack and the communication
application layer managing TCP connection. It implies the management of socket
interface.
• The Communication application layer which is composed by the MODBUS client
on one side and the MODBUS server on the other side. This package is linked
with the user application.
The User application, which corresponds to the device application, is completely dependent
on the device and therefore it will be not part of this Specification.
This model is independent of implementation choices like the type of OS, the memory
management, etc. In order to guarantee this independence generic Interface layers are
used between the TCP management layer and the communication layer and between
the communication layer and the user application layer.
Different implementations of this interface can be realized by the User: Pipe between
two tasks, shared memory, serial link interface, procedural call, etc.
Some assumptions have to be taken to define the hereafter implementation model :
• Static memory management
• Synchronous treatment of the server
• One task to process the receptions on all sockets.

5.1.1 TCP management package

October 24, 2006 http://www.Modbus.org 33/46

MODBUS Messaging on TCP/IP Implementation Guide V1.0b Modbus Organization

InterfaceIndicationMsg
InterfaceRespons eMsg
(from Logical View)
(from Logical View)

-----------------------------------------------------------------------------------------------------------------------------------------------

ConnexionMgt
NbConnectionSupported : Int
Int erfaceConnex ion
NbLocalConnection : Int
NbRemoteConnection : int
GetObjectConnexion()
m_sendData() FreeObjectConnexion()
m_Receivedata() RetreivingObject Connexion()
m_isConnectionAuthorized() TCP management
pac kage

TCPConnexion
MB AP
IsConnexionRequest ()
It emConnexion OpenConnexion() IsMdbHeader()
SocketDescript : Int AcceptConnexion() GetMessagelength()
IPSource : Long CloseConnexion() WriteTransactionId()
PortSource : Long IsEt ablishedConnexion() ReadTransactionId()
PortDest : Long
IPdestination : long
BufferIn : Char*
BufferOut : Char*

Stack TCP IP

Socket interface()

Figure 19: MODBUS TCP management package

The TCP management package comprises the following classes :

CInterfaceConnexion: The role of this class consists in managing memory pool for
connections.

CItemConnexion: This class contains all information needed to describe a connection.

CTCPConnexion:, This class provides methods for managing automatically a TCP

connection (Interface socket is provided by CStackTCP_IP).

CConnexionMngt: This class manages all connections and send query/response to

MODBUS Server/MODBUS Client through CinterfaceIndicationMsg and
CInterfaceResponseMsg. This class also treats the Access control for the connection
opening.

CMBAP: This class provides methods for reading/writing/analyzing the MODBUS

MBAP.

CStackTCP_IP: This class Implements socket services and provides parameterization

of the stack.

October 24, 2006 http://www.Modbus.org 34/46

MODBUS Messaging on TCP/IP Implementation Guide V1.0b Modbus Organization

5.1.2 Configuration layer package

Communication applicat ion layer TCP management

(from Logical View) (from Logical View)

------------------------------------------------------------------------------------------------------------------------------------------------

Operating Mode

m_Configure()
m_Start()
Configuartion layer
m_Stop()
package
m_Reset()

ConfigurationObject
GlobalState : char
MyModbusAddress : Int
MyIPAddress : long
MyPortNumber : Long
NumberAuthorized_IP : int
ListAuthorized_IP : int
NumberForbidden_IP : Int
ListForbidden_IP : long()
NumberConnect ionSupported : int

Figure 20: MODBUS Configuration layer package

The Configuration layer package comprises the following classes :

TConfigureObject: This class groups all data needed for configuring each other
component. This structure is filled by the method m_Configure from the class
CoperatingMode. Each class needing to be configured gets its own configuration data
from this object. The configuration data is implementation dependent therefore the list
of attributes of this class is provided as an example.

COperatingMode: The role of this class is to fill the TConfigureObject (according to

the user configuration) and to manage the operating modes of the classes described
below:

CMODBUSServer
CMODBUSClient

October 24, 2006 http://www.Modbus.org 35/46

MODBUS Messaging on TCP/IP Implementation Guide V1.0b Modbus Organization

CconnexionMngt

5.1.3 Communication layer package

InterfaceUserApplication
(from Logical View)

--------------------------------------------------------------------------------------------------------------------------------------------------------

ModbusPDU Communication
Application layer
package
IsMdbAnalysisOfDataCorrect()
m_BuildModbusException()
m_WritePDU()

ModbusServer
ModbusClient
m_ServerReceivingMessage()
m_ServerModbus() m_ClientReceivingResponse()
m_BuildResponse() m_ClientReceivingMessage()
m_InitServerfunction() m_ClientModbus()

Transaction
TransactionId : int
TimeSnapShot : int

IsTransactionTimeOut()
m_WriteTransactionID()
m_StartTimesnapShoot()
--------------------------------------------------------------------------------------------------------------------------------------------------------

Int erfaceIndicationMsg InterfaceResponseMsg

(from Logical View) (from Logical View)

Figure 21: MODBUS Communication Application layer package

The Communication Application layer package comprises the following classes :

CMODBUSServer: MODBUS query is received from class CInterfaceIndicationMsg

(by the method m_ServerReceivingMessage). The role of this class is to build the
MODBUS response or the MODBUS Exception according the query (incoming from
network). This class implements the Graph State of MODBUS server. Response can be
built only if class COperatingMode has sent both user configuration and right operating
modes.

CMODBUSClient: MODBUS query is read from class CInterfaceUserApplication, The

client task receives query by the method m_ClientReceivingMessage. This class
October 24, 2006 http://www.Modbus.org 36/46
MODBUS Messaging on TCP/IP Implementation Guide V1.0b Modbus Organization

implements the State Graph of MODBUS client and manages transactions for linking
query with response (from network). Query can be sent over network only if class
CoperatingMode has sent both user configuration and right operating modes.

CTransaction: This class implements methods and structures for managing

transactions.

5.1.4 Interface classes

CInterfaceUserApplication: This class represents the interface with the user

application, it provides two methods to access to the user data. In a real
implementation this method can be implemented in different way depending of the
hardware and software device capabilities (equivalent to an end-driver, example access
to PCMCIA, shared memory, etc).

CInterfaceIndicationMsg: This Interface class is proposed for sending query from

Network to the MODBUS Server, and for sending response from Network for the Client.
This class interfaces TCPManagement and ‘Communication Application Layer’
packages (From Network). The implementation of this class is device dependent.

CInterfaceResponseMsg: This Interface class is used for receiving response from the
Server and for sending query from the client to the Network. This class interfaces
packages ‘Communication Application Layer’ and package ‘TCPManagement’ (To
Network). The implementation of this class is device dependent.

5.2 IMPLEMENTATION CLASS DIAGRAM

The following Class Diagram describes the complete diagram of a proposal

implementation.

October 24, 2006 http://www.Modbus.org 37/46

MODBUS Messaging on TCP/IP Implementation Guide V1.0b Modbus Organization

Figure 22: Class Diagram

October 24, 2006 http://www.Modbus.org 38/46

MODBUS Messaging on TCP/IP Implementation Guide V1.0b Modbus Organization

5.3 SEQUENCE DIAGRAMS

Two Sequence diagrams are described hereafter are an example in order to illustrate a
Client MODBUS transaction and a Server MODBUS transaction.

Figure 23: MODBUS client sequence diagram

October 24, 2006 http://www.Modbus.org 39/46

MODBUS Messaging on TCP/IP Implementation Guide V1.0b Modbus Organization
General comments for a better understanding of the Client sequence diagram:

First step: A Reading query comes from User Application (method m_Read).

Second Step: The ‘Client’ task receives the MODBUS query (method
m_ClientReceivingMessage). This is the entry point of the Client. To associate the
query with the corresponding response when it will arrive, the Client uses a
Transaction resource (Class CTransaction). The MODBUS query is sent to the
TCP_Management by calling the class interface CInterfaceResponseMsg (method
m_MODBUSRequest)

Third Step: If the connection is already established there is nothing to do on

connection, the message can be send over the network. Otherwise, a connection must
be opened before the message can be sent over the network.
At this time the client is waiting for a response (from a remote server)

Fourth step: Once a response has been received from the network, the TCP/IP stack
receives data (method m_EventOnSocket is implicitly called).
If the connection is already established, then the MBAP is read for retrieving the
connection object (connection object gives memory resource and other information).
Data coming from network is read and confirmation is sent to the client task via the
class Interface CInterfaceIndicationMsg (method m_MODBUSConfirmation). Client
task receives the MODBUS Confirmation (method m_ClientReceivingResponse).
Finally the response is written to the user application (method m_WriteData), and
transaction resource is freed.

October 24, 2006 http://www.Modbus.org 40/46