Stair56E UART project

project/example/ble/ble_central/app/api/app_task.h

@@ -0,0 +1,336 @@
+/**
+ ****************************************************************************************
+ *
+ * @file app_task.h
+ *
+ * @brief Header file - APPTASK.
+ *
+ * Copyright (C) RivieraWaves 2009-2015
+ *
+ *
+ ****************************************************************************************
+ */
+
+#ifndef APP_TASK_H_
+#define APP_TASK_H_
+
+/**
+ ****************************************************************************************
+ * @addtogroup APPTASK Task
+ * @ingroup APP
+ * @brief Routes ALL messages to/from APP block.
+ *
+ * The APPTASK is the block responsible for bridging the final application with
+ *the RWBLE software host stack. It communicates with the different modules of
+ *the BLE host, i.e. @ref SMP, @ref GAP and @ref GATT.
+ *
+ * @{
+ ****************************************************************************************
+ */
+
+#include "app_sec.h"
+#include "co_bt_defines.h"
+#include "dbg.h"
+#include "gapm_int.h"
+#include "gatt_msg_int.h" // GATTC Definitions
+#include "ke_task.h"      // Kernel Task
+#include "rwip_task.h"    // Task definitions
+#include "usr_client.h"
+#include "xc_gap_api.h"
+#include <stdbool.h>
+#include <stdint.h> // Standard Integer Definition
+#include <stdio.h>
+
+#define BOND_TEST       0
+#define MULTI_ROLE_TEST 1
+#define WHITE_LIST_TEST 0
+
+#define CONNECT_DEV_NUM 5
+extern struct app_env_tag app_env;
+#if (NVDS_SUPPORT)
+#include "nvds.h"
+#endif // (NVDS_SUPPORT)
+
+#define APP_HANDLERS(subtask)                                                  \
+    {                                                                          \
+        &subtask##_msg_handler_list[0], ARRAY_LEN(subtask##_msg_handler_list)  \
+    }
+
+#define APP_DEVICE_NAME_MAX_LEN  (18)
+/// Default Device Name
+#define APP_DFLT_DEVICE_NAME     ("XC_BLE_MULTI_ROLE")
+#define APP_DFLT_DEVICE_NAME_LEN (sizeof(APP_DFLT_DEVICE_NAME))//must not be greater than APP_DEVICE_NAME_MAX_LEN
+/// Maximal length of the Device Name value
+#define APP_DEVICE_NAME_MAX_LEN  (18)
+#define APP_MAX_TX_POWER         (0)
+// Advertising channel map - 37, 38, 39
+#define APP_ADV_CHMAP            (0x07)
+// Advertising minimum interval - 40ms (64*0.625ms)
+#define APP_ADV_INT_MIN          (64)
+// Advertising maximum interval - 40ms (64*0.625ms)
+#define APP_ADV_INT_MAX          (64)
+
+#define ADV_DATA_MAX_LENGTH      28
+
+#define MANUFACTURER_DATA        "\x09\xFF\x00\x60\x52\x57\x2D\x42\x4C\x45"
+#define MANUFACTURER_DATA_LEN    10
+/// Advertising duration (in unit of 10ms). 0 means that advertising continues
+/// until the host disable it
+#define ADV_DURATION             0
+
+#define APP_SCAN_INTERVAL        (0xa0)
+#define APP_SCAN_WINDOW          (0x50)
+
+#define APP_CONN_EST_TIME_OUT    (0)
+#define APP_CONN_SCNA_INTV       (32)
+#define APP_CONN_SCAN_WD         (20)
+#define APP_CONN_INTV_MIN        (80)
+#define APP_CONN_INV_MAX         (80)
+#define APP_CONN_LATENCY         (0)
+#define APP_CONN_TIME_OUT        (500)
+
+/// Number of APP Task Instances
+#define APP_IDX_MAX              1
+#define DEV_APPEARANCE           0
+
+#define BLE_UAPDATA_MIN_INTVALUE 8
+#define BLE_UAPDATA_MAX_INTVALUE 10
+#define BLE_UAPDATA_LATENCY      0
+#define BLE_UAPDATA_TIMEOUT      200
+
+#define INVALID_DATA             0xFF
+// #define TAGET_DEVICE_ADDR        ("\x02\x6e\x00\x05\x21\x41")
+#define TAGET_DEVICE_ADDR        ("\x41\x21\x05\x00\x6e\x02")
+
+/// Application environment structure
+struct app_env_tag
+{
+    /// Connection handle
+    uint16_t conhdl;
+    /// Connection Index
+    uint8_t conidx;
+    /// Current advertising state (@see enum app_adv_state)
+    uint8_t adv_state;
+    /// Current advertising state (@see enum app_adv_state)
+    uint8_t scan_state;
+    /// Current advertising state (@see enum app_adv_state)
+    uint8_t init_state;
+    /// Next expected operation completed event
+    uint8_t adv_op;
+
+    /// Last initialized profile
+    uint8_t next_svc;
+
+    /// Bonding status
+    bool bonded;
+
+    /// Device Name length
+    uint8_t dev_name_len;
+    /// Device Name
+    uint8_t dev_name[APP_DEVICE_NAME_MAX_LEN];
+
+    /// Local device IRK
+    uint8_t loc_irk[KEY_LEN];
+
+    /// Secure Connections on current link
+    bool sec_con_enabled;
+
+    /// Counter used to generate IRK
+    uint8_t rand_cnt;
+
+    /// Demonstration type length
+    uint8_t demo_type_len;
+    /// Demonstration type
+    uint8_t demo_type;
+    /// GATT user local identifier
+    uint8_t user_lid;
+    uint8_t adv_actv_idx;
+    uint8_t scan_actv_idx;
+    uint8_t init_actv_idx;
+    uint8_t slave_conidx;
+    uint8_t master_conidx;
+    bool slave_connected;
+    bool master_connected;
+};
+
+struct conn_dev_info
+{
+    uint8_t conidx;
+    uint8_t addr[6];
+    bool connnectd;
+};
+
+#if (NVDS_SUPPORT)
+/// List of Application NVDS TAG identifiers
+enum app_nvds_tag
+{
+    /// Device Name
+    NVDS_TAG_DEVICE_NAME = 0x02,
+    NVDS_LEN_DEVICE_NAME = 62,
+
+    /// BD Address
+    NVDS_TAG_BD_ADDRESS  = 0x01,
+    NVDS_LEN_BD_ADDRESS  = 6,
+
+    /// Local device Identity resolving key
+    NVDS_TAG_LOC_IRK     = 0xA0,
+    NVDS_LEN_LOC_IRK     = KEY_LEN,
+
+#if (BLE_APP_PRF)
+    /// BLE Application Advertising data
+    NVDS_TAG_APP_BLE_ADV_DATA       = 0x0B,
+    NVDS_LEN_APP_BLE_ADV_DATA       = 32,
+
+    /// BLE Application Scan response data
+    NVDS_TAG_APP_BLE_SCAN_RESP_DATA = 0x0C,
+    NVDS_LEN_APP_BLE_SCAN_RESP_DATA = 32,
+
+    /// Mouse Sample Rate
+    NVDS_TAG_MOUSE_SAMPLE_RATE      = 0x38,
+    NVDS_LEN_MOUSE_SAMPLE_RATE      = 1,
+
+    /// Peripheral Bonded
+    NVDS_TAG_PERIPH_BONDED          = 0x39,
+    NVDS_LEN_PERIPH_BONDED          = 1,
+
+    /// Mouse NTF Cfg
+    NVDS_TAG_MOUSE_NTF_CFG          = 0x3A,
+    NVDS_LEN_MOUSE_NTF_CFG          = 2,
+
+    /// Mouse Timeout value
+    NVDS_TAG_MOUSE_TIMEOUT          = 0x3B,
+    NVDS_LEN_MOUSE_TIMEOUT          = 2,
+
+    /// Peer Device BD Address
+    NVDS_TAG_PEER_BD_ADDRESS        = 0x3C,
+    NVDS_LEN_PEER_BD_ADDRESS        = 7,
+
+    /// Mouse Energy Safe
+    NVDS_TAG_MOUSE_ENERGY_SAFE      = 0x3D,
+    NVDS_LEN_MOUSE_SAFE_ENERGY      = 2,
+
+    /// EDIV (2bytes), RAND NB (8bytes),  LTK (16 bytes), Key Size (1 byte)
+    NVDS_TAG_LTK                    = 0x3E,
+    NVDS_LEN_LTK                    = 28,
+
+    /// PAIRING
+    NVDS_TAG_PAIRING                = 0x3F,
+    NVDS_LEN_PAIRING                = 54,
+
+    /// Audio mode 0 task
+    NVDS_TAG_AM0_FIRST              = 0x90,
+    NVDS_TAG_AM0_LAST               = 0x9F,
+
+    /// Peer device Resolving identity key (+identity address)
+    NVDS_TAG_PEER_IRK               = 0xA1,
+    NVDS_LEN_PEER_IRK               = sizeof(struct gapc_irk),
+
+#endif //(BLE_APP_PRF)
+};
+#endif // (NVDS_SUPPORT)
+
+/// Advertising state machine
+enum app_adv_state
+{
+    /// Advertising activity does not exists
+    APP_ADV_STATE_IDLE = 0,
+#if BLE_APP_PRF
+    /// Creating advertising activity
+    APP_ADV_STATE_CREATING,
+    /// Setting advertising data
+    APP_ADV_STATE_SETTING_ADV_DATA,
+    /// Setting scan response data
+    APP_ADV_STATE_SETTING_SCAN_RSP_DATA,
+
+    /// Advertising activity created
+    APP_ADV_STATE_CREATED,
+    /// Starting advertising activity
+    APP_ADV_STATE_STARTING,
+    /// Advertising activity started
+    APP_ADV_STATE_STARTED,
+    /// Stopping advertising activity
+    APP_ADV_STATE_STOPPING,
+    APP_ADV_STATE_STOPPED,
+#endif //(BLE_APP_PRF)
+};
+
+/// Scanning state machine
+enum app_scan_state
+{
+    APP_SCAN_STATE_IDLE = 0,
+    APP_SCAN_STATE_CREATING,
+    APP_SCAN_STATE_CREATED,
+    APP_SCAN_STATE_STARTING,
+    APP_SCAN_STATE_STARTED,
+    APP_SCAN_STATE_STOPPING,
+    APP_SCAN_STATE_STOPPED,
+};
+
+/// initting state machine
+enum app_init_state
+{
+    APP_INIT_STATE_IDLE = 0,
+    APP_INIT_STATE_CREATING,
+    APP_INIT_STATE_CREATED,
+    APP_INIT_STATE_STARTING,
+    APP_INIT_STATE_STARTED,
+    APP_INIT_STATE_STOPPING,
+    APP_INIT_STATE_STOPPED,
+};
+
+/// States of APP task
+enum app_state
+{
+    /// Initialization state
+    APP_INIT,
+    /// Database create state
+    APP_CREATE_DB,
+    /// Ready State
+    APP_READY,
+    /// Connected state
+    APP_CONNECTED,
+
+    /// Number of defined states.
+    APP_STATE_MAX
+};
+
+/// APP Task messages
+/*@TRACE*/
+enum app_msg_id
+{
+    APP_DUMMY_MSG = TASK_FIRST_MSG(TASK_ID_APP),
+
+#if (BLE_APP_PRF)
+#if (BLE_APP_HT)
+    /// Timer used to refresh the temperature measurement value
+    APP_HT_MEAS_INTV_TIMER,
+#endif //(BLE_APP_HT)
+
+#if (BLE_APP_HID)
+    /// Timer used to disconnect the moue if no activity is detecter
+    APP_HID_MOUSE_TIMEOUT_TIMER,
+#endif //(BLE_APP_HID)
+#endif //(BLE_APP_PRF)
+#if (FLASH_TEST_IN_TASK || FLASH_TEST_IN_BLUETOOTH_GAP)
+ONE_SEC_TIMER_MSG
+#endif // (FLASH_TEST_IN_TASK || FLASH_TEST_IN_BLUETOOTH_GAP)
+};
+
+struct app_subtask_handlers
+{
+    /// Pointer to the message handler table
+    const struct ke_msg_handler *p_msg_handler_tab;
+    /// Number of messages handled
+    uint16_t msg_cnt;
+};
+
+/**
+ ****************************************************************************************
+ * @brief Initialize the BLE demo application.
+ ****************************************************************************************
+ */
+void app_init(void);
+struct app_env_tag *get_app_env(void);
+/// @} APPTASK
+
+#endif // APP_TASK_H_

project/example/ble/ble_central/app/api/rwapp_config.h

@@ -0,0 +1,87 @@
+/**
+ ****************************************************************************************
+ *
+ * @file rwapp_config.h
+ *
+ * @brief Application configuration definition
+ *
+ * Copyright (C) RivieraWaves 2009-2016
+ *
+ ****************************************************************************************
+ */
+
+#ifndef _RWAPP_CONFIG_H_
+#define _RWAPP_CONFIG_H_
+
+/**
+ ****************************************************************************************
+ * @addtogroup app
+ * @brief Application configuration definition
+ *
+ * @{
+ ****************************************************************************************
+ */
+
+/*
+ * INCLUDE FILES
+ ****************************************************************************************
+ */
+
+/*
+ * DEFINES
+ ****************************************************************************************
+ */
+
+#define CFG_APP_BATT
+/******************************************************************************************/
+/* -------------------------   BLE APPLICATION SETTINGS
+ * -----------------------------*/
+/******************************************************************************************/
+
+/// Application Profile
+#if defined(CFG_APP_PRF)
+#define BLE_APP_PRF 1
+#else // defined(CFG_APP_PRF)
+#define BLE_APP_PRF 0
+#endif // defined(CFG_APP_PRF)
+
+/// Health Thermometer Application
+#if defined(CFG_APP_HT)
+#define BLE_APP_HT 1
+#else // defined(CFG_APP_HT)
+#define BLE_APP_HT 0
+#endif // defined(CFG_APP_HT)
+
+/// HID Application
+#if defined(CFG_APP_HID)
+#define BLE_APP_HID 1
+#else // defined(CFG_APP_HID)
+#define BLE_APP_HID 0
+#endif // defined(CFG_APP_HID)
+
+/// DIS Application
+#if defined(CFG_APP_DIS)
+#define BLE_APP_DIS 1
+#else // defined(CFG_APP_DIS)
+#define BLE_APP_DIS 0
+#endif // defined(CFG_APP_DIS)
+
+/// Battery Service Application
+#if defined(CFG_APP_BATT)
+#define BLE_APP_BATT 1
+#else
+#define BLE_APP_BATT 0
+#endif //(BLE_APP_BATT)
+
+// There are 3 modes of flash operation, turn on one of them according to your needs.
+// This method can be operated at any time without affecting the Bluetooth send and receive packets.
+#define FLASH_TEST_IN_INTERRUPT      (0)
+// This method can be operated at any time, and will affect the Bluetooth send and receive packets.
+#define FLASH_TEST_IN_TASK           (0)
+// This way operates in the gap of Bluetooth and will not affect the Bluetooth sending and receiving packets, 
+// but the flash operation may not be successful immediately.
+#define FLASH_TEST_IN_BLUETOOTH_GAP  (0)
+
+/// @} rwapp_config
+
+#endif /* _RWAPP_CONFIG_H_ */

project/example/ble/ble_central/app/src/app_batt.c

@@ -0,0 +1,189 @@
+/**
+ ****************************************************************************************
+ *
+ * @file app_batt.c
+ *
+ * @brief Battery Application Module entry point
+ *
+ * Copyright (C) RivieraWaves 2009-2015
+ *
+ *
+ ****************************************************************************************
+ */
+
+/**
+ ****************************************************************************************
+ * @addtogroup APP
+ * @{
+ ****************************************************************************************
+ */
+
+#include "rwip_config.h"     // SW configuration
+
+#if (BLE_APP_BATT)
+
+/*
+ * INCLUDE FILES
+ ****************************************************************************************
+ */
+
+#include "app_batt.h"                // Battery Application Module Definitions
+#include "app_task.h"                // application task definitions
+#include "bass_msg.h"               // health thermometer functions
+#include "co_bt.h"
+#include "co_utils.h"
+#include "prf_types.h"               // Profile common types definition
+#include "arch.h"                    // Platform Definitions
+#include "prf.h"
+#include <string.h>
+
+/*
+ * DEFINES
+ ****************************************************************************************
+ */
+
+/*
+ * GLOBAL VARIABLE DEFINITIONS
+ ****************************************************************************************
+ */
+
+/// Battery Application Module Environment Structure
+struct app_batt_env_tag app_batt_env;
+
+/*
+ * GLOBAL FUNCTION DEFINITIONS
+ ****************************************************************************************
+ */
+
+void app_batt_init(void)
+{
+    // Reset the environment
+    memset(&app_batt_env, 0, sizeof(struct app_batt_env_tag));
+
+    // Initial battery level: 100
+    app_batt_env.batt_lvl = 100;
+}
+
+void app_batt_add_bas(void)
+{
+    struct bass_db_cfg* db_cfg;
+    // Allocate the BASS_CREATE_DB_REQ
+    struct gapm_profile_task_add_cmd *req = KE_MSG_ALLOC_DYN(GAPM_PROFILE_TASK_ADD_CMD,
+                                                  TASK_GAPM, TASK_APP,
+                                                  gapm_profile_task_add_cmd, sizeof(struct bass_db_cfg));
+    // Fill message
+    req->operation   = GAPM_PROFILE_TASK_ADD;
+    req->sec_lvl     = 0;//PERM(SVC_AUTH, AUTH);
+    req->prf_api_id = TASK_ID_BASS;
+    req->app_task    = TASK_APP;
+    req->start_hdl   = 0;
+
+    // Set parameters
+    db_cfg = (struct bass_db_cfg* ) req->param;
+ 
+    // Add a BAS instance
+    db_cfg->bas_nb      = 1;
+    // Sending of notifications is supported
+    db_cfg->features[0] = BAS_BATT_LVL_NTF_SUP;
+
+    // Send the message
+    ke_msg_send(req);
+}
+
+void app_batt_enable_prf(uint8_t conidx)
+{
+    app_batt_env.conidx = conidx;
+
+    // Allocate the message
+    struct bass_enable_req * req = KE_MSG_ALLOC(BASS_ENABLE_REQ,
+                                                prf_dst_task_get(TASK_ID_BASS),
+                                                TASK_APP,
+                                                bass_enable_req);
+
+    // Fill in the parameter structure
+    req->conidx             = conidx;
+
+    // NTF initial status - Disabled
+    req->ntf_cfg           = PRF_CLI_STOP_NTFIND;
+    req->old_batt_lvl[0]   = 50;
+
+    // Send the message
+    ke_msg_send(req);
+}
+
+void app_batt_send_lvl(uint8_t batt_lvl)
+{
+    ASSERT_ERR(batt_lvl <= BAS_BATTERY_LVL_MAX);
+
+    // Allocate the message
+    struct bass_batt_level_upd_req * req = KE_MSG_ALLOC(BASS_BATT_LEVEL_UPD_REQ,
+                                                        prf_dst_task_get(TASK_ID_BASS),
+                                                        TASK_APP,
+                                                        bass_batt_level_upd_req);
+
+    // Fill in the parameter structure
+    req->bas_instance = 0;
+    req->batt_level   = batt_lvl;
+
+    // Send the message
+    ke_msg_send(req);
+}
+
+static int bass_batt_level_ntf_cfg_ind_handler(ke_msg_id_t const msgid,
+                                               struct bass_batt_level_ntf_cfg_ind const *param,
+                                               ke_task_id_t const dest_id,
+                                               ke_task_id_t const src_id)
+{
+    return (KE_MSG_CONSUMED);
+}
+
+static int batt_level_upd_handler(ke_msg_id_t const msgid,
+                                      struct bass_batt_level_upd_rsp const *param,
+                                      ke_task_id_t const dest_id,
+                                      ke_task_id_t const src_id)
+{
+    return (KE_MSG_CONSUMED);
+}
+
+/**
+ ****************************************************************************************
+ * @brief
+ *
+ * @param[in] msgid     Id of the message received.
+ * @param[in] param     Pointer to the parameters of the message.
+ * @param[in] dest_id   ID of the receiving task instance (TASK_GAP).
+ * @param[in] src_id    ID of the sending task instance.
+ *
+ * @return If the message was consumed or not.
+ ****************************************************************************************
+ */
+static int app_batt_msg_dflt_handler(ke_msg_id_t const msgid,
+                                     void const *param,
+                                     ke_task_id_t const dest_id,
+                                     ke_task_id_t const src_id)
+{
+    // Drop the message
+
+    return (KE_MSG_CONSUMED);
+}
+
+/*
+ * LOCAL VARIABLE DEFINITIONS
+ ****************************************************************************************
+ */
+
+/// Default State handlers definition
+const struct ke_msg_handler app_batt_msg_handler_list[] =
+{
+    // Note: first message is latest message checked by kernel so default is put on top.
+    {KE_MSG_DEFAULT_HANDLER,        (ke_msg_func_t)app_batt_msg_dflt_handler},
+
+    {BASS_BATT_LEVEL_NTF_CFG_IND,   (ke_msg_func_t)bass_batt_level_ntf_cfg_ind_handler},
+    {BASS_BATT_LEVEL_UPD_RSP,       (ke_msg_func_t)batt_level_upd_handler},
+};
+
+const struct app_subtask_handlers app_batt_handlers = APP_HANDLERS(app_batt);
+
+#endif //BLE_APP_BATT
+
+/// @} APP

project/example/ble/ble_central/app/src/app_batt.h

@@ -0,0 +1,110 @@
+/**
+ ****************************************************************************************
+ *
+ * @file app_batt.h
+ *
+ * @brief Battery Application Module entry point
+ *
+ * Copyright (C) RivieraWaves 2009-2015
+ *
+ *
+ ****************************************************************************************
+ */
+
+#ifndef APP_BATT_H_
+#define APP_BATT_H_
+
+/**
+ ****************************************************************************************
+ * @addtogroup APP
+ * @ingroup RICOW
+ *
+ * @brief Battery Application Module entry point
+ *
+ * @{
+ ****************************************************************************************
+ */
+
+/*
+ * INCLUDE FILES
+ ****************************************************************************************
+ */
+
+#include "rwip_config.h"     // SW configuration
+
+#if (BLE_APP_BATT)
+
+#include <stdint.h>          // Standard Integer Definition
+#include "ke_task.h"         // Kernel Task Definition
+
+/*
+ * STRUCTURES DEFINITION
+ ****************************************************************************************
+ */
+
+/// Battery Application Module Environment Structure
+struct app_batt_env_tag
+{
+    /// Connection handle
+    uint8_t conidx;
+    /// Current Battery Level
+    uint8_t batt_lvl;
+};
+
+/*
+ * GLOBAL VARIABLES DECLARATIONS
+ ****************************************************************************************
+ */
+
+/// Battery Application environment
+extern struct app_batt_env_tag app_batt_env;
+
+/// Table of message handlers
+extern const struct app_subtask_handlers app_batt_handlers;
+
+/*
+ * FUNCTIONS DECLARATION
+ ****************************************************************************************
+ */
+
+/**
+ ****************************************************************************************
+ *
+ * Health Thermometer Application Functions
+ *
+ ****************************************************************************************
+ */
+
+/**
+ ****************************************************************************************
+ * @brief Initialize Battery Application Module
+ ****************************************************************************************
+ */
+void app_batt_init(void);
+
+/**
+ ****************************************************************************************
+ * @brief Add a Battery Service instance in the DB
+ ****************************************************************************************
+ */
+void app_batt_add_bas(void);
+
+/**
+ ****************************************************************************************
+ * @brief Enable the Battery Service
+ ****************************************************************************************
+ */
+void app_batt_enable_prf(uint8_t conidx);
+
+/**
+ ****************************************************************************************
+ * @brief Send a Battery level value
+ ****************************************************************************************
+ */
+void app_batt_send_lvl(uint8_t batt_lvl);
+
+#endif //(BLE_APP_BATT)
+
+/// @} APP
+
+#endif // APP_BATT_H_

project/example/ble/ble_central/app/src/app_battc.c

@@ -0,0 +1,56 @@
+#if 0
+/*@TRACE*/
+enum basc_msg_id
+{
+    /// Start the Battery Service Client Role - at connection
+    // BASC_ENABLE_REQ                 = MSG_ID(BASC, 0x00),
+    ///Confirm that cfg connection has finished with discovery results, or that normal cnx started
+    BASC_ENABLE_RSP                 = MSG_ID(BASC, 0x01),
+
+    /// Read Characteristic Value Request
+    // BASC_READ_INFO_REQ              = MSG_ID(BASC, 0x02),
+    /// Read Characteristic Value Request
+    BASC_READ_INFO_RSP              = MSG_ID(BASC, 0x03),
+
+    /// Write Battery Level Notification Configuration Value request
+    // BASC_BATT_LEVEL_NTF_CFG_REQ     = MSG_ID(BASC, 0x04),
+    /// Write Battery Level Notification Configuration Value response
+    BASC_BATT_LEVEL_NTF_CFG_RSP     = MSG_ID(BASC, 0x05),
+
+    /// Indicate to APP that the Battery Level value has been received
+    BASC_BATT_LEVEL_IND             = MSG_ID(BASC, 0x06),
+};
+#endif
+
+void xc_basc_enbale_req()
+{
+    //send msg
+    BASC_ENABLE_REQ
+}
+
+void xc_basc_read_info_req()
+{
+    //send msg
+    BASC_READ_INFO_REQ
+}
+
+void xc_basc_batt_leval_ntf_cfg_req()
+{
+    //send msg
+    BASC_BATT_LEVEL_NTF_CFG_REQ
+}
+
+
+
+/// Default State handlers definition
+KE_MSG_HANDLER_TAB(basc)
+{
+    // Note: all messages must be sorted in ID ascending order
+
+    {BASC_ENABLE_RSP,               (ke_msg_func_t) xxx_handler             },
+    {BASC_READ_INFO_RSP,            (ke_msg_func_t) xxx_handler          },
+    {BASC_BATT_LEVEL_NTF_CFG_RSP,   (ke_msg_func_t) xxx_handler },
+    {BASC_BATT_LEVEL_IND,   (ke_msg_func_t) xxx_handler },
+};
+
+

project/example/ble/ble_central/app/src/app_sec.c

@@ -0,0 +1,546 @@
+/**
+ ****************************************************************************************
+ *
+ * @file app_sec.c
+ *
+ * @brief Application Security Entry Point
+ *
+ * Copyright (C) RivieraWaves 2009-2015
+ *
+ *
+ ****************************************************************************************
+ */
+
+/**
+ ****************************************************************************************
+ * @addtogroup APP
+ * @{
+ ****************************************************************************************
+ */
+
+/*
+ * INCLUDE FILES
+ ****************************************************************************************
+ */
+#include "rwip_config.h"
+#if (BLE_APP_PRESENT)
+#if (BLE_HOST_SUPPORT_SMP)
+#include "rwip_config.h"
+
+#include <string.h>
+#include "co_utils.h"
+#include "co_math.h"
+//#include "gapc_task.h"      // GAP Controller Task API Definition
+#include "gap.h"            // GAP Definition
+#include "gapc.h"           // GAPC Definition
+#include "gapc_int.h"
+#include "prf_types.h"
+
+#include "app_sec.h"        // Application Security API Definition
+#include "app_task.h"       // Application Manager API Definition
+
+#if (NVDS_SUPPORT)
+#include "nvds.h"           // NVDS API Definitions
+#endif //(NVDS_SUPPORT)
+
+#include "app_task.h"
+uint8_t bond_flag = 0;
+struct gapc_ltk g_ltk = {0};
+/*
+ * GLOBAL VARIABLE DEFINITIONS
+ ****************************************************************************************
+ */
+
+/// Application Security Environment Structure
+struct app_sec_env_tag app_sec_env;
+
+/*
+ * GLOBAL FUNCTION DEFINITIONS
+ ****************************************************************************************
+ */
+
+void app_sec_init()
+{
+    /*------------------------------------------------------
+     * RETRIEVE BOND STATUS
+     *------------------------------------------------------*/
+    #if (NVDS_SUPPORT)
+    uint8_t length = NVDS_LEN_PERIPH_BONDED;
+
+    // Get bond status from NVDS
+    if (nvds_get(NVDS_TAG_PERIPH_BONDED, &length, (uint8_t *)&app_sec_env.bonded) != NVDS_OK)
+    {
+        // If read value is invalid, set status to not bonded
+        app_sec_env.bonded = false;
+    }
+
+    if ((app_sec_env.bonded != true) && (app_sec_env.bonded != false))
+    {
+        app_sec_env.bonded = false;
+    }
+    LOGI("===bond_state:%d\r\n",app_sec_env.bonded);
+   #endif //(NVDS_SUPPORT)
+}
+
+bool app_sec_get_bond_status(void)
+{
+    return app_sec_env.bonded;
+}
+
+#if (NVDS_SUPPORT)
+void app_sec_remove_bond(void)
+{
+    #if (BLE_APP_HID)
+    uint16_t ntf_cfg = PRF_CLI_STOP_NTFIND;
+    #endif //(BLE_APP_HID)
+
+    // Check if we are well bonded
+    if (app_sec_env.bonded == true)
+    {
+        // Update the environment variable
+        app_sec_env.bonded = false;
+
+        if (nvds_put(NVDS_TAG_PERIPH_BONDED, NVDS_LEN_PERIPH_BONDED,
+                     (uint8_t *)&app_sec_env.bonded) != NVDS_OK)
+        {
+            ASSERT_ERR(0);
+        }
+
+        if (nvds_del(NVDS_TAG_LTK) != NVDS_OK)
+        {
+            ASSERT_ERR(0);
+        }
+
+        if (nvds_del(NVDS_TAG_PEER_BD_ADDRESS) != NVDS_OK)
+        {
+            ASSERT_ERR(0);
+        }
+     
+        #if (BLE_APP_HID)
+        if (nvds_put(NVDS_TAG_MOUSE_NTF_CFG, NVDS_LEN_MOUSE_NTF_CFG,
+                     (uint8_t *)&ntf_cfg) != NVDS_OK)
+        {
+            ASSERT_ERR(0);
+        }
+        #endif //(BLE_APP_HID)
+    }
+}
+#endif //(NVDS_SUPPORT)
+
+
+/*
+ * MESSAGE HANDLERS
+ ****************************************************************************************
+ */
+static int app_sec_msg_dflt_handler(ke_msg_id_t const msgid,
+                                    void *param,
+                                    ke_task_id_t const dest_id,
+                                    ke_task_id_t const src_id)
+{
+    // Drop the message
+
+    return (KE_MSG_CONSUMED);
+}
+
+
+
+
+
+static int gapc_bond_req_ind_handler(ke_msg_id_t const msgid,
+                                     void const * p_param,
+                                     ke_task_id_t const dest_id,
+                                     ke_task_id_t const src_id)
+{
+    struct gapc_bond_req_ind *param = (struct gapc_bond_req_ind *)p_param;
+    LOGI(" [debug] gapc_bond_req_ind_handler,request:0x%x \r\n",param->request);
+    // Prepare the GAPC_BOND_CFM message
+    struct gapc_bond_cfm *cfm = KE_MSG_ALLOC(GAPC_BOND_CFM,
+                                             src_id, TASK_APP,
+                                             gapc_bond_cfm);                                          
+    switch (param->request)
+    {
+        case (GAPC_PAIRING_REQ):
+        {
+            cfm->request = GAPC_PAIRING_RSP;
+            {
+                cfm->accept  = true;
+				#if (BLE_SEC_CON)
+				cfm->data.pairing_feat.auth      = GAP_AUTH_REQ_SEC_CON_BOND;
+				#else // (BLE_SEC_CON)
+				cfm->data.pairing_feat.auth      = GAP_AUTH_REQ_NO_MITM_BOND;
+				#endif // (BLE_SEC_CON)
+                
+                app_env.sec_con_enabled = true;
+                cfm->data.pairing_feat.iocap     = GAP_IO_CAP_NO_INPUT_NO_OUTPUT;//GAP_IO_CAP_KB_ONLY;//GAP_IO_CAP_DISPLAY_ONLY;//GAP_IO_CAP_NO_INPUT_NO_OUTPUT;
+                cfm->data.pairing_feat.key_size  = 16;
+                cfm->data.pairing_feat.oob       = GAP_OOB_AUTH_DATA_NOT_PRESENT;
+                cfm->data.pairing_feat.sec_req   = GAP_SEC1_NOAUTH_PAIR_ENC;//GAP_SEC1_AUTH_PAIR_ENC;//GAP_NO_SEC;
+                cfm->data.pairing_feat.rkey_dist = GAP_KDIST_ENCKEY | GAP_KDIST_IDKEY;
+                cfm->data.pairing_feat.ikey_dist = GAP_KDIST_ENCKEY | GAP_KDIST_IDKEY;
+            }
+        } break;
+
+        case (GAPC_LTK_EXCH):
+        {
+            // Counter
+            uint8_t counter;
+            cfm->accept  = true;
+            cfm->request = GAPC_LTK_EXCH;
+            // Generate all the values
+            cfm->data.ltk.ediv = (uint16_t)co_rand_word();
+
+            for (counter = 0; counter < RAND_NB_LEN; counter++)
+            {
+                cfm->data.ltk.ltk.key[counter]    = (uint8_t)co_rand_word();
+                cfm->data.ltk.randnb.nb[counter] = (uint8_t)co_rand_word();
+            }
+
+            for (counter = RAND_NB_LEN; counter < KEY_LEN; counter++)
+            {
+                cfm->data.ltk.ltk.key[counter]    = (uint8_t)co_rand_word();
+            }
+#if (1)
+            LOGI( "nvds_put cfm->ediv=0x%x\r\nparam_randnb:",cfm->data.ltk.ediv);
+            for(uint8_t i=0;i<GAP_RAND_NB_LEN;i++)
+                LOGI( "%x",cfm->data.ltk.randnb.nb[i]);  
+            LOGI("\r\nltk:");
+            for(uint8_t i=0;i<GAP_KEY_LEN;i++)
+                LOGI( "%x",cfm->data.ltk.ltk.key[i]);  
+            LOGI("\r\n");
+#endif             
+
+            #if (NVDS_SUPPORT)
+            uint8_t err = nvds_del(NVDS_TAG_LTK);
+           LOGI("err2 =%d \n", err);
+            // Store the generated value in NVDS
+            if (nvds_put(NVDS_TAG_LTK, NVDS_LEN_LTK, (uint8_t *)&cfm->data.ltk) != NVDS_OK)
+            {
+                ASSERT_ERR(0);
+            }
+            
+//            uint8_t buff5[10] = {1,2,3,4,5,6,9,8,9,11};
+//          // LOGI("nvds del:%d \r\n",nvds_del(16)); 
+//           if (nvds_put(18, 10, buff5) != NVDS_OK)               
+//           {
+//               LOGI("77111\r\n");
+//               ASSERT_ERR(0);
+//           }
+//           LOGI("77222\r\n");
+  
+            #endif // #if (NVDS_SUPPORT)
+        } break;
+
+
+        case (GAPC_IRK_EXCH):
+        {
+            #if (NVDS_SUPPORT)
+            uint8_t addr_len = BD_ADDR_LEN;
+            #endif //(NVDS_SUPPORT)
+
+            cfm->accept  = true;
+            cfm->request = GAPC_IRK_EXCH;
+
+            // Load IRK
+            memcpy(cfm->data.irk.irk.key, app_env.loc_irk, KEY_LEN);
+
+            #if (NVDS_SUPPORT)
+            if (nvds_get(NVDS_TAG_BD_ADDRESS, &addr_len, cfm->data.irk.addr.addr) != NVDS_OK)
+            #endif //(NVDS_SUPPORT)
+            {
+                ASSERT_ERR(0);
+            }
+            // load device address
+            cfm->data.irk.addr.addr_type = (cfm->data.irk.addr.addr[5] & 0xC0) ? ADDR_RAND : ADDR_PUBLIC;
+        } break;
+
+
+        //#if (BLE_APP_HT)
+        case (GAPC_TK_EXCH):
+        {
+            // Generate a PIN Code- (Between 100000 and 999999)
+            uint32_t pin_code = (100000 + (co_rand_word()%900000));
+
+            LOGI("app_sec GAPC_TK_EXCH: tk_type=%d\r\n",param->data.tk_type);
+            cfm->accept  = true;
+            cfm->request = GAPC_TK_EXCH;
+
+            // Set the TK value
+            memset(cfm->data.tk.key, 0, KEY_LEN);
+
+            cfm->data.tk.key[0] = (uint8_t)((pin_code & 0x000000FF) >>  0);
+            cfm->data.tk.key[1] = (uint8_t)((pin_code & 0x0000FF00) >>  8);
+            cfm->data.tk.key[2] = (uint8_t)((pin_code & 0x00FF0000) >> 16);
+            cfm->data.tk.key[3] = (uint8_t)((pin_code & 0xFF000000) >> 24);
+
+           LOGI("###GAPC_TK_EXCH pincode=%d\r\n", pin_code);
+
+        } break;
+        //#endif //(BLE_APP_HT)
+
+        default:
+        {
+            ASSERT_ERR(0);
+        } break;
+    }
+
+    // Send the message
+    ke_msg_send(cfm);
+
+    return (KE_MSG_CONSUMED);
+}
+
+static int gapc_bond_ind_handler(ke_msg_id_t const msgid,
+                                 void const *p_param,
+                                 ke_task_id_t const dest_id,
+                                 ke_task_id_t const src_id)
+{
+    struct gapc_bond_ind const *param = (struct gapc_bond_ind const *)p_param;
+
+    LOGI(" [debug] gapc_bond_ind_handler : info=%d\r\n", param->info);
+    switch (param->info)
+    {
+        case (GAPC_PAIRING_SUCCEED):
+        {
+            // Update the bonding status in the environment
+            app_sec_env.bonded = true;
+            bond_flag = 1;
+            LOGI("GAPC_PAIRING_SUCCEED auth=%d,ltk_present=%d\r\n", 
+                                param->data.pairing.level,param->data.pairing.ltk_present);
+
+            // Update the bonding status in the environment
+            #if (PLF_NVDS)
+             uint8_t err = nvds_del(NVDS_TAG_PERIPH_BONDED);
+           LOGI("err1 =%d \n", err);
+            if (nvds_put(NVDS_TAG_PERIPH_BONDED, NVDS_LEN_PERIPH_BONDED,
+                         (uint8_t *)&app_sec_env.bonded) != NVDS_OK)
+            {
+                // An error has occurred during access to the NVDS
+                ASSERT_ERR(0);
+                 LOGI("3\n");
+            }
+             LOGI("4\n");
+            // Set the BD Address of the peer device in NVDS
+            uint8_t err2 = nvds_del(NVDS_TAG_PEER_BD_ADDRESS);
+           LOGI("err2 =%d \n", err);
+			struct app_env_tag *app_env = get_app_env();
+            if (nvds_put(NVDS_TAG_PEER_BD_ADDRESS, NVDS_LEN_PEER_BD_ADDRESS,
+                         (uint8_t *)gapc_get_bdaddr(app_env->slave_conidx, GAPC_SMP_INFO_PEER)) != NVDS_OK)
+            {
+                // An error has occurred during access to the NVDS
+                ASSERT_ERR(0);
+                  LOGI("5\n");
+            }
+          LOGI("6\n");
+            #endif //(PLF_NVDS)
+
+
+
+        } break;
+
+        case (GAPC_REPEATED_ATTEMPT):
+        {
+           // app_disconnect();
+        } break;
+
+        case (GAPC_IRK_EXCH):
+        {
+           
+            #if (NVDS_SUPPORT)
+           // Store peer identity in NVDS
+          LOGI("GAPC_IRK_EXCH\r\n");
+            uint8_t err = nvds_del(NVDS_TAG_PEER_IRK);
+           LOGI("err2 =%d \n", err);
+           if (nvds_put(NVDS_TAG_PEER_IRK, NVDS_LEN_PEER_IRK, (uint8_t *)&param->data.irk.irk.key[0]) != NVDS_OK) 
+          
+           {
+              LOGI("1\r\n");
+               ASSERT_ERR(0);
+           }
+            LOGI("2\r\n");
+
+           #endif // (NVDS_SUPPORT)
+        } break;
+
+        case (GAPC_PAIRING_FAILED):
+        {
+           // app_sec_send_security_req(0);
+        } break;
+
+        // In Secure Connections we get BOND_IND with SMPC calculated LTK
+        case (GAPC_LTK_EXCH) :
+        {
+    LOGI( "GAPC_LTK_EXCH sec_con_enabled=%d\r\n",app_env.sec_con_enabled);
+
+            LOGI( " param->ediv=0x%x\r\nparam_randnb:",param->data.ltk.ediv);
+            for(uint8_t i=0;i<GAP_RAND_NB_LEN;i++)
+                LOGI( "%x",param->data.ltk.randnb.nb[i]);  
+            LOGI("\r\nltk:");
+            for(uint8_t i=0;i<GAP_KEY_LEN;i++)
+                LOGI( "%x",param->data.ltk.ltk.key[i]);  
+            LOGI("\r\n");
+
+            #if (0)
+            if (app_env.sec_con_enabled == true)
+            {
+                #if (NVDS_SUPPORT)
+                // Store LTK in NVDS
+                if (nvds_put(NVDS_TAG_LTK, NVDS_LEN_LTK,(uint8_t *)&param->data.ltk.ltk.key[0]) != NVDS_OK)
+                {
+                    ASSERT_ERR(0);
+                }
+                #endif // (NVDS_SUPPORT)
+            }
+            #endif // (BLE_APP_SEC_CON)
+        }
+        break;
+
+        default:
+        {
+            ASSERT_ERR(0);
+        } break;
+    }
+
+    return (KE_MSG_CONSUMED);
+}
+
+static int gapc_encrypt_req_ind_handler(ke_msg_id_t const msgid,
+                                        void const *p_param,
+                                        ke_task_id_t const dest_id,
+                                        ke_task_id_t const src_id)
+{
+    #if (NVDS_SUPPORT)
+    struct gapc_encrypt_req_ind const *param = (struct gapc_encrypt_req_ind const *)p_param;
+    #endif // (NVDS_SUPPORT)
+    LOGI(" [debug] gapc_encrypt_req_ind_handler \r\n");
+
+    #if (NVDS_SUPPORT)
+    // LTK value
+    struct gapc_ltk ltk;
+    // Length
+    uint8_t length = NVDS_LEN_LTK;
+    #endif // #if (NVDS_SUPPORT)
+
+    // Prepare the GAPC_ENCRYPT_CFM message
+    struct gapc_encrypt_cfm *cfm = KE_MSG_ALLOC(GAPC_ENCRYPT_CFM,
+                                                src_id, TASK_APP,
+                                                gapc_encrypt_cfm);
+
+    cfm->found    = false;
+    
+
+    LOGI("app_sec gapc_encrypt_req_ind_handler: bonded=%d\r\n", app_sec_env.bonded);
+
+
+   // if (app_sec_env.bonded)
+    {
+        #if (NVDS_SUPPORT)
+        // Retrieve the required informations from NVDS
+        if (nvds_get(NVDS_TAG_LTK, &length, (uint8_t *)&ltk) == NVDS_OK)
+        {
+       
+
+            LOGI( "nvds_get param->ediv=0x%x,ltk.ediv=0x%x\r\nparam_randnb:",param->ediv,ltk.ediv);
+            for(uint8_t i=0;i<GAP_RAND_NB_LEN;i++)
+                LOGI( "%x",param->rand_nb.nb[i]);  
+            LOGI("\r\nltk.randnb.nb:");
+            for(uint8_t i=0;i<GAP_RAND_NB_LEN;i++)
+                LOGI( "%x",ltk.randnb.nb[i]);  
+            LOGI("\r\n");
+            
+        
+            // Check if the provided EDIV and Rand Nb values match with the stored values
+            if ((param->ediv == ltk.ediv) &&
+                !memcmp(&param->rand_nb.nb[0], &ltk.randnb.nb[0], sizeof(struct rand_nb)))
+            {
+                LOGI("EDIV and randnb are same!!!\r\n");
+                cfm->found    = true;
+                cfm->key_size = 16;
+                memcpy(&cfm->ltk, &ltk.ltk, sizeof(struct gap_sec_key));
+                bond_flag = 1;
+            }
+            else
+            {
+                LOGI("EDIV and randnb not same!!!\r\n");
+            }
+            /*
+             * else we are bonded with another device, disconnect the link
+             */
+        }
+        else
+        {
+            ASSERT_ERR(0);
+        }
+        #endif // (NVDS_SUPPORT)
+    }
+    /*
+     * else the peer device is not known, an error should trigger a new pairing procedure.
+     */
+
+    // Send the message
+    ke_msg_send(cfm);
+
+    
+    
+    
+
+    return (KE_MSG_CONSUMED);
+}
+
+
+static int gapc_encrypt_ind_handler(ke_msg_id_t const msgid,
+                                    void const *p_param,
+                                    ke_task_id_t const dest_id,
+                                    ke_task_id_t const src_id)
+{
+    struct gapc_encrypt_ind const *param = (struct gapc_encrypt_ind const *)p_param;
+    LOGI(" [debug] gapc_encrypt_ind_handler \r\n");
+
+    // encryption/ re-encryption succeeded
+
+    LOGI("app_sec gapc_encrypt_ind_handler: auth=%d\r\n", param->pairing_lvl);
+
+
+//    struct gapc_set_le_pkt_size_cmd *req = KE_MSG_ALLOC(GAPC_SET_LE_PKT_SIZE_CMD,
+//                                                        KE_BUILD_ID(TASK_GAPC, KE_IDX_GET(src_id)), TASK_APP,
+//                                                        gapc_set_le_pkt_size_cmd);
+
+//    req->operation = GAPC_SET_LE_PKT_SIZE;
+//    req->tx_octets = 0xFB;
+//    req->tx_time = 2120;
+
+//    // Send the message
+//    ke_msg_send(req);
+
+
+    
+    
+    return (KE_MSG_CONSUMED);
+}
+
+
+
+
+
+ /*
+  * LOCAL VARIABLE DEFINITIONS
+  ****************************************************************************************
+  */
+
+/// Default State handlers definition
+const struct ke_msg_handler app_sec_msg_handler_list[] =
+{
+    // Note: first message is latest message checked by kernel so default is put on top.
+    {KE_MSG_DEFAULT_HANDLER,  (ke_msg_func_t)app_sec_msg_dflt_handler},
+
+    {GAPC_BOND_REQ_IND,       (ke_msg_func_t)gapc_bond_req_ind_handler},
+    {GAPC_BOND_IND,           (ke_msg_func_t)gapc_bond_ind_handler},
+
+    {GAPC_ENCRYPT_REQ_IND,    (ke_msg_func_t)gapc_encrypt_req_ind_handler},
+    {GAPC_ENCRYPT_IND,        (ke_msg_func_t)gapc_encrypt_ind_handler},
+};
+
+const struct app_subtask_handlers app_sec_handlers = {&app_sec_msg_handler_list[0], ARRAY_LEN(app_sec_msg_handler_list)};
+#endif
+#endif // (BLE_APP_PRESENT)
+
+/// @} APP

project/example/ble/ble_central/app/src/app_sec.h

@@ -0,0 +1,93 @@
+/**
+ ****************************************************************************************
+ *
+ * @file app_sec.h
+ *
+ * @brief Application Security Entry Point
+ *
+ * Copyright (C) RivieraWaves 2009-2015
+ *
+ *
+ ****************************************************************************************
+ */
+
+/**
+ ****************************************************************************************
+ * @addtogroup APP_SEC
+ * @{
+ ****************************************************************************************
+ */
+
+#ifndef APP_SEC_H_
+#define APP_SEC_H_
+
+/*
+ * INCLUDE FILES
+ ****************************************************************************************
+ */
+
+#include "rwip_config.h"
+#include <stdbool.h>
+#include <stdint.h> // Standard Integer Definition
+/*
+ * DEFINES
+ ****************************************************************************************
+ */
+
+/*
+ * STRUCTURES DEFINITIONS
+ ****************************************************************************************
+ */
+
+struct app_sec_env_tag
+{
+    // Bond status
+    bool bonded;
+};
+
+/*
+ * GLOBAL VARIABLE DECLARATIONS
+ ****************************************************************************************
+ */
+
+/// Application Security Environment
+extern struct app_sec_env_tag app_sec_env;
+
+/// Table of message handlers
+extern const struct app_subtask_handlers app_sec_handlers;
+
+/*
+ * GLOBAL FUNCTIONS DECLARATIONS
+ ****************************************************************************************
+ */
+
+/**
+ ****************************************************************************************
+ * @brief Initialize the Application Security Module
+ ****************************************************************************************
+ */
+void app_sec_init(void);
+
+#if (NVDS_SUPPORT)
+/**
+ ****************************************************************************************
+ * @brief Remove all bond data stored in NVDS
+ ****************************************************************************************
+ */
+void app_sec_remove_bond(void);
+#endif //(NVDS_SUPPORT)
+
+/**
+ ****************************************************************************************
+ * @brief Send a security request to the peer device. This function is used to
+ *require the central to start the encryption with a LTK that would have shared
+ *during a previous bond procedure.
+ *
+ * @param[in]   - conidx: Connection Index
+ ****************************************************************************************
+ */
+void app_sec_send_security_req(uint8_t conidx);
+
+#endif // APP_SEC_H_
+
+/// @} APP_SEC

project/example/ble/ble_central/app/src/app_task.c

@@ -0,0 +1,983 @@
+/**
+ ****************************************************************************************
+ *
+ * @file app_task.c
+ *
+ * @brief RW APP Task implementation
+ *
+ * Copyright (C) RivieraWaves 2009-2015
+ *
+ *
+ ****************************************************************************************
+ */
+
+#include "app_task.h" // Application Manager Task API
+#include "timer.h"
+#include "xc_drv_timer.h"
+#include "lld_int.h"
+
+extern struct lld_env_tag lld_env;
+__RAM_EM struct conn_dev_info conn_dev[CONNECT_DEV_NUM] = {0};
+
+/// Application Task Descriptor
+const struct ke_task_desc TASK_DESC_APP;
+/// Application Environment Structure
+__RAM_EM struct app_env_tag app_env = {
+    .adv_actv_idx     = INVALID_DATA,
+    .scan_actv_idx    = INVALID_DATA,
+    .init_actv_idx    = INVALID_DATA,
+    .slave_conidx     = INVALID_DATA,
+    .master_conidx    = INVALID_DATA,
+    .slave_connected  = false,
+    .master_connected = false,
+};
+
+static uint8_t gapc_callback(ke_msg_id_t const msgid, void const *param,
+                             ke_task_id_t const dest_id,
+                             ke_task_id_t const src_id);
+
+static uint8_t gapm_callback(ke_msg_id_t const msgid, void const *param,
+                             ke_task_id_t const dest_id,
+                             ke_task_id_t const src_id);
+
+struct app_env_tag *get_app_env(void) { return &app_env; }
+
+uint8_t find_conn_dev(uint8_t *addr)
+{
+    uint8_t find_idx = 0xFF;
+    for (uint8_t i = 0; i < CONNECT_DEV_NUM; i++) {
+        if (memcmp(&(conn_dev[i].addr[0]), &addr[0], GAP_BD_ADDR_LEN) == 0) {
+            find_idx = i;
+            break;
+        }
+    }
+    return find_idx;
+}
+
+
+uint8_t calc_conn_num(void)
+{
+    uint8_t num = 0;
+    for(uint8_t i  = 0; i <CONNECT_DEV_NUM ;i++)
+    {
+        if(conn_dev[i].connnectd)
+        {
+            num++;
+        }
+    }
+    return num;
+}
+
+void printf_conn_dev(void)
+{
+    for(uint8_t i  = 0; i <CONNECT_DEV_NUM ;i++)
+    {
+        LOGI(" idx :%d  condix :%d addr:%x %x %x %x %x %x   connectd:%d \r\n",i,conn_dev[i].conidx,conn_dev[i].addr[0],conn_dev[i].addr[1],conn_dev[i].addr[2],conn_dev[i].addr[3],conn_dev[i].addr[4],conn_dev[i].addr[5],conn_dev[i].connnectd);
+    }
+   
+}
+
+
+uint8_t find_conn_dev_idx(uint8_t conidx)
+{
+    uint8_t find_idx = 0xFF;
+    for (uint8_t i = 0; i < CONNECT_DEV_NUM; i++) {
+        if (conn_dev[i].conidx == conidx) {
+            find_idx = i;
+            break;
+        }
+    }
+    return find_idx;
+}
+
+uint8_t add_conn_dev(uint8_t *addr)
+{
+    uint8_t add_idx        = 0xFF;
+    uint8_t invild_addr[6] = {0, 0, 0, 0, 0, 0};
+    for (uint8_t i = 0; i < CONNECT_DEV_NUM; i++) {
+        if (memcmp(&(conn_dev[i].addr[0]), &invild_addr[0], GAP_BD_ADDR_LEN) ==
+            0) {
+            memcpy(&(conn_dev[i].addr[0]), &addr[0], GAP_BD_ADDR_LEN);
+            add_idx = i;
+            break;
+        }
+    }
+    return add_idx;
+}
+
+void app_init()
+{
+    // Reset the application manager environment
+    // memset(&app_env, 0, sizeof(app_env));
+    // Create APP task
+    ke_task_create(TASK_APP, &TASK_DESC_APP);
+    // Initialize Task state
+    ke_state_set(TASK_APP, APP_INIT);
+#if (NVDS_SUPPORT)
+    // Get the Device Name to add in the Advertising Data (Default one or NVDS
+    // one)
+    // app_env.dev_name_len = APP_DEVICE_NAME_MAX_LEN;
+    // if (nvds_get(NVDS_TAG_DEVICE_NAME, &(app_env.dev_name_len),
+    // app_env.dev_name) != NVDS_OK)
+#endif //(NVDS_SUPPORT)
+    {
+        // Get default Device Name (No name if not enough space)
+        memcpy(app_env.dev_name, APP_DFLT_DEVICE_NAME,
+               APP_DFLT_DEVICE_NAME_LEN);
+        app_env.dev_name_len = APP_DFLT_DEVICE_NAME_LEN;
+    }
+    // Reset the stack
+    xc_ble_gapm_reset();
+    for(uint8_t i  = 0;i<CONNECT_DEV_NUM;i++)
+    {
+        conn_dev[i].conidx =0xff;
+    }
+    
+}
+
+uint8_t app_get_dev_name(uint8_t *name)
+{
+    if ((app_env.dev_name_len > 0) &&
+        (app_env.dev_name_len <= APP_DEVICE_NAME_MAX_LEN) && (name != NULL)) {
+        // copy name to provided pointer
+        memcpy(name, app_env.dev_name, APP_DFLT_DEVICE_NAME_LEN);
+        // return name length
+        return app_env.dev_name_len;
+    } else {
+        return 0;
+    }
+}
+
+void app_set_dev_name(uint8_t *name, uint8_t name_len)
+{
+    if ((name_len > 0) && (name_len <= APP_DEVICE_NAME_MAX_LEN) &&
+        (name != NULL)) {
+        memcpy(app_env.dev_name, name, name_len);
+        app_env.dev_name_len = name_len;
+    }
+}
+
+#if MULTI_ROLE_TEST
+// adv
+void app_create_advertising(void)
+{
+    if (app_env.adv_state == APP_ADV_STATE_IDLE) {
+        struct gapm_activity_create_adv_cmd param = {0};
+        param.own_addr_type                       = GAPM_STATIC_ADDR;
+        param.adv_param.type                      = GAPM_ADV_TYPE_LEGACY;
+        param.adv_param.disc_mode                 = GAPM_ADV_MODE_GEN_DISC;
+        param.adv_param.prop                  = GAPM_ADV_PROP_UNDIR_CONN_MASK;
+        param.adv_param.max_tx_pwr            = APP_MAX_TX_POWER;
+        param.adv_param.filter_pol            = ADV_ALLOW_SCAN_ANY_CON_ANY;
+        param.adv_param.prim_cfg.adv_intv_min = APP_ADV_INT_MIN;
+        param.adv_param.prim_cfg.adv_intv_max = APP_ADV_INT_MAX;
+        param.adv_param.prim_cfg.chnl_map     = APP_ADV_CHMAP;
+        param.adv_param.prim_cfg.phy          = GAP_PHY_1MBPS;
+
+        xc_ble_advertise_create(&param);
+        app_env.adv_state = APP_ADV_STATE_STARTING;
+    }
+}
+
+void app_set_adv_data(void)
+{
+    if (app_env.adv_state == APP_ADV_STATE_STARTING) {
+        uint8_t adv_data[ADV_DATA_MAX_LENGTH] = {0};
+        adv_data[0]                           = APP_DFLT_DEVICE_NAME_LEN + 1;
+        adv_data[1]                           = GAP_AD_TYPE_COMPLETE_NAME;
+        memcpy(&adv_data[2], APP_DFLT_DEVICE_NAME, APP_DFLT_DEVICE_NAME_LEN);
+        xc_ble_set_adv_data(app_env.adv_actv_idx, APP_DFLT_DEVICE_NAME_LEN + 2,
+                            adv_data);
+        app_env.adv_state = APP_ADV_STATE_SETTING_ADV_DATA;
+    }
+}
+
+void app_set_scan_rsp_data(void)
+{
+    if (app_env.adv_state == APP_ADV_STATE_SETTING_ADV_DATA) {
+        uint8_t scan_rsp_data[ADV_DATA_MAX_LENGTH] = {0};
+        scan_rsp_data[0]                           = MANUFACTURER_DATA_LEN + 1;
+        scan_rsp_data[1] = GAP_AD_TYPE_MANU_SPECIFIC_DATA;
+        memcpy(&scan_rsp_data[2], MANUFACTURER_DATA, MANUFACTURER_DATA_LEN);
+        xc_ble_set_scan_rsp_data(app_env.adv_actv_idx,
+                                 MANUFACTURER_DATA_LEN + 2, scan_rsp_data);
+        app_env.adv_state = APP_ADV_STATE_SETTING_SCAN_RSP_DATA;
+    }
+}
+
+void app_start_advertising(void)
+{
+    if (app_env.adv_state == APP_ADV_STATE_SETTING_ADV_DATA ||
+        app_env.adv_state == APP_ADV_STATE_SETTING_SCAN_RSP_DATA ||
+        app_env.adv_state == APP_ADV_STATE_STOPPED) {
+        struct gapm_activity_start_cmd param = {0};
+        param.actv_idx                       = app_env.adv_actv_idx;
+        param.u_param.adv_add_param.duration = ADV_DURATION;
+
+        xc_ble_advertise_start(&param);
+        app_env.adv_state = APP_ADV_STATE_STARTING;
+    }
+}
+
+void app_stop_advertising(void)
+{
+    if (app_env.adv_state == APP_ADV_STATE_STARTING) {
+        xc_ble_activity_stop(app_env.adv_actv_idx);
+        app_env.adv_state = APP_ADV_STATE_STOPPING;
+    }
+}
+#endif
+// scan
+void app_create_scan(void)
+{
+    if (app_env.scan_state == APP_SCAN_STATE_IDLE) {
+        struct gapm_activity_create_cmd param = {
+            .own_addr_type = GAPM_STATIC_ADDR,
+        };
+        xc_ble_scan_create(&param);
+        app_env.scan_state = APP_SCAN_STATE_CREATING;
+    }
+}
+
+void app_start_scan(void)
+{
+    if (app_env.scan_state == APP_SCAN_STATE_CREATING ||
+        app_env.scan_state == APP_SCAN_STATE_STOPPED) {
+        struct gapm_activity_start_cmd scan_param = {0};
+        struct gapm_scan_param *param  = &scan_param.u_param.scan_param;
+        scan_param.actv_idx            = app_env.scan_actv_idx;
+        param->type                    = GAPM_SCAN_TYPE_OBSERVER;
+        param->prop                    = GAPM_SCAN_PROP_PHY_1M_BIT | GAPM_SCAN_PROP_ACTIVE_1M_BIT;
+        param->dup_filt_pol            = GAPM_DUP_FILT_DIS;
+        param->scan_param_1m.scan_intv = 0xa0; // 20*0.625 ms
+        param->scan_param_1m.scan_wd   = 0x50; // 15*0.625 ms
+        param->duration                = 0;
+
+        xc_ble_scan_start(&scan_param);
+        app_env.scan_state = APP_SCAN_STATE_STARTING;
+    }
+}
+
+void app_stop_scanning(void)
+{
+    if (app_env.scan_state == APP_SCAN_STATE_STARTING) {
+        xc_ble_activity_stop(app_env.scan_actv_idx);
+        app_env.scan_state = APP_SCAN_STATE_STOPPING;
+    }
+}
+
+// init
+
+void app_create_init(void)
+{
+    if (app_env.init_state == APP_INIT_STATE_IDLE) {
+        struct gapm_activity_create_cmd param = {
+            .own_addr_type = GAPM_STATIC_ADDR,
+        };
+
+        xc_ble_init_create(&param);
+        app_env.init_state = APP_INIT_STATE_CREATING;
+    }
+}
+
+void app_start_init(uint8_t addr_type, uint8_t *addr)
+{
+    LOGI(" start init state :%d \r\n", app_env.init_state);
+    #if !WHITE_LIST_TEST
+    if (app_env.init_state == APP_INIT_STATE_CREATING ||
+        app_env.init_state == APP_INIT_STATE_STOPPED)
+        #else
+        #endif
+    {
+        struct gapm_activity_start_cmd init_param = {0};
+        struct gapm_init_param *param       = &init_param.u_param.init_param;
+        init_param.actv_idx                 = app_env.init_actv_idx;
+        #if WHITE_LIST_TEST
+        param->type                         = GAPM_INIT_TYPE_AUTO_CONN_EST;
+        #else
+        param->type                         = GAPM_INIT_TYPE_DIRECT_CONN_EST;
+        #endif
+        param->prop                         = GAPM_INIT_PROP_1M_BIT;
+        param->conn_to                      = APP_CONN_EST_TIME_OUT;
+        param->scan_param_1m.scan_intv      = APP_CONN_SCNA_INTV;
+        param->scan_param_1m.scan_wd        = APP_CONN_SCAN_WD;
+        param->conn_param_1m.conn_intv_min  = APP_CONN_INTV_MIN;
+        param->conn_param_1m.conn_intv_max  = APP_CONN_INTV_MIN;
+        param->conn_param_1m.conn_latency   = APP_CONN_LATENCY;
+        param->conn_param_1m.supervision_to = APP_CONN_TIME_OUT;
+        param->peer_addr.addr_type          = addr_type;
+        memcpy(param->peer_addr.addr, addr, GAP_BD_ADDR_LEN);
+
+        xc_ble_init_start(&init_param);
+        app_env.init_state = APP_INIT_STATE_STARTING;
+    }
+}
+
+void app_stop_init(void)
+{
+    if (app_env.init_state == APP_INIT_STATE_STARTING) {
+        xc_ble_activity_stop(app_env.init_actv_idx);
+        app_env.init_state = APP_INIT_STATE_STOPPING;
+    }
+}
+
+static uint8_t
+app_get_handler(const struct app_subtask_handlers *handler_list_desc,
+                ke_msg_id_t msgid, void *p_param, ke_task_id_t src_id)
+{
+    // Counter
+    uint8_t counter;
+    // Get the message handler function by parsing the message table
+    for (counter = handler_list_desc->msg_cnt; 0 < counter; counter--) {
+        struct ke_msg_handler handler = (struct ke_msg_handler)(
+            *(handler_list_desc->p_msg_handler_tab + counter - 1));
+        if ((handler.id == msgid) || (handler.id == KE_MSG_DEFAULT_HANDLER)) {
+            // If handler is NULL, message should not have been received in this
+            // state
+            ASSERT_ERR(handler.func);
+            return (uint8_t)(handler.func(msgid, p_param, TASK_APP, src_id));
+        }
+    }
+
+    // If we are here no handler has been found, drop the message
+    return (KE_MSG_CONSUMED);
+}
+
+/**
+ ****************************************************************************************
+ * @brief Handles reception of all messages sent from the lower layers to the
+ *application
+ * @param[in] msgid     Id of the message received.
+ * @param[in] p_param   Pointer to the parameters of the message.
+ * @param[in] dest_id   ID of the receiving task instance
+ * @param[in] src_id    ID of the sending task instance.
+ *
+ * @return If the message was consumed or not.
+ ****************************************************************************************
+ */
+static int app_msg_handler(ke_msg_id_t const msgid, void *p_param,
+                           ke_task_id_t const dest_id,
+                           ke_task_id_t const src_id)
+{
+    // Retrieve identifier of the task from received message
+    ke_task_id_t src_task_id = MSG_T(msgid);
+    // Message policy
+    uint8_t msg_pol          = KE_MSG_CONSUMED;
+    switch (src_task_id) {
+    case TASK_ID_GAPM: {
+        msg_pol = gapm_callback(msgid, p_param, dest_id, src_id);
+    } break;
+    case TASK_ID_GAPC: {
+        if ((msgid >= GAPC_BOND_CMD) && (msgid <= GAPC_BOND_DATA_UPDATE_IND)) {
+            // Call the Security Module
+            msg_pol =
+                app_get_handler(&app_sec_handlers, msgid, p_param, src_id);
+        } else {
+            msg_pol = gapc_callback(msgid, p_param, dest_id, src_id);
+        }
+    } break;
+    case TASK_ID_GATT: {
+
+    } break;
+#if (BLE_APP_HT)
+    case (TASK_ID_HTPT): {
+        // Call the Health Thermometer Module
+        msg_pol = app_get_handler(&app_ht_handlers, msgid, p_param, src_id);
+    } break;
+#endif //(BLE_APP_HT)
+
+#if (BLE_APP_DIS)
+    case (TASK_ID_DISS): {
+        // Call the Device Information Module
+        msg_pol = app_get_handler(&app_dis_handlers, msgid, p_param, src_id);
+    } break;
+#endif //(BLE_APP_DIS)
+
+#if (BLE_APP_HID)
+    case (TASK_ID_HOGPD): {
+        // Call the HID Module
+        msg_pol = app_get_handler(&app_hid_handlers, msgid, p_param, src_id);
+    } break;
+#endif //(BLE_APP_HID)
+    default:
+        break;
+    }
+    return (msg_pol);
+}
+
+
+#define IP_DIAGCNTL_ADDR   0x53000050
+
+__INLINE void ip_diagcntl_pack(uint8_t diag3en, uint8_t diag3, uint8_t diag2en, uint8_t diag2, uint8_t diag1en, uint8_t diag1, uint8_t diag0en, uint8_t diag0)
+{
+    ASSERT_ERR((((uint32_t)diag3en << 31) & ~((uint32_t)0x80000000)) == 0);
+    ASSERT_ERR((((uint32_t)diag3 << 24) & ~((uint32_t)0x3F000000)) == 0);
+    ASSERT_ERR((((uint32_t)diag2en << 23) & ~((uint32_t)0x00800000)) == 0);
+    ASSERT_ERR((((uint32_t)diag2 << 16) & ~((uint32_t)0x003F0000)) == 0);
+    ASSERT_ERR((((uint32_t)diag1en << 15) & ~((uint32_t)0x00008000)) == 0);
+    ASSERT_ERR((((uint32_t)diag1 << 8) & ~((uint32_t)0x00003F00)) == 0);
+    ASSERT_ERR((((uint32_t)diag0en << 7) & ~((uint32_t)0x00000080)) == 0);
+    ASSERT_ERR((((uint32_t)diag0 << 0) & ~((uint32_t)0x0000003F)) == 0);
+    REG_IP_WR(IP_DIAGCNTL_ADDR,  ((uint32_t)diag3en << 31) | ((uint32_t)diag3 << 24) | ((uint32_t)diag2en << 23) | ((uint32_t)diag2 << 16) | ((uint32_t)diag1en << 15) | ((uint32_t)diag1 << 8) | ((uint32_t)diag0en << 7) | ((uint32_t)diag0 << 0));
+}
+
+
+/**
+ ****************************************************************************************
+ * @brief Handles GAP manager command complete events.
+ *
+ * @param[in] msgid     Id of the message received.
+ * @param[in] p_param   Pointer to the parameters of the message.
+ * @param[in] dest_id   ID of the receiving task instance (TASK_GAP).
+ * @param[in] src_id    ID of the sending task instance.
+ ****************************************************************************************
+ */
+static void gapm_cmp_evt(ke_msg_id_t const msgid,
+                         struct gapm_cmp_evt const *p_param,
+                         ke_task_id_t const dest_id, ke_task_id_t const src_id)
+{
+    LOGI(
+        " app gapm_cmp_evt operation:0x%02x,  act_id:0x%02x status :0x%02x\r\n",
+        p_param->operation, p_param->actv_idx, p_param->status);
+    if (p_param->status == GAP_ERR_NO_ERROR) {
+        switch (p_param->operation) {
+        // Reset completed
+        case GAPM_RESET: {
+            struct gapm_set_dev_config_cmd cfg_param = {
+                .role         = GAP_ROLE_ALL,
+                .pairing_mode = GAPM_PAIRING_SEC_CON | GAPM_PAIRING_LEGACY,
+                .sugg_max_tx_octets = BLE_MIN_OCTETS,
+                .sugg_max_tx_time   = BLE_MIN_TIME,
+            };
+            // SETF(cfg_param.att_cfg, GAPM_ATT_SLV_PREF_CON_PAR_EN, 1);
+            xc_ble_set_dev_config(&cfg_param);
+#if (FLASH_TEST_IN_TASK || FLASH_TEST_IN_BLUETOOTH_GAP)
+            ke_timer_set(ONE_SEC_TIMER_MSG, TASK_APP, 1000);
+#endif // #if (FLASH_TEST_IN_TASK || FLASH_TEST_IN_BLUETOOTH_GAP)
+
+            if (CFG_CON > 1) {
+                extern uint8_t rwip_prog_delay;
+                rwip_prog_delay = 6;
+            }
+            lld_env.dft_slave_md = 0;
+            // ip_diagcntl_pack(0,0,0,0,1,0x7c,1,0x3);
+        } break;
+        case GAPM_SET_DEV_CONFIG: {
+#if WHITE_LIST_TEST
+            gap_bdaddr_t wl_info[10] = {0};
+            uint8_t addr1[6] = {0x89, 0x23, 0x33, 0x46, 0x55, 0x88}; 
+            uint8_t addr2[6] = {0x21 ,0x9c,  0xe4 ,0xd2 ,0xe6 ,0x02};
+            uint8_t addr3[6] = {0x21 ,0x9c,  0xb8 ,0xd3 ,0x0e ,0x13 };
+            uint8_t addr4[6] = {0x21 ,0x9c,  0xe4 ,0xd2 ,0x7d ,0x02 };
+          
+            
+            
+            
+            
+//           wl_info[0].addr_type = 1;
+//            wl_info[1].addr_type = 1;
+//             wl_info[2].addr_type = 1;
+            memcpy(&wl_info[0].addr[0],&addr1[0],6);
+            memcpy(&wl_info[1].addr[0],&addr2[0],6);
+            memcpy(&wl_info[2].addr[0],&addr3[0],6);
+            memcpy(&wl_info[3].addr[0],&addr4[0],6);
+ 
+            xc_ble_set_white_list(4, &wl_info[0]);
+#endif        
+            // xc_ble_gen_random_nb();
+            // xc_ble_gen_random_nb();
+        // } break;
+        // case GAPM_GEN_RAND_NB: {
+            // if (app_env.rand_cnt == 2) {
+                gap_sec_key_t irk = {0};
+                memcpy(&irk.key[0], &app_env.loc_irk[0], GAP_KEY_LEN);
+                xc_ble_set_irk(&irk);
+                // app_env.rand_cnt = 0;
+                if (!app_cli_register()) {
+                    app_create_scan();
+                    app_create_init();
+                }
+#if MULTI_ROLE_TEST
+                if (!custom_svc_add()) {
+                    app_create_advertising();
+                }
+#endif
+            // }
+
+        } break;
+
+        case GAPM_SET_ADV_DATA: {
+#if MULTI_ROLE_TEST
+            app_start_advertising();
+#endif
+        } break;
+
+        default:
+            break;
+        }
+    } else {
+        ASSERT_ERR(0);
+    }
+}
+
+static void gapc_get_device_info_req_ind(
+    ke_msg_id_t const msgid, struct gapc_get_dev_info_req_ind const *param,
+    ke_task_id_t const dest_id, ke_task_id_t const src_id)
+{
+    uint8_t conidx                   = KE_IDX_GET(src_id);
+    struct gapc_get_dev_info_cfm *pcfm = NULL;
+    switch (param->req) {
+    case GAPC_DEV_NAME: {
+        pcfm = KE_MSG_ALLOC_DYN(
+            GAPC_GET_DEV_INFO_CFM, KE_BUILD_ID(TASK_GAPC, conidx), TASK_APP,
+            gapc_get_dev_info_cfm, DEVICE_NAME_MAX_LEN);
+        pcfm->req                    = param->req;
+        pcfm->token                  = param->token;
+        pcfm->status                 = GAP_ERR_NO_ERROR;
+        pcfm->info.name.value_length = app_get_dev_name(pcfm->info.name.value);
+    } break;
+
+    case GAPC_DEV_APPEARANCE: {
+        pcfm = KE_MSG_ALLOC_DYN(
+            GAPC_GET_DEV_INFO_CFM, KE_BUILD_ID(TASK_GAPC, conidx), TASK_APP,
+            gapc_get_dev_info_cfm, 0);
+        pcfm->req             = param->req;
+        pcfm->info.appearance = DEV_APPEARANCE;
+        pcfm->token           = param->token;
+        pcfm->status          = GAP_ERR_NO_ERROR;
+    } break;
+
+    case GAPC_DEV_SLV_PREF_PARAMS: {
+        pcfm = KE_MSG_ALLOC_DYN(
+            GAPC_GET_DEV_INFO_CFM, KE_BUILD_ID(TASK_GAPC, conidx), TASK_APP,
+            gapc_get_dev_info_cfm, 0);
+        pcfm->req                                = param->req;
+        pcfm->info.slv_pref_params.con_intv_min  = BLE_UAPDATA_MIN_INTVALUE;
+        // Slave preferred Connection interval Max
+        pcfm->info.slv_pref_params.con_intv_max  = BLE_UAPDATA_MAX_INTVALUE;
+        // Slave preferred Connection latency
+        pcfm->info.slv_pref_params.slave_latency = BLE_UAPDATA_LATENCY;
+        // Slave preferred Link supervision timeout
+        pcfm->info.slv_pref_params.conn_timeout  = BLE_UAPDATA_TIMEOUT;
+        pcfm->token                              = param->token;
+        pcfm->status                             = GAP_ERR_NO_ERROR;
+    } break;
+    default:
+        break;
+    }
+    if (pcfm) {
+        xc_ble_get_dev_info_cfm(conidx, pcfm);
+    }
+}
+
+static void gapm_profile_add_ind(ke_msg_id_t const msgid, void const *param,
+                                 ke_task_id_t const dest_id,
+                                 ke_task_id_t const src_id)
+{
+    struct gapm_profile_added_ind *p_param =
+        (struct gapm_profile_added_ind *)param;
+    // Current State
+    ke_state_t state = ke_state_get(dest_id);
+    LOGI("gapm_profile_add_ind profile_task_id:0x%x,state=0x%x\r\n",
+         p_param->prf_task_id, state);
+    switch (p_param->prf_task_id) {
+    case TASK_ID_BASS: {
+
+    } break;
+    case TASK_ID_BASC: {
+
+    } break;
+    default:
+        break;
+    }
+}
+
+static void gapm_activity_created_ind(ke_msg_id_t const msgid,
+                                      void const *param,
+                                      ke_task_id_t const dest_id,
+                                      ke_task_id_t const src_id)
+{
+    struct gapm_activity_created_ind *p_param =
+        (struct gapm_activity_created_ind *)param;
+    LOGI(" gapm_activity_created_ind  actv_idx = %d,actv_type = %d ",
+         p_param->actv_idx, p_param->actv_type);
+    switch (p_param->actv_type) {
+    case GAPM_ACTV_TYPE_SCAN: {
+        app_env.scan_actv_idx = p_param->actv_idx;
+        app_start_scan();
+    } break;
+    case GAPM_ACTV_TYPE_INIT: {
+        app_env.init_actv_idx = p_param->actv_idx;
+
+    } break;
+    case GAPM_ACTV_TYPE_ADV: {
+#if MULTI_ROLE_TEST
+        app_env.adv_actv_idx = p_param->actv_idx;
+        app_set_adv_data();
+#endif
+    } break;
+    default:
+        break;
+    }
+}
+
+static void gapm_activity_stop_ind(ke_msg_id_t const msgid, void const *param,
+                                   ke_task_id_t const dest_id,
+                                   ke_task_id_t const src_id)
+{
+    struct gapm_activity_stopped_ind *p_param =
+        (struct gapm_activity_stopped_ind *)param;
+    LOGI(" activity stop actv_id=%d   actv_type=%d, reason=0x%x\r\n",
+         p_param->actv_idx, p_param->actv_type, p_param->reason);
+    if (p_param->actv_idx == app_env.scan_actv_idx) {
+        app_env.scan_state = APP_SCAN_STATE_STOPPED;
+
+    } else if (p_param->actv_idx == app_env.init_actv_idx) {
+        app_env.init_state = APP_INIT_STATE_STOPPED;
+        #if WHITE_LIST_TEST
+        app_start_init(0,NULL);
+        #endif
+    } else if (p_param->actv_idx == app_env.adv_actv_idx) {
+        app_env.adv_state = APP_ADV_STATE_STOPPED;
+    }
+}
+
+static uint8_t gapm_callback(ke_msg_id_t const msgid, void const *param,
+                             ke_task_id_t const dest_id,
+                             ke_task_id_t const src_id)
+{
+    switch (msgid) {
+    case GAPM_CMP_EVT:
+        gapm_cmp_evt(msgid, param, dest_id, src_id);
+        break;
+    case GAPM_DEV_BDADDR_IND: {
+        struct gapm_dev_bdaddr_ind *p_param =
+            (struct gapm_dev_bdaddr_ind *)param;
+        LOGI("GAPM_DEV_BDADDR_IND\r\n");
+        LOGI("app_gapm_dev_bdaddr_ind_handler   addr type:0x%x, addr:0x%x  "
+             "0x%x 0x%x 0x%x 0x%x  0x%x \r\n",
+             p_param->addr.addr_type, p_param->addr.addr[0],
+             p_param->addr.addr[1], p_param->addr.addr[2],
+             p_param->addr.addr[3], p_param->addr.addr[4],
+             p_param->addr.addr[5]);
+
+    } break;
+    case GAPM_GEN_RAND_NB_IND: {
+        struct gapm_gen_rand_nb_ind *p_param =
+            (struct gapm_gen_rand_nb_ind *)param;
+        // First part of IRK
+        if (app_env.rand_cnt == 0) {
+            memcpy(&app_env.loc_irk[0], &p_param->randnb.nb[0], 8);
+        }
+        // Second part of IRK
+        else if (app_env.rand_cnt == 1) {
+            memcpy(&app_env.loc_irk[8], &p_param->randnb.nb[0], 8);
+        }
+        app_env.rand_cnt++;
+    } break;
+    case GAPM_ACTIVITY_CREATED_IND: {
+        gapm_activity_created_ind(msgid, param, dest_id, src_id);
+    } break;
+    case GAPM_ACTIVITY_STOPPED_IND: {
+        gapm_activity_stop_ind(msgid, param, dest_id, src_id);
+    } break;
+    case GAPM_SCAN_REQUEST_IND:
+        LOGI("GAPM_SCAN_REQUEST_IND\r\n");
+        break;
+    case GAPM_PROFILE_ADDED_IND: {
+        gapm_profile_add_ind(msgid, param, dest_id, src_id);
+    } break;
+
+    case GAPM_ADDR_SOLVED_IND: {
+        LOGI("======== GAPM_ADDR_SOLVED_IND ========\r\n");
+        struct gapm_addr_solved_ind *p_param =
+            (struct gapm_addr_solved_ind *)param;
+        LOGI("addr: %x %x %x %x %x %x \r\n", p_param->addr.addr[0],
+             p_param->addr.addr[1], p_param->addr.addr[2],
+             p_param->addr.addr[3], p_param->addr.addr[4],
+             p_param->addr.addr[5]);
+        for (uint8_t i = 0; i < 16; i++) {
+            LOGI(" %x ", p_param->irk.key[i]);
+        }
+    } break;
+    case GAPM_EXT_ADV_REPORT_IND: {
+        struct gapm_ext_adv_report_ind *p_param =
+        (struct gapm_ext_adv_report_ind *)param;
+        
+    //    LOGI("addr: %x %x %x %x %x %x\r\n", p_param->trans_addr.addr[0],
+    //    p_param->trans_addr.addr[1], p_param->trans_addr.addr[2],
+    //    p_param->trans_addr.addr[3], p_param->trans_addr.addr[4],
+    //    p_param->trans_addr.addr[5]);
+        #if (SCAN_RSSI_DEBUG)
+        LOGI("rssi=%d\n",p_param->rssi);
+        #endif
+
+        #if WHITE_LIST_TEST
+         app_start_init(0,NULL);
+        #else
+        
+            uint8_t addr2[6] = {0xA9, 0xE4, 0x7B, 0x68, 0x32, 0x96};
+            uint8_t addr3[6] = {0xAB, 0xD5, 0x7B, 0x68, 0x32, 0x96};
+            uint8_t addr4[6] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x52};
+            uint8_t addr5[6] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x53};
+
+            if ((memcmp(p_param->trans_addr.addr, addr2,
+               GAP_BD_ADDR_LEN) == 0) ||(memcmp(p_param->trans_addr.addr, addr3,
+               GAP_BD_ADDR_LEN) == 0) ||(memcmp(p_param->trans_addr.addr, addr4,
+               GAP_BD_ADDR_LEN) == 0) ||(memcmp(p_param->trans_addr.addr, addr5,
+               GAP_BD_ADDR_LEN) == 0)) 
+               {
+                   LOGI("find target device \r\n");
+                   LOGI("addr_type :%d ,addr :%x %x  %x %x %x %x \r\n",p_param->trans_addr.addr_type,p_param->trans_addr.addr[0],p_param->trans_addr.addr[1],p_param->trans_addr.addr[2],p_param->trans_addr.addr[3],p_param->trans_addr.addr[4],p_param->trans_addr.addr[5]);
+
+                    uint8_t find_idx =  find_conn_dev(&(p_param->trans_addr.addr[0]));
+                    if(find_idx != 0xff)
+                    {
+                       if(conn_dev[find_idx].connnectd == false)
+                       {
+                           LOGI(" dddd1 find_idx :%d ,connect dev addr :%x %x  %x %x %x %x \r\n",find_idx,p_param->trans_addr.addr[0],p_param->trans_addr.addr[1],p_param->trans_addr.addr[2],p_param->trans_addr.addr[3],p_param->trans_addr.addr[4],p_param->trans_addr.addr[5]);
+                           printf_conn_dev();
+                           app_start_init(p_param->trans_addr.addr_type,
+                           p_param->trans_addr.addr);
+                       }
+                       
+                    }
+                    else
+                    {
+                        LOGI("dddd2 find_idx :%d,conn dev addr :%x %x  %x %x %x %x \r\n",find_idx,p_param->trans_addr.addr[0],p_param->trans_addr.addr[1],p_param->trans_addr.addr[2],p_param->trans_addr.addr[3],p_param->trans_addr.addr[4],p_param->trans_addr.addr[5]);
+                        printf_conn_dev();
+                        app_start_init(p_param->trans_addr.addr_type,
+                        p_param->trans_addr.addr);
+                    }
+               }
+        #endif
+        
+    } break;
+    default:
+        break;
+    }
+    return (KE_MSG_CONSUMED);
+}
+
+static uint8_t gapc_callback(ke_msg_id_t const msgid, void const *param,
+                             ke_task_id_t const dest_id,
+                             ke_task_id_t const src_id)
+{
+    uint8_t conidx = KE_IDX_GET(src_id);
+    switch (msgid) {
+    case GAPC_CMP_EVT: {
+        struct gapc_cmp_evt const *p_param = (struct gapc_cmp_evt const *)param;
+        LOGI("GAPC_CMP_EVT   operation = 0x%x, status = 0x%x   conidx = "
+             "0x%x\r\n",
+             p_param->operation, p_param->status, conidx);
+    } break;
+    case GAPC_CONNECTION_REQ_IND: {
+        struct gapc_connection_req_ind *p_param =
+            (struct gapc_connection_req_ind *)param;
+        LOGI(" ======= GAPC_CONNECTION_REQ_IND conhdl = x%x,  conidx = 0x%x ",
+             p_param->conhdl, conidx);
+        LOGI("conn_intv:%d, role=%d   addr: ", p_param->con_interval,
+             p_param->role);
+        // DUMP_DATA_PRINTF(&(p_param->peer_addr.addr[0]), GAP_BD_ADDR_LEN);
+        for (uint8_t i = 0; i < GAP_BD_ADDR_LEN; i++) {
+            LOGI(" %02x ", p_param->peer_addr.addr[i]);
+        }
+        LOGI("\r\n");
+       
+
+        // Check if the received connection index is valid
+        if (conidx != GAP_INVALID_CONIDX) {
+            struct gapc_connection_cfm cfm = {0};
+            cfm.pairing_lvl                = GAP_PAIRING_UNAUTH;
+            xc_ble_conn_cfm(conidx, &cfm);
+        }
+
+        uint8_t find_idx = find_conn_dev(&(p_param->peer_addr.addr[0]));
+        if (find_idx != 0xff) {
+            conn_dev[find_idx].connnectd = true;
+            LOGI(" debug conn_dev[find_idx].conidx :%d  conidx :%d \r\n ",
+                 conn_dev[find_idx].conidx, conidx);
+            conn_dev[find_idx].conidx = conidx;
+        } else {
+            uint8_t add_idx = add_conn_dev(&(p_param->peer_addr.addr[0]));
+            if (add_idx == 0xff) {
+                LOGI("==== add dev error===\r\n");
+            } else {
+                conn_dev[add_idx].conidx    = conidx;
+                conn_dev[add_idx].connnectd = true;
+            }
+        }
+       printf_conn_dev();
+       LOGI("--------- connect num :%d --------\r\n",calc_conn_num());
+
+        if (p_param->role == GAPM_ROLE_SLAVE) {
+            app_env.slave_conidx    = conidx;
+            app_env.slave_connected = true;
+        }
+        // device as master
+        if (p_param->role == GAPM_ROLE_MASTER) {
+            //app_stop_scanning();
+            app_env.master_conidx    = conidx;
+            app_env.master_connected = true;
+#if (BOND_TEST)
+            struct gapc_bond_cmd bond_param = {0};
+            bond_param.pairing.auth =
+                GAP_AUTH_REQ_NO_MITM_BOND; // GAP_AUTH_REQ_MITM_BOND;//GAP_AUTH_REQ_MITM_BOND;
+            bond_param.pairing.iocap =
+                GAP_IO_CAP_NO_INPUT_NO_OUTPUT; // GAP_IO_CAP_KB_ONLY;//GAP_IO_CAP_DISPLAY_ONLY;//GAP_IO_CAP_NO_INPUT_NO_OUTPUT;
+            bond_param.pairing.key_size = 16;
+            bond_param.pairing.oob      = GAP_OOB_AUTH_DATA_NOT_PRESENT;
+            bond_param.pairing.sec_req =
+                GAP_SEC1_NOAUTH_PAIR_ENC; // GAP_SEC1_AUTH_PAIR_ENC;//GAP_NO_SEC;
+            bond_param.pairing.rkey_dist = GAP_KDIST_ENCKEY | GAP_KDIST_IDKEY;
+            bond_param.pairing.ikey_dist = GAP_KDIST_ENCKEY | GAP_KDIST_IDKEY;
+            xc_ble_bond(conidx, &bond_param);
+#endif // (BOND_TEST)
+            usr_cli_feat_enable(conidx);
+        }
+    } break;
+    case GAPC_DISCONNECT_IND: {
+        struct gapc_disconnect_ind *p_param =
+            (struct gapc_disconnect_ind *)param;
+        LOGI("******* GAPC_DISCONNECT_IND  conidx = 0x%x, reason = 0x%x  "
+             "conhdl = 0x%x,\r\n",
+             conidx, p_param->reason, p_param->conhdl);
+       
+        uint8_t find_idx = find_conn_dev_idx(conidx);
+        if (find_idx == 0xff) {
+            LOGI("debug  find condix error\r\n");
+        } else {
+            conn_dev[find_idx].connnectd = false;
+            conn_dev[find_idx].conidx = 0xff;
+        }
+         printf_conn_dev();
+         LOGI("--------- connect num :%d --------\r\n",calc_conn_num());
+        #if !WHITE_LIST_TEST
+         if (conidx == app_env.master_conidx) {
+            app_env.master_conidx    = INVALID_DATA;
+            app_env.master_connected = false;
+           // app_start_scan();
+        }
+        #else
+        app_start_init(0,NULL);
+        #endif
+#if MULTI_ROLE_TEST
+        if (conidx == app_env.slave_conidx) {
+            app_env.slave_conidx    = INVALID_DATA;
+            app_env.slave_connected = false;
+            app_start_advertising();
+        }
+#endif
+
+    } break;
+    case GAPC_GET_DEV_INFO_REQ_IND: {
+        gapc_get_device_info_req_ind(msgid, param, dest_id, src_id);
+    } break;
+    case GAPC_SET_DEV_INFO_REQ_IND: {
+        struct gapc_set_dev_info_req_ind *p_param =
+            (struct gapc_set_dev_info_req_ind *)param;
+        struct gapc_set_dev_info_cfm cfm = {0};
+        LOGI("GAPC_SET_DEV_INFO_REQ_IND  param->req=0x%x,conidx=0x%x\r\n",
+             p_param->req, conidx);
+        xc_ble_set_dev_info_cfm(conidx, &cfm);
+    } break;
+    case GAPC_PARAM_UPDATE_REQ_IND: {
+        struct gapc_param_update_req_ind *p_param =
+            (struct gapc_param_update_req_ind *)param;
+        struct gapc_param_update_cfm cfm = {0};
+        LOGI("GAPC_PARAM_UPDATE_REQ_IND  "
+             "conidx=0x%x,intv_max=0x%x,intv_min=0x%x",
+             conidx, p_param->intv_max, p_param->intv_min);
+        LOGI("latency=0x%x,time_out=0x%x\r\n", p_param->latency,
+             p_param->time_out);
+        // Check if the received Connection Handle was valid
+        if (app_env.conidx != GAP_INVALID_CONIDX) {
+            cfm.accept     = true;
+            cfm.ce_len_min = CE_LEN_MIN;
+            cfm.ce_len_max = CE_LEN_MAX;
+            xc_ble_param_update_cfm(conidx, &cfm);
+        }
+    } break;
+    case GAPC_PARAM_UPDATED_IND: {
+        struct gapc_param_updated_ind *p_param =
+            (struct gapc_param_updated_ind *)param;
+        LOGI("GAPC_PARAM_UPDATED_IND "
+             "conidx=0x%x,con_interval=0x%x,con_latency=0x%x ",
+             conidx, p_param->con_interval, p_param->con_latency);
+        LOGI("sup_to=0x%x\r\n", p_param->sup_to);
+    } break;
+    case GAPC_LE_PKT_SIZE_IND: {
+        struct gapc_le_pkt_size_ind *p_param =
+            (struct gapc_le_pkt_size_ind *)param;
+        LOGI("GAPC_LE_PKT_SIZE_IND "
+             "conidx=0x%x, max_rx_octets:%d",
+             conidx, p_param->max_rx_octets);
+        LOGI("max_rx_time:%d,max_tx_octets:%d, "
+             "max_tx_time :%d\r\n",
+             p_param->max_rx_time, p_param->max_tx_octets,
+             p_param->max_tx_time);
+    } break;
+    case GAPC_CON_RSSI_IND: {
+        struct gapc_con_rssi_ind *p_param = (struct gapc_con_rssi_ind *)param;
+        LOGI("GAPC_CON_RSSI_IND conidx=0x%x,rssi = %d\r\n", conidx,
+             p_param->rssi);
+    } break;
+    case GAPC_LE_PHY_IND: {
+        struct gapc_le_phy_ind *p_param = (struct gapc_le_phy_ind *)param;
+        LOGI("GAPC_LE_PHY_IND conidx=0x%x  tx phy:%d  rx phy:%d \r\n", conidx,
+             p_param->tx_phy, p_param->rx_phy);
+    } break;
+    case GAPC_BOND_REQ_IND:
+        // gapc_bond_req_ind_handler(msgid, p_param, dest_id,src_id)
+        break;
+    case GAPC_BOND_IND:
+        // gapc_bond_ind_handler(msgid, p_param, dest_id,src_id)
+        break;
+    case GAPC_SECURITY_IND:
+        // gapc_security_ind_handler(msgid, p_param, dest_id,src_id)
+        break;
+    case GAPC_ENCRYPT_REQ_IND:
+        // gapc_encrypt_req_ind_handler(msgid, p_param, dest_id,src_id)
+        break;
+    case GAPC_ENCRYPT_IND:
+        // gapc_encrypt_ind_handler(msgid, p_param, dest_id,src_id)
+        break;
+    default:
+        break;
+    }
+    return (KE_MSG_CONSUMED);
+}
+
+#if (FLASH_TEST_IN_TASK || FLASH_TEST_IN_BLUETOOTH_GAP)
+static int one_sec_timer_handler(ke_msg_id_t const msgid, void *p_param,
+                           ke_task_id_t const dest_id,
+                           ke_task_id_t const src_id)
+{
+    ke_timer_set(ONE_SEC_TIMER_MSG, TASK_APP, 1000);
+#if (FLASH_TEST_IN_TASK)
+    flash_test_in_task();
+#endif // (FLASH_TEST_IN_TASK)
+#if (FLASH_TEST_IN_BLUETOOTH_GAP)
+    flash_test_in_bluetooth_gap();
+#endif // (FLASH_TEST_IN_BLUETOOTH_GAP)
+    return (KE_MSG_CONSUMED);
+}
+#endif // #if (FLASH_TEST_IN_TASK || FLASH_TEST_IN_BLUETOOTH_GAP)
+
+/* Default State handlers definition. */
+KE_MSG_HANDLER_TAB(app){
+#if (FLASH_TEST_IN_TASK || FLASH_TEST_IN_BLUETOOTH_GAP)
+    {ONE_SEC_TIMER_MSG, (ke_msg_func_t)one_sec_timer_handler},
+#endif // #if (FLASH_TEST_IN_TASK || FLASH_TEST_IN_BLUETOOTH_GAP)
+    {KE_MSG_DEFAULT_HANDLER, (ke_msg_func_t)app_msg_handler},
+};
+
+/* Defines the place holder for the states of all the task instances. */
+ke_state_t app_state[APP_IDX_MAX];
+
+// Application task descriptor
+const struct ke_task_desc TASK_DESC_APP = {app_msg_handler_tab, app_state,
+                                           APP_IDX_MAX,
+                                           ARRAY_LEN(app_msg_handler_tab)};
+
+/// @} APPTASK

project/example/ble/ble_central/app/src/arch_main.c

@@ -0,0 +1,433 @@
+/**
+ ****************************************************************************************
+ *
+ * @file arch_main.c
+ *
+ * @brief Main loop of the application.
+ *
+ * Copyright (C) RivieraWaves 2009-2015
+ *
+ *
+ ****************************************************************************************
+ */
+
+/*
+ * INCLUDES
+ ****************************************************************************************
+ */
+
+#include "rwip_config.h" // RW SW configuration
+#include "xc_drv_pwr.h"
+#if (USE_ROM_FLASH)
+#include "xc6xxx_fmc_spi.h"
+#endif // (USE_ROM_FLASH)
+#include "app_task.h"
+#include "rom_port.h"
+
+#if (BLE_TEST_MODE_SUPPORT)
+#include "uart.h" // UART initialization
+#endif            // (BLE_TEST_MODE_SUPPORT)
+
+#if (BLE_EMB_PRESENT || BT_EMB_PRESENT)
+#include "rf.h" // RF initialization
+#endif          // BLE_EMB_PRESENT || BT_EMB_PRESENT
+
+#if (PLF_NVDS)
+#include "nvds.h" // NVDS definitions
+#endif            // PLF_NVDS
+
+#include "xc6xxx.h"
+#include "xc_drv_fmc_spi.h"
+
+/**
+ ****************************************************************************************
+ * @addtogroup DRIVERS
+ * @{
+ *
+ *
+ * ****************************************************************************************
+ */
+
+/*
+ * DEFINES
+ ****************************************************************************************
+ */
+/// NVDS location in FLASH : 0x000E0000 (896KB (1Mo - 128KB))
+#define NVDS_FLASH_ADDRESS (0x0003E000)
+
+/// NVDS size in RAM : 0x00010000 (128KB)
+#define NVDS_FLASH_SIZE    (0x00000800)
+
+/*
+ * GLOBAL VARIABLE DEFINITIONS
+ ****************************************************************************************
+ */
+
+/*
+ * MAIN FUNCTION
+ ****************************************************************************************
+ */
+
+/**
+ ****************************************************************************************
+ * @brief RW main function.
+ *
+ * This function is called right after the booting process has completed.
+ *
+ * @return status   exit status
+ ****************************************************************************************
+ */
+
+void flash_init()
+{
+    // uint32_t mid = 0;
+//    uint32_t flash_size;
+//    uint16_t flash_type;
+    // xc_fmc_spi_init_oprt();
+    // xc_fmc_spi_flash_wake_up();
+
+    // xc_fmc_spi_flash_rdid((uint8_t *)&mid);
+    // LOGI("Flash RDID: 0x%08x\n", mid);
+
+
+#if (PLF_NVDS)
+    if (false == flash_size_and_type_get(&flash_size, &flash_type)) {
+        LOGI("Flash Memory size Get ERROR ! ");
+        while (1)
+            ;
+    }
+
+    nvds_space_init(flash_size);
+#endif
+    // if chip unique get failed,then use flash RUID
+    if (false == xc_unique_identification_read(co_default_bdaddr.addr)) {
+        uint8_t ruid[16];
+        xc_fmc_spi_flash_ruid(ruid);
+        LOGI("Flash RUID11: ");
+        for (int i = 0; i < 16; i++) {
+            LOGI("%02x ", ruid[i]);
+        }
+        LOGI("\n");
+        LOGI("The chip does not have unique , then use flash RUID\n");
+        memset(co_default_bdaddr.addr, 0, 6);
+        for (int i = 0; i < 16; i++) {
+            co_default_bdaddr.addr[i % 6] += ruid[i];
+        }
+    }
+}
+
+#define clrbit(x, y) ((x) &= ~(1 << (y)))
+#define AHB_CTL      clrbit(*(uint32_t volatile *)(0x40000000 + 0x130), 0)
+#define _TOSTRING(s) #s
+#define TOSTRING(s)  _TOSTRING(s)
+
+extern void clock_init(void);
+void app_uart_init(void)
+{
+    GPIO_InitCfg_t gpio_cfg = {0};
+
+    gpio_cfg.Mux            = GPIO_Mux0;
+    gpio_cfg.Pull           = GPIO_PULLUP;
+    gpio_cfg.Int            = NOT_INT;
+    gpio_cfg.FunSel         = UART0_TX;
+
+    gpio_cfg.Pin            = GPIO_18;
+    gpio_cfg.Dir            = GPIO_DIR_OUTPUT;
+    xc_gpio_init(&gpio_cfg);
+
+    gpio_cfg.FunSel = UART0_RX;
+    gpio_cfg.Pin    = GPIO_19;
+    gpio_cfg.Dir    = GPIO_DIR_INPUT;
+    xc_gpio_init(&gpio_cfg);
+
+    UART_InitCfg_t uart_cfg      = {0};
+
+    uart_cfg.Parity              = UART_PARITY_DISABLE;
+    uart_cfg.StopBits            = UART_STOP_1_BITS;
+    uart_cfg.WordLength          = UART_DATA_8_BITS;
+    uart_cfg.BaudRate            = UART_BAUDRATE_115200;
+    uart_cfg.HardwareFlowControl = UART_HWFC_DISABLE;
+
+    xc_uart_init(UART0_IDX, &uart_cfg);
+}
+void wdt_init(void)
+{
+    WDT_InitCfg_t wdt_cfg ;
+
+    wdt_cfg.WorkMode      = WDT_WORK_MODE0;
+    wdt_cfg.ReloadValue   = WDT_CLK_32K_RESET_MODE0_2048MS;
+    wdt_cfg.PclkSel       = WDT_WORK_32K;
+    xc_wdt_init(&wdt_cfg);
+    xc_wdt_start();
+}
+
+void system_lightsleep_cfg()
+{
+#if (USE_XIP != 1)
+    cprao_aon_puctrl1_set(0x4); /* puctrl1= 0x4 , SSI0RX must pulldown*/
+#endif
+    cprao_aon_sys_time_set((RST_READY_TIME << 12) | (OSC32_STABLE_TIME));
+
+    xc_pwr_pd_lightsleep_set();
+    xc_pwr_sleepsrc_mask_set(0x1e001e);
+    xc_pwr_osc_off();
+}
+
+/* Zero the host global variable. */
+void rom_env_host_init()
+{
+
+    uint32_t *ptr = (uint32_t *)(0x10000800);
+    memset(ptr, 0, 0x10001300 - 0x10000800);
+
+    rom_env.stack_printf = printf;
+}
+
+void board_init()
+{
+    clock_init();
+
+    app_uart_init();
+
+    LOGI("sdk version: %s build time: %s %s\n", TOSTRING(SDK_VERSION), __DATE__,
+         __TIME__);
+//    xc_fmc_spi_init_oprt();
+#if (SLEEP_ENABLE)
+    // xc_rc32k_calib_by_hw();
+// xc_rc32k_calib_by_soft();
+#endif // (SLEEP_ENABLE)
+    rom_env_host_init();
+    rom_env_init();
+    AHB_CTL;
+
+    // Initialize random process
+    // srand(1);
+}
+
+void bluetooth_init()
+{
+
+    uint32_t error = RESET_NO_ERROR;
+    flash_init();
+#if (PLF_NVDS)
+
+    // Initialize NVDS module
+    nvds_init(NVDS_FLASH_SIZE);
+#endif // PLF_NVDS
+    /*
+     ************************************************************************************
+     * RW SW stack initialization
+     ************************************************************************************
+     */
+    NVIC_SetPriority((IRQn_Type)BLE_IRQn, 0);
+    NVIC_EnableIRQ((IRQn_Type)BLE_IRQn);
+#if (!HCI_TEST_NO_IP)
+    // Initialize modem
+    modem_init();
+#endif
+// Initialize RF
+#if (BT_EMB_PRESENT || BLE_EMB_PRESENT)
+    rf_init(&rwip_rf);
+#endif // BT_EMB_PRESENT || BLE_EMB_PRESENT
+    // Initialize RW SW stack
+    rwip_init(error);
+
+    uint32_t seed;
+    rwip_time_t current_time = rwip_time_get();
+    seed =  current_time.hs;
+    seed += current_time.hus;
+    //Init the random seed
+    co_random_init(seed);
+
+#if (BLE_TEST_MODE_SUPPORT)
+    enter_test_mode();
+#else  // (BLE_TEST_MODE_SUPPORT)
+    // Initialize APP
+    app_init();
+#endif // (BLE_TEST_MODE_SUPPORT)
+    // finally start interrupt handling
+    GLOBAL_INT_START();
+}
+
+#if ((ADV_EVENT_NOT_RUN_XIP ==1) || (CONN_EVENT_NOT_RUN_XIP == 0) || (CONN_EVENT_NOT_RUN_XIP == 1))
+extern uint8_t adv_evt_start ; // adv  event
+extern uint8_t evt_start ;     // conn event
+extern volatile uint8_t sv_lock;
+extern volatile uint8_t sv_txlen;
+__RAM_CODE void PendSV_Handler(void)
+{
+    if(adv_evt_start){        // adv  event
+#if (ADV_EVENT_NOT_RUN_XIP ==1)
+        while (!sv_lock)
+            ;
+#endif // (ADV_EVENT_NOT_RUN_XIP ==1)
+    }else if(evt_start){      // conn event
+#if (CONN_EVENT_NOT_RUN_XIP == 0)
+        uint32_t nus  = sv_txlen * 8 + 148;
+        uint32_t unit = 32;
+        uint32_t temp;
+
+        SysTick->CTRL = 0x00;
+        SysTick->LOAD = unit * nus - unit + 1;
+
+        SysTick->VAL  = 0;
+        SysTick->CTRL = 0x05;
+
+        do {
+            temp = SysTick->CTRL;
+            if (sv_lock) {
+                break;
+            }
+        } while ((temp & 0x01) && (!(temp & (1 << 16))));
+#endif // (CONN_EVENT_NOT_RUN_XIP == 0)
+
+#if (CONN_EVENT_NOT_RUN_XIP == 1)
+        while (!sv_lock)
+            ;
+#endif // (CONN_EVENT_NOT_RUN_XIP == 1)
+    }
+
+}
+#endif // ((ADV_EVENT_NOT_RUN_XIP ==1) || (CONN_EVENT_NOT_RUN_XIP == 0) || (CONN_EVENT_NOT_RUN_XIP == 1))
+
+#if (FLASH_TEST_IN_INTERRUPT)
+void flash_test_in_interrupt(void)
+{
+    uint8_t wr_data[10] = {0x63,0x89,0x63,0x89,0x63,0x89};
+    uint8_t rd_data[10] ={0};
+    // Timer 1 can be used for flash, interrupt priority is lower than bluetooth, then higher than other interrupts.
+    // Operate flash in timer 1 interrupt context, no need to lock interrupt, won't affect bluetooth send/receive packets.
+    // xc_fmc_spi_flash_write(0x32000 , wr_data, sizeof(wr_data));
+    xc_fmc_spi_flash_write_page(0x32000, wr_data,
+                                        sizeof(wr_data));
+    xc_fmc_spi_flash_read(0x32000 , rd_data, sizeof(rd_data));
+    for(uint8_t i = 0;i<sizeof(rd_data);i++)
+    {
+        printf(" %02x ",rd_data[i]);
+    }
+    printf("\r\n");
+}
+
+
+void timer_init(uint8_t timer_idx,uint32_t us)
+{
+    Timer_InitCfg_t timer_cfg;
+
+    timer_cfg.timer_src_clk = TIMER_CLK_SRC_32K;
+    timer_cfg.timer_div_clk = TIMER_DIV_CLK_16MHzOr16K;
+    timer_cfg.timer_mode = TIMER_MODE_CYCLE; 
+    
+    xc_timer_init(timer_idx, &timer_cfg);
+    xc_timer_set_value(timer_idx, us);
+    xc_timer_start(timer_idx);
+    NVIC_SetPriority((IRQn_Type)TIMER0_IRQn + timer_idx, 1);
+}
+
+void timer1_callback(void *context) {
+    flash_test_in_interrupt();
+}
+#endif // (FLASH_TEST_IN_INTERRUPT)
+
+
+#if (FLASH_TEST_IN_TASK)
+void flash_test_in_task(void)
+{
+    uint8_t wr_data[10] = {0x63,0x89,0x63,0x89,0x63,0x89};
+    static uint8_t wr_cnt= 0;
+    uint8_t rd_data[10] ={0};
+    wr_cnt++;
+    if(wr_cnt >= 252)
+    {
+        wr_cnt = 0;
+    }
+    wr_data[9] = wr_cnt;
+    GLOBAL_INT_DISABLE();
+    xc_fmc_spi_flash_write_page(0x32000, wr_data,
+                                        sizeof(wr_data));
+    xc_fmc_spi_flash_read(0x32000 , rd_data, sizeof(rd_data));
+    
+    GLOBAL_INT_RESTORE();
+    for(uint8_t i = 0;i<sizeof(rd_data);i++)
+    {
+        printf(" %02x ",rd_data[i]);
+    }
+    printf("\r\n");
+}
+#endif // (FLASH_TEST_IN_TASK)
+
+#if (FLASH_TEST_IN_BLUETOOTH_GAP)
+#include "rwip_int.h"
+extern struct rwip_env_tag        rwip_env;
+void flash_test_in_bluetooth_gap(void)
+{
+    uint8_t wr_data[10] = {0x63,0x89,0x63,0x89,0x63,0x89};
+    static uint8_t wr_cnt= 0;
+    uint8_t rd_data[10] ={0};
+    wr_cnt++;
+    if(wr_cnt >= 252)
+    {
+        wr_cnt = 0;
+    }
+    wr_data[9] = wr_cnt;
+
+    if (rwip_env.prevent_sleep != 0)
+        return;
+
+    rwip_time_t current_time;
+    current_time = rwip_time_get();
+    // Get the most recent Bluetooth event interval.
+    int32_t duration = CLK_DIFF(current_time.hs, rwip_env.timer_arb_target); //312.5us
+    if(duration < 64){                                                       // 20ms = 64*312.5
+         return;
+    }
+
+    GLOBAL_INT_DISABLE();
+    xc_fmc_spi_flash_write_page(0x32000, wr_data,
+                                        sizeof(wr_data));
+    xc_fmc_spi_flash_read(0x32000 , rd_data, sizeof(rd_data));
+
+    GLOBAL_INT_RESTORE();
+   for(uint8_t i = 0;i<sizeof(rd_data);i++)
+   {
+       printf(" %02x ",rd_data[i]);
+   }
+   printf("\r\n");
+}
+#endif // (FLASH_TEST_IN_BLUETOOTH_GAP)
+
+int main(void)
+{
+    wdt_init();
+    board_init();
+    bluetooth_init();
+
+#if (SLEEP_ENABLE)
+    //lvr bor_intr
+    cprao_aon_bor_ctr_reg0__bor_ctrl__setf(0x0);
+    cprao_aon_bor_ctr_reg0__bor_rstn_mask__setf(1);
+    cprao_aon_bor_ctr_reg0__bor_intr_mask__setf(0);
+    NVIC_EnableIRQ(MPU_IRQn);
+#endif // (SLEEP_ENABLE)
+
+#if ((ADV_EVENT_NOT_RUN_XIP ==1) || (CONN_EVENT_NOT_RUN_XIP == 0) || (CONN_EVENT_NOT_RUN_XIP == 1))
+    NVIC_SetPriority(PendSV_IRQn, 0xff);
+    NVIC_EnableIRQ(PendSV_IRQn);
+#endif // ((ADV_EVENT_NOT_RUN_XIP ==1) || (CONN_EVENT_NOT_RUN_XIP == 0) || (CONN_EVENT_NOT_RUN_XIP == 1))
+#if (FLASH_TEST_IN_INTERRUPT)
+    timer_init(TIMER1_IDX,1000*1000); 
+#endif //(FLASH_TEST_IN_INTERRUPT)
+
+    // rf_test_pin_init();
+#if (BLE_APP_PRESENT)
+    while (1) {
+        // schedule all pending events
+        rwip_schedule();
+#if (SLEEP_ENABLE)
+        sleep_schedule();
+#endif // (SLEEP_ENABLE)
+     xc_wdt_reload();  //TOOD
+    }
+#endif // (BLE_APP_PRESENT)
+}
+
+/// @} DRIVERS

project/example/ble/ble_central/app/src/rom_symdefs.o

@@ -0,0 +1,284 @@
+#<SYMDEFS># ARM Linker, 5060750: Last Updated: Tue Sep 05 15:30:26 2023
+0x10000808 D co_default_bdaddr
+0x00004169 T ke_msg_alloc
+0x000041ed T ke_msg_send
+0x00004225 T ke_msg_send_basic
+0x000042e9 T ke_state_set
+0x00004359 T ke_task_create
+0x000042b9 T ke_state_get
+0x000041af T ke_msg_discard
+0x000041b3 T ke_msg_forward
+0x000041dd T ke_msg_in_queue
+0x00004233 T ke_msg_src_id_get
+0x00003e05 T ke_free
+0x000041d5 T ke_msg_free
+0x00003c21 T ke_check_malloc
+0x0000dbf5 T rwip_init
+0x0000de79 T rwip_schedule
+0x10000938 D rwip_rf
+0x00000df9 T BLE_Handler
+0x0000238d T co_buf_alloc
+0x000024fd T co_buf_copy_data_from_mem
+0x00002721 T co_buf_release
+0x000028c9 T co_djob_prepare
+0x000028d5 T co_djob_reg
+0x0000291d T co_djob_unreg
+0x00002969 T co_list_extract
+0x000029ad T co_list_extract_after
+0x00002ac5 T co_list_pop_front
+0x00002ae9 T co_list_push_back
+0x00002b39 T co_list_push_front
+0x00002b55 T co_time_get
+0x00002ce5 T co_time_timer_init
+0x00002dcd T co_time_timer_set
+0x00002df9 T co_time_timer_stop
+0x00000e95 T aes_c1
+0x00001465 T aes_encrypt
+0x000014cd T aes_f4
+0x00001521 T aes_f5
+0x00001641 T aes_f6
+0x000016bd T aes_g2
+0x00001c35 T aes_rand
+0x000012a1 T aes_cmac
+0x000025b1 T co_buf_head_release
+0x000025dd T co_buf_head_reserve
+0x00002ec5 T co_util_pack
+0x000030d5 T co_util_unpack
+0x0000ddd9 T rwip_reset
+0x00001da5 T aes_rpa_resolve
+0x00002799 T co_buf_reuse
+0x000027dd T co_buf_size
+0x00002489 T co_buf_copy
+0x00002569 T co_buf_duplicate
+0x000027ed T co_buf_tail_release
+0x00002a0d T co_list_init
+0x00002285 T ble_util_buf_rx_free
+0x00001f69 T ble_util_buf_acl_tx_alloc
+0x00002439 T co_buf_cb_free_set
+0x00003fad T ke_malloc
+0x00002a25 T co_list_insert_after
+0x0000459d T ke_timer_active
+0x000045ad T ke_timer_clear
+0x00004641 T ke_timer_set
+0x00002369 T co_buf_acquire
+0x00002819 T co_buf_tail_reserve
+0x00002531 T co_buf_copy_data_to_mem
+0x00002a55 T co_list_insert_before
+0x10000e90 D rom_env
+0x1000096c D rwip_param
+0x0000fe8d D one_bits
+0x000039bd T hci_rd_rem_ver_info_cmd_handler
+0x00003445 T hci_le_con_upd_cmd_handler
+0x00003705 T hci_le_rd_chnl_map_cmd_handler
+0x00003761 T hci_le_rd_rem_feats_cmd_handler
+0x0000354d T hci_le_en_enc_cmd_handler
+0x0000369d T hci_le_ltk_req_reply_cmd_handler
+0x0000360d T hci_le_ltk_req_neg_reply_cmd_handler
+0x00003851 T hci_le_rem_con_param_req_reply_cmd_handler
+0x000037f9 T hci_le_rem_con_param_req_neg_reply_cmd_handler
+0x000038d9 T hci_le_set_data_len_cmd_handler
+0x00003be5 T hci_vs_set_pref_slave_latency_cmd_handler
+0x00003b9d T hci_vs_set_pref_slave_evt_dur_cmd_handler
+0x00003ab9 T hci_vs_set_max_rx_size_and_time_cmd_handler
+0x00003a39 T hci_rd_rssi_cmd_handler
+0x0000d749 T llm_ch_map_update_ind_handler
+0x0000650d T llc_loc_llcp_rsp_to_handler
+0x00007161 T llc_rem_llcp_rsp_to_handler
+0x00005255 T llc_encrypt_ind_handler
+0x00006739 T llc_op_ver_exch_ind_handler
+0x000066d5 T llc_op_feats_exch_ind_handler
+0x00006675 T llc_op_encrypt_ind_handler
+0x00006609 T llc_op_dl_upd_ind_handler
+0x0000657d T llc_op_con_upd_ind_handler
+0x00006525 T llc_op_ch_map_upd_ind_handler
+0x0000bda9 T lld_llcp_rx_ind_handler
+0x0000bf1d T lld_llcp_tx_cfm_handler
+0x00007551 T lld_acl_rx_ind_handler
+0x000075dd T lld_acl_tx_cfm_handler
+0x00009509 T lld_con_param_upd_cfm_handler
+0x00008921 T lld_ch_map_upd_cfm_handler
+0x000094cd T lld_con_offset_upd_ind_handler
+0x00003435 T hci_command_llc_handler
+0x00003385 T hci_acl_data_handler
+0x00003cc1 T ke_event_callback_set
+0x00003cd9 T ke_event_clear
+0x00003db1 T ke_event_set
+0x000022e5 T ble_util_nb_good_channels
+0x0000230d T ble_util_pkt_dur_in_us
+0x0000234d T co_bdaddr_compare
+0x000088bd T lld_ch_assess_data_get
+0x000088c5 T lld_ch_map_set
+0x0000c16d T lld_read_clock
+0x0000c30d T lld_res_list_peer_update
+0x0000d60d T lld_white_list_add
+0x0000dd99 T rwip_prevent_sleep_clear
+0x0000ddb9 T rwip_prevent_sleep_set
+0x0000f071 T sch_plan_rem
+0x00001ce5 T aes_rpa_gen
+0x00002029 T ble_util_buf_adv_tx_alloc
+0x00002061 T ble_util_buf_adv_tx_free
+0x0000feae D co_null_bdaddr
+0x0000feb4 D co_null_key
+0x000050c9 T llc_con_move_cbk
+0x000071d9 T llc_start
+0x00007669 T lld_adv_adv_data_update
+0x00007ff5 T lld_adv_rand_addr_update
+0x00008071 T lld_adv_restart
+0x0000817d T lld_adv_scan_rsp_data_update
+0x000081c5 T lld_adv_start
+0x00008831 T lld_adv_stop
+0x0000d6c1 T lld_white_list_rem
+0x0000b401 T lld_init_rand_addr_update
+0x0000c179 T lld_res_list_add
+0x0000c251 T lld_res_list_clear
+0x0000c27d T lld_res_list_local_rpa_get
+0x0000c2c5 T lld_res_list_peer_rpa_get
+0x0000c341 T lld_res_list_priv_mode_update
+0x0000c37d T lld_res_list_rem
+0x0000cedd T lld_scan_rand_addr_update
+0x0000b699 T lld_init_start
+0x0000bc9d T lld_init_stop
+0x0000f081 T sch_plan_req
+0x0000f0d5 T sch_plan_set
+0x0000fec4 D co_rate_to_phy
+0x0000cb81 T lld_scan_params_update
+0x0000d115 T lld_scan_start
+0x0000d5c5 T lld_scan_stop
+0x0000c3ad T lld_rpa_renew
+0x0000408d T ke_mem_init
+0x00002609 T co_buf_init
+0x0000de9d T rwip_sleep
+0x10000810 D em_ble_base_address_table_0
+0x10000812 D em_ble_base_address_table_1
+0x10000814 D em_ble_base_address_table_2
+0x10000816 D em_ble_base_address_table_3
+0x10000818 D em_ble_base_address_table_4
+0x1000081a D em_ble_base_address_table_5
+0x10000822 D em_ble_base_address_table_6
+0x1000081c D em_ble_base_address_table_7
+0x10000824 D em_ble_base_address_table_8
+0x1000081e D em_ble_base_address_table_9
+0x10000820 D em_ble_base_address_table_10
+0x000021d9 T ble_util_buf_init_env
+0x10000978 D PATCH_FUN
+0x1000108c D lld_adv_env
+0x0000ebe5 T sch_arb_remove
+0x0000f739 T sch_slice_fg_remove
+0x10000f44 D llc_env
+0x0000693d T llc_proc_err_ind
+0x000073c1 T llc_stop
+0x00004695 T ll_channel_map_ind_handler
+0x0000471d T ll_connection_param_req_handler
+0x00004809 T ll_connection_param_rsp_handler
+0x0000489d T ll_connection_update_ind_handler
+0x000049c1 T ll_enc_req_handler
+0x00004a85 T ll_enc_rsp_handler
+0x00004af9 T ll_feature_req_handler
+0x00004b4d T ll_feature_rsp_handler
+0x00004ba1 T ll_length_req_handler
+0x00004bf9 T ll_length_rsp_handler
+0x00004c75 T ll_min_used_channels_ind_handler
+0x00004cf1 T ll_pause_enc_req_handler
+0x00004d5d T ll_pause_enc_rsp_handler
+0x00004db5 T ll_reject_ext_ind_handler
+0x00004dd5 T ll_reject_ind_handler
+0x00004df5 T ll_slave_feature_req_handler
+0x00004e49 T ll_start_enc_req_handler
+0x00004e99 T ll_start_enc_rsp_handler
+0x00004ee9 T ll_unknown_rsp_handler
+0x00004ef9 T ll_version_ind_handler
+0x00001fd9 T ble_util_buf_acl_tx_free
+0x0000c5c1 T lld_rxdesc_check
+0x0000c609 T lld_rxdesc_free
+0x0000fee4 D rwip_priority
+0x0000e8b1 T sch_arb_insert
+0x0000f355 T sch_prog_push
+0x0000fde5 T FMC_SPI_Flash_RDID
+0x0000fd8d T FMC_SPI_Flash_RUID
+0x0000fa71 T FMC_SPI_Flash_WakeUp
+0x0000f9f1 T FMC_SPI_Init_Oprt
+0x0000fa49 T FMC_SPI_Flash_PowerDown
+0x0000fceb T FMC_SPI_FlashRead
+0x0000fc1f T FMC_SPI_FlashWrite
+0x0000fb09 T FMC_SPI_Flash_Erase_Sector
+0x00004fc9 T llc_cleanup
+0x00005091 T llc_cmd_stat_send
+0x00005a39 T llc_llcp_send
+0x00005ac9 T llc_llcp_state_set
+0x00006981 T llc_proc_get
+0x00006999 T llc_proc_id_get
+0x000069b5 T llc_proc_init
+0x000069c1 T llc_proc_reg
+0x00006a05 T llc_proc_state_get
+0x00006a09 T llc_proc_state_set
+0x00006a0d T llc_proc_timer_pause_set
+0x00006a7d T llc_proc_timer_set
+0x00006ae5 T llc_proc_unreg
+0x0000a1c1 T lld_con_stop
+0x00007869 T lld_adv_evt_start_cbk
+0x10000e68 D rwip_env
+0x1000080e D rwip_prog_delay
+0x0000e041 T rwip_time_get
+0x0000e2cd T rwip_wakeup_end
+0x1000112c D sch_arb_env
+0x00007905 T lld_adv_frm_cbk
+0x0000e0b1 T rwip_timer_alarm_handler
+0x0000e11d T rwip_timer_arb_handler
+0x0000e189 T rwip_timer_co_handler
+0x10000f94 D lld_env
+0x10000828 D aa_gen
+0x00007c25 T lld_adv_init
+0x00009301 T lld_con_init
+0x0000a7f1 T lld_core_init
+0x1000082c D lld_rpa_renew_env
+0x00008959 T lld_channel_assess
+0x100010dc D lld_con_env
+0x0000a4ad T lld_con_tx_len_update
+0x10000830 D lld_exp_sync_pos_tab
+0x0000bce5 T lld_instant_proc_end
+0x11012145 T prf_dst_task_get
+0x1101227d T rom_env_init
+0x110048f5 T gapc_get_bdaddr
+0x1100bcd9 T gatt_db_svc16_add
+0x1100be5d T gatt_db_svc_add
+0x1100d49d T gatt_srv_event_send
+0x1100d8a5 T gatt_user_srv_register
+0x1101302c D llc_msg_handler_tab
+0x10001c80 D rom_llc_state
+0x00008e4d T lld_con_evt_start_cbk
+0x00008ddd T lld_con_evt_canceled_cbk
+0x0000fe9e D co_sca2ppm
+0x00009051 T lld_con_evt_time_update
+0x00009415 T lld_con_max_lat_calc
+0x00009a69 T lld_con_sched
+0x0000f7e1 T sch_slice_per_add
+0x0000d801 T rwble_isr
+0x0000dc75 T rwip_isr
+0x00009189 T lld_con_frm_isr
+0x000044f9 T ke_task_schedule
+0x00007949 T lld_adv_frm_isr
+0x10001c9b D sv_lock
+0x10001ca2 D sv_txlen
+0x10001735 T rom_lld_con_rx
+0x100019c5 T rom_lld_con_evt_start_cbk
+0x10001a1d T rom_lld_con_frm_isr
+0x1100abbd T gatt_cli_mtu_exch
+0x11012425 T rom_lld_disable_latency
+0x11012451 T rom_lld_enable_latency
+0x10001c9a D evt_start
+0x11009ced T gatt_cli_discover_svc
+0x1100d945 T gatt_uuid16_comp
+0x11009415 T gatt_cli_att_event_cfm
+0x11009729 T gatt_cli_discover_cancel
+0x1100977d T gatt_cli_discover_char
+0x110097e3 T gatt_cli_discover_desc
+0x1100a1b9 T gatt_cli_event_register
+0x1100ac9d T gatt_cli_read
+0x1100acd1 T gatt_cli_read_by_uuid
+0x1100b369 T gatt_cli_write
+0x1100d7ad T gatt_user_cli_register
+0x11003cdd T co_rand_word
+0x11003ce5 T co_random_init
+0x10001c98 D adv_evt_start
+0x10001c40 D gatt_srv_read_api_tbl
+0x10001c54 D gatt_srv_write_api_tbl

project/example/ble/ble_central/app/src/sleep.c

@@ -0,0 +1,219 @@
+/**
+ ****************************************************************************************
+ *
+ * @file arch_main.c
+ *
+ * @brief Main loop of the application.
+ *
+ * Copyright (C) RivieraWaves 2009-2015
+ *
+ *
+ ****************************************************************************************
+ */
+
+/*
+ * INCLUDES
+ ****************************************************************************************
+ */
+
+#include "rwip_config.h" // RW SW configuration
+
+#include "arch.h" // architectural platform definitions
+#include "boot.h" // boot definition
+#include "rwip.h" // RW SW initialization
+#include "xc_drv_pwr.h"
+#include <stdbool.h> // boolean definition
+#include <stddef.h>  // standard definitions
+#include <stdint.h>  // standard integer definition
+#include <stdlib.h>  // standard lib functions
+
+#if (BLE_TEST_MODE_SUPPORT)
+#include "uart.h" // UART initialization
+#endif            // (BLE_TEST_MODE_SUPPORT)
+
+#if (BLE_EMB_PRESENT || BT_EMB_PRESENT)
+#include "rf.h" // RF initialization
+#endif          // BLE_EMB_PRESENT || BT_EMB_PRESENT
+
+#if (BLE_APP_PRESENT)
+// #include "app.h"       // application functions
+#endif // BLE_APP_PRESENT
+
+#if PLF_DMA
+#include "dma.h" // DMA initialization
+#endif           // PLF_DMA
+
+#if (PLF_NVDS)
+#include "nvds.h" // NVDS definitions
+#endif            // PLF_NVDS
+
+#include "reg_assert_mgr.h"
+#if (PLF_PROFILING || PLF_MEM_PROTECTION)
+#include "reg_sw_profiling.h"
+#endif // (PLF_PROFILING || PLF_MEM_PROTECTION)
+#include "platform.h"
+
+#include "xc6xxx.h"
+
+// CPU early wake-up time (unit:us)
+#define SLEEP_TIME_EARLY (3000)
+
+#define HS_TO_US(frame)  (((frame) * SLOT_SIZE) >> 1)
+
+/**
+ * @brief       clock_init
+ * @details
+ * @param       void
+ * @retval      void
+ */
+void clock_init(void)
+{
+    CLOCK_InitCfg_t clock_cfg;
+
+    clock_cfg.hfclk_src = CLOCK_HFCLK_SRC_XTAL;
+    clock_cfg.hfclk_in  = CLOCK_HFCLK_IN_32M;
+#if (RC_32K)
+    clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_RC;
+#endif //(RC_32K)
+
+#if (XTAL_32K)
+    clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
+#endif // (XTAL_32K)
+
+#if (XTAL_32768K)
+    clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
+#endif // (XTAL_32768K)
+
+    if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_XTAL) {
+        clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32768;
+    } else if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_RC) {
+        clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32K;
+    }
+
+    xc_clock_init_cfg(&clock_cfg);
+
+    SysTick_Config(xc_clock_hfclk_in_get() / 100);
+    SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;
+}
+
+#if (SLEEP_ENABLE)
+void wakeup_timer_init(void)
+{
+    TIMER_BaseInitTypeDef Timer_Init;
+    Timer_Init.src_clk = TIMER_CLK_SRC_32K;
+    Timer_Init.mode    = TIMER_MODE_SINGLE_COUNT;
+    Timer_Init.div_clk = TIMER_DIV_CLK_32000Hz;
+    // Timer0 Config & Start
+    TIMER_Base_Init(XC_TIMER0, &Timer_Init);
+
+    PWR_InitTypeDef PWR_InitStruct = {0};
+    PWR_InitStruct.PWR_WakeITSrc   = GPIO_IRQn_WAKE | TIMER0_IRQn_WAKE;
+    PWR_InitStruct.PWR_SleepMode   = LIGHT_SLEEP_MODE;
+    PWR_SleepInit(&PWR_InitStruct);
+
+    PWR_GPIO_SleepConfig(PWR_InitStruct.PWR_SleepMode);
+
+    PWR_GPIO_LightSleepWakeConfig(GPIO_2, RIS_EDGE_INT);
+    PWR_GPIO_LightSleepWakeConfig(GPIO_3, RIS_EDGE_INT);
+}
+
+void sleep_wkup()
+{
+    PWR_InitTypeDef PWR_InitStruct = {0};
+
+#if (USE_XIP != 1)
+    SPI_InitCfg_t spi_cfg     = {0};
+    spi_cfg.Mode              = SPI_MODE_MASTER;
+    spi_cfg.DataSize          = SSI_CTRL0_DFS_LEN_8BIT;
+    spi_cfg.Direction         = SSI_CTRL0_TMOD_WR;
+    spi_cfg.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
+    spi_cfg.CLKPolarity       = SSI_CTRL0_SCPOL_LOW;
+    spi_cfg.CLKPhase          = SPI_CPHA_LEAD;
+    spi_cfg.FirstBit          = SPI_FirstBit_MSB;
+
+    xc_spi_init(XC_SPI0, &spi_cfg);
+    SPI_Flash_PowerDown(XC_SPI0);
+#endif //(USE_XIP!=1)
+
+    //    PWR_InitStruct.PWR_WakeITSrc = GPIO_IRQn_WAKE | TIMER0_IRQn_WAKE ;
+    //    PWR_InitStruct.PWR_SleepMode = LIGHT_SLEEP_MODE;
+    //    PWR_SleepInit(&PWR_InitStruct);
+    //    PWR_GPIO_SleepConfig(PWR_InitStruct.PWR_SleepMode);
+    sleep_init();
+    PWR_BLE_SleepEnter();
+}
+
+void Turn_Off_PeripheralClk()
+{
+    XC_CPR->SSI0_MCLK_CTL     = (((0UL << CPR_SSI_MCLK_CTL_SSI_MCLK_DIV_Pos) |
+                              CPR_SSI_MCLK_CTL_SSI_MCLK_DIV_WE) |
+                             ((CPR_SSI_MCLK_CTL_SSI_MCLK_EN_DISABLE) |
+                              CPR_SSI_MCLK_CTL_SSI_MCLK_EN_WE));
+
+    XC_CPR->CTLAPBCLKEN_GRCTL = ((CPR_CTLAPBCLKEN_GRCTL_SSI0_PCLK_EN_DISABLE) |
+                                 (CPR_CTLAPBCLKEN_GRCTL_SSI0_PCLK_EN_Msk
+                                  << CPR_CTLAPBCLKEN_GRCTL_MASK_OFFSET))
+                                << 0;
+
+    XC_CPR->CTLAPBCLKEN_GRCTL = ((CPR_CTLAPBCLKEN_GRCTL_UART0_PCLK_EN_DISABLE) |
+                                 (CPR_CTLAPBCLKEN_GRCTL_UART0_PCLK_EN_Msk
+                                  << CPR_CTLAPBCLKEN_GRCTL_MASK_OFFSET));
+
+    XC_CPR->UART0_CLK_GRCTL   = (((8UL << CPR_UART_CLK_GRCTL_UART0_CLK_GR_Pos) |
+                                CPR_UART_CLK_GRCTL_UART0_CLK_GR_WE) |
+                               ((CPR_UART_CLK_GRCTL_UART0_CLK_GR_UPD_DISABLE) |
+                                (CPR_UART_CLK_GRCTL_UART1_CLK_GR_UPD_WE)));
+
+    XC_CPR->CTLAPBCLKEN_GRCTL = ((CPR_CTLAPBCLKEN_GRCTL_UART0_PCLK_EN_DISABLE) |
+                                 (CPR_CTLAPBCLKEN_GRCTL_UART0_PCLK_EN_Msk
+                                  << CPR_CTLAPBCLKEN_GRCTL_MASK_OFFSET))
+                                << 1;
+    //
+    //    XC_CPR->UART1_CLK_GRCTL = (((8UL <<
+    //    CPR_UART_CLK_GRCTL_UART1_CLK_GR_Pos) |
+    //    CPR_UART_CLK_GRCTL_UART1_CLK_GR_WE) |
+    //                              ((CPR_UART_CLK_GRCTL_UART1_CLK_GR_UPD_DISABLE)
+    //                              |
+    //                              (CPR_UART_CLK_GRCTL_UART1_CLK_GR_UPD_WE)));
+
+    //    XC_CPR->AHBCLKEN_GRCTL =0x1e001e;
+}
+
+void sleep_schedule()
+{
+    // Checks for sleep have to be done with interrupt disabled
+    GLOBAL_INT_DISABLE();
+
+    // Check if the processor clock can be gated
+    uint32_t duration       = 0;
+    uint32_t duration_timer = 0;
+    //    switch(rwip_sleep(&duration, 2, \
+//			0x7D00, RWIP_MINIMUM_SLEEP_TIME)){
+    switch (rwip_sleep(&duration, 1, 0x7D00, 20)) {
+    case RWIP_DEEP_SLEEP: {
+        duration_timer = (HS_TO_US(duration) - SLEEP_TIME_EARLY);
+        TIMER_SetUs(XC_TIMER0, duration_timer);
+        TIMER_Start_IT(XC_TIMER0);
+        sleep_wkup();
+        __TIMER_Disable(XC_TIMER0);
+    }
+    // no break
+    case RWIP_CPU_SLEEP: {
+        // Wait for interrupt
+        //          Turn_Off_PeripheralClk();
+
+        //			__PWR_SleepSrcMask_Set(0x1e000e);
+        //			__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
+        //			__WFI();
+        //			__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
+        //			__PWR_SleepSrcMask_Set(0x1e001e);
+    } break;
+    case RWIP_ACTIVE:
+    default: {
+        // nothing to do.
+    } break;
+    }
+    // Checks for sleep have to be done with interrupt disabled
+    GLOBAL_INT_RESTORE();
+}
+#endif // (SLEEP_ENABLE)

project/example/ble/ble_central/app/src/startup_xinc.s

@@ -0,0 +1,245 @@
+
+;/*****************************************************************************
+; * @file:    startup_xinc.s
+; * @purpose: CMSIS Cortex-M0 Core Device Startup File for the 
+; *           Device xinc.
+; *****************************************************************************/
+
+Stack_Size      EQU     0x000006f0
+
+                AREA    STACK, NOINIT, READWRITE, ALIGN=3
+Stack_Mem       SPACE   Stack_Size
+__initial_sp
+
+Heap_Size       EQU     0x00000000
+
+                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
+__heap_base
+Heap_Mem        SPACE   Heap_Size
+__heap_limit
+
+
+                PRESERVE8
+                THUMB
+
+; Vector Table Mapped to Address 0 at Reset
+
+                AREA    RESET, DATA, READONLY
+                EXPORT  __Vectors
+                EXPORT  __Vectors_End
+                EXPORT  __Vectors_Size
+
+__Vectors       DCD     __initial_sp              ; Top of Stack
+                DCD     Reset_Handler             ; Reset Handler
+                DCD     NMI_Handler               ; NMI Handler
+                DCD     HardFault_Handler         ; Hard Fault Handler
+                DCD     MemManage_Handler         ; MPU Fault Handler
+                DCD     BusFault_Handler          ; Bus Fault Handler
+                DCD     UsageFault_Handler        ; Usage Fault Handler
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     SVC_Handler               ; SVCall Handler
+                DCD     DebugMon_Handler          ; Debug Monitor Handler
+                DCD     0                         ; Reserved
+                DCD     PendSV_Handler            ; PendSV Handler
+                DCD     SysTick_Handler           ; SysTick Handler
+
+                ; External Interrupts
+; ToDo:  Add here the vectors for the device specific external interrupts handler
+                DCD  	BLE_Handler               ; 0 
+                DCD  	DMA_Handler               ; 1 
+                DCD  	CPR_Handler               ; 2
+                DCD  	GPIO_Handler              ; 3
+                DCD  	RTC_Handler               ; 4
+                DCD  	TIMER0_Handler            ; 5
+                DCD  	TIMER1_Handler            ; 6
+                DCD  	TIMER2_Handler            ; 7
+                DCD  	TIMER3_Handler            ; 8
+                DCD  	WDT_Handler               ; 9
+                DCD  	I2C_Handler               ; 10
+                DCD  	UART0_Handler             ; 11
+                DCD  	UART1_Handler             ; 12
+                DCD  	SPI0_Handler              ; 13
+                DCD  	SPI1_Handler              ; 14
+                DCD  	0                         ; 15
+                DCD  	0                         ; 16
+                DCD  	GADC_Handler              ; 17
+				DCD		PWM_Handler               ; 18
+				DCD		AES_Handler               ; 19
+                DCD		USB_Handler               ; 20
+                DCD		AUDIO_Handler             ; 21               
+                DCD		RF24G_Handler             ; 22
+                DCD		SPI2_Handler              ; 23  
+                DCD		MPU_Handler               ; 24    
+                DCD		UART2_Handler             ; 25
+                DCD		I2S_Handler               ; 26     
+                DCD     AOTIMER0_Handler          ; 27    
+                DCD     AOTIMER1_Handler          ; 28
+                DCD     CMP_Handler               ; 29
+				DCD     FMC_Handler               ; 30        
+                DCD     CAN_Handler               ; 31
+       	     		     	              	              	              	              	  
+__Vectors_End
+
+__Vectors_Size 	EQU 	__Vectors_End - __Vectors
+
+
+
+                AREA    |.text|, CODE, READONLY
+; Reset Handler
+
+Reset_Handler   PROC
+
+                EXPORT  Reset_Handler           [WEAK]
+
+                IMPORT  SystemInit        
+                IMPORT  __main  
+          		
+                LDR     r0, =0x4000013C         ; remap
+                LDR     r1, =0x10000001
+                STR     r1, [r0] 
+
+
+
+                LDR     R0, =SystemInit
+                BLX     R0
+                
+                LDR     R0, =__main
+                BX      R0
+        
+                ENDP
+
+; Dummy Exception Handlers (infinite loops which can be modified)
+NMI_Handler     PROC
+                EXPORT  NMI_Handler               [WEAK]
+                B       .
+                ENDP
+
+
+HardFault_Handler\
+                PROC
+                EXPORT  HardFault_Handler         [WEAK]
+                B       .
+                ENDP
+MemManage_Handler\
+                PROC
+                EXPORT  MemManage_Handler         [WEAK]
+                B       .
+                ENDP
+BusFault_Handler\
+                PROC
+                EXPORT  BusFault_Handler          [WEAK]
+                B       .
+                ENDP
+UsageFault_Handler\
+                PROC
+                EXPORT  UsageFault_Handler        [WEAK]
+                B       .
+                ENDP
+SVC_Handler     PROC
+                EXPORT  SVC_Handler               [WEAK]
+                B       .
+                ENDP
+DebugMon_Handler\
+                PROC
+                EXPORT  DebugMon_Handler          [WEAK]
+                B       .
+                ENDP
+
+Default_Handler PROC
+                EXPORT  	BLE_Handler          	    [WEAK]
+                EXPORT  	DMA_Handler    	            [WEAK]	   
+                EXPORT  	CPR_Handler		    	    [WEAK]
+                EXPORT  	GPIO_Handler	    	    [WEAK]
+                EXPORT  	RTC_Handler	    	        [WEAK]
+                EXPORT  	TIMER0_Handler 		        [WEAK]
+                EXPORT  	TIMER1_Handler 		        [WEAK]
+                EXPORT  	TIMER2_Handler 		        [WEAK]
+                EXPORT  	TIMER3_Handler 		        [WEAK]
+                EXPORT  	WDT_Handler	                [WEAK]
+                EXPORT  	I2C_Handler    		        [WEAK]
+                EXPORT  	UART0_Handler	            [WEAK]
+                EXPORT  	UART1_Handler               [WEAK]
+                EXPORT  	SPI0_Handler                [WEAK]
+                EXPORT  	SPI1_Handler                [WEAK]
+                ;EXPORT  	KBS_Handler                 [WEAK]
+                ;EXPORT  	QDEC_Handler     	    	[WEAK]
+                EXPORT  	GADC_Handler    	        [WEAK]
+                EXPORT      PWM_Handler                 [WEAK]
+                EXPORT      AES_Handler                 [WEAK]
+                    
+                EXPORT		PendSV_Handler      	    [WEAK]
+		        EXPORT		SysTick_Handler	            [WEAK]	
+                    
+                EXPORT		USB_Handler                 [WEAK];20
+                EXPORT		AUDIO_Handler               [WEAK];21
+                EXPORT		RF24G_Handler               [WEAK];22
+                EXPORT		SPI2_Handler                [WEAK];23
+                EXPORT		MPU_Handler                 [WEAK];24
+                EXPORT		UART2_Handler               [WEAK];25
+                EXPORT		I2S_Handler                 [WEAK];26
+                EXPORT		AOTIMER0_Handler            [WEAK];27
+                EXPORT		AOTIMER1_Handler            [WEAK];28
+                EXPORT		CMP_Handler                 [WEAK];29
+                EXPORT		FMC_Handler                 [WEAK];30
+                EXPORT		CAN_Handler                 [WEAK];31
+                    
+PendSV_Handler
+SysTick_Handler
+BLE_Handler
+RF24G_Handler
+DMA_Handler    	
+CPR_Handler
+GPIO_Handler
+RTC_Handler
+TIMER0_Handler
+TIMER1_Handler
+TIMER2_Handler
+TIMER3_Handler
+WDT_Handler
+I2C_Handler
+I2S_Handler
+UART0_Handler
+UART1_Handler
+UART2_Handler
+SPI0_Handler
+SPI1_Handler
+SPI2_Handler
+MPU_Handler
+;KBS_Handler
+;QDEC_Handler
+GADC_Handler
+PWM_Handler
+AUDIO_Handler
+;SIM_Handler
+AES_Handler
+AOTIMER0_Handler
+AOTIMER1_Handler
+CMP_Handler  
+FMC_Handler	
+CAN_Handler
+USB_Handler
+
+                B       .
+                ENDP
+
+
+                ALIGN
+
+; User Initial Stack & Heap
+
+                IMPORT  __use_two_region_memory
+                EXPORT  __user_initial_stackheap
+__user_initial_stackheap
+
+                LDR     R0, =  Heap_Mem
+                LDR     R1, = (Stack_Mem + Stack_Size)
+                LDR     R2, = (Heap_Mem +  Heap_Size)
+                LDR     R3, = Stack_Mem
+                BX      LR
+
+                ALIGN
+
+                END

project/example/ble/ble_central/app/src/system_xinc.c

@@ -0,0 +1,117 @@
+/**
+ * Initialize the system
+ *
+ * @param  none
+ * @return none
+ *
+ * @brief  Setup the microcontroller system
+ *
+ */
+
+/*-----------------------------------------------------------------------------------
+                                       INCLUDE HEADE FILES
+ ------------------------------------------------------------------------------------*/
+#include <stdio.h>
+
+#include "rwip.h"
+#include "xc6xxx.h"
+/*------------------------------------------------------------------------------------
+                                             Macros
+ -------------------------------------------------------------------------------------*/
+#define __DEBUG_OUT_PORT 0
+
+/*------------------------------------------------------------------------------------
+                                            Functions
+ -------------------------------------------------------------------------------------*/
+#define VECTOR_NUM       48
+
+void set_vector(void)
+{
+#if (USE_XIP == 1)
+    __disable_irq();
+    for (uint32_t i = 0, *Pvector = (uint32_t *)(0x11014000 + 0),
+                  *_vector_table = (uint32_t *)(0x10000000);
+         i < VECTOR_NUM; i++) // copy vertor table
+    {
+        _vector_table[i] = *Pvector++;
+    }
+
+    *((volatile unsigned int *)(0x4000013C)) =
+        0x10000001; // inter vertor table remap
+    __enable_irq();
+#endif
+}
+
+static void WDT_ResetInit(void)
+{
+    cpr_ctlapbclken_grctl__wdt_pclk_en__setf(ENABLE);
+
+    cpr_rstctl_ctlapb_sw__wdt_rstn__setf(RSTCTL_ENABLE);
+    cpr_rstctl_ctlapb_sw__wdt_rstn__setf(RSTCTL_DISABLE);
+
+    cpr_rstctl_wdtrst_mask_set(
+        (WDT_SYS_RSTN_MASK_DISABLE | WDT_M0_RSTN_MASK_ENABLE));
+
+    cpr_lp_ctl__wdt_tclk_en__setf(DISABLE);
+    wdt_cr__wdt_en__setf(DISABLE);
+}
+
+void SystemInit(void)
+{
+
+    WDT_ResetInit();
+
+#if (USE_XIP == 1)
+
+    set_vector();
+#endif
+
+    // enable BT CLK
+    writel(0x40000040, readl(0x40000040) | (0x01 << 4) | 0xFFFF0000);
+}
+
+__RAM_CODE int sendchar(int c)
+{
+    unsigned int status;
+#if (__DEBUG_OUT_PORT == 1)
+    for (;;) {
+        status  = (*((volatile unsigned *)(0x40011000 + 0x14)));
+        status &= 0x20;
+        if (status == 0x20)
+            break;
+    }
+    (*((volatile unsigned *)(0x40011000 + 0x00))) = c;
+    return (1);
+#else
+    for (;;) {
+        status  = (*((volatile unsigned *)(0x40010000 + 0x14)));
+        status &= 0x20;
+        if (status == 0x20)
+            break;
+    }
+    (*((volatile unsigned *)(0x40010000 + 0x00))) = c;
+    return (1);
+#endif
+}
+
+struct __FILE
+{
+    int handle; /* Add whatever you need here */
+};
+
+FILE __stdout;
+__RAM_CODE int fputc(int ch, FILE *f) { return (sendchar(ch)); }
+
+int ferror(FILE *f)
+{
+    /* Your implementation of ferror */
+    return EOF;
+}
+
+void _ttywrch(int ch) { sendchar(ch); }
+
+void _sys_exit(int return_code)
+{
+label:
+    goto label; /* endless loop */
+}

project/example/ble/ble_central/app/src/usr_client.c

@@ -0,0 +1,192 @@
+#include "usr_client.h"
+
+uint8_t cli_user_lid     = GATT_INVALID_USER_LID;
+/* Handle for sending data from the centre to the slave. */
+uint16_t cli_tx_hdl      = GATT_INVALID_HDL;
+uint16_t cli_chg_ccc_hdl = GATT_INVALID_HDL;
+
+#define CUSTOM_SVC_UUID_CLI         0xFFF0
+#define CUSTOM_SVC_RX_CHAR_UUID_CLI 0xFFF3
+#define CUSTOM_SVC_TX_CHAR_UUID_CLI 0xFFF4
+
+uint8_t get_cli_user_ild(void) { return cli_user_lid; }
+
+void cli_discover_cmp_cb(uint8_t conidx, uint8_t user_lid, uint16_t dummy,
+                         uint16_t status)
+{
+    LOGI(
+        "[%s] conidx = 0x%x, user_lid = 0x%x, dummy = 0x%x, status = 0x%x \r\n",
+        __func__, conidx, user_lid, dummy, status);
+
+    uint16_t cli_cfg = GATT_CCC_START_NTF;
+    status = xc_ble_gatt_cli_write(conidx, get_cli_user_ild(), 0, GATT_WRITE,
+                                   cli_chg_ccc_hdl, 2, (uint8_t *)&cli_cfg);
+
+    if (status != GATT_NO_ERROR) {
+        LOGI_ERR("xc_ble_gatt_cli_write error 0x%x", status);
+    }
+
+   // send_data(conidx);
+}
+
+void cli_read_cmp_cb(uint8_t conidx, uint8_t user_lid, uint16_t dummy,
+                     uint16_t status)
+{
+    LOGI(
+        "[%s] conidx = 0x%x, user_lid = 0x%x, dummy = 0x%x, status = 0x%x \r\n",
+        __func__, conidx, user_lid, dummy, status);
+}
+
+void cli_write_cmp_cb(uint8_t conidx, uint8_t user_lid, uint16_t dummy,
+                      uint16_t status)
+{
+    LOGI("[%s] conidx = 0x%x, user_lid = 0x%x, dummy = 0x%x, status = 0x%x\r\n",
+         __func__, conidx, user_lid, dummy, status);
+}
+
+void cli_svc_cb(uint8_t conidx, uint8_t user_lid, uint16_t dummy, uint16_t hdl,
+                uint8_t disc_info, uint8_t nb_att, const gatt_svc_att_t *p_atts)
+{
+    LOGI("[%s] conidx = 0x%x, user_lid = 0x%x, dummy = 0x%x, hdl = 0x%x \r\n",
+         __func__, conidx, user_lid, dummy, hdl);
+
+    uint8_t cursor;
+    uint16_t att_handle = GATT_INVALID_HDL;
+
+    // check all attributes
+    for (cursor = 0; cursor < nb_att; cursor++) {
+        const gatt_svc_att_t *p_att = &(p_atts[cursor]);
+
+        switch (p_att->att_type) {
+        case GATT_ATT_PRIMARY_SVC: {
+        } break;
+        case GATT_ATT_CHAR: {
+            att_handle = p_att->info.charac.val_hdl;
+        } break;
+        case GATT_ATT_VAL: {
+            if (gatt_uuid16_comp(p_att->uuid, p_att->uuid_type,
+                                 CUSTOM_SVC_RX_CHAR_UUID_CLI)) {
+                cli_tx_hdl = att_handle;
+                LOGI("cli_tx_hdl=0x%x\n", cli_tx_hdl);
+            }
+        } break;
+        case GATT_ATT_DESC: {
+            // Client Char Configuration of service changed value
+            if (gatt_uuid16_comp(p_att->uuid, p_att->uuid_type,
+                                 GATT_DESC_CLIENT_CHAR_CFG)) {
+                cli_chg_ccc_hdl = hdl + cursor;
+                LOGI("cli_chg_ccc_hdl=0x%x\n", cli_chg_ccc_hdl);
+            }
+        } break;
+        default: { /* Nothing to do */
+        } break;
+        }
+    }
+}
+
+void cli_svc_info_cb(uint8_t conidx, uint8_t user_lid, uint16_t dummy,
+                     uint16_t start_hdl, uint16_t end_hdl, uint8_t uuid_type,
+                     const uint8_t *p_uuid)
+{
+    LOGI("[%s] conidx = 0x%x, user_lid = 0x%x, start_hdl = 0x%x, end_hdl = "
+         "0x%x, uuid[0] = 0x%x, uuid[1] = 0x%x \r\n",
+         __func__, conidx, user_lid, start_hdl, end_hdl, p_uuid[0], p_uuid[1]);
+}
+
+void cli_read_val_cb(uint8_t conidx, uint8_t user_lid, uint16_t dummy,
+                     uint16_t hdl, uint16_t offset, co_buf_t *p_data)
+{
+    uint16_t length = co_buf_data_len(p_data);
+    LOGI("[%s] conidx = 0x%x, user_lid = 0x%x, handler = 0x%x, length = "
+         "0x%x  data: \r\n",
+         __func__, conidx, user_lid, hdl, length);
+    // DUMP_DATA_PRINTF(&(co_buf_data(p_data)[0]), length);
+}
+
+void cli_val_evt_cb(uint8_t conidx, uint8_t user_lid, uint16_t token,
+                    uint8_t evt_type, bool complete, uint16_t hdl,
+                    co_buf_t *p_data)
+{
+    uint16_t status;
+    uint16_t length = co_buf_data_len(p_data);
+
+    LOGI("[%s] conidx = 0x%x, user_lid = 0x%x, token = 0x%x  evt_type = \
+    0x%x complete  = 0x%x handler = 0x%x, length =  %d  data: \r\n",
+         __func__, conidx, user_lid, token, evt_type, complete, hdl, length);    
+        status = xc_ble_gatt_cli_indicate_cfm(conidx, user_lid, token);
+        if (status != GATT_NO_ERROR) {
+            LOGI_ERR("gatt_cli_indicate_cfm error 0x%x", status);
+        }
+    
+    
+    for(uint8_t i = 0;i<length;i++)
+    {
+        LOGI(" %02x ",co_buf_data(p_data)[i]);
+    }
+    LOGI("\r\n");
+    //(&(co_buf_data(p_data)[0]), length);
+}
+
+void cli_svc_changed_cb(uint8_t conidx, uint8_t user_lid, bool out_of_sync,
+                        uint16_t start_hdl, uint16_t end_hdl)
+{
+    LOGI("[%s] conidx = 0x%x, user_lid = 0x%x, out_of_sync = 0x%x ,start_hdl = "
+         "0x%x, end_hdl = "
+         "0x%x \r\n",
+         __func__, conidx, user_lid, out_of_sync, start_hdl, end_hdl);
+}
+
+static const gatt_cli_cb_t cli_cb = {
+    .cb_discover_cmp = cli_discover_cmp_cb,
+    .cb_read_cmp     = cli_read_cmp_cb,
+    .cb_write_cmp    = cli_write_cmp_cb,
+    .cb_svc          = cli_svc_cb,
+    .cb_svc_info     = cli_svc_info_cb,
+    .cb_att_val      = cli_read_val_cb,
+    .cb_att_val_evt  = cli_val_evt_cb,
+    .cb_svc_changed  = cli_svc_changed_cb,
+};
+
+uint8_t app_cli_register(void)
+{
+    uint16_t status = 0;
+    status          = xc_ble_gatt_user_cli_register(GAP_LE_MTU_MAX, 0, &cli_cb,
+                                                    &cli_user_lid);
+    if (status != GATT_NO_ERROR) {
+        LOGI_ERR("gatt_user_cli_register error 0x%x", status);
+    }
+    return status;
+}
+
+__RAM_EM uint8_t data_test[THROUGHTPUT_SEND_DATA_LEN] = {0x00, 0x01, 0x02,
+                                                         0x03};
+void send_data(uint8_t conidx)
+{
+    uint16_t status;
+
+    status = xc_ble_gatt_cli_write(conidx, get_cli_user_ild(), 0, GATT_WRITE,
+                                   cli_tx_hdl, sizeof(data_test), data_test);
+    if (status != GATT_NO_ERROR) {
+        LOGI_ERR("write error 0x%x", status);
+    }
+}
+
+void usr_cli_feat_enable(uint8_t conidx)
+{
+    uint16_t svc_uuid = CUSTOM_SVC_UUID_CLI;
+    uint8_t status    = gatt_cli_discover_svc(
+        conidx, get_cli_user_ild(), 0, GATT_DISCOVER_SVC_PRIMARY_BY_UUID, true,
+        GATT_MIN_HDL, GATT_MAX_HDL, GATT_UUID_16, (uint8_t *)&svc_uuid);
+
+    if (status == GATT_NO_ERROR) {
+        status = xc_ble_gatt_cli_event_register(conidx, get_cli_user_ild(),
+                                                GATT_MIN_HDL, GATT_MAX_HDL);
+        if (status != GATT_NO_ERROR) {
+            LOGI_ERR("xc_ble_gatt_cli_event_register error 0x%x", status);
+        }
+    } else {
+        LOGI_ERR("gatt_cli_discover_svc error 0x%x", status);
+    }
+
+    //  uint16_t xc_ble_gatt_cli_mtu_exch( conidx, get_cli_user_ild());
+}

project/example/ble/ble_central/app/src/usr_client.h

@@ -0,0 +1,28 @@
+/**
+ ****************************************************************************************
+ *
+ * @file usr_client.h
+ *
+ * @brief Custom client
+ *
+ * Copyright (c) 2022 - 2025, XinChip
+ * All rights reserved.
+ *
+ ****************************************************************************************
+ */
+
+#ifndef _USR_CLIENT_H_
+#define _USE_CLIENT_H_
+
+#include "app_task.h"
+#include "dbg.h"
+#include "gatt_msg.h"
+#include "usr_server.h"
+#include "xc_gatt_client_api.h"
+
+#define THROUGHTPUT_SEND_DATA_LEN 20
+
+uint8_t get_cli_user_ild(void);
+uint8_t app_cli_register(void);
+void usr_cli_feat_enable(uint8_t conidx);
+#endif // _USE_CLIENT_H_

project/example/ble/ble_central/app/src/usr_server.c

@@ -0,0 +1,170 @@
+
+/**
+ ****************************************************************************************
+ *
+ * @file usr_server.c
+ *
+ * @brief Custom Server  profile database definitions.
+ *
+ * Copyright (c) 2022 - 2025, XinChip
+ * All rights reserved.p
+ *
+ ****************************************************************************************
+ */
+#include "usr_server.h"
+#include "xc6xxx.h"
+uint8_t srv_user_lid                              = GATT_INVALID_USER_LID;
+uint16_t custom_svc_start_hdl                     = GATT_INVALID_HDL;
+uint8_t custom_svc_tx_char_notify                 = DISABLE;
+
+static const gatt_att_desc_t custom_server_atts[] = {
+    [CUSTOM_SVC_DECL] =
+        {
+            .uuid = 0x00,
+            0x28,
+            .info     = GATT_ATT_RD_BIT | ATT_UUID(16),
+            .ext_info = 0,
+        },
+    [CUSTOM_SVC_RX_CHAR_DECL_CHAR] =
+        {
+            .uuid = 0x03,
+            0x28,
+            .info     = GATT_ATT_RD_BIT | ATT_UUID(16),
+            .ext_info = 0,
+        },
+    [CUSTOM_SVC_RX_CHAR_VAL] =
+        {
+            .uuid = CUSTOM_SVC_RX_CHAR_UUID,
+            .info = GATT_ATT_WC_BIT | GATT_ATT_RD_BIT | ATT_UUID(128),
+            .ext_info =
+                GATT_ATT_NO_OFFSET_BIT | CUSTOM_SVC_RX_CHAR_VAL_MAX_LENGTH,
+        },
+    [CUSTOM_SVC_TX_CHAR_DECL_CHAR] =
+        {
+            .uuid = 0x03,
+            0x28,
+            .info     = GATT_ATT_RD_BIT | ATT_UUID(16),
+            .ext_info = 0,
+        },
+    [CUSTOM_SVC_TX_CHAR_VAL] =
+        {
+            .uuid = CUSTOM_SVC_TX_CHAR_UUID,
+            .info = GATT_ATT_N_BIT | ATT_UUID(128),
+            .ext_info =
+                GATT_ATT_NO_OFFSET_BIT | CUSTOM_SVC_TX_CHAR_VAL_MAX_LENGTH,
+        },
+    [CUSTOM_SVC_TX_CHAR_CFG] =
+        {
+            .uuid = 0x02,
+            0x29,
+            .info     = GATT_ATT_RD_BIT | GATT_ATT_WR_BIT | ATT_UUID(16),
+            .ext_info = 0,
+        },
+};
+
+uint8_t slave_send_data(uint8_t *data, uint8_t len, uint8_t att_idx);
+
+uint16_t srv_get_hdl_from_att_idx(uint8_t idx)
+{
+    return custom_svc_start_hdl + idx;
+}
+
+// This function is called when GATT server user has initiated event send to
+// peer device or if an error occurs.
+__STATIC void custom_svc_cb_event_sent(uint8_t conidx, uint8_t user_lid,
+                                       uint16_t dummy, uint16_t status)
+{
+    LOGI("[%s] conidx:%d, usr_lid:%d, dummy:%d, status:%d \r\n", __func__,
+         conidx, user_lid, dummy, status);
+}
+
+// This function is called when peer want to read local attribute database
+// value.
+__STATIC void custom_svc_cb_att_read_get(uint8_t conidx, uint8_t user_lid,
+                                         uint16_t token, uint16_t hdl,
+                                         uint16_t offset, uint16_t max_length)
+{
+    uint16_t status;
+    uint8_t data[] = {0x12, 0x15, 0x46, 0x62};
+    LOGI("[%s] conidx:%d, usr_lid:%d, token:%d, hdl:%d, offset:%d, "
+         "max_length:%d \r\n",
+         __func__, conidx, user_lid, token, hdl, offset, max_length);
+    // Send result to peer device
+    status = xc_ble_gatt_srv_read_cfm(conidx, user_lid, token, GAP_ERR_NO_ERROR,
+                                      sizeof(data), sizeof(data), data);
+    if (status != GATT_NO_ERROR) {
+        LOGI_ERR("gatt_srv_read_cfm error 0x%x", status);
+    }
+}
+
+// This function is called during a write procedure to modify attribute handle.
+__STATIC void custom_svc_cb_att_val_set(uint8_t conidx, uint8_t user_lid,
+                                        uint16_t token, uint16_t hdl,
+                                        uint16_t offset, co_buf_t *p_data)
+{
+    uint16_t length = co_buf_data_len(p_data);
+    uint16_t status;
+    LOGI("[%s] conidx:%d, usr_lid:%d, token:%d, hdl:%d, offset:%d  \r\n",
+         __func__, conidx, user_lid, token, hdl, offset);
+    status =
+        xc_ble_gatt_srv_write_cfm(conidx, user_lid, token, GAP_ERR_NO_ERROR);
+    if (status != GATT_NO_ERROR) {
+        LOGI_ERR("gatt_srv_write_cfm error 0x%x", status);
+    }
+    LOGI("length:%d data:\r\n", length);
+    // DUMP_DATA_PRINTF(co_buf_data(p_data), length);
+    //  xc_fota_server_write_ind(co_buf_data(p_data), length);
+    //  LOGI("hdl=%x  %x\r\n", hdl,
+    //  srv_get_hdl_from_att_idx(CUSTOM_SVC_TX_CHAR_CFG));
+    if (hdl == srv_get_hdl_from_att_idx(CUSTOM_SVC_TX_CHAR_CFG)) {
+        if ((co_buf_data(p_data)[1] == 0) && (co_buf_data(p_data)[0] == 0)) {
+            custom_svc_tx_char_notify = DISABLE;
+        } else {
+            custom_svc_tx_char_notify = ENABLE;
+            LOGI("custom_svc_tx_char_notify ENABLE\r\n");
+            uint8_t data[254] = {0x12, 0x13, 0x14};
+            slave_send_data(data, sizeof(data), CUSTOM_SVC_TX_CHAR_VAL);
+            LOGI("notify test\r\n");
+        }
+    }
+}
+
+static const gatt_srv_cb_t custom_src_cb = {
+    .cb_event_sent   = custom_svc_cb_event_sent,
+    .cb_att_read_get = custom_svc_cb_att_read_get,
+    .cb_att_val_set  = custom_svc_cb_att_val_set,
+};
+
+uint8_t custom_svc_add(void)
+{
+    int nb_att = sizeof(custom_server_atts) / sizeof(custom_server_atts[0]);
+    uint16_t status;
+    uint8_t custom_svc_uuid[GATT_UUID_128_LEN] = CUSTOM_SVC_UUID;
+    status = xc_ble_gatt_user_srv_register(GAP_LE_MTU_MAX, 0, &custom_src_cb,
+                                           &srv_user_lid);
+    if (status != GATT_NO_ERROR) {
+        LOGI_ERR("gatt_user_srv_register error 0x%x", status);
+    }
+    status = xc_ble_gatt_service_add(
+        srv_user_lid, GATT_UUID_128 << GATT_SVC_UUID_TYPE_LSB, custom_svc_uuid,
+        nb_att, NULL, &(custom_server_atts[0]), nb_att, &custom_svc_start_hdl);
+    if (status != GATT_NO_ERROR) {
+        LOGI_ERR("xc_ble_gatt_service_add error 0x%x", status);
+    }
+    return status;
+}
+
+uint8_t slave_send_data(uint8_t *data, uint8_t len, uint8_t att_idx)
+{
+    uint16_t status             = INVALID_DATA;
+    struct app_env_tag *app_env = get_app_env();
+    if (app_env->slave_connected && custom_svc_tx_char_notify) {
+        status = xc_ble_gatt_srv_notify(app_env->slave_conidx, srv_user_lid, 0,
+                                        srv_get_hdl_from_att_idx(att_idx), len,
+                                        data);
+        if (status != GATT_NO_ERROR) {
+            LOGI_ERR("gatt_srv_notify error 0x%x", status);
+        }
+    }
+    return status;
+}

project/example/ble/ble_central/app/src/usr_server.h

@@ -0,0 +1,64 @@
+/**
+ ****************************************************************************************
+ *
+ * @file usr_server.h
+ *
+ * @brief Custom Server  profile database definitions.
+ *
+ * Copyright (c) 2022 - 2025, XinChip
+ * All rights reserved.
+ *
+ ****************************************************************************************
+ */
+#ifndef _USR_SERVER_H_
+#define _USR_SERVER_H_
+
+#include "app_task.h"
+#include "dbg.h"
+#include "gatt.h"
+#include "gatt_msg.h"
+#include "rwble_hl_config.h"
+#include "xc_gatt_server_api.h"
+
+// #define CUSTOM_SVC_UUID
+// {0x00,0x00,0xFF,0x10,0x00,0x00,0x10,0x00,0x80,0x00,0x00,0x80,0x5F,0x9B,0x34,0xFA}
+// #define CUSTOM_SVC_RX_CHAR_UUID
+// 0x00,0x00,0xFF,0x11,0x00,0x00,0x10,0x00,0x80,0x00,0x00,0x80,0x5F,0x9B,0x34,0xFB
+// #define CUSTOM_SVC_TX_CHAR_UUID
+// 0x00,0x00,0xFF,0x12,0x00,0x00,0x10,0x00,0x80,0x00,0x00,0x80,0x5F,0x9B,0x34,0xFB
+
+#define CUSTOM_SVC_UUID                                                        \
+    {                                                                          \
+        0xFA, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00,      \
+            0x00, 0x10, 0xFF, 0x00, 0x00                                       \
+    }
+#define CUSTOM_SVC_TX_CHAR_UUID                                                \
+    0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00,    \
+        0x11, 0xFF, 0x00, 0x00
+#define CUSTOM_SVC_RX_CHAR_UUID                                                \
+    0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00,    \
+        0x12, 0xFF, 0x00, 0x00
+
+#define CUSTOM_SVC_RX_CHAR_VAL_MAX_LENGTH (512)
+#define CUSTOM_SVC_TX_CHAR_VAL_MAX_LENGTH (512)
+
+#ifndef DISABLE
+#define DISABLE  0
+#endif // DISABLE
+
+#ifndef ENABLE
+#define ENABLE   1
+#endif // ENABLE
+
+enum cust_svc
+{
+    CUSTOM_SVC_DECL = 0,
+    CUSTOM_SVC_RX_CHAR_DECL_CHAR,
+    CUSTOM_SVC_RX_CHAR_VAL,
+    CUSTOM_SVC_TX_CHAR_DECL_CHAR,
+    CUSTOM_SVC_TX_CHAR_VAL,
+    CUSTOM_SVC_TX_CHAR_CFG,
+};
+uint8_t custom_svc_add(void);
+uint8_t slave_send_data(uint8_t *data, uint8_t len, uint8_t att_idx);
+#endif // _USR_SERVER_H_