e-bike-tracker-device/src/modem.rs

use std::fmt::Write;
use std::thread;
use std::time::Duration;

use embedded_hal::digital::v2::OutputPin;
use embedded_hal::serial::Read;
use esp_idf_hal::serial::{self, Rx, Tx};

pub fn init(mut pwrkey: impl OutputPin, mut rst: impl OutputPin, mut power: impl OutputPin) -> Result<()> {
    println!("Turning SIM800L on ...");
    power.set_high().map_err(|_| ModemError::SetupError("Error setting POWER to high.".to_owned()))?;
    rst.set_high().map_err(|_| ModemError::SetupError("Error setting RST to high.".to_owned()))?;
    // Pull down PWRKEY for more than 1 second according to manual requirements
    pwrkey.set_high().map_err(|_| ModemError::SetupError("Error setting PWRKEY to high.".to_owned()))?;
    thread::sleep(Duration::from_millis(100));
    pwrkey.set_low().map_err(|_| ModemError::SetupError("Error setting PWRKEY to low.".to_owned()))?;
    thread::sleep(Duration::from_millis(1000));
    pwrkey.set_high().map_err(|_| ModemError::SetupError("Error setting PWRKEY to high.".to_owned()))?;
    println!("Waiting 5s for sim module to come online ...");
    thread::sleep(Duration::from_millis(5000));
    Ok(())
}

pub struct Modem<UART: serial::Uart> {
    is_connected: bool,
    rx: Rx<UART>,
    tx: Tx<UART>,
}

#[derive(Debug)]
pub enum ModemError {
    GprsAPConnectionError(String),
    ATCommandError(String),
    CommandError(String),
    SetupError(String),
}

impl std::fmt::Display for ModemError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

pub type Result<T> = std::result::Result<T, ModemError>;

impl<UART: serial::Uart> Modem<UART> {
    pub fn new(tx: Tx<UART>, rx: Rx<UART>) -> Self {
        Self {
            is_connected: false,
            rx,
            tx,
        }
    }

    fn at_command(&mut self, cmd: &str) -> Result<String> {
        let mut msg = "AT+".to_owned();
        msg.push_str(cmd);
        self.send_command(&msg)
            .map_err(|err| ModemError::ATCommandError(format!("{}", err)))
    }

    fn read_response(&mut self) -> Result<String> {
        let len = self.rx.count()
            .map_err(|_| ModemError::CommandError("Error getting RX fifo length".to_owned()))?;

        if cfg!(debug_assertions) {
            println!("Reading {} bytes from serial RX ...", len);
        }

        let mut response = String::new();
        for _ in 0..len {
            nb::block!(self.rx.read())
                .map(|b| response.push(b as char))
                .map_err(|_| ModemError::CommandError("Error reading from RX".to_owned()))?;
        }
        response = response.trim().to_owned();

        if cfg!(debug_assertions) {
            println!("Received: {}", response);
        }
        Ok(response)
    }

    fn send_command(&mut self, cmd: &str) -> Result<String> {
        writeln!(self.tx, "{}", cmd)
            .map_err(|_| ModemError::CommandError("error writing to serial".to_owned()))?;
        self.read_response()
    }

    pub fn connect_to_gprs_ap(&mut self, apn: &str, username: &str, password: &str)-> Result<String> {
        println!("connecting to {} with {}:{}", apn, username, password);
        self.at_command("CGATTCGATT=1")
            .map(|response| {
                println!("connected to {} with response: {}", apn, response);
                self.is_connected = true;
                response
            })
            .map_err(|err| ModemError::GprsAPConnectionError(format!("{}", err)))
    }

    pub fn test_modem(&mut self)-> Result<String> {
        println!("testing modem with AP command");
        self.at_command("AT")
            .map(|response| {
                println!("modem responded with: {}", response);
                response
            })
            .map_err(|err| ModemError::GprsAPConnectionError(format!("{}", err)))
    }
}