Implement GATT server for Zephyr _bleio

Implement Service, Characteristic, and Descriptor for local (server-side)
GATT services on the Zephyr port. A Service dynamically builds a
bt_gatt_attr table and registers it with bt_gatt_service_register().
Characteristics support READ, WRITE, NOTIFY and INDICATE properties with
configurable security permissions. Setting a characteristic value with
the NOTIFY property automatically calls bt_gatt_notify().

Zephyr's BT_UUID_GATT_PRIMARY / BT_UUID_GATT_CHRC / etc. macros expand
to compound-literal pointers that have automatic storage duration inside
functions. The attr table outlives those functions, so file-scope static
const UUIDs are used instead to avoid dangling pointers.

A bsim integration test verifies the full round-trip: CircuitPython
creates a Battery Service (0x180F), sets the level to 75, and advertises.
A Zephyr central connects, discovers the service, reads the Battery Level
characteristic, and confirms the value is 75.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: tannewt

ports/zephyr-cp/boards/nrf5340bsim_nrf5340_cpuapp.conf

@@ -24,6 +24,7 @@ CONFIG_BT_BUF_ACL_RX_SIZE=255
 
 CONFIG_BT_DEVICE_NAME_DYNAMIC=y
 CONFIG_BT_DEVICE_NAME_MAX=28
+CONFIG_BT_GATT_DYNAMIC_DB=y
 
 # Ensure the network core image starts when using native simulator
 CONFIG_NATIVE_SIMULATOR_AUTOSTART_MCU=y

ports/zephyr-cp/common-hal/_bleio/Adapter.c

@@ -159,7 +159,6 @@ static void bleio_connected_cb(struct bt_conn *conn, uint8_t err) {
 }
 
 static void bleio_disconnected_cb(struct bt_conn *conn, uint8_t reason) {
-    printk("disconnected %p\n", conn);
     bleio_connection_release(bleio_connection_find_by_conn(conn), reason);
 }
 

ports/zephyr-cp/common-hal/_bleio/Characteristic.c

@@ -5,10 +5,89 @@
 //
 // SPDX-License-Identifier: MIT
 
+#include <string.h>
+
+#include <zephyr/bluetooth/gatt.h>
+
 #include "py/runtime.h"
 #include "shared-bindings/_bleio/Characteristic.h"
 #include "shared-bindings/_bleio/Descriptor.h"
 #include "shared-bindings/_bleio/Service.h"
+#include "common-hal/_bleio/__init__.h"
+
+uint16_t bleio_security_to_zephyr_perm(
+    bleio_attribute_security_mode_t read_perm,
+    bleio_attribute_security_mode_t write_perm,
+    bleio_characteristic_properties_t props) {
+    uint16_t perm = 0;
+
+    if (props & CHAR_PROP_READ) {
+        switch (read_perm) {
+            case SECURITY_MODE_OPEN:
+                perm |= BT_GATT_PERM_READ;
+                break;
+            case SECURITY_MODE_ENC_NO_MITM:
+                perm |= BT_GATT_PERM_READ_ENCRYPT;
+                break;
+            case SECURITY_MODE_ENC_WITH_MITM:
+                perm |= BT_GATT_PERM_READ_AUTHEN;
+                break;
+            case SECURITY_MODE_LESC_ENC_WITH_MITM:
+                perm |= BT_GATT_PERM_READ_LESC;
+                break;
+            default:
+                break;
+        }
+    }
+
+    if (props & (CHAR_PROP_WRITE | CHAR_PROP_WRITE_NO_RESPONSE)) {
+        switch (write_perm) {
+            case SECURITY_MODE_OPEN:
+                perm |= BT_GATT_PERM_WRITE;
+                break;
+            case SECURITY_MODE_ENC_NO_MITM:
+                perm |= BT_GATT_PERM_WRITE_ENCRYPT;
+                break;
+            case SECURITY_MODE_ENC_WITH_MITM:
+                perm |= BT_GATT_PERM_WRITE_AUTHEN;
+                break;
+            case SECURITY_MODE_LESC_ENC_WITH_MITM:
+                perm |= BT_GATT_PERM_WRITE_LESC;
+                break;
+            default:
+                break;
+        }
+    }
+
+    return perm;
+}
+
+ssize_t bleio_char_read_cb(struct bt_conn *conn,
+    const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset) {
+    bleio_characteristic_obj_t *self = attr->user_data;
+    return bt_gatt_attr_read(conn, attr, buf, len, offset,
+        self->current_value, self->current_value_len);
+}
+
+ssize_t bleio_char_write_cb(struct bt_conn *conn,
+    const struct bt_gatt_attr *attr, const void *buf, uint16_t len,
+    uint16_t offset, uint8_t flags) {
+    bleio_characteristic_obj_t *self = attr->user_data;
+    if (offset + len > self->max_length) {
+        return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET);
+    }
+    memcpy(self->current_value + offset, buf, len);
+    if (offset + len > self->current_value_len) {
+        self->current_value_len = offset + len;
+    }
+    return len;
+}
+
+void bleio_ccc_changed_cb(const struct bt_gatt_attr *attr, uint16_t value) {
+    // Track subscription state if needed in the future.
+    (void)attr;
+    (void)value;
+}
 
 bleio_characteristic_properties_t common_hal_bleio_characteristic_get_properties(bleio_characteristic_obj_t *self) {
     return self->props;
@@ -31,31 +110,95 @@ size_t common_hal_bleio_characteristic_get_max_length(bleio_characteristic_obj_t
 }
 
 size_t common_hal_bleio_characteristic_get_value(bleio_characteristic_obj_t *self, uint8_t *buf, size_t len) {
-    mp_raise_NotImplementedError(NULL);
+    size_t copy_len = self->current_value_len;
+    if (copy_len > len) {
+        copy_len = len;
+    }
+    memcpy(buf, self->current_value, copy_len);
+    return copy_len;
 }
 
-void common_hal_bleio_characteristic_add_descriptor(bleio_characteristic_obj_t *self, bleio_descriptor_obj_t *descriptor) {
-    mp_raise_NotImplementedError(NULL);
-}
+void common_hal_bleio_characteristic_construct(bleio_characteristic_obj_t *self,
+    bleio_service_obj_t *service, uint16_t handle, bleio_uuid_obj_t *uuid,
+    bleio_characteristic_properties_t props,
+    bleio_attribute_security_mode_t read_perm,
+    bleio_attribute_security_mode_t write_perm,
+    mp_int_t max_length, bool fixed_length,
+    mp_buffer_info_t *initial_value_bufinfo,
+    const char *user_description) {
 
-void common_hal_bleio_characteristic_construct(bleio_characteristic_obj_t *self, bleio_service_obj_t *service, uint16_t handle, bleio_uuid_obj_t *uuid, bleio_characteristic_properties_t props, bleio_attribute_security_mode_t read_perm, bleio_attribute_security_mode_t write_perm, mp_int_t max_length, bool fixed_length, mp_buffer_info_t *initial_value_bufinfo, const char *user_description) {
-    mp_raise_NotImplementedError(NULL);
+    self->service = service;
+    self->uuid = uuid;
+    self->handle = handle;
+    self->props = props;
+    self->read_perm = read_perm;
+    self->write_perm = write_perm;
+    self->max_length = max_length;
+    self->fixed_length = fixed_length;
+    self->observer = mp_const_none;
+    self->descriptor_list = mp_obj_new_list(0, NULL);
+
+    // Allocate value buffer
+    self->current_value = m_malloc(max_length);
+    memset(self->current_value, 0, max_length);
+    self->current_value_alloc = max_length;
+    self->current_value_len = 0;
+
+    // Copy initial value if provided
+    if (initial_value_bufinfo != NULL && initial_value_bufinfo->len > 0) {
+        size_t len = initial_value_bufinfo->len;
+        if (len > (size_t)max_length) {
+            len = max_length;
+        }
+        memcpy(self->current_value, initial_value_bufinfo->buf, len);
+        self->current_value_len = len;
+    }
+
+    // Convert UUID to Zephyr format
+    bleio_uuid_to_zephyr(uuid, &self->zephyr_uuid);
+
+    if (!service->is_remote) {
+        common_hal_bleio_service_add_characteristic(service, self,
+            initial_value_bufinfo, user_description);
+    }
 }
 
 bool common_hal_bleio_characteristic_deinited(bleio_characteristic_obj_t *self) {
     return self->service == NULL;
 }
 
 void common_hal_bleio_characteristic_deinit(bleio_characteristic_obj_t *self) {
-    // Nothing to do
+    // Nothing to do - service handles unregistration
 }
 
 void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self, bool notify, bool indicate) {
+    // Client-side only operation
     mp_raise_NotImplementedError(NULL);
 }
 
 void common_hal_bleio_characteristic_set_value(bleio_characteristic_obj_t *self, mp_buffer_info_t *bufinfo) {
-    mp_raise_NotImplementedError(NULL);
+    size_t len = bufinfo->len;
+    if (len > self->max_length) {
+        len = self->max_length;
+    }
+    memcpy(self->current_value, bufinfo->buf, len);
+    self->current_value_len = len;
+
+    // If NOTIFY and service is registered, send notification
+    if ((self->props & CHAR_PROP_NOTIFY) && self->service != NULL &&
+        self->service->registered) {
+        bt_gatt_notify(NULL, &self->service->attrs[self->value_attr_index],
+            self->current_value, self->current_value_len);
+    }
+}
+
+void common_hal_bleio_characteristic_add_descriptor(bleio_characteristic_obj_t *self,
+    bleio_descriptor_obj_t *descriptor) {
+    mp_obj_list_append(MP_OBJ_FROM_PTR(self->descriptor_list),
+        MP_OBJ_FROM_PTR(descriptor));
+    // Descriptors added after characteristic construction would need
+    // service re-registration; for now the common case is handled by
+    // Service.add_characteristic which adds descriptors at registration time.
 }
 
 void bleio_characteristic_set_observer(bleio_characteristic_obj_t *self, mp_obj_t observer) {

ports/zephyr-cp/common-hal/_bleio/Characteristic.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <zephyr/bluetooth/gatt.h>
+
 #include "py/obj.h"
 #include "py/objlist.h"
 #include "shared-bindings/_bleio/Attribute.h"
@@ -34,7 +36,26 @@ typedef struct _bleio_characteristic_obj {
     uint16_t cccd_handle;
     uint16_t sccd_handle;
     bool fixed_length;
+    // Zephyr GATT server fields:
+    struct bt_gatt_chrc zephyr_chrc;
+    struct bt_uuid_128 zephyr_uuid;
+    struct bt_gatt_ccc_managed_user_data zephyr_ccc;
+    size_t value_attr_index;  // index in service attrs for notify
 } bleio_characteristic_obj_t;
 
 void bleio_characteristic_set_observer(bleio_characteristic_obj_t *self, mp_obj_t observer);
 void bleio_characteristic_clear_observer(bleio_characteristic_obj_t *self);
+
+// Callbacks used by Service.c when building GATT attr table
+ssize_t bleio_char_read_cb(struct bt_conn *conn,
+    const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset);
+ssize_t bleio_char_write_cb(struct bt_conn *conn,
+    const struct bt_gatt_attr *attr, const void *buf, uint16_t len,
+    uint16_t offset, uint8_t flags);
+void bleio_ccc_changed_cb(const struct bt_gatt_attr *attr, uint16_t value);
+
+// Permission mapping helper
+uint16_t bleio_security_to_zephyr_perm(
+    bleio_attribute_security_mode_t read_perm,
+    bleio_attribute_security_mode_t write_perm,
+    bleio_characteristic_properties_t props);

ports/zephyr-cp/common-hal/_bleio/Descriptor.c

@@ -5,26 +5,68 @@
 //
 // SPDX-License-Identifier: MIT
 
+#include <string.h>
+
 #include "py/runtime.h"
 #include "shared-bindings/_bleio/Descriptor.h"
 #include "shared-bindings/_bleio/Characteristic.h"
+#include "common-hal/_bleio/__init__.h"
+
+void common_hal_bleio_descriptor_construct(bleio_descriptor_obj_t *self,
+    bleio_characteristic_obj_t *characteristic, bleio_uuid_obj_t *uuid,
+    bleio_attribute_security_mode_t read_perm,
+    bleio_attribute_security_mode_t write_perm,
+    mp_int_t max_length, bool fixed_length,
+    mp_buffer_info_t *initial_value_bufinfo) {
+
+    self->characteristic = characteristic;
+    self->uuid = uuid;
+    self->read_perm = read_perm;
+    self->write_perm = write_perm;
+    self->max_length = max_length;
+    self->fixed_length = fixed_length;
+
+    // Allocate value buffer
+    self->value = m_malloc(max_length);
+    memset(self->value, 0, max_length);
+    self->value_length = 0;
+
+    // Copy initial value if provided
+    if (initial_value_bufinfo != NULL && initial_value_bufinfo->len > 0) {
+        size_t len = initial_value_bufinfo->len;
+        if (len > (size_t)max_length) {
+            len = max_length;
+        }
+        memcpy(self->value, initial_value_bufinfo->buf, len);
+        self->value_length = len;
+    }
 
-void common_hal_bleio_descriptor_construct(bleio_descriptor_obj_t *self, bleio_characteristic_obj_t *characteristic, bleio_uuid_obj_t *uuid, bleio_attribute_security_mode_t read_perm, bleio_attribute_security_mode_t write_perm, mp_int_t max_length, bool fixed_length, mp_buffer_info_t *initial_value_bufinfo) {
-    mp_raise_NotImplementedError(NULL);
+    // Convert UUID to Zephyr format
+    bleio_uuid_to_zephyr(uuid, &self->zephyr_uuid);
 }
 
 bleio_uuid_obj_t *common_hal_bleio_descriptor_get_uuid(bleio_descriptor_obj_t *self) {
     return self->uuid;
 }
 
 bleio_characteristic_obj_t *common_hal_bleio_descriptor_get_characteristic(bleio_descriptor_obj_t *self) {
-    mp_raise_NotImplementedError(NULL);
+    return (bleio_characteristic_obj_t *)self->characteristic;
 }
 
 size_t common_hal_bleio_descriptor_get_value(bleio_descriptor_obj_t *self, uint8_t *buf, size_t len) {
-    mp_raise_NotImplementedError(NULL);
+    size_t copy_len = self->value_length;
+    if (copy_len > len) {
+        copy_len = len;
+    }
+    memcpy(buf, self->value, copy_len);
+    return copy_len;
 }
 
 void common_hal_bleio_descriptor_set_value(bleio_descriptor_obj_t *self, mp_buffer_info_t *bufinfo) {
-    mp_raise_NotImplementedError(NULL);
+    size_t len = bufinfo->len;
+    if (len > self->max_length) {
+        len = self->max_length;
+    }
+    memcpy(self->value, bufinfo->buf, len);
+    self->value_length = len;
 }

ports/zephyr-cp/common-hal/_bleio/Descriptor.h

@@ -7,10 +7,15 @@
 
 #pragma once
 
+#include <zephyr/bluetooth/uuid.h>
+
 #include "py/obj.h"
 #include "shared-bindings/_bleio/Attribute.h"
 #include "common-hal/_bleio/UUID.h"
 
+// Forward declaration to break circular dependency
+struct _bleio_characteristic_obj;
+
 typedef struct _bleio_descriptor_obj {
     mp_obj_base_t base;
     bleio_uuid_obj_t *uuid;
@@ -21,4 +26,6 @@ typedef struct _bleio_descriptor_obj {
     bool fixed_length;
     uint8_t *value;
     uint16_t value_length;
+    struct _bleio_characteristic_obj *characteristic;
+    struct bt_uuid_128 zephyr_uuid;
 } bleio_descriptor_obj_t;