sim7020 2.2.0

driver for sim7020E NB IoT modem
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::at_command::{AtRequest, AtResponse};
use crate::{at_command, AtError, BUFFER_SIZE, ERROR_TERMINATOR, OK_TERMINATOR};
use embedded_io_async::{Read, Write};

use crate::at_command::cmee::ReportMobileEquipmentErrorSetting;
#[cfg(feature = "defmt")]
use defmt::*;
#[cfg(feature = "defmt")]
use embedded_io::Error;
use log::error;

pub struct AsyncModem<T: Write, U: Read> {
    pub writer: T,
    pub reader: U,
}

impl<'a, T: Write, U: Read> AsyncModem<T, U> {
    pub async fn new(writer: T, reader: U) -> Result<Self, AtError> {
        let mut modem = Self { writer, reader };
        modem.disable_echo().await?;
        Ok(modem)
    }

    async fn disable_echo(&mut self) -> Result<AtResponse, AtError> {
        self.send_and_wait_reply(at_command::ate::AtEcho {
            status: at_command::ate::Echo::Disable,
        })
        .await
    }

    pub async fn verbosity(
        &mut self,
        verbosity: ReportMobileEquipmentErrorSetting,
    ) -> Result<AtResponse, AtError> {
        self.send_and_wait_reply(at_command::cmee::SetReportMobileEquipmentError {
            setting: verbosity,
        })
        .await
    }

    pub async fn send_and_wait_reply<V: AtRequest + 'a>(
        &'a mut self,
        payload: V,
    ) -> Result<AtResponse, crate::AtError> {
        let mut buffer = [0; BUFFER_SIZE];
        let data = payload.get_command_no_error(&mut buffer);
        #[cfg(feature = "defmt")]
        debug!("payload: {=[u8]:a}", &data);
        self.writer.write(data).await.unwrap();
        match self.read_response(&mut buffer).await {
            Ok(response_size) => {
                #[cfg(feature = "defmt")]
                debug!("received response: {=[u8]:a}", buffer[..response_size]);
                let response = payload.parse_response(&buffer);
                #[cfg(feature = "defmt")]
                debug!("parsed response: {}", response);
                response
            }
            Err(at_error) => {
                match at_error {
                    AtError::ErrorReply(response_size) => {
                        #[cfg(feature = "defmt")]
                        debug!("received response: {=[u8]:a}", buffer[..response_size]);
                    }
                    _ => {
                        #[cfg(feature = "defmt")]
                        debug!("error: {:?}", at_error);
                    }
                }

                Err(at_error)
            }
        }
    }

    pub async fn read_next_response(&mut self) -> Result<AtResponse, crate::AtError> {
        let mut buffer = [0; BUFFER_SIZE];
        #[cfg(feature = "defmt")]
        let response_size = self.read_response(&mut buffer).await?;
        #[cfg(feature = "defmt")]
        debug!("received response: {=[u8]:a}", buffer[..response_size]);
        Ok(AtResponse::Ok)
    }

    async fn read_response(
        &mut self,
        response_out: &mut [u8; BUFFER_SIZE],
    ) -> Result<usize, crate::AtError> {
        let mut offset = 0_usize;
        let mut read_buffer: [u8; 10] = [0; 10];
        loop {
            match self.reader.read(&mut read_buffer).await {
                Ok(num_bytes) => {
                    for i in 0..num_bytes {
                        response_out[offset + i] = read_buffer[i];
                        // debug!("{=[u8]:a}, {}", *response_out, offset + i );

                        // why is the index with + 1 and - 5?
                        if offset + i < 5 {
                            continue;
                        }

                        let start = offset + i - 5;
                        let stop = offset + i + 1;

                        match &response_out[start..stop] {
                            OK_TERMINATOR => return Ok(offset + i),
                            ERROR_TERMINATOR => return Err(AtError::ErrorReply(offset + i)),
                            _ => continue,
                        }
                    }
                    offset += num_bytes;
                }

                Err(e) => {
                    #[cfg(feature = "defmt")]
                    error!("no data: {:?}", e.kind());
                }
            }
        }
    }
}