nordic-dev.net/embassy
2
0
Fork 0
mirror of https://github.com/embassy-rs/embassy.git synced 2024-11-21 22:32:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add context run task

Browse Source
This commit is contained in:
Ulf Lilleengen 2024-09-04 18:47:26 +02:00
parent 49881f6fd1
commit 372e45dabc
3 changed files with 137 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
embassy-net-nrf91/src/context.rs
View File

@ -5,6 +5,7 @@ use core::str::FromStr;
use at_commands::builder::CommandBuilder;
use at_commands::parser::CommandParser;
use heapless::Vec;
use embassy_time::{Timer, Duration};
/// Provides a higher level API for controlling a given context.
pub struct Control<'a> {
@ -23,6 +24,8 @@ pub struct Config<'a> {
}
/// Authentication protocol.
#[derive(Clone, Copy, PartialEq, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[repr(u8)]
pub enum AuthProt {
/// No authentication.
@ -84,7 +87,7 @@ impl<'a> Control<'a> {
}
/// Configures the modem with the provided config.
pub async fn configure(&self, config: Config<'_>) -> Result<(), Error> {
pub async fn configure(&self, config: &Config<'_>) -> Result<(), Error> {
let mut cmd: [u8; 256] = [0; 256];
let mut buf: [u8; 256] = [0; 256];
@ -118,9 +121,64 @@ impl<'a> Control<'a> {
let n = self.control.at_command(op, &mut buf).await;
CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
let op = CommandBuilder::create_set(&mut cmd, true)
.named("%XPDNCFG")
.with_int_parameter(1)
.finish()
.map_err(|_| Error::BufferTooSmall)?;
let n = self.control.at_command(op, &mut buf).await;
CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
Ok(())
}
/// Attach to the PDN
pub async fn attach(&self) -> Result<(), Error> {
let mut cmd: [u8; 256] = [0; 256];
let mut buf: [u8; 256] = [0; 256];
let op = CommandBuilder::create_set(&mut cmd, true)
.named("+CGATT")
.with_int_parameter(1)
.finish()
.map_err(|_| Error::BufferTooSmall)?;
let n = self.control.at_command(op, &mut buf).await;
CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
Ok(())
}
/// Read current connectivity status for modem.
pub async fn detach(&self) -> Result<(), Error> {
let mut cmd: [u8; 256] = [0; 256];
let mut buf: [u8; 256] = [0; 256];
let op = CommandBuilder::create_set(&mut cmd, true)
.named("+CGATT")
.with_int_parameter(0)
.finish()
.map_err(|_| Error::BufferTooSmall)?;
let n = self.control.at_command(op, &mut buf).await;
CommandParser::parse(&buf[..n]).expect_identifier(b"OK").finish()?;
Ok(())
}
async fn attached(&self) -> Result<bool, Error> {
let mut cmd: [u8; 256] = [0; 256];
let mut buf: [u8; 256] = [0; 256];
let op = CommandBuilder::create_query(&mut cmd, true)
.named("+CGATT")
.finish()
.map_err(|_| Error::BufferTooSmall)?;
let n = self.control.at_command(op, &mut buf).await;
let (res,) = CommandParser::parse(&buf[..n])
.expect_identifier(b"+CGATT: ")
.expect_int_parameter()
.expect_identifier(b"\r\nOK")
.finish()?;
Ok(res == 1)
}
/// Read current connectivity status for modem.
pub async fn status(&self) -> Result<Status, Error> {
let mut cmd: [u8; 256] = [0; 256];
@ -162,7 +220,6 @@ impl<'a> Control<'a> {
let ip = if let Some(ip) = ip1 {
let ip = IpAddr::from_str(ip).map_err(|_| Error::AddrParseError)?;
self.control.open_raw_socket().await;
Some(ip)
} else {
None
@ -219,4 +276,29 @@ impl<'a> Control<'a> {
dns,
})
}
/// Run a control loop for this context, ensuring that reaattach is handled.
pub async fn run<F: Fn(&Status)>(&self, config: &Config<'_>, reattach: F) -> Result<(), Error> {
self.configure(config).await?;
while !self.attached().await? {
Timer::after(Duration::from_secs(1)).await;
}
let status = self.status().await?;
let mut fd = self.control.open_raw_socket().await;
reattach(&status);
loop {
if !self.attached().await? {
// TODO: self.control.close_raw_socket(fd).await;
self.attach().await?;
while !self.attached().await? {
Timer::after(Duration::from_secs(1)).await;
}
let status = self.status().await?;
// TODO: let mut fd = self.control.open_raw_socket().await;
reattach(&status);
}
Timer::after(Duration::from_secs(10)).await;
}
}
}

5
embassy-net-nrf91/src/lib.rs
View File

@ -844,7 +844,7 @@ impl<'a> Control<'a> {
/// Open the raw socket used for sending/receiving IP packets.
///
/// This must be done after `AT+CFUN=1` (?)
async fn open_raw_socket(&self) {
async fn open_raw_socket(&self) -> u32 {
let mut msg: Message = unsafe { mem::zeroed() };
msg.channel = 2; // data
msg.id = 0x7001_0004; // open socket
@ -867,7 +867,8 @@ impl<'a> Control<'a> {
assert_eq!(status, 0);
assert_eq!(msg.param_len, 16);
let fd = u32::from_le_bytes(msg.param[12..16].try_into().unwrap());
debug!("got FD: {}", fd);
trace!("got FD: {}", fd);
fd
}
}

93
examples/nrf9160/src/bin/modem_tcp_client.rs
View File

@ -49,6 +49,43 @@ async fn net_task(stack: &'static Stack<embassy_net_nrf91::NetDriver<'static>>)
stack.run().await
}
#[embassy_executor::task]
async fn control_task(
control: &'static context::Control<'static>,
config: context::Config<'static>,
stack: &'static Stack<embassy_net_nrf91::NetDriver<'static>>,
) {
unwrap!(
control
.run(&config, |status| {
let Some(IpAddr::V4(addr)) = status.ip else {
panic!("Unexpected IP address");
};
let addr = Ipv4Address(addr.octets());
let gateway = if let Some(IpAddr::V4(addr)) = status.gateway {
Some(Ipv4Address(addr.octets()))
} else {
None
};
let mut dns_servers = Vec::new();
for dns in status.dns.iter() {
if let IpAddr::V4(ip) = dns {
unwrap!(dns_servers.push(Ipv4Address(ip.octets())));
}
}
stack.set_config_v4(embassy_net::ConfigV4::Static(embassy_net::StaticConfigV4 {
address: Ipv4Cidr::new(addr, 32),
gateway,
dns_servers,
}));
})
.await
);
}
#[embassy_executor::task]
async fn blink_task(pin: AnyPin) {
let mut led = Output::new(pin, Level::Low, OutputDrive::Standard);
@ -117,50 +154,20 @@ async fn main(spawner: Spawner) {
unwrap!(spawner.spawn(net_task(stack)));
let control = context::Control::new(control, 0).await;
static CONTROL: StaticCell<context::Control<'static>> = StaticCell::new();
let control = CONTROL.init(context::Control::new(control, 0).await);
unwrap!(
control
.configure(context::Config {
apn: "iot.nat.es",
auth_prot: context::AuthProt::Pap,
auth: Some(("orange", "orange")),
})
.await
);
unwrap!(spawner.spawn(control_task(
control,
context::Config {
apn: "iot.nat.es",
auth_prot: context::AuthProt::Pap,
auth: Some(("orange", "orange")),
},
stack
)));
info!("waiting for attach...");
let mut status = unwrap!(control.status().await);
while !status.attached && status.ip.is_none() {
Timer::after_millis(1000).await;
status = unwrap!(control.status().await);
info!("STATUS: {:?}", status);
}
let Some(IpAddr::V4(addr)) = status.ip else {
panic!("Unexpected IP address");
};
let addr = Ipv4Address(addr.octets());
let gateway = if let Some(IpAddr::V4(addr)) = status.gateway {
Some(Ipv4Address(addr.octets()))
} else {
None
};
let mut dns_servers = Vec::new();
for dns in status.dns {
if let IpAddr::V4(ip) = dns {
unwrap!(dns_servers.push(Ipv4Address(ip.octets())));
}
}
stack.set_config_v4(embassy_net::ConfigV4::Static(embassy_net::StaticConfigV4 {
address: Ipv4Cidr::new(addr, 32),
gateway,
dns_servers,
}));
stack.wait_config_up().await;
let mut rx_buffer = [0; 4096];
let mut tx_buffer = [0; 4096];
@ -172,7 +179,7 @@ async fn main(spawner: Spawner) {
let host_addr = embassy_net::Ipv4Address::from_str("45.79.112.203").unwrap();
if let Err(e) = socket.connect((host_addr, 4242)).await {
warn!("connect error: {:?}", e);
Timer::after_secs(1).await;
Timer::after_secs(10).await;
continue;
}
info!("Connected to {:?}", socket.remote_endpoint());