warning: usage of wildcard import
 --> examples/src/common/general/mod.rs:6:5
  |
6 | use responses::*;
  |     ^^^^^^^^^^^^ help: try: `responses::{ManufacturerId, ModelId, SoftwareVersion, WifiMac}`
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports
  = note: `-W clippy::wildcard-imports` implied by `-W clippy::pedantic`
  = help: to override `-W clippy::pedantic` add `#[allow(clippy::wildcard_imports)]`

warning: multiple versions for dependency `nb`: 0.1.3, 1.1.0
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_crate_versions

warning: multiple versions for dependency `heapless`: 0.7.17, 0.8.0
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_crate_versions

warning: multiple versions for dependency `hash32`: 0.2.1, 0.3.1
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_crate_versions

warning: multiple versions for dependency `embedded-hal`: 0.2.7, 1.0.0
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_crate_versions
  = note: `-W clippy::multiple-crate-versions` implied by `-W clippy::cargo`
  = help: to override `-W clippy::cargo` add `#[allow(clippy::multiple_crate_versions)]`

warning: use Option::map_or_else instead of an if let/else
  --> atat_derive/src/urc.rs:53:26
   |
53 |           let digest_arm = if let Some(parse_fn) = parse {
   |  __________________________^
54 | |             quote! {
55 | |                 #parse_fn(&#code[..]),
56 | |             }
...  |
60 | |             }
61 | |         };
   | |_________^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_if_let_else
help: try
   |
53 ~         let digest_arm = parse.map_or_else(|| quote! {
54 +                 atat::digest::parser::urc_helper(&#code[..]),
55 +             }, |parse_fn| quote! {
56 +                 #parse_fn(&#code[..]),
57 ~             });
   |

warning: unnecessary boolean `not` operation
   --> atat/src/blocking/client.rs:111:9
    |
111 | /         if !Cmd::EXPECTS_RESPONSE_CODE {
112 | |             cmd.parse(Ok(&[]))
113 | |         } else {
114 | |             let response = self.wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))?;
115 | |             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
116 | |             cmd.parse(response.into())
117 | |         }
    | |_________^
    |
    = help: remove the `!` and swap the blocks of the `if`/`else`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#if_not_else

warning: this expression creates a reference which is immediately dereferenced by the compiler
   --> atat/src/blocking/client.rs:109:29
    |
109 |         let len = cmd.write(&mut self.buf);
    |                             ^^^^^^^^^^^^^ help: change this to: `self.buf`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow

warning: temporary with significant `Drop` can be early dropped
   --> atat/src/blocking/client.rs:114:17
    |
113 |           } else {
    |  ________________-
114 | |             let response = self.wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))?;
    | |                 ^^^^^^^^
115 | |             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
116 | |             cmd.parse(response.into())
117 | |         }
    | |_________- temporary `response` is currently being dropped at the end of its contained scope
    |
    = note: this might lead to unnecessary resource contention
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_tightening
help: merge the temporary construction with its single usage
    |
114 ~             
115 +             let response = self.wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))?.;
    |
help: remove separated single usage
    |
115 -             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
115 +             
    |

warning: the following explicit lifetimes could be elided: 'guard
  --> atat/src/blocking/client.rs:68:22
   |
68 |     fn wait_response<'guard>(
   |                      ^^^^^^
69 |         &'guard mut self,
   |          ^^^^^^
70 |         timeout: Duration,
71 |     ) -> Result<ResponseSlotGuard<'guard, INGRESS_BUF_SIZE>, Error> {
   |                                   ^^^^^^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
help: elide the lifetimes
   |
68 ~     fn wait_response(
69 ~         &mut self,
70 |         timeout: Duration,
71 ~     ) -> Result<ResponseSlotGuard<'_, INGRESS_BUF_SIZE>, Error> {
   |

warning: unnecessary boolean `not` operation
   --> atat/src/asynch/simple_client.rs:144:9
    |
144 | /         if !Cmd::EXPECTS_RESPONSE_CODE {
145 | |             cmd.parse(Ok(&[]))
146 | |         } else {
147 | |             let response = embassy_time::with_timeout(
...   |
154 | |             cmd.parse((&response).into())
155 | |         }
    | |_________^
    |
    = help: remove the `!` and swap the blocks of the `if`/`else`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#if_not_else

warning: this expression creates a reference which is immediately dereferenced by the compiler
   --> atat/src/asynch/simple_client.rs:141:29
    |
141 |         let len = cmd.write(&mut self.buf);
    |                             ^^^^^^^^^^^^^ help: change this to: `self.buf`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow

warning: future cannot be sent between threads safely
   --> atat/src/asynch/simple_client.rs:140:5
    |
140 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `send` is not `Send`
    |
note: future is not `Send` as this value is used across an await
   --> atat/src/asynch/simple_client.rs:143:32
    |
140 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |                                            --- has type `&Cmd` which is not `Send`
...
143 |         self.send_request(len).await?;
    |                                ^^^^^ await occurs here, with `cmd` maybe used later
    = note: `Cmd` doesn't implement `core::marker::Sync`
note: future is not `Send` as this value is used across an await
   --> atat/src/asynch/simple_client.rs:143:32
    |
140 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |                                 --------- has type `&mut asynch::simple_client::SimpleClient<'_, RW, D>` which is not `Send`
...
143 |         self.send_request(len).await?;
    |                                ^^^^^ await occurs here, with `&mut self` maybe used later
    = note: `RW` doesn't implement `core::marker::Send`
note: future is not `Send` as this value is used across an await
   --> atat/src/asynch/simple_client.rs:143:32
    |
140 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |                                 --------- has type `&mut asynch::simple_client::SimpleClient<'_, RW, D>` which is not `Send`
...
143 |         self.send_request(len).await?;
    |                                ^^^^^ await occurs here, with `&mut self` maybe used later
    = note: `D` doesn't implement `core::marker::Send`
    = note: `impl futures::Future<Output = core::result::Result<(), <RW as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
    = note: `impl futures::Future<Output = core::result::Result<(), <RW as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
note: future is not `Send` as it awaits another future which is not `Send`
   --> atat/src/asynch/simple_client.rs:53:19
    |
53  |             match self.rw.read(&mut self.buf[self.pos..]).await {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ await occurs here on type `impl futures::Future<Output = core::result::Result<usize, <RW as embedded_io::ErrorType>::Error>>`, which is not `Send`
    = note: `impl futures::Future<Output = core::result::Result<usize, <RW as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send

warning: consider adding a `;` to the last statement for consistent formatting
   --> atat/src/asynch/simple_client.rs:134:13
    |
134 |             cooldown.await
    |             ^^^^^^^^^^^^^^ help: add a `;` here: `cooldown.await;`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned

warning: future cannot be sent between threads safely
   --> atat/src/asynch/simple_client.rs:132:5
    |
132 |     async fn wait_cooldown_timer(&mut self) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `wait_cooldown_timer` is not `Send`
    |
note: captured value is not `Send` because `&mut` references cannot be sent unless their referent is `Send`
   --> atat/src/asynch/simple_client.rs:132:34
    |
132 |     async fn wait_cooldown_timer(&mut self) {
    |                                  ^^^^^^^^^ has type `&mut asynch::simple_client::SimpleClient<'a, RW, D>` which is not `Send`, because `asynch::simple_client::SimpleClient<'a, RW, D>` is not `Send`
    = note: `RW` doesn't implement `core::marker::Send`
note: captured value is not `Send` because `&mut` references cannot be sent unless their referent is `Send`
   --> atat/src/asynch/simple_client.rs:132:34
    |
132 |     async fn wait_cooldown_timer(&mut self) {
    |                                  ^^^^^^^^^ has type `&mut asynch::simple_client::SimpleClient<'a, RW, D>` which is not `Send`, because `asynch::simple_client::SimpleClient<'a, RW, D>` is not `Send`
    = note: `D` doesn't implement `core::marker::Send`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send

warning: consider adding a `;` to the last statement for consistent formatting
  --> atat/src/asynch/simple_client.rs:88:37
   |
88 | ...                   debug!("Received OK ({}/{})", swallowed, self.pos)
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add a `;` here: `debug!("Received OK ({}/{})", swallowed, self.pos);`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned

warning: future cannot be sent between threads safely
  --> atat/src/asynch/simple_client.rs:51:5
   |
51 |     async fn wait_response<'guard>(&'guard mut self) -> Result<Response<256>, Error> {
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `wait_response` is not `Send`
   |
note: future is not `Send` as it awaits another future which is not `Send`
  --> atat/src/asynch/simple_client.rs:53:19
   |
53 |             match self.rw.read(&mut self.buf[self.pos..]).await {
   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ await occurs here on type `impl futures::Future<Output = core::result::Result<usize, <RW as embedded_io::ErrorType>::Error>>`, which is not `Send`
   = note: `impl futures::Future<Output = core::result::Result<usize, <RW as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
note: future is not `Send` as this value is used across an await
  --> atat/src/asynch/simple_client.rs:53:59
   |
51 |     async fn wait_response<'guard>(&'guard mut self) -> Result<Response<256>, Error> {
   |                                    ---------------- has type `&mut asynch::simple_client::SimpleClient<'a, RW, D>` which is not `Send`
52 |         loop {
53 |             match self.rw.read(&mut self.buf[self.pos..]).await {
   |                                                           ^^^^^ await occurs here, with `&'guard mut self` maybe used later
   = note: `RW` doesn't implement `core::marker::Send`
note: future is not `Send` as this value is used across an await
  --> atat/src/asynch/simple_client.rs:53:59
   |
51 |     async fn wait_response<'guard>(&'guard mut self) -> Result<Response<256>, Error> {
   |                                    ---------------- has type `&mut asynch::simple_client::SimpleClient<'a, RW, D>` which is not `Send`
52 |         loop {
53 |             match self.rw.read(&mut self.buf[self.pos..]).await {
   |                                                           ^^^^^ await occurs here, with `&'guard mut self` maybe used later
   = note: `D` doesn't implement `core::marker::Send`
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send

warning: future cannot be sent between threads safely
  --> atat/src/asynch/simple_client.rs:27:5
   |
27 |     async fn send_request(&mut self, len: usize) -> Result<(), Error> {
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `send_request` is not `Send`
   |
note: future is not `Send` as this value is used across an await
  --> atat/src/asynch/simple_client.rs:34:36
   |
27 |     async fn send_request(&mut self, len: usize) -> Result<(), Error> {
   |                           --------- has type `&mut asynch::simple_client::SimpleClient<'a, RW, D>` which is not `Send`
...
34 |         self.wait_cooldown_timer().await;
   |                                    ^^^^^ await occurs here, with `&mut self` maybe used later
   = note: `RW` doesn't implement `core::marker::Send`
note: future is not `Send` as this value is used across an await
  --> atat/src/asynch/simple_client.rs:34:36
   |
27 |     async fn send_request(&mut self, len: usize) -> Result<(), Error> {
   |                           --------- has type `&mut asynch::simple_client::SimpleClient<'a, RW, D>` which is not `Send`
...
34 |         self.wait_cooldown_timer().await;
   |                                    ^^^^^ await occurs here, with `&mut self` maybe used later
   = note: `D` doesn't implement `core::marker::Send`
   = note: `impl futures::Future<Output = core::result::Result<(), <RW as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
   = note: `impl futures::Future<Output = core::result::Result<(), <RW as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send

warning: unnecessary boolean `not` operation
   --> atat/src/asynch/client.rs:117:9
    |
117 | /         if !Cmd::EXPECTS_RESPONSE_CODE {
118 | |             cmd.parse(Ok(&[]))
119 | |         } else {
120 | |             let response = self
...   |
124 | |             cmd.parse(response.into())
125 | |         }
    | |_________^
    |
    = help: remove the `!` and swap the blocks of the `if`/`else`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#if_not_else
    = note: `-W clippy::if-not-else` implied by `-W clippy::pedantic`
    = help: to override `-W clippy::pedantic` add `#[allow(clippy::if_not_else)]`

warning: this expression creates a reference which is immediately dereferenced by the compiler
   --> atat/src/asynch/client.rs:115:29
    |
115 |         let len = cmd.write(&mut self.buf);
    |                             ^^^^^^^^^^^^^ help: change this to: `self.buf`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
    = note: `-W clippy::needless-borrow` implied by `-W clippy::all`
    = help: to override `-W clippy::all` add `#[allow(clippy::needless_borrow)]`

warning: temporary with significant `Drop` can be early dropped
   --> atat/src/asynch/client.rs:120:17
    |
119 |           } else {
    |  ________________-
120 | |             let response = self
    | |                 ^^^^^^^^
121 | |                 .wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))
122 | |                 .await?;
123 | |             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
124 | |             cmd.parse(response.into())
125 | |         }
    | |_________- temporary `response` is currently being dropped at the end of its contained scope
    |
    = note: this might lead to unnecessary resource contention
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_tightening
help: merge the temporary construction with its single usage
    |
120 ~             
121 +             let response = self
122 +                 .wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))
123 +                 .await?.;
    |
help: remove separated single usage
    |
123 -             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
123 +             
    |

warning: future cannot be sent between threads safely
   --> atat/src/asynch/client.rs:114:5
    |
114 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `send` is not `Send`
    |
note: future is not `Send` as this value is used across an await
   --> atat/src/asynch/client.rs:116:32
    |
114 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |                                            --- has type `&Cmd` which is not `Send`
115 |         let len = cmd.write(&mut self.buf);
116 |         self.send_request(len).await?;
    |                                ^^^^^ await occurs here, with `cmd` maybe used later
    = note: `Cmd` doesn't implement `core::marker::Sync`
note: future is not `Send` as this value is used across an await
   --> atat/src/asynch/client.rs:116:32
    |
114 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |                                 --------- has type `&mut asynch::client::Client<'_, W, INGRESS_BUF_SIZE>` which is not `Send`
115 |         let len = cmd.write(&mut self.buf);
116 |         self.send_request(len).await?;
    |                                ^^^^^ await occurs here, with `&mut self` maybe used later
    = note: `W` doesn't implement `core::marker::Send`
    = note: `impl futures::Future<Output = core::result::Result<(), <W as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
    = note: `impl futures::Future<Output = core::result::Result<(), <W as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
note: future is not `Send` as this value is used across an await
   --> atat/src/asynch/client.rs:88:57
    |
78  |         &self,
    |         ----- has type `&asynch::client::Client<'_, W, INGRESS_BUF_SIZE>` which is not `Send`
...
88  |             fut = match select(fut, Timer::at(expires)).await {
    |                                                         ^^^^^ await occurs here, with `&self` maybe used later
    = note: `W` doesn't implement `core::marker::Sync`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send

warning: consider adding a `;` to the last statement for consistent formatting
   --> atat/src/asynch/client.rs:108:13
    |
108 |             cooldown.await
    |             ^^^^^^^^^^^^^^ help: add a `;` here: `cooldown.await;`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned

warning: future cannot be sent between threads safely
   --> atat/src/asynch/client.rs:106:5
    |
106 |     async fn wait_cooldown_timer(&mut self) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `wait_cooldown_timer` is not `Send`
    |
note: captured value is not `Send` because `&mut` references cannot be sent unless their referent is `Send`
   --> atat/src/asynch/client.rs:106:34
    |
106 |     async fn wait_cooldown_timer(&mut self) {
    |                                  ^^^^^^^^^ has type `&mut asynch::client::Client<'a, W, INGRESS_BUF_SIZE>` which is not `Send`, because `asynch::client::Client<'a, W, INGRESS_BUF_SIZE>` is not `Send`
    = note: `W` doesn't implement `core::marker::Send`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send

warning: matching over `()` is more explicit
  --> atat/src/asynch/client.rs:90:32
   |
90 |                 Either::Right((_, fut)) => {
   |                                ^ help: use `()` instead of `_`: `()`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ignored_unit_patterns