autd3-rs 0.2.0

Core async client library for the AUTD3 phased-array kit.
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

use std::num::{NonZeroU32, NonZeroUsize};

use core_affinity::CoreId;
use thread_priority::ThreadPriority;

use crate::error::{Error, PayloadError};
use crate::protocol::MAX_IN_FLIGHT;

pub const MAX_DEVICES: usize = 128;

#[derive(Clone, Copy, Debug)]
pub struct ClientConfig {
    pub timeout_cycles: u32,
    pub max_inflight: NonZeroUsize,
    pub send_interval_cycles: NonZeroU32,
    pub max_resync_rounds: NonZeroU32,
    pub low_latency: bool,
    pub reset_resend_cycles: u32,
    pub rt_priority: Option<ThreadPriority>,
    pub rt_affinity: Option<CoreId>,
    pub validate_state: bool,
}

impl Default for ClientConfig {
    fn default() -> Self {
        Self {
            timeout_cycles: 10,
            max_inflight: NonZeroUsize::new(MAX_IN_FLIGHT).unwrap(),
            send_interval_cycles: NonZeroU32::new(1).unwrap(),
            max_resync_rounds: NonZeroU32::new(8).unwrap(),
            low_latency: false,
            reset_resend_cycles: 2,
            rt_priority: None,
            rt_affinity: None,
            validate_state: true,
        }
    }
}

impl ClientConfig {
    pub(super) fn validate(self) -> Result<Self, Error> {
        if self.max_inflight.get() > MAX_IN_FLIGHT {
            return Err(Error::InvalidPayload(PayloadError::MaxInFlightTooLarge {
                max: MAX_IN_FLIGHT,
            }));
        }
        Ok(self)
    }
}