🥮 mooncakes.io

moonbit-canbus

A deterministic, dependency-free CAN 2.0 and CAN-FD toolkit for MoonBit.

can
can-fd
dbc
isotp
j1939
vehicle-network
moon add myc1234567/moonbit-canbus@0.1.1
Download zip
Version
0.1.1
License
Apache-2.0
Repository
Last updated
8 hours ago
Downloads
5
README

#MoonBit CAN Bus

一个纯 MoonBit、无原生依赖的 CAN 2.0 / CAN-FD 协议与仿真工具包，面向汽车电子、机器人、工业控制和协议测试场景。项目把帧语义、线级编解码、传输层、诊断、DBC 信号、网关和确定性仿真组合成可独立复用的 API。

#项目定位

本项目解决的是“没有硬件也能可靠验证控制器网络逻辑”的问题：同一套数据模型可以用于协议单元测试、DBC 信号解码、虚拟 ECU 联调、日志分析和网关规则验证。它不直接驱动 CAN 控制器，也不替代操作系统的 SocketCAN 或商业硬件 SDK。

#核心能力

  • 标准 11-bit、扩展 29-bit、数据帧、远程帧、错误帧和 CAN-FD 帧模型。
  • CAN-FD DLC 映射、CRC-15/17/21、位填充与去填充、完整 wire 编解码和稳定二进制帧格式。
  • 优先级仲裁、掩码/精确过滤器、确定性虚拟总线、节点注册、发送队列和多节点网络模型。
  • ISO-TP 分段与重组、J1939 标识符与 BAM、CANopen COB-ID/SDO/PDO，以及 UDS 请求、会话、DTC 编解码。
  • DBC BO_ / SG_ 解析、运行时信号编解码、规范化序列化、结构校验和 schema diff。
  • 路由网关、调度器、帧批处理、日志/trace、总线指标、延迟窗口和帧准入策略。

#快速开始

需要已安装 MoonBit stable 工具链。

moon check --target all --deny-warn
moon test --target all --deny-warn

在 MoonBit 中创建并检查一帧：

let frame = @moonbit_canbus.data_frame(0x120, [0x2A]) catch {
  _ => panic()
}
let wire = @moonbit_canbus.encode_frame(frame)
let restored = @moonbit_canbus.decode_frame(wire) catch {
  _ => panic()
}
assert_true(@moonbit_canbus.frame_equal(frame, restored))

#CLI

CLI 位于 src/cmd/canctl，用于快速查看帧编码和指标：

moon run src/cmd/canctl -- demo
moon run src/cmd/canctl -- decode 01000000012303102030

基准程序位于 src/cmd/bench，执行 100,000 次稳定帧编码/解码并输出耗时、吞吐、字节数和校验值：

moon run src/cmd/bench

#架构

层次主要模块责任
Frame / wireframe.mbt, frame_codec.mbt, wire.mbt, wire_codec.mbt帧不变量、DLC、CRC、bit stuffing 和可移植编码
Transporttransport.mbt, isotp_engine.mbt, isotp_session.mbt, j1939_transport.mbt, transport_queue.mbtISO-TP、J1939、队列、时序与边界处理
Databasedbc.mbt, dbc_extended.mbt, dbc_runtime.mbt, dbc_workspace.mbt, dbc_codegen.mbt, dbc_serializer.mbtDBC 解析、信号运行时、schema 工具和代码生成
Diagnosticsdiagnostic.mbt, uds_stack.mbt, diagnostic_session.mbt, diagnostic_catalog.mbt, diagnostic_workflow.mbt, diagnostic_codec.mbt, ecu_simulator.mbtUDS 服务、会话状态、DTC、ECU 仿真和诊断工作流
Networkfilter.mbt, can_network.mbt, hardware_adapter.mbt, canopen_device.mbt, routing.mbt, gateway_policy_advanced.mbt, simulation.mbt, simulation_profile.mbt过滤、适配器抽象、CANopen、网关、多节点网络和确定性仿真
Analysistrace.mbt, trace_query.mbt, trace_export.mbt, bus_analysis_advanced.mbt, network_health_advanced.mbt, compatibility_matrix.mbt, metrics.mbt, latency.mbt日志查询、导出、总线利用率、网络健康和部署兼容性分析

模块之间通过 Frame、Filter、Trace 等小型值对象连接，避免把硬件 I/O、时钟和协议状态耦合到核心算法中。

#基准

基准程序使用本地 MoonBit WASM-GC 后端和固定的 8-byte Classic CAN 数据帧，实际运行记录见 BENCHMARKS.md。基准输出包含可复核的迭代次数、墙钟耗时、吞吐和 checksum；不同机器和后端的绝对数值会变化，因此仓库不把单次机器结果当作性能承诺。

#测试与边界覆盖

测试覆盖 Classic CAN、CAN-FD、29-bit ID、64-byte payload、DLC 边界、CRC/bit stuffing、ISO-TP 长消息、UDS 负响应、DTC、DBC 非法布局、队列满/空、时间逆序、节点离线、速率限制、trace 和延迟百分位等路径。

本地质量门禁：

moon fmt
moon check --target all --deny-warn
moon test --target all --deny-warn
moon info

#CI

.github/workflows/check.yml 在 Linux、macOS 和 Windows 上安装 MoonBit stable，显式配置 Node.js 运行时，执行格式检查、moon info、全后端 check/build/test，并验证生产 MoonBit 源码规模门槛。工作流使用官方安装脚本，便于工具链持续跟随 stable。

#许可证

本项目采用 Apache License 2.0。

#
AdmissionError

source
pub suberror AdmissionError {
  InvalidRule
  NoMatchingRule
  ProtocolNotAllowed
  PayloadTooLarge
  RemoteNotAllowed
  RateExceeded
  TimestampReversed
} derive(
Debug)

Errors raised by a frame admission policy.

#
BatchError

source
pub suberror BatchError {
  EmptyBatch
  BatchTooLarge
  InvalidRecord
  ChecksumMismatch
} derive(
Debug)

Errors raised by batch processing and binary archive helpers.

#
BitError

source
pub suberror BitError {
  InvalidWidth
  InvalidValue
  OutOfBounds
} derive(
Debug)

Errors raised by the bit-level reader and writer.

#
CanAdapterError

source
pub suberror CanAdapterError {
  CanAdapterNotOpen
  CanAdapterAlreadyOpen
  CanAdapterBusOffError
  CanAdapterQueueFull
  CanAdapterUnsupported
  CanAdapterInvalidConfiguration
  CanAdapterRejectedFrame
}

Errors returned by the backend-neutral adapter façade.

#
CanOpenError

source
pub suberror CanOpenError {
  InvalidNodeId
  InvalidCobId
  InvalidIndex
  InvalidSdoPayload
  InvalidDataLength
} derive(
Debug)

Errors raised by CANopen identifier and SDO helpers.

#
CanTextError

source
pub suberror CanTextError {
  InvalidHeader
  InvalidFieldCount
  InvalidTimestamp
  InvalidPayload
} derive(
Debug)

Errors raised by text log parsing.

#
CanTimingError

source
pub suberror CanTimingError {
  InvalidClock
  InvalidBitrate
  InvalidSamplePoint
  NoTimingCandidate
} derive(
Debug)

Errors raised by CAN bit-timing calculations.

#
DbcError

source
pub suberror DbcError {
  InvalidMessageLine(String)
  InvalidSignalLine(String)
  InvalidNumber(String)
}

A small, dependency-free DBC reader for message and signal definitions.

#
DbcExtendedError

source
pub suberror DbcExtendedError {
  InvalidMessage
  InvalidSignal
  InvalidNumber
  MissingMessage
  InvalidRange
} derive(
Debug)

Errors from the extended DBC reader.

#
DbcRuntimeError

source
pub suberror DbcRuntimeError {
  InvalidSignalLayout
  PayloadTooShort
  PayloadTooLong
  DuplicateSignal
  MissingSignalValue
  ValueOutOfRange
} derive(
Debug)

Errors raised by checked DBC runtime operations.

#
DbcSchemaError

source
pub suberror DbcSchemaError {
  DuplicateMessageId
  InvalidIdentifier
  EmptyMessageName
  InvalidDlc
  InvalidSignalLayout
  OverlappingSignals
} derive(
Debug)

Errors raised when validating or serializing a DBC schema.

#
DtcCodecError

source
pub suberror DtcCodecError {
  InvalidCode
  InvalidPayload
  InvalidRecordLength
  CapacityExceeded
} derive(
Debug)

Errors raised while encoding or decoding diagnostic trouble codes.

#
EcuMemoryError

source
pub suberror EcuMemoryError {
  EcuMemoryOutOfRange
  EcuMemoryPermissionDenied
  EcuMemoryInvalidLength
  EcuMemoryOverlappingRegion
}

#
FrameCodecError

source
pub suberror FrameCodecError {
  UnsupportedVersion
  Truncated
  InvalidFlags
  InvalidPayloadLength
  InvalidHex
} derive(
Debug)

Errors raised by the portable frame codec.

#
FrameError

source
pub suberror FrameError {
  InvalidIdentifier
  InvalidLength
} derive(
Debug)

A frame validation error.

#
FramePipelineError

source
pub suberror FramePipelineError {
  FramePipelineInvalidPayload
  FramePipelineRuleExists
  FramePipelineRuleMissing
  FramePipelineCapacity
}

#
GatewayPolicyError

source
pub suberror GatewayPolicyError {
  GatewayPolicyInvalidPayload
  GatewayPolicyDuplicateRule
  GatewayPolicyRuleNotFound
  GatewayPolicyInvalidInterval
}

#
IsoTpError

source
pub suberror IsoTpError {
  InvalidFrameSize
  PayloadTooLarge
  TruncatedPacket
  InvalidFirstFrame
  UnexpectedConsecutive
  SequenceMismatch
  LengthMismatch
  UnsupportedFlowStatus
} derive(
Debug)

Errors raised by checked ISO-TP operations.

#
J1939Error

source
pub suberror J1939Error {
  InvalidPriority
  InvalidPgn
  InvalidAddress
  InvalidPayloadLength
  InvalidSequence
  TransferTooLarge
} derive(
Debug)

Errors raised by J1939 identifier and transport helpers.

#
LatencyError

source
pub suberror LatencyError {
  InvalidCapacity
  InvalidTimestamp
  InvalidPercentile
} derive(
Debug)

Errors raised by a latency measurement window.

#
NetworkError

source
pub suberror NetworkError {
  InvalidNodeId
  DuplicateNode
  UnknownNode
  InvalidTimestamp
  QueueFull
} derive(
Debug)

Errors raised by the deterministic multi-node network model.

#
NodeRegistryError

source
pub suberror NodeRegistryError {
  InvalidNodeId
  DuplicateNode
  UnknownNode
} derive(
Debug)

Errors raised by node registry operations.

#
PayloadError

source
pub suberror PayloadError {
  InvalidOffset
  InvalidWidth
  InvalidCounter
  InvalidFrame
} derive(
Debug)

Payload transformation errors.

#
PdoError

source
pub suberror PdoError {
  InvalidMapping
  TooManyEntries
  ValueTooLarge
  PayloadOverflow
} derive(
Debug)

CANopen PDO mapping errors.

#
QueueError

source
pub suberror QueueError {
  InvalidCapacity
  InvalidLimit
  Full
  Empty
  UnknownSequence
} derive(
Debug)

Errors raised by the bounded transmit queue.

#
RoutingError

source
pub suberror RoutingError {
  InvalidOutputIdentifier
  InvalidPrefix
  PayloadOverflow
} derive(
Debug)

Errors raised when a gateway transforms a frame.

#
SchedulerError

source
pub suberror SchedulerError {
  InvalidPeriod
  InvalidDeadline
  DuplicateTask
  UnknownTask
} derive(
Debug)

Errors raised by the deterministic message scheduler.

#
SimulationError

source
pub suberror SimulationError {
  TimeWentBackwards
  InvalidPeriod
  EventLimitReached
} derive(
Debug)

Errors raised by deterministic network simulation.

#
TraceError

source
pub suberror TraceError {
  NonMonotonicTimestamp
  InvalidLine
  InvalidTimestamp
  InvalidFrame
} derive(
Debug)

Errors raised when validating or parsing a trace log.

#
UdsError

source
pub suberror UdsError {
  InvalidIdentifier
  InvalidAddressFormat
  EmptyPayload
  InvalidBlockCounter
  InvalidLength
} derive(
Debug)

Additional errors for building and validating UDS exchanges.

#
UdsSessionError

source
pub suberror UdsSessionError {
  InvalidTransition
  SecurityRequired
  ResponseTimeout
  UnexpectedResponse
} derive(
Debug)

Errors raised by the session state machine.

#
WireCodecError

source
pub suberror WireCodecError {
  InvalidEof
  InvalidCrc
  InvalidControl
  InvalidDlc
  InvalidFrameBits
} derive(
Debug)

Errors raised by the complete bit-level wire codec.

#
WireError

source
pub suberror WireError {
  InvalidStuffedBit
}

Errors produced when removing CAN bit stuffing.

#
AdmissionDecision

source
pub struct AdmissionDecision {
  accepted : Bool
  rule_name : String
  reason : String
}

The result of an admission check.

#
AdmissionDecision::accepted

source
fn AdmissionDecision::accepted(self : AdmissionDecision) -> Bool

#
AdmissionDecision::reason

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

#
AdmissionDecision::rule_name

source
fn AdmissionDecision::rule_name(self : AdmissionDecision) -> String

#
AdmissionPolicy

source
pub struct AdmissionPolicy {
  rules : Array[AdmissionRule]
  accepted_count : Int
  rejected_count : Int
  last_timestamp_us : UInt64?
}

A first-match frame admission policy with counters and timing guards.

#
AdmissionPolicy::accepted

source
fn AdmissionPolicy::accepted(self : AdmissionPolicy) -> Int

#
AdmissionPolicy::add_rule

source
fn AdmissionPolicy::add_rule(self : AdmissionPolicy, rule : AdmissionRule) -> Unit

#
AdmissionPolicy::admit

source
fn AdmissionPolicy::admit(self : AdmissionPolicy, frame : Frame, timestamp_us : UInt64) -> Bool

Return whether a frame is admitted, preserving the policy counters.

#
AdmissionPolicy::evaluate

source
fn AdmissionPolicy::evaluate(self : AdmissionPolicy, frame : Frame, timestamp_us : UInt64) -> AdmissionDecision raise AdmissionError

Evaluate the first matching rule and update its rate window on success.

#
AdmissionPolicy::rejected

source
fn AdmissionPolicy::rejected(self : AdmissionPolicy) -> Int

#
AdmissionPolicy::reset

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

Reset all per-rule timing windows and counters.

#
AdmissionPolicy::rule_count

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

#
AdmissionRule

source
pub struct AdmissionRule {
  name : String
  filter : Filter
  max_payload : Int
  allow_fd : Bool
  allow_remote : Bool
  min_interval_us : UInt64
  last_seen_us : UInt64?
}

A named rule for a group of accepted frames.

#
AdmissionRule::allows_fd

source
fn AdmissionRule::allows_fd(self : AdmissionRule) -> Bool

#
AdmissionRule::allows_remote

source
fn AdmissionRule::allows_remote(self : AdmissionRule) -> Bool

#
AdmissionRule::max_payload

source
fn AdmissionRule::max_payload(self : AdmissionRule) -> Int

#
AdmissionRule::minimum_interval

source
fn AdmissionRule::minimum_interval(self : AdmissionRule) -> UInt64

#
AdmissionRule::name

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

#
BitReader

source
pub struct BitReader {
  bits : Array[Bool]
  position : Int
}

A sequential most-significant-bit-first reader.

#
BitReader::peek

source
fn BitReader::peek(self : BitReader, width : Int) -> UInt raise BitError

Inspect a bit without advancing the reader.

#
BitReader::position

source
fn BitReader::position(self : BitReader) -> Int

Return the current read offset.

#
BitReader::read

source
fn BitReader::read(self : BitReader, width : Int) -> UInt raise BitError

Read an unsigned value of exactly width bits.

#
BitReader::read_bit

source
fn BitReader::read_bit(self : BitReader) -> Bool raise BitError

Read one bit.

#
BitReader::read_signed

source
fn BitReader::read_signed(self : BitReader, width : Int) -> Int raise BitError

Read a signed two's-complement value of up to 31 bits.

#
BitReader::remaining

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

Return the number of unread bits.

#
BitReader::skip

source
fn BitReader::skip(self : BitReader, width : Int) -> Unit raise BitError

Skip a number of bits.

#
BitWriter

source
pub struct BitWriter {
  bits : Array[Bool]
}

A growable most-significant-bit-first writer.

#
BitWriter::align_byte

source
fn BitWriter::align_byte(self : BitWriter) -> Unit

Add zero padding until the writer reaches a byte boundary.

#
BitWriter::finish

source
fn BitWriter::finish(self : BitWriter) -> Array[Bool]

Return a defensive copy of the written bits.

#
BitWriter::length

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

Return the number of bits currently written.

#
BitWriter::to_bytes

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

Return the written bits packed into bytes, padding the final byte with 0.

#
BitWriter::write

source
fn BitWriter::write(self : BitWriter, value : UInt, width : Int) -> Unit raise BitError

Append an unsigned value using exactly width high-to-low bits.

#
BitWriter::write_bit

source
fn BitWriter::write_bit(self : BitWriter, bit : Bool) -> Unit

Append one bit.

#
BitWriter::write_signed

source
fn BitWriter::write_signed(self : BitWriter, value : Int, width : Int) -> Unit raise BitError

Append a signed two's-complement value.

#
BusAnalysisAnomaly

source
pub enum BusAnalysisAnomaly {
  BusAnomalyBurst(UInt, Int)
  BusAnomalyJitter(UInt, UInt64)
  BusAnomalyPayloadGrowth(UInt, Int, Int)
  BusAnomalyIdentifierChange(UInt)
  BusAnomalyTimestampRegression(UInt64)
  BusAnomalySequenceGap(UInt, UInt)
  BusAnomalyOverload(Double)
}

A compliance or quality anomaly detected from observations.

#
BusAnalysisMode

source
pub enum BusAnalysisMode {
  BusAnalysisLive
  BusAnalysisOffline
  BusAnalysisReplay
  BusAnalysisCompliance
}

Analysis mode used by a bus observability pipeline.

#
BusAnalysisReport

source
pub struct BusAnalysisReport {
  mode : BusAnalysisMode
  channel : String
  start_us : UInt64?
  end_us : UInt64?
  total_frames : Int
  payload_bytes : Int
  wire_bits : Int
  profiles : Array[BusIdentifierProfile]
  anomalies : Array[BusAnalysisAnomaly]
  utilization : Double
}

A completed report from a bus analyzer.

#
BusAnalysisReport::anomalies

source

#
BusAnalysisReport::channel

source
fn BusAnalysisReport::channel(self : BusAnalysisReport) -> String

#
BusAnalysisReport::end_us

source
fn BusAnalysisReport::end_us(self : BusAnalysisReport) -> UInt64?

#
BusAnalysisReport::healthy

source
fn BusAnalysisReport::healthy(self : BusAnalysisReport) -> Bool

#
BusAnalysisReport::mode

source

#
BusAnalysisReport::payload_bytes

source
fn BusAnalysisReport::payload_bytes(self : BusAnalysisReport) -> Int

#
BusAnalysisReport::profiles

source

#
BusAnalysisReport::start_us

source
fn BusAnalysisReport::start_us(self : BusAnalysisReport) -> UInt64?

#
BusAnalysisReport::to_text

source
fn BusAnalysisReport::to_text(self : BusAnalysisReport) -> String

#
BusAnalysisReport::total_frames

source
fn BusAnalysisReport::total_frames(self : BusAnalysisReport) -> Int

#
BusAnalysisReport::utilization

source
fn BusAnalysisReport::utilization(self : BusAnalysisReport) -> Double

#
BusAnalysisReport::wire_bits

source
fn BusAnalysisReport::wire_bits(self : BusAnalysisReport) -> Int

#
BusAnalyzer

source
pub struct BusAnalyzer {
  mode : BusAnalysisMode
  channel : String
  bitrate_kbps : UInt
  burst_window_us : UInt64
  jitter_limit_us : UInt64
  observations : Array[BusObservation]
  last_timestamp_us : UInt64?
  last_sequence : UInt?
}

A stateful analyzer that can be fed by a live adapter or a trace.

#
BusAnalyzer::anomalies

source

#
BusAnalyzer::bitrate_kbps

source
fn BusAnalyzer::bitrate_kbps(self : BusAnalyzer) -> UInt

#
BusAnalyzer::channel

source
fn BusAnalyzer::channel(self : BusAnalyzer) -> String

#
BusAnalyzer::length

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

#
BusAnalyzer::mode

source

#
BusAnalyzer::observations

source
fn BusAnalyzer::observations(self : BusAnalyzer) -> Array[BusObservation]

#
BusAnalyzer::observe

source
fn BusAnalyzer::observe(self : BusAnalyzer, item : BusObservation) -> Unit

#
BusAnalyzer::observe_frame

source
fn BusAnalyzer::observe_frame(self : BusAnalyzer, timestamp_us : UInt64, frame : Frame) -> Unit

#
BusAnalyzer::profile

source
fn BusAnalyzer::profile(self : BusAnalyzer, identifier : UInt) -> BusIdentifierProfile?

#
BusAnalyzer::profiles

source

#
BusAnalyzer::report

source

#
BusAnalyzer::reset

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

#
BusAnalyzer::sorted_observations

source
fn BusAnalyzer::sorted_observations(self : BusAnalyzer) -> Array[BusObservation]

#
BusHealth

source
pub struct BusHealth {
  state : BusHealthState
  utilization : Double
  drop_rate : Double
  error_rate : Double
  recommendations : Array[String]
}

A deterministic health assessment for dashboards and CI.

#
BusHealth::drop_rate

source
fn BusHealth::drop_rate(self : BusHealth) -> Double

#
BusHealth::error_rate

source
fn BusHealth::error_rate(self : BusHealth) -> Double

#
BusHealth::recommendations

source
fn BusHealth::recommendations(self : BusHealth) -> Array[String]

#
BusHealth::state

source
fn BusHealth::state(self : BusHealth) -> BusHealthState

#
BusHealth::to_text

source
fn BusHealth::to_text(self : BusHealth) -> String

#
BusHealth::utilization

source
fn BusHealth::utilization(self : BusHealth) -> Double

#
BusHealthState

source
pub enum BusHealthState {
  Healthy
  Busy
  Degraded
  Overloaded
  Silent
} derive(
Debug)

Health levels for a monitored CAN channel.

#
BusIdentifierProfile

source
pub struct BusIdentifierProfile {
  identifier : UInt
  frames : Int
  first_seen_us : UInt64
  last_seen_us : UInt64
  min_payload : Int
  max_payload : Int
  wire_bits : Int
  extended : Bool
  intervals : Array[UInt64]
}

Per-identifier statistics accumulated by a bus analyzer.

#
BusIdentifierProfile::average_interval_us

source
fn BusIdentifierProfile::average_interval_us(self : BusIdentifierProfile) -> UInt64

#
BusIdentifierProfile::extended

source
fn BusIdentifierProfile::extended(self : BusIdentifierProfile) -> Bool

#
BusIdentifierProfile::first_seen_us

source
fn BusIdentifierProfile::first_seen_us(self : BusIdentifierProfile) -> UInt64

#
BusIdentifierProfile::frames

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

#
BusIdentifierProfile::frequency_hz

source
fn BusIdentifierProfile::frequency_hz(self : BusIdentifierProfile) -> Double

#
BusIdentifierProfile::identifier

source
fn BusIdentifierProfile::identifier(self : BusIdentifierProfile) -> UInt

#
BusIdentifierProfile::intervals

source
fn BusIdentifierProfile::intervals(self : BusIdentifierProfile) -> Array[UInt64]

#
BusIdentifierProfile::jitter_us

source
fn BusIdentifierProfile::jitter_us(self : BusIdentifierProfile) -> UInt64

#
BusIdentifierProfile::last_seen_us

source
fn BusIdentifierProfile::last_seen_us(self : BusIdentifierProfile) -> UInt64

#
BusIdentifierProfile::max_payload

source
fn BusIdentifierProfile::max_payload(self : BusIdentifierProfile) -> Int

#
BusIdentifierProfile::min_payload

source
fn BusIdentifierProfile::min_payload(self : BusIdentifierProfile) -> Int

#
BusIdentifierProfile::wire_bits

source
fn BusIdentifierProfile::wire_bits(self : BusIdentifierProfile) -> Int

#
BusObservation

source
pub struct BusObservation {
  timestamp_us : UInt64
  frame : Frame
  channel : String
  sequence : UInt
}

One timestamped observation supplied to the analyzer.

#
BusObservation::channel

source
fn BusObservation::channel(self : BusObservation) -> String

#
BusObservation::frame

source
fn BusObservation::frame(self : BusObservation) -> Frame

#
BusObservation::sequence

source
fn BusObservation::sequence(self : BusObservation) -> UInt

#
BusObservation::timestamp_us

source
fn BusObservation::timestamp_us(self : BusObservation) -> UInt64

#
ByteOrder

source
pub(all) enum ByteOrder {
  BigEndian
  LittleEndian
}

Byte ordering used by application payload adapters.

#
CanAdapterCapabilities

source
pub struct CanAdapterCapabilities {
  classic : Bool
  can_fd : Bool
  bitrate_switch : Bool
  listen_only : Bool
  loopback : Bool
  timestamping : Bool
  max_rx_queue : Int
  max_tx_queue : Int
}

Capabilities exposed by a hardware or virtual CAN backend.

#
CanAdapterCapabilities::bitrate_switch

source
fn CanAdapterCapabilities::bitrate_switch(self : CanAdapterCapabilities) -> Bool

#
CanAdapterCapabilities::can_fd

source

#
CanAdapterCapabilities::classic

source

#
CanAdapterCapabilities::listen_only

source
fn CanAdapterCapabilities::listen_only(self : CanAdapterCapabilities) -> Bool

#
CanAdapterCapabilities::loopback

source
fn CanAdapterCapabilities::loopback(self : CanAdapterCapabilities) -> Bool

#
CanAdapterCapabilities::max_rx_queue

source
fn CanAdapterCapabilities::max_rx_queue(self : CanAdapterCapabilities) -> Int

#
CanAdapterCapabilities::max_tx_queue

source
fn CanAdapterCapabilities::max_tx_queue(self : CanAdapterCapabilities) -> Int

#
CanAdapterCapabilities::timestamping

source
fn CanAdapterCapabilities::timestamping(self : CanAdapterCapabilities) -> Bool

#
CanAdapterConfig

source
pub struct CanAdapterConfig {
  nominal_bitrate_kbps : UInt
  data_bitrate_kbps : UInt
  listen_only : Bool
  loopback : Bool
  receive_own : Bool
  filter : Filter?
}

Configuration requested from an adapter before opening it.

#
CanAdapterConfig::data_bitrate_kbps

source
fn CanAdapterConfig::data_bitrate_kbps(self : CanAdapterConfig) -> UInt

#
CanAdapterConfig::filter

source

#
CanAdapterConfig::listen_only

source
fn CanAdapterConfig::listen_only(self : CanAdapterConfig) -> Bool

#
CanAdapterConfig::loopback

source
fn CanAdapterConfig::loopback(self : CanAdapterConfig) -> Bool

#
CanAdapterConfig::nominal_bitrate_kbps

source
fn CanAdapterConfig::nominal_bitrate_kbps(self : CanAdapterConfig) -> UInt

#
CanAdapterConfig::receive_own

source
fn CanAdapterConfig::receive_own(self : CanAdapterConfig) -> Bool

#
CanAdapterHub

source
pub struct CanAdapterHub {
  ports : Array[CanPort]
  routed : Int
  missed : Int
}

A collection of adapter ports used by a test harness.

#
CanAdapterHub::add

source
fn CanAdapterHub::add(self : CanAdapterHub, port : CanPort) -> Bool

#
CanAdapterHub::broadcast

source
fn CanAdapterHub::broadcast(self : CanAdapterHub, source : String, timestamp_us : UInt64, frame : Frame) -> Int

#
CanAdapterHub::find

source
fn CanAdapterHub::find(self : CanAdapterHub, name : String) -> CanPort?

#
CanAdapterHub::missed

source
fn CanAdapterHub::missed(self : CanAdapterHub) -> Int

#
CanAdapterHub::ports

source

#
CanAdapterHub::routed

source
fn CanAdapterHub::routed(self : CanAdapterHub) -> Int

#
CanAdapterHub::to_text

source
fn CanAdapterHub::to_text(self : CanAdapterHub) -> String

#
CanAdapterLifecycle

source
pub enum CanAdapterLifecycle {
  CanAdapterCreated
  CanAdapterConfigured
  CanAdapterOpen
  CanAdapterBusOff
  CanAdapterClosed
}

Lifecycle state of a portable CAN adapter.

#
CanAdapterMessage

source
pub struct CanAdapterMessage {
  timestamp_us : UInt64
  frame : Frame
  direction_tx : Bool
  sequence : UInt
}

A timestamped frame delivered by an adapter.

#
CanAdapterMessage::direction_text

source
fn CanAdapterMessage::direction_text(self : CanAdapterMessage) -> String

#
CanAdapterMessage::direction_tx

source
fn CanAdapterMessage::direction_tx(self : CanAdapterMessage) -> Bool

#
CanAdapterMessage::frame

source

#
CanAdapterMessage::sequence

source
fn CanAdapterMessage::sequence(self : CanAdapterMessage) -> UInt

#
CanAdapterMessage::timestamp_us

source
fn CanAdapterMessage::timestamp_us(self : CanAdapterMessage) -> UInt64

#
CanAdapterStats

source
pub struct CanAdapterStats {
  transmitted : Int
  received : Int
  dropped_rx : Int
  rejected_tx : Int
  bus_off : Int
  error_frames : Int
  bytes_tx : Int
  bytes_rx : Int
}

Counters maintained by a CAN adapter.

#
CanAdapterStats::bus_off

source
fn CanAdapterStats::bus_off(self : CanAdapterStats) -> Int

#
CanAdapterStats::bytes_rx

source
fn CanAdapterStats::bytes_rx(self : CanAdapterStats) -> Int

#
CanAdapterStats::bytes_tx

source
fn CanAdapterStats::bytes_tx(self : CanAdapterStats) -> Int

#
CanAdapterStats::dropped_rx

source
fn CanAdapterStats::dropped_rx(self : CanAdapterStats) -> Int

#
CanAdapterStats::error_frames

source
fn CanAdapterStats::error_frames(self : CanAdapterStats) -> Int

#
CanAdapterStats::received

source
fn CanAdapterStats::received(self : CanAdapterStats) -> Int

#
CanAdapterStats::rejected_tx

source
fn CanAdapterStats::rejected_tx(self : CanAdapterStats) -> Int

#
CanAdapterStats::to_text

source
fn CanAdapterStats::to_text(self : CanAdapterStats) -> String

#
CanAdapterStats::total

source
fn CanAdapterStats::total(self : CanAdapterStats) -> Int

#
CanAdapterStats::transmitted

source
fn CanAdapterStats::transmitted(self : CanAdapterStats) -> Int

#
CanBitTiming

source
pub struct CanBitTiming {
  clock_hz : UInt
  bitrate : UInt
  prescaler : UInt
  time_quanta : UInt
  propagation_segment : UInt
  phase_segment_1 : UInt
  phase_segment_2 : UInt
  sample_point_percent : Double
}

A nominal or data-phase bit-timing candidate.

#
CanBitTiming::actual_bitrate

source
fn CanBitTiming::actual_bitrate(self : CanBitTiming) -> UInt

Return the actual bitrate represented by a timing configuration.

#
CanBitTiming::bit_time_ns

source
fn CanBitTiming::bit_time_ns(self : CanBitTiming) -> UInt64

#
CanBitTiming::bitrate

source
fn CanBitTiming::bitrate(self : CanBitTiming) -> UInt

#
CanBitTiming::clock_hz

source
fn CanBitTiming::clock_hz(self : CanBitTiming) -> UInt

#
CanBitTiming::prescaler

source
fn CanBitTiming::prescaler(self : CanBitTiming) -> UInt

#
CanBitTiming::sample_point

source
fn CanBitTiming::sample_point(self : CanBitTiming) -> Double

#
CanBitTiming::time_quanta

source
fn CanBitTiming::time_quanta(self : CanBitTiming) -> UInt

#
CanFdTiming

source
pub struct CanFdTiming {
  nominal : CanBitTiming
  data : CanBitTiming
}

CAN-FD timing for nominal and data phases.

#
CanFdTiming::data

source

#
CanFdTiming::nominal

source
fn CanFdTiming::nominal(self : CanFdTiming) -> CanBitTiming

#
CanGateway

source
pub struct CanGateway {
  routes : Array[RouteRule]
  forwarded : Int
  rejected : Int
}

A stateless rule-based CAN gateway.

#
CanGateway::add_rule

source
fn CanGateway::add_rule(self : CanGateway, rule : RouteRule) -> Unit

#
CanGateway::forward

source
fn CanGateway::forward(self : CanGateway, input : Frame) -> RoutedFrame? raise RoutingError

Apply the first matching rule.

#
CanGateway::forwarded

source
fn CanGateway::forwarded(self : CanGateway) -> Int

#
CanGateway::rejected

source
fn CanGateway::rejected(self : CanGateway) -> Int

#
CanGateway::rule_count

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

#
CanGateway::rule_names

source
fn CanGateway::rule_names(self : CanGateway) -> Array[String]

Return route names in insertion order.

#
CanLog

source
pub struct CanLog {
  entries : Array[CanLogEntry]
}

A portable text log with stable ordering.

#
CanLog::entries

source
fn CanLog::entries(self : CanLog) -> Array[CanLogEntry]

#
CanLog::filter_channel

source
fn CanLog::filter_channel(self : CanLog, channel : String) -> CanLog

#
CanLog::length

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

#
CanLog::push

source
fn CanLog::push(self : CanLog, timestamp_us : UInt64, frame : Frame, channel? : String) -> Unit

#
CanLog::sorted

source
fn CanLog::sorted(self : CanLog) -> CanLog

#
CanLog::to_text

source
fn CanLog::to_text(self : CanLog) -> String

Encode a log with a header and one comma-separated record per line.

#
CanLogEntry

source
pub struct CanLogEntry {
  timestamp_us : UInt64
  frame : Frame
  channel : String
}

A human-readable CAN log record.

#
CanLogEntry::channel

source
fn CanLogEntry::channel(self : CanLogEntry) -> String

#
CanLogEntry::frame

source
fn CanLogEntry::frame(self : CanLogEntry) -> Frame

#
CanLogEntry::timestamp

source
fn CanLogEntry::timestamp(self : CanLogEntry) -> UInt64

#
CanNetwork

source
pub struct CanNetwork {
  timeout_us : UInt64
  now_us : UInt64
  nodes : Array[NetworkNode]
  queue : FrameQueue
  delivered : Int
}

A deterministic CAN network with bounded transmit buffering and liveness.

#
CanNetwork::add_node

source
fn CanNetwork::add_node(self : CanNetwork, node_id : Byte, name : String, timestamp_us : UInt64) -> Unit raise NetworkError

Register a node at a known timestamp.

#
CanNetwork::delivered

source
fn CanNetwork::delivered(self : CanNetwork) -> Int

#
CanNetwork::heartbeat

source
fn CanNetwork::heartbeat(self : CanNetwork, node_id : Byte, timestamp_us : UInt64) -> Unit raise NetworkError

Record a heartbeat and bring a node online.

#
CanNetwork::node

source
fn CanNetwork::node(self : CanNetwork, node_id : Byte) -> NetworkNode?

#
CanNetwork::node_count

source
fn CanNetwork::node_count(self : CanNetwork) -> Int

#
CanNetwork::now

source
fn CanNetwork::now(self : CanNetwork) -> UInt64

#
CanNetwork::offline_nodes

source
fn CanNetwork::offline_nodes(self : CanNetwork, timestamp_us : UInt64) -> Array[String] raise NetworkError

Mark nodes stale at a timestamp and return their stable names.

#
CanNetwork::pending

source
fn CanNetwork::pending(self : CanNetwork) -> Int

#
CanNetwork::poll

source
fn CanNetwork::poll(self : CanNetwork, timestamp_us : UInt64) -> Array[NetworkDelivery] raise NetworkError

Deliver every frame queued by timestamp_us in arbitration order.

#
CanNetwork::send

source
fn CanNetwork::send(self : CanNetwork, sender : Byte, frame : Frame, timestamp_us : UInt64) -> UInt raise NetworkError

Queue a frame from a registered sender.

#
CanNode

source
pub struct CanNode {
  node_id : Byte
  name : String
  filter : Filter
  received : Int
  transmitted : Int
}

A monitored node and its receive filter.

#
CanNode::name

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

#
CanNode::node_id

source
fn CanNode::node_id(self : CanNode) -> Byte

#
CanNode::received

source
fn CanNode::received(self : CanNode) -> Int

#
CanNode::transmitted

source
fn CanNode::transmitted(self : CanNode) -> Int

#
CanOpenCobId

source
pub struct CanOpenCobId {
  object_type : CanOpenCobType
  node_id : Byte
  identifier : UInt
}

A decoded CANopen communication object identifier.

#
CanOpenCobId::identifier

source
fn CanOpenCobId::identifier(self : CanOpenCobId) -> UInt

#
CanOpenCobId::node_id

source
fn CanOpenCobId::node_id(self : CanOpenCobId) -> Byte

#
CanOpenCobId::object_type

source
fn CanOpenCobId::object_type(self : CanOpenCobId) -> CanOpenCobType

#
CanOpenCobType

source
pub(all) enum CanOpenCobType {
  Nmt
  Sync
  Emergency
  Pdo1Transmit
  Pdo1Receive
  Pdo2Transmit
  Pdo2Receive
  Pdo3Transmit
  Pdo3Receive
  Pdo4Transmit
  Pdo4Receive
  SdoTransmit
  SdoReceive
  Heartbeat
} derive(
Debug)

CANopen communication object types.

#
CanOpenDevice

source
pub struct CanOpenDevice {
  node_id : Byte
  name : String
  state : CanOpenDeviceState
  dictionary : CanOpenObjectDictionary
  heartbeat : CanOpenHeartbeatMonitor
  nmt_commands : Int
  sdo_uploads : Int
  sdo_downloads : Int
}

A CANopen device model with NMT, SDO and heartbeat support.

#
CanOpenDevice::add_object

source
fn CanOpenDevice::add_object(self : CanOpenDevice, entry : CanOpenObjectEntry) -> Bool

#
CanOpenDevice::dictionary

source

#
CanOpenDevice::heartbeat

source

#
CanOpenDevice::heartbeat_receive

source
fn CanOpenDevice::heartbeat_receive(self : CanOpenDevice, state_byte : Byte, timestamp_us : UInt64) -> Unit

#
CanOpenDevice::heartbeat_tick

source
fn CanOpenDevice::heartbeat_tick(self : CanOpenDevice, timestamp_us : UInt64) -> CanOpenHeartbeatState

#
CanOpenDevice::name

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

#
CanOpenDevice::nmt

source

#
CanOpenDevice::nmt_commands

source
fn CanOpenDevice::nmt_commands(self : CanOpenDevice) -> Int

#
CanOpenDevice::node_id

source
fn CanOpenDevice::node_id(self : CanOpenDevice) -> Byte

#
CanOpenDevice::sdo_download

source
fn CanOpenDevice::sdo_download(self : CanOpenDevice, index : UInt, sub_index : Byte, data : Array[Byte]) -> CanOpenDeviceSdoResult

#
CanOpenDevice::sdo_downloads

source
fn CanOpenDevice::sdo_downloads(self : CanOpenDevice) -> Int

#
CanOpenDevice::sdo_upload

source
fn CanOpenDevice::sdo_upload(self : CanOpenDevice, index : UInt, sub_index : Byte) -> CanOpenDeviceSdoResult

#
CanOpenDevice::sdo_uploads

source
fn CanOpenDevice::sdo_uploads(self : CanOpenDevice) -> Int

#
CanOpenDevice::state

source

#
CanOpenDevice::to_text

source
fn CanOpenDevice::to_text(self : CanOpenDevice) -> String

#
CanOpenDeviceNetwork

source
pub struct CanOpenDeviceNetwork {
  devices : Array[CanOpenDevice]
  commands : Int
  unknown_nodes : Int
}

A deterministic collection of CANopen devices.

#
CanOpenDeviceNetwork::add

source
fn CanOpenDeviceNetwork::add(self : CanOpenDeviceNetwork, device : CanOpenDevice) -> Bool

#
CanOpenDeviceNetwork::broadcast_nmt

source
fn CanOpenDeviceNetwork::broadcast_nmt(self : CanOpenDeviceNetwork, command : CanOpenNmtCommand) -> Int

#
CanOpenDeviceNetwork::commands

source
fn CanOpenDeviceNetwork::commands(self : CanOpenDeviceNetwork) -> Int

#
CanOpenDeviceNetwork::devices

source

#
CanOpenDeviceNetwork::find

source
fn CanOpenDeviceNetwork::find(self : CanOpenDeviceNetwork, node_id : Byte) -> CanOpenDevice?

#
CanOpenDeviceNetwork::sdo_upload

source
fn CanOpenDeviceNetwork::sdo_upload(self : CanOpenDeviceNetwork, node_id : Byte, index : UInt, sub_index : Byte) -> CanOpenDeviceSdoResult

#
CanOpenDeviceNetwork::unknown_nodes

source
fn CanOpenDeviceNetwork::unknown_nodes(self : CanOpenDeviceNetwork) -> Int

#
CanOpenDeviceSdoResult

source
pub enum CanOpenDeviceSdoResult {
  CanOpenDeviceSdoUploaded(Array[Byte])
  CanOpenDeviceSdoDownloaded
  CanOpenDeviceSdoAbort(UInt)
}

Result of an SDO access handled by a device.

#
CanOpenDeviceSdoSession

source
pub struct CanOpenDeviceSdoSession {
  index : UInt
  sub_index : Byte
  upload : Bool
  data : Array[Byte]
  offset : Int
  toggle : Bool
  block_size : Int
}

Stateful SDO transfer context.

#
CanOpenDeviceSdoSession::complete

source

#
CanOpenDeviceSdoSession::index

source

#
CanOpenDeviceSdoSession::next_segment

source
fn CanOpenDeviceSdoSession::next_segment(self : CanOpenDeviceSdoSession) -> Array[Byte]?

#
CanOpenDeviceSdoSession::offset

source

#
CanOpenDeviceSdoSession::remaining

source

#
CanOpenDeviceSdoSession::sub_index

source
fn CanOpenDeviceSdoSession::sub_index(self : CanOpenDeviceSdoSession) -> Byte

#
CanOpenDeviceSdoSession::toggle

source

#
CanOpenDeviceSdoSession::upload

source

#
CanOpenDeviceState

source
pub enum CanOpenDeviceState {
  CanOpenDeviceInitializing
  CanOpenDevicePreOperational
  CanOpenDeviceOperational
  CanOpenDeviceStopped
  CanOpenDeviceResetting
}

CANopen NMT state maintained by a device model.

#
CanOpenHeartbeatMonitor

source
pub struct CanOpenHeartbeatMonitor {
  node_id : Byte
  timeout_us : UInt64
  state : CanOpenHeartbeatState
  last_seen_us : UInt64
  heartbeats : Int
  transitions : Int
}

#
CanOpenHeartbeatMonitor::heartbeats

source
fn CanOpenHeartbeatMonitor::heartbeats(self : CanOpenHeartbeatMonitor) -> Int

#
CanOpenHeartbeatMonitor::last_seen_us

source
fn CanOpenHeartbeatMonitor::last_seen_us(self : CanOpenHeartbeatMonitor) -> UInt64

#
CanOpenHeartbeatMonitor::node_id

source

#
CanOpenHeartbeatMonitor::observe

source
fn CanOpenHeartbeatMonitor::observe(self : CanOpenHeartbeatMonitor, state_byte : Byte, timestamp_us : UInt64) -> Unit

#
CanOpenHeartbeatMonitor::poll

source
fn CanOpenHeartbeatMonitor::poll(self : CanOpenHeartbeatMonitor, timestamp_us : UInt64) -> CanOpenHeartbeatState

#
CanOpenHeartbeatMonitor::state

source

#
CanOpenHeartbeatMonitor::timeout_us

source
fn CanOpenHeartbeatMonitor::timeout_us(self : CanOpenHeartbeatMonitor) -> UInt64

#
CanOpenHeartbeatMonitor::transitions

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

#
CanOpenHeartbeatState

source
pub enum CanOpenHeartbeatState {
  CanOpenHeartbeatUnknown
  CanOpenHeartbeatAlive
  CanOpenHeartbeatTimeout
  CanOpenHeartbeatStopped
}

Heartbeat state of a monitored CANopen node.

#
CanOpenNmtCommand

source
pub(all) enum CanOpenNmtCommand {
  Start
  Stop
  EnterPreOperational
  ResetNode
  ResetCommunication
}

CANopen NMT state commands.

#
CanOpenObjectAccess

source
pub enum CanOpenObjectAccess {
  CanOpenObjectReadOnly
  CanOpenObjectWriteOnly
  CanOpenObjectReadWrite
  CanOpenObjectConstant
}

Object-dictionary access rights.

#
CanOpenObjectDictionary

source
pub struct CanOpenObjectDictionary {
  entries : Array[CanOpenObjectEntry]
  revision : UInt
  capacity : Int
}

A bounded object dictionary.

#
CanOpenObjectDictionary::add

source

#
CanOpenObjectDictionary::entries

source

#
CanOpenObjectDictionary::find

source
fn CanOpenObjectDictionary::find(self : CanOpenObjectDictionary, index : UInt, sub_index : Byte) -> CanOpenObjectEntry?

#
CanOpenObjectDictionary::indices

source

#
CanOpenObjectDictionary::length

source

#
CanOpenObjectDictionary::read

source
fn CanOpenObjectDictionary::read(self : CanOpenObjectDictionary, index : UInt, sub_index : Byte) -> Array[Byte]?

#
CanOpenObjectDictionary::replace

source

#
CanOpenObjectDictionary::revision

source

#
CanOpenObjectDictionary::to_text

source
fn CanOpenObjectDictionary::to_text(self : CanOpenObjectDictionary) -> String

#
CanOpenObjectDictionary::write

source
fn CanOpenObjectDictionary::write(self : CanOpenObjectDictionary, index : UInt, sub_index : Byte, data : Array[Byte]) -> Bool

#
CanOpenObjectEntry

source
pub struct CanOpenObjectEntry {
  index : UInt
  sub_index : Byte
  name : String
  access : CanOpenObjectAccess
  data : Array[Byte]
  max_length : Int
  revision : UInt
}

A typed object-dictionary entry.

#
CanOpenObjectEntry::access

source

#
CanOpenObjectEntry::data

source
fn CanOpenObjectEntry::data(self : CanOpenObjectEntry) -> Array[Byte]

#
CanOpenObjectEntry::index

source
fn CanOpenObjectEntry::index(self : CanOpenObjectEntry) -> UInt

#
CanOpenObjectEntry::max_length

source
fn CanOpenObjectEntry::max_length(self : CanOpenObjectEntry) -> Int

#
CanOpenObjectEntry::name

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

#
CanOpenObjectEntry::read

source
fn CanOpenObjectEntry::read(self : CanOpenObjectEntry) -> Array[Byte]?

#
CanOpenObjectEntry::readable

source
fn CanOpenObjectEntry::readable(self : CanOpenObjectEntry) -> Bool

#
CanOpenObjectEntry::revision

source
fn CanOpenObjectEntry::revision(self : CanOpenObjectEntry) -> UInt

#
CanOpenObjectEntry::sub_index

source
fn CanOpenObjectEntry::sub_index(self : CanOpenObjectEntry) -> Byte

#
CanOpenObjectEntry::to_text

source
fn CanOpenObjectEntry::to_text(self : CanOpenObjectEntry) -> String

#
CanOpenObjectEntry::writable

source
fn CanOpenObjectEntry::writable(self : CanOpenObjectEntry) -> Bool

#
CanOpenObjectEntry::write

source
fn CanOpenObjectEntry::write(self : CanOpenObjectEntry, data : Array[Byte]) -> Bool

#
CanOpenSdoCommand

source
pub enum CanOpenSdoCommand {
  DownloadInitiate(index~ : UInt, sub_index~ : Byte, data~ : Array[Byte])
  UploadInitiate(index~ : UInt, sub_index~ : Byte)
  DownloadSegment(toggle~ : Bool, data~ : Array[Byte], last~ : Bool)
  UploadSegment(toggle~ : Bool)
  Abort(index~ : UInt, sub_index~ : Byte, code~ : UInt)
}

A compact SDO command representation.

#
CanPort

source
pub struct CanPort {
  name : String
  capabilities : CanAdapterCapabilities
  config : CanAdapterConfig
  lifecycle : CanAdapterLifecycle
  rx_queue : Array[CanAdapterMessage]
  tx_queue : Array[CanAdapterMessage]
  sequence : UInt
  stats : CanAdapterStats
}

A deterministic in-memory adapter implementing the hardware contract.

#
CanPort::capabilities

source
fn CanPort::capabilities(self : CanPort) -> CanAdapterCapabilities

#
CanPort::close

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

#
CanPort::completion_time_us

source
fn CanPort::completion_time_us(self : CanPort, message : CanAdapterMessage) -> UInt64

Estimate the wire completion time for a queued frame.

#
CanPort::config

source
fn CanPort::config(self : CanPort) -> CanAdapterConfig

#
CanPort::configure

source
fn CanPort::configure(self : CanPort, config : CanAdapterConfig) -> Unit raise CanAdapterError

#
CanPort::drain_rx

source
fn CanPort::drain_rx(self : CanPort, limit? : Int) -> Array[CanAdapterMessage]

#
CanPort::drain_tx

source
fn CanPort::drain_tx(self : CanPort, limit? : Int) -> Array[CanAdapterMessage]

#
CanPort::inject

source
fn CanPort::inject(self : CanPort, timestamp_us : UInt64, frame : Frame) -> Bool

#
CanPort::is_ready

source
fn CanPort::is_ready(self : CanPort) -> Bool

#
CanPort::lifecycle

source
fn CanPort::lifecycle(self : CanPort) -> CanAdapterLifecycle

#
CanPort::name

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

#
CanPort::open

source
fn CanPort::open(self : CanPort) -> Unit raise CanAdapterError

#
CanPort::pending_tx

source
fn CanPort::pending_tx(self : CanPort) -> Array[CanAdapterMessage]

Return a queue snapshot ordered by timestamp then sequence.

#
CanPort::receive

source
fn CanPort::receive(self : CanPort) -> CanAdapterMessage?

#
CanPort::recover

source
fn CanPort::recover(self : CanPort) -> Unit

#
CanPort::rx_pending

source
fn CanPort::rx_pending(self : CanPort) -> Int

#
CanPort::set_bus_off

source
fn CanPort::set_bus_off(self : CanPort) -> Unit

#
CanPort::stats

source
fn CanPort::stats(self : CanPort) -> CanAdapterStats

#
CanPort::transmit

source
fn CanPort::transmit(self : CanPort, timestamp_us : UInt64, frame : Frame) -> Unit raise CanAdapterError

#
CanPort::tx_pending

source
fn CanPort::tx_pending(self : CanPort) -> Int

#
CanScheduler

source
pub struct CanScheduler {
  tasks : Array[CanTask]
  now_us : UInt64
  executed : Int
  missed : Int
}

A deterministic task scheduler independent from wall-clock time.

#
CanScheduler::add

source
fn CanScheduler::add(self : CanScheduler, name : String, frame : Frame, first_due_us : UInt64, period_us : UInt64, deadline_us : UInt64, count : Int) -> Unit raise SchedulerError

Add a task. period_us == 0 creates a one-shot task.

#
CanScheduler::executed

source
fn CanScheduler::executed(self : CanScheduler) -> Int

#
CanScheduler::find

source
fn CanScheduler::find(self : CanScheduler, name : String) -> CanTask?

#
CanScheduler::missed

source
fn CanScheduler::missed(self : CanScheduler) -> Int

#
CanScheduler::next_due

source
fn CanScheduler::next_due(self : CanScheduler) -> UInt64?

Return the next due time among pending tasks.

#
CanScheduler::now

source
fn CanScheduler::now(self : CanScheduler) -> UInt64

#
CanScheduler::remove

source
fn CanScheduler::remove(self : CanScheduler, name : String) -> Unit raise SchedulerError

#
CanScheduler::task_count

source
fn CanScheduler::task_count(self : CanScheduler) -> Int

#
CanScheduler::tick

source
fn CanScheduler::tick(self : CanScheduler, timestamp_us : UInt64) -> Array[SchedulerTick] raise SchedulerError

Execute all tasks due by timestamp_us, ordered by CAN arbitration.

#
CanTask

source
pub struct CanTask {
  name : String
  frame : Frame
  next_due_us : UInt64
  period_us : UInt64
  deadline_us : UInt64
  remaining : Int
  priority : Int
}

A periodic or one-shot transmission task.

#
CompatibilityCandidate

source
pub struct CompatibilityCandidate {
  target : CompatibilityTarget
  evaluation : CompatibilityEvaluation
  rank : Int
}

A ranked compatibility candidate.

#
CompatibilityCandidate::evaluation

source

#
CompatibilityCandidate::rank

source

#
CompatibilityCandidate::summary

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

#
CompatibilityCandidate::target

source

#
CompatibilityDelta

source
pub struct CompatibilityDelta {
  source : String
  destination : String
  bitrate_loss : Int
  data_bitrate_loss : Int
  payload_loss : Int
  identifier_loss : Int
  node_capacity_loss : Int
  lost_features : Array[String]
}

Compare two targets and describe the capabilities that are lost during a downgrade.

#
CompatibilityDelta::bitrate_loss

source
fn CompatibilityDelta::bitrate_loss(self : CompatibilityDelta) -> Int

#
CompatibilityDelta::data_bitrate_loss

source
fn CompatibilityDelta::data_bitrate_loss(self : CompatibilityDelta) -> Int

#
CompatibilityDelta::destination

source
fn CompatibilityDelta::destination(self : CompatibilityDelta) -> String

#
CompatibilityDelta::identifier_loss

source
fn CompatibilityDelta::identifier_loss(self : CompatibilityDelta) -> Int

#
CompatibilityDelta::is_lossless

source
fn CompatibilityDelta::is_lossless(self : CompatibilityDelta) -> Bool

#
CompatibilityDelta::lost_features

source
fn CompatibilityDelta::lost_features(self : CompatibilityDelta) -> Array[String]

#
CompatibilityDelta::node_capacity_loss

source
fn CompatibilityDelta::node_capacity_loss(self : CompatibilityDelta) -> Int

#
CompatibilityDelta::payload_loss

source
fn CompatibilityDelta::payload_loss(self : CompatibilityDelta) -> Int

#
CompatibilityDelta::report

source
fn CompatibilityDelta::report(self : CompatibilityDelta) -> String

#
CompatibilityDelta::source

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

#
CompatibilityEvaluation

source
pub struct CompatibilityEvaluation {
  target : CompatibilityTarget
  issues : Array[CompatibilityIssue]
  passed : Int
  warnings : Int
  failures : Int
  score : Int
}

Aggregated result for one target.

#
CompatibilityEvaluation::failures

source

#
CompatibilityEvaluation::is_compatible

source
fn CompatibilityEvaluation::is_compatible(self : CompatibilityEvaluation) -> Bool

#
CompatibilityEvaluation::issue_count

source
fn CompatibilityEvaluation::issue_count(self : CompatibilityEvaluation) -> Int

#
CompatibilityEvaluation::issues

source

#
CompatibilityEvaluation::passed

source

#
CompatibilityEvaluation::report

source

#
CompatibilityEvaluation::score

source

#
CompatibilityEvaluation::summary

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

#
CompatibilityEvaluation::target

source

#
CompatibilityEvaluation::warnings

source

#
CompatibilityFleetSummary

source
pub struct CompatibilityFleetSummary {
  target_count : Int
  compatible_count : Int
  warning_count : Int
  failure_count : Int
  average_score : Int
  lowest_score : Int
  highest_score : Int
}

A fleet-level summary used by acceptance gates and dashboards.

#
CompatibilityFleetSummary::average_score

source
fn CompatibilityFleetSummary::average_score(self : CompatibilityFleetSummary) -> Int

#
CompatibilityFleetSummary::compatible_count

source
fn CompatibilityFleetSummary::compatible_count(self : CompatibilityFleetSummary) -> Int

#
CompatibilityFleetSummary::failure_count

source
fn CompatibilityFleetSummary::failure_count(self : CompatibilityFleetSummary) -> Int

#
CompatibilityFleetSummary::highest_score

source
fn CompatibilityFleetSummary::highest_score(self : CompatibilityFleetSummary) -> Int

#
CompatibilityFleetSummary::is_release_ready

source
fn CompatibilityFleetSummary::is_release_ready(self : CompatibilityFleetSummary) -> Bool

#
CompatibilityFleetSummary::lowest_score

source

#
CompatibilityFleetSummary::target_count

source

#
CompatibilityFleetSummary::text

source

#
CompatibilityFleetSummary::warning_count

source
fn CompatibilityFleetSummary::warning_count(self : CompatibilityFleetSummary) -> Int

#
CompatibilityIssue

source
pub struct CompatibilityIssue {
  target : String
  code : String
  severity : CompatibilitySeverity
  passed : Bool
  message : String
  observed : String
  expected : String
}

A single finding produced while checking a target.

#
CompatibilityIssue::code

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

#
CompatibilityIssue::expected

source
fn CompatibilityIssue::expected(self : CompatibilityIssue) -> String

#
CompatibilityIssue::message

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

#
CompatibilityIssue::observed

source
fn CompatibilityIssue::observed(self : CompatibilityIssue) -> String

#
CompatibilityIssue::passed

source
fn CompatibilityIssue::passed(self : CompatibilityIssue) -> Bool

#
CompatibilityIssue::severity

source

#
CompatibilityIssue::target

source
fn CompatibilityIssue::target(self : CompatibilityIssue) -> String

#
CompatibilityIssue::text

source
fn CompatibilityIssue::text(self : CompatibilityIssue) -> String

#
CompatibilityMatrix

source
pub struct CompatibilityMatrix {
  name : String
  strict : Bool
  targets : Array[CompatibilityTarget]
  requirements : Array[CompatibilityRequirement]
}

A matrix of target profiles and production requirements.

#
CompatibilityMatrix::add_requirement

source
fn CompatibilityMatrix::add_requirement(self : CompatibilityMatrix, requirement : CompatibilityRequirement) -> Unit

#
CompatibilityMatrix::add_target

source
fn CompatibilityMatrix::add_target(self : CompatibilityMatrix, target : CompatibilityTarget) -> Unit

#
CompatibilityMatrix::best_target

source

#
CompatibilityMatrix::clear_requirements

source
fn CompatibilityMatrix::clear_requirements(self : CompatibilityMatrix) -> Unit

#
CompatibilityMatrix::clear_targets

source
fn CompatibilityMatrix::clear_targets(self : CompatibilityMatrix) -> Unit

#
CompatibilityMatrix::compatible_targets

source

#
CompatibilityMatrix::csv

source
fn CompatibilityMatrix::csv(self : CompatibilityMatrix) -> String

#
CompatibilityMatrix::evaluate

source

#
CompatibilityMatrix::evaluate_all

source

#
CompatibilityMatrix::fingerprint

source
fn CompatibilityMatrix::fingerprint(self : CompatibilityMatrix) -> UInt64

Fingerprint all targets in insertion order for reproducible deployment metadata.

#
CompatibilityMatrix::fleet_summary

source

#
CompatibilityMatrix::name

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

#
CompatibilityMatrix::ranked_candidates

source

#
CompatibilityMatrix::report

source
fn CompatibilityMatrix::report(self : CompatibilityMatrix) -> String

#
CompatibilityMatrix::requirement_count

source
fn CompatibilityMatrix::requirement_count(self : CompatibilityMatrix) -> Int

#
CompatibilityMatrix::requirement_report

source
fn CompatibilityMatrix::requirement_report(self : CompatibilityMatrix) -> String

#
CompatibilityMatrix::requirements

source

#
CompatibilityMatrix::requirements_by_severity

source

Filter requirements by severity for an operator-facing view.

#
CompatibilityMatrix::status

source
fn CompatibilityMatrix::status(self : CompatibilityMatrix) -> String

Return a short status suitable for a health endpoint.

#
CompatibilityMatrix::strict

source
fn CompatibilityMatrix::strict(self : CompatibilityMatrix) -> Bool

#
CompatibilityMatrix::target_count

source
fn CompatibilityMatrix::target_count(self : CompatibilityMatrix) -> Int

#
CompatibilityMatrix::targets

source

#
CompatibilityProtocol

source
pub(all) enum CompatibilityProtocol {
  CompatibilityClassicCan
  CompatibilityCanFd
  CompatibilityIsoTp
  CompatibilityUds
  CompatibilityCanOpen
  CompatibilityJ1939
  CompatibilityGateway
  CompatibilityCustom
}

Protocol families that can be checked by a deployment compatibility matrix.

#
CompatibilityReleaseGate

source
pub struct CompatibilityReleaseGate {
  name : String
  matrices : Array[CompatibilityMatrix]
  minimum_score : Int
  require_all_targets : Bool
}

A named release gate composed of several matrices.

#
CompatibilityReleaseGate::add_matrix

source

#
CompatibilityReleaseGate::matrix_count

source
fn CompatibilityReleaseGate::matrix_count(self : CompatibilityReleaseGate) -> Int

#
CompatibilityReleaseGate::minimum_score

source
fn CompatibilityReleaseGate::minimum_score(self : CompatibilityReleaseGate) -> Int

#
CompatibilityReleaseGate::ready

source

#
CompatibilityReleaseGate::report

source

#
CompatibilityReleaseGate::require_all_targets

source
fn CompatibilityReleaseGate::require_all_targets(self : CompatibilityReleaseGate) -> Bool

#
CompatibilityRequirement

source
pub struct CompatibilityRequirement {
  code : String
  description : String
  kind : CompatibilityRequirementKind
  numeric_value : Int
  protocol_value : CompatibilityProtocol?
  feature_value : String?
  severity : CompatibilitySeverity
}

A reusable requirement for a production target.

#
CompatibilityRequirement::code

source

#
CompatibilityRequirement::description

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

#
CompatibilityRequirement::feature_value

source
fn CompatibilityRequirement::feature_value(self : CompatibilityRequirement) -> String?

#
CompatibilityRequirement::kind

source

#
CompatibilityRequirement::numeric_value

source
fn CompatibilityRequirement::numeric_value(self : CompatibilityRequirement) -> Int

#
CompatibilityRequirement::protocol_value

source

#
CompatibilityRequirement::severity

source

#
CompatibilityRequirementKind

source
pub(all) enum CompatibilityRequirementKind {
  CompatibilityMinimumBitrate
  CompatibilityMinimumDataBitrate
  CompatibilityMinimumPayload
  CompatibilityMinimumIdentifierBits
  CompatibilityMinimumNodeCapacity
  CompatibilityProtocolIs
  CompatibilityRequiresFeature
  CompatibilityForbidsFeature
  CompatibilityRequiresFd
  CompatibilityRequiresClassic
  CompatibilityRequiresIsoTp
  CompatibilityRequiresDiagnostics
}

A machine-readable kind of capability requirement.

#
CompatibilityRoute

source
pub struct CompatibilityRoute {
  source : CompatibilityTarget
  destination : CompatibilityTarget
  transport : CompatibilityProtocol
  max_payload : Int
  uses_segmentation : Bool
  valid : Bool
  reason : String
}

Validate a route between two protocol endpoints.

#
CompatibilityRoute::destination

source

#
CompatibilityRoute::max_payload

source
fn CompatibilityRoute::max_payload(self : CompatibilityRoute) -> Int

#
CompatibilityRoute::reason

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

#
CompatibilityRoute::source

source

#
CompatibilityRoute::summary

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

#
CompatibilityRoute::transport

source

#
CompatibilityRoute::uses_segmentation

source
fn CompatibilityRoute::uses_segmentation(self : CompatibilityRoute) -> Bool

#
CompatibilityRoute::valid

source
fn CompatibilityRoute::valid(self : CompatibilityRoute) -> Bool

#
CompatibilityRouteTable

source
pub struct CompatibilityRouteTable {
  routes : Array[CompatibilityRoute]
}

A route table that prevents unsupported forwarding paths from reaching runtime.

#
CompatibilityRouteTable::add

source

#
CompatibilityRouteTable::invalid_routes

source

#
CompatibilityRouteTable::report

source

#
CompatibilityRouteTable::routes

source

#
CompatibilityRouteTable::valid_routes

source

#
CompatibilitySeverity

source
pub(all) enum CompatibilitySeverity {
  CompatibilityInfo
  CompatibilityWarning
  CompatibilityError
}

The level attached to a requirement or finding.

#
CompatibilityTarget

source
pub struct CompatibilityTarget {
  name : String
  protocol : CompatibilityProtocol
  nominal_bitrate : Int
  data_bitrate : Int
  max_payload : Int
  identifier_bits : Int
  node_capacity : Int
  features : Array[String]
  notes : String
}

A deployment target and the capabilities it advertises.

#
CompatibilityTarget::data_bitrate

source
fn CompatibilityTarget::data_bitrate(self : CompatibilityTarget) -> Int

#
CompatibilityTarget::feature_count

source
fn CompatibilityTarget::feature_count(self : CompatibilityTarget) -> Int

#
CompatibilityTarget::feature_csv

source
fn CompatibilityTarget::feature_csv(self : CompatibilityTarget) -> String

#
CompatibilityTarget::features

source
fn CompatibilityTarget::features(self : CompatibilityTarget) -> Array[String]

#
CompatibilityTarget::has_feature

source
fn CompatibilityTarget::has_feature(self : CompatibilityTarget, wanted : String) -> Bool

#
CompatibilityTarget::identifier_bits

source
fn CompatibilityTarget::identifier_bits(self : CompatibilityTarget) -> Int

#
CompatibilityTarget::max_payload

source
fn CompatibilityTarget::max_payload(self : CompatibilityTarget) -> Int

#
CompatibilityTarget::name

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

#
CompatibilityTarget::node_capacity

source
fn CompatibilityTarget::node_capacity(self : CompatibilityTarget) -> Int

#
CompatibilityTarget::nominal_bitrate

source
fn CompatibilityTarget::nominal_bitrate(self : CompatibilityTarget) -> Int

#
CompatibilityTarget::notes

source
fn CompatibilityTarget::notes(self : CompatibilityTarget) -> String

#
CompatibilityTarget::protocol

source

#
CompatibilityTarget::summary

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

#
DbcCodegenOptions

source
pub struct DbcCodegenOptions {
  target : DbcCodegenTarget
  module_name : String
  include_comments : Bool
  include_validation : Bool
  line_ending : String
}

Options used by a deterministic DBC artifact generator.

#
DbcCodegenOptions::include_comments

source
fn DbcCodegenOptions::include_comments(self : DbcCodegenOptions) -> Bool

#
DbcCodegenOptions::include_validation

source
fn DbcCodegenOptions::include_validation(self : DbcCodegenOptions) -> Bool

#
DbcCodegenOptions::line_ending

source
fn DbcCodegenOptions::line_ending(self : DbcCodegenOptions) -> String

#
DbcCodegenOptions::module_name

source
fn DbcCodegenOptions::module_name(self : DbcCodegenOptions) -> String

#
DbcCodegenOptions::target

source

#
DbcCodegenTarget

source
pub enum DbcCodegenTarget {
  DbcCodegenMoonBit
  DbcCodegenCHeader
  DbcCodegenJsonSchema
  DbcCodegenMarkdown
}

Output dialect for generated DBC integration artifacts.

#
DbcDatabase

source
pub struct DbcDatabase {
  messages : Array[Message]
}

A lookup table for message definitions.

#
DbcDatabase::add

source
fn DbcDatabase::add(self : DbcDatabase, item : Message) -> Unit raise DbcRuntimeError

Add a message definition, rejecting duplicate numeric identifiers.

#
DbcDatabase::by_id

source
fn DbcDatabase::by_id(self : DbcDatabase, id : UInt) -> Message?

Find a message by CAN identifier.

#
DbcDatabase::by_name

source
fn DbcDatabase::by_name(self : DbcDatabase, name : String) -> Message?

Find a message by its symbolic name.

#
DbcDatabase::decode_frame

source
fn DbcDatabase::decode_frame(self : DbcDatabase, frame : Frame) -> DecodedMessage? raise DbcRuntimeError

Decode a frame using the message selected by its identifier.

#
DbcDatabase::ids

source
fn DbcDatabase::ids(self : DbcDatabase) -> Array[UInt]

Return all numeric message identifiers.

#
DbcDatabase::length

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

Return the number of definitions.

#
DbcDatabase::messages

source
fn DbcDatabase::messages(self : DbcDatabase) -> Array[Message]

Return all message definitions in source order.

#
DbcGeneratedArtifact

source
pub struct DbcGeneratedArtifact {
  path : String
  target : DbcCodegenTarget
  content : String
  line_count : Int
  message_count : Int
  signal_count : Int
  warnings : Array[String]
}

A generated artifact with reproducible metadata.

#
DbcGeneratedArtifact::content

source
fn DbcGeneratedArtifact::content(self : DbcGeneratedArtifact) -> String

#
DbcGeneratedArtifact::line_count

source
fn DbcGeneratedArtifact::line_count(self : DbcGeneratedArtifact) -> Int

#
DbcGeneratedArtifact::message_count

source
fn DbcGeneratedArtifact::message_count(self : DbcGeneratedArtifact) -> Int

#
DbcGeneratedArtifact::path

source
fn DbcGeneratedArtifact::path(self : DbcGeneratedArtifact) -> String

#
DbcGeneratedArtifact::signal_count

source
fn DbcGeneratedArtifact::signal_count(self : DbcGeneratedArtifact) -> Int

#
DbcGeneratedArtifact::target

source

#
DbcGeneratedArtifact::warnings

source
fn DbcGeneratedArtifact::warnings(self : DbcGeneratedArtifact) -> Array[String]

#
DbcParseReport

source
pub struct DbcParseReport {
  messages : Array[Message]
  ignored_lines : Int
  signal_lines : Int
}

A parse result that records ignored non-semantic lines.

#
DbcParseReport::ignored_lines

source
fn DbcParseReport::ignored_lines(self : DbcParseReport) -> Int

#
DbcParseReport::message_count

source
fn DbcParseReport::message_count(self : DbcParseReport) -> Int

#
DbcParseReport::messages

source
fn DbcParseReport::messages(self : DbcParseReport) -> Array[Message]

#
DbcParseReport::signal_lines

source
fn DbcParseReport::signal_lines(self : DbcParseReport) -> Int

#
DbcSchemaChange

source
pub struct DbcSchemaChange {
  id : UInt
  kind : String
  before : String?
  after : String?
}

A single schema difference between two message collections.

#
DbcSchemaChange::after

source
fn DbcSchemaChange::after(self : DbcSchemaChange) -> String?

#
DbcSchemaChange::before

source
fn DbcSchemaChange::before(self : DbcSchemaChange) -> String?

#
DbcSchemaChange::id

source
fn DbcSchemaChange::id(self : DbcSchemaChange) -> UInt

#
DbcSchemaChange::kind

source
fn DbcSchemaChange::kind(self : DbcSchemaChange) -> String

#
DbcSchemaReport

source
pub struct DbcSchemaReport {
  message_count : Int
  signal_count : Int
  unique_identifier_count : Int
  maximum_required_bytes : Int
}

Stable statistics for a validated DBC schema.

#
DbcSchemaReport::maximum_required_bytes

source
fn DbcSchemaReport::maximum_required_bytes(self : DbcSchemaReport) -> Int

#
DbcSchemaReport::message_count

source
fn DbcSchemaReport::message_count(self : DbcSchemaReport) -> Int

#
DbcSchemaReport::signal_count

source
fn DbcSchemaReport::signal_count(self : DbcSchemaReport) -> Int

#
DbcSchemaReport::unique_identifier_count

source
fn DbcSchemaReport::unique_identifier_count(self : DbcSchemaReport) -> Int

#
DbcWorkspace

source
pub struct DbcWorkspace {
  messages : Array[Message]
  groups : Array[DbcWorkspaceSignalGroup]
  bindings : Array[DbcWorkspaceBinding]
  revision : UInt
  encoded_frames : Int
  decoded_frames : Int
}

A runtime registry for DBC schemas, groups and bindings.

#
DbcWorkspace::add_binding

source
fn DbcWorkspace::add_binding(self : DbcWorkspace, binding : DbcWorkspaceBinding) -> Bool

#
DbcWorkspace::add_group

source
fn DbcWorkspace::add_group(self : DbcWorkspace, group : DbcWorkspaceSignalGroup) -> Bool

#
DbcWorkspace::add_message

source
fn DbcWorkspace::add_message(self : DbcWorkspace, item : Message) -> Bool

#
DbcWorkspace::bindings

source

#
DbcWorkspace::by_id

source
fn DbcWorkspace::by_id(self : DbcWorkspace, id : UInt) -> Message?

#
DbcWorkspace::by_name

source
fn DbcWorkspace::by_name(self : DbcWorkspace, name : String) -> Message?

#
DbcWorkspace::decode

source
fn DbcWorkspace::decode(self : DbcWorkspace, frame : Frame) -> DecodedMessage? raise DbcRuntimeError

Decode a frame using its message identifier.

#
DbcWorkspace::decoded_frames

source
fn DbcWorkspace::decoded_frames(self : DbcWorkspace) -> Int

#
DbcWorkspace::encode

source
fn DbcWorkspace::encode(self : DbcWorkspace, name : String, values : DbcWorkspaceValueSet) -> Frame raise DbcRuntimeError

Encode a named binding into a CAN frame.

#
DbcWorkspace::encoded_frames

source
fn DbcWorkspace::encoded_frames(self : DbcWorkspace) -> Int

#
DbcWorkspace::find_binding

source
fn DbcWorkspace::find_binding(self : DbcWorkspace, name : String) -> DbcWorkspaceBinding?

#
DbcWorkspace::find_group

source
fn DbcWorkspace::find_group(self : DbcWorkspace, name : String) -> DbcWorkspaceSignalGroup?

#
DbcWorkspace::fingerprint

source
fn DbcWorkspace::fingerprint(self : DbcWorkspace) -> UInt

Return a compact fingerprint for cache keys and CI artifacts.

#
DbcWorkspace::groups

source

#
DbcWorkspace::ids

source
fn DbcWorkspace::ids(self : DbcWorkspace) -> Array[UInt]

Return all message identifiers sorted for deterministic reports.

#
DbcWorkspace::messages

source
fn DbcWorkspace::messages(self : DbcWorkspace) -> Array[Message]

#
DbcWorkspace::replace_message

source
fn DbcWorkspace::replace_message(self : DbcWorkspace, item : Message) -> Bool

#
DbcWorkspace::revision

source
fn DbcWorkspace::revision(self : DbcWorkspace) -> UInt

#
DbcWorkspace::schema_text

source
fn DbcWorkspace::schema_text(self : DbcWorkspace) -> String

Return a stable, human-readable workspace schema summary.

#
DbcWorkspace::validate

source

Validate messages, groups, bindings and duplicate identifiers.

#
DbcWorkspaceBinding

source
pub struct DbcWorkspaceBinding {
  name : String
  message : Message
  selector : DbcWorkspaceMuxSelector
  extended : Bool
  default_values : DbcWorkspaceValueSet
  encoded : Int
  decoded : Int
}

A message binding with a stable runtime name and mux selector.

#
DbcWorkspaceBinding::decode

source

#
DbcWorkspaceBinding::decoded

source
fn DbcWorkspaceBinding::decoded(self : DbcWorkspaceBinding) -> Int

#
DbcWorkspaceBinding::defaults

source

#
DbcWorkspaceBinding::encode

source

#
DbcWorkspaceBinding::encoded

source
fn DbcWorkspaceBinding::encoded(self : DbcWorkspaceBinding) -> Int

#
DbcWorkspaceBinding::extended

source
fn DbcWorkspaceBinding::extended(self : DbcWorkspaceBinding) -> Bool

#
DbcWorkspaceBinding::matches_mux

source
fn DbcWorkspaceBinding::matches_mux(self : DbcWorkspaceBinding, mux : UInt) -> Bool

#
DbcWorkspaceBinding::message

source

#
DbcWorkspaceBinding::name

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

#
DbcWorkspaceBinding::selector

source

#
DbcWorkspaceBinding::set_default

source
fn DbcWorkspaceBinding::set_default(self : DbcWorkspaceBinding, values : DbcWorkspaceValueSet) -> Unit

#
DbcWorkspaceIssue

source
pub enum DbcWorkspaceIssue {
  DbcWorkspaceDuplicateId(UInt)
  DbcWorkspaceDuplicateName(String)
  DbcWorkspaceInvalidMessage(String)
  DbcWorkspaceMissingBinding(UInt)
  DbcWorkspaceEmptyGroup(String)
  DbcWorkspaceMuxConflict(String)
}

A schema finding returned by workspace validation.

#
DbcWorkspaceMuxSelector

source
pub enum DbcWorkspaceMuxSelector {
  DbcWorkspaceMuxNone
  DbcWorkspaceMuxValue(UInt)
  DbcWorkspaceMuxRange(UInt, UInt)
}

Selection rule for a multiplexed DBC message.

#
DbcWorkspaceSignalGroup

source
pub struct DbcWorkspaceSignalGroup {
  name : String
  message_id : UInt
  signals : Array[Signal]
  active : Bool
}

A named group of DBC signals used by a calibration tool.

#
DbcWorkspaceSignalGroup::active

source

#
DbcWorkspaceSignalGroup::add_signal

source
fn DbcWorkspaceSignalGroup::add_signal(self : DbcWorkspaceSignalGroup, item : Signal) -> Bool

#
DbcWorkspaceSignalGroup::contains

source
fn DbcWorkspaceSignalGroup::contains(self : DbcWorkspaceSignalGroup, name : String) -> Bool

#
DbcWorkspaceSignalGroup::find

source
fn DbcWorkspaceSignalGroup::find(self : DbcWorkspaceSignalGroup, name : String) -> Signal?

#
DbcWorkspaceSignalGroup::length

source

#
DbcWorkspaceSignalGroup::message_id

source
fn DbcWorkspaceSignalGroup::message_id(self : DbcWorkspaceSignalGroup) -> UInt

#
DbcWorkspaceSignalGroup::name

source

#
DbcWorkspaceSignalGroup::set_active

source
fn DbcWorkspaceSignalGroup::set_active(self : DbcWorkspaceSignalGroup, active : Bool) -> Unit

#
DbcWorkspaceSignalGroup::signals

source

#
DbcWorkspaceValue

source
pub struct DbcWorkspaceValue {
  name : String
  value : Double
}

A physical value associated with a named DBC signal.

#
DbcWorkspaceValue::name

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

#
DbcWorkspaceValue::value

source
fn DbcWorkspaceValue::value(self : DbcWorkspaceValue) -> Double

#
DbcWorkspaceValueSet

source
pub struct DbcWorkspaceValueSet {
  values : Array[DbcWorkspaceValue]
  revision : UInt
}

A deterministic value set that can be converted to a DBC map.

#
DbcWorkspaceValueSet::contains

source
fn DbcWorkspaceValueSet::contains(self : DbcWorkspaceValueSet, name : String) -> Bool

#
DbcWorkspaceValueSet::find

source
fn DbcWorkspaceValueSet::find(self : DbcWorkspaceValueSet, name : String) -> DbcWorkspaceValue?

#
DbcWorkspaceValueSet::names

source
fn DbcWorkspaceValueSet::names(self : DbcWorkspaceValueSet) -> Array[String]

#
DbcWorkspaceValueSet::put

source

#
DbcWorkspaceValueSet::put_number

source
fn DbcWorkspaceValueSet::put_number(self : DbcWorkspaceValueSet, name : String, value : Double) -> Unit

#
DbcWorkspaceValueSet::remove

source
fn DbcWorkspaceValueSet::remove(self : DbcWorkspaceValueSet, name : String) -> Bool

#
DbcWorkspaceValueSet::revision

source
fn DbcWorkspaceValueSet::revision(self : DbcWorkspaceValueSet) -> UInt

#
DbcWorkspaceValueSet::to_map

source
fn DbcWorkspaceValueSet::to_map(self : DbcWorkspaceValueSet) -> Map[String, Double]

#
DbcWorkspaceValueSet::values

source

#
DecodedMessage

source
pub struct DecodedMessage {
  id : UInt
  name : String
  signals : Array[DecodedSignal]
}

A decoded DBC message with the source identifier.

#
DecodedMessage::find

source
fn DecodedMessage::find(self : DecodedMessage, name : String) -> DecodedSignal?

Find a decoded value by signal name.

#
DecodedMessage::id

source
fn DecodedMessage::id(self : DecodedMessage) -> UInt

Return the message identifier from a decoded message.

#
DecodedMessage::name

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

Return the message name from a decoded message.

#
DecodedMessage::signals

source

Return decoded signals.

#
DecodedMessage::to_text

source
fn DecodedMessage::to_text(self : DecodedMessage) -> String

Render a decoded message as a stable diagnostic line.

#
DecodedSignal

source
pub struct DecodedSignal {
  name : String
  raw : UInt
  physical : Double
  unit : String
}

A decoded physical signal value.

#
DecodedSignal::name

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

#
DecodedSignal::physical

source
fn DecodedSignal::physical(self : DecodedSignal) -> Double

#
DecodedSignal::raw

source
fn DecodedSignal::raw(self : DecodedSignal) -> UInt

#
DecodedSignal::unit

source
fn DecodedSignal::unit(self : DecodedSignal) -> String

#
DiagnosticAddressingMode

source
pub enum DiagnosticAddressingMode {
  NormalAddressing
  ExtendedAddressing
  MixedAddressing(Byte)
}

Addressing modes supported by a diagnostic transport endpoint.

#
DiagnosticDataIdentifier

source
pub struct DiagnosticDataIdentifier {
  identifier : UInt
  name : String
  length : Int
  readable : Bool
  writable : Bool
  value : Array[Byte]
}

A data identifier entry exposed by an ECU.

#
DiagnosticDataIdentifier::identifier

source
fn DiagnosticDataIdentifier::identifier(self : DiagnosticDataIdentifier) -> UInt

#
DiagnosticDataIdentifier::length

source

#
DiagnosticDataIdentifier::name

source

#
DiagnosticDataIdentifier::read_value

source

Return the readable value padded to the configured length.

#
DiagnosticDataIdentifier::readable

source

#
DiagnosticDataIdentifier::set_value

source
fn DiagnosticDataIdentifier::set_value(self : DiagnosticDataIdentifier, value : Array[Byte]) -> Bool

Update a DID value, applying the configured maximum length.

#
DiagnosticDataIdentifier::value

source

#
DiagnosticDataIdentifier::writable

source

#
DiagnosticDataTable

source
pub struct DiagnosticDataTable {
  entries : Array[DiagnosticDataIdentifier]
  revision : UInt
}

A table of ECU data identifiers.

#
DiagnosticDataTable::add

source

#
DiagnosticDataTable::entries

source

#
DiagnosticDataTable::find

source
fn DiagnosticDataTable::find(self : DiagnosticDataTable, identifier : UInt) -> DiagnosticDataIdentifier?

#
DiagnosticDataTable::identifiers

source
fn DiagnosticDataTable::identifiers(self : DiagnosticDataTable) -> Array[UInt]

#
DiagnosticDataTable::length

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

#
DiagnosticDataTable::read

source
fn DiagnosticDataTable::read(self : DiagnosticDataTable, identifier : UInt) -> Array[Byte]?

#
DiagnosticDataTable::replace

source

#
DiagnosticDataTable::revision

source
fn DiagnosticDataTable::revision(self : DiagnosticDataTable) -> UInt

#
DiagnosticDataTable::to_text

source
fn DiagnosticDataTable::to_text(self : DiagnosticDataTable) -> String

#
DiagnosticDataTable::write

source
fn DiagnosticDataTable::write(self : DiagnosticDataTable, identifier : UInt, value : Array[Byte]) -> Bool

#
DiagnosticEvent

source
pub struct DiagnosticEvent {
  timestamp_us : UInt64
  request : DiagnosticRequest
  response : Array[Byte]
  positive : Bool
  duration_us : UInt64
}

A diagnostic event suitable for a tester trace.

#
DiagnosticEvent::duration_us

source
fn DiagnosticEvent::duration_us(self : DiagnosticEvent) -> UInt64

#
DiagnosticEvent::positive

source
fn DiagnosticEvent::positive(self : DiagnosticEvent) -> Bool

#
DiagnosticEvent::request

source

#
DiagnosticEvent::response

source
fn DiagnosticEvent::response(self : DiagnosticEvent) -> Array[Byte]

#
DiagnosticEvent::timestamp_us

source
fn DiagnosticEvent::timestamp_us(self : DiagnosticEvent) -> UInt64

#
DiagnosticExchangeLog

source
pub struct DiagnosticExchangeLog {
  events : Array[DiagnosticEvent]
  positive_count : Int
  negative_count : Int
}

An ordered diagnostic exchange log.

#
DiagnosticExchangeLog::average_duration_us

source
fn DiagnosticExchangeLog::average_duration_us(self : DiagnosticExchangeLog) -> UInt64

#
DiagnosticExchangeLog::events

source

#
DiagnosticExchangeLog::failed_services

source
fn DiagnosticExchangeLog::failed_services(self : DiagnosticExchangeLog) -> Array[String]

#
DiagnosticExchangeLog::length

source

#
DiagnosticExchangeLog::negative_count

source
fn DiagnosticExchangeLog::negative_count(self : DiagnosticExchangeLog) -> Int

#
DiagnosticExchangeLog::positive_count

source
fn DiagnosticExchangeLog::positive_count(self : DiagnosticExchangeLog) -> Int

#
DiagnosticExchangeLog::record

source
fn DiagnosticExchangeLog::record(self : DiagnosticExchangeLog, event : DiagnosticEvent) -> Unit

#
DiagnosticExchangeLog::to_text

source
fn DiagnosticExchangeLog::to_text(self : DiagnosticExchangeLog) -> String

#
DiagnosticReadiness

source
pub struct DiagnosticReadiness {
  session_ok : Bool
  security_ok : Bool
  voltage_ok : Bool
  temperature_ok : Bool
  dtc_ok : Bool
  reasons : Array[String]
}

A readiness check used before programming or calibration.

#
DiagnosticReadiness::dtc_ok

source
fn DiagnosticReadiness::dtc_ok(self : DiagnosticReadiness) -> Bool

#
DiagnosticReadiness::ready

source
fn DiagnosticReadiness::ready(self : DiagnosticReadiness) -> Bool

#
DiagnosticReadiness::reasons

source
fn DiagnosticReadiness::reasons(self : DiagnosticReadiness) -> Array[String]

#
DiagnosticReadiness::security_ok

source
fn DiagnosticReadiness::security_ok(self : DiagnosticReadiness) -> Bool

#
DiagnosticReadiness::session_ok

source
fn DiagnosticReadiness::session_ok(self : DiagnosticReadiness) -> Bool

#
DiagnosticReadiness::temperature_ok

source
fn DiagnosticReadiness::temperature_ok(self : DiagnosticReadiness) -> Bool

#
DiagnosticReadiness::voltage_ok

source
fn DiagnosticReadiness::voltage_ok(self : DiagnosticReadiness) -> Bool

#
DiagnosticRequest

source
pub struct DiagnosticRequest {
  service : UdsService
  payload : Array[Byte]
}

A diagnostic request represented as a CAN payload.

#
DiagnosticRequest::payload

source
fn DiagnosticRequest::payload(self : DiagnosticRequest) -> Array[Byte]

Return a defensive copy of the UDS payload.

#
DiagnosticRequest::service

source

Return the service kind.

#
DiagnosticRequest::service_id

source
fn DiagnosticRequest::service_id(self : DiagnosticRequest) -> Byte

Return the request's numeric service identifier.

#
DiagnosticRequest::service_name

source
fn DiagnosticRequest::service_name(self : DiagnosticRequest) -> String

Return the service's name.

#
DiagnosticRequest::suppress_response

source
fn DiagnosticRequest::suppress_response(self : DiagnosticRequest) -> Bool

Return whether a request contains a suppress-positive-response bit.

#
DiagnosticResponse

source
pub enum DiagnosticResponse {
  Positive(Array[Byte])
  Negative(code~ : Byte)
  Malformed
}

A response classification for a diagnostic exchange.

#
DiagnosticRetryPolicy

source
pub struct DiagnosticRetryPolicy {
  max_attempts : Int
  backoff_us : UInt64
  retry_negative : Bool
  attempts : Int
}

Retry policy used by a diagnostic workflow step.

#
DiagnosticRetryPolicy::attempts

source
fn DiagnosticRetryPolicy::attempts(self : DiagnosticRetryPolicy) -> Int

#
DiagnosticRetryPolicy::backoff_us

source
fn DiagnosticRetryPolicy::backoff_us(self : DiagnosticRetryPolicy) -> UInt64

#
DiagnosticRetryPolicy::begin_attempt

source
fn DiagnosticRetryPolicy::begin_attempt(self : DiagnosticRetryPolicy) -> Bool

#
DiagnosticRetryPolicy::can_retry

source
fn DiagnosticRetryPolicy::can_retry(self : DiagnosticRetryPolicy) -> Bool

#
DiagnosticRetryPolicy::max_attempts

source
fn DiagnosticRetryPolicy::max_attempts(self : DiagnosticRetryPolicy) -> Int

#
DiagnosticRetryPolicy::reset

source

#
DiagnosticRetryPolicy::retry_negative

source
fn DiagnosticRetryPolicy::retry_negative(self : DiagnosticRetryPolicy) -> Bool

#
DiagnosticSessionKind

source
pub enum DiagnosticSessionKind {
  DefaultSession
  ProgrammingSession
  ExtendedSession
  SafetySystemSession
  SupplierSession(Byte)
}

A diagnostic application session defined by ISO 14229.

#
DiagnosticSessionProfile

source
pub struct DiagnosticSessionProfile {
  kind : DiagnosticSessionKind
  p2_server_us : UInt64
  p2_star_server_us : UInt64
  s3_server_us : UInt64
  addressing : DiagnosticAddressingMode
  security_level : Byte
}

Timing and security policy for a diagnostic session.

#
DiagnosticSessionProfile::addressing

source

Return the addressing mode.

#
DiagnosticSessionProfile::kind

source

Return the session kind.

#
DiagnosticSessionProfile::p2_server_us

source
fn DiagnosticSessionProfile::p2_server_us(self : DiagnosticSessionProfile) -> UInt64

Return the P2 timeout in microseconds.

#
DiagnosticSessionProfile::p2_star_server_us

source
fn DiagnosticSessionProfile::p2_star_server_us(self : DiagnosticSessionProfile) -> UInt64

Return the P2-star timeout in microseconds.

#
DiagnosticSessionProfile::s3_server_us

source
fn DiagnosticSessionProfile::s3_server_us(self : DiagnosticSessionProfile) -> UInt64

Return the S3 timeout in microseconds.

#
DiagnosticSessionProfile::security_level

source
fn DiagnosticSessionProfile::security_level(self : DiagnosticSessionProfile) -> Byte

Return the required security level.

#
DiagnosticTroubleCode

source
pub struct DiagnosticTroubleCode {
  code : UInt
  status : Byte
  severity : Byte
  occurrence_count : Int
  snapshot : Array[Byte]
  extended_data : Array[Byte]
  last_seen_us : UInt64
}

A normalized diagnostic trouble code record.

#
DiagnosticTroubleCode::code

source

Return the numeric DTC code.

#
DiagnosticTroubleCode::extended_data

source
fn DiagnosticTroubleCode::extended_data(self : DiagnosticTroubleCode) -> Array[Byte]

Return a copy of the extended DTC data.

#
DiagnosticTroubleCode::has_status

source
fn DiagnosticTroubleCode::has_status(self : DiagnosticTroubleCode, bit : DtcStatusBit) -> Bool

Return whether a status bit is set.

#
DiagnosticTroubleCode::last_seen_us

source
fn DiagnosticTroubleCode::last_seen_us(self : DiagnosticTroubleCode) -> UInt64

Return the most recent observation timestamp.

#
DiagnosticTroubleCode::observe

source
fn DiagnosticTroubleCode::observe(self : DiagnosticTroubleCode, status : Byte, timestamp_us : UInt64) -> Unit

Apply a new observation to a DTC record.

#
DiagnosticTroubleCode::occurrence_count

source
fn DiagnosticTroubleCode::occurrence_count(self : DiagnosticTroubleCode) -> Int

Return the number of observed occurrences.

#
DiagnosticTroubleCode::set_extended_data

source
fn DiagnosticTroubleCode::set_extended_data(self : DiagnosticTroubleCode, data : Array[Byte]) -> Unit

Add or update extended DTC data.

#
DiagnosticTroubleCode::set_snapshot

source
fn DiagnosticTroubleCode::set_snapshot(self : DiagnosticTroubleCode, data : Array[Byte]) -> Unit

Add or update a freeze-frame snapshot.

#
DiagnosticTroubleCode::severity

source
fn DiagnosticTroubleCode::severity(self : DiagnosticTroubleCode) -> Byte

Return the configured severity byte.

#
DiagnosticTroubleCode::snapshot

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

Return a copy of the freeze-frame snapshot.

#
DiagnosticTroubleCode::status

source
fn DiagnosticTroubleCode::status(self : DiagnosticTroubleCode) -> Byte

Return the raw UDS status byte.

#
DiagnosticTroubleCode::status_text

source
fn DiagnosticTroubleCode::status_text(self : DiagnosticTroubleCode) -> String

Return a human-readable status summary.

#
DiagnosticTroubleCode::to_bytes

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

Serialize a DTC into the three-byte code plus status byte form.

#
DiagnosticTroubleCodeStore

source
pub struct DiagnosticTroubleCodeStore {
  capacity : Int
  records : Array[DiagnosticTroubleCode]
  generation : UInt
  cleared_at_us : UInt64
}

A bounded DTC store suitable for an ECU simulator or gateway.

#
DiagnosticTroubleCodeStore::capacity

source

Return the configured store capacity.

#
DiagnosticTroubleCodeStore::clear

source
fn DiagnosticTroubleCodeStore::clear(self : DiagnosticTroubleCodeStore, timestamp_us : UInt64) -> Unit

Clear all records and update the clear timestamp.

#
DiagnosticTroubleCodeStore::cleared_at_us

source
fn DiagnosticTroubleCodeStore::cleared_at_us(self : DiagnosticTroubleCodeStore) -> UInt64

Return the timestamp of the last clear operation.

#
DiagnosticTroubleCodeStore::codes

source

Return all DTC codes sorted numerically.

#
DiagnosticTroubleCodeStore::encode_report

source
fn DiagnosticTroubleCodeStore::encode_report(self : DiagnosticTroubleCodeStore, selector : DtcQuery, limit? : Int) -> Array[Byte]

Encode a DTC response payload for ReadDTCInformation.

#
DiagnosticTroubleCodeStore::find

source

Find a DTC by numeric code.

#
DiagnosticTroubleCodeStore::generation

source

Return the mutation generation.

#
DiagnosticTroubleCodeStore::length

source

Return the number of stored DTCs.

#
DiagnosticTroubleCodeStore::mark_cycle_start

source
fn DiagnosticTroubleCodeStore::mark_cycle_start(self : DiagnosticTroubleCodeStore) -> Unit

Mark every stored DTC as not completed since clear.

#
DiagnosticTroubleCodeStore::query

source

Query all matching DTCs in insertion order.

#
DiagnosticTroubleCodeStore::record

source

Add a new DTC or update an existing code.

#
DiagnosticTroubleCodeStore::records

source

Return a defensive copy of all records.

#
DiagnosticTroubleCodeStore::remove

source
fn DiagnosticTroubleCodeStore::remove(self : DiagnosticTroubleCodeStore, code : UInt) -> Bool

Remove one DTC by code and return whether it existed.

#
DiagnosticWorkflow

source
pub struct DiagnosticWorkflow {
  steps : Array[DiagnosticWorkflowStep]
  results : Array[DiagnosticWorkflowResult]
  cursor : Int
  state : DiagnosticWorkflowState
  started_us : UInt64
  last_timestamp_us : UInt64
  failures : Int
}

A sequential diagnostic workflow runner.

#
DiagnosticWorkflow::accept_current

source
fn DiagnosticWorkflow::accept_current(self : DiagnosticWorkflow, payload : Array[Byte], timestamp_us : UInt64) -> Bool

#
DiagnosticWorkflow::add

source

#
DiagnosticWorkflow::begin_current

source
fn DiagnosticWorkflow::begin_current(self : DiagnosticWorkflow, timestamp_us : UInt64) -> Bool

#
DiagnosticWorkflow::cancel

source
fn DiagnosticWorkflow::cancel(self : DiagnosticWorkflow) -> Unit

#
DiagnosticWorkflow::continue_after_wait

source
fn DiagnosticWorkflow::continue_after_wait(self : DiagnosticWorkflow) -> Bool

#
DiagnosticWorkflow::current

source

#
DiagnosticWorkflow::cursor

source
fn DiagnosticWorkflow::cursor(self : DiagnosticWorkflow) -> Int

#
DiagnosticWorkflow::failures

source
fn DiagnosticWorkflow::failures(self : DiagnosticWorkflow) -> Int

#
DiagnosticWorkflow::last_timestamp_us

source
fn DiagnosticWorkflow::last_timestamp_us(self : DiagnosticWorkflow) -> UInt64

#
DiagnosticWorkflow::length

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

#
DiagnosticWorkflow::poll_timeout

source
fn DiagnosticWorkflow::poll_timeout(self : DiagnosticWorkflow, timestamp_us : UInt64) -> Bool

#
DiagnosticWorkflow::progress_percent

source
fn DiagnosticWorkflow::progress_percent(self : DiagnosticWorkflow) -> Int

#
DiagnosticWorkflow::reset

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

#
DiagnosticWorkflow::results

source

#
DiagnosticWorkflow::start

source
fn DiagnosticWorkflow::start(self : DiagnosticWorkflow, timestamp_us : UInt64) -> Bool

#
DiagnosticWorkflow::started_us

source
fn DiagnosticWorkflow::started_us(self : DiagnosticWorkflow) -> UInt64

#
DiagnosticWorkflow::state

source

#
DiagnosticWorkflow::successful

source
fn DiagnosticWorkflow::successful(self : DiagnosticWorkflow) -> Bool

#
DiagnosticWorkflow::to_text

source
fn DiagnosticWorkflow::to_text(self : DiagnosticWorkflow) -> String

#
DiagnosticWorkflowResult

source
pub struct DiagnosticWorkflowResult {
  step_name : String
  service : String
  positive : Bool
  attempts : Int
  duration_us : UInt64
  response : DiagnosticResponse
}

A result record retained after a workflow step completes.

#
DiagnosticWorkflowResult::attempts

source

#
DiagnosticWorkflowResult::duration_us

source
fn DiagnosticWorkflowResult::duration_us(self : DiagnosticWorkflowResult) -> UInt64

#
DiagnosticWorkflowResult::positive

source

#
DiagnosticWorkflowResult::response

source

#
DiagnosticWorkflowResult::service

source

#
DiagnosticWorkflowResult::step_name

source
fn DiagnosticWorkflowResult::step_name(self : DiagnosticWorkflowResult) -> String

#
DiagnosticWorkflowState

source
pub enum DiagnosticWorkflowState {
  DiagnosticWorkflowIdle
  DiagnosticWorkflowRunning
  DiagnosticWorkflowWaiting
  DiagnosticWorkflowSucceeded
  DiagnosticWorkflowFailed
  DiagnosticWorkflowCancelled
}

State of a deterministic diagnostic workflow.

#
DiagnosticWorkflowStep

source
pub struct DiagnosticWorkflowStep {
  name : String
  request : DiagnosticRequest
  timeout_us : UInt64
  retry : DiagnosticRetryPolicy
  sent_at_us : UInt64?
  completed : Bool
  result : DiagnosticResponse?
}

One request scheduled in a diagnostic workflow.

#
DiagnosticWorkflowStep::accept

source
fn DiagnosticWorkflowStep::accept(self : DiagnosticWorkflowStep, payload : Array[Byte]) -> Bool

#
DiagnosticWorkflowStep::begin

source
fn DiagnosticWorkflowStep::begin(self : DiagnosticWorkflowStep, timestamp_us : UInt64) -> Bool

#
DiagnosticWorkflowStep::clear_attempt

source
fn DiagnosticWorkflowStep::clear_attempt(self : DiagnosticWorkflowStep) -> Unit

#
DiagnosticWorkflowStep::completed

source
fn DiagnosticWorkflowStep::completed(self : DiagnosticWorkflowStep) -> Bool

#
DiagnosticWorkflowStep::name

source

#
DiagnosticWorkflowStep::request

source

#
DiagnosticWorkflowStep::result

source

#
DiagnosticWorkflowStep::retry

source

#
DiagnosticWorkflowStep::sent_at_us

source
fn DiagnosticWorkflowStep::sent_at_us(self : DiagnosticWorkflowStep) -> UInt64?

#
DiagnosticWorkflowStep::timed_out

source
fn DiagnosticWorkflowStep::timed_out(self : DiagnosticWorkflowStep, timestamp_us : UInt64) -> Bool

#
DiagnosticWorkflowStep::timeout_us

source
fn DiagnosticWorkflowStep::timeout_us(self : DiagnosticWorkflowStep) -> UInt64

#
DtcQuery

source
pub enum DtcQuery {
  AllDtc
  ByCode(UInt)
  ByStatusMask(Byte)
  BySeverityAtLeast(Byte)
  ConfirmedOnly
  WarningOnly
  SeenAfter(UInt64)
}

A DTC query selector.

#
DtcRecord

source
pub struct DtcRecord {
  code : UInt
  status : Byte
  occurrence : UInt
  snapshot : Array[Byte]
}

A normalized three-byte diagnostic trouble code.

#
DtcRecord::code

source
fn DtcRecord::code(self : DtcRecord) -> UInt

#
DtcRecord::occurrence

source
fn DtcRecord::occurrence(self : DtcRecord) -> UInt

#
DtcRecord::snapshot

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

#
DtcRecord::status

source
fn DtcRecord::status(self : DtcRecord) -> Byte

#
DtcReport

source
pub struct DtcReport {
  subfunction : Byte
  status_availability_mask : Byte
  records : Array[DtcRecord]
}

A parsed ReadDTCInformation response.

#
DtcReport::records

source
fn DtcReport::records(self : DtcReport) -> Array[DtcRecord]

#
DtcReport::status_availability_mask

source
fn DtcReport::status_availability_mask(self : DtcReport) -> Byte

#
DtcReport::subfunction

source
fn DtcReport::subfunction(self : DtcReport) -> Byte

#
DtcStatusBit

source
pub enum DtcStatusBit {
  TestFailed
  TestFailedThisOperationCycle
  PendingDtc
  ConfirmedDtc
  TestNotCompletedSinceClear
  TestFailedSinceClear
  TestNotCompletedThisOperationCycle
  WarningIndicatorRequested
}

A status bit set used by a stored diagnostic trouble code.

#
DtcStore

source
pub struct DtcStore {
  capacity : Int
  records : Array[DtcRecord]
  updates : UInt
}

A bounded DTC store suitable for an ECU simulator or gateway cache.

#
DtcStore::clear_mask

source
fn DtcStore::clear_mask(self : DtcStore, code : UInt, mask : UInt) -> Int

Clear all records whose code matches a 24-bit mask.

#
DtcStore::find

source
fn DtcStore::find(self : DtcStore, code : UInt) -> DtcRecord?

#
DtcStore::length

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

#
DtcStore::query_status

source
fn DtcStore::query_status(self : DtcStore, status_mask : Byte) -> Array[DtcRecord]

Query records whose status contains every bit in status_mask.

#
DtcStore::remove

source
fn DtcStore::remove(self : DtcStore, code : UInt) -> Bool

Remove one DTC, returning whether it existed.

#
DtcStore::snapshot

source
fn DtcStore::snapshot(self : DtcStore) -> Array[DtcRecord]

#
DtcStore::updates

source
fn DtcStore::updates(self : DtcStore) -> UInt

#
DtcStore::upsert

source
fn DtcStore::upsert(self : DtcStore, record : DtcRecord) -> Unit raise DtcCodecError

Add a code or update the status and occurrence count of an existing code.

#
EcuEndpoint

source
pub struct EcuEndpoint {
  address : UInt
  name : String
  session : DiagnosticSessionProfile
  data : DiagnosticDataTable
  dtcs : DiagnosticTroubleCodeStore
  memory : EcuMemoryMap
  security : EcuSecurityPolicy
  reset_count : Int
  request_count : Int
  positive_count : Int
  negative_count : Int
  last_timestamp_us : UInt64
  pending_reset : EcuResetKind?
}

A deterministic ECU endpoint for integration testing.

#
EcuEndpoint::address

source
fn EcuEndpoint::address(self : EcuEndpoint) -> UInt

#
EcuEndpoint::clear_dtcs

source
fn EcuEndpoint::clear_dtcs(self : EcuEndpoint, timestamp_us : UInt64) -> Unit

#
EcuEndpoint::data

source

#
EcuEndpoint::dtcs

source

#
EcuEndpoint::handle

source
fn EcuEndpoint::handle(self : EcuEndpoint, request : DiagnosticRequest, timestamp_us : UInt64) -> EcuRequestOutcome

Handle a request and update endpoint counters.

#
EcuEndpoint::memory

source
fn EcuEndpoint::memory(self : EcuEndpoint) -> EcuMemoryMap

#
EcuEndpoint::name

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

#
EcuEndpoint::negative_count

source
fn EcuEndpoint::negative_count(self : EcuEndpoint) -> Int

#
EcuEndpoint::pending_reset

source
fn EcuEndpoint::pending_reset(self : EcuEndpoint) -> EcuResetKind?

#
EcuEndpoint::positive_count

source
fn EcuEndpoint::positive_count(self : EcuEndpoint) -> Int

#
EcuEndpoint::record_dtc

source
fn EcuEndpoint::record_dtc(self : EcuEndpoint, item : DiagnosticTroubleCode) -> Unit

#
EcuEndpoint::register_data

source
fn EcuEndpoint::register_data(self : EcuEndpoint, item : DiagnosticDataIdentifier) -> Bool

#
EcuEndpoint::register_memory

source
fn EcuEndpoint::register_memory(self : EcuEndpoint, region : EcuMemoryRegion) -> Bool

#
EcuEndpoint::request_count

source
fn EcuEndpoint::request_count(self : EcuEndpoint) -> Int

#
EcuEndpoint::reset_count

source
fn EcuEndpoint::reset_count(self : EcuEndpoint) -> Int

#
EcuEndpoint::security

source
fn EcuEndpoint::security(self : EcuEndpoint) -> EcuSecurityPolicy

#
EcuEndpoint::session

source

#
EcuEndpoint::to_text

source
fn EcuEndpoint::to_text(self : EcuEndpoint) -> String

Return a compact endpoint health line for a simulation report.

#
EcuFleet

source
pub struct EcuFleet {
  endpoints : Array[EcuEndpoint]
  routed : Int
  missed : Int
}

A deterministic fleet of ECU endpoints.

#
EcuFleet::add

source
fn EcuFleet::add(self : EcuFleet, endpoint : EcuEndpoint) -> Bool

#
EcuFleet::endpoints

source
fn EcuFleet::endpoints(self : EcuFleet) -> Array[EcuEndpoint]

#
EcuFleet::find

source
fn EcuFleet::find(self : EcuFleet, address : UInt) -> EcuEndpoint?

#
EcuFleet::handle

source
fn EcuFleet::handle(self : EcuFleet, address : UInt, request : DiagnosticRequest, timestamp_us : UInt64) -> EcuRequestOutcome

#
EcuFleet::length

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

#
EcuFleet::missed

source
fn EcuFleet::missed(self : EcuFleet) -> Int

#
EcuFleet::remove

source
fn EcuFleet::remove(self : EcuFleet, address : UInt) -> Bool

#
EcuFleet::routed

source
fn EcuFleet::routed(self : EcuFleet) -> Int

#
EcuFleet::to_text

source
fn EcuFleet::to_text(self : EcuFleet) -> String

#
EcuMemoryMap

source
pub struct EcuMemoryMap {
  regions : Array[EcuMemoryRegion]
  reads : Int
  writes : Int
}

A collection of non-overlapping ECU memory regions.

#
EcuMemoryMap::add

source
fn EcuMemoryMap::add(self : EcuMemoryMap, region : EcuMemoryRegion) -> Unit raise EcuMemoryError

#
EcuMemoryMap::find

source
fn EcuMemoryMap::find(self : EcuMemoryMap, address : UInt, length : Int) -> EcuMemoryRegion?

#
EcuMemoryMap::length

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

#
EcuMemoryMap::read

source
fn EcuMemoryMap::read(self : EcuMemoryMap, address : UInt, length : Int) -> Array[Byte] raise EcuMemoryError

#
EcuMemoryMap::reads

source
fn EcuMemoryMap::reads(self : EcuMemoryMap) -> Int

#
EcuMemoryMap::regions

source

#
EcuMemoryMap::write

source
fn EcuMemoryMap::write(self : EcuMemoryMap, address : UInt, data : Array[Byte]) -> Unit raise EcuMemoryError

#
EcuMemoryMap::writes

source
fn EcuMemoryMap::writes(self : EcuMemoryMap) -> Int

#
EcuMemoryPermission

source
pub enum EcuMemoryPermission {
  EcuMemoryReadable
  EcuMemoryWritable
  EcuMemoryReadWrite
  EcuMemoryLocked
}

Access permission for a deterministic ECU memory region.

#
EcuMemoryRegion

source
pub struct EcuMemoryRegion {
  start : UInt
  length : Int
  permission : EcuMemoryPermission
  bytes : Array[Byte]
}

An addressable memory region exposed by an ECU simulator.

#
EcuMemoryRegion::bytes

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

#
EcuMemoryRegion::contains

source
fn EcuMemoryRegion::contains(self : EcuMemoryRegion, address : UInt, length : Int) -> Bool

#
EcuMemoryRegion::fill

source
fn EcuMemoryRegion::fill(self : EcuMemoryRegion, value : Byte) -> Unit raise EcuMemoryError

#
EcuMemoryRegion::length

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

#
EcuMemoryRegion::permission

source

#
EcuMemoryRegion::read

source
fn EcuMemoryRegion::read(self : EcuMemoryRegion, address : UInt, length : Int) -> Array[Byte] raise EcuMemoryError

#
EcuMemoryRegion::start

source
fn EcuMemoryRegion::start(self : EcuMemoryRegion) -> UInt

#
EcuMemoryRegion::write

source
fn EcuMemoryRegion::write(self : EcuMemoryRegion, address : UInt, data : Array[Byte]) -> Unit raise EcuMemoryError

#
EcuRequestOutcome

source
pub enum EcuRequestOutcome {
  EcuPositiveResponse(Array[Byte])
  EcuNegativeResponse(Byte)
  EcuRequestRejected(String)
}

The result of handling a diagnostic request at an ECU endpoint.

#
EcuResetKind

source
pub enum EcuResetKind {
  EcuHardReset
  EcuKeyOffOnReset
  EcuSoftReset
  EcuResetBySupplier(Byte)
}

ECU reset kinds understood by the simulator.

#
EcuSecurityPolicy

source
pub struct EcuSecurityPolicy {
  level : Byte
  secret : UInt
  max_attempts : Int
  delay_us : UInt64
  attempts : Int
  state : EcuSecurityState
  seed_counter : UInt
}

Deterministic security access policy for tests and simulation.

#
EcuSecurityPolicy::attempts

source
fn EcuSecurityPolicy::attempts(self : EcuSecurityPolicy) -> Int

#
EcuSecurityPolicy::expected_key

source
fn EcuSecurityPolicy::expected_key(self : EcuSecurityPolicy, seed : UInt) -> UInt

#
EcuSecurityPolicy::is_unlocked

source
fn EcuSecurityPolicy::is_unlocked(self : EcuSecurityPolicy) -> Bool

#
EcuSecurityPolicy::issue_seed

source
fn EcuSecurityPolicy::issue_seed(self : EcuSecurityPolicy, timestamp_us : UInt64) -> UInt

#
EcuSecurityPolicy::level

source
fn EcuSecurityPolicy::level(self : EcuSecurityPolicy) -> Byte

#
EcuSecurityPolicy::lock

source
fn EcuSecurityPolicy::lock(self : EcuSecurityPolicy) -> Unit

#
EcuSecurityPolicy::state

source

#
EcuSecurityPolicy::unlock

source
fn EcuSecurityPolicy::unlock(self : EcuSecurityPolicy, key : UInt, seed : UInt, timestamp_us : UInt64) -> Bool

#
EcuSecurityState

source
pub enum EcuSecurityState {
  EcuSecurityLocked
  EcuSecuritySeedIssued(Byte)
  EcuSecurityUnlocked(Byte)
  EcuSecurityDelay(UInt64)
}

Security access state maintained by an ECU endpoint.

#
Filter

source
pub struct Filter {
  id : UInt
  mask : UInt
  extended : Bool?
}

A CAN acceptance filter.

#
Filter::extended

source
fn Filter::extended(self : Filter) -> Bool?

#
Filter::id

source
fn Filter::id(self : Filter) -> UInt

Return a filter's identifier pattern.

#
Filter::mask

source
fn Filter::mask(self : Filter) -> UInt

#
Filter::matches

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

Return whether a frame passes this filter.

#
FilterBank

source
pub struct FilterBank {
  filters : Array[Filter]
}

A group of filters evaluated in insertion order.

#
FilterBank::accepts

source
fn FilterBank::accepts(self : FilterBank, frame : Frame) -> Bool

Test whether any filter accepts a frame. An empty bank rejects all frames.

#
FilterBank::add

source
fn FilterBank::add(self : FilterBank, filter : Filter) -> Unit

Add a filter to the bank.

#
FilterBank::filters

source
fn FilterBank::filters(self : FilterBank) -> Array[Filter]

#
FilterBank::length

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

#
FilterIndex

source
pub struct FilterIndex {
  bank : FilterBank
  accepted : Int
  rejected : Int
}

A compact exact-or-mask index for a monitoring application.

#
FilterIndex::accepted

source
fn FilterIndex::accepted(self : FilterIndex) -> Int

#
FilterIndex::check

source
fn FilterIndex::check(self : FilterIndex, frame : Frame) -> Bool

#
FilterIndex::rejected

source
fn FilterIndex::rejected(self : FilterIndex) -> Int

#
Frame

source
pub struct Frame {
  id : UInt
  extended : Bool
  kind : FrameKind
  protocol : Protocol
  bitrate_switch : Bool
  error_state_indicator : Bool
  data : Array[Byte]
}

A normalized CAN frame.

#
Frame::bitrate_switch

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

Return whether the CAN-FD bit-rate switch is set.

#
Frame::data

source
fn Frame::data(self : Frame) -> Array[Byte]

Return a defensive copy of the payload.

#
Frame::dlc

source
fn Frame::dlc(self : Frame) -> Byte

Return the data length code for this frame.

#
Frame::error_state_indicator

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

Return whether the CAN-FD error-state indicator is set.

#
Frame::id

source
fn Frame::id(self : Frame) -> UInt

The arbitration identifier.

#
Frame::is_data

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

Return whether this frame carries application data.

#
Frame::is_error

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

Return whether this frame is a local simulation error.

#
Frame::is_extended

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

Whether the frame uses the 29-bit identifier format.

#
Frame::is_remote

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

Return whether this frame is a remote request.

#
Frame::kind

source
fn Frame::kind(self : Frame) -> FrameKind

Return the frame kind.

#
Frame::protocol

source
fn Frame::protocol(self : Frame) -> Protocol

Return the protocol version.

#
FrameAnalysis

source
pub struct FrameAnalysis {
  unique_ids : Int
  changed_payloads : Int
  repeated_payloads : Int
  average_payload : Double
  minimum_gap_us : UInt64?
  maximum_gap_us : UInt64?
}

A compact analysis of identifier and payload behavior.

#
FrameAnalysis::average_payload

source
fn FrameAnalysis::average_payload(self : FrameAnalysis) -> Double

#
FrameAnalysis::changed_payloads

source
fn FrameAnalysis::changed_payloads(self : FrameAnalysis) -> Int

#
FrameAnalysis::maximum_gap

source
fn FrameAnalysis::maximum_gap(self : FrameAnalysis) -> UInt64?

#
FrameAnalysis::minimum_gap

source
fn FrameAnalysis::minimum_gap(self : FrameAnalysis) -> UInt64?

#
FrameAnalysis::repeated_payloads

source
fn FrameAnalysis::repeated_payloads(self : FrameAnalysis) -> Int

#
FrameAnalysis::to_text

source
fn FrameAnalysis::to_text(self : FrameAnalysis) -> String

#
FrameAnalysis::unique_ids

source
fn FrameAnalysis::unique_ids(self : FrameAnalysis) -> Int

#
FrameBatch

source
pub struct FrameBatch {
  sequence : UInt
  frames : Array[Frame]
}

A validated batch of frames with a caller-provided sequence number.

#
FrameBatch::checksum

source
fn FrameBatch::checksum(self : FrameBatch) -> Byte

Return a non-cryptographic checksum suitable for corruption detection.

#
FrameBatch::encode

source
fn FrameBatch::encode(self : FrameBatch) -> Array[Byte]

Encode a batch as a length-prefixed binary archive.

#
FrameBatch::frames

source
fn FrameBatch::frames(self : FrameBatch) -> Array[Frame]

#
FrameBatch::length

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

#
FrameBatch::payload_bytes

source
fn FrameBatch::payload_bytes(self : FrameBatch) -> Int

Return the sum of payload bytes in the batch.

#
FrameBatch::sequence

source
fn FrameBatch::sequence(self : FrameBatch) -> UInt

#
FrameClass

source
pub enum FrameClass {
  ClassicData
  ClassicRemote
  CanFdData
  SimulationError
}

A coarse frame class useful for metrics and routing policies.

#
FrameDeduplicator

source
pub struct FrameDeduplicator {
  last : Array[(UInt, Array[Byte])]
  window_us : UInt64
  duplicates : Int
  unique : Int
}

A duplicate detector for cyclic frames.

#
FrameDeduplicator::accept

source
fn FrameDeduplicator::accept(self : FrameDeduplicator, timestamp_us : UInt64, frame : Frame) -> Bool

#
FrameDeduplicator::duplicates

source
fn FrameDeduplicator::duplicates(self : FrameDeduplicator) -> Int

#
FrameDeduplicator::reset

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

#
FrameDeduplicator::unique

source
fn FrameDeduplicator::unique(self : FrameDeduplicator) -> Int

#
FrameKind

source
pub enum FrameKind {
  Data
  Remote
  Error
}

A CAN frame kind.

#
FrameMetrics

source
pub struct FrameMetrics {
  total : Int
  classic_data : Int
  classic_remote : Int
  can_fd : Int
  errors : Int
  extended : Int
  payload_bytes : Int
  wire_bits : Int
  minimum_id : UInt?
  maximum_id : UInt?
  identifiers : Array[UInt]
  payload_histogram : Array[Int]
}

Aggregate counters for a collection of CAN frames.

#
FrameMetrics::can_fd

source
fn FrameMetrics::can_fd(self : FrameMetrics) -> Int

#
FrameMetrics::classic_data

source
fn FrameMetrics::classic_data(self : FrameMetrics) -> Int

#
FrameMetrics::classic_remote

source
fn FrameMetrics::classic_remote(self : FrameMetrics) -> Int

#
FrameMetrics::errors

source
fn FrameMetrics::errors(self : FrameMetrics) -> Int

#
FrameMetrics::extended

source
fn FrameMetrics::extended(self : FrameMetrics) -> Int

#
FrameMetrics::identifiers

source
fn FrameMetrics::identifiers(self : FrameMetrics) -> Array[UInt]

#
FrameMetrics::maximum_id

source
fn FrameMetrics::maximum_id(self : FrameMetrics) -> UInt?

#
FrameMetrics::minimum_id

source
fn FrameMetrics::minimum_id(self : FrameMetrics) -> UInt?

#
FrameMetrics::payload_bytes

source
fn FrameMetrics::payload_bytes(self : FrameMetrics) -> Int

#
FrameMetrics::payload_count

source
fn FrameMetrics::payload_count(self : FrameMetrics, length : Int) -> Int

#
FrameMetrics::to_text

source
fn FrameMetrics::to_text(self : FrameMetrics) -> String

Render a stable metrics report for a CLI or CI artifact.

#
FrameMetrics::total

source
fn FrameMetrics::total(self : FrameMetrics) -> Int

#
FrameMetrics::wire_bits

source
fn FrameMetrics::wire_bits(self : FrameMetrics) -> Int

#
FramePipeline

source
pub struct FramePipeline {
  rules : Array[FramePipelineRule]
  capacity : Int
  processed : Int
  accepted : Int
  rejected : Int
  unmatched : Int
  failures : Int
}

A deterministic ordered frame-processing pipeline.

#
FramePipeline::accepted

source
fn FramePipeline::accepted(self : FramePipeline) -> Int

#
FramePipeline::add_rule

source
fn FramePipeline::add_rule(self : FramePipeline, rule : FramePipelineRule) -> Unit raise FramePipelineError

#
FramePipeline::failures

source
fn FramePipeline::failures(self : FramePipeline) -> Int

#
FramePipeline::find

source
fn FramePipeline::find(self : FramePipeline, name : String) -> FramePipelineRule?

#
FramePipeline::process

source
fn FramePipeline::process(self : FramePipeline, frame : Frame) -> FramePipelineResult

#
FramePipeline::process_batch

source
fn FramePipeline::process_batch(self : FramePipeline, frames : Array[Frame]) -> Array[Frame]

#
FramePipeline::processed

source
fn FramePipeline::processed(self : FramePipeline) -> Int

#
FramePipeline::rejected

source
fn FramePipeline::rejected(self : FramePipeline) -> Int

#
FramePipeline::remove_rule

source
fn FramePipeline::remove_rule(self : FramePipeline, name : String) -> Unit raise FramePipelineError

#
FramePipeline::reset_counters

source
fn FramePipeline::reset_counters(self : FramePipeline) -> Unit

#
FramePipeline::rules

source

#
FramePipeline::to_text

source
fn FramePipeline::to_text(self : FramePipeline) -> String

#
FramePipeline::unmatched

source
fn FramePipeline::unmatched(self : FramePipeline) -> Int

#
FramePipelineAction

source
pub(all) enum FramePipelineAction {
  FramePipelineForward
  FramePipelineDrop(String)
  FramePipelineRewriteId(UInt)
  FramePipelinePrefix(Array[Byte])
  FramePipelineReplaceData(Array[Byte])
}

Action applied by a deterministic frame-processing rule.

#
FramePipelineResult

source
pub(all) enum FramePipelineResult {
  FramePipelineAccepted(Frame, String)
  FramePipelineRejected(String)
  FramePipelineUnmatched(Frame)
}

Result emitted by one pipeline invocation.

#
FramePipelineRule

source
pub struct FramePipelineRule {
  name : String
  filter : Filter
  action : FramePipelineAction
  max_payload : Int
  allow_fd : Bool
  enabled : Bool
  hits : Int
}

A named frame-processing rule.

#
FramePipelineRule::action

source

#
FramePipelineRule::allow_fd

source
fn FramePipelineRule::allow_fd(self : FramePipelineRule) -> Bool

#
FramePipelineRule::enabled

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

#
FramePipelineRule::filter

source

#
FramePipelineRule::hits

source
fn FramePipelineRule::hits(self : FramePipelineRule) -> Int

#
FramePipelineRule::matches

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

#
FramePipelineRule::max_payload

source
fn FramePipelineRule::max_payload(self : FramePipelineRule) -> Int

#
FramePipelineRule::name

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

#
FramePipelineRule::set_enabled

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

#
FramePipelineWindow

source
pub struct FramePipelineWindow {
  start_us : UInt64?
  duration_us : UInt64
  frames : Array[Frame]
  closed : Bool
}

A rolling batch window for aggregating frames before analysis.

#
FramePipelineWindow::close

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

#
FramePipelineWindow::closed

source
fn FramePipelineWindow::closed(self : FramePipelineWindow) -> Bool

#
FramePipelineWindow::duration_us

source
fn FramePipelineWindow::duration_us(self : FramePipelineWindow) -> UInt64

#
FramePipelineWindow::frames

source

#
FramePipelineWindow::length

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

#
FramePipelineWindow::metrics

source

#
FramePipelineWindow::push

source
fn FramePipelineWindow::push(self : FramePipelineWindow, timestamp_us : UInt64, frame : Frame) -> Bool

#
FramePipelineWindow::start_us

source
fn FramePipelineWindow::start_us(self : FramePipelineWindow) -> UInt64?

#
FrameQueue

source
pub struct FrameQueue {
  capacity : Int
  next_sequence : UInt
  items : Array[QueueItem]
  dropped : Int
}

A deterministic priority queue for CAN transmit pipelines.

#
FrameQueue::capacity

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

#
FrameQueue::clear

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

Remove every pending item.

#
FrameQueue::dequeue

source
fn FrameQueue::dequeue(self : FrameQueue) -> QueueItem raise QueueError

Remove the highest-priority item.

#
FrameQueue::dropped

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

#
FrameQueue::enqueue

source
fn FrameQueue::enqueue(self : FrameQueue, channel : Byte, frame : Frame, enqueued_us : UInt64, deadline_us : UInt64) -> UInt raise QueueError

Add a frame and return its monotonic sequence number.

#
FrameQueue::expire

source
fn FrameQueue::expire(self : FrameQueue, now_us : UInt64) -> Array[QueueItem]

Remove items whose deadline has expired at now_us.

#
FrameQueue::is_empty

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

#
FrameQueue::is_full

source
fn FrameQueue::is_full(self : FrameQueue) -> Bool

#
FrameQueue::length

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

#
FrameQueue::peek

source
fn FrameQueue::peek(self : FrameQueue) -> QueueItem?

Return the highest-priority item without removing it.

#
FrameQueue::remove

source
fn FrameQueue::remove(self : FrameQueue, sequence : UInt) -> QueueItem raise QueueError

Remove a particular sequence number.

#
FrameQueue::snapshot

source
fn FrameQueue::snapshot(self : FrameQueue) -> Array[QueueItem]

#
FrameQueue::take_channel

source
fn FrameQueue::take_channel(self : FrameQueue, channel : Byte, limit : Int) -> Array[QueueItem] raise QueueError

Take up to limit items for one logical channel.

#
FrameRateLimiter

source
pub struct FrameRateLimiter {
  intervals : Array[(UInt, UInt64)]
  last_sent : Array[(UInt, UInt64)]
  allowed : Int
  limited : Int
}

A simple per-identifier rate limiter.

#
FrameRateLimiter::allow

source
fn FrameRateLimiter::allow(self : FrameRateLimiter, identifier : UInt, timestamp_us : UInt64) -> Bool

#
FrameRateLimiter::allowed

source
fn FrameRateLimiter::allowed(self : FrameRateLimiter) -> Int

#
FrameRateLimiter::limited

source
fn FrameRateLimiter::limited(self : FrameRateLimiter) -> Int

#
FrameRateLimiter::reset

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

#
FrameRateLimiter::set_interval

source
fn FrameRateLimiter::set_interval(self : FrameRateLimiter, identifier : UInt, interval_us : UInt64) -> Unit

#
FrameReport

source
pub struct FrameReport {
  valid : Bool
  violations : Array[FrameViolation]
  wire_bits : Int
  stuffed_bits : Int
}

The result of validating a normalized frame.

#
FrameReport::is_valid

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

#
FrameReport::stuffed_bits

source
fn FrameReport::stuffed_bits(self : FrameReport) -> Int

#
FrameReport::violations

source
fn FrameReport::violations(self : FrameReport) -> Array[FrameViolation]

#
FrameReport::wire_bits

source
fn FrameReport::wire_bits(self : FrameReport) -> Int

#
FrameViolation

source
pub enum FrameViolation {
  IdentifierRange
  ClassicPayloadRange
  FdPayloadRange
  RemoteCarriesData
  FdControlOnClassic
  InvalidErrorShape
  NonCanonicalDlc
} derive(
Debug)

A concrete validation finding.

#
GatewayPair

source
pub struct GatewayPair {
  left_to_right : CanGateway
  right_to_left : CanGateway
}

Create a bidirectional bridge from two gateways.

#
GatewayPair::left

source
fn GatewayPair::left(self : GatewayPair) -> CanGateway

#
GatewayPair::right

source
fn GatewayPair::right(self : GatewayPair) -> CanGateway

#
GatewayPolicyAudit

source
pub struct GatewayPolicyAudit {
  timestamp_us : UInt64
  rule_name : String
  source_channel : String
  destination_channel : String
  decision : GatewayPolicyDecision
  input_id : UInt
  output_id : UInt?
}

An immutable audit record produced by the policy engine.

#
GatewayPolicyAudit::decision

source

#
GatewayPolicyAudit::destination_channel

source
fn GatewayPolicyAudit::destination_channel(self : GatewayPolicyAudit) -> String

#
GatewayPolicyAudit::input_id

source
fn GatewayPolicyAudit::input_id(self : GatewayPolicyAudit) -> UInt

#
GatewayPolicyAudit::output_id

source
fn GatewayPolicyAudit::output_id(self : GatewayPolicyAudit) -> UInt?

#
GatewayPolicyAudit::rule_name

source
fn GatewayPolicyAudit::rule_name(self : GatewayPolicyAudit) -> String

#
GatewayPolicyAudit::source_channel

source
fn GatewayPolicyAudit::source_channel(self : GatewayPolicyAudit) -> String

#
GatewayPolicyAudit::timestamp_us

source
fn GatewayPolicyAudit::timestamp_us(self : GatewayPolicyAudit) -> UInt64

#
GatewayPolicyContext

source
pub struct GatewayPolicyContext {
  timestamp_us : UInt64
  source_channel : String
  destination_channel : String
  frame : Frame
}

A policy evaluation context used for audit and rate limiting.

#
GatewayPolicyContext::destination_channel

source
fn GatewayPolicyContext::destination_channel(self : GatewayPolicyContext) -> String

#
GatewayPolicyContext::frame

source

#
GatewayPolicyContext::source_channel

source
fn GatewayPolicyContext::source_channel(self : GatewayPolicyContext) -> String

#
GatewayPolicyContext::timestamp_us

source
fn GatewayPolicyContext::timestamp_us(self : GatewayPolicyContext) -> UInt64

#
GatewayPolicyDecision

source
pub enum GatewayPolicyDecision {
  GatewayPolicyAllow
  GatewayPolicyDeny(String)
  GatewayPolicyRewrite(Frame)
  GatewayPolicyRateLimited
}

Result of evaluating a gateway policy.

#
GatewayPolicyEngine

source
pub struct GatewayPolicyEngine {
  rules : Array[GatewayPolicyRule]
  audits : Array[GatewayPolicyAudit]
  capacity : Int
  evaluated : Int
  allowed : Int
  denied : Int
  rewritten : Int
  rate_limited : Int
}

An ordered, rate-limited gateway policy engine.

#
GatewayPolicyEngine::add_rule

source
fn GatewayPolicyEngine::add_rule(self : GatewayPolicyEngine, rule : GatewayPolicyRule) -> Bool

#
GatewayPolicyEngine::allowed

source
fn GatewayPolicyEngine::allowed(self : GatewayPolicyEngine) -> Int

#
GatewayPolicyEngine::audit_count

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

#
GatewayPolicyEngine::audits

source

#
GatewayPolicyEngine::denied

source
fn GatewayPolicyEngine::denied(self : GatewayPolicyEngine) -> Int

#
GatewayPolicyEngine::evaluate

source

#
GatewayPolicyEngine::evaluated

source
fn GatewayPolicyEngine::evaluated(self : GatewayPolicyEngine) -> Int

#
GatewayPolicyEngine::find

source
fn GatewayPolicyEngine::find(self : GatewayPolicyEngine, name : String) -> GatewayPolicyRule?

#
GatewayPolicyEngine::forward

source

#
GatewayPolicyEngine::rate_limited

source
fn GatewayPolicyEngine::rate_limited(self : GatewayPolicyEngine) -> Int

#
GatewayPolicyEngine::remove_rule

source
fn GatewayPolicyEngine::remove_rule(self : GatewayPolicyEngine, name : String) -> Bool

#
GatewayPolicyEngine::reset

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

#
GatewayPolicyEngine::rewritten

source
fn GatewayPolicyEngine::rewritten(self : GatewayPolicyEngine) -> Int

#
GatewayPolicyEngine::rules

source

#
GatewayPolicyEngine::to_text

source
fn GatewayPolicyEngine::to_text(self : GatewayPolicyEngine) -> String

#
GatewayPolicyRule

source
pub struct GatewayPolicyRule {
  name : String
  filter : Filter
  output_id : UInt?
  prefix : Array[Byte]
  max_payload : Int
  min_interval_us : UInt64
  allow_remote : Bool
  enabled : Bool
  hits : Int
  denied : Int
  last_timestamp_us : UInt64?
}

A policy rule for a gateway direction.

#
GatewayPolicyRule::allow_remote

source
fn GatewayPolicyRule::allow_remote(self : GatewayPolicyRule) -> Bool

#
GatewayPolicyRule::denied

source
fn GatewayPolicyRule::denied(self : GatewayPolicyRule) -> Int

#
GatewayPolicyRule::enabled

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

#
GatewayPolicyRule::filter

source

#
GatewayPolicyRule::hits

source
fn GatewayPolicyRule::hits(self : GatewayPolicyRule) -> Int

#
GatewayPolicyRule::matches

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

#
GatewayPolicyRule::max_payload

source
fn GatewayPolicyRule::max_payload(self : GatewayPolicyRule) -> Int

#
GatewayPolicyRule::min_interval_us

source
fn GatewayPolicyRule::min_interval_us(self : GatewayPolicyRule) -> UInt64

#
GatewayPolicyRule::name

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

#
GatewayPolicyRule::output_id

source
fn GatewayPolicyRule::output_id(self : GatewayPolicyRule) -> UInt?

#
GatewayPolicyRule::prefix

source
fn GatewayPolicyRule::prefix(self : GatewayPolicyRule) -> Array[Byte]

#
GatewayPolicyRule::rewrite

source
fn GatewayPolicyRule::rewrite(self : GatewayPolicyRule, frame : Frame) -> Frame raise FrameError

Apply the rewrite portion of a gateway policy rule.

#
GatewayPolicyRule::set_enabled

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

#
IsoTpChannel

source
pub struct IsoTpChannel {
  source_id : UInt
  target_id : UInt
  extended : Bool
  addressing : IsoTpSessionAddressing
  flow_control : IsoTpFlowControlConfig
}

An ISO-TP channel identity used by a transport router.

#
IsoTpChannel::accepts

source
fn IsoTpChannel::accepts(self : IsoTpChannel, frame : Frame) -> Bool

Return whether a frame identifier belongs to a channel.

#
IsoTpChannel::addressing

source

#
IsoTpChannel::extended

source
fn IsoTpChannel::extended(self : IsoTpChannel) -> Bool

#
IsoTpChannel::flow_control

source

#
IsoTpChannel::frame

source
fn IsoTpChannel::frame(self : IsoTpChannel, payload : Array[Byte], transmit : Bool) -> Frame raise FrameError

Build a CAN frame carrying an ISO-TP payload.

#
IsoTpChannel::source_id

source
fn IsoTpChannel::source_id(self : IsoTpChannel) -> UInt

#
IsoTpChannel::target_id

source
fn IsoTpChannel::target_id(self : IsoTpChannel) -> UInt

#
IsoTpConfig

source
pub struct IsoTpConfig {
  frame_bytes : Int
  block_size : Byte
  separation_time : Byte
}

ISO-TP transfer parameters for classic CAN and CAN-FD.

#
IsoTpConfig::block_size

source
fn IsoTpConfig::block_size(self : IsoTpConfig) -> Byte

#
IsoTpConfig::frame_bytes

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

#
IsoTpConfig::separation_time

source
fn IsoTpConfig::separation_time(self : IsoTpConfig) -> Byte

#
IsoTpFlowControlConfig

source
pub struct IsoTpFlowControlConfig {
  block_size : Int
  separation_time_us : UInt64
  wait_frame_limit : Int
  max_payload : Int
}

Flow-control parameters advertised by a receiver.

#
IsoTpFlowControlConfig::block_size

source
fn IsoTpFlowControlConfig::block_size(self : IsoTpFlowControlConfig) -> Int

#
IsoTpFlowControlConfig::max_payload

source
fn IsoTpFlowControlConfig::max_payload(self : IsoTpFlowControlConfig) -> Int

#
IsoTpFlowControlConfig::separation_time_us

source
fn IsoTpFlowControlConfig::separation_time_us(self : IsoTpFlowControlConfig) -> UInt64

#
IsoTpFlowControlConfig::to_payload

source
fn IsoTpFlowControlConfig::to_payload(self : IsoTpFlowControlConfig) -> Array[Byte]

Return the wire representation of a flow-control frame.

#
IsoTpFlowControlConfig::wait_frame_limit

source
fn IsoTpFlowControlConfig::wait_frame_limit(self : IsoTpFlowControlConfig) -> Int

#
IsoTpPacket

source
pub enum IsoTpPacket {
  Single(payload~ : Array[Byte])
  First(total_length~ : Int, payload~ : Array[Byte])
  Consecutive(sequence~ : Byte, payload~ : Array[Byte])
  FlowControl(status~ : Byte, block_size~ : Byte, separation_time~ : Byte)
}

A decoded ISO-TP packet.

#
IsoTpReceiver

source
pub struct IsoTpReceiver {
  config : IsoTpConfig
  total_length : Int
  payload : Array[Byte]
  next_sequence : Byte
  block_count : Int
}

An incremental ISO-TP receiver for a single outstanding transfer.

#
IsoTpReceiver::flow_control

source
fn IsoTpReceiver::flow_control(self : IsoTpReceiver) -> Array[Byte]

Return a flow-control packet for this receiver's configured limits.

#
IsoTpReceiver::push

source
fn IsoTpReceiver::push(self : IsoTpReceiver, packet : IsoTpPacket) -> IsoTpStatus raise IsoTpError

Feed one decoded packet into the receiver.

#
IsoTpReceiver::reset

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

Clear the current transfer.

#
IsoTpReceiverResult

source
pub enum IsoTpReceiverResult {
  IsoTpRxIgnored
  IsoTpRxFlowControl(Array[Byte])
  IsoTpRxProgress(Int)
  IsoTpRxComplete(Array[Byte])
  IsoTpRxError(String)
}

A receiver result for an incoming ISO-TP payload.

#
IsoTpRouter

source
pub struct IsoTpRouter {
  channels : Array[IsoTpChannel]
  accepted : Int
  rejected : Int
}

A bounded transport router for multiple diagnostic channels.

#
IsoTpRouter::accepted

source
fn IsoTpRouter::accepted(self : IsoTpRouter) -> Int

#
IsoTpRouter::add_channel

source
fn IsoTpRouter::add_channel(self : IsoTpRouter, channel : IsoTpChannel) -> Bool

#
IsoTpRouter::channels

source
fn IsoTpRouter::channels(self : IsoTpRouter) -> Array[IsoTpChannel]

#
IsoTpRouter::find_channel

source
fn IsoTpRouter::find_channel(self : IsoTpRouter, source_id : UInt, target_id : UInt) -> IsoTpChannel?

#
IsoTpRouter::rejected

source
fn IsoTpRouter::rejected(self : IsoTpRouter) -> Int

#
IsoTpRouter::remove_channel

source
fn IsoTpRouter::remove_channel(self : IsoTpRouter, source_id : UInt, target_id : UInt) -> Bool

#
IsoTpRouter::route

source
fn IsoTpRouter::route(self : IsoTpRouter, frame : Frame) -> IsoTpChannel?

#
IsoTpSession

source
pub struct IsoTpSession {
  transmitter : IsoTpTransmitter?
  receiver : IsoTpStreamReceiver
  sent_frames : Int
  received_frames : Int
  dropped_frames : Int
}

A transport exchange combining a transmitter and receiver.

#
IsoTpSession::accept_flow_control

source
fn IsoTpSession::accept_flow_control(self : IsoTpSession, payload : Array[Byte], timestamp_us : UInt64) -> Bool

#
IsoTpSession::dropped_frames

source
fn IsoTpSession::dropped_frames(self : IsoTpSession) -> Int

#
IsoTpSession::next_transmit

source
fn IsoTpSession::next_transmit(self : IsoTpSession, timestamp_us : UInt64) -> Array[Byte]?

#
IsoTpSession::receive

source
fn IsoTpSession::receive(self : IsoTpSession, payload : Array[Byte], timestamp_us : UInt64) -> IsoTpReceiverResult

#
IsoTpSession::received_frames

source
fn IsoTpSession::received_frames(self : IsoTpSession) -> Int

#
IsoTpSession::receiver

source

#
IsoTpSession::sent_frames

source
fn IsoTpSession::sent_frames(self : IsoTpSession) -> Int

#
IsoTpSession::start_transmit

source
fn IsoTpSession::start_transmit(self : IsoTpSession, payload : Array[Byte], timestamp_us : UInt64) -> Unit

#
IsoTpSession::transmitter

source
fn IsoTpSession::transmitter(self : IsoTpSession) -> IsoTpTransmitter?

#
IsoTpSessionAddressing

source
pub enum IsoTpSessionAddressing {
  IsoTpNormalAddressing
  IsoTpExtendedAddressing(Byte)
  IsoTpMixedAddressing(Byte)
}

ISO-TP addressing format for a diagnostic transport channel.

#
IsoTpStatus

source
pub enum IsoTpStatus {
  Waiting(received~ : Int, total~ : Int)
  Complete(payload~ : Array[Byte])
}

The state of an incremental receiver.

#
IsoTpStreamReceiver

source
pub struct IsoTpStreamReceiver {
  expected_length : Int
  received : Array[Byte]
  next_sequence : Byte
  block_received : Int
  wait_frames : Int
  last_timestamp_us : UInt64
  active : Bool
  complete : Bool
  flow_control : IsoTpFlowControlConfig
  timeout_us : UInt64
}

A stateful ISO-TP receiver.

#
IsoTpStreamReceiver::active

source
fn IsoTpStreamReceiver::active(self : IsoTpStreamReceiver) -> Bool

#
IsoTpStreamReceiver::complete

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

#
IsoTpStreamReceiver::expected_length

source
fn IsoTpStreamReceiver::expected_length(self : IsoTpStreamReceiver) -> Int

#
IsoTpStreamReceiver::feed

source
fn IsoTpStreamReceiver::feed(self : IsoTpStreamReceiver, payload : Array[Byte], timestamp_us : UInt64) -> IsoTpReceiverResult

Feed a complete ISO-TP payload received from the bus.

#
IsoTpStreamReceiver::last_timestamp_us

source
fn IsoTpStreamReceiver::last_timestamp_us(self : IsoTpStreamReceiver) -> UInt64

#
IsoTpStreamReceiver::next_sequence

source
fn IsoTpStreamReceiver::next_sequence(self : IsoTpStreamReceiver) -> Byte

#
IsoTpStreamReceiver::payload

source
fn IsoTpStreamReceiver::payload(self : IsoTpStreamReceiver) -> Array[Byte]

#
IsoTpStreamReceiver::received_length

source
fn IsoTpStreamReceiver::received_length(self : IsoTpStreamReceiver) -> Int

#
IsoTpStreamReceiver::remaining

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

#
IsoTpStreamReceiver::reset

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

Reset a receiver to accept a new transfer.

#
IsoTpStreamReceiver::take_payload

source
fn IsoTpStreamReceiver::take_payload(self : IsoTpStreamReceiver) -> Array[Byte]?

Take the completed payload and reset the receiver.

#
IsoTpStreamReceiver::timed_out

source
fn IsoTpStreamReceiver::timed_out(self : IsoTpStreamReceiver, timestamp_us : UInt64) -> Bool

Return whether a receiver transfer has timed out.

#
IsoTpTransmitter

source
pub struct IsoTpTransmitter {
  payload : Array[Byte]
  offset : Int
  sequence : Byte
  block_sent : Int
  wait_frames : Int
  state : IsoTpTransmitterState
  flow_control : IsoTpFlowControlConfig
  next_due_us : UInt64
  started_us : UInt64
}

A stateful ISO-TP transmitter.

#
IsoTpTransmitter::abort

source
fn IsoTpTransmitter::abort(self : IsoTpTransmitter, reason : String) -> Unit

Abort a transmitter with a stable reason.

#
IsoTpTransmitter::accept_flow_control

source
fn IsoTpTransmitter::accept_flow_control(self : IsoTpTransmitter, payload : Array[Byte], timestamp_us : UInt64) -> Bool

Accept a receiver flow-control payload.

#
IsoTpTransmitter::estimated_finish_us

source
fn IsoTpTransmitter::estimated_finish_us(self : IsoTpTransmitter) -> UInt64

Return an upper bound for the remaining transfer duration.

#
IsoTpTransmitter::is_aborted

source
fn IsoTpTransmitter::is_aborted(self : IsoTpTransmitter) -> Bool

#
IsoTpTransmitter::is_complete

source
fn IsoTpTransmitter::is_complete(self : IsoTpTransmitter) -> Bool

#
IsoTpTransmitter::next_due_us

source
fn IsoTpTransmitter::next_due_us(self : IsoTpTransmitter) -> UInt64

#
IsoTpTransmitter::next_payload

source
fn IsoTpTransmitter::next_payload(self : IsoTpTransmitter, timestamp_us : UInt64) -> Array[Byte]?

Produce the next ISO-TP payload when the transmitter is due.

#
IsoTpTransmitter::offset

source
fn IsoTpTransmitter::offset(self : IsoTpTransmitter) -> Int

#
IsoTpTransmitter::payload

source
fn IsoTpTransmitter::payload(self : IsoTpTransmitter) -> Array[Byte]

#
IsoTpTransmitter::remaining

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

#
IsoTpTransmitter::sequence

source
fn IsoTpTransmitter::sequence(self : IsoTpTransmitter) -> Byte

#
IsoTpTransmitter::started_us

source
fn IsoTpTransmitter::started_us(self : IsoTpTransmitter) -> UInt64

#
IsoTpTransmitter::state

source

#
IsoTpTransmitterState

source
pub enum IsoTpTransmitterState {
  IsoTpTxIdle
  IsoTpTxWaitingFlowControl
  IsoTpTxSending
  IsoTpTxComplete
  IsoTpTxAborted(String)
}

State of a long-payload ISO-TP transmitter.

#
J1939AddressClaim

source
pub struct J1939AddressClaim {
  source_address : Byte
  name : UInt64
  manufacturer : UInt
  function : Byte
  instance : Byte
  last_seen_us : UInt64
  preferred : Bool
}

A J1939 address-claim record.

#
J1939AddressClaim::function

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

#
J1939AddressClaim::instance

source
fn J1939AddressClaim::instance(self : J1939AddressClaim) -> Byte

#
J1939AddressClaim::last_seen_us

source
fn J1939AddressClaim::last_seen_us(self : J1939AddressClaim) -> UInt64

#
J1939AddressClaim::manufacturer

source
fn J1939AddressClaim::manufacturer(self : J1939AddressClaim) -> UInt

#
J1939AddressClaim::name

source
fn J1939AddressClaim::name(self : J1939AddressClaim) -> UInt64

#
J1939AddressClaim::preferred

source
fn J1939AddressClaim::preferred(self : J1939AddressClaim) -> Bool

#
J1939AddressClaim::refresh

source
fn J1939AddressClaim::refresh(self : J1939AddressClaim, timestamp_us : UInt64) -> Unit

#
J1939AddressClaim::set_preferred

source
fn J1939AddressClaim::set_preferred(self : J1939AddressClaim, preferred : Bool) -> Unit

#
J1939AddressClaim::source_address

source
fn J1939AddressClaim::source_address(self : J1939AddressClaim) -> Byte

#
J1939AddressClaim::wire_name

source
fn J1939AddressClaim::wire_name(self : J1939AddressClaim) -> Array[Byte]

#
J1939AddressManager

source
pub struct J1939AddressManager {
  claims : Array[J1939AddressClaim]
  conflicts : Int
  changes : Int
  timeout_us : UInt64
}

Address-claim table with deterministic conflict resolution.

#
J1939AddressManager::changes

source
fn J1939AddressManager::changes(self : J1939AddressManager) -> Int

#
J1939AddressManager::claim

source
fn J1939AddressManager::claim(self : J1939AddressManager, claim : J1939AddressClaim) -> Bool

#
J1939AddressManager::claims

source

#
J1939AddressManager::conflicts

source
fn J1939AddressManager::conflicts(self : J1939AddressManager) -> Int

#
J1939AddressManager::expire

source
fn J1939AddressManager::expire(self : J1939AddressManager, timestamp_us : UInt64) -> Int

#
J1939AddressManager::find

source
fn J1939AddressManager::find(self : J1939AddressManager, source_address : Byte) -> J1939AddressClaim?

#
J1939AddressManager::refresh

source
fn J1939AddressManager::refresh(self : J1939AddressManager, source_address : Byte, timestamp_us : UInt64) -> Bool

#
J1939Id

source
pub struct J1939Id {
  priority : Byte
  data_page : Bool
  pdu_format : Byte
  pdu_specific : Byte
  source_address : Byte
}

A decoded 29-bit J1939 identifier.

#
J1939Id::data_page

source
fn J1939Id::data_page(self : J1939Id) -> Bool

#
J1939Id::destination

source
fn J1939Id::destination(self : J1939Id) -> Byte?

#
J1939Id::pdu_format

source
fn J1939Id::pdu_format(self : J1939Id) -> Byte

#
J1939Id::pdu_specific

source
fn J1939Id::pdu_specific(self : J1939Id) -> Byte

#
J1939Id::pgn

source
fn J1939Id::pgn(self : J1939Id) -> UInt

Return the PGN, omitting destination address for PDU1 messages.

#
J1939Id::priority

source
fn J1939Id::priority(self : J1939Id) -> Byte

#
J1939Id::source

source
fn J1939Id::source(self : J1939Id) -> Byte

The source address of a J1939 message.

#
J1939Message

source
pub struct J1939Message {
  identifier : J1939Id
  payload : Array[Byte]
}

A J1939 application payload with its decoded identifier.

#
J1939Message::identifier

source
fn J1939Message::identifier(self : J1939Message) -> J1939Id

#
J1939Message::payload

source
fn J1939Message::payload(self : J1939Message) -> Array[Byte]

#
J1939Message::to_frame

source
fn J1939Message::to_frame(self : J1939Message) -> Frame raise FrameError

Create a data frame from a J1939 message.

#
J1939SpnDefinition

source
pub struct J1939SpnDefinition {
  spn : UInt
  name : String
  start_bit : Int
  length : Int
  factor : Double
  offset : Double
  minimum : Double
  maximum : Double
  unit : String
}

A scale and offset definition for a J1939 SPN.

#
J1939SpnDefinition::decode

source
fn J1939SpnDefinition::decode(self : J1939SpnDefinition, data : Array[Byte]) -> Double

#
J1939SpnDefinition::encode

source
fn J1939SpnDefinition::encode(self : J1939SpnDefinition, data : Array[Byte], value : Double) -> Array[Byte]

#
J1939SpnDefinition::factor

source
fn J1939SpnDefinition::factor(self : J1939SpnDefinition) -> Double

#
J1939SpnDefinition::length

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

#
J1939SpnDefinition::name

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

#
J1939SpnDefinition::offset

source
fn J1939SpnDefinition::offset(self : J1939SpnDefinition) -> Double

#
J1939SpnDefinition::spn

source
fn J1939SpnDefinition::spn(self : J1939SpnDefinition) -> UInt

#
J1939SpnDefinition::start_bit

source
fn J1939SpnDefinition::start_bit(self : J1939SpnDefinition) -> Int

#
J1939SpnDefinition::unit

source
fn J1939SpnDefinition::unit(self : J1939SpnDefinition) -> String

#
J1939TransportDirection

source
pub enum J1939TransportDirection {
  J1939TransportTransmit
  J1939TransportReceive
}

Direction of a J1939 transport-protocol session.

#
J1939TransportSession

source
pub struct J1939TransportSession {
  pgn : UInt
  direction : J1939TransportDirection
  total_length : Int
  packet_count : Int
  payload : Array[Byte]
  next_sequence : Int
  state : J1939TransportState
  last_timestamp_us : UInt64
  timeout_us : UInt64
  retries : Int
}

A stateful J1939 transport-protocol transfer.

#
J1939TransportSession::accept_announcement

source
fn J1939TransportSession::accept_announcement(self : J1939TransportSession, announcement : Array[Byte], timestamp_us : UInt64) -> Bool

Accept a BAM announcement for a receive session.

#
J1939TransportSession::accept_packet

source
fn J1939TransportSession::accept_packet(self : J1939TransportSession, packet : Array[Byte], timestamp_us : UInt64) -> Bool

Accept one TP.DT packet and return whether it advanced the transfer.

#
J1939TransportSession::complete

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

#
J1939TransportSession::direction

source

#
J1939TransportSession::last_timestamp_us

source
fn J1939TransportSession::last_timestamp_us(self : J1939TransportSession) -> UInt64

#
J1939TransportSession::next_sequence

source
fn J1939TransportSession::next_sequence(self : J1939TransportSession) -> Int

#
J1939TransportSession::packet_count

source
fn J1939TransportSession::packet_count(self : J1939TransportSession) -> Int

#
J1939TransportSession::payload

source

#
J1939TransportSession::pgn

source

#
J1939TransportSession::received_length

source
fn J1939TransportSession::received_length(self : J1939TransportSession) -> Int

#
J1939TransportSession::retries

source
fn J1939TransportSession::retries(self : J1939TransportSession) -> Int

#
J1939TransportSession::start_transmit

source
fn J1939TransportSession::start_transmit(self : J1939TransportSession, payload : Array[Byte], timestamp_us : UInt64) -> Array[Array[Byte]] raise J1939Error

Start a BAM transfer and generate the announcement and data packets.

#
J1939TransportSession::state

source

#
J1939TransportSession::take_payload

source
fn J1939TransportSession::take_payload(self : J1939TransportSession) -> Array[Byte]?

#
J1939TransportSession::timed_out

source
fn J1939TransportSession::timed_out(self : J1939TransportSession, timestamp_us : UInt64) -> Bool

#
J1939TransportSession::total_length

source
fn J1939TransportSession::total_length(self : J1939TransportSession) -> Int

#
J1939TransportState

source
pub enum J1939TransportState {
  J1939TransportIdle
  J1939TransportAnnounced
  J1939TransportTransferring
  J1939TransportComplete
  J1939TransportTimedOut
  J1939TransportAborted
}

State of a J1939 BAM or TP.DT transfer.

#
LatencySample

source
pub struct LatencySample {
  sequence : UInt
  created_us : UInt64
  completed_us : UInt64
  payload_bytes : Int
}

One completed request/response timing sample.

#
LatencySample::completed_at

source
fn LatencySample::completed_at(self : LatencySample) -> UInt64

#
LatencySample::created_at

source
fn LatencySample::created_at(self : LatencySample) -> UInt64

#
LatencySample::duration

source
fn LatencySample::duration(self : LatencySample) -> UInt64

#
LatencySample::payload_bytes

source
fn LatencySample::payload_bytes(self : LatencySample) -> Int

#
LatencySample::sequence

source
fn LatencySample::sequence(self : LatencySample) -> UInt

#
LatencyStats

source
pub struct LatencyStats {
  count : Int
  minimum_us : UInt64?
  maximum_us : UInt64?
  average_us : Double
  p95_us : UInt64?
  jitter_us : UInt64
  payload_bytes : Int
}

A summary of samples currently retained by a latency window.

#
LatencyStats::average

source
fn LatencyStats::average(self : LatencyStats) -> Double

#
LatencyStats::count

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

#
LatencyStats::has_data

source
fn LatencyStats::has_data(self : LatencyStats) -> Bool

#
LatencyStats::jitter

source
fn LatencyStats::jitter(self : LatencyStats) -> UInt64

#
LatencyStats::maximum

source
fn LatencyStats::maximum(self : LatencyStats) -> UInt64?

#
LatencyStats::minimum

source
fn LatencyStats::minimum(self : LatencyStats) -> UInt64?

#
LatencyStats::p95

source
fn LatencyStats::p95(self : LatencyStats) -> UInt64?

#
LatencyStats::payload_bytes

source
fn LatencyStats::payload_bytes(self : LatencyStats) -> Int

#
LatencyStats::throughput_bytes_per_second

source
fn LatencyStats::throughput_bytes_per_second(self : LatencyStats, duration_us : UInt64) -> Double

Calculate payload throughput over an observation interval.

#
LatencyStats::to_text

source
fn LatencyStats::to_text(self : LatencyStats) -> String

Render a compact, stable summary for benchmark artifacts.

#
LatencyWindow

source
pub struct LatencyWindow {
  capacity : Int
  next_sequence : UInt
  samples : Array[LatencySample]
  last_completed_us : UInt64?
}

A bounded rolling timing window for transport and diagnostic paths.

#
LatencyWindow::capacity

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

#
LatencyWindow::is_empty

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

#
LatencyWindow::latest

source

Return the newest retained sample, if any.

#
LatencyWindow::length

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

#
LatencyWindow::oldest

source

Return the oldest retained sample, if any.

#
LatencyWindow::percentile

source
fn LatencyWindow::percentile(self : LatencyWindow, percent : Int) -> UInt64 raise LatencyError

Return an arbitrary percentile using nearest-rank selection.

#
LatencyWindow::record

source
fn LatencyWindow::record(self : LatencyWindow, created_us : UInt64, completed_us : UInt64, payload_bytes : Int) -> UInt raise LatencyError

Record a completed sample and return its sequence number.

#
LatencyWindow::samples

source

#
LatencyWindow::stats

source

Calculate a stable summary of the retained timing samples.

#
Message

source
pub struct Message {
  id : UInt
  name : String
  dlc : Int
  signals : Array[Signal]
}

A CAN message with named signals.

#
Message::add_signal

source
fn Message::add_signal(self : Message, item : Signal) -> Unit

Add a signal to a message.

#
Message::decode

source
fn Message::decode(self : Message, data : Array[Byte]) -> DecodedMessage raise DbcRuntimeError

Decode all signals in a payload.

#
Message::dlc

source
fn Message::dlc(self : Message) -> Int

The configured payload length.

#
Message::encode_frame

source
fn Message::encode_frame(self : Message, values : Map[String, Double], extended? : Bool) -> Frame raise DbcRuntimeError

Encode a message definition and values as a CAN frame.

#
Message::encode_values

source
fn Message::encode_values(self : Message, values : Map[String, Double], initial? : Array[Byte]) -> Array[Byte] raise DbcRuntimeError

Encode physical signal values into a message payload.

#
Message::find

source
fn Message::find(self : Message, name : String) -> Signal?

Find a signal by name.

#
Message::id

source
fn Message::id(self : Message) -> UInt

The message identifier.

#
Message::name

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

The message name.

#
Message::required_bytes

source
fn Message::required_bytes(self : Message) -> Int

Return a message's maximum configured bit end.

#
Message::schema_text

source
fn Message::schema_text(self : Message) -> String

Return a stable schema summary for tooling.

#
Message::signal_count

source
fn Message::signal_count(self : Message) -> Int

Return the number of defined signals.

#
Message::signals

source
fn Message::signals(self : Message) -> Array[Signal]

Return signal definitions in source order.

#
Message::signals_by_start_bit

source
fn Message::signals_by_start_bit(self : Message) -> Array[Signal]

Return a message's signals ordered by start bit.

#
Message::validate

source
fn Message::validate(self : Message) -> Bool

Validate message size and all signal bit ranges.

#
NetworkDelivery

source
pub struct NetworkDelivery {
  timestamp_us : UInt64
  sender : Byte
  frame : Frame
  recipients : Array[String]
}

One broadcast delivery produced by CanNetwork::poll.

#
NetworkDelivery::frame

source

#
NetworkDelivery::recipients

source
fn NetworkDelivery::recipients(self : NetworkDelivery) -> Array[String]

#
NetworkDelivery::sender

source
fn NetworkDelivery::sender(self : NetworkDelivery) -> Byte

#
NetworkDelivery::timestamp

source
fn NetworkDelivery::timestamp(self : NetworkDelivery) -> UInt64

#
NetworkErrorBudget

source
pub struct NetworkErrorBudget {
  max_error_rate : Double
  max_drop_rate : Double
  max_offline_nodes : Int
  total_frames : Int
  error_frames : Int
  dropped_frames : Int
  offline_nodes : Int
}

An error budget for a production CAN network.

#
NetworkErrorBudget::drop_rate

source
fn NetworkErrorBudget::drop_rate(self : NetworkErrorBudget) -> Double

#
NetworkErrorBudget::dropped_frames

source
fn NetworkErrorBudget::dropped_frames(self : NetworkErrorBudget) -> Int

#
NetworkErrorBudget::error_frames

source
fn NetworkErrorBudget::error_frames(self : NetworkErrorBudget) -> Int

#
NetworkErrorBudget::error_rate

source
fn NetworkErrorBudget::error_rate(self : NetworkErrorBudget) -> Double

#
NetworkErrorBudget::max_drop_rate

source
fn NetworkErrorBudget::max_drop_rate(self : NetworkErrorBudget) -> Double

#
NetworkErrorBudget::max_error_rate

source
fn NetworkErrorBudget::max_error_rate(self : NetworkErrorBudget) -> Double

#
NetworkErrorBudget::offline_nodes

source
fn NetworkErrorBudget::offline_nodes(self : NetworkErrorBudget) -> Int

#
NetworkErrorBudget::record_frame

source
fn NetworkErrorBudget::record_frame(self : NetworkErrorBudget, error : Bool, dropped : Bool) -> Unit

#
NetworkErrorBudget::set_offline_nodes

source
fn NetworkErrorBudget::set_offline_nodes(self : NetworkErrorBudget, count : Int) -> Unit

#
NetworkErrorBudget::total_frames

source
fn NetworkErrorBudget::total_frames(self : NetworkErrorBudget) -> Int

#
NetworkErrorBudget::within_budget

source
fn NetworkErrorBudget::within_budget(self : NetworkErrorBudget) -> Bool

#
NetworkHealthReport

source
pub struct NetworkHealthReport {
  timestamp_us : UInt64
  nodes : Array[NetworkNodeHealth]
  online : Int
  degraded : Int
  offline : Int
  budget : NetworkErrorBudget
}

A summary of network health at one observation point.

#
NetworkHealthReport::budget

source

#
NetworkHealthReport::degraded

source
fn NetworkHealthReport::degraded(self : NetworkHealthReport) -> Int

#
NetworkHealthReport::healthy

source
fn NetworkHealthReport::healthy(self : NetworkHealthReport) -> Bool

#
NetworkHealthReport::nodes

source

#
NetworkHealthReport::offline

source
fn NetworkHealthReport::offline(self : NetworkHealthReport) -> Int

#
NetworkHealthReport::online

source
fn NetworkHealthReport::online(self : NetworkHealthReport) -> Int

#
NetworkHealthReport::timestamp_us

source
fn NetworkHealthReport::timestamp_us(self : NetworkHealthReport) -> UInt64

#
NetworkHealthReport::to_text

source
fn NetworkHealthReport::to_text(self : NetworkHealthReport) -> String

#
NetworkHealthTracker

source
pub struct NetworkHealthTracker {
  nodes : Array[NetworkNodeHealth]
  budget : NetworkErrorBudget
  samples : Int
  last_timestamp_us : UInt64
}

A fleet-level health tracker for virtual or hardware-connected nodes.

#
NetworkHealthTracker::add_node

source
fn NetworkHealthTracker::add_node(self : NetworkHealthTracker, node : NetworkNodeHealth) -> Bool

#
NetworkHealthTracker::budget

source

#
NetworkHealthTracker::find

source
fn NetworkHealthTracker::find(self : NetworkHealthTracker, node_id : Byte) -> NetworkNodeHealth?

#
NetworkHealthTracker::last_timestamp_us

source
fn NetworkHealthTracker::last_timestamp_us(self : NetworkHealthTracker) -> UInt64

#
NetworkHealthTracker::nodes

source

#
NetworkHealthTracker::observe_drop

source
fn NetworkHealthTracker::observe_drop(self : NetworkHealthTracker) -> Unit

#
NetworkHealthTracker::observe_error

source
fn NetworkHealthTracker::observe_error(self : NetworkHealthTracker, node_id : Byte) -> Bool

#
NetworkHealthTracker::observe_frame

source
fn NetworkHealthTracker::observe_frame(self : NetworkHealthTracker, node_id : Byte, timestamp_us : UInt64, frame : Frame, transmit : Bool) -> Bool

#
NetworkHealthTracker::observe_heartbeat

source
fn NetworkHealthTracker::observe_heartbeat(self : NetworkHealthTracker, node_id : Byte, timestamp_us : UInt64, latency_us? : UInt64) -> Bool

#
NetworkHealthTracker::poll

source
fn NetworkHealthTracker::poll(self : NetworkHealthTracker, timestamp_us : UInt64) -> NetworkHealthReport

#
NetworkHealthTracker::reset

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

#
NetworkHealthTracker::samples

source
fn NetworkHealthTracker::samples(self : NetworkHealthTracker) -> Int

#
NetworkNode

source
pub struct NetworkNode {
  node_id : Byte
  name : String
  last_seen_us : UInt64
  online : Bool
  transmitted : Int
  received : Int
}

A node registered with the network model.

#
NetworkNode::last_seen

source
fn NetworkNode::last_seen(self : NetworkNode) -> UInt64

#
NetworkNode::name

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

#
NetworkNode::node_id

source
fn NetworkNode::node_id(self : NetworkNode) -> Byte

#
NetworkNode::online

source
fn NetworkNode::online(self : NetworkNode) -> Bool

#
NetworkNode::received

source
fn NetworkNode::received(self : NetworkNode) -> Int

#
NetworkNode::transmitted

source
fn NetworkNode::transmitted(self : NetworkNode) -> Int

#
NetworkNodeHealth

source
pub struct NetworkNodeHealth {
  node_id : Byte
  name : String
  state : NetworkNodeHealthState
  last_seen_us : UInt64
  timeout_us : UInt64
  received : Int
  transmitted : Int
  errors : Int
  missed_heartbeats : Int
  latency_samples : Array[UInt64]
}

A node health sample with counters and timing.

#
NetworkNodeHealth::average_latency_us

source
fn NetworkNodeHealth::average_latency_us(self : NetworkNodeHealth) -> UInt64

#
NetworkNodeHealth::errors

source
fn NetworkNodeHealth::errors(self : NetworkNodeHealth) -> Int

#
NetworkNodeHealth::last_seen_us

source
fn NetworkNodeHealth::last_seen_us(self : NetworkNodeHealth) -> UInt64

#
NetworkNodeHealth::latency_samples

source
fn NetworkNodeHealth::latency_samples(self : NetworkNodeHealth) -> Array[UInt64]

#
NetworkNodeHealth::missed_heartbeats

source
fn NetworkNodeHealth::missed_heartbeats(self : NetworkNodeHealth) -> Int

#
NetworkNodeHealth::name

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

#
NetworkNodeHealth::node_id

source
fn NetworkNodeHealth::node_id(self : NetworkNodeHealth) -> Byte

#
NetworkNodeHealth::observe_error

source
fn NetworkNodeHealth::observe_error(self : NetworkNodeHealth) -> Unit

#
NetworkNodeHealth::observe_frame

source
fn NetworkNodeHealth::observe_frame(self : NetworkNodeHealth, timestamp_us : UInt64, transmit : Bool) -> Unit

#
NetworkNodeHealth::observe_heartbeat

source
fn NetworkNodeHealth::observe_heartbeat(self : NetworkNodeHealth, timestamp_us : UInt64, latency_us? : UInt64) -> Unit

#
NetworkNodeHealth::online

source
fn NetworkNodeHealth::online(self : NetworkNodeHealth) -> Bool

#
NetworkNodeHealth::p95_latency_us

source
fn NetworkNodeHealth::p95_latency_us(self : NetworkNodeHealth) -> UInt64

#
NetworkNodeHealth::poll

source
fn NetworkNodeHealth::poll(self : NetworkNodeHealth, timestamp_us : UInt64) -> NetworkNodeHealthState

#
NetworkNodeHealth::received

source
fn NetworkNodeHealth::received(self : NetworkNodeHealth) -> Int

#
NetworkNodeHealth::state

source

#
NetworkNodeHealth::timeout_us

source
fn NetworkNodeHealth::timeout_us(self : NetworkNodeHealth) -> UInt64

#
NetworkNodeHealth::to_text

source
fn NetworkNodeHealth::to_text(self : NetworkNodeHealth) -> String

#
NetworkNodeHealth::transmitted

source
fn NetworkNodeHealth::transmitted(self : NetworkNodeHealth) -> Int

#
NetworkNodeHealthState

source
pub enum NetworkNodeHealthState {
  NetworkNodeUnknown
  NetworkNodeHealthy
  NetworkNodeDegraded
  NetworkNodeOffline
  NetworkNodeMaintenance
}

Operational state used by a network health dashboard.

#
NodeRegistry

source
pub struct NodeRegistry {
  nodes : Array[CanNode]
}

A registry used by simulations and gateway applications.

#
NodeRegistry::deliver

source
fn NodeRegistry::deliver(self : NodeRegistry, frame : Frame) -> Array[String]

Deliver a frame to every matching registered node.

#
NodeRegistry::find

source
fn NodeRegistry::find(self : NodeRegistry, node_id : Byte) -> CanNode?

#
NodeRegistry::length

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

#
NodeRegistry::record_transmission

source
fn NodeRegistry::record_transmission(self : NodeRegistry, node_id : Byte) -> Unit raise NodeRegistryError

Record a transmission for a node.

#
NodeRegistry::register

source
fn NodeRegistry::register(self : NodeRegistry, node_id : Byte, name : String, filter : Filter) -> Unit raise NodeRegistryError

#
NodeRegistry::unregister

source
fn NodeRegistry::unregister(self : NodeRegistry, node_id : Byte) -> Unit raise NodeRegistryError

#
PayloadCodec

source
pub struct PayloadCodec {
  options : PayloadCodecOptions
  encoded : Int
  decoded : Int
  failures : Int
  next_counter : Byte
}

A reusable cyclic payload codec.

#
PayloadCodec::decode

source
fn PayloadCodec::decode(self : PayloadCodec, data : Array[Byte], expected_counter : Byte?) -> PayloadCodecResult

Decode and validate a received payload against the rolling counter.

#
PayloadCodec::decoded

source
fn PayloadCodec::decoded(self : PayloadCodec) -> Int

#
PayloadCodec::encode

source
fn PayloadCodec::encode(self : PayloadCodec, data : Array[Byte]) -> PayloadCodecResult

Encode a payload, setting the configured counter and integrity byte.

#
PayloadCodec::encoded

source
fn PayloadCodec::encoded(self : PayloadCodec) -> Int

#
PayloadCodec::failures

source
fn PayloadCodec::failures(self : PayloadCodec) -> Int

#
PayloadCodec::next_counter

source
fn PayloadCodec::next_counter(self : PayloadCodec) -> Byte

#
PayloadCodec::options

source

#
PayloadCodec::reset

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

#
PayloadCodecOptions

source
pub struct PayloadCodecOptions {
  profile : PayloadCodecProfile
  counter_offset : Int
  counter_high_nibble : Bool
  crc_offset : Int
  checksum_offset : Int
  expected_length : Int
  counter_modulus : Int
}

Codec layout options for a cyclic payload.

#
PayloadCodecOptions::checksum_offset

source
fn PayloadCodecOptions::checksum_offset(self : PayloadCodecOptions) -> Int

#
PayloadCodecOptions::counter_high_nibble

source
fn PayloadCodecOptions::counter_high_nibble(self : PayloadCodecOptions) -> Bool

#
PayloadCodecOptions::counter_modulus

source
fn PayloadCodecOptions::counter_modulus(self : PayloadCodecOptions) -> Int

#
PayloadCodecOptions::counter_offset

source
fn PayloadCodecOptions::counter_offset(self : PayloadCodecOptions) -> Int

#
PayloadCodecOptions::crc_offset

source
fn PayloadCodecOptions::crc_offset(self : PayloadCodecOptions) -> Int

#
PayloadCodecOptions::expected_length

source
fn PayloadCodecOptions::expected_length(self : PayloadCodecOptions) -> Int

#
PayloadCodecOptions::profile

source

#
PayloadCodecProfile

source
pub(all) enum PayloadCodecProfile {
  PayloadCodecPlain
  PayloadCodecCounterCrc
  PayloadCodecCounterChecksum
  PayloadCodecAliveAndCrc
}

Application payload profile used by a safety or control message.

#
PayloadCodecResult

source
pub struct PayloadCodecResult {
  status : PayloadCodecStatus
  data : Array[Byte]
  counter : Byte?
  expected_counter : Byte?
  checksum : Byte?
}

A codec result includes transformed data and validation state.

#
PayloadCodecResult::accepted

source
fn PayloadCodecResult::accepted(self : PayloadCodecResult) -> Bool

#
PayloadCodecResult::checksum

source
fn PayloadCodecResult::checksum(self : PayloadCodecResult) -> Byte?

#
PayloadCodecResult::counter

source
fn PayloadCodecResult::counter(self : PayloadCodecResult) -> Byte?

#
PayloadCodecResult::data

source
fn PayloadCodecResult::data(self : PayloadCodecResult) -> Array[Byte]

#
PayloadCodecResult::expected_counter

source
fn PayloadCodecResult::expected_counter(self : PayloadCodecResult) -> Byte?

#
PayloadCodecResult::status

source

#
PayloadCodecResult::to_text

source
fn PayloadCodecResult::to_text(self : PayloadCodecResult) -> String

#
PayloadCodecStatus

source
pub(all) enum PayloadCodecStatus {
  PayloadCodecAccepted
  PayloadCodecBadLength
  PayloadCodecBadCounter
  PayloadCodecBadCrc
  PayloadCodecBadChecksum
}

Result classification from a payload codec operation.

#
PdoMapEntry

source
pub struct PdoMapEntry {
  index : UInt
  sub_index : Byte
  bit_offset : Int
  bit_length : Int
}

One object-dictionary entry mapped into a PDO.

#
PdoMapEntry::bit_length

source
fn PdoMapEntry::bit_length(self : PdoMapEntry) -> Int

#
PdoMapEntry::bit_offset

source
fn PdoMapEntry::bit_offset(self : PdoMapEntry) -> Int

#
PdoMapEntry::index

source
fn PdoMapEntry::index(self : PdoMapEntry) -> UInt

#
PdoMapEntry::sub_index

source
fn PdoMapEntry::sub_index(self : PdoMapEntry) -> Byte

#
PdoMapping

source
pub struct PdoMapping {
  entries : Array[PdoMapEntry]
  payload_bytes : Int
}

A bit-packed PDO mapping.

#
PdoMapping::add

source
fn PdoMapping::add(self : PdoMapping, index : UInt, sub_index : Byte, bit_length : Int) -> Unit raise PdoError

Add a mapping entry at the next available bit offset.

#
PdoMapping::entries

source
fn PdoMapping::entries(self : PdoMapping) -> Array[PdoMapEntry]

#
PdoMapping::length

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

#
PdoMapping::pack

source
fn PdoMapping::pack(self : PdoMapping, values : Array[UInt]) -> Array[Byte] raise PdoError

Pack values in mapping order into a little-endian bit payload.

#
PdoMapping::payload_bytes

source
fn PdoMapping::payload_bytes(self : PdoMapping) -> Int

#
PdoMapping::unpack

source
fn PdoMapping::unpack(self : PdoMapping, data : Array[Byte]) -> Array[PdoValue] raise PdoError

Unpack all mapped values from a PDO payload.

#
PdoValue

source
pub struct PdoValue {
  index : UInt
  sub_index : Byte
  value : UInt
}

A decoded mapped value.

#
PdoValue::index

source
fn PdoValue::index(self : PdoValue) -> UInt

#
PdoValue::sub_index

source
fn PdoValue::sub_index(self : PdoValue) -> Byte

#
PdoValue::value

source
fn PdoValue::value(self : PdoValue) -> UInt

#
PeriodicPublisher

source
pub struct PeriodicPublisher {
  source : String
  frame : Frame
  period_us : UInt64
  remaining : Int
}

A periodic publisher registered with a simulation.

#
Pgn

source
pub struct Pgn {
  number : UInt
  name : String
  data_length : Int
}

A J1939 parameter group entry.

#
Pgn::name

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

Return the PGN label.

#
Pgn::number

source
fn Pgn::number(self : Pgn) -> UInt

Return the PGN number.

#
Protocol

source
pub enum Protocol {
  Can20
  CanFd
}

A CAN bus protocol version.

#
QueueItem

source
pub struct QueueItem {
  sequence : UInt
  channel : Byte
  frame : Frame
  enqueued_us : UInt64
  deadline_us : UInt64
}

A queued frame with timing and channel metadata.

#
QueueItem::channel

source
fn QueueItem::channel(self : QueueItem) -> Byte

#
QueueItem::deadline

source
fn QueueItem::deadline(self : QueueItem) -> UInt64

#
QueueItem::enqueued_at

source
fn QueueItem::enqueued_at(self : QueueItem) -> UInt64

#
QueueItem::frame

source
fn QueueItem::frame(self : QueueItem) -> Frame

#
QueueItem::sequence

source
fn QueueItem::sequence(self : QueueItem) -> UInt

#
RouteRule

source
pub struct RouteRule {
  name : String
  filter : Filter
  output_id : UInt?
  output_extended : Bool?
  prefix : Array[Byte]
  strip_prefix : Int
}

A deterministic one-way gateway rule.

#
RouteRule::name

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

Return a route's stable name.

#
RouteRule::prefix

source
fn RouteRule::prefix(self : RouteRule) -> Array[Byte]

Return the rule's payload prefix.

#
RoutedFrame

source
pub struct RoutedFrame {
  rule_name : String
  input_id : UInt
  frame : Frame
}

A frame accepted and transformed by a route.

#
RoutedFrame::frame

source
fn RoutedFrame::frame(self : RoutedFrame) -> Frame

#
RoutedFrame::input_id

source
fn RoutedFrame::input_id(self : RoutedFrame) -> UInt

#
RoutedFrame::rule_name

source
fn RoutedFrame::rule_name(self : RoutedFrame) -> String

#
ScheduledFrame

source
pub struct ScheduledFrame {
  timestamp_us : UInt64
  frame : Frame
  source : String
}

A frame scheduled for a simulated bus time.

#
ScheduledFrame::frame

source
fn ScheduledFrame::frame(self : ScheduledFrame) -> Frame

#
ScheduledFrame::source

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

#
ScheduledFrame::timestamp

source
fn ScheduledFrame::timestamp(self : ScheduledFrame) -> UInt64

#
SchedulerTick

source
pub struct SchedulerTick {
  timestamp_us : UInt64
  task_name : String
  frame : Frame
  late : Bool
}

A scheduler execution result.

#
SchedulerTick::frame

source
fn SchedulerTick::frame(self : SchedulerTick) -> Frame

#
SchedulerTick::is_late

source
fn SchedulerTick::is_late(self : SchedulerTick) -> Bool

#
SchedulerTick::task_name

source
fn SchedulerTick::task_name(self : SchedulerTick) -> String

#
SchedulerTick::timestamp

source
fn SchedulerTick::timestamp(self : SchedulerTick) -> UInt64

#
Signal

source
pub struct Signal {
  name : String
  start_bit : Int
  size : Int
  little_endian : Bool
  signed : Bool
  factor : Double
  offset : Double
  minimum : Double
  maximum : Double
  unit : String
}

A DBC signal description.

#
Signal::accepts

source
fn Signal::accepts(self : Signal, value : Double) -> Bool

Check a physical value against the configured range.

#
Signal::decode

source
fn Signal::decode(self : Signal, data : Array[Byte]) -> Double

Decode a physical value using factor and offset.

#
Signal::decode_physical

source
fn Signal::decode_physical(self : Signal, data : Array[Byte]) -> Double

Decode a physical value while honoring the DBC signedness flag.

#
Signal::decode_raw

source
fn Signal::decode_raw(self : Signal, data : Array[Byte]) -> UInt

Extract a raw signal value from a payload.

#
Signal::decode_signed

source
fn Signal::decode_signed(self : Signal, data : Array[Byte]) -> Int

Decode a signed raw value using the signal width.

#
Signal::encode

source
fn Signal::encode(self : Signal, data : Array[Byte], value : Double) -> Array[Byte]

Encode a physical value into a payload copy.

#
Signal::encode_raw

source
fn Signal::encode_raw(self : Signal, data : Array[Byte], value : UInt) -> Array[Byte]

Encode a raw value into a payload copy.

#
Signal::factor

source
fn Signal::factor(self : Signal) -> Double

#
Signal::has_range

source
fn Signal::has_range(self : Signal) -> Bool

Return the signal's inclusive physical range when configured.

#
Signal::is_signed

source
fn Signal::is_signed(self : Signal) -> Bool

Return whether this signal uses signed two's-complement values.

#
Signal::is_valid

source
fn Signal::is_valid(self : Signal, dlc : Int) -> Bool

Check whether a signal fits inside a payload of dlc bytes.

#
Signal::little_endian

source
fn Signal::little_endian(self : Signal) -> Bool

Return whether the signal uses Intel/little-endian bit ordering.

#
Signal::maximum

source
fn Signal::maximum(self : Signal) -> Double

#
Signal::minimum

source
fn Signal::minimum(self : Signal) -> Double

#
Signal::name

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

The signal name.

#
Signal::offset

source
fn Signal::offset(self : Signal) -> Double

#
Signal::raw_max

source
fn Signal::raw_max(self : Signal) -> UInt

Return the largest raw unsigned value representable by this signal.

#
Signal::size

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

Return the configured signal bit size.

#
Signal::start_bit

source
fn Signal::start_bit(self : Signal) -> Int

The signal's start bit.

#
Signal::unit

source
fn Signal::unit(self : Signal) -> String

#
Simulation

source
pub struct Simulation {
  now_us : UInt64
  bus : VirtualBus
  events : Array[ScheduledFrame]
  publishers : Array[PeriodicPublisher]
  trace : Trace
  scheduled : Int
  delivered : Int
  dropped : Int
  arbitration_bits : UInt64
  bitrate_kbps : UInt
}

A deterministic, single-threaded CAN network model.

#
Simulation::add_periodic

source
fn Simulation::add_periodic(self : Simulation, source : String, frame : Frame, first_timestamp_us : UInt64, period_us : UInt64, count : Int) -> Unit raise SimulationError

Register a periodic publisher and schedule its first event.

#
Simulation::bus

source
fn Simulation::bus(self : Simulation) -> VirtualBus

#
Simulation::now

source
fn Simulation::now(self : Simulation) -> UInt64

#
Simulation::pending_events

source
fn Simulation::pending_events(self : Simulation) -> Int

#
Simulation::receive

source
fn Simulation::receive(self : Simulation) -> Frame?

Drain the highest-priority frame ready at the current time.

#
Simulation::report

source
fn Simulation::report(self : Simulation, start_us : UInt64) -> SimulationReport

Return a summary of the run so far.

#
Simulation::run_steps

source
fn Simulation::run_steps(self : Simulation, limit : Int) -> Int raise SimulationError

Execute at most limit events.

#
Simulation::run_until

source
fn Simulation::run_until(self : Simulation, end_us : UInt64) -> Int raise SimulationError

Execute events up to an inclusive timestamp.

#
Simulation::schedule

source
fn Simulation::schedule(self : Simulation, timestamp_us : UInt64, frame : Frame, source? : String) -> Unit raise SimulationError

Schedule a frame at an absolute microsecond timestamp.

#
Simulation::step

source
fn Simulation::step(self : Simulation) -> ScheduledFrame?

Execute the next event and deliver it through the virtual bus.

#
Simulation::trace

source
fn Simulation::trace(self : Simulation) -> Trace

Return the captured trace.

#
SimulationReport

source
pub struct SimulationReport {
  start_us : UInt64
  end_us : UInt64
  scheduled : Int
  delivered : Int
  dropped : Int
  arbitration_bits : UInt64
}

Counters produced by a deterministic simulation run.

#
SimulationReport::arbitration_bits

source
fn SimulationReport::arbitration_bits(self : SimulationReport) -> UInt64

#
SimulationReport::delivered

source
fn SimulationReport::delivered(self : SimulationReport) -> Int

#
SimulationReport::dropped

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

#
SimulationReport::duration_us

source
fn SimulationReport::duration_us(self : SimulationReport) -> UInt64

#
SimulationReport::scheduled

source
fn SimulationReport::scheduled(self : SimulationReport) -> Int

#
SimulationScenario

source
pub struct SimulationScenario {
  name : String
  capacity : Int
  bitrate_kbps : UInt
  events : Array[SimulationScenarioEvent]
  assertions : Array[SimulationScenarioAssertion]
  state : SimulationScenarioState
}

A reusable deterministic scenario for ECU and gateway testing.

#
SimulationScenario::add_assertion

source
fn SimulationScenario::add_assertion(self : SimulationScenario, assertion : SimulationScenarioAssertion) -> Unit

#
SimulationScenario::assertions

source

#
SimulationScenario::bitrate_kbps

source
fn SimulationScenario::bitrate_kbps(self : SimulationScenario) -> UInt

#
SimulationScenario::capacity

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

#
SimulationScenario::clear

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

#
SimulationScenario::events

source

#
SimulationScenario::name

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

#
SimulationScenario::ready

source
fn SimulationScenario::ready(self : SimulationScenario) -> Bool

#
SimulationScenario::run

source

#
SimulationScenario::schedule

source
fn SimulationScenario::schedule(self : SimulationScenario, timestamp_us : UInt64, frame : Frame, source? : String) -> Bool

#
SimulationScenario::schedule_periodic

source
fn SimulationScenario::schedule_periodic(self : SimulationScenario, first_timestamp_us : UInt64, period_us : UInt64, count : Int, frame : Frame, source? : String) -> Bool

#
SimulationScenario::state

source

#
SimulationScenario::to_text

source
fn SimulationScenario::to_text(self : SimulationScenario) -> String

#
SimulationScenarioAssertion

source
pub enum SimulationScenarioAssertion {
  SimulationAssertDeliveredAtLeast(Int)
  SimulationAssertDroppedAtMost(Int)
  SimulationAssertDurationAtMost(UInt64)
  SimulationAssertIdentifierSeen(UInt)
  SimulationAssertHealth(BusHealthState)
}

An assertion applied to a completed simulation report.

#
SimulationScenarioEvent

source
pub struct SimulationScenarioEvent {
  timestamp_us : UInt64
  frame : Frame
  source : String
}

An event scheduled in a reusable simulation scenario.

#
SimulationScenarioEvent::frame

source

#
SimulationScenarioEvent::source

source

#
SimulationScenarioEvent::timestamp_us

source
fn SimulationScenarioEvent::timestamp_us(self : SimulationScenarioEvent) -> UInt64

#
SimulationScenarioResult

source
pub struct SimulationScenarioResult {
  name : String
  state : SimulationScenarioState
  report : SimulationReport
  assertions : Array[SimulationScenarioAssertion]
  failures : Array[String]
}

A result produced by running a scenario.

#
SimulationScenarioResult::assertions

source

#
SimulationScenarioResult::failures

source

#
SimulationScenarioResult::name

source

#
SimulationScenarioResult::passed

source

#
SimulationScenarioResult::report

source

#
SimulationScenarioResult::state

source

#
SimulationScenarioResult::to_text

source

#
SimulationScenarioState

source
pub enum SimulationScenarioState {
  SimulationScenarioDraft
  SimulationScenarioReady
  SimulationScenarioRunning
  SimulationScenarioPassed
  SimulationScenarioFailed
}

Lifecycle state of a deterministic simulation scenario.

#
Trace

source
pub struct Trace {
  entries : Array[TraceEntry]
}

An append-only trace that can be replayed deterministically.

#
Trace::between

source
fn Trace::between(self : Trace, start_us : UInt64, end_us : UInt64) -> Trace

Select entries in a closed timestamp interval.

#
Trace::entries

source
fn Trace::entries(self : Trace) -> Array[TraceEntry]

Return entries in capture order.

#
Trace::filter_id

source
fn Trace::filter_id(self : Trace, id : UInt) -> Trace

Select entries matching an identifier.

#
Trace::frames

source
fn Trace::frames(self : Trace) -> Array[Frame]

Return all frames in capture order.

#
Trace::length

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

Return the number of captured frames.

#
Trace::record

source
fn Trace::record(self : Trace, timestamp_us : UInt64, frame : Frame) -> Unit

Append a timestamped frame.

#
Trace::replay

source
fn Trace::replay(self : Trace, bus : VirtualBus) -> Int

Replay frames to a virtual bus, preserving capture order.

#
Trace::sorted

source
fn Trace::sorted(self : Trace) -> Trace

Return a capture-order copy sorted by timestamp and arbitration id.

#
Trace::time_range

source
fn Trace::time_range(self : Trace) -> (UInt64, UInt64)?

Return the first and last capture timestamps.

#
Trace::to_text

source
fn Trace::to_text(self : Trace) -> String

Encode a trace in a stable CSV-like text format.

#
Trace::validate

source
fn Trace::validate(self : Trace) -> Unit raise TraceError

Validate timestamps and frame invariants in capture order.

#
TraceDiff

source
pub struct TraceDiff {
  ordinal : Int
  kind : TraceDiffKind
  left : TraceQueryMatch?
  right : TraceQueryMatch?
}

#
TraceDiff::kind

source
fn TraceDiff::kind(self : TraceDiff) -> TraceDiffKind

#
TraceDiff::left

source
fn TraceDiff::left(self : TraceDiff) -> TraceQueryMatch?

#
TraceDiff::ordinal

source
fn TraceDiff::ordinal(self : TraceDiff) -> Int

#
TraceDiff::right

source
fn TraceDiff::right(self : TraceDiff) -> TraceQueryMatch?

#
TraceDiffKind

source
pub enum TraceDiffKind {
  TraceDiffMissingLeft
  TraceDiffMissingRight
  TraceDiffIdentifier
  TraceDiffPayload
  TraceDiffTimestamp
}

A difference between two captures at a matching ordinal.

#
TraceEntry

source
pub struct TraceEntry {
  timestamp_us : UInt64
  frame : Frame
}

A timestamped frame captured from a virtual bus.

#
TraceEntry::frame

source
fn TraceEntry::frame(self : TraceEntry) -> Frame

The captured frame.

#
TraceEntry::timestamp

source
fn TraceEntry::timestamp(self : TraceEntry) -> UInt64

The capture timestamp in microseconds.

#
TraceExportFormat

source
pub enum TraceExportFormat {
  TraceExportCanText
  TraceExportCsv
  TraceExportSummary
  TraceExportReplayScript
}

Stable output formats for trace artifacts.

#
TraceExportOptions

source
pub struct TraceExportOptions {
  format : TraceExportFormat
  include_channel : Bool
  include_sequence : Bool
  include_header : Bool
  normalize_timestamps : Bool
  max_rows : Int
}

Options controlling deterministic trace export.

#
TraceExportOptions::format

source

#
TraceExportOptions::include_channel

source
fn TraceExportOptions::include_channel(self : TraceExportOptions) -> Bool

#
TraceExportOptions::include_header

source
fn TraceExportOptions::include_header(self : TraceExportOptions) -> Bool

#
TraceExportOptions::include_sequence

source
fn TraceExportOptions::include_sequence(self : TraceExportOptions) -> Bool

#
TraceExportOptions::max_rows

source
fn TraceExportOptions::max_rows(self : TraceExportOptions) -> Int

#
TraceExportOptions::normalize_timestamps

source
fn TraceExportOptions::normalize_timestamps(self : TraceExportOptions) -> Bool

#
TraceExportRecord

source
pub struct TraceExportRecord {
  timestamp_us : UInt64
  sequence : Int
  channel : String
  frame : Frame
}

A line-level export record used by CSV and replay tools.

#
TraceExportRecord::channel

source
fn TraceExportRecord::channel(self : TraceExportRecord) -> String

#
TraceExportRecord::frame

source

#
TraceExportRecord::relative_to

source
fn TraceExportRecord::relative_to(self : TraceExportRecord, base : UInt64) -> UInt64

#
TraceExportRecord::sequence

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

#
TraceExportRecord::timestamp_us

source
fn TraceExportRecord::timestamp_us(self : TraceExportRecord) -> UInt64

#
TraceExporter

source
pub struct TraceExporter {
  options : TraceExportOptions
  records : Array[TraceExportRecord]
  rows : Int
  bytes : Int
  errors : Int
}

A stateful exporter that can be used incrementally by a logger.

#
TraceExporter::add

source
fn TraceExporter::add(self : TraceExporter, record : TraceExportRecord) -> Bool

#
TraceExporter::add_trace

source
fn TraceExporter::add_trace(self : TraceExporter, trace : Trace, channel? : String) -> Int

#
TraceExporter::bytes

source
fn TraceExporter::bytes(self : TraceExporter) -> Int

#
TraceExporter::errors

source
fn TraceExporter::errors(self : TraceExporter) -> Int

#
TraceExporter::records

source

#
TraceExporter::render

source
fn TraceExporter::render(self : TraceExporter) -> String

#
TraceExporter::rows

source
fn TraceExporter::rows(self : TraceExporter) -> Int

#
TraceQueryBucket

source
pub struct TraceQueryBucket {
  start_us : UInt64
  end_us : UInt64
  frames : Int
  payload_bytes : Int
  wire_bits : Int
}

A fixed time bucket for frame-rate and load dashboards.

#
TraceQueryBucket::end_us

source
fn TraceQueryBucket::end_us(self : TraceQueryBucket) -> UInt64

#
TraceQueryBucket::frames

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

#
TraceQueryBucket::payload_bytes

source
fn TraceQueryBucket::payload_bytes(self : TraceQueryBucket) -> Int

#
TraceQueryBucket::start_us

source
fn TraceQueryBucket::start_us(self : TraceQueryBucket) -> UInt64

#
TraceQueryBucket::utilization

source
fn TraceQueryBucket::utilization(self : TraceQueryBucket, bitrate_kbps : UInt) -> Double

#
TraceQueryBucket::wire_bits

source
fn TraceQueryBucket::wire_bits(self : TraceQueryBucket) -> Int

#
TraceQueryMatch

source
pub struct TraceQueryMatch {
  index : Int
  timestamp_us : UInt64
  frame : Frame
}

A selected trace entry with its original position.

#
TraceQueryMatch::frame

source

#
TraceQueryMatch::index

source
fn TraceQueryMatch::index(self : TraceQueryMatch) -> Int

#
TraceQueryMatch::latency_from

source
fn TraceQueryMatch::latency_from(self : TraceQueryMatch, timestamp_us : UInt64) -> UInt64

#
TraceQueryMatch::timestamp_us

source
fn TraceQueryMatch::timestamp_us(self : TraceQueryMatch) -> UInt64

#
TraceQueryPredicate

source
pub enum TraceQueryPredicate {
  TraceQueryAny
  TraceQueryIdentifier(UInt)
  TraceQueryExtended(Bool)
  TraceQueryProtocol(Protocol)
  TraceQueryFrameClass(FrameClass)
  TraceQueryPayloadLength(Int)
  TraceQueryPayloadAtLeast(Int)
  TraceQueryPayloadByte(Int, Byte)
  TraceQueryIdentifierRange(UInt, UInt)
}

A predicate for selecting frames from a capture trace.

#
TraceQuerySpec

source
pub struct TraceQuerySpec {
  start_us : UInt64?
  end_us : UInt64?
  predicates : Array[TraceQueryPredicate]
  inspected : Int
  matched : Int
}

A time and predicate specification for trace analysis.

#
TraceQuerySpec::after

source
fn TraceQuerySpec::after(self : TraceQuerySpec, start_us : UInt64) -> Unit

#
TraceQuerySpec::before

source
fn TraceQuerySpec::before(self : TraceQuerySpec, end_us : UInt64) -> Unit

#
TraceQuerySpec::between

source
fn TraceQuerySpec::between(self : TraceQuerySpec, start_us : UInt64, end_us : UInt64) -> Unit

#
TraceQuerySpec::inspected

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

#
TraceQuerySpec::matched

source
fn TraceQuerySpec::matched(self : TraceQuerySpec) -> Int

#
TraceQuerySpec::predicates

source

#
TraceQuerySpec::reset_counters

source
fn TraceQuerySpec::reset_counters(self : TraceQuerySpec) -> Unit

#
TraceQuerySpec::where_is

source
fn TraceQuerySpec::where_is(self : TraceQuerySpec, predicate : TraceQueryPredicate) -> Unit

#
TraceReplayEvent

source
pub struct TraceReplayEvent {
  offset_us : UInt64
  frame : Frame
  original_index : Int
}

A normalized replay event with a relative timestamp.

#
TraceReplayEvent::frame

source

#
TraceReplayEvent::offset_us

source
fn TraceReplayEvent::offset_us(self : TraceReplayEvent) -> UInt64

#
TraceReplayEvent::original_index

source
fn TraceReplayEvent::original_index(self : TraceReplayEvent) -> Int

#
TraceReplayPlan

source
pub struct TraceReplayPlan {
  events : Array[TraceReplayEvent]
  scale_num : UInt64
  scale_den : UInt64
  cursor : Int
}

A replay plan that supports deterministic time scaling and filtering.

#
TraceReplayPlan::at

source
fn TraceReplayPlan::at(self : TraceReplayPlan, offset_us : UInt64) -> Array[TraceReplayEvent]

#
TraceReplayPlan::cursor

source
fn TraceReplayPlan::cursor(self : TraceReplayPlan) -> Int

#
TraceReplayPlan::duration_us

source
fn TraceReplayPlan::duration_us(self : TraceReplayPlan) -> UInt64

#
TraceReplayPlan::events

source

#
TraceReplayPlan::next

source

#
TraceReplayPlan::reset

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

#
TraceReplayPlan::scale_den

source
fn TraceReplayPlan::scale_den(self : TraceReplayPlan) -> UInt64

#
TraceReplayPlan::scale_num

source
fn TraceReplayPlan::scale_num(self : TraceReplayPlan) -> UInt64

#
UdsResponseInfo

source
pub struct UdsResponseInfo {
  positive : Bool
  response_service : Byte
  payload : Array[Byte]
  negative_code : Byte?
}

A parsed positive or negative response with its service identifier.

#
UdsResponseInfo::is_positive

source
fn UdsResponseInfo::is_positive(self : UdsResponseInfo) -> Bool

#
UdsResponseInfo::negative_code

source
fn UdsResponseInfo::negative_code(self : UdsResponseInfo) -> Byte?

#
UdsResponseInfo::payload

source
fn UdsResponseInfo::payload(self : UdsResponseInfo) -> Array[Byte]

#
UdsResponseInfo::response_service

source
fn UdsResponseInfo::response_service(self : UdsResponseInfo) -> Byte

#
UdsService

source
pub enum UdsService {
  DiagnosticSessionControl
  EcuReset
  ReadDataByIdentifier
  WriteDataByIdentifier
  ReadMemoryByAddress
  WriteMemoryByAddress
  RoutineControl
  SecurityAccess
  CommunicationControl
  ClearDiagnosticInformation
  ReadDtcInformation
  RequestDownload
  TransferData
  RequestTransferExit
  TesterPresent
}

Common UDS service identifiers used by a diagnostic client.

#
UdsSession

source
pub struct UdsSession {
  state : UdsSessionState
  unlocked : Bool
  last_activity_us : UInt64
  p2_timeout_us : UInt64
  pending_service : UdsService?
}

A small deterministic UDS session tracker.

#
UdsSession::accept

source
fn UdsSession::accept(self : UdsSession, request : DiagnosticRequest, payload : Array[Byte], timestamp_us : UInt64) -> UdsResponseInfo raise UdsSessionError

Apply a diagnostic response and advance session state.

#
UdsSession::allows

source
fn UdsSession::allows(self : UdsSession, service : UdsService) -> Bool

Return whether a service is safe in the current state.

#
UdsSession::begin

source
fn UdsSession::begin(self : UdsSession, request : DiagnosticRequest, timestamp_us : UInt64) -> DiagnosticRequest raise UdsSessionError

Begin a request and remember the expected service.

#
UdsSession::change_state

source
fn UdsSession::change_state(self : UdsSession, target : UdsSessionState) -> Unit raise UdsSessionError

Force a session change after an externally validated response.

#
UdsSession::is_unlocked

source
fn UdsSession::is_unlocked(self : UdsSession) -> Bool

#
UdsSession::last_activity

source
fn UdsSession::last_activity(self : UdsSession) -> UInt64

#
UdsSession::pending_service

source
fn UdsSession::pending_service(self : UdsSession) -> UdsService?

#
UdsSession::state

source

#
UdsSession::timed_out

source
fn UdsSession::timed_out(self : UdsSession, timestamp_us : UInt64) -> Bool

Check whether the response timer has expired.

#
UdsSession::touch

source
fn UdsSession::touch(self : UdsSession, timestamp_us : UInt64) -> Unit

Mark the current activity time.

#
UdsSessionState

source
pub enum UdsSessionState {
  DefaultSession
  ProgrammingSession
  ExtendedDiagnosticSession
  SafetySystemDiagnosticSession
  LockedSession
} derive(
Debug)

UDS application session states.

#
VirtualBus

source
pub struct VirtualBus {
  capacity : Int
  queue : Array[Frame]
  filters : FilterBank
  dropped : Int
}

A deterministic in-memory CAN bus.

#
VirtualBus::dropped

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

Number of dropped frames.

#
VirtualBus::filters

source
fn VirtualBus::filters(self : VirtualBus) -> FilterBank

Configure the receiver acceptance filters.

#
VirtualBus::pending

source
fn VirtualBus::pending(self : VirtualBus) -> Int

Number of pending frames.

#
VirtualBus::publish

source
fn VirtualBus::publish(self : VirtualBus, frame : Frame) -> Bool

Publish a frame. The queue is ordered by arbitration priority.

#
VirtualBus::receive

source
fn VirtualBus::receive(self : VirtualBus) -> Frame?

Receive and remove the highest-priority pending frame.

#
VirtualBus::set_filters

source
fn VirtualBus::set_filters(self : VirtualBus, filters : FilterBank) -> Unit

Replace all acceptance filters.

#
admission_rule

source
fn admission_rule(name : String, filter : Filter, max_payload? : Int, allow_fd? : Bool, allow_remote? : Bool, min_interval_us? : UInt64) -> AdmissionRule raise AdmissionError

Construct a policy rule.

#
analyze_trace

source
fn analyze_trace(trace : Trace) -> FrameAnalysis

Analyze adjacent frames in capture order.

#
append_bits

source
fn append_bits(target : Array[Bool], value : UInt, width : Int) -> Unit

Append a value as most-significant-bit-first bits.

#
arbitration_winner

source
fn arbitration_winner(frames : Array[Frame]) -> Frame?

Calculate the arbitration winner: the numerically lowest identifier wins.

#
assess_bus_health

source
fn assess_bus_health(metrics : FrameMetrics, dropped : Int, duration_us : UInt64, bitrate_kbps : UInt) -> BusHealth

Assess health from frame metrics and virtual-bus counters.

#
batch_frames

source
fn batch_frames(frames : Array[Frame], size : Int) -> Array[FrameBatch] raise BatchError

Partition frames into batches with at most size members.

#
bit_at

source
fn bit_at(bits : Array[Bool], position : Int) -> Bool?

Return the bit at an absolute offset, or None when outside the array.

#
bit_reader_from_bytes

source
fn bit_reader_from_bytes(bytes : Array[Byte]) -> BitReader

Create a reader directly from packed bytes.

#
bits_of

source
fn bits_of(value : UInt, width : Int) -> Array[Bool]

Convert an integer to most-significant-bit-first bits.

#
bits_to_bytes

source
fn bits_to_bytes(bits : Array[Bool]) -> Array[Byte]

Convert bits to packed bytes. The last byte is zero padded.

#
bits_to_string

source
fn bits_to_string(bits : Array[Bool]) -> String

Return a string made of 0 and 1 for diagnostics and golden tests.

#
bus_analysis_anomaly_text

source
fn bus_analysis_anomaly_text(anomaly : BusAnalysisAnomaly) -> String

#
bus_analysis_anomaly_variants

source
fn bus_analysis_anomaly_variants() -> Array[BusAnalysisAnomaly]

#
bus_analysis_mode_variants

source
fn bus_analysis_mode_variants() -> Array[BusAnalysisMode]

#
bus_analysis_trace

source
fn bus_analysis_trace(trace : Trace, channel : String, mode? : BusAnalysisMode, bitrate_kbps? : UInt) -> BusAnalysisReport

Return one report for each channel represented by a trace.

#
bus_health_name

source
fn bus_health_name(state : BusHealthState) -> String

#
bus_interval_percentile

source
fn bus_interval_percentile(intervals : Array[UInt64], percentile : Int) -> UInt64

Calculate a stable percentile from interval samples.

#
bus_observation

source
fn bus_observation(timestamp_us : UInt64, frame : Frame, channel? : String, sequence? : UInt) -> BusObservation

#
bus_utilization

source
fn bus_utilization(metrics : FrameMetrics, duration_us : UInt64, bitrate_kbps : UInt) -> Double

Calculate approximate utilization for a bitrate in kbit/s.

#
bytes_to_bits

source
fn bytes_to_bits(bytes : Array[Byte]) -> Array[Bool]

Convert packed bytes to high-to-low bits.

#
calculate_bit_timing

source
fn calculate_bit_timing(clock_hz : UInt, bitrate : UInt, sample_point_percent : Double) -> CanBitTiming raise CanTimingError

Calculate a practical timing candidate using an integer clock divider.

#
can_adapter_capabilities

source
fn can_adapter_capabilities(classic? : Bool, can_fd? : Bool, bitrate_switch? : Bool, listen_only? : Bool, loopback? : Bool, timestamping? : Bool, max_rx_queue? : Int, max_tx_queue? : Int) -> CanAdapterCapabilities

#
can_adapter_config

source
fn can_adapter_config(nominal_bitrate_kbps? : UInt, data_bitrate_kbps? : UInt, listen_only? : Bool, loopback? : Bool, receive_own? : Bool, filter? : Filter?) -> CanAdapterConfig

#
can_adapter_lifecycle_variants

source
fn can_adapter_lifecycle_variants() -> Array[CanAdapterLifecycle]

#
can_adapter_message

source
fn can_adapter_message(timestamp_us : UInt64, frame : Frame, direction_tx : Bool, sequence : UInt) -> CanAdapterMessage

#
can_fd_timing

source
fn can_fd_timing(nominal : CanBitTiming, data : CanBitTiming) -> CanFdTiming raise CanTimingError

#
can_frame_duration_us

source
fn can_frame_duration_us(frame : Frame, nominal_bitrate_kbps : UInt, data_bitrate_kbps : UInt) -> UInt64

Estimate a frame duration using the nominal and data bitrates.

#
can_line

source
fn can_line(timestamp_us : UInt64, frame : Frame) -> String

Encode a single compact line for shell tools.

#
can_log_from_text

source
fn can_log_from_text(text : String) -> CanLog raise CanTextError

Parse a log produced by CanLog::to_text.

#
canonicalize_dbc

source
fn canonicalize_dbc(input : String) -> String raise DbcExtendedError

Parse, validate and normalize an extended DBC document.

#
canopen_cob_id

source
fn canopen_cob_id(object_type : CanOpenCobType, node_id : Byte) -> UInt raise CanOpenError

Create a standard CANopen COB-ID for a node.

#
canopen_cob_name

source
fn canopen_cob_name(object_type : CanOpenCobType) -> String

Return the textual name of a CANopen object type.

#
canopen_device_sdo_result_variants

source
fn canopen_device_sdo_result_variants() -> Array[CanOpenDeviceSdoResult]

#
canopen_device_sdo_session

source
fn canopen_device_sdo_session(index : UInt, sub_index : Byte, upload : Bool, data : Array[Byte], block_size? : Int) -> CanOpenDeviceSdoSession

#
canopen_device_state_text

source
fn canopen_device_state_text(state : CanOpenDeviceState) -> String

#
canopen_device_state_variants

source
fn canopen_device_state_variants() -> Array[CanOpenDeviceState]

#
canopen_emergency

source
fn canopen_emergency(error_code : UInt, error_register : Byte, manufacturer_data : Array[Byte]) -> Array[Byte] raise CanOpenError

Build an emergency payload with standard CANopen fields.

#
canopen_heartbeat

source
fn canopen_heartbeat(state : Byte) -> Array[Byte]

Build a heartbeat payload.

#
canopen_heartbeat_monitor

source
fn canopen_heartbeat_monitor(node_id : Byte, timeout_us : UInt64) -> CanOpenHeartbeatMonitor

#
canopen_heartbeat_state_variants

source
fn canopen_heartbeat_state_variants() -> Array[CanOpenHeartbeatState]

#
canopen_nmt

source
fn canopen_nmt(command : CanOpenNmtCommand, node_id : Byte) -> Array[Byte] raise CanOpenError

Build an NMT command frame.

#
canopen_object_access_variants

source
fn canopen_object_access_variants() -> Array[CanOpenObjectAccess]

#
canopen_object_entry

source
fn canopen_object_entry(index : UInt, sub_index : Byte, name : String, access? : CanOpenObjectAccess, initial? : Array[Byte], max_length? : Int) -> CanOpenObjectEntry

#
canopen_sdo_decode

source
fn canopen_sdo_decode(payload : Array[Byte]) -> CanOpenSdoCommand raise CanOpenError

Decode one SDO response command.

#
canopen_sdo_download

source
fn canopen_sdo_download(index : UInt, sub_index : Byte, data : Array[Byte]) -> Array[Byte] raise CanOpenError

Build an expedited SDO download request.

#
canopen_sdo_download_command

source
fn canopen_sdo_download_command(index : UInt, sub_index : Byte, data : Array[Byte]) -> CanOpenSdoCommand raise CanOpenError

Build a typed expedited download command.

#
canopen_sdo_download_segment

source
fn canopen_sdo_download_segment(toggle : Bool, data : Array[Byte], last : Bool) -> CanOpenSdoCommand raise CanOpenError

Build a typed segmented download command.

#
canopen_sdo_frame

source
fn canopen_sdo_frame(node_id : Byte, transmit : Bool, payload : Array[Byte]) -> Frame raise CanOpenError

Build a CAN frame for an SDO payload.

#
canopen_sdo_upload

source
fn canopen_sdo_upload(index : UInt, sub_index : Byte) -> Array[Byte] raise CanOpenError

Build an SDO upload request.

#
canopen_sdo_upload_segment

source
fn canopen_sdo_upload_segment(toggle : Bool) -> CanOpenSdoCommand

Build a typed segmented upload command.

#
classify_frame

source
fn classify_frame(frame : Frame) -> FrameClass

Classify a frame for counters and dashboards.

#
clear_diagnostic_information

source
fn clear_diagnostic_information(group : UInt) -> DiagnosticRequest raise UdsError

Build a request to clear one DTC group or all groups.

#
communication_control

source
fn communication_control(control_type : Byte, communication_type : Byte) -> DiagnosticRequest

Build a communication-control request.

#
compare_frames

source
fn compare_frames(left : Frame, right : Frame) -> Int

Compare frames in the order used by deterministic arbitration.

#
compatibility_accepts

source
fn compatibility_accepts(matrix : CompatibilityMatrix, target : CompatibilityTarget) -> Bool

Use the matrix as an acceptance predicate for one target.

#
compatibility_add_diagnostic_requirements

source
fn compatibility_add_diagnostic_requirements(matrix : CompatibilityMatrix) -> Unit

Add the common minimums for a diagnostic service.

#
compatibility_add_gateway_requirements

source
fn compatibility_add_gateway_requirements(matrix : CompatibilityMatrix) -> Unit

Add the common minimums for a gateway deployment.

#
compatibility_add_vehicle_requirements

source
fn compatibility_add_vehicle_requirements(matrix : CompatibilityMatrix) -> Unit

Add the common minimums for a classical vehicle network.

#
compatibility_build_default_routes

source
fn compatibility_build_default_routes() -> CompatibilityRouteTable

#
compatibility_can_bridge

source
fn compatibility_can_bridge(target : CompatibilityTarget, protocol : CompatibilityProtocol) -> Bool

Check whether a target can be used as a bridge endpoint for a protocol.

#
compatibility_canopen_target

source
fn compatibility_canopen_target(name? : String, node_capacity? : Int) -> CompatibilityTarget

#
compatibility_ci_annotations

source
fn compatibility_ci_annotations(matrix : CompatibilityMatrix) -> String

Stable line-oriented output for CI annotations.

#
compatibility_classic_target

source
fn compatibility_classic_target(name? : String, node_capacity? : Int) -> CompatibilityTarget

#
compatibility_compare_targets

source
fn compatibility_compare_targets(source : CompatibilityTarget, destination : CompatibilityTarget) -> CompatibilityDelta

#
compatibility_default_matrix

source
fn compatibility_default_matrix() -> CompatibilityMatrix

#
compatibility_default_release_gate

source
fn compatibility_default_release_gate() -> CompatibilityReleaseGate

#
compatibility_diagnostics_matrix

source
fn compatibility_diagnostics_matrix() -> CompatibilityMatrix

#
compatibility_failures

source
fn compatibility_failures(evaluation : CompatibilityEvaluation) -> Array[CompatibilityIssue]

Return all failed requirements for a target.

#
compatibility_fd_target

source
fn compatibility_fd_target(name? : String, node_capacity? : Int) -> CompatibilityTarget

#
compatibility_forbids_feature

source
fn compatibility_forbids_feature(code : String, feature : String, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_gateway_matrix

source
fn compatibility_gateway_matrix() -> CompatibilityMatrix

#
compatibility_gateway_target

source
fn compatibility_gateway_target(name? : String, node_capacity? : Int) -> CompatibilityTarget

#
compatibility_inventory

source
fn compatibility_inventory(target : CompatibilityTarget) -> String

Describe the exact resources available to a target.

#
compatibility_isotp_target

source
fn compatibility_isotp_target(name? : String, node_capacity? : Int) -> CompatibilityTarget

#
compatibility_j1939_target

source
fn compatibility_j1939_target(name? : String, node_capacity? : Int) -> CompatibilityTarget

#
compatibility_matrix

source
fn compatibility_matrix(name? : String, strict? : Bool) -> CompatibilityMatrix

#
compatibility_matrix_for_target

source
fn compatibility_matrix_for_target(target : CompatibilityTarget, requirements : Array[CompatibilityRequirement], strict? : Bool) -> CompatibilityMatrix

Create a matrix from a single target and a reusable requirement set.

#
compatibility_minimum_bitrate

source
fn compatibility_minimum_bitrate(code : String, minimum : Int, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_minimum_data_bitrate

source
fn compatibility_minimum_data_bitrate(code : String, minimum : Int, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_minimum_identifier_bits

source
fn compatibility_minimum_identifier_bits(code : String, minimum : Int, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_minimum_node_capacity

source
fn compatibility_minimum_node_capacity(code : String, minimum : Int, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_minimum_payload

source
fn compatibility_minimum_payload(code : String, minimum : Int, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_protocol_is

source
fn compatibility_protocol_is(code : String, protocol : CompatibilityProtocol, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_protocol_text

source
fn compatibility_protocol_text(protocol : CompatibilityProtocol) -> String

#
compatibility_protocol_variants

source
fn compatibility_protocol_variants() -> Array[CompatibilityProtocol]

#
compatibility_release_gate

source
fn compatibility_release_gate(name? : String, minimum_score? : Int, require_all_targets? : Bool) -> CompatibilityReleaseGate

#
compatibility_remediation

source
fn compatibility_remediation(evaluation : CompatibilityEvaluation) -> String

Build a plain-text incident hint from a failed evaluation.

#
compatibility_requirement_kind_text

source
fn compatibility_requirement_kind_text(kind : CompatibilityRequirementKind) -> String

#
compatibility_requirement_kind_variants

source
fn compatibility_requirement_kind_variants() -> Array[CompatibilityRequirementKind]

#
compatibility_requires_classic

source
fn compatibility_requires_classic(code : String, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_requires_diagnostics

source
fn compatibility_requires_diagnostics(code : String, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_requires_fd

source
fn compatibility_requires_fd(code : String, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_requires_feature

source
fn compatibility_requires_feature(code : String, feature : String, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_requires_isotp

source
fn compatibility_requires_isotp(code : String, description? : String, severity? : CompatibilitySeverity) -> CompatibilityRequirement

#
compatibility_route

source
fn compatibility_route(source : CompatibilityTarget, destination : CompatibilityTarget, transport : CompatibilityProtocol) -> CompatibilityRoute

#
compatibility_route_payload_budget

source
fn compatibility_route_payload_budget(route : CompatibilityRoute) -> Int

Produce a bounded payload size for a route, reserving a byte for framing when needed.

#
compatibility_route_table

source
fn compatibility_route_table() -> CompatibilityRouteTable

#
compatibility_schema_version

source
fn compatibility_schema_version() -> String

Stable schema version for compatibility snapshots.

#
compatibility_severity_text

source
fn compatibility_severity_text(severity : CompatibilitySeverity) -> String

#
compatibility_severity_variants

source
fn compatibility_severity_variants() -> Array[CompatibilitySeverity]

#
compatibility_snapshot

source
fn compatibility_snapshot(matrix : CompatibilityMatrix) -> String

A compact machine-readable snapshot for logging and support bundles.

#
compatibility_standard_target_matrix

source
fn compatibility_standard_target_matrix(target : CompatibilityTarget) -> CompatibilityMatrix

Construct a standard acceptance matrix for one target.

#
compatibility_target

source
fn compatibility_target(name : String, protocol : CompatibilityProtocol, nominal_bitrate : Int, data_bitrate : Int, max_payload : Int, identifier_bits : Int, node_capacity : Int, features? : Array[String], notes? : String) -> CompatibilityTarget

#
compatibility_target_fingerprint

source
fn compatibility_target_fingerprint(target : CompatibilityTarget) -> UInt64

Return a deterministic checksum-like fingerprint for a target.

#
compatibility_targets_for_protocol

source
fn compatibility_targets_for_protocol(protocol : CompatibilityProtocol) -> Array[CompatibilityTarget]

Build a target set from a requested protocol family.

#
compatibility_uds_target

source
fn compatibility_uds_target(name? : String, node_capacity? : Int) -> CompatibilityTarget

#
compatibility_warnings

source
fn compatibility_warnings(evaluation : CompatibilityEvaluation) -> Array[CompatibilityIssue]

Return all warnings for a target.

#
count_stuffed_bits

source
fn count_stuffed_bits(bits : Array[Bool]) -> Int

Count stuffed bits in a sequence without allocating the stuffed result.

#
counter_is_next

source
fn counter_is_next(previous : Byte, current : Byte) -> Bool

Verify the expected modulo-16 counter progression.

#
counter_nibble

source
fn counter_nibble(data : Array[Byte], offset : Int, high_nibble : Bool) -> Byte raise PayloadError

Read a rolling counter nibble.

#
crc15

source
fn crc15(bits : Array[Bool]) -> UInt

CRC-15 used by the classical CAN frame format.

#
crc17

source
fn crc17(bits : Array[Bool]) -> UInt

CRC-17 used by CAN-FD frames with a payload up to 16 bytes.

#
crc21

source
fn crc21(bits : Array[Bool]) -> UInt

CRC-21 used by CAN-FD frames with a payload above 16 bytes.

#
crc8_autosar

source
fn crc8_autosar(data : Array[Byte], initial : Byte) -> Byte

Return the CRC-8/AUTOSAR checksum with configurable initial value.

#
crc8_sae_j1850

source
fn crc8_sae_j1850(data : Array[Byte]) -> Byte

Return the CRC-8/SAE-J1850 checksum of a payload.

#
data_frame

source
fn data_frame(id : UInt, data : Array[Byte], extended? : Bool) -> Frame raise FrameError

Create a classic CAN data frame.

#
dbc_codegen

source
fn dbc_codegen(messages : Array[Message], options : DbcCodegenOptions) -> DbcGeneratedArtifact

Generate an artifact for a collection of DBC messages.

#
dbc_codegen_all_targets

source
fn dbc_codegen_all_targets(messages : Array[Message], module_name : String) -> Array[DbcGeneratedArtifact]

Produce one artifact per supported target.

#
dbc_codegen_identifier

source
fn dbc_codegen_identifier(name : String) -> String

Render a safe identifier for generated code.

#
dbc_codegen_lint

source
fn dbc_codegen_lint(messages : Array[Message]) -> Array[String]

Lint a DBC schema for issues that affect generated integration code.

#
dbc_codegen_options

source
fn dbc_codegen_options(target? : DbcCodegenTarget, module_name? : String, include_comments? : Bool, include_validation? : Bool, line_ending? : String) -> DbcCodegenOptions

#
dbc_codegen_report

source
fn dbc_codegen_report(messages : Array[Message]) -> String

Return a deterministic schema report suitable for CI.

#
dbc_codegen_target_name

source
fn dbc_codegen_target_name(target : DbcCodegenTarget) -> String

#
dbc_codegen_target_variants

source
fn dbc_codegen_target_variants() -> Array[DbcCodegenTarget]

#
dbc_codegen_total_lines

source
fn dbc_codegen_total_lines(artifacts : Array[DbcGeneratedArtifact]) -> Int

Return the total generated source size across artifacts.

#
dbc_codegen_workspace

source
fn dbc_codegen_workspace(workspace : DbcWorkspace, options : DbcCodegenOptions) -> DbcGeneratedArtifact

Generate a DBC workspace artifact without mutating its schema.

#
dbc_workspace_binding

source
fn dbc_workspace_binding(name : String, message : Message, selector? : DbcWorkspaceMuxSelector, extended? : Bool) -> DbcWorkspaceBinding

#
dbc_workspace_from_text

source
fn dbc_workspace_from_text(input : String) -> DbcWorkspace raise DbcError

Create a workspace from a parsed DBC document.

#
dbc_workspace_issue_text

source
fn dbc_workspace_issue_text(issue : DbcWorkspaceIssue) -> String

#
dbc_workspace_issue_variants

source
fn dbc_workspace_issue_variants() -> Array[DbcWorkspaceIssue]

#
dbc_workspace_mux_accepts

source
fn dbc_workspace_mux_accepts(selector : DbcWorkspaceMuxSelector, value : UInt) -> Bool

Return whether a mux selector accepts a value.

#
dbc_workspace_mux_variants

source
fn dbc_workspace_mux_variants() -> Array[DbcWorkspaceMuxSelector]

#
dbc_workspace_signal_group

source
fn dbc_workspace_signal_group(name : String, message_id : UInt, signals? : Array[Signal]) -> DbcWorkspaceSignalGroup

#
dbc_workspace_value

source
fn dbc_workspace_value(name : String, value : Double) -> DbcWorkspaceValue

#
dbc_workspace_values

source
fn dbc_workspace_values(names : Array[String], values : Array[Double]) -> DbcWorkspaceValueSet

Build a value set from parallel signal names and values.

#
decode_canopen_cob_id

source
fn decode_canopen_cob_id(identifier : UInt) -> CanOpenCobId raise CanOpenError

Decode a standard CANopen COB-ID using the conventional ranges.

#
decode_frame

source
fn decode_frame(bytes : Array[Byte]) -> Frame raise FrameCodecError

Decode one frame from the stable binary representation.

#
decode_frame_batch

source
fn decode_frame_batch(bytes : Array[Byte]) -> FrameBatch raise BatchError

Decode a batch archive and check its checksum.

#
decode_j1939

source
fn decode_j1939(id : UInt) -> J1939Id

Decode the fields of a J1939 identifier.

#
decode_j1939_frame

source
fn decode_j1939_frame(frame : Frame) -> J1939Message? raise J1939Error

Decode an extended CAN data frame as a J1939 message.

#
decode_response

source
fn decode_response(request : DiagnosticRequest, payload : Array[Byte]) -> DiagnosticResponse

Decode a UDS response payload.

#
decode_wire_can20

source
fn decode_wire_can20(bits : Array[Bool]) -> Frame raise WireCodecError

Decode a classic CAN wire sequence produced by encode_wire.

#
decode_wire_canfd

source
fn decode_wire_canfd(bits : Array[Bool]) -> Frame raise WireCodecError

Decode a CAN-FD wire sequence produced by encode_wire.

#
default_diagnostic_session

source
fn default_diagnostic_session() -> DiagnosticSessionProfile

Return the default session profile used by a tester.

#
destuff

source
fn destuff(bits : Array[Bool]) -> Array[Bool] raise WireError

Remove CAN bit stuffing from a received bit sequence.

#
diagnostic_addressing_modes

source
fn diagnostic_addressing_modes() -> Array[DiagnosticAddressingMode]

Construct the addressing modes accepted by the portable transport layer.

#
diagnostic_data_identifier

source
fn diagnostic_data_identifier(identifier : UInt, name : String, length : Int, readable? : Bool, writable? : Bool, initial? : Array[Byte]) -> DiagnosticDataIdentifier

Create a data identifier entry.

#
diagnostic_dtc_queries

source
fn diagnostic_dtc_queries() -> Array[DtcQuery]

Construct representative selectors for a diagnostic UI.

#
diagnostic_event

source
fn diagnostic_event(timestamp_us : UInt64, request : DiagnosticRequest, response : Array[Byte], duration_us : UInt64) -> DiagnosticEvent

#
diagnostic_frame

source
fn diagnostic_frame(request : DiagnosticRequest, id : UInt, extended? : Bool) -> Frame raise FrameError

Return a service request encoded as a CAN data frame.

#
diagnostic_identification_workflow

source
fn diagnostic_identification_workflow(identifiers : Array[UInt]) -> DiagnosticWorkflow

Build a standard ECU identification workflow.

#
diagnostic_keepalive_deadline

source
fn diagnostic_keepalive_deadline(profile : DiagnosticSessionProfile, now_us : UInt64) -> UInt64

Return the next TesterPresent deadline.

#
diagnostic_readiness

source
fn diagnostic_readiness(session_ok : Bool, security_ok : Bool, voltage_ok : Bool, temperature_ok : Bool, dtc_ok : Bool) -> DiagnosticReadiness

#
diagnostic_readiness_all

source
fn diagnostic_readiness_all(checks : Array[DiagnosticReadiness]) -> DiagnosticReadiness

Aggregate the outcome of multiple readiness checks.

#
diagnostic_retry_policy

source
fn diagnostic_retry_policy(max_attempts? : Int, backoff_us? : UInt64, retry_negative? : Bool) -> DiagnosticRetryPolicy

#
diagnostic_session_kinds

source
fn diagnostic_session_kinds() -> Array[DiagnosticSessionKind]

Construct all standard session variants for capability discovery.

#
diagnostic_session_name

source
fn diagnostic_session_name(kind : DiagnosticSessionKind) -> String

Return a stable session name for reports.

#
diagnostic_session_profile

source
fn diagnostic_session_profile(kind : DiagnosticSessionKind, p2_server_us : UInt64, p2_star_server_us : UInt64, s3_server_us : UInt64, addressing? : DiagnosticAddressingMode, security_level? : Byte) -> DiagnosticSessionProfile

Create a standard diagnostic session profile.

#
diagnostic_session_requires_keepalive

source
fn diagnostic_session_requires_keepalive(profile : DiagnosticSessionProfile) -> Bool

Return whether the session should be kept alive by TesterPresent.

#
diagnostic_trouble_code

source
fn diagnostic_trouble_code(code : UInt, status : Byte, severity? : Byte, snapshot? : Array[Byte], extended_data? : Array[Byte], timestamp_us? : UInt64) -> DiagnosticTroubleCode

Create a diagnostic trouble code record.

#
diagnostic_workflow_state_text

source
fn diagnostic_workflow_state_text(state : DiagnosticWorkflowState) -> String

#
diagnostic_workflow_state_variants

source
fn diagnostic_workflow_state_variants() -> Array[DiagnosticWorkflowState]

#
diagnostic_workflow_step

source
fn diagnostic_workflow_step(name : String, request : DiagnosticRequest, timeout_us? : UInt64, retry? : DiagnosticRetryPolicy) -> DiagnosticWorkflowStep

#
diff_dbc_schema

source
fn diff_dbc_schema(before : Array[Message], after : Array[Message]) -> Array[DbcSchemaChange]

Compare message collections by identifier and canonical schema text.

#
dtc_matches

source
fn dtc_matches(dtc : DiagnosticTroubleCode, query : DtcQuery) -> Bool

Return whether a DTC matches a query selector.

#
dtc_record

source
fn dtc_record(code : UInt, status : Byte, occurrence? : UInt, snapshot? : Array[Byte]) -> DtcRecord raise DtcCodecError

Create a DTC record with an optional occurrence counter and snapshot.

#
ecu_memory_permission_variants

source
fn ecu_memory_permission_variants() -> Array[EcuMemoryPermission]

#
ecu_memory_region

source
fn ecu_memory_region(start : UInt, length : Int, permission? : EcuMemoryPermission) -> EcuMemoryRegion raise EcuMemoryError

Create a zero-initialized ECU memory region.

#
ecu_request_outcome_variants

source
fn ecu_request_outcome_variants() -> Array[EcuRequestOutcome]

#
ecu_reset

source
fn ecu_reset(reset_type : Byte) -> DiagnosticRequest

Build an ECU reset request.

#
ecu_reset_kind_variants

source
fn ecu_reset_kind_variants() -> Array[EcuResetKind]

#
ecu_security_policy

source
fn ecu_security_policy(level : Byte, secret : UInt, max_attempts? : Int, delay_us? : UInt64) -> EcuSecurityPolicy

#
ecu_security_state_variants

source
fn ecu_security_state_variants() -> Array[EcuSecurityState]

#
encode_bits

source
fn encode_bits(frame : Frame) -> Array[Bool]

Encode a frame's arbitration and control fields before CRC.

#
encode_dtc_record

source
fn encode_dtc_record(record : DtcRecord) -> Array[Byte]

Encode the four-byte DTC record used in a UDS response.

#
encode_dtc_report

source
fn encode_dtc_report(report : DtcReport) -> Array[Byte]

Encode a report while preserving record order.

#
encode_frame

source
fn encode_frame(frame : Frame) -> Array[Byte]

A stable binary representation for trace files and test fixtures.

The format is: version, flags, four-byte identifier, payload length, data. All multi-byte values are big-endian so the format is identical on every MoonBit backend.

#
encode_j1939

source
fn encode_j1939(value : J1939Id) -> UInt

Encode a J1939 identifier from its fields.

#
encode_wire

source
fn encode_wire(frame : Frame) -> Array[Bool]

Encode identifier, control, data, CRC, stuffing and EOF bits.

#
encoded_wire_length

source
fn encoded_wire_length(frame : Frame) -> Int

Return the stuffed frame length, including SOF-free EOF bits.

#
error_frame

source
fn error_frame(code : Byte) -> Frame

Create a local error frame for simulation and diagnostics.

#
estimate_transmission_us

source
fn estimate_transmission_us(frame : Frame, arbitration_kbps : UInt, data_kbps : UInt) -> UInt64

Estimate transmission time in microseconds.

#
exact_filter

source
fn exact_filter(id : UInt, extended? : Bool) -> Filter

Match an exact identifier.

#
extended_diagnostic_session

source
fn extended_diagnostic_session() -> DiagnosticSessionProfile

Return an extended diagnostic session profile.

#
fd_frame

source
fn fd_frame(id : UInt, data : Array[Byte], extended? : Bool, bitrate_switch? : Bool, error_state_indicator? : Bool) -> Frame raise FrameError

Create a CAN-FD data frame.

#
fd_frame_duration_ns

source
fn fd_frame_duration_ns(frame : Frame, timing : CanFdTiming) -> UInt64

Estimate the data-phase duration for a CAN-FD frame with BRS.

#
fd_length_from_dlc

source
fn fd_length_from_dlc(dlc : Byte) -> Int

Decode a CAN-FD DLC into its payload capacity.

#
filter_bank_is_valid

source
fn filter_bank_is_valid(bank : FilterBank) -> Bool

Return whether all filters in a bank are valid.

#
filter_is_valid

source
fn filter_is_valid(filter : Filter) -> Bool

Validate a filter against the selected identifier width.

#
frame_batch

source
fn frame_batch(sequence : UInt, frames : Array[Frame]) -> FrameBatch raise BatchError

#
frame_class_name

source
fn frame_class_name(class : FrameClass) -> String

Return the frame class as a stable text label.

#
frame_crc

source
fn frame_crc(frame : Frame) -> UInt

Return the CRC for the unstuffed arbitration/control/data sequence.

#
frame_duration_ns

source
fn frame_duration_ns(frame : Frame, timing : CanBitTiming) -> UInt64

Estimate a frame's nominal-only transmission duration.

#
frame_encoded_size

source
fn frame_encoded_size(frame : Frame) -> Int

Return the number of encoded frame bytes, including the codec header.

#
frame_equal

source
fn frame_equal(left : Frame, right : Frame) -> Bool

Compare frame payloads and all control flags.

#
frame_from_hex

source
fn frame_from_hex(text : String) -> Frame raise FrameCodecError

Decode a hexadecimal frame representation.

#
frame_is_valid

source
fn frame_is_valid(frame : Frame) -> Bool

Return whether a frame passes all normalized invariants.

#
frame_metrics

source
fn frame_metrics(frames : Array[Frame]) -> FrameMetrics

Calculate deterministic metrics without changing the input order.

#
frame_pipeline_action_variants

source
fn frame_pipeline_action_variants() -> Array[FramePipelineAction]

#
frame_pipeline_result_variants

source
fn frame_pipeline_result_variants() -> Array[FramePipelineResult]

#
frame_pipeline_rule

source
fn frame_pipeline_rule(name : String, filter : Filter, action : FramePipelineAction, max_payload? : Int, allow_fd? : Bool) -> FramePipelineRule raise FramePipelineError

#
frame_summary

source
fn frame_summary(frame : Frame) -> String

Return a compact human-readable frame summary.

#
frame_to_hex

source
fn frame_to_hex(frame : Frame) -> String

Encode a frame as lowercase hexadecimal bytes.

#
frame_violation_message

source
fn frame_violation_message(violation : FrameViolation) -> String

Return a diagnostic description for a validation finding.

#
frame_wire_bits

source
fn frame_wire_bits(frame : Frame) -> Int

Return the approximate wire bit count before inter-frame spacing.

#
frame_with_data

source
fn frame_with_data(frame : Frame, data : Array[Byte]) -> Frame raise PayloadError

Rebuild a frame with a defensive payload copy.

#
frame_with_id

source
fn frame_with_id(frame : Frame, id : UInt) -> Frame raise PayloadError

Rebuild a frame with a different arbitration identifier.

#
frames_per_second

source
fn frames_per_second(metrics : FrameMetrics, duration_us : UInt64) -> Double

Calculate frames per second over an observation interval.

#
gateway_pair

source
fn gateway_pair(left_to_right : CanGateway, right_to_left : CanGateway) -> GatewayPair

#
gateway_policy_context

source
fn gateway_policy_context(timestamp_us : UInt64, source_channel : String, destination_channel : String, frame : Frame) -> GatewayPolicyContext

#
gateway_policy_decision_text

source
fn gateway_policy_decision_text(decision : GatewayPolicyDecision) -> String

Return a stable policy decision label.

#
gateway_policy_decision_variants

source
fn gateway_policy_decision_variants() -> Array[GatewayPolicyDecision]

#
gateway_policy_error_variants

source
fn gateway_policy_error_variants() -> Array[GatewayPolicyError]

#
gateway_policy_pair

source
fn gateway_policy_pair(left : GatewayPolicyEngine, right : GatewayPolicyEngine, source : String, destination : String, timestamp_us : UInt64, frame : Frame) -> Frame?

Evaluate one frame against a pair of channel-specific engines.

#
gateway_policy_rule

source
fn gateway_policy_rule(name : String, filter : Filter, output_id? : UInt?, prefix? : Array[Byte], max_payload? : Int, min_interval_us? : UInt64, allow_remote? : Bool) -> GatewayPolicyRule raise GatewayPolicyError

#
isotp_channel

source
fn isotp_channel(source_id : UInt, target_id : UInt, extended? : Bool, addressing? : IsoTpSessionAddressing, flow_control? : IsoTpFlowControlConfig) -> IsoTpChannel

#
isotp_config

source
fn isotp_config(frame_bytes? : Int, block_size? : Byte, separation_time? : Byte) -> IsoTpConfig raise IsoTpError

Create an ISO-TP configuration. Data capacity is normally 8 or 64 bytes.

#
isotp_decode

source
fn isotp_decode(packet : Array[Byte]) -> IsoTpPacket?

Decode one ISO-TP packet.

#
isotp_decode_checked

source
fn isotp_decode_checked(packet : Array[Byte], config : IsoTpConfig) -> IsoTpPacket raise IsoTpError

Decode a packet while enforcing its declared payload length.

#
isotp_flow_control_config

source
fn isotp_flow_control_config(block_size : Int, separation_time_us : UInt64, wait_frame_limit : Int, max_payload : Int) -> IsoTpFlowControlConfig

Create flow-control parameters with safe bounds.

#
isotp_frames

source
fn isotp_frames(tx_id : UInt, payload : Array[Byte], config : IsoTpConfig, extended? : Bool) -> Array[Frame] raise IsoTpError

Wrap ISO-TP packets in CAN or CAN-FD data frames.

#
isotp_reassemble

source
fn isotp_reassemble(first : IsoTpPacket, rest : Array[IsoTpPacket]) -> Array[Byte]?

Reassemble consecutive ISO-TP packets after a first frame.

#
isotp_reassemble_checked

source
fn isotp_reassemble_checked(packets : Array[IsoTpPacket]) -> Array[Byte] raise IsoTpError

Reassemble a complete ISO-TP transfer and verify sequence numbers.

#
isotp_reassemble_frames

source
fn isotp_reassemble_frames(frames : Array[Frame], config : IsoTpConfig) -> Array[Byte] raise IsoTpError

Decode and reassemble a sequence of CAN data frames.

#
isotp_receiver_result_variants

source
fn isotp_receiver_result_variants() -> Array[IsoTpReceiverResult]

Construct representative receiver results.

#
isotp_segment

source
fn isotp_segment(payload : Array[Byte]) -> Array[Array[Byte]]

Encode a payload into ISO-TP packets carried by classic CAN frames.

#
isotp_segment_checked

source
fn isotp_segment_checked(payload : Array[Byte], config : IsoTpConfig) -> Array[Array[Byte]] raise IsoTpError

Segment a payload while respecting frame size and the 12-bit classic length.

#
isotp_session_addressing_variants

source
fn isotp_session_addressing_variants() -> Array[IsoTpSessionAddressing]

Construct all portable ISO-TP addressing formats.

#
isotp_transfer_summary

source
fn isotp_transfer_summary(transmitter : IsoTpTransmitter, receiver : IsoTpStreamReceiver) -> String

Return a stable transfer summary for diagnostics.

#
isotp_transmitter_state_variants

source
fn isotp_transmitter_state_variants() -> Array[IsoTpTransmitterState]

Construct every transmitter state for state-machine tools.

#
j1939_address_claim

source
fn j1939_address_claim(source_address : Byte, name : UInt64, manufacturer : UInt, function : Byte, instance : Byte, timestamp_us? : UInt64) -> J1939AddressClaim

#
j1939_bam

source
fn j1939_bam(pgn : UInt, payload : Array[Byte]) -> Array[Array[Byte]] raise J1939Error

Build a J1939 BAM transport-protocol announcement.

#
j1939_decode_spns

source
fn j1939_decode_spns(definitions : Array[J1939SpnDefinition], data : Array[Byte]) -> Array[(UInt, Double)]

Decode multiple configured SPNs from a PGN payload.

#
j1939_destination

source
fn j1939_destination(identifier : J1939Id) -> Byte

Return the numeric destination address, or broadcast for PDU2 messages.

#
j1939_id

source
fn j1939_id(priority : Byte, data_page : Bool, pdu_format : Byte, pdu_specific : Byte, source_address : Byte) -> J1939Id

Create a J1939 identifier from its wire fields.

#
j1939_matches_pgn

source
fn j1939_matches_pgn(identifier : J1939Id, pgn : UInt) -> Bool

Test whether a J1939 identifier belongs to a PGN.

#
j1939_message

source
fn j1939_message(identifier : J1939Id, payload : Array[Byte]) -> J1939Message raise J1939Error

#
j1939_parse_bam

source
fn j1939_parse_bam(announcement : Array[Byte]) -> (Int, Int, UInt)?

Parse a BAM announcement as (length, packet_count, pgn).

#
j1939_reassemble_bam

source
fn j1939_reassemble_bam(packets : Array[Array[Byte]], total_length : Int) -> Array[Byte] raise J1939Error

Reassemble BAM data packets after validating their sequence numbers.

#
j1939_spn

source
fn j1939_spn(spn : UInt, name : String, start_bit : Int, length : Int, factor? : Double, offset? : Double, minimum? : Double, maximum? : Double, unit? : String) -> J1939SpnDefinition

#
j1939_transport_direction_variants

source
fn j1939_transport_direction_variants() -> Array[J1939TransportDirection]

#
j1939_transport_state_variants

source
fn j1939_transport_state_variants() -> Array[J1939TransportState]

#
j1939_with_priority

source
fn j1939_with_priority(identifier : J1939Id, priority : Byte) -> J1939Id raise J1939Error

Return a priority-adjusted arbitration identifier.

#
j1939_with_source

source
fn j1939_with_source(identifier : J1939Id, source : Byte) -> J1939Id raise J1939Error

Return a source-address-adjusted identifier.

#
locked_uds_session

source
fn locked_uds_session(p2_timeout_us? : UInt64) -> UdsSession

Create a session that requires security access for protected services.

#
mask_filter

source
fn mask_filter(id : UInt, mask : UInt, extended? : Bool?) -> Filter

Match identifier bits selected by a mask.

#
mask_payload

source
fn mask_payload(data : Array[Byte], offset : Int, mask : Byte) -> Array[Byte] raise PayloadError

Mask a payload byte range without changing its length.

#
matching_filters

source
fn matching_filters(bank : FilterBank, frame : Frame) -> Array[Filter]

Return all filters that match a frame.

#
max_payload

source
fn max_payload(protocol : Protocol) -> Int

Return the maximum payload allowed by the protocol.

#
merge_traces

source
fn merge_traces(left : Trace, right : Trace) -> Trace

Merge two traces and normalize their ordering.

#
message

source
fn message(id : UInt, name : String, dlc : Int) -> Message

Create a message definition.

#
network_error_budget

source
fn network_error_budget(max_error_rate? : Double, max_drop_rate? : Double, max_offline_nodes? : Int) -> NetworkErrorBudget

#
network_node_health

source
fn network_node_health(node_id : Byte, name : String, timeout_us? : UInt64) -> NetworkNodeHealth

#
network_node_health_state_text

source
fn network_node_health_state_text(state : NetworkNodeHealthState) -> String

#
network_node_health_state_variants

source
fn network_node_health_state_variants() -> Array[NetworkNodeHealthState]

#
new_admission_policy

source
fn new_admission_policy() -> AdmissionPolicy

#
new_bit_reader

source
fn new_bit_reader(bits : Array[Bool]) -> BitReader

Create a reader over a defensive copy of the input bits.

#
new_bit_writer

source
fn new_bit_writer() -> BitWriter

Create an empty bit writer.

#
new_bus

source
fn new_bus(capacity : Int) -> VirtualBus

Create a bus. A zero capacity means an unbounded queue.

#
new_bus_analyzer

source
fn new_bus_analyzer(mode : BusAnalysisMode, channel? : String, bitrate_kbps? : UInt, burst_window_us? : UInt64, jitter_limit_us? : UInt64) -> BusAnalyzer

#
new_can_adapter_hub

source
fn new_can_adapter_hub() -> CanAdapterHub

#
new_can_adapter_stats

source
fn new_can_adapter_stats() -> CanAdapterStats

#
new_can_log

source
fn new_can_log() -> CanLog

#
new_can_network

source
fn new_can_network(timeout_us? : UInt64, queue_capacity? : Int) -> CanNetwork raise QueueError

Create a network. A zero timeout disables automatic offline detection.

#
new_can_port

source
fn new_can_port(name : String, capabilities? : CanAdapterCapabilities) -> CanPort

#
new_canopen_device

source
fn new_canopen_device(node_id : Byte, name : String, heartbeat_timeout_us? : UInt64) -> CanOpenDevice

#
new_canopen_device_network

source
fn new_canopen_device_network() -> CanOpenDeviceNetwork

#
new_canopen_object_dictionary

source
fn new_canopen_object_dictionary(capacity? : Int) -> CanOpenObjectDictionary

#
new_dbc_database

source
fn new_dbc_database() -> DbcDatabase

Create an empty database.

#
new_dbc_workspace

source
fn new_dbc_workspace() -> DbcWorkspace

#
new_dbc_workspace_value_set

source
fn new_dbc_workspace_value_set() -> DbcWorkspaceValueSet

#
new_diagnostic_data_table

source
fn new_diagnostic_data_table() -> DiagnosticDataTable

#
new_diagnostic_exchange_log

source
fn new_diagnostic_exchange_log() -> DiagnosticExchangeLog

#
new_diagnostic_trouble_code_store

source
fn new_diagnostic_trouble_code_store(capacity : Int) -> DiagnosticTroubleCodeStore

Create an empty bounded DTC store.

#
new_diagnostic_workflow

source
fn new_diagnostic_workflow() -> DiagnosticWorkflow

#
new_dtc_report

source
fn new_dtc_report(subfunction : Byte, status_availability_mask : Byte, records : Array[DtcRecord]) -> DtcReport

Construct a report for a positive ReadDTCInformation response.

#
new_dtc_store

source
fn new_dtc_store(capacity : Int) -> DtcStore raise DtcCodecError

#
new_ecu_endpoint

source
fn new_ecu_endpoint(address : UInt, name : String, security? : EcuSecurityPolicy) -> EcuEndpoint

Create an ECU endpoint with empty data, DTC and memory tables.

#
new_ecu_fleet

source
fn new_ecu_fleet() -> EcuFleet

#
new_ecu_memory_map

source
fn new_ecu_memory_map() -> EcuMemoryMap

#
new_filter_bank

source
fn new_filter_bank() -> FilterBank

Create an empty filter bank.

#
new_filter_index

source
fn new_filter_index(bank : FilterBank) -> FilterIndex

#
new_frame_deduplicator

source
fn new_frame_deduplicator(window_us? : UInt64) -> FrameDeduplicator

#
new_frame_pipeline

source
fn new_frame_pipeline(capacity? : Int) -> FramePipeline

#
new_frame_pipeline_window

source
fn new_frame_pipeline_window(duration_us : UInt64) -> FramePipelineWindow

#
new_frame_queue

source
fn new_frame_queue(capacity : Int) -> FrameQueue raise QueueError

Create a queue. Capacity zero means unlimited buffering.

#
new_frame_rate_limiter

source
fn new_frame_rate_limiter() -> FrameRateLimiter

#
new_gateway

source
fn new_gateway() -> CanGateway

Create an empty gateway.

#
new_gateway_policy_engine

source
fn new_gateway_policy_engine(capacity? : Int) -> GatewayPolicyEngine

#
new_isotp_receiver

source
fn new_isotp_receiver(config : IsoTpConfig) -> IsoTpReceiver

#
new_isotp_router

source
fn new_isotp_router() -> IsoTpRouter

#
new_isotp_session

source
fn new_isotp_session(flow_control : IsoTpFlowControlConfig, timeout_us : UInt64) -> IsoTpSession

#
new_isotp_stream_receiver

source
fn new_isotp_stream_receiver(flow_control : IsoTpFlowControlConfig, timeout_us : UInt64) -> IsoTpStreamReceiver

#
new_isotp_transmitter

source
fn new_isotp_transmitter(payload : Array[Byte], flow_control : IsoTpFlowControlConfig, started_us : UInt64) -> IsoTpTransmitter

Create a transmitter for a bounded payload.

#
new_j1939_address_manager

source
fn new_j1939_address_manager(timeout_us? : UInt64) -> J1939AddressManager

#
new_j1939_transport_session

source
fn new_j1939_transport_session(pgn : UInt, direction : J1939TransportDirection, timeout_us? : UInt64) -> J1939TransportSession

#
new_latency_window

source
fn new_latency_window(capacity : Int) -> LatencyWindow raise LatencyError

#
new_network_health_tracker

source
fn new_network_health_tracker(budget? : NetworkErrorBudget) -> NetworkHealthTracker

#
new_node_registry

source
fn new_node_registry() -> NodeRegistry

#
new_payload_codec

source
fn new_payload_codec(options? : PayloadCodecOptions) -> PayloadCodec

#
new_pdo_mapping

source
fn new_pdo_mapping(payload_bytes? : Int) -> PdoMapping raise PdoError

#
new_scheduler

source
fn new_scheduler() -> CanScheduler

#
new_simulation

source
fn new_simulation(capacity : Int, bitrate_kbps : UInt) -> Simulation

Create a simulation with a bounded or unbounded receive queue.

#
new_simulation_scenario

source
fn new_simulation_scenario(name : String, capacity? : Int, bitrate_kbps? : UInt) -> SimulationScenario

#
new_trace

source
fn new_trace() -> Trace

Create an empty trace.

#
new_trace_exporter

source
fn new_trace_exporter(options? : TraceExportOptions) -> TraceExporter

#
new_trace_query

source
fn new_trace_query() -> TraceQuerySpec

#
new_uds_session

source
fn new_uds_session(p2_timeout_us? : UInt64) -> UdsSession

#
parse_can_line

source
fn parse_can_line(line : String) -> (UInt64, Frame) raise CanTextError

Parse a compact two-field line.

#
parse_dbc

source
fn parse_dbc(input : String) -> Array[Message] raise DbcError

Parse the message/signal subset commonly used by simulation tools.

#
parse_dbc_database

source
fn parse_dbc_database(input : String) -> DbcDatabase raise DbcError

Build a database using the existing DBC subset parser.

#
parse_dbc_extended

source
fn parse_dbc_extended(input : String) -> DbcParseReport raise DbcExtendedError

Parse common factor, offset, range and unit fields in SG_ records.

#
parse_dtc_report

source
fn parse_dtc_report(payload : Array[Byte]) -> DtcReport raise DtcCodecError

Parse a positive ReadDTCInformation response.

#
parse_uds_response

source
fn parse_uds_response(request : DiagnosticRequest, payload : Array[Byte]) -> UdsResponseInfo raise UdsError

Parse a response and preserve the original payload for callers.

#
payload_codec_checksum

source
fn payload_codec_checksum(data : Array[Byte], excluded : Int) -> Byte

Compute an additive checksum excluding one byte position.

#
payload_codec_counter_valid

source
fn payload_codec_counter_valid(previous : Byte, current : Byte, modulus : Int) -> Bool

Validate a counter sequence against a modulus.

#
payload_codec_crc

source
fn payload_codec_crc(data : Array[Byte]) -> Byte

Compute a CRC over a payload prefix.

#
payload_codec_layout_valid

source
fn payload_codec_layout_valid(options : PayloadCodecOptions) -> Bool

Return whether a payload layout is internally consistent.

#
payload_codec_options

source
fn payload_codec_options(profile? : PayloadCodecProfile, counter_offset? : Int, counter_high_nibble? : Bool, crc_offset? : Int, checksum_offset? : Int, expected_length? : Int, counter_modulus? : Int) -> PayloadCodecOptions

#
payload_codec_pack_counter

source
fn payload_codec_pack_counter(payload : Array[Byte], counter : Byte, offset : Int, high_nibble : Bool) -> Array[Byte] raise PayloadError

Pack a sequence counter and payload into a fixed-length frame payload.

#
payload_codec_profile_text

source
fn payload_codec_profile_text(profile : PayloadCodecProfile) -> String

#
payload_codec_profile_variants

source
fn payload_codec_profile_variants() -> Array[PayloadCodecProfile]

#
payload_codec_report

source
fn payload_codec_report(codec : PayloadCodec) -> String

Produce a stable codec health report.

#
payload_codec_status_text

source
fn payload_codec_status_text(status : PayloadCodecStatus) -> String

#
payload_codec_status_variants

source
fn payload_codec_status_variants() -> Array[PayloadCodecStatus]

#
payload_set_uint

source
fn payload_set_uint(data : Array[Byte], offset : Int, width : Int, value : UInt, order : ByteOrder) -> Array[Byte] raise PayloadError

Insert an unsigned integer into a copied payload.

#
payload_uint

source
fn payload_uint(data : Array[Byte], offset : Int, width : Int, order : ByteOrder) -> UInt raise PayloadError

Extract an unsigned integer from a payload.

#
pdo_frame

source
fn pdo_frame(node_id : Byte, transmit_number : Byte, data : Array[Byte]) -> Frame raise PdoError

Build a PDO frame with the standard 11-bit COB-ID.

#
pgn

source
fn pgn(number : UInt, name : String, data_length : Int) -> Pgn

Describe a PGN for higher-level applications.

#
process_frame_batch

source
fn process_frame_batch(pipeline : FramePipeline, limiter : FrameRateLimiter, frames : Array[(UInt64, Frame)]) -> Array[Frame]

Run a pipeline and rate limiter together over a timestamped batch.

#
programming_diagnostic_session

source
fn programming_diagnostic_session() -> DiagnosticSessionProfile

Return a programming session profile.

#
read_data

source
fn read_data(identifier : UInt) -> DiagnosticRequest

Build a read-data-by-identifier request.

#
read_dtc_information

source
fn read_dtc_information(subfunction : Byte, mask : Byte) -> DiagnosticRequest

Build a DTC information request.

#
read_memory

source
fn read_memory(address : UInt, length : UInt, address_bytes? : Int, length_bytes? : Int) -> DiagnosticRequest raise UdsError

Build a memory read request using a compact address/length format.

#
remote_frame

source
fn remote_frame(id : UInt, extended? : Bool) -> Frame raise FrameError

Create a remote request frame.

#
request_download

source
fn request_download(data_format : Byte, address : UInt, length : UInt, address_bytes? : Int, length_bytes? : Int) -> DiagnosticRequest raise UdsError

Build a request-download command.

#
request_transfer_exit

source
fn request_transfer_exit(data? : Array[Byte]) -> DiagnosticRequest

#
reverse_payload

source
fn reverse_payload(data : Array[Byte], start : Int, end : Int) -> Array[Byte] raise PayloadError

Return a payload with bytes reversed in a selected range.

#
route_batch

source
fn route_batch(gateway : CanGateway, frames : Array[Frame]) -> Array[RoutedFrame] raise RoutingError

Route a batch and keep only successfully forwarded frames.

#
route_rule

source
fn route_rule(name : String, filter : Filter, output_id? : UInt?, output_extended? : Bool?, prefix? : Array[Byte], strip_prefix? : Int) -> RouteRule raise RoutingError

Construct a route rule with optional identifier and payload rewrites.

#
routine_control

source
fn routine_control(routine_type : Byte, identifier : UInt, data? : Array[Byte]) -> DiagnosticRequest raise UdsError

Build a routine-control request with an optional input record.

#
run_simulation_scenarios

source
fn run_simulation_scenarios(scenarios : Array[SimulationScenario]) -> Array[SimulationScenarioResult] raise SimulationError

Run multiple scenarios and return only failed results.

#
schedule_miss_rate

source
fn schedule_miss_rate(ticks : Array[SchedulerTick]) -> Double

Return the fraction of ticks that missed their deadline.

#
schedule_wire_bits

source
fn schedule_wire_bits(ticks : Array[SchedulerTick]) -> Int

Estimate the total wire bits for one scheduler window.

#
security_access

source
fn security_access(subfunction : Byte) -> DiagnosticRequest

Build a security-access seed/key request.

#
serialize_dbc_schema

source
fn serialize_dbc_schema(messages : Array[Message]) -> String raise DbcSchemaError

Serialize a schema to deterministic DBC text.

#
session_control

source
fn session_control(session : Byte) -> DiagnosticRequest

Build a session-control request.

#
set_bit

source
fn set_bit(bits : Array[Bool], position : Int, value : Bool) -> Array[Bool]

Set a bit in a defensive copy. Out-of-range positions are ignored.

#
set_counter_nibble

source
fn set_counter_nibble(data : Array[Byte], offset : Int, counter : Byte, high_nibble : Bool) -> Array[Byte] raise PayloadError

Insert a rolling counter into a payload nibble.

#
signal

source
fn signal(name : String, start_bit : Int, size : Int, little_endian? : Bool, signed? : Bool, factor? : Double, offset? : Double, minimum? : Double, maximum? : Double, unit? : String) -> Signal

Create a signal descriptor.

#
simulation_scenario_assertion_variants

source
fn simulation_scenario_assertion_variants() -> Array[SimulationScenarioAssertion]

#
simulation_scenario_event

source
fn simulation_scenario_event(timestamp_us : UInt64, frame : Frame, source? : String) -> SimulationScenarioEvent

#
simulation_scenario_state_text

source
fn simulation_scenario_state_text(state : SimulationScenarioState) -> String

#
simulation_scenario_state_variants

source
fn simulation_scenario_state_variants() -> Array[SimulationScenarioState]

#
simulation_scenario_summary

source
fn simulation_scenario_summary(results : Array[SimulationScenarioResult]) -> String

Produce a regression summary for scenario results.

#
sort_by_arbitration

source
fn sort_by_arbitration(frames : Array[Frame]) -> Array[Frame]

Return a stable arbitration-sorted copy.

#
sort_j1939

source
fn sort_j1939(messages : Array[J1939Message]) -> Array[J1939Message]

Return the standard J1939 priority ordering for messages.

#
stuff

source
fn stuff(bits : Array[Bool]) -> Array[Bool]

Apply CAN bit stuffing to a bit sequence.

#
tester_present

source
fn tester_present(suppress_response? : Bool) -> DiagnosticRequest

Build a tester-present request.

#
trace_diff

source
fn trace_diff(left : Trace, right : Trace, compare_timestamp? : Bool) -> Array[TraceDiff]

Compare two captures in order, reporting only observable differences.

#
trace_diff_kind_variants

source
fn trace_diff_kind_variants() -> Array[TraceDiffKind]

#
trace_export_between

source
fn trace_export_between(records : Array[TraceExportRecord], start_us : UInt64, end_us : UInt64) -> Array[TraceExportRecord]

Return records in a closed time interval.

#
trace_export_can_text

source
fn trace_export_can_text(records : Array[TraceExportRecord], options : TraceExportOptions) -> String

#
trace_export_csv

source
fn trace_export_csv(records : Array[TraceExportRecord], options : TraceExportOptions) -> String

#
trace_export_difference_count

source
fn trace_export_difference_count(left : Array[TraceExportRecord], right : Array[TraceExportRecord]) -> Int

Compare two export streams and return a compact diff count.

#
trace_export_filter_id

source
fn trace_export_filter_id(records : Array[TraceExportRecord], identifier : UInt) -> Array[TraceExportRecord]

Return records belonging to one identifier.

#
trace_export_format_variants

source
fn trace_export_format_variants() -> Array[TraceExportFormat]

#
trace_export_intervals

source
fn trace_export_intervals(records : Array[TraceExportRecord], identifier : UInt) -> Array[UInt64]

Calculate inter-arrival times for one identifier.

#
trace_export_options

source
fn trace_export_options(format? : TraceExportFormat, include_channel? : Bool, include_sequence? : Bool, include_header? : Bool, normalize_timestamps? : Bool, max_rows? : Int) -> TraceExportOptions

#
trace_export_record

source
fn trace_export_record(timestamp_us : UInt64, sequence : Int, channel : String, frame : Frame) -> TraceExportRecord

#
trace_export_records

source
fn trace_export_records(trace : Trace, channel? : String, normalize_timestamps? : Bool) -> Array[TraceExportRecord]

Convert a trace into ordered export records.

#
trace_export_replay_script

source
fn trace_export_replay_script(records : Array[TraceExportRecord]) -> String

#
trace_export_sample

source
fn trace_export_sample(records : Array[TraceExportRecord], stride : Int) -> Array[TraceExportRecord]

Produce a bounded sample for a large trace export.

#
trace_export_summary

source
fn trace_export_summary(records : Array[TraceExportRecord]) -> String

#
trace_export_time_range

source
fn trace_export_time_range(records : Array[TraceExportRecord]) -> (UInt64, UInt64)?

Return the earliest and latest timestamps in an export.

#
trace_from_text

source
fn trace_from_text(text : String) -> Trace raise TraceError

Parse a trace produced by Trace::to_text.

#
trace_import_can_text

source
fn trace_import_can_text(text : String) -> Trace raise CanTextError

Parse a compact CAN-text export generated by this package.

#
trace_metrics

source
fn trace_metrics(trace : Trace) -> FrameMetrics

Compute metrics directly from a trace.

#
trace_query

source
fn trace_query(trace : Trace, query : TraceQuerySpec) -> Array[TraceQueryMatch]

Select entries from a trace without changing capture order.

#
trace_query_buckets

source
fn trace_query_buckets(trace : Trace, start_us : UInt64, end_us : UInt64, bucket_us : UInt64) -> Array[TraceQueryBucket]

Partition a trace into fixed-width buckets.

#
trace_query_first

source
fn trace_query_first(trace : Trace, query : TraceQuerySpec) -> TraceQueryMatch?

Return the first query match, if any.

#
trace_query_identifier_counts

source
fn trace_query_identifier_counts(matches : Array[TraceQueryMatch]) -> Array[(UInt, Int)]

Count frames by identifier in a query result.

#
trace_query_last

source
fn trace_query_last(trace : Trace, query : TraceQuerySpec) -> TraceQueryMatch?

Return the last query match, if any.

#
trace_query_matches

source
fn trace_query_matches(frame : Frame, predicates : Array[TraceQueryPredicate]) -> Bool

#
trace_query_matches_predicate

source
fn trace_query_matches_predicate(frame : Frame, predicate : TraceQueryPredicate) -> Bool

Return whether a frame matches one predicate.

#
trace_query_predicate_variants

source
fn trace_query_predicate_variants() -> Array[TraceQueryPredicate]

#
trace_query_summary

source
fn trace_query_summary(matches : Array[TraceQueryMatch]) -> String

Return a stable textual summary of a trace query.

#
trace_replay_plan

source
fn trace_replay_plan(trace : Trace, scale_num? : UInt64, scale_den? : UInt64) -> TraceReplayPlan

#
transfer_data

source
fn transfer_data(block_counter : Byte, data : Array[Byte]) -> DiagnosticRequest raise UdsError

Build a transfer-data block.

#
uds_negative_code_name

source
fn uds_negative_code_name(code : Byte) -> String

Return a stable description for common UDS negative response codes.

#
uds_service_id

source
fn uds_service_id(service : UdsService) -> Byte

Return the numeric service identifier.

#
uds_service_name

source
fn uds_service_name(service : UdsService) -> String

Return the service's stable diagnostic name.

#
uds_session_name

source
fn uds_session_name(state : UdsSessionState) -> String

Return a stable state label.

#
validate_dbc_schema

source
fn validate_dbc_schema(messages : Array[Message]) -> DbcSchemaReport raise DbcSchemaError

Validate identifiers, payload bounds and signal overlap.

#
validate_frame

source
fn validate_frame(frame : Frame) -> FrameReport

Validate protocol and simulation invariants.

#
validate_j1939

source
fn validate_j1939(value : J1939Id) -> Unit raise J1939Error

Validate a J1939 identifier's fields.

#
wire_round_trip

source
fn wire_round_trip(frame : Frame) -> Bool

Verify that a frame's wire encoding can be decoded without loss.

#
write_data

source
fn write_data(identifier : UInt, data : Array[Byte]) -> DiagnosticRequest raise UdsError

Build a write-data-by-identifier request.

#
write_memory

source
fn write_memory(address : UInt, data : Array[Byte], address_bytes? : Int) -> DiagnosticRequest raise UdsError

Build a memory write request.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io