probe-rs-tools 0.31.0

A collection of on chip debugging tools to communicate with microchips.
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use std::io::Write;

use bytesize::ByteSize;

use crate::rpc::{client::RpcClient, functions::chip::MemoryRegion};

#[derive(clap::Parser)]
pub struct Cmd {
    #[clap(subcommand)]
    subcommand: Subcommand,
}

#[derive(clap::Subcommand)]
/// Inspect internal registry of supported chips
enum Subcommand {
    /// Lists all the available families and their chips with their full.
    #[clap(name = "list")]
    List,
    /// Shows chip properties of a specific chip
    #[clap(name = "info")]
    Info {
        /// The name of the chip to display.
        name: String,
    },
}

impl Cmd {
    pub async fn run(self, client: RpcClient) -> anyhow::Result<()> {
        let output = std::io::stdout().lock();

        match self.subcommand {
            Subcommand::List => print_families(&client, output).await,
            Subcommand::Info { name } => print_chip_info(&client, output, &name).await,
        }
    }
}

/// Print all the available families and their contained chips to the
/// commandline.
pub async fn print_families(client: &RpcClient, mut output: impl Write) -> anyhow::Result<()> {
    writeln!(output, "Available chips:")?;
    let families = client.list_chip_families().await?;
    for family in families {
        writeln!(output, "{}", &family.name)?;
        writeln!(output, "    Variants:")?;
        for variant in family.variants {
            writeln!(output, "        {}", variant.name)?;
        }
    }
    Ok(())
}

/// Print all the available families and their contained chips to the
/// commandline.
pub async fn print_chip_info(
    client: &RpcClient,
    mut output: impl Write,
    name: &str,
) -> anyhow::Result<()> {
    writeln!(output, "{name}")?;
    let target = client.chip_info(name).await?;
    writeln!(output, "Cores ({}):", target.cores.len())?;
    for core in target.cores {
        writeln!(
            output,
            "    - {} ({:?})",
            core.name.to_ascii_lowercase(),
            core.core_type
        )?;
    }

    fn get_range_len(range: &std::ops::Range<u64>) -> u64 {
        range.end - range.start
    }

    for memory in target.memory_map {
        let range = memory.address_range();
        let size = ByteSize(get_range_len(&range)).display().iec();
        let kind = match memory {
            MemoryRegion::Ram(_) => "RAM",
            MemoryRegion::Generic(_) => "Generic",
            MemoryRegion::Nvm(_) => "NVM",
        };
        writeln!(output, "{kind}: {range:#010x?} ({size})")?
    }
    Ok(())
}

#[cfg(test)]
mod test {
    use super::*;
    use std::future::Future;

    async fn run_on_local_server<F, Fut>(f: F)
    where
        F: Fn(RpcClient) -> Fut,
        Fut: Future<Output = ()>,
    {
        use crate::rpc::functions::RpcApp;

        // Create a local server to run commands against.
        let (mut local_server, tx, rx) =
            RpcApp::create_server(16, crate::rpc::functions::ProbeAccess::All);
        let handle = tokio::spawn(async move { local_server.run().await });

        // Run the command locally.
        let client = RpcClient::new_local_from_wire(tx, rx);

        f(client).await;

        // Wait for the server to shut down
        _ = handle.await.unwrap();
    }

    #[tokio::test]
    async fn single_chip_output() {
        run_on_local_server(|client| {
            async move {
                let mut buff = Vec::new();

                print_chip_info(&client, &mut buff, "nrf52840_xxaa")
                    .await
                    .unwrap();

                // output should be valid utf8
                let output = String::from_utf8(buff).unwrap();

                insta::assert_snapshot!(output);
            }
        })
        .await;
    }

    #[tokio::test]
    async fn multiple_chip_output() {
        run_on_local_server(|client| async move {
            let mut buff = Vec::new();

            let error = print_chip_info(&client, &mut buff, "nrf52")
                .await
                .unwrap_err();

            insta::assert_snapshot!(error.to_string());
        })
        .await;
    }
}