142 lines
3.5 KiB
Rust
142 lines
3.5 KiB
Rust
#![no_std]
|
|
#![no_main]
|
|
#![feature(type_alias_impl_trait)]
|
|
|
|
mod modem;
|
|
|
|
use esp_backtrace as _;
|
|
use esp_println::println;
|
|
use hal::{
|
|
clock::ClockControl,
|
|
Delay,
|
|
embassy::{self, executor::Executor},
|
|
gpio::IO,
|
|
peripherals::{Peripherals, UART1},
|
|
prelude::*,
|
|
prelude::entry,
|
|
timer::TimerGroup,
|
|
Uart,
|
|
uart::{
|
|
config::{
|
|
Config,
|
|
DataBits,
|
|
Parity,
|
|
StopBits,
|
|
},
|
|
TxRxPins,
|
|
},
|
|
};
|
|
use esp_hal_common::{UartRx, UartTx};
|
|
|
|
use atat::{
|
|
asynch::{
|
|
AtatClient,
|
|
Client,
|
|
},
|
|
AtatIngress,
|
|
Buffers,
|
|
DefaultDigester,
|
|
Ingress,
|
|
};
|
|
use static_cell::StaticCell;
|
|
|
|
const READ_BUF_SIZE: usize = 64;
|
|
const INGRESS_BUF_SIZE: usize = 1024;
|
|
const URC_CAPACITY: usize = 128;
|
|
const URC_SUBSCRIBERS: usize = 3;
|
|
|
|
#[embassy_executor::task]
|
|
async fn ingress_task(
|
|
mut ingress: Ingress<
|
|
'static,
|
|
DefaultDigester<modem::Urc>,
|
|
modem::Urc,
|
|
INGRESS_BUF_SIZE,
|
|
URC_CAPACITY,
|
|
URC_SUBSCRIBERS,
|
|
>,
|
|
mut rx: UartRx<'static, UART1>) {
|
|
println!("reading in ingress_task...");
|
|
ingress.read_from(&mut rx).await;
|
|
}
|
|
|
|
#[embassy_executor::task]
|
|
async fn test_send(mut client: Client<'static, UartTx<'static, UART1>, INGRESS_BUF_SIZE>) {
|
|
println!("sending a single message (GetManufacturerId)");
|
|
client.send(&modem::GetManufacturerId).await.ok();
|
|
}
|
|
|
|
#[entry]
|
|
fn main() -> ! {
|
|
let peripherals = Peripherals::take();
|
|
let mut system = peripherals.DPORT.split();
|
|
let clocks = ClockControl::boot_defaults(system.clock_control).freeze();
|
|
let mut delay = Delay::new(&clocks);
|
|
|
|
let timer_group0 = TimerGroup::new(
|
|
peripherals.TIMG0,
|
|
&clocks,
|
|
&mut system.peripheral_clock_control,
|
|
);
|
|
|
|
embassy::init(&clocks, timer_group0.timer0);
|
|
|
|
let io = IO::new(peripherals.GPIO, peripherals.IO_MUX);
|
|
|
|
// Power on the LilyGo A7670E module.
|
|
let mut power = io.pins.gpio4.into_push_pull_output();
|
|
power.set_high().ok();
|
|
|
|
for i in 0..15 {
|
|
println!("waiting {} seconds ...", 15 - i);
|
|
delay.delay_ms(1000u32);
|
|
}
|
|
|
|
let modem_uart_pins = TxRxPins::new_tx_rx(
|
|
io.pins.gpio26.into_push_pull_output(),
|
|
io.pins.gpio27.into_floating_input(),
|
|
);
|
|
|
|
let config = Config {
|
|
baudrate: 115200,
|
|
data_bits: DataBits::DataBits8,
|
|
parity: Parity::ParityNone,
|
|
stop_bits: StopBits::STOP1,
|
|
};
|
|
|
|
// UART interface for the GSM modem
|
|
let mut uart = Uart::new_with_config(
|
|
peripherals.UART1,
|
|
config,
|
|
Some(modem_uart_pins),
|
|
&clocks,
|
|
&mut system.peripheral_clock_control,
|
|
);
|
|
uart.set_rx_fifo_full_threshold(READ_BUF_SIZE as u16).unwrap();
|
|
|
|
let (tx, rx) = uart.split();
|
|
|
|
static BUFFERS: Buffers<modem::Urc, INGRESS_BUF_SIZE, URC_CAPACITY, URC_SUBSCRIBERS> =
|
|
Buffers::<modem::Urc, INGRESS_BUF_SIZE, URC_CAPACITY, URC_SUBSCRIBERS>::new();
|
|
|
|
let digester = DefaultDigester::<modem::Urc>::default()
|
|
.with_custom_success(|buf| {
|
|
println!("digested:\n{:?}", buf);
|
|
Ok((buf, buf.len()))
|
|
});
|
|
|
|
let (ingress, client) = BUFFERS.split(
|
|
tx,
|
|
digester,
|
|
atat::Config::default()
|
|
);
|
|
|
|
println!("Starting embassy executor ...");
|
|
|
|
static CELL: StaticCell<Executor> = StaticCell::new();
|
|
let executor = CELL.init(Executor::new());
|
|
executor.run(|spawner| {
|
|
let _ = spawner.spawn(ingress_task(ingress, rx));
|
|
let _ = spawner.spawn(test_send(client));
|
|
});
|
|
}
|