🥮 mooncakes.io
    Sign in

    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
    Download zip
    Version
    0.2.2
    License
    Apache-2.0
    Repository
    Last updated
    last month
    Downloads
    28

    #moonbit-modbus

    moonbit-modbus 是一个面向工业设备接入的 MoonBit Modbus 协议栈。它把 PDU、RTU、ASCII 和 TCP MBAP 统一到同一套类型安全 API，并提供设备内存、客户端事务、轮询、网关和虚拟链路等可组合模块，适合 PLC、变频器、仪表、数据采集器和协议测试工具。

    #核心能力

    • 协议编解码：Modbus RTU、ASCII、TCP，CRC16、LRC、MBAP 事务标识和异常响应。
    • 功能码覆盖：线圈、离散输入、保持寄存器、输入寄存器的读写，以及掩码写、读写组合、诊断、事件计数器、文件记录、设备识别和 FIFO。
    • 流式处理：有界增量解析器支持分段输入、多帧输入和坏帧恢复，避免无界缓存。
    • 设备与内存：寄存器/线圈 bank、地址空间、schema、文件记录存储、设备状态和异常统计。
    • 应用层服务：设备 profile、缩放校准、质量管线、告警引擎、历史聚合、维护工单、设备库存和快照对账。
    • 集成组件：客户端重试与超时、请求规划、轮询分组合并、命令中心、事务批处理、网关策略、租约和事件总线。
    • 运行保障：协议准入防护、容量账本、可靠性熔断、确定性故障场景、健康汇总、指标导出和配置迁移回滚。
    • 工程质量：无第三方运行时依赖，支持 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/bench

    cmd/bench 输出确定性的迭代次数、成功数、失败数和处理字节数；独立的端到端命令耗时记录在 BENCHMARK.md。

    #架构

    代码按协议边界拆分为几个层次：

    1. types.mbt、validation.mbt 和 limits.mbt 定义公共类型、功能码、异常码和边界规则。
    2. codec.mbt、checksum.mbt、parser.mbt 和 frame_text.mbt 负责 PDU/ADU 编解码、校验和流式解析。
    3. functions.mbt、responses.mbt、coils.mbt、register_codec.mbt 和 file_records.mbt 提供功能码与数据表示。
    4. banks.mbt、device.mbt、register_schema.mbt 和 address_space.mbt 组成可测试的设备内存层。
    5. client.mbt、transport.mbt、polling.mbt、poll_groups.mbt、gateway.mbt、gateway_policy.mbt、server_pool.mbt 和 simulation.mbt 提供系统集成能力。
    6. profiles.mbt、scaling.mbt、quality_pipeline.mbt、alarms.mbt、historian.mbt、maintenance.mbt、device_inventory.mbt 和 device_services.mbt 提供设备应用层能力。
    7. commands.mbt、transaction_batch.mbt、scheduler.mbt、lease_manager.mbt、event_bus.mbt、protocol_guard.mbt 和 capacity.mbt 负责控制面编排与资源边界。
    8. reliability.mbt、analytics.mbt、fleet_health.mbt、observability.mbt、transport_metrics.mbt、scenarios.mbt、data_migration.mbt 和 frame_contracts.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 应用协议与串行链路规范重新实现，源码和测试夹具均保留在本仓库中。

    AccessOperation

    source
    pub(all) enum AccessOperation {
      ReadOperation
      WriteOperation
      DiagnosticsOperation
      IdentificationOperation
    } derive(Eq, 
    Debug    )

    High-level operation guarded by an access policy.

    AccessPolicy

    source
    pub(all) struct AccessPolicy {
      rules : Array[AccessRule]
      max_rules : Int
      default_allow : Bool
    }

    A first-match access policy with an explicit default decision.

    AccessPolicy::add

    source
    fn AccessPolicy::add(self : AccessPolicy, rule : AccessRule) -> Result[Unit, ModbusError]

    AccessPolicy::allows

    source
    fn AccessPolicy::allows(self : AccessPolicy, role : AccessRole, operation : AccessOperation, frame : Frame) -> Bool

    AccessPolicy::decision

    source
    fn AccessPolicy::decision(self : AccessPolicy, role : AccessRole, operation : AccessOperation, frame : Frame) -> Result[Unit, ModbusError]

    AccessPolicy::length

    source
    fn AccessPolicy::length(self : AccessPolicy) -> Int

    AccessPolicy::new

    source
    fn AccessPolicy::new(default_allow? : Bool, max_rules? : Int) -> Result[AccessPolicy, ModbusError]

    AccessPolicy::remove

    source
    fn AccessPolicy::remove(self : AccessPolicy, name : String) -> Result[AccessRule, ModbusError]

    AccessPolicy::rules

    source

    AccessPolicy::set_default

    source
    fn AccessPolicy::set_default(self : AccessPolicy, allow : Bool) -> Unit

    AccessPolicy::summary

    source
    fn AccessPolicy::summary(self : AccessPolicy) -> String

    AccessRole

    source
    pub(all) enum AccessRole {
      Observer
      Operator
      Engineer
      Administrator
    } derive(Eq, 
    Debug    )

    Role used by a deployment policy.

    AccessRule

    source
    pub(all) struct AccessRule {
      name : String
      role : AccessRole
      operation : AccessOperation
      unit_start : Byte
      unit_end : Byte
      functions : Array[Byte]
      enabled : Bool
    }

    A rule matching unit ids and function codes.

    AccessRule::enabled

    source
    fn AccessRule::enabled(self : AccessRule) -> Bool

    AccessRule::matches

    source
    fn AccessRule::matches(self : AccessRule, role : AccessRole, operation : AccessOperation, frame : Frame) -> Bool

    AccessRule::name

    source
    fn AccessRule::name(self : AccessRule) -> String

    AccessRule::new

    source
    fn AccessRule::new(name : String, role : AccessRole, operation : AccessOperation, unit_start : Byte, unit_end : Byte, functions : Array[Byte]) -> Result[AccessRule, ModbusError]

    AccessRule::operation

    source
    fn AccessRule::operation(self : AccessRule) -> AccessOperation

    AccessRule::role

    source
    fn AccessRule::role(self : AccessRule) -> AccessRole

    AccessRule::set_enabled

    source
    fn AccessRule::set_enabled(self : AccessRule, value : Bool) -> Unit

    AccessRule::summary

    source
    fn AccessRule::summary(self : AccessRule) -> String

    AddressAllocator

    source
    pub struct AddressAllocator {
      capacity : Int
      used : Array[AddressRange]
    }

    A first-fit allocator for contiguous register or coil ranges.

    AddressAllocator::allocate

    source
    fn AddressAllocator::allocate(self : AddressAllocator, length : Int) -> Result[AddressRange, ModbusError]

    AddressAllocator::free_capacity

    source
    fn AddressAllocator::free_capacity(self : AddressAllocator) -> Int

    AddressAllocator::new

    source
    fn AddressAllocator::new(capacity : Int) -> Result[AddressAllocator, ModbusError]

    AddressAllocator::release

    source
    fn AddressAllocator::release(self : AddressAllocator, range : AddressRange) -> Result[Unit, ModbusError]

    AddressAllocator::snapshot

    source

    AddressAllocator::used_capacity

    source
    fn AddressAllocator::used_capacity(self : AddressAllocator) -> Int

    AddressAllocator::used_count

    source
    fn AddressAllocator::used_count(self : AddressAllocator) -> Int

    AddressRange

    source
    pub(all) struct AddressRange {
      start : UInt16
      length : Int
    }

    A half-open address range in the Modbus 16-bit address space.

    AddressRange::contains

    source
    fn AddressRange::contains(self : AddressRange, address : UInt16) -> Bool

    AddressRange::contains_range

    source
    fn AddressRange::contains_range(self : AddressRange, other : AddressRange) -> Bool

    AddressRange::end_exclusive

    source
    fn AddressRange::end_exclusive(self : AddressRange) -> Int

    AddressRange::length

    source
    fn AddressRange::length(self : AddressRange) -> Int

    AddressRange::new

    source
    fn AddressRange::new(start : UInt16, length : Int) -> Result[AddressRange, ModbusError]

    AddressRange::offset

    source
    fn AddressRange::offset(self : AddressRange, address : UInt16) -> Result[Int, ModbusError]

    AddressRange::overlaps

    source
    fn AddressRange::overlaps(self : AddressRange, other : AddressRange) -> Bool

    AddressRange::slice

    source
    fn AddressRange::slice(self : AddressRange, offset : Int, length : Int) -> Result[AddressRange, ModbusError]

    AddressRange::split

    source
    fn AddressRange::split(self : AddressRange, segment_length : Int) -> Result[Array[AddressRange], ModbusError]

    Split a range into non-overlapping segments of at most segment_length.

    AddressRange::start

    source
    fn AddressRange::start(self : AddressRange) -> UInt16

    Aggregation

    source
    pub(all) enum Aggregation {
      LastValue
      MinimumValue
      MaximumValue
      SumValue
      AverageValue
      CountValue
    } derive(Eq, 
    Debug    )

    Aggregation used when reducing samples for a dashboard or export.

    AlarmCondition

    source
    pub(all) enum AlarmCondition {
      Below
      AtOrBelow
      Equal
      NotEqual
      AtOrAbove
      Above
      Outside
      Inside
    } derive(Eq, 
    Debug    )

    Comparison used by an alarm rule.

    AlarmEngine

    source
    pub(all) struct AlarmEngine {
      instances : Array[AlarmInstance]
      events : Array[AlarmEvent]
      max_events : Int
      next_sequence : Int
    }

    A bounded alarm engine suitable for a device server or polling loop.

    AlarmEngine::acknowledge

    source
    fn AlarmEngine::acknowledge(self : AlarmEngine, rule_id : String, operator : String, timestamp : Int) -> Result[AlarmEvent, ModbusError]

    AlarmEngine::active

    source

    AlarmEngine::active_count

    source
    fn AlarmEngine::active_count(self : AlarmEngine) -> Int

    AlarmEngine::add_rule

    source
    fn AlarmEngine::add_rule(self : AlarmEngine, rule : AlarmRule) -> Result[Unit, ModbusError]

    AlarmEngine::clear_events

    source
    fn AlarmEngine::clear_events(self : AlarmEngine) -> Unit

    AlarmEngine::evaluate

    source
    fn AlarmEngine::evaluate(self : AlarmEngine, point_id : String, value : Int, timestamp : Int) -> Result[Array[AlarmEvent], ModbusError]

    AlarmEngine::event_count

    source
    fn AlarmEngine::event_count(self : AlarmEngine) -> Int

    AlarmEngine::events

    source
    fn AlarmEngine::events(self : AlarmEngine) -> Array[AlarmEvent]

    AlarmEngine::events_for_point

    source
    fn AlarmEngine::events_for_point(self : AlarmEngine, point_id : String) -> Array[AlarmEvent]

    AlarmEngine::instance

    source
    fn AlarmEngine::instance(self : AlarmEngine, rule_id : String) -> AlarmInstance?

    AlarmEngine::new

    source
    fn AlarmEngine::new(max_events? : Int) -> Result[AlarmEngine, ModbusError]

    AlarmEngine::remove_rule

    source
    fn AlarmEngine::remove_rule(self : AlarmEngine, rule_id : String) -> Result[Unit, ModbusError]

    AlarmEngine::reset

    source
    fn AlarmEngine::reset(self : AlarmEngine) -> Unit

    AlarmEngine::rule_count

    source
    fn AlarmEngine::rule_count(self : AlarmEngine) -> Int

    AlarmEngine::shelve

    source
    fn AlarmEngine::shelve(self : AlarmEngine, rule_id : String, timestamp : Int) -> Result[AlarmEvent, ModbusError]

    AlarmEngine::summary

    source
    fn AlarmEngine::summary(self : AlarmEngine) -> String

    AlarmEngine::unshelve

    source
    fn AlarmEngine::unshelve(self : AlarmEngine, rule_id : String, timestamp : Int) -> Result[AlarmEvent, ModbusError]

    AlarmEvent

    source
    pub(all) struct AlarmEvent {
      sequence : Int
      rule_id : String
      point_id : String
      state : AlarmState
      value : Int
      timestamp : Int
      severity : AlarmSeverity
      message : String
    } derive(
    Debug    )

    An event emitted when an alarm lifecycle changes.

    AlarmEvent::message

    source
    fn AlarmEvent::message(self : AlarmEvent) -> String

    AlarmEvent::point_id

    source
    fn AlarmEvent::point_id(self : AlarmEvent) -> String

    AlarmEvent::rule_id

    source
    fn AlarmEvent::rule_id(self : AlarmEvent) -> String

    AlarmEvent::sequence

    source
    fn AlarmEvent::sequence(self : AlarmEvent) -> Int

    AlarmEvent::severity

    source
    fn AlarmEvent::severity(self : AlarmEvent) -> AlarmSeverity

    AlarmEvent::state

    source
    fn AlarmEvent::state(self : AlarmEvent) -> AlarmState

    AlarmEvent::summary

    source
    fn AlarmEvent::summary(self : AlarmEvent) -> String

    AlarmEvent::timestamp

    source
    fn AlarmEvent::timestamp(self : AlarmEvent) -> Int

    AlarmEvent::value

    source
    fn AlarmEvent::value(self : AlarmEvent) -> Int

    AlarmInstance

    source
    pub(all) struct AlarmInstance {
      rule : AlarmRule
      state : AlarmState
      pending_since : Int?
      clearing_since : Int?
      last_value : Int
      last_timestamp : Int
      transitions : Int
      acknowledger : String?
    }

    Internal state retained for one rule.

    AlarmInstance::acknowledge

    source
    fn AlarmInstance::acknowledge(self : AlarmInstance, operator : String) -> Result[Unit, ModbusError]

    AlarmInstance::acknowledger

    source
    fn AlarmInstance::acknowledger(self : AlarmInstance) -> String?

    AlarmInstance::evaluate

    source
    fn AlarmInstance::evaluate(self : AlarmInstance, value : Int, timestamp : Int, sequence : Int) -> AlarmTransition

    Evaluate one new sample and update the instance lifecycle.

    AlarmInstance::id

    source
    fn AlarmInstance::id(self : AlarmInstance) -> String

    AlarmInstance::is_active

    source
    fn AlarmInstance::is_active(self : AlarmInstance) -> Bool

    AlarmInstance::last_timestamp

    source
    fn AlarmInstance::last_timestamp(self : AlarmInstance) -> Int

    AlarmInstance::last_value

    source
    fn AlarmInstance::last_value(self : AlarmInstance) -> Int

    AlarmInstance::new

    source

    AlarmInstance::point_id

    source
    fn AlarmInstance::point_id(self : AlarmInstance) -> String

    AlarmInstance::rule

    source

    AlarmInstance::shelve

    source
    fn AlarmInstance::shelve(self : AlarmInstance) -> Result[Unit, ModbusError]

    AlarmInstance::state

    source

    AlarmInstance::transitions

    source
    fn AlarmInstance::transitions(self : AlarmInstance) -> Int

    AlarmInstance::unshelve

    source
    fn AlarmInstance::unshelve(self : AlarmInstance) -> Unit

    AlarmMonitor

    source
    pub(all) struct AlarmMonitor {
      threshold : Threshold
      state : ThresholdState
      transitions : Int
      last_value : Int?
    }

    Stateful threshold monitor that counts state transitions.

    AlarmMonitor::last_value

    source
    fn AlarmMonitor::last_value(self : AlarmMonitor) -> Int?

    AlarmMonitor::new

    source
    fn AlarmMonitor::new(threshold : Threshold) -> AlarmMonitor

    AlarmMonitor::observe

    source
    fn AlarmMonitor::observe(self : AlarmMonitor, value : Int) -> ThresholdState

    AlarmMonitor::reset

    source
    fn AlarmMonitor::reset(self : AlarmMonitor) -> Unit

    AlarmMonitor::state

    source

    AlarmMonitor::threshold

    source
    fn AlarmMonitor::threshold(self : AlarmMonitor) -> Threshold

    AlarmMonitor::transitions

    source
    fn AlarmMonitor::transitions(self : AlarmMonitor) -> Int

    AlarmRule

    source
    pub(all) struct AlarmRule {
      id : String
      point_id : String
      condition : AlarmCondition
      low : Int
      high : Int
      severity : AlarmSeverity
      activation_delay : Int
      clear_delay : Int
      hysteresis : Int
      enabled : Bool
    }

    A declarative threshold rule attached to a profile point.

    AlarmRule::activation_delay

    source
    fn AlarmRule::activation_delay(self : AlarmRule) -> Int

    AlarmRule::clear_delay

    source
    fn AlarmRule::clear_delay(self : AlarmRule) -> Int

    AlarmRule::clear_matches

    source
    fn AlarmRule::clear_matches(self : AlarmRule, value : Int) -> Bool

    AlarmRule::condition

    source
    fn AlarmRule::condition(self : AlarmRule) -> AlarmCondition

    AlarmRule::enabled

    source
    fn AlarmRule::enabled(self : AlarmRule) -> Bool

    AlarmRule::high

    source
    fn AlarmRule::high(self : AlarmRule) -> Int

    AlarmRule::hysteresis

    source
    fn AlarmRule::hysteresis(self : AlarmRule) -> Int

    AlarmRule::id

    source
    fn AlarmRule::id(self : AlarmRule) -> String

    AlarmRule::low

    source
    fn AlarmRule::low(self : AlarmRule) -> Int

    AlarmRule::matches

    source
    fn AlarmRule::matches(self : AlarmRule, value : Int) -> Bool

    AlarmRule::new

    source
    fn AlarmRule::new(id : String, point_id : String, condition : AlarmCondition, low : Int, high : Int, severity : AlarmSeverity, activation_delay? : Int, clear_delay? : Int, hysteresis? : Int) -> Result[AlarmRule, ModbusError]

    AlarmRule::point_id

    source
    fn AlarmRule::point_id(self : AlarmRule) -> String

    AlarmRule::set_enabled

    source
    fn AlarmRule::set_enabled(self : AlarmRule, enabled : Bool) -> Unit

    AlarmRule::severity

    source
    fn AlarmRule::severity(self : AlarmRule) -> AlarmSeverity

    AlarmRule::summary

    source
    fn AlarmRule::summary(self : AlarmRule) -> String

    AlarmSeverity

    source
    pub(all) enum AlarmSeverity {
      Informational
      Warning
      Critical
    } derive(Eq, 
    Debug    )

    Severity assigned to an operational alarm.

    AlarmState

    source
    pub(all) enum AlarmState {
      Normal
      Pending
      Active
      Acknowledged
      Clearing
      Shelved
    } derive(Eq, 
    Debug    )

    Lifecycle state of an alarm instance.

    AlarmTransition

    source
    pub(all) enum AlarmTransition {
      Unchanged(AlarmState)
      Changed(AlarmEvent)
    } derive(
    Debug    )

    A deterministic transition result used by polling and UI layers.

    AnalyticsReport

    source
    pub(all) struct AnalyticsReport {
      direction : TrendDirection
      average : Int
      minimum : Int
      maximum : Int
      slope : Int
      anomalies : Int
      p95 : Int
    }

    Combined trend and distribution report.

    AnalyticsReport::anomalies

    source
    fn AnalyticsReport::anomalies(self : AnalyticsReport) -> Int

    AnalyticsReport::average

    source
    fn AnalyticsReport::average(self : AnalyticsReport) -> Int

    AnalyticsReport::direction

    source

    AnalyticsReport::maximum

    source
    fn AnalyticsReport::maximum(self : AnalyticsReport) -> Int

    AnalyticsReport::minimum

    source
    fn AnalyticsReport::minimum(self : AnalyticsReport) -> Int

    AnalyticsReport::p95

    source
    fn AnalyticsReport::p95(self : AnalyticsReport) -> Int

    AnalyticsReport::slope

    source
    fn AnalyticsReport::slope(self : AnalyticsReport) -> Int

    AnalyticsRule

    source
    pub(all) struct AnalyticsRule {
      id : String
      lower : Int?
      upper : Int?
      spike_delta : Int
      flatline_delta : Int
      flatline_count : Int
    }

    A limit and deviation rule applied to a series.

    AnalyticsRule::evaluate

    source
    fn AnalyticsRule::evaluate(self : AnalyticsRule, window : AnalyticsWindow) -> Array[ValueAnomaly]

    AnalyticsRule::flatline_count

    source
    fn AnalyticsRule::flatline_count(self : AnalyticsRule) -> Int

    AnalyticsRule::flatline_delta

    source
    fn AnalyticsRule::flatline_delta(self : AnalyticsRule) -> Int

    AnalyticsRule::id

    source
    fn AnalyticsRule::id(self : AnalyticsRule) -> String

    AnalyticsRule::lower

    source
    fn AnalyticsRule::lower(self : AnalyticsRule) -> Int?

    AnalyticsRule::new

    source
    fn AnalyticsRule::new(id : String, lower? : Int, upper? : Int, spike_delta? : Int, flatline_delta? : Int, flatline_count? : Int) -> Result[AnalyticsRule, ModbusError]

    AnalyticsRule::spike_delta

    source
    fn AnalyticsRule::spike_delta(self : AnalyticsRule) -> Int

    AnalyticsRule::upper

    source
    fn AnalyticsRule::upper(self : AnalyticsRule) -> Int?

    AnalyticsSample

    source
    pub(all) struct AnalyticsSample {
      timestamp : Int
      value : Int
      quality : ReadingQuality
    }

    A timestamped value used by trend and anomaly calculations.

    AnalyticsSample::new

    source
    fn AnalyticsSample::new(timestamp : Int, value : Int, quality? : ReadingQuality) -> Result[AnalyticsSample, ModbusError]

    AnalyticsSample::quality

    source

    AnalyticsSample::timestamp

    source
    fn AnalyticsSample::timestamp(self : AnalyticsSample) -> Int

    AnalyticsSample::usable

    source
    fn AnalyticsSample::usable(self : AnalyticsSample) -> Bool

    AnalyticsSample::value

    source
    fn AnalyticsSample::value(self : AnalyticsSample) -> Int

    AnalyticsWindow

    source
    pub(all) struct AnalyticsWindow {
      id : String
      capacity : Int
      samples : Array[AnalyticsSample]
      dropped : Int
    }

    A bounded time series with deterministic order guarantees.

    AnalyticsWindow::append

    source
    fn AnalyticsWindow::append(self : AnalyticsWindow, sample : AnalyticsSample) -> Result[Unit, ModbusError]

    AnalyticsWindow::at

    source
    fn AnalyticsWindow::at(self : AnalyticsWindow, index : Int) -> Result[AnalyticsSample, ModbusError]

    AnalyticsWindow::average

    source
    fn AnalyticsWindow::average(self : AnalyticsWindow) -> Result[Int, ModbusError]

    AnalyticsWindow::capacity

    source
    fn AnalyticsWindow::capacity(self : AnalyticsWindow) -> Int

    AnalyticsWindow::direction

    source
    fn AnalyticsWindow::direction(self : AnalyticsWindow, threshold : Int) -> Result[TrendDirection, ModbusError]

    AnalyticsWindow::dropped

    source
    fn AnalyticsWindow::dropped(self : AnalyticsWindow) -> Int

    AnalyticsWindow::first

    source

    AnalyticsWindow::id

    source
    fn AnalyticsWindow::id(self : AnalyticsWindow) -> String

    AnalyticsWindow::last

    source

    AnalyticsWindow::length

    source
    fn AnalyticsWindow::length(self : AnalyticsWindow) -> Int

    AnalyticsWindow::maximum

    source
    fn AnalyticsWindow::maximum(self : AnalyticsWindow) -> Result[Int, ModbusError]

    AnalyticsWindow::minimum

    source
    fn AnalyticsWindow::minimum(self : AnalyticsWindow) -> Result[Int, ModbusError]

    AnalyticsWindow::new

    source
    fn AnalyticsWindow::new(id : String, capacity? : Int) -> Result[AnalyticsWindow, ModbusError]

    AnalyticsWindow::range

    source
    fn AnalyticsWindow::range(self : AnalyticsWindow) -> Result[Int, ModbusError]

    AnalyticsWindow::slope

    source
    fn AnalyticsWindow::slope(self : AnalyticsWindow) -> Result[Int, ModbusError]

    AnalyticsWindow::usable_values

    source
    fn AnalyticsWindow::usable_values(self : AnalyticsWindow) -> Array[Int]

    AnomalyKind

    source
    pub(all) enum AnomalyKind {
      UpperLimitAnomaly
      LowerLimitAnomaly
      SpikeAnomaly
      FlatlineAnomaly
      RateAnomaly
    } derive(Eq, 
    Debug    )

    Reason a sample was flagged by an analytics rule.

    AuditEntry

    source
    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

    source
    pub struct AuditLog {
      entries : Array[AuditEntry]
      max_entries : Int
      next_sequence : Int
    }

    AuditLog::clear

    source
    fn AuditLog::clear(self : AuditLog) -> Unit

    AuditLog::length

    source
    fn AuditLog::length(self : AuditLog) -> Int

    AuditLog::new

    source
    fn AuditLog::new(max_entries? : Int) -> Result[AuditLog, ModbusError]

    AuditLog::record

    source
    fn AuditLog::record(self : AuditLog, direction : String, mode : Mode, transaction_id : UInt16, frame : Frame, outcome : String) -> Unit

    AuditLog::snapshot

    source
    fn AuditLog::snapshot(self : AuditLog) -> Array[AuditEntry]

    BatchItem

    source
    pub(all) struct BatchItem {
      id : Int
      request : Frame
    }

    A named request in a batch operation.

    BatchItem::new

    source
    fn BatchItem::new(id : Int, request : Frame) -> Result[BatchItem, ModbusError]

    BatchPlan

    source
    pub struct BatchPlan {
      items : Array[BatchItem]
      max_items : Int
    }

    An ordered batch plan used to pipeline independent requests.

    BatchPlan::add

    source
    fn BatchPlan::add(self : BatchPlan, item : BatchItem) -> Result[Unit, ModbusError]

    BatchPlan::execute

    source
    fn BatchPlan::execute(self : BatchPlan, device : Device) -> Array[BatchResult]

    Execute an ordered plan against a deterministic device.

    BatchPlan::item

    source
    fn BatchPlan::item(self : BatchPlan, index : Int) -> Result[BatchItem, ModbusError]

    BatchPlan::length

    source
    fn BatchPlan::length(self : BatchPlan) -> Int

    BatchPlan::new

    source
    fn BatchPlan::new(max_items? : Int) -> Result[BatchPlan, ModbusError]

    BatchPlan::snapshot

    source
    fn BatchPlan::snapshot(self : BatchPlan) -> Array[BatchItem]

    BatchResult

    source
    pub(all) enum BatchResult {
      Completed(Int, Frame)
      Failed(Int, ModbusError)
    }

    The result of executing one batch item.

    BenchmarkResult

    source
    pub(all) struct BenchmarkResult {
      name : String
      iterations : Int
      successful : Int
      failed : Int
      bytes : Int
    }

    Deterministic benchmark counters emitted by the command-line benchmark.

    BenchmarkResult::operations

    source
    fn BenchmarkResult::operations(self : BenchmarkResult) -> Int

    BenchmarkResult::success_rate

    source
    fn BenchmarkResult::success_rate(self : BenchmarkResult) -> Float

    BenchmarkResult::summary

    source
    fn BenchmarkResult::summary(self : BenchmarkResult) -> String

    BitVector

    source
    pub(all) struct BitVector {
      length : Int
      storage : Array[Byte]
    }

    A mutable bounded bit vector for coils and discrete inputs.

    BitVector::bit_and

    source
    fn BitVector::bit_and(self : BitVector, other : BitVector) -> Result[BitVector, ModbusError]

    Apply a bitwise AND to two equally sized vectors.

    BitVector::byte_length

    source
    fn BitVector::byte_length(self : BitVector) -> Int

    BitVector::copy

    source
    fn BitVector::copy(self : BitVector) -> BitVector

    Copy a bit vector and keep its logical length.

    BitVector::count

    source
    fn BitVector::count(self : BitVector) -> Int

    BitVector::equal

    source
    fn BitVector::equal(self : BitVector, other : BitVector) -> Bool

    Compare two bit vectors including their logical lengths.

    BitVector::fill

    source
    fn BitVector::fill(self : BitVector, value : Bool) -> Unit

    BitVector::from_bits

    source
    fn BitVector::from_bits(values : Array[Bool]) -> BitVector

    BitVector::get

    source
    fn BitVector::get(self : BitVector, index : Int) -> Result[Bool, ModbusError]

    BitVector::length

    source
    fn BitVector::length(self : BitVector) -> Int

    BitVector::new

    source
    fn BitVector::new(length : Int) -> Result[BitVector, ModbusError]

    Create a zero-filled bit vector.

    BitVector::not

    source
    fn BitVector::not(self : BitVector) -> BitVector

    Invert all logical bits, keeping padding bits clear.

    BitVector::or

    source
    fn BitVector::or(self : BitVector, other : BitVector) -> Result[BitVector, ModbusError]

    Apply a bitwise OR to two equally sized vectors.

    BitVector::pack_range

    source
    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

    source
    fn BitVector::set(self : BitVector, index : Int, value : Bool) -> Result[Unit, ModbusError]

    BitVector::shift_left

    source
    fn BitVector::shift_left(self : BitVector, distance : Int) -> Result[BitVector, ModbusError]

    Shift logical bits left, dropping values that fall outside the vector.

    BitVector::shift_right

    source
    fn BitVector::shift_right(self : BitVector, distance : Int) -> Result[BitVector, ModbusError]

    Shift logical bits right, dropping values that fall outside the vector.

    BitVector::to_bits

    source
    fn BitVector::to_bits(self : BitVector) -> Array[Bool]

    BitVector::to_bytes

    source
    fn BitVector::to_bytes(self : BitVector) -> Array[Byte]

    BitVector::unpack_into

    source
    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.

    BridgeAction

    source
    pub(all) enum BridgeAction {
      ForwardBridge
      RewriteBridge
      DenyBridge
      AuditBridge
      RateLimitBridge
    } derive(Eq, 
    Debug    )

    Action taken when a frame matches a gateway policy rule.

    BridgeDecision

    source
    pub(all) struct BridgeDecision {
      rule_id : String?
      action : BridgeAction
      frame : Frame?
      reason : String
      matched : Bool
    }

    Result of applying one gateway rule to a frame.

    BridgeDecision::action

    source

    BridgeDecision::frame

    source
    fn BridgeDecision::frame(self : BridgeDecision) -> Frame?

    BridgeDecision::matched

    source
    fn BridgeDecision::matched(rule : ServiceBridgeRule, action : BridgeAction, frame : Frame?, reason : String) -> BridgeDecision

    BridgeDecision::matched_rule

    source
    fn BridgeDecision::matched_rule(self : BridgeDecision) -> Bool

    BridgeDecision::new

    source
    fn BridgeDecision::new(action : BridgeAction, reason : String) -> BridgeDecision

    BridgeDecision::reason

    source
    fn BridgeDecision::reason(self : BridgeDecision) -> String

    BridgeDecision::rule_id

    source
    fn BridgeDecision::rule_id(self : BridgeDecision) -> String?

    ByteQueue

    source
    pub struct ByteQueue {
      data : Array[Byte]
      max_length : Int
    }

    A bounded byte queue for adapters that receive arbitrary chunk sizes.

    ByteQueue::clear

    source
    fn ByteQueue::clear(self : ByteQueue) -> Unit

    ByteQueue::contains_sequence

    source
    fn ByteQueue::contains_sequence(self : ByteQueue, pattern : Array[Byte]) -> Bool

    ByteQueue::find

    source
    fn ByteQueue::find(self : ByteQueue, value : Byte) -> Int?

    ByteQueue::is_empty

    source
    fn ByteQueue::is_empty(self : ByteQueue) -> Bool

    ByteQueue::length

    source
    fn ByteQueue::length(self : ByteQueue) -> Int

    ByteQueue::new

    source
    fn ByteQueue::new(max_length? : Int) -> Result[ByteQueue, ModbusError]

    ByteQueue::peek

    source
    fn ByteQueue::peek(self : ByteQueue, index : Int) -> Result[Byte, ModbusError]

    ByteQueue::push

    source
    fn ByteQueue::push(self : ByteQueue, bytes : Array[Byte]) -> Result[Unit, ModbusError]

    ByteQueue::push_byte

    source
    fn ByteQueue::push_byte(self : ByteQueue, byte : Byte) -> Result[Unit, ModbusError]

    ByteQueue::remaining

    source
    fn ByteQueue::remaining(self : ByteQueue) -> Int

    ByteQueue::snapshot

    source
    fn ByteQueue::snapshot(self : ByteQueue) -> Array[Byte]

    ByteQueue::take

    source
    fn ByteQueue::take(self : ByteQueue, count : Int) -> Result[Array[Byte], ModbusError]

    ByteQueue::take_all

    source
    fn ByteQueue::take_all(self : ByteQueue) -> Array[Byte]

    CalibrationCurve

    source
    pub(all) struct CalibrationCurve {
      samples : Array[CalibrationSample]
      max_samples : Int
      clamp : Bool
    }

    A monotonic calibration curve for sensors with non-linear error.

    CalibrationCurve::add

    source
    fn CalibrationCurve::add(self : CalibrationCurve, sample : CalibrationSample) -> Result[Unit, ModbusError]

    CalibrationCurve::convert

    source
    fn CalibrationCurve::convert(self : CalibrationCurve, raw : Int) -> Result[Int, ModbusError]

    CalibrationCurve::convert_many

    source
    fn CalibrationCurve::convert_many(self : CalibrationCurve, values : Array[Int]) -> Result[Array[Int], ModbusError]

    CalibrationCurve::length

    source
    fn CalibrationCurve::length(self : CalibrationCurve) -> Int

    CalibrationCurve::new

    source
    fn CalibrationCurve::new(max_samples? : Int, clamp? : Bool) -> Result[CalibrationCurve, ModbusError]

    CalibrationCurve::raw_max

    source
    fn CalibrationCurve::raw_max(self : CalibrationCurve) -> Result[Int, ModbusError]

    CalibrationCurve::raw_min

    source
    fn CalibrationCurve::raw_min(self : CalibrationCurve) -> Result[Int, ModbusError]

    CalibrationCurve::sample

    source
    fn CalibrationCurve::sample(self : CalibrationCurve, index : Int) -> Result[CalibrationSample, ModbusError]

    CalibrationCurve::snapshot

    source

    CalibrationSample

    source
    pub(all) struct CalibrationSample {
      raw : Int
      engineering : Int
    }

    A calibration sample used to build a piecewise-linear curve.

    CalibrationSample::engineering

    source
    fn CalibrationSample::engineering(self : CalibrationSample) -> Int

    CalibrationSample::new

    source
    fn CalibrationSample::new(raw : Int, engineering : Int) -> CalibrationSample

    CalibrationSample::raw

    source
    fn CalibrationSample::raw(self : CalibrationSample) -> Int

    CapabilitySet

    source
    pub(all) struct CapabilitySet {
      functions : Array[Byte]
      modes : Array[Mode]
      max_pdu : Int
      broadcasts : Bool
    }

    A set of capabilities expected from a server or gateway.

    CapabilitySet::add_function

    source
    fn CapabilitySet::add_function(self : CapabilitySet, function : Byte) -> Result[Unit, ModbusError]

    CapabilitySet::add_mode

    source
    fn CapabilitySet::add_mode(self : CapabilitySet, mode : Mode) -> Unit

    CapabilitySet::broadcasts

    source
    fn CapabilitySet::broadcasts(self : CapabilitySet) -> Bool

    CapabilitySet::coverage

    source
    fn CapabilitySet::coverage(self : CapabilitySet, expected : Array[Byte]) -> Int

    CapabilitySet::functions

    source
    fn CapabilitySet::functions(self : CapabilitySet) -> Array[Byte]

    CapabilitySet::max_pdu

    source
    fn CapabilitySet::max_pdu(self : CapabilitySet) -> Int

    CapabilitySet::modes

    source
    fn CapabilitySet::modes(self : CapabilitySet) -> Array[Mode]

    CapabilitySet::new

    source
    fn CapabilitySet::new(max_pdu? : Int, broadcasts? : Bool) -> Result[CapabilitySet, ModbusError]

    CapabilitySet::supports_function

    source
    fn CapabilitySet::supports_function(self : CapabilitySet, function : Byte) -> Bool

    CapabilitySet::supports_mode

    source
    fn CapabilitySet::supports_mode(self : CapabilitySet, mode : Mode) -> Bool

    CapabilitySet::validate_frame

    source
    fn CapabilitySet::validate_frame(self : CapabilitySet, frame : Frame) -> Result[Unit, ModbusError]

    CapacityLedger

    source
    pub(all) struct CapacityLedger {
      limits : Array[CapacityLimit]
      reservations : Array[CapacityReservation]
      max_reservations : Int
      sequence : Int
    }

    Multi-resource ledger for admission control.

    CapacityLedger::add_limit

    source
    fn CapacityLedger::add_limit(self : CapacityLedger, limit : CapacityLimit) -> Result[Unit, ModbusError]

    CapacityLedger::expire

    source
    fn CapacityLedger::expire(self : CapacityLedger, now : Int, age : Int) -> Result[Int, ModbusError]

    Expire all reservations older than a caller-supplied age.

    CapacityLedger::export_lines

    source
    fn CapacityLedger::export_lines(self : CapacityLedger) -> Array[String]

    Human-readable capacity table for health endpoints.

    CapacityLedger::limit

    source

    CapacityLedger::limit_count

    source
    fn CapacityLedger::limit_count(self : CapacityLedger) -> Int

    CapacityLedger::new

    source
    fn CapacityLedger::new(max_reservations? : Int) -> Result[CapacityLedger, ModbusError]

    CapacityLedger::pressure

    source

    Return resources currently above their soft limit.

    CapacityLedger::release

    source
    fn CapacityLedger::release(self : CapacityLedger, reservation_id : String) -> Result[Unit, ModbusError]

    Release a previously issued reservation exactly once.

    CapacityLedger::reservation_count

    source
    fn CapacityLedger::reservation_count(self : CapacityLedger) -> Int

    CapacityLedger::reserve

    source
    fn CapacityLedger::reserve(self : CapacityLedger, resource : CapacityResource, amount : Int, now : Int) -> Result[CapacityReservation, ModbusError]

    Reserve one resource atomically and create an expirable token.

    CapacityLedger::reset

    source
    fn CapacityLedger::reset(self : CapacityLedger) -> Unit

    Reset all limits and reservation tokens after a controlled restart.

    CapacityLimit

    source
    pub(all) struct CapacityLimit {
      resource : CapacityResource
      name : String
      soft_limit : Int
      hard_limit : Int
      used : Int
    }

    A named resource limit with soft and hard thresholds.

    CapacityLimit::available

    source
    fn CapacityLimit::available(self : CapacityLimit) -> Int

    CapacityLimit::hard_limit

    source
    fn CapacityLimit::hard_limit(self : CapacityLimit) -> Int

    CapacityLimit::name

    source
    fn CapacityLimit::name(self : CapacityLimit) -> String

    CapacityLimit::new

    source
    fn CapacityLimit::new(resource : CapacityResource, name : String, soft_limit : Int, hard_limit : Int) -> Result[CapacityLimit, ModbusError]

    CapacityLimit::over_hard

    source
    fn CapacityLimit::over_hard(self : CapacityLimit) -> Bool

    CapacityLimit::over_soft

    source
    fn CapacityLimit::over_soft(self : CapacityLimit) -> Bool

    CapacityLimit::release

    source
    fn CapacityLimit::release(self : CapacityLimit, amount : Int) -> Result[Unit, ModbusError]

    CapacityLimit::reserve

    source
    fn CapacityLimit::reserve(self : CapacityLimit, amount : Int) -> Result[Unit, ModbusError]

    CapacityLimit::reset

    source
    fn CapacityLimit::reset(self : CapacityLimit) -> Unit

    CapacityLimit::resource

    source

    CapacityLimit::soft_limit

    source
    fn CapacityLimit::soft_limit(self : CapacityLimit) -> Int

    CapacityLimit::used

    source
    fn CapacityLimit::used(self : CapacityLimit) -> Int

    CapacityReservation

    source
    pub(all) struct CapacityReservation {
      id : String
      resource : CapacityResource
      amount : Int
      created_at : Int
      released : Bool
    }

    A reservation returned to a caller so releases can be audited.

    CapacityReservation::amount

    source
    fn CapacityReservation::amount(self : CapacityReservation) -> Int

    CapacityReservation::created_at

    source
    fn CapacityReservation::created_at(self : CapacityReservation) -> Int

    CapacityReservation::id

    source
    fn CapacityReservation::id(self : CapacityReservation) -> String

    CapacityReservation::mark_released

    source
    fn CapacityReservation::mark_released(self : CapacityReservation) -> Result[Unit, ModbusError]

    CapacityReservation::new

    source
    fn CapacityReservation::new(id : String, resource : CapacityResource, amount : Int, created_at : Int) -> Result[CapacityReservation, ModbusError]

    CapacityReservation::released

    source
    fn CapacityReservation::released(self : CapacityReservation) -> Bool

    CapacityReservation::resource

    source

    CapacityResource

    source
    pub(all) enum CapacityResource {
      InFlightRequests
      PollRegisters
      CaptureBytes
      CommandQueue
      HistorianSamples
      AlarmEvents
    } derive(Eq, 
    Debug    )

    Resource tracked by a gateway or device service budget.

    CaptureDirection

    source
    pub(all) enum CaptureDirection {
      Received
      Transmitted
      Internal
    } derive(Eq, 
    Debug    )

    Direction of a frame in a transport capture.

    CaptureFilter

    source
    pub(all) struct CaptureFilter {
      mode : Mode?
      unit_id : Byte?
      function : Byte?
      direction : CaptureDirection?
      status : CaptureStatus?
      start_time : Int?
      end_time : Int?
    }

    Filter used to query a capture ring without decoding records again.

    CaptureFilter::between

    source
    fn CaptureFilter::between(self : CaptureFilter, start : Int, end : Int) -> Result[CaptureFilter, ModbusError]

    CaptureFilter::matches

    source
    fn CaptureFilter::matches(self : CaptureFilter, record : CaptureRecord) -> Bool

    CaptureFilter::new

    source

    CaptureFilter::with_direction

    source
    fn CaptureFilter::with_direction(self : CaptureFilter, direction : CaptureDirection) -> CaptureFilter

    CaptureFilter::with_function

    source
    fn CaptureFilter::with_function(self : CaptureFilter, function : Byte) -> CaptureFilter

    CaptureFilter::with_mode

    source
    fn CaptureFilter::with_mode(self : CaptureFilter, mode : Mode) -> CaptureFilter

    CaptureFilter::with_status

    source
    fn CaptureFilter::with_status(self : CaptureFilter, status : CaptureStatus) -> CaptureFilter

    CaptureFilter::with_unit

    source
    fn CaptureFilter::with_unit(self : CaptureFilter, unit_id : Byte) -> CaptureFilter

    CaptureRecord

    source
    pub(all) struct CaptureRecord {
      id : Int
      timestamp : Int
      mode : Mode
      transaction_id : UInt16
      direction : CaptureDirection
      bytes : Array[Byte]
      frame : Frame?
      status : CaptureStatus
      note : String
    }

    A single timestamped wire record.

    CaptureRecord::bytes

    source
    fn CaptureRecord::bytes(self : CaptureRecord) -> Array[Byte]

    CaptureRecord::direction

    source

    CaptureRecord::frame

    source
    fn CaptureRecord::frame(self : CaptureRecord) -> Frame?

    CaptureRecord::from_frame

    source
    fn CaptureRecord::from_frame(id : Int, timestamp : Int, mode : Mode, transaction_id : UInt16, direction : CaptureDirection, frame : Frame, note? : String) -> Result[CaptureRecord, ModbusError]

    CaptureRecord::function

    source
    fn CaptureRecord::function(self : CaptureRecord) -> Byte?

    CaptureRecord::id

    source
    fn CaptureRecord::id(self : CaptureRecord) -> Int

    CaptureRecord::is_valid

    source
    fn CaptureRecord::is_valid(self : CaptureRecord) -> Bool

    CaptureRecord::mode

    source
    fn CaptureRecord::mode(self : CaptureRecord) -> Mode

    CaptureRecord::new

    source
    fn CaptureRecord::new(id : Int, timestamp : Int, mode : Mode, transaction_id : UInt16, direction : CaptureDirection, bytes : Array[Byte], note? : String) -> Result[CaptureRecord, ModbusError]

    CaptureRecord::note

    source
    fn CaptureRecord::note(self : CaptureRecord) -> String

    CaptureRecord::status

    source

    CaptureRecord::summary

    source
    fn CaptureRecord::summary(self : CaptureRecord) -> String

    CaptureRecord::timestamp

    source
    fn CaptureRecord::timestamp(self : CaptureRecord) -> Int

    CaptureRecord::transaction_id

    source
    fn CaptureRecord::transaction_id(self : CaptureRecord) -> UInt16

    CaptureRecord::unit_id

    source
    fn CaptureRecord::unit_id(self : CaptureRecord) -> Byte?

    CaptureRing

    source
    pub(all) struct CaptureRing {
      records : Array[CaptureRecord]
      max_records : Int
      next_id : Int
      lost : Int
    }

    A bounded rolling store for protocol captures.

    CaptureRing::byte_count

    source
    fn CaptureRing::byte_count(self : CaptureRing) -> Int

    CaptureRing::capacity

    source
    fn CaptureRing::capacity(self : CaptureRing) -> Int

    CaptureRing::clear

    source
    fn CaptureRing::clear(self : CaptureRing) -> Unit

    CaptureRing::corrupt_count

    source
    fn CaptureRing::corrupt_count(self : CaptureRing) -> Int

    CaptureRing::decoded_count

    source
    fn CaptureRing::decoded_count(self : CaptureRing) -> Int

    CaptureRing::get

    source
    fn CaptureRing::get(self : CaptureRing, index : Int) -> Result[CaptureRecord, ModbusError]

    CaptureRing::latest

    source
    fn CaptureRing::latest(self : CaptureRing) -> CaptureRecord?

    CaptureRing::length

    source
    fn CaptureRing::length(self : CaptureRing) -> Int

    CaptureRing::lost

    source
    fn CaptureRing::lost(self : CaptureRing) -> Int

    CaptureRing::new

    source
    fn CaptureRing::new(max_records? : Int) -> Result[CaptureRing, ModbusError]

    CaptureRing::push

    source
    fn CaptureRing::push(self : CaptureRing, timestamp : Int, mode : Mode, transaction_id : UInt16, direction : CaptureDirection, bytes : Array[Byte], note? : String) -> Result[CaptureRecord, ModbusError]

    CaptureRing::push_frame

    source
    fn CaptureRing::push_frame(self : CaptureRing, timestamp : Int, mode : Mode, transaction_id : UInt16, direction : CaptureDirection, frame : Frame, note? : String) -> Result[CaptureRecord, ModbusError]

    CaptureRing::query

    source
    fn CaptureRing::query(self : CaptureRing, filter : CaptureFilter) -> Array[CaptureRecord]

    CaptureRing::snapshot

    source
    fn CaptureRing::snapshot(self : CaptureRing) -> Array[CaptureRecord]

    CaptureRing::summary

    source
    fn CaptureRing::summary(self : CaptureRing) -> String

    CaptureStatus

    source
    pub(all) enum CaptureStatus {
      Decoded
      Undecoded
      Corrupt
      Truncated
    } derive(Eq, 
    Debug    )

    Integrity state retained with a captured byte sequence.

    CircuitGuard

    source
    pub(all) struct CircuitGuard {
      name : String
      failure_threshold : Int
      recovery_after : Int
      probe_limit : Int
      state : CircuitGuardState
      consecutive_failures : Int
      opened_at : Int?
      probes : Int
    }

    A circuit breaker with failure threshold and recovery probes.

    CircuitGuard::allow

    source
    fn CircuitGuard::allow(self : CircuitGuard, now : Int) -> Result[Bool, ModbusError]

    CircuitGuard::consecutive_failures

    source
    fn CircuitGuard::consecutive_failures(self : CircuitGuard) -> Int

    CircuitGuard::failure_threshold

    source
    fn CircuitGuard::failure_threshold(self : CircuitGuard) -> Int

    CircuitGuard::force_close

    source
    fn CircuitGuard::force_close(self : CircuitGuard) -> Unit

    CircuitGuard::force_open

    source
    fn CircuitGuard::force_open(self : CircuitGuard, now : Int) -> Result[Unit, ModbusError]

    CircuitGuard::name

    source
    fn CircuitGuard::name(self : CircuitGuard) -> String

    CircuitGuard::new

    source
    fn CircuitGuard::new(name : String, failure_threshold : Int, recovery_after : Int, probe_limit? : Int) -> Result[CircuitGuard, ModbusError]

    CircuitGuard::opened_at

    source
    fn CircuitGuard::opened_at(self : CircuitGuard) -> Int?

    CircuitGuard::record_failure

    source
    fn CircuitGuard::record_failure(self : CircuitGuard, now : Int) -> Result[Unit, ModbusError]

    CircuitGuard::record_success

    source
    fn CircuitGuard::record_success(self : CircuitGuard) -> Unit

    CircuitGuard::recovery_after

    source
    fn CircuitGuard::recovery_after(self : CircuitGuard) -> Int

    CircuitGuard::state

    source

    CircuitGuardState

    source
    pub(all) enum CircuitGuardState {
      ClosedCircuit
      OpenCircuit
      HalfOpenCircuit
    } derive(Eq, 
    Debug    )

    State of a circuit guard protecting a device or route.

    Client

    source
    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

    source
    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

    source
    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

    source
    fn Client::allocate_transaction(self : Client) -> UInt16

    Allocate a non-zero transaction id for TCP and a stable zero id for serial modes.

    Client::attempts

    source
    fn Client::attempts(self : Client, transaction_id : UInt16) -> Int

    Return a request's retry count, or zero when it is not tracked.

    Client::begin

    source
    fn Client::begin(self : Client, frame : Frame) -> Result[ClientRequest, ModbusError]

    Begin an exchange at logical tick zero.

    Client::begin_at

    source
    fn Client::begin_at(self : Client, frame : Frame, now : Int) -> Result[ClientRequest, ModbusError]

    Begin an exchange at a caller-supplied logical tick.

    Client::cancel

    source
    fn Client::cancel(self : Client, transaction_id : UInt16) -> Result[Unit, ModbusError]

    Client::completed_count

    source
    fn Client::completed_count(self : Client) -> Int

    Client::config

    source
    fn Client::config(self : Client) -> ClientConfig

    Client::expire

    source
    fn Client::expire(self : Client, now : Int) -> Array[UInt16]

    Mark all timed-out exchanges as failed and return their transaction ids.

    Client::failed_count

    source
    fn Client::failed_count(self : Client) -> Int

    Client::mode

    source
    fn Client::mode(self : Client) -> Mode

    Client::new

    source
    fn Client::new(mode : Mode, config? : ClientConfig) -> Client

    Client::next_transaction

    source
    fn Client::next_transaction(self : Client) -> UInt16

    Client::pending_active

    source
    fn Client::pending_active(self : Client) -> Int

    Client::pending_request

    source
    fn Client::pending_request(self : Client, transaction_id : UInt16) -> PendingExchange?

    Find a pending request by transaction id.

    Client::pending_snapshot

    source
    fn Client::pending_snapshot(self : Client) -> Array[PendingExchange]

    Return a copy of all pending records for an external scheduler.

    Client::retry_due

    source
    fn Client::retry_due(self : Client, now : Int) -> Array[UInt16]

    Return pending exchanges that can be retried at a logical tick.

    ClientConfig

    source
    pub(all) struct ClientConfig {
      timeout_ticks : Int
      retries : Int
      max_pending : Int
      strict_unit : Bool
    }

    Client retry and framing policy.

    ClientRequest

    source
    pub(all) struct ClientRequest {
      transaction_id : UInt16
      frame : Frame
      bytes : Array[Byte]
    }

    A request prepared for a transport adapter.

    ClientRequest::encoded_length

    source
    fn ClientRequest::encoded_length(self : ClientRequest) -> Int

    ClientResult

    source
    pub(all) enum ClientResult {
      Success(Frame)
      Exception(ExceptionCode)
    }

    A decoded client result with a typed success/exception branch.

    CoilBank

    source
    pub(all) struct CoilBank {
      start : UInt16
      bits : BitVector
      writable : Bool
    }

    A bounded coil/discrete-input bank backed by a bit vector.

    CoilBank::clear

    source
    fn CoilBank::clear(self : CoilBank) -> Unit

    CoilBank::contains

    source
    fn CoilBank::contains(self : CoilBank, address : UInt16, quantity : Int) -> Bool

    CoilBank::fill

    source
    fn CoilBank::fill(self : CoilBank, value : Bool) -> Unit

    CoilBank::get

    source
    fn CoilBank::get(self : CoilBank, address : UInt16) -> Result[Bool, ModbusError]

    CoilBank::is_writable

    source
    fn CoilBank::is_writable(self : CoilBank) -> Bool

    CoilBank::length

    source
    fn CoilBank::length(self : CoilBank) -> Int

    CoilBank::new

    source
    fn CoilBank::new(start : UInt16, length : Int, writable? : Bool) -> Result[CoilBank, ModbusError]

    CoilBank::read

    source
    fn CoilBank::read(self : CoilBank, address : UInt16, quantity : Int) -> Result[Array[Bool], ModbusError]

    CoilBank::set

    source
    fn CoilBank::set(self : CoilBank, address : UInt16, value : Bool) -> Result[Unit, ModbusError]

    CoilBank::snapshot

    source
    fn CoilBank::snapshot(self : CoilBank) -> Array[Bool]

    CoilBank::snapshot_bytes

    source
    fn CoilBank::snapshot_bytes(self : CoilBank) -> Array[Byte]

    CoilBank::start

    source
    fn CoilBank::start(self : CoilBank) -> UInt16

    CoilBank::write

    source
    fn CoilBank::write(self : CoilBank, address : UInt16, values : Array[Bool]) -> Result[Unit, ModbusError]

    CommandArgument

    source
    pub(all) struct CommandArgument {
      key : String
      value : String
    }

    A typed key/value argument supplied by a UI, rule, or automation.

    CommandArgument::as_bool

    source
    fn CommandArgument::as_bool(self : CommandArgument) -> Result[Bool, ModbusError]

    CommandArgument::as_int

    source
    fn CommandArgument::as_int(self : CommandArgument) -> Result[Int, ModbusError]

    CommandArgument::key

    source
    fn CommandArgument::key(self : CommandArgument) -> String

    CommandArgument::new

    source
    fn CommandArgument::new(key : String, value : String) -> Result[CommandArgument, ModbusError]

    CommandArgument::value

    source
    fn CommandArgument::value(self : CommandArgument) -> String

    CommandAuditEntry

    source
    pub(all) struct CommandAuditEntry {
      sequence : Int
      command_id : String
      principal : String
      device_id : String
      operation : String
      state : DeviceCommandState
      timestamp : Int
      detail : String
    }

    Immutable audit event for compliance exports.

    CommandAuditEntry::command_id

    source
    fn CommandAuditEntry::command_id(self : CommandAuditEntry) -> String

    CommandAuditEntry::detail

    source
    fn CommandAuditEntry::detail(self : CommandAuditEntry) -> String

    CommandAuditEntry::device_id

    source
    fn CommandAuditEntry::device_id(self : CommandAuditEntry) -> String

    CommandAuditEntry::new

    source
    fn CommandAuditEntry::new(sequence : Int, command : DeviceCommand, state : DeviceCommandState, timestamp : Int, detail? : String) -> Result[CommandAuditEntry, ModbusError]

    CommandAuditEntry::operation

    source
    fn CommandAuditEntry::operation(self : CommandAuditEntry) -> String

    CommandAuditEntry::principal

    source
    fn CommandAuditEntry::principal(self : CommandAuditEntry) -> String

    CommandAuditEntry::sequence

    source
    fn CommandAuditEntry::sequence(self : CommandAuditEntry) -> Int

    CommandAuditEntry::state

    source

    CommandAuditEntry::timestamp

    source
    fn CommandAuditEntry::timestamp(self : CommandAuditEntry) -> Int

    CommandCenter

    source
    pub(all) struct CommandCenter {
      queue : Array[DeviceCommand]
      completed : Array[CommandExecution]
      audit : Array[CommandAuditEntry]
      max_queue : Int
      max_audit : Int
      sequence : Int
    }

    Central queue and audit log used by a control-plane service.

    CommandCenter::audit_count

    source
    fn CommandCenter::audit_count(self : CommandCenter) -> Int

    CommandCenter::cancel

    source
    fn CommandCenter::cancel(self : CommandCenter, command_id : String, timestamp : Int) -> Result[Unit, ModbusError]

    CommandCenter::completed_count

    source
    fn CommandCenter::completed_count(self : CommandCenter) -> Int

    CommandCenter::find_audit

    source
    fn CommandCenter::find_audit(self : CommandCenter, command_id : String) -> Array[CommandAuditEntry]

    CommandCenter::finish

    source
    fn CommandCenter::finish(self : CommandCenter, command : DeviceCommand, execution : CommandExecution) -> Result[Unit, ModbusError]

    Complete a dispatched command and retain its result for inspection.

    CommandCenter::new

    source
    fn CommandCenter::new(max_queue? : Int, max_audit? : Int) -> Result[CommandCenter, ModbusError]

    CommandCenter::next

    source
    fn CommandCenter::next(self : CommandCenter, timestamp : Int) -> Result[DeviceCommand, ModbusError]

    CommandCenter::queue_count

    source
    fn CommandCenter::queue_count(self : CommandCenter) -> Int

    CommandCenter::recent

    source
    fn CommandCenter::recent(self : CommandCenter, limit : Int) -> Result[Array[CommandAuditEntry], ModbusError]

    CommandCenter::state_counts

    source
    fn CommandCenter::state_counts(self : CommandCenter) -> Array[Int]

    CommandCenter::submit

    source
    fn CommandCenter::submit(self : CommandCenter, command : DeviceCommand, timestamp : Int) -> Result[Unit, ModbusError]

    CommandExecution

    source
    pub(all) struct CommandExecution {
      command_id : String
      state : DeviceCommandState
      started_at : Int
      finished_at : Int
      response : Frame?
      error : ModbusError?
      message : String
    }

    Result returned by a transport or a simulated execution backend.

    CommandExecution::command_id

    source
    fn CommandExecution::command_id(self : CommandExecution) -> String

    CommandExecution::duration

    source
    fn CommandExecution::duration(self : CommandExecution) -> Int

    CommandExecution::error

    source

    CommandExecution::finished_at

    source
    fn CommandExecution::finished_at(self : CommandExecution) -> Int

    CommandExecution::message

    source
    fn CommandExecution::message(self : CommandExecution) -> String

    CommandExecution::new

    source
    fn CommandExecution::new(command_id : String, state : DeviceCommandState, started_at : Int, finished_at : Int, response? : Frame, error? : ModbusError, message? : String) -> Result[CommandExecution, ModbusError]

    CommandExecution::response

    source
    fn CommandExecution::response(self : CommandExecution) -> Frame?

    CommandExecution::started_at

    source
    fn CommandExecution::started_at(self : CommandExecution) -> Int

    CommandExecution::state

    source

    ConfigEntry

    source
    pub(all) struct ConfigEntry {
      key : String
      value : ConfigValue
      source : String
      revision : Int
    }

    A key/value pair in a runtime configuration snapshot.

    ConfigEntry::display

    source
    fn ConfigEntry::display(self : ConfigEntry, redact? : Bool) -> String

    ConfigEntry::key

    source
    fn ConfigEntry::key(self : ConfigEntry) -> String

    ConfigEntry::new

    source
    fn ConfigEntry::new(key : String, value : ConfigValue, source? : String, revision? : Int) -> Result[ConfigEntry, ModbusError]

    ConfigEntry::revision

    source
    fn ConfigEntry::revision(self : ConfigEntry) -> Int

    ConfigEntry::source

    source
    fn ConfigEntry::source(self : ConfigEntry) -> String

    ConfigEntry::value

    source
    fn ConfigEntry::value(self : ConfigEntry) -> ConfigValue

    ConfigKind

    source
    pub(all) enum ConfigKind {
      Text
      Integer
      Boolean
      ModeValue
      ByteSequence
    } derive(Eq, 
    Debug    )

    Type constraint for a runtime configuration key.

    ConfigOperation

    source
    pub(all) enum ConfigOperation {
      SetValue(String, ConfigValue)
      RemoveValue(String)
    } derive(
    Debug    )

    A change applied to a runtime configuration.

    ConfigSchema

    source
    pub(all) struct ConfigSchema {
      specs : Array[ConfigSpec]
      max_specs : Int
    }

    A collection of configuration specifications.

    ConfigSchema::add

    source
    fn ConfigSchema::add(self : ConfigSchema, spec : ConfigSpec) -> Result[Unit, ModbusError]

    ConfigSchema::find

    source
    fn ConfigSchema::find(self : ConfigSchema, key : String) -> ConfigSpec?

    ConfigSchema::get

    source
    fn ConfigSchema::get(self : ConfigSchema, index : Int) -> Result[ConfigSpec, ModbusError]

    ConfigSchema::length

    source
    fn ConfigSchema::length(self : ConfigSchema) -> Int

    ConfigSchema::new

    source
    fn ConfigSchema::new(max_specs? : Int) -> Result[ConfigSchema, ModbusError]

    ConfigSchema::snapshot

    source
    fn ConfigSchema::snapshot(self : ConfigSchema) -> Array[ConfigSpec]

    ConfigSchema::validate_values

    source
    fn ConfigSchema::validate_values(self : ConfigSchema, values : Array[ConfigEntry]) -> Result[Unit, ModbusError]

    ConfigSpec

    source
    pub(all) struct ConfigSpec {
      key : String
      kind : ConfigKind
      required : Bool
      default_value : ConfigValue?
      min_integer : Int?
      max_integer : Int?
      min_length : Int
      max_length : Int
      secret : Bool
      description : String
    }

    A schema entry describing a single configurable field.

    ConfigSpec::default_value

    source
    fn ConfigSpec::default_value(self : ConfigSpec) -> ConfigValue?

    ConfigSpec::description

    source
    fn ConfigSpec::description(self : ConfigSpec) -> String

    ConfigSpec::key

    source
    fn ConfigSpec::key(self : ConfigSpec) -> String

    ConfigSpec::kind

    source
    fn ConfigSpec::kind(self : ConfigSpec) -> ConfigKind

    ConfigSpec::new

    source
    fn ConfigSpec::new(key : String, kind : ConfigKind, required? : Bool, default_value? : ConfigValue, min_integer? : Int, max_integer? : Int, min_length? : Int, max_length? : Int, secret? : Bool, description? : String) -> Result[ConfigSpec, ModbusError]

    ConfigSpec::required

    source
    fn ConfigSpec::required(self : ConfigSpec) -> Bool

    ConfigSpec::secret

    source
    fn ConfigSpec::secret(self : ConfigSpec) -> Bool

    ConfigSpec::summary

    source
    fn ConfigSpec::summary(self : ConfigSpec) -> String

    ConfigSpec::validate

    source
    fn ConfigSpec::validate(self : ConfigSpec, value : ConfigValue) -> Result[Unit, ModbusError]

    ConfigValue

    source
    pub(all) enum ConfigValue {
      TextValue(String)
      IntegerValue(Int)
      BooleanValue(Bool)
      ModeValue(Mode)
      ByteSequenceValue(Array[Byte])
    } derive(
    Debug    )

    A configuration value represented without a dynamic runtime dependency.

    ConfigValue::as_boolean

    source
    fn ConfigValue::as_boolean(self : ConfigValue) -> Result[Bool, ModbusError]

    ConfigValue::as_bytes

    source
    fn ConfigValue::as_bytes(self : ConfigValue) -> Result[Array[Byte], ModbusError]

    ConfigValue::as_integer

    source
    fn ConfigValue::as_integer(self : ConfigValue) -> Result[Int, ModbusError]

    ConfigValue::as_mode

    source
    fn ConfigValue::as_mode(self : ConfigValue) -> Result[Mode, ModbusError]

    ConfigValue::as_text

    source
    fn ConfigValue::as_text(self : ConfigValue) -> Result[String, ModbusError]

    ConfigValue::display

    source
    fn ConfigValue::display(self : ConfigValue, redact? : Bool) -> String

    ConfigValue::kind

    source
    fn ConfigValue::kind(self : ConfigValue) -> ConfigKind

    ConformanceResult

    source
    pub(all) struct ConformanceResult {
      name : String
      passed : Bool
      detail : String
    }

    A vector execution result.

    ConformanceSuite

    source
    pub struct ConformanceSuite {
      vectors : Array[ConformanceVector]
    }

    A reusable conformance suite.

    ConformanceSuite::add

    source
    fn ConformanceSuite::add(self : ConformanceSuite, vector : ConformanceVector) -> Unit

    ConformanceSuite::length

    source
    fn ConformanceSuite::length(self : ConformanceSuite) -> Int

    ConformanceSuite::new

    source

    ConformanceSuite::run

    source

    ConformanceVector

    source
    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

    source
    fn ConformanceVector::invalid(name : String, mode : Mode, bytes : Array[Byte], expected_error : ModbusError) -> ConformanceVector

    ConformanceVector::valid

    source
    fn ConformanceVector::valid(name : String, mode : Mode, bytes : Array[Byte], expected_function : Byte) -> ConformanceVector

    ContractResult

    source
    pub(all) enum ContractResult {
      ContractPass
      ContractUnitMismatch
      ContractFunctionMismatch
      ContractLengthMismatch
      ContractDataMismatch
      ContractException
    } derive(Eq, 
    Debug    )

    Contract check result for a request/response pair.

    Counter

    source
    pub(all) struct Counter {
      name : String
      value : Int
    }

    A small integer counter used for protocol telemetry.

    Counter::add

    source
    fn Counter::add(self : Counter, amount : Int) -> Result[Unit, ModbusError]

    Counter::inc

    source
    fn Counter::inc(self : Counter) -> Unit

    Counter::name

    source
    fn Counter::name(self : Counter) -> String

    Counter::new

    source
    fn Counter::new(name : String) -> Counter

    Counter::reset

    source
    fn Counter::reset(self : Counter) -> Unit

    Counter::value

    source
    fn Counter::value(self : Counter) -> Int

    Crc16State

    source
    pub(all) struct Crc16State {
      value : UInt16
    }

    Incremental CRC16 accumulator for serial readers.

    Crc16State::finalize

    source
    fn Crc16State::finalize(self : Crc16State) -> UInt16

    Crc16State::finalize_bytes

    source
    fn Crc16State::finalize_bytes(self : Crc16State) -> Array[Byte]

    Crc16State::new

    source
    fn Crc16State::new() -> Crc16State

    Crc16State::update

    source
    fn Crc16State::update(self : Crc16State, bytes : Array[Byte]) -> Unit

    Crc16State::update_byte

    source
    fn Crc16State::update_byte(self : Crc16State, byte : Byte) -> Unit

    Device

    source
    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::event_count

    source
    fn Device::event_count(self : Device) -> UInt16

    Device::exception_count

    source
    fn Device::exception_count(self : Device) -> Int

    Device::file_store

    source
    fn Device::file_store(self : Device) -> FileRecordStore

    Device::handle

    source
    fn Device::handle(self : Device, request : Frame) -> Result[Frame, ModbusError]

    Handle a request and return a normal or exception response.

    Device::health

    source
    fn Device::health(self : Device) -> DeviceHealth

    Device::is_busy

    source
    fn Device::is_busy(self : Device) -> Bool

    Device::memory

    source
    fn Device::memory(self : Device) -> DeviceMemory

    Device::new

    source
    fn Device::new(unit_id : Byte, coil_capacity? : Int, register_capacity? : Int) -> Result[Device, ModbusError]

    Create a device with configurable table capacities.

    Device::serve

    source
    fn Device::serve(self : Device, request : Frame) -> Result[DeviceResponse, ModbusError]

    Handle a request while making broadcast no-response semantics explicit.

    Device::server_id

    source
    fn Device::server_id(self : Device) -> Array[Byte]

    Device::set_busy

    source
    fn Device::set_busy(self : Device, busy : Bool) -> Unit

    Device::set_server_id

    source
    fn Device::set_server_id(self : Device, values : Array[Byte]) -> Result[Unit, ModbusError]

    Device::unit_id

    source
    fn Device::unit_id(self : Device) -> Byte

    DeviceCommand

    source
    pub(all) struct DeviceCommand {
      id : String
      device_id : String
      unit_id : Byte
      kind : DeviceCommandKind
      function : Byte
      address : UInt16
      quantity : Int
      arguments : Array[CommandArgument]
      principal : String
      reason : String
      timeout : Int
      state : DeviceCommandState
      created_at : Int
    }

    Definition and authorization context for one device operation.

    DeviceCommand::add_argument

    source
    fn DeviceCommand::add_argument(self : DeviceCommand, argument : CommandArgument) -> Result[Unit, ModbusError]

    DeviceCommand::address

    source
    fn DeviceCommand::address(self : DeviceCommand) -> UInt16

    DeviceCommand::argument

    source
    fn DeviceCommand::argument(self : DeviceCommand, key : String) -> CommandArgument?

    DeviceCommand::argument_count

    source
    fn DeviceCommand::argument_count(self : DeviceCommand) -> Int

    DeviceCommand::created_at

    source
    fn DeviceCommand::created_at(self : DeviceCommand) -> Int

    DeviceCommand::device_id

    source
    fn DeviceCommand::device_id(self : DeviceCommand) -> String

    DeviceCommand::function

    source
    fn DeviceCommand::function(self : DeviceCommand) -> Byte

    DeviceCommand::id

    source
    fn DeviceCommand::id(self : DeviceCommand) -> String

    DeviceCommand::is_terminal

    source
    fn DeviceCommand::is_terminal(self : DeviceCommand) -> Bool

    DeviceCommand::is_write

    source
    fn DeviceCommand::is_write(self : DeviceCommand) -> Bool

    DeviceCommand::kind

    source

    DeviceCommand::new

    source
    fn DeviceCommand::new(id : String, device_id : String, unit_id : Byte, kind : DeviceCommandKind, function : Byte, address : UInt16, quantity : Int, principal : String, reason : String, created_at : Int, timeout? : Int) -> Result[DeviceCommand, ModbusError]

    DeviceCommand::principal

    source
    fn DeviceCommand::principal(self : DeviceCommand) -> String

    DeviceCommand::quantity

    source
    fn DeviceCommand::quantity(self : DeviceCommand) -> Int

    DeviceCommand::reason

    source
    fn DeviceCommand::reason(self : DeviceCommand) -> String

    DeviceCommand::request

    source
    fn DeviceCommand::request(self : DeviceCommand) -> Result[Frame, ModbusError]

    Build a PDU for commands represented directly by standard Modbus writes.

    DeviceCommand::set_state

    source
    fn DeviceCommand::set_state(self : DeviceCommand, state : DeviceCommandState) -> Result[Unit, ModbusError]

    DeviceCommand::state

    source

    DeviceCommand::timeout

    source
    fn DeviceCommand::timeout(self : DeviceCommand) -> Int

    DeviceCommand::unit_id

    source
    fn DeviceCommand::unit_id(self : DeviceCommand) -> Byte

    DeviceCommand::verify_address

    source
    fn DeviceCommand::verify_address(self : DeviceCommand) -> Bool

    DeviceCommandKind

    source
    pub(all) enum DeviceCommandKind {
      WriteCoilCommand
      WriteRegisterCommand
      WriteCoilsCommand
      WriteRegistersCommand
      ReadVerificationCommand
      ClearAlarmCommand
      RestartDeviceCommand
      CustomCommand
    } derive(Eq, 
    Debug    )

    Kind of operator command accepted by the control plane.

    DeviceCommandState

    source
    pub(all) enum DeviceCommandState {
      Queued
      Validating
      Dispatched
      Acknowledged
      Rejected
      TimedOut
      FailedCommand
      CancelledCommand
    } derive(Eq, 
    Debug    )

    Lifecycle of a command from admission to audit completion.

    DeviceHealth

    source
    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

    source
    pub(all) enum DeviceIdCategory {
      Basic
      Regular
      Extended
      Individual(Byte)
    } derive(Eq, 
    Debug    )

    Device-identification access category used by MEI type 0x0E.

    DeviceIdCategory::to_byte

    source
    fn DeviceIdCategory::to_byte(category : DeviceIdCategory) -> Byte

    DeviceIdObject

    source
    pub(all) struct DeviceIdObject {
      object_id : Byte
      value : String
    }

    One TLV object returned by a device-identification response.

    DeviceIdObject::new

    source
    fn DeviceIdObject::new(object_id : Byte, value : String) -> Result[DeviceIdObject, ModbusError]

    DeviceIdentification

    source
    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

    source
    pub struct DeviceIdentityCatalog {
      category : DeviceIdCategory
      objects : Array[DeviceIdObject]
      conformity : Byte
    }

    A reusable identity catalogue for virtual devices.

    DeviceIdentityCatalog::add

    source
    fn DeviceIdentityCatalog::add(self : DeviceIdentityCatalog, object : DeviceIdObject) -> Result[Unit, ModbusError]

    DeviceIdentityCatalog::length

    source

    DeviceIdentityCatalog::new

    source

    DeviceIdentityCatalog::objects

    source

    DeviceIdentityCatalog::response

    source
    fn DeviceIdentityCatalog::response(self : DeviceIdentityCatalog, request : Frame) -> Result[Frame, ModbusError]

    DeviceIdentityCatalog::set_conformity

    source
    fn DeviceIdentityCatalog::set_conformity(self : DeviceIdentityCatalog, conformity : Byte) -> Unit

    DeviceInventory

    source
    pub(all) struct DeviceInventory {
      devices : Array[InventoryDevice]
      max_devices : Int
      revision : Int
    }

    A fleet inventory with lookup and stale-device reporting.

    DeviceInventory::add

    source
    fn DeviceInventory::add(self : DeviceInventory, device : InventoryDevice) -> Result[Unit, ModbusError]

    DeviceInventory::by_state

    source
    fn DeviceInventory::by_state(self : DeviceInventory, state : InventoryState) -> Array[String]

    Return devices by lifecycle state.

    DeviceInventory::by_tag

    source
    fn DeviceInventory::by_tag(self : DeviceInventory, tag : String) -> Array[String]

    DeviceInventory::by_vendor

    source
    fn DeviceInventory::by_vendor(self : DeviceInventory, vendor : String) -> Array[String]

    DeviceInventory::count

    source
    fn DeviceInventory::count(self : DeviceInventory) -> Int

    DeviceInventory::export_lines

    source
    fn DeviceInventory::export_lines(self : DeviceInventory) -> Array[String]

    Stable tabular export for provisioning and support tools.

    DeviceInventory::get

    source
    fn DeviceInventory::get(self : DeviceInventory, id : String) -> InventoryDevice?

    DeviceInventory::mark_stale

    source
    fn DeviceInventory::mark_stale(self : DeviceInventory, now : Int, timeout : Int) -> Result[Int, ModbusError]

    Mark devices stale or offline using one common fleet timestamp.

    DeviceInventory::new

    source
    fn DeviceInventory::new(max_devices? : Int) -> Result[DeviceInventory, ModbusError]

    DeviceInventory::remove

    source
    fn DeviceInventory::remove(self : DeviceInventory, id : String) -> Result[InventoryDevice, ModbusError]

    DeviceInventory::revision

    source
    fn DeviceInventory::revision(self : DeviceInventory) -> Int

    DeviceMemory

    source
    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::clear

    source
    fn DeviceMemory::clear(self : DeviceMemory) -> Unit

    DeviceMemory::coils

    source
    fn DeviceMemory::coils(self : DeviceMemory) -> CoilBank

    DeviceMemory::discrete_inputs

    source
    fn DeviceMemory::discrete_inputs(self : DeviceMemory) -> CoilBank

    DeviceMemory::holding_registers

    source
    fn DeviceMemory::holding_registers(self : DeviceMemory) -> RegisterBank

    DeviceMemory::input_registers

    source
    fn DeviceMemory::input_registers(self : DeviceMemory) -> RegisterBank

    DeviceMemory::load_discrete

    source
    fn DeviceMemory::load_discrete(self : DeviceMemory, address : UInt16, values : Array[Bool]) -> Result[Unit, ModbusError]

    DeviceMemory::load_holding

    source
    fn DeviceMemory::load_holding(self : DeviceMemory, address : UInt16, values : Array[UInt16]) -> Result[Unit, ModbusError]

    DeviceMemory::load_input

    source
    fn DeviceMemory::load_input(self : DeviceMemory, address : UInt16, values : Array[UInt16]) -> Result[Unit, ModbusError]

    DeviceMemory::new

    source
    fn DeviceMemory::new(coil_capacity? : Int, register_capacity? : Int) -> Result[DeviceMemory, ModbusError]

    Create a device memory map with all tables starting at address zero.

    DeviceProfile

    source
    pub(all) struct DeviceProfile {
      name : String
      model : String
      unit_id : Byte
      revision : String
      points : Array[ProfilePoint]
      max_points : Int
    }

    A named set of points belonging to one device model.

    DeviceProfile::add_point

    source
    fn DeviceProfile::add_point(self : DeviceProfile, point : ProfilePoint) -> Result[Unit, ModbusError]

    DeviceProfile::find

    source
    fn DeviceProfile::find(self : DeviceProfile, id : String) -> ProfilePoint?

    DeviceProfile::model

    source
    fn DeviceProfile::model(self : DeviceProfile) -> String

    DeviceProfile::name

    source
    fn DeviceProfile::name(self : DeviceProfile) -> String

    DeviceProfile::new

    source
    fn DeviceProfile::new(name : String, model : String, unit_id : Byte, revision? : String, max_points? : Int) -> Result[DeviceProfile, ModbusError]

    DeviceProfile::point

    source
    fn DeviceProfile::point(self : DeviceProfile, index : Int) -> Result[ProfilePoint, ModbusError]

    DeviceProfile::point_count

    source
    fn DeviceProfile::point_count(self : DeviceProfile) -> Int

    DeviceProfile::points

    source

    DeviceProfile::points_in_area

    source
    fn DeviceProfile::points_in_area(self : DeviceProfile, area : ProfileArea) -> Array[ProfilePoint]

    DeviceProfile::read_requests

    source
    fn DeviceProfile::read_requests(self : DeviceProfile) -> Result[Array[Frame], ModbusError]

    DeviceProfile::remove_point

    source
    fn DeviceProfile::remove_point(self : DeviceProfile, id : String) -> Result[ProfilePoint, ModbusError]

    DeviceProfile::revision

    source
    fn DeviceProfile::revision(self : DeviceProfile) -> String

    DeviceProfile::summary

    source
    fn DeviceProfile::summary(self : DeviceProfile) -> String

    DeviceProfile::unit_id

    source
    fn DeviceProfile::unit_id(self : DeviceProfile) -> Byte

    DeviceProfile::validate

    source
    fn DeviceProfile::validate(self : DeviceProfile) -> Result[Unit, ModbusError]

    DeviceProfile::writable_points

    source
    fn DeviceProfile::writable_points(self : DeviceProfile) -> Array[ProfilePoint]

    DeviceReliability

    source
    pub(all) struct DeviceReliability {
      device_id : String
      window : ReliabilityWindow
      circuit : CircuitGuard
      last_seen : Int?
      total_requests : Int
      total_successes : Int
    }

    Current availability and latency indicators for a device.

    DeviceReliability::allow_request

    source
    fn DeviceReliability::allow_request(self : DeviceReliability, now : Int) -> Result[Bool, ModbusError]

    DeviceReliability::average_latency

    source
    fn DeviceReliability::average_latency(self : DeviceReliability) -> Int

    DeviceReliability::device_id

    source
    fn DeviceReliability::device_id(self : DeviceReliability) -> String

    DeviceReliability::failure_breakdown

    source
    fn DeviceReliability::failure_breakdown(self : DeviceReliability) -> Array[Int]

    DeviceReliability::health_score

    source
    fn DeviceReliability::health_score(self : DeviceReliability, now : Int) -> Result[Int, ModbusError]

    Return a health score from 0 (offline) to 100 (healthy).

    DeviceReliability::last_seen

    source
    fn DeviceReliability::last_seen(self : DeviceReliability) -> Int?

    DeviceReliability::new

    source
    fn DeviceReliability::new(device_id : String, window_width : Int, failure_threshold : Int, recovery_after : Int) -> Result[DeviceReliability, ModbusError]

    DeviceReliability::record

    source
    fn DeviceReliability::record(self : DeviceReliability, sample : ReliabilitySample) -> Result[Unit, ModbusError]

    Record one outcome and update breaker state atomically from the caller's view.

    DeviceReliability::state

    source

    DeviceReliability::success_rate

    source
    fn DeviceReliability::success_rate(self : DeviceReliability) -> Int

    DeviceReliability::total_requests

    source
    fn DeviceReliability::total_requests(self : DeviceReliability) -> Int

    DeviceReliability::total_successes

    source
    fn DeviceReliability::total_successes(self : DeviceReliability) -> Int

    DeviceResponse

    source
    pub(all) enum DeviceResponse {
      Reply(Frame)
      NoReply
    }

    A response returned by a virtual or embedded device service.

    DeviceService

    source
    pub(all) struct DeviceService {
      id : String
      device_id : String
      kind : DeviceServiceKind
      endpoint : String
      state : DeviceServiceState
      started_at : Int?
      stopped_at : Int?
      restart_count : Int
      tags : Array[String]
    }

    Registration record for a long-lived device-facing service.

    DeviceService::add_tag

    source
    fn DeviceService::add_tag(self : DeviceService, tag : String) -> Result[Unit, ModbusError]

    DeviceService::device_id

    source
    fn DeviceService::device_id(self : DeviceService) -> String

    DeviceService::drain

    source
    fn DeviceService::drain(self : DeviceService) -> Result[Unit, ModbusError]

    DeviceService::endpoint

    source
    fn DeviceService::endpoint(self : DeviceService) -> String

    DeviceService::fail

    source
    fn DeviceService::fail(self : DeviceService, timestamp : Int) -> Result[Unit, ModbusError]

    DeviceService::id

    source
    fn DeviceService::id(self : DeviceService) -> String

    DeviceService::kind

    source

    DeviceService::new

    source
    fn DeviceService::new(id : String, device_id : String, kind : DeviceServiceKind, endpoint : String) -> Result[DeviceService, ModbusError]

    DeviceService::restart

    source
    fn DeviceService::restart(self : DeviceService, timestamp : Int) -> Result[Unit, ModbusError]

    DeviceService::restart_count

    source
    fn DeviceService::restart_count(self : DeviceService) -> Int

    DeviceService::start

    source
    fn DeviceService::start(self : DeviceService, timestamp : Int) -> Result[Unit, ModbusError]

    DeviceService::started_at

    source
    fn DeviceService::started_at(self : DeviceService) -> Int?

    DeviceService::state

    source

    DeviceService::stop

    source
    fn DeviceService::stop(self : DeviceService, timestamp : Int) -> Result[Unit, ModbusError]

    DeviceService::stopped_at

    source
    fn DeviceService::stopped_at(self : DeviceService) -> Int?

    DeviceService::tag_count

    source
    fn DeviceService::tag_count(self : DeviceService) -> Int

    DeviceServiceKind

    source
    pub(all) enum DeviceServiceKind {
      PollingService
      CommandService
      AlarmService
      HistorianService
      GatewayService
      DiagnosticsService
    } derive(Eq, 
    Debug    )

    Kind of service hosted by the integration layer.

    DeviceServiceRegistry

    source
    pub(all) struct DeviceServiceRegistry {
      services : Array[DeviceService]
      snapshots : Array[DeviceSnapshot]
      max_services : Int
      max_snapshots : Int
    }

    Registry for services and latest snapshots.

    DeviceServiceRegistry::export_summary

    source
    fn DeviceServiceRegistry::export_summary(self : DeviceServiceRegistry) -> Array[String]

    Return a stable line-oriented snapshot for diagnostics and support bundles.

    DeviceServiceRegistry::failed

    source
    fn DeviceServiceRegistry::failed(self : DeviceServiceRegistry) -> Array[String]

    DeviceServiceRegistry::for_device

    source
    fn DeviceServiceRegistry::for_device(self : DeviceServiceRegistry, device_id : String) -> Array[DeviceService]

    DeviceServiceRegistry::new

    source
    fn DeviceServiceRegistry::new(max_services? : Int, max_snapshots? : Int) -> Result[DeviceServiceRegistry, ModbusError]

    DeviceServiceRegistry::put_snapshot

    source
    fn DeviceServiceRegistry::put_snapshot(self : DeviceServiceRegistry, snapshot : DeviceSnapshot) -> Result[Unit, ModbusError]

    DeviceServiceRegistry::register

    source
    fn DeviceServiceRegistry::register(self : DeviceServiceRegistry, service : DeviceService) -> Result[Unit, ModbusError]

    DeviceServiceRegistry::running

    source
    fn DeviceServiceRegistry::running(self : DeviceServiceRegistry) -> Array[String]

    DeviceServiceRegistry::service

    source
    fn DeviceServiceRegistry::service(self : DeviceServiceRegistry, id : String) -> DeviceService?

    DeviceServiceRegistry::service_count

    source
    fn DeviceServiceRegistry::service_count(self : DeviceServiceRegistry) -> Int

    DeviceServiceRegistry::snapshot

    source
    fn DeviceServiceRegistry::snapshot(self : DeviceServiceRegistry, device_id : String) -> DeviceSnapshot?

    DeviceServiceRegistry::snapshot_count

    source
    fn DeviceServiceRegistry::snapshot_count(self : DeviceServiceRegistry) -> Int

    DeviceServiceState

    source
    pub(all) enum DeviceServiceState {
      ServiceCreated
      ServiceStarting
      ServiceRunning
      ServiceDraining
      ServiceStopped
      ServiceFailed
    } derive(Eq, 
    Debug    )

    Lifecycle of an application service attached to a device.

    DeviceSnapshot

    source
    pub(all) struct DeviceSnapshot {
      device_id : String
      captured_at : Int
      values : Array[SnapshotValue]
      sequence : Int
      complete : Bool
    }

    A consistent set of point values from one acquisition cycle.

    DeviceSnapshot::add

    source
    fn DeviceSnapshot::add(self : DeviceSnapshot, value : SnapshotValue) -> Result[Unit, ModbusError]

    DeviceSnapshot::captured_at

    source
    fn DeviceSnapshot::captured_at(self : DeviceSnapshot) -> Int

    DeviceSnapshot::complete

    source
    fn DeviceSnapshot::complete(self : DeviceSnapshot) -> Bool

    DeviceSnapshot::device_id

    source
    fn DeviceSnapshot::device_id(self : DeviceSnapshot) -> String

    DeviceSnapshot::diff

    source
    fn DeviceSnapshot::diff(self : DeviceSnapshot, previous : DeviceSnapshot) -> Array[String]

    DeviceSnapshot::finish

    source
    fn DeviceSnapshot::finish(self : DeviceSnapshot, expected : Int) -> Result[Unit, ModbusError]

    DeviceSnapshot::get

    source
    fn DeviceSnapshot::get(self : DeviceSnapshot, point_id : String) -> SnapshotValue?

    DeviceSnapshot::good_count

    source
    fn DeviceSnapshot::good_count(self : DeviceSnapshot) -> Int

    DeviceSnapshot::new

    source
    fn DeviceSnapshot::new(device_id : String, captured_at : Int, sequence : Int) -> Result[DeviceSnapshot, ModbusError]

    DeviceSnapshot::quality

    source

    DeviceSnapshot::sequence

    source
    fn DeviceSnapshot::sequence(self : DeviceSnapshot) -> Int

    DeviceSnapshot::value_count

    source
    fn DeviceSnapshot::value_count(self : DeviceSnapshot) -> Int

    DiagnosticCategory

    source
    pub(all) enum DiagnosticCategory {
      Framing
      Addressing
      FunctionSupport
      Payload
      Timing
      Capacity
      Configuration
      Interoperability
    } derive(Eq, 
    Debug    )

    Category assigned to a diagnostic finding.

    DiagnosticIssue

    source
    pub(all) struct DiagnosticIssue {
      code : String
      category : DiagnosticCategory
      severity : DiagnosticSeverity
      message : String
      context : String
      suggestion : String
    }

    One actionable finding from a diagnostic pass.

    DiagnosticIssue::category

    source

    DiagnosticIssue::code

    source
    fn DiagnosticIssue::code(self : DiagnosticIssue) -> String

    DiagnosticIssue::context

    source
    fn DiagnosticIssue::context(self : DiagnosticIssue) -> String

    DiagnosticIssue::message

    source
    fn DiagnosticIssue::message(self : DiagnosticIssue) -> String

    DiagnosticIssue::new

    source
    fn DiagnosticIssue::new(code : String, category : DiagnosticCategory, severity : DiagnosticSeverity, message : String, context? : String, suggestion? : String) -> Result[DiagnosticIssue, ModbusError]

    DiagnosticIssue::severity

    source

    DiagnosticIssue::suggestion

    source
    fn DiagnosticIssue::suggestion(self : DiagnosticIssue) -> String

    DiagnosticIssue::summary

    source
    fn DiagnosticIssue::summary(self : DiagnosticIssue) -> String

    DiagnosticReport

    source
    pub(all) struct DiagnosticReport {
      name : String
      issues : Array[DiagnosticIssue]
      max_issues : Int
      inspected : Int
    }

    A report collected from one or more protocol checks.

    DiagnosticReport::add

    source
    fn DiagnosticReport::add(self : DiagnosticReport, issue : DiagnosticIssue) -> Result[Unit, ModbusError]

    DiagnosticReport::clear

    source
    fn DiagnosticReport::clear(self : DiagnosticReport) -> Unit

    DiagnosticReport::count_category

    source
    fn DiagnosticReport::count_category(self : DiagnosticReport, category : DiagnosticCategory) -> Int

    DiagnosticReport::count_severity

    source
    fn DiagnosticReport::count_severity(self : DiagnosticReport, severity : DiagnosticSeverity) -> Int

    DiagnosticReport::has_errors

    source
    fn DiagnosticReport::has_errors(self : DiagnosticReport) -> Bool

    DiagnosticReport::has_warnings

    source
    fn DiagnosticReport::has_warnings(self : DiagnosticReport) -> Bool

    DiagnosticReport::inspect_one

    source
    fn DiagnosticReport::inspect_one(self : DiagnosticReport, frame : Frame) -> Result[Unit, ModbusError]

    DiagnosticReport::inspect_wire

    source
    fn DiagnosticReport::inspect_wire(self : DiagnosticReport, mode : Mode, bytes : Array[Byte]) -> Unit

    DiagnosticReport::inspected

    source
    fn DiagnosticReport::inspected(self : DiagnosticReport) -> Int

    DiagnosticReport::issues

    source

    DiagnosticReport::length

    source
    fn DiagnosticReport::length(self : DiagnosticReport) -> Int

    DiagnosticReport::name

    source
    fn DiagnosticReport::name(self : DiagnosticReport) -> String

    DiagnosticReport::new

    source
    fn DiagnosticReport::new(name? : String, max_issues? : Int) -> Result[DiagnosticReport, ModbusError]

    DiagnosticReport::ok

    source
    fn DiagnosticReport::ok(self : DiagnosticReport) -> Bool

    DiagnosticReport::summary

    source
    fn DiagnosticReport::summary(self : DiagnosticReport) -> String

    DiagnosticSeverity

    source
    pub(all) enum DiagnosticSeverity {
      Note
      WarningFinding
      ErrorFinding
    } derive(Eq, 
    Debug    )

    Severity of a diagnostic finding.

    EncodedAdu

    source
    pub(all) struct EncodedAdu {
      mode : Mode
      transaction_id : UInt16
      bytes : Array[Byte]
    }

    An encoded ADU that can be handed to a socket or serial adapter.

    EncodedAdu::bytes

    source
    fn EncodedAdu::bytes(self : EncodedAdu) -> Array[Byte]

    EncodedAdu::decode

    source
    fn EncodedAdu::decode(self : EncodedAdu) -> Result[Frame, ModbusError]

    EncodedAdu::mode

    source
    fn EncodedAdu::mode(self : EncodedAdu) -> Mode

    EncodedAdu::new

    source
    fn EncodedAdu::new(mode : Mode, transaction_id : UInt16, frame : Frame) -> Result[EncodedAdu, ModbusError]

    EncodedAdu::transaction_id

    source
    fn EncodedAdu::transaction_id(self : EncodedAdu) -> UInt16

    EndpointConfig

    source
    pub(all) enum EndpointConfig {
      Serial(SerialConfig)
      Tcp(TcpConfig)
    }

    A transport endpoint configuration.

    EndpointConfig::mode

    source
    fn EndpointConfig::mode(config : EndpointConfig) -> Mode

    EndpointConfig::name

    source
    fn EndpointConfig::name(config : EndpointConfig) -> String

    EndpointHealth

    source
    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

    source
    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::backoff

    source
    fn EndpointRuntime::backoff(self : EndpointRuntime) -> Unit

    EndpointRuntime::close

    source
    fn EndpointRuntime::close(self : EndpointRuntime) -> Unit

    EndpointRuntime::config

    source

    EndpointRuntime::fail

    source
    fn EndpointRuntime::fail(self : EndpointRuntime, error : ModbusError) -> Unit

    EndpointRuntime::frames_in

    source
    fn EndpointRuntime::frames_in(self : EndpointRuntime) -> Int

    EndpointRuntime::frames_out

    source
    fn EndpointRuntime::frames_out(self : EndpointRuntime) -> Int

    EndpointRuntime::last_error

    source
    fn EndpointRuntime::last_error(self : EndpointRuntime) -> ModbusError?

    EndpointRuntime::new

    source

    EndpointRuntime::open

    source
    fn EndpointRuntime::open(self : EndpointRuntime, now : Int) -> Result[Unit, ModbusError]

    EndpointRuntime::reconnects

    source
    fn EndpointRuntime::reconnects(self : EndpointRuntime) -> Int

    EndpointRuntime::record_in

    source
    fn EndpointRuntime::record_in(self : EndpointRuntime) -> Result[Unit, ModbusError]

    EndpointRuntime::record_out

    source
    fn EndpointRuntime::record_out(self : EndpointRuntime) -> Result[Unit, ModbusError]

    EndpointRuntime::state

    source

    EndpointRuntime::uptime

    source
    fn EndpointRuntime::uptime(self : EndpointRuntime, now : Int) -> Int

    EndpointState

    source
    pub(all) enum EndpointState {
      Closed
      Connecting
      Ready
      Backoff
      Faulted
    } derive(Eq, 
    Debug    )

    Lifecycle state of a transport endpoint.

    EngineeringUnit

    source
    pub(all) enum EngineeringUnit {
      Unitless
      Percent
      Celsius
      Fahrenheit
      Pascal
      Kilopascal
      Volt
      Ampere
      Hertz
      Rpm
      Meter
      Millimeter
      LiterPerMinute
    } derive(Eq, 
    Debug    )

    Physical unit associated with an engineering value.

    EventDelivery

    source
    pub(all) enum EventDelivery {
      EventPending
      EventDelivered
      EventFailed
      EventDeadLetter
    } derive(Eq, 
    Debug    )

    Delivery state used by durable event consumers.

    EventSubscription

    source
    pub(all) struct EventSubscription {
      id : String
      source : String?
      kind : ServiceEventKind?
      enabled : Bool
    }

    Subscription filter for one consumer.

    EventSubscription::enabled

    source
    fn EventSubscription::enabled(self : EventSubscription) -> Bool

    EventSubscription::id

    source
    fn EventSubscription::id(self : EventSubscription) -> String

    EventSubscription::matches

    source
    fn EventSubscription::matches(self : EventSubscription, event : ServiceEvent) -> Bool

    EventSubscription::new

    source
    fn EventSubscription::new(id : String, source? : String, kind? : ServiceEventKind) -> Result[EventSubscription, ModbusError]

    EventSubscription::set_enabled

    source
    fn EventSubscription::set_enabled(self : EventSubscription, enabled : Bool) -> Unit

    ExceptionCode

    source
    pub(all) enum ExceptionCode {
      IllegalFunction
      IllegalDataAddress
      IllegalDataValue
      ServerDeviceFailure
      Acknowledge
      ServerDeviceBusy
      NegativeAcknowledge
      MemoryParityError
      GatewayPathUnavailable
      GatewayTargetFailedToRespond
      UnknownException(Byte)
    } derive(Eq, 
    Debug    )

    Standard exception codes returned by a Modbus server.

    ExceptionCode::to_byte

    source
    fn ExceptionCode::to_byte(code : ExceptionCode) -> Byte

    ExchangeEnvelope

    source
    pub(all) struct ExchangeEnvelope {
      source : String
      destination : String
      adu : EncodedAdu
    }

    A transport-neutral request envelope.

    ExchangeEnvelope::new

    source
    fn ExchangeEnvelope::new(source : String, destination : String, adu : EncodedAdu) -> ExchangeEnvelope

    ExchangeEnvelope::size

    source
    fn ExchangeEnvelope::size(self : ExchangeEnvelope) -> Int

    ExchangeState

    source
    pub(all) enum ExchangeState {
      Pending
      Completed
      Failed
      Cancelled
    } derive(Eq, 
    Debug    )

    Lifecycle of a client-side exchange.

    FaultMode

    source
    pub(all) enum FaultMode {
      NoFault
      DropResponse
      CorruptCrc
      CorruptLrc
      WrongTransaction
      BusyDevice
      InvalidFunction
    } derive(Eq, 
    Debug    )

    Deterministic fault modes for protocol integration tests.

    FileRecordReference

    source
    pub(all) struct FileRecordReference {
      reference_type : Byte
      file_number : UInt16
      record_number : UInt16
      record_length : UInt16
    }

    A Modbus file-record selector.

    FileRecordReference::encoded_length

    source
    fn FileRecordReference::encoded_length(_self : FileRecordReference) -> Int

    FileRecordReference::new

    source
    fn FileRecordReference::new(file_number : UInt16, record_number : UInt16, record_length : UInt16, reference_type? : Byte) -> Result[FileRecordReference, ModbusError]

    FileRecordStore

    source
    pub(all) struct FileRecordStore {
      records : Array[FileRecordWrite]
      max_records : Int
    }

    A bounded in-memory store for file records used by simulators.

    FileRecordStore::clear

    source
    fn FileRecordStore::clear(self : FileRecordStore) -> Unit

    FileRecordStore::get

    source
    fn FileRecordStore::get(self : FileRecordStore, reference : FileRecordReference) -> Result[Array[UInt16], ModbusError]

    FileRecordStore::length

    source
    fn FileRecordStore::length(self : FileRecordStore) -> Int

    FileRecordStore::new

    source
    fn FileRecordStore::new(max_records? : Int) -> Result[FileRecordStore, ModbusError]

    FileRecordStore::put

    source
    fn FileRecordStore::put(self : FileRecordStore, record : FileRecordWrite) -> Result[Unit, ModbusError]

    FileRecordWrite

    source
    pub(all) struct FileRecordWrite {
      reference : FileRecordReference
      values : Array[UInt16]
    }

    A file-record write item combines a selector and its register payload.

    FileRecordWrite::new

    source
    fn FileRecordWrite::new(reference : FileRecordReference, values : Array[UInt16]) -> Result[FileRecordWrite, ModbusError]

    FirmwareConstraint

    source
    pub(all) struct FirmwareConstraint {
      vendor : String
      model : String
      minimum : String
      recommended : String
    }

    A small firmware compatibility constraint.

    FirmwareConstraint::matches

    source
    fn FirmwareConstraint::matches(self : FirmwareConstraint, device : InventoryDevice) -> Bool

    FirmwareConstraint::minimum

    source
    fn FirmwareConstraint::minimum(self : FirmwareConstraint) -> String

    FirmwareConstraint::new

    source
    fn FirmwareConstraint::new(vendor : String, model : String, minimum : String, recommended : String) -> Result[FirmwareConstraint, ModbusError]

    FirmwareConstraint::recommended

    source
    fn FirmwareConstraint::recommended(self : FirmwareConstraint) -> String

    FleetHealthRollup

    source
    pub(all) struct FleetHealthRollup {
      contributions : Array[HealthContribution]
      score : Int
      state : FleetHealthState
      timestamp : Int
    }

    Weighted score calculation used by operator dashboards.

    FleetHealthRollup::add

    source
    fn FleetHealthRollup::add(self : FleetHealthRollup, contribution : HealthContribution) -> Result[Unit, ModbusError]

    FleetHealthRollup::contribution

    source
    fn FleetHealthRollup::contribution(self : FleetHealthRollup, source : String) -> HealthContribution?

    FleetHealthRollup::contribution_count

    source
    fn FleetHealthRollup::contribution_count(self : FleetHealthRollup) -> Int

    FleetHealthRollup::contributions

    source

    FleetHealthRollup::export_lines

    source
    fn FleetHealthRollup::export_lines(self : FleetHealthRollup) -> Array[String]

    A serializable health line for logs and support bundles.

    FleetHealthRollup::new

    source
    fn FleetHealthRollup::new(timestamp : Int) -> Result[FleetHealthRollup, ModbusError]

    FleetHealthRollup::recalculate

    source
    fn FleetHealthRollup::recalculate(self : FleetHealthRollup) -> Unit

    FleetHealthRollup::remove

    source
    fn FleetHealthRollup::remove(self : FleetHealthRollup, source : String) -> Result[HealthContribution, ModbusError]

    FleetHealthRollup::score

    source
    fn FleetHealthRollup::score(self : FleetHealthRollup) -> Int

    FleetHealthRollup::state

    source

    FleetHealthRollup::timestamp

    source
    fn FleetHealthRollup::timestamp(self : FleetHealthRollup) -> Int

    FleetHealthState

    source
    pub(all) enum FleetHealthState {
      FleetHealthy
      FleetDegraded
      FleetCritical
      FleetEmpty
    } derive(Eq, 
    Debug    )

    Fleet-level state derived from reliability, services, and inventory.

    Frame

    source
    pub(all) struct Frame {
      unit_id : Byte
      pdu : Pdu
    }

    A decoded frame, including the unit identifier.

    Frame::data_length

    source
    fn Frame::data_length(self : Frame) -> Int

    Frame::function_code

    source
    fn Frame::function_code(self : Frame) -> FunctionCode

    Frame::is_exception

    source
    fn Frame::is_exception(self : Frame) -> Bool

    Frame::new

    source
    fn Frame::new(unit_id : Byte, function : Byte, data : Array[Byte]) -> Frame

    FrameContract

    source
    pub(all) struct FrameContract {
      id : String
      function : Byte
      request_min : Int
      request_max : Int
      response_min : Int
      response_max : Int
      require_echo : Bool
    }

    Expected shape of one application data unit.

    FrameContract::check

    source
    fn FrameContract::check(self : FrameContract, request : Frame, response : Frame) -> ContractResult

    Validate a response against this function-level contract.

    FrameContract::function

    source
    fn FrameContract::function(self : FrameContract) -> Byte

    FrameContract::id

    source
    fn FrameContract::id(self : FrameContract) -> String

    FrameContract::new

    source
    fn FrameContract::new(id : String, function : Byte, request_min : Int, request_max : Int, response_min : Int, response_max : Int, require_echo? : Bool) -> Result[FrameContract, ModbusError]

    FrameContract::request_max

    source
    fn FrameContract::request_max(self : FrameContract) -> Int

    FrameContract::request_min

    source
    fn FrameContract::request_min(self : FrameContract) -> Int

    FrameContract::require_echo

    source
    fn FrameContract::require_echo(self : FrameContract) -> Bool

    FrameContract::response_max

    source
    fn FrameContract::response_max(self : FrameContract) -> Int

    FrameContract::response_min

    source
    fn FrameContract::response_min(self : FrameContract) -> Int

    FrameContractCatalog

    source
    pub(all) struct FrameContractCatalog {
      contracts : Array[FrameContract]
      max_contracts : Int
    }

    A catalog of frame contracts used by server and gateway adapters.

    FrameContractCatalog::add

    source
    fn FrameContractCatalog::add(self : FrameContractCatalog, contract : FrameContract) -> Result[Unit, ModbusError]

    FrameContractCatalog::check

    source
    fn FrameContractCatalog::check(self : FrameContractCatalog, request : Frame, response : Frame) -> Result[ContractResult, ModbusError]

    FrameContractCatalog::check_all

    source

    Check all known standard functions and return the first failure.

    FrameContractCatalog::count

    source

    FrameContractCatalog::find

    source
    fn FrameContractCatalog::find(self : FrameContractCatalog, function : Byte) -> FrameContract?

    FrameContractCatalog::new

    source
    fn FrameContractCatalog::new(max_contracts? : Int) -> Result[FrameContractCatalog, ModbusError]

    FrameFingerprint

    source
    pub(all) struct FrameFingerprint {
      unit_id : Byte
      function : Byte
      data_length : Int
      checksum : Int
    }

    Immutable frame fingerprint for duplicate detection.

    FrameFingerprint::checksum

    source
    fn FrameFingerprint::checksum(self : FrameFingerprint) -> Int

    FrameFingerprint::data_length

    source
    fn FrameFingerprint::data_length(self : FrameFingerprint) -> Int

    FrameFingerprint::from_frame

    source
    fn FrameFingerprint::from_frame(frame : Frame) -> FrameFingerprint

    FrameFingerprint::function

    source
    fn FrameFingerprint::function(self : FrameFingerprint) -> Byte

    FrameFingerprint::same

    source
    fn FrameFingerprint::same(self : FrameFingerprint, other : FrameFingerprint) -> Bool

    FrameFingerprint::unit_id

    source
    fn FrameFingerprint::unit_id(self : FrameFingerprint) -> Byte

    FrameSequence

    source
    pub struct FrameSequence {
      frames : Array[Frame]
      max_frames : Int
    }

    A bounded ordered collection of frames for gateways and batch adapters.

    FrameSequence::encoded_bytes

    source
    fn FrameSequence::encoded_bytes(self : FrameSequence, mode : Mode) -> Int

    FrameSequence::filter_function

    source
    fn FrameSequence::filter_function(self : FrameSequence, function : Byte) -> Array[Frame]

    FrameSequence::filter_unit

    source
    fn FrameSequence::filter_unit(self : FrameSequence, unit_id : Byte) -> Array[Frame]

    FrameSequence::get

    source
    fn FrameSequence::get(self : FrameSequence, index : Int) -> Result[Frame, ModbusError]

    FrameSequence::length

    source
    fn FrameSequence::length(self : FrameSequence) -> Int

    FrameSequence::new

    source
    fn FrameSequence::new(max_frames? : Int) -> Result[FrameSequence, ModbusError]

    FrameSequence::push

    source
    fn FrameSequence::push(self : FrameSequence, frame : Frame) -> Result[Unit, ModbusError]

    FrameSequence::snapshot

    source
    fn FrameSequence::snapshot(self : FrameSequence) -> Array[Frame]

    FrameSequence::validate

    source
    fn FrameSequence::validate(self : FrameSequence, allow_broadcast : Bool) -> Result[Unit, ModbusError]

    FrameStream

    source
    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::chunks

    source
    fn FrameStream::chunks(self : FrameStream) -> Int

    FrameStream::finish

    source
    fn FrameStream::finish(self : FrameStream) -> Result[Frame, ModbusError]

    FrameStream::frames

    source
    fn FrameStream::frames(self : FrameStream) -> Int

    FrameStream::mode

    source
    fn FrameStream::mode(self : FrameStream) -> Mode

    FrameStream::new

    source
    fn FrameStream::new(mode : Mode, role? : ParserRole, max_buffer? : Int, max_frame? : Int) -> Result[FrameStream, ModbusError]

    FrameStream::push

    source
    fn FrameStream::push(self : FrameStream, bytes : Array[Byte]) -> Result[Array[Frame], ModbusError]

    FrameStream::reset

    source
    fn FrameStream::reset(self : FrameStream) -> Unit

    FrameSummary

    source
    pub(all) struct FrameSummary {
      unit_id : Byte
      function : Byte
      data_length : Int
      exception : Bool
    }

    A compact description useful for logs and metrics.

    FrameTextLog

    source
    pub struct FrameTextLog {
      entries : Array[String]
      max_entries : Int
    }

    A bounded text trace used by CLI tools and embedded diagnostics.

    FrameTextLog::clear

    source
    fn FrameTextLog::clear(self : FrameTextLog) -> Unit

    FrameTextLog::length

    source
    fn FrameTextLog::length(self : FrameTextLog) -> Int

    FrameTextLog::lines

    source
    fn FrameTextLog::lines(self : FrameTextLog) -> Array[String]

    FrameTextLog::new

    source
    fn FrameTextLog::new(max_entries? : Int) -> Result[FrameTextLog, ModbusError]

    FrameTextLog::push

    source
    fn FrameTextLog::push(self : FrameTextLog, line : String) -> Unit

    FrameTextLog::record

    source
    fn FrameTextLog::record(self : FrameTextLog, direction : String, frame : Frame) -> Unit

    FrameTextLog::record_wire

    source
    fn FrameTextLog::record_wire(self : FrameTextLog, direction : String, mode : Mode, transaction_id : UInt16, frame : Frame) -> Unit

    FunctionCode

    source
    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

    source
    fn FunctionCode::to_byte(code : FunctionCode) -> Byte

    Return the numeric representation of a typed function code.

    FunctionDescriptor

    source
    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

    source
    fn FunctionDescriptor::description(self : FunctionDescriptor) -> String

    FunctionDescriptor::function

    source
    fn FunctionDescriptor::function(self : FunctionDescriptor) -> Byte

    FunctionDescriptor::is_write

    source
    fn FunctionDescriptor::is_write(self : FunctionDescriptor) -> Bool

    FunctionDescriptor::name

    source
    fn FunctionDescriptor::name(self : FunctionDescriptor) -> String

    FunctionDescriptor::supports_request

    source
    fn FunctionDescriptor::supports_request(self : FunctionDescriptor, length : Int) -> Bool

    Gateway

    source
    pub struct Gateway {
      rules : Array[GatewayRule]
      forwarded : Int
      rejected : Int
      translated : Int
    }

    A deterministic frame gateway that rewrites unit ids and register/coil addresses.

    Gateway::add_rule

    source
    fn Gateway::add_rule(self : Gateway, rule : GatewayRule) -> Result[Unit, ModbusError]

    Gateway::forwarded_count

    source
    fn Gateway::forwarded_count(self : Gateway) -> Int

    Gateway::new

    source
    fn Gateway::new() -> Gateway

    Gateway::rejected_count

    source
    fn Gateway::rejected_count(self : Gateway) -> Int

    Gateway::reset_metrics

    source
    fn Gateway::reset_metrics(self : Gateway) -> Unit

    Gateway::reverse

    source
    fn Gateway::reverse(self : Gateway, request : Frame, response : Frame) -> Result[Frame, ModbusError]

    Translate a response back to the source address space.

    Gateway::rule_count

    source
    fn Gateway::rule_count(self : Gateway) -> Int

    Gateway::rules

    source
    fn Gateway::rules(self : Gateway) -> Array[GatewayRule]

    Gateway::translate

    source
    fn Gateway::translate(self : Gateway, frame : Frame) -> Result[Frame, ModbusError]

    Translate one request according to the first matching rule.

    Gateway::translated_count

    source
    fn Gateway::translated_count(self : Gateway) -> Int

    GatewayPolicyTable

    source
    pub(all) struct GatewayPolicyTable {
      policies : Array[ServiceGatewayPolicy]
      max_policies : Int
    }

    Fleet-level route table for selecting one policy by endpoint pair.

    GatewayPolicyTable::add

    source
    fn GatewayPolicyTable::add(self : GatewayPolicyTable, policy : ServiceGatewayPolicy) -> Result[Unit, ModbusError]

    GatewayPolicyTable::count

    source
    fn GatewayPolicyTable::count(self : GatewayPolicyTable) -> Int

    GatewayPolicyTable::evaluate

    source
    fn GatewayPolicyTable::evaluate(self : GatewayPolicyTable, source : String, destination : String, frame : Frame) -> Result[BridgeDecision, ModbusError]

    GatewayPolicyTable::find

    source
    fn GatewayPolicyTable::find(self : GatewayPolicyTable, source : String, destination : String) -> ServiceGatewayPolicy?

    GatewayPolicyTable::new

    source
    fn GatewayPolicyTable::new(max_policies? : Int) -> Result[GatewayPolicyTable, ModbusError]

    GatewayPolicyTable::routes

    source
    fn GatewayPolicyTable::routes(self : GatewayPolicyTable) -> Array[String]

    GatewayRoute

    source
    pub(all) struct GatewayRoute {
      name : String
      gateway : Gateway
      device : Device
      client : Client
    }

    A gateway route that combines a rule set, client, and virtual device.

    GatewayRoute::add_rule

    source
    fn GatewayRoute::add_rule(self : GatewayRoute, rule : GatewayRule) -> Result[Unit, ModbusError]

    GatewayRoute::exchange

    source
    fn GatewayRoute::exchange(self : GatewayRoute, request : Frame) -> Result[Frame, ModbusError]

    GatewayRoute::metrics

    source
    fn GatewayRoute::metrics(self : GatewayRoute) -> (Int, Int, Int)

    GatewayRoute::name

    source
    fn GatewayRoute::name(self : GatewayRoute) -> String

    GatewayRoute::new

    source
    fn GatewayRoute::new(name : String, mode : Mode, device : Device) -> GatewayRoute

    GatewayRule

    source
    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::enable

    source
    fn GatewayRule::enable(self : GatewayRule, enabled : Bool) -> Unit

    GatewayRule::matches

    source
    fn GatewayRule::matches(self : GatewayRule, frame : Frame) -> Bool

    GatewayRule::new

    source
    fn GatewayRule::new(source_unit : Byte, target_unit : Byte, function : Byte, source_start : UInt16, target_start : UInt16, span : Int) -> Result[GatewayRule, ModbusError]

    GuardDecision

    source
    pub(all) enum GuardDecision {
      AdmitFrame
      RejectFrame
      DeferFrame
      DuplicateFrame
      QuotaFrame
      OversizeFrame
    } derive(Eq, 
    Debug    )

    Decision made before a frame enters a server or gateway pipeline.

    GuardEvent

    source
    pub(all) struct GuardEvent {
      sequence : Int
      timestamp : Int
      peer : String
      decision : GuardDecision
      reason : GuardReason
      unit_id : Byte
      function : Byte
      frame_bytes : Int
      fingerprint : FrameFingerprint
    }

    Admission event retained for metrics and support diagnostics.

    GuardEvent::decision

    source
    fn GuardEvent::decision(self : GuardEvent) -> GuardDecision

    GuardEvent::fingerprint

    source
    fn GuardEvent::fingerprint(self : GuardEvent) -> FrameFingerprint

    GuardEvent::frame_bytes

    source
    fn GuardEvent::frame_bytes(self : GuardEvent) -> Int

    GuardEvent::function

    source
    fn GuardEvent::function(self : GuardEvent) -> Byte

    GuardEvent::new

    source
    fn GuardEvent::new(sequence : Int, timestamp : Int, peer : String, decision : GuardDecision, reason : GuardReason, frame : Frame) -> Result[GuardEvent, ModbusError]

    GuardEvent::peer

    source
    fn GuardEvent::peer(self : GuardEvent) -> String

    GuardEvent::reason

    source
    fn GuardEvent::reason(self : GuardEvent) -> GuardReason

    GuardEvent::sequence

    source
    fn GuardEvent::sequence(self : GuardEvent) -> Int

    GuardEvent::timestamp

    source
    fn GuardEvent::timestamp(self : GuardEvent) -> Int

    GuardEvent::unit_id

    source
    fn GuardEvent::unit_id(self : GuardEvent) -> Byte

    GuardReason

    source
    pub(all) enum GuardReason {
      GuardAccepted
      GuardBadUnit
      GuardBadFunction
      GuardBadLength
      GuardDuplicate
      GuardRateLimited
      GuardTooLarge
      GuardUnknownPeer
    } derive(Eq, 
    Debug    )

    Reason included in a protocol admission record.

    HealthContribution

    source
    pub(all) struct HealthContribution {
      source : String
      score : Int
      weight : Int
      detail : String
    }

    A weighted health contribution from one subsystem.

    HealthContribution::detail

    source
    fn HealthContribution::detail(self : HealthContribution) -> String

    HealthContribution::new

    source
    fn HealthContribution::new(source : String, score : Int, weight : Int, detail : String) -> Result[HealthContribution, ModbusError]

    HealthContribution::score

    source
    fn HealthContribution::score(self : HealthContribution) -> Int

    HealthContribution::source

    source
    fn HealthContribution::source(self : HealthContribution) -> String

    HealthContribution::weight

    source
    fn HealthContribution::weight(self : HealthContribution) -> Int

    Historian

    source
    pub(all) struct Historian {
      series : Array[TagSeries]
      max_points : Int
      per_point_capacity : Int
    }

    A bounded multi-point historian.

    Historian::aggregate

    source
    fn Historian::aggregate(self : Historian, point_id : String, start : Int, end : Int, aggregation : Aggregation) -> Result[Int, ModbusError]

    Historian::append

    source
    fn Historian::append(self : Historian, sample : TagSample) -> Result[Unit, ModbusError]

    Historian::clear

    source
    fn Historian::clear(self : Historian) -> Unit

    Historian::ensure_point

    source
    fn Historian::ensure_point(self : Historian, point_id : String) -> Result[Unit, ModbusError]

    Historian::get

    source
    fn Historian::get(self : Historian, point_id : String) -> TagSeries?

    Historian::new

    source
    fn Historian::new(max_points? : Int, per_point_capacity? : Int) -> Result[Historian, ModbusError]

    Historian::point_count

    source
    fn Historian::point_count(self : Historian) -> Int

    Historian::query

    source
    fn Historian::query(self : Historian, point_id : String, start : Int, end : Int) -> Result[Array[TagSample], ModbusError]

    Historian::remove

    source
    fn Historian::remove(self : Historian, point_id : String) -> Result[TagSeries, ModbusError]

    Historian::series_snapshot

    source
    fn Historian::series_snapshot(self : Historian) -> Array[TagSeries]

    Historian::summary

    source
    fn Historian::summary(self : Historian) -> String

    Historian::total_samples

    source
    fn Historian::total_samples(self : Historian) -> Int

    HistoryBucket

    source
    pub(all) struct HistoryBucket {
      start : Int
      end : Int
      count : Int
      minimum : Int
      maximum : Int
      sum : Int
    }

    A fixed interval bucket for downsampled exports.

    HistoryBucket::add

    source
    fn HistoryBucket::add(self : HistoryBucket, value : Int) -> Unit

    HistoryBucket::average

    source
    fn HistoryBucket::average(self : HistoryBucket) -> Int

    HistoryBucket::contains

    source
    fn HistoryBucket::contains(self : HistoryBucket, timestamp : Int) -> Bool

    HistoryBucket::count

    source
    fn HistoryBucket::count(self : HistoryBucket) -> Int

    HistoryBucket::end

    source
    fn HistoryBucket::end(self : HistoryBucket) -> Int

    HistoryBucket::maximum

    source
    fn HistoryBucket::maximum(self : HistoryBucket) -> Int

    HistoryBucket::minimum

    source
    fn HistoryBucket::minimum(self : HistoryBucket) -> Int

    HistoryBucket::new

    source
    fn HistoryBucket::new(start : Int, width : Int, first : Int) -> Result[HistoryBucket, ModbusError]

    HistoryBucket::start

    source
    fn HistoryBucket::start(self : HistoryBucket) -> Int

    IncrementalParser

    source
    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

    source
    fn IncrementalParser::buffered(self : IncrementalParser) -> Int

    Return the number of bytes waiting in the parser.

    IncrementalParser::errors_seen

    source
    fn IncrementalParser::errors_seen(self : IncrementalParser) -> Int

    IncrementalParser::feed

    source
    fn IncrementalParser::feed(self : IncrementalParser, input : Array[Byte]) -> Result[Array[Frame], ModbusError]

    Feed bytes and return every complete frame currently available.

    IncrementalParser::feed_byte

    source
    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

    source
    fn IncrementalParser::finish(self : IncrementalParser) -> Result[Frame, ModbusError]

    Finish a serial frame at an externally supplied RTU silent interval.

    IncrementalParser::frames_seen

    source
    fn IncrementalParser::frames_seen(self : IncrementalParser) -> Int

    IncrementalParser::max_frame

    source
    fn IncrementalParser::max_frame(self : IncrementalParser) -> Int

    IncrementalParser::mode

    source

    IncrementalParser::new

    source
    fn IncrementalParser::new(mode : Mode, max_frame? : Int, role? : ParserRole) -> IncrementalParser

    Create a stream parser. max_frame prevents unbounded input growth.

    IncrementalParser::reset

    source
    fn IncrementalParser::reset(self : IncrementalParser) -> Unit

    Discard buffered bytes after a transport reset.

    IncrementalParser::role

    source

    IncrementalParser::set_max_frame

    source
    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

    source
    fn IncrementalParser::take_buffer(self : IncrementalParser) -> Array[Byte]

    Take the current buffered bytes and reset the parser.

    InventoryDevice

    source
    pub(all) struct InventoryDevice {
      id : String
      label : String
      vendor : String
      model : String
      serial : String
      firmware : String
      unit_id : Byte
      transport : String
      state : InventoryState
      last_seen : Int?
      tags : Array[String]
    }

    Firmware and identity metadata used by fleet operations.

    InventoryDevice::add_tag

    source
    fn InventoryDevice::add_tag(self : InventoryDevice, tag : String) -> Result[Unit, ModbusError]

    InventoryDevice::firmware

    source
    fn InventoryDevice::firmware(self : InventoryDevice) -> String

    InventoryDevice::has_tag

    source
    fn InventoryDevice::has_tag(self : InventoryDevice, tag : String) -> Bool

    InventoryDevice::id

    source
    fn InventoryDevice::id(self : InventoryDevice) -> String

    InventoryDevice::label

    source
    fn InventoryDevice::label(self : InventoryDevice) -> String

    InventoryDevice::last_seen

    source
    fn InventoryDevice::last_seen(self : InventoryDevice) -> Int?

    InventoryDevice::mark_seen

    source
    fn InventoryDevice::mark_seen(self : InventoryDevice, timestamp : Int) -> Result[Unit, ModbusError]

    InventoryDevice::model

    source
    fn InventoryDevice::model(self : InventoryDevice) -> String

    InventoryDevice::new

    source
    fn InventoryDevice::new(id : String, label : String, vendor : String, model : String, serial : String, firmware : String, unit_id : Byte, transport : String) -> Result[InventoryDevice, ModbusError]

    InventoryDevice::serial

    source
    fn InventoryDevice::serial(self : InventoryDevice) -> String

    InventoryDevice::set_state

    source
    fn InventoryDevice::set_state(self : InventoryDevice, state : InventoryState) -> Unit

    InventoryDevice::stale

    source
    fn InventoryDevice::stale(self : InventoryDevice, now : Int, timeout : Int) -> Result[Bool, ModbusError]

    InventoryDevice::state

    source

    InventoryDevice::transport

    source
    fn InventoryDevice::transport(self : InventoryDevice) -> String

    InventoryDevice::unit_id

    source
    fn InventoryDevice::unit_id(self : InventoryDevice) -> Byte

    InventoryDevice::vendor

    source
    fn InventoryDevice::vendor(self : InventoryDevice) -> String

    InventoryState

    source
    pub(all) enum InventoryState {
      InventoryDiscovered
      InventoryProvisioned
      InventoryOnline
      InventoryOffline
      InventoryRetired
    } derive(Eq, 
    Debug    )

    Lifecycle state of an enrolled industrial device.

    JobPriority

    source
    pub(all) enum JobPriority {
      Background
      NormalPriority
      HighPriority
      Emergency
    } derive(Eq, 
    Debug    )

    Priority used by the application-level request scheduler.

    JobScheduler

    source
    pub(all) struct JobScheduler {
      jobs : Array[ScheduledJob]
      max_jobs : Int
      now : Int
      dispatched : Int
      completed : Int
      failed : Int
      cancelled : Int
    }

    A bounded scheduler with priority-aware due-job selection.

    JobScheduler::add

    source
    fn JobScheduler::add(self : JobScheduler, job : ScheduledJob) -> Result[Unit, ModbusError]

    JobScheduler::cancel

    source
    fn JobScheduler::cancel(self : JobScheduler, id : String) -> Result[Unit, ModbusError]

    JobScheduler::cancelled

    source
    fn JobScheduler::cancelled(self : JobScheduler) -> Int

    JobScheduler::complete

    source
    fn JobScheduler::complete(self : JobScheduler, id : String, now : Int) -> Result[Unit, ModbusError]

    JobScheduler::completed

    source
    fn JobScheduler::completed(self : JobScheduler) -> Int

    JobScheduler::dispatch

    source
    fn JobScheduler::dispatch(self : JobScheduler, now : Int) -> Result[ScheduledJob, ModbusError]

    JobScheduler::dispatched

    source
    fn JobScheduler::dispatched(self : JobScheduler) -> Int

    JobScheduler::due_count

    source
    fn JobScheduler::due_count(self : JobScheduler, now : Int) -> Int

    JobScheduler::fail

    source
    fn JobScheduler::fail(self : JobScheduler, id : String, error : ModbusError, now : Int) -> Result[Bool, ModbusError]

    JobScheduler::failed

    source
    fn JobScheduler::failed(self : JobScheduler) -> Int

    JobScheduler::find

    source
    fn JobScheduler::find(self : JobScheduler, id : String) -> ScheduledJob?

    JobScheduler::get

    source
    fn JobScheduler::get(self : JobScheduler, index : Int) -> Result[ScheduledJob, ModbusError]

    JobScheduler::length

    source
    fn JobScheduler::length(self : JobScheduler) -> Int

    JobScheduler::new

    source
    fn JobScheduler::new(max_jobs? : Int) -> Result[JobScheduler, ModbusError]

    JobScheduler::next_due

    source
    fn JobScheduler::next_due(self : JobScheduler, now : Int) -> ScheduledJob?

    JobScheduler::now

    source
    fn JobScheduler::now(self : JobScheduler) -> Int

    JobScheduler::remove

    source
    fn JobScheduler::remove(self : JobScheduler, id : String) -> Result[ScheduledJob, ModbusError]

    JobScheduler::reschedule

    source
    fn JobScheduler::reschedule(self : JobScheduler, id : String, due_at : Int) -> Result[Unit, ModbusError]

    JobScheduler::reset_metrics

    source
    fn JobScheduler::reset_metrics(self : JobScheduler) -> Unit

    JobScheduler::snapshot

    source
    fn JobScheduler::snapshot(self : JobScheduler) -> Array[ScheduledJob]

    JobScheduler::snapshot_metrics

    source
    fn JobScheduler::snapshot_metrics(self : JobScheduler) -> SchedulerSnapshot

    JobScheduler::state_count

    source
    fn JobScheduler::state_count(self : JobScheduler, state : JobState) -> Int

    JobScheduler::summary

    source
    fn JobScheduler::summary(self : JobScheduler) -> String

    JobState

    source
    pub(all) enum JobState {
      Ready
      InFlight
      Waiting
      Completed
      Failed
      Cancelled
    } derive(Eq, 
    Debug    )

    Lifecycle state of a scheduled request.

    LatencyHistogram

    source
    pub(all) struct LatencyHistogram {
      bounds : Array[Int]
      counts : Array[Int]
      total : Int
      sum : Int
    }

    Fixed latency buckets, expressed in logical ticks.

    LatencyHistogram::bucket_counts

    source
    fn LatencyHistogram::bucket_counts(self : LatencyHistogram) -> Array[Int]

    LatencyHistogram::mean

    source
    fn LatencyHistogram::mean(self : LatencyHistogram) -> Float

    LatencyHistogram::new

    source
    fn LatencyHistogram::new(bounds : Array[Int]) -> Result[LatencyHistogram, ModbusError]

    LatencyHistogram::observe

    source
    fn LatencyHistogram::observe(self : LatencyHistogram, ticks : Int) -> Result[Unit, ModbusError]

    LatencyHistogram::sum

    source
    fn LatencyHistogram::sum(self : LatencyHistogram) -> Int

    LatencyHistogram::total

    source
    fn LatencyHistogram::total(self : LatencyHistogram) -> Int

    LeaseManager

    source
    pub(all) struct LeaseManager {
      leases : Array[ResourceLease]
      max_leases : Int
      default_duration : Int
      sequence : Int
    }

    Manages exclusive resource ownership across client workers.

    LeaseManager::acquire

    source
    fn LeaseManager::acquire(self : LeaseManager, resource : String, owner : String, now : Int, priority? : Int) -> Result[ResourceLease, ModbusError]

    Acquire a resource if no active lease has a higher or equal priority.

    LeaseManager::active_resources

    source
    fn LeaseManager::active_resources(self : LeaseManager, now : Int) -> Result[Array[String], ModbusError]

    Return resource names with an active owner.

    LeaseManager::compact

    source
    fn LeaseManager::compact(self : LeaseManager, before : Int) -> Result[Int, ModbusError]

    Clean up old terminal leases while retaining recent history.

    LeaseManager::count

    source
    fn LeaseManager::count(self : LeaseManager) -> Int

    LeaseManager::default_duration

    source
    fn LeaseManager::default_duration(self : LeaseManager) -> Int

    LeaseManager::expire

    source
    fn LeaseManager::expire(self : LeaseManager, now : Int) -> Result[Int, ModbusError]

    Expire inactive leases and return their count.

    LeaseManager::find

    source
    fn LeaseManager::find(self : LeaseManager, resource : String) -> ResourceLease?

    LeaseManager::new

    source
    fn LeaseManager::new(max_leases? : Int, default_duration? : Int) -> Result[LeaseManager, ModbusError]

    LeaseManager::owned_by

    source
    fn LeaseManager::owned_by(self : LeaseManager, owner : String, now : Int) -> Result[Array[String], ModbusError]

    Return active leases for a given owner.

    LeaseManager::release

    source
    fn LeaseManager::release(self : LeaseManager, lease_id : String, owner : String) -> Result[Unit, ModbusError]

    Release a lease at the end of a request or connection.

    LeaseManager::renew

    source
    fn LeaseManager::renew(self : LeaseManager, lease_id : String, owner : String, now : Int, duration? : Int) -> Result[Unit, ModbusError]

    Renew a lease only for its current owner.

    LeaseState

    source
    pub(all) enum LeaseState {
      LeaseAvailable
      LeaseHeld
      LeaseExpired
      LeaseRevoked
    } derive(Eq, 
    Debug    )

    Ownership state for a serial line, TCP endpoint, or device command lane.

    MaintenanceKind

    source
    pub(all) enum MaintenanceKind {
      Inspection
      Calibration
      Cleaning
      FirmwareUpdate
      CableReplacement
      PreventiveService
      CorrectiveRepair
    } derive(Eq, 
    Debug    )

    Type of maintenance activity tracked for a field device.

    MaintenancePlanner

    source
    pub(all) struct MaintenancePlanner {
      plans : Array[ServicePlan]
      records : Array[ServiceRecord]
      work_orders : Array[MaintenanceWorkOrder]
      max_records : Int
      max_orders : Int
    }

    Plan and audit maintenance across multiple devices.

    MaintenancePlanner::add_plan

    source
    fn MaintenancePlanner::add_plan(self : MaintenancePlanner, plan : ServicePlan) -> Result[Unit, ModbusError]

    MaintenancePlanner::add_record

    source
    fn MaintenancePlanner::add_record(self : MaintenancePlanner, record : ServiceRecord) -> Result[Unit, ModbusError]

    MaintenancePlanner::add_work_order

    source
    fn MaintenancePlanner::add_work_order(self : MaintenancePlanner, order : MaintenanceWorkOrder) -> Result[Unit, ModbusError]

    MaintenancePlanner::complete_order

    source
    fn MaintenancePlanner::complete_order(self : MaintenancePlanner, order_id : String, timestamp : Int, note? : String) -> Result[Unit, ModbusError]

    Complete a linked order and update the corresponding service plan.

    MaintenancePlanner::due_plans

    source
    fn MaintenancePlanner::due_plans(self : MaintenancePlanner, now : Int) -> Result[Array[String], ModbusError]

    Return plans due or overdue at a timestamp.

    MaintenancePlanner::generate_due

    source
    fn MaintenancePlanner::generate_due(self : MaintenancePlanner, now : Int) -> Result[Int, ModbusError]

    Generate due work orders for plans that have not been scheduled at now.

    MaintenancePlanner::history_count

    source
    fn MaintenancePlanner::history_count(self : MaintenancePlanner, asset_id : String, start : Int, end : Int) -> Result[Int, ModbusError]

    Count service records for an asset within a time range.

    MaintenancePlanner::new

    source
    fn MaintenancePlanner::new(max_records? : Int, max_orders? : Int) -> Result[MaintenancePlanner, ModbusError]

    MaintenancePlanner::open_orders

    source
    fn MaintenancePlanner::open_orders(self : MaintenancePlanner, now : Int, overdue_only? : Bool) -> Result[Array[String], ModbusError]

    Return the IDs of open work orders, optionally limited to overdue work.

    MaintenancePlanner::plan

    source
    fn MaintenancePlanner::plan(self : MaintenancePlanner, id : String) -> ServicePlan?

    MaintenancePlanner::plan_count

    source
    fn MaintenancePlanner::plan_count(self : MaintenancePlanner) -> Int

    MaintenancePlanner::record_count

    source
    fn MaintenancePlanner::record_count(self : MaintenancePlanner) -> Int

    MaintenancePlanner::summary

    source
    fn MaintenancePlanner::summary(self : MaintenancePlanner, now : Int) -> Result[MaintenanceSummary, ModbusError]

    MaintenancePlanner::work_order

    source
    fn MaintenancePlanner::work_order(self : MaintenancePlanner, id : String) -> MaintenanceWorkOrder?

    MaintenancePlanner::work_order_count

    source
    fn MaintenancePlanner::work_order_count(self : MaintenancePlanner) -> Int

    MaintenancePriority

    source
    pub(all) enum MaintenancePriority {
      Routine
      Important
      Urgent
      Critical
    } derive(Eq, 
    Debug    )

    Priority assigned by an operator or by an automated due-date rule.

    MaintenanceSummary

    source
    pub(all) struct MaintenanceSummary {
      plans : Int
      due : Int
      overdue : Int
      completed : Int
      open : Int
      records : Int
    }

    Summary for maintenance dashboards and export jobs.

    MaintenanceSummary::completed

    source
    fn MaintenanceSummary::completed(self : MaintenanceSummary) -> Int

    MaintenanceSummary::due

    source
    fn MaintenanceSummary::due(self : MaintenanceSummary) -> Int

    MaintenanceSummary::open

    source
    fn MaintenanceSummary::open(self : MaintenanceSummary) -> Int

    MaintenanceSummary::overdue

    source
    fn MaintenanceSummary::overdue(self : MaintenanceSummary) -> Int

    MaintenanceSummary::plans

    source
    fn MaintenanceSummary::plans(self : MaintenanceSummary) -> Int

    MaintenanceSummary::records

    source
    fn MaintenanceSummary::records(self : MaintenanceSummary) -> Int

    MaintenanceSummary::summary

    source
    fn MaintenanceSummary::summary(self : MaintenanceSummary) -> String

    MaintenanceWorkOrder

    source
    pub(all) struct MaintenanceWorkOrder {
      id : String
      asset_id : String
      plan_id : String?
      title : String
      priority : MaintenancePriority
      state : WorkOrderState
      created_at : Int
      due_at : Int
      assigned_to : String?
      started_at : Int?
      finished_at : Int?
      note : String
    }

    An actionable unit of work generated from a service plan or alarm.

    MaintenanceWorkOrder::asset_id

    source
    fn MaintenanceWorkOrder::asset_id(self : MaintenanceWorkOrder) -> String

    MaintenanceWorkOrder::assign

    source
    fn MaintenanceWorkOrder::assign(self : MaintenanceWorkOrder, technician : String) -> Result[Unit, ModbusError]

    MaintenanceWorkOrder::assigned_to

    source
    fn MaintenanceWorkOrder::assigned_to(self : MaintenanceWorkOrder) -> String?

    MaintenanceWorkOrder::block

    source
    fn MaintenanceWorkOrder::block(self : MaintenanceWorkOrder, note : String) -> Result[Unit, ModbusError]

    MaintenanceWorkOrder::cancel

    source
    fn MaintenanceWorkOrder::cancel(self : MaintenanceWorkOrder, reason : String) -> Result[Unit, ModbusError]

    MaintenanceWorkOrder::complete

    source
    fn MaintenanceWorkOrder::complete(self : MaintenanceWorkOrder, timestamp : Int, note? : String) -> Result[Unit, ModbusError]

    MaintenanceWorkOrder::continue_work

    source
    fn MaintenanceWorkOrder::continue_work(self : MaintenanceWorkOrder) -> Result[Unit, ModbusError]

    MaintenanceWorkOrder::created_at

    source
    fn MaintenanceWorkOrder::created_at(self : MaintenanceWorkOrder) -> Int

    MaintenanceWorkOrder::due_at

    source
    fn MaintenanceWorkOrder::due_at(self : MaintenanceWorkOrder) -> Int

    MaintenanceWorkOrder::duration

    source
    fn MaintenanceWorkOrder::duration(self : MaintenanceWorkOrder) -> Int?

    MaintenanceWorkOrder::id

    source

    MaintenanceWorkOrder::is_due

    source
    fn MaintenanceWorkOrder::is_due(self : MaintenanceWorkOrder, now : Int) -> Bool

    MaintenanceWorkOrder::is_overdue

    source
    fn MaintenanceWorkOrder::is_overdue(self : MaintenanceWorkOrder, now : Int) -> Bool

    MaintenanceWorkOrder::new

    source
    fn MaintenanceWorkOrder::new(id : String, asset_id : String, title : String, priority : MaintenancePriority, created_at : Int, due_at : Int, plan_id? : String) -> Result[MaintenanceWorkOrder, ModbusError]

    MaintenanceWorkOrder::note

    source
    fn MaintenanceWorkOrder::note(self : MaintenanceWorkOrder) -> String

    MaintenanceWorkOrder::plan_id

    source
    fn MaintenanceWorkOrder::plan_id(self : MaintenanceWorkOrder) -> String?

    MaintenanceWorkOrder::priority

    source

    MaintenanceWorkOrder::start

    source
    fn MaintenanceWorkOrder::start(self : MaintenanceWorkOrder, timestamp : Int) -> Result[Unit, ModbusError]

    MaintenanceWorkOrder::state

    source

    MaintenanceWorkOrder::title

    source
    fn MaintenanceWorkOrder::title(self : MaintenanceWorkOrder) -> String

    MetricKind

    source
    pub(all) enum MetricKind {
      CounterMetric
      GaugeMetric
      DurationMetric
      RatioMetric
      EventMetric
    } derive(Eq, 
    Debug    )

    Storage type of a metric emitted by a Modbus service.

    MetricRegistry

    source
    pub(all) struct MetricRegistry {
      series : Array[MetricSeries]
      max_series : Int
      max_samples : Int
    }

    A registry used by transports, schedulers, and HTTP adapters.

    MetricRegistry::digest

    source

    MetricRegistry::export_lines

    source
    fn MetricRegistry::export_lines(self : MetricRegistry) -> Array[String]

    Export a compact Prometheus-like line representation without external dependencies.

    MetricRegistry::has

    source
    fn MetricRegistry::has(self : MetricRegistry, name : String) -> Bool

    MetricRegistry::latest

    source
    fn MetricRegistry::latest(self : MetricRegistry, name : String) -> ServiceMetric?

    MetricRegistry::names

    source
    fn MetricRegistry::names(self : MetricRegistry) -> Array[String]

    MetricRegistry::new

    source
    fn MetricRegistry::new(max_series? : Int, max_samples? : Int) -> Result[MetricRegistry, ModbusError]

    MetricRegistry::range

    source
    fn MetricRegistry::range(self : MetricRegistry, start : Int, end : Int) -> Result[Array[ServiceMetric], ModbusError]

    Collect a time range from every registered series.

    MetricRegistry::record

    source
    fn MetricRegistry::record(self : MetricRegistry, metric : ServiceMetric) -> Result[Unit, ModbusError]

    MetricRegistry::register

    source
    fn MetricRegistry::register(self : MetricRegistry, name : String, kind : MetricKind) -> Result[Unit, ModbusError]

    MetricRegistry::series

    source
    fn MetricRegistry::series(self : MetricRegistry, name : String) -> MetricSeries?

    MetricRegistry::series_count

    source
    fn MetricRegistry::series_count(self : MetricRegistry) -> Int

    MetricSeries

    source
    pub(all) struct MetricSeries {
      name : String
      kind : MetricKind
      capacity : Int
      samples : Array[ServiceMetric]
      dropped : Int
    }

    Bounded history for one named metric.

    MetricSeries::append

    source
    fn MetricSeries::append(self : MetricSeries, metric : ServiceMetric) -> Result[Unit, ModbusError]

    MetricSeries::average

    source
    fn MetricSeries::average(self : MetricSeries) -> Int?

    MetricSeries::between

    source
    fn MetricSeries::between(self : MetricSeries, start : Int, end : Int) -> Result[Array[ServiceMetric], ModbusError]

    MetricSeries::dropped

    source
    fn MetricSeries::dropped(self : MetricSeries) -> Int

    MetricSeries::kind

    source

    MetricSeries::latest

    source
    fn MetricSeries::latest(self : MetricSeries) -> ServiceMetric?

    MetricSeries::length

    source
    fn MetricSeries::length(self : MetricSeries) -> Int

    MetricSeries::maximum

    source
    fn MetricSeries::maximum(self : MetricSeries) -> Int?

    MetricSeries::minimum

    source
    fn MetricSeries::minimum(self : MetricSeries) -> Int?

    MetricSeries::name

    source
    fn MetricSeries::name(self : MetricSeries) -> String

    MetricSeries::new

    source
    fn MetricSeries::new(name : String, kind : MetricKind, capacity? : Int) -> Result[MetricSeries, ModbusError]

    MetricSeries::sum

    source
    fn MetricSeries::sum(self : MetricSeries) -> Int

    MetricsTransport

    source
    pub(all) enum MetricsTransport {
      MetricsRtu
      MetricsAscii
      MetricsTcp
      MetricsTls
      MetricsVirtual
    } derive(Eq, 
    Debug    )

    Transport mode used for operational metrics.

    MigrationOperation

    source
    pub(all) enum MigrationOperation {
      AddSetting
      RemoveSetting
      RenameSetting
      ReplaceSetting
      ValidateSetting
    } derive(Eq, 
    Debug    )

    Operation used by a migration step.

    MigrationPlan

    source
    pub(all) struct MigrationPlan {
      id : String
      from_version : Int
      to_version : Int
      steps : Array[MigrationStep]
      max_steps : Int
      state : MigrationState
    }

    Ordered migration plan with transactional execution state.

    MigrationPlan::add_step

    source
    fn MigrationPlan::add_step(self : MigrationPlan, step : MigrationStep) -> Result[Unit, ModbusError]

    MigrationPlan::apply

    source

    Apply each step and return the changed snapshot.

    MigrationPlan::export_lines

    source
    fn MigrationPlan::export_lines(self : MigrationPlan) -> Array[String]

    MigrationPlan::from_version

    source
    fn MigrationPlan::from_version(self : MigrationPlan) -> Int

    MigrationPlan::id

    source
    fn MigrationPlan::id(self : MigrationPlan) -> String

    MigrationPlan::new

    source
    fn MigrationPlan::new(id : String, from_version : Int, to_version : Int, max_steps? : Int) -> Result[MigrationPlan, ModbusError]

    MigrationPlan::rollback

    source
    fn MigrationPlan::rollback(self : MigrationPlan, snapshot : MigrationSnapshot) -> Result[MigrationSnapshot, ModbusError]

    Roll back applied steps in reverse order where rollback values exist.

    MigrationPlan::state

    source

    MigrationPlan::step_count

    source
    fn MigrationPlan::step_count(self : MigrationPlan) -> Int

    MigrationPlan::to_version

    source
    fn MigrationPlan::to_version(self : MigrationPlan) -> Int

    MigrationSnapshot

    source
    pub(all) struct MigrationSnapshot {
      version : Int
      entries : Array[(String, String)]
      timestamp : Int
    }

    A copy-on-write key/value configuration snapshot.

    MigrationSnapshot::get

    source
    fn MigrationSnapshot::get(self : MigrationSnapshot, key : String) -> String?

    MigrationSnapshot::keys

    source
    fn MigrationSnapshot::keys(self : MigrationSnapshot) -> Array[String]

    MigrationSnapshot::length

    source
    fn MigrationSnapshot::length(self : MigrationSnapshot) -> Int

    MigrationSnapshot::new

    source
    fn MigrationSnapshot::new(version : Int, timestamp : Int) -> Result[MigrationSnapshot, ModbusError]

    MigrationSnapshot::put

    source
    fn MigrationSnapshot::put(self : MigrationSnapshot, key : String, value : String) -> Result[Unit, ModbusError]

    MigrationSnapshot::remove

    source
    fn MigrationSnapshot::remove(self : MigrationSnapshot, key : String) -> Result[String, ModbusError]

    MigrationSnapshot::timestamp

    source
    fn MigrationSnapshot::timestamp(self : MigrationSnapshot) -> Int

    MigrationSnapshot::version

    source
    fn MigrationSnapshot::version(self : MigrationSnapshot) -> Int

    MigrationState

    source
    pub(all) enum MigrationState {
      MigrationPlanned
      MigrationRunning
      MigrationApplied
      MigrationRolledBack
      MigrationFailed
    } derive(Eq, 
    Debug    )

    Lifecycle state of a configuration migration.

    MigrationStep

    source
    pub(all) struct MigrationStep {
      id : String
      operation : MigrationOperation
      key : String
      value : String
      rollback_value : String?
      order : Int
      applied : Bool
    }

    One deterministic configuration change with a rollback value.

    MigrationStep::applied

    source
    fn MigrationStep::applied(self : MigrationStep) -> Bool

    MigrationStep::id

    source
    fn MigrationStep::id(self : MigrationStep) -> String

    MigrationStep::key

    source
    fn MigrationStep::key(self : MigrationStep) -> String

    MigrationStep::mark_applied

    source
    fn MigrationStep::mark_applied(self : MigrationStep) -> Unit

    MigrationStep::mark_pending

    source
    fn MigrationStep::mark_pending(self : MigrationStep) -> Unit

    MigrationStep::new

    source
    fn MigrationStep::new(id : String, operation : MigrationOperation, key : String, value : String, order : Int, rollback_value? : String) -> Result[MigrationStep, ModbusError]

    MigrationStep::operation

    source

    MigrationStep::order

    source
    fn MigrationStep::order(self : MigrationStep) -> Int

    MigrationStep::rollback_value

    source
    fn MigrationStep::rollback_value(self : MigrationStep) -> String?

    MigrationStep::value

    source
    fn MigrationStep::value(self : MigrationStep) -> String

    ModbusError

    source
    pub(all) enum ModbusError {
      Incomplete
      InvalidLength
      InvalidChecksum
      InvalidAscii
      InvalidMbap
      InvalidUnitId
      InvalidFunction
      InvalidAddress
      InvalidQuantity
      InvalidByteCount
      InvalidData
      InvalidTransaction
      Unsupported
      UnitMismatch
      CapacityExceeded
      NoResponse
      Busy
    } derive(Eq, 
    Debug    )

    Errors produced by the protocol core and its in-memory services.

    ModbusScenario

    source
    pub(all) struct ModbusScenario {
      id : String
      description : String
      steps : Array[ScenarioStep]
      max_steps : Int
      revision : Int
    }

    Scenario definition containing steps and shared test variables.

    ModbusScenario::add

    source
    fn ModbusScenario::add(self : ModbusScenario, step : ScenarioStep) -> Result[Unit, ModbusError]

    ModbusScenario::at

    source
    fn ModbusScenario::at(self : ModbusScenario, index : Int) -> Result[ScenarioStep, ModbusError]

    ModbusScenario::description

    source
    fn ModbusScenario::description(self : ModbusScenario) -> String

    ModbusScenario::faults

    source
    fn ModbusScenario::faults(self : ModbusScenario) -> Int

    ModbusScenario::id

    source
    fn ModbusScenario::id(self : ModbusScenario) -> String

    ModbusScenario::new

    source
    fn ModbusScenario::new(id : String, description : String, max_steps? : Int) -> Result[ModbusScenario, ModbusError]

    ModbusScenario::revision

    source
    fn ModbusScenario::revision(self : ModbusScenario) -> Int

    ModbusScenario::step

    source
    fn ModbusScenario::step(self : ModbusScenario, id : String) -> ScenarioStep?

    ModbusScenario::step_count

    source
    fn ModbusScenario::step_count(self : ModbusScenario) -> Int

    ModbusScenario::steps

    source

    ModbusTransaction

    source
    pub(all) struct ModbusTransaction {
      id : String
      unit_id : Byte
      items : Array[TransactionItem]
      outcomes : Array[TransactionOutcome]
      max_items : Int
      state : TransactionState
      next_order : Int
    }

    Ordered transaction coordinator for write-and-verify workflows.

    ModbusTransaction::acknowledge

    source
    fn ModbusTransaction::acknowledge(self : ModbusTransaction, item_id : String, response : Frame, timestamp : Int) -> Result[Unit, ModbusError]

    Record a successful response for the next prepared item.

    ModbusTransaction::add

    source
    fn ModbusTransaction::add(self : ModbusTransaction, request : Frame, compensation? : Frame) -> Result[String, ModbusError]

    ModbusTransaction::commit

    source
    fn ModbusTransaction::commit(self : ModbusTransaction) -> Result[Unit, ModbusError]

    Commit only when every prepared item has acknowledged successfully.

    ModbusTransaction::fail

    source
    fn ModbusTransaction::fail(self : ModbusTransaction, item_id : String, error : ModbusError, timestamp : Int) -> Result[Unit, ModbusError]

    Mark an item failed and retain the protocol error.

    ModbusTransaction::id

    source
    fn ModbusTransaction::id(self : ModbusTransaction) -> String

    ModbusTransaction::is_successful

    source
    fn ModbusTransaction::is_successful(self : ModbusTransaction) -> Bool

    ModbusTransaction::item_count

    source
    fn ModbusTransaction::item_count(self : ModbusTransaction) -> Int

    ModbusTransaction::new

    source
    fn ModbusTransaction::new(id : String, unit_id : Byte, max_items? : Int) -> Result[ModbusTransaction, ModbusError]

    ModbusTransaction::next_prepared

    source

    ModbusTransaction::outcome_count

    source
    fn ModbusTransaction::outcome_count(self : ModbusTransaction) -> Int

    ModbusTransaction::outcomes

    source

    ModbusTransaction::prepare

    source
    fn ModbusTransaction::prepare(self : ModbusTransaction) -> Result[Unit, ModbusError]

    Prepare all requests, rejecting malformed frames before transport I/O.

    ModbusTransaction::rollback

    source
    fn ModbusTransaction::rollback(self : ModbusTransaction, timestamp : Int) -> Result[Array[Frame], ModbusError]

    Roll back a prepared or partially committed transaction.

    ModbusTransaction::state

    source

    ModbusTransaction::unit_id

    source
    fn ModbusTransaction::unit_id(self : ModbusTransaction) -> Byte

    Mode

    source
    pub(all) enum Mode {
      Rtu
      Ascii
      Tcp
    } derive(Eq, 
    Debug    )

    A Modbus wire mode.

    MovingAverage

    source
    pub(all) struct MovingAverage {
      values : Array[Int]
      max_values : Int
    }

    Fixed-size moving average with integer arithmetic.

    MovingAverage::average

    source
    fn MovingAverage::average(self : MovingAverage) -> Result[Int, ModbusError]

    MovingAverage::clear

    source
    fn MovingAverage::clear(self : MovingAverage) -> Unit

    MovingAverage::length

    source
    fn MovingAverage::length(self : MovingAverage) -> Int

    MovingAverage::new

    source
    fn MovingAverage::new(max_values : Int) -> Result[MovingAverage, ModbusError]

    MovingAverage::push

    source
    fn MovingAverage::push(self : MovingAverage, value : Int) -> Unit

    MovingAverage::snapshot

    source
    fn MovingAverage::snapshot(self : MovingAverage) -> Array[Int]

    NetworkTopology

    source
    pub(all) struct NetworkTopology {
      nodes : Array[TopologyNode]
      links : Array[TopologyLink]
      max_nodes : Int
      max_links : Int
    }

    A mutable topology graph used by gateway routing and deployment tools.
    fn NetworkTopology::add_link(self : NetworkTopology, link : TopologyLink) -> Result[Unit, ModbusError]

    NetworkTopology::add_node

    source
    fn NetworkTopology::add_node(self : NetworkTopology, node : TopologyNode) -> Result[Unit, ModbusError]

    fn NetworkTopology::busy_links(self : NetworkTopology, threshold : Int) -> Result[Array[String], ModbusError]

    Return links at or above a utilization threshold.

    NetworkTopology::has_node

    source
    fn NetworkTopology::has_node(self : NetworkTopology, id : String) -> Bool

    fn NetworkTopology::link(self : NetworkTopology, id : String) -> TopologyLink?

    fn NetworkTopology::link_count(self : NetworkTopology) -> Int

    fn NetworkTopology::max_links(self : NetworkTopology) -> Int

    NetworkTopology::max_nodes

    source
    fn NetworkTopology::max_nodes(self : NetworkTopology) -> Int

    NetworkTopology::new

    source
    fn NetworkTopology::new(max_nodes? : Int, max_links? : Int) -> Result[NetworkTopology, ModbusError]

    NetworkTopology::node

    source
    fn NetworkTopology::node(self : NetworkTopology, id : String) -> TopologyNode?

    NetworkTopology::node_count

    source
    fn NetworkTopology::node_count(self : NetworkTopology) -> Int

    NetworkTopology::remove_node

    source
    fn NetworkTopology::remove_node(self : NetworkTopology, id : String) -> Result[TopologyNode, ModbusError]

    NetworkTopology::route

    source
    fn NetworkTopology::route(self : NetworkTopology, source : String, destination : String) -> Result[TopologyRoute, ModbusError]

    Find a low-cost path with a bounded Bellman-Ford relaxation.
    fn NetworkTopology::set_link_utilization(self : NetworkTopology, id : String, utilization : Int) -> Result[Unit, ModbusError]

    NetworkTopology::set_node_health

    source
    fn NetworkTopology::set_node_health(self : NetworkTopology, id : String, health : TopologyHealth) -> Result[Unit, ModbusError]

    NetworkTopology::unhealthy_nodes

    source
    fn NetworkTopology::unhealthy_nodes(self : NetworkTopology) -> Array[String]

    Return all nodes whose health is not currently healthy.

    NetworkTopology::validate

    source

    Validate graph references, duplicate identifiers, and unit assignments.

    ObservabilityDigest

    source
    pub(all) struct ObservabilityDigest {
      metric_series : Int
      samples : Int
      counters : Int
      gauges : Int
      latest_timestamp : Int
    }

    Snapshot counts for a service status endpoint.

    ObservabilityDigest::counters

    source
    fn ObservabilityDigest::counters(self : ObservabilityDigest) -> Int

    ObservabilityDigest::gauges

    source
    fn ObservabilityDigest::gauges(self : ObservabilityDigest) -> Int

    ObservabilityDigest::latest_timestamp

    source
    fn ObservabilityDigest::latest_timestamp(self : ObservabilityDigest) -> Int

    ObservabilityDigest::metric_series

    source
    fn ObservabilityDigest::metric_series(self : ObservabilityDigest) -> Int

    ObservabilityDigest::samples

    source
    fn ObservabilityDigest::samples(self : ObservabilityDigest) -> Int

    ParserRole

    source
    pub(all) enum ParserRole {
      Request
      Response
      Either
    } derive(Eq, 
    Debug    )

    The side of a stream that an incremental parser is consuming.

    Pdu

    source
    pub(all) struct Pdu {
      function : Byte
      data : Array[Byte]
    }

    A Modbus application data unit without transport framing.

    Pdu::data_length

    source
    fn Pdu::data_length(self : Pdu) -> Int

    Pdu::function_code

    source
    fn Pdu::function_code(self : Pdu) -> FunctionCode

    Pdu::is_exception

    source
    fn Pdu::is_exception(self : Pdu) -> Bool

    Pdu::new

    source
    fn Pdu::new(function : Byte, data : Array[Byte]) -> Pdu

    PeerGuardState

    source
    pub(all) struct PeerGuardState {
      peer : String
      timestamps : Array[Int]
      fingerprints : Array[(FrameFingerprint, Int)]
      accepted : Int
      rejected : Int
    }

    Per-peer admission state.

    PeerGuardState::accepted

    source
    fn PeerGuardState::accepted(self : PeerGuardState) -> Int

    PeerGuardState::duplicate

    source
    fn PeerGuardState::duplicate(self : PeerGuardState, fingerprint : FrameFingerprint, now : Int, policy : ProtocolGuardPolicy) -> Bool

    PeerGuardState::frame_count

    source
    fn PeerGuardState::frame_count(self : PeerGuardState) -> Int

    PeerGuardState::new

    source
    fn PeerGuardState::new(peer : String) -> Result[PeerGuardState, ModbusError]

    PeerGuardState::peer

    source
    fn PeerGuardState::peer(self : PeerGuardState) -> String

    PeerGuardState::prune

    source
    fn PeerGuardState::prune(self : PeerGuardState, now : Int, policy : ProtocolGuardPolicy) -> Result[Unit, ModbusError]

    PeerGuardState::record

    source
    fn PeerGuardState::record(self : PeerGuardState, fingerprint : FrameFingerprint, now : Int, accepted : Bool) -> Unit

    PeerGuardState::rejected

    source
    fn PeerGuardState::rejected(self : PeerGuardState) -> Int

    PendingExchange

    source
    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

    source
    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

    source
    pub(all) struct PlannedRequest {
      id : Int
      frame : Frame
      address : AddressRange
    }

    A range request planner that splits large logical reads into legal PDUs.

    PollArea

    source
    pub(all) enum PollArea {
      PollCoils
      PollDiscreteInputs
      PollHoldingRegisters
      PollInputRegisters
    } derive(Eq, 
    Debug    )

    Address space selected by a polling point.

    PollBudget

    source
    pub(all) struct PollBudget {
      max_requests : Int
      max_registers : Int
      requests : Int
      registers : Int
      rejected : Int
    }

    A budget for limiting requests emitted in one scheduler cycle.

    PollBudget::accept

    source
    fn PollBudget::accept(self : PollBudget, group : PollRequestGroup) -> Bool

    PollBudget::max_registers

    source
    fn PollBudget::max_registers(self : PollBudget) -> Int

    PollBudget::max_requests

    source
    fn PollBudget::max_requests(self : PollBudget) -> Int

    PollBudget::new

    source
    fn PollBudget::new(max_requests : Int, max_registers : Int) -> Result[PollBudget, ModbusError]

    PollBudget::registers

    source
    fn PollBudget::registers(self : PollBudget) -> Int

    PollBudget::rejected

    source
    fn PollBudget::rejected(self : PollBudget) -> Int

    PollBudget::remaining_registers

    source
    fn PollBudget::remaining_registers(self : PollBudget) -> Int

    PollBudget::remaining_requests

    source
    fn PollBudget::remaining_requests(self : PollBudget) -> Int

    PollBudget::requests

    source
    fn PollBudget::requests(self : PollBudget) -> Int

    PollBudget::reset

    source
    fn PollBudget::reset(self : PollBudget) -> Unit

    PollGroupPlan

    source
    pub(all) struct PollGroupPlan {
      points : Array[PollPoint]
      groups : Array[PollRequestGroup]
      max_groups : Int
      merge_gap : Int
      revision : Int
    }

    A complete plan generated from point definitions.

    PollGroupPlan::add_point

    source
    fn PollGroupPlan::add_point(self : PollGroupPlan, point : PollPoint) -> Result[Unit, ModbusError]

    PollGroupPlan::budgeted

    source
    fn PollGroupPlan::budgeted(self : PollGroupPlan, budget : PollBudget) -> Array[PollRequestGroup]

    Produce a budgeted batch while preserving group priority order.

    PollGroupPlan::due_groups

    source
    fn PollGroupPlan::due_groups(self : PollGroupPlan, now : Int, last_run : Array[(String, Int)]) -> Result[Array[String], ModbusError]

    PollGroupPlan::group_count

    source
    fn PollGroupPlan::group_count(self : PollGroupPlan) -> Int

    PollGroupPlan::groups

    source

    PollGroupPlan::groups_for

    source
    fn PollGroupPlan::groups_for(self : PollGroupPlan, device_id : String) -> Array[PollRequestGroup]

    PollGroupPlan::new

    source
    fn PollGroupPlan::new(max_groups? : Int, merge_gap? : Int) -> Result[PollGroupPlan, ModbusError]

    PollGroupPlan::point_count

    source
    fn PollGroupPlan::point_count(self : PollGroupPlan) -> Int

    PollGroupPlan::points

    source

    PollGroupPlan::rebuild

    source
    fn PollGroupPlan::rebuild(self : PollGroupPlan) -> Unit

    Rebuild groups using a stable address order and contiguous coalescing.

    PollGroupPlan::remove_point

    source
    fn PollGroupPlan::remove_point(self : PollGroupPlan, id : String) -> Result[PollPoint, ModbusError]

    PollGroupPlan::request_for

    source
    fn PollGroupPlan::request_for(self : PollGroupPlan, group_id : String) -> Result[Frame, ModbusError]

    PollGroupPlan::revision

    source
    fn PollGroupPlan::revision(self : PollGroupPlan) -> Int

    PollGroupPlan::stats

    source

    PollGroupPlan::validate

    source
    fn PollGroupPlan::validate(self : PollGroupPlan) -> Array[ModbusError]

    PollJob

    source
    pub(all) struct PollJob {
      id : Int
      name : String
      request : Frame
      interval : Int
      timeout : Int
      retries : Int
      next_due : Int
      attempts : Int
      runs : Int
      failures : Int
      last_response : Frame?
    }

    A polling job with a deterministic logical-clock schedule.

    PollJob::is_due

    source
    fn PollJob::is_due(self : PollJob, now : Int) -> Bool

    PollJob::mark_failure

    source
    fn PollJob::mark_failure(self : PollJob, now : Int) -> Unit

    PollJob::mark_success

    source
    fn PollJob::mark_success(self : PollJob, now : Int, response : Frame) -> Unit

    PollJob::new

    source
    fn PollJob::new(id : Int, name : String, request : Frame, interval? : Int, timeout? : Int, retries? : Int) -> Result[PollJob, ModbusError]

    PollJob::success_rate

    source
    fn PollJob::success_rate(self : PollJob) -> Float

    PollPlan

    source
    pub struct PollPlan {
      jobs : Array[PollJob]
      max_jobs : Int
    }

    A polling plan keeps jobs ordered and addresses them by stable ids.

    PollPlan::add

    source
    fn PollPlan::add(self : PollPlan, job : PollJob) -> Result[Unit, ModbusError]

    PollPlan::due

    source
    fn PollPlan::due(self : PollPlan, now : Int) -> Array[PollJob]

    PollPlan::job

    source
    fn PollPlan::job(self : PollPlan, id : Int) -> PollJob?

    PollPlan::length

    source
    fn PollPlan::length(self : PollPlan) -> Int

    PollPlan::mark_failure

    source
    fn PollPlan::mark_failure(self : PollPlan, id : Int, now : Int) -> Result[Unit, ModbusError]

    PollPlan::mark_success

    source
    fn PollPlan::mark_success(self : PollPlan, id : Int, now : Int, response : Frame) -> Result[Unit, ModbusError]

    PollPlan::new

    source
    fn PollPlan::new(max_jobs? : Int) -> Result[PollPlan, ModbusError]

    PollPlan::remove

    source
    fn PollPlan::remove(self : PollPlan, id : Int) -> Result[Unit, ModbusError]

    PollPlan::run_once

    source
    fn PollPlan::run_once(self : PollPlan, device : Device, now : Int) -> PollReport

    Execute due jobs against a deterministic device.

    PollPlan::snapshot

    source
    fn PollPlan::snapshot(self : PollPlan) -> Array[PollJob]

    PollPlanStats

    source
    pub(all) struct PollPlanStats {
      points : Int
      enabled_points : Int
      groups : Int
      merged_points : Int
      estimated_registers : Int
      highest_priority : Int
    }

    A plan statistic used to tune address maps and transport budgets.

    PollPlanStats::enabled_points

    source
    fn PollPlanStats::enabled_points(self : PollPlanStats) -> Int

    PollPlanStats::estimated_registers

    source
    fn PollPlanStats::estimated_registers(self : PollPlanStats) -> Int

    PollPlanStats::groups

    source
    fn PollPlanStats::groups(self : PollPlanStats) -> Int

    PollPlanStats::highest_priority

    source
    fn PollPlanStats::highest_priority(self : PollPlanStats) -> Int

    PollPlanStats::merged_points

    source
    fn PollPlanStats::merged_points(self : PollPlanStats) -> Int

    PollPlanStats::points

    source
    fn PollPlanStats::points(self : PollPlanStats) -> Int

    PollPoint

    source
    pub(all) struct PollPoint {
      id : String
      device_id : String
      unit_id : Byte
      area : PollArea
      address : UInt16
      quantity : Int
      period : Int
      priority : Int
      enabled : Bool
    }

    A point requested by a periodic acquisition job.

    PollPoint::address

    source
    fn PollPoint::address(self : PollPoint) -> UInt16

    PollPoint::area

    source
    fn PollPoint::area(self : PollPoint) -> PollArea

    PollPoint::device_id

    source
    fn PollPoint::device_id(self : PollPoint) -> String

    PollPoint::enabled

    source
    fn PollPoint::enabled(self : PollPoint) -> Bool

    PollPoint::end_exclusive

    source
    fn PollPoint::end_exclusive(self : PollPoint) -> Int

    PollPoint::id

    source
    fn PollPoint::id(self : PollPoint) -> String

    PollPoint::new

    source
    fn PollPoint::new(id : String, device_id : String, unit_id : Byte, area : PollArea, address : UInt16, quantity : Int, period : Int, priority? : Int) -> Result[PollPoint, ModbusError]

    PollPoint::overlaps

    source
    fn PollPoint::overlaps(self : PollPoint, other : PollPoint) -> Bool

    PollPoint::period

    source
    fn PollPoint::period(self : PollPoint) -> Int

    PollPoint::priority

    source
    fn PollPoint::priority(self : PollPoint) -> Int

    PollPoint::quantity

    source
    fn PollPoint::quantity(self : PollPoint) -> Int

    PollPoint::set_enabled

    source
    fn PollPoint::set_enabled(self : PollPoint, enabled : Bool) -> Unit

    PollPoint::unit_id

    source
    fn PollPoint::unit_id(self : PollPoint) -> Byte

    PollReport

    source
    pub(all) struct PollReport {
      now : Int
      attempted : Int
      succeeded : Int
      failed : Int
      responses : Array[Frame]
    }

    One scheduler run result.

    PollRequestGroup

    source
    pub(all) struct PollRequestGroup {
      id : String
      device_id : String
      unit_id : Byte
      area : PollArea
      address : UInt16
      quantity : Int
      points : Array[String]
      period : Int
      priority : Int
    }

    A contiguous request made from one or more polling points.

    PollRequestGroup::address

    source
    fn PollRequestGroup::address(self : PollRequestGroup) -> UInt16

    PollRequestGroup::area

    source

    PollRequestGroup::can_merge

    source
    fn PollRequestGroup::can_merge(self : PollRequestGroup, point : PollPoint, gap : Int) -> Bool

    PollRequestGroup::device_id

    source
    fn PollRequestGroup::device_id(self : PollRequestGroup) -> String

    PollRequestGroup::end_exclusive

    source
    fn PollRequestGroup::end_exclusive(self : PollRequestGroup) -> Int

    PollRequestGroup::id

    source
    fn PollRequestGroup::id(self : PollRequestGroup) -> String

    PollRequestGroup::merge

    source
    fn PollRequestGroup::merge(self : PollRequestGroup, point : PollPoint) -> Result[Unit, ModbusError]

    PollRequestGroup::new

    source
    fn PollRequestGroup::new(id : String, first : PollPoint) -> PollRequestGroup

    PollRequestGroup::period

    source
    fn PollRequestGroup::period(self : PollRequestGroup) -> Int

    PollRequestGroup::point_count

    source
    fn PollRequestGroup::point_count(self : PollRequestGroup) -> Int

    PollRequestGroup::points

    source
    fn PollRequestGroup::points(self : PollRequestGroup) -> Array[String]

    PollRequestGroup::priority

    source
    fn PollRequestGroup::priority(self : PollRequestGroup) -> Int

    PollRequestGroup::quantity

    source
    fn PollRequestGroup::quantity(self : PollRequestGroup) -> Int

    PollRequestGroup::request

    source
    fn PollRequestGroup::request(self : PollRequestGroup) -> Result[Frame, ModbusError]

    Build the request frame for a contiguous poll group.

    PollRequestGroup::summary

    source
    fn PollRequestGroup::summary(self : PollRequestGroup) -> String

    PollRequestGroup::unit_id

    source
    fn PollRequestGroup::unit_id(self : PollRequestGroup) -> Byte

    PollScheduler

    source
    pub struct PollScheduler {
      plan : PollPlan
      device : Device
      mode : Mode
      last_report : PollReport?
    }

    A scheduler that records the last report and applies a transport mode.

    PollScheduler::last_report

    source
    fn PollScheduler::last_report(self : PollScheduler) -> PollReport?

    PollScheduler::mode

    source
    fn PollScheduler::mode(self : PollScheduler) -> Mode

    PollScheduler::new

    source
    fn PollScheduler::new(plan : PollPlan, device : Device, mode : Mode) -> PollScheduler

    PollScheduler::plan

    source

    PollScheduler::tick

    source
    fn PollScheduler::tick(self : PollScheduler, now : Int) -> PollReport

    PreflightReport

    source
    pub(all) struct PreflightReport {
      errors : Array[String]
      warnings : Array[String]
      checked_frames : Int
      checked_devices : Int
    }

    A structured preflight report for deployment and CI diagnostics.

    PreflightReport::error_count

    source
    fn PreflightReport::error_count(self : PreflightReport) -> Int

    PreflightReport::errors

    source
    fn PreflightReport::errors(self : PreflightReport) -> Array[String]

    PreflightReport::new

    source

    PreflightReport::ok

    source
    fn PreflightReport::ok(self : PreflightReport) -> Bool

    PreflightReport::warning_count

    source
    fn PreflightReport::warning_count(self : PreflightReport) -> Int

    PreflightReport::warnings

    source
    fn PreflightReport::warnings(self : PreflightReport) -> Array[String]

    ProfileArea

    source
    pub(all) enum ProfileArea {
      Coils
      DiscreteInputs
      HoldingRegisters
      InputRegisters
    } derive(Eq, 
    Debug    )

    A logical address area used by a device profile.

    ProfileEncoding

    source
    pub(all) enum ProfileEncoding {
      Bit
      Unsigned16
      Signed16
      Unsigned32
      Signed32
      Unsigned64
      RawWords
    } derive(Eq, 
    Debug    )

    Encoding used when a profile point is mapped to registers.

    ProfilePoint

    source
    pub(all) struct ProfilePoint {
      id : String
      label : String
      area : ProfileArea
      address : UInt16
      quantity : Int
      encoding : ProfileEncoding
      writable : Bool
      scale_numerator : Int
      scale_denominator : Int
      offset : Int
    }

    A single named data point exposed by an industrial device.

    ProfilePoint::address

    source
    fn ProfilePoint::address(self : ProfilePoint) -> UInt16

    ProfilePoint::area

    source

    ProfilePoint::contains

    source
    fn ProfilePoint::contains(self : ProfilePoint, address : UInt16) -> Bool

    ProfilePoint::contains_range

    source
    fn ProfilePoint::contains_range(self : ProfilePoint, address : UInt16, length : Int) -> Bool

    ProfilePoint::encoding

    source
    fn ProfilePoint::encoding(self : ProfilePoint) -> ProfileEncoding

    ProfilePoint::end_exclusive

    source
    fn ProfilePoint::end_exclusive(self : ProfilePoint) -> Int

    ProfilePoint::engineering_to_raw

    source
    fn ProfilePoint::engineering_to_raw(self : ProfilePoint, value : Int) -> Result[Int, ModbusError]

    ProfilePoint::function_code

    source
    fn ProfilePoint::function_code(self : ProfilePoint) -> Byte

    ProfilePoint::id

    source
    fn ProfilePoint::id(self : ProfilePoint) -> String

    ProfilePoint::label

    source
    fn ProfilePoint::label(self : ProfilePoint) -> String

    ProfilePoint::new

    source
    fn ProfilePoint::new(id : String, label : String, area : ProfileArea, address : UInt16, quantity : Int, encoding : ProfileEncoding, writable? : Bool, scale_numerator? : Int, scale_denominator? : Int, offset? : Int) -> Result[ProfilePoint, ModbusError]

    ProfilePoint::offset

    source
    fn ProfilePoint::offset(self : ProfilePoint) -> Int

    ProfilePoint::quantity

    source
    fn ProfilePoint::quantity(self : ProfilePoint) -> Int

    ProfilePoint::raw_to_engineering

    source
    fn ProfilePoint::raw_to_engineering(self : ProfilePoint, raw : Int) -> Int

    ProfilePoint::read_request

    source
    fn ProfilePoint::read_request(self : ProfilePoint, unit_id : Byte) -> Result[Frame, ModbusError]

    ProfilePoint::register_count

    source
    fn ProfilePoint::register_count(self : ProfilePoint) -> Int

    ProfilePoint::scale_denominator

    source
    fn ProfilePoint::scale_denominator(self : ProfilePoint) -> Int

    ProfilePoint::scale_numerator

    source
    fn ProfilePoint::scale_numerator(self : ProfilePoint) -> Int

    ProfilePoint::summary

    source
    fn ProfilePoint::summary(self : ProfilePoint) -> String

    ProfilePoint::writable

    source
    fn ProfilePoint::writable(self : ProfilePoint) -> Bool

    ProfilePoint::write_request

    source
    fn ProfilePoint::write_request(self : ProfilePoint, unit_id : Byte, value : Int) -> Result[Frame, ModbusError]

    ProfileRegistry

    source
    pub(all) struct ProfileRegistry {
      profiles : Array[DeviceProfile]
      max_profiles : Int
    }

    Registry for profiles loaded from an application configuration.

    ProfileRegistry::add

    source
    fn ProfileRegistry::add(self : ProfileRegistry, profile : DeviceProfile) -> Result[Unit, ModbusError]

    ProfileRegistry::by_name

    source
    fn ProfileRegistry::by_name(self : ProfileRegistry, name : String) -> DeviceProfile?

    ProfileRegistry::by_unit

    source
    fn ProfileRegistry::by_unit(self : ProfileRegistry, unit_id : Byte) -> DeviceProfile?

    ProfileRegistry::count

    source
    fn ProfileRegistry::count(self : ProfileRegistry) -> Int

    ProfileRegistry::new

    source
    fn ProfileRegistry::new(max_profiles? : Int) -> Result[ProfileRegistry, ModbusError]

    ProfileRegistry::remove_by_name

    source
    fn ProfileRegistry::remove_by_name(self : ProfileRegistry, name : String) -> Result[DeviceProfile, ModbusError]

    ProfileRegistry::replace

    source
    fn ProfileRegistry::replace(self : ProfileRegistry, profile : DeviceProfile) -> Result[Unit, ModbusError]

    ProfileRegistry::snapshot

    source

    ProfileValue

    source
    pub(all) enum ProfileValue {
      BitValue(Bool)
      U16(UInt16)
      I16(Int)
      U32(UInt)
      I32(Int)
      U64(UInt64)
      Words(Array[UInt16])
    } derive(
    Debug    )

    A typed value returned by a profile point decoder.

    ProfileValue::as_int

    source
    fn ProfileValue::as_int(self : ProfileValue) -> Result[Int, ModbusError]

    ProfileValue::summary

    source
    fn ProfileValue::summary(self : ProfileValue) -> String

    ProfileValue::word_count

    source
    fn ProfileValue::word_count(self : ProfileValue) -> Int

    ProtocolGuard

    source
    pub(all) struct ProtocolGuard {
      policy : ProtocolGuardPolicy
      peers : Array[PeerGuardState]
      events : Array[GuardEvent]
      max_peers : Int
      max_events : Int
      sequence : Int
    }

    A protocol admission guard safe to use before decoding application data.

    ProtocolGuard::admit

    source
    fn ProtocolGuard::admit(self : ProtocolGuard, peer_name : String, frame : Frame, now : Int) -> Result[GuardDecision, ModbusError]

    Validate and record a frame before transport-specific decoding.

    ProtocolGuard::clear_events

    source
    fn ProtocolGuard::clear_events(self : ProtocolGuard) -> Unit

    Flush historical events while retaining peer counters.

    ProtocolGuard::decision_counts

    source
    fn ProtocolGuard::decision_counts(self : ProtocolGuard) -> Array[Int]

    ProtocolGuard::event_count

    source
    fn ProtocolGuard::event_count(self : ProtocolGuard) -> Int

    ProtocolGuard::new

    source
    fn ProtocolGuard::new(policy : ProtocolGuardPolicy, max_peers? : Int, max_events? : Int) -> Result[ProtocolGuard, ModbusError]

    ProtocolGuard::peer_count

    source
    fn ProtocolGuard::peer_count(self : ProtocolGuard) -> Int

    ProtocolGuard::peer_stats

    source
    fn ProtocolGuard::peer_stats(self : ProtocolGuard, name : String) -> Result[(Int, Int), ModbusError]

    ProtocolGuard::policy

    source

    ProtocolGuard::recent_events

    source
    fn ProtocolGuard::recent_events(self : ProtocolGuard, limit : Int) -> Result[Array[GuardEvent], ModbusError]

    ProtocolGuardPolicy

    source
    pub(all) struct ProtocolGuardPolicy {
      max_frame_bytes : Int
      max_frames : Int
      window : Int
      duplicate_window : Int
      allow_broadcast : Bool
      functions : Array[Byte]
    }

    Per-peer frame quota and size policy.

    ProtocolGuardPolicy::add_function

    source
    fn ProtocolGuardPolicy::add_function(self : ProtocolGuardPolicy, function : Byte) -> Result[Unit, ModbusError]

    ProtocolGuardPolicy::allow_broadcast

    source
    fn ProtocolGuardPolicy::allow_broadcast(self : ProtocolGuardPolicy) -> Bool

    ProtocolGuardPolicy::duplicate_window

    source
    fn ProtocolGuardPolicy::duplicate_window(self : ProtocolGuardPolicy) -> Int

    ProtocolGuardPolicy::function_allowed

    source
    fn ProtocolGuardPolicy::function_allowed(self : ProtocolGuardPolicy, function : Byte) -> Bool

    ProtocolGuardPolicy::max_frame_bytes

    source
    fn ProtocolGuardPolicy::max_frame_bytes(self : ProtocolGuardPolicy) -> Int

    ProtocolGuardPolicy::max_frames

    source
    fn ProtocolGuardPolicy::max_frames(self : ProtocolGuardPolicy) -> Int

    ProtocolGuardPolicy::new

    source
    fn ProtocolGuardPolicy::new(max_frame_bytes? : Int, max_frames? : Int, window? : Int, duplicate_window? : Int, allow_broadcast? : Bool) -> Result[ProtocolGuardPolicy, ModbusError]

    ProtocolGuardPolicy::window

    source
    fn ProtocolGuardPolicy::window(self : ProtocolGuardPolicy) -> Int

    ProtocolLimits

    source
    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

    source
    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::active

    source
    fn ProtocolMetrics::active(self : ProtocolMetrics) -> Int

    ProtocolMetrics::errors

    source
    fn ProtocolMetrics::errors(self : ProtocolMetrics) -> Int

    ProtocolMetrics::exceptions

    source
    fn ProtocolMetrics::exceptions(self : ProtocolMetrics) -> Int

    ProtocolMetrics::new

    source

    ProtocolMetrics::record_error

    source
    fn ProtocolMetrics::record_error(self : ProtocolMetrics) -> Unit

    ProtocolMetrics::record_request

    source
    fn ProtocolMetrics::record_request(self : ProtocolMetrics, bytes : Int) -> Result[Unit, ModbusError]

    ProtocolMetrics::record_response

    source
    fn ProtocolMetrics::record_response(self : ProtocolMetrics, bytes : Int, latency : Int, exception : Bool) -> Result[Unit, ModbusError]

    ProtocolMetrics::requests

    source
    fn ProtocolMetrics::requests(self : ProtocolMetrics) -> Int

    ProtocolMetrics::responses

    source
    fn ProtocolMetrics::responses(self : ProtocolMetrics) -> Int

    ProtocolMetrics::throughput

    source
    fn ProtocolMetrics::throughput(self : ProtocolMetrics, ticks : Int) -> Float

    QualityDecision

    source
    pub(all) enum QualityDecision {
      QualityAccepted
      QualitySubstituted
      QualityRejected
      QualityDeferred
    } derive(Eq, 
    Debug    )

    Decision produced by a quality pipeline.

    QualityFinding

    source
    pub(all) struct QualityFinding {
      rule_id : String
      point_id : String
      check_kind : QualityTest
      decision : QualityDecision
      value : Int
      timestamp : Int
      message : String
    }

    One quality evaluation with stable evidence for the operator.

    QualityFinding::check_kind

    source
    fn QualityFinding::check_kind(self : QualityFinding) -> QualityTest

    QualityFinding::decision

    source

    QualityFinding::message

    source
    fn QualityFinding::message(self : QualityFinding) -> String

    QualityFinding::new

    source
    fn QualityFinding::new(rule : QualityRule, decision : QualityDecision, value : Int, timestamp : Int, message : String) -> Result[QualityFinding, ModbusError]

    QualityFinding::point_id

    source
    fn QualityFinding::point_id(self : QualityFinding) -> String

    QualityFinding::rule_id

    source
    fn QualityFinding::rule_id(self : QualityFinding) -> String

    QualityFinding::timestamp

    source
    fn QualityFinding::timestamp(self : QualityFinding) -> Int

    QualityFinding::value

    source
    fn QualityFinding::value(self : QualityFinding) -> Int

    QualityPipeline

    source
    pub(all) struct QualityPipeline {
      rules : Array[QualityRule]
      findings : Array[QualityFinding]
      max_findings : Int
    }

    Ordered rules and recent findings for a point pipeline.

    QualityPipeline::add_rule

    source
    fn QualityPipeline::add_rule(self : QualityPipeline, rule : QualityRule) -> Result[Unit, ModbusError]

    QualityPipeline::evaluate

    source
    fn QualityPipeline::evaluate(self : QualityPipeline, point_id : String, value : Int, timestamp : Int, previous? : Int?, previous_timestamp? : Int?) -> Result[QualityDecision, ModbusError]

    Evaluate all rules for a point and retain every finding.

    QualityPipeline::finding_count

    source
    fn QualityPipeline::finding_count(self : QualityPipeline) -> Int

    QualityPipeline::findings_for

    source
    fn QualityPipeline::findings_for(self : QualityPipeline, point_id : String) -> Array[QualityFinding]

    QualityPipeline::new

    source
    fn QualityPipeline::new(max_findings? : Int) -> Result[QualityPipeline, ModbusError]

    QualityPipeline::rejected

    source
    fn QualityPipeline::rejected(self : QualityPipeline) -> Int

    QualityPipeline::rule

    source
    fn QualityPipeline::rule(self : QualityPipeline, id : String) -> QualityRule?

    QualityPipeline::rule_count

    source
    fn QualityPipeline::rule_count(self : QualityPipeline) -> Int

    QualityPipeline::substituted

    source
    fn QualityPipeline::substituted(self : QualityPipeline) -> Int

    QualityPipeline::summary

    source
    fn QualityPipeline::summary(self : QualityPipeline, point_id : String) -> QualitySummary

    QualityRule

    source
    pub(all) struct QualityRule {
      id : String
      point_id : String
      check_kind : QualityTest
      lower : Int?
      upper : Int?
      limit : Int
      allowed : Array[Int]
      enabled : Bool
    }

    A field-level quality rule.

    QualityRule::allow_value

    source
    fn QualityRule::allow_value(self : QualityRule, value : Int) -> Result[Unit, ModbusError]

    QualityRule::check_kind

    source
    fn QualityRule::check_kind(self : QualityRule) -> QualityTest

    QualityRule::enabled

    source
    fn QualityRule::enabled(self : QualityRule) -> Bool

    QualityRule::evaluate

    source
    fn QualityRule::evaluate(self : QualityRule, value : Int, timestamp : Int, previous : Int?, previous_timestamp : Int?) -> Result[QualityFinding, ModbusError]

    Evaluate a rule against current and previous observations.

    QualityRule::id

    source
    fn QualityRule::id(self : QualityRule) -> String

    QualityRule::limit

    source
    fn QualityRule::limit(self : QualityRule) -> Int

    QualityRule::lower

    source
    fn QualityRule::lower(self : QualityRule) -> Int?

    QualityRule::new

    source
    fn QualityRule::new(id : String, point_id : String, check_kind : QualityTest, lower? : Int, upper? : Int, limit? : Int) -> Result[QualityRule, ModbusError]

    QualityRule::point_id

    source
    fn QualityRule::point_id(self : QualityRule) -> String

    QualityRule::set_enabled

    source
    fn QualityRule::set_enabled(self : QualityRule, enabled : Bool) -> Unit

    QualityRule::upper

    source
    fn QualityRule::upper(self : QualityRule) -> Int?

    QualitySummary

    source
    pub(all) struct QualitySummary {
      accepted : Int
      substituted : Int
      rejected : Int
      deferred : Int
    }

    A compact quality summary for one point.

    QualitySummary::accepted

    source
    fn QualitySummary::accepted(self : QualitySummary) -> Int

    QualitySummary::deferred

    source
    fn QualitySummary::deferred(self : QualitySummary) -> Int

    QualitySummary::rejected

    source
    fn QualitySummary::rejected(self : QualitySummary) -> Int

    QualitySummary::substituted

    source
    fn QualitySummary::substituted(self : QualitySummary) -> Int

    QualityTest

    source
    pub(all) enum QualityTest {
      RangeTest
      FreshnessTest
      StepTest
      DuplicateTest
      EnumTest
      RequiredTest
    } derive(Eq, 
    Debug    )

    Quality test applied to a decoded point value.

    RateLimiter

    source
    pub(all) struct RateLimiter {
      max_delta : Int
      previous : Int?
    }

    Simple rate limiter for noisy integer signals.

    RateLimiter::apply

    source
    fn RateLimiter::apply(self : RateLimiter, value : Int) -> Int

    RateLimiter::max_delta

    source
    fn RateLimiter::max_delta(self : RateLimiter) -> Int

    RateLimiter::new

    source
    fn RateLimiter::new(max_delta : Int) -> Result[RateLimiter, ModbusError]

    RateLimiter::reset

    source
    fn RateLimiter::reset(self : RateLimiter) -> Unit

    RateWindow

    source
    pub(all) struct RateWindow {
      width : Int
      limit : Int
      timestamps : Array[Int]
    }

    A fixed-size request window for rate limiting a transport or unit.

    RateWindow::allow

    source
    fn RateWindow::allow(self : RateWindow, now : Int) -> Bool

    RateWindow::count

    source
    fn RateWindow::count(self : RateWindow, now : Int) -> Int

    RateWindow::limit

    source
    fn RateWindow::limit(self : RateWindow) -> Int

    RateWindow::new

    source
    fn RateWindow::new(width : Int, limit : Int) -> Result[RateWindow, ModbusError]

    RateWindow::prune

    source
    fn RateWindow::prune(self : RateWindow, now : Int) -> Unit

    RateWindow::remaining

    source
    fn RateWindow::remaining(self : RateWindow, now : Int) -> Int

    RateWindow::reset

    source
    fn RateWindow::reset(self : RateWindow) -> Unit

    RateWindow::width

    source
    fn RateWindow::width(self : RateWindow) -> Int

    ReadingQuality

    source
    pub(all) enum ReadingQuality {
      Good
      OutOfRange
      Stale
      Disconnected
      BadFormat
      Substituted
    } derive(Eq, 
    Debug    )

    Quality assigned to a value after conversion and filtering.

    ReconciliationDiff

    source
    pub(all) struct ReconciliationDiff {
      point_id : String
      kind : ReconciliationKind
      expected : Int?
      observed : Int?
      detail : String
    }

    One difference between an expected and observed snapshot.

    ReconciliationDiff::detail

    source
    fn ReconciliationDiff::detail(self : ReconciliationDiff) -> String

    ReconciliationDiff::expected

    source
    fn ReconciliationDiff::expected(self : ReconciliationDiff) -> Int?

    ReconciliationDiff::kind

    source

    ReconciliationDiff::new

    source
    fn ReconciliationDiff::new(point_id : String, kind : ReconciliationKind, expected? : Int, observed? : Int, detail? : String) -> Result[ReconciliationDiff, ModbusError]

    ReconciliationDiff::observed

    source
    fn ReconciliationDiff::observed(self : ReconciliationDiff) -> Int?

    ReconciliationDiff::point_id

    source
    fn ReconciliationDiff::point_id(self : ReconciliationDiff) -> String

    ReconciliationKind

    source
    pub(all) enum ReconciliationKind {
      MissingPoint
      AddedPoint
      ValueChanged
      QualityChanged
      TimestampRegressed
      SnapshotComplete
    } derive(Eq, 
    Debug    )

    Difference class produced when comparing two device observations.

    ReconciliationReport

    source
    pub(all) struct ReconciliationReport {
      device_id : String
      compared : Int
      differences : Int
      missing : Int
      added : Int
      changed : Int
      equivalent : Bool
    }

    Accumulated reconciliation result for a device fleet.

    ReconciliationReport::added

    source

    ReconciliationReport::changed

    source
    fn ReconciliationReport::changed(self : ReconciliationReport) -> Int

    ReconciliationReport::compared

    source
    fn ReconciliationReport::compared(self : ReconciliationReport) -> Int

    ReconciliationReport::device_id

    source
    fn ReconciliationReport::device_id(self : ReconciliationReport) -> String

    ReconciliationReport::differences

    source
    fn ReconciliationReport::differences(self : ReconciliationReport) -> Int

    ReconciliationReport::equivalent

    source
    fn ReconciliationReport::equivalent(self : ReconciliationReport) -> Bool

    ReconciliationReport::missing

    source
    fn ReconciliationReport::missing(self : ReconciliationReport) -> Int

    RegisterBank

    source
    pub(all) struct RegisterBank {
      start : UInt16
      values : Array[UInt16]
      writable : Bool
    }

    A contiguous, bounds-checked register bank.

    RegisterBank::clear

    source
    fn RegisterBank::clear(self : RegisterBank) -> Unit

    RegisterBank::contains

    source
    fn RegisterBank::contains(self : RegisterBank, address : UInt16, quantity : Int) -> Bool

    RegisterBank::end_exclusive

    source
    fn RegisterBank::end_exclusive(self : RegisterBank) -> Int

    RegisterBank::fill

    source
    fn RegisterBank::fill(self : RegisterBank, value : UInt16) -> Unit

    RegisterBank::get

    source
    fn RegisterBank::get(self : RegisterBank, address : UInt16) -> Result[UInt16, ModbusError]

    RegisterBank::is_writable

    source
    fn RegisterBank::is_writable(self : RegisterBank) -> Bool

    RegisterBank::length

    source
    fn RegisterBank::length(self : RegisterBank) -> Int

    RegisterBank::new

    source
    fn RegisterBank::new(start : UInt16, length : Int, writable? : Bool) -> Result[RegisterBank, ModbusError]

    Create a register bank in the 16-bit address space.

    RegisterBank::read

    source
    fn RegisterBank::read(self : RegisterBank, address : UInt16, quantity : Int) -> Result[Array[UInt16], ModbusError]

    RegisterBank::set

    source
    fn RegisterBank::set(self : RegisterBank, address : UInt16, value : UInt16) -> Result[Unit, ModbusError]

    RegisterBank::snapshot

    source
    fn RegisterBank::snapshot(self : RegisterBank) -> Array[UInt16]

    RegisterBank::start

    source
    fn RegisterBank::start(self : RegisterBank) -> UInt16

    RegisterBank::write

    source
    fn RegisterBank::write(self : RegisterBank, address : UInt16, values : Array[UInt16]) -> Result[Unit, ModbusError]

    RegisterBank::write_mask

    source
    fn RegisterBank::write_mask(self : RegisterBank, address : UInt16, and_mask : UInt16, or_mask : UInt16) -> Result[UInt16, ModbusError]

    RegisterByteOrder

    source
    pub(all) enum RegisterByteOrder {
      BigEndian
      LittleEndian
    } derive(Eq, 
    Debug    )

    Register byte order used when mapping multi-register values.

    RegisterCursor

    source
    pub(all) struct RegisterCursor {
      values : Array[UInt16]
      position : Int
    }

    A bounds-checked cursor over an owned register array.

    RegisterCursor::at_end

    source
    fn RegisterCursor::at_end(self : RegisterCursor) -> Bool

    RegisterCursor::new

    source
    fn RegisterCursor::new(values : Array[UInt16]) -> RegisterCursor

    RegisterCursor::position

    source
    fn RegisterCursor::position(self : RegisterCursor) -> Int

    RegisterCursor::read_f32

    source
    fn RegisterCursor::read_f32(self : RegisterCursor, order : RegisterWordOrder) -> Result[Float, ModbusError]

    RegisterCursor::read_i16

    source
    fn RegisterCursor::read_i16(self : RegisterCursor) -> Result[Int, ModbusError]

    RegisterCursor::read_i32

    source
    fn RegisterCursor::read_i32(self : RegisterCursor, order : RegisterWordOrder) -> Result[Int, ModbusError]

    RegisterCursor::read_u16

    source
    fn RegisterCursor::read_u16(self : RegisterCursor) -> Result[UInt16, ModbusError]

    RegisterCursor::read_u32

    source
    fn RegisterCursor::read_u32(self : RegisterCursor, order : RegisterWordOrder) -> Result[UInt, ModbusError]

    RegisterCursor::read_u64

    source
    fn RegisterCursor::read_u64(self : RegisterCursor, order : RegisterWordOrder) -> Result[UInt64, ModbusError]

    RegisterCursor::remaining

    source
    fn RegisterCursor::remaining(self : RegisterCursor) -> Int

    RegisterCursor::seek

    source
    fn RegisterCursor::seek(self : RegisterCursor, position : Int) -> Result[Unit, ModbusError]

    RegisterCursor::skip

    source
    fn RegisterCursor::skip(self : RegisterCursor, count : Int) -> Result[Unit, ModbusError]

    RegisterField

    source
    pub(all) struct RegisterField {
      name : String
      address : UInt16
      kind : RegisterFieldKind
      writable : Bool
      scale : Float
    }

    A named register field with an explicit wire representation.

    RegisterField::address

    source
    fn RegisterField::address(self : RegisterField) -> UInt16

    RegisterField::is_writable

    source
    fn RegisterField::is_writable(self : RegisterField) -> Bool

    RegisterField::kind

    source

    RegisterField::name

    source
    fn RegisterField::name(self : RegisterField) -> String

    RegisterField::new

    source
    fn RegisterField::new(name : String, address : UInt16, kind : RegisterFieldKind, writable? : Bool, scale? : Float) -> Result[RegisterField, ModbusError]

    RegisterField::scale

    source
    fn RegisterField::scale(self : RegisterField) -> Float

    RegisterField::width

    source
    fn RegisterField::width(self : RegisterField) -> Int

    RegisterFieldKind

    source
    pub(all) enum RegisterFieldKind {
      Unsigned16
      Signed16
      Unsigned32
      Signed32
      Float32
      Unsigned64
      BitField(Int)
    } derive(Eq, 
    Debug    )

    Typed interpretation for a register-backed device schema.

    RegisterFieldKind::name

    source
    fn RegisterFieldKind::name(self : RegisterFieldKind) -> String

    RegisterFieldKind::width

    source
    fn RegisterFieldKind::width(self : RegisterFieldKind) -> Int

    RegisterSchema

    source
    pub struct RegisterSchema {
      fields : Array[RegisterField]
      max_fields : Int
    }

    A schema with unique named fields and no overlapping wire ranges.

    RegisterSchema::add

    source
    fn RegisterSchema::add(self : RegisterSchema, field : RegisterField) -> Result[Unit, ModbusError]

    RegisterSchema::field

    source
    fn RegisterSchema::field(self : RegisterSchema, name : String) -> RegisterField?

    RegisterSchema::fields

    source

    RegisterSchema::length

    source
    fn RegisterSchema::length(self : RegisterSchema) -> Int

    RegisterSchema::new

    source
    fn RegisterSchema::new(max_fields? : Int) -> Result[RegisterSchema, ModbusError]

    RegisterSchema::read

    source
    fn RegisterSchema::read(self : RegisterSchema, name : String, bank : RegisterBank) -> Result[RegisterValue, ModbusError]

    Decode one schema field from a register bank.

    RegisterSchema::read_all

    source
    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

    source
    fn RegisterSchema::validate_against(self : RegisterSchema, bank : RegisterBank) -> Result[Unit, ModbusError]

    Validate a schema against a register bank before starting a service.

    RegisterSchema::write

    source
    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

    source
    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

    source
    pub(all) enum RegisterWordOrder {
      HighWordFirst
      LowWordFirst
    } derive(Eq, 
    Debug    )

    Word order used for values wider than one register.

    RegisterWriter

    source
    pub(all) struct RegisterWriter {
      values : Array[UInt16]
      capacity : Int
    }

    A register writer that grows only up to a configured capacity.

    RegisterWriter::length

    source
    fn RegisterWriter::length(self : RegisterWriter) -> Int

    RegisterWriter::new

    source
    fn RegisterWriter::new(capacity : Int) -> Result[RegisterWriter, ModbusError]

    RegisterWriter::push

    source
    fn RegisterWriter::push(self : RegisterWriter, value : UInt16) -> Result[Unit, ModbusError]

    RegisterWriter::push_f32

    source
    fn RegisterWriter::push_f32(self : RegisterWriter, value : Float, order : RegisterWordOrder) -> Result[Unit, ModbusError]

    RegisterWriter::push_i16

    source
    fn RegisterWriter::push_i16(self : RegisterWriter, value : Int) -> Result[Unit, ModbusError]

    RegisterWriter::push_u32

    source
    fn RegisterWriter::push_u32(self : RegisterWriter, value : UInt, order : RegisterWordOrder) -> Result[Unit, ModbusError]

    RegisterWriter::push_u64

    source
    fn RegisterWriter::push_u64(self : RegisterWriter, value : UInt64, order : RegisterWordOrder) -> Result[Unit, ModbusError]

    RegisterWriter::remaining

    source
    fn RegisterWriter::remaining(self : RegisterWriter) -> Int

    RegisterWriter::to_array

    source
    fn RegisterWriter::to_array(self : RegisterWriter) -> Array[UInt16]

    ReliabilityFailure

    source
    pub(all) enum ReliabilityFailure {
      TimeoutFailure
      ChecksumFailure
      ProtocolFailure
      TransportFailure
      DeviceException
      ValidationFailure
    } derive(Eq, 
    Debug    )

    Classification used by reliability counters and incident reports.

    ReliabilityFleetSummary

    source
    pub(all) struct ReliabilityFleetSummary {
      devices : Int
      healthy : Int
      degraded : Int
      open_circuits : Int
      average_success_rate : Int
      average_latency : Int
    }

    A fleet-level reliability snapshot for dashboards and alert rules.

    ReliabilityFleetSummary::average_latency

    source
    fn ReliabilityFleetSummary::average_latency(self : ReliabilityFleetSummary) -> Int

    ReliabilityFleetSummary::average_success_rate

    source
    fn ReliabilityFleetSummary::average_success_rate(self : ReliabilityFleetSummary) -> Int

    ReliabilityFleetSummary::degraded

    source

    ReliabilityFleetSummary::devices

    source

    ReliabilityFleetSummary::healthy

    source

    ReliabilityFleetSummary::open_circuits

    source
    fn ReliabilityFleetSummary::open_circuits(self : ReliabilityFleetSummary) -> Int

    ReliabilitySample

    source
    pub(all) struct ReliabilitySample {
      timestamp : Int
      latency : Int
      success : Bool
      failure : ReliabilityFailure?
      operation : String
    }

    One outcome recorded by a transport or polling worker.

    ReliabilitySample::failure

    source

    ReliabilitySample::latency

    source
    fn ReliabilitySample::latency(self : ReliabilitySample) -> Int

    ReliabilitySample::new

    source
    fn ReliabilitySample::new(timestamp : Int, latency : Int, success : Bool, operation : String, failure? : ReliabilityFailure) -> Result[ReliabilitySample, ModbusError]

    ReliabilitySample::operation

    source
    fn ReliabilitySample::operation(self : ReliabilitySample) -> String

    ReliabilitySample::success

    source
    fn ReliabilitySample::success(self : ReliabilitySample) -> Bool

    ReliabilitySample::timestamp

    source
    fn ReliabilitySample::timestamp(self : ReliabilitySample) -> Int

    ReliabilityWindow

    source
    pub(all) struct ReliabilityWindow {
      width : Int
      max_samples : Int
      samples : Array[ReliabilitySample]
      evicted : Int
    }

    A bounded sliding window of request outcomes.

    ReliabilityWindow::append

    source
    fn ReliabilityWindow::append(self : ReliabilityWindow, sample : ReliabilitySample) -> Result[Unit, ModbusError]

    ReliabilityWindow::average_latency

    source
    fn ReliabilityWindow::average_latency(self : ReliabilityWindow) -> Int

    ReliabilityWindow::clear

    source
    fn ReliabilityWindow::clear(self : ReliabilityWindow) -> Unit

    ReliabilityWindow::evicted

    source
    fn ReliabilityWindow::evicted(self : ReliabilityWindow) -> Int

    ReliabilityWindow::failure_count

    source
    fn ReliabilityWindow::failure_count(self : ReliabilityWindow, failure : ReliabilityFailure) -> Int

    ReliabilityWindow::failures

    source
    fn ReliabilityWindow::failures(self : ReliabilityWindow) -> Int

    ReliabilityWindow::latest

    source

    ReliabilityWindow::length

    source
    fn ReliabilityWindow::length(self : ReliabilityWindow) -> Int

    ReliabilityWindow::new

    source
    fn ReliabilityWindow::new(width : Int, max_samples? : Int) -> Result[ReliabilityWindow, ModbusError]

    ReliabilityWindow::prune

    source
    fn ReliabilityWindow::prune(self : ReliabilityWindow, now : Int) -> Result[Int, ModbusError]

    ReliabilityWindow::success_rate

    source
    fn ReliabilityWindow::success_rate(self : ReliabilityWindow) -> Int

    ReliabilityWindow::successes

    source
    fn ReliabilityWindow::successes(self : ReliabilityWindow) -> Int

    ReliabilityWindow::width

    source
    fn ReliabilityWindow::width(self : ReliabilityWindow) -> Int

    ReplayItem

    source
    pub(all) struct ReplayItem {
      record_id : Int
      due_at : Int
      bytes : Array[Byte]
      attempts : Int
      sent : Bool
    }

    A deterministic replay item generated from a capture record.

    ReplayItem::attempts

    source
    fn ReplayItem::attempts(self : ReplayItem) -> Int

    ReplayItem::bytes

    source
    fn ReplayItem::bytes(self : ReplayItem) -> Array[Byte]

    ReplayItem::due_at

    source
    fn ReplayItem::due_at(self : ReplayItem) -> Int

    ReplayItem::is_due

    source
    fn ReplayItem::is_due(self : ReplayItem, now : Int) -> Bool

    ReplayItem::mark_sent

    source
    fn ReplayItem::mark_sent(self : ReplayItem) -> Result[Unit, ModbusError]

    ReplayItem::new

    source
    fn ReplayItem::new(record : CaptureRecord, due_at : Int) -> Result[ReplayItem, ModbusError]

    ReplayItem::record_id

    source
    fn ReplayItem::record_id(self : ReplayItem) -> Int

    ReplayItem::reset

    source
    fn ReplayItem::reset(self : ReplayItem, due_at : Int) -> Result[Unit, ModbusError]

    ReplayItem::sent

    source
    fn ReplayItem::sent(self : ReplayItem) -> Bool

    ReplayPlan

    source
    pub(all) struct ReplayPlan {
      items : Array[ReplayItem]
      max_items : Int
      started_at : Int?
    }

    A replay plan for deterministic integration tests and diagnostics.

    ReplayPlan::add

    source
    fn ReplayPlan::add(self : ReplayPlan, record : CaptureRecord, delay : Int) -> Result[Unit, ModbusError]

    ReplayPlan::completed

    source
    fn ReplayPlan::completed(self : ReplayPlan) -> Int

    ReplayPlan::length

    source
    fn ReplayPlan::length(self : ReplayPlan) -> Int

    ReplayPlan::mark_sent

    source
    fn ReplayPlan::mark_sent(self : ReplayPlan, record_id : Int) -> Result[Unit, ModbusError]

    ReplayPlan::new

    source
    fn ReplayPlan::new(max_items? : Int) -> Result[ReplayPlan, ModbusError]

    ReplayPlan::next_due

    source
    fn ReplayPlan::next_due(self : ReplayPlan, now : Int) -> ReplayItem?

    ReplayPlan::pending

    source
    fn ReplayPlan::pending(self : ReplayPlan) -> Int

    ReplayPlan::reset

    source
    fn ReplayPlan::reset(self : ReplayPlan, timestamp : Int) -> Result[Unit, ModbusError]

    ReplayPlan::snapshot

    source
    fn ReplayPlan::snapshot(self : ReplayPlan) -> Array[ReplayItem]

    ReplayPlan::start

    source
    fn ReplayPlan::start(self : ReplayPlan, timestamp : Int) -> Result[Unit, ModbusError]

    ResourceLease

    source
    pub(all) struct ResourceLease {
      id : String
      resource : String
      owner : String
      acquired_at : Int
      expires_at : Int
      state : LeaseState
      renewals : Int
      priority : Int
    }

    A time-bounded exclusive lease with renewal history.

    ResourceLease::acquired_at

    source
    fn ResourceLease::acquired_at(self : ResourceLease) -> Int

    ResourceLease::active

    source
    fn ResourceLease::active(self : ResourceLease, now : Int) -> Bool

    ResourceLease::expire

    source
    fn ResourceLease::expire(self : ResourceLease, now : Int) -> Result[Unit, ModbusError]

    ResourceLease::expires_at

    source
    fn ResourceLease::expires_at(self : ResourceLease) -> Int

    ResourceLease::id

    source
    fn ResourceLease::id(self : ResourceLease) -> String

    ResourceLease::new

    source
    fn ResourceLease::new(id : String, resource : String, owner : String, acquired_at : Int, duration : Int, priority? : Int) -> Result[ResourceLease, ModbusError]

    ResourceLease::owner

    source
    fn ResourceLease::owner(self : ResourceLease) -> String

    ResourceLease::priority

    source
    fn ResourceLease::priority(self : ResourceLease) -> Int

    ResourceLease::renew

    source
    fn ResourceLease::renew(self : ResourceLease, now : Int, duration : Int) -> Result[Unit, ModbusError]

    ResourceLease::renewals

    source
    fn ResourceLease::renewals(self : ResourceLease) -> Int

    ResourceLease::resource

    source
    fn ResourceLease::resource(self : ResourceLease) -> String

    ResourceLease::revoke

    source
    fn ResourceLease::revoke(self : ResourceLease) -> Result[Unit, ModbusError]

    ResourceLease::state

    source

    ResponseValue

    source
    pub(all) enum ResponseValue {
      Normal(Frame)
      Exception(Frame, ExceptionCode)
    }

    A raw PDU result that retains whether a response was an exception.

    RetryPolicy

    source
    pub(all) struct RetryPolicy {
      max_attempts : Int
      initial_backoff : Int
      max_backoff : Int
      multiplier : Int
    }

    Policy controlling retry count and backoff growth.

    RetryPolicy::backoff

    source
    fn RetryPolicy::backoff(self : RetryPolicy, attempt : Int) -> Result[Int, ModbusError]

    RetryPolicy::can_retry

    source
    fn RetryPolicy::can_retry(self : RetryPolicy, attempt : Int) -> Bool

    RetryPolicy::initial_backoff

    source
    fn RetryPolicy::initial_backoff(self : RetryPolicy) -> Int

    RetryPolicy::max_attempts

    source
    fn RetryPolicy::max_attempts(self : RetryPolicy) -> Int

    RetryPolicy::max_backoff

    source
    fn RetryPolicy::max_backoff(self : RetryPolicy) -> Int

    RetryPolicy::multiplier

    source
    fn RetryPolicy::multiplier(self : RetryPolicy) -> Int

    RetryPolicy::new

    source
    fn RetryPolicy::new(max_attempts : Int, initial_backoff : Int, max_backoff : Int, multiplier? : Int) -> Result[RetryPolicy, ModbusError]

    RetryPolicy::summary

    source
    fn RetryPolicy::summary(self : RetryPolicy) -> String

    RuntimeConfig

    source
    pub(all) struct RuntimeConfig {
      schema : ConfigSchema
      entries : Array[ConfigEntry]
      revision : Int
    }

    Mutable configuration store with atomic-style patch application.

    RuntimeConfig::apply

    source
    fn RuntimeConfig::apply(self : RuntimeConfig, operations : Array[ConfigOperation], source? : String) -> Result[Int, ModbusError]

    RuntimeConfig::entry

    source
    fn RuntimeConfig::entry(self : RuntimeConfig, key : String) -> ConfigEntry?

    RuntimeConfig::export_lines

    source
    fn RuntimeConfig::export_lines(self : RuntimeConfig, redact? : Bool) -> Array[String]

    RuntimeConfig::get

    source
    fn RuntimeConfig::get(self : RuntimeConfig, key : String) -> ConfigValue?

    RuntimeConfig::length

    source
    fn RuntimeConfig::length(self : RuntimeConfig) -> Int

    RuntimeConfig::new

    source

    RuntimeConfig::remove

    source
    fn RuntimeConfig::remove(self : RuntimeConfig, key : String) -> Result[Unit, ModbusError]

    RuntimeConfig::revision

    source
    fn RuntimeConfig::revision(self : RuntimeConfig) -> Int

    RuntimeConfig::schema

    source

    RuntimeConfig::set

    source
    fn RuntimeConfig::set(self : RuntimeConfig, key : String, value : ConfigValue, source? : String) -> Result[Unit, ModbusError]

    RuntimeConfig::snapshot

    source
    fn RuntimeConfig::snapshot(self : RuntimeConfig) -> Array[ConfigEntry]

    RuntimeConfig::validate

    source
    fn RuntimeConfig::validate(self : RuntimeConfig) -> Result[Unit, ModbusError]

    ScaleTransform

    source
    pub(all) struct ScaleTransform {
      raw_min : Int
      raw_max : Int
      engineering_min : Int
      engineering_max : Int
      unit : EngineeringUnit
      deadband : Int
      clamp : Bool
      precision : Int
    }

    A deterministic integer scaling transform for register data.

    ScaleTransform::apply_deadband

    source
    fn ScaleTransform::apply_deadband(self : ScaleTransform, previous : Int, current : Int) -> Int

    ScaleTransform::clamp_engineering

    source
    fn ScaleTransform::clamp_engineering(self : ScaleTransform, value : Int) -> Int

    ScaleTransform::clamp_raw

    source
    fn ScaleTransform::clamp_raw(self : ScaleTransform, raw : Int) -> Int

    ScaleTransform::deadband

    source
    fn ScaleTransform::deadband(self : ScaleTransform) -> Int

    ScaleTransform::engineering_in_range

    source
    fn ScaleTransform::engineering_in_range(self : ScaleTransform, value : Int) -> Bool

    ScaleTransform::engineering_max

    source
    fn ScaleTransform::engineering_max(self : ScaleTransform) -> Int

    ScaleTransform::engineering_min

    source
    fn ScaleTransform::engineering_min(self : ScaleTransform) -> Int

    ScaleTransform::engineering_to_raw

    source
    fn ScaleTransform::engineering_to_raw(self : ScaleTransform, value : Int) -> Result[Int, ModbusError]

    ScaleTransform::format

    source
    fn ScaleTransform::format(self : ScaleTransform, value : Int) -> String

    ScaleTransform::new

    source
    fn ScaleTransform::new(raw_min : Int, raw_max : Int, engineering_min : Int, engineering_max : Int, unit? : EngineeringUnit, deadband? : Int, clamp? : Bool, precision? : Int) -> Result[ScaleTransform, ModbusError]

    ScaleTransform::normalize

    source
    fn ScaleTransform::normalize(self : ScaleTransform, raw : Int) -> Result[Int, ModbusError]

    ScaleTransform::precision

    source
    fn ScaleTransform::precision(self : ScaleTransform) -> Int

    ScaleTransform::raw_in_range

    source
    fn ScaleTransform::raw_in_range(self : ScaleTransform, raw : Int) -> Bool

    ScaleTransform::raw_max

    source
    fn ScaleTransform::raw_max(self : ScaleTransform) -> Int

    ScaleTransform::raw_min

    source
    fn ScaleTransform::raw_min(self : ScaleTransform) -> Int

    ScaleTransform::raw_to_engineering

    source
    fn ScaleTransform::raw_to_engineering(self : ScaleTransform, raw : Int) -> Result[Int, ModbusError]

    ScaleTransform::summary

    source
    fn ScaleTransform::summary(self : ScaleTransform) -> String

    ScaleTransform::unit

    source

    ScaledReading

    source
    pub(all) struct ScaledReading {
      point_id : String
      raw : Int
      value : Int
      unit : EngineeringUnit
      quality : ReadingQuality
      timestamp : Int
    }

    A timestamped reading after scaling and quality assessment.

    ScaledReading::new

    source
    fn ScaledReading::new(point_id : String, raw : Int, transform : ScaleTransform, timestamp : Int) -> Result[ScaledReading, ModbusError]

    ScaledReading::point_id

    source
    fn ScaledReading::point_id(self : ScaledReading) -> String

    ScaledReading::quality

    source

    ScaledReading::raw

    source
    fn ScaledReading::raw(self : ScaledReading) -> Int

    ScaledReading::summary

    source
    fn ScaledReading::summary(self : ScaledReading) -> String

    ScaledReading::timestamp

    source
    fn ScaledReading::timestamp(self : ScaledReading) -> Int

    ScaledReading::unit

    source

    ScaledReading::value

    source
    fn ScaledReading::value(self : ScaledReading) -> Int

    ScaledReading::with_quality

    source
    fn ScaledReading::with_quality(self : ScaledReading, quality : ReadingQuality) -> ScaledReading

    Scenario

    source
    pub(all) struct Scenario {
      name : String
      requests : Array[Frame]
      mode : Mode
    }

    A deterministic multi-request scenario.

    Scenario::add

    source
    fn Scenario::add(self : Scenario, request : Frame) -> Result[Unit, ModbusError]

    Scenario::length

    source
    fn Scenario::length(self : Scenario) -> Int

    Scenario::mode

    source
    fn Scenario::mode(self : Scenario) -> Mode

    Scenario::name

    source
    fn Scenario::name(self : Scenario) -> String

    Scenario::new

    source
    fn Scenario::new(name : String, mode : Mode) -> Scenario

    Scenario::run

    source
    fn Scenario::run(self : Scenario, simulation : Simulation) -> Array[SimulationResult]

    ScenarioFault

    source
    pub(all) enum ScenarioFault {
      NoFault
      DropNext
      DelayNext(Int)
      CorruptByte(Int)
      ForceException(Byte)
      Repeat(Int)
    } derive(Eq, 
    Debug    )

    Fault applied to a selected step in a reproducible test scenario.

    ScenarioOutcome

    source
    pub(all) enum ScenarioOutcome {
      ScenarioSuccess
      ScenarioTimeout
      ScenarioException
      ScenarioCorrupt
      ScenarioDropped
      ScenarioDelayed
    } derive(Eq, 
    Debug    )

    Deterministic outcome injected into a protocol simulation.

    ScenarioResult

    source
    pub(all) struct ScenarioResult {
      step_id : String
      outcome : ScenarioOutcome
      started_at : Int
      finished_at : Int
      response : Frame?
      error : ModbusError?
      detail : String
    }

    A single result emitted by the deterministic runner.

    ScenarioResult::detail

    source
    fn ScenarioResult::detail(self : ScenarioResult) -> String

    ScenarioResult::duration

    source
    fn ScenarioResult::duration(self : ScenarioResult) -> Int

    ScenarioResult::error

    source

    ScenarioResult::finished_at

    source
    fn ScenarioResult::finished_at(self : ScenarioResult) -> Int

    ScenarioResult::new

    source
    fn ScenarioResult::new(step_id : String, outcome : ScenarioOutcome, started_at : Int, finished_at : Int, response? : Frame, error? : ModbusError, detail? : String) -> Result[ScenarioResult, ModbusError]

    ScenarioResult::outcome

    source

    ScenarioResult::response

    source
    fn ScenarioResult::response(self : ScenarioResult) -> Frame?

    ScenarioResult::started_at

    source
    fn ScenarioResult::started_at(self : ScenarioResult) -> Int

    ScenarioResult::step_id

    source
    fn ScenarioResult::step_id(self : ScenarioResult) -> String

    ScenarioRunner

    source
    pub(all) struct ScenarioRunner {
      scenario : ModbusScenario
      results : Array[ScenarioResult]
      cursor : Int
      now : Int
    }

    Deterministic runner with no wall-clock or random dependencies.

    ScenarioRunner::cursor

    source
    fn ScenarioRunner::cursor(self : ScenarioRunner) -> Int

    ScenarioRunner::new

    source
    fn ScenarioRunner::new(scenario : ModbusScenario, start_at? : Int) -> Result[ScenarioRunner, ModbusError]

    ScenarioRunner::now

    source
    fn ScenarioRunner::now(self : ScenarioRunner) -> Int

    ScenarioRunner::outcome_counts

    source
    fn ScenarioRunner::outcome_counts(self : ScenarioRunner) -> Array[Int]

    Count each deterministic outcome in runner results.

    ScenarioRunner::passed

    source
    fn ScenarioRunner::passed(self : ScenarioRunner) -> Bool

    Verify that all outcomes match the scenario's declared expectations.

    ScenarioRunner::result_count

    source
    fn ScenarioRunner::result_count(self : ScenarioRunner) -> Int

    ScenarioRunner::results

    source

    ScenarioRunner::run_all

    source

    Run all remaining steps, stopping at the first execution error.

    ScenarioRunner::run_next

    source
    fn ScenarioRunner::run_next(self : ScenarioRunner) -> Result[ScenarioResult, ModbusError]

    Execute the next step and return its deterministic result.

    ScenarioStep

    source
    pub(all) struct ScenarioStep {
      id : String
      timestamp : Int
      request : Frame
      expected_function : Byte
      expected_outcome : ScenarioOutcome
      fault : ScenarioFault
      note : String
    }

    One input/output expectation used by integration and boundary tests.

    ScenarioStep::expected_function

    source
    fn ScenarioStep::expected_function(self : ScenarioStep) -> Byte

    ScenarioStep::expected_outcome

    source
    fn ScenarioStep::expected_outcome(self : ScenarioStep) -> ScenarioOutcome

    ScenarioStep::fault

    source

    ScenarioStep::id

    source
    fn ScenarioStep::id(self : ScenarioStep) -> String

    ScenarioStep::new

    source
    fn ScenarioStep::new(id : String, timestamp : Int, request : Frame, expected_outcome : ScenarioOutcome, note? : String) -> Result[ScenarioStep, ModbusError]

    ScenarioStep::note

    source
    fn ScenarioStep::note(self : ScenarioStep) -> String

    ScenarioStep::request

    source
    fn ScenarioStep::request(self : ScenarioStep) -> Frame

    ScenarioStep::timestamp

    source
    fn ScenarioStep::timestamp(self : ScenarioStep) -> Int

    ScenarioStep::with_fault

    source
    fn ScenarioStep::with_fault(self : ScenarioStep, fault : ScenarioFault) -> Unit

    ScheduledJob

    source
    pub(all) struct ScheduledJob {
      id : String
      request : Frame
      priority : JobPriority
      period : Int
      deadline : Int
      policy : RetryPolicy
      due_at : Int
      attempts : Int
      state : JobState
      last_error : ModbusError?
      last_started : Int?
      last_finished : Int?
      tag : String
    }

    A request retained by the scheduler until it is dispatched or expires.

    ScheduledJob::age

    source
    fn ScheduledJob::age(self : ScheduledJob, now : Int) -> Int

    ScheduledJob::attempts

    source
    fn ScheduledJob::attempts(self : ScheduledJob) -> Int

    ScheduledJob::cancel

    source
    fn ScheduledJob::cancel(self : ScheduledJob) -> Result[Unit, ModbusError]

    ScheduledJob::complete

    source
    fn ScheduledJob::complete(self : ScheduledJob, now : Int) -> Result[Unit, ModbusError]

    ScheduledJob::deadline

    source
    fn ScheduledJob::deadline(self : ScheduledJob) -> Int

    ScheduledJob::due_at

    source
    fn ScheduledJob::due_at(self : ScheduledJob) -> Int

    ScheduledJob::fail

    source
    fn ScheduledJob::fail(self : ScheduledJob, error : ModbusError, now : Int) -> Result[Bool, ModbusError]

    ScheduledJob::id

    source
    fn ScheduledJob::id(self : ScheduledJob) -> String

    ScheduledJob::is_due

    source
    fn ScheduledJob::is_due(self : ScheduledJob, now : Int) -> Bool

    ScheduledJob::is_expired

    source
    fn ScheduledJob::is_expired(self : ScheduledJob, now : Int) -> Bool

    ScheduledJob::is_periodic

    source
    fn ScheduledJob::is_periodic(self : ScheduledJob) -> Bool

    ScheduledJob::last_error

    source
    fn ScheduledJob::last_error(self : ScheduledJob) -> ModbusError?

    ScheduledJob::latency

    source
    fn ScheduledJob::latency(self : ScheduledJob) -> Int?

    ScheduledJob::new

    source
    fn ScheduledJob::new(id : String, request : Frame, due_at : Int, period? : Int, priority? : JobPriority, deadline? : Int, policy? : RetryPolicy, tag? : String) -> Result[ScheduledJob, ModbusError]

    ScheduledJob::period

    source
    fn ScheduledJob::period(self : ScheduledJob) -> Int

    ScheduledJob::priority

    source
    fn ScheduledJob::priority(self : ScheduledJob) -> JobPriority

    ScheduledJob::request

    source
    fn ScheduledJob::request(self : ScheduledJob) -> Frame

    ScheduledJob::reset

    source
    fn ScheduledJob::reset(self : ScheduledJob, due_at : Int) -> Result[Unit, ModbusError]

    ScheduledJob::start

    source
    fn ScheduledJob::start(self : ScheduledJob, now : Int) -> Result[Unit, ModbusError]

    ScheduledJob::state

    source
    fn ScheduledJob::state(self : ScheduledJob) -> JobState

    ScheduledJob::tag

    source
    fn ScheduledJob::tag(self : ScheduledJob) -> String

    SchedulerSnapshot

    source
    pub(all) struct SchedulerSnapshot {
      total : Int
      ready : Int
      in_flight : Int
      waiting : Int
      completed : Int
      failed : Int
      cancelled : Int
    }

    A compact schedule snapshot for metrics export.

    SchedulerSnapshot::healthy

    source
    fn SchedulerSnapshot::healthy(self : SchedulerSnapshot) -> Bool

    SchedulerSnapshot::summary

    source
    fn SchedulerSnapshot::summary(self : SchedulerSnapshot) -> String

    SecurityAudit

    source
    pub(all) struct SecurityAudit {
      sequence : Int
      timestamp : Int
      principal : String
      role : AccessRole
      operation : AccessOperation
      unit_id : Byte
      function : Byte
      allowed : Bool
      reason : String
    }

    Security audit record generated by a policy decision.

    SecurityAudit::allowed

    source
    fn SecurityAudit::allowed(self : SecurityAudit) -> Bool

    SecurityAudit::new

    source
    fn SecurityAudit::new(sequence : Int, timestamp : Int, principal : String, role : AccessRole, operation : AccessOperation, frame : Frame, allowed : Bool, reason : String) -> Result[SecurityAudit, ModbusError]

    SecurityAudit::sequence

    source
    fn SecurityAudit::sequence(self : SecurityAudit) -> Int

    SecurityAudit::summary

    source
    fn SecurityAudit::summary(self : SecurityAudit) -> String

    SerialConfig

    source
    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

    source
    fn SerialConfig::new(path : String, baud : Int, mode : Mode, data_bits? : Int, stop_bits? : Int, parity? : Byte) -> Result[SerialConfig, ModbusError]

    SerialConfig::parity_name

    source
    fn SerialConfig::parity_name(self : SerialConfig) -> String

    Server

    source
    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

    source
    fn Server::add_device(self : Server, device : Device) -> Result[Unit, ModbusError]

    Server::audit

    source
    fn Server::audit(self : Server) -> AuditLog

    Server::broadcast

    source
    fn Server::broadcast(self : Server, request : Frame) -> Array[Frame]

    Run a request against every configured unit and return normal replies.

    Server::config

    source
    fn Server::config(self : Server) -> ServerConfig

    Server::device

    source
    fn Server::device(self : Server, unit_id : Byte) -> Device?

    Server::device_count

    source
    fn Server::device_count(self : Server) -> Int

    Server::handle

    source
    fn Server::handle(self : Server, request : Frame) -> Result[Frame, ModbusError]

    Handle a decoded request and return a decoded reply.

    Server::handle_adu

    source
    fn Server::handle_adu(self : Server, bytes : Array[Byte]) -> Result[Array[Byte], ModbusError]

    Decode an ADU, dispatch it, and encode the reply.

    Server::metrics

    source
    fn Server::metrics(self : Server) -> ProtocolMetrics

    Server::mode

    source
    fn Server::mode(self : Server) -> Mode

    Server::new

    source
    fn Server::new(config : ServerConfig) -> Result[Server, ModbusError]

    Server::parser

    source
    fn Server::parser(self : Server) -> IncrementalParser

    Server::remove_device

    source
    fn Server::remove_device(self : Server, unit_id : Byte) -> Result[Unit, ModbusError]

    ServerConfig

    source
    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.

    ServiceBridgeRule

    source
    pub(all) struct ServiceBridgeRule {
      id : String
      source_unit : Byte
      target_unit : Byte
      function : Byte
      source_start : UInt16
      span : Int
      target_start : UInt16
      action : BridgeAction
      priority : Int
      enabled : Bool
      tag : String
    }

    Rule matching a source request and selecting a target route.

    ServiceBridgeRule::action

    source

    ServiceBridgeRule::enabled

    source
    fn ServiceBridgeRule::enabled(self : ServiceBridgeRule) -> Bool

    ServiceBridgeRule::function

    source
    fn ServiceBridgeRule::function(self : ServiceBridgeRule) -> Byte

    ServiceBridgeRule::id

    source
    fn ServiceBridgeRule::id(self : ServiceBridgeRule) -> String

    ServiceBridgeRule::matches

    source
    fn ServiceBridgeRule::matches(self : ServiceBridgeRule, frame : Frame) -> Bool

    ServiceBridgeRule::new

    source
    fn ServiceBridgeRule::new(id : String, source_unit : Byte, target_unit : Byte, function : Byte, source_start : UInt16, span : Int, target_start : UInt16, action : BridgeAction, priority? : Int, tag? : String) -> Result[ServiceBridgeRule, ModbusError]

    ServiceBridgeRule::priority

    source
    fn ServiceBridgeRule::priority(self : ServiceBridgeRule) -> Int

    ServiceBridgeRule::rewrite

    source
    fn ServiceBridgeRule::rewrite(self : ServiceBridgeRule, frame : Frame) -> Result[Frame, ModbusError]

    ServiceBridgeRule::set_enabled

    source
    fn ServiceBridgeRule::set_enabled(self : ServiceBridgeRule, enabled : Bool) -> Unit

    ServiceBridgeRule::source_start

    source
    fn ServiceBridgeRule::source_start(self : ServiceBridgeRule) -> UInt16

    ServiceBridgeRule::source_unit

    source
    fn ServiceBridgeRule::source_unit(self : ServiceBridgeRule) -> Byte

    ServiceBridgeRule::span

    source
    fn ServiceBridgeRule::span(self : ServiceBridgeRule) -> Int

    ServiceBridgeRule::tag

    source
    fn ServiceBridgeRule::tag(self : ServiceBridgeRule) -> String

    ServiceBridgeRule::target_start

    source
    fn ServiceBridgeRule::target_start(self : ServiceBridgeRule) -> UInt16

    ServiceBridgeRule::target_unit

    source
    fn ServiceBridgeRule::target_unit(self : ServiceBridgeRule) -> Byte

    ServiceEvent

    source
    pub(all) struct ServiceEvent {
      id : String
      kind : ServiceEventKind
      source : String
      timestamp : Int
      payload : Array[Byte]
      delivery : EventDelivery
      attempts : Int
    }

    Small immutable event envelope suitable for an in-memory or file queue.

    ServiceEvent::attempts

    source
    fn ServiceEvent::attempts(self : ServiceEvent) -> Int

    ServiceEvent::delivery

    source
    fn ServiceEvent::delivery(self : ServiceEvent) -> EventDelivery

    ServiceEvent::id

    source
    fn ServiceEvent::id(self : ServiceEvent) -> String

    ServiceEvent::kind

    source

    ServiceEvent::mark_delivered

    source
    fn ServiceEvent::mark_delivered(self : ServiceEvent) -> Unit

    ServiceEvent::mark_failed

    source
    fn ServiceEvent::mark_failed(self : ServiceEvent, dead_letter_after : Int) -> Result[Unit, ModbusError]

    ServiceEvent::new

    source
    fn ServiceEvent::new(id : String, kind : ServiceEventKind, source : String, timestamp : Int, payload : Array[Byte]) -> Result[ServiceEvent, ModbusError]

    ServiceEvent::payload

    source
    fn ServiceEvent::payload(self : ServiceEvent) -> Array[Byte]

    ServiceEvent::source

    source
    fn ServiceEvent::source(self : ServiceEvent) -> String

    ServiceEvent::timestamp

    source
    fn ServiceEvent::timestamp(self : ServiceEvent) -> Int

    ServiceEventBus

    source
    pub(all) struct ServiceEventBus {
      queue : Array[ServiceEvent]
      dead_letters : Array[ServiceEvent]
      subscriptions : Array[EventSubscription]
      max_queue : Int
      max_dead_letters : Int
      max_subscriptions : Int
    }

    Event queue with bounded pending and dead-letter retention.

    ServiceEventBus::ack

    source
    fn ServiceEventBus::ack(self : ServiceEventBus, event : ServiceEvent, success : Bool, dead_letter_after? : Int) -> Result[Unit, ModbusError]

    Acknowledge an event or return it to the queue after a failed attempt.

    ServiceEventBus::claim

    source
    fn ServiceEventBus::claim(self : ServiceEventBus, subscription_id : String) -> Result[ServiceEvent, ModbusError]

    Claim the next event matching a subscription.

    ServiceEventBus::clear_dead_letters

    source
    fn ServiceEventBus::clear_dead_letters(self : ServiceEventBus) -> Unit

    ServiceEventBus::dead_letter_count

    source
    fn ServiceEventBus::dead_letter_count(self : ServiceEventBus) -> Int

    ServiceEventBus::new

    source
    fn ServiceEventBus::new(max_queue? : Int, max_dead_letters? : Int, max_subscriptions? : Int) -> Result[ServiceEventBus, ModbusError]

    ServiceEventBus::peek_kind

    source

    Return events filtered by kind without claiming them.

    ServiceEventBus::publish

    source
    fn ServiceEventBus::publish(self : ServiceEventBus, event : ServiceEvent) -> Result[Unit, ModbusError]

    Publish an event and enforce the queue capacity.

    ServiceEventBus::queue_count

    source
    fn ServiceEventBus::queue_count(self : ServiceEventBus) -> Int

    ServiceEventBus::subscribe

    source
    fn ServiceEventBus::subscribe(self : ServiceEventBus, subscription : EventSubscription) -> Result[Unit, ModbusError]

    ServiceEventBus::subscription_count

    source
    fn ServiceEventBus::subscription_count(self : ServiceEventBus) -> Int

    ServiceEventBus::unsubscribe

    source
    fn ServiceEventBus::unsubscribe(self : ServiceEventBus, id : String) -> Result[EventSubscription, ModbusError]

    ServiceEventKind

    source
    pub(all) enum ServiceEventKind {
      FrameReceivedEvent
      FrameSentEvent
      AlarmRaisedEvent
      AlarmClearedEvent
      CommandUpdatedEvent
      DeviceHealthEvent
      MaintenanceDueEvent
      GatewayDeniedEvent
    } derive(Eq, 
    Debug    )

    Application event categories emitted by the protocol services.

    ServiceGatewayPolicy

    source
    pub(all) struct ServiceGatewayPolicy {
      id : String
      source : String
      destination : String
      rules : Array[ServiceBridgeRule]
      default_action : BridgeAction
      max_rules : Int
      revision : Int
    }

    An ordered policy set for one gateway route.

    ServiceGatewayPolicy::add_rule

    source
    fn ServiceGatewayPolicy::add_rule(self : ServiceGatewayPolicy, rule : ServiceBridgeRule) -> Result[Unit, ModbusError]

    ServiceGatewayPolicy::default_action

    source

    ServiceGatewayPolicy::destination

    source
    fn ServiceGatewayPolicy::destination(self : ServiceGatewayPolicy) -> String

    ServiceGatewayPolicy::evaluate

    source

    Find the highest priority matching rule and execute its action.

    ServiceGatewayPolicy::export_rules

    source
    fn ServiceGatewayPolicy::export_rules(self : ServiceGatewayPolicy) -> Array[String]

    Produce the stable rule table used in support bundles.

    ServiceGatewayPolicy::id

    source

    ServiceGatewayPolicy::new

    source
    fn ServiceGatewayPolicy::new(id : String, source : String, destination : String, default_action? : BridgeAction, max_rules? : Int) -> Result[ServiceGatewayPolicy, ModbusError]

    ServiceGatewayPolicy::remove_rule

    source
    fn ServiceGatewayPolicy::remove_rule(self : ServiceGatewayPolicy, id : String) -> Result[ServiceBridgeRule, ModbusError]

    ServiceGatewayPolicy::revision

    source
    fn ServiceGatewayPolicy::revision(self : ServiceGatewayPolicy) -> Int

    ServiceGatewayPolicy::rule

    source

    ServiceGatewayPolicy::rule_count

    source
    fn ServiceGatewayPolicy::rule_count(self : ServiceGatewayPolicy) -> Int

    ServiceGatewayPolicy::source

    source
    fn ServiceGatewayPolicy::source(self : ServiceGatewayPolicy) -> String

    ServiceGatewayPolicy::validate

    source

    Validate rule ordering and overlapping address windows.

    ServiceMetric

    source
    pub(all) struct ServiceMetric {
      name : String
      kind : MetricKind
      value : Int
      timestamp : Int
      labels : Array[(String, String)]
    }

    A metric sample with a small, allocation-friendly label set.

    ServiceMetric::kind

    source

    ServiceMetric::label

    source
    fn ServiceMetric::label(self : ServiceMetric, key : String) -> String?

    ServiceMetric::label_count

    source
    fn ServiceMetric::label_count(self : ServiceMetric) -> Int

    ServiceMetric::name

    source
    fn ServiceMetric::name(self : ServiceMetric) -> String

    ServiceMetric::new

    source
    fn ServiceMetric::new(name : String, kind : MetricKind, value : Int, timestamp : Int) -> Result[ServiceMetric, ModbusError]

    ServiceMetric::timestamp

    source
    fn ServiceMetric::timestamp(self : ServiceMetric) -> Int

    ServiceMetric::value

    source
    fn ServiceMetric::value(self : ServiceMetric) -> Int

    ServiceMetric::with_label

    source
    fn ServiceMetric::with_label(self : ServiceMetric, key : String, value : String) -> Result[Unit, ModbusError]

    ServicePlan

    source
    pub(all) struct ServicePlan {
      id : String
      asset_id : String
      title : String
      kind : MaintenanceKind
      interval : Int
      grace : Int
      estimated_minutes : Int
      enabled : Bool
      last_completed : Int?
      owner : String
    }

    A repeatable service plan for one device or profile point.

    ServicePlan::asset_id

    source
    fn ServicePlan::asset_id(self : ServicePlan) -> String

    ServicePlan::due_at

    source
    fn ServicePlan::due_at(self : ServicePlan) -> Int?

    ServicePlan::enabled

    source
    fn ServicePlan::enabled(self : ServicePlan) -> Bool

    ServicePlan::estimated_minutes

    source
    fn ServicePlan::estimated_minutes(self : ServicePlan) -> Int

    ServicePlan::grace

    source
    fn ServicePlan::grace(self : ServicePlan) -> Int

    ServicePlan::id

    source
    fn ServicePlan::id(self : ServicePlan) -> String

    ServicePlan::interval

    source
    fn ServicePlan::interval(self : ServicePlan) -> Int

    ServicePlan::is_due

    source
    fn ServicePlan::is_due(self : ServicePlan, now : Int) -> Result[Bool, ModbusError]

    ServicePlan::is_overdue

    source
    fn ServicePlan::is_overdue(self : ServicePlan, now : Int) -> Result[Bool, ModbusError]

    ServicePlan::kind

    source

    ServicePlan::last_completed

    source
    fn ServicePlan::last_completed(self : ServicePlan) -> Int?

    ServicePlan::mark_completed

    source
    fn ServicePlan::mark_completed(self : ServicePlan, timestamp : Int) -> Result[Unit, ModbusError]

    ServicePlan::new

    source
    fn ServicePlan::new(id : String, asset_id : String, title : String, kind : MaintenanceKind, interval : Int, grace? : Int, estimated_minutes? : Int, owner? : String) -> Result[ServicePlan, ModbusError]

    ServicePlan::owner

    source
    fn ServicePlan::owner(self : ServicePlan) -> String

    ServicePlan::priority

    source
    fn ServicePlan::priority(self : ServicePlan, now : Int) -> Result[MaintenancePriority, ModbusError]

    ServicePlan::set_enabled

    source
    fn ServicePlan::set_enabled(self : ServicePlan, enabled : Bool) -> Unit

    ServicePlan::title

    source
    fn ServicePlan::title(self : ServicePlan) -> String

    ServiceRecord

    source
    pub(all) struct ServiceRecord {
      id : String
      plan_id : String
      asset_id : String
      started_at : Int
      finished_at : Int
      technician : String
      result : String
      readings : Array[Int]
      parts : Array[String]
    }

    A historical service record including measurements and the operator note.

    ServiceRecord::add_part

    source
    fn ServiceRecord::add_part(self : ServiceRecord, part : String) -> Result[Unit, ModbusError]

    ServiceRecord::add_reading

    source
    fn ServiceRecord::add_reading(self : ServiceRecord, reading : Int) -> Unit

    ServiceRecord::asset_id

    source
    fn ServiceRecord::asset_id(self : ServiceRecord) -> String

    ServiceRecord::average_reading

    source
    fn ServiceRecord::average_reading(self : ServiceRecord) -> Result[Int, ModbusError]

    ServiceRecord::duration

    source
    fn ServiceRecord::duration(self : ServiceRecord) -> Int

    ServiceRecord::finished_at

    source
    fn ServiceRecord::finished_at(self : ServiceRecord) -> Int

    ServiceRecord::id

    source
    fn ServiceRecord::id(self : ServiceRecord) -> String

    ServiceRecord::new

    source
    fn ServiceRecord::new(id : String, plan_id : String, asset_id : String, started_at : Int, finished_at : Int, technician : String, result : String) -> Result[ServiceRecord, ModbusError]

    ServiceRecord::part_count

    source
    fn ServiceRecord::part_count(self : ServiceRecord) -> Int

    ServiceRecord::plan_id

    source
    fn ServiceRecord::plan_id(self : ServiceRecord) -> String

    ServiceRecord::reading_count

    source
    fn ServiceRecord::reading_count(self : ServiceRecord) -> Int

    ServiceRecord::result

    source
    fn ServiceRecord::result(self : ServiceRecord) -> String

    ServiceRecord::started_at

    source
    fn ServiceRecord::started_at(self : ServiceRecord) -> Int

    ServiceRecord::technician

    source
    fn ServiceRecord::technician(self : ServiceRecord) -> String

    Simulation

    source
    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

    source
    fn Simulation::advance(self : Simulation, ticks : Int) -> Result[Unit, ModbusError]

    Simulation::audit

    source
    fn Simulation::audit(self : Simulation) -> AuditLog

    Simulation::clock

    source
    fn Simulation::clock(self : Simulation) -> Int

    Simulation::device

    source
    fn Simulation::device(self : Simulation) -> Device

    Simulation::fault

    source
    fn Simulation::fault(self : Simulation) -> FaultMode

    Simulation::metrics

    source
    fn Simulation::metrics(self : Simulation) -> ProtocolMetrics

    Simulation::mode

    source
    fn Simulation::mode(self : Simulation) -> Mode

    Simulation::new

    source
    fn Simulation::new(device : Device, mode : Mode) -> Result[Simulation, ModbusError]

    Simulation::request

    source
    fn Simulation::request(self : Simulation, transaction_id : UInt16, request : Frame) -> SimulationResult

    Send one request through the selected fault model.

    Simulation::reset

    source
    fn Simulation::reset(self : Simulation) -> Unit

    Simulation::set_fault

    source
    fn Simulation::set_fault(self : Simulation, fault : FaultMode) -> Unit

    SimulationResult

    source
    pub(all) enum SimulationResult {
      Delivered(Frame)
      Dropped
      Rejected(ModbusError)
    }

    Result of one deterministic simulation step.

    SnapshotValue

    source
    pub(all) struct SnapshotValue {
      point_id : String
      value : Int
      quality : ReadingQuality
      timestamp : Int
    }

    A point/value pair captured from a device snapshot.

    SnapshotValue::is_good

    source
    fn SnapshotValue::is_good(self : SnapshotValue) -> Bool

    SnapshotValue::new

    source
    fn SnapshotValue::new(point_id : String, value : Int, timestamp : Int, quality? : ReadingQuality) -> Result[SnapshotValue, ModbusError]

    SnapshotValue::point_id

    source
    fn SnapshotValue::point_id(self : SnapshotValue) -> String

    SnapshotValue::quality

    source

    SnapshotValue::timestamp

    source
    fn SnapshotValue::timestamp(self : SnapshotValue) -> Int

    SnapshotValue::value

    source
    fn SnapshotValue::value(self : SnapshotValue) -> Int

    TagSample

    source
    pub(all) struct TagSample {
      point_id : String
      timestamp : Int
      value : Int
      quality : ReadingQuality
    }

    One immutable historian sample.

    TagSample::is_good

    source
    fn TagSample::is_good(self : TagSample) -> Bool

    TagSample::new

    source
    fn TagSample::new(point_id : String, timestamp : Int, value : Int, quality? : ReadingQuality) -> Result[TagSample, ModbusError]

    TagSample::point_id

    source
    fn TagSample::point_id(self : TagSample) -> String

    TagSample::quality

    source
    fn TagSample::quality(self : TagSample) -> ReadingQuality

    TagSample::summary

    source
    fn TagSample::summary(self : TagSample) -> String

    TagSample::timestamp

    source
    fn TagSample::timestamp(self : TagSample) -> Int

    TagSample::value

    source
    fn TagSample::value(self : TagSample) -> Int

    TagSeries

    source
    pub(all) struct TagSeries {
      point_id : String
      samples : Array[TagSample]
      max_samples : Int
      dropped : Int
    }

    A time range with samples belonging to one point.

    TagSeries::aggregate

    source
    fn TagSeries::aggregate(self : TagSeries, start : Int, end : Int, aggregation : Aggregation) -> Result[Int, ModbusError]

    TagSeries::append

    source
    fn TagSeries::append(self : TagSeries, sample : TagSample) -> Result[Unit, ModbusError]

    TagSeries::at

    source
    fn TagSeries::at(self : TagSeries, index : Int) -> Result[TagSample, ModbusError]

    TagSeries::average

    source
    fn TagSeries::average(self : TagSeries, start : Int, end : Int) -> Result[Int, ModbusError]

    TagSeries::between

    source
    fn TagSeries::between(self : TagSeries, start : Int, end : Int) -> Result[Array[TagSample], ModbusError]

    TagSeries::clear

    source
    fn TagSeries::clear(self : TagSeries) -> Unit

    TagSeries::dropped

    source
    fn TagSeries::dropped(self : TagSeries) -> Int

    TagSeries::first

    source
    fn TagSeries::first(self : TagSeries) -> TagSample?

    TagSeries::good_count

    source
    fn TagSeries::good_count(self : TagSeries) -> Int

    TagSeries::last

    source
    fn TagSeries::last(self : TagSeries) -> TagSample?

    TagSeries::length

    source
    fn TagSeries::length(self : TagSeries) -> Int

    TagSeries::new

    source
    fn TagSeries::new(point_id : String, max_samples? : Int) -> Result[TagSeries, ModbusError]

    TagSeries::point_id

    source
    fn TagSeries::point_id(self : TagSeries) -> String

    TagSeries::snapshot

    source
    fn TagSeries::snapshot(self : TagSeries) -> Array[TagSample]

    TagSeries::summary

    source
    fn TagSeries::summary(self : TagSeries) -> String

    TcpConfig

    source
    pub(all) struct TcpConfig {
      host : String
      port : Int
      connect_timeout : Int
      keep_alive : Bool
    }

    TCP endpoint settings.

    TcpConfig::address

    source
    fn TcpConfig::address(self : TcpConfig) -> String

    TcpConfig::new

    source
    fn TcpConfig::new(host : String, port : Int, connect_timeout? : Int, keep_alive? : Bool) -> Result[TcpConfig, ModbusError]

    TelemetryRing

    source
    pub(all) struct TelemetryRing {
      values : Array[Int]
      capacity : Int
      cursor : Int
      count : Int
    }

    A bounded ring of integer telemetry samples for device dashboards.

    TelemetryRing::at

    source
    fn TelemetryRing::at(self : TelemetryRing, logical : Int) -> Result[Int, ModbusError]

    Read a sample from oldest to newest order.

    TelemetryRing::average

    source
    fn TelemetryRing::average(self : TelemetryRing) -> Float

    TelemetryRing::capacity

    source
    fn TelemetryRing::capacity(self : TelemetryRing) -> Int

    TelemetryRing::clear

    source
    fn TelemetryRing::clear(self : TelemetryRing) -> Unit

    TelemetryRing::delta

    source
    fn TelemetryRing::delta(self : TelemetryRing) -> Result[Int, ModbusError]

    TelemetryRing::is_full

    source
    fn TelemetryRing::is_full(self : TelemetryRing) -> Bool

    TelemetryRing::latest

    source
    fn TelemetryRing::latest(self : TelemetryRing) -> Result[Int, ModbusError]

    TelemetryRing::length

    source
    fn TelemetryRing::length(self : TelemetryRing) -> Int

    TelemetryRing::maximum

    source
    fn TelemetryRing::maximum(self : TelemetryRing) -> Result[Int, ModbusError]

    TelemetryRing::minimum

    source
    fn TelemetryRing::minimum(self : TelemetryRing) -> Result[Int, ModbusError]

    TelemetryRing::new

    source
    fn TelemetryRing::new(capacity : Int) -> Result[TelemetryRing, ModbusError]

    TelemetryRing::previous

    source
    fn TelemetryRing::previous(self : TelemetryRing) -> Result[Int, ModbusError]

    TelemetryRing::record

    source
    fn TelemetryRing::record(self : TelemetryRing, value : Int) -> Unit

    Add a sample and overwrite the oldest sample when the ring is full.

    TelemetryRing::snapshot

    source
    fn TelemetryRing::snapshot(self : TelemetryRing) -> Array[Int]

    TelemetryRing::sum

    source
    fn TelemetryRing::sum(self : TelemetryRing) -> Int

    Threshold

    source
    pub(all) struct Threshold {
      low : Int
      high : Int
    }

    A closed interval used for a device alarm threshold.

    Threshold::classify

    source
    fn Threshold::classify(self : Threshold, value : Int) -> ThresholdState

    Threshold::high

    source
    fn Threshold::high(self : Threshold) -> Int

    Threshold::low

    source
    fn Threshold::low(self : Threshold) -> Int

    Threshold::new

    source
    fn Threshold::new(low : Int, high : Int) -> Result[Threshold, ModbusError]

    ThresholdState

    source
    pub(all) enum ThresholdState {
      Below
      Within
      Above
    } derive(Eq, 
    Debug    )

    TokenBucket

    source
    pub(all) struct TokenBucket {
      capacity : Int
      refill_interval : Int
      tokens : Int
      last_refill : Int
    }

    A token bucket with integer tokens, suitable for frame-level quotas.

    TokenBucket::capacity

    source
    fn TokenBucket::capacity(self : TokenBucket) -> Int

    TokenBucket::new

    source
    fn TokenBucket::new(capacity : Int, refill_interval : Int, now : Int) -> Result[TokenBucket, ModbusError]

    TokenBucket::refill

    source
    fn TokenBucket::refill(self : TokenBucket, now : Int) -> Unit

    TokenBucket::reset

    source
    fn TokenBucket::reset(self : TokenBucket, now : Int) -> Result[Unit, ModbusError]

    TokenBucket::take

    source
    fn TokenBucket::take(self : TokenBucket, amount : Int, now : Int) -> Bool

    TokenBucket::tokens

    source
    fn TokenBucket::tokens(self : TokenBucket, now : Int) -> Int

    TopologyHealth

    source
    pub(all) enum TopologyHealth {
      Healthy
      Degraded
      Unreachable
      Maintenance
      UnknownHealth
    } derive(Eq, 
    Debug    )

    Operational health used by route selection and dashboards.

    TopologyHealthReport

    source
    pub(all) struct TopologyHealthReport {
      node_count : Int
      link_count : Int
      healthy : Int
      degraded : Int
      unavailable : Int
      average_load : Int
      invalid_edges : Int
    }

    A compact health report suitable for a gateway status endpoint.

    TopologyHealthReport::average_load

    source
    fn TopologyHealthReport::average_load(self : TopologyHealthReport) -> Int

    TopologyHealthReport::degraded

    source
    fn TopologyHealthReport::degraded(self : TopologyHealthReport) -> Int

    TopologyHealthReport::healthy

    source
    fn TopologyHealthReport::healthy(self : TopologyHealthReport) -> Int

    TopologyHealthReport::invalid_edges

    source
    fn TopologyHealthReport::invalid_edges(self : TopologyHealthReport) -> Int

    fn TopologyHealthReport::link_count(self : TopologyHealthReport) -> Int

    TopologyHealthReport::new

    source

    TopologyHealthReport::node_count

    source
    fn TopologyHealthReport::node_count(self : TopologyHealthReport) -> Int

    TopologyHealthReport::summary

    source
    fn TopologyHealthReport::summary(self : TopologyHealthReport) -> String

    TopologyHealthReport::unavailable

    source
    fn TopologyHealthReport::unavailable(self : TopologyHealthReport) -> Int

    pub(all) struct TopologyLink {
      id : String
      from : String
      to : String
      latency : Int
      capacity : Int
      utilization : Int
      bidirectional : Bool
      transport : String
    }

    A directed or bidirectional connection between topology nodes.

    TopologyLink::available

    source
    fn TopologyLink::available(self : TopologyLink) -> Bool

    TopologyLink::capacity

    source
    fn TopologyLink::capacity(self : TopologyLink) -> Int

    TopologyLink::connects

    source
    fn TopologyLink::connects(self : TopologyLink, node_id : String) -> Bool

    TopologyLink::cost

    source
    fn TopologyLink::cost(self : TopologyLink) -> Int

    TopologyLink::from

    source
    fn TopologyLink::from(self : TopologyLink) -> String

    TopologyLink::id

    source
    fn TopologyLink::id(self : TopologyLink) -> String

    TopologyLink::is_bidirectional

    source
    fn TopologyLink::is_bidirectional(self : TopologyLink) -> Bool

    TopologyLink::latency

    source
    fn TopologyLink::latency(self : TopologyLink) -> Int

    TopologyLink::new

    source
    fn TopologyLink::new(id : String, from : String, to : String, latency : Int, capacity : Int, bidirectional? : Bool, transport? : String) -> Result[TopologyLink, ModbusError]

    TopologyLink::other

    source
    fn TopologyLink::other(self : TopologyLink, node_id : String) -> String?

    TopologyLink::set_utilization

    source
    fn TopologyLink::set_utilization(self : TopologyLink, value : Int) -> Result[Unit, ModbusError]

    TopologyLink::to

    source
    fn TopologyLink::to(self : TopologyLink) -> String

    TopologyLink::transport

    source
    fn TopologyLink::transport(self : TopologyLink) -> String

    TopologyLink::utilization

    source
    fn TopologyLink::utilization(self : TopologyLink) -> Int

    TopologyNode

    source
    pub(all) struct TopologyNode {
      id : String
      label : String
      kind : TopologyNodeKind
      unit_id : Byte?
      health : TopologyHealth
      load : Int
      zone : String
      tags : Array[String]
    }

    A graph node representing a site, device, gateway, or consumer.

    TopologyNode::add_tag

    source
    fn TopologyNode::add_tag(self : TopologyNode, tag : String) -> Result[Unit, ModbusError]

    TopologyNode::has_tag

    source
    fn TopologyNode::has_tag(self : TopologyNode, tag : String) -> Bool

    TopologyNode::health

    source

    TopologyNode::id

    source
    fn TopologyNode::id(self : TopologyNode) -> String

    TopologyNode::is_available

    source
    fn TopologyNode::is_available(self : TopologyNode) -> Bool

    TopologyNode::kind

    source

    TopologyNode::label

    source
    fn TopologyNode::label(self : TopologyNode) -> String

    TopologyNode::load

    source
    fn TopologyNode::load(self : TopologyNode) -> Int

    TopologyNode::new

    source
    fn TopologyNode::new(id : String, label : String, kind : TopologyNodeKind, unit_id? : Byte, zone? : String) -> Result[TopologyNode, ModbusError]

    TopologyNode::set_health

    source
    fn TopologyNode::set_health(self : TopologyNode, health : TopologyHealth) -> Unit

    TopologyNode::set_load

    source
    fn TopologyNode::set_load(self : TopologyNode, load : Int) -> Result[Unit, ModbusError]

    TopologyNode::tag_count

    source
    fn TopologyNode::tag_count(self : TopologyNode) -> Int

    TopologyNode::unit_id

    source
    fn TopologyNode::unit_id(self : TopologyNode) -> Byte?

    TopologyNode::zone

    source
    fn TopologyNode::zone(self : TopologyNode) -> String

    TopologyNodeKind

    source
    pub(all) enum TopologyNodeKind {
      SiteNode
      DeviceNode
      GatewayNode
      ServiceNode
    } derive(Eq, 
    Debug    )

    The role of a node in a Modbus deployment topology.

    TopologyRoute

    source
    pub(all) struct TopologyRoute {
      source : String
      destination : String
      nodes : Array[String]
      links : Array[String]
      cost : Int
      reachable : Bool
    }

    A selected path with aggregate latency and link identifiers.

    TopologyRoute::cost

    source
    fn TopologyRoute::cost(self : TopologyRoute) -> Int

    TopologyRoute::destination

    source
    fn TopologyRoute::destination(self : TopologyRoute) -> String

    TopologyRoute::hops

    source
    fn TopologyRoute::hops(self : TopologyRoute) -> Int

    fn TopologyRoute::links(self : TopologyRoute) -> Array[String]

    TopologyRoute::new

    source
    fn TopologyRoute::new(source : String, destination : String, nodes : Array[String], links : Array[String], cost : Int) -> TopologyRoute

    TopologyRoute::nodes

    source
    fn TopologyRoute::nodes(self : TopologyRoute) -> Array[String]

    TopologyRoute::not_reachable

    source
    fn TopologyRoute::not_reachable(source : String, destination : String) -> TopologyRoute

    TopologyRoute::reachable

    source
    fn TopologyRoute::reachable(self : TopologyRoute) -> Bool

    TopologyRoute::source

    source
    fn TopologyRoute::source(self : TopologyRoute) -> String

    TopologyRoute::summary

    source
    fn TopologyRoute::summary(self : TopologyRoute) -> String

    TransactionBatch

    source
    pub(all) struct TransactionBatch {
      transactions : Array[ModbusTransaction]
      max_transactions : Int
    }

    A transaction batch containing several independent units.

    TransactionBatch::add

    source
    fn TransactionBatch::add(self : TransactionBatch, transaction : ModbusTransaction) -> Result[Unit, ModbusError]

    TransactionBatch::count

    source
    fn TransactionBatch::count(self : TransactionBatch) -> Int

    TransactionBatch::failed

    source
    fn TransactionBatch::failed(self : TransactionBatch) -> Int

    TransactionBatch::new

    source
    fn TransactionBatch::new(max_transactions? : Int) -> Result[TransactionBatch, ModbusError]

    TransactionBatch::successful

    source
    fn TransactionBatch::successful(self : TransactionBatch) -> Int

    TransactionFrame

    source
    pub(all) struct TransactionFrame {
      transaction_id : UInt16
      request : Frame
      response : Frame?
    }

    A request/response pair associated with a TCP transaction identifier.

    TransactionFrame::complete

    source
    fn TransactionFrame::complete(self : TransactionFrame, response : Frame) -> TransactionFrame

    TransactionFrame::is_complete

    source
    fn TransactionFrame::is_complete(self : TransactionFrame) -> Bool

    TransactionFrame::new

    source
    fn TransactionFrame::new(transaction_id : UInt16, request : Frame) -> TransactionFrame

    TransactionItem

    source
    pub(all) struct TransactionItem {
      id : String
      request : Frame
      compensation : Frame?
      state : TransactionState
      order : Int
    }

    A request in a transaction with an optional compensation frame.

    TransactionItem::compensation

    source
    fn TransactionItem::compensation(self : TransactionItem) -> Frame?

    TransactionItem::id

    source
    fn TransactionItem::id(self : TransactionItem) -> String

    TransactionItem::mark

    source
    fn TransactionItem::mark(self : TransactionItem, state : TransactionState) -> Unit

    TransactionItem::new

    source
    fn TransactionItem::new(id : String, request : Frame, order : Int, compensation? : Frame) -> Result[TransactionItem, ModbusError]

    TransactionItem::order

    source
    fn TransactionItem::order(self : TransactionItem) -> Int

    TransactionItem::request

    source
    fn TransactionItem::request(self : TransactionItem) -> Frame

    TransactionItem::state

    source

    TransactionOutcome

    source
    pub(all) struct TransactionOutcome {
      item_id : String
      state : TransactionState
      response : Frame?
      error : ModbusError?
      timestamp : Int
    }

    A transaction result with response and error context.

    TransactionOutcome::error

    source

    TransactionOutcome::item_id

    source
    fn TransactionOutcome::item_id(self : TransactionOutcome) -> String

    TransactionOutcome::new

    source
    fn TransactionOutcome::new(item_id : String, state : TransactionState, timestamp : Int, response? : Frame, error? : ModbusError) -> Result[TransactionOutcome, ModbusError]

    TransactionOutcome::response

    source

    TransactionOutcome::state

    source

    TransactionOutcome::timestamp

    source
    fn TransactionOutcome::timestamp(self : TransactionOutcome) -> Int

    TransactionState

    source
    pub(all) enum TransactionState {
      TransactionOpen
      TransactionPrepared
      TransactionCommitted
      TransactionRolledBack
      TransactionFailed
    } derive(Eq, 
    Debug    )

    Lifecycle state for a multi-request transaction.

    TransportCapabilities

    source
    pub(all) struct TransportCapabilities {
      mode : Mode
      max_adu : Int
      supports_broadcast : Bool
      preserves_transaction_id : Bool
    }

    A transport capability report for startup diagnostics.

    TransportKind

    source
    pub(all) enum TransportKind {
      SerialRtu
      SerialAscii
      ModbusTcp
    } derive(Eq, 
    Debug    )

    Named transport choices used by adapters.

    TransportMetricWindow

    source
    pub(all) struct TransportMetricWindow {
      transport : MetricsTransport
      window : Int
      requests : Int
      successes : Int
      failures : Int
      bytes_sent : Int
      bytes_received : Int
      latency_total : Int
      latency_max : Int
      last_timestamp : Int
    }

    Request outcome accumulated by a transport lane.

    TransportMetricWindow::average_latency

    source
    fn TransportMetricWindow::average_latency(self : TransportMetricWindow) -> Int

    TransportMetricWindow::bytes_received

    source
    fn TransportMetricWindow::bytes_received(self : TransportMetricWindow) -> Int

    TransportMetricWindow::bytes_sent

    source
    fn TransportMetricWindow::bytes_sent(self : TransportMetricWindow) -> Int

    TransportMetricWindow::failures

    source
    fn TransportMetricWindow::failures(self : TransportMetricWindow) -> Int

    TransportMetricWindow::maximum_latency

    source
    fn TransportMetricWindow::maximum_latency(self : TransportMetricWindow) -> Int

    TransportMetricWindow::new

    source
    fn TransportMetricWindow::new(transport : MetricsTransport, window : Int) -> Result[TransportMetricWindow, ModbusError]

    TransportMetricWindow::record

    source
    fn TransportMetricWindow::record(self : TransportMetricWindow, timestamp : Int, success : Bool, latency : Int, sent : Int, received : Int) -> Result[Unit, ModbusError]

    TransportMetricWindow::requests

    source
    fn TransportMetricWindow::requests(self : TransportMetricWindow) -> Int

    TransportMetricWindow::reset

    source

    TransportMetricWindow::success_rate

    source
    fn TransportMetricWindow::success_rate(self : TransportMetricWindow) -> Int

    TransportMetricWindow::successes

    source
    fn TransportMetricWindow::successes(self : TransportMetricWindow) -> Int

    TransportMetricWindow::transport

    source

    TransportMetricWindow::window

    source

    TransportMetricsRegistry

    source
    pub(all) struct TransportMetricsRegistry {
      windows : Array[TransportMetricWindow]
      max_windows : Int
    }

    Fleet transport metrics registry.

    TransportMetricsRegistry::count

    source

    TransportMetricsRegistry::export_lines

    source
    fn TransportMetricsRegistry::export_lines(self : TransportMetricsRegistry) -> Array[String]

    TransportMetricsRegistry::new

    source
    fn TransportMetricsRegistry::new(max_windows? : Int, window? : Int) -> Result[TransportMetricsRegistry, ModbusError]

    TransportMetricsRegistry::record

    source
    fn TransportMetricsRegistry::record(self : TransportMetricsRegistry, transport : MetricsTransport, timestamp : Int, success : Bool, latency : Int, sent : Int, received : Int) -> Result[Unit, ModbusError]

    TransportMetricsRegistry::total_failures

    source
    fn TransportMetricsRegistry::total_failures(self : TransportMetricsRegistry) -> Int

    TransportMetricsRegistry::total_requests

    source
    fn TransportMetricsRegistry::total_requests(self : TransportMetricsRegistry) -> Int

    TransportMetricsRegistry::window

    source

    TrendDirection

    source
    pub(all) enum TrendDirection {
      RisingTrend
      FallingTrend
      StableTrend
      InsufficientTrend
    } derive(Eq, 
    Debug    )

    Direction of a value series over a configured observation window.

    ValueAnomaly

    source
    pub(all) struct ValueAnomaly {
      rule_id : String
      timestamp : Int
      value : Int
      kind : AnomalyKind
      severity : Int
      detail : String
    }

    A detected deviation with enough context for an incident message.

    ValueAnomaly::detail

    source
    fn ValueAnomaly::detail(self : ValueAnomaly) -> String

    ValueAnomaly::kind

    source

    ValueAnomaly::new

    source
    fn ValueAnomaly::new(rule_id : String, timestamp : Int, value : Int, kind : AnomalyKind, severity : Int, detail : String) -> Result[ValueAnomaly, ModbusError]

    ValueAnomaly::rule_id

    source
    fn ValueAnomaly::rule_id(self : ValueAnomaly) -> String

    ValueAnomaly::severity

    source
    fn ValueAnomaly::severity(self : ValueAnomaly) -> Int

    ValueAnomaly::timestamp

    source
    fn ValueAnomaly::timestamp(self : ValueAnomaly) -> Int

    ValueAnomaly::value

    source
    fn ValueAnomaly::value(self : ValueAnomaly) -> Int

    ValueHistogram

    source
    pub(all) struct ValueHistogram {
      lower : Int
      upper : Int
      width : Int
      bins : Array[Int]
      outside : Int
    }

    Fixed-width histogram used for distribution and percentile approximations.

    ValueHistogram::add

    source
    fn ValueHistogram::add(self : ValueHistogram, value : Int) -> Unit

    ValueHistogram::bins

    source
    fn ValueHistogram::bins(self : ValueHistogram) -> Array[Int]

    ValueHistogram::new

    source
    fn ValueHistogram::new(lower : Int, upper : Int, bin_count : Int) -> Result[ValueHistogram, ModbusError]

    ValueHistogram::outside

    source
    fn ValueHistogram::outside(self : ValueHistogram) -> Int

    ValueHistogram::percentile

    source
    fn ValueHistogram::percentile(self : ValueHistogram, percent : Int) -> Result[Int, ModbusError]

    ValueHistogram::total

    source
    fn ValueHistogram::total(self : ValueHistogram) -> Int

    pub struct VirtualLink {
      mode : Mode
      max_queue : Int
      master_to_device : Array[Array[Byte]]
      device_to_master : Array[Array[Byte]]
      sent : Int
      received : Int
      dropped : Int
    }

    A deterministic in-memory transport used by tests, demos, and simulators.

    VirtualLink::clear

    source
    fn VirtualLink::clear(self : VirtualLink) -> Unit

    VirtualLink::dropped_count

    source
    fn VirtualLink::dropped_count(self : VirtualLink) -> Int

    VirtualLink::mode

    source
    fn VirtualLink::mode(self : VirtualLink) -> Mode

    VirtualLink::new

    source
    fn VirtualLink::new(mode : Mode, max_queue? : Int) -> Result[VirtualLink, ModbusError]

    VirtualLink::queued_requests

    source
    fn VirtualLink::queued_requests(self : VirtualLink) -> Int

    VirtualLink::queued_responses

    source
    fn VirtualLink::queued_responses(self : VirtualLink) -> Int

    VirtualLink::receive_request

    source
    fn VirtualLink::receive_request(self : VirtualLink) -> Result[Frame, ModbusError]

    VirtualLink::receive_response

    source
    fn VirtualLink::receive_response(self : VirtualLink) -> Result[Array[Byte], ModbusError]

    VirtualLink::received_count

    source
    fn VirtualLink::received_count(self : VirtualLink) -> Int

    VirtualLink::round_trip

    source
    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

    source
    fn VirtualLink::send_request(self : VirtualLink, transaction_id : UInt16, frame : Frame) -> Result[Unit, ModbusError]

    VirtualLink::send_response

    source
    fn VirtualLink::send_response(self : VirtualLink, transaction_id : UInt16, frame : Frame) -> Result[Unit, ModbusError]

    VirtualLink::sent_count

    source
    fn VirtualLink::sent_count(self : VirtualLink) -> Int

    WorkOrderState

    source
    pub(all) enum WorkOrderState {
      Planned
      Assigned
      InProgress
      Blocked
      Completed
      Cancelled
    } derive(Eq, 
    Debug    )

    State of a maintenance work order.

    accepts_broadcast

    source
    fn accepts_broadcast(mode : Mode) -> Bool

    access_operation_name

    source
    fn access_operation_name(value : AccessOperation) -> String

    access_role_rank

    source
    fn access_role_rank(value : AccessRole) -> Int

    address_bytes

    source
    fn address_bytes(address : UInt16) -> Array[Byte]

    Make the two-byte address representation used by request builders.

    aggregation_name

    source
    fn aggregation_name(value : Aggregation) -> String

    alarm_condition_name

    source
    fn alarm_condition_name(value : AlarmCondition) -> String

    alarm_severity_name

    source
    fn alarm_severity_name(value : AlarmSeverity) -> String

    alarm_state_name

    source
    fn alarm_state_name(value : AlarmState) -> String

    analytics_report

    source
    fn analytics_report(window : AnalyticsWindow, rule : AnalyticsRule, histogram : ValueHistogram) -> Result[AnalyticsReport, ModbusError]

    anomaly_kind_name

    source
    fn anomaly_kind_name(kind : AnomalyKind) -> String

    append_u16_be

    source
    fn append_u16_be(out : Array[Byte], value : UInt16) -> Unit

    Append a big-endian unsigned 16-bit value.

    append_u32_be

    source
    fn append_u32_be(out : Array[Byte], value : UInt) -> Unit

    Append a big-endian unsigned 32-bit value.

    ascii_boundary

    source
    fn ascii_boundary(bytes : Array[Byte]) -> Int?

    Return a complete ASCII frame boundary if CRLF is present.

    ascii_mode

    source
    fn ascii_mode() -> Mode

    base_function

    source
    fn base_function(frame : Frame) -> Byte

    Return the function number without the exception bit.

    batch_completed

    source
    fn batch_completed(results : Array[BatchResult]) -> Int

    batch_failed

    source
    fn batch_failed(results : Array[BatchResult]) -> Int

    batch_register_values

    source
    fn batch_register_values(results : Array[BatchResult]) -> Result[Array[UInt16], ModbusError]

    Merge successful register responses from a batch into one ordered array.

    benchmark_crc

    source
    fn benchmark_crc(iterations : Int) -> Result[BenchmarkResult, ModbusError]

    Run repeated CRC work over a representative RTU payload.

    benchmark_device_reads

    source
    fn benchmark_device_reads(iterations : Int) -> Result[BenchmarkResult, ModbusError]

    Run a device read workload over the in-memory server path.

    benchmark_rtu_round_trip

    source
    fn benchmark_rtu_round_trip(iterations : Int) -> Result[BenchmarkResult, ModbusError]

    Run encode/decode round trips for the RTU transport.

    benchmark_suite

    source
    fn benchmark_suite(iterations : Int) -> Result[Array[BenchmarkResult], ModbusError]

    Run the standard local benchmark suite.

    benchmark_tcp_round_trip

    source
    fn benchmark_tcp_round_trip(iterations : Int) -> Result[BenchmarkResult, ModbusError]

    Run encode/decode round trips for the TCP transport.

    boundary_vectors

    source
    fn boundary_vectors(frame : Frame) -> Array[ConformanceVector]

    Generate boundary vectors for empty, short, and corrupt inputs.

    bridge_action_name

    source
    fn bridge_action_name(action : BridgeAction) -> String

    bucket_samples

    source
    fn bucket_samples(samples : Array[TagSample], start : Int, width : Int) -> Result[Array[HistoryBucket], ModbusError]

    byte_sum

    source
    fn byte_sum(bytes : Array[Byte]) -> Byte

    byte_xor

    source
    fn byte_xor(bytes : Array[Byte]) -> Byte

    bytes_equal

    source
    fn bytes_equal(left : Array[Byte], right : Array[Byte]) -> Bool

    bytes_to_hex_string

    source
    fn bytes_to_hex_string(bytes : Array[Byte]) -> String

    Convert a byte array to a printable uppercase hexadecimal string.

    bytes_to_register

    source
    fn bytes_to_register(bytes : Array[Byte], offset : Int, order : RegisterByteOrder) -> Result[UInt16, ModbusError]

    Decode two bytes as one register.

    bytes_to_registers

    source
    fn bytes_to_registers(bytes : Array[Byte], order : RegisterByteOrder) -> Result[Array[UInt16], ModbusError]

    Convert an even-length byte array to registers.

    capabilities

    source
    fn capabilities(mode : Mode) -> TransportCapabilities

    capacity_resource_name

    source
    fn capacity_resource_name(resource : CapacityResource) -> String

    capture_direction_name

    source
    fn capture_direction_name(direction : CaptureDirection) -> String

    capture_status_name

    source
    fn capture_status_name(status : CaptureStatus) -> String

    chunk_bytes

    source
    fn chunk_bytes(bytes : Array[Byte], chunk_size : Int) -> Result[Array[Array[Byte]], ModbusError]

    Split a byte array into bounded chunks for transport fuzzing and tests.

    clamp_int

    source
    fn clamp_int(value : Int, minimum : Int, maximum : Int) -> Result[Int, ModbusError]

    client_result

    source
    fn client_result(response : Frame) -> ClientResult

    config_diff

    source
    fn config_diff(before : Array[ConfigEntry], after : Array[ConfigEntry]) -> Array[ConfigOperation]

    config_kind_name

    source
    fn config_kind_name(kind : ConfigKind) -> String

    config_schema_summary

    source
    fn config_schema_summary(schema : ConfigSchema) -> String

    config_values_equal

    source
    fn config_values_equal(left : ConfigValue, right : ConfigValue) -> Bool

    conformance_failed

    source
    fn conformance_failed(results : Array[ConformanceResult]) -> Int

    conformance_passed

    source
    fn conformance_passed(results : Array[ConformanceResult]) -> Int

    contract_result_name

    source
    fn contract_result_name(result : ContractResult) -> String

    copy_bytes

    source
    fn copy_bytes(bytes : Array[Byte]) -> Array[Byte]

    Make an owned byte-array copy. Protocol parsers use this to avoid retaining views.

    copy_range

    source
    fn copy_range(bytes : Array[Byte], start : Int, end : Int) -> Result[Array[Byte], ModbusError]

    Copy a half-open range and return a protocol error when the range is invalid.

    count_bits

    source
    fn count_bits(bytes : Array[Byte]) -> Int

    Count the set bits in a packed byte array.

    crc16

    source
    fn crc16(bytes : Array[Byte]) -> UInt16

    Modbus polynomial CRC16, low byte first on the wire.

    crc16_range

    source
    fn crc16_range(bytes : Array[Byte], start : Int, end : Int) -> Result[UInt16, ModbusError]

    Compute CRC16 for a half-open range without allocating a slice.

    crc16_update

    source
    fn crc16_update(crc : UInt16, byte : Byte) -> UInt16

    Update a CRC16 accumulator with one byte.

    crc_bytes

    source
    fn crc_bytes(bytes : Array[Byte]) -> Array[Byte]

    Return CRC bytes in Modbus RTU order.

    decode_ascii

    source
    fn decode_ascii(bytes : Array[Byte]) -> Result[Frame, ModbusError]

    Decode one complete Modbus ASCII frame.

    decode_bits_response

    source
    fn decode_bits_response(request : Frame, response : Frame) -> Result[Array[Bool], ModbusError]

    Decode a read-coils or read-discrete-inputs response.

    decode_comm_event_counter

    source
    fn decode_comm_event_counter(request : Frame, response : Frame) -> Result[(UInt16, UInt16), ModbusError]

    Decode the communication event counter response.

    decode_device_identification

    source
    fn decode_device_identification(request : Frame, response : Frame) -> Result[DeviceIdentification, ModbusError]

    Decode a Read Device Identification response into TLV objects.

    decode_diagnostics

    source
    fn decode_diagnostics(request : Frame, response : Frame) -> Result[(UInt16, Array[Byte]), ModbusError]

    Decode the two-byte diagnostics subfunction and its data.

    decode_exception_status

    source
    fn decode_exception_status(request : Frame, response : Frame) -> Result[Byte, ModbusError]

    Decode an exception-status response.

    decode_fifo_queue

    source
    fn decode_fifo_queue(request : Frame, response : Frame) -> Result[Array[UInt16], ModbusError]

    Decode a FIFO response into the queue values.

    decode_file_record_response

    source
    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

    source
    fn decode_file_record_write_response(request : Frame, response : Frame) -> Result[Unit, ModbusError]

    Decode the echo of a Write File Record response.

    decode_hex

    source
    fn decode_hex(bytes : Array[Byte]) -> Result[Array[Byte], ModbusError]

    Decode an even-length hexadecimal ASCII array.

    decode_mask_write

    source
    fn decode_mask_write(request : Frame, response : Frame) -> Result[(UInt16, UInt16), ModbusError]

    Decode a mask-write response and return (and_mask, or_mask).

    decode_mode

    source
    fn decode_mode(mode : Mode, bytes : Array[Byte]) -> Result[Frame, ModbusError]

    Decode a complete frame when the transport does not carry a TCP transaction id.

    decode_multiple_write

    source
    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

    source
    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

    source
    fn decode_register_response(request : Frame, response : Frame) -> Result[Array[UInt16], ModbusError]

    Decode a function 03 or 04 register response.

    decode_response

    source
    fn decode_response(request : Frame, response : Frame) -> Result[ResponseValue, ModbusError]

    Decode any response while preserving exception information.

    decode_rtu

    source
    fn decode_rtu(bytes : Array[Byte]) -> Result[Frame, ModbusError]

    Decode one complete Modbus RTU frame.

    decode_server_id

    source
    fn decode_server_id(request : Frame, response : Frame) -> Result[Array[Byte], ModbusError]

    Decode a Report Server ID response into its raw payload.

    decode_tcp

    source
    fn decode_tcp(bytes : Array[Byte]) -> Result[(UInt16, Frame), ModbusError]

    Decode one complete Modbus TCP ADU and return its transaction id.

    decode_transaction

    source
    fn decode_transaction(mode : Mode, bytes : Array[Byte]) -> Result[(UInt16, Frame), ModbusError]

    Decode an encoded frame and preserve a TCP transaction identifier when present.

    decode_write_single_coil

    source
    fn decode_write_single_coil(request : Frame, response : Frame) -> Result[Bool, ModbusError]

    Decode a single-coil echo and return its logical value.

    decode_write_single_register

    source
    fn decode_write_single_register(request : Frame, response : Frame) -> Result[UInt16, ModbusError]

    Decode a single-register write echo.

    default_client_config

    source
    fn default_client_config() -> ClientConfig

    default_frame_limit

    source
    fn default_frame_limit(mode : Mode) -> Int

    default_limits

    source
    fn default_limits() -> ProtocolLimits

    default_queue_limit

    source
    fn default_queue_limit(mode : Mode) -> Int

    default_retry_policy

    source
    fn default_retry_policy() -> RetryPolicy

    default_server_capabilities

    source
    fn default_server_capabilities() -> CapabilitySet

    default_server_config

    source
    fn default_server_config(mode : Mode) -> ServerConfig

    device_command_kind_name

    source
    fn device_command_kind_name(kind : DeviceCommandKind) -> String

    device_command_state_name

    source
    fn device_command_state_name(state : DeviceCommandState) -> String

    device_id_category

    source
    fn device_id_category(value : Byte) -> DeviceIdCategory

    device_service_kind_name

    source
    fn device_service_kind_name(kind : DeviceServiceKind) -> String

    device_service_state_name

    source
    fn device_service_state_name(state : DeviceServiceState) -> String

    diagnose_capability_gap

    source
    fn diagnose_capability_gap(capabilities : CapabilitySet, expected_functions : Array[Byte]) -> DiagnosticReport

    diagnose_frames

    source
    fn diagnose_frames(frames : Array[Frame]) -> DiagnosticReport

    diagnostic_category_name

    source
    fn diagnostic_category_name(value : DiagnosticCategory) -> String

    diagnostic_severity_name

    source
    fn diagnostic_severity_name(value : DiagnosticSeverity) -> String

    diagnostics

    source
    fn diagnostics(unit_id : Byte, subfunction : UInt16, data : Array[Byte]) -> Result[Frame, ModbusError]

    Build a diagnostics request (function 08).

    diagnostics_return_query_data

    source
    fn diagnostics_return_query_data(unit_id : Byte, data : Array[Byte]) -> Result[Frame, ModbusError]

    Build the common Return Query Data diagnostics request.

    encapsulated_interface

    source
    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

    source
    fn encode_ascii(frame : Frame) -> Array[Byte]

    Encode a frame as Modbus ASCII, including : prefix and CRLF suffix.

    encode_device_identification

    source
    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

    source
    fn encode_hex(bytes : Array[Byte]) -> Array[Byte]

    Encode an owned byte array as uppercase hexadecimal ASCII.

    encode_mode

    source
    fn encode_mode(mode : Mode, frame : Frame) -> Array[Byte]

    Encode a frame for a mode; TCP uses transaction id zero for this convenience API.

    encode_rtu

    source
    fn encode_rtu(frame : Frame) -> Array[Byte]

    Encode a frame as Modbus RTU.

    encode_tcp

    source
    fn encode_tcp(transaction_id : UInt16, frame : Frame) -> Array[Byte]

    Encode a frame as Modbus TCP, using a caller-provided transaction id.

    encoded_length

    source
    fn encoded_length(mode : Mode, frame : Frame) -> Int

    Return the encoded size of a frame on a transport.

    endpoint_health

    source
    fn endpoint_health(device : Device, metrics : ProtocolMetrics) -> EndpointHealth

    endpoint_health_summary

    source
    fn endpoint_health_summary(health : EndpointHealth) -> String

    Summarize health in stable key/value form for a CLI or metrics exporter.

    endpoint_score

    source
    fn endpoint_score(health : EndpointHealth) -> Int

    Return a score in [0, 100] suitable for a small status indicator.

    engineering_unit_name

    source
    fn engineering_unit_name(unit : EngineeringUnit) -> String

    error_name

    source
    fn error_name(error : ModbusError) -> String

    Convert a protocol error to a stable diagnostic name.

    error_or_unit

    source
    fn error_or_unit(result : Result[Unit, ModbusError]) -> String

    error_response

    source
    fn error_response(request : Frame, error : ModbusError) -> Frame

    Construct an exception from a protocol error.

    evaluate_access

    source
    fn evaluate_access(policy : AccessPolicy, role : AccessRole, operation : AccessOperation, principal : String, frame : Frame, timestamp : Int, sequence : Int) -> Result[SecurityAudit, ModbusError]

    exception_code

    source
    fn exception_code(value : Byte) -> ExceptionCode

    exception_for_error

    source
    fn exception_for_error(error : ModbusError) -> ExceptionCode

    exception_from_frame

    source
    fn exception_from_frame(frame : Frame) -> Result[ExceptionCode, ModbusError]

    Decode the exception code from a standard exception response.

    exception_response

    source
    fn exception_response(unit_id : Byte, function : Byte, code : Byte) -> Frame

    Build a standard Modbus exception response.

    expected_response_function

    source
    fn expected_response_function(request : Frame) -> Byte

    Return the expected response function byte for a request.

    expected_tcp_length

    source
    fn expected_tcp_length(bytes : Array[Byte]) -> Result[Int, ModbusError]

    Return the expected TCP ADU size from a partial header.

    f32_to_registers

    source
    fn f32_to_registers(value : Float, word_order : RegisterWordOrder) -> Array[UInt16]

    Encode a Float in IEEE-754 binary32 form as two registers.

    fault_mode_name

    source
    fn fault_mode_name(mode : FaultMode) -> String

    fits_mode_limit

    source
    fn fits_mode_limit(mode : Mode, frame : Frame) -> Bool

    Return whether a frame can be represented by a mode's ADU limit.

    fits_queue_budget

    source
    fn fits_queue_budget(frames : Array[Frame], mode : Mode, budget : Int) -> Bool

    Check that an entire sequence stays below a caller's queue budget.

    fleet_health_from_inventory

    source
    fn fleet_health_from_inventory(rollup : FleetHealthRollup, inventory : DeviceInventory, now : Int, timeout : Int) -> Result[Unit, ModbusError]

    Generate a contribution from inventory reachability.

    fleet_health_from_reliability

    source
    fn fleet_health_from_reliability(timestamp : Int, summary : ReliabilityFleetSummary) -> Result[FleetHealthRollup, ModbusError]

    Generate contributions from a reliability fleet summary.

    fleet_health_from_services

    source
    fn fleet_health_from_services(rollup : FleetHealthRollup, registry : DeviceServiceRegistry) -> Result[Unit, ModbusError]

    Generate contributions from a service registry.

    fleet_health_state_name

    source
    fn fleet_health_state_name(state : FleetHealthState) -> String

    fleet_score

    source
    fn fleet_score(health : Array[EndpointHealth]) -> Int

    Compute an overall score for a fleet of devices.

    float_words

    source
    fn float_words(high : UInt16, low : UInt16) -> UInt64

    Decode two registers as the raw IEEE-754 single precision words.

    format_error

    source
    fn format_error(error : ModbusError) -> String

    Produce a one-line protocol error for a CLI diagnostic.

    format_frame

    source
    fn format_frame(frame : Frame) -> String

    Format a complete frame for logs without exposing transport framing.

    format_wire_frame

    source
    fn format_wire_frame(mode : Mode, transaction_id : UInt16, frame : Frame) -> String

    Format a frame with its RTU, ASCII, or TCP wire representation.

    frame_budget_available

    source
    fn frame_budget_available(mode : Mode, frame : Frame, budget : Int) -> Bool

    frame_count_for_coils

    source
    fn frame_count_for_coils(quantity : Int) -> Result[Int, ModbusError]

    Calculate the number of frames needed for a logical coil read.

    frame_count_for_registers

    source
    fn frame_count_for_registers(quantity : Int) -> Result[Int, ModbusError]

    Calculate the number of frames needed for a logical register read.

    frame_data_copy

    source
    fn frame_data_copy(frame : Frame) -> Array[Byte]

    frame_is_empty

    source
    fn frame_is_empty(frame : Frame) -> Bool

    frame_is_valid

    source
    fn frame_is_valid(frame : Frame) -> Bool

    frame_with_data_copy

    source
    fn frame_with_data_copy(frame : Frame, data : Array[Byte]) -> Frame

    frames_equal

    source
    fn frames_equal(left : Frame, right : Frame) -> Bool

    Compare frames at the logical PDU level.

    function_catalog

    source
    fn function_catalog() -> Array[FunctionDescriptor]

    Return every descriptor in numeric order.

    function_code

    source
    fn function_code(value : Byte) -> FunctionCode

    Convert a function code byte into the typed function-code vocabulary.

    function_descriptor

    source
    fn function_descriptor(function : Byte) -> FunctionDescriptor?

    function_name

    source
    fn function_name(function : Byte) -> String

    Human-readable function-code name used by diagnostic output.

    gateway_function_supported

    source
    fn gateway_function_supported(function : Byte) -> Bool

    Return whether a gateway rule can safely carry a function code.

    get_bit

    source
    fn get_bit(bytes : Array[Byte], index : Int) -> Result[Bool, ModbusError]

    Read a single bit from a packed byte array.

    get_comm_event_counter

    source
    fn get_comm_event_counter(unit_id : Byte) -> Result[Frame, ModbusError]

    Build a request for the communication event counter (function 11).

    get_comm_event_log

    source
    fn get_comm_event_log(unit_id : Byte) -> Result[Frame, ModbusError]

    Build a request for the communication event log (function 12).

    guard_decision_name

    source
    fn guard_decision_name(value : GuardDecision) -> String

    guard_reason_name

    source
    fn guard_reason_name(value : GuardReason) -> String

    hex_string_to_bytes

    source
    fn hex_string_to_bytes(text : String) -> Result[Array[Byte], ModbusError]

    Convert a string containing hexadecimal digits and optional whitespace to bytes.

    i32_to_registers

    source
    fn i32_to_registers(value : Int, word_order : RegisterWordOrder) -> Array[UInt16]

    Encode a signed 32-bit value using two's-complement bits.

    inventory_state_name

    source
    fn inventory_state_name(state : InventoryState) -> String

    is_broadcast

    source
    fn is_broadcast(unit_id : Byte) -> Bool

    True when the frame uses the serial-line broadcast address.

    is_client_input_error

    source
    fn is_client_input_error(error : ModbusError) -> Bool

    is_exception

    source
    fn is_exception(frame : Frame) -> Bool

    Whether a PDU is an exception response.

    is_read_function

    source
    fn is_read_function(function : Byte) -> Bool

    is_retryable

    source
    fn is_retryable(error : ModbusError) -> Bool

    Return whether an error is recoverable by a retry policy.

    is_supported_mode

    source
    fn is_supported_mode(mode : Mode) -> Bool

    is_transport_error

    source
    fn is_transport_error(error : ModbusError) -> Bool

    is_valid_unit_id

    source
    fn is_valid_unit_id(unit_id : Byte, broadcast? : Bool) -> Bool

    True for a legal serial-line unit identifier, including broadcast.

    is_write_echo

    source
    fn is_write_echo(request : Frame, response : Frame) -> Bool

    Check an ordinary write response without decoding its fields.

    is_write_function

    source
    fn is_write_function(function : Byte) -> Bool

    job_priority_rank

    source
    fn job_priority_rank(priority : JobPriority) -> Int

    job_state_name

    source
    fn job_state_name(state : JobState) -> String

    join_chunks

    source
    fn join_chunks(chunks : Array[Array[Byte]], max_length : Int) -> Result[Array[Byte], ModbusError]

    Reassemble byte chunks and check their total size.

    lease_state_name

    source
    fn lease_state_name(state : LeaseState) -> String

    least_healthy

    source
    fn least_healthy(health : Array[EndpointHealth]) -> EndpointHealth?

    Return the least healthy endpoint, if any.

    limits_for

    source
    fn limits_for(mode : Mode) -> ProtocolLimits

    lrc

    source
    fn lrc(bytes : Array[Byte]) -> Byte

    LRC used by Modbus ASCII.

    lrc_from_sum

    source
    fn lrc_from_sum(sum : Byte) -> Byte

    Compute the LRC from a running sum, using the Modbus two's-complement rule.

    lrc_with_sum

    source
    fn lrc_with_sum(bytes : Array[Byte]) -> (Byte, Byte)

    Return both the LRC and the modulo-256 sum for diagnostics.

    maintenance_kind_name

    source
    fn maintenance_kind_name(kind : MaintenanceKind) -> String

    maintenance_priority_name

    source
    fn maintenance_priority_name(priority : MaintenancePriority) -> String

    mask_write_register

    source
    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

    source
    fn max_request_adu(mode : Mode, function : Byte) -> Int

    Return a conservative maximum request size for a function and mode.

    metric_kind_name

    source
    fn metric_kind_name(kind : MetricKind) -> String

    metrics_transport_name

    source
    fn metrics_transport_name(transport : MetricsTransport) -> String

    migration_operation_name

    source
    fn migration_operation_name(operation : MigrationOperation) -> String

    migration_state_name

    source
    fn migration_state_name(state : MigrationState) -> String

    minimum_frame_length

    source
    fn minimum_frame_length(mode : Mode) -> Int

    Calculate how many bytes are needed for the shortest frame of a mode.

    mode_description

    source
    fn mode_description(mode : Mode) -> String

    mode_name

    source
    fn mode_name(mode : Mode) -> String

    Return the stable display name of a transport mode.

    mode_payload_capacity

    source
    fn mode_payload_capacity(mode : Mode) -> Int

    Return the number of data bytes available after transport framing.

    offset_frame_address

    source
    fn offset_frame_address(frame : Frame, delta : Int) -> Result[Frame, ModbusError]

    Add a signed address offset while preserving 16-bit bounds.

    ordinary_function

    source
    fn ordinary_function(function : Byte) -> Byte

    Return the ordinary function code for an exception response.

    pack_bits

    source
    fn pack_bits(values : Array[Bool]) -> Array[Byte]

    Pack boolean values into Modbus LSB-first coil bytes.

    parse_hex_byte

    source
    fn parse_hex_byte(high : Byte, low : Byte) -> Result[Byte, ModbusError]

    Convert one ASCII hex byte into a binary byte.

    parse_wire_frame

    source
    fn parse_wire_frame(mode : Mode, text : String) -> Result[(UInt16, Frame), ModbusError]

    Parse a wire representation in the selected mode.

    parser_load

    source
    fn parser_load(parser : IncrementalParser) -> Int

    Return the number of bytes currently held across parser metrics.

    payload_is_bounded

    source
    fn payload_is_bounded(mode : Mode, size : Int) -> Bool

    pdu_bytes

    source
    fn pdu_bytes(frame : Frame) -> Array[Byte]

    Return the PDU bytes following the unit identifier.

    pdus_equal

    source
    fn pdus_equal(left : Pdu, right : Pdu) -> Bool

    plan_read_coils

    source
    fn plan_read_coils(unit_id : Byte, address : UInt16, quantity : Int, discrete? : Bool) -> Result[Array[PlannedRequest], ModbusError]

    plan_read_registers

    source
    fn plan_read_registers(unit_id : Byte, address : UInt16, quantity : Int, function? : Byte) -> Result[Array[PlannedRequest], ModbusError]

    plan_write_registers

    source
    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.

    poll_area_function

    source
    fn poll_area_function(area : PollArea) -> Byte

    poll_area_name

    source
    fn poll_area_name(area : PollArea) -> String

    preflight_device

    source
    fn preflight_device(report : PreflightReport, device : Device) -> Unit

    Check a device's table capacities and unit id.

    preflight_frame

    source
    fn preflight_frame(report : PreflightReport, mode : Mode, frame : Frame) -> Unit

    Check a frame's unit, PDU shape, and transport envelope constraints.

    preflight_plan

    source
    fn preflight_plan(report : PreflightReport, plan : PollPlan, mode : Mode) -> Unit

    Check every job in a polling plan.

    preflight_server

    source
    fn preflight_server(server : Server) -> PreflightReport

    Validate a complete server configuration and its registered devices.

    preflight_summary

    source
    fn preflight_summary(report : PreflightReport) -> String

    Return a compact result line for CI logs.

    profile_area_name

    source
    fn profile_area_name(area : ProfileArea) -> String

    profile_contiguous_points

    source
    fn profile_contiguous_points(points : Array[ProfilePoint], area : ProfileArea) -> Array[ProfilePoint]

    Return all points that are safe to poll in one contiguous register range.

    profile_encoding_name

    source
    fn profile_encoding_name(encoding : ProfileEncoding) -> String

    profile_point_value_from_registers

    source
    fn profile_point_value_from_registers(point : ProfilePoint, registers : Array[UInt16]) -> Result[ProfileValue, ModbusError]

    quality_decision_name

    source
    fn quality_decision_name(decision : QualityDecision) -> String

    quality_test_name

    source
    fn quality_test_name(kind : QualityTest) -> String

    quantity_bytes_checked

    source
    fn quantity_bytes_checked(quantity : UInt16) -> Array[Byte]

    Make a quantity representation used by request builders.

    read_coils

    source
    fn read_coils(unit_id : Byte, address : UInt16, quantity : UInt16) -> Result[Frame, ModbusError]

    Build a read-coils request (function 01).

    read_device_identification

    source
    fn read_device_identification(unit_id : Byte, category : DeviceIdCategory, object_id : Byte) -> Result[Frame, ModbusError]

    Build a Read Device Identification request.

    read_discrete_inputs

    source
    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

    source
    fn read_exception_status(unit_id : Byte) -> Result[Frame, ModbusError]

    Build a request for the exception status byte (function 07).

    read_fifo_queue

    source
    fn read_fifo_queue(unit_id : Byte, address : UInt16) -> Result[Frame, ModbusError]

    Build a Read FIFO Queue request (function 24).

    read_file_record

    source
    fn read_file_record(unit_id : Byte, references : Array[FileRecordReference]) -> Result[Frame, ModbusError]

    Build a Read File Record request (function 20).

    read_holding

    source
    fn read_holding(unit_id : Byte, address : UInt16, quantity : UInt16) -> Frame

    A request for reading holding registers (function 03).

    read_holding_checked

    source
    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

    source
    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

    source
    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

    source
    fn read_quantity_limit(function : Byte) -> Int

    Return the maximum legal request quantity for a read function.

    read_u16_be

    source
    fn read_u16_be(bytes : Array[Byte], offset : Int) -> Result[UInt16, ModbusError]

    Read a big-endian unsigned 16-bit value from a byte array.

    read_u32_be

    source
    fn read_u32_be(bytes : Array[Byte], offset : Int) -> Result[UInt, ModbusError]

    Read a big-endian unsigned 32-bit value using MoonBit's platform unsigned type.

    read_write_multiple_registers

    source
    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).

    reading_quality_name

    source
    fn reading_quality_name(value : ReadingQuality) -> String

    fn recommended_parser_role(function : Byte) -> ParserRole

    Return the recommended parser role for a function family.

    reconcile_snapshots

    source
    fn reconcile_snapshots(expected : DeviceSnapshot, observed : DeviceSnapshot) -> Result[Array[ReconciliationDiff], ModbusError]

    Compare point values and qualities in two snapshots.

    reconciliation_kind_name

    source
    fn reconciliation_kind_name(kind : ReconciliationKind) -> String

    reconciliation_report

    source
    fn reconciliation_report(device_id : String, diffs : Array[ReconciliationDiff], compared : Int) -> Result[ReconciliationReport, ModbusError]

    register_byte_order_name

    source
    fn register_byte_order_name(order : RegisterByteOrder) -> String

    register_to_bytes

    source
    fn register_to_bytes(value : UInt16, order : RegisterByteOrder) -> Array[Byte]

    Convert one register to two bytes in the requested byte order.

    register_value_name

    source
    fn register_value_name(value : RegisterValue) -> String

    Render a typed value as a compact diagnostic string.

    register_word_order_name

    source
    fn register_word_order_name(order : RegisterWordOrder) -> String

    registers

    source
    fn registers(frame : Frame) -> Result[Array[UInt16], ModbusError]

    Decode the data portion of a register-oriented frame without a byte count.

    registers_to_bytes

    source
    fn registers_to_bytes(values : Array[UInt16], order : RegisterByteOrder) -> Array[Byte]

    Convert an array of registers to bytes with a selected byte order.

    registers_to_f32

    source
    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

    source
    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

    source
    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

    source
    fn registers_to_u64(values : Array[UInt16], word_order : RegisterWordOrder) -> Result[UInt64, ModbusError]

    Decode four registers as a 64-bit value.

    reliability_failure_name

    source
    fn reliability_failure_name(failure : ReliabilityFailure) -> String

    reliability_fleet_summary

    source
    fn reliability_fleet_summary(devices : Array[DeviceReliability]) -> ReliabilityFleetSummary

    replace_frame_unit

    source
    fn replace_frame_unit(frame : Frame, unit_id : Byte) -> Result[Frame, ModbusError]

    report_server_id

    source
    fn report_server_id(unit_id : Byte) -> Result[Frame, ModbusError]

    Build a Report Server ID request (function 17).

    response_frame

    source
    fn response_frame(request : Frame, data : Array[Byte]) -> Frame

    Construct a response with an explicit function and owned data array.

    response_payload_length

    source
    fn response_payload_length(frame : Frame) -> Int

    response_quality

    source
    fn response_quality(request : Frame, response : Frame) -> String

    Return a short response quality classification for metrics.

    response_timeout_hint

    source
    fn response_timeout_hint(mode : Mode) -> Int

    response_value

    source
    fn response_value(frame : Frame) -> ResponseValue

    retry_limit_for

    source
    fn retry_limit_for(mode : Mode) -> Int

    reverse_registers

    source
    fn reverse_registers(values : Array[UInt16]) -> Array[UInt16]

    Reverse register order in a copied array.

    round_trip_all_modes

    source
    fn round_trip_all_modes(frame : Frame) -> Result[Array[Frame], ModbusError]

    Run the same frame through every transport codec.

    round_trip_vectors

    source
    fn round_trip_vectors(frame : Frame) -> Array[ConformanceVector]

    Build protocol vectors from a known request in all three transports.

    rtu_mode

    source
    fn rtu_mode() -> Mode

    Standard constructors kept as named entry points for configuration files.

    rtu_payload

    source
    fn rtu_payload(frame : Frame) -> Array[Byte]

    Return the RTU payload before its two-byte CRC.

    safe_address

    source
    fn safe_address(value : UInt16, quantity : Int) -> Result[Unit, ModbusError]

    safe_byte_at

    source
    fn safe_byte_at(bytes : Array[Byte], index : Int) -> Result[Byte, ModbusError]

    safe_quantity

    source
    fn safe_quantity(value : UInt16, limit : Int) -> Result[Int, ModbusError]

    scenario_boundary_suite

    source
    fn scenario_boundary_suite(unit_id : Byte, function : Byte) -> Result[ModbusScenario, ModbusError]

    Build a common boundary scenario for a unit and function pair.

    scenario_fault_name

    source
    fn scenario_fault_name(fault : ScenarioFault) -> String

    scenario_outcome_name

    source
    fn scenario_outcome_name(outcome : ScenarioOutcome) -> String

    service_event_kind_name

    source
    fn service_event_kind_name(kind : ServiceEventKind) -> String

    set_bit

    source
    fn set_bit(bytes : Array[Byte], index : Int, value : Bool) -> Result[Unit, ModbusError]

    Set a single bit in a packed byte array.

    should_retry

    source
    fn should_retry(mode : Mode, error : ModbusError) -> Bool

    signed_register

    source
    fn signed_register(value : UInt16) -> Int

    Decode a signed 16-bit register using two's-complement representation.

    simulation_failures

    source
    fn simulation_failures(results : Array[SimulationResult]) -> Int

    simulation_successes

    source
    fn simulation_successes(results : Array[SimulationResult]) -> Int

    Count successful deliveries in a scenario result.

    standard_frame_contracts

    source
    fn standard_frame_contracts() -> FrameContractCatalog

    Build a conservative catalog for the common Modbus function codes.

    summarize

    source
    fn summarize(frame : Frame) -> FrameSummary

    summarize_plan

    source
    fn summarize_plan(items : Array[PlannedRequest]) -> PlanSummary

    supported_function

    source
    fn supported_function(function : Byte) -> Bool

    Check that a function code is in the supported public subset.

    swap_register_bytes

    source
    fn swap_register_bytes(values : Array[UInt16]) -> Array[UInt16]

    Rotate bytes inside every register, useful for devices with byte-swapped words.

    tcp_mode

    source
    fn tcp_mode() -> Mode

    topology_health_name

    source
    fn topology_health_name(health : TopologyHealth) -> String

    topology_node_kind_name

    source
    fn topology_node_kind_name(kind : TopologyNodeKind) -> String

    transaction_state_name

    source
    fn transaction_state_name(state : TransactionState) -> String

    transport_is_network

    source
    fn transport_is_network(mode : Mode) -> Bool

    transport_is_serial

    source
    fn transport_is_serial(mode : Mode) -> Bool

    transport_kind_mode

    source
    fn transport_kind_mode(kind : TransportKind) -> Mode

    transport_kind_name

    source
    fn transport_kind_name(kind : TransportKind) -> String

    trend_direction_name

    source
    fn trend_direction_name(direction : TrendDirection) -> String

    try_encode_ascii

    source
    fn try_encode_ascii(frame : Frame) -> Result[Array[Byte], ModbusError]

    Checked ASCII encoder.

    try_encode_mode

    source
    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

    source
    fn try_encode_rtu(frame : Frame) -> Result[Array[Byte], ModbusError]

    Checked RTU encoder for code that wants validation errors instead of a raw frame.

    try_encode_tcp

    source
    fn try_encode_tcp(transaction_id : UInt16, frame : Frame) -> Result[Array[Byte], ModbusError]

    Checked TCP encoder.

    typed_exception_response

    source
    fn typed_exception_response(unit_id : Byte, function : Byte, code : ExceptionCode) -> Frame

    Build a typed exception response.

    u32_to_registers

    source
    fn u32_to_registers(value : UInt, word_order : RegisterWordOrder) -> Array[UInt16]

    Encode an unsigned 32-bit value into two registers.

    u64_to_registers

    source
    fn u64_to_registers(value : UInt64, word_order : RegisterWordOrder) -> Array[UInt16]

    Encode a 64-bit value into four registers.

    unpack_bits

    source
    fn unpack_bits(bytes : Array[Byte], quantity : Int) -> Result[Array[Bool], ModbusError]

    Unpack exactly quantity coil values from LSB-first bytes.

    valid_address_range

    source
    fn valid_address_range(address : UInt16, quantity : Int) -> Bool

    Check whether an address/count pair fits in the 16-bit Modbus address space.

    validate_catalog_request

    source
    fn validate_catalog_request(frame : Frame) -> Result[Unit, ModbusError]

    Validate a request against the catalog before invoking a builder.

    validate_endpoint

    source
    fn validate_endpoint(config : EndpointConfig) -> Result[Unit, ModbusError]

    validate_endpoint_health

    source
    fn validate_endpoint_health(health : EndpointHealth) -> Result[Unit, ModbusError]

    Validate that endpoint counters are internally consistent.

    validate_frame

    source
    fn validate_frame(frame : Frame, allow_broadcast : Bool) -> Result[Unit, ModbusError]

    Validate a complete logical frame before encoding it on any transport.

    validate_mode_payload

    source
    fn validate_mode_payload(mode : Mode, data_length : Int) -> Result[Unit, ModbusError]

    validate_pdu

    source
    fn validate_pdu(pdu : Pdu) -> Result[Unit, ModbusError]

    Validate a request PDU's byte-level shape and protocol limits.

    validate_plan_order

    source
    fn validate_plan_order(items : Array[PlannedRequest]) -> Result[Unit, ModbusError]

    Validate that planned ranges are ordered and non-overlapping.

    validate_poll_plan

    source
    fn validate_poll_plan(plan : PollPlan) -> Result[Unit, ModbusError]

    Validate plan timing invariants before deployment.

    validate_response_header

    source
    fn validate_response_header(request : Frame, response : Frame) -> Result[Unit, ModbusError]

    Validate the common unit/function relationship of a response.

    validate_server_config

    source
    fn validate_server_config(config : ServerConfig) -> Result[Unit, ModbusError]

    validate_unit

    source
    fn validate_unit(unit_id : Byte, allow_broadcast : Bool) -> Result[Unit, ModbusError]

    Validate a unit identifier for a request.

    validate_wire_frame

    source
    fn validate_wire_frame(frame : Frame, allow_broadcast : Bool) -> Result[Unit, ModbusError]

    Validate a frame for wire encoding without assuming request-only payload shapes.

    validate_write_shape

    source
    fn validate_write_shape(function : Byte, quantity : Int) -> Result[Unit, ModbusError]

    Check whether a write payload is legal before allocating its data array.

    variable_response_function_names

    source
    fn variable_response_function_names() -> Array[String]

    Return the names of all functions whose response contains a byte count.

    verify_crc16

    source
    fn verify_crc16(bytes : Array[Byte]) -> Result[Unit, ModbusError]

    Verify a CRC16 trailer in low-byte-first wire order.

    verify_lrc

    source
    fn verify_lrc(bytes : Array[Byte]) -> Result[Unit, ModbusError]

    Verify an LRC trailer at the end of a byte array.

    with_data

    source
    fn with_data(frame : Frame, data : Array[Byte]) -> Frame

    Return a copy of a frame with a different data payload.

    with_function

    source
    fn with_function(frame : Frame, function : Byte) -> Frame

    Return a copy of a frame with a different function code.

    with_unit

    source
    fn with_unit(frame : Frame, unit_id : Byte) -> Frame

    Return a copy of a frame with a different unit identifier.

    work_order_state_name

    source
    fn work_order_state_name(state : WorkOrderState) -> String

    writable_function_names

    source
    fn writable_function_names() -> Array[String]

    Return the names of all writable functions.

    write_file_record

    source
    fn write_file_record(unit_id : Byte, records : Array[FileRecordWrite]) -> Result[Frame, ModbusError]

    Build a Write File Record request (function 21).

    write_multiple_coils

    source
    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

    source
    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

    source
    fn write_quantity_limit(function : Byte) -> Int

    Return the maximum legal write quantity for a write-multiple function.

    write_single_coil

    source
    fn write_single_coil(unit_id : Byte, address : UInt16, value : Bool) -> Result[Frame, ModbusError]

    Build a write-single-coil request (function 05).

    write_single_register

    source
    fn write_single_register(unit_id : Byte, address : UInt16, value : UInt16) -> Frame

    A request for writing one holding register (function 06).

    write_single_register_checked

    source
    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

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io