Make rclrs no_std compatible (#60)

* Convert error to mostly c-style enums
Implement display for result code
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* Remove unused imports
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* Re-implement `to_rcl_result`
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* Initial transcription of `context`
Note: no default implementation due to `no_std`
lacking environment variable support...
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* Forgot to include custom Mutex (Spinlock)
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* Fix missing dependencies
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* Fix more missing dependencies
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* Generate `no_std` compatible bindings
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* First working version of `no_std` code
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* Quick `cargo fmt` run
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

* Replace custom spinlock with `spin` crate.
Also enable a "std" feature for compilation.
Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: Jacob Hassold <[email protected]>

Author: jhdcs

rclrs/Cargo.toml

@@ -5,10 +5,17 @@ authors = ["Esteve Fernandez <[email protected]>"]
 edition = "2018"
 
 [dependencies]
-anyhow = {version = "1", features = ["backtrace"]}
 libc = "0.2.43"
-parking_lot = "0.11"
-thiserror = "1"
+lock_api = "0.4.5"
+cstr_core = "0.2"
+cty = "0.2"
+core-error = "0.0.0"
+parking_lot = {version = "0.11.2", optional = true}
+spin = "0.9.2"
 
 [build-dependencies]
-bindgen = "0.59.1"
+bindgen = "0.59.1"
+
+[features]
+default = ["std"]
+std = ["parking_lot"]

rclrs/build.rs

@@ -6,6 +6,8 @@ use std::path::PathBuf;
 fn main() {
     let mut builder = bindgen::Builder::default()
         .header("src/rcl_wrapper.h")
+        .use_core()
+        .ctypes_prefix("cty")
         .derive_copy(false)
         .size_t_is_usize(true)
         .default_enum_style(bindgen::EnumVariation::Rust {

rclrs/src/context.rs

@@ -1,12 +1,16 @@
 use crate::error::ToResult;
 use crate::rcl_bindings::*;
 use crate::Node;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use cstr_core::{c_char, CString};
+use rclrs_common::error::RclReturnCode;
+
+#[cfg(not(feature = "std"))]
+use spin::{Mutex, MutexGuard};
+
+#[cfg(feature = "std")]
 use parking_lot::{Mutex, MutexGuard};
-use rclrs_common::error::RclError;
-use std::env;
-use std::ffi::CString;
-use std::os::raw::c_char;
-use std::sync::Arc;
 
 pub struct ContextHandle(Mutex<rcl_context_t>);
 
@@ -37,12 +41,8 @@ pub struct Context {
 }
 
 impl Context {
-    fn init(&self) -> Result<(), RclError> {
-        let args: Vec<CString> = env::args()
-            .filter_map(|arg| CString::new(arg).ok())
-            .collect();
-
-        let c_args: Vec<*const c_char> = args.iter().map(|arg| arg.as_ptr()).collect();
+    fn init(&self, context_env_args: Vec<CString>) -> Result<(), RclReturnCode> {
+        let c_args: Vec<*const c_char> = context_env_args.iter().map(|arg| arg.as_ptr()).collect();
         let handle = &mut *self.handle.lock();
 
         unsafe {
@@ -62,24 +62,22 @@ impl Context {
         Ok(())
     }
 
-    pub fn ok(&self) -> Result<bool, RclError> {
-        let handle = &mut *self.handle.lock();
-        unsafe { Ok(rcl_context_is_valid(handle as *mut _)) }
-    }
-
-    pub fn create_node(&self, node_name: &str) -> Result<Node, RclError> {
-        Ok(Node::new(node_name, self)?)
-    }
-}
-
-impl Default for Context {
-    fn default() -> Self {
+    pub fn default(args: Vec<CString>) -> Self {
         let context = Self {
             handle: Arc::new(ContextHandle(Mutex::new(unsafe {
                 rcl_get_zero_initialized_context()
             }))),
         };
-        context.init().unwrap();
+        context.init(args).unwrap(); // If we can't initialize the context, ROS 2 cannot function
         context
     }
+
+    pub fn ok(&self) -> Result<bool, RclReturnCode> {
+        let handle = &mut *self.handle.lock();
+        unsafe { Ok(rcl_context_is_valid(handle as *mut _)) }
+    }
+
+    pub fn create_node(&self, node_name: &str) -> Result<Node, RclReturnCode> {
+        Ok(Node::new(node_name, self)?)
+    }
 }

rclrs/src/error.rs

@@ -1,16 +1,16 @@
 use crate::rcl_bindings::*;
-pub use rclrs_common::error::{to_rcl_result, RclError};
+pub use rclrs_common::error::{to_rcl_result, RclReturnCode};
 
 pub(crate) trait ToResult {
-    fn ok(&self) -> Result<(), RclError>;
+    fn ok(&self) -> Result<(), RclReturnCode>;
 
     fn unwrap(&self) {
         self.ok().unwrap();
     }
 }
 
 impl ToResult for rcl_ret_t {
-    fn ok(&self) -> Result<(), RclError> {
+    fn ok(&self) -> Result<(), RclReturnCode> {
         to_rcl_result(*self as i32)
     }
 }

rclrs/src/lib.rs

@@ -1,7 +1,21 @@
+#![no_std]
+extern crate alloc;
+extern crate core_error;
+
+#[cfg(feature = "std")]
+extern crate std;
+
+#[cfg(feature = "std")]
+extern crate parking_lot;
+
+#[cfg(not(feature = "std"))]
+extern crate spin;
+
 pub mod context;
 pub mod error;
 pub mod node;
 pub mod qos;
+// pub mod spinlock;
 pub mod wait;
 
 mod rcl_bindings;
@@ -12,9 +26,8 @@ pub use self::node::*;
 pub use self::qos::*;
 
 use self::rcl_bindings::*;
-use rclrs_common::error::WaitSetError;
-use std::ops::{Deref, DerefMut};
-use wait::WaitSet;
+use core::ops::{Deref, DerefMut};
+use wait::{WaitSet, WaitSetErrorResponse};
 
 pub trait Handle<T> {
     type DerefT: Deref<Target = T>;
@@ -25,13 +38,12 @@ pub trait Handle<T> {
 }
 
 /// Wrapper around [`spin_once`]
-pub fn spin<'node>(node: &'node node::Node) -> Result<(), WaitSetError> {
+pub fn spin<'node>(node: &'node node::Node) -> Result<(), WaitSetErrorResponse> {
     while unsafe { rcl_context_is_valid(&mut *node.context.lock() as *mut _) } {
         if let Some(error) = spin_once(node, 500).err() {
             match error {
-                WaitSetError::DroppedSubscription | WaitSetError::RclError(RclError::Timeout) => {
-                    continue
-                }
+                WaitSetErrorResponse::DroppedSubscription
+                | WaitSetErrorResponse::ReturnCode(RclReturnCode::Timeout) => continue,
                 error => return Err(error),
             };
         }
@@ -77,7 +89,7 @@ pub fn spin<'node>(node: &'node node::Node) -> Result<(), WaitSetError> {
 ///         +--------------------+
 ///
 ///
-pub fn spin_once<'node>(node: &'node Node, timeout: i64) -> Result<(), WaitSetError> {
+pub fn spin_once<'node>(node: &'node Node, timeout: i64) -> Result<(), WaitSetErrorResponse> {
     let number_of_subscriptions = node.subscriptions.len();
     let number_of_guard_conditions = 0;
     let number_of_timers = 0;
@@ -100,7 +112,7 @@ pub fn spin_once<'node>(node: &'node Node, timeout: i64) -> Result<(), WaitSetEr
     for subscription in &node.subscriptions {
         match wait_set.add_subscription(subscription) {
             Ok(()) => (),
-            Err(WaitSetError::DroppedSubscription) => (),
+            Err(WaitSetErrorResponse::DroppedSubscription) => (),
             Err(err) => return Err(err),
         };
     }

rclrs/src/node/mod.rs

@@ -1,18 +1,27 @@
+use alloc::{
+    sync::{Arc, Weak},
+    vec::Vec,
+};
+
+use crate::error::ToResult;
 use crate::qos::QoSProfile;
 use crate::rcl_bindings::*;
-use crate::ToResult;
-use crate::{Context, ContextHandle};
-use rclrs_common::error::RclError;
-use std::ffi::CString;
-use std::sync::{Arc, Weak};
 
-use parking_lot::{Mutex, MutexGuard};
+use crate::{Context, ContextHandle};
+use cstr_core::CString;
+use rclrs_common::error::RclReturnCode;
 
 pub mod publisher;
 pub use self::publisher::*;
 pub mod subscription;
 pub use self::subscription::*;
 
+#[cfg(not(feature = "std"))]
+use spin::{Mutex, MutexGuard};
+
+#[cfg(feature = "std")]
+use parking_lot::{Mutex, MutexGuard};
+
 pub struct NodeHandle(Mutex<rcl_node_t>);
 
 impl NodeHandle {
@@ -44,15 +53,15 @@ pub struct Node {
 
 impl Node {
     #[allow(clippy::new_ret_no_self)]
-    pub fn new<'ctxt>(node_name: &str, context: &Context) -> Result<Node, RclError> {
+    pub fn new<'ctxt>(node_name: &str, context: &Context) -> Result<Node, RclReturnCode> {
         Self::new_with_namespace(node_name, "", context)
     }
 
     pub fn new_with_namespace<'ctxt>(
         node_name: &str,
         node_ns: &str,
         context: &Context,
-    ) -> Result<Node, RclError> {
+    ) -> Result<Node, RclReturnCode> {
         let raw_node_name = CString::new(node_name).unwrap();
         let raw_node_ns = CString::new(node_ns).unwrap();
 
@@ -76,7 +85,7 @@ impl Node {
         Ok(Node {
             handle,
             context: context.handle.clone(),
-            subscriptions: vec![],
+            subscriptions: alloc::vec![],
         })
     }
 
@@ -85,7 +94,7 @@ impl Node {
         &self,
         topic: &str,
         qos: QoSProfile,
-    ) -> Result<Publisher<T>, RclError>
+    ) -> Result<Publisher<T>, RclReturnCode>
     where
         T: rclrs_common::traits::MessageDefinition<T>,
     {
@@ -98,7 +107,7 @@ impl Node {
         topic: &str,
         qos: QoSProfile,
         callback: F,
-    ) -> Result<Arc<Subscription<T>>, RclError>
+    ) -> Result<Arc<Subscription<T>>, RclReturnCode>
     where
         T: rclrs_common::traits::MessageDefinition<T> + Default,
         F: FnMut(&T) + Sized + 'static,

rclrs/src/node/publisher.rs

@@ -2,12 +2,16 @@ use crate::error::ToResult;
 use crate::qos::QoSProfile;
 use crate::rcl_bindings::*;
 use crate::{Node, NodeHandle};
-use rclrs_common::error::RclError;
-use std::borrow::Borrow;
-use std::ffi::CString;
-use std::marker::PhantomData;
-use std::sync::Arc;
+use alloc::sync::Arc;
+use core::borrow::Borrow;
+use core::marker::PhantomData;
+use cstr_core::CString;
+use rclrs_common::error::RclReturnCode;
 
+#[cfg(not(feature = "std"))]
+use spin::{Mutex, MutexGuard};
+
+#[cfg(feature = "std")]
 use parking_lot::{Mutex, MutexGuard};
 
 pub struct PublisherHandle {
@@ -56,7 +60,7 @@ impl<T> Publisher<T>
 where
     T: rclrs_common::traits::MessageDefinition<T>,
 {
-    pub fn new(node: &Node, topic: &str, qos: QoSProfile) -> Result<Self, RclError>
+    pub fn new(node: &Node, topic: &str, qos: QoSProfile) -> Result<Self, RclReturnCode>
     where
         T: rclrs_common::traits::MessageDefinition<T>,
     {
@@ -90,14 +94,14 @@ where
         })
     }
 
-    pub fn publish(&self, message: &T) -> Result<(), RclError> {
+    pub fn publish(&self, message: &T) -> Result<(), RclReturnCode> {
         let native_message_ptr = message.get_native_message();
         let handle = &mut *self.handle.lock();
         let ret = unsafe {
             rcl_publish(
                 handle as *mut _,
                 native_message_ptr as *mut _,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         message.destroy_native_message(native_message_ptr);