autd3-rs 0.6.1

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
50

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

use autd3_rs_core::CoreId;
use autd3_rs_core::RtSchedulePolicy;
use thread_priority::ThreadPriority;

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

pub const MAX_DEVICES: usize = 128;

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

impl Default for ClientConfig {
    fn default() -> Self {
        Self {
            timeout_cycles: NonZeroU32::new(10).unwrap(),
            max_inflight: NonZeroUsize::new(MAX_INFLIGHT).unwrap(),
            max_resync_rounds: NonZeroU32::new(8).unwrap(),
            low_latency: false,
            reset_resend_cycles: NonZeroU32::new(2).unwrap(),
            rt_priority: autd3_rs_core::default_rt_priority(),
            rt_policy: RtSchedulePolicy::default(),
            rt_affinity: None,
            validate_state: true,
            require_supported_firmware: false,
        }
    }
}

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