Implement support for defmt

Author: optlink

canadensis/Cargo.toml

@@ -13,7 +13,9 @@ description = "A Cyphal implementation: Node types and re-exports from some othe
 fallible_collections = "0.5.1"
 heapless = "0.8.0"
 half = { version = ">=2.2, <2.5", default-features = false }
-log = "0.4"
+log = { version = "0.4", optional = true }
+defmt = { version = "1.0.1", optional = true }
+defmt-or-log = { git = "https://github.com/t-moe/defmt-or-log.git", rev = "a16380e8737b18846c45195328fa0b469ccf43f2" }
 
 # Depends on most other canadensis crates that are not transport-specific
 [dependencies.canadensis_core]
@@ -50,3 +52,6 @@ path = "../canadensis_serial"
 version = "0.4.1"
 path = "../canadensis_udp"
 
+[features]
+defmt = ["dep:defmt", "defmt-or-log/defmt", "canadensis_core/defmt", "canadensis_encoding/defmt"]
+log = ["dep:log", "defmt-or-log/log", "canadensis_core/log", "canadensis_encoding/log"]

canadensis/src/node/basic.rs

@@ -16,6 +16,7 @@ use canadensis_data_types::uavcan::node::port::subject_id_1_0;
 use canadensis_data_types::uavcan::node::port::subject_id_list_1_0::SubjectIDList;
 use canadensis_encoding::bits::BitArray;
 use canadensis_encoding::{Message, Request, Response, Serialize};
+use defmt_or_log::unwrap;
 
 /// A node that provides all basic application-layer functionality
 ///
@@ -76,18 +77,16 @@ where
         let port_list = List {
             publishers: SubjectIDList::SparseList({
                 let mut published_topics = heapless::Vec::new();
-                published_topics
+                unwrap!(published_topics
                     .push(subject_id_1_0::SubjectID {
                         value: heartbeat_1_0::SUBJECT.into(),
                     })
-                    .ok()
-                    .unwrap();
-                published_topics
+                    .ok());
+                unwrap!(published_topics
                     .push(subject_id_1_0::SubjectID {
                         value: list_1_0::SUBJECT.into(),
                     })
-                    .ok()
-                    .unwrap();
+                    .ok());
                 published_topics
             }),
             subscribers: SubjectIDList::SparseList(heapless::Vec::new()),

canadensis/src/node/core.rs

@@ -9,6 +9,7 @@ use canadensis_core::transfer::{
 use canadensis_core::transport::{Receiver, Transmitter, Transport};
 use canadensis_core::{nb, OutOfMemoryError, ServiceId, ServiceSubscribeError, SubjectId};
 use canadensis_encoding::{Message, Request, Response, Serialize};
+use defmt_or_log::{expect, unreachable};
 
 use crate::publisher::Publisher;
 use crate::requester::{Requester, TransferIdTracker};
@@ -215,10 +216,10 @@ where
     where
         M: Message + Serialize,
     {
-        let publisher = self
-            .publishers
-            .get_mut(&token.0)
-            .expect("Bug: Token exists but no publisher");
+        let publisher = expect!(
+            self.publishers.get_mut(&token.0),
+            "Bug: Token exists but no publisher"
+        );
         publisher.publish(
             &mut self.clock,
             token.0,
@@ -236,10 +237,10 @@ where
     where
         M: Message + Serialize,
     {
-        let publisher = self
-            .publishers
-            .get_mut(&token.0)
-            .expect("Bug: Token exists but no publisher");
+        let publisher = expect!(
+            self.publishers.get_mut(&token.0),
+            "Bug: Token exists but no publisher"
+        );
         publisher.publish_loopback(
             &mut self.clock,
             token.0,
@@ -310,10 +311,10 @@ where
     where
         M: Request + Serialize,
     {
-        let requester = self
-            .requesters
-            .get_mut(&token.0)
-            .expect("Bug: No requester for token");
+        let requester = expect!(
+            self.requesters.get_mut(&token.0),
+            "Bug: No requester for token"
+        );
         requester.send(
             &mut self.clock,
             token.0,
@@ -336,10 +337,10 @@ where
     where
         M: Request + Serialize,
     {
-        let requester = self
-            .requesters
-            .get_mut(&token.0)
-            .expect("Bug: No requester for token");
+        let requester = expect!(
+            self.requesters.get_mut(&token.0),
+            "Bug: No requester for token"
+        );
         requester.send_loopback(
             &mut self.clock,
             token.0,

canadensis/src/register.rs

@@ -16,6 +16,7 @@ use canadensis_data_types::uavcan::register::name_1_0::Name;
 use canadensis_data_types::uavcan::register::value_1_0::Value;
 use canadensis_data_types::uavcan::time::synchronized_timestamp_1_0::SynchronizedTimestamp;
 use canadensis_encoding::Deserialize;
+use defmt_or_log::{debug, expect, warn};
 
 pub use canadensis_derive_register_block::RegisterBlock;
 
@@ -164,7 +165,7 @@ where
     fn handle_access_request(&mut self, request: &AccessRequest) -> AccessResponse {
         match str::from_utf8(&request.name.name) {
             Ok(register_name) => {
-                log::debug!("Handling access request for {}", register_name);
+                debug!("Handling access request for {}", register_name);
                 if let Some(register) = self.block.register_by_name_mut(register_name) {
                     register_handle_access(register, request)
                 } else {
@@ -194,7 +195,7 @@ where
     }
 
     fn handle_list_request(&mut self, request: &ListRequest) -> ListResponse {
-        log::debug!("Handling register list request, index {}", {
+        debug!("Handling register list request, index {}", {
             request.index
         });
         match self.block.register_by_index(request.index.into()) {
@@ -208,7 +209,7 @@ where
                 };
                 ListResponse {
                     name: Name {
-                        name: heapless::Vec::from_slice(name).expect("Incorrect name length"),
+                        name: expect!(heapless::Vec::from_slice(name), "Incorrect name length"),
                     },
                 }
             }
@@ -261,7 +262,7 @@ where
                     let response = self.handle_access_request(&request);
                     let status = node.send_response(token, milliseconds(1000), &response);
                     if status.is_err() {
-                        log::warn!("Out of memory when sending register access response");
+                        warn!("Out of memory when sending register access response");
                     }
                     true
                 } else {
@@ -273,7 +274,7 @@ where
                     let response = self.handle_list_request(&request);
                     let status = node.send_response(token, milliseconds(1000), &response);
                     if status.is_err() {
-                        log::warn!("Out of memory when sending register list response");
+                        warn!("Out of memory when sending register list response");
                     }
                     true
                 } else {

canadensis/src/register/basic.rs

@@ -18,6 +18,7 @@ use canadensis_data_types::uavcan::primitive::unstructured_1_0;
 use canadensis_data_types::uavcan::register::value_1_0::Value;
 use canadensis_encoding::bits::BitArray;
 use core::convert::TryFrom;
+use defmt_or_log::{expect, unimplemented, unwrap};
 use half::f16;
 
 /// A register containing its name, value, and mutable/persistent flags
@@ -263,7 +264,7 @@ macro_rules! register_primitive {
         impl RegisterType for $type {
             fn read(&self) -> Value {
                 Value::$variant($variant {
-                    value: heapless::Vec::from_slice(&[*self]).unwrap(),
+                    value: unwrap!(heapless::Vec::from_slice(&[*self])),
                 })
             }
 
@@ -305,14 +306,16 @@ macro_rules! register_primitive_array {
             fn read(&self) -> Value {
                 let mut value_vec = heapless::Vec::new();
                 if N <= value_vec.capacity() {
-                    value_vec
-                        .extend_from_slice(&*self)
-                        .expect("Incorrect length calculation");
+                    expect!(
+                        value_vec.extend_from_slice(&*self),
+                        "Incorrect length calculation"
+                    );
                 } else {
                     // Truncate to the maximum allowed size
-                    value_vec
-                        .extend_from_slice(&self[..value_vec.capacity()])
-                        .expect("Incorrect length calculation");
+                    expect!(
+                        value_vec.extend_from_slice(&self[..value_vec.capacity()]),
+                        "Incorrect length calculation"
+                    );
                 }
                 Value::$variant($variant { value: value_vec })
             }
@@ -516,8 +519,10 @@ impl Register for FixedStringRegister {
 
     fn read(&self) -> Value {
         Value::String(string_1_0::String {
-            value: heapless::Vec::from_slice(self.value.as_bytes())
-                .expect("Register value too long"),
+            value: expect!(
+                heapless::Vec::from_slice(self.value.as_bytes()),
+                "Register value too long"
+            ),
         })
     }
 

canadensis_can/Cargo.toml

@@ -12,7 +12,9 @@ description = "A Cyphal implementation: Cyphal/CAN (CAN and CAN FD) transport la
 [dependencies]
 fallible_collections = "0.5.1"
 heapless = "0.8.0"
-log = "0.4"
+log = { version = "0.4", optional = true }
+defmt = { version = "1.0.1", optional = true }
+defmt-or-log = { git = "https://github.com/t-moe/defmt-or-log.git", rev = "a16380e8737b18846c45195328fa0b469ccf43f2" }
 
 [dependencies.canadensis_core]
 version = "0.3.1"
@@ -25,3 +27,5 @@ path = "../canadensis_filter_config"
 [features]
 # The can-fd feature increases the maximum frame capacity and maximum MTU from 8 to 64 bytes
 can-fd = []
+defmt = ["dep:defmt", "defmt-or-log/defmt", "canadensis_core/defmt"]
+log = ["dep:log", "defmt-or-log/log", "canadensis_core/log"]

canadensis_can/src/data.rs

@@ -7,6 +7,7 @@ use core::fmt;
 
 use canadensis_core::time::Microseconds32;
 use canadensis_core::InvalidValue;
+use defmt_or_log::expect;
 
 /// Bit mask for a 29-bit CAN ID
 const CAN_ID_MASK: u32 = 0x1f_ff_ff_ff;
@@ -119,7 +120,7 @@ impl Frame {
             timestamp,
             id,
             loopback: false,
-            data: heapless::Vec::from_slice(data).expect("Data to large for a frame"),
+            data: expect!(heapless::Vec::from_slice(data), "Data to large for a frame"),
         }
     }
 

canadensis_can/src/lib.rs

@@ -13,7 +13,6 @@ extern crate canadensis_core;
 extern crate canadensis_filter_config;
 extern crate fallible_collections;
 extern crate heapless;
-extern crate log;
 
 pub use crate::crc::TransferCrc;
 pub use crate::data::*;
@@ -31,6 +30,7 @@ mod tx;
 mod types;
 
 use core::cmp;
+use defmt_or_log::{assert, panic};
 
 /// Calculates the number of frames required and the number of padding bytes to add to a payload so
 /// that all frames will have valid length values for CAN FD

canadensis_can/src/queue/mod.rs

@@ -9,6 +9,8 @@ pub use self::queue_only_driver::QueueOnlyDriver;
 pub use self::single_frame_queue::SingleFrameQueue;
 use core::marker::PhantomData;
 
+use defmt_or_log::expect;
+
 use crate::driver::{ReceiveDriver, TransmitDriver};
 use crate::types::CanNodeId;
 use crate::Frame;
@@ -160,19 +162,18 @@ where
                 if !frame_is_expired(&removed_frame, now) {
                     // Because we just popped a frame from the queue, it must have space to
                     // return a frame.
-                    queue
-                        .return_frame(removed_frame)
-                        .expect("return_frame out of memory");
+                    expect!(
+                        queue.return_frame(removed_frame),
+                        "return_frame out of memory"
+                    );
                 }
                 // Keep going and try the next frame
             }
             Err(nb::Error::WouldBlock) => {
                 // The frame couldn't be transmitted, so put it back in the queue
                 // Because we just popped a frame from the queue, it must have space to
                 // return a frame.
-                queue
-                    .return_frame(frame)
-                    .expect("return_frame out of memory");
+                expect!(queue.return_frame(frame), "return_frame out of memory");
                 return Err(nb::Error::WouldBlock);
             }
             Err(nb::Error::Other(e)) => return Err(nb::Error::Other(e)),

canadensis_can/src/redundant/deduplicator.rs

@@ -1,5 +1,6 @@
 use crate::Frame;
 use canadensis_core::time::{MicrosecondDuration32, Microseconds32};
+use defmt_or_log::assert_ne;
 
 /// Deduplicates incoming frames from multiple transports
 ///