darra-ethercat-master 2.7.0

Commercial EtherCAT master protocol stack, real-time kernel driver integration, Windows and Linux support, multi-language SDKs, complex topology and hot-plug support.
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


use crate::data::error::{EcState, LinkState, RedundancyState, CiA402State, CiA402Mode};
use crate::slave::core::Slave;
use crate::utils::ffi::SlaveIdentity;

impl From<&Slave> for SlaveIdentity {

    fn from(s: &Slave) -> Self {
        SlaveIdentity {
            vendor_id: s.vendor_id(),
            product_code: s.product_id(),
            revision_no: s.rev_id(),
            serial_no: 0,
        }
    }
}

impl From<Slave> for SlaveIdentity {
    fn from(s: Slave) -> Self {
        (&s).into()
    }
}

impl From<u8> for EcState {

    fn from(v: u8) -> Self {
        EcState::from_raw(v).unwrap_or(EcState::None)
    }
}

impl From<EcState> for u8 {

    fn from(s: EcState) -> u8 {
        s as u8
    }
}

impl From<EcState> for i32 {

    fn from(s: EcState) -> i32 {
        (s as u8) as i32
    }
}

impl From<u8> for LinkState {
    fn from(v: u8) -> Self {
        LinkState::from_raw(v)
    }
}

impl From<LinkState> for u8 {
    fn from(s: LinkState) -> u8 {
        s as u8
    }
}

impl From<i32> for RedundancyState {
    fn from(v: i32) -> Self {
        RedundancyState::from_raw(v)
    }
}

impl From<RedundancyState> for i32 {
    fn from(s: RedundancyState) -> i32 {
        s as i32
    }
}

impl From<i32> for CiA402State {
    fn from(v: i32) -> Self {
        CiA402State::from_raw(v)
    }
}

impl From<CiA402State> for i32 {
    fn from(s: CiA402State) -> i32 {
        s as i32
    }
}

impl From<CiA402Mode> for i8 {
    fn from(m: CiA402Mode) -> i8 {
        m as i8
    }
}

impl From<CiA402Mode> for i32 {
    fn from(m: CiA402Mode) -> i32 {
        (m as i8) as i32
    }
}

impl From<EcState> for &'static str {
    fn from(s: EcState) -> &'static str {
        match s {
            EcState::None => "None",
            EcState::Init => "Init",
            EcState::PreOp => "PreOp",
            EcState::Boot => "Boot",
            EcState::SafeOp => "SafeOp",
            EcState::Operational => "OP",
        }
    }
}

impl From<LinkState> for &'static str {
    fn from(s: LinkState) -> &'static str {
        match s {
            LinkState::Disconnected => "Disconnected",
            LinkState::Connected => "Connected",
            LinkState::Redundancy => "Redundancy",
            LinkState::PrimaryOnly => "PrimaryOnly",
            LinkState::SecondaryOnly => "SecondaryOnly",
        }
    }
}

impl From<RedundancyState> for &'static str {
    fn from(s: RedundancyState) -> &'static str {
        match s {
            RedundancyState::None => "None",
            RedundancyState::Primary => "PrimaryOnly",
            RedundancyState::Secondary => "SecondaryOnly",
            RedundancyState::Both => "Both",
        }
    }
}