implement non-blocking read with timeout
much better than before :)
This commit is contained in:
parent
94b9ce312f
commit
792eef13ba
4 changed files with 276 additions and 175 deletions
249
src/modem.rs
249
src/modem.rs
|
|
@ -1,19 +1,17 @@
|
|||
use crate::command::Command;
|
||||
|
||||
use std::thread;
|
||||
use std::io::{Error as IoError, ErrorKind, BufRead};
|
||||
use std::error::Error;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use embedded_hal::serial::{Read, Write};
|
||||
use embedded_hal::digital::v2::OutputPin;
|
||||
use esp_idf_hal::serial::{self, Rx, Tx, SerialError};
|
||||
use esp_idf_hal::serial::{self, Rx, Tx};
|
||||
|
||||
pub type Result<T> = std::result::Result<T, ModemError>;
|
||||
|
||||
pub struct Modem<UART: serial::Uart> {
|
||||
is_connected: bool,
|
||||
rx: MyRx<UART>,
|
||||
rx: Rx<UART>,
|
||||
tx: Tx<UART>,
|
||||
}
|
||||
|
||||
|
|
@ -21,6 +19,7 @@ pub struct Modem<UART: serial::Uart> {
|
|||
pub enum ModemError {
|
||||
CommandError(String),
|
||||
SetupError(String),
|
||||
ReadError,
|
||||
TimeoutError,
|
||||
}
|
||||
|
||||
|
|
@ -32,161 +31,191 @@ impl std::fmt::Display for ModemError {
|
|||
}
|
||||
}
|
||||
|
||||
struct MyRx<UART: serial::Uart>(Rx<UART>);
|
||||
|
||||
impl<UART: serial::Uart> MyRx<UART> {
|
||||
fn read(&mut self) -> nb::Result<u8, SerialError> {
|
||||
self.0.read()
|
||||
}
|
||||
|
||||
fn read_blocking(&mut self) -> std::result::Result<u8, SerialError> {
|
||||
nb::block!(self.read())
|
||||
}
|
||||
}
|
||||
|
||||
impl<UART: serial::Uart> std::io::Read for MyRx<UART> {
|
||||
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
|
||||
let mut read_bytes: usize = 0;
|
||||
loop {
|
||||
let b = self.read_blocking()
|
||||
.map_err(|err| IoError::new(ErrorKind::Other, format!("Serial error {:?}", err)))?;
|
||||
buf[read_bytes] = b;
|
||||
read_bytes += 1;
|
||||
if b == '\0' as u8 || b == '\n' as u8 {
|
||||
break;
|
||||
}
|
||||
};
|
||||
Ok(read_bytes)
|
||||
}
|
||||
}
|
||||
|
||||
impl<UART: serial::Uart> Modem<UART> {
|
||||
pub fn new(tx: Tx<UART>, rx: Rx<UART>) -> Self {
|
||||
Self {
|
||||
is_connected: false,
|
||||
rx: MyRx(rx),
|
||||
rx,
|
||||
tx,
|
||||
}
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// 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.
|
||||
///
|
||||
/// 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, contains: Option<String>, timeout: Duration) -> Result<String> {
|
||||
let mut response = String::new();
|
||||
let now = Instant::now();
|
||||
let match_text: String = contains.unwrap_or("".to_string());
|
||||
/// Below is an example for sim800l pins on a LilyGo TTGO T-Call.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// let modem_pwrkey = dp.pins.gpio4.into_output().unwrap();
|
||||
/// let modem_rst = dp.pins.gpio5.into_output().unwrap();
|
||||
/// let modem_power = dp.pins.gpio23.into_output().unwrap();
|
||||
///
|
||||
/// modem::init(modem_pwrkey, modem_rst, modem_power);
|
||||
/// ```
|
||||
pub fn init(&mut self, 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_string()))?;
|
||||
rst.set_high().map_err(|_| ModemError::SetupError("Error setting RST to high.".to_string()))?;
|
||||
// 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_string()))?;
|
||||
thread::sleep(Duration::from_millis(100));
|
||||
pwrkey.set_low().map_err(|_| ModemError::SetupError("Error setting PWRKEY to low.".to_string()))?;
|
||||
thread::sleep(Duration::from_millis(1000));
|
||||
pwrkey.set_high().map_err(|_| ModemError::SetupError("Error setting PWRKEY to high.".to_string()))?;
|
||||
println!("Waiting 3s for sim module to come online ...");
|
||||
thread::sleep(Duration::from_millis(3000));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
let mut reader = std::io::BufReader::new(&mut self.rx);
|
||||
/// Reads a whole line (that ends with \\n) within the given `timeout` passed on input.
|
||||
/// `nb` returns Ok(byte), or one of Err(WouldBlock) and Err(Other) which isn't of anyone's
|
||||
/// interest, so the retry mechanism is triggered on _any_ error every 200ms until a byte is
|
||||
/// received, or the timeout is reached.
|
||||
///
|
||||
fn read_line(&mut self, timeout: Duration) -> Result<String> {
|
||||
let mut buf = String::new();
|
||||
let start = Instant::now();
|
||||
|
||||
loop {
|
||||
let mut line = String::new();
|
||||
reader.read_line(&mut line)
|
||||
.map_err(|err| ModemError::CommandError(format!("read line failed: {}", err)))?;
|
||||
println!("Read {} from serial ...", line.trim());
|
||||
match self.rx.read() {
|
||||
Ok(b) => {
|
||||
print!("{}, ", b);
|
||||
buf.push(b as char);
|
||||
if b == '\n' as u8 {
|
||||
return Ok(buf);
|
||||
}
|
||||
},
|
||||
_ => {
|
||||
if Instant::now() > start + timeout {
|
||||
return Err(ModemError::ReadError);
|
||||
}
|
||||
else {
|
||||
thread::sleep(Duration::from_millis(200));
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// check if empty first because it's much simpler and more frequent
|
||||
if line == "" {
|
||||
if now + timeout > Instant::now() {
|
||||
return Err(ModemError::TimeoutError);
|
||||
}
|
||||
thread::sleep(Duration::from_millis(1000));
|
||||
continue;
|
||||
} else {
|
||||
/// Reads the serial RX until a \\n char is encoutered, or a timeout is reached. The timeout is
|
||||
/// provided on input via the `timeout` argument. The first argument `contains` is checked
|
||||
/// against a line in the response, if it's there the reading stops.
|
||||
///
|
||||
/// If `contains` is `None`, the first line only is returned in the response. If it's
|
||||
/// `Some(match_txt)`, then the end of the response is matched against `match_txt`.
|
||||
fn read_response(&mut self, contains: Option<String>, timeout: Duration) -> Result<String> {
|
||||
let mut response = String::new();
|
||||
let start = Instant::now();
|
||||
let match_text: String = contains.unwrap_or("".to_string());
|
||||
|
||||
loop {
|
||||
if let Ok(line) = self.read_line(start + timeout - Instant::now()) {
|
||||
response.push_str(&line);
|
||||
if line.contains(&match_text) {
|
||||
if line.contains("ERROR") || line.contains(&match_text) {
|
||||
println!("Found match {} for line {} ... exiting response reader now!", match_text, line);
|
||||
println!("-----------------------------------------------------------");
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if Instant::now() > start + timeout {
|
||||
return Err(ModemError::TimeoutError);
|
||||
}
|
||||
println!("got into retry loop in read_response");
|
||||
thread::sleep(Duration::from_millis(200));
|
||||
}
|
||||
}
|
||||
Ok(response.to_string())
|
||||
}
|
||||
|
||||
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_string()))?;
|
||||
fn send(&mut self, b: u8) -> Result<()> {
|
||||
nb::block!(self.tx.write(b))
|
||||
.map_err(|_| ModemError::CommandError(format!("error writing {} to serial", b)))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn send_bytes(&mut self, payload: &[u8]) -> Result<()> {
|
||||
for b in payload.iter() {
|
||||
self.send(*b)?;
|
||||
}
|
||||
nb::block!(self.tx.write('\r' as u8)).map_err(|_| ModemError::CommandError("error writing <CR> to serial".to_string()))?;
|
||||
self.send('\r' as u8)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn send_command(&mut self, cmd: Command) -> Result<String> {
|
||||
println!("-----------------------------------------------------------");
|
||||
println!("Sending {} ...", cmd.text);
|
||||
let _ = self.send_bytes(cmd.text.as_bytes())?;
|
||||
self.read_response(cmd.contains.clone(), cmd.timeout.clone())
|
||||
}
|
||||
|
||||
pub fn get_ip_addr(&mut self) -> Result<String> {
|
||||
println!("getting ip addres ...");
|
||||
let res = self.send_command(Command::getbear())?;
|
||||
println!("{}", res);
|
||||
Ok(res)
|
||||
self.send_command(Command::getbear())
|
||||
}
|
||||
|
||||
pub fn get_local_ip_addr(&mut self) -> Result<()> {
|
||||
let _ = self.send_command(Command::get_local_ip_addr())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn connect_to_gprs_ap(&mut self, apn: &str, username: &str, password: &str)-> Result<()> {
|
||||
println!("init gprs ...");
|
||||
let _ = self.send_command(Command::initgprs())?;
|
||||
let _ = self.send_command(Command::gprs_init())?;
|
||||
|
||||
println!("connecting to {} with {}:{}", apn, username, password);
|
||||
println!("setting up gprs credentials for apn {}, {}:{})", apn, username, password);
|
||||
|
||||
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::gprs_set_apn(apn))?;
|
||||
let _ = self.send_command(Command::gprs_set_user(username))?;
|
||||
let _ = self.send_command(Command::gprs_set_pwd(password))?;
|
||||
|
||||
println!("open gprs ...");
|
||||
let _ = self.send_command(Command::initgprs())?;
|
||||
let _ = self.send_command(Command::gprs_open())?;
|
||||
|
||||
self.is_connected = true;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn info(&mut self)-> Result<String> {
|
||||
println!("getting modem info with API command");
|
||||
self.send_command(Command::modeminfo())
|
||||
self.send_command(Command::modem_info())
|
||||
}
|
||||
|
||||
pub fn probe(&mut self)-> Result<String> {
|
||||
println!("probing modem with AP command");
|
||||
self.send_command(Command::probe())
|
||||
}
|
||||
|
||||
pub fn is_gprs_attached(&mut self)-> Result<bool> {
|
||||
println!("testing gprs connection ...");
|
||||
let res = self.send_command(Command::is_gprs_attached())?;
|
||||
|
||||
Ok(res.contains("+CGATT: 1"))
|
||||
}
|
||||
}
|
||||
|
||||
/// 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 modem_pwrkey = dp.pins.gpio4.into_output().unwrap();
|
||||
/// let modem_rst = dp.pins.gpio5.into_output().unwrap();
|
||||
/// let 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_string()))?;
|
||||
rst.set_high().map_err(|_| ModemError::SetupError("Error setting RST to high.".to_string()))?;
|
||||
// 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_string()))?;
|
||||
thread::sleep(Duration::from_millis(100));
|
||||
pwrkey.set_low().map_err(|_| ModemError::SetupError("Error setting PWRKEY to low.".to_string()))?;
|
||||
thread::sleep(Duration::from_millis(1000));
|
||||
pwrkey.set_high().map_err(|_| ModemError::SetupError("Error setting PWRKEY to high.".to_string()))?;
|
||||
println!("Waiting 3s for sim module to come online ...");
|
||||
thread::sleep(Duration::from_millis(3000));
|
||||
Ok(())
|
||||
pub fn ping(&mut self, domain: &str)-> Result<()> {
|
||||
self.send_command(Command::ping(domain))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn tcp_is_ssl_enabled(&mut self) -> Result<bool> {
|
||||
let res = self.send_command(Command::tcp_ssl_check())?;
|
||||
Ok(res.contains("+CIPSSL: (1)"))
|
||||
}
|
||||
|
||||
pub fn tcp_ssl_disable(&mut self) -> Result<()> {
|
||||
let _ = self.send_command(Command::tcp_ssl_disable())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn tcp_connect(&mut self, addr: &str, port: u16) -> Result<()> {
|
||||
self.send_command(Command::tcp_connect(addr, port))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn tcp_set_quick_mode(&mut self, mode: bool) -> Result<()> {
|
||||
self.send_command(Command::tcp_set_quick_mode(mode))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn tcp_send(&mut self, payload: &str) -> Result<()> {
|
||||
self.send_command(Command::tcp_send(payload.len()))?;
|
||||
self.send_command(Command::tcp_write(payload))?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue