autd3-driver 38.1.0

AUTD3 driver
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

use autd3_core::{
    datagram::{
        Datagram, DatagramOption, DatagramS, DeviceMask, Inspectable, InspectionResult,
        internal::HasSegment,
    },
    environment::Environment,
    firmware::{Segment, transition_mode::TransitionMode},
    geometry::Geometry,
};

/// A wrapper of [`DatagramS`] to specify the segment to write the data.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct WithSegment<T: TransitionMode, D> {
    /// The original [`DatagramS`]
    pub inner: D,
    /// The segment to write the data
    pub segment: Segment,
    /// Whether to transition the segment
    pub transition_mode: T,
}

impl<'a, T, D> WithSegment<T, D>
where
    T: TransitionMode,
    D: DatagramS<'a> + HasSegment<T>,
{
    /// Create a new [`WithSegment`].
    #[must_use]
    pub const fn new(inner: D, segment: Segment, transition_mode: T) -> Self {
        Self {
            inner,
            segment,
            transition_mode,
        }
    }
}

impl<'a, T, D> Datagram<'a> for WithSegment<T, D>
where
    T: TransitionMode,
    D: DatagramS<'a> + HasSegment<T>,
{
    type G = D::G;
    type Error = D::Error;

    fn operation_generator(
        self,
        geometry: &'a Geometry,
        env: &Environment,
        filter: &DeviceMask,
    ) -> Result<Self::G, Self::Error> {
        <D as DatagramS>::operation_generator_with_segment(
            self.inner,
            geometry,
            env,
            filter,
            self.segment,
            self.transition_mode.params(),
        )
    }

    fn option(&self) -> DatagramOption {
        <D as DatagramS>::option(&self.inner)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct WithSegmentInspectionResult<I, T: TransitionMode> {
    pub inner: I,
    pub segment: Segment,
    pub transition_mode: T,
}

impl<'a, T, D> Inspectable<'a> for WithSegment<T, D>
where
    T: TransitionMode,
    D: Inspectable<'a> + DatagramS<'a> + HasSegment<T>,
    <D as DatagramS<'a>>::Error: From<<D as Datagram<'a>>::Error>,
{
    type Result = WithSegmentInspectionResult<D::Result, T>;

    fn inspect(
        self,
        geometry: &'a Geometry,
        env: &Environment,
        filter: &DeviceMask,
    ) -> Result<InspectionResult<Self::Result>, Self::Error> {
        Ok(InspectionResult {
            result: self
                .inner
                .inspect(geometry, env, filter)?
                .result
                .into_iter()
                .map(|r| {
                    r.map(|r| WithSegmentInspectionResult {
                        inner: r,
                        segment: self.segment,
                        transition_mode: self.transition_mode,
                    })
                })
                .collect(),
        })
    }
}