Unify examples (esp-rs#296)

This PR merges the chip specific examples into one folder, inside the
esp-wifi project.

To simplify building, alias' have been added to
`esp-wifi/.cargo/config.toml` per chip to automatically select the right
target and enable the chip feature.

Add build script detection for invalid features

Fix CI, use build instead of check to detect linker errors

enable async feature of hal, this breaks because of interrupt definition for systimer

upgrade hal rev

upgrade hal rev c6

undo binding modifications

fix esp now

fix esp coex

use released hals, update async examples

sync example names

sync example names

Update examples.md

Document alias

update build alias

Author: MabezDev

esp-wifi/.cargo/config.toml

@@ -1,12 +1,33 @@
+# Alias' for quickly building for different chips or running examples
+# By default we enable 
+#   - `embassy-time-timg0` as the examples assume we are using this time driver
+#   - `embassy-executor-thread` on Xtensa chips to take advantage of the Xtensa specific executor we have in esp-hal
+[alias]
+esp32 =   "run --features   esp32 --target xtensa-esp32-none-elf        --features esp32-hal/embassy-time-timg0,esp32-hal/embassy-executor-thread"
+esp32s2 = "run --features esp32s2 --target xtensa-esp32s2-none-elf      --features esp32s2-hal/embassy-time-timg0,esp32s2-hal/embassy-executor-thread"
+esp32s3 = "run --features esp32s3 --target xtensa-esp32s3-none-elf      --features esp32s3-hal/embassy-time-timg0,esp32s3-hal/embassy-executor-thread"
+esp32c2 = "run --features esp32c2 --target riscv32imc-unknown-none-elf  --features esp32c2-hal/embassy-time-timg0"
+esp32c3 = "run --features esp32c3 --target riscv32imc-unknown-none-elf  --features esp32c3-hal/embassy-time-timg0"
+esp32c6 = "run --features esp32c6 --target riscv32imac-unknown-none-elf --features esp32c6-hal/embassy-time-timg0"
+
+besp32 =   "build --features   esp32 --target xtensa-esp32-none-elf        --features esp32-hal/embassy-time-timg0,esp32-hal/embassy-executor-thread"
+besp32s2 = "build --features esp32s2 --target xtensa-esp32s2-none-elf      --features esp32s2-hal/embassy-time-timg0,esp32s2-hal/embassy-executor-thread"
+besp32s3 = "build --features esp32s3 --target xtensa-esp32s3-none-elf      --features esp32s3-hal/embassy-time-timg0,esp32s3-hal/embassy-executor-thread"
+besp32c2 = "build --features esp32c2 --target riscv32imc-unknown-none-elf  --features esp32c2-hal/embassy-time-timg0"
+besp32c3 = "build --features esp32c3 --target riscv32imc-unknown-none-elf  --features esp32c3-hal/embassy-time-timg0"
+besp32c6 = "build --features esp32c6 --target riscv32imac-unknown-none-elf --features esp32c6-hal/embassy-time-timg0"
+
 [target.riscv32imc-unknown-none-elf]
 runner = "espflash flash --monitor"
-
 rustflags = [
     "-C", "link-arg=-Tlinkall.x",
     "-C", "link-arg=-Trom_functions.x",
 
     "-C", "force-frame-pointers",
 
+    # Enable the atomic codegen option for RISCV
+    "-C", "target-feature=+a",
+
     # tell the core library have atomics even though it's not specified in the target definition
     "--cfg", "target_has_atomic_load_store",
     "--cfg", 'target_has_atomic_load_store="8"',
@@ -23,72 +44,49 @@ rustflags = [
 
 [target.riscv32imac-unknown-none-elf]
 runner = "espflash flash --monitor"
-
 rustflags = [
     "-C", "link-arg=-Tlinkall.x",
     "-C", "link-arg=-Trom_functions.x",
-
     "-C", "force-frame-pointers",
-
-    # tell the core library have atomics even though it's not specified in the target definition
-    "--cfg", "target_has_atomic_load_store",
-    "--cfg", 'target_has_atomic_load_store="8"',
-    "--cfg", 'target_has_atomic_load_store="16"',
-    "--cfg", 'target_has_atomic_load_store="32"',
-    "--cfg", 'target_has_atomic_load_store="ptr"',
-    # enable cas
-    "--cfg", "target_has_atomic",
-    "--cfg", 'target_has_atomic="8"',
-    "--cfg", 'target_has_atomic="16"',
-    "--cfg", 'target_has_atomic="32"',
-    "--cfg", 'target_has_atomic="ptr"',
 ]
 
 [target.xtensa-esp32-none-elf]
 runner = "espflash flash --monitor"
-
 rustflags = [
-    #"-C", "linker=rust-lld",    
-
     "-C", "link-arg=-Tlinkall.x",
     "-C", "link-arg=-Trom_functions.x",
 ]
 
 [target.xtensa-esp32s3-none-elf]
 runner = "espflash flash --monitor"
-
 rustflags = [
-    #"-C", "linker=rust-lld",    
-
     "-C", "link-arg=-Tlinkall.x",
     "-C", "link-arg=-Trom_functions.x",
-
-    # for now disable loop optimization
-    "-C", "target-feature=-loop",
 ]
 
 [target.xtensa-esp32s2-none-elf]
 runner = "espflash flash --monitor"
-
 rustflags = [
-    #"-C", "linker=rust-lld",    
-    
     "-C", "link-arg=-Tlinkall.x",
     "-C", "link-arg=-Trom_functions.x",
 
     # Enable the atomic codegen option for Xtensa
     "-C", "target-feature=+s32c1i",
 
+    # tell the core library have atomics even though it's not specified in the target definition
+    "--cfg", "target_has_atomic_load_store",
+    "--cfg", 'target_has_atomic_load_store="8"',
+    "--cfg", 'target_has_atomic_load_store="16"',
+    "--cfg", 'target_has_atomic_load_store="32"',
+    "--cfg", 'target_has_atomic_load_store="ptr"',
     # Tell the `core` library that we have atomics, even though it's not
     # specified in the target definition
+    "--cfg", 'target_has_atomic',
     "--cfg", 'target_has_atomic="8"',
     "--cfg", 'target_has_atomic="16"',
     "--cfg", 'target_has_atomic="32"',
     "--cfg", 'target_has_atomic="ptr"',
 ]
 
-[build]
-target = "riscv32imc-unknown-none-elf"
- 
 [unstable]
 build-std = [ "core" ]

esp-wifi/Cargo.toml

@@ -36,16 +36,33 @@ atomic_enum = { workspace = true }
 [build-dependencies]
 toml-cfg.workspace = true
 
+[dev-dependencies]
+esp-println = { workspace = true, features = ["log"] }
+esp-backtrace = { workspace = true }
+embedded-svc.workspace = true
+embassy-executor = { workspace = true }
+embassy-time.workspace = true
+embassy-futures.workspace = true
+futures-util.workspace = true
+embassy-net = { workspace = true }
+embassy-sync.workspace = true
+bleps.workspace = true
+embedded-io.workspace = true
+embedded-hal-async = { workspace = true }
+log = { workspace = true }
+smoltcp.workspace = true
+static_cell = { workspace = true }
+
 [features]
 default = [ "utils", "log" ]
 
 # chip features
-esp32c2 = [ "esp32c2-hal", "esp-wifi-sys/esp32c2" ]
-esp32c3 = [ "esp32c3-hal", "esp-wifi-sys/esp32c3" ]
-esp32c6 = [ "esp32c6-hal", "esp-wifi-sys/esp32c6" ]
-esp32 = [ "esp32-hal",  "esp-wifi-sys/esp32" ]
-esp32s2 = [ "esp32s2-hal", "esp-wifi-sys/esp32s2" ]
-esp32s3 = [ "esp32s3-hal", "esp-wifi-sys/esp32s3" ]
+esp32c2 = [ "esp32c2-hal", "esp-wifi-sys/esp32c2", "esp-println/esp32c2", "esp-backtrace/esp32c2", "embassy-executor/arch-riscv32" ]
+esp32c3 = [ "esp32c3-hal", "esp-wifi-sys/esp32c3", "esp-println/esp32c3", "esp-backtrace/esp32c3", "embassy-executor/arch-riscv32" ]
+esp32c6 = [ "esp32c6-hal", "esp-wifi-sys/esp32c6", "esp-println/esp32c6", "esp-backtrace/esp32c6", "embassy-executor/arch-riscv32" ]
+esp32 = [ "esp32-hal",  "esp-wifi-sys/esp32", "esp-println/esp32", "esp-backtrace/esp32" ]
+esp32s2 = [ "esp32s2-hal", "esp-wifi-sys/esp32s2", "esp-println/esp32s2", "esp-backtrace/esp32s2" ]
+esp32s3 = [ "esp32s3-hal", "esp-wifi-sys/esp32s3", "esp-println/esp32s3", "esp-backtrace/esp32s3" ]
 
 # async features
 async = [
@@ -58,6 +75,13 @@ async = [
   "esp32-hal?/embassy",
   "esp32s2-hal?/embassy",
   "esp32s3-hal?/embassy",
+  "esp32c3-hal?/async",
+  "esp32c2-hal?/async",
+  "esp32c6-hal?/async",
+  "esp32-hal?/async",
+  "esp32s2-hal?/async",
+  "esp32s3-hal?/async",
+  "bleps/async"
 ]
 
 embassy-net = ["dep:embassy-net-driver", "async"]

esp-wifi/build.rs

@@ -7,6 +7,31 @@
     feature = "esp32s3",
 ))]
 fn main() -> Result<(), String> {
+    #[cfg(all(feature = "ble", feature = "esp32s2"))]
+    {
+        panic!(
+            r#"
+
+        BLE is not supported on this target.
+
+        "#
+        );
+    }
+    #[cfg(all(
+        feature = "coex",
+        any(feature = "esp32s2", feature = "esp32c2", feature = "esp32c6")
+    ))]
+    {
+        panic!(
+            r#"
+
+        COEX is not yet supported on this target. 
+
+        See https://github.com/esp-rs/esp-wifi/issues/92.
+
+        "#
+        );
+    }
     match std::env::var("OPT_LEVEL") {
         Ok(level) => {
             if level != "2" && level != "3" {

esp-wifi/examples/access_point.rs

@@ -0,0 +1,163 @@
+#![no_std]
+#![no_main]
+#![feature(c_variadic)]
+#![feature(const_mut_refs)]
+
+#[path = "../../examples-util/util.rs"]
+mod examples_util;
+use examples_util::hal;
+
+use embedded_io::blocking::*;
+use embedded_svc::ipv4::Interface;
+use embedded_svc::wifi::{AccessPointConfiguration, Configuration, Wifi};
+
+use esp_backtrace as _;
+use esp_println::{print, println};
+use esp_wifi::initialize;
+use esp_wifi::wifi::utils::create_network_interface;
+use esp_wifi::wifi::WifiMode;
+use esp_wifi::wifi_interface::WifiStack;
+use esp_wifi::{current_millis, EspWifiInitFor};
+use hal::clock::ClockControl;
+use hal::Rng;
+use hal::{peripherals::Peripherals, prelude::*};
+
+use smoltcp::iface::SocketStorage;
+
+#[entry]
+fn main() -> ! {
+    #[cfg(feature = "log")]
+    esp_println::logger::init_logger(log::LevelFilter::Info);
+
+    let peripherals = Peripherals::take();
+
+    let system = peripherals.SYSTEM.split();
+    let clocks = ClockControl::max(system.clock_control).freeze();
+
+    #[cfg(target_arch = "xtensa")]
+    let timer = hal::timer::TimerGroup::new(peripherals.TIMG1, &clocks).timer0;
+    #[cfg(target_arch = "riscv32")]
+    let timer = hal::systimer::SystemTimer::new(peripherals.SYSTIMER).alarm0;
+    let init = initialize(
+        EspWifiInitFor::Wifi,
+        timer,
+        Rng::new(peripherals.RNG),
+        system.radio_clock_control,
+        &clocks,
+    )
+    .unwrap();
+
+    let wifi = peripherals.WIFI;
+    let mut socket_set_entries: [SocketStorage; 3] = Default::default();
+    let (iface, device, mut controller, sockets) =
+        create_network_interface(&init, wifi, WifiMode::Ap, &mut socket_set_entries).unwrap();
+    let mut wifi_stack = WifiStack::new(iface, device, sockets, current_millis);
+
+    let client_config = Configuration::AccessPoint(AccessPointConfiguration {
+        ssid: "esp-wifi".into(),
+        ..Default::default()
+    });
+    let res = controller.set_configuration(&client_config);
+    println!("wifi_set_configuration returned {:?}", res);
+
+    controller.start().unwrap();
+    println!("is wifi started: {:?}", controller.is_started());
+
+    println!("{:?}", controller.get_capabilities());
+
+    wifi_stack
+        .set_iface_configuration(&embedded_svc::ipv4::Configuration::Client(
+            embedded_svc::ipv4::ClientConfiguration::Fixed(embedded_svc::ipv4::ClientSettings {
+                ip: embedded_svc::ipv4::Ipv4Addr::from(parse_ip("192.168.2.1")),
+                subnet: embedded_svc::ipv4::Subnet {
+                    gateway: embedded_svc::ipv4::Ipv4Addr::from(parse_ip("192.168.2.1")),
+                    mask: embedded_svc::ipv4::Mask(24),
+                },
+                dns: None,
+                secondary_dns: None,
+            }),
+        ))
+        .unwrap();
+
+    println!("Start busy loop on main. Connect to the AP `esp-wifi` and point your browser to http://192.168.2.1:8080/");
+    println!("Use a static IP in the range 192.168.2.2 .. 192.168.2.255, use gateway 192.168.2.1");
+
+    let mut rx_buffer = [0u8; 1536];
+    let mut tx_buffer = [0u8; 1536];
+    let mut socket = wifi_stack.get_socket(&mut rx_buffer, &mut tx_buffer);
+
+    socket.listen(8080).unwrap();
+
+    loop {
+        socket.work();
+
+        if !socket.is_open() {
+            socket.listen(8080).unwrap();
+        }
+
+        if socket.is_connected() {
+            println!("Connected");
+
+            let mut time_out = false;
+            let wait_end = current_millis() + 20 * 1000;
+            let mut buffer = [0u8; 1024];
+            let mut pos = 0;
+            loop {
+                if let Ok(len) = socket.read(&mut buffer[pos..]) {
+                    let to_print =
+                        unsafe { core::str::from_utf8_unchecked(&buffer[..(pos + len)]) };
+
+                    if to_print.contains("\r\n\r\n") {
+                        print!("{}", to_print);
+                        println!();
+                        break;
+                    }
+
+                    pos += len;
+                } else {
+                    break;
+                }
+
+                if current_millis() > wait_end {
+                    println!("Timeout");
+                    time_out = true;
+                    break;
+                }
+            }
+
+            if !time_out {
+                socket
+                    .write_all(
+                        b"HTTP/1.0 200 OK\r\n\r\n\
+                    <html>\
+                        <body>\
+                            <h1>Hello Rust! Hello esp-wifi!</h1>\
+                        </body>\
+                    </html>\r\n\
+                    ",
+                    )
+                    .unwrap();
+
+                socket.flush().unwrap();
+            }
+
+            socket.close();
+
+            println!("Done\n");
+            println!();
+        }
+
+        let wait_end = current_millis() + 5 * 1000;
+        while current_millis() < wait_end {
+            socket.work();
+        }
+    }
+}
+
+fn parse_ip(ip: &str) -> [u8; 4] {
+    let mut result = [0u8; 4];
+    for (idx, octet) in ip.split(".").into_iter().enumerate() {
+        result[idx] = u8::from_str_radix(octet, 10).unwrap();
+    }
+    result
+}