wip display

display/src/ble/advertisment.rs

@@ -0,0 +1,31 @@
+use defmt::{info, unwrap};
+use nrf_softdevice::ble::advertisement_builder::{
+    Flag, LegacyAdvertisementBuilder, LegacyAdvertisementPayload, ServiceList, ServiceUuid16,
+};
+use nrf_softdevice::ble::peripheral::ConnectableAdvertisement;
+use nrf_softdevice::ble::{peripheral, Connection};
+use nrf_softdevice::Softdevice;
+
+static SCAN_DATA: LegacyAdvertisementPayload = LegacyAdvertisementBuilder::new()
+    .services_128(
+        ServiceList::Complete,
+        &[0x9e7312e0_2354_11eb_9f10_fbc30a62cf38_u128.to_le_bytes()],
+    )
+    .build();
+
+pub async fn run(sd: &Softdevice, device_name: &str) -> Connection {
+    let config = peripheral::Config::default();
+
+    let adv_data = LegacyAdvertisementBuilder::new()
+        .flags(&[Flag::GeneralDiscovery, Flag::LE_Only])
+        .services_16(ServiceList::Complete, &[ServiceUuid16::BATTERY])
+        .full_name(device_name)
+        .build();
+
+    let adv = ConnectableAdvertisement::ScannableUndirected {
+        adv_data: &adv_data,
+        scan_data: &SCAN_DATA,
+    };
+    info!("advertising started");
+    unwrap!(peripheral::advertise_connectable(sd, adv, &config).await)
+}

display/src/ble/battery_service.rs

@@ -0,0 +1,5 @@
+#[nrf_softdevice::gatt_service(uuid = "180f")]
+pub struct BatteryService {
+    #[characteristic(uuid = "2a19", read, notify)]
+    pub battery_level: u8,
+}

display/src/ble/gatt.rs

@@ -0,0 +1,24 @@
+use crate::ble::battery_service::BatteryService;
+use crate::ble::battery_service::BatteryServiceEvent;
+
+use defmt::info;
+use nrf_softdevice::ble::gatt_server;
+use nrf_softdevice::ble::Connection;
+use nrf_softdevice::ble::DisconnectedError;
+
+#[nrf_softdevice::gatt_server]
+pub struct Server {
+    pub bas: BatteryService,
+}
+
+pub async fn run(conn: &Connection, server: &Server) -> DisconnectedError {
+    info!("gatt started");
+    gatt_server::run(conn, server, |e| match e {
+        ServerEvent::Bas(e) => match e {
+            BatteryServiceEvent::BatteryLevelCccdWrite { notifications } => {
+                info!("battery notifications: {}", notifications)
+            }
+        },
+    })
+    .await
+}

display/src/ble/softdevice.rs

@@ -0,0 +1,58 @@
+use core::mem;
+
+use crate::ble::gatt::Server;
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use nrf_softdevice::{raw, Softdevice};
+
+#[embassy_executor::task]
+async fn softdevice_task(sd: &'static Softdevice) -> ! {
+    sd.run().await
+}
+
+fn configure(device_name: &str) -> nrf_softdevice::Config {
+    nrf_softdevice::Config {
+        clock: Some(raw::nrf_clock_lf_cfg_t {
+            source: raw::NRF_CLOCK_LF_SRC_RC as u8,
+            rc_ctiv: 16,
+            rc_temp_ctiv: 2,
+            accuracy: raw::NRF_CLOCK_LF_ACCURACY_500_PPM as u8,
+        }),
+        conn_gap: Some(raw::ble_gap_conn_cfg_t {
+            conn_count: 6,
+            event_length: 24,
+        }),
+        conn_gatt: Some(raw::ble_gatt_conn_cfg_t { att_mtu: 256 }),
+        gatts_attr_tab_size: Some(raw::ble_gatts_cfg_attr_tab_size_t {
+            attr_tab_size: raw::BLE_GATTS_ATTR_TAB_SIZE_DEFAULT,
+        }),
+        gap_role_count: Some(raw::ble_gap_cfg_role_count_t {
+            adv_set_count: 1,
+            periph_role_count: 3,
+            central_role_count: 3,
+            central_sec_count: 0,
+            _bitfield_1: raw::ble_gap_cfg_role_count_t::new_bitfield_1(0),
+        }),
+        gap_device_name: Some(raw::ble_gap_cfg_device_name_t {
+            p_value: device_name.as_bytes().as_ptr() as *const u8 as _,
+            current_len: 9,
+            max_len: 9,
+            write_perm: unsafe { mem::zeroed() },
+            _bitfield_1: raw::ble_gap_cfg_device_name_t::new_bitfield_1(
+                raw::BLE_GATTS_VLOC_STACK as u8,
+            ),
+        }),
+        ..Default::default()
+    }
+}
+
+pub fn run<'a>(spawner: Spawner, device_name: &str) -> (&'a Softdevice, Server) {
+    let config = configure(device_name);
+
+    let sd = Softdevice::enable(&config);
+    let server = unwrap!(Server::new(sd));
+    unwrap!(spawner.spawn(softdevice_task(sd)));
+    info!("softdevice started");
+
+    (sd, server)
+}