Symbols ![]()
loading...
Files ![]()
loading (2/5)...
mb_slave sample sample
mb_slave sample is a sample project defining the following symbols:Most used functions
Name
Location
Summary
This function is wait for modbus master request finish and return result. Waiting result include request process success, request respond timeout, receive data error and execute function error.You can use the above callback function.
This function is take Mobus Master running resource. Note:The resource is define by Operating System.
Function to set bits in a byte buffer. This function allows the efficient use of an array to implement bitfields. The array used for storing the bits must always be a multiple of two bytes. Up to eight bits can be set or cleared in one operation.
ucBits[2] = {0, 0};
// Set bit 4 to 1 (read: set 1 bit starting at bit offset 4 to value 1)
xMBUtilSetBits( ucBits, 4, 1, 1 );
// Set bit 7 to 1 and bit 8 to 0.
xMBUtilSetBits( ucBits, 7, 2, 0x01 );
// Set bits 8 - 11 to 0x05 and bits 12 - 15 to 0x0A;
xMBUtilSetBits( ucBits, 8, 8, 0x5A);
This is modbus master user error handling funcion. If it is defined in the user application, then helps to handle the errors and received/sent buffers to transfer as well as handle the slave exception codes.
Function to read bits in a byte buffer. This function is used to extract up bit values from an array. Up to eight bit values can be extracted in one step.
UCHAR ucBits[2] = {0, 0};
UCHAR ucResult;
// Extract the bits 3 - 10.
ucResult = xMBUtilGetBits( ucBits, 3, 8 );
Callback function used if a Holding Register value is read or written by the protocol stack. The starting register address is given by \c usAddress and the last register is given by usAddress + usNRegs - 1.
Callback function used if a Holding Register value is read or written by the protocol stack. The starting register address is given by \c usAddress and the last register is given by usAddress + usNRegs - 1.
The helper function to set data of parameters according to its type
Callback function used if a Coil Register value is read or written by the protocol stack. If you are going to use this function you might use the functions xMBUtilSetBits( ) and xMBUtilGetBits( ) for working with bitfields.
Callback function used if a Coil Register value is read or written by the protocol stack. If you are going to use this function you might use the functions xMBUtilSetBits( ) and xMBUtilGetBits( ) for working with bitfields.
This function is release Modbus Master running resource. Note:The resource is define by Operating System. If you not use OS this function can be empty.
Release resources used by the protocol stack. This function disables the Modbus Master protocol stack and release all hardware resources. It must only be called when the protocol stack is disabled.
Enable the Modbus Master protocol stack. This function enables processing of Modbus Master frames. Enabling the protocol stack is only possible if it is in the disabled state.
Disable the Modbus Master protocol stack. This function disables processing of Modbus frames.
The main pooling loop of the Modbus Master protocol stack. This function must be called periodically. The timer interval required is given by the application dependent Modbus slave timeout. Internally the function calls xMBMasterPortEventGet() and waits for an event from the receiver or transmitter state machines.
This function will request write holding register.
This function will request write multiple holding register.
This function will request read holding register.
This function will request read and write holding register.
This function will request write one coil. @see eMBMasterReqWriteMultipleCoils
This function will request write multiple coils. @see eMBMasterReqWriteCoil
Enable the Modbus protocol stack. This function enables processing of Modbus frames. Enabling the protocol stack is only possible if it is in the disabled state.
Disable the Modbus protocol stack. This function disables processing of Modbus frames.
The main pooling loop of the Modbus protocol stack. This function must be called periodically. The timer interval required is given by the application dependent Modbus slave timeout. Internally the function calls xMBPortEventGet() and waits for an event from the receiver or transmitter state machines.
Callback function used if a Input Discrete Register value is read by the protocol stack. If you are going to use his function you might use the functions xMBUtilSetBits( ) and xMBUtilGetBits( ) for working with bitfields.
#include "mb_m.h"
The protocol stack does not internally allocate any memory for the registers. This makes the protocol stack very small and also usable on low end targets. In addition the values don't have to be in the memory and could for example be stored in a flash. Whenever the protocol stack requires a value it calls one of the callback function with the register address and the number of registers to read as an argument. The application should then read the actual register values (for example the ADC voltage) and should store the result in the supplied buffer. If the protocol stack wants to update a register value because a write register function was received a buffer with the new register values is passed to the callback function. The function should then use these values to update the application register values. The common callback function used to transfer common data as bytes from command buffer in little endian format.Callback function used if the value of a Input Register is required by the protocol stack. The starting register address is given by \c usAddress and the last register is given by usAddress + usNRegs - 1.
This is modbus master respond timeout error process callback function.
This is modbus master receive data error process callback function.
This is modbus master execute function error process callback function.
This is modbus master request process success callback function.
Initialize the Modbus Master protocol stack. This functions initializes the ASCII or RTU module and calls the init functions of the porting layer to prepare the hardware. Please note that the receiver is still disabled and no Modbus frames are processed until eMBMasterEnable( ) has been called.
Initialize the Modbus Master protocol stack for Modbus TCP. This function initializes the Modbus TCP Module. Please note that frame processing is still disabled until eMBEnable( ) is called.
These Modbus functions are called for user when Modbus run in Master Mode.
Initialize the Modbus protocol stack. This functions initializes the ASCII or RTU module and calls the init functions of the porting layer to prepare the hardware. Please note that the receiver is still disabled and no Modbus frames are processed until eMBEnable( ) has been called.
Initialize the Modbus protocol stack for Modbus TCP. This function initializes the Modbus TCP Module. Please note that frame processing is still disabled until eMBEnable( ) is called.
Release resources used by the protocol stack. This function disables the Modbus protocol stack and release all hardware resources. It must only be called when the protocol stack is disabled.
Configure the slave id of the device. This function should be called when the Modbus function Report Slave ID is enabled ( By defining MB_FUNC_OTHER_REP_SLAVEID_ENABLED in mbconfig.h ).
#include "mb.h"
The protocol stack does not internally allocate any memory for the registers. This makes the protocol stack very small and also usable on low end targets. In addition the values don't have to be in the memory and could for example be stored in a flash. Whenever the protocol stack requires a value it calls one of the callback function with the register address and the number of registers to read as an argument. The application should then read the actual register values (for example the ADC voltage) and should store the result in the supplied buffer. If the protocol stack wants to update a register value because a write register function was received a buffer with the new register values is passed to the callback function. The function should then use these values to update the application register values. Callback function used if the value of a Input Register is required by the protocol stack. The starting register address is given by \c usAddress and the last register is given by usAddress + usNRegs - 1.Callback function used if a Input Discrete Register value is read by the protocol stack. If you are going to use his function you might use the functions xMBUtilSetBits( ) and xMBUtilGetBits( ) for working with bitfields.
Function to setup communication options for TCP/UDP Modbus port
Keeps FSM event handle and mask then wait for Master stack to start
Read parameter from modbus slave device whose name is defined by name and has cid. The additional data for request is taken from parameter description (lookup) table.
Specific interface functions ******************************************** Interface functions below provide basic methods to read/write access to slave devices in Modbus segment as well as API to read specific supported characteristics linked to Modbus parameters of devices in Modbus network. Assign parameter description table for Modbus controller interface.
Set characteristic's value defined as a name and cid parameter. The additional data for cid parameter request is taken from master parameter lookup table.
Get information about supported characteristic defined as cid. Uses parameter description table to get this information. The function will check if characteristic defined as a cid parameter is supported and returns its description in param_info. Returns ESP_ERR_NOT_FOUND if characteristic is not supported.
Initialize Modbus Slave controller and stack for Serial port
Initialize Modbus Master controller and stack for Serial port
Initialize Modbus Slave controller and stack for TCP port
Send data request as defined in parameter request, waits response from slave and returns status of command execution. This function provides standard way for read/write access to Modbus devices in the network.
The helper function to expose transaction info from modbus layer
Registers a callback handler for a given function code. This function registers a new callback handler for a given function code. The callback handler supplied is responsible for interpreting the Modbus PDU and the creation of an appropriate response. In case of an error it should return one of the possible Modbus exceptions which results in a Modbus exception frame sent by the protocol stack.
Modbus master holding register callback function.
Registers a callback handler for a given function code. This function registers a new callback handler for a given function code. The callback handler supplied is responsible for interpreting the Modbus PDU and the creation of an appropriate response. In case of an error it should return one of the possible Modbus exceptions which results in a Modbus exception frame sent by the protocol stack.
Other commonly used symbols
Name
Location
Summary
Characteristics descriptor type is used to describe characteristic and link it with Modbus parameters that reflect its data.
Device communication structure to setup Modbus controller
Most modules in the protocol stack are completly optional and can be excluded. This is specially important if target resources are very small and program memory space should be saved. All of these settings are available in the file mbconfig.h
Maximum number of Modbus functions codes the protocol stack should support. The maximum number of supported Modbus functions must be greater than the sum of all enabled functions in this file and custom function handlers. If set to small adding more functions will fail.
If master send a frame which is not broadcast,the master will wait sometime for slave. And if slave is not respond in this time,the master will process this timeout error.
the characteristic of the device are readable & writable & triggerable
Callback function for the porting layer when a new byte is available. Depending upon the mode this callback function is used by the RTU or ASCII transmission layers. In any case a call to xMBPortSerialGetByte() must immediately return a new character.
Number of bytes which should be allocated for the Report Slave ID command. This number limits the maximum size of the additional segment in the report slave id function. See eMBSetSlaveID( ) for more information on how to set this value. It is only used if MB_FUNC_OTHER_REP_SLAVEID_ENABLED is set to 1.
This is the Modbus register address. This is the 0 based value.
the characteristic of the device are readable & writable
If master send a broadcast frame, the master will wait time of convert to delay,
Constants which defines the format of a modbus frame. The example is shown for a Modbus RTU/ASCII frame. Note that the Modbus PDU is not dependent on the underlying transport. +-----------+---------------+----------------------------+-------------+ | Address | Function Code | Data | CRC/LRC | +-----------+---------------+----------------------------+-------------+ | | | | (2) (3/2') (3') (4) (1) ... MB_SER_PDU_SIZE_MAX = 256 (2) ... MB_SER_PDU_ADDR_OFF = 0 (3) ... MB_SER_PDU_PDU_OFF = 1 (4) ... MB_SER_PDU_SIZE_CRC = 2 (1') ... MB_PDU_SIZE_MAX = 253 (2') ... MB_PDU_FUNC_OFF = 0 (3') ... MB_PDU_DATA_OFF = 1 Maximum size of a PDU.
This option defines the number of data bits per ASCII character. A parity bit is added before the stop bit which keeps the actual byte size at 10 bits.
The character timeout value for Modbus ASCII. The character timeout value is not fixed for Modbus ASCII and is therefore a configuration option. It should be set to the maximum expected delay time of the network.
the characteristic of the device are readable & triggerable
the characteristic of the device are writable & triggerable
Double GHEFCDAB floating point, big endian, reversed register order
Double BADCFEHG floating point, little endian, reversed register order
I32 CDAB signed integer, big endian, reversed register order
I32 BADC signed integer, little endian, reversed register order
U32 CDAB unsigned integer, big endian, reversed register order
U32 BADC unsigned integer, little endian, reversed register order
Float CDAB floating point big endian, reversed register order
Float BADC floating point, little endian, reversed register order
I64, GHEFCDAB signed integer, big endian, reversed register order
I64, BADCFEHG signed integer, little endian, reversed register order
U64, GHEFCDAB unsigned integer, big endian, reversed register order
U64, BADCFEHG unsigned integer, little endian, reversed register order
#include "mb.h"
This module defines the interface for the application. It contains the basic functions and types required to use the Modbus protocol stack. A typical application will want to call eMBInit() first. If the device is ready to answer network requests it must then call eMBEnable() to activate the protocol stack. In the main loop the function eMBPoll() must be called periodically. The time interval between pooling depends on the configured Modbus timeout. If an RTOS is available a separate task should be created and the task should always call the function eMBPoll().
// Initialize protocol stack in RTU mode for a slave with address 10 = 0x0A
eMBInit( MB_RTU, 0x0A, 38400, MB_PAR_EVEN );
// Enable the Modbus Protocol Stack.
eMBEnable( );
for( ;; )
{
// Call the main polling loop of the Modbus protocol stack.
eMBPoll( );
...
}
Use the default Modbus TCP port (502) #include "mb.h"
This module defines the interface for the application. It contains the basic functions and types required to use the Modbus Master protocol stack. A typical application will want to call eMBMasterInit() first. If the device is ready to answer network requests it must then call eMBEnable() to activate the protocol stack. In the main loop the function eMBMasterPoll() must be called periodically. The time interval between pooling depends on the configured Modbus timeout. If an RTOS is available a separate task should be created and the task should always call the function eMBMasterPoll().
// Initialize protocol stack in RTU mode for a Master
eMBMasterInit( MB_RTU, 38400, MB_PAR_EVEN );
// Enable the Modbus Protocol Stack.
eMBMasterEnable( );
for( ;; )
{
// Call the main polling loop of the Modbus Master protocol stack.
eMBMasterPoll( );
...
}
Use the default Modbus Master TCP port (502)Dependencies
mb_slave sample depends on the following libraries: