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

@@ -24,10 +24,18 @@ struct Server {
 // Battery service
 #[gatt_service(uuid = "180f")]
 struct BatteryService {
-    #[characteristic(uuid = "2a19", read, notify)]
+    #[characteristic(uuid = "2a19", read, write, notify, on_read = battery_level_on_read, on_write = battery_level_on_write)]
     level: u8,
 }
 
+fn battery_level_on_read(_connection: &Connection) {
+    info!("[gatt] Read event on battery level characteristic");
+}
+
+fn battery_level_on_write(_connection: &Connection, data: &[u8]) {
+    info!("[gatt] Write event on battery level characteristic: {:?}", data);
+}
+
 pub async fn run<C>(controller: C)
 where
     C: Controller,
@@ -46,7 +54,8 @@ where
             name: "TrouBLE",
             appearance: &appearance::GENERIC_POWER,
         }),
-    );
+    )
+    .unwrap();
 
     info!("Starting advertising and GATT service");
     let _ = join3(
@@ -61,16 +70,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 +124,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/esp32/.cargo/config.toml

@@ -3,14 +3,14 @@ runner = "espflash flash --monitor"
 
 
 [env]
-ESP_LOGLEVEL="trace"
-ESP_LOGTARGETS="trouble_host"
+ESP_LOGLEVEL = "info"
 
 [build]
 rustflags = [
   # Required to obtain backtraces (e.g. when using the "esp-backtrace" crate.)
   # NOTE: May negatively impact performance of produced code
-  "-C", "force-frame-pointers",
+  "-C",
+  "force-frame-pointers",
 ]
 
 target = "riscv32imc-unknown-none-elf"

host-macro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "trouble-host-macros"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "Apache-2.0 or MIT"
 description = "An async Rust BLE host - Derive macros crate"

host-macro/src/characteristic.rs

@@ -9,8 +9,9 @@ use darling::Error;
 use darling::FromMeta;
 use proc_macro2::Span;
 use syn::parse::Result;
-use syn::spanned::Spanned as _;
+use syn::spanned::Spanned;
 use syn::Field;
+use syn::Ident;
 use syn::LitStr;
 
 #[derive(Debug)]
@@ -47,10 +48,10 @@ pub(crate) struct DescriptorArgs {
 }
 
 /// Characteristic attribute arguments
-#[derive(Debug, FromMeta, Default)]
+#[derive(Debug, FromMeta)]
 pub(crate) struct CharacteristicArgs {
     /// The UUID of the characteristic.
-    pub uuid: Option<Uuid>,
+    pub uuid: Uuid,
     /// If true, the characteristic can be read.
     #[darling(default)]
     pub read: bool,
@@ -66,39 +67,57 @@ pub(crate) struct CharacteristicArgs {
     /// If true, the characteristic can send indications.
     #[darling(default)]
     pub indicate: bool,
+    /// Optional callback to be triggered on a read event
+    #[darling(default)]
+    pub on_read: Option<Ident>,
+    /// Optional callback to be triggered on a write event
+    #[darling(default)]
+    pub on_write: Option<Ident>,
     /// The initial value of the characteristic.
     /// This is optional and can be used to set the initial value of the characteristic.
     #[darling(default)]
-    pub value: Option<syn::Expr>,
+    pub _default_value: Option<syn::Expr>,
     // /// Descriptors for the characteristic.
     // /// Descriptors are optional and can be used to add additional metadata to the characteristic.
     #[darling(default, multiple)]
-    pub _descriptor: Vec<DescriptorArgs>,
+    pub _descriptors: Vec<DescriptorArgs>,
 }
 
 impl CharacteristicArgs {
     /// Parse the arguments of a characteristic attribute
     pub fn parse(attribute: &syn::Attribute) -> Result<Self> {
-        let mut args = CharacteristicArgs::default();
+        let mut uuid: Option<Uuid> = None;
+        let mut read = false;
+        let mut write = false;
+        let mut write_without_response = false;
+        let mut notify = false;
+        let mut indicate = false;
+        let mut on_read = None;
+        let mut on_write = None;
+        let mut _default_value: Option<syn::Expr> = None;
+        let descriptors: Vec<DescriptorArgs> = Vec::new();
         attribute.parse_nested_meta(|meta| {
             match meta.path.get_ident().ok_or(Error::custom("no ident"))?.to_string().as_str() {
                 "uuid" => {
                     let value = meta
                     .value()
                     .map_err(|_| Error::custom("uuid must be followed by '= [data]'.  i.e. uuid = '0x2A37'".to_string()))?;
                     let uuid_string: LitStr = value.parse()?;
-                    args.uuid = Some(Uuid::from_string(uuid_string.value().as_str())?);
+                    uuid = Some(Uuid::from_string(uuid_string.value().as_str())?);
                 },
-                "read" => args.read = true,
-                "write" => args.write = true,
-                "write_without_response" => args.write_without_response = true,
-                "notify" => args.notify = true,
-                "indicate" => args.indicate = true,
+                "read" => read = true,
+                "write" => write = true,
+                "write_without_response" => write_without_response = true,
+                "notify" => notify = true,
+                "indicate" => indicate = true,
+                "on_read" => on_read = Some(meta.value()?.parse()?),
+                "on_write" => on_write = Some(meta.value()?.parse()?),
                 "value" => {
-                    let value = meta
-                    .value()
-                    .map_err(|_| Error::custom("value must be followed by '= [data]'.  i.e. value = 'hello'".to_string()))?;
-                    args.value = Some(value.parse()?);
+                    return Err(Error::custom("Default value is currently unsupported").with_span(&meta.path.span()).into())
+                    // let value = meta
+                    // .value()
+                    // .map_err(|_| Error::custom("value must be followed by '= [data]'.  i.e. value = 'hello'".to_string()))?;
+                    // default_value = Some(value.parse()?);
                 },
                 other => return Err(
                     meta.error(
@@ -108,9 +127,17 @@ impl CharacteristicArgs {
             };
             Ok(())
         })?;
-        if args.uuid.is_none() {
-            return Err(Error::custom("Characteristic must have a UUID").into());
-        }
-        Ok(args)
+        Ok(Self {
+            uuid: uuid.ok_or(Error::custom("Characteristic must have a UUID"))?,
+            read,
+            write,
+            write_without_response,
+            notify,
+            indicate,
+            on_read,
+            on_write,
+            _default_value,
+            _descriptors: descriptors,
+        })
     }
 }

host-macro/src/lib.rs

@@ -16,6 +16,7 @@ use ctxt::Ctxt;
 use proc_macro::TokenStream;
 use server::{ServerArgs, ServerBuilder};
 use service::{ServiceArgs, ServiceBuilder};
+use syn::parse_macro_input;
 
 /// Gatt Service attribute macro.
 ///
@@ -73,21 +74,11 @@ pub fn gatt_server(args: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_attribute]
 pub fn gatt_service(args: TokenStream, item: TokenStream) -> TokenStream {
-    let service_uuid = {
-        // Get arguments from the gatt_service macro attribute (i.e. uuid)
-        let service_attributes: ServiceArgs = {
-            let mut attributes = ServiceArgs::default();
-            let arg_parser = syn::meta::parser(|meta| attributes.parse(meta));
-
-            syn::parse_macro_input!(args with arg_parser);
-            attributes
-        };
-        service_attributes.uuid
-    }
-    .expect("uuid is required for gatt_service");
+    // Get arguments from the gatt_service macro attribute
+    let service_arguments = parse_macro_input!(args as ServiceArgs);
 
     // Parse the contents of the struct
-    let mut service_props = syn::parse_macro_input!(item as syn::ItemStruct);
+    let mut service_props = parse_macro_input!(item as syn::ItemStruct);
 
     let ctxt = Ctxt::new(); // error handling context, must be initialized after parse_macro_input calls.
 
@@ -119,7 +110,7 @@ pub fn gatt_service(args: TokenStream, item: TokenStream) -> TokenStream {
     }
 
     // Build the service struct
-    let result = ServiceBuilder::new(service_props, service_uuid)
+    let result = ServiceBuilder::new(service_props, service_arguments)
         .process_characteristics_and_fields(fields, characteristics)
         .build();
 

host-macro/src/server.rs

@@ -95,6 +95,12 @@ impl ServerBuilder {
             });
         }
 
+        const GAP_UUID: u16 = 0x1800;
+        const GATT_UUID: u16 = 0x1801;
+
+        const DEVICE_NAME_UUID: u16 = 0x2a00;
+        const APPEARANCE_UUID: u16 = 0x2a01;
+
         quote! {
             #visibility struct #name<'reference, 'values, C: Controller>
             {
@@ -119,40 +125,68 @@ impl ServerBuilder {
                 /// Create a new Gatt Server instance.
                 ///
                 /// This function will add a Generic GAP Service with the given name.
-                #visibility fn new_default(stack: Stack<'reference, C>, name: &'values str) -> Self {
+                /// The maximum length which the name can be is 22 bytes (limited by the size of the advertising packet).
+                /// If a name longer than this is passed, Err() is returned.
+                #visibility fn new_default(stack: Stack<'reference, C>, name: &'values str) -> Result<Self, &'static str> {
                     let mut table: AttributeTable<'_, #mutex_type, #attribute_data_size> = AttributeTable::new();
 
-                    GapConfig::default(name).build(&mut table);
+                    static DEVICE_NAME: static_cell::StaticCell<HeaplessString<{DEVICE_NAME_MAX_LENGTH}>> = static_cell::StaticCell::new();
+                    let device_name = DEVICE_NAME.init(HeaplessString::new());
+                    if device_name.push_str(name).is_err() {
+                        return Err("Name is too long. Device name must be <= 22 bytes");
+                    };
+                    let mut svc = table.add_service(Service::new(#GAP_UUID), None);
+                    svc.add_characteristic_ro(#DEVICE_NAME_UUID, device_name, None);
+                    svc.add_characteristic_ro(#APPEARANCE_UUID, &appearance::GENERIC_UNKNOWN, None);
+                    svc.build();
+
+                    table.add_service(Service::new(#GATT_UUID), None);
 
                     #code_service_init
 
-                    Self {
+                    Ok(Self {
                         server: GattServer::new(stack, table),
                         #code_server_populate
-                    }
+                    })
                 }
 
                 /// Create a new Gatt Server instance.
                 ///
                 /// This function will add a GAP Service.
-                #visibility fn new_with_config(stack: Stack<'reference, C>, gap: GapConfig<'values>) -> Self {
+                /// The maximum length which the device name can be is 22 bytes (limited by the size of the advertising packet).
+                /// If a name longer than this is passed, Err() is returned.
+                #visibility fn new_with_config(stack: Stack<'reference, C>, gap: GapConfig<'values>) -> Result<Self, &'static str> {
                     let mut table: AttributeTable<'_, #mutex_type, #attribute_data_size> = AttributeTable::new();
 
-                    gap.build(&mut table);
+                    static DEVICE_NAME: static_cell::StaticCell<HeaplessString<{DEVICE_NAME_MAX_LENGTH}>> = static_cell::StaticCell::new();
+                    let device_name = DEVICE_NAME.init(HeaplessString::new());
+                    let (name, appearance) = match gap {
+                        GapConfig::Peripheral(config) => (config.name, config.appearance),
+                        GapConfig::Central(config) => (config.name, config.appearance),
+                    };
+                    if device_name.push_str(name).is_err() {
+                        return Err("Name is too long. Device name must be <= 22 bytes");
+                    };
+                    let mut svc = table.add_service(Service::new(#GAP_UUID), None);
+                    svc.add_characteristic_ro(#DEVICE_NAME_UUID, device_name, None);
+                    svc.add_characteristic_ro(#APPEARANCE_UUID, appearance, None);
+                    svc.build();
+
+                    table.add_service(Service::new(#GATT_UUID), None);
 
                     #code_service_init
 
-                    Self {
+                    Ok(Self {
                         server: GattServer::new(stack, table),
                         #code_server_populate
-                    }
+                    })
                 }
 
-                #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)
                 }
             }