Add reattempt on parse err flag to AtatCmd (#178)

* add reattempt_on_parse_err flag to AtatCmd

* add missing parsing of reattempt_on_parse_err in atat_cmd attribute

* fix REATTEMPT_ON_PARSE_ERR type in macro expand

* make REATTEMPT_ON_PARSE_ERR default to true

atat/src/asynch/mod.rs

@@ -28,6 +28,11 @@ pub trait AtatClient {
 
             match self.send(cmd).await {
                 Err(Error::Timeout) => {}
+                Err(Error::Parse) => {
+                    if !Cmd::REATTEMPT_ON_PARSE_ERR {
+                        return Err(Error::Parse);
+                    }
+                }
                 r => return r,
             }
         }

atat/src/traits.rs

@@ -71,6 +71,10 @@ pub trait AtatCmd<const LEN: usize> {
     /// using `send_retry`.
     const ATTEMPTS: u8 = 1;
 
+    /// Whether or not to reattempt a command on a parse error
+    /// using `send_retry`.
+    const REATTEMPT_ON_PARSE_ERR: bool = true;
+
     /// Force client to look for a response.
     /// Empty slice is then passed to parse by client.
     /// Implemented to enhance expandability of ATAT

atat_derive/src/cmd.rs

@@ -19,6 +19,7 @@ pub fn atat_cmd(input: TokenStream) -> TokenStream {
         resp,
         timeout_ms,
         attempts,
+        reattempt_on_parse_err,
         abortable,
         value_sep,
         cmd_prefix,
@@ -59,6 +60,15 @@ pub fn atat_cmd(input: TokenStream) -> TokenStream {
         None => quote! {},
     };
 
+    let reattempt_on_parse_err = match reattempt_on_parse_err {
+        Some(reattempt_on_parse_err) => {
+            quote! {
+                const REATTEMPT_ON_PARSE_ERR: bool = #reattempt_on_parse_err;
+            }
+        }
+        None => quote! {},
+    };
+
     // let quote_escape_strings = !matches!(quote_escape_strings, Some(false));
 
     let mut cmd_len = cmd_prefix.len() + cmd.len() + termination.len();
@@ -99,6 +109,8 @@ pub fn atat_cmd(input: TokenStream) -> TokenStream {
 
             #attempts
 
+            #reattempt_on_parse_err
+
             #[inline]
             fn as_bytes(&self) -> atat::heapless::Vec<u8, { #ident_len + #cmd_len }> {
                 match atat::serde_at::to_vec(self, #cmd, atat::serde_at::SerializeOptions {

atat_derive/src/parse.rs

@@ -22,6 +22,7 @@ pub struct CmdAttributes {
     pub timeout_ms: Option<u32>,
     pub attempts: Option<u8>,
     pub abortable: Option<bool>,
+    pub reattempt_on_parse_err: Option<bool>,
     pub value_sep: bool,
     pub cmd_prefix: String,
     pub termination: String,
@@ -253,6 +254,7 @@ impl Parse for CmdAttributes {
             timeout_ms: None,
             attempts: None,
             abortable: None,
+            reattempt_on_parse_err: None,
             value_sep: true,
             cmd_prefix: String::from("AT"),
             termination: String::from("\r\n"),
@@ -289,6 +291,20 @@ impl Parse for CmdAttributes {
                         ))
                     }
                 }
+            } else if optional.path.is_ident("reattempt_on_parse_err") {
+                match optional.value {
+                    Expr::Lit(ExprLit {
+                        lit: Lit::Bool(v), ..
+                    }) => {
+                        at_cmd.reattempt_on_parse_err = Some(v.value);
+                    }
+                    _ => {
+                        return Err(Error::new(
+                            call_site,
+                            "expected bool value for 'reattempt_on_parse_err'",
+                        ))
+                    }
+                }
             } else if optional.path.is_ident("abortable") {
                 match optional.value {
                     Expr::Lit(ExprLit {