Hello!
Hardware: nrf52840
IDE: Segger Embedded Studio
SDK: nrf5 SDK 17.0.2
I've been having issues with receiving USB HID IN reports on Android. If I send at an interval of around 1 ms (which is within USB's interrupt spec) from the device to an Android device, I will about only half of the packets - usually every other packet is received. The same device works normally on other OSes (macOS, Windows). And similar code running on a different microcontroller (Teensy) works normally on Android.
For reproducibility, I based my code off of the generic mouse example in /example/peripheral/usbd_hid_generic/ to set an IN report every 1 ms with a counter:
(also tested 900 us - 2000 us and the results are the same)
/**
* Copyright (c) 2017 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "nrf.h"
#include "app_util_platform.h"
#include "nrf_drv_usbd.h"
#include "nrf_drv_clock.h"
#include "nrf_gpio.h"
#include "nrf_drv_power.h"
#include "app_timer.h"
#include "app_usbd.h"
#include "app_usbd_core.h"
#include "app_usbd_hid_generic.h"
#include "app_usbd_hid_mouse.h"
#include "app_usbd_hid_kbd.h"
#include "app_error.h"
#include "bsp.h"
#include "bsp_cli.h"
#include "nrf_cli.h"
#include "nrf_cli_uart.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#define APP_TIMER_TICKS_US(US) \
((uint32_t)ROUNDED_DIV( \
(US) * (uint64_t)APP_TIMER_CLOCK_FREQ, \
1000000 * (APP_TIMER_CONFIG_RTC_FREQUENCY + 1)))
#if NRF_CLI_ENABLED
/**
* @brief CLI interface over UART
*/
NRF_CLI_UART_DEF(m_cli_uart_transport, 0, 64, 16);
NRF_CLI_DEF(m_cli_uart,
"uart_cli:~$ ",
&m_cli_uart_transport.transport,
'\r',
4);
#endif
/**
* @brief Enable USB power detection
*/
#ifndef USBD_POWER_DETECTION
#define USBD_POWER_DETECTION true
#endif
/**
* @brief HID generic class interface number.
* */
#define HID_GENERIC_INTERFACE 0
/**
* @brief HID generic class endpoint number.
* */
#define HID_GENERIC_EPIN NRF_DRV_USBD_EPIN1
/**
* @brief Number of reports defined in report descriptor.
*/
#define REPORT_IN_QUEUE_SIZE 1
/**
* @brief Size of maximum output report. HID generic class will reserve
* this buffer size + 1 memory space.
*
* Maximum value of this define is 63 bytes. Library automatically adds
* one byte for report ID. This means that output report size is limited
* to 64 bytes.
*/
#define REPORT_OUT_MAXSIZE 0
/**
* @brief Feature report maximum size. HID generic class will reserve
* this buffer size + 1 memory space.
*/
#define REPORT_FEATURE_MAXSIZE 31
/**
* @brief HID generic class endpoints count.
* */
#define HID_GENERIC_EP_COUNT 1
/**
* @brief List of HID generic class endpoints.
* */
#define ENDPOINT_LIST() \
( \
HID_GENERIC_EPIN \
)
// Teensyduino 1.53 Compatible
#define USBD_GENERIC_REPORT_DESCRIPTOR { \
0x06, 0xAB, 0xFF, /* 0xFFAB */ \
0x0A, 0x00, 0x02, /* 0x0200 */ \
0xA1, 0x01, /* Collection 0x01 */ \
0x75, 0x08, /* report size = 8 bits */ \
0x15, 0x00, /* logical minimum = 0 */ \
0x26, 0xFF, 0x00, /* logical maximum = 255 */ \
0x95, 64, /* report count */ \
0x09, 0x01, /* usage */ \
0x81, 0x02, /* Input (array) */ \
0x95, 64, /* report count */ \
0x09, 0x02, /* usage */ \
0x91, 0x02, /* Output (array) */ \
0xC0 /* end collection */ \
}
/**
* @brief User event handler.
* */
static void hid_user_ev_handler(app_usbd_class_inst_t const * p_inst,
app_usbd_hid_user_event_t event);
/**
* @brief Reuse HID mouse report descriptor for HID generic class
*/
APP_USBD_HID_GENERIC_SUBCLASS_REPORT_DESC(desc, USBD_GENERIC_REPORT_DESCRIPTOR);
static const app_usbd_hid_subclass_desc_t * reps[] = {&desc};
/*lint -save -e26 -e64 -e123 -e505 -e651*/
/**
* @brief Global HID generic instance
*/
APP_USBD_HID_GENERIC_GLOBAL_DEF(m_app_hid_generic,
HID_GENERIC_INTERFACE,
hid_user_ev_handler,
ENDPOINT_LIST(),
reps,
REPORT_IN_QUEUE_SIZE,
REPORT_OUT_MAXSIZE,
REPORT_FEATURE_MAXSIZE,
APP_USBD_HID_SUBCLASS_NONE, // MUST NOT BE BOOT FOR ANDROID TO ENUMERATE!
APP_USBD_HID_PROTO_GENERIC
);
/*lint -restore*/
/**
* @brief Mark the ongoing transmission
*
* Marks that the report buffer is busy and cannot be used until transmission finishes
* or invalidates (by USB reset or suspend event).
*/
static bool m_report_pending;
/**
* @brief Timer to repeat mouse move
*/
APP_TIMER_DEF(m_mouse_move_timer);
uint8_t count = 0;
/**
* @brief Internal function that process mouse state
*
* This function checks current mouse state and tries to send
* new report if required.
* If report sending was successful it clears accumulated positions
* and mark last button state that was transfered.
*/
static void hid_generic_mouse_process_state(void)
{
if (m_report_pending)
return;
ret_code_t ret;
static uint8_t report[64] = {0};
/* We have some status changed that we need to transfer */
report[0] = 0xAB;
report[1] = count;
/* Start the transfer */
ret = app_usbd_hid_generic_in_report_set(
&m_app_hid_generic,
report,
sizeof(report));
if (ret == NRF_SUCCESS)
{
printf("In report set SUCCESS\n");
m_report_pending = true;
}
else
{
printf("In report set ERROR: %d\n", ret);
}
}
/**
* @brief Class specific event handler.
*
* @param p_inst Class instance.
* @param event Class specific event.
* */
static void hid_user_ev_handler(app_usbd_class_inst_t const * p_inst,
app_usbd_hid_user_event_t event)
{
switch (event)
{
case APP_USBD_HID_USER_EVT_OUT_REPORT_READY:
{
/* No output report defined for this example.*/
ASSERT(0);
break;
}
case APP_USBD_HID_USER_EVT_IN_REPORT_DONE:
{
printf("In report done\n");
//m_report_pending = false;
//hid_generic_mouse_process_state();
break;
}
case APP_USBD_HID_USER_EVT_SET_BOOT_PROTO:
{
UNUSED_RETURN_VALUE(hid_generic_clear_buffer(p_inst));
NRF_LOG_INFO("SET_BOOT_PROTO");
break;
}
case APP_USBD_HID_USER_EVT_SET_REPORT_PROTO:
{
UNUSED_RETURN_VALUE(hid_generic_clear_buffer(p_inst));
NRF_LOG_INFO("SET_REPORT_PROTO");
break;
}
default:
break;
}
}
/**
* @brief USBD library specific event handler.
*
* @param event USBD library event.
* */
static void usbd_user_ev_handler(app_usbd_event_type_t event)
{
switch (event)
{
case APP_USBD_EVT_DRV_SOF:
break;
case APP_USBD_EVT_DRV_RESET:
m_report_pending = false;
break;
case APP_USBD_EVT_DRV_SUSPEND:
m_report_pending = false;
app_usbd_suspend_req(); // Allow the library to put the peripheral into sleep mode
break;
case APP_USBD_EVT_DRV_RESUME:
m_report_pending = false;
break;
case APP_USBD_EVT_STARTED:
m_report_pending = false;
break;
case APP_USBD_EVT_STOPPED:
app_usbd_disable();
break;
case APP_USBD_EVT_POWER_DETECTED:
NRF_LOG_INFO("USB power detected");
if (!nrf_drv_usbd_is_enabled())
{
app_usbd_enable();
}
break;
case APP_USBD_EVT_POWER_REMOVED:
NRF_LOG_INFO("USB power removed");
app_usbd_stop();
break;
case APP_USBD_EVT_POWER_READY:
NRF_LOG_INFO("USB ready");
app_usbd_start();
break;
default:
break;
}
}
static void mouse_move_timer_handler(void * p_context)
{
ret_code_t ret;
static uint8_t report[64] = {0};
report[0] = 0xAB;
report[1] = count;
ret = app_usbd_hid_generic_in_report_set(
&m_app_hid_generic,
report,
sizeof(report));
if (ret == NRF_SUCCESS)
{
printf("In report set SUCCESS\n");
}
else
{
printf("In report set ERROR: %d\n", ret);
}
count++;
}
static ret_code_t idle_handle(app_usbd_class_inst_t const * p_inst, uint8_t report_id)
{
switch (report_id)
{
case 0:
{
uint8_t report[] = {0xBE, 0xEF};
return app_usbd_hid_generic_idle_report_set(
&m_app_hid_generic,
report,
sizeof(report));
}
default:
return NRF_ERROR_NOT_SUPPORTED;
}
}
int main(void)
{
ret_code_t ret;
static const app_usbd_config_t usbd_config = {
.ev_state_proc = usbd_user_ev_handler
};
ret = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(ret);
ret = nrf_drv_clock_init();
APP_ERROR_CHECK(ret);
nrf_drv_clock_lfclk_request(NULL);
while(!nrf_drv_clock_lfclk_is_running())
{
/* Just waiting */
}
ret = app_timer_init();
APP_ERROR_CHECK(ret);
ret = app_timer_create(&m_mouse_move_timer, APP_TIMER_MODE_REPEATED, mouse_move_timer_handler);
APP_ERROR_CHECK(ret);
ret = app_timer_start(m_mouse_move_timer, APP_TIMER_TICKS_US(1000), NULL);
APP_ERROR_CHECK(ret);
printf("Hello USB!\n");
ret = app_usbd_init(&usbd_config);
APP_ERROR_CHECK(ret);
NRF_LOG_INFO("USBD HID generic example started.");
app_usbd_class_inst_t const * class_inst_generic;
class_inst_generic = app_usbd_hid_generic_class_inst_get(&m_app_hid_generic);
ret = hid_generic_idle_handler_set(class_inst_generic, idle_handle);
APP_ERROR_CHECK(ret);
ret = app_usbd_class_append(class_inst_generic);
APP_ERROR_CHECK(ret);
if (USBD_POWER_DETECTION)
{
ret = app_usbd_power_events_enable();
APP_ERROR_CHECK(ret);
}
else
{
NRF_LOG_INFO("No USB power detection enabled\r\nStarting USB now");
app_usbd_enable();
app_usbd_start();
}
while (true)
{
CRITICAL_REGION_ENTER();
while (app_usbd_event_queue_process())
{
/* Nothing to do */
}
CRITICAL_REGION_EXIT();
/* Sleep CPU only if there was no interrupt since last loop processing */
__WFE();
__SEV();
__WFE();
}
}
I made a simple app to poll the device as fast as it can. It uses Android's standard UsbRequest to do interrupt transfers, although the issue also occurs with bulkTransfer(). The app can be downloaded here for sideloading: 4456.hidTestApp.apk
Here's a screenshot showing what happens when a Teensy attached (the expected output). The first value in each row is the time in milliseconds since app start. The counter value is the value received from USB HID. Here it is as expected, received every 1 ms, with the counter incrementing by 1.
Now here's a screenshot when the nrf52840 is connected. Only about every other packet is received. The average interval is now over 2 ms. I've tested this on other Android devices as well with the same results.
Any help or pointers appreciated! Thank you!
