nican 0.4.0

A Nican driver.
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

mod api;
mod constant;
mod constants;
mod driver;
mod frame;

pub use self::{constants::*, driver::*, frame::*};

use rs_can::{CanDevice, CanFilter, CanResult, DeviceBuilder};

#[async_trait::async_trait]
impl CanDevice for NiCan {
    type Channel = String;
    type Frame = NiCanFrame;

    fn new(builder: DeviceBuilder<String>) -> CanResult<Self> {
        let libpath = builder.get_other::<String>(LIBPATH)?;
        let mut device = NiCan::new(libpath.as_deref())?;
        builder
            .channel_configs()
            .iter()
            .try_for_each(|(chl, cfg)| {
                let filters = cfg
                    .get_other::<Vec<CanFilter>>(FILTERS)?
                    .unwrap_or_default();
                let bitrate = cfg.nominal_bitrate;
                let log_error = cfg.get_other::<bool>(LOG_ERROR)?.unwrap_or_default();

                device.open(chl, filters, bitrate, log_error)
            })?;

        Ok(device)
    }

    #[inline]
    fn is_closed(&self) -> bool {
        self.channels.is_empty()
    }

    #[inline]
    fn opened_channels(&self) -> Vec<Self::Channel> {
        self.channels.keys().map(|v| v.clone()).collect()
    }

    #[inline]
    async fn transmit(&self, msg: Self::Frame, _: Option<u32>) -> CanResult<()> {
        self.transmit_can(msg)
    }

    #[inline]
    async fn receive(
        &self,
        channel: Self::Channel,
        timeout: Option<u32>,
    ) -> CanResult<Vec<Self::Frame>> {
        self.receive_can(channel, timeout)
    }

    #[inline]
    fn shutdown(&mut self) {
        self.channels.iter().for_each(|(c, ctx)| {
            let ret = unsafe { (self.ncCloseObject)(ctx.handle) };

            if let Err(e) = self.check_status(c, ret) {
                rsutil::warn!(
                    "{} error {} when close",
                    Self::channel_info(c),
                    self.status_to_str(e)
                );
            }
        });

        self.channels.clear();
    }
}