bump a lot of big changes I dont want to break down into individual commits

src/tasks/wifi.rs

@@ -0,0 +1,147 @@
+use bleps::{ad_structure::{create_advertising_data, AdStructure, BR_EDR_NOT_SUPPORTED, LE_GENERAL_DISCOVERABLE}, attribute_server::{AttributeServer, NotificationData}, gatt, Ble, HciConnector};
+use embassy_sync::channel::DynamicReceiver;
+use embassy_time::Timer;
+use esp_hal::timer::AnyTimer;
+use esp_wifi::ble::controller::BleConnector;
+use log::*;
+
+use crate::events::Notification;
+
+pub async fn ble_task(notify: DynamicReceiver<'static, Notification>, wifi_init: &esp_wifi::EspWifiController<'_>, bluetooth_device: esp_hal::peripherals::BT<'static>) {
+    info!("Setting up BLE stack");
+    let connector = BleConnector::new(wifi_init, bluetooth_device);
+    let get_millis = || esp_hal::time::Instant::now().duration_since_epoch().as_millis();
+    let hci = HciConnector::new(connector, get_millis);
+    let mut ble = Ble::new(&hci);
+    ble.init().unwrap();
+    ble.cmd_set_le_advertising_parameters().unwrap();
+    ble.cmd_set_le_advertising_data(
+        create_advertising_data(&[
+            AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
+            AdStructure::ServiceUuids16(&[Uuid::Uuid16(0x0001)]),
+            AdStructure::CompleteLocalName("Renderbug!")
+        ])
+        .unwrap()
+    ).unwrap();
+    ble.cmd_set_le_advertise_enable(true).unwrap();
+
+    let mut wf1 = |_offset: usize, data: &[u8]| {
+        info!("Read serial data! {data:?}");
+    };
+
+    // Other useful characteristics:
+    // 0x2A67 - Location and speed
+    // 0x2A00 - Device name
+    // 0x2B90 - Device time
+    // Permitted characteristics:
+    // Acceleration
+    // Force
+    // Length
+    // Linear position
+    // Rotational speed
+    // Temperature
+    // Torque
+    // Useful app that logs data: https://github.com/a2ruan/ArduNetApp?tab=readme-ov-file
+    // Requires service 4fafc201-1fb5-459e-8fcc-c5c9c331914b, characteristic beb5483e-36e1-4688-b7f5-ea07361b26a8
+    let s = &b""[..];
+    gatt!([service {
+        uuid: "6E400001-B5A3-F393-E0A9-E50E24DCCA9E", // Nordic UART
+        characteristics: [
+            characteristic {
+                uuid: "6E400003-B5A3-F393-E0A9-E50E24DCCA9E", // TX from device, everything is sent as notifications
+                notify: true,
+                name: "tx",
+                value: s
+            },
+            characteristic {
+                uuid: "6E400002-B5A3-F393-E0A9-E50E24DCCA9E", // RX from phone
+                write: wf1
+            },
+        ]
+    }]);
+    let mut rng = bleps::no_rng::NoRng;
+    let mut srv = AttributeServer::new(&mut ble, &mut gatt_attributes, &mut rng);
+
+    info!("BLE running!");
+    // TODO: Somehow need to recreate the attributeserver after disconnecting?
+    loop {
+        let notification = match notify.try_receive() {
+            Err(_) => None,
+            Ok(Notification::Beat) => Some("beat"),
+            //TODO: Should make Telemetry values serde-encodable
+            /*Ok(Telemetry::Measurement(Measurement::IMU { accel, gyro })) => {
+                let json_data = json!({
+                    "x": accel.x,
+                    "y": accel.y,
+                    "z": accel.z,
+                    "gx": gyro.x,
+                    "gy": gyro.y,
+                    "gz": gyro.z
+                });
+                let json_buf = serde_json::to_string(&json_data).unwrap();
+                Some(json_buf)
+            },
+            Ok(Telemetry::Measurement(Measurement::GPS(Some(measurement)))) => {
+                info!("gps telemetry");
+                let json_data = json!({
+                    "lat": measurement.x,
+                    "lng": measurement.y
+                });
+                let json_buf = serde_json::to_string(&json_data).unwrap();
+                Some(json_buf)
+            },*/
+            _ => None
+        };
+
+        match notification {
+            None => {
+                srv.do_work().unwrap();
+                Timer::after_millis(5).await;
+            },
+            Some(serial_data) => {
+                for chunk in serial_data.as_bytes().chunks(20) {
+                    srv.do_work_with_notification(Some(NotificationData::new(tx_handle, chunk))).unwrap();
+                }
+                srv.do_work_with_notification(Some(NotificationData::new(tx_handle, &b"\n"[..]))).unwrap();
+            }
+        }
+    }
+}
+
+// TODO: Wifi task needs to know when there is data to upload, so it only connects when needed.
+#[embassy_executor::task]
+pub async fn wireless_task(notify: DynamicReceiver<'static, Notification>, timer: AnyTimer<'static>, rng: esp_hal::peripherals::RNG<'static>, _wifi_device: esp_hal::peripherals::WIFI<'static>, bluetooth_device: esp_hal::peripherals::BT<'static>) {
+    let rng = esp_hal::rng::Rng::new(rng);
+    let wifi_init =
+        esp_wifi::init(timer, rng).expect("Failed to initialize WIFI/BLE controller");
+
+    ble_task(notify, &wifi_init, bluetooth_device).await;
+
+    /*
+    loop {
+        let (mut wifi, _interfaces) = esp_wifi::wifi::new(&wifi_init, wifi_device)
+            .expect("Failed to initialize WIFI controller");    }
+
+        loop {
+            //let results = wifi.scan_n_async(16).await.unwrap();
+            wifi.set_configuration(&esp_wifi::wifi::Configuration::Client(
+                ClientConfiguration {
+                    ssid: "The Frequency".to_string(),
+                    auth_method: esp_wifi::wifi::AuthMethod::WPA2Personal,
+                    password: "thepasswordkenneth".to_string(),
+                    ..Default::default()
+                }
+            )).unwrap();
+
+            if wifi.connect_async().await.is_ok() {
+                info!("Connected to wifi!");
+                while wifi.is_connected().unwrap() {
+                    Timer::after_secs(60).await;
+                }
+                info!("Disconnected.");
+            }
+            Timer::after_secs(30).await;
+        }
+    }
+    */
+}