1 files changed, 90 insertions, 6 deletions

diff --git a/src/main.rs b/src/main.rs
index 86f4975..2b839d7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,15 +1,21 @@
 #![no_std]
 #![no_main]
 #![feature(impl_trait_in_assoc_type)]
+#![feature(try_blocks)]
 
 extern crate alloc;
 
+use core::net::{
+    IpAddr,
+    Ipv4Addr,
+};
+use embassy_net::tcp::client::TcpClientState;
 use molybdos::{
     embassy_embedded_hal::shared_bus::asynch::{
         i2c::I2cDevice,
         spi::SpiDevice,
     },
-    embassy_executor,
+    embassy_net::StackResources,
     embassy_rp,
     embassy_rp::{
         i2c::{
@@ -37,24 +43,39 @@ use molybdos::{
         pubsub,
         pubsub::PubSubBehavior,
     },
+    embassy_time,
+    embassy_usb,
+    embassy_usb::class::{
+        cdc_ncm,
+        cdc_ncm::embassy_net::Device,
+    },
     embedded_hal_async,
     embedded_hal_async::spi::{
         Operation,
         SpiDevice as _,
     },
+    embedded_io_async::Write,
     embedded_sdmmc_async::{
         VolumeIdx,
         VolumeManager,
     },
     genlog,
-    genlog::defmt,
+    genlog::{
+        defmt,
+        defmt::unwrap,
+    },
     heapless,
     pal::StaticOutput,
+    static_cell::{
+        ConstStaticCell,
+        StaticCell,
+    },
 };
 use ocularium_common::{
     Downlink,
     Sensor,
 };
+use reqwless::request::Method;
 
 use crate::usb::COBS_DOWNLINK;
 
@@ -71,7 +92,12 @@ pub type SensorI2c = I2c<'static, I2C1, i2c::Async>;
 pub static I2S_PIPE: Pipe<ThreadModeRawMutex, 1024> = Pipe::new();
 
 #[::embassy_executor::main]
+#[inline]
 async fn main(spawner: embassy_executor::Spawner) {
+    _main(spawner).await
+}
+
+async fn _main(spawner: embassy_executor::Spawner) {
     molybdos::pal::heap::init();
 
     defmt::info!("boot");
@@ -92,18 +118,58 @@ async fn main(spawner: embassy_executor::Spawner) {
 
     // spawner.must_spawn(molybdos::pal::watchdog(wdt));
 
-    let (acm,) = molybdos::lib::usb::bringup!(
+    const MTU: usize = 1514;
+    const MAC: [u8; 6] = [0, 0, 0, 0, 0, 0];
+
+    let (acm, ncm) = molybdos::lib::usb::bringup!(
         spawn,
         usb,
         molybdos::pal::UsbDriver,
         molybdos::lib::usb::config("npry", "ocularium", 0x8888, 0x0011),
         endpoints = {
             acm => |builder| molybdos::lib::usb::acm!(builder),
+            ncm => |builder| {
+                static STATE: StaticCell<cdc_ncm::State> = StaticCell::new();
+                let state =
+                    StaticCell::init(&STATE, cdc_ncm::State::new());
+                cdc_ncm::CdcNcmClass::new(builder, state, MAC, 64)
+            },
         }
     );
 
+    #[embassy_executor::task]
+    async fn ncm_task(
+        runner: cdc_ncm::embassy_net::Runner<
+            'static,
+            embassy_rp::usb::Driver<'static, embassy_rp::peripherals::USB>,
+            MTU,
+        >,
+    ) -> ! {
+        runner.run().await
+    }
+
     molybdos::lib::usb::start!(molybdos::pal::UsbDriver, acm, &usb::UPLINK, &usb::DOWNLINK);
 
+    static NET_STATE: ConstStaticCell<cdc_ncm::embassy_net::State<MTU, 4, 4>> =
+        ConstStaticCell::new(cdc_ncm::embassy_net::State::new());
+    let (runner, dev) = ncm.into_embassy_net_device::<MTU, 4, 4>(NET_STATE.take(), MAC);
+
+    spawner.must_spawn(ncm_task(runner));
+
+    let config = molybdos::embassy_net::Config::dhcpv4(Default::default());
+    static RESOURCES: StaticCell<StackResources<3>> = StaticCell::new();
+    let (stack, runner) =
+        molybdos::embassy_net::new(dev, config, RESOURCES.init(StackResources::new()), 0);
+
+    #[embassy_executor::task]
+    async fn net_task(
+        mut runner: molybdos::embassy_net::Runner<'static, Device<'static, MTU>>,
+    ) -> ! {
+        runner.run().await
+    }
+
+    spawner.must_spawn(net_task(runner));
+
     molybdos::lib::util::cobs::start!(
         ocularium_common::Uplink,
         &usb::UPLINK,
@@ -161,11 +227,29 @@ async fn main(spawner: embassy_executor::Spawner) {
         spawner.must_spawn(run_i2s(i2s, i2s_dma));
     }
 
+    let target_addr = core::net::SocketAddrV4::new(Ipv4Addr::from([1, 1, 1, 1]), 80);
+
+    let state = TcpClientState::new();
+    let client = embassy_net::tcp::client::TcpClient::<1>::new(stack, &state);
+
+    let dns = embassy_net::dns::DnsSocket::new(stack);
+
+    let mut client = reqwless::client::HttpClient::new(&client, &dns);
+
+    let mut headers_buf = [0; 512];
+
     loop {
-        molybdos::embassy_time::Timer::after(molybdos::embassy_time::Duration::from_secs(1)).await;
+        let _result: Result<(), reqwless::Error> = try {
+            let mut req = client.request(Method::GET, "http://httpbin.org/anything").await?;
+            let resp = req.send(&mut headers_buf).await?;
+
+            let body = resp.body().read_to_end().await?;
+            let body_str = core::str::from_utf8(&body).unwrap();
+
+            defmt::info!("got response: {}", body_str);
+        };
 
-        let meas = bme.measure_default().await.unwrap().unwrap();
-        defmt::info!("got bme measurement: {}", defmt::Debug2Format(&meas));
+        embassy_time::Timer::after(embassy_time::Duration::from_secs(1)).await;
     }
 }