mbus-async 0.14.0

Native async Modbus client and server stack for Tokio-based applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Async client module.
//!
//! Public entry points:
//! - [`AsyncTcpClient`] (TCP)
//! - [`AsyncSerialClient`] (RTU/ASCII)
//!
//! # Module layout
//!
//! | Module | Contents |
//! |---|---|
//! | `command` | `ClientRequest` and `TaskCommand` channel envelopes |
//! | `response` | `ClientResponse` typed result enum |
//! | `notifier` | [`AsyncClientTrafficNotifier`] traffic hook trait (`traffic` feature) |
//! | `client_core` | [`AsyncClientCore`] — public request API |
//! | `network_client` | [`AsyncTcpClient`] — TCP constructor |
//! | `serial_client` | [`AsyncSerialClient`] — serial constructor |

pub(crate) mod command;
pub(crate) mod decode;
pub(crate) mod encode;
#[cfg(feature = "traffic")]
pub mod notifier;
pub(crate) mod response;
pub(crate) mod task;

mod client_core;
mod network_client;
mod serial_client;

pub use client_core::AsyncClientCore;
pub use network_client::AsyncTcpClient;
#[cfg(feature = "traffic")]
pub use notifier::AsyncClientTrafficNotifier;
#[cfg(any(feature = "serial-rtu", feature = "serial-ascii"))]
pub use serial_client::AsyncSerialClientKind;
pub use serial_client::{AsyncAsciiClient, AsyncRtuClient, AsyncSerialClient};

use mbus_core::errors::MbusError;
#[cfg(feature = "diagnostics")]
use mbus_core::function_codes::public::DiagnosticSubFunction;
#[cfg(feature = "diagnostics")]
pub use mbus_core::models::diagnostic::{DeviceIdentificationResponse, ObjectId, ReadDeviceIdCode};
#[cfg(feature = "file-record")]
pub use mbus_core::models::file_record::{SubRequest, SubRequestParams};

#[cfg(feature = "diagnostics")]
/// Diagnostics response payload returned by FC 08.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiagnosticsDataResponse {
    /// Echoed diagnostic sub-function code.
    pub sub_function: DiagnosticSubFunction,
    /// Echoed diagnostic data words.
    pub data: Vec<u16>,
}
#[cfg(feature = "diagnostics")]
/// Communication event log payload `(status, event_count, message_count, events)` returned by FC 12.
pub type CommEventLogResponse = (u16, u16, u16, Vec<u8>);

/// Async facade error type.
#[derive(Debug, PartialEq, Eq)]
pub enum AsyncError {
    /// Error propagated from the underlying Modbus client stack.
    Mbus(MbusError),
    /// Background worker channel is closed or worker thread has stopped.
    WorkerClosed,
    /// Internal response routing mismatch between request and callback payload type.
    UnexpectedResponseType,
    /// Per-request timeout elapsed before the server responded.
    ///
    /// Set via [`AsyncClientCore::set_request_timeout`].  The in-flight entry
    /// remains in the background task until the transport delivers or errors;
    /// call [`connect`](AsyncClientCore::connect) to reset transport state.
    ///
    /// [`AsyncClientCore::set_request_timeout`]: crate::client::AsyncClientCore::set_request_timeout
    /// [`connect`]: crate::client::AsyncClientCore::connect
    Timeout,
}

impl From<MbusError> for AsyncError {
    fn from(value: MbusError) -> Self {
        Self::Mbus(value)
    }
}

impl core::fmt::Display for AsyncError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::Mbus(err) => write!(f, "Modbus error: {err:?}"),
            Self::WorkerClosed => write!(f, "async worker channel closed"),
            Self::UnexpectedResponseType => write!(f, "unexpected response type from worker"),
            Self::Timeout => write!(f, "request timed out"),
        }
    }
}

impl std::error::Error for AsyncError {}