BLE hid Keyboard key press/release [Clarifications needed]

RE: BLE hid Keyboard key press/release [Clarifications needed]

Kenneth — Thu, 04 Jan 2024 12:40:00 GMT

Hello,

For new development you should be using the nRF Connect SDK that have a very different implementation. Something like this example show:
https://github.com/martelmy/NCS_examples/tree/main/peripherals/long_press_button

To get familiar with nRF Connect SDK: https://academy.nordicsemi.com/

In any case, this post if 4 years old, so I am closing it.

Kenneth

RE: BLE hid Keyboard key press/release [Clarifications needed]

bharatb4196 — Wed, 03 Jan 2024 15:07:03 GMT

Has anything been followed up on this, with the press and hold effect as I am in the same situation studying the example code, but finding it difficult to understand

RE: BLE hid Keyboard key press/release [Clarifications needed]

Kenneth — Wed, 12 Feb 2020 13:01:38 GMT

I am not sure what key code 0x04 is, however it would be interesting to get a sniffer log of the on-air communication here:
https://infocenter.nordicsemi.com/topic/ug_sniffer_ble/UG/sniffer_ble/intro.html
https://www.nordicsemi.com/Software-and-tools/Development-Tools/nRF-Sniffer-for-Bluetooth-LE/Download#infotabs

Best regards,
Kenneth

RE: BLE hid Keyboard key press/release [Clarifications needed]

abdelali — Wed, 12 Feb 2020 10:11:44 GMT

Hi,

thank you,

Yes i did. and here is the button handler i use to test it :

static void button_event_handler(uint8_t pin_no, uint8_t button_action)
{
  ret_code_t err_code;

  uint8_t  data[INPUT_REPORT_KEYS_MAX_LEN];

  switch(pin_no){

   case BUTTON_1:

      if(button_action == APP_BUTTON_PUSH) {
      
            memset(data, 0, sizeof(data));
            data[2] = 0x04;

            err_code = ble_hids_inp_rep_send(&m_hids,
                                             INPUT_REPORT_KEYS_INDEX,
                                             INPUT_REPORT_KEYS_MAX_LEN,
                                             data,
                                             m_conn_handle);

            if(err_code != NRF_SUCCESS) NRF_LOG_INFO("err : %x; \n",err_code); 

            NRF_LOG_INFO("button1 PUSHED");      
      
      }

     else if(button_action == APP_BUTTON_RELEASE) { 
     
           memset(data, 0, sizeof(data));    
           err_code = ble_hids_inp_rep_send(&m_hids,
                                             INPUT_REPORT_KEYS_INDEX,
                                             INPUT_REPORT_KEYS_MAX_LEN,
                                             data,
                                             m_conn_handle);

           if(err_code != NRF_SUCCESS) NRF_LOG_INFO("err : %x; \n",err_code); 

           NRF_LOG_INFO("button1 RELEASED");    

      }


     break;

 }

}

But even that, the same output!

[*] tested on an Android device :

Best Regards,

Abdelali

RE: BLE hid Keyboard key press/release [Clarifications needed]

Kenneth — Wed, 12 Feb 2020 09:25:10 GMT

Have you tried to call ble_hids_inp_rep_send() when pressing, and then ble_hids_inp_rep_send() when releasing directly?

Just make sure that the data buffer is 8 bytes, where the first 2 bytes (data[0] and data[1]) are key modifier (e.g. shift, num lock etc), so the actual key that is pressed is 3rd byte (data[2]) in the array. The remaining data bytes (data[3]-data[7]) can be 0.

Kenneth

RE: BLE hid Keyboard key press/release [Clarifications needed]

abdelali — Wed, 12 Feb 2020 07:44:29 GMT

Hi,

I have experimented with the send_key_scan_press_release() function, just sending a one key, and not even using the buffering feature.

For the press i just fill the data array with the scan code (1 key_pattern). and for the release i clear the data array.

The BLE HID output seems to output a KEY PRESS followed by KEY RELEASE, a hold on the button will keep outputting a PRESS followed with a RELEASE.

I even tried to only send a PRESS (by not clearing the data array); but that also sends a RELEASE after.

I'm not quite sure how the RELEASE event is sent right after the PRESS, even without clearing the data[] variable!

I Really appreciate any hints/guidance/documentation on how to implement it.

Best Regards,

Abdelali

static uint32_t send_key_scan_press_release(ble_hids_t * p_hids,
                                            uint8_t    * p_key_pattern,
                                            uint16_t     pattern_len,
                                            uint8_t      action )
{
    ret_code_t err_code;
    uint16_t data_len;
    uint8_t  data[INPUT_REPORT_KEYS_MAX_LEN];

    // HID Report Descriptor enumerates an array of size 6, the pattern hence shall not be any
    // longer than this.
    STATIC_ASSERT((INPUT_REPORT_KEYS_MAX_LEN - 2) == 6);

    ASSERT(pattern_len <= (INPUT_REPORT_KEYS_MAX_LEN - 2));

    data_len = pattern_len;   // 1

  if(action == 1){ // press

        // Reset the data buffer.
        memset(data, 0, sizeof(data));
        // Copy the scan code.
        memcpy(data + SCAN_CODE_POS , p_key_pattern , data_len );

        if (modifier_status)
        {
           data[MODIFIER_KEY_POS] |= ble_hid_config[11];//
        }

    }

  else { // release 
  
          // Reset the data buffer.
          memset(data, 0, sizeof(data));
    }

        if (!m_in_boot_mode)
        {
            err_code = ble_hids_inp_rep_send(p_hids,
                                             INPUT_REPORT_KEYS_INDEX,
                                             INPUT_REPORT_KEYS_MAX_LEN,
                                             data,
                                             m_conn_handle);
        }
        else
        {
            err_code = ble_hids_boot_kb_inp_rep_send(p_hids,
                                                     INPUT_REPORT_KEYS_MAX_LEN,
                                                     data,
                                                     m_conn_handle);
        }

        if (err_code != NRF_SUCCESS)
        {

         APP_ERROR_CHECK(err_code);

         }

    return err_code;
}

RE: BLE hid Keyboard key press/release [Clarifications needed]

Kenneth — Tue, 11 Feb 2020 08:04:53 GMT

It's the same as the HID keyboard example yes, I only shared the description here.

RE: BLE hid Keyboard key press/release [Clarifications needed]

abdelali — Mon, 10 Feb 2020 15:47:34 GMT

Hi,

Ok, but i see the code snippet in your response looks like corrupted, i see just the function declaration ?! is it the same one in the ble hid keyboard example in the sdk ?

Best regards,

RE: BLE hid Keyboard key press/release [Clarifications needed]

Kenneth — Mon, 10 Feb 2020 09:36:09 GMT

Feel free to modify this as you see fit, also check out the api description:

/**@brief   Function for transmitting a key scan Press & Release Notification.
 *
 * @warning This handler is an example only. You need to analyze how you wish to send the key
 *          release.
 *
 * @param[in]  p_instance     Identifies the service for which Key Notifications are requested.
 * @param[in]  p_key_pattern  Pointer to key pattern.
 * @param[in]  pattern_len    Length of key pattern. 0 < pattern_len < 7.
 * @param[in]  pattern_offset Offset applied to Key Pattern for transmission.
 * @param[out] actual_len     Provides actual length of Key Pattern transmitted, making buffering of
 *                            rest possible if needed.
 * @return     NRF_SUCCESS on success, NRF_ERROR_RESOURCES in case transmission could not be
 *             completed due to lack of transmission buffer or other error codes indicating reason
 *             for failure.
 *
 * @note       In case of NRF_ERROR_RESOURCES, remaining pattern that could not be transmitted
 *             can be enqueued \ref buffer_enqueue function.
 *             In case a pattern of 'cofFEe' is the p_key_pattern, with pattern_len as 6 and
 *             pattern_offset as 0, the notifications as observed on the peer side would be
 *             1>    'c', 'o', 'f', 'F', 'E', 'e'
 *             2>    -  , 'o', 'f', 'F', 'E', 'e'
 *             3>    -  ,   -, 'f', 'F', 'E', 'e'
 *             4>    -  ,   -,   -, 'F', 'E', 'e'
 *             5>    -  ,   -,   -,   -, 'E', 'e'
 *             6>    -  ,   -,   -,   -,   -, 'e'
 *             7>    -  ,   -,   -,   -,   -,  -
 *             Here, '-' refers to release, 'c' refers to the key character being transmitted.
 *             Therefore 7 notifications will be sent.
 *             In case an offset of 4 was provided, the pattern notifications sent will be from 5-7
 *             will be transmitted.
 */
static uint32_t send_key_scan_press_release(ble_hids_t * p_hids,
                                            uint8_t    * p_key_pattern,
                                            uint16_t     pattern_len,
                                            uint16_t     pattern_offset,
                                            uint16_t   * p_actual_len)

If you wait more than 500ms between key press and release, then at least for Windows it will treat this as a key repeat automatically until release it received.