Basic Timer implementation

examples/rclrs_timer_demo/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "rclrs_timer_demo"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name="rclrs_timer_demo"
+path="src/rclrs_timer_demo.rs"
+
+
+[dependencies]
+rclrs = "*"

examples/rclrs_timer_demo/package.xml

@@ -0,0 +1,13 @@
+<package format="3">
+  <name>rclrs_timer_demo</name>
+  <version>0.1.0</version>
+  <description>Shows how to implement a timer within a Node using rclrs.</description>
+  <maintainer email="user@todo.todo">user</maintainer>
+  <license>TODO: License declaration.</license>
+
+  <depend>rclrs</depend>
+
+  <export>
+    <build_type>ament_cargo</build_type>
+  </export>
+</package>

examples/rclrs_timer_demo/src/rclrs_timer_demo.rs

@@ -0,0 +1,48 @@
+/// Creates a SimpleTimerNode, initializes a node and the timer with a callback
+/// that prints the timer callback execution iteration. The callback is executed
+/// thanks to the spin, which is in charge of executing the timer's events among
+/// other entities' events.
+use rclrs::{create_node, Context, Node, RclrsError, Timer};
+use std::{
+    env,
+    sync::{Arc, Mutex},
+};
+
+/// Contains both the node and timer.
+struct SimpleTimerNode {
+    node: Arc<Node>,
+    timer: Arc<Timer>,
+}
+
+impl SimpleTimerNode {
+    /// Creates a node and a timer with a callback.
+    ///
+    /// The callback will simply print to stdout:
+    /// "Drinking 🧉 for the xth time every p nanoseconds."
+    /// where x is the iteration callback counter and p is the period of the timer.
+    fn new(context: &Context, timer_period_ns: i64) -> Result<Self, RclrsError> {
+        let node = create_node(context, "simple_timer_node")?;
+        let count: Arc<Mutex<i32>> = Arc::new(Mutex::new(0));
+        let timer = node.create_timer(
+            timer_period_ns,
+            context,
+            Some(Box::new(move |_| {
+                let x = *count.lock().unwrap();
+                println!(
+                    "Drinking 🧉 for the {}th time every {} nanoseconds.",
+                    x, timer_period_ns
+                );
+                *count.lock().unwrap() = x + 1;
+            })),
+            None,
+        )?;
+        Ok(Self { node, timer })
+    }
+}
+
+fn main() -> Result<(), RclrsError> {
+    let timer_period: i64 = 1e9 as i64; // 1 seconds.
+    let context = Context::new(env::args()).unwrap();
+    let simple_timer_node = Arc::new(SimpleTimerNode::new(&context, timer_period).unwrap());
+    rclrs::spin(simple_timer_node.node.clone())
+}

rclrs/src/clock.rs

@@ -83,6 +83,11 @@ impl Clock {
         }
     }
 
+    /// Returns the clock's `rcl_clock_t`.
+    pub(crate) fn get_rcl_clock(&self) -> &Arc<Mutex<rcl_clock_t>> {
+        &self.rcl_clock
+    }
+
     /// Returns the clock's `ClockType`.
     pub fn clock_type(&self) -> ClockType {
         self.kind

rclrs/src/executor.rs

@@ -48,7 +48,11 @@ impl SingleThreadedExecutor {
             })
         {
             let wait_set = WaitSet::new_for_node(&node)?;
-            let ready_entities = wait_set.wait(timeout)?;
+            let mut ready_entities = wait_set.wait(timeout)?;
+
+            for ready_timer in ready_entities.timers.iter_mut() {
+                ready_timer.execute()?;
+            }
 
             for ready_subscription in ready_entities.subscriptions {
                 ready_subscription.execute()?;

rclrs/src/lib.rs

@@ -20,6 +20,7 @@ mod service;
 mod subscription;
 mod time;
 mod time_source;
+mod timer;
 mod vendor;
 mod wait;
 
@@ -49,6 +50,7 @@ pub use service::*;
 pub use subscription::*;
 pub use time::*;
 use time_source::*;
+pub use timer::*;
 pub use wait::*;
 
 /// Polls the node for new messages and executes the corresponding callbacks.

rclrs/src/node.rs

@@ -16,7 +16,7 @@ use crate::{
     rcl_bindings::*, Client, ClientBase, Clock, Context, ContextHandle, GuardCondition, LogParams,
     Logger, ParameterBuilder, ParameterInterface, ParameterVariant, Parameters, Publisher,
     QoSProfile, RclrsError, Service, ServiceBase, Subscription, SubscriptionBase,
-    SubscriptionCallback, TimeSource, ToLogParams, ENTITY_LIFECYCLE_MUTEX,
+    SubscriptionCallback, TimeSource, Timer, TimerCallback, ToLogParams, ENTITY_LIFECYCLE_MUTEX,
 };
 
 // SAFETY: The functions accessing this type, including drop(), shouldn't care about the thread
@@ -63,6 +63,7 @@ pub struct Node {
     pub(crate) guard_conditions_mtx: Mutex<Vec<Weak<GuardCondition>>>,
     pub(crate) services_mtx: Mutex<Vec<Weak<dyn ServiceBase>>>,
     pub(crate) subscriptions_mtx: Mutex<Vec<Weak<dyn SubscriptionBase>>>,
+    pub(crate) timers_mtx: Mutex<Vec<Weak<Timer>>>,
     time_source: TimeSource,
     parameter: ParameterInterface,
     pub(crate) handle: Arc<NodeHandle>,
@@ -340,6 +341,30 @@ impl Node {
         Ok(subscription)
     }
 
+    /// Creates a [`Timer`][1].
+    ///
+    /// [1]: crate::Timer
+    /// TODO: make timer's lifetime depend on node's lifetime.
+    pub fn create_timer(
+        &self,
+        period_ns: i64,
+        context: &Context,
+        callback: Option<TimerCallback>,
+        clock: Option<Clock>,
+    ) -> Result<Arc<Timer>, RclrsError> {
+        let clock_used = match clock {
+            Some(value) => value,
+            None => self.get_clock(),
+        };
+        let timer = Timer::new(&clock_used, &context, period_ns, callback)?;
+        let timer = Arc::new(timer);
+        self.timers_mtx
+            .lock()
+            .unwrap()
+            .push(Arc::downgrade(&timer) as Weak<Timer>);
+        Ok(timer)
+    }
+
     /// Returns the subscriptions that have not been dropped yet.
     pub(crate) fn live_subscriptions(&self) -> Vec<Arc<dyn SubscriptionBase>> {
         { self.subscriptions_mtx.lock().unwrap() }
@@ -369,6 +394,13 @@ impl Node {
             .collect()
     }
 
+    pub(crate) fn live_timers(&self) -> Vec<Arc<Timer>> {
+        { self.timers_mtx.lock().unwrap() }
+            .iter()
+            .filter_map(Weak::upgrade)
+            .collect()
+    }
+
     /// Returns the ROS domain ID that the node is using.
     ///
     /// The domain ID controls which nodes can send messages to each other, see the [ROS 2 concept article][1].
@@ -551,6 +583,21 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_create_timer_without_clock_source() -> Result<(), RclrsError> {
+        let timer_period_ns: i64 = 1e6 as i64; // 1 millisecond.
+        let context = Context::new([])?;
+        let dut = NodeBuilder::new(&context, "node_with_timer")
+            .namespace("test_create_timer")
+            .build()?;
+
+        let _timer =
+            dut.create_timer(timer_period_ns, &context, Some(Box::new(move |_| {})), None)?;
+        assert_eq!(dut.live_timers().len(), 1);
+
+        Ok(())
+    }
+
     #[test]
     fn test_logger_name() -> Result<(), RclrsError> {
         // Use helper to create 2 nodes for us

rclrs/src/node/builder.rs

@@ -340,6 +340,7 @@ impl NodeBuilder {
             guard_conditions_mtx: Mutex::new(vec![]),
             services_mtx: Mutex::new(vec![]),
             subscriptions_mtx: Mutex::new(vec![]),
+            timers_mtx: Mutex::new(vec![]),
             time_source: TimeSource::builder(self.clock_type)
                 .clock_qos(self.clock_qos)
                 .build(),

rclrs/src/rcl_bindings.rs

@@ -89,6 +89,10 @@ cfg_if::cfg_if! {
         #[derive(Debug)]
         pub struct rcl_wait_set_t;
 
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct rcl_timer_t;
+
         #[repr(C)]
         #[derive(Debug)]
         pub struct rcutils_string_array_t;