diff --git a/examples/.cargo/config.toml b/examples/.cargo/config.toml index 28c6f091b..0674fc95c 100644 --- a/examples/.cargo/config.toml +++ b/examples/.cargo/config.toml @@ -1,5 +1,5 @@ [alias] -esp32 = "run --release --features=esp32 --target=xtensa-esp32-none-elf" +esp32 = "run --release --features=esp32 --target=xtensa-esp32-none-elf" esp32c2 = "run --release --features=esp32c2 --target=riscv32imc-unknown-none-elf" esp32c3 = "run --release --features=esp32c3 --target=riscv32imc-unknown-none-elf" esp32c6 = "run --release --features=esp32c6 --target=riscv32imac-unknown-none-elf" @@ -8,18 +8,17 @@ esp32s2 = "run --release --features=esp32s2 --target=xtensa-esp32s2-none-elf" esp32s3 = "run --release --features=esp32s3 --target=xtensa-esp32s3-none-elf" [target.'cfg(target_arch = "riscv32")'] -runner = "espflash flash --monitor" -rustflags = [ - "-C", "link-arg=-Tlinkall.x", - "-C", "force-frame-pointers", -] +runner = "espflash flash --monitor" +rustflags = ["-C", "link-arg=-Tlinkall.x", "-C", "force-frame-pointers"] [target.'cfg(target_arch = "xtensa")'] -runner = "espflash flash --monitor" +runner = "espflash flash --monitor" rustflags = [ # GNU LD - "-C", "link-arg=-Wl,-Tlinkall.x", - "-C", "link-arg=-nostartfiles", + "-C", + "link-arg=-Wl,-Tlinkall.x", + "-C", + "link-arg=-nostartfiles", # LLD # "-C", "link-arg=-Tlinkall.x", @@ -28,8 +27,9 @@ rustflags = [ [env] ESP_LOG = "info" -SSID = "SSID" -PASSWORD = "PASSWORD" +SSID = "925511496560803" +PASSWORD = ")~Y!zEycpx=gPeE0D%\\y {{ + static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new(); + #[deny(unused_attributes)] + let x = STATIC_CELL.uninit().write(($val)); + x + }}; +} + +#[esp_hal_embassy::main] +async fn main(spawner: Spawner) -> ! { + esp_println::logger::init_logger_from_env(); + println!("Init!"); + + let peripherals = esp_hal::init(esp_hal::Config::default()); + + // let sclk = peripherals.GPIO0; + // let miso = peripherals.GPIO2; + // let mosi = peripherals.GPIO4; + // let cs = peripherals.GPIO5; + + let sclk = Output::new(peripherals.GPIO0, Level::Low); + let miso = Output::new(peripherals.GPIO2, Level::Low); + let mosi = Output::new(peripherals.GPIO4, Level::Low); // only mosi is used for ws28* + let cs = Output::new(peripherals.GPIO5, Level::Low); + + let sw_ints = SoftwareInterruptControl::new(peripherals.SW_INTERRUPT); + + esp_alloc::heap_allocator!(72 * 1024); + + let timg0 = TimerGroup::new(peripherals.TIMG0); + + let mut rng = Rng::new(peripherals.RNG); + + let init = &*mk_static!( + EspWifiController<'static>, + init(timg0.timer0, rng.clone(), peripherals.RADIO_CLK).unwrap() + ); + + static EXECUTOR: StaticCell> = StaticCell::new(); + let executor = InterruptExecutor::new(sw_ints.software_interrupt2); + let executor = EXECUTOR.init(executor); + + // let spawner = executor.start(Priority::Priority3); + // spawner.must_spawn(led_ctrl_core_task(sclk, miso, mosi, cs, peripherals.SPI2)); + + /////////////////////////// WIFI //////////////////////////////// + + let wifi = peripherals.WIFI; + let (wifi_interface, controller) = + esp_wifi::wifi::new_with_mode(&init, wifi, WifiStaDevice).unwrap(); + + cfg_if::cfg_if! { + if #[cfg(feature = "esp32")] { + let timg1 = TimerGroup::new(peripherals.TIMG1); + esp_hal_embassy::init(timg1.timer0); + } else { + use esp_hal::timer::systimer::SystemTimer; + let systimer = SystemTimer::new(peripherals.SYSTIMER); + esp_hal_embassy::init(systimer.alarm0); + } + } + + let config = embassy_net::Config::dhcpv4(Default::default()); + + let seed = (rng.random() as u64) << 32 | rng.random() as u64; + + // Init network stack + let (stack, runner) = embassy_net::new( + wifi_interface, + config, + mk_static!(StackResources<3>, StackResources::<3>::new()), + seed, + ); + + spawner.spawn(connection(controller)).ok(); + spawner.spawn(net_task(runner)).ok(); + spawner.spawn(led_ctrl_core_task(sclk, miso, mosi, cs, peripherals.SPI2)).ok(); + + let mut rx_buffer = [0; 4096]; + let mut tx_buffer = [0; 4096]; + + loop { + if stack.is_link_up() { + break; + } + Timer::after(Duration::from_millis(500)).await; + } + + println!("Waiting to get IP address..."); + loop { + if let Some(config) = stack.config_v4() { + println!("Got IP: {}", config.address); + break; + } + Timer::after(Duration::from_millis(500)).await; + } + + loop { + Timer::after(Duration::from_millis(1_000)).await; + + let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer); + + socket.set_timeout(Some(embassy_time::Duration::from_secs(10))); + + let remote_endpoint = (Ipv4Addr::new(142, 250, 185, 115), 80); + println!("connecting..."); + let r = socket.connect(remote_endpoint).await; + if let Err(e) = r { + println!("connect error: {:?}", e); + continue; + } + println!("connected!"); + let mut buf = [0; 1024]; + loop { + use embedded_io_async::Write; + let r = socket + .write_all(b"GET / HTTP/1.0\r\nHost: www.mobile-j.de\r\n\r\n") + .await; + if let Err(e) = r { + println!("write error: {:?}", e); + break; + } + let n = match socket.read(&mut buf).await { + Ok(0) => { + println!("read EOF"); + break; + } + Ok(n) => n, + Err(e) => { + println!("read error: {:?}", e); + break; + } + }; + println!("{}", core::str::from_utf8(&buf[..n]).unwrap()); + } + Timer::after(Duration::from_millis(3000)).await; + } + +} + +// highest priority task +#[embassy_executor::task] +async fn led_ctrl_core_task(sclk: Output<'static>, miso: Output<'static>, mosi: Output<'static>, cs: Output<'static>, spi2: esp_hal::peripherals::SPI2) { + esp_println::println!("Hello world from embassy using esp-hal-async!"); + + // Spi configuration for the neopixel + // let mut spi_config = Config::default(); + // spi_config.frequency = 3_800_000; + + //let peripherals = esp_hal::init(esp_hal::Config::default()); + + let mut spi = Spi::new( + spi2, + Config::default() + .with_frequency(3_800.kHz()) + .with_mode(Mode::_0), + ) + .unwrap() + .with_sck(sclk) + .with_miso(miso) // order matters + .with_mosi(mosi) // order matters + .with_cs(cs) + .into_async(); + + let mut np: Ws2812<_, { 12 * NUM_LEDS }> = Ws2812::new(spi); + np.set_color_order(ColorOrder::GRB); + + let mut data = [RGB8::default(); NUM_LEDS]; + + loop { + println!("Writing led!"); + for led in data.iter_mut().step_by(1) { + led.r = 0; // blue + led.g = 0; // red + led.b = 20; // green + } + + np.write(data.iter().cloned()).await.ok(); + + Timer::after(embassy_time::Duration::from_millis(5)).await; + + for led in data.iter_mut().step_by(1) { + led.r = 20; // blue + led.g = 0; // red + led.b = 0; // green + } + + np.write(data.iter().cloned()).await.ok(); + + Timer::after(embassy_time::Duration::from_millis(5)).await; + + for led in data.iter_mut().step_by(1) { + led.r = 0; // blue + led.g = 20; // red + led.b = 0; // green + } + + np.write(data.iter().cloned()).await.ok(); + + Timer::after(embassy_time::Duration::from_millis(5)).await; + + } +} + +#[embassy_executor::task] +async fn connection(mut controller: WifiController<'static>) { + println!("start connection task"); + println!("Device capabilities: {:?}", controller.capabilities()); + loop { + match esp_wifi::wifi::wifi_state() { + WifiState::StaConnected => { + // wait until we're no longer connected + controller.wait_for_event(WifiEvent::StaDisconnected).await; + Timer::after(Duration::from_millis(5000)).await + } + _ => {} + } + if !matches!(controller.is_started(), Ok(true)) { + let client_config = Configuration::Client(ClientConfiguration { + ssid: SSID.try_into().unwrap(), + password: PASSWORD.try_into().unwrap(), + ..Default::default() + }); + controller.set_configuration(&client_config).unwrap(); + println!("Starting wifi"); + controller.start_async().await.unwrap(); + println!("Wifi started!"); + } + println!("About to connect..."); + + match controller.connect_async().await { + Ok(_) => println!("Wifi connected!"), + Err(e) => { + println!("Failed to connect to wifi: {e:?}"); + Timer::after(Duration::from_millis(5000)).await + } + } + } +} + +#[embassy_executor::task] +async fn net_task(mut runner: Runner<'static, WifiDevice<'static, WifiStaDevice>>) { + runner.run().await +} + +#[derive(Debug, Decode, Clone, Copy, PartialEq)] +struct Led { + r: u8, + g: u8, + b: u8, +} + +#[derive(Clone, Debug, Decode, PartialEq)] +pub struct LedStrip { + leds: [Led; NUM_LEDS], +} + +impl LedStrip { + // naive inital start with uniform colour on entire strip + pub fn new(_r: u8) -> Self { + let arr: [Led; NUM_LEDS] = [Led { r: 0, g: 0, b: 0 }; NUM_LEDS]; + + LedStrip { leds: arr } + } + pub fn to_array(&self) { + for i in 0..NUM_LEDS { + unsafe { RGBARRAY[i] = RGB8::new(self.leds[i].g, self.leds[i].r, self.leds[i].b) } + } + } +} + +#[derive(Clone, Debug, Decode, PartialEq)] +pub struct LedContainer { + message_count: u32, + ledstrip: LedStrip, +} diff --git a/examples/src/bin/wifi_ble.rs b/examples/src/bin/wifi_ble.rs index 6be700c36..0fee0fb13 100644 --- a/examples/src/bin/wifi_ble.rs +++ b/examples/src/bin/wifi_ble.rs @@ -12,15 +12,10 @@ use bleps::{ ad_structure::{ - create_advertising_data, - AdStructure, - BR_EDR_NOT_SUPPORTED, - LE_GENERAL_DISCOVERABLE, + create_advertising_data, AdStructure, BR_EDR_NOT_SUPPORTED, LE_GENERAL_DISCOVERABLE, }, attribute_server::{AttributeServer, NotificationData, WorkResult}, - gatt, - Ble, - HciConnector, + gatt, Ble, HciConnector, }; use esp_alloc as _; use esp_backtrace as _; diff --git a/examples/src/bin/wifi_dhcp.rs b/examples/src/bin/wifi_dhcp.rs index 32df2787a..0ad05d877 100644 --- a/examples/src/bin/wifi_dhcp.rs +++ b/examples/src/bin/wifi_dhcp.rs @@ -30,12 +30,8 @@ use esp_println::{print, println}; use esp_wifi::{ init, wifi::{ - utils::create_network_interface, - AccessPointInfo, - ClientConfiguration, - Configuration, - WifiError, - WifiStaDevice, + utils::create_network_interface, AccessPointInfo, ClientConfiguration, Configuration, + WifiError, WifiStaDevice, }, }; use smoltcp::{ diff --git a/qa-test/.cargo/config.toml b/qa-test/.cargo/config.toml index 8604b2d39..b66e65181 100644 --- a/qa-test/.cargo/config.toml +++ b/qa-test/.cargo/config.toml @@ -1,5 +1,5 @@ [alias] -esp32 = "run --release --features=esp32 --target=xtensa-esp32-none-elf" +esp32 = "run --release --features=esp32 --target=xtensa-esp32-none-elf" esp32c2 = "run --release --features=esp32c2 --target=riscv32imc-unknown-none-elf" esp32c3 = "run --release --features=esp32c3 --target=riscv32imc-unknown-none-elf" esp32c6 = "run --release --features=esp32c6 --target=riscv32imac-unknown-none-elf" @@ -8,18 +8,17 @@ esp32s2 = "run --release --features=esp32s2 --target=xtensa-esp32s2-none-elf" esp32s3 = "run --release --features=esp32s3 --target=xtensa-esp32s3-none-elf" [target.'cfg(target_arch = "riscv32")'] -runner = "espflash flash --monitor" -rustflags = [ - "-C", "link-arg=-Tlinkall.x", - "-C", "force-frame-pointers", -] +runner = "espflash flash --monitor" +rustflags = ["-C", "link-arg=-Tlinkall.x", "-C", "force-frame-pointers"] [target.'cfg(target_arch = "xtensa")'] -runner = "espflash flash --monitor" +runner = "espflash flash --monitor" rustflags = [ # GNU LD - "-C", "link-arg=-Wl,-Tlinkall.x", - "-C", "link-arg=-nostartfiles", + "-C", + "link-arg=-Wl,-Tlinkall.x", + "-C", + "link-arg=-nostartfiles", # LLD # "-C", "link-arg=-Tlinkall.x",