Hi,All:
When i use SDK16 ble_app_hids_mouse example, the computer warns: driver error.But when i use the same dongle with another mouse,it is no problem.It seems the problem coms from the example?
The same dongle and with another mouse is OK:
The computer OS win10 x64,At the beginning,There is no problem,but when later and later........like this ,I have spent two dongles.
Hi,
Could you translate exactly what the error or warning that you're getting is? Are you getting this with both dongles? What kind of dongles are you using?
regards
Jared
Hi,Jared:
I guess that there would be no problem with the dongle,Because when i change to another mouse with the same dongle,It will be OK.In fact,I have two dongles. I have used them separately with the SDK16 BLE_APP_HIDS_MOUSE example.In both way,error occurs.On the other hand,I used another mouse,there would be no errors. Oh,one dongle is made of CSR chip,and another of Broadcom chip.
enen,the warning is as the picture above:
when nrf5_Mouse,the warning means "PC diver error" next line below the "nRF5_Mouse" in the picture.
and the line below the MM831 (mouse),it means "has connected"
here,there is details,when connect with nRF5_Mouse,First it warns "connect", then "paired",then "driver error ".
Does your PC has inbuilt BLE support? Would it work on your PC if you omit the dongle? ble_app_hids_mouse use bonding, which means that old bonding information might be used on either side. Could you reprogram the nRF with the example and delete any bonding information on the PC before you proceed to connect again.
Hi，Jared：
Yes,I have tried on a desktop with BLE dongle and on HP laptop with inbuilt BLE separatly.But I received the same result. I would send you my code. In the code,if it do not call the Sensor_init() and the SensorMovement() function,it seems no rproblem.
/**
* Copyright (c) 2014 - 2019, 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.
*
*/
/** @file
*
* @defgroup ble_sdk_app_hids_mouse_main main.c
* @{
* @ingroup ble_sdk_app_hids_mouse
* @brief HID Mouse Sample Application main file.
*
* This file contains is the source code for a sample application using the HID, Battery and Device
* Information Service for implementing a simple mouse functionality. This application uses the
* @ref app_scheduler.
*
* Also it would accept pairing requests from any peer device. This implementation of the
* application will not know whether a connected central is a known device or not.
*/
#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "nrf_sdm.h"
#include "app_error.h"
#include "ble.h"
#include "ble_err.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_hids.h"
#include "ble_bas.h"
#include "ble_dis.h"
#include "ble_conn_params.h"
#include "sensorsim.h"
#include "bsp_btn_ble.h"
#include "app_scheduler.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "peer_manager.h"
#include "ble_advertising.h"
#include "fds.h"
#include "ble_conn_state.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_pwr_mgmt.h"
#include "peer_manager_handler.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
//#include "nrfx_timer.h"
#include "nrf_drv_timer.h"
#include "nrf_gpio.h"
#include "nrf_drv_qdec.h"
#define DEVICE_NAME "nRF5_Mouse" /**< Name of device. Will be included in the advertising data. */
#define MANUFACTURER_NAME "NordicSemiconductor" /**< Manufacturer. Will be passed to Device Information Service. */
#define APP_BLE_OBSERVER_PRIO 3 /**< Application's BLE observer priority. You shouldn't need to modify this value. */
#define APP_BLE_CONN_CFG_TAG 1 /**< A tag identifying the SoftDevice BLE configuration. */
#define BATTERY_LEVEL_MEAS_INTERVAL APP_TIMER_TICKS(2000) /**< Battery level measurement interval (ticks). */
#define MIN_BATTERY_LEVEL 81 /**< Minimum simulated battery level. */
#define MAX_BATTERY_LEVEL 100 /**< Maximum simulated battery level. */
#define BATTERY_LEVEL_INCREMENT 1 /**< Increment between each simulated battery level measurement. */
#define PNP_ID_VENDOR_ID_SOURCE 0x02 /**< Vendor ID Source. */
#define PNP_ID_VENDOR_ID 0x1915 /**< Vendor ID. */
#define PNP_ID_PRODUCT_ID 0xEEEE /**< Product ID. */
#define PNP_ID_PRODUCT_VERSION 0x0001 /**< Product Version. */
/*lint -emacro(524, MIN_CONN_INTERVAL) // Loss of precision */
#define MIN_CONN_INTERVAL MSEC_TO_UNITS(7.5, UNIT_1_25_MS) /**< Minimum connection interval (7.5 ms). */
#define MAX_CONN_INTERVAL MSEC_TO_UNITS(15, UNIT_1_25_MS) /**< Maximum connection interval (15 ms). */
#define SLAVE_LATENCY 20 /**< Slave latency. */
#define CONN_SUP_TIMEOUT MSEC_TO_UNITS(3000, UNIT_10_MS) /**< Connection supervisory timeout (3000 ms). */
#define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(30000) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
#define MAX_CONN_PARAM_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */
#define SEC_PARAM_BOND 1 /**< Perform bonding. */
#define SEC_PARAM_MITM 0 /**< Man In The Middle protection not required. */
#define SEC_PARAM_LESC 0 /**< LE Secure Connections not enabled. */
#define SEC_PARAM_KEYPRESS 0 /**< Keypress notifications not enabled. */
#define SEC_PARAM_IO_CAPABILITIES BLE_GAP_IO_CAPS_NONE /**< No I/O capabilities. */
#define SEC_PARAM_OOB 0 /**< Out Of Band data not available. */
#define SEC_PARAM_MIN_KEY_SIZE 7 /**< Minimum encryption key size. */
#define SEC_PARAM_MAX_KEY_SIZE 16 /**< Maximum encryption key size. */
#define SWIFT_PAIR_SUPPORTED 1 /**< Swift Pair feature is supported. */
#if SWIFT_PAIR_SUPPORTED == 1
#define MICROSOFT_VENDOR_ID 0x0006 /**< Microsoft Vendor ID.*/
#define MICROSOFT_BEACON_ID 0x03 /**< Microsoft Beacon ID, used to indicate that Swift Pair feature is supported. */
#define MICROSOFT_BEACON_SUB_SCENARIO 0x00 /**< Microsoft Beacon Sub Scenario, used to indicate how the peripheral will pair using Swift Pair feature. */
#define RESERVED_RSSI_BYTE 0x80 /**< Reserved RSSI byte, used to maintain forwards and backwards compatibility. */
#endif
#define MOVEMENT_SPEED 5 /**< Number of pixels by which the cursor is moved each time a button is pushed. */
#define INPUT_REPORT_COUNT 3 /**< Number of input reports in this application. */
#define INPUT_REP_BUTTONS_LEN 3 /**< Length of Mouse Input Report containing button data. */
#define INPUT_REP_MOVEMENT_LEN 3 /**< Length of Mouse Input Report containing movement data. */
#define INPUT_REP_MEDIA_PLAYER_LEN 1 /**< Length of Mouse Input Report containing media player data. */
#define INPUT_REP_BUTTONS_INDEX 0 /**< Index of Mouse Input Report containing button data. */
#define INPUT_REP_MOVEMENT_INDEX 1 /**< Index of Mouse Input Report containing movement data. */
#define INPUT_REP_MPLAYER_INDEX 2 /**< Index of Mouse Input Report containing media player data. */
#define INPUT_REP_REF_BUTTONS_ID 1 /**< Id of reference to Mouse Input Report containing button data. */
#define INPUT_REP_REF_MOVEMENT_ID 2 /**< Id of reference to Mouse Input Report containing movement data. */
#define INPUT_REP_REF_MPLAYER_ID 3 /**< Id of reference to Mouse Input Report containing media player data. */
#define BASE_USB_HID_SPEC_VERSION 0x0101 /**< Version number of base USB HID Specification implemented by this application. */
#define SCHED_MAX_EVENT_DATA_SIZE APP_TIMER_SCHED_EVENT_DATA_SIZE /**< Maximum size of scheduler events. */
#ifdef SVCALL_AS_NORMAL_FUNCTION
#define SCHED_QUEUE_SIZE 20 /**< Maximum number of events in the scheduler queue. More is needed in case of Serialization. */
#else
#define SCHED_QUEUE_SIZE 10 /**< Maximum number of events in the scheduler queue. */
#endif
#define DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
#define APP_ADV_FAST_INTERVAL 0x0028 /**< Fast advertising interval (in units of 0.625 ms. This value corresponds to 25 ms.). */
#define APP_ADV_SLOW_INTERVAL 0x00A0 /**< Slow advertising interval (in units of 0.625 ms. This value corresponds to 100 ms.). */
#define APP_ADV_FAST_DURATION 3000 /**< The advertising duration of fast advertising in units of 10 milliseconds. */
#define APP_ADV_SLOW_DURATION 18000 /**< The advertising duration of slow advertising in units of 10 milliseconds. */
#define LR 26
#define LG 27
#define LB 04
#define RR 06
#define RG 05
#define RB 07
#define TR 39
#define TG 8
#define TB 40
#define EN 12
#define motion 24
#define cs 21
#define ddata 22
#define clk 32
#define power 11
uint8_t vPwmLR;
uint8_t vPwmLG;
uint8_t vPwmLB;
uint8_t vPwmRR;
uint8_t vPwmRG;
uint8_t vPwmRB;
uint8_t vPwmTR;
uint8_t vPwmTG;
uint8_t vPwmTB;
uint8_t vPwm;
uint8_t vTime1ms;
uint8_t vTime10ms;
uint8_t vTime100ms;
uint8_t vTimePwmChange;
uint8_t vColorMode;
static volatile bool m_report_ready_flag = false;
static volatile bool m_first_report_flag = true;
static volatile uint32_t m_accdblread;
static volatile int32_t m_accread;
union
{
uint32_t byte;
struct{
bool time1ms ;
bool time1msinterval ;
bool timepwmchange ;
}bits;
}timeflag1;
#define vTimeFlag1 timeflag1.byte
#define bTime1ms timeflag1.bits.time1ms
#define bTime1msInterval timeflag1.bits.time1msinterval
#define bTimePwmChange timeflag1.bits.timepwmchange
APP_TIMER_DEF(m_battery_timer_id); /**< Battery timer. */
BLE_BAS_DEF(m_bas); /**< Battery service instance. */
BLE_HIDS_DEF(m_hids, /**< HID service instance. */
NRF_SDH_BLE_TOTAL_LINK_COUNT,
INPUT_REP_BUTTONS_LEN,
INPUT_REP_MOVEMENT_LEN,
INPUT_REP_MEDIA_PLAYER_LEN);
NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */
NRF_BLE_QWR_DEF(m_qwr); /**< Context for the Queued Write module.*/
BLE_ADVERTISING_DEF(m_advertising); /**< Advertising module instance. */
static bool m_in_boot_mode = false; /**< Current protocol mode. */
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */
static pm_peer_id_t m_peer_id; /**< Device reference handle to the current bonded central. */
static sensorsim_cfg_t m_battery_sim_cfg; /**< Battery Level sensor simulator configuration. */
static sensorsim_state_t m_battery_sim_state; /**< Battery Level sensor simulator state. */
static ble_uuid_t m_adv_uuids[] = /**< Universally unique service identifiers. */
{
{BLE_UUID_HUMAN_INTERFACE_DEVICE_SERVICE, BLE_UUID_TYPE_BLE}
};
#if SWIFT_PAIR_SUPPORTED == 1
static uint8_t m_sp_payload[] = /**< Payload of advertising data structure for Microsoft Swift Pair feature. */
{
MICROSOFT_BEACON_ID,
MICROSOFT_BEACON_SUB_SCENARIO,
RESERVED_RSSI_BYTE
};
static ble_advdata_manuf_data_t m_sp_manuf_advdata = /**< Advertising data structure for Microsoft Swift Pair feature. */
{
.company_identifier = MICROSOFT_VENDOR_ID,
.data =
{
.size = sizeof(m_sp_payload),
.p_data = &m_sp_payload[0]
}
};
static ble_advdata_t m_sp_advdata;
#endif
static void on_hids_evt(ble_hids_t * p_hids, ble_hids_evt_t * p_evt);
/**@brief Callback function for asserts in the SoftDevice.
*
* @details This function will be called in case of an assert in the SoftDevice.
*
* @warning This handler is an example only and does not fit a final product. You need to analyze
* how your product is supposed to react in case of Assert.
* @warning On assert from the SoftDevice, the system can only recover on reset.
*
* @param[in] line_num Line number of the failing ASSERT call.
* @param[in] file_name File name of the failing ASSERT call.
*/
void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
app_error_handler(DEAD_BEEF, line_num, p_file_name);
}
/**@brief Function for setting filtered whitelist.
*
* @param[in] skip Filter passed to @ref pm_peer_id_list.
*/
static void whitelist_set(pm_peer_id_list_skip_t skip)
{
pm_peer_id_t peer_ids[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
uint32_t peer_id_count = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
ret_code_t err_code = pm_peer_id_list(peer_ids, &peer_id_count, PM_PEER_ID_INVALID, skip);
APP_ERROR_CHECK(err_code);
NRF_LOG_INFO("\tm_whitelist_peer_cnt %d, MAX_PEERS_WLIST %d",
peer_id_count + 1,
BLE_GAP_WHITELIST_ADDR_MAX_COUNT);
err_code = pm_whitelist_set(peer_ids, peer_id_count);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for setting filtered device identities.
*
* @param[in] skip Filter passed to @ref pm_peer_id_list.
*/
static void identities_set(pm_peer_id_list_skip_t skip)
{
pm_peer_id_t peer_ids[BLE_GAP_DEVICE_IDENTITIES_MAX_COUNT];
uint32_t peer_id_count = BLE_GAP_DEVICE_IDENTITIES_MAX_COUNT;
ret_code_t err_code = pm_peer_id_list(peer_ids, &peer_id_count, PM_PEER_ID_INVALID, skip);
APP_ERROR_CHECK(err_code);
err_code = pm_device_identities_list_set(peer_ids, peer_id_count);
APP_ERROR_CHECK(err_code);
}
/**@brief Clear bond information from persistent storage.
*/
static void delete_bonds(void)
{
ret_code_t err_code;
NRF_LOG_INFO("Erase bonds!");
err_code = pm_peers_delete();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for starting advertising.
*/
static void advertising_start(bool erase_bonds)
{
if (erase_bonds == true)
{
delete_bonds();
// Advertising is started by PM_EVT_PEERS_DELETE_SUCCEEDED event.
}
else
{
whitelist_set(PM_PEER_ID_LIST_SKIP_NO_ID_ADDR);
ret_code_t ret = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(ret);
}
}
/**@brief Function for handling Peer Manager events.
*
* @param[in] p_evt Peer Manager event.
*/
static void pm_evt_handler(pm_evt_t const * p_evt)
{
pm_handler_on_pm_evt(p_evt);
pm_handler_flash_clean(p_evt);
switch (p_evt->evt_id)
{
case PM_EVT_PEERS_DELETE_SUCCEEDED:
advertising_start(false);
break;
case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
if ( p_evt->params.peer_data_update_succeeded.flash_changed
&& (p_evt->params.peer_data_update_succeeded.data_id == PM_PEER_DATA_ID_BONDING))
{
NRF_LOG_INFO("New Bond, add the peer to the whitelist if possible");
// Note: You should check on what kind of white list policy your application should use.
whitelist_set(PM_PEER_ID_LIST_SKIP_NO_ID_ADDR);
}
break;
default:
break;
}
}
/**@brief Function for handling Service errors.
*
* @details A pointer to this function will be passed to each service which may need to inform the
* application about an error.
*
* @param[in] nrf_error Error code containing information about what went wrong.
*/
static void service_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/**@brief Function for handling advertising errors.
*
* @param[in] nrf_error Error code containing information about what went wrong.
*/
static void ble_advertising_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/**@brief Function for performing a battery measurement, and update the Battery Level characteristic in the Battery Service.
*/
static void battery_level_update(void)
{
ret_code_t err_code;
uint8_t battery_level;
battery_level = (uint8_t)sensorsim_measure(&m_battery_sim_state, &m_battery_sim_cfg);
err_code = ble_bas_battery_level_update(&m_bas, battery_level, BLE_CONN_HANDLE_ALL);
if ((err_code != NRF_SUCCESS) &&
(err_code != NRF_ERROR_BUSY) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_FORBIDDEN) &&
(err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
)
{
APP_ERROR_HANDLER(err_code);
}
}
/**@brief Function for handling the Battery measurement timer timeout.
*
* @details This function will be called each time the battery level measurement timer expires.
*
* @param[in] p_context Pointer used for passing some arbitrary information (context) from the
* app_start_timer() call to the timeout handler.
*/
static void battery_level_meas_timeout_handler(void * p_context)
{
UNUSED_PARAMETER(p_context);
battery_level_update();
}
/**@brief Function for the Timer initialization.
*
* @details Initializes the timer module.
*/
static void timers_init(void)
{
ret_code_t err_code;
err_code = app_timer_init();
APP_ERROR_CHECK(err_code);
// Create battery timer.
err_code = app_timer_create(&m_battery_timer_id,
APP_TIMER_MODE_REPEATED,
battery_level_meas_timeout_handler);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for the GAP initialization.
*
* @details This function sets up all the necessary GAP (Generic Access Profile) parameters of the
* device including the device name, appearance, and the preferred connection parameters.
*/
static void gap_params_init(void)
{
ret_code_t err_code;
ble_gap_conn_params_t gap_conn_params;
ble_gap_conn_sec_mode_t sec_mode;
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *)DEVICE_NAME,
strlen(DEVICE_NAME));
APP_ERROR_CHECK(err_code);
err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_HID_MOUSE);
APP_ERROR_CHECK(err_code);
memset(&gap_conn_params, 0, sizeof(gap_conn_params));
gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
gap_conn_params.slave_latency = SLAVE_LATENCY;
gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT;
err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the GATT module.
*/
static void gatt_init(void)
{
ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling Queued Write Module errors.
*
* @details A pointer to this function will be passed to each service which may need to inform the
* application about an error.
*
* @param[in] nrf_error Error code containing information about what went wrong.
*/
static void nrf_qwr_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/**@brief Function for initializing the Queued Write Module.
*/
static void qwr_init(void)
{
ret_code_t err_code;
nrf_ble_qwr_init_t qwr_init_obj = {0};
qwr_init_obj.error_handler = nrf_qwr_error_handler;
err_code = nrf_ble_qwr_init(&m_qwr, &qwr_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing Device Information Service.
*/
static void dis_init(void)
{
ret_code_t err_code;
ble_dis_init_t dis_init_obj;
ble_dis_pnp_id_t pnp_id;
pnp_id.vendor_id_source = PNP_ID_VENDOR_ID_SOURCE;
pnp_id.vendor_id = PNP_ID_VENDOR_ID;
pnp_id.product_id = PNP_ID_PRODUCT_ID;
pnp_id.product_version = PNP_ID_PRODUCT_VERSION;
memset(&dis_init_obj, 0, sizeof(dis_init_obj));
ble_srv_ascii_to_utf8(&dis_init_obj.manufact_name_str, MANUFACTURER_NAME);
dis_init_obj.p_pnp_id = &pnp_id;
dis_init_obj.dis_char_rd_sec = SEC_JUST_WORKS;
err_code = ble_dis_init(&dis_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing Battery Service.
*/
static void bas_init(void)
{
ret_code_t err_code;
ble_bas_init_t bas_init_obj;
memset(&bas_init_obj, 0, sizeof(bas_init_obj));
bas_init_obj.evt_handler = NULL;
bas_init_obj.support_notification = true;
bas_init_obj.p_report_ref = NULL;
bas_init_obj.initial_batt_level = 100;
bas_init_obj.bl_rd_sec = SEC_JUST_WORKS;
bas_init_obj.bl_cccd_wr_sec = SEC_JUST_WORKS;
bas_init_obj.bl_report_rd_sec = SEC_JUST_WORKS;
err_code = ble_bas_init(&m_bas, &bas_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing HID Service.
*/
static void hids_init(void)
{
ret_code_t err_code;
ble_hids_init_t hids_init_obj;
ble_hids_inp_rep_init_t * p_input_report;
uint8_t hid_info_flags;
static ble_hids_inp_rep_init_t inp_rep_array[INPUT_REPORT_COUNT];
static uint8_t rep_map_data[] =
{
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x02, // Usage (Mouse)
0xA1, 0x01, // Collection (Application)
// Report ID 1: Mouse buttons + scroll/pan
0x85, 0x01, // Report Id 1
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 2: Mouse motion
0x85, 0x02, // Report Id 2
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 3: Advanced buttons
0x05, 0x0C, // Usage Page (Consumer)
0x09, 0x01, // Usage (Consumer Control)
0xA1, 0x01, // Collection (Application)
0x85, 0x03, // Report Id (3)
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
};
memset(inp_rep_array, 0, sizeof(inp_rep_array));
// Initialize HID Service.
p_input_report = &inp_rep_array[INPUT_REP_BUTTONS_INDEX];
p_input_report->max_len = INPUT_REP_BUTTONS_LEN;
p_input_report->rep_ref.report_id = INPUT_REP_REF_BUTTONS_ID;
p_input_report->rep_ref.report_type = BLE_HIDS_REP_TYPE_INPUT;
p_input_report->sec.cccd_wr = SEC_JUST_WORKS;
p_input_report->sec.wr = SEC_JUST_WORKS;
p_input_report->sec.rd = SEC_JUST_WORKS;
p_input_report = &inp_rep_array[INPUT_REP_MOVEMENT_INDEX];
p_input_report->max_len = INPUT_REP_MOVEMENT_LEN;
p_input_report->rep_ref.report_id = INPUT_REP_REF_MOVEMENT_ID;
p_input_report->rep_ref.report_type = BLE_HIDS_REP_TYPE_INPUT;
p_input_report->sec.cccd_wr = SEC_JUST_WORKS;
p_input_report->sec.wr = SEC_JUST_WORKS;
p_input_report->sec.rd = SEC_JUST_WORKS;
p_input_report = &inp_rep_array[INPUT_REP_MPLAYER_INDEX];
p_input_report->max_len = INPUT_REP_MEDIA_PLAYER_LEN;
p_input_report->rep_ref.report_id = INPUT_REP_REF_MPLAYER_ID;
p_input_report->rep_ref.report_type = BLE_HIDS_REP_TYPE_INPUT;
p_input_report->sec.cccd_wr = SEC_JUST_WORKS;
p_input_report->sec.wr = SEC_JUST_WORKS;
p_input_report->sec.rd = SEC_JUST_WORKS;
hid_info_flags = HID_INFO_FLAG_REMOTE_WAKE_MSK | HID_INFO_FLAG_NORMALLY_CONNECTABLE_MSK;
memset(&hids_init_obj, 0, sizeof(hids_init_obj));
hids_init_obj.evt_handler = on_hids_evt;
hids_init_obj.error_handler = service_error_handler;
hids_init_obj.is_kb = false;
hids_init_obj.is_mouse = true;
hids_init_obj.inp_rep_count = INPUT_REPORT_COUNT;
hids_init_obj.p_inp_rep_array = inp_rep_array;
hids_init_obj.outp_rep_count = 0;
hids_init_obj.p_outp_rep_array = NULL;
hids_init_obj.feature_rep_count = 0;
hids_init_obj.p_feature_rep_array = NULL;
hids_init_obj.rep_map.data_len = sizeof(rep_map_data);
hids_init_obj.rep_map.p_data = rep_map_data;
hids_init_obj.hid_information.bcd_hid = BASE_USB_HID_SPEC_VERSION;
hids_init_obj.hid_information.b_country_code = 0;
hids_init_obj.hid_information.flags = hid_info_flags;
hids_init_obj.included_services_count = 0;
hids_init_obj.p_included_services_array = NULL;
hids_init_obj.rep_map.rd_sec = SEC_JUST_WORKS;
hids_init_obj.hid_information.rd_sec = SEC_JUST_WORKS;
hids_init_obj.boot_mouse_inp_rep_sec.cccd_wr = SEC_JUST_WORKS;
hids_init_obj.boot_mouse_inp_rep_sec.wr = SEC_JUST_WORKS;
hids_init_obj.boot_mouse_inp_rep_sec.rd = SEC_JUST_WORKS;
hids_init_obj.protocol_mode_rd_sec = SEC_JUST_WORKS;
hids_init_obj.protocol_mode_wr_sec = SEC_JUST_WORKS;
hids_init_obj.ctrl_point_wr_sec = SEC_JUST_WORKS;
err_code = ble_hids_init(&m_hids, &hids_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing services that will be used by the application.
*/
static void services_init(void)
{
qwr_init();
dis_init();
bas_init();
hids_init();
}
/**@brief Function for initializing the battery sensor simulator.
*/
static void sensor_simulator_init(void)
{
m_battery_sim_cfg.min = MIN_BATTERY_LEVEL;
m_battery_sim_cfg.max = MAX_BATTERY_LEVEL;
m_battery_sim_cfg.incr = BATTERY_LEVEL_INCREMENT;
m_battery_sim_cfg.start_at_max = true;
sensorsim_init(&m_battery_sim_state, &m_battery_sim_cfg);
}
/**@brief Function for handling a Connection Parameters error.
*
* @param[in] nrf_error Error code containing information about what went wrong.
*/
static void conn_params_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/**@brief Function for initializing the Connection Parameters module.
*/
static void conn_params_init(void)
{
ret_code_t err_code;
ble_conn_params_init_t cp_init;
memset(&cp_init, 0, sizeof(cp_init));
cp_init.p_conn_params = NULL;
cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY;
cp_init.max_conn_params_update_count = MAX_CONN_PARAM_UPDATE_COUNT;
cp_init.start_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID;
cp_init.disconnect_on_fail = false;
cp_init.evt_handler = NULL;
cp_init.error_handler = conn_params_error_handler;
err_code = ble_conn_params_init(&cp_init);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for starting timers.
*/
static void timers_start(void)
{
ret_code_t err_code;
err_code = app_timer_start(m_battery_timer_id, BATTERY_LEVEL_MEAS_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for putting the chip into sleep mode.
*
* @note This function will not return.
*/
static void sleep_mode_enter(void)
{
ret_code_t err_code;
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
// Prepare wakeup buttons.
err_code = bsp_btn_ble_sleep_mode_prepare();
APP_ERROR_CHECK(err_code);
// Go to system-off mode (this function will not return; wakeup will cause a reset).
err_code = sd_power_system_off();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling HID events.
*
* @details This function will be called for all HID events which are passed to the application.
*
* @param[in] p_hids HID service structure.
* @param[in] p_evt Event received from the HID service.
*/
static void on_hids_evt(ble_hids_t * p_hids, ble_hids_evt_t * p_evt)
{
switch (p_evt->evt_type)
{
case BLE_HIDS_EVT_BOOT_MODE_ENTERED:
m_in_boot_mode = true;
break;
case BLE_HIDS_EVT_REPORT_MODE_ENTERED:
m_in_boot_mode = false;
break;
case BLE_HIDS_EVT_NOTIF_ENABLED:
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling advertising events.
*
* @details This function will be called for advertising events which are passed to the application.
*
* @param[in] ble_adv_evt Advertising event.
*/
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
ret_code_t err_code;
switch (ble_adv_evt)
{
case BLE_ADV_EVT_DIRECTED_HIGH_DUTY:
NRF_LOG_INFO("Directed advertising.");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_DIRECTED);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_FAST:
NRF_LOG_INFO("Fast advertising.");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_SLOW:
NRF_LOG_INFO("Slow advertising.");
#if SWIFT_PAIR_SUPPORTED == 1
m_sp_advdata.p_manuf_specific_data = NULL;
err_code = ble_advertising_advdata_update(&m_advertising, &m_sp_advdata, NULL);
APP_ERROR_CHECK(err_code);
#endif
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_SLOW);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_FAST_WHITELIST:
NRF_LOG_INFO("Fast advertising with whitelist.");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_WHITELIST);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_SLOW_WHITELIST:
NRF_LOG_INFO("Slow advertising with whitelist.");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_WHITELIST);
APP_ERROR_CHECK(err_code);
err_code = ble_advertising_restart_without_whitelist(&m_advertising);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_IDLE:
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
sleep_mode_enter();
break;
case BLE_ADV_EVT_WHITELIST_REQUEST:
{
ble_gap_addr_t whitelist_addrs[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
ble_gap_irk_t whitelist_irks[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
uint32_t addr_cnt = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
uint32_t irk_cnt = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
err_code = pm_whitelist_get(whitelist_addrs, &addr_cnt,
whitelist_irks, &irk_cnt);
APP_ERROR_CHECK(err_code);
NRF_LOG_DEBUG("pm_whitelist_get returns %d addr in whitelist and %d irk whitelist",
addr_cnt,
irk_cnt);
// Set the correct identities list (no excluding peers with no Central Address Resolution).
identities_set(PM_PEER_ID_LIST_SKIP_NO_IRK);
// Apply the whitelist.
err_code = ble_advertising_whitelist_reply(&m_advertising,
whitelist_addrs,
addr_cnt,
whitelist_irks,
irk_cnt);
APP_ERROR_CHECK(err_code);
}
break;
case BLE_ADV_EVT_PEER_ADDR_REQUEST:
{
pm_peer_data_bonding_t peer_bonding_data;
// Only Give peer address if we have a handle to the bonded peer.
if (m_peer_id != PM_PEER_ID_INVALID)
{
err_code = pm_peer_data_bonding_load(m_peer_id, &peer_bonding_data);
if (err_code != NRF_ERROR_NOT_FOUND)
{
APP_ERROR_CHECK(err_code);
// Manipulate identities to exclude peers with no Central Address Resolution.
identities_set(PM_PEER_ID_LIST_SKIP_ALL);
ble_gap_addr_t * p_peer_addr = &(peer_bonding_data.peer_ble_id.id_addr_info);
err_code = ble_advertising_peer_addr_reply(&m_advertising, p_peer_addr);
APP_ERROR_CHECK(err_code);
}
}
break;
}
default:
break;
}
}
/**@brief Function for handling BLE events.
*
* @param[in] p_ble_evt Bluetooth stack event.
* @param[in] p_context Unused.
*/
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
ret_code_t err_code;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
NRF_LOG_INFO("Connected");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, m_conn_handle);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected");
// LED indication will be changed when advertising starts.
m_conn_handle = BLE_CONN_HANDLE_INVALID;
break;
case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
{
NRF_LOG_DEBUG("PHY update request.");
ble_gap_phys_t const phys =
{
.rx_phys = BLE_GAP_PHY_AUTO,
.tx_phys = BLE_GAP_PHY_AUTO,
};
err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
APP_ERROR_CHECK(err_code);
} break;
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
NRF_LOG_DEBUG("GATT Client Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
NRF_LOG_DEBUG("GATT Server Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
ret_code_t err_code;
err_code = nrf_sdh_enable_request();
APP_ERROR_CHECK(err_code);
// Configure the BLE stack using the default settings.
// Fetch the start address of the application RAM.
uint32_t ram_start = 0;
err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
APP_ERROR_CHECK(err_code);
// Enable BLE stack.
err_code = nrf_sdh_ble_enable(&ram_start);
APP_ERROR_CHECK(err_code);
// Register a handler for BLE events.
NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}
/**@brief Function for the Peer Manager initialization.
*/
static void peer_manager_init(void)
{
ble_gap_sec_params_t sec_param;
ret_code_t err_code;
err_code = pm_init();
APP_ERROR_CHECK(err_code);
memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));
// Security parameters to be used for all security procedures.
sec_param.bond = SEC_PARAM_BOND;
sec_param.mitm = SEC_PARAM_MITM;
sec_param.lesc = SEC_PARAM_LESC;
sec_param.keypress = SEC_PARAM_KEYPRESS;
sec_param.io_caps = SEC_PARAM_IO_CAPABILITIES;
sec_param.oob = SEC_PARAM_OOB;
sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE;
sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE;
sec_param.kdist_own.enc = 1;
sec_param.kdist_own.id = 1;
sec_param.kdist_peer.enc = 1;
sec_param.kdist_peer.id = 1;
err_code = pm_sec_params_set(&sec_param);
APP_ERROR_CHECK(err_code);
err_code = pm_register(pm_evt_handler);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
ret_code_t err_code;
uint8_t adv_flags;
ble_advertising_init_t init;
memset(&init, 0, sizeof(init));
adv_flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;
init.advdata.name_type = BLE_ADVDATA_FULL_NAME;
init.advdata.include_appearance = true;
init.advdata.flags = adv_flags;
init.advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
init.advdata.uuids_complete.p_uuids = m_adv_uuids;
#if SWIFT_PAIR_SUPPORTED == 1
init.advdata.p_manuf_specific_data = &m_sp_manuf_advdata;
memcpy(&m_sp_advdata, &init.advdata, sizeof(m_sp_advdata));
#endif
init.config.ble_adv_whitelist_enabled = true;
init.config.ble_adv_directed_high_duty_enabled = true;
init.config.ble_adv_directed_enabled = false;
init.config.ble_adv_directed_interval = 0;
init.config.ble_adv_directed_timeout = 0;
init.config.ble_adv_fast_enabled = true;
init.config.ble_adv_fast_interval = APP_ADV_FAST_INTERVAL;
init.config.ble_adv_fast_timeout = APP_ADV_FAST_DURATION;
init.config.ble_adv_slow_enabled = true;
init.config.ble_adv_slow_interval = APP_ADV_SLOW_INTERVAL;
init.config.ble_adv_slow_timeout = APP_ADV_SLOW_DURATION;
init.evt_handler = on_adv_evt;
init.error_handler = ble_advertising_error_handler;
err_code = ble_advertising_init(&m_advertising, &init);
APP_ERROR_CHECK(err_code);
ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}
/**@brief Function for the Event Scheduler initialization.
*/
static void scheduler_init(void)
{
APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE);
}
/**@brief Function for sending a Mouse Movement.
*
* @param[in] x_delta Horizontal movement.
* @param[in] y_delta Vertical movement.
*/
static void mouse_movement_send(int16_t x_delta, int16_t y_delta)
{
ret_code_t err_code;
if (m_in_boot_mode)
{
x_delta = MIN(x_delta, 0x00ff);
y_delta = MIN(y_delta, 0x00ff);
err_code = ble_hids_boot_mouse_inp_rep_send(&m_hids,
0x00,
(int8_t)x_delta,
(int8_t)y_delta,
0,
NULL,
m_conn_handle);
}
else
{
uint8_t buffer[INPUT_REP_MOVEMENT_LEN];
APP_ERROR_CHECK_BOOL(INPUT_REP_MOVEMENT_LEN == 3);
x_delta = MIN(x_delta, 0x0fff);
y_delta = MIN(y_delta, 0x0fff);
buffer[0] = x_delta & 0x00ff;
buffer[1] = ((y_delta & 0x000f) << 4) | ((x_delta & 0x0f00) >> 8);
buffer[2] = (y_delta & 0x0ff0) >> 4;
err_code = ble_hids_inp_rep_send(&m_hids,
INPUT_REP_MOVEMENT_INDEX,
INPUT_REP_MOVEMENT_LEN,
buffer,
m_conn_handle);
}
if ((err_code != NRF_SUCCESS) &&
(err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_BUSY) &&
(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
)
{
APP_ERROR_HANDLER(err_code);
}
}
static void mouse_click_send(uint8_t x, uint8_t y, uint8_t z)
{
uint32_t err_code;
uint8_t buffer[3];
if (m_in_boot_mode) return;
buffer[0] = x; // Left button (bit 0) pressed
buffer[1] = y; // Scroll value (-127, 128)
buffer[2] = z; // Sideways scroll value (-127, 128)
err_code = ble_hids_inp_rep_send(&m_hids,INPUT_REP_BUTTONS_INDEX, INPUT_REP_BUTTONS_LEN, buffer, m_conn_handle);
if (err_code != NRF_SUCCESS)
{
APP_ERROR_CHECK(err_code);
}
}
/**@brief Function for handling events from the BSP module.
*
* @param[in] event Event generated by button press.
*/
static void bsp_event_handler(bsp_event_t event)
{
ret_code_t err_code;
switch (event)
{
case BSP_EVENT_SLEEP:
sleep_mode_enter();
break;
case BSP_EVENT_DISCONNECT:
err_code = sd_ble_gap_disconnect(m_conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
break;
case BSP_EVENT_WHITELIST_OFF:
if (m_conn_handle == BLE_CONN_HANDLE_INVALID)
{
err_code = ble_advertising_restart_without_whitelist(&m_advertising);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
}
break;
case BSP_EVENT_KEY_0:
if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
{
mouse_click_send(1,0,0);// mouse_movement_send(-MOVEMENT_SPEED, 0);
mouse_click_send(0,0,0);
}
break;
case BSP_EVENT_KEY_1:
if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
{
mouse_click_send(2,0,0);// mouse_movement_send(-MOVEMENT_SPEED, 0);
mouse_click_send(0,0,0);//mouse_movement_send(0, -MOVEMENT_SPEED);
}
break;
case BSP_EVENT_KEY_2:
if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
{
mouse_movement_send(MOVEMENT_SPEED, -MOVEMENT_SPEED);
}
break;
case BSP_EVENT_KEY_3:
if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
{
mouse_movement_send(0, MOVEMENT_SPEED);
}
break;
case BSP_EVENT_KEY_4:
if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
{
mouse_movement_send(0, MOVEMENT_SPEED);
}
break;
default:
break;
}
}
/**@brief Function for initializing buttons and leds.
*
* @param[out] p_erase_bonds Will be true if the clear bonding button was pressed to wake the application up.
*/
static void buttons_leds_init(bool * p_erase_bonds)
{
ret_code_t err_code;
bsp_event_t startup_event;
err_code = bsp_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS, bsp_event_handler);
APP_ERROR_CHECK(err_code);
err_code = bsp_btn_ble_init(NULL, &startup_event);
APP_ERROR_CHECK(err_code);
*p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);
}
/**@brief Function for initializing the nrf log module.
*/
static void log_init(void)
{
ret_code_t err_code = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(err_code);
NRF_LOG_DEFAULT_BACKENDS_INIT();
}
/**@brief Function for initializing power management.
*/
static void power_management_init(void)
{
ret_code_t err_code;
err_code = nrf_pwr_mgmt_init();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling the idle state (main loop).
*
* @details If there is no pending log operation, then sleep until next the next event occurs.
*/
static void idle_state_handle(void)
{
app_sched_execute();
if (NRF_LOG_PROCESS() == false)
{
nrf_pwr_mgmt_run();
}
}
//Timer
void timer_led_event_handler( void* p_context)
{
static uint32_t i;
++vPwm;
if(vPwm>=100)
{
vPwm=0x00;
//LR
if(vPwmLR==0)
{
nrf_gpio_pin_clear(LR);
}
else
{
nrf_gpio_pin_set(LR);
}
//LG
if(vPwmLG==0)
{
nrf_gpio_pin_clear(LG);
}
else
{
nrf_gpio_pin_set(LG);
}
//LB
if(vPwmLB==0)
{
nrf_gpio_pin_clear(LB);
}
else
{
nrf_gpio_pin_set(LB);
}
//RR
if(vPwmRR==0)
{
nrf_gpio_pin_clear(RR);
}
else
{
nrf_gpio_pin_set(RR);
}
//RG
if(vPwmRG==0)
{
nrf_gpio_pin_clear(RG);
}
else
{
nrf_gpio_pin_set(RG);
}
//RB
if(vPwmRB==0)
{
nrf_gpio_pin_clear(RB);
}
else
{
nrf_gpio_pin_set(RB);
}
}
else
{
//LR
if(vPwm>vPwmLR)
{
nrf_gpio_pin_clear(LR);
}
//LG
if(vPwm>vPwmLG)
{
nrf_gpio_pin_clear(LG);
}
//LB
if(vPwm>vPwmLB)
{
nrf_gpio_pin_clear(LB);
}
//RR
if(vPwm>vPwmRR)
{
nrf_gpio_pin_clear(RR);
}
//RG
if(vPwm>vPwmRG)
{
nrf_gpio_pin_clear(RG);
}
//RB
if(vPwm>vPwmRB)
{
nrf_gpio_pin_clear(RB);
}
//TR
if(vPwm>vPwmTR)
{
nrf_gpio_pin_clear(TR);
}
//TG
if(vPwm>vPwmTG)
{
nrf_gpio_pin_clear(TG);
}
//TB
if(vPwm>vPwmTB)
{
nrf_gpio_pin_clear(TB);
}
}
++vTime1ms;
if(vTime1ms>=50)
{
vTime1ms=0x00;
bTime1ms=1;
bTime1msInterval=1;
}
}
void TimeProc(void)
{
if(!bTime1ms)return;
bTime1ms=0;
if(++vTimePwmChange>=20)
{
vTimePwmChange=0;
bTimePwmChange=1;
}
if(++vTime10ms>=10)
{
vTime10ms=0;
if(++vTime100ms>=10)
{
vTime100ms=0;
}
}
}
void PwmChange(void)
{
if(!bTimePwmChange)return;
bTimePwmChange=0x00;
switch(vColorMode)
{
case 0:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 1:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 2:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 3:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 4:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 5:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 6:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 7:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 8:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 9:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 10:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 11:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 12:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 13:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 14:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 15:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 16:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 17:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 18:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 19:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 20:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 21:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 22:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 23:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 24:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 25:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
case 26:
vPwmLR=100;
vPwmLG=0x00;
vPwmLB=0x00;
break;
}
}
const nrf_drv_timer_t TIMER_LED = NRF_DRV_TIMER_INSTANCE(1);
static void timer_init(void)
{
uint32_t time_ms = 2; //Time(in miliseconds) between consecutive compare events.
uint32_t time_ticks;
ret_code_t err_code = NRF_SUCCESS;
//Configure all leds on board.
bsp_board_init(BSP_INIT_LEDS);
//Configure TIMER_LED for generating simple light effect - leds on board will invert his state one after the other.
nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
err_code = nrf_drv_timer_init(&TIMER_LED, &timer_cfg, timer_led_event_handler);
APP_ERROR_CHECK(err_code);
time_ticks = nrf_drv_timer_ms_to_ticks(&TIMER_LED, time_ms);
nrf_drv_timer_extended_compare(
&TIMER_LED, NRF_TIMER_CC_CHANNEL0, time_ticks, NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, true);
nrf_drv_timer_enable(&TIMER_LED);
}
//QDEC
static void qdec_io_event_handler(nrf_drv_qdec_event_t event)
{
if (event.type == NRF_QDEC_EVENT_REPORTRDY)
{
m_accdblread = event.data.report.accdbl;
m_accread = event.data.report.acc;
m_report_ready_flag = true;
}
}
void scrollsend(void)
{
if(!m_report_ready_flag)return;
m_report_ready_flag=0;
if(m_accread<0)
{
if((m_accread + m_accdblread)<0)
{
mouse_click_send(0,-(m_accread+m_accdblread),0);
mouse_click_send(0,0,0);
}
else
{
mouse_click_send(0,2,0);
mouse_click_send(0,0,0);
}
}
else
{
if((m_accread - m_accdblread)>0)
{
mouse_click_send(0,-(m_accread-m_accdblread),0);
mouse_click_send(0,0,0);
}
else
{
mouse_click_send(0,-2,0);
mouse_click_send(0,0,0);
}
}
}
void qdec_init(void)
{
ret_code_t err_code = NRF_SUCCESS;
err_code = nrf_drv_qdec_init(NULL, qdec_io_event_handler);
APP_ERROR_CHECK(err_code);
nrf_drv_qdec_enable();
}
//sensor
void SendByte(uint8_t bytes)
{
uint8_t i=8;
nrf_gpio_pin_clear(clk);
do{
if(bytes&0x80)
{
nrf_gpio_pin_set(ddata);
}
nrf_gpio_pin_set(clk);
bytes<<=1;
__NOP();
__NOP();
nrf_gpio_pin_clear(clk);
__NOP();
__NOP();
}while(--i);
}
void ReadByte(uint8_t bytes)
{
uint8_t i=8;
bytes=0;
nrf_gpio_cfg_input(ddata,NRF_GPIO_PIN_NOPULL);
do{
bytes<<=1;
if(nrf_gpio_pin_read(ddata))
{
bytes|=0x01;
}
nrf_gpio_pin_set(clk);
__NOP();
__NOP();
__NOP();
nrf_gpio_pin_clear(clk);
__NOP();
__NOP();
}while(--i);
nrf_gpio_cfg_output(ddata);
}
void WriteReg(uint8_t reg,uint8_t dat)
{
SendByte(reg);
SendByte(dat);
}
uint8_t ReadReg(uint8_t reg)
{
uint8_t i=0;
SendByte(reg);
ReadByte(i);
return i;
}
void InitialReg(void)
{
WriteReg(0x40,0x80);
WriteReg(0x55,0x01);
}
void sensor_init(void)
{
uint8_t R1,R2,i;
nrf_gpio_cfg_output(cs);
nrf_gpio_cfg_output(clk);
nrf_gpio_cfg_output(ddata);
nrf_gpio_cfg_output(power);
nrf_gpio_pin_set(power);
nrf_gpio_pin_clear(clk);
nrf_gpio_pin_set(cs);
nrf_gpio_pin_clear(ddata);
WriteReg(0x40,0x80);
WriteReg(0x55,0x01);
bTime1msInterval=0;
__NOP();
while(1)
{
if(bTime1msInterval)
break;
}
WriteReg(0x7F,0x0E);
WriteReg(0x43,0x1D);
R1=ReadReg(0x46);
WriteReg(0x43,0x1e);
R2=ReadReg(0x46);
WriteReg(0x7F,0x14);
WriteReg(0x6A,R1);
WriteReg(0x6C,R2);
WriteReg(0x7F,0x00);
WriteReg(0x55,0x00);
WriteReg(0x4E,0x23);
WriteReg(0x77,0x18);
WriteReg(0x7F,0x05);
WriteReg(0x53,0x0c);
WriteReg(0x5B,0xea);
WriteReg(0x61,0x13);
WriteReg(0x62,0x0b);
WriteReg(0x64,0xd8);
WriteReg(0x6D,0x86);
WriteReg(0x7D,0x84);
WriteReg(0x7E,0x00);
WriteReg(0x7F,0x06);
WriteReg(0x60,0xb0);
WriteReg(0x61,0x00);
WriteReg(0x7E,0x40);
WriteReg(0x7F,0x0a);
WriteReg(0x4A,0x23);
WriteReg(0x4C,0x28);
WriteReg(0x49,0x00);
WriteReg(0x4F,0x02);
WriteReg(0x7F,0x14);
WriteReg(0x4A,0x67);
WriteReg(0x6D,0x82);
WriteReg(0x73,0x83);
WriteReg(0x74,0x00);
WriteReg(0x7A,0x16);
WriteReg(0x63,0x14);
WriteReg(0x62,0x14);
WriteReg(0x7F,0x10);
WriteReg(0x48,0x0f);
WriteReg(0x49,0x88);
WriteReg(0x4C,0x1d);
WriteReg(0x4F,0x08);
WriteReg(0x51,0x6f);
WriteReg(0x52,0x90);
WriteReg(0x54,0x64);
WriteReg(0x55,0xf0);
WriteReg(0x5C,0x40);
WriteReg(0x61,0xee);
WriteReg(0x62,0xe5);
WriteReg(0x7F,0x00);
WriteReg(0x5B,0x40);
WriteReg(0x61,0xad);
WriteReg(0x51,0xea);
WriteReg(0x19,0x9f);
bTime1msInterval=0;
i=0;
while(1)
{
if(bTime1msInterval)
{
bTime1msInterval=0;
if(ReadReg(0x20)==0x0f)break;
i++;
}
if(i>=55)break;
}
WriteReg(0x19,0x10);
WriteReg(0x61,0xd5);
WriteReg(0x40,0x00);
WriteReg(0x7f,0x00);
WriteReg(0x77,0x2f);
WriteReg(0x7f,0x0d);
WriteReg(0x4e,0x6b);
WriteReg(0x7f,0x05);
WriteReg(0x44,0xa8);
WriteReg(0x4a,0x14);
WriteReg(0x7f,0x00);
WriteReg(0x4f,0x46);
WriteReg(0x4d,0x00);
}
void SensorMovement(void)
{
uint32_t x,y;
x=(ReadReg(0x04)<<8)|(ReadReg(0x03));
y=(ReadReg(0x06)<<8)|(ReadReg(0x05));
}
//Initial
void Custom_Init(void)
{
nrf_gpio_cfg_output(LR);
nrf_gpio_cfg_output(LG);
nrf_gpio_cfg_output(LB);
nrf_gpio_cfg_output(RR);
nrf_gpio_cfg_output(RG);
nrf_gpio_cfg_output(RB);
nrf_gpio_cfg_output(TR);
nrf_gpio_cfg_output(TG);
nrf_gpio_cfg_output(TB);
// nrf_gpio_cfg_output(EN);
// nrf_gpio_pin_set(EN);
vPwmLR=0x00;
vPwmLG=0x00;
vPwmLB=0x00;
vPwmRR=0x00;
vPwmRG=0x00;
vPwmRB=0x00;
vPwmTR=0x00;
vPwmTG=0x00;
vPwmTB=0x00;
vTimeFlag1=0x0000;
vColorMode=0x00;
}
/**@brief Function for application main entry.
*/
int main(void)
{
bool erase_bonds;
timer_init();
Custom_Init();
qdec_init();
sensor_init();
// Initialize.
log_init();
timers_init();
buttons_leds_init(&erase_bonds);
power_management_init();
ble_stack_init();
scheduler_init();
gap_params_init();
gatt_init();
advertising_init();
services_init();
sensor_simulator_init();
conn_params_init();
peer_manager_init();
// Start execution.
NRF_LOG_INFO("HID Mouse example started.");
timers_start();
advertising_start(erase_bonds);
/* RTC
// APP_TIMER_DEF(my_timer_id);
// app_timer_create(&my_timer_id,APP_TIMER_MODE_REPEATED,my_timerout_handle);
// app_timer_start(my_timer_id,APP_TIMER_TICKS(5),NULL);
*/
// Enter main loop.
for (;;)
{
idle_state_handle();
TimeProc();
PwmChange();
scrollsend();
SensorMovement();
}
}
/**
* @}
*/
Hi,Jared:
As add,when i emulate the code to connect to another BLE device (dongle),It seems the other device would be distroyed and could never be connected to this example but can be connected to other BLE.
And more，When error occurs,There is no battery symbol.
Hi,
In your problem statement you mentioned ble_app_hids_mouse example, but the code that you've shared is a modified version of it.Does this only happen with you modified example?Have you tried debugging your example? Maybe it asserts in the Sensor_init() or somewhere else.
regards
Jared
Hi,
In your problem statement you mentioned ble_app_hids_mouse example, but the code that you've shared is a modified version of it.Does this only happen with you modified example?Have you tried debugging your example? Maybe it asserts in the Sensor_init() or somewhere else.
regards
Jared
Hi,Jared:
As add, I paired at first time with no problem,but I pair the second time with the same code,the error occurs.
Hi,
wzszzxj said:As add, I paired at first time with no problem,but I pair the second time with the same code,the error occurs
Is this when you use the SDK example or your own modified one, did you try with the SDK example?
Try erasing the bonding data from both the nRF and PC.
regards
Jared
Hi,Jared:
Thank you for your reply, Pls close this topic,thank you!