Hi, I'm making a keyboard and mouse composite device based on the peripheral_hids_keyboard project in the sample.
The only modification I made was to add the contents of the hid-init() function of peripheral_hids_mouse to that of peripheral_hids_keyboard, but after many attempts, nRF52840DK always gives the following error in the console:
*** Booting Zephyr OS build v3.3.99-ncs1 ***
Starting Bluetooth Peripheral HIDS keyboard example
E: No space left on given svc
ASSERTION FAIL @ WEST_TOPDIR/nrf/subsys/bluetooth/services/hids.c:963
E: r0/a1: 0x00000004 r1/a2: 0x000003c3 r2/a3: 0x00000001
E: r3/a4: 0x0001f21d r12/ip: 0xa0000000 r14/lr: 0x00014a33
E: xpsr: 0x41000000
E: Faulting instruction address (r15/pc): 0x0002b8a6
E: >>> ZEPHYR FATAL ERROR 4: Kernel panic on CPU 0
E: Current thread: 0x200031a8 (unknown)
* Connection lost
I did many searches in Devzone and sure there is no problem with my report_map, but I'm not sure about the rest in that function or maybe I'm missing some other config
(I have replaced all macro definitions with numbers to make it look clearer):
static void hid_init(void)
{
int err;
struct bt_hids_init_param hids_init_obj = { 0 };
struct bt_hids_inp_rep *hids_inp_rep;
struct bt_hids_outp_feat_rep *hids_outp_rep;
static const uint8_t mouse_movement_mask[DIV_ROUND_UP(3, 8)] = {0};
static const uint8_t report_map[] = {
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x06, // Usage (Keyboard)
0xA1, 0x01, // Collection (Application)
0x85, 0x01, // Report Id 1
0x05, 0x07, // Usage Page (Key Codes)
0x19, 0xe0, // Usage Minimum (224)
0x29, 0xe7, // Usage Maximum (231)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x75, 0x01, // Report Size (1)
0x95, 0x08, // Report Count (8)
0x81, 0x02, // Input (Data, Variable, Absolute)
0x95, 0x01, // Report Count (1)
0x75, 0x08, // Report Size (8)
0x81, 0x01, // Input (Constant) reserved byte(1)
0x95, 0x05, // Report Count (5)
0x75, 0x01, // Report Size (1)
0x05, 0x08, // Usage Page (Page# for LEDs)
0x19, 0x01, // Usage Minimum (1)
0x29, 0x05, // Usage Maximum (5)
0x91, 0x02, // Output (Data, Variable, Absolute), Led report
0x95, 0x01, // Report Count (1)
0x75, 0x03, // Report Size (3)
0x91, 0x01, // Output (Data, Variable, Absolute), Led report padding
0x95, 0x06, // Report Count (6)
0x75, 0x08, // Report Size (8)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x65, // Logical Maximum (101)
0x05, 0x07, // Usage Page (Key codes)
0x19, 0x00, // Usage Minimum (0)
0x29, 0x65, // Usage Maximum (101)
0x81, 0x00, // Input (Data, Array) Key array(6 bytes)
0x09, 0x05, // Usage (Vendor Defined)
0x15, 0x00, // Logical Minimum (0)
0x26, 0xFF, 0x00, // Logical Maximum (255)
0x75, 0x08, // Report Count (2)
0x95, 0x02, // Report Size (8 bit)
0xB1, 0x02, // Feature (Data, Variable, Absolute)
0xC0, // End Collection (Application)
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x02, // Usage (Mouse)
0xA1, 0x01, // Collection (Application)
// Report ID 2: Mouse buttons + scroll/pan
0x85, 0x02, // Report Id 2
0x09, 0x01, // Usage (Pointer)
0xA1, 0x00, // Collection (Physical)
0x95, 0x05, // Report Count (3)
0x75, 0x01, // Report Size (1)
0x05, 0x09, // Usage Page (Buttons)
0x19, 0x01, // Usage Minimum (01)
0x29, 0x05, // Usage Maximum (05)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x81, 0x02, // Input (Data, Variable, Absolute)
0x95, 0x01, // Report Count (1)
0x75, 0x03, // Report Size (3)
0x81, 0x01, // Input (Constant) for padding
0x75, 0x08, // Report Size (8)
0x95, 0x01, // Report Count (1)
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x38, // Usage (Wheel)
0x15, 0x81, // Logical Minimum (-127)
0x25, 0x7F, // Logical Maximum (127)
0x81, 0x06, // Input (Data, Variable, Relative)
0x05, 0x0C, // Usage Page (Consumer)
0x0A, 0x38, 0x02, // Usage (AC Pan)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0xC0, // End Collection (Physical)
// Report ID 3: Mouse motion
0x85, 0x03, // Report Id 3
0x09, 0x01, // Usage (Pointer)
0xA1, 0x00, // Collection (Physical)
0x75, 0x0C, // Report Size (12)
0x95, 0x02, // Report Count (2)
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x30, // Usage (X)
0x09, 0x31, // Usage (Y)
0x16, 0x01, 0xF8, // Logical maximum (2047)
0x26, 0xFF, 0x07, // Logical minimum (-2047)
0x81, 0x06, // Input (Data, Variable, Relative)
0xC0, // End Collection (Physical)
0xC0, // End Collection (Application)
// Report ID 4: Advanced buttons
0x05, 0x0C, // Usage Page (Consumer)
0x09, 0x01, // Usage (Consumer Control)
0xA1, 0x01, // Collection (Application)
0x85, 0x04, // Report Id (4)
0x15, 0x00, // Logical minimum (0)
0x25, 0x01, // Logical maximum (1)
0x75, 0x01, // Report Size (1)
0x95, 0x01, // Report Count (1)
0x09, 0xCD, // Usage (Play/Pause)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x0A, 0x83, 0x01, // Usage (AL Consumer Control Configuration)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x09, 0xB5, // Usage (Scan Next Track)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x09, 0xB6, // Usage (Scan Previous Track)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x09, 0xEA, // Usage (Volume Down)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x09, 0xE9, // Usage (Volume Up)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x0A, 0x25, 0x02, // Usage (AC Forward)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x0A, 0x24, 0x02, // Usage (AC Back)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0xC0 // End Collection
};
hids_init_obj.rep_map.data = report_map;
hids_init_obj.rep_map.size = sizeof(report_map);
hids_init_obj.info.bcd_hid = BASE_USB_HID_SPEC_VERSION;
hids_init_obj.info.b_country_code = 0x00;
hids_init_obj.info.flags = (BT_HIDS_REMOTE_WAKE |
BT_HIDS_NORMALLY_CONNECTABLE);
//input kb
hids_inp_rep =
&hids_init_obj.inp_rep_group_init.reports[0];
hids_inp_rep->size = 8;
hids_inp_rep->id = 1;
hids_init_obj.inp_rep_group_init.cnt++;
//output kb
hids_outp_rep =
&hids_init_obj.outp_rep_group_init.reports[0];
hids_outp_rep->size = 1;
hids_outp_rep->id = 1;
hids_outp_rep->handler = hids_outp_rep_handler;
hids_init_obj.outp_rep_group_init.cnt++;
//input mouse button & wheel
hids_inp_rep++;
hids_inp_rep->size = 3;
hids_inp_rep->id = 2;
hids_init_obj.inp_rep_group_init.cnt++;
//input mouse movement
hids_inp_rep++;
hids_inp_rep->size = 3;
hids_inp_rep->id = 3;
hids_inp_rep->rep_mask = mouse_movement_mask;
hids_init_obj.inp_rep_group_init.cnt++;
//input media
hids_inp_rep++;
hids_inp_rep->size = 1;
hids_inp_rep->id = 4;
hids_init_obj.inp_rep_group_init.cnt++;
hids_init_obj.is_mouse = true;
hids_init_obj.is_kb = true;
hids_init_obj.boot_kb_outp_rep_handler = hids_boot_kb_outp_rep_handler;
hids_init_obj.pm_evt_handler = hids_pm_evt_handler;
err = bt_hids_init(&hids_obj, &hids_init_obj);
__ASSERT(err == 0, "HIDS initialization failed\n");
}
The full file:
/*
* Copyright (c) 2018 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
*/
#include <zephyr/types.h>
#include <stddef.h>
#include <string.h>
#include <errno.h>
#include <zephyr/sys/printk.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <soc.h>
#include <assert.h>
#include <zephyr/spinlock.h>
#include <zephyr/settings/settings.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/services/bas.h>
#include <bluetooth/services/hids.h>
#include <zephyr/bluetooth/services/dis.h>
#include <dk_buttons_and_leds.h>
#include "app_nfc.h"
#define DEVICE_NAME CONFIG_BT_DEVICE_NAME
#define DEVICE_NAME_LEN (sizeof(DEVICE_NAME) - 1)
#define BASE_USB_HID_SPEC_VERSION 0x0101
#define OUTPUT_REPORT_MAX_LEN 1
#define OUTPUT_REPORT_BIT_MASK_CAPS_LOCK 0x02
#define INPUT_REP_KEYS_REF_ID 1
#define OUTPUT_REP_KEYS_REF_ID 1
#define MODIFIER_KEY_POS 0
#define SHIFT_KEY_CODE 0x02
#define SCAN_CODE_POS 2
#define KEYS_MAX_LEN (INPUT_REPORT_KEYS_MAX_LEN - \
SCAN_CODE_POS)
#define ADV_LED_BLINK_INTERVAL 1000
#define ADV_STATUS_LED DK_LED1
#define CON_STATUS_LED DK_LED2
#define LED_CAPS_LOCK DK_LED3
#define NFC_LED DK_LED4
#define KEY_TEXT_MASK DK_BTN1_MSK
#define KEY_SHIFT_MASK DK_BTN2_MSK
#define KEY_ADV_MASK DK_BTN4_MSK
/* Key used to accept or reject passkey value */
#define KEY_PAIRING_ACCEPT DK_BTN1_MSK
#define KEY_PAIRING_REJECT DK_BTN2_MSK
/* HIDs queue elements. */
#define HIDS_QUEUE_SIZE 10
/* ********************* */
/* Buttons configuration */
/* Note: The configuration below is the same as BOOT mode configuration
* This simplifies the code as the BOOT mode is the same as REPORT mode.
* Changing this configuration would require separate implementation of
* BOOT mode report generation.
*/
#define KEY_CTRL_CODE_MIN 224 /* Control key codes - required 8 of them */
#define KEY_CTRL_CODE_MAX 231 /* Control key codes - required 8 of them */
#define KEY_CODE_MIN 0 /* Normal key codes */
#define KEY_CODE_MAX 101 /* Normal key codes */
#define KEY_PRESS_MAX 6 /* Maximum number of non-control keys
* pressed simultaneously
*/
/* Number of bytes in key report
*
* 1B - control keys
* 1B - reserved
* rest - non-control keys
*/
#define INPUT_REPORT_KEYS_MAX_LEN (1 + 1 + KEY_PRESS_MAX)
/* Current report map construction requires exactly 8 buttons */
BUILD_ASSERT((KEY_CTRL_CODE_MAX - KEY_CTRL_CODE_MIN) + 1 == 8);
/* OUT report internal indexes.
*
* This is a position in internal report table and is not related to
* report ID.
*/
enum {
OUTPUT_REP_KEYS_IDX = 0
};
/* INPUT report internal indexes.
*
* This is a position in internal report table and is not related to
* report ID.
*/
enum {
INPUT_REP_KEYS_IDX = 0
};
/* HIDS instance. */
BT_HIDS_DEF(hids_obj,
OUTPUT_REPORT_MAX_LEN,
INPUT_REPORT_KEYS_MAX_LEN);
static volatile bool is_adv;
static const struct bt_data ad[] = {
BT_DATA_BYTES(BT_DATA_GAP_APPEARANCE,
(CONFIG_BT_DEVICE_APPEARANCE >> 0) & 0xff,
(CONFIG_BT_DEVICE_APPEARANCE >> 8) & 0xff),
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_HIDS_VAL),
BT_UUID_16_ENCODE(BT_UUID_BAS_VAL)),
};
static const struct bt_data sd[] = {
BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN),
};
static struct conn_mode {
struct bt_conn *conn;
bool in_boot_mode;
} conn_mode[CONFIG_BT_HIDS_MAX_CLIENT_COUNT];
static const uint8_t hello_world_str[] = {
0x0b, /* Key h */
0x08, /* Key e */
0x0f, /* Key l */
0x0f, /* Key l */
0x12, /* Key o */
0x28, /* Key Return */
};
static const uint8_t shift_key[] = { 225 };
/* Current report status
*/
static struct keyboard_state {
uint8_t ctrl_keys_state; /* Current keys state */
uint8_t keys_state[KEY_PRESS_MAX];
} hid_keyboard_state;
#if CONFIG_NFC_OOB_PAIRING
static struct k_work adv_work;
#endif
static struct k_work pairing_work;
struct pairing_data_mitm {
struct bt_conn *conn;
unsigned int passkey;
};
K_MSGQ_DEFINE(mitm_queue,
sizeof(struct pairing_data_mitm),
CONFIG_BT_HIDS_MAX_CLIENT_COUNT,
4);
static void advertising_start(void)
{
int err;
struct bt_le_adv_param *adv_param = BT_LE_ADV_PARAM(
BT_LE_ADV_OPT_CONNECTABLE |
BT_LE_ADV_OPT_ONE_TIME,
BT_GAP_ADV_FAST_INT_MIN_2,
BT_GAP_ADV_FAST_INT_MAX_2,
NULL);
err = bt_le_adv_start(adv_param, ad, ARRAY_SIZE(ad), sd,
ARRAY_SIZE(sd));
if (err) {
if (err == -EALREADY) {
printk("Advertising continued\n");
} else {
printk("Advertising failed to start (err %d)\n", err);
}
return;
}
is_adv = true;
printk("Advertising successfully started\n");
}
#if CONFIG_NFC_OOB_PAIRING
static void delayed_advertising_start(struct k_work *work)
{
advertising_start();
}
void nfc_field_detected(void)
{
dk_set_led_on(NFC_LED);
for (int i = 0; i < CONFIG_BT_HIDS_MAX_CLIENT_COUNT; i++) {
if (!conn_mode[i].conn) {
k_work_submit(&adv_work);
break;
}
}
}
void nfc_field_lost(void)
{
dk_set_led_off(NFC_LED);
}
#endif
static void pairing_process(struct k_work *work)
{
int err;
struct pairing_data_mitm pairing_data;
char addr[BT_ADDR_LE_STR_LEN];
err = k_msgq_peek(&mitm_queue, &pairing_data);
if (err) {
return;
}
bt_addr_le_to_str(bt_conn_get_dst(pairing_data.conn),
addr, sizeof(addr));
printk("Passkey for %s: %06u\n", addr, pairing_data.passkey);
printk("Press Button 1 to confirm, Button 2 to reject.\n");
}
static void connected(struct bt_conn *conn, uint8_t err)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err) {
printk("Failed to connect to %s (%u)\n", addr, err);
return;
}
printk("Connected %s\n", addr);
dk_set_led_on(CON_STATUS_LED);
err = bt_hids_connected(&hids_obj, conn);
if (err) {
printk("Failed to notify HID service about connection\n");
return;
}
for (size_t i = 0; i < CONFIG_BT_HIDS_MAX_CLIENT_COUNT; i++) {
if (!conn_mode[i].conn) {
conn_mode[i].conn = conn;
conn_mode[i].in_boot_mode = false;
break;
}
}
#if CONFIG_NFC_OOB_PAIRING == 0
for (size_t i = 0; i < CONFIG_BT_HIDS_MAX_CLIENT_COUNT; i++) {
if (!conn_mode[i].conn) {
advertising_start();
return;
}
}
#endif
is_adv = false;
}
static void disconnected(struct bt_conn *conn, uint8_t reason)
{
int err;
bool is_any_dev_connected = false;
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Disconnected from %s (reason %u)\n", addr, reason);
err = bt_hids_disconnected(&hids_obj, conn);
if (err) {
printk("Failed to notify HID service about disconnection\n");
}
for (size_t i = 0; i < CONFIG_BT_HIDS_MAX_CLIENT_COUNT; i++) {
if (conn_mode[i].conn == conn) {
conn_mode[i].conn = NULL;
} else {
if (conn_mode[i].conn) {
is_any_dev_connected = true;
}
}
}
if (!is_any_dev_connected) {
dk_set_led_off(CON_STATUS_LED);
}
#if CONFIG_NFC_OOB_PAIRING
if (is_adv) {
printk("Advertising stopped after disconnect\n");
bt_le_adv_stop();
is_adv = false;
}
#else
advertising_start();
#endif
}
static void security_changed(struct bt_conn *conn, bt_security_t level,
enum bt_security_err err)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (!err) {
printk("Security changed: %s level %u\n", addr, level);
} else {
printk("Security failed: %s level %u err %d\n", addr, level,
err);
}
}
BT_CONN_CB_DEFINE(conn_callbacks) = {
.connected = connected,
.disconnected = disconnected,
.security_changed = security_changed,
};
static void caps_lock_handler(const struct bt_hids_rep *rep)
{
uint8_t report_val = ((*rep->data) & OUTPUT_REPORT_BIT_MASK_CAPS_LOCK) ?
1 : 0;
dk_set_led(LED_CAPS_LOCK, report_val);
}
static void hids_outp_rep_handler(struct bt_hids_rep *rep,
struct bt_conn *conn,
bool write)
{
char addr[BT_ADDR_LE_STR_LEN];
if (!write) {
printk("Output report read\n");
return;
};
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Output report has been received %s\n", addr);
caps_lock_handler(rep);
}
static void hids_boot_kb_outp_rep_handler(struct bt_hids_rep *rep,
struct bt_conn *conn,
bool write)
{
char addr[BT_ADDR_LE_STR_LEN];
if (!write) {
printk("Output report read\n");
return;
};
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Boot Keyboard Output report has been received %s\n", addr);
caps_lock_handler(rep);
}
static void hids_pm_evt_handler(enum bt_hids_pm_evt evt,
struct bt_conn *conn)
{
char addr[BT_ADDR_LE_STR_LEN];
size_t i;
for (i = 0; i < CONFIG_BT_HIDS_MAX_CLIENT_COUNT; i++) {
if (conn_mode[i].conn == conn) {
break;
}
}
if (i >= CONFIG_BT_HIDS_MAX_CLIENT_COUNT) {
printk("Cannot find connection handle when processing PM");
return;
}
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
switch (evt) {
case BT_HIDS_PM_EVT_BOOT_MODE_ENTERED:
printk("Boot mode entered %s\n", addr);
conn_mode[i].in_boot_mode = true;
break;
case BT_HIDS_PM_EVT_REPORT_MODE_ENTERED:
printk("Report mode entered %s\n", addr);
conn_mode[i].in_boot_mode = false;
break;
default:
break;
}
}
/* Number of pixels by which the cursor is moved when a button is pushed. */
#define MOVEMENT_SPEED 5
/* Number of input reports in this application. */
#define INPUT_REPORT_COUNT 3
/* Length of Mouse Input Report containing button data. */
#define INPUT_REP_BUTTONS_LEN 3
/* Length of Mouse Input Report containing movement data. */
#define INPUT_REP_MOVEMENT_LEN 3
/* Length of Mouse Input Report containing media player data. */
#define INPUT_REP_MEDIA_PLAYER_LEN 1
/* Index of Mouse Input Report containing button data. */
#define INPUT_REP_BUTTONS_INDEX 0
/* Index of Mouse Input Report containing movement data. */
#define INPUT_REP_MOVEMENT_INDEX 1
/* Index of Mouse Input Report containing media player data. */
#define INPUT_REP_MPLAYER_INDEX 2
/* Id of reference to Mouse Input Report containing button data. */
#define INPUT_REP_REF_BUTTONS_ID 2
/* Id of reference to Mouse Input Report containing movement data. */
#define INPUT_REP_REF_MOVEMENT_ID 3
/* Id of reference to Mouse Input Report containing media player data. */
#define INPUT_REP_REF_MPLAYER_ID 4
static void hid_init(void)
{
int err;
struct bt_hids_init_param hids_init_obj = { 0 };
struct bt_hids_inp_rep *hids_inp_rep;
struct bt_hids_outp_feat_rep *hids_outp_rep;
static const uint8_t mouse_movement_mask[DIV_ROUND_UP(INPUT_REP_MOVEMENT_LEN, 8)] = {0};
static const uint8_t report_map[] = {
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x06, // Usage (Keyboard)
0xA1, 0x01, // Collection (Application)
0x85, 0x01, // Report Id 1
0x05, 0x07, // Usage Page (Key Codes)
0x19, 0xe0, // Usage Minimum (224)
0x29, 0xe7, // Usage Maximum (231)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x75, 0x01, // Report Size (1)
0x95, 0x08, // Report Count (8)
0x81, 0x02, // Input (Data, Variable, Absolute)
0x95, 0x01, // Report Count (1)
0x75, 0x08, // Report Size (8)
0x81, 0x01, // Input (Constant) reserved byte(1)
0x95, 0x05, // Report Count (5)
0x75, 0x01, // Report Size (1)
0x05, 0x08, // Usage Page (Page# for LEDs)
0x19, 0x01, // Usage Minimum (1)
0x29, 0x05, // Usage Maximum (5)
0x91, 0x02, // Output (Data, Variable, Absolute), Led report
0x95, 0x01, // Report Count (1)
0x75, 0x03, // Report Size (3)
0x91, 0x01, // Output (Data, Variable, Absolute), Led report padding
0x95, 0x06, // Report Count (6)
0x75, 0x08, // Report Size (8)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x65, // Logical Maximum (101)
0x05, 0x07, // Usage Page (Key codes)
0x19, 0x00, // Usage Minimum (0)
0x29, 0x65, // Usage Maximum (101)
0x81, 0x00, // Input (Data, Array) Key array(6 bytes)
0x09, 0x05, // Usage (Vendor Defined)
0x15, 0x00, // Logical Minimum (0)
0x26, 0xFF, 0x00, // Logical Maximum (255)
0x75, 0x08, // Report Count (2)
0x95, 0x02, // Report Size (8 bit)
0xB1, 0x02, // Feature (Data, Variable, Absolute)
0xC0, // End Collection (Application)
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x02, // Usage (Mouse)
0xA1, 0x01, // Collection (Application)
// Report ID 2: Mouse buttons + scroll/pan
0x85, 0x02, // Report Id 2
0x09, 0x01, // Usage (Pointer)
0xA1, 0x00, // Collection (Physical)
0x95, 0x05, // Report Count (3)
0x75, 0x01, // Report Size (1)
0x05, 0x09, // Usage Page (Buttons)
0x19, 0x01, // Usage Minimum (01)
0x29, 0x05, // Usage Maximum (05)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x81, 0x02, // Input (Data, Variable, Absolute)
0x95, 0x01, // Report Count (1)
0x75, 0x03, // Report Size (3)
0x81, 0x01, // Input (Constant) for padding
0x75, 0x08, // Report Size (8)
0x95, 0x01, // Report Count (1)
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x38, // Usage (Wheel)
0x15, 0x81, // Logical Minimum (-127)
0x25, 0x7F, // Logical Maximum (127)
0x81, 0x06, // Input (Data, Variable, Relative)
0x05, 0x0C, // Usage Page (Consumer)
0x0A, 0x38, 0x02, // Usage (AC Pan)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0xC0, // End Collection (Physical)
// Report ID 3: Mouse motion
0x85, 0x03, // Report Id 3
0x09, 0x01, // Usage (Pointer)
0xA1, 0x00, // Collection (Physical)
0x75, 0x0C, // Report Size (12)
0x95, 0x02, // Report Count (2)
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x30, // Usage (X)
0x09, 0x31, // Usage (Y)
0x16, 0x01, 0xF8, // Logical maximum (2047)
0x26, 0xFF, 0x07, // Logical minimum (-2047)
0x81, 0x06, // Input (Data, Variable, Relative)
0xC0, // End Collection (Physical)
0xC0, // End Collection (Application)
// Report ID 4: Advanced buttons
0x05, 0x0C, // Usage Page (Consumer)
0x09, 0x01, // Usage (Consumer Control)
0xA1, 0x01, // Collection (Application)
0x85, 0x04, // Report Id (4)
0x15, 0x00, // Logical minimum (0)
0x25, 0x01, // Logical maximum (1)
0x75, 0x01, // Report Size (1)
0x95, 0x01, // Report Count (1)
0x09, 0xCD, // Usage (Play/Pause)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x0A, 0x83, 0x01, // Usage (AL Consumer Control Configuration)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x09, 0xB5, // Usage (Scan Next Track)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x09, 0xB6, // Usage (Scan Previous Track)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x09, 0xEA, // Usage (Volume Down)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x09, 0xE9, // Usage (Volume Up)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x0A, 0x25, 0x02, // Usage (AC Forward)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0x0A, 0x24, 0x02, // Usage (AC Back)
0x81, 0x06, // Input (Data,Value,Relative,Bit Field)
0xC0 // End Collection
};
hids_init_obj.rep_map.data = report_map;
hids_init_obj.rep_map.size = sizeof(report_map);
hids_init_obj.info.bcd_hid = BASE_USB_HID_SPEC_VERSION;
hids_init_obj.info.b_country_code = 0x00;
hids_init_obj.info.flags = (BT_HIDS_REMOTE_WAKE |
BT_HIDS_NORMALLY_CONNECTABLE);
//input kb
hids_inp_rep =
&hids_init_obj.inp_rep_group_init.reports[INPUT_REP_KEYS_IDX];
hids_inp_rep->size = INPUT_REPORT_KEYS_MAX_LEN;
hids_inp_rep->id = INPUT_REP_KEYS_REF_ID;
hids_init_obj.inp_rep_group_init.cnt++;
//output kb
hids_outp_rep =
&hids_init_obj.outp_rep_group_init.reports[OUTPUT_REP_KEYS_IDX];
hids_outp_rep->size = OUTPUT_REPORT_MAX_LEN;
hids_outp_rep->id = OUTPUT_REP_KEYS_REF_ID;
hids_outp_rep->handler = hids_outp_rep_handler;
hids_init_obj.outp_rep_group_init.cnt++;
//input mouse button & wheel
hids_inp_rep++;
hids_inp_rep->size = 3;
hids_inp_rep->id = INPUT_REP_REF_BUTTONS_ID;
hids_init_obj.inp_rep_group_init.cnt++;
//input mouse movement
hids_inp_rep++;
hids_inp_rep->size = INPUT_REP_MOVEMENT_LEN;
hids_inp_rep->id = INPUT_REP_REF_MOVEMENT_ID;
hids_inp_rep->rep_mask = mouse_movement_mask;
hids_init_obj.inp_rep_group_init.cnt++;
//input media
hids_inp_rep++;
hids_inp_rep->size = INPUT_REP_MEDIA_PLAYER_LEN;
hids_inp_rep->id = INPUT_REP_REF_MPLAYER_ID;
hids_init_obj.inp_rep_group_init.cnt++;
hids_init_obj.is_mouse = true;
hids_init_obj.is_kb = true;
hids_init_obj.boot_kb_outp_rep_handler = hids_boot_kb_outp_rep_handler;
hids_init_obj.pm_evt_handler = hids_pm_evt_handler;
err = bt_hids_init(&hids_obj, &hids_init_obj);
__ASSERT(err == 0, "HIDS initialization failed\n");
}
static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Passkey for %s: %06u\n", addr, passkey);
}
static void auth_passkey_confirm(struct bt_conn *conn, unsigned int passkey)
{
int err;
struct pairing_data_mitm pairing_data;
pairing_data.conn = bt_conn_ref(conn);
pairing_data.passkey = passkey;
err = k_msgq_put(&mitm_queue, &pairing_data, K_NO_WAIT);
if (err) {
printk("Pairing queue is full. Purge previous data.\n");
}
/* In the case of multiple pairing requests, trigger
* pairing confirmation which needed user interaction only
* once to avoid display information about all devices at
* the same time. Passkey confirmation for next devices will
* be proccess from queue after handling the earlier ones.
*/
if (k_msgq_num_used_get(&mitm_queue) == 1) {
k_work_submit(&pairing_work);
}
}
static void auth_cancel(struct bt_conn *conn)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Pairing cancelled: %s\n", addr);
}
#if CONFIG_NFC_OOB_PAIRING
static void auth_oob_data_request(struct bt_conn *conn,
struct bt_conn_oob_info *info)
{
int err;
struct bt_le_oob *oob_local = app_nfc_oob_data_get();
printk("LESC OOB data requested\n");
if (info->type != BT_CONN_OOB_LE_SC) {
printk("Only LESC pairing supported\n");
return;
}
if (info->lesc.oob_config != BT_CONN_OOB_LOCAL_ONLY) {
printk("LESC OOB config not supported\n");
return;
}
/* Pass only local OOB data. */
err = bt_le_oob_set_sc_data(conn, &oob_local->le_sc_data, NULL);
if (err) {
printk("Error while setting OOB data: %d\n", err);
} else {
printk("Successfully provided LESC OOB data\n");
}
}
#endif
static void pairing_complete(struct bt_conn *conn, bool bonded)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Pairing completed: %s, bonded: %d\n", addr, bonded);
}
static void pairing_failed(struct bt_conn *conn, enum bt_security_err reason)
{
char addr[BT_ADDR_LE_STR_LEN];
struct pairing_data_mitm pairing_data;
if (k_msgq_peek(&mitm_queue, &pairing_data) != 0) {
return;
}
if (pairing_data.conn == conn) {
bt_conn_unref(pairing_data.conn);
k_msgq_get(&mitm_queue, &pairing_data, K_NO_WAIT);
}
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Pairing failed conn: %s, reason %d\n", addr, reason);
}
static struct bt_conn_auth_cb conn_auth_callbacks = {
.passkey_display = auth_passkey_display,
.passkey_confirm = auth_passkey_confirm,
.cancel = auth_cancel,
#if CONFIG_NFC_OOB_PAIRING
.oob_data_request = auth_oob_data_request,
#endif
};
static struct bt_conn_auth_info_cb conn_auth_info_callbacks = {
.pairing_complete = pairing_complete,
.pairing_failed = pairing_failed
};
/** @brief Function process keyboard state and sends it
*
* @param pstate The state to be sent
* @param boot_mode Information if boot mode protocol is selected.
* @param conn Connection handler
*
* @return 0 on success or negative error code.
*/
static int key_report_con_send(const struct keyboard_state *state,
bool boot_mode,
struct bt_conn *conn)
{
int err = 0;
uint8_t data[INPUT_REPORT_KEYS_MAX_LEN];
uint8_t *key_data;
const uint8_t *key_state;
size_t n;
data[0] = state->ctrl_keys_state;
data[1] = 0;
key_data = &data[2];
key_state = state->keys_state;
for (n = 0; n < KEY_PRESS_MAX; ++n) {
*key_data++ = *key_state++;
}
if (boot_mode) {
err = bt_hids_boot_kb_inp_rep_send(&hids_obj, conn, data,
sizeof(data), NULL);
} else {
err = bt_hids_inp_rep_send(&hids_obj, conn,
INPUT_REP_KEYS_IDX, data,
sizeof(data), NULL);
}
return err;
}
/** @brief Function process and send keyboard state to all active connections
*
* Function process global keyboard state and send it to all connected
* clients.
*
* @return 0 on success or negative error code.
*/
static int key_report_send(void)
{
for (size_t i = 0; i < CONFIG_BT_HIDS_MAX_CLIENT_COUNT; i++) {
if (conn_mode[i].conn) {
int err;
err = key_report_con_send(&hid_keyboard_state,
conn_mode[i].in_boot_mode,
conn_mode[i].conn);
if (err) {
printk("Key report send error: %d\n", err);
return err;
}
}
}
return 0;
}
/** @brief Change key code to ctrl code mask
*
* Function changes the key code to the mask in the control code
* field inside the raport.
* Returns 0 if key code is not a control key.
*
* @param key Key code
*
* @return Mask of the control key or 0.
*/
static uint8_t button_ctrl_code(uint8_t key)
{
if (KEY_CTRL_CODE_MIN <= key && key <= KEY_CTRL_CODE_MAX) {
return (uint8_t)(1U << (key - KEY_CTRL_CODE_MIN));
}
return 0;
}
static int hid_kbd_state_key_set(uint8_t key)
{
uint8_t ctrl_mask = button_ctrl_code(key);
if (ctrl_mask) {
hid_keyboard_state.ctrl_keys_state |= ctrl_mask;
return 0;
}
for (size_t i = 0; i < KEY_PRESS_MAX; ++i) {
if (hid_keyboard_state.keys_state[i] == 0) {
hid_keyboard_state.keys_state[i] = key;
return 0;
}
}
/* All slots busy */
return -EBUSY;
}
static int hid_kbd_state_key_clear(uint8_t key)
{
uint8_t ctrl_mask = button_ctrl_code(key);
if (ctrl_mask) {
hid_keyboard_state.ctrl_keys_state &= ~ctrl_mask;
return 0;
}
for (size_t i = 0; i < KEY_PRESS_MAX; ++i) {
if (hid_keyboard_state.keys_state[i] == key) {
hid_keyboard_state.keys_state[i] = 0;
return 0;
}
}
/* Key not found */
return -EINVAL;
}
/** @brief Press a button and send report
*
* @note Functions to manipulate hid state are not reentrant
* @param keys
* @param cnt
*
* @return 0 on success or negative error code.
*/
static int hid_buttons_press(const uint8_t *keys, size_t cnt)
{
while (cnt--) {
int err;
err = hid_kbd_state_key_set(*keys++);
if (err) {
printk("Cannot set selected key.\n");
return err;
}
}
return key_report_send();
}
/** @brief Release the button and send report
*
* @note Functions to manipulate hid state are not reentrant
* @param keys
* @param cnt
*
* @return 0 on success or negative error code.
*/
static int hid_buttons_release(const uint8_t *keys, size_t cnt)
{
while (cnt--) {
int err;
err = hid_kbd_state_key_clear(*keys++);
if (err) {
printk("Cannot clear selected key.\n");
return err;
}
}
return key_report_send();
}
static void button_text_changed(bool down)
{
static const uint8_t *chr = hello_world_str;
if (down) {
hid_buttons_press(chr, 1);
} else {
hid_buttons_release(chr, 1);
if (++chr == (hello_world_str + sizeof(hello_world_str))) {
chr = hello_world_str;
}
}
}
static void button_shift_changed(bool down)
{
if (down) {
hid_buttons_press(shift_key, 1);
} else {
hid_buttons_release(shift_key, 1);
}
}
static void num_comp_reply(bool accept)
{
struct pairing_data_mitm pairing_data;
struct bt_conn *conn;
if (k_msgq_get(&mitm_queue, &pairing_data, K_NO_WAIT) != 0) {
return;
}
conn = pairing_data.conn;
if (accept) {
bt_conn_auth_passkey_confirm(conn);
printk("Numeric Match, conn %p\n", conn);
} else {
bt_conn_auth_cancel(conn);
printk("Numeric Reject, conn %p\n", conn);
}
bt_conn_unref(pairing_data.conn);
if (k_msgq_num_used_get(&mitm_queue)) {
k_work_submit(&pairing_work);
}
}
static void button_changed(uint32_t button_state, uint32_t has_changed)
{
static bool pairing_button_pressed;
uint32_t buttons = button_state & has_changed;
if (k_msgq_num_used_get(&mitm_queue)) {
if (buttons & KEY_PAIRING_ACCEPT) {
pairing_button_pressed = true;
num_comp_reply(true);
return;
}
if (buttons & KEY_PAIRING_REJECT) {
pairing_button_pressed = true;
num_comp_reply(false);
return;
}
}
/* Do not take any action if the pairing button is released. */
if (pairing_button_pressed &&
(has_changed & (KEY_PAIRING_ACCEPT | KEY_PAIRING_REJECT))) {
pairing_button_pressed = false;
return;
}
if (has_changed & KEY_TEXT_MASK) {
button_text_changed((button_state & KEY_TEXT_MASK) != 0);
}
if (has_changed & KEY_SHIFT_MASK) {
button_shift_changed((button_state & KEY_SHIFT_MASK) != 0);
}
#if CONFIG_NFC_OOB_PAIRING
if (has_changed & KEY_ADV_MASK) {
size_t i;
for (i = 0; i < CONFIG_BT_HIDS_MAX_CLIENT_COUNT; i++) {
if (!conn_mode[i].conn) {
advertising_start();
return;
}
}
printk("Cannot start advertising, all connections slots are"
" taken\n");
}
#endif
}
static void configure_gpio(void)
{
int err;
err = dk_buttons_init(button_changed);
if (err) {
printk("Cannot init buttons (err: %d)\n", err);
}
err = dk_leds_init();
if (err) {
printk("Cannot init LEDs (err: %d)\n", err);
}
}
static void bas_notify(void)
{
uint8_t battery_level = bt_bas_get_battery_level();
battery_level--;
if (!battery_level) {
battery_level = 100U;
}
bt_bas_set_battery_level(battery_level);
}
int main(void)
{
int err;
int blink_status = 0;
printk("Starting Bluetooth Peripheral HIDS keyboard example\n");
configure_gpio();
err = bt_conn_auth_cb_register(&conn_auth_callbacks);
if (err) {
printk("Failed to register authorization callbacks.\n");
return 0;
}
err = bt_conn_auth_info_cb_register(&conn_auth_info_callbacks);
if (err) {
printk("Failed to register authorization info callbacks.\n");
return 0;
}
hid_init();
err = bt_enable(NULL);
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return 0;
}
printk("Bluetooth initialized\n");
if (IS_ENABLED(CONFIG_SETTINGS)) {
settings_load();
}
#if CONFIG_NFC_OOB_PAIRING
k_work_init(&adv_work, delayed_advertising_start);
app_nfc_init();
#else
advertising_start();
#endif
k_work_init(&pairing_work, pairing_process);
for (;;) {
if (is_adv) {
dk_set_led(ADV_STATUS_LED, (++blink_status) % 2);
} else {
dk_set_led_off(ADV_STATUS_LED);
}
k_sleep(K_MSEC(ADV_LED_BLINK_INTERVAL));
/* Battery level simulation */
bas_notify();
}
}
