Simplified pub/sub example to be more user friendly to new users (#26)

Author: kydos

ros-z/examples/z_pubsub.rs

@@ -1,100 +1,66 @@
 use std::time::Duration;
 
 use ros_z::{Builder, Result, context::ZContextBuilder};
-use ros_z_msgs::std_msgs::{ByteMultiArray, MultiArrayLayout};
+use ros_z_msgs::std_msgs::ByteMultiArray;
 
-use clap::Parser;
-#[derive(Debug, Parser)]
-struct Args {
-    #[arg(short, long, default_value = "64")]
-    payload: usize,
-    #[arg(short, long, default_value = "1")]
-    rate: usize,
-    #[arg(short, long, default_value = "default_topic")]
-    topic: String,
-    #[arg(short, long, default_value = "0")]
-    duration: f64,
-    #[arg(short, long, default_value = "sub")]
-    mode: String,
-}
-
-fn run_subscriber(topic: String, duration: Duration) -> Result<()> {
+async fn run_subscriber(topic: String) -> Result<()> {
     let ctx = ZContextBuilder::default().build()?;
-    let node = ctx.create_node("MyNode").build()?;
+    let node = ctx.create_node("Sub").build()?;
     let zsub = node.create_sub::<ByteMultiArray>(&topic).build()?;
-
-    let mut counter = 0;
-    if duration.is_zero() {
-        loop {
-            let _msg = zsub.recv()?;
-            tracing::info!("Recv {counter}-th msg");
-            counter += 1;
-        }
-    } else {
-        let fut = async {
-            loop {
-                match zsub.async_recv().await {
-                    Ok(_msg) => {
-                        tracing::info!("Recv {counter}-th msg");
-                    }
-                    Err(err) => {
-                        tracing::error!(err);
-                        break;
-                    }
-                }
-                counter += 1;
-            }
-        };
-        tokio::runtime::Runtime::new()?.block_on(async {
-            tokio::time::timeout(duration, fut).await?;
-            Result::Ok(())
-        })?;
+    let mut counter = 1;
+    while let Ok(msg) = zsub.async_recv().await {
+        println!("sub:>> #{counter}: {}", String::from_utf8_lossy(&msg.data));
+        counter += 1;
     }
-
     Ok(())
 }
 
-fn run_publisher(
-    topic: String,
-    duration: Duration,
-    period: Duration,
-    payload_size: usize,
-) -> Result<()> {
+async fn run_publisher(topic: String, period: Duration, payload: String) -> Result<()> {
     let ctx = ZContextBuilder::default().build()?;
-    let node = ctx.create_node("MyNode").build()?;
+    let node = ctx.create_node("Pub").build()?;
     let zpub = node.create_pub::<ByteMultiArray>(&topic).build()?;
-    let now = std::time::Instant::now();
-    let msg = ByteMultiArray {
-        layout: MultiArrayLayout::default(),
-        data: vec![0u8; payload_size as _],
-    };
+
+    let mut count = 0;
     loop {
-        zpub.publish(&msg)?;
-        std::thread::sleep(period);
-        if !duration.is_zero() && now.elapsed() >= duration {
-            break;
-        }
+        let bs = format!("{payload} - #{count}");
+        println!("pub:>> {bs}");
+        let msg = ByteMultiArray {
+            data: bs.into(),
+            ..Default::default()
+        };
+        zpub.async_publish(&msg).await?;
+        let _ = tokio::time::sleep(period).await;
+        count += 1;
     }
-    Ok(())
 }
 
-fn main() -> Result<()> {
+#[tokio::main]
+async fn main() -> Result<()> {
     let args = Args::parse();
-    let duration = std::time::Duration::from_secs_f64(args.duration);
-    let period = std::time::Duration::from_secs_f64(1.0 / args.rate as f64);
+    let period = std::time::Duration::from_secs_f64(args.period);
     zenoh::init_log_from_env_or("error");
-    tracing::info!(
-        "Begin testing with topic: {}, duration: {duration:?}, payload: {}, rate: {} Hz",
-        args.topic,
-        args.payload,
-        args.rate
-    );
     if args.mode == "sub" {
-        run_subscriber(args.topic, duration)?;
+        run_subscriber(args.topic).await?;
     } else if args.mode == "pub" {
-        run_publisher(args.topic, duration, period, args.payload)?;
+        run_publisher(args.topic, period, args.data).await?;
     } else {
-        tracing::error!("The mode {} is not supported.", args.mode);
+        println!(
+            "Please use \"pub\" or \"sub\" as mode,  {} is not supported.",
+            args.mode
+        );
     }
     Ok(())
 }
+
+use clap::Parser;
+#[derive(Debug, Parser)]
+struct Args {
+    #[arg(short, long, default_value = "Hello ROS-Z")]
+    data: String,
+    #[arg(short, long, default_value = "rosz/hello")]
+    topic: String,
+    #[arg(short, long, default_value = "1.0")]
+    period: f64,
+    #[arg(short, long, default_value = "sub")]
+    mode: String,
+}