e-bike-tracker/e-bike-tracker-device
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

implement commands and turn everything on

Browse source 
Turn the modem on by setting appropriate pins to high/low.

Implemented all commands from
https://github.com/pythings/Drivers/blob/master/SIM800L.py#L116-L143 in Rust.

Moved AP values to a config module. Maybe create a build environment for this
later on, we'll need to support multiple telecom providers for sure ...

Fix the write/read implementation for the Serial. Match on end and handle the
timeout properly for every command.
This commit is contained in:
Vladan Popovic 2022-06-16 01:06:32 +02:00
parent 737e29f108
commit 43424ba997
4 changed files with 354 additions and 98 deletions
Download patch file Download diff file Expand all files Collapse all files

152
src/modem.rs
View file

@ -1,25 +1,13 @@
use std::fmt::Write;
use std::thread;
use std::time::Duration;
use crate::command::Command;
use std::iter::FromIterator;
use std::thread;
use std::time::{Duration, Instant};
use embedded_hal::serial::{Read, Write};
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,
@ -29,8 +17,6 @@ pub struct Modem<UART: serial::Uart> {
#[derive(Debug)]
pub enum ModemError {
GprsAPConnectionError(String),
ATCommandError(String),
CommandError(String),
SetupError(String),
}
@ -52,59 +38,107 @@ impl<UART: serial::Uart> Modem<UART> {
}
}
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> {
/// Reads the serial RX until it has bytes, or until a timeout is reached. The timeout is
/// provided on input via the `timeout` argument. The first argument `expected` is the expected
/// end of the buffer. If it's `None`, the whole response is returned as is. If it's
/// `Some(expected_end)`, then the end of the response is matched against `expected_end`. If
/// they match, great! The response is returned from the function, but if not, then a
/// [ModemError::CommandError](crate::modem::ModemError::CommandError) is returned.
///
/// It's ok to use this function like this for now because the write/read cycle is blocking,
/// hence the case where multiple writes happen asynchronously isn't handled. See
/// [send_command](crate::modem::Modem::send_command) for more info on the blocking part.
fn read_response(&mut self, expected: Option<String>, timeout: Duration) -> 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);
}
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();
let now = Instant::now();
if cfg!(debug_assertions) {
println!("Received: {}", response);
loop {
let len = self.rx.count().unwrap();
if len == 0 {
if now + timeout > Instant::now() {
break;
}
thread::sleep(Duration::from_secs(1));
continue;
}
println!("Reading {} bytes from serial RX ...", len);
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()))?;
}
}
Ok(response)
let response = response.trim();
println!("Received: {}", response);
expected.map(|expected_end| {
if response.ends_with(&expected_end) {
Ok(response.to_owned())
} else {
let res = String::from_iter(response.chars().rev().take(expected_end.len()));
Err(ModemError::CommandError(format!("Got invalid response end {} instead of expected {}", res, expected_end)))
}
}).unwrap_or(Ok(response.to_owned()))
}
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()
fn send_command(&mut self, cmd: Command) -> Result<String> {
for b in cmd.text.as_bytes().iter() {
nb::block!(self.tx.write(*b)).map_err(|_| ModemError::CommandError("error writing to serial".to_owned()))?;
}
self.read_response(cmd.ends_with, cmd.timeout)
}
pub fn connect_to_gprs_ap(&mut self, apn: &str, username: &str, password: &str)-> Result<String> {
pub fn connect_to_gprs_ap(&mut self, apn: &str, username: &str, password: &str)-> Result<()> {
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)))
let _ = self.send_command(Command::setapn(apn))?;
let _ = self.send_command(Command::setuser(username))?;
let _ = self.send_command(Command::setpwd(password))?;
let _ = self.send_command(Command::opengprs())?;
self.is_connected = true;
Ok(())
}
pub fn test_modem(&mut self)-> Result<String> {
pub fn modem_info(&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)))
self.send_command(Command::modeminfo())
}
}
/// Initialize the modem (sim800l in this case). The initialization process sets all pins in the
/// required state so that the modem is turned on, then resets it a couple of times (beats me) and
/// sleeps for 3 seconds, which is enough for the modem to come online.
///
/// Below is an example for sim800l pins on a LilyGo TTGO T-Call.
///
/// # Examples
///
/// ```
/// let mut modem_pwrkey = dp.pins.gpio4.into_output().unwrap();
/// let mut modem_rst = dp.pins.gpio5.into_output().unwrap();
/// let mut modem_power = dp.pins.gpio23.into_output().unwrap();
///
/// modem::init(modem_pwrkey, modem_rst, modem_power);
/// ```
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 3s for sim module to come online ...");
thread::sleep(Duration::from_millis(3000));
Ok(())
}