linting

src/at_command/at.rs

@@ -17,19 +17,19 @@ impl AtRequest for At {
     fn parse_response(&self, data: &[u8]) -> Result<AtResponse, AtError> {
         #[cfg(feature = "defmt")]
         info!("parse_response {=[u8]:a}", data);
-        let (matready, cfun) = at_commands::parser::CommandParser::parse(data)
+        let (_matready, _cfun) = at_commands::parser::CommandParser::parse(data)
             .expect_identifier(b"AT\r\r\n")
             .expect_raw_string()
             .expect_identifier(b"\r\n\r\n")
             .expect_raw_string()
             .expect_identifier(b"\r\nAT\r\r\nOK\r")
             .finish()
-            .inspect_err(|e| {
+            .inspect_err(|_e| {
                 #[cfg(feature = "defmt")]
                 error!("Failed to parse response: {=[u8]:a}", data);
             })?;
         #[cfg(feature = "defmt")]
-        info!("matready: {} | cfun: {}", matready, cfun);
+        info!("matready: {} | cfun: {}", _matready, _cfun);
         Ok(AtResponse::Ok)
     }
 }

src/at_command/ate.rs

@@ -1,4 +1,4 @@
-use crate::at_command::{AtRequest, AtResponse, BufferType};
+use crate::at_command::{AtRequest, BufferType};
 use crate::AtError;
 
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]

src/at_command/battery.rs

@@ -2,13 +2,13 @@ use crate::at_command::{AtRequest, AtResponse, BufferType};
 use crate::AtError;
 use at_commands::parser::CommandParser;
 
+#[allow(dead_code)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub struct BatteryChargeStatus{
+pub struct BatteryChargeStatus {
     capacity_percent: i32,
     voltage_millivolt: i32,
 }
 
-
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct BatteryCharge;
 
@@ -28,7 +28,10 @@ impl AtRequest for BatteryCharge {
             .expect_int_parameter()
             .expect_identifier(b"\r\n\r\nOK")
             .finish()?;
-        let status = BatteryChargeStatus{capacity_percent, voltage_millivolt};
+        let status = BatteryChargeStatus {
+            capacity_percent,
+            voltage_millivolt,
+        };
         Ok(AtResponse::BatteryCharge(status))
     }
 }

src/at_command/ceer.rs

@@ -1,6 +1,5 @@
 use crate::at_command::{AtRequest, AtResponse, BufferType};
 use crate::AtError;
-use at_commands::parser::CommandParser;
 
 #[cfg(feature = "defmt")]
 use defmt::info;
@@ -17,9 +16,9 @@ impl AtRequest for ExtendedErrorReport {
             .finish()
     }
 
-    fn parse_response(&self, data: &[u8]) -> Result<AtResponse, AtError> {
+    fn parse_response(&self, _data: &[u8]) -> Result<AtResponse, AtError> {
         #[cfg(feature = "defmt")]
-        info!("error report response: {=[u8]:a}", data);
+        info!("error report response: {=[u8]:a}", _data);
         Ok(AtResponse::Ok)
     }
 }

src/at_command/cmee.rs

@@ -62,10 +62,4 @@ impl AtRequest for SetReportMobileEquipmentError {
             .with_int_parameter(setting)
             .finish()
     }
-
-    fn parse_response(&self, data: &[u8]) -> Result<AtResponse, AtError> {
-        #[cfg(feature = "defmt")]
-        info!("error report response write: {=[u8]:a}", data);
-        Ok(AtResponse::Ok)
-    }
 }

src/at_command/flow_control.rs

@@ -6,24 +6,24 @@ use at_commands::parser::CommandParser;
 use defmt::info;
 
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub enum FlowControl {
+pub enum ControlFlowStatus {
     No,
     Software,
     Hardware,
 }
 
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct SetFlowControl {
-    pub(crate) ta_to_te: FlowControl,
-    pub(crate) te_to_ta: FlowControl,
+    pub(crate) ta_to_te: ControlFlowStatus,
+    pub(crate) te_to_ta: ControlFlowStatus,
 }
 
-impl FlowControl {
+impl ControlFlowStatus {
     fn to_int(&self) -> i32 {
         match self {
-            FlowControl::No => 0,
-            FlowControl::Software => 1,
-            FlowControl::Hardware => 2,
+            ControlFlowStatus::No => 0,
+            ControlFlowStatus::Software => 1,
+            ControlFlowStatus::Hardware => 2,
         }
     }
 }
@@ -65,19 +65,19 @@ impl AtRequest for GetFlowControl {
             .expect_raw_string()
             .finish()?;
         let dce_by_dte = match dce_by_dte {
-            0 => FlowControl::No,
-            1 => FlowControl::Software,
-            2 => FlowControl::Hardware,
+            0 => ControlFlowStatus::No,
+            1 => ControlFlowStatus::Software,
+            2 => ControlFlowStatus::Hardware,
             _ => panic!("Invalid dce-by-dte parameter returned"),
         };
         let dte_by_dce = match dte_by_dce {
-            0 => FlowControl::No,
-            1 => FlowControl::Software,
-            2 => FlowControl::Hardware,
+            0 => ControlFlowStatus::No,
+            1 => ControlFlowStatus::Software,
+            2 => ControlFlowStatus::Hardware,
             _ => panic!("Invalid dce-by-dte parameter returned"),
         };
         #[cfg(feature = "defmt")]
         info!("parity {}, {}", dce_by_dte, dte_by_dce);
-        Ok(AtResponse::Ok {})
+        Ok(AtResponse::ControlFlow(dce_by_dte, dte_by_dce))
     }
 }

src/at_command/http.rs

@@ -111,12 +111,6 @@ impl AtRequest for HttpConnect {
             .with_int_parameter(self.client_id)
             .finish()
     }
-
-    fn parse_response(&self, data: &[u8]) -> Result<AtResponse, AtError> {
-        #[cfg(feature = "defmt")]
-        info!("parsing {=[u8]:a}", data);
-        Ok(AtResponse::Ok)
-    }
 }
 
 /// Disconnect from a server

src/at_command/mod.rs

@@ -1,4 +1,6 @@
 use crate::at_command::at_cgatt::GPRSServiceState;
+use crate::at_command::battery::BatteryChargeStatus;
+use crate::at_command::flow_control::ControlFlowStatus;
 use crate::at_command::mqtt::UsedState;
 use crate::at_command::network_information::{NetworkFormat, NetworkMode, NetworkOperator};
 use crate::at_command::network_registration_status::{
@@ -10,7 +12,6 @@ use crate::at_command::sleep_indication::SleepIndication;
 use crate::{AtError, BUFFER_SIZE};
 #[cfg(feature = "defmt")]
 use defmt::debug;
-use crate::at_command::battery::BatteryChargeStatus;
 
 pub mod at;
 pub mod at_cgatt;
@@ -20,6 +21,7 @@ pub mod at_csq;
 pub mod at_cstt;
 pub mod ate;
 pub mod ati;
+pub mod battery;
 pub mod ceer;
 pub mod cgcontrdp;
 pub mod clock;
@@ -34,7 +36,6 @@ pub mod ntp;
 pub mod pdp_context;
 pub mod power_saving_mode;
 pub mod sleep_indication;
-pub mod battery;
 
 type BufferType = [u8; BUFFER_SIZE];
 
@@ -58,6 +59,7 @@ pub enum AtResponse {
     SleepIndication(SleepIndication),
     PowerSavingMode(PowerSavingModeState),
     BatteryCharge(BatteryChargeStatus),
+    ControlFlow(ControlFlowStatus, ControlFlowStatus),
 }
 
 pub trait AtRequest {

src/at_command/model_identification.rs

@@ -21,7 +21,7 @@ impl AtRequest for ModelIdentification {
             .expect_raw_string()
             .expect_identifier(b"\r\n\r\nOK")
             .finish()
-            .inspect(|e| {
+            .inspect(|_e| {
                 #[cfg(feature = "defmt")]
                 error!("Failed to parse response: {=[u8]:a}", data);
             })?;

src/at_command/mqtt.rs

@@ -106,9 +106,9 @@ impl MQTTSessionWrapper {
         match self {
             Disconnected(session) => match session.create_session(modem, session_settings) {
                 Ok(session) => Ok(Self::Connected(session)),
-                Err(err) => {
+                Err(_e) => {
                     #[cfg(feature = "defmt")]
-                    error!("{:?}", err);
+                    error!("{:?}", _e);
                     Err(MQTTError::Disconnected)
                 }
             },
@@ -130,9 +130,9 @@ impl MQTTSessionWrapper {
             MQTTSessionWrapper::Connected(session) => {
                 match session.connect(modem, connection_settings) {
                     Ok(session) => Ok(Self::ConnectedGood(session)),
-                    Err(err) => {
+                    Err(_e) => {
                         #[cfg(feature = "defmt")]
-                        error!("{:?}", err);
+                        error!("{:?}", _e);
                         Err(MQTTError::Disconnected)
                     }
                 }
@@ -193,9 +193,9 @@ impl<'a> MQTTSession<StateDisconnected> {
             Ok(AtResponse::MQTTSessionCreated(mqtt_connection_id)) => Ok(MQTTSession {
                 state: StateConnected { mqtt_connection_id },
             }),
-            Ok(response) => {
+            Ok(_response) => {
                 #[cfg(feature = "defmt")]
-                error!("unexpected response from mqtt modem: {:?}", response);
+                error!("unexpected response from mqtt modem: {:?}", _response);
                 Err(AtError::ErrorReply(0))
             }
             Err(e) => Err(e),

src/at_command/network_information.rs

@@ -4,6 +4,7 @@ use at_commands::parser::CommandParser;
 #[cfg(feature = "defmt")]
 use defmt::info;
 
+#[allow(dead_code)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct NetworkOperator([u8; 10]);
 

src/at_command/power_saving_mode.rs

@@ -58,7 +58,7 @@ impl AtRequest for SetPowerSavingMode {
     }
 
     fn parse_response(&self, data: &[u8]) -> Result<AtResponse, AtError> {
-        let (state, context) = CommandParser::parse(data)
+        let (state, _context) = CommandParser::parse(data)
             .expect_identifier(b"\r\n+CPSMS: ")
             .expect_int_parameter()
             .expect_int_parameter()

src/lib.rs

@@ -6,16 +6,16 @@ pub mod at_command;
 pub mod nonblocking;
 
 use crate::at_command::cmee::ReportMobileEquipmentErrorSetting;
-use crate::at_command::flow_control::FlowControl;
+use crate::at_command::flow_control::ControlFlowStatus;
 use crate::at_command::http::HttpClient;
 use at_command::AtRequest;
 use at_command::AtResponse;
 use at_commands::parser::ParseError;
-use core::ptr::read;
 #[cfg(feature = "defmt")]
 use defmt::*;
-use embedded_io::{Error, ErrorKind};
-pub use embedded_io::{ErrorType, Read, Write};
+#[cfg(feature = "defmt")]
+use embedded_io::Error;
+pub use embedded_io::{Read, Write};
 
 const BUFFER_SIZE: usize = 512;
 const LF: u8 = 10; // n
@@ -80,8 +80,8 @@ impl<'a, T: Write, U: Read> Modem<'a, T, U> {
 
     pub fn set_flow_control(&mut self) -> Result<(), AtError> {
         self.send_and_wait_reply(&at_command::flow_control::SetFlowControl {
-            ta_to_te: FlowControl::Software,
-            te_to_ta: FlowControl::Software,
+            ta_to_te: ControlFlowStatus::Software,
+            te_to_ta: ControlFlowStatus::Software,
         })
         .expect("TODO: panic message");
         Ok(())
@@ -104,18 +104,18 @@ impl<'a, T: Write, U: Read> Modem<'a, T, U> {
 
         #[cfg(feature = "defmt")]
         debug!("sending command: {=[u8]:a}", data);
-        self.writer.write(&data).map_err(|e| AtError::IOError)?;
+        self.writer.write(&data).map_err(|_e| AtError::IOError)?;
 
         let mut read_buffer = [0; BUFFER_SIZE];
         let response_size = self.read_response(&mut read_buffer)?;
         let response = payload.parse_response(&read_buffer[..response_size]);
         match response {
             Ok(response) => Ok(response),
-            Err(e) => {
+            Err(_e) => {
                 #[cfg(feature = "defmt")]
                 error!(
                     "{}\nparse response failed on request: {=[u8]:a}\n response: {=[u8]:a}",
-                    e,
+                    _e,
                     &data,
                     &read_buffer[..response_size]
                 );
@@ -175,9 +175,9 @@ impl<'a, T: Write, U: Read> Modem<'a, T, U> {
                     offset += num_bytes;
                 }
 
-                Err(e) => {
+                Err(_e) => {
                     #[cfg(feature = "defmt")]
-                    error!("uart error {}", e.kind());
+                    error!("uart error {}", _e.kind());
                     return Err(AtError::NotReady);
                 }
             }