fennec-modbus 0.95.2

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use core::marker::PhantomData;

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

pub mod read_multiple;
pub mod read_write_multiple;
pub 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.
#[must_use]
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.
#[must_use]
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.
#[must_use]
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.
#[must_use]
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.
#[must_use]
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;
}

/// Read and write multiple registers.
///
/// The write operation is performed *before* the read.
#[must_use]
pub struct ReadWriteRegisters<ReadAddress, ReadValue, WriteAddress, WriteValue>(
    /// Binding to the address type to read.
    PhantomData<ReadAddress>,
    /// Binding to the value type to read.
    PhantomData<ReadValue>,
    /// Binding to the address type to write.
    PhantomData<WriteAddress>,
    /// Binding to the value type to write.
    PhantomData<WriteValue>,
);

impl<ReadAddress, ReadValue, WriteAddress, WriteValue> Code
    for ReadWriteRegisters<ReadAddress, ReadValue, WriteAddress, WriteValue>
{
    const CODE: u8 = 23;
}

impl<ReadAddress, ReadValue, WriteAddress, WriteValue> Function
    for ReadWriteRegisters<ReadAddress, ReadValue, WriteAddress, WriteValue>
where
    read_write_multiple::Args<ReadAddress, ReadValue, WriteAddress, WriteValue>: Encode,
    read_multiple::Output<ReadValue>: Decode,
{
    type Args = read_write_multiple::Args<ReadAddress, ReadValue, WriteAddress, WriteValue>;
    type Output = read_multiple::Output<ReadValue>;
}