maix.comm.modbus

maix.comm.modbus module

You can use maix.comm.modbus to access this module with MaixPy
This module is generated from MaixPy and MaixCDK

Module

No module

Enum

Mode

modbus mode

C++ defination code:

enum class Mode : unsigned char {
        RTU,
        TCP
    }

RequestType

Modbus request types enumeration.\nThis enumeration defines the various Modbus request types,\nincluding functions for reading and writing coils, registers,\nas well as diagnostics and identification.

C++ defination code:

enum class RequestType : unsigned char {
        READ_COILS                      = 0x01,     ///< Read Coils
        READ_DISCRETE_INPUTS            = 0x02,     ///< Read Discrete Inputs
        READ_HOLDING_REGISTERS          = 0x03,     ///< Read Holding Registers
        READ_INPUT_REGISTERS            = 0x04,     ///< Read Input Registers
        WRITE_SINGLE_COIL               = 0x05,     ///< Write Single Coil
        WRITE_SINGLE_REGISTER           = 0x06,     ///< Write Single Register
        DIAGNOSTICS                     = 0x08,     ///< Diagnostics (Serial Line only)
        GET_COMM_EVENT_COUNTER          = 0x0B,     ///< Get Comm Event Counter (Serial Line only)
        WRITE_MULTIPLE_COILS            = 0x0F,     ///< Write Multiple Coils
        WRITE_MULTIPLE_REGISTERS        = 0x10,     ///< Write Multiple Registers
        REPORT_SERVER_ID                = 0x11,     ///< Report Slave ID (Serial Line only)
        MASK_WRITE_REGISTER             = 0x16,     ///< Mask Write Register
        READ_WRITE_MULTIPLE_REGISTERS   = 0x17,     ///< Read/Write Multiple Registers
        READ_DEVICE_IDENTIFICATION      = 0x2B,     ///< Read Device Identification
        UNKNOWN                         = 0xFF      ///< Unknown Request Type
    }

Variable

Function

Class

Slave

Class for modbus Slave

C++ defination code:

class Slave

__init__

def __init__(self, mode: Mode, ip_or_device: str, coils_start: int = 0, coils_size: int = 0, discrete_start: int = 0, discrete_size: int = 0, holding_start: int = 0, holding_size: int = 0, input_start: int = 0, input_size: int = 0, rtu_baud: int = 115200, rtu_slave: int = 1, tcp_port: int = 5020, debug: bool = False) -> None

Modbus Slave constructor.\nThis constructor initializes a Modbus Slave instance. Depending on the mode (RTU or TCP),\nit sets up the necessary parameters for communication and defines the register structure.

C++ defination code:

Slave(maix::comm::modbus::Mode mode, const std::string& ip_or_device,
            uint32_t coils_start=0, uint32_t coils_size=0,
            uint32_t discrete_start=0, uint32_t discrete_size=0,
            uint32_t holding_start=0, uint32_t holding_size=0,
            uint32_t input_start=0, uint32_t input_size=0,
            int rtu_baud=115200, uint8_t rtu_slave=1,
            int tcp_port=5020, bool debug=false)

receive

def receive(self, timeout_ms: int = -1) -> maix.err.Err

Receives a Modbus request\nThis function is used to receive a Modbus request from the client. The behavior of the function\ndepends on the parameter timeout_ms provided, which dictates how long the function will wait\nfor a request before returning.

C++ defination code:

::maix::err::Err receive(const int timeout_ms=-1)

request_type

def request_type(self) -> RequestType

Gets the type of the Modbus request that was successfully received\nThis function can be used to retrieve the type of the request received after a successful\ncall to receive(). The return value indicates the type of the Modbus request, allowing\nthe user to understand and process the received request appropriately.

C++ defination code:

::maix::comm::modbus::RequestType request_type()

reply

def reply(self) -> maix.err.Err

Processes the request and returns the corresponding data.\nThis function handles the requests received from the client. It retrieves any data that the client\nneeds to write to the registers and updates the registers accordingly. Additionally, it retrieves\nthe requested data from the registers and sends it back to the client in the response.\nThis function is essential for managing read and write operations in a Modbus Slave context.

C++ defination code:

::maix::err::Err reply()

receive_and_reply

def receive_and_reply(self, timeout_ms: int = -1) -> RequestType

Receives a request from the client and sends a response.\nThis function combines the operations of receiving a request and sending a corresponding\nresponse in a single call. It waits for a specified duration (defined by the timeout_ms\nparameter) to receive a request from the client. Upon successful receipt of the request,\nit processes the request and prepares the necessary data to be sent back to the client.

C++ defination code:

::maix::comm::modbus::RequestType receive_and_reply(const int timeout_ms=-1)

coils

def coils(self, data: list[int] = [], index: int = 0) -> list[int]

Reads from or writes to coils.\nThis function can be used to either read data from coils or write data to them.\nIf the data parameter is empty, the function performs a read operation.\nIf data is not empty, the function writes the contents of data to the coils\nstarting at the specified index.

C++ defination code:

std::vector<uint8_t> coils(const std::vector<uint8_t>& data = std::vector<uint8_t>{}, const uint32_t index = 0)

discrete_input

def discrete_input(self, data: list[int] = [], index: int = 0) -> list[int]

Reads from or writes to discrete input.\nThis function can be used to either read data from discrete input or write data to them.\nIf the data parameter is empty, the function performs a read operation.\nIf data is not empty, the function writes the contents of data to the discrete input\nstarting at the specified index.

C++ defination code:

std::vector<uint8_t> discrete_input(const std::vector<uint8_t>& data = std::vector<uint8_t>{}, const uint32_t index = 0)

input_registers

def input_registers(self, data: list[int] = [], index: int = 0) -> list[int]

Reads from or writes to input registers.\nThis function can be used to either read data from input registers or write data to them.\nIf the data parameter is empty, the function performs a read operation.\nIf data is not empty, the function writes the contents of data to the input registers\nstarting at the specified index.

C++ defination code:

std::vector<uint16_t> input_registers(const std::vector<uint16_t>& data = std::vector<uint16_t>{}, const uint32_t index = 0)

holding_registers

def holding_registers(self, data: list[int] = [], index: int = 0) -> list[int]

Reads from or writes to holding registers.\nThis function can be used to either read data from holding registers or write data to them.\nIf the data parameter is empty, the function performs a read operation.\nIf data is not empty, the function writes the contents of data to the holding registers\nstarting at the specified index.

C++ defination code:

std::vector<uint16_t> holding_registers(const std::vector<uint16_t>& data = std::vector<uint16_t>{}, const uint32_t index = 0)