HID over GATT issue

Question

Hello,

I would like some help in understanding how HID over GATT works in the nRF Connect SDK.

I'm digging into the peripheral_hid_mouse example, and I don't understand how to structure the data, for example mouse movement is sent like this:

uint8_t x_buff[2];
uint8_t y_buff[2];
uint8_t buffer[INPUT_REP_MOVEMENT_LEN];

int16_t x = MAX(MIN(x_delta, 0x07ff), -0x07ff);
int16_t y = MAX(MIN(y_delta, 0x07ff), -0x07ff);

/* Convert to little-endian. */
sys_put_le16(x, x_buff);
sys_put_le16(y, y_buff);

/* Encode report. */
BUILD_ASSERT(sizeof(buffer) == 3,
"Only 2 axis, 12-bit each, are supported");

buffer[0] = x_buff[0];
buffer[1] = (y_buff[0] << 4) | (x_buff[1] & 0x0f);
buffer[2] = (y_buff[1] << 4) | (y_buff[0] >> 4);


bt_hids_inp_rep_send(&hids_obj, conn_mode[i].conn,
INPUT_REP_MOVEMENT_INDEX,
buffer, sizeof(buffer), NULL);

My questions:

- Why are mouse movements converted to little endian? In the standard HID mouse example there is no need for this and the mouse works the same

- Why are the X/Y displacement values sent across three bytes? My understanding is that you either send 2 bytes as 8 bits per axis or 4 bytes as 16 bit per axis

After digging a bit I tried the following code with no success:

		// Send movement
		buffer[0] = x_buff[0];
		buffer[1] = (y_buff[0] << 4) | (x_buff[1] & 0x0f);
		buffer[2] = (y_buff[1] << 4) | (y_buff[0] >> 4);

		bt_hids_inp_rep_send(&hids_obj, conn_mode.conn,
							 INPUT_REP_MOVEMENT_INDEX,
							 buffer, sizeof(buffer), NULL);

		// Send a right click
		buffer[0] = 0b10000000;
		buffer[1] = 0x0;
		buffer[2] = 0x0;

		bt_hids_inp_rep_send(&hids_obj, conn_mode.conn,
							 INPUT_REP_BUTTONS_INDEX,
							 buffer, sizeof(buffer), NULL);

The general question here is, how do I properly send both buttons and movement data with bt_hids_inp_rep_send()?

Thanks

StefanoN · Accepted Answer

Those resources were exactly what I need, now I understand the report descriptor much better. 
 I tried to simplify everything by just sending the mouse buttons byte, so on the sending side I use this descriptor: 
 static void hid_init(void)
{
	int err;
	struct bt_hids_init_param hids_init_param = {0};
	struct bt_hids_inp_rep *hids_inp_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, 0x02, /* Usage (Mouse) */
 0xA1, 0x01, /* Collection (Application) */

/* Report ID 1: Mouse buttons + scroll wheel */
 0x85, 0x01, /* Report Id 1 */

// Button data - 1 byte
 0x05, 0x09, // Usage Page (Buttons)
 0x09, 0x01, // Usage (Pointer)
 0xA1, 0x00, // Collection (Physical)
 0x95, 0x05, // Report Count (5) - 5 values
 0x75, 0x01, // Report Size (1) - 1 bit each
 0x19, 0x01, // Usage Minimum (1)
 0x29, 0x05, // Usage Maximum (5)
 0x15, 0x00, // Logical Minimum (0)
 0x25, 0x01, // Logical Maximum (1)
 0x81, 0x02, // Input (Data, Variable, Absolute) - HID spec Sec. 6.2.2.5

// Button data padding to complete the byte
 0x95, 0x01, // Report Count (1) - 1 value
 0x75, 0x03, // Report Size (3) - 3 bits long
 0x81, 0x01, // Input (Constant) - for padding, can be ignored

0xC0, // End Collection (Physical)
 0xC0, // End Collection (Application)

hids_init_param.rep_map.data = report_map;
	hids_init_param.rep_map.size = sizeof(report_map);

hids_init_param.info.bcd_hid = BASE_USB_HID_SPEC_VERSION;
	hids_init_param.info.b_country_code = 0x00;
	hids_init_param.info.flags = (BT_HIDS_REMOTE_WAKE |
 BT_HIDS_NORMALLY_CONNECTABLE);

hids_inp_rep = &hids_init_param.inp_rep_group_init.reports[0];
	hids_inp_rep->size = INPUT_REP_BUTTONS_LEN;
	hids_inp_rep->id = INPUT_REP_REF_BUTTONS_ID;
	hids_init_param.inp_rep_group_init.cnt++;

hids_init_param.is_mouse = true;
	hids_init_param.pm_evt_handler = hids_pm_evt_handler;

err = bt_hids_init(&hids_obj, &hids_init_param);
	__ASSERT(err == 0, "HIDS initialization failed
");
} 
 
 Than I send the byte like this: 
 uint8_t buttons[] = {0b00000010};

while (1)
{
	k_sleep(K_SECONDS(1));
	
	bt_hids_inp_rep_send(&hids_obj, conn_mode.conn,
 1,
 buttons, sizeof(buttons), NULL);
} 
 This byte doesn't get received by the receiver, which is running the central_hids sample and receiving data with the hogp_notify_cb(), to which I only added a print of the data to a COM port, so that I read the received data while having the Jlink attached to the sender, see below: 
 static uint8_t hogp_notify_cb(struct bt_hogp *hogp,
 struct bt_hogp_rep_info *rep,
 uint8_t err,

const uint8_t *data)
{

gpio_pin_toggle_dt(&led_batt_low);

uint8_t size = bt_hogp_rep_size(rep);
	uint8_t i;

if (!data)
	{
 return BT_GATT_ITER_STOP;
	}

// Send to COM port
	char binaryStr[9] = {'\0'}; // 8 bits + 1 null terminator
	for (i = 0; i < size; ++i)
	{
 byteToBinaryString(data[i], binaryStr);
 uart_fifo_fill(dev, binaryStr, sizeof(binaryStr));
 uart_fifo_fill(dev, "
", 2);
	}
	uart_fifo_fill(dev, "========
", 10);

return BT_GATT_ITER_CONTINUE;
} 
 I don't understand why this is not working, the only way I found to make it work is to un-comment the following piece of code from the hid_init() function and send exactly three bytes of data instead of 1, WITHOUT changing the report descriptor. 
 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_param.inp_rep_group_init.cnt++; 
 The only way I can explain this is that, from the wiki page you linked it says: "For example, a basic mouse defines a 3 byte Report...", which to my USB-new eye it seems to be enforced by this line in the hid_init() function: 
 hids_init_param.is_mouse = true; 
 Meaning that if I want a HID mouse I need at least 3 bytes, wether or not they are specified in the report descriptor. 
 Seems a bit silly, what if my mouse only has buttons? This can't be right. 
 Any ideas? 
 Thanks

StefanoN · Answer

Solved. 
 I had forgotten to modify INPUT_REP_BUTTONS_LEN, which was still set to 3, hence the code working only when 3 bytes where sent. 
 After changing it to the correct value, 1 in this case, I was able to send a single byte of data successfully. 
 Thanks for the help!

HID over GATT issue

Top Replies