Fix: Handle all escape characters

.vscode/settings.json

@@ -2,7 +2,6 @@
     // override the default setting (`cargo check --all-targets`) which produces the following error
     // "can't find crate for `test`" when the default compilation target is a no_std target
     // with these changes RA will call `cargo check --bins` on save
-    "rust-analyzer.checkOnSave.allTargets": false,
     "rust-analyzer.cargo.target": "thumbv6m-none-eabi",
     "rust-analyzer.diagnostics.disabled": [
         "unresolved-import"

atat/Cargo.toml

@@ -21,10 +21,10 @@ name = "atat"
 embedded-io = "0.6"
 embedded-io-async = "0.6"
 futures = { version = "0.3", default-features = false }
-embassy-sync = "0.6"
-embassy-time = "0.4"
+embassy-sync = "0.7.2"
+embassy-time = "0.5.0"
 embassy-futures = "0.1"
-heapless = { version = "^0.8", features = ["serde"] }
+heapless = { version = "^0.9", features = ["serde"] }
 thiserror = { version = "2", default-features = false }
 serde_at = { path = "../serde_at", version = "^0.24.1", optional = true }
 atat_derive = { path = "../atat_derive", version = "^0.24.1", optional = true }
@@ -38,7 +38,7 @@ log = { version = "^0.4", default-features = false, optional = true }
 defmt = { version = "^0.3", optional = true }
 
 [dev-dependencies]
-embassy-time = { version = "0.4", features = ["std"] }
+embassy-time = { version = "0.5", features = ["std", "generic-queue-8"] }
 critical-section = { version = "1.1", features = ["std"] }
 serde_at = { path = "../serde_at", version = "^0.24.1", features = [
     "heapless",
@@ -48,7 +48,7 @@ static_cell = { version = "2.0.0" }
 
 [features]
 default = ["derive", "bytes"]
-defmt = ["dep:defmt", "embedded-io-async/defmt-03", "heapless/defmt-03"]
+defmt = ["dep:defmt", "embedded-io-async/defmt-03", "heapless/defmt"]
 derive = ["atat_derive", "serde_at"]
 bytes = ["heapless-bytes", "serde_bytes"]
 custom-error-messages = []

atat/src/asynch/client.rs

@@ -20,20 +20,20 @@
 }
 
 impl<'a, W: Write, const INGRESS_BUF_SIZE: usize> Client<'a, W, INGRESS_BUF_SIZE> {
     pub fn new(
         writer: W,
         res_slot: &'a ResponseSlot<INGRESS_BUF_SIZE>,
         buf: &'a mut [u8],
         config: Config,
     ) -> Self {
         Self {
             writer,
             res_slot,
             buf,
             config,
             cooldown_timer: None,
         }
     }
 
     async fn send_request(&mut self, len: usize) -> Result<(), Error> {
         if len < 50 {
@@ -65,8 +65,8 @@
         Ok(())
     }
 
     async fn wait_response<'guard>(
         &'guard mut self,
         timeout: Duration,
     ) -> Result<ResponseSlotGuard<'guard, INGRESS_BUF_SIZE>, Error> {
         self.with_timeout(timeout, self.res_slot.get())
@@ -74,11 +74,11 @@
             .map_err(|_| Error::Timeout)
     }
 
     async fn with_timeout<F: Future>(
         &self,
         timeout: Duration,
         fut: F,
     ) -> Result<F::Output, TimeoutError> {
         let start = Instant::now();
         let mut expires = (self.config.get_response_timeout)(start, timeout);
 
@@ -87,7 +87,7 @@
         loop {
             fut = match select(fut, Timer::at(expires)).await {
                 Either::Left((r, _)) => return Ok(r),
                 Either::Right((_, fut)) => {
                     let new_expires = (self.config.get_response_timeout)(start, timeout);
                     if new_expires <= expires {
                         return Err(TimeoutError);
@@ -105,24 +105,24 @@
 
     async fn wait_cooldown_timer(&mut self) {
         if let Some(cooldown) = self.cooldown_timer.take() {
             cooldown.await
         }
     }
 }
 
 impl<W: Write, const INGRESS_BUF_SIZE: usize> AtatClient for Client<'_, W, INGRESS_BUF_SIZE> {
     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
-        let len = cmd.write(&mut self.buf);
+        let len = cmd.write(self.buf);
         self.send_request(len).await?;
         if !Cmd::EXPECTS_RESPONSE_CODE {
             cmd.parse(Ok(&[]))
         } else {
             let response = self
                 .wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))
                 .await?;
             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
             cmd.parse(response.into())
         }
     }
 }
 
@@ -152,6 +152,7 @@
 
     #[derive(Clone, PartialEq, AtatEnum)]
     #[at_enum(u8)]
+    #[allow(clippy::upper_case_acronyms)]
     pub enum Functionality {
         #[at_arg(value = 0)]
         Min,
@@ -183,8 +184,12 @@
             static mut BUF: [u8; 1000] = [0; 1000];
 
             let tx_mock = crate::tx_mock::TxMock::new(TX_CHANNEL.publisher().unwrap());
-            let client: Client<crate::tx_mock::TxMock, TEST_RX_BUF_LEN> =
-                Client::new(tx_mock, &RES_SLOT, unsafe { BUF.as_mut() }, $config);
+            let client: Client<crate::tx_mock::TxMock, TEST_RX_BUF_LEN> = Client::new(
+                tx_mock,
+                &RES_SLOT,
+                unsafe { &mut *core::ptr::addr_of_mut!(BUF) },
+                $config,
+            );
             (client, TX_CHANNEL.subscriber().unwrap(), &RES_SLOT)
         }};
     }

atat/src/asynch/simple_client.rs

@@ -13,16 +13,16 @@
 }
 
 impl<'a, RW: Read + Write, D: Digester> SimpleClient<'a, RW, D> {
     pub fn new(rw: RW, digester: D, buf: &'a mut [u8], config: Config) -> Self {
         Self {
             rw,
             digester,
             buf,
             config,
             pos: 0,
             cooldown_timer: None,
         }
     }
 
     async fn send_request(&mut self, len: usize) -> Result<(), Error> {
         if len < 50 {
@@ -48,14 +48,14 @@
         Ok(())
     }
 
-    async fn wait_response<'guard>(&'guard mut self) -> Result<Response<256>, Error> {
+    async fn wait_response(&mut self) -> Result<Response<256>, Error> {
         loop {
             match self.rw.read(&mut self.buf[self.pos..]).await {
                 Ok(n) => {
                     self.pos += n;
                 }
                 _ => return Err(Error::Read),
             };
 
             trace!(
                 "Buffer contents: ({:?} bytes) '{:?}'",
@@ -89,7 +89,7 @@
                         match &resp {
                             Ok(r) => {
                                 if r.is_empty() {
                                     debug!("Received OK ({}/{})", swallowed, self.pos)
                                 } else {
                                     debug!(
                                         "Received response ({}/{}): {:?}",
@@ -136,27 +136,27 @@
 
     async fn wait_cooldown_timer(&mut self) {
         if let Some(cooldown) = self.cooldown_timer.take() {
             cooldown.await
         }
     }
 }
 
 impl<RW: Read + Write, D: Digester> AtatClient for SimpleClient<'_, RW, D> {
     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
-        let len = cmd.write(&mut self.buf);
+        let len = cmd.write(self.buf);
 
         self.send_request(len).await?;
         if !Cmd::EXPECTS_RESPONSE_CODE {
             cmd.parse(Ok(&[]))
         } else {
             let response = embassy_time::with_timeout(
                 Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()),
                 self.wait_response(),
             )
             .await
             .map_err(|_| Error::Timeout)??;
 
             cmd.parse((&response).into())
         }
     }
 }

atat/src/blocking/client.rs

@@ -8,11 +8,11 @@
     AtatCmd, Config, Error, Response,
 };
 
 /// Client responsible for handling send, receive and timeout from the
 /// userfacing side. The client is decoupled from the ingress-manager through
 /// some spsc queue consumers, where any received responses can be dequeued. The
 /// Client also has an spsc producer, to allow signaling commands like
 /// `reset` to the ingress-manager.
 pub struct Client<'a, W, const INGRESS_BUF_SIZE: usize>
 where
     W: Write,
@@ -28,20 +28,20 @@
 where
     W: Write,
 {
     pub fn new(
         writer: W,
         res_slot: &'a ResponseSlot<INGRESS_BUF_SIZE>,
         buf: &'a mut [u8],
         config: Config,
     ) -> Self {
         Self {
             writer,
             res_slot,
             buf,
             cooldown_timer: None,
             config,
         }
     }
 
     fn send_request(&mut self, len: usize) -> Result<(), Error> {
         if len < 50 {
@@ -65,8 +65,8 @@
         Ok(())
     }
 
     fn wait_response<'guard>(
         &'guard mut self,
         timeout: Duration,
     ) -> Result<ResponseSlotGuard<'guard, INGRESS_BUF_SIZE>, Error> {
         self.with_timeout(timeout, || self.res_slot.try_get())
@@ -106,12 +106,12 @@
     W: Write,
 {
     fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
-        let len = cmd.write(&mut self.buf);
+        let len = cmd.write(self.buf);
         self.send_request(len)?;
         if !Cmd::EXPECTS_RESPONSE_CODE {
             cmd.parse(Ok(&[]))
         } else {
             let response = self.wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))?;
             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
             cmd.parse(response.into())
         }
@@ -132,6 +132,7 @@
     const TEST_RX_BUF_LEN: usize = 256;
 
     #[derive(Debug, PartialEq, Eq)]
+    #[allow(dead_code)]
     pub enum InnerError {
         Test,
     }
@@ -192,6 +193,7 @@
 
     #[derive(Clone, PartialEq, AtatEnum)]
     #[at_enum(u8)]
+    #[allow(clippy::upper_case_acronyms)]
     pub enum Functionality {
         #[at_arg(value = 0)]
         Min,
@@ -235,6 +237,7 @@
     }
 
     #[derive(Debug, Clone, AtatResp, PartialEq)]
+    #[allow(dead_code)]
     pub struct MessageWaitingIndication {
         #[at_arg(position = 0)]
         pub status: u8,
@@ -243,6 +246,7 @@
     }
 
     #[derive(Debug, Clone, AtatUrc, PartialEq)]
+    #[allow(dead_code)]
     pub enum Urc {
         #[at_urc(b"+UMWI")]
         MessageWaitingIndication(MessageWaitingIndication),
@@ -258,8 +262,12 @@
             static mut BUF: [u8; 1000] = [0; 1000];
 
             let tx_mock = crate::tx_mock::TxMock::new(TX_CHANNEL.publisher().unwrap());
-            let client: Client<crate::tx_mock::TxMock, TEST_RX_BUF_LEN> =
-                Client::new(tx_mock, &RES_SLOT, unsafe { BUF.as_mut() }, $config);
+            let client: Client<crate::tx_mock::TxMock, TEST_RX_BUF_LEN> = Client::new(
+                tx_mock,
+                &RES_SLOT,
+                unsafe { &mut *core::ptr::addr_of_mut!(BUF) },
+                $config,
+            );
             (client, TX_CHANNEL.subscriber().unwrap(), &RES_SLOT)
         }};
     }
@@ -272,8 +280,7 @@
 
         let sent = tokio::spawn(async move {
             tx.next_message_pure().await;
-            rx.signal_response(Err(InternalError::Error).into())
-                .unwrap();
+            rx.signal_response(Err(InternalError::Error)).unwrap();
         });
 
         tokio::task::spawn_blocking(move || {
@@ -296,8 +303,7 @@
 
         let sent = tokio::spawn(async move {
             tx.next_message_pure().await;
-            rx.signal_response(Err(InternalError::Error).into())
-                .unwrap();
+            rx.signal_response(Err(InternalError::Error)).unwrap();
         });
 
         tokio::task::spawn_blocking(move || {

atat/src/config.rs

@@ -6,6 +6,7 @@ use embassy_time::{Duration, Instant};
 ///
 /// [`Command`]: enum.Command.html
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[allow(unpredictable_function_pointer_comparisons)]
 pub struct Config {
     pub(crate) cmd_cooldown: Duration,
     pub(crate) tx_timeout: Duration,

atat/src/derive.rs

@@ -8,18 +8,21 @@ use serde_at::HexStr;
 /// [`atat_derive`]: https://crates.io/crates/atat_derive
 pub trait AtatLen {
     const LEN: usize;
+    const ESCAPED_LEN: usize;
 }
 
 #[cfg(feature = "bytes")]
 impl<const N: usize> AtatLen for heapless_bytes::Bytes<N> {
     const LEN: usize = N;
+    const ESCAPED_LEN: usize = N;
 }
 
 macro_rules! impl_length {
     ($type:ty, $len:expr) => {
         #[allow(clippy::use_self)]
         impl AtatLen for $type {
             const LEN: usize = $len;
+            const ESCAPED_LEN: usize = $len;
         }
     };
 }
@@ -51,27 +54,32 @@ impl_length!(HexStr<u128>, 130);
 
 impl<const T: usize> AtatLen for String<T> {
     const LEN: usize = 1 + T + 1;
+    const ESCAPED_LEN: usize = 3 * T + 2;
 }
 
 impl<T: AtatLen> AtatLen for Option<T> {
     const LEN: usize = T::LEN;
+    const ESCAPED_LEN: usize = T::ESCAPED_LEN;
 }
 
 impl<T: AtatLen> AtatLen for &T {
     const LEN: usize = T::LEN;
+    const ESCAPED_LEN: usize = T::ESCAPED_LEN;
 }
 
 impl<T, const L: usize> AtatLen for Vec<T, L>
 where
     T: AtatLen,
 {
     const LEN: usize = L * <T as AtatLen>::LEN;
+    const ESCAPED_LEN: usize = L * <T as AtatLen>::ESCAPED_LEN;
 }
 
 //       0x   F:F:F:F
 // uN = (2 + (N*4) - 1) * 2 bytes
 impl<const L: usize> AtatLen for HexStr<[u8; L]> {
     const LEN: usize = (2 + L * 4 - 1) * 2;
+    const ESCAPED_LEN: usize = (2 + L * 4 - 1) * 2;
 }
 
 // Currently, stable rust (version at the time of writing: 1.93)
@@ -81,6 +89,7 @@ macro_rules! impl_nonzero_length {
     ($type:ty) => {
         impl AtatLen for NonZero<$type> {
             const LEN: usize = <$type as AtatLen>::LEN;
+            const ESCAPED_LEN: usize = <$type as AtatLen>::ESCAPED_LEN;
         }
     };
 }
@@ -202,8 +211,18 @@ mod tests {
         assert_eq!(<f32 as AtatLen>::LEN, 42);
         assert_eq!(<f64 as AtatLen>::LEN, 312);
 
+        // For non-string primitives, ESCAPED_LEN == LEN
+        assert_eq!(<u8 as AtatLen>::ESCAPED_LEN, 3);
+        assert_eq!(<i64 as AtatLen>::ESCAPED_LEN, 20);
+
+        // String<T>: LEN = 1 + T + 1 (quotes), ESCAPED_LEN = 3*T + 2
+        assert_eq!(<String<10> as AtatLen>::LEN, 12);
+        assert_eq!(<String<10> as AtatLen>::ESCAPED_LEN, 32);
+
         assert_eq!(<SimpleEnum as AtatLen>::LEN, 3);
         assert_eq!(<SimpleEnumU32 as AtatLen>::LEN, 10);
+        assert_eq!(<SimpleEnum as AtatLen>::ESCAPED_LEN, 3);
+        assert_eq!(<SimpleEnumU32 as AtatLen>::ESCAPED_LEN, 10);
 
         assert_eq!(<HexStr<u8> as AtatLen>::LEN, 10);
         assert_eq!(<HexStr<u16> as AtatLen>::LEN, 18);
@@ -214,18 +233,31 @@ mod tests {
         #[cfg(feature = "hex_str_arrays")]
         {
             assert_eq!(<HexStr<[u8; 16]> as AtatLen>::LEN, 130);
+            assert_eq!(<HexStr<[u8; 16]> as AtatLen>::ESCAPED_LEN, 130);
         }
 
         // (fields) + (n_fields - 1)
-        // (3 + (1 + 128 + 1) + 2 + (1 + 150 + 1) + 3 + 10 + 3 + (10*5)) + 7
+        // (3 + (1 + 128 + 1) + 2 + (1 + 150 + 1) + 3 + 10 + 3) + 6
         assert_eq!(
             <LengthTester<'_> as AtatLen>::LEN,
             (3 + (1 + 128 + 1) + 2 + (1 + 150 + 1) + 3 + 10 + 3) + 6
         );
+        // ESCAPED_LEN: String<128> -> 3*128+2=386, &str len=150 -> 3*150+2=452
+        // (3 + 386 + 2 + 452 + 3 + 10 + 3) + 6
+        assert_eq!(
+            <LengthTester<'_> as AtatLen>::ESCAPED_LEN,
+            (3 + (3 * 128 + 2) + 2 + (3 * 150 + 2) + 3 + 10 + 3) + 6
+        );
         assert_eq!(
             <MixedEnum<'_> as AtatLen>::LEN,
             (3 + 3 + (1 + 10 + 1) + 20 + 10) + 4
         );
+        // ESCAPED_LEN: String<10> -> 3*10+2=32
+        // max variant AdvancedTuple: (3 + 32 + 20 + 10) + 4 separators = 69
+        assert_eq!(
+            <MixedEnum<'_> as AtatLen>::ESCAPED_LEN,
+            3 + (3 + 32 + 20 + 10) + 4
+        );
     }
 
     #[test]

atat/src/digest.rs

@@ -33,8 +33,8 @@
 pub trait Parser {
     /// Parse a URC, if it exists.
     ///
     /// - if no URC exists, return [ParseError::NoMatch]
     /// - if a URC exists but is incomplete, return [ParseError::Incomplete]
     /// - if a URC exists and is complete, return it and its length
     fn parse(buf: &[u8]) -> Result<(&[u8], usize), ParseError>;
 }
@@ -244,7 +244,7 @@
         }
     }
 
-    pub fn error_response(buf: &[u8]) -> IResult<&[u8], (DigestResult, usize)> {
+    pub fn error_response(buf: &[u8]) -> IResult<&[u8], (DigestResult<'_>, usize)> {
         alt((
             // Matches the equivalent of regex: "\r\n\+CME ERROR:\s*(\d+)\r\n"
             map(numeric_error("\r\n+CME ERROR:"), |(error_code, len)| {
@@ -310,8 +310,8 @@
         ))(buf)
     }
 
-    pub fn prompt_response(buf: &[u8]) -> IResult<&[u8], (DigestResult, usize)> {
-        for prompt in &[b'>', b'@'] {
+    pub fn prompt_response(buf: &[u8]) -> IResult<&[u8], (DigestResult<'_>, usize)> {
+        for prompt in b">@" {
             if let Ok((buf, ((prefix, p), ws, _))) = tuple((
                 take_until_including::<_, _, nom::error::Error<_>>(&[*prompt][..]),
                 complete::multispace0,
@@ -333,7 +333,7 @@
         )))
     }
 
-    pub fn success_response(buf: &[u8]) -> IResult<&[u8], (DigestResult, usize)> {
+    pub fn success_response(buf: &[u8]) -> IResult<&[u8], (DigestResult<'_>, usize)> {
         let (i, ((data, tag), ws)) = alt((
             tuple((
                 take_until_including("\r\nOK\r\n"),
@@ -478,19 +478,19 @@
     }
 
     fn trim_ascii_whitespace(x: &[u8]) -> &[u8] {
         let from = match x.iter().position(|x| !x.is_ascii_whitespace()) {
             Some(i) => i,
             None => return &x[0..0],
         };
         let to = x.iter().rposition(|x| !x.is_ascii_whitespace()).unwrap();
         &x[from..=to]
     }
 
     pub fn trim_start_ascii_space(x: &[u8]) -> &[u8] {
         match x.iter().position(|&x| x != b' ') {
             Some(offset) => &x[offset..],
             None => &x[0..0],
         }
     }
 }
 #[cfg(test)]
@@ -499,10 +499,9 @@
 
     use super::parser::{echo, urc_helper};
     use super::*;
-    use crate::{
-        error::{CmeError, CmsError, ConnectionError},
-        helpers::LossyStr,
-    };
+    #[cfg(feature = "string_errors")]
+    use crate::error::{CmsError, ConnectionError};
+    use crate::{error::CmeError, helpers::LossyStr};
 
     const TEST_RX_BUF_LEN: usize = 256;
 

atat/src/ingress.rs

@@ -3,7 +3,7 @@
     UrcChannel,
 };
 
 #[derive(Debug, PartialEq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Error {
     ResponseSlotBusy,
@@ -104,12 +104,12 @@
         const URC_SUBSCRIBERS: usize,
     > Ingress<'a, D, Urc, RES_BUF_SIZE, URC_CAPACITY, URC_SUBSCRIBERS>
 {
     pub fn new(
         digester: D,
         buf: &'a mut [u8],
         res_slot: &'a ResponseSlot<RES_BUF_SIZE>,
         urc_channel: &'a UrcChannel<Urc, URC_CAPACITY, URC_SUBSCRIBERS>,
     ) -> Self {
         Self {
             digester,
             buf,
@@ -181,7 +181,7 @@
                     match &resp {
                         Ok(r) => {
                             if r.is_empty() {
                                 debug!("Received OK ({}/{})", swallowed, self.pos,)
                             } else {
                                 debug!(
                                     "Received response ({}/{}): {:?}",
@@ -217,7 +217,7 @@
         Ok(())
     }
 
     async fn advance(&mut self, commit: usize) {
         self.pos += commit;
         assert!(self.pos <= self.buf.len());
 
@@ -265,7 +265,7 @@
                     match &resp {
                         Ok(r) => {
                             if r.is_empty() {
                                 debug!("Received OK ({}/{})", swallowed, self.pos,)
                             } else {
                                 debug!(
                                     "Received response ({}/{}): {:?}",
@@ -476,7 +476,7 @@
         }
         impl embedded_io_async::Read for Reader {
             async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-                assert!(buf.len() > 0);
+                assert!(!buf.is_empty());
                 if self.pos >= self.data.len() {
                     // Simulate waiting on more data.
                     loop {

atat/src/response.rs

@@ -1,7 +1,7 @@
 use crate::InternalError;
 use heapless::Vec;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Response<const N: usize> {
     Ok(Vec<u8, N>),
     Prompt(u8),
@@ -19,7 +19,7 @@
 }
 
 impl<const N: usize> Response<N> {
     pub fn ok(value: &[u8]) -> Self {
         Response::Ok(Vec::from_slice(value).unwrap())
     }
 }
@@ -69,11 +69,9 @@
             Response::AbortedError => Err(InternalError::Aborted),
             Response::ParseError => Err(InternalError::Parse),
             Response::OtherError => Err(InternalError::Error),
-            Response::CmeError(e) => Err(InternalError::CmeError((*e).try_into().unwrap())),
-            Response::CmsError(e) => Err(InternalError::CmsError((*e).try_into().unwrap())),
-            Response::ConnectionError(e) => {
-                Err(InternalError::ConnectionError((*e).try_into().unwrap()))
-            }
+            Response::CmeError(e) => Err(InternalError::CmeError((*e).into())),
+            Response::CmsError(e) => Err(InternalError::CmsError((*e).into())),
+            Response::ConnectionError(e) => Err(InternalError::ConnectionError((*e).into())),
             Response::CustomError(e) => Err(InternalError::Custom(e)),
         }
     }

atat/src/response_slot.rs

@@ -19,8 +19,14 @@
 #[derive(Debug)]
 pub struct SlotInUseError;
 
+impl<const N: usize> Default for ResponseSlot<N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<const N: usize> ResponseSlot<N> {
     pub const fn new() -> Self {
         Self(
             Mutex::new(RefCell::new(Response::Ok(Vec::new()))),
             Signal::new(),
@@ -33,7 +39,7 @@
     }
 
     /// Wait for a response to be signaled and get a guard to the response
     pub async fn get<'a>(&'a self) -> ResponseSlotGuard<'a, N> {
         self.1.wait().await;
 
         // The mutex is not locked when signal is emitted
@@ -41,7 +47,7 @@
     }
 
     /// If signaled, get a guard to the response
     pub fn try_get<'a>(&'a self) -> Option<ResponseSlotGuard<'a, N>> {
         if self.1.signaled() {
             // The mutex is not locked when signal is emitted
             Some(self.0.try_lock().unwrap())
@@ -57,7 +63,7 @@
 
         // Not currently signaled: We know that the client is not currently holding the response slot guard
         {
             let buf = self.0.try_lock().unwrap();
             let mut res = buf.borrow_mut();
             *res = Response::Prompt(prompt);
         }
@@ -77,7 +83,7 @@
 
         // Not currently signaled: We know that the client is not currently holding the response slot guard
         {
             let buf = self.0.try_lock().unwrap();
             let mut res = buf.borrow_mut();
             *res = response.into();
         }

atat/src/urc_channel.rs

@@ -18,10 +18,18 @@
     pub(crate) PubSubChannel<CriticalSectionRawMutex, Urc::Response, CAPACITY, SUBSCRIBERS, 1>,
 );
 
+impl<Urc: AtatUrc, const CAPACITY: usize, const SUBSCRIBERS: usize> Default
+    for UrcChannel<Urc, CAPACITY, SUBSCRIBERS>
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<Urc: AtatUrc, const CAPACITY: usize, const SUBSCRIBERS: usize>
     UrcChannel<Urc, CAPACITY, SUBSCRIBERS>
 {
     pub const fn new() -> Self {
         Self(PubSubChannel::new())
     }