🥮 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
    19

    #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