How ait-rdp/rdp-modbus-crawler works
Project type and purpose
• This is an open-source Python library (“Modbus Crawler”) that automates reading and writing Modbus registers.
• It provides generic, pluggable support for specifying registers via CSV or pandas DataFrame, and for connecting over TCP or RTU, sync or async.
File structure
Top level:
• setup.py, README.md, LICENSE, CI config
• modbus_crawler/ (core package)
– input_data_validation.py
– modbus_register_list_parser.py
– modbus_register_list_parser_csv.py
– modbus_register_list_parser_pandas.py
– register_block.py
– modbus_device.py
– modbus_device_tcp.py / modbus_device_tcp_async.py
– modbus_device_rtu.py / modbus_device_rtu_async.py
• test/ (unit tests and example CSVs)
Patterns & layers:
• “Parser” layer: reading & validating spec (CSV or pandas)
• “Model” layer: RegisterBlock abstraction
• “Device” layer: common API + four transport implementations (TCP/RTU × sync/async)
• “External I/O” layer: network socket or serial port to Modbus slave device
Insights from the README
• Purpose: group registers into blocks, decode to Python types, minimize Modbus calls
• Supported data types, case-insensitive headers, string handling
• Example API use (connect, read_registers_as_dict, disconnect)
• Extensibility: alias maps in input_data_validation, multiple parser backends
Main components
A. Register Spec Input
• CSV Parser (modbus_register_list_parser_csv.py)
• Pandas Parser (modbus_register_list_parser_pandas.py)
• Validation module (input_data_validation.py)
B. RegisterBlock assembly (register_block.py)
C. Device API layer (modbus_device.py)
– defines connect(), disconnect(), read_register(s), write_register()
D. Transport implementations
• ModbusTcpDevice (modbus_device_tcp.py)
• ModbusTcpDeviceAsync (modbus_device_tcp_async.py)
• ModbusRtuDevice (modbus_device_rtu.py)
• ModbusRtuDeviceAsync (modbus_device_rtu_async.py)
E. External Modbus Slave
F. Test suite (test/)
Relationships & data flows
1. User application → invokes library API (ModbusTcpDevice or RTU)
2. Device constructor loads a register spec via Parser layer → Validation
3. Parser outputs list of register definitions → RegisterBlock groups registers into blocks
4. read_registers() calls the transport implementation → issues Modbus read on TCP/Serial
5. Raw bytes ← network/serial → transport → decode in RegisterBlock → Map to Python types
6. write_register() mirrors above for writes
7. Test suite exercises parsers, blocks, devices using sample CSV & config
Architectural patterns & principles
• Layered architecture: Separation between parsing, business logic, transport
• Strategy/Plugin pattern: interchangeable parsers (CSV vs pandas), transport classes (sync vs async)
• Single Responsibility: each module handles one concern (validation, parsing, register grouping, transport)
• Abstraction: common Device API hiding sync/async and TCP/RTU differences