socketcan-rs 0.3.0

SocketCAN driver with UDS protocol.
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

[![Latest version](https://img.shields.io/crates/v/socketcan-rs.svg)](https://crates.io/crates/socketcan-rs)
[![Documentation](https://docs.rs/socketcan-rs/badge.svg)](https://docs.rs/socketcan-rs)
![LGPL](https://img.shields.io/badge/license-LGPL-green.svg)
![MIT](https://img.shields.io/badge/license-MIT-yellow.svg)

## Overview
**socketcan-rs** is a driver for SocketCAN device.

It is a part of rust-can driver.

- v0.1.x is deprecated
- v0.2.x is sync
- v0.3.x and over is async

### Prerequisites
- Rust 1.80 or higher
- Cargo (included with Rust)

### Adding to Your Project

To use **socketcan-rs** in your Rust project, add it as a dependency in your `Cargo.toml`:

```toml
[dependencies]
socketcan-rs = { version="lastest-version" }
rs-can = { version="lastest-version" }
```

```shell
sudo ip link add dev vcan0 type vcan
sudo ip link set dev vcan0 up
candump vcan0   # show vcan0 message
```

```rust
use rs_can::{CanDevice, CanError, CanFrame, DeviceBuilder};
use socketcan_rs::{CanMessage, SocketCan};

#[tokio::main]
async fn main() -> Result<(), CanError> {
    let iface = "vcan0".to_string();
    let mut builder = DeviceBuilder::new();
    builder.add_config(iface.clone(), Default::default());

    let device = builder.build::<SocketCan>()?;

    let data = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07];
    let mut message = CanMessage::new(0x1234, &data).unwrap();
    message.set_channel(iface.clone());
    device.transmit(message, None).await?;

    let data = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08];
    let mut message = CanMessage::new(0x1234, &data).unwrap();
    message.set_channel(iface.clone());
    device.transmit(message, None).await?;

    loop {
        match device.receive(iface.clone(), None).await {
            Ok(frames) =>
                if !frames.is_empty() {
                    frames.into_iter()
                        .for_each(|f| println!("{}", f));
                    break;
                }
            Err(e) => match e {
                CanError::TimeoutError(_) => {},
                e => return Err(e),
            }
        }
    }

    Ok(())
}
```

## Contributing

We're always looking for users who have thoughts on how to make `socketcan-rs` better, or users with
interesting use cases.

Of course, we're also happy to accept code contributions for outstanding feature requests!