Improve characteristic interactions

examples/apps/src/ble_bas_central.rs

@@ -47,7 +47,7 @@ where
             let service = services.first().unwrap().clone();
 
             info!("Looking for value handle");
-            let c = client
+            let c: Characteristic<u8> = client
                 .characteristic_by_uuid(&service, &Uuid::new_short(0x2a19))
                 .await
                 .unwrap();

examples/apps/src/ble_bas_peripheral.rs

@@ -43,7 +43,7 @@ where
     let server = Server::new_with_config(
         stack,
         GapConfig::Peripheral(PeripheralConfig {
-            name: "TrouBLE",
+            name: b"TrouBLE",
             appearance: &appearance::GENERIC_POWER,
         }),
     );
@@ -61,16 +61,20 @@ async fn ble_task<C: Controller>(mut runner: Runner<'_, C>) -> Result<(), BleHos
     runner.run().await
 }
 
-async fn gatt_task<C: Controller>(server: &Server<'_,'_, C>) {
+async fn gatt_task<C: Controller>(server: &Server<'_, '_, C>) {
     loop {
         match server.next().await {
-            Ok(GattEvent::Write { handle, connection: _ }) => {
-                let _ = server.get(handle, |value| {
-                    info!("[gatt] Write event on {:?}. Value written: {:?}", handle, value);
-                });
+            Ok(GattEvent::Write {
+                value_handle,
+                connection: _,
+            }) => {
+                info!("[gatt] Write event on {:?}", value_handle);
             }
-            Ok(GattEvent::Read { handle, connection: _ }) => {
-                info!("[gatt] Read event on {:?}", handle);
+            Ok(GattEvent::Read {
+                value_handle,
+                connection: _,
+            }) => {
+                info!("[gatt] Read event on {:?}", value_handle);
             }
             Err(e) => {
                 error!("[gatt] Error processing GATT events: {:?}", e);
@@ -111,7 +115,7 @@ async fn advertise_task<C: Controller>(
             Timer::after(Duration::from_secs(2)).await;
             tick = tick.wrapping_add(1);
             info!("[adv] notifying connection of tick {}", tick);
-            let _ = server.notify(server.battery_service.level, &conn, &[tick]).await;
+            let _ = server.notify(server.battery_service.level, &conn, &tick).await;
         }
     }
 }

examples/apps/src/lib.rs

@@ -8,3 +8,5 @@ pub mod ble_bas_central;
 pub mod ble_bas_peripheral;
 pub mod ble_l2cap_central;
 pub mod ble_l2cap_peripheral;
+
+mod out;

host-macro/src/server.rs

@@ -148,11 +148,11 @@ impl ServerBuilder {
                     }
                 }
 
-                #visibility fn get<F: FnMut(&[u8]) -> T, T>(&self, handle: Characteristic, f: F) -> Result<T, Error> {
-                    self.server.server().table().get(handle, f)
+                #visibility fn get<T: trouble_host::types::gatt_traits::GattValue>(&self, handle: &Characteristic<T>) -> Result<T, Error> {
+                    self.server.server().table().get(handle)
                 }
 
-                #visibility fn set(&self, handle: Characteristic, input: &[u8]) -> Result<(), Error> {
+                #visibility fn set<T: trouble_host::types::gatt_traits::GattValue>(&self, handle: &Characteristic<T>, input: &T) -> Result<(), Error> {
                     self.server.server().table().set(handle, input)
                 }
             }

host-macro/src/service.rs

@@ -156,7 +156,7 @@ impl ServiceBuilder {
             // add fields for each characteristic value handle
             fields.push(syn::Field {
                 ident: Some(char_name.clone()),
-                ty: syn::Type::Verbatim(quote!(Characteristic)),
+                ty: syn::Type::Verbatim(quote!(Characteristic<#ty>)),
                 attrs: Vec::new(),
                 colon_token: Default::default(),
                 vis: ch.vis.clone(),

host/src/attribute.rs

@@ -395,12 +395,12 @@ impl<'d, M: RawMutex, const MAX: usize> AttributeTable<'d, M, MAX> {
     /// The return value of the closure is returned in this function and is assumed to be infallible.
     ///
     /// If the characteristic for the handle cannot be found, an error is returned.
-    pub fn get<F: FnMut(&[u8]) -> T, T: GattValue>(&self, handle: &Characteristic<T>, mut f: F) -> Result<T, Error> {
+    pub fn get<T: GattValue>(&self, handle: &Characteristic<T>) -> Result<T, Error> {
         self.iterate(|mut it| {
             while let Some(att) = it.next() {
                 if att.handle == handle.handle {
                     if let AttributeData::Data { props, value } = &mut att.data {
-                        let v = f(value);
+                        let v = <T as GattValue>::from_gatt(value);
                         return Ok(v);
                     }
                 }

host/src/gap.rs

@@ -7,10 +7,16 @@
 //! In addition, this profile includes common format requirements for
 //! parameters accessible on the user interface level.
 
+use core::fmt::Write;
+
 use crate::prelude::*;
 use embassy_sync::blocking_mutex::raw::RawMutex;
+use heapless::Vec;
 use static_cell::StaticCell;
 
+/// Advertising packet is limited to 31 bytes. 9 of these are used by other GAP data, leaving 22 for Device Name characteristic
+const DEVICE_NAME_MAX_LENGTH: usize = 22;
+
 pub mod appearance {
     //! The representation of the external appearance of the device.
     //!
@@ -63,7 +69,7 @@ pub enum GapConfig<'a> {
 /// Configuration for a peripheral device GAP Service.
 pub struct PeripheralConfig<'a> {
     /// The name of the peripheral device.
-    pub name: &'a [u8; 22],
+    pub name: &'a Vec<u8, DEVICE_NAME_MAX_LENGTH>,
     /// The representation of the external appearance of the device.
     ///
     /// /// Example: `&appearance::GENERIC_SENSOR`
@@ -75,7 +81,7 @@ pub struct PeripheralConfig<'a> {
 /// Configuration for a central device GAP Service.
 pub struct CentralConfig<'a> {
     /// The name of the central device.
-    pub name: &'a [u8; 22],
+    pub name: &'a Vec<u8, DEVICE_NAME_MAX_LENGTH>,
     /// The representation of the external appearance of the device.
     ///
     /// Example: `&appearance::GENERIC_SENSOR`
@@ -88,9 +94,9 @@ impl<'a> GapConfig<'a> {
     ///
     /// This configuration will use the `GENERIC_UNKNOWN` appearance.
     pub fn default(name: &'a str) -> Self {
-        static NAME_BYTES: StaticCell<[u8; 22]> = StaticCell::new();
-        let name_bytes = NAME_BYTES.init([0; 22]);
-        name_bytes.copy_from_slice(name.as_bytes());
+        static NAME_BYTES: StaticCell<Vec<u8, DEVICE_NAME_MAX_LENGTH>> = StaticCell::new();
+        let name_bytes = NAME_BYTES.init(Vec::new());
+        fill_vec(name_bytes, name.as_bytes());
         GapConfig::Peripheral(PeripheralConfig {
             name: name_bytes,
             appearance: &appearance::GENERIC_UNKNOWN,
@@ -124,3 +130,10 @@ impl<'a> GapConfig<'a> {
         table.add_service(Service::new(GATT_UUID)); // GATT UUID (mandatory)
     }
 }
+
+fn fill_vec<const N: usize>(vector: &mut Vec<u8, N>, bytes: &[u8]) {
+    let mut byte_index = 0;
+    while byte_index < bytes.len() && vector.push(bytes[byte_index]).is_ok() {
+        byte_index += 1;
+    }
+}

host/src/gatt.rs

@@ -54,7 +54,7 @@ impl<'reference, 'values, C: Controller, M: RawMutex, const MAX: usize, const L2
     ///
     /// If attributes are written or read, an event will be returned describing the handle
     /// and the connection causing the event.
-    pub async fn next<T: GattValue>(&self) -> Result<GattEvent<'reference, T>, Error> {
+    pub async fn next(&self) -> Result<GattEvent<'reference>, Error> {
         loop {
             let (handle, pdu) = self.rx.receive().await;
             if let Some(connection) = self.connections.get_connected_handle(handle) {
@@ -76,17 +76,17 @@ impl<'reference, 'values, C: Controller, M: RawMutex, const MAX: usize, const L2
                                 let event = match att {
                                     AttReq::Write { handle, data } => Some(GattEvent::Write {
                                         connection,
-                                        handle: self.server.table.find_characteristic_by_value_handle(handle)?,
+                                        value_handle: handle,
                                     }),
 
                                     AttReq::Read { handle } => Some(GattEvent::Read {
                                         connection,
-                                        handle: self.server.table.find_characteristic_by_value_handle(handle)?,
+                                        value_handle: handle,
                                     }),
 
                                     AttReq::ReadBlob { handle, offset } => Some(GattEvent::Read {
                                         connection,
-                                        handle: self.server.table.find_characteristic_by_value_handle(handle)?,
+                                        value_handle: handle,
                                     }),
                                     _ => None,
                                 };
@@ -157,20 +157,20 @@ impl<'reference, 'values, C: Controller, M: RawMutex, const MAX: usize, const L2
 
 /// An event returned while processing GATT requests.
 #[derive(Clone)]
-pub enum GattEvent<'reference, T: GattValue> {
+pub enum GattEvent<'reference> {
     /// A characteristic was read.
     Read {
         /// Connection that read the characteristic.
         connection: Connection<'reference>,
         /// Characteristic handle that was read.
-        handle: Characteristic<T>,
+        value_handle: u16,
     },
     /// A characteristic was written.
     Write {
         /// Connection that wrote the characteristic.
         connection: Connection<'reference>,
         /// Characteristic handle that was written.
-        handle: Characteristic<T>,
+        value_handle: u16,
     },
 }
 

host/src/types/mod.rs

@@ -1,5 +1,5 @@
 //! Common types.
-pub(crate) mod gatt_traits;
+pub mod gatt_traits;
 pub(crate) mod l2cap;
 pub(crate) mod primitives;
 

host/tests/gatt.rs

@@ -43,7 +43,7 @@ async fn gatt_client_server() {
         let mut expected = value[0].wrapping_add(1);
         let mut svc = table.add_service(Service::new(0x1800));
         let _ = svc.add_characteristic_ro(0x2a00, id);
-        let _ = svc.add_characteristic_ro(0x2a01, &appearance[..]);
+        let _ = svc.add_characteristic_ro(0x2a01, &appearance);
         svc.build();
 
         // Generic attribute service (mandatory)
@@ -71,7 +71,7 @@ async fn gatt_client_server() {
                             handle,
                         }) => {
                             assert_eq!(handle, value_handle);
-                            let _ = server.server().table().get(handle, |value| {
+                            let _ = server.server().table().get(&handle, |value| {
                                 assert_eq!(expected, value[0]);
                                 expected += 1;
                                 writes += 1;