[zencan-cli] Add scan-pdo-config command to CLI

Author: mcbridejc

Cargo.toml

@@ -31,7 +31,6 @@ zencan-node = { path = "zencan-node" }
 # External
 crc16 = "0.4.0"
 critical-section = { version = "1.2.0", default-features = false }
-crossbeam = { version = "0.8.4", default-features = false }
 defmt = "1.0.1"
 defmt-or-log = { version = "0.2.1", default-features = false }
 embedded-io = { version = "0.6.1" }

examples/socketcan_node/example_pdo_config.toml

@@ -0,0 +1,9 @@
+ [tpdo.0]
+ enabled = true
+ cob = 0x800
+ extended = true
+ transmission_type = 254
+ mappings = [
+     { index=0x2000, sub=0, size=16 },
+     { index=0x2001, sub=1, size=16 },
+ ]

integration_tests/tests/pdo_tests.rs

@@ -264,7 +264,7 @@ async fn test_pdo_configuration() {
 
     let test_task = async move {
         let config = PdoConfig {
-            cob: 0x301,
+            cob: CanId::std(0x301),
             enabled: true,
             mappings: vec![
                 PdoMapping {

zencan-cli/Cargo.toml

@@ -29,3 +29,6 @@ tokio = { version = "1.45.0", features = ["net", "macros", "rt-multi-thread"] }
 reedline = "0.40.0"
 shlex = "1.3.0"
 clap-num = "1.2.0"
+
+[dev-dependencies]
+assertables = "9.8.2"

zencan-cli/src/bin/zencan-cli.rs

@@ -19,7 +19,7 @@ use reedline::{
 use shlex::Shlex;
 use zencan_cli::command::{Cli, Commands, LssCommands, NmtAction, SdoDataType};
 use zencan_client::{
-    common::{lss::LssState, traits::AsyncCanSender, NodeId},
+    common::{lss::LssState, node_id::ConfiguredNodeId, traits::AsyncCanSender, NodeId},
     open_socketcan, BusManager, NodeConfig,
 };
 
@@ -374,7 +374,6 @@ async fn run_command<S: AsyncCanSender + Sync + Send>(cmd: Commands, manager: &m
                 },
                 Err(e) => {
                     println!("Error reading object: {e}");
-                    return;
                 }
             }
         }
@@ -417,11 +416,59 @@ async fn run_command<S: AsyncCanSender + Sync + Send>(cmd: Commands, manager: &m
                 Err(e) => println!("Error: {e}"),
             }
         }
+        Commands::ScanPdoConfig(args) => {
+            let node_id = match ConfiguredNodeId::new(args.node_id) {
+                Ok(id) => id,
+                Err(_) => {
+                    println!("{} is not a valid node ID", args.node_id);
+                    return;
+                }
+            };
+
+            match manager.read_pdo_config(node_id).await {
+                Ok(pdos) => {
+                    println!("Node {node_id}");
+                    for (i, pdo) in pdos.tpdos.iter().enumerate() {
+                        println!("TPDO{i}:");
+                        println!(
+                            "  valid={}, COB={}, transmission_type={}",
+                            pdo.enabled, pdo.cob, pdo.transmission_type
+                        );
+                        if !pdo.mappings.is_empty() {
+                            println!("  mapping: ");
+                            for m in &pdo.mappings {
+                                println!(
+                                    "    - index=0x{:x}, sub={}, size={}",
+                                    m.index, m.sub, m.size
+                                );
+                            }
+                        }
+                    }
+                    for (i, pdo) in pdos.rpdos.iter().enumerate() {
+                        println!("RPDO{i}:");
+                        println!(
+                            "  valid={}, COB={}, transmission_type={}",
+                            pdo.enabled, pdo.cob, pdo.transmission_type
+                        );
+                        if !pdo.mappings.is_empty() {
+                            println!("  mapping: ");
+                            for m in &pdo.mappings {
+                                println!(
+                                    "    - index=0x{:x}, sub={}, size={}",
+                                    m.index, m.sub, m.size
+                                );
+                            }
+                        }
+                    }
+                }
+                Err(e) => println!("Error reading PDO config: {e}"),
+            }
+        }
     }
 }
 
 fn parse_command(line: &str) -> Result<Cli, clap::Error> {
-    match shlex::split(&line) {
+    match shlex::split(line) {
         Some(split) => {
             Cli::try_parse_from(std::iter::once("").chain(split.iter().map(String::as_str)))
         }

zencan-cli/src/command.rs

@@ -17,6 +17,8 @@ pub enum Commands {
     Write(WriteArgs),
     /// Scan all node IDs to find configured devices
     Scan,
+    /// Scan the PDO configuration from a node
+    ScanPdoConfig(ScanPdoConfigArgs),
     /// Print info about nodes
     Info,
     /// Load a configuration from a file to a node
@@ -72,6 +74,11 @@ pub struct WriteArgs {
     pub value: String,
 }
 
+#[derive(Debug, Args)]
+pub struct ScanPdoConfigArgs {
+    pub node_id: u8,
+}
+
 #[derive(Debug, Args)]
 pub struct LoadConfigArgs {
     /// The ID of the node to load the configuration into

zencan-client/Cargo.toml

@@ -31,6 +31,9 @@ tokio = { version = "1.45.0", features = [
 toml = "0.8.22"
 serde = { version = "1.0.219", features = ["derive"] }
 
+[dev-dependencies]
+assertables = "9.8.2"
+
 # docs.rs-specific configuration
 [package.metadata.docs.rs]
 # defines the configuration attribute `docsrs`

zencan-client/src/bus_manager/bus_manager.rs

@@ -5,16 +5,22 @@ use std::{collections::HashMap, sync::Arc, time::Instant};
 
 use futures::future::join_all;
 use tokio::task::JoinHandle;
+use zencan_common::constants::object_ids::{
+    RPDO_COMM_BASE, RPDO_MAP_BASE, TPDO_COMM_BASE, TPDO_MAP_BASE,
+};
 use zencan_common::lss::{LssIdentity, LssState};
 use zencan_common::messages::{NmtCommand, NmtCommandSpecifier, NmtState, ZencanMessage};
+use zencan_common::node_id::ConfiguredNodeId;
+use zencan_common::sdo::AbortCode;
+use zencan_common::CanId;
 use zencan_common::{
     traits::{AsyncCanReceiver, AsyncCanSender},
     NodeId,
 };
 
 use super::shared_sender::SharedSender;
 use crate::sdo_client::{SdoClient, SdoClientError};
-use crate::{LssError, LssMaster};
+use crate::{LssError, LssMaster, PdoConfig, PdoMapping, RawAbortCode};
 
 use super::shared_receiver::{SharedReceiver, SharedReceiverChannel};
 
@@ -150,6 +156,79 @@ async fn scan_node<S: AsyncCanSender + Sync + Send>(
     })
 }
 
+/// Result struct for reading PDO configuration from a single node
+#[derive(Clone, Debug)]
+pub struct PdoScanResult {
+    /// List of TPDO configurations
+    pub tpdos: Vec<PdoConfig>,
+    /// List of RPDO configurations
+    pub rpdos: Vec<PdoConfig>,
+}
+
+async fn read_pdos<S: AsyncCanSender + Sync + Send, R: AsyncCanReceiver>(
+    mut comm_base: u16,
+    mut mapping_base: u16,
+    client: &mut SdoClient<S, R>,
+) -> Result<Vec<PdoConfig>, SdoClientError> {
+    let mut result = Vec::new();
+
+    loop {
+        let _comm_max_sub = match client.read_u8(comm_base, 0).await {
+            Ok(val) => val,
+            // This error is expected; this means there are no more PDOs to read
+            Err(SdoClientError::ServerAbort {
+                index: _,
+                sub: _,
+                abort_code: RawAbortCode::Valid(AbortCode::NoSuchObject),
+            }) => break,
+            // Any other error is unexpected
+            Err(e) => {
+                return Err(e);
+            }
+        };
+
+        let cob_value = client.read_u32(comm_base, 1).await?;
+        let transmission_type = client.read_u8(comm_base, 2).await?;
+
+        let frame = (cob_value & (1 << 29)) != 0;
+        let enabled = (cob_value & (1 << 31)) == 0;
+        let cob_id = cob_value & 0x1FFFFFFF;
+        let cob = if frame {
+            CanId::extended(cob_id)
+        } else {
+            CanId::std((cob_id & 0x7ff) as u16)
+        };
+        let num_mappings = client.read_u8(mapping_base, 0).await?;
+        let mut mappings = Vec::new();
+        for i in 0..num_mappings {
+            let map_param = client.read_u32(mapping_base, i + 1).await?;
+            mappings.push(PdoMapping::from_object_value(map_param));
+        }
+
+        result.push(PdoConfig {
+            cob,
+            enabled,
+            mappings,
+            transmission_type,
+        });
+        comm_base += 1;
+        mapping_base += 1;
+    }
+    Ok(result)
+}
+
+async fn read_rpdo_config<S: AsyncCanSender + Sync + Send, R: AsyncCanReceiver>(
+    client: &mut SdoClient<S, R>,
+) -> Result<Vec<PdoConfig>, SdoClientError> {
+    read_pdos(RPDO_COMM_BASE, RPDO_MAP_BASE, client).await
+}
+
+async fn read_tpdo_config<S: AsyncCanSender + Sync + Send, R: AsyncCanReceiver>(
+    client: &mut SdoClient<S, R>,
+) -> Result<Vec<PdoConfig>, SdoClientError> {
+    read_pdos(TPDO_COMM_BASE, TPDO_MAP_BASE, client).await
+}
+
 #[derive(Debug)]
 pub struct SdoClientGuard<'a, S, R>
 where
@@ -470,4 +549,19 @@ impl<S: AsyncCanSender + Sync + Send> BusManager<S> {
         let message = NmtCommand { cs: cmd, node };
         self.sender.send(message.into()).await.ok();
     }
+
+    /// Read the RPDO and TPDO configuration for the specified node
+    ///
+    /// node - The node ID to read from
+    pub async fn read_pdo_config(
+        &mut self,
+        node: ConfiguredNodeId,
+    ) -> Result<PdoScanResult, SdoClientError> {
+        let mut client = self.sdo_client(node.raw());
+
+        let tpdos = read_tpdo_config(&mut client).await?;
+        let rpdos = read_rpdo_config(&mut client).await?;
+
+        Ok(PdoScanResult { tpdos, rpdos })
+    }
 }