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


use crate::data::error::EcState;
use crate::slave::core::Slave;

pub trait SlaveIterExt: Iterator<Item = Slave> + Sized {

    fn by_state(self, state: EcState) -> ByState<Self> {
        ByState { inner: self, target: state }
    }

    fn by_group(self, group: u8) -> ByGroup<Self> {
        ByGroup { inner: self, group }
    }

    fn by_vendor(self, vendor_id: u32) -> ByVendor<Self> {
        ByVendor { inner: self, vendor_id }
    }

    fn filter_slave<F: FnMut(&Slave) -> bool>(self, pred: F) -> FilterSlave<Self, F> {
        FilterSlave { inner: self, pred }
    }

    fn with_dc(self) -> WithDc<Self> {
        WithDc { inner: self }
    }
}

impl<I: Iterator<Item = Slave>> SlaveIterExt for I {}

pub struct ByState<I> {
    inner: I,
    target: EcState,
}

impl<I: Iterator<Item = Slave>> Iterator for ByState<I> {
    type Item = Slave;
    fn next(&mut self) -> Option<Self::Item> {
        let target = self.target;
        self.inner.find(|s| s.state().map(|st| st == target).unwrap_or(false))
    }
}

pub struct ByGroup<I> {
    inner: I,
    group: u8,
}

impl<I: Iterator<Item = Slave>> Iterator for ByGroup<I> {
    type Item = Slave;
    fn next(&mut self) -> Option<Self::Item> {
        let g = self.group;
        self.inner.find(|s| s.group() == g)
    }
}

pub struct ByVendor<I> {
    inner: I,
    vendor_id: u32,
}

impl<I: Iterator<Item = Slave>> Iterator for ByVendor<I> {
    type Item = Slave;
    fn next(&mut self) -> Option<Self::Item> {
        let v = self.vendor_id;
        self.inner.find(|s| s.vendor_id() == v)
    }
}

pub struct FilterSlave<I, F> {
    inner: I,
    pred: F,
}

impl<I, F> Iterator for FilterSlave<I, F>
where
    I: Iterator<Item = Slave>,
    F: FnMut(&Slave) -> bool,
{
    type Item = Slave;
    fn next(&mut self) -> Option<Self::Item> {
        let pred = &mut self.pred;
        self.inner.find(|s| pred(s))
    }
}

pub struct WithDc<I> {
    inner: I,
}

impl<I: Iterator<Item = Slave>> Iterator for WithDc<I> {
    type Item = Slave;
    fn next(&mut self) -> Option<Self::Item> {
        self.inner.find(|s| {

            s.detailed_info().map(|info| info.hasdc != 0).unwrap_or(false)
        })
    }
}