fennec-modbus 0.92.0

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use core::marker::PhantomData;

use crate::protocol::{
    Function,
    codec::{Decode, Encode},
};

pub mod read_multiple;
mod size_argument;
pub mod write_multiple;

/// Associates function code with function type.
pub trait Code {
    /// Modbus function code.
    const CODE: u8;
}

/// Function response output.
pub trait IntoValue {
    type Value;

    /// Unwrap the function response output.
    fn into_value(self) -> Self::Value;
}

/// Read coils.
///
/// Type parameters bind to the address, value, and codec types.
pub struct ReadCoils<A, V>(PhantomData<(A, V)>);

impl<A, V> Code for ReadCoils<A, V> {
    const CODE: u8 = 1;
}

impl<A, V> Function for ReadCoils<A, V>
where
    read_multiple::Args<A, V, size_argument::Bits>: Encode,
    read_multiple::Output<V>: Decode,
{
    type Args = read_multiple::Args<A, V, size_argument::Bits>;
    type Output = read_multiple::Output<V>;
}

/// Read discrete inputs.
pub struct ReadDiscreteInputs<A, V>(PhantomData<(A, V)>);

impl<A, V> Code for ReadDiscreteInputs<A, V> {
    const CODE: u8 = 2;
}

impl<A, V> Function for ReadDiscreteInputs<A, V>
where
    read_multiple::Args<A, V, size_argument::Bits>: Encode,
    read_multiple::Output<V>: Decode,
{
    type Args = read_multiple::Args<A, V, size_argument::Bits>;
    type Output = read_multiple::Output<V>;
}

/// Read holding registers.
pub struct ReadHoldingRegisters<A, V>(PhantomData<(A, V)>);

impl<A, V> Code for ReadHoldingRegisters<A, V> {
    const CODE: u8 = 3;
}

impl<A, V> Function for ReadHoldingRegisters<A, V>
where
    read_multiple::Args<A, V, size_argument::Words>: Encode,
    read_multiple::Output<V>: Decode,
{
    type Args = read_multiple::Args<A, V, size_argument::Words>;
    type Output = read_multiple::Output<V>;
}

/// Read input registers.
pub struct ReadInputRegisters<A, V>(PhantomData<(A, V)>);

impl<A, V> Code for ReadInputRegisters<A, V> {
    const CODE: u8 = 4;
}

impl<A, V> Function for ReadInputRegisters<A, V>
where
    read_multiple::Args<A, V, size_argument::Words>: Encode,
    read_multiple::Output<V>: Decode,
{
    type Args = read_multiple::Args<A, V, size_argument::Words>;
    type Output = read_multiple::Output<V>;
}

/// Write multiple registers.
pub struct WriteMultipleRegisters<A, V>(PhantomData<(A, V)>);

impl<A, V> Code for WriteMultipleRegisters<A, V> {
    const CODE: u8 = 16;
}

impl<A, V> Function for WriteMultipleRegisters<A, V>
where
    write_multiple::Args<A, V, size_argument::Words>: Encode,
{
    type Args = write_multiple::Args<A, V, size_argument::Words>;
    type Output = write_multiple::Output;
}