fennec-modbus 0.90.3

Modular Modbus client implementation
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

use alloc::vec::Vec;
use core::fmt::Debug;

use crate::protocol::{
    Function,
    function,
    function::{ReadRegisters, ReadRegistersExact, read_registers},
};

/// Abstraction over async Modbus clients.
///
/// Concrete implementations get the provided shortcut functions for common operations.
pub trait AsyncClient {
    /// Server address type which allows to support proprietary node addressing like, for example, in Modbus+.
    type UnitId: Debug;

    type Error: From<crate::protocol::Error>;

    /// Call the Modbus function.
    ///
    /// This is a lower-level interface that allows calling any [`Function`], including user-defined ones.
    #[expect(async_fn_in_trait)]
    async fn call<F: Function>(
        &self,
        unit_id: Self::UnitId,
        args: F::Args,
    ) -> Result<F::Output, Self::Error>;

    /// Read the contents of a contiguous block of registers in a remote device
    /// and parse them as values of type `V`.
    #[expect(async_fn_in_trait)]
    #[cfg_attr(feature = "tracing", tracing::instrument(skip_all, level = "trace"))]
    async fn read_registers<C: function::Code, V: read_registers::Value>(
        &self,
        unit_id: Self::UnitId,
        starting_address: u16,
        n_values: usize,
    ) -> Result<Vec<V>, Self::Error> {
        #[cfg(feature = "tracing")]
        tracing::trace!(?unit_id, starting_address, n_values, "reading holding registers…");

        let args = read_registers::Args::new(starting_address, n_values)?;
        Ok(self.call::<ReadRegisters<C, V>>(unit_id, args).await?.values)
    }

    /// Read the contents of a contiguous block of holding registers in a remote device
    /// and parse them as `N` values of type `V`.
    ///
    /// This is the same function as [`Self::read_registers`] – but with the register count known at compile time.
    #[expect(async_fn_in_trait)]
    #[cfg_attr(feature = "tracing", tracing::instrument(skip_all, level = "trace"))]
    async fn read_registers_exact<C: function::Code, V: read_registers::Value, const N: usize>(
        &self,
        unit_id: Self::UnitId,
        starting_address: u16,
    ) -> Result<[V; N], Self::Error> {
        #[cfg(feature = "tracing")]
        tracing::trace!(?unit_id, starting_address, N, "reading registers…");

        let args = read_registers::Args::new(starting_address, N)?;
        Ok(self.call::<ReadRegistersExact<C, V, N>>(unit_id, args).await?.values)
    }

    /// Convenience method to read a single value from one or more registers and unpack it.
    #[expect(async_fn_in_trait)]
    async fn read_registers_value<C: function::Code, V: read_registers::Value>(
        &self,
        unit_id: Self::UnitId,
        address: u16,
    ) -> Result<V, Self::Error> {
        let [value] = self.read_registers_exact::<C, V, 1>(unit_id, address).await?;
        Ok(value)
    }
}