ank/door
1
Fork 0
Code Issues Activity

added alloc

Browse source
This commit is contained in:
Andy Killorin 2024-12-03 22:23:23 -05:00
parent 0a8012b6f7
commit b4e09c573f
Signed by: ank
GPG key ID: 23F9463ECB67FE8C
2 changed files with 70 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
outside/Cargo.toml
View file

@ -25,7 +25,7 @@ fixed-macro = "1.2"
# for web request example
reqwless = { version = "0.12.0", features = ["defmt",]}
serde = { version = "1.0.203", default-features = false, features = ["derive"] }
serde = { version = "1.0.203", default-features = false, features = ["derive", "alloc"] }
serde-json-core = "0.5.1"
# for assign resources example
@ -60,6 +60,7 @@ embedded-sdmmc = "0.7.0"
bt-hci = { version = "0.1.0", default-features = false, features = ["defmt"] }
hex = { version = "0.4.3", default-features=false}
embedded-alloc = "0.6.0"
[profile.release]
debug = 2

100
outside/src/main.rs
View file

@ -5,48 +5,44 @@
#![no_main]
#![allow(async_fn_in_trait)]
use core::array;
use core::borrow::BorrowMut;
use core::cell::RefCell;
use core::fmt::Formatter;
use core::marker::PhantomData;
use core::panic::PanicInfo;
use core::str::from_utf8;
use core::sync::atomic::{AtomicU8};
use core::sync::atomic::AtomicU8;
use bt_hci::cmd::info;
use alloc::string::String;
use critical_section::Mutex;
use cyw43::JoinOptions;
use cyw43_pio::PioSpi;
use embassy_futures::join::join;
use embassy_futures::yield_now;
use embassy_rp::interrupt::typelevel::{Handler, Interrupt, IO_IRQ_BANK0};
use defmt::println;
use embassy_rp::multicore::{spawn_core1, Stack};
use embassy_rp::pwm::{self, Pwm};
use embassy_rp::uart::{BufferedInterruptHandler, BufferedUart};
use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
use embassy_sync::channel::Channel;
use fixed::FixedU16;
use embassy_sync::channel::{Channel, Receiver};
use log::*;
//use embassy_rp::i2c::InterruptHandler;
use embassy_executor::{InterruptExecutor, Spawner};
use embassy_net::tcp::TcpSocket;
use embassy_net::{Config, IpEndpoint, Ipv4Address, StackResources};
use embassy_rp::{bind_interrupts, interrupt};
use embassy_rp::{bind_interrupts, interrupt, uart};
use embassy_rp::clocks::RoscRng;
use embassy_rp::gpio::{AnyPin, Input, InterruptTrigger, Level, Output};
use embassy_rp::peripherals::{DMA_CH0, PIN_21, PIO0, USB};
use embassy_rp::peripherals::{DMA_CH0, PIN_21, PIO0, UART1, USB};
use embassy_rp::pio::{InterruptHandler, Pio};
use embassy_rp::usb::Driver;
use embassy_time::{Duration, Timer};
use embedded_io_async::Write;
use embedded_io_async::{Read, ReadReady, Write};
use rand::RngCore;
use reqwless::response;
use static_cell::StaticCell;
use defmt_rtt as _;
use embedded_alloc::LlffHeap as Heap;
extern crate alloc;
#[global_allocator]
static HEAP: Heap = Heap::empty();
bind_interrupts!(struct Irqs {
PIO0_IRQ_0 => InterruptHandler<PIO0>;
USBCTRL_IRQ => embassy_rp::usb::InterruptHandler<USB>;
UART1_IRQ => BufferedInterruptHandler<UART1>;
});
@ -71,8 +67,6 @@ async fn net_task(mut runner: embassy_net::Runner<'static, cyw43::NetDriver<'sta
runner.run().await
}
#[embassy_executor::task]
async fn data_extractor() -> ! {
let mut last_bit = 0;
@ -104,7 +98,7 @@ fn panic( info: &PanicInfo) -> ! {
#[embassy_executor::main]
async fn main(spawner: Spawner) {
let p = embassy_rp::init(Default::default());
let data_0= Input::new(p.PIN_21, embassy_rp::gpio::Pull::None);
let data_0= Input::new(p.PIN_18, embassy_rp::gpio::Pull::None);
let data_1= Input::new(p.PIN_16, embassy_rp::gpio::Pull::None);
let mut rng = RoscRng;
@ -112,6 +106,13 @@ async fn main(spawner: Spawner) {
let driver = Driver::new(p.USB, Irqs);
spawner.spawn(logger_task(driver)).unwrap();
let mut config = uart::Config::default();
config.baudrate = 115200;
let mut rx = [0; 2048];
let mut tx = [0; 2048];
let mut uart = BufferedUart::new(p.UART1, Irqs, p.PIN_20, p.PIN_21, &mut tx, &mut rx, config);
uart.read_ready().unwrap();
let fw = include_bytes!("../../cyw43-firmware/43439A0.bin");
let clm = include_bytes!("../../cyw43-firmware/43439A0_clm.bin");
@ -135,12 +136,12 @@ async fn main(spawner: Spawner) {
control.init(clm).await;
control
.set_power_management(cyw43::PowerManagementMode::PowerSave)
.set_power_management(cyw43::PowerManagementMode::None)
.await;
// Use a link-local address for communication without DHCP server
let config = Config::ipv4_static(embassy_net::StaticConfigV4 {
address: embassy_net::Ipv4Cidr::new(embassy_net::Ipv4Address::new(169, 254, 2, 1), 16),
address: embassy_net::Ipv4Cidr::new(embassy_net::Ipv4Address::new(169, 254, 8, 1), 16),
dns_servers: heapless::Vec::new(),
gateway: None,
});
@ -149,18 +150,16 @@ async fn main(spawner: Spawner) {
let seed = rng.next_u64();
// Init network stack
static RESOURCES: StaticCell<StackResources<3>> = StaticCell::new();
static RESOURCES: StaticCell<StackResources<5>> = StaticCell::new();
let (stack, runner) = embassy_net::new(net_device, config, RESOURCES.init(StackResources::new()), seed);
defmt::unwrap!(spawner.spawn(net_task(runner)));
control.start_ap_wpa2(include_str!("../../ssid"), include_str!("../../password"), 5).await;
let mut rx_buffer = [0; 4096];
let mut tx_buffer = [0; 4096];
let mut buf = [0; 4096];
let mut uart_buf = [0; 4096];
spawner.spawn(data_extractor()).unwrap();
//spawner.spawn(data_extractor()).unwrap();
let mut partial: u64 = 0;
let mut bit: u8 = 0;
@ -196,21 +195,59 @@ async fn main(spawner: Spawner) {
}
});
//defmt::unwrap!(spawner.spawn(send_badge(CHANNEL.receiver(),stack)));
let mut rx_buffer = [0; 4096];
let mut tx_buffer = [0; 4096];
let mut to_send_buffer = [0; 512];
let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
socket.set_timeout(Some(Duration::from_secs(10)));
control.gpio_set(0, false).await;
info!("recv on 2223");
while let Err(_) = socket.accept(1234).await {
error!("socket failure");
}
info!("connected");
control.gpio_set(0, true).await;
info!("connected");
//info!("Received connection from {:?}", socket.remote_endpoint());
info!("connected");
loop {
let card = CHANNEL.receive().await;
if socket.read_ready().unwrap() {
info!("attempting read");
let n = socket.read(&mut to_send_buffer).await.unwrap();
info!("recv: {}", String::from_utf8_lossy(&to_send_buffer[..n]));
uart.write_all(&to_send_buffer[..n]).await.unwrap();
}
if uart.read_ready().unwrap() {
let n = uart.read(&mut uart_buf).await.unwrap();
info!("read: {}", String::from_utf8_lossy(&uart_buf[..n]));
socket.write_all(&uart_buf[..n]).await.unwrap();
}
}
}
#[embassy_executor::task]
async fn send_badge(channel: Receiver<'static,CriticalSectionRawMutex,u64,1>,stack: embassy_net::Stack<'static>) -> ! {
let mut rx_buffer = [0; 512];
let mut tx_buffer = [0; 512];
loop {
let card = channel.receive().await;
let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
socket.set_timeout(Some(Duration::from_secs(10)));
info!("attempting conn to inside");
control.gpio_set(0, false).await;
if let Err(e) = socket.connect(IpEndpoint::new(Ipv4Address::new(169, 254, 1, 1).into_address(), 1234)).await {
warn!("connect error: {:?}", e);
continue;
}
info!("Connected to {:?}", socket.remote_endpoint());
control.gpio_set(0, true).await;
let mut data: [u8;18] = [b' ';18];
data[0] = b'B';
@ -221,6 +258,5 @@ async fn main(spawner: Spawner) {
info!("wrote to {:?}", socket.remote_endpoint());
socket.close();
control.gpio_set(0, false).await;
}
}