Add create_timer to node (WIP) (#4)

* Added timer_period_ns

* Adds Timer::is_ready().

Signed-off-by: Agustin Alba Chicar <[email protected]>

* Added comments to avoid warnings

* Added the getter for rcl_clock_t

* WIP add create_timer to node

* Cleaning some stuff

---------

Signed-off-by: Agustin Alba Chicar <[email protected]>
Co-authored-by: Agustin Alba Chicar <[email protected]>

Author: JesusSilvaUtrera

rclrs/src/node.rs

@@ -16,9 +16,12 @@ 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, Timer, TimerCallback, TimeSource, ToLogParams, ENTITY_LIFECYCLE_MUTEX,
 };
 
+/// Constant conversion from seconds to nanoseconds
+const S_TO_NS: f64 = 1e9;
+
 // SAFETY: The functions accessing this type, including drop(), shouldn't care about the thread
 // they are running in. Therefore, this type can be safely sent to another thread.
 unsafe impl Send for rcl_node_t {}
@@ -63,6 +66,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 +344,31 @@ impl Node {
         Ok(subscription)
     }
 
+    /// Creates a [`Timer`]
+    pub(crate) fn create_timer(
+        &self,
+        timer_period_s: i64,
+        context: Context,
+        callback: Option<TimerCallback>,
+        clock: Option<Clock>
+    ) -> Arc<Timer> {
+        let timer_period_ns = (timer_period_s as f64 * S_TO_NS) as i64;
+        let clock_used;
+        match clock {
+            Some(value) => {
+                clock_used = value;
+            }
+            None => {
+                clock_used = self.get_clock();
+            }
+        }
+        let context = Context::new(vec![]).unwrap();
+        let timer = Timer::new(&clock_used, &context, timer_period_ns);
+        let timer = Arc::new(timer.unwrap());
+        self.timers_mtx.lock().unwrap().push(Arc::downgrade(&timer) as Weak<Timer>);
+        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() }

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(),