moonbit-modbus
A portable Modbus RTU, ASCII, and TCP protocol stack with device simulation and gateway primitives for MoonBit.
modbus
industrial
protocol
rtu
ascii
tcp
plc
moon add qyt1234567/moonbit-modbus@0.2.0
Download zipAuthor
Version
0.2.0
License
Apache-2.0
Repository
Last updated
2 hours ago
Downloads
2
README#moonbit-modbus
moonbit-modbus 是一个面向工业设备接入的 MoonBit Modbus 协议栈。它把 PDU、RTU、ASCII 和 TCP MBAP 统一到同一套类型安全 API，并提供设备内存、客户端事务、轮询、网关和虚拟链路等可组合模块，适合 PLC、变频器、仪表、数据采集器和协议测试工具。
#核心能力
- 协议编解码：Modbus RTU、ASCII、TCP，CRC16、LRC、MBAP 事务标识和异常响应。
- 功能码覆盖：线圈、离散输入、保持寄存器、输入寄存器的读写，以及掩码写、读写组合、诊断、事件计数器、文件记录、设备识别和 FIFO。
- 流式处理：有界增量解析器支持分段输入、多帧输入和坏帧恢复，避免无界缓存。
- 设备与内存：寄存器/线圈 bank、地址空间、schema、文件记录存储、设备状态和异常统计。
- 集成组件：客户端重试与超时、请求规划、轮询计划、批处理、网关映射、服务器池和虚拟传输链路。
- 工程质量：无第三方运行时依赖，支持 native、wasm 和 wasm-gc 目标；公共接口生成 .mbti 文件并由 CI 校验。
#快速开始
需要已安装 MoonBit stable 工具链。仓库根目录执行：
moon update
moon check --target all --deny-warn
moon test --target all --deny-warn
moon run cmd/main最小 API 示例：
///|
let request = @moonbit-modbus.read_holding(1, 0, 4)
///|
let rtu_bytes = @moonbit-modbus.encode_rtu(request)
///|
let parsed = @moonbit-modbus.decode_rtu(rtu_bytes)增量解析示例：
///|
let parser = @moonbit-modbus.IncrementalParser::new(@moonbit-modbus.rtu_mode())
///|
let frames = parser.feed(rtu_bytes)#CLI
仓库包含两个可直接运行的示例程序：
# 展示请求编码、虚拟设备处理和响应格式化
moon run --target native cmd/main
# 运行 1000 次 CRC、RTU、TCP 和设备读工作负载
moon run --target native cmd/benchcmd/bench 输出确定性的迭代次数、成功数、失败数和处理字节数；独立的端到端命令耗时记录在 BENCHMARK.md。
#架构
代码按协议边界拆分为几个层次：
- types.mbt、validation.mbt 和 limits.mbt 定义公共类型、功能码、异常码和边界规则。
- codec.mbt、checksum.mbt、parser.mbt 和 frame_text.mbt 负责 PDU/ADU 编解码、校验和流式解析。
- functions.mbt、responses.mbt、coils.mbt、register_codec.mbt 和 file_records.mbt 提供功能码与数据表示。
- banks.mbt、device.mbt、register_schema.mbt 和 address_space.mbt 组成可测试的设备内存层。
- client.mbt、transport.mbt、polling.mbt、gateway.mbt、server_pool.mbt 和 simulation.mbt 提供系统集成能力。
- conformance.mbt、preflight.mbt、quality.mbt、metrics.mbt 和 benchmark_core.mbt 提供一致性检查、运行指标和可复现基准。
核心层只依赖 MoonBit 标准能力；真实串口和 TCP socket 可在上层适配，而不改变协议模型和测试夹具。
#基准
基准使用 native 目标和固定的 1000 次迭代，覆盖 CRC16、RTU 编解码往返、TCP 编解码往返和设备读路径。结果分为确定性工作量统计与主机端到端耗时两部分，避免把不同机器的时钟结果伪装成协议吞吐率。复现实验方法和原始测量值见 BENCHMARK.md。
#测试
测试覆盖正常路径和边界路径，包括：
- 地址、单位号、数量、PDU/ADU 长度、字节计数和广播请求边界；
- CRC/LRC、ASCII/TCP/RTU 错帧、分段输入、多帧输入和截断输入；
- 线圈 bit packing、寄存器字节序、32/64 位数值、游标越界和写入器容量；
- 设备读写、异常响应、busy 状态、文件记录、设备识别、客户端事务和网关映射；
- schema、轮询、批处理、预检、指标、虚拟传输和文本帧工具。
本地质量门槛：
moon fmt --check
moon info
moon check --target all --deny-warn
moon test --target all --deny-warn#CI
.github/workflows/check.yml 在 Ubuntu、macOS 和 Windows 上安装 MoonBit stable，执行 moon update、格式检查、全目标检查、构建、测试、CLI smoke test 和 .mbti 清洁工作树校验。.github/workflows/publish.yml 仅支持手动触发，用于在配置发布凭据后执行 Mooncakes 发布流程。
#许可证
本项目采用 Apache-2.0 许可证。协议实现依据公开的 Modbus 应用协议与串行链路规范重新实现，源码和测试夹具均保留在本仓库中。
#AddressAllocator
A first-fit allocator for contiguous register or coil ranges.
#AddressAllocator::allocate
fn AddressAllocator::allocate(self : AddressAllocator, length : Int) -> Result[AddressRange, ModbusError]#AddressAllocator::free_capacity
#AddressAllocator::new
#AddressAllocator::release
fn AddressAllocator::release(self : AddressAllocator, range : AddressRange) -> Result[Unit, ModbusError]#AddressAllocator::snapshot
#AddressAllocator::used_capacity
#AddressRange
pub(all) struct AddressRange {
start : UInt16
length : Int
}A half-open address range in the Modbus 16-bit address space.
#AddressRange::contains
#AddressRange::contains_range
#AddressRange::new
#AddressRange::offset
#AddressRange::overlaps
#AddressRange::slice
fn AddressRange::slice(self : AddressRange, offset : Int, length : Int) -> Result[AddressRange, ModbusError]#AddressRange::split
fn AddressRange::split(self : AddressRange, segment_length : Int) -> Result[Array[AddressRange], ModbusError]Split a range into non-overlapping segments of at most segment_length.
#AlarmMonitor
pub(all) struct AlarmMonitor {
threshold : Threshold
state : ThresholdState
transitions : Int
last_value : Int?
}Stateful threshold monitor that counts state transitions.
#AlarmMonitor::observe
#AuditEntry
pub(all) struct AuditEntry {
sequence : Int
direction : String
mode : Mode
transaction_id : UInt16
summary : FrameSummary
outcome : String
}A trace record suitable for debugging a gateway or device exchange.
#AuditLog
#AuditLog::record
#BatchItem
A named request in a batch operation.
#BatchPlan
An ordered batch plan used to pipeline independent requests.
#BatchPlan::add
#BatchPlan::execute
Execute an ordered plan against a deterministic device.
#BatchPlan::item
#BatchResult
The result of executing one batch item.
#BenchmarkResult
pub(all) struct BenchmarkResult {
name : String
iterations : Int
successful : Int
failed : Int
bytes : Int
}Deterministic benchmark counters emitted by the command-line benchmark.
#BenchmarkResult::success_rate
#BitVector
A mutable bounded bit vector for coils and discrete inputs.
#BitVector::bit_and
Apply a bitwise AND to two equally sized vectors.
#BitVector::copy
Copy a bit vector and keep its logical length.
#BitVector::equal
Compare two bit vectors including their logical lengths.
#BitVector::new
Create a zero-filled bit vector.
#BitVector::not
Invert all logical bits, keeping padding bits clear.
#BitVector::or
Apply a bitwise OR to two equally sized vectors.
#BitVector::pack_range
fn BitVector::pack_range(self : BitVector, start : Int, quantity : Int) -> Result[Array[Byte], ModbusError]Pack a range of bits from a vector for a Modbus response.
#BitVector::set
#BitVector::shift_left
Shift logical bits left, dropping values that fall outside the vector.
#BitVector::shift_right
Shift logical bits right, dropping values that fall outside the vector.
#BitVector::unpack_into
fn BitVector::unpack_into(self : BitVector, start : Int, quantity : Int, bytes : Array[Byte]) -> Result[Unit, ModbusError]Replace a range of bits from packed input bytes.
#ByteQueue
A bounded byte queue for adapters that receive arbitrary chunk sizes.
#ByteQueue::contains_sequence
#ByteQueue::peek
#ByteQueue::push
#ByteQueue::push_byte
#ByteQueue::take
#Client
pub struct Client {
mode : Mode
config : ClientConfig
next_transaction : UInt16
pending : Array[PendingExchange]
}A stateful protocol client that does not assume a particular socket runtime.
#Client::accept
fn Client::accept(self : Client, request : ClientRequest, bytes : Array[Byte]) -> Result[Frame, ModbusError]Accept bytes from the transport and correlate them with a pending request.
#Client::accept_frame
fn Client::accept_frame(self : Client, request : ClientRequest, transaction_id : UInt16, response : Frame) -> Result[Frame, ModbusError]Accept an already decoded response frame.
#Client::allocate_transaction
Allocate a non-zero transaction id for TCP and a stable zero id for serial modes.
#Client::attempts
Return a request's retry count, or zero when it is not tracked.
#Client::begin
Begin an exchange at logical tick zero.
#Client::begin_at
Begin an exchange at a caller-supplied logical tick.
#Client::cancel
#Client::expire
Mark all timed-out exchanges as failed and return their transaction ids.
#Client::pending_request
Find a pending request by transaction id.
#Client::pending_snapshot
Return a copy of all pending records for an external scheduler.
#ClientConfig
pub(all) struct ClientConfig {
timeout_ticks : Int
retries : Int
max_pending : Int
strict_unit : Bool
}Client retry and framing policy.
#ClientRequest
A request prepared for a transport adapter.
#ClientResult
A decoded client result with a typed success/exception branch.
#CoilBank
A bounded coil/discrete-input bank backed by a bit vector.
#CoilBank::contains
#CoilBank::get
#CoilBank::new
#CoilBank::read
fn CoilBank::read(self : CoilBank, address : UInt16, quantity : Int) -> Result[Array[Bool], ModbusError]#CoilBank::set
#CoilBank::write
fn CoilBank::write(self : CoilBank, address : UInt16, values : Array[Bool]) -> Result[Unit, ModbusError]#ConformanceResult
pub(all) struct ConformanceResult {
name : String
passed : Bool
detail : String
}A vector execution result.
#ConformanceSuite
A reusable conformance suite.
#ConformanceSuite::add
#ConformanceSuite::run
#ConformanceVector
pub(all) struct ConformanceVector {
name : String
mode : Mode
bytes : Array[Byte]
expected_function : Byte?
expected_error : ModbusError?
}A portable conformance vector for transport and frame decoders.
#ConformanceVector::invalid
fn ConformanceVector::invalid(name : String, mode : Mode, bytes : Array[Byte], expected_error : ModbusError) -> ConformanceVector#ConformanceVector::valid
fn ConformanceVector::valid(name : String, mode : Mode, bytes : Array[Byte], expected_function : Byte) -> ConformanceVector#Counter
pub(all) struct Counter {
name : String
value : Int
}A small integer counter used for protocol telemetry.
#Crc16State
pub(all) struct Crc16State {
value : UInt16
}Incremental CRC16 accumulator for serial readers.
#Device
pub struct Device {
unit_id : Byte
memory : DeviceMemory
file_store : FileRecordStore
server_id : Array[Byte]
event_count : UInt16
busy : Bool
exception_count : Int
}A protocol-level Modbus device backed by four bounded data tables.
#Device::handle
Handle a request and return a normal or exception response.
#Device::new
fn Device::new(unit_id : Byte, coil_capacity? : Int, register_capacity? : Int) -> Result[Device, ModbusError]Create a device with configurable table capacities.
#Device::serve
Handle a request while making broadcast no-response semantics explicit.
#Device::set_server_id
#DeviceHealth
pub(all) struct DeviceHealth {
unit_id : Byte
event_count : UInt16
exception_count : Int
busy : Bool
}A compact device health snapshot for dashboards and polling logs.
#DeviceIdCategory
Device-identification access category used by MEI type 0x0E.
#DeviceIdObject
pub(all) struct DeviceIdObject {
object_id : Byte
value : String
}One TLV object returned by a device-identification response.
#DeviceIdObject::new
#DeviceIdentification
pub(all) struct DeviceIdentification {
category : DeviceIdCategory
conformity : Byte
more_follows : Bool
next_object_id : Byte
objects : Array[DeviceIdObject]
}Parsed MEI device-identification response metadata.
#DeviceIdentityCatalog
pub struct DeviceIdentityCatalog {
category : DeviceIdCategory
objects : Array[DeviceIdObject]
conformity : Byte
}A reusable identity catalogue for virtual devices.
#DeviceIdentityCatalog::add
fn DeviceIdentityCatalog::add(self : DeviceIdentityCatalog, object : DeviceIdObject) -> Result[Unit, ModbusError]#DeviceIdentityCatalog::length
#DeviceIdentityCatalog::new
#DeviceIdentityCatalog::objects
#DeviceIdentityCatalog::response
fn DeviceIdentityCatalog::response(self : DeviceIdentityCatalog, request : Frame) -> Result[Frame, ModbusError]#DeviceIdentityCatalog::set_conformity
#DeviceMemory
pub(all) struct DeviceMemory {
coils : CoilBank
discrete_inputs : CoilBank
input_registers : RegisterBank
holding_registers : RegisterBank
}The four standard Modbus data tables exposed by a device.
#DeviceMemory::discrete_inputs
#DeviceMemory::holding_registers
#DeviceMemory::input_registers
#DeviceMemory::load_discrete
fn DeviceMemory::load_discrete(self : DeviceMemory, address : UInt16, values : Array[Bool]) -> Result[Unit, ModbusError]#DeviceMemory::load_holding
fn DeviceMemory::load_holding(self : DeviceMemory, address : UInt16, values : Array[UInt16]) -> Result[Unit, ModbusError]#DeviceMemory::load_input
fn DeviceMemory::load_input(self : DeviceMemory, address : UInt16, values : Array[UInt16]) -> Result[Unit, ModbusError]#DeviceMemory::new
fn DeviceMemory::new(coil_capacity? : Int, register_capacity? : Int) -> Result[DeviceMemory, ModbusError]Create a device memory map with all tables starting at address zero.
#DeviceResponse
A response returned by a virtual or embedded device service.
#EncodedAdu
An encoded ADU that can be handed to a socket or serial adapter.
#EncodedAdu::new
fn EncodedAdu::new(mode : Mode, transaction_id : UInt16, frame : Frame) -> Result[EncodedAdu, ModbusError]#EndpointConfig
A transport endpoint configuration.
#EndpointHealth
pub(all) struct EndpointHealth {
unit_id : Byte
ready : Bool
event_count : UInt16
exceptions : Int
requests : Int
responses : Int
errors : Int
}Aggregated endpoint health used by operations dashboards.
#EndpointRuntime
pub(all) struct EndpointRuntime {
config : EndpointConfig
state : EndpointState
opened_at : Int
last_error : ModbusError?
reconnects : Int
frames_in : Int
frames_out : Int
}Runtime state tracked independently from operating-system handles.
#EndpointRuntime::fail
#EndpointRuntime::last_error
#EndpointRuntime::new
#EndpointRuntime::open
#EndpointRuntime::record_in
#EndpointRuntime::record_out
#EndpointState
Lifecycle state of a transport endpoint.
#ExceptionCode
Standard exception codes returned by a Modbus server.
#ExchangeEnvelope
A transport-neutral request envelope.
#ExchangeEnvelope::new
fn ExchangeEnvelope::new(source : String, destination : String, adu : EncodedAdu) -> ExchangeEnvelope#ExchangeState
Lifecycle of a client-side exchange.
#FaultMode
Deterministic fault modes for protocol integration tests.
#FileRecordReference
pub(all) struct FileRecordReference {
reference_type : Byte
file_number : UInt16
record_number : UInt16
record_length : UInt16
}A Modbus file-record selector.
#FileRecordReference::encoded_length
#FileRecordReference::new
fn FileRecordReference::new(file_number : UInt16, record_number : UInt16, record_length : UInt16, reference_type? : Byte) -> Result[FileRecordReference, ModbusError]#FileRecordStore
A bounded in-memory store for file records used by simulators.
#FileRecordStore::get
fn FileRecordStore::get(self : FileRecordStore, reference : FileRecordReference) -> Result[Array[UInt16], ModbusError]#FileRecordStore::new
#FileRecordStore::put
fn FileRecordStore::put(self : FileRecordStore, record : FileRecordWrite) -> Result[Unit, ModbusError]#FileRecordWrite
A file-record write item combines a selector and its register payload.
#FileRecordWrite::new
fn FileRecordWrite::new(reference : FileRecordReference, values : Array[UInt16]) -> Result[FileRecordWrite, ModbusError]#Frame
A decoded frame, including the unit identifier.
#FrameSequence
A bounded ordered collection of frames for gateways and batch adapters.
#FrameSequence::encoded_bytes
#FrameSequence::filter_function
#FrameSequence::filter_unit
#FrameSequence::get
#FrameSequence::new
#FrameSequence::push
#FrameSequence::validate
fn FrameSequence::validate(self : FrameSequence, allow_broadcast : Bool) -> Result[Unit, ModbusError]#FrameStream
pub struct FrameStream {
mode : Mode
parser : IncrementalParser
queue : ByteQueue
chunks : Int
frames : Int
}A frame stream combines a byte queue with the protocol parser.
#FrameStream::new
fn FrameStream::new(mode : Mode, role? : ParserRole, max_buffer? : Int, max_frame? : Int) -> Result[FrameStream, ModbusError]#FrameStream::push
#FrameSummary
pub(all) struct FrameSummary {
unit_id : Byte
function : Byte
data_length : Int
exception : Bool
}A compact description useful for logs and metrics.
#FrameTextLog
A bounded text trace used by CLI tools and embedded diagnostics.
#FrameTextLog::new
#FrameTextLog::record
#FrameTextLog::record_wire
fn FrameTextLog::record_wire(self : FrameTextLog, direction : String, mode : Mode, transaction_id : UInt16, frame : Frame) -> Unit#FunctionCode
pub(all) enum FunctionCode {
ReadCoils
ReadDiscreteInputs
ReadHoldingRegisters
ReadInputRegisters
WriteSingleCoil
WriteSingleRegister
ReadExceptionStatus
Diagnostics
GetCommEventCounter
GetCommEventLog
ReportServerId
WriteMultipleCoils
WriteMultipleRegisters
ReportServerIdExtended
ReadFileRecord
WriteFileRecord
MaskWriteRegister
ReadWriteMultipleRegisters
ReadFifoQueue
EncapsulatedInterface
Unknown(Byte)
} derive(Eq, Debug)The function codes defined by the Modbus application protocol.
#FunctionCode::to_byte
Return the numeric representation of a typed function code.
#FunctionDescriptor
pub(all) struct FunctionDescriptor {
function : Byte
name : String
request_min : Int
request_max : Int
response_variable : Bool
writable : Bool
description : String
}Metadata used by configuration UIs and validation tools.
#FunctionDescriptor::description
#FunctionDescriptor::function
#FunctionDescriptor::is_write
#FunctionDescriptor::supports_request
#Gateway
A deterministic frame gateway that rewrites unit ids and register/coil addresses.
#Gateway::add_rule
#Gateway::reverse
Translate a response back to the source address space.
#Gateway::translate
Translate one request according to the first matching rule.
#GatewayRoute
A gateway route that combines a rule set, client, and virtual device.
#GatewayRoute::add_rule
#GatewayRoute::exchange
#GatewayRoute::new
#GatewayRule
pub(all) struct GatewayRule {
source_unit : Byte
target_unit : Byte
function : Byte
source_start : UInt16
target_start : UInt16
span : Int
enabled : Bool
}Address mapping rule for a protocol gateway.
#GatewayRule::new
fn GatewayRule::new(source_unit : Byte, target_unit : Byte, function : Byte, source_start : UInt16, target_start : UInt16, span : Int) -> Result[GatewayRule, ModbusError]#IncrementalParser
pub struct IncrementalParser {
mode : Mode
role : ParserRole
buffer : Array[Byte]
max_frame : Int
frames_seen : Int
errors_seen : Int
}A bounded incremental parser for stream transports.
#IncrementalParser::buffered
Return the number of bytes waiting in the parser.
#IncrementalParser::errors_seen
#IncrementalParser::feed
fn IncrementalParser::feed(self : IncrementalParser, input : Array[Byte]) -> Result[Array[Frame], ModbusError]Feed bytes and return every complete frame currently available.
#IncrementalParser::feed_byte
fn IncrementalParser::feed_byte(self : IncrementalParser, byte : Byte) -> Result[Array[Frame], ModbusError]Feed a single byte without allocating an input array at the call site.
#IncrementalParser::finish
Finish a serial frame at an externally supplied RTU silent interval.
#IncrementalParser::frames_seen
#IncrementalParser::new
Create a stream parser. max_frame prevents unbounded input growth.
#IncrementalParser::reset
Discard buffered bytes after a transport reset.
#IncrementalParser::set_max_frame
fn IncrementalParser::set_max_frame(self : IncrementalParser, max_frame : Int) -> Result[Unit, ModbusError]Change the maximum frame size for a parser that is already in use.
#IncrementalParser::take_buffer
Take the current buffered bytes and reset the parser.
#LatencyHistogram
Fixed latency buckets, expressed in logical ticks.
#LatencyHistogram::bucket_counts
#LatencyHistogram::new
#LatencyHistogram::observe
#ModbusError
Errors produced by the protocol core and its in-memory services.
#ParserRole
The side of a stream that an incremental parser is consuming.
#Pdu
A Modbus application data unit without transport framing.
#PendingExchange
pub(all) struct PendingExchange {
transaction_id : UInt16
frame : Frame
attempts : Int
created_at : Int
last_sent_at : Int
state : ExchangeState
}A pending exchange retained for correlation and retry accounting.
#PlanSummary
pub(all) struct PlanSummary {
requests : Int
total_registers : Int
total_coils : Int
total_bytes : Int
}A request plan summary used to size queues before dispatch.
#PlannedRequest
A range request planner that splits large logical reads into legal PDUs.
#PollJob
A polling job with a deterministic logical-clock schedule.
#PollJob::mark_success
#PollJob::new
fn PollJob::new(id : Int, name : String, request : Frame, interval? : Int, timeout? : Int, retries? : Int) -> Result[PollJob, ModbusError]#PollPlan
A polling plan keeps jobs ordered and addresses them by stable ids.
#PollPlan::mark_failure
#PollPlan::mark_success
fn PollPlan::mark_success(self : PollPlan, id : Int, now : Int, response : Frame) -> Result[Unit, ModbusError]#PollPlan::run_once
Execute due jobs against a deterministic device.
#PollReport
One scheduler run result.
#PollScheduler
A scheduler that records the last report and applies a transport mode.
#PollScheduler::new
#PreflightReport
A structured preflight report for deployment and CI diagnostics.
#PreflightReport::warning_count
#PreflightReport::warnings
#ProtocolLimits
pub(all) struct ProtocolLimits {
max_adu : Int
max_pdu : Int
max_registers : Int
max_coils : Int
max_buffer : Int
}A small immutable configuration snapshot used by clients and servers.
#ProtocolMetrics
pub(all) struct ProtocolMetrics {
requests : Int
responses : Int
exceptions : Int
errors : Int
bytes_in : Int
bytes_out : Int
active : Int
latency : LatencyHistogram
}A snapshot-friendly metrics set for a protocol endpoint.
#ProtocolMetrics::record_error
#ProtocolMetrics::record_request
fn ProtocolMetrics::record_request(self : ProtocolMetrics, bytes : Int) -> Result[Unit, ModbusError]#ProtocolMetrics::record_response
fn ProtocolMetrics::record_response(self : ProtocolMetrics, bytes : Int, latency : Int, exception : Bool) -> Result[Unit, ModbusError]#ProtocolMetrics::throughput
#RegisterBank
A contiguous, bounds-checked register bank.
#RegisterBank::contains
#RegisterBank::get
#RegisterBank::new
fn RegisterBank::new(start : UInt16, length : Int, writable? : Bool) -> Result[RegisterBank, ModbusError]Create a register bank in the 16-bit address space.
#RegisterBank::read
fn RegisterBank::read(self : RegisterBank, address : UInt16, quantity : Int) -> Result[Array[UInt16], ModbusError]#RegisterBank::set
fn RegisterBank::set(self : RegisterBank, address : UInt16, value : UInt16) -> Result[Unit, ModbusError]#RegisterBank::write
fn RegisterBank::write(self : RegisterBank, address : UInt16, values : Array[UInt16]) -> Result[Unit, ModbusError]#RegisterBank::write_mask
fn RegisterBank::write_mask(self : RegisterBank, address : UInt16, and_mask : UInt16, or_mask : UInt16) -> Result[UInt16, ModbusError]#RegisterByteOrder
Register byte order used when mapping multi-register values.
#RegisterCursor
A bounds-checked cursor over an owned register array.
#RegisterCursor::read_f32
fn RegisterCursor::read_f32(self : RegisterCursor, order : RegisterWordOrder) -> Result[Float, ModbusError]#RegisterCursor::read_i16
#RegisterCursor::read_i32
fn RegisterCursor::read_i32(self : RegisterCursor, order : RegisterWordOrder) -> Result[Int, ModbusError]#RegisterCursor::read_u16
#RegisterCursor::read_u32
fn RegisterCursor::read_u32(self : RegisterCursor, order : RegisterWordOrder) -> Result[UInt, ModbusError]#RegisterCursor::read_u64
fn RegisterCursor::read_u64(self : RegisterCursor, order : RegisterWordOrder) -> Result[UInt64, ModbusError]#RegisterCursor::seek
#RegisterCursor::skip
#RegisterField
pub(all) struct RegisterField {
name : String
address : UInt16
kind : RegisterFieldKind
writable : Bool
scale : Float
}A named register field with an explicit wire representation.
#RegisterField::new
fn RegisterField::new(name : String, address : UInt16, kind : RegisterFieldKind, writable? : Bool, scale? : Float) -> Result[RegisterField, ModbusError]#RegisterFieldKind
Typed interpretation for a register-backed device schema.
#RegisterSchema
A schema with unique named fields and no overlapping wire ranges.
#RegisterSchema::add
#RegisterSchema::field
#RegisterSchema::fields
#RegisterSchema::new
#RegisterSchema::read
fn RegisterSchema::read(self : RegisterSchema, name : String, bank : RegisterBank) -> Result[RegisterValue, ModbusError]Decode one schema field from a register bank.
#RegisterSchema::read_all
fn RegisterSchema::read_all(self : RegisterSchema, bank : RegisterBank) -> Result[Array[(String, RegisterValue)], ModbusError]Return the values of every field that fits in a bank snapshot.
#RegisterSchema::validate_against
fn RegisterSchema::validate_against(self : RegisterSchema, bank : RegisterBank) -> Result[Unit, ModbusError]Validate a schema against a register bank before starting a service.
#RegisterSchema::write
fn RegisterSchema::write(self : RegisterSchema, name : String, value : RegisterValue, bank : RegisterBank) -> Result[Unit, ModbusError]Encode a typed value and write it to a schema field.
#RegisterValue
pub(all) enum RegisterValue {
U16(UInt16)
I16(Int)
U32(UInt)
I32(Int)
F32(Float)
U64(UInt64)
Bits(Array[Bool])
}A value returned by schema-aware reads.
#RegisterWordOrder
Word order used for values wider than one register.
#RegisterWriter
A register writer that grows only up to a configured capacity.
#RegisterWriter::new
#RegisterWriter::push
#RegisterWriter::push_f32
fn RegisterWriter::push_f32(self : RegisterWriter, value : Float, order : RegisterWordOrder) -> Result[Unit, ModbusError]#RegisterWriter::push_i16
#RegisterWriter::push_u32
fn RegisterWriter::push_u32(self : RegisterWriter, value : UInt, order : RegisterWordOrder) -> Result[Unit, ModbusError]#RegisterWriter::push_u64
fn RegisterWriter::push_u64(self : RegisterWriter, value : UInt64, order : RegisterWordOrder) -> Result[Unit, ModbusError]#ResponseValue
A raw PDU result that retains whether a response was an exception.
#Scenario
A deterministic multi-request scenario.
#Scenario::run
#SerialConfig
pub(all) struct SerialConfig {
path : String
baud : Int
data_bits : Int
stop_bits : Int
parity : Byte
mode : Mode
}Serial-line parameters independent of any concrete serial-port library.
#SerialConfig::new
fn SerialConfig::new(path : String, baud : Int, mode : Mode, data_bits? : Int, stop_bits? : Int, parity? : Byte) -> Result[SerialConfig, ModbusError]#Server
pub struct Server {
config : ServerConfig
devices : Array[Device]
parser : IncrementalParser
metrics : ProtocolMetrics
audit : AuditLog
}A multi-unit server that owns device instances and performs transport framing.
#Server::add_device
#Server::broadcast
Run a request against every configured unit and return normal replies.
#Server::handle
Handle a decoded request and return a decoded reply.
#Server::handle_adu
Decode an ADU, dispatch it, and encode the reply.
#Server::remove_device
#ServerConfig
pub(all) struct ServerConfig {
mode : Mode
max_devices : Int
max_frame : Int
allow_broadcast : Bool
max_pending_bytes : Int
}Configuration for an in-process Modbus server.
#Simulation
pub struct Simulation {
device : Device
mode : Mode
fault : FaultMode
clock : Int
metrics : ProtocolMetrics
audit : AuditLog
}A portable protocol simulation with no operating-system I/O.
#Simulation::advance
#Simulation::new
#Simulation::request
fn Simulation::request(self : Simulation, transaction_id : UInt16, request : Frame) -> SimulationResultSend one request through the selected fault model.
#SimulationResult
Result of one deterministic simulation step.
#TcpConfig
pub(all) struct TcpConfig {
host : String
port : Int
connect_timeout : Int
keep_alive : Bool
}#TelemetryRing
A bounded ring of integer telemetry samples for device dashboards.
#TelemetryRing::at
Read a sample from oldest to newest order.
#TelemetryRing::delta
#TelemetryRing::latest
#TelemetryRing::maximum
#TelemetryRing::minimum
#TelemetryRing::new
#TelemetryRing::previous
#TelemetryRing::record
Add a sample and overwrite the oldest sample when the ring is full.
#Threshold
pub(all) struct Threshold {
low : Int
high : Int
}A closed interval used for a device alarm threshold.
#TransactionFrame
A request/response pair associated with a TCP transaction identifier.
#TransactionFrame::complete
#TransactionFrame::is_complete
#TransactionFrame::new
#TransportCapabilities
pub(all) struct TransportCapabilities {
mode : Mode
max_adu : Int
supports_broadcast : Bool
preserves_transaction_id : Bool
}A transport capability report for startup diagnostics.
#TransportKind
Named transport choices used by adapters.
#VirtualLink
A deterministic in-memory transport used by tests, demos, and simulators.
#VirtualLink::new
#VirtualLink::receive_request
#VirtualLink::receive_response
#VirtualLink::round_trip
fn VirtualLink::round_trip(self : VirtualLink, device : Device, transaction_id : UInt16, request : Frame) -> Result[DeviceResponse, ModbusError]Execute one request against a device and enqueue its response.
#VirtualLink::send_request
fn VirtualLink::send_request(self : VirtualLink, transaction_id : UInt16, frame : Frame) -> Result[Unit, ModbusError]#VirtualLink::send_response
fn VirtualLink::send_response(self : VirtualLink, transaction_id : UInt16, frame : Frame) -> Result[Unit, ModbusError]#address_bytes
Make the two-byte address representation used by request builders.
#append_u16_be
Append a big-endian unsigned 16-bit value.
#append_u32_be
Append a big-endian unsigned 32-bit value.
#ascii_boundary
Return a complete ASCII frame boundary if CRLF is present.
#base_function
Return the function number without the exception bit.
#batch_register_values
Merge successful register responses from a batch into one ordered array.
#benchmark_crc
Run repeated CRC work over a representative RTU payload.
#benchmark_device_reads
Run a device read workload over the in-memory server path.
#benchmark_rtu_round_trip
Run encode/decode round trips for the RTU transport.
#benchmark_suite
Run the standard local benchmark suite.
#benchmark_tcp_round_trip
Run encode/decode round trips for the TCP transport.
#boundary_vectors
Generate boundary vectors for empty, short, and corrupt inputs.
#bytes_to_hex_string
Convert a byte array to a printable uppercase hexadecimal string.
#bytes_to_register
fn bytes_to_register(bytes : Array[Byte], offset : Int, order : RegisterByteOrder) -> Result[UInt16, ModbusError]Decode two bytes as one register.
#bytes_to_registers
fn bytes_to_registers(bytes : Array[Byte], order : RegisterByteOrder) -> Result[Array[UInt16], ModbusError]Convert an even-length byte array to registers.
#chunk_bytes
Split a byte array into bounded chunks for transport fuzzing and tests.
#copy_bytes
Make an owned byte-array copy. Protocol parsers use this to avoid retaining views.
#copy_range
Copy a half-open range and return a protocol error when the range is invalid.
#count_bits
Count the set bits in a packed byte array.
#crc16
Modbus polynomial CRC16, low byte first on the wire.
#crc16_range
Compute CRC16 for a half-open range without allocating a slice.
#crc16_update
fn crc16_update(crc : UInt16, byte : Byte) -> UInt16Update a CRC16 accumulator with one byte.
#crc_bytes
Return CRC bytes in Modbus RTU order.
#decode_ascii
Decode one complete Modbus ASCII frame.
#decode_bits_response
Decode a read-coils or read-discrete-inputs response.
#decode_comm_event_counter
fn decode_comm_event_counter(request : Frame, response : Frame) -> Result[(UInt16, UInt16), ModbusError]Decode the communication event counter response.
#decode_device_identification
fn decode_device_identification(request : Frame, response : Frame) -> Result[DeviceIdentification, ModbusError]Decode a Read Device Identification response into TLV objects.
#decode_diagnostics
fn decode_diagnostics(request : Frame, response : Frame) -> Result[(UInt16, Array[Byte]), ModbusError]Decode the two-byte diagnostics subfunction and its data.
#decode_exception_status
Decode an exception-status response.
#decode_fifo_queue
Decode a FIFO response into the queue values.
#decode_file_record_response
fn decode_file_record_response(request : Frame, response : Frame) -> Result[Array[Array[UInt16]], ModbusError]Decode the values returned for a Read File Record response.
#decode_file_record_write_response
fn decode_file_record_write_response(request : Frame, response : Frame) -> Result[Unit, ModbusError]Decode the echo of a Write File Record response.
#decode_hex
Decode an even-length hexadecimal ASCII array.
#decode_mask_write
Decode a mask-write response and return (and_mask, or_mask).
#decode_mode
Decode a complete frame when the transport does not carry a TCP transaction id.
#decode_multiple_write
fn decode_multiple_write(request : Frame, response : Frame) -> Result[(UInt16, UInt16), ModbusError]Decode a multiple-write echo and return (address, quantity).
#decode_read_write_response
fn decode_read_write_response(request : Frame, response : Frame) -> Result[Array[UInt16], ModbusError]Decode the register payload of a combined read/write response.
#decode_register_response
fn decode_register_response(request : Frame, response : Frame) -> Result[Array[UInt16], ModbusError]Decode a function 03 or 04 register response.
#decode_response
Decode any response while preserving exception information.
#decode_rtu
Decode one complete Modbus RTU frame.
#decode_server_id
Decode a Report Server ID response into its raw payload.
#decode_tcp
Decode one complete Modbus TCP ADU and return its transaction id.
#decode_transaction
Decode an encoded frame and preserve a TCP transaction identifier when present.
#decode_write_single_coil
Decode a single-coil echo and return its logical value.
#decode_write_single_register
Decode a single-register write echo.
#diagnostics
fn diagnostics(unit_id : Byte, subfunction : UInt16, data : Array[Byte]) -> Result[Frame, ModbusError]Build a diagnostics request (function 08).
#diagnostics_return_query_data
Build the common Return Query Data diagnostics request.
#encapsulated_interface
fn encapsulated_interface(unit_id : Byte, mei_type : Byte, payload : Array[Byte]) -> Result[Frame, ModbusError]Build a generic encapsulated-interface request (function 43).
#encode_ascii
Encode a frame as Modbus ASCII, including : prefix and CRLF suffix.
#encode_device_identification
fn encode_device_identification(unit_id : Byte, category : DeviceIdCategory, conformity : Byte, more_follows : Bool, next_object_id : Byte, objects : Array[DeviceIdObject]) -> Result[Frame, ModbusError]Encode an identification response from typed objects.
#encode_hex
Encode an owned byte array as uppercase hexadecimal ASCII.
#encode_mode
Encode a frame for a mode; TCP uses transaction id zero for this convenience API.
#encode_tcp
Encode a frame as Modbus TCP, using a caller-provided transaction id.
#encoded_length
Return the encoded size of a frame on a transport.
#endpoint_health
#endpoint_health_summary
Summarize health in stable key/value form for a CLI or metrics exporter.
#endpoint_score
Return a score in [0, 100] suitable for a small status indicator.
#error_name
Convert a protocol error to a stable diagnostic name.
#error_response
Construct an exception from a protocol error.
#exception_from_frame
Decode the exception code from a standard exception response.
#exception_response
Build a standard Modbus exception response.
#expected_response_function
Return the expected response function byte for a request.
#expected_tcp_length
Return the expected TCP ADU size from a partial header.
#f32_to_registers
Encode a Float in IEEE-754 binary32 form as two registers.
#fits_mode_limit
Return whether a frame can be represented by a mode's ADU limit.
#fits_queue_budget
Check that an entire sequence stays below a caller's queue budget.
#fleet_score
Compute an overall score for a fleet of devices.
#float_words
fn float_words(high : UInt16, low : UInt16) -> UInt64Decode two registers as the raw IEEE-754 single precision words.
#format_error
Produce a one-line protocol error for a CLI diagnostic.
#format_frame
Format a complete frame for logs without exposing transport framing.
#format_wire_frame
Format a frame with its RTU, ASCII, or TCP wire representation.
#frame_budget_available
#frame_count_for_coils
Calculate the number of frames needed for a logical coil read.
#frame_count_for_registers
Calculate the number of frames needed for a logical register read.
#frames_equal
Compare frames at the logical PDU level.
#function_catalog
Return every descriptor in numeric order.
#function_code
Convert a function code byte into the typed function-code vocabulary.
#function_name
fn function_name(function : Byte) -> StringHuman-readable function-code name used by diagnostic output.
#gateway_function_supported
fn gateway_function_supported(function : Byte) -> BoolReturn whether a gateway rule can safely carry a function code.
#get_bit
Read a single bit from a packed byte array.
#get_comm_event_counter
Build a request for the communication event counter (function 11).
#get_comm_event_log
Build a request for the communication event log (function 12).
#hex_string_to_bytes
Convert a string containing hexadecimal digits and optional whitespace to bytes.
#i32_to_registers
Encode a signed 32-bit value using two's-complement bits.
#is_broadcast
fn is_broadcast(unit_id : Byte) -> BoolTrue when the frame uses the serial-line broadcast address.
#is_retryable
Return whether an error is recoverable by a retry policy.
#is_valid_unit_id
fn is_valid_unit_id(unit_id : Byte, broadcast? : Bool) -> BoolTrue for a legal serial-line unit identifier, including broadcast.
#is_write_echo
Check an ordinary write response without decoding its fields.
#join_chunks
Reassemble byte chunks and check their total size.
#least_healthy
Return the least healthy endpoint, if any.
#lrc_from_sum
fn lrc_from_sum(sum : Byte) -> ByteCompute the LRC from a running sum, using the Modbus two's-complement rule.
#lrc_with_sum
Return both the LRC and the modulo-256 sum for diagnostics.
#mask_write_register
fn mask_write_register(unit_id : Byte, address : UInt16, and_mask : UInt16, or_mask : UInt16) -> Result[Frame, ModbusError]Build a mask-write-register request (function 22).
#max_request_adu
Return a conservative maximum request size for a function and mode.
#minimum_frame_length
Calculate how many bytes are needed for the shortest frame of a mode.
#mode_name
Return the stable display name of a transport mode.
#mode_payload_capacity
Return the number of data bytes available after transport framing.
#offset_frame_address
Add a signed address offset while preserving 16-bit bounds.
#ordinary_function
fn ordinary_function(function : Byte) -> ByteReturn the ordinary function code for an exception response.
#pack_bits
Pack boolean values into Modbus LSB-first coil bytes.
#parse_hex_byte
Convert one ASCII hex byte into a binary byte.
#parse_wire_frame
Parse a wire representation in the selected mode.
#parser_load
Return the number of bytes currently held across parser metrics.
#pdu_bytes
Return the PDU bytes following the unit identifier.
#plan_read_coils
fn plan_read_coils(unit_id : Byte, address : UInt16, quantity : Int, discrete? : Bool) -> Result[Array[PlannedRequest], ModbusError]#plan_read_registers
fn plan_read_registers(unit_id : Byte, address : UInt16, quantity : Int, function? : Byte) -> Result[Array[PlannedRequest], ModbusError]#plan_write_registers
fn plan_write_registers(unit_id : Byte, address : UInt16, values : Array[UInt16]) -> Result[Array[PlannedRequest], ModbusError]Plan a write block, respecting the protocol's maximum register quantity.
#preflight_device
Check a device's table capacities and unit id.
#preflight_frame
Check a frame's unit, PDU shape, and transport envelope constraints.
#preflight_plan
Check every job in a polling plan.
#preflight_server
Validate a complete server configuration and its registered devices.
#preflight_summary
Return a compact result line for CI logs.
#quantity_bytes_checked
Make a quantity representation used by request builders.
#read_coils
Build a read-coils request (function 01).
#read_device_identification
fn read_device_identification(unit_id : Byte, category : DeviceIdCategory, object_id : Byte) -> Result[Frame, ModbusError]Build a Read Device Identification request.
#read_discrete_inputs
fn read_discrete_inputs(unit_id : Byte, address : UInt16, quantity : UInt16) -> Result[Frame, ModbusError]Build a read-discrete-inputs request (function 02).
#read_exception_status
Build a request for the exception status byte (function 07).
#read_fifo_queue
Build a Read FIFO Queue request (function 24).
#read_file_record
fn read_file_record(unit_id : Byte, references : Array[FileRecordReference]) -> Result[Frame, ModbusError]Build a Read File Record request (function 20).
#read_holding
A request for reading holding registers (function 03).
#read_holding_checked
fn read_holding_checked(unit_id : Byte, address : UInt16, quantity : UInt16) -> Result[Frame, ModbusError]Checked variant of read_holding for application code.
#read_holding_registers
fn read_holding_registers(unit_id : Byte, address : UInt16, quantity : UInt16) -> Result[Frame, ModbusError]Build a read-holding-registers request (function 03).
#read_input_registers
fn read_input_registers(unit_id : Byte, address : UInt16, quantity : UInt16) -> Result[Frame, ModbusError]Build a read-input-registers request (function 04).
#read_quantity_limit
fn read_quantity_limit(function : Byte) -> IntReturn the maximum legal request quantity for a read function.
#read_u16_be
Read a big-endian unsigned 16-bit value from a byte array.
#read_u32_be
Read a big-endian unsigned 32-bit value using MoonBit's platform unsigned type.
#read_write_multiple_registers
fn read_write_multiple_registers(unit_id : Byte, read_address : UInt16, read_quantity : UInt16, write_address : UInt16, write_values : Array[UInt16]) -> Result[Frame, ModbusError]Build a combined read/write-multiple-registers request (function 23).
#recommended_parser_role
Return the recommended parser role for a function family.
#register_to_bytes
Convert one register to two bytes in the requested byte order.
#register_value_name
Render a typed value as a compact diagnostic string.
#registers
Decode the data portion of a register-oriented frame without a byte count.
#registers_to_bytes
Convert an array of registers to bytes with a selected byte order.
#registers_to_f32
fn registers_to_f32(values : Array[UInt16], word_order : RegisterWordOrder) -> Result[Float, ModbusError]Decode two registers as an IEEE-754 binary32 Float.
#registers_to_i32
fn registers_to_i32(values : Array[UInt16], word_order : RegisterWordOrder) -> Result[Int, ModbusError]Decode a signed 32-bit value from two registers.
#registers_to_u32
fn registers_to_u32(values : Array[UInt16], word_order : RegisterWordOrder) -> Result[UInt, ModbusError]Decode two registers as an unsigned 32-bit value.
#registers_to_u64
fn registers_to_u64(values : Array[UInt16], word_order : RegisterWordOrder) -> Result[UInt64, ModbusError]Decode four registers as a 64-bit value.
#replace_frame_unit
#report_server_id
Build a Report Server ID request (function 17).
#response_frame
Construct a response with an explicit function and owned data array.
#response_quality
Return a short response quality classification for metrics.
#reverse_registers
Reverse register order in a copied array.
#round_trip_all_modes
Run the same frame through every transport codec.
#round_trip_vectors
Build protocol vectors from a known request in all three transports.
#rtu_mode
Standard constructors kept as named entry points for configuration files.
#rtu_payload
Return the RTU payload before its two-byte CRC.
#set_bit
Set a single bit in a packed byte array.
#signed_register
fn signed_register(value : UInt16) -> IntDecode a signed 16-bit register using two's-complement representation.
#simulation_successes
Count successful deliveries in a scenario result.
#supported_function
fn supported_function(function : Byte) -> BoolCheck that a function code is in the supported public subset.
#swap_register_bytes
Rotate bytes inside every register, useful for devices with byte-swapped words.
#try_encode_ascii
Checked ASCII encoder.
#try_encode_mode
fn try_encode_mode(mode : Mode, transaction_id : UInt16, frame : Frame) -> Result[Array[Byte], ModbusError]Checked transport encoder with an explicit TCP transaction id.
#try_encode_rtu
Checked RTU encoder for code that wants validation errors instead of a raw frame.
#try_encode_tcp
Checked TCP encoder.
#typed_exception_response
Build a typed exception response.
#u32_to_registers
Encode an unsigned 32-bit value into two registers.
#u64_to_registers
Encode a 64-bit value into four registers.
#unpack_bits
Unpack exactly quantity coil values from LSB-first bytes.
#valid_address_range
fn valid_address_range(address : UInt16, quantity : Int) -> BoolCheck whether an address/count pair fits in the 16-bit Modbus address space.
#validate_catalog_request
Validate a request against the catalog before invoking a builder.
#validate_endpoint_health
Validate that endpoint counters are internally consistent.
#validate_frame
Validate a complete logical frame before encoding it on any transport.
#validate_mode_payload
#validate_pdu
Validate a request PDU's byte-level shape and protocol limits.
#validate_plan_order
Validate that planned ranges are ordered and non-overlapping.
#validate_poll_plan
Validate plan timing invariants before deployment.
#validate_response_header
Validate the common unit/function relationship of a response.
#validate_server_config
#validate_unit
Validate a unit identifier for a request.
#validate_wire_frame
Validate a frame for wire encoding without assuming request-only payload shapes.
#validate_write_shape
Check whether a write payload is legal before allocating its data array.
#variable_response_function_names
Return the names of all functions whose response contains a byte count.
#verify_crc16
Verify a CRC16 trailer in low-byte-first wire order.
#verify_lrc
Verify an LRC trailer at the end of a byte array.
#with_data
Return a copy of a frame with a different data payload.
#with_function
Return a copy of a frame with a different function code.
#with_unit
Return a copy of a frame with a different unit identifier.
#writable_function_names
Return the names of all writable functions.
#write_file_record
fn write_file_record(unit_id : Byte, records : Array[FileRecordWrite]) -> Result[Frame, ModbusError]Build a Write File Record request (function 21).
#write_multiple_coils
fn write_multiple_coils(unit_id : Byte, address : UInt16, values : Array[Bool]) -> Result[Frame, ModbusError]Build a write-multiple-coils request (function 15).
#write_multiple_registers
fn write_multiple_registers(unit_id : Byte, address : UInt16, values : Array[UInt16]) -> Result[Frame, ModbusError]Build a write-multiple-registers request (function 16).
#write_quantity_limit
fn write_quantity_limit(function : Byte) -> IntReturn the maximum legal write quantity for a write-multiple function.
#write_single_coil
Build a write-single-coil request (function 05).
#write_single_register
A request for writing one holding register (function 06).
#write_single_register_checked
fn write_single_register_checked(unit_id : Byte, address : UInt16, value : UInt16) -> Result[Frame, ModbusError]Build a write-single-register request (function 06) with validation.
Source Files
- address_space.mbt
- api_helpers.mbt
- banks.mbt
- batch.mbt
- benchmark_core.mbt
- checksum.mbt
- client.mbt
- codec.mbt
- coils.mbt
- conformance.mbt
- device.mbt
- endpoint.mbt
- file_device.mbt
- file_records.mbt
- frame_text.mbt
- function_catalog.mbt
- functions.mbt
- gateway.mbt
- identification.mbt
- limits.mbt
- metrics.mbt
- parser.mbt
- policies.mbt
- polling.mbt
- preflight.mbt
- quality.mbt
- register_codec.mbt
- register_schema.mbt
- request_planner.mbt
- responses.mbt
- server_pool.mbt
- simulation.mbt
- small_helpers.mbt
- stream.mbt
- telemetry.mbt
- transport.mbt
- types.mbt
- validation.mbt
A portable Modbus RTU, ASCII, and TCP protocol stack with device simulation and gateway primitives for MoonBit.
modbusindustrialprotocolrtuasciitcpplc
0.2.0
Apache-2.0
Updated 2 hours ago
2 downloads