ashv2 6.0.1

Implementation of the Asynchronous Serial Host (ASH) 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

# ashv2

Asynchronous Serial Host protocol, version 2

## Documentation

The official protocol description can be found
at [silabs.com](https://docs.silabs.com/zigbee/latest/uart-gateway-protocol-reference/).

## Usage

This library provides the `Actor` struct which implements the [actor model](https://en.wikipedia.org/wiki/Actor_model)
for the ASHv2 protocol.

It is to be initialized with the underlying serial port ASH transmitter and response channel size.

```rust
use ashv2::{Actor, BaudRate, FlowControl, open};
use tokio::sync::mpsc::channel;

#[tokio::main]
async fn main() {
    // Open the serial port connected to the NCP.
    let serial_port = open("/dev/ttymxc3", BaudRate::RstCts, FlowControl::Hardware)
        .expect("Failed to open serial port");

    // Crate a response channel with a specified size.
    let (response_tx, response_rx) = channel(64);
    // Create the ASHv2 actor, which returns the actor,
    // a proxy to communicate with it, and a receiver for responses.
    let actor = Actor::new(serial_port, response_tx, 64).expect("Failed to create actor");
    // Spawn the actor's tasks to handle communication.
    // This also returns a proxy to communicate with the actor.
    let (tasks, proxy) = actor.spawn();

    // Send a data frame to the NCP using the proxy.
    // Example: EZSP version command
    let request_data = vec![0x00, 0x00, 0x00, 0x02];
    proxy
        .send(request_data.into_iter().collect())
        .await
        .expect("Failed to send request")
        .await
        .expect("Failed to receive response")
        .expect("Actor reported an error");

    // Receive a response from the NCP.
    if let Some(response) = response_rx.recv().await {
        println!("Received response: {response:?}");
    }

    let _serial_port = tasks.terminate().await.expect("Actor tasks failed to join");
}
```

Expected result:

```
Received response: [0, 128, 0, 8, 2, 48, 106]
```

## Legal

This project is free software and is not affiliated with Silicon Labs.

## Contribution guidelines

* Use `cargo fmt`
* Check code with `cargo clippy`

## Credits

* Special thanks to *Simon Farnsworth*, *Kevin Reid* and the rest of the great community
  at [users.rust-lang.org](https://users.rust-lang.org/).