This commit is contained in:
moyuhai
2026-06-11 13:00:46 +08:00
commit e8074162f3
2017 changed files with 507042 additions and 0 deletions
@@ -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))
/// 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_
@@ -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_ */
@@ -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
@@ -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_
@@ -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 },
};
@@ -0,0 +1,544 @@
/**
****************************************************************************************
*
* @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)
{
struct gapc_encrypt_req_ind const *param = (struct gapc_encrypt_req_ind const *)p_param;
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 // #if (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
@@ -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
@@ -0,0 +1,972 @@
/**
****************************************************************************************
*
* @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"
__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;
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;
}
// 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 cfm = {0};
switch (param->req) {
case GAPC_DEV_NAME: {
cfm.req = param->req;
cfm.token = param->token;
cfm.status = GAP_ERR_NO_ERROR;
cfm.info.name.value_length = app_get_dev_name(cfm.info.name.value);
xc_ble_get_dev_info_cfm(conidx, &cfm);
} break;
case GAPC_DEV_APPEARANCE: {
cfm.req = param->req;
cfm.info.appearance = DEV_APPEARANCE;
cfm.token = param->token;
cfm.status = GAP_ERR_NO_ERROR;
xc_ble_get_dev_info_cfm(conidx, &cfm);
} break;
case GAPC_DEV_SLV_PREF_PARAMS: {
cfm.req = param->req;
cfm.info.slv_pref_params.con_intv_min = BLE_UAPDATA_MIN_INTVALUE;
// Slave preferred Connection interval Max
cfm.info.slv_pref_params.con_intv_max = BLE_UAPDATA_MAX_INTVALUE;
// Slave preferred Connection latency
cfm.info.slv_pref_params.slave_latency = BLE_UAPDATA_LATENCY;
// Slave preferred Link supervision timeout
cfm.info.slv_pref_params.conn_timeout = BLE_UAPDATA_TIMEOUT;
cfm.token = param->token;
cfm.status = GAP_ERR_NO_ERROR;
xc_ble_get_dev_info_cfm(conidx, &cfm);
} break;
default:
break;
}
}
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
@@ -0,0 +1,432 @@
/**
****************************************************************************************
*
* @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"
/**
****************************************************************************************
* @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()
{
uint8_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
@@ -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
0x11011a35 T prf_dst_task_get
0x11011b69 T rom_env_init
0x110038ad T gapc_get_bdaddr
0x1100a7e1 T gatt_db_svc16_add
0x1100a965 T gatt_db_svc_add
0x1100b94d T gatt_srv_att_read_get_cfm
0x1100ba85 T gatt_srv_att_val_set_cfm
0x1100c465 T gatt_srv_event_send
0x1100d34d T gatt_user_srv_register
0x11012938 D llc_msg_handler_tab
0x10001c00 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
0x10001c1b D sv_lock
0x10001c22 D sv_txlen
0x10001715 T rom_lld_con_rx
0x1000199f T rom_lld_con_evt_start_cbk
0x100019ef T rom_lld_con_frm_isr
0x11009621 T gatt_cli_mtu_exch
0x11011d21 T rom_lld_disable_latency
0x11011d6d T rom_lld_enable_latency
0x10001c1a D evt_start
0x11008751 T gatt_cli_discover_svc
0x1100d3ed T gatt_uuid16_comp
0x11007e79 T gatt_cli_att_event_cfm
0x1100818d T gatt_cli_discover_cancel
0x110081e1 T gatt_cli_discover_char
0x11008247 T gatt_cli_discover_desc
0x11008c1d T gatt_cli_event_register
0x11009701 T gatt_cli_read
0x11009735 T gatt_cli_read_by_uuid
0x11009dcd T gatt_cli_write
0x1100d255 T gatt_user_cli_register
0x11002bc9 T co_rand_word
0x11002bd1 T co_random_init
0x10001c18 D adv_evt_start
@@ -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_cb.lfclk_src = CLOCK_LFCLK_SRC_RC;
#endif //(RC_32K)
#if (XTAL_32K)
clock_cb.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
#endif // (XTAL_32K)
#if (XTAL_32768K)
clock_cb.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)
@@ -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
@@ -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 */
}
@@ -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 0xFFF0
#define CUSTOM_SVC_RX_CHAR_UUID 0xFFF3
#define CUSTOM_SVC_TX_CHAR_UUID 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_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);
}
}
int usr_cli_feat_enable(uint8_t conidx)
{
uint16_t svc_uuid = CUSTOM_SVC_UUID;
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());
}
@@ -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);
int usr_cli_feat_enable(uint8_t conidx);
#endif // _USE_CLIENT_H_
@@ -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;
}
@@ -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_
@@ -0,0 +1,12 @@
FUNC void Initialization(void)
{
SP = _RDWORD(0x10000000);
PC = _RDWORD(0x10000004);
}
LOAD %L INCREMENTAL
Initialization();
@@ -0,0 +1,39 @@
[BREAKPOINTS]
ForceImpTypeAny = 0
ShowInfoWin = 1
EnableFlashBP = 2
BPDuringExecution = 0
[CFI]
CFISize = 0x00
CFIAddr = 0x00
[CPU]
MonModeVTableAddr = 0xFFFFFFFF
MonModeDebug = 0
MaxNumAPs = 0
LowPowerHandlingMode = 0
OverrideMemMap = 0
AllowSimulation = 1
ScriptFile=""
[FLASH]
CacheExcludeSize = 0x00
CacheExcludeAddr = 0x00
MinNumBytesFlashDL = 0
SkipProgOnCRCMatch = 1
VerifyDownload = 1
AllowCaching = 1
EnableFlashDL = 2
Override = 0
Device="ARM7"
[GENERAL]
WorkRAMSize = 0x00
WorkRAMAddr = 0x00
RAMUsageLimit = 0x00
[SWO]
SWOLogFile=""
[MEM]
RdOverrideOrMask = 0x00
RdOverrideAndMask = 0xFFFFFFFF
RdOverrideAddr = 0xFFFFFFFF
WrOverrideOrMask = 0x00
WrOverrideAndMask = 0xFFFFFFFF
WrOverrideAddr = 0xFFFFFFFF
@@ -0,0 +1,16 @@
LOAD 0x10000000
{
EXE 0x10000000
{
startup_xinc.o (RESET, +FIRST)
* (+RO)
}
RW +0000
{
* (+RW,+ZI)
}
ScatterAssert(ImageLength(RW) < 1024 * 28)
}
@@ -0,0 +1,33 @@
LOAD 0x11014000
{
EXE 0x11014000
{
startup_xinc.o (RESET, +FIRST)
* (+RO)
}
;This area is vector
RW1 0x10000100
{
startup_xinc.o(STACK)
}
ScatterAssert(ImageLength(RW1) < (0x800 - 0x100))
RW 0x10002200
{
; startup_xinc.o(STACK)
* (+RW,+ZI)
*(ram_code)
aeabi_sdiv.o(.text)
uread4.o(.text)
rt_memclr.o(.text)
}
ScatterAssert((0x2200+ImageLength(RW)) < 1024 * 32 )
; RW2 (0x53004000+12*1024)
; {
; *(ram_em)
; }
; ScatterAssert((0x53004000+12*1024)+ImageLength(RW2) < (0x53004000+16*1024))
}
File diff suppressed because it is too large Load Diff
Binary file not shown.
@@ -0,0 +1,553 @@
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<ProjectOpt xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="project_optx.xsd">
<SchemaVersion>1.0</SchemaVersion>
<Header>### uVision Project, (C) Keil Software</Header>
<Extensions>
<cExt>*.c</cExt>
<aExt>*.s*; *.src; *.a*</aExt>
<oExt>*.obj; *.o</oExt>
<lExt>*.lib</lExt>
<tExt>*.txt; *.h; *.inc</tExt>
<pExt>*.plm</pExt>
<CppX>*.cpp</CppX>
<nMigrate>0</nMigrate>
</Extensions>
<DaveTm>
<dwLowDateTime>0</dwLowDateTime>
<dwHighDateTime>0</dwHighDateTime>
</DaveTm>
<Target>
<TargetName>ble-sdk-xip</TargetName>
<ToolsetNumber>0x4</ToolsetNumber>
<ToolsetName>ARM-ADS</ToolsetName>
<TargetOption>
<CLKADS>12000000</CLKADS>
<OPTTT>
<gFlags>1</gFlags>
<BeepAtEnd>1</BeepAtEnd>
<RunSim>0</RunSim>
<RunTarget>1</RunTarget>
<RunAbUc>0</RunAbUc>
</OPTTT>
<OPTHX>
<HexSelection>1</HexSelection>
<FlashByte>65535</FlashByte>
<HexRangeLowAddress>0</HexRangeLowAddress>
<HexRangeHighAddress>0</HexRangeHighAddress>
<HexOffset>0</HexOffset>
</OPTHX>
<OPTLEX>
<PageWidth>79</PageWidth>
<PageLength>66</PageLength>
<TabStop>8</TabStop>
<ListingPath>.\Listings\</ListingPath>
</OPTLEX>
<ListingPage>
<CreateCListing>1</CreateCListing>
<CreateAListing>1</CreateAListing>
<CreateLListing>1</CreateLListing>
<CreateIListing>0</CreateIListing>
<AsmCond>1</AsmCond>
<AsmSymb>1</AsmSymb>
<AsmXref>0</AsmXref>
<CCond>1</CCond>
<CCode>0</CCode>
<CListInc>0</CListInc>
<CSymb>0</CSymb>
<LinkerCodeListing>0</LinkerCodeListing>
</ListingPage>
<OPTXL>
<LMap>1</LMap>
<LComments>1</LComments>
<LGenerateSymbols>1</LGenerateSymbols>
<LLibSym>1</LLibSym>
<LLines>1</LLines>
<LLocSym>1</LLocSym>
<LPubSym>1</LPubSym>
<LXref>0</LXref>
<LExpSel>0</LExpSel>
</OPTXL>
<OPTFL>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<IsCurrentTarget>1</IsCurrentTarget>
</OPTFL>
<CpuCode>7</CpuCode>
<DebugOpt>
<uSim>0</uSim>
<uTrg>1</uTrg>
<sLdApp>1</sLdApp>
<sGomain>1</sGomain>
<sRbreak>1</sRbreak>
<sRwatch>1</sRwatch>
<sRmem>1</sRmem>
<sRfunc>1</sRfunc>
<sRbox>1</sRbox>
<tLdApp>1</tLdApp>
<tGomain>1</tGomain>
<tRbreak>1</tRbreak>
<tRwatch>1</tRwatch>
<tRmem>1</tRmem>
<tRfunc>0</tRfunc>
<tRbox>1</tRbox>
<tRtrace>1</tRtrace>
<sRSysVw>1</sRSysVw>
<tRSysVw>1</tRSysVw>
<sRunDeb>0</sRunDeb>
<sLrtime>0</sLrtime>
<bEvRecOn>1</bEvRecOn>
<bSchkAxf>0</bSchkAxf>
<bTchkAxf>0</bTchkAxf>
<nTsel>4</nTsel>
<sDll></sDll>
<sDllPa></sDllPa>
<sDlgDll></sDlgDll>
<sDlgPa></sDlgPa>
<sIfile></sIfile>
<tDll></tDll>
<tDllPa></tDllPa>
<tDlgDll></tDlgDll>
<tDlgPa></tDlgPa>
<tIfile>..\..\..\driver\adc\mdk\Linker\XIPInitialization.ini</tIfile>
<pMon>Segger\JL2CM3.dll</pMon>
</DebugOpt>
<TargetDriverDllRegistry>
<SetRegEntry>
<Number>0</Number>
<Key>JL2CM3</Key>
<Name>-U4294967295 -O78 -S2 -ZTIFSpeedSel5000 -A0 -C0 -JU1 -JI127.0.0.1 -JP0 -RST0 -N00("ARM CoreSight SW-DP") -D00(0BB11477) -L00(0) -TO18 -TC10000000 -TP21 -TDS8027 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -TB1 -TFE0 -FO7 -FD10000000 -FC1000 -FN1 -FF0XIP_SPI_FLASH_M0 -FS011001000 -FL020000</Name>
</SetRegEntry>
<SetRegEntry>
<Number>0</Number>
<Key>UL2CM3</Key>
<Name>UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000)</Name>
</SetRegEntry>
</TargetDriverDllRegistry>
<Breakpoint/>
<Tracepoint>
<THDelay>0</THDelay>
</Tracepoint>
<DebugFlag>
<trace>0</trace>
<periodic>0</periodic>
<aLwin>0</aLwin>
<aCover>0</aCover>
<aSer1>0</aSer1>
<aSer2>0</aSer2>
<aPa>0</aPa>
<viewmode>0</viewmode>
<vrSel>0</vrSel>
<aSym>0</aSym>
<aTbox>0</aTbox>
<AscS1>0</AscS1>
<AscS2>0</AscS2>
<AscS3>0</AscS3>
<aSer3>0</aSer3>
<eProf>0</eProf>
<aLa>0</aLa>
<aPa1>0</aPa1>
<AscS4>0</AscS4>
<aSer4>0</aSer4>
<StkLoc>0</StkLoc>
<TrcWin>0</TrcWin>
<newCpu>0</newCpu>
<uProt>0</uProt>
</DebugFlag>
<LintExecutable></LintExecutable>
<LintConfigFile></LintConfigFile>
<bLintAuto>0</bLintAuto>
<bAutoGenD>0</bAutoGenD>
<LntExFlags>0</LntExFlags>
<pMisraName></pMisraName>
<pszMrule></pszMrule>
<pSingCmds></pSingCmds>
<pMultCmds></pMultCmds>
<pMisraNamep></pMisraNamep>
<pszMrulep></pszMrulep>
<pSingCmdsp></pSingCmdsp>
<pMultCmdsp></pMultCmdsp>
</TargetOption>
</Target>
<Group>
<GroupName>startup</GroupName>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
<File>
<GroupNumber>1</GroupNumber>
<FileNumber>1</FileNumber>
<FileType>5</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\CMSIS\core_cm0.h</PathWithFileName>
<FilenameWithoutPath>core_cm0.h</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>1</GroupNumber>
<FileNumber>2</FileNumber>
<FileType>2</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\startup_xinc.s</PathWithFileName>
<FilenameWithoutPath>startup_xinc.s</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>1</GroupNumber>
<FileNumber>3</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\system_xinc.c</PathWithFileName>
<FilenameWithoutPath>system_xinc.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group>
<Group>
<GroupName>application</GroupName>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>4</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\app_task.c</PathWithFileName>
<FilenameWithoutPath>app_task.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>5</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\usr_client.c</PathWithFileName>
<FilenameWithoutPath>usr_client.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>6</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\sleep.c</PathWithFileName>
<FilenameWithoutPath>sleep.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>7</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\arch_main.c</PathWithFileName>
<FilenameWithoutPath>arch_main.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>8</FileNumber>
<FileType>3</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\rom_symdefs.o</PathWithFileName>
<FilenameWithoutPath>rom_symdefs.o</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>9</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\app_sec.c</PathWithFileName>
<FilenameWithoutPath>app_sec.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>10</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\usr_server.c</PathWithFileName>
<FilenameWithoutPath>usr_server.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group>
<Group>
<GroupName>modules_rf</GroupName>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
<File>
<GroupNumber>3</GroupNumber>
<FileNumber>11</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\ble\modules\rf\src\rf_extrc.c</PathWithFileName>
<FilenameWithoutPath>rf_extrc.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group>
<Group>
<GroupName>hal</GroupName>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
<File>
<GroupNumber>4</GroupNumber>
<FileNumber>12</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\ringbuffer.c</PathWithFileName>
<FilenameWithoutPath>ringbuffer.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>4</GroupNumber>
<FileNumber>13</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_clock.c</PathWithFileName>
<FilenameWithoutPath>xc_drv_clock.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>4</GroupNumber>
<FileNumber>14</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_gpio.c</PathWithFileName>
<FilenameWithoutPath>xc_drv_gpio.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>4</GroupNumber>
<FileNumber>15</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_pwr.c</PathWithFileName>
<FilenameWithoutPath>xc_drv_pwr.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>4</GroupNumber>
<FileNumber>16</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_systick.c</PathWithFileName>
<FilenameWithoutPath>xc_drv_systick.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>4</GroupNumber>
<FileNumber>17</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_timer.c</PathWithFileName>
<FilenameWithoutPath>xc_drv_timer.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>4</GroupNumber>
<FileNumber>18</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_uart.c</PathWithFileName>
<FilenameWithoutPath>xc_drv_uart.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>4</GroupNumber>
<FileNumber>19</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_wdt.c</PathWithFileName>
<FilenameWithoutPath>xc_drv_wdt.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>4</GroupNumber>
<FileNumber>20</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_fmc_spi.c</PathWithFileName>
<FilenameWithoutPath>xc_drv_fmc_spi.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group>
<Group>
<GroupName>ble_api</GroupName>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
<File>
<GroupNumber>5</GroupNumber>
<FileNumber>21</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\ble\ip\ble\api\xc_gap_api.c</PathWithFileName>
<FilenameWithoutPath>xc_gap_api.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>5</GroupNumber>
<FileNumber>22</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\ble\ip\ble\api\xc_gatt_client_api.c</PathWithFileName>
<FilenameWithoutPath>xc_gatt_client_api.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>5</GroupNumber>
<FileNumber>23</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\ble\ip\ble\api\xc_gatt_server_api.c</PathWithFileName>
<FilenameWithoutPath>xc_gatt_server_api.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group>
<Group>
<GroupName>modules_nvds</GroupName>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
<File>
<GroupNumber>6</GroupNumber>
<FileNumber>24</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\ble\modules\nvds\src\nvds.c</PathWithFileName>
<FilenameWithoutPath>nvds.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group>
<Group>
<GroupName>lib</GroupName>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
<File>
<GroupNumber>7</GroupNumber>
<FileNumber>25</FileNumber>
<FileType>4</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\app\src\Xinc_ble_sdk_central.lib</PathWithFileName>
<FilenameWithoutPath>Xinc_ble_sdk_central.lib</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group>
<Group>
<GroupName>dut</GroupName>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
<File>
<GroupNumber>8</GroupNumber>
<FileNumber>26</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\..\..\..\component\ble\plf\refip\src\driver\uart\uart.c</PathWithFileName>
<FilenameWithoutPath>uart.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group>
</ProjectOpt>
@@ -0,0 +1,666 @@
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<Project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="project_projx.xsd">
<SchemaVersion>2.1</SchemaVersion>
<Header>### uVision Project, (C) Keil Software</Header>
<Targets>
<Target>
<TargetName>ble-sdk-xip</TargetName>
<ToolsetNumber>0x4</ToolsetNumber>
<ToolsetName>ARM-ADS</ToolsetName>
<pCCUsed>5060750::V5.06 update 6 (build 750)::.\ARMCC</pCCUsed>
<uAC6>0</uAC6>
<TargetOption>
<TargetCommonOption>
<Device>ARMCM0</Device>
<Vendor>ARM</Vendor>
<PackID>ARM.CMSIS.5.7.0</PackID>
<PackURL>http://www.keil.com/pack/</PackURL>
<Cpu>IRAM(0x20000000,0x00020000) IROM(0x00000000,0x00040000) CPUTYPE("Cortex-M0") CLOCK(12000000) ESEL ELITTLE</Cpu>
<FlashUtilSpec></FlashUtilSpec>
<StartupFile></StartupFile>
<FlashDriverDll>UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000)</FlashDriverDll>
<DeviceId>0</DeviceId>
<RegisterFile>$$Device:ARMCM0$Device\ARM\ARMCM0\Include\ARMCM0.h</RegisterFile>
<MemoryEnv></MemoryEnv>
<Cmp></Cmp>
<Asm></Asm>
<Linker></Linker>
<OHString></OHString>
<InfinionOptionDll></InfinionOptionDll>
<SLE66CMisc></SLE66CMisc>
<SLE66AMisc></SLE66AMisc>
<SLE66LinkerMisc></SLE66LinkerMisc>
<SFDFile>$$Device:ARMCM0$Device\ARM\SVD\ARMCM0.svd</SFDFile>
<bCustSvd>0</bCustSvd>
<UseEnv>0</UseEnv>
<BinPath></BinPath>
<IncludePath></IncludePath>
<LibPath></LibPath>
<RegisterFilePath></RegisterFilePath>
<DBRegisterFilePath></DBRegisterFilePath>
<TargetStatus>
<Error>0</Error>
<ExitCodeStop>0</ExitCodeStop>
<ButtonStop>0</ButtonStop>
<NotGenerated>0</NotGenerated>
<InvalidFlash>1</InvalidFlash>
</TargetStatus>
<OutputDirectory>.\Objects\</OutputDirectory>
<OutputName>Xinc_ble_sdk</OutputName>
<CreateExecutable>1</CreateExecutable>
<CreateLib>0</CreateLib>
<CreateHexFile>0</CreateHexFile>
<DebugInformation>1</DebugInformation>
<BrowseInformation>1</BrowseInformation>
<ListingPath>.\Listings\</ListingPath>
<HexFormatSelection>1</HexFormatSelection>
<Merge32K>0</Merge32K>
<CreateBatchFile>0</CreateBatchFile>
<BeforeCompile>
<RunUserProg1>0</RunUserProg1>
<RunUserProg2>0</RunUserProg2>
<UserProg1Name></UserProg1Name>
<UserProg2Name></UserProg2Name>
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
<nStopU1X>0</nStopU1X>
<nStopU2X>0</nStopU2X>
</BeforeCompile>
<BeforeMake>
<RunUserProg1>0</RunUserProg1>
<RunUserProg2>0</RunUserProg2>
<UserProg1Name></UserProg1Name>
<UserProg2Name></UserProg2Name>
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
<nStopB1X>0</nStopB1X>
<nStopB2X>0</nStopB2X>
</BeforeMake>
<AfterMake>
<RunUserProg1>1</RunUserProg1>
<RunUserProg2>1</RunUserProg2>
<UserProg1Name>fromelf --bin --output=app.bin !L</UserProg1Name>
<UserProg2Name>.\output_tool\xinchip_bootloader2.bat</UserProg2Name>
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
<nStopA1X>0</nStopA1X>
<nStopA2X>0</nStopA2X>
</AfterMake>
<SelectedForBatchBuild>0</SelectedForBatchBuild>
<SVCSIdString></SVCSIdString>
</TargetCommonOption>
<CommonProperty>
<UseCPPCompiler>0</UseCPPCompiler>
<RVCTCodeConst>0</RVCTCodeConst>
<RVCTZI>0</RVCTZI>
<RVCTOtherData>0</RVCTOtherData>
<ModuleSelection>0</ModuleSelection>
<IncludeInBuild>1</IncludeInBuild>
<AlwaysBuild>0</AlwaysBuild>
<GenerateAssemblyFile>0</GenerateAssemblyFile>
<AssembleAssemblyFile>0</AssembleAssemblyFile>
<PublicsOnly>0</PublicsOnly>
<StopOnExitCode>3</StopOnExitCode>
<CustomArgument></CustomArgument>
<IncludeLibraryModules></IncludeLibraryModules>
<ComprImg>1</ComprImg>
</CommonProperty>
<DllOption>
<SimDllName>SARMCM3.DLL</SimDllName>
<SimDllArguments> </SimDllArguments>
<SimDlgDll>DARMCM1.DLL</SimDlgDll>
<SimDlgDllArguments>-pCM0</SimDlgDllArguments>
<TargetDllName>SARMCM3.DLL</TargetDllName>
<TargetDllArguments> </TargetDllArguments>
<TargetDlgDll>TARMCM1.DLL</TargetDlgDll>
<TargetDlgDllArguments>-pCM0</TargetDlgDllArguments>
</DllOption>
<DebugOption>
<OPTHX>
<HexSelection>1</HexSelection>
<HexRangeLowAddress>0</HexRangeLowAddress>
<HexRangeHighAddress>0</HexRangeHighAddress>
<HexOffset>0</HexOffset>
<Oh166RecLen>16</Oh166RecLen>
</OPTHX>
</DebugOption>
<Utilities>
<Flash1>
<UseTargetDll>1</UseTargetDll>
<UseExternalTool>0</UseExternalTool>
<RunIndependent>0</RunIndependent>
<UpdateFlashBeforeDebugging>1</UpdateFlashBeforeDebugging>
<Capability>1</Capability>
<DriverSelection>4096</DriverSelection>
</Flash1>
<bUseTDR>1</bUseTDR>
<Flash2>BIN\UL2CM3.DLL</Flash2>
<Flash3>"" ()</Flash3>
<Flash4></Flash4>
<pFcarmOut></pFcarmOut>
<pFcarmGrp></pFcarmGrp>
<pFcArmRoot></pFcArmRoot>
<FcArmLst>0</FcArmLst>
</Utilities>
<TargetArmAds>
<ArmAdsMisc>
<GenerateListings>0</GenerateListings>
<asHll>1</asHll>
<asAsm>1</asAsm>
<asMacX>1</asMacX>
<asSyms>1</asSyms>
<asFals>1</asFals>
<asDbgD>1</asDbgD>
<asForm>1</asForm>
<ldLst>0</ldLst>
<ldmm>1</ldmm>
<ldXref>1</ldXref>
<BigEnd>0</BigEnd>
<AdsALst>1</AdsALst>
<AdsACrf>1</AdsACrf>
<AdsANop>0</AdsANop>
<AdsANot>0</AdsANot>
<AdsLLst>1</AdsLLst>
<AdsLmap>1</AdsLmap>
<AdsLcgr>1</AdsLcgr>
<AdsLsym>1</AdsLsym>
<AdsLszi>1</AdsLszi>
<AdsLtoi>1</AdsLtoi>
<AdsLsun>1</AdsLsun>
<AdsLven>1</AdsLven>
<AdsLsxf>1</AdsLsxf>
<RvctClst>0</RvctClst>
<GenPPlst>0</GenPPlst>
<AdsCpuType>"Cortex-M0"</AdsCpuType>
<RvctDeviceName></RvctDeviceName>
<mOS>0</mOS>
<uocRom>0</uocRom>
<uocRam>0</uocRam>
<hadIROM>1</hadIROM>
<hadIRAM>1</hadIRAM>
<hadXRAM>0</hadXRAM>
<uocXRam>0</uocXRam>
<RvdsVP>0</RvdsVP>
<RvdsMve>0</RvdsMve>
<RvdsCdeCp>0</RvdsCdeCp>
<hadIRAM2>0</hadIRAM2>
<hadIROM2>0</hadIROM2>
<StupSel>8</StupSel>
<useUlib>0</useUlib>
<EndSel>1</EndSel>
<uLtcg>0</uLtcg>
<nSecure>0</nSecure>
<RoSelD>3</RoSelD>
<RwSelD>3</RwSelD>
<CodeSel>0</CodeSel>
<OptFeed>0</OptFeed>
<NoZi1>0</NoZi1>
<NoZi2>0</NoZi2>
<NoZi3>0</NoZi3>
<NoZi4>0</NoZi4>
<NoZi5>0</NoZi5>
<Ro1Chk>0</Ro1Chk>
<Ro2Chk>0</Ro2Chk>
<Ro3Chk>0</Ro3Chk>
<Ir1Chk>0</Ir1Chk>
<Ir2Chk>0</Ir2Chk>
<Ra1Chk>0</Ra1Chk>
<Ra2Chk>0</Ra2Chk>
<Ra3Chk>0</Ra3Chk>
<Im1Chk>0</Im1Chk>
<Im2Chk>0</Im2Chk>
<OnChipMemories>
<Ocm1>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm1>
<Ocm2>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm2>
<Ocm3>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm3>
<Ocm4>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm4>
<Ocm5>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm5>
<Ocm6>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm6>
<IRAM>
<Type>0</Type>
<StartAddress>0x20000000</StartAddress>
<Size>0x20000</Size>
</IRAM>
<IROM>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x40000</Size>
</IROM>
<XRAM>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</XRAM>
<OCR_RVCT1>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT1>
<OCR_RVCT2>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT2>
<OCR_RVCT3>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT3>
<OCR_RVCT4>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x40000</Size>
</OCR_RVCT4>
<OCR_RVCT5>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT5>
<OCR_RVCT6>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT6>
<OCR_RVCT7>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT7>
<OCR_RVCT8>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT8>
<OCR_RVCT9>
<Type>0</Type>
<StartAddress>0x20000000</StartAddress>
<Size>0x20000</Size>
</OCR_RVCT9>
<OCR_RVCT10>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT10>
</OnChipMemories>
<RvctStartVector></RvctStartVector>
</ArmAdsMisc>
<Cads>
<interw>1</interw>
<Optim>4</Optim>
<oTime>0</oTime>
<SplitLS>0</SplitLS>
<OneElfS>1</OneElfS>
<Strict>0</Strict>
<EnumInt>0</EnumInt>
<PlainCh>0</PlainCh>
<Ropi>0</Ropi>
<Rwpi>0</Rwpi>
<wLevel>2</wLevel>
<uThumb>0</uThumb>
<uSurpInc>0</uSurpInc>
<uC99>1</uC99>
<uGnu>1</uGnu>
<useXO>0</useXO>
<v6Lang>3</v6Lang>
<v6LangP>3</v6LangP>
<vShortEn>1</vShortEn>
<vShortWch>1</vShortWch>
<v6Lto>0</v6Lto>
<v6WtE>0</v6WtE>
<v6Rtti>0</v6Rtti>
<VariousControls>
<MiscControls>--gnu --diag_suppress=66 --feedback fb.txt</MiscControls>
<Define>SDK_VERSION="99cd0ea8" RC_32K=1 XC60XX CFG_BLE CFG_EMB CFG_STATIC USE_XIP=0 HCI_TEST_NO_IP=0 CFG_ACT=20 CFG_CON=4 CFG_RAL=1 CFG_HOST CFG_APP CFG_APP_PRF CFG_RF_EXTRC CFG_AES_RPA CFG_ALLROLES CFG_GATT_CLI USE_XIP=1 DEBUG_ENABLE ROM_ENV_ENABLE=0 CODE_USE_XIP CFG_PRF_BASS USE_ROM_FLASH=1 CFG_SCAN_PERFORMANCE CFG_MIN_STACK CONFIG_BT_WAKEUP_VIA_GPIO=1 CONFIG_HFCLK_IS_OSC32M_PLL_32M=1 SCATTER_LOAD_RAM_EM=1</Define>
<Undefine></Undefine>
<IncludePath>..\..\..\..\..\component\ble\Include;..\app\api;..\..\..\..\..\component\ble\modules\aes\api;..\..\..\..\..\component\ble\modules\aes\src;..\..\..\..\..\component\ble\modules\common\api;..\..\..\..\..\component\ble\modules\common\src;..\..\..\..\..\component\ble\modules\ecc_p256\api;..\..\..\..\..\component\ble\modules\ecc_p256\src;..\..\..\..\..\component\ble\modules\h4tl\api;..\..\..\..\..\component\ble\modules\h4tl\src;..\..\..\..\..\component\ble\modules\ke\api;..\..\..\..\..\component\ble\modules\ke\src;..\..\..\..\..\component\ble\modules\nvds\api;..\..\..\..\..\component\ble\modules\nvds\src;..\..\..\..\..\component\ble\modules\rf\api;..\..\..\..\..\component\ble\modules\rf\src;..\..\..\..\..\component\ble\modules\rwip\api;..\..\..\..\..\component\ble\modules\rwip\src;..\..\..\..\..\component\ble\ip\ahi\api;..\..\..\..\..\component\ble\ip\ahi\src;..\..\..\..\..\component\ble\ip\ble\gaf\api;..\..\..\..\..\component\ble\ip\ble\gaf\inc;..\..\..\..\..\component\ble\ip\ble\gaf\src;..\..\..\..\..\component\ble\ip\ble\gaf\src\acc;..\..\..\..\..\component\ble\ip\ble\gaf\src\al;..\..\..\..\..\component\ble\ip\ble\gaf\src\arc;..\..\..\..\..\component\ble\ip\ble\gaf\src\bap\bc;..\..\..\..\..\component\ble\ip\ble\gaf\src\bap\capa;..\..\..\..\..\component\ble\ip\ble\gaf\src\bap\codec;..\..\..\..\..\component\ble\ip\ble\gaf\src\bap\uc;..\..\..\..\..\component\ble\ip\ble\gaf\src\iap;..\..\..\..\..\component\ble\ip\ble\hl\api;..\..\..\..\..\component\ble\ip\ble\hl\inc;..\..\..\..\..\component\ble\ip\ble\hl\src;..\..\..\..\..\component\ble\ip\ble\hl\src\gap;..\..\..\..\..\component\ble\ip\ble\hl\src\gap\gapc;..\..\..\..\..\component\ble\ip\ble\hl\src\gap\gapm;..\..\..\..\..\component\ble\ip\ble\hl\src\gatt;..\..\..\..\..\component\ble\ip\ble\hl\src\inc;..\..\..\..\..\component\ble\ip\ble\hl\src\l2cap;..\..\..\..\..\component\ble\ip\ble\ll\api;..\..\..\..\..\component\ble\ip\ble\ll\src;..\..\..\..\..\component\ble\ip\ble\ll\src\co;..\..\..\..\..\component\ble\ip\ble\ll\src\llc;..\..\..\..\..\component\ble\ip\ble\ll\src\lld;..\..\..\..\..\component\ble\ip\ble\ll\src\lli;..\..\..\..\..\component\ble\ip\ble\ll\src\llm;..\..\..\..\..\component\ble\ip\ble\profiles\bas\bass\api;..\..\..\..\..\component\ble\ip\ble\profiles\bas\bass\src;..\..\..\..\..\component\ble\ip\em\api;..\..\..\..\..\component\ble\ip\em\src;..\..\..\..\..\component\ble\ip\hci\api;..\..\..\..\..\component\ble\ip\hci\src;..\..\..\..\..\component\ble\ip\sch\api;..\..\..\..\..\component\ble\ip\sch\src;..\..\..\..\..\component\ble\plf\refip\src\build\ble-full\reg\fw;..\app\api;..\app\src;..\..\..\..\..\component\ble\plf\refip\src\arch;..\..\..\..\..\component\ble\plf\refip\src\arch\compiler\gnuarm;..\..\..\..\..\component\ble\plf\refip\src\arch\ll\gnuarm;..\..\..\..\..\component\ble\plf\refip\src\driver\reg;..\..\..\..\..\component\ble\plf\refip\src\arch\boot\rvds;..\..\..\..\..\component\ble\plf\refip\src\driver\syscntl;..\..\..\..\..\component\ble\plf\refip\src\driver\emi;..\..\..\..\..\component\ble\plf\refip\src\driver\intc;..\..\..\..\..\component\ble\plf\refip\src\driver\uart;..\..\..\..\..\component\ble\plf\refip\src\driver\flash;..\..\..\..\..\component\ble\plf\refip\src\driver\led;..\..\..\..\..\component\ble\modules\dbg\api;..\..\..\..\..\component\ble\plf\refip\src\driver\uart;..\..\..\..\..\component\xc6xx_drivers\Drivers\CMSIS;..\..\..\..\..\component\xc6xx_drivers\Drivers\CMSIS\Device;..\..\..\..\..\component\xc6xx_drivers\Drivers\Startup;..\..\..\..\..\component\xc6xx_drivers\Drivers\Startup\xc60xx;..\..\..\..\..\component\xc6xx_drivers\Drivers\Periph_HAL_Driver;..\..\..\..\..\component\xc6xx_drivers\Drivers\Periph_HAL_Driver\Bitfields;..\..\..\..\..\component\xc6xx_drivers\Drivers\Periph_HAL_Driver\Ringbuffer;..\..\..\..\..\component\xc6xx_drivers\Drivers\test_case\PWR;..\..\..\..\..\component\xc6xx_drivers\Drivers\test_case\TIMER;..\..\..\..\..\component\ble\ip\ble\api;..\..\..\..\..\component\xc6xx_drivers\Drivers\test_case\TIMER;..\..\..\..\..\component\xc6xx_drivers\Drivers\CMSIS\Device;..\..\..\..\..\component\xc6xx_drivers\Drivers\CMSIS;..\..\..\..\..\component\xc6xx_drivers\Drivers;..\..\..\..\..\component\ble\ip\ble\ll_rom_port;..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver;..\..\..\..\..\component\xc6xx_drivers\Drivers\CMSIS\Device\xc_m0_register;..\..\..\..\..\component\ble\modules\flash</IncludePath>
</VariousControls>
</Cads>
<Aads>
<interw>1</interw>
<Ropi>0</Ropi>
<Rwpi>0</Rwpi>
<thumb>0</thumb>
<SplitLS>0</SplitLS>
<SwStkChk>0</SwStkChk>
<NoWarn>0</NoWarn>
<uSurpInc>0</uSurpInc>
<useXO>0</useXO>
<ClangAsOpt>1</ClangAsOpt>
<VariousControls>
<MiscControls></MiscControls>
<Define></Define>
<Undefine></Undefine>
<IncludePath></IncludePath>
</VariousControls>
</Aads>
<LDads>
<umfTarg>0</umfTarg>
<Ropi>0</Ropi>
<Rwpi>0</Rwpi>
<noStLib>0</noStLib>
<RepFail>1</RepFail>
<useFile>0</useFile>
<TextAddressRange>0x00000000</TextAddressRange>
<DataAddressRange>0x20000000</DataAddressRange>
<pXoBase></pXoBase>
<ScatterFile>.\Linker\cpu_xip.scat</ScatterFile>
<IncludeLibs></IncludeLibs>
<IncludeLibsPath></IncludeLibsPath>
<Misc>--feedback fb.txt --info=stack --callgraph</Misc>
<LinkerInputFile></LinkerInputFile>
<DisabledWarnings></DisabledWarnings>
</LDads>
</TargetArmAds>
</TargetOption>
<Groups>
<Group>
<GroupName>startup</GroupName>
<Files>
<File>
<FileName>core_cm0.h</FileName>
<FileType>5</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\CMSIS\core_cm0.h</FilePath>
</File>
<File>
<FileName>startup_xinc.s</FileName>
<FileType>2</FileType>
<FilePath>..\app\src\startup_xinc.s</FilePath>
</File>
<File>
<FileName>system_xinc.c</FileName>
<FileType>1</FileType>
<FilePath>..\app\src\system_xinc.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>application</GroupName>
<Files>
<File>
<FileName>app_task.c</FileName>
<FileType>1</FileType>
<FilePath>..\app\src\app_task.c</FilePath>
</File>
<File>
<FileName>usr_client.c</FileName>
<FileType>1</FileType>
<FilePath>..\app\src\usr_client.c</FilePath>
</File>
<File>
<FileName>sleep.c</FileName>
<FileType>1</FileType>
<FilePath>..\app\src\sleep.c</FilePath>
</File>
<File>
<FileName>arch_main.c</FileName>
<FileType>1</FileType>
<FilePath>..\app\src\arch_main.c</FilePath>
</File>
<File>
<FileName>rom_symdefs.o</FileName>
<FileType>3</FileType>
<FilePath>..\app\src\rom_symdefs.o</FilePath>
</File>
<File>
<FileName>app_sec.c</FileName>
<FileType>1</FileType>
<FilePath>..\app\src\app_sec.c</FilePath>
</File>
<File>
<FileName>usr_server.c</FileName>
<FileType>1</FileType>
<FilePath>..\app\src\usr_server.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>modules_rf</GroupName>
<Files>
<File>
<FileName>rf_extrc.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\ble\modules\rf\src\rf_extrc.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>hal</GroupName>
<Files>
<File>
<FileName>ringbuffer.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\ringbuffer.c</FilePath>
</File>
<File>
<FileName>xc_drv_clock.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_clock.c</FilePath>
</File>
<File>
<FileName>xc_drv_gpio.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_gpio.c</FilePath>
</File>
<File>
<FileName>xc_drv_pwr.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_pwr.c</FilePath>
</File>
<File>
<FileName>xc_drv_systick.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_systick.c</FilePath>
</File>
<File>
<FileName>xc_drv_timer.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_timer.c</FilePath>
</File>
<File>
<FileName>xc_drv_uart.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_uart.c</FilePath>
</File>
<File>
<FileName>xc_drv_wdt.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_wdt.c</FilePath>
</File>
<File>
<FileName>xc_drv_fmc_spi.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\xc6xx_drivers\Drivers\xc_driver\xc_drv_fmc_spi.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>ble_api</GroupName>
<Files>
<File>
<FileName>xc_gap_api.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\ble\ip\ble\api\xc_gap_api.c</FilePath>
</File>
<File>
<FileName>xc_gatt_client_api.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\ble\ip\ble\api\xc_gatt_client_api.c</FilePath>
</File>
<File>
<FileName>xc_gatt_server_api.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\ble\ip\ble\api\xc_gatt_server_api.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>modules_nvds</GroupName>
<Files>
<File>
<FileName>nvds.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\ble\modules\nvds\src\nvds.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>lib</GroupName>
<GroupOption>
<CommonProperty>
<UseCPPCompiler>0</UseCPPCompiler>
<RVCTCodeConst>0</RVCTCodeConst>
<RVCTZI>0</RVCTZI>
<RVCTOtherData>0</RVCTOtherData>
<ModuleSelection>0</ModuleSelection>
<IncludeInBuild>0</IncludeInBuild>
<AlwaysBuild>2</AlwaysBuild>
<GenerateAssemblyFile>2</GenerateAssemblyFile>
<AssembleAssemblyFile>2</AssembleAssemblyFile>
<PublicsOnly>2</PublicsOnly>
<StopOnExitCode>11</StopOnExitCode>
<CustomArgument></CustomArgument>
<IncludeLibraryModules></IncludeLibraryModules>
<ComprImg>1</ComprImg>
</CommonProperty>
<GroupArmAds>
<Cads>
<interw>2</interw>
<Optim>0</Optim>
<oTime>2</oTime>
<SplitLS>2</SplitLS>
<OneElfS>2</OneElfS>
<Strict>2</Strict>
<EnumInt>2</EnumInt>
<PlainCh>2</PlainCh>
<Ropi>2</Ropi>
<Rwpi>2</Rwpi>
<wLevel>0</wLevel>
<uThumb>2</uThumb>
<uSurpInc>2</uSurpInc>
<uC99>2</uC99>
<uGnu>2</uGnu>
<useXO>2</useXO>
<v6Lang>0</v6Lang>
<v6LangP>0</v6LangP>
<vShortEn>2</vShortEn>
<vShortWch>2</vShortWch>
<v6Lto>2</v6Lto>
<v6WtE>2</v6WtE>
<v6Rtti>2</v6Rtti>
<VariousControls>
<MiscControls></MiscControls>
<Define></Define>
<Undefine></Undefine>
<IncludePath></IncludePath>
</VariousControls>
</Cads>
<Aads>
<interw>2</interw>
<Ropi>2</Ropi>
<Rwpi>2</Rwpi>
<thumb>2</thumb>
<SplitLS>2</SplitLS>
<SwStkChk>2</SwStkChk>
<NoWarn>2</NoWarn>
<uSurpInc>2</uSurpInc>
<useXO>2</useXO>
<ClangAsOpt>0</ClangAsOpt>
<VariousControls>
<MiscControls></MiscControls>
<Define></Define>
<Undefine></Undefine>
<IncludePath></IncludePath>
</VariousControls>
</Aads>
</GroupArmAds>
</GroupOption>
<Files>
<File>
<FileName>Xinc_ble_sdk_central.lib</FileName>
<FileType>4</FileType>
<FilePath>..\app\src\Xinc_ble_sdk_central.lib</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>dut</GroupName>
<Files>
<File>
<FileName>uart.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\..\..\..\component\ble\plf\refip\src\driver\uart\uart.c</FilePath>
</File>
</Files>
</Group>
</Groups>
</Target>
</Targets>
<RTE>
<apis/>
<components/>
<files>
<file attr="config" category="linkerScript" condition="ARMCC5" name="Device\ARM\ARMCM0\Source\ARM\ARMCM0_ac5.sct" version="1.0.0">
<instance index="0" removed="1">RTE\Device\ARMCM0\ARMCM0_ac5.sct</instance>
<component Cclass="Device" Cgroup="Startup" Cvariant="C Startup" Cvendor="ARM" Cversion="2.0.3" condition="ARMCM0 CMSIS" isDefaultVariant="1"/>
<package name="CMSIS" schemaVersion="1.3" url="http://www.keil.com/pack/" vendor="ARM" version="5.8.0"/>
<targetInfos/>
</file>
<file attr="config" category="sourceC" name="Device\ARM\ARMCM0\Source\startup_ARMCM0.c" version="2.0.3">
<instance index="0" removed="1">RTE\Device\ARMCM0\startup_ARMCM0.c</instance>
<component Cclass="Device" Cgroup="Startup" Cvariant="C Startup" Cvendor="ARM" Cversion="2.0.3" condition="ARMCM0 CMSIS" isDefaultVariant="1"/>
<package name="CMSIS" schemaVersion="1.3" url="http://www.keil.com/pack/" vendor="ARM" version="5.8.0"/>
<targetInfos/>
</file>
<file attr="config" category="sourceC" name="Device\ARM\ARMCM0\Source\system_ARMCM0.c" version="1.0.0">
<instance index="0" removed="1">RTE\Device\ARMCM0\system_ARMCM0.c</instance>
<component Cclass="Device" Cgroup="Startup" Cvariant="C Startup" Cvendor="ARM" Cversion="2.0.3" condition="ARMCM0 CMSIS" isDefaultVariant="1"/>
<package name="CMSIS" schemaVersion="1.3" url="http://www.keil.com/pack/" vendor="ARM" version="5.8.0"/>
<targetInfos/>
</file>
</files>
</RTE>
<LayerInfo>
<Layers>
<Layer>
<LayName>&lt;Project Info&gt;</LayName>
<LayDesc></LayDesc>
<LayUrl></LayUrl>
<LayKeys></LayKeys>
<LayCat></LayCat>
<LayLic></LayLic>
<LayTarg>0</LayTarg>
<LayPrjMark>1</LayPrjMark>
</Layer>
</Layers>
</LayerInfo>
</Project>
+164
View File
@@ -0,0 +1,164 @@
;#<FEEDBACK># ARM Linker, 5060750: Last Updated: Fri Aug 15 17:58:35 2025
;VERSION 0.2
;FILE app_sec.o
__asm___9_app_sec_c_9f4819f3____REV16 <= USED 0
__asm___9_app_sec_c_9f4819f3____REVSH <= USED 0
app_sec_get_bond_status <= USED 0
app_sec_init <= USED 0
;FILE app_task.o
__asm___10_app_task_c_conn_dev____REV16 <= USED 0
__asm___10_app_task_c_conn_dev____REVSH <= USED 0
app_set_dev_name <= USED 0
app_set_scan_rsp_data <= USED 0
app_stop_advertising <= USED 0
app_stop_init <= USED 0
app_stop_scanning <= USED 0
;FILE arch_main.o
__asm___11_arch_main_c_fd31ea27____REV16 <= USED 0
__asm___11_arch_main_c_fd31ea27____REVSH <= USED 0
system_lightsleep_cfg <= USED 0
;FILE rf_extrc.o
__asm___10_rf_extrc_c_87e03416____REV16 <= USED 0
__asm___10_rf_extrc_c_87e03416____REVSH <= USED 0
auto_agc_init <= USED 0
rf_test_pin_init <= USED 0
rf_xtal_cal_set <= USED 0
;FILE ringbuffer.o
ring_buffer_create <= USED 0
ring_buffer_dequeue <= USED 0
ring_buffer_dequeue_arr <= USED 0
ring_buffer_is_empty <= USED 0
ring_buffer_is_full <= USED 0
ring_buffer_num_items <= USED 0
ring_buffer_peek <= USED 0
ring_buffer_queue <= USED 0
ring_buffer_queue_arr <= USED 0
;FILE sleep.o
__asm___7_sleep_c_efd8dd31____REV16 <= USED 0
__asm___7_sleep_c_efd8dd31____REVSH <= USED 0
;FILE startup_xinc.o
;FILE system_xinc.o
__asm___13_system_xinc_c_bf2b7dca____REV16 <= USED 0
__asm___13_system_xinc_c_bf2b7dca____REVSH <= USED 0
_ttywrch <= USED 0
;FILE uart.o
__asm___6_uart_c____REV16 <= USED 0
__asm___6_uart_c____REVSH <= USED 0
;FILE usr_client.o
__asm___12_usr_client_c_3096fd6e____REV16 <= USED 0
__asm___12_usr_client_c_3096fd6e____REVSH <= USED 0
get_cli_user_ild <= USED 0
send_data <= USED 0
;FILE usr_server.o
__asm___12_usr_server_c_16ab253a____REV16 <= USED 0
__asm___12_usr_server_c_16ab253a____REVSH <= USED 0
;FILE xc_drv_clock.o
__asm___14_xc_drv_clock_c_54f5dcab____REV16 <= USED 0
__asm___14_xc_drv_clock_c_54f5dcab____REVSH <= USED 0
xc_clock_hfclk_src_get <= USED 0
xc_clock_lfclk_in_get <= USED 0
xc_clock_lfclk_src_get <= USED 0
xc_clock_set_osc32m <= USED 0
xc_clock_set_osc32m_bbpll_16m <= USED 0
xc_systick_unit_get <= USED 0
;FILE xc_drv_fmc_spi.o
__asm___16_xc_drv_fmc_spi_c_0d19a3b4____REV16 <= USED 0
__asm___16_xc_drv_fmc_spi_c_0d19a3b4____REVSH <= USED 0
xc_adc_2v4_calibrate_read <= USED 0
xc_fmc_spi_flash_erase_page <= USED 0
xc_fmc_spi_flash_erase_sector <= USED 0
xc_fmc_spi_flash_power_down <= USED 0
xc_fmc_spi_flash_write <= USED 0
xc_fmc_spi_flash_write_page <= USED 0
;FILE xc_drv_gpio.o
__asm___13_xc_drv_gpio_c_f617b6af____REV16 <= USED 0
__asm___13_xc_drv_gpio_c_f617b6af____REVSH <= USED 0
xc_gpio_read_pin <= USED 0
xc_gpio_toggle_pin <= USED 0
xc_gpio_write_pin <= USED 0
;FILE xc_drv_pwr.o
__asm___12_xc_drv_pwr_c_ed5c409a____REV16 <= USED 0
__asm___12_xc_drv_pwr_c_ed5c409a____REVSH <= USED 0
xc_adc_powerdown <= USED 0
xc_adc_wakeup <= USED 0
xc_deep_sleep <= USED 0
xc_pwr_ao_timer_pclk32k_set <= USED 0
xc_pwr_ao_timer_pclk32m_Set <= USED 0
xc_pwr_ble_sleep_enter <= USED 0
xc_pwr_cpu_sleep_enter <= USED 0
xc_pwr_dcdc_close <= USED 0
xc_pwr_dcdc_init <= USED 0
xc_pwr_dcdc_open <= USED 0
xc_pwr_gpio_lightsleep_wake_config <= USED 0
xc_pwr_gpio_sleep_config <= USED 0
xc_pwr_pwrkey_deepsleep_wake_config <= USED 0
xc_pwr_pwrkey_init <= USED 0
xc_pwr_pwrkey_toggle_pin <= USED 0
xc_pwr_pwrkey_write_pin <= USED 0
xc_pwr_sleep_init <= USED 0
xc_sleep <= USED 0
;FILE xc_drv_systick.o
__asm___16_xc_drv_systick_c_b672aa62____REV16 <= USED 0
__asm___16_xc_drv_systick_c_b672aa62____REVSH <= USED 0
delay_ms <= USED 0
delay_us <= USED 0
;FILE xc_drv_timer.o
__asm___14_xc_drv_timer_c_a67257da____REV16 <= USED 0
__asm___14_xc_drv_timer_c_a67257da____REVSH <= USED 0
xc_timer_init <= USED 0
xc_timer_set_value <= USED 0
xc_timer_start <= USED 0
xc_timer_stop <= USED 0
;FILE xc_drv_uart.o
__asm___13_xc_drv_uart_c_c8f8d781____REV16 <= USED 0
__asm___13_xc_drv_uart_c_c8f8d781____REVSH <= USED 0
xc_uart_ctl_block_reset <= USED 0
xc_uart_disable_rx_it <= USED 0
xc_uart_enable_rx_it <= USED 0
xc_uart_register_receive_cb <= USED 0
xc_uart_send_byte <= USED 0
xc_uart_send_data <= USED 0
;FILE xc_drv_wdt.o
__asm___12_xc_drv_wdt_c_acf1ef54____REV16 <= USED 0
__asm___12_xc_drv_wdt_c_acf1ef54____REVSH <= USED 0
xc_ext32k_wdt_init <= USED 0
xc_ext32k_wdt_start <= USED 0
xc_wdt_stop <= USED 0
;FILE xc_gap_api.o
__asm___12_xc_gap_api_c_76ebb078____REV16 <= USED 0
__asm___12_xc_gap_api_c_76ebb078____REVSH <= USED 0
xc_ble_activity_delete <= USED 0
xc_ble_activity_stop <= USED 0
xc_ble_bond <= USED 0
xc_ble_bond_cfm <= USED 0
xc_ble_disconnect <= USED 0
xc_ble_encrypt <= USED 0
xc_ble_encrypt_cfm <= USED 0
xc_ble_gen_random_addr <= USED 0
xc_ble_gen_random_nb <= USED 0
xc_ble_get_dev_info <= USED 0
xc_ble_get_ral_addr <= USED 0
xc_ble_req_security <= USED 0
xc_ble_resolve_addr <= USED 0
xc_ble_set_channel_map <= USED 0
xc_ble_set_pkt_size <= USED 0
xc_ble_set_ral_list <= USED 0
xc_ble_set_rx_pkt_size <= USED 0
xc_ble_set_scan_rsp_data <= USED 0
xc_ble_set_white_list <= USED 0
xc_ble_update_param <= USED 0
;FILE xc_gatt_client_api.o
__asm___20_xc_gatt_client_api_c_d2fbc8a0____REV16 <= USED 0
__asm___20_xc_gatt_client_api_c_d2fbc8a0____REVSH <= USED 0
xc_ble_gatt_cli_discover_cancel <= USED 0
xc_ble_gatt_cli_discover_char <= USED 0
xc_ble_gatt_cli_discover_desc <= USED 0
xc_ble_gatt_cli_discover_svc <= USED 0
xc_ble_gatt_cli_mtu_exch <= USED 0
xc_ble_gatt_cli_read <= USED 0
xc_ble_gatt_cli_read_by_uuid <= USED 0
;FILE xc_gatt_server_api.o
__asm___20_xc_gatt_server_api_c_f4c610f4____REV16 <= USED 0
__asm___20_xc_gatt_server_api_c_f4c610f4____REVSH <= USED 0
xc_ble_gatt_service16_add <= USED 0
xc_ble_gatt_srv_indicate <= USED 0
@@ -0,0 +1,8 @@
cd ./output_tool
copy ..\app.bin .\
xinchip_bootloader2_tool.exe boot2 ^
stack.bin 0x11002000 0 ^
app.bin 0x11014000 1 ^
ble_Central.bin 1
del ..\app.bin
copy .\ble_Central.bin ..\
@@ -0,0 +1,415 @@
#!/usr/bin/env python
#-*- coding:UTF-8 -*-
import socket
from select import select
import time
import os
import sys
import threading
import json
import struct
import binascii
import time
import re
import fileinput
import io
import logging
replace = {
"co_default_bdaddr":"0x0",
"ke_msg_alloc":"0x0",
"ke_msg_send":"0x0",
"ke_msg_send_basic":"0x0",
"ke_state_set":"0x0",
"ke_task_create":"0x0",
"ke_state_get":"0x0",
"ke_msg_discard":"0x0",
"ke_msg_forward":"0x0",
"ke_msg_in_queue":"0x0",
"ke_msg_src_id_get":"0x0",
"ke_free":"0x0",
"ke_msg_free":"0x0",
"ke_check_malloc":"0x0",
"rwip_init":"0x0",
"rwip_schedule":"0x0",
"rwip_rf":"0x0",
"BLE_Handler":"0x0",
"co_buf_alloc":"0x0",
"co_buf_copy_data_from_mem":"0x0",
"co_buf_release":"0x0",
"co_djob_prepare":"0x0",
"co_djob_reg":"0x0",
"co_djob_unreg":"0x0",
"co_list_extract":"0x0",
"co_list_extract_after":"0x0",
"co_list_pop_front":"0x0",
"co_list_push_back":"0x0",
"co_list_push_front":"0x0",
"co_time_get":"0x0",
"co_time_timer_init":"0x0",
"co_time_timer_set":"0x0",
"co_time_timer_stop":"0x0",
"aes_c1":"0x0",
"aes_decrypt":"0x0",
"aes_encrypt":"0x0",
"aes_f4":"0x0",
"aes_f5":"0x0",
"aes_f6":"0x0",
"aes_g2":"0x0",
"aes_rand":"0x0",
"aes_cmac":"0x0",
"co_buf_head_release":"0x0",
"co_buf_head_reserve":"0x0",
"co_util_pack":"0x0",
"co_util_unpack":"0x0",
"rwip_reset":"0x0",
"aes_rpa_resolve":"0x0",
"co_buf_reuse":"0x0",
"co_buf_size":"0x0",
"co_buf_copy":"0x0",
"co_buf_duplicate":"0x0",
"co_buf_tail_release":"0x0",
"co_list_init":"0x0",
"ble_util_buf_rx_free":"0x0",
"ble_util_buf_acl_tx_alloc":"0x0",
"co_buf_cb_free_set":"0x0",
"ke_malloc":"0x0",
"co_list_insert_after":"0x0",
"ke_timer_active":"0x0",
"ke_timer_clear":"0x0",
"ke_timer_set":"0x0",
"co_buf_acquire":"0x0",
"co_buf_tail_reserve":"0x0",
"co_buf_copy_data_to_mem":"0x0",
"co_list_insert_before":"0x0",
"rom_env":"0x0",
"rwip_param":"0x0",
"one_bits":"0x0",
"hci_rd_rem_ver_info_cmd_handler":"0x0",
"hci_le_con_upd_cmd_handler":"0x0",
"hci_le_rd_chnl_map_cmd_handler":"0x0",
"hci_le_rd_rem_feats_cmd_handler":"0x0",
"hci_le_en_enc_cmd_handler":"0x0",
"hci_le_ltk_req_reply_cmd_handler":"0x0",
"hci_le_ltk_req_neg_reply_cmd_handler":"0x0",
"hci_le_rem_con_param_req_reply_cmd_handler":"0x0",
"hci_le_rem_con_param_req_neg_reply_cmd_handler":"0x0",
"hci_le_set_data_len_cmd_handler":"0x0",
"hci_vs_set_pref_slave_latency_cmd_handler":"0x0",
"hci_vs_set_pref_slave_evt_dur_cmd_handler":"0x0",
"hci_vs_set_max_rx_size_and_time_cmd_handler":"0x0",
"hci_rd_rssi_cmd_handler":"0x0",
"llm_ch_map_update_ind_handler":"0x0",
"llc_loc_llcp_rsp_to_handler":"0x0",
"llc_rem_llcp_rsp_to_handler":"0x0",
"llc_encrypt_ind_handler":"0x0",
"llc_op_ver_exch_ind_handler":"0x0",
"llc_op_feats_exch_ind_handler":"0x0",
"llc_op_encrypt_ind_handler":"0x0",
"llc_op_dl_upd_ind_handler":"0x0",
"llc_op_con_upd_ind_handler":"0x0",
"llc_op_ch_map_upd_ind_handler":"0x0",
"lld_llcp_rx_ind_handler":"0x0",
"lld_llcp_tx_cfm_handler":"0x0",
"lld_acl_rx_ind_handler":"0x0",
"lld_acl_tx_cfm_handler":"0x0",
"lld_con_param_upd_cfm_handler":"0x0",
"lld_ch_map_upd_cfm_handler":"0x0",
"lld_con_offset_upd_ind_handler":"0x0",
"hci_command_llc_handler":"0x0",
"hci_acl_data_handler":"0x0",
"ke_event_callback_set":"0x0",
"ke_event_clear":"0x0",
"ke_event_set":"0x0",
"ble_util_nb_good_channels":"0x0",
"ble_util_pkt_dur_in_us":"0x0",
"co_bdaddr_compare":"0x0",
"lld_ch_assess_data_get":"0x0",
"lld_ch_map_set":"0x0",
"lld_read_clock":"0x0",
"lld_res_list_peer_update":"0x0",
"lld_white_list_add":"0x0",
"rwip_prevent_sleep_clear":"0x0",
"rwip_prevent_sleep_set":"0x0",
"sch_plan_rem":"0x0",
"aes_rpa_gen":"0x0",
"ble_util_buf_adv_tx_alloc":"0x0",
"ble_util_buf_adv_tx_free":"0x0",
"co_null_bdaddr":"0x0",
"co_null_key":"0x0",
"llc_con_move_cbk":"0x0",
"llc_start":"0x0",
"lld_adv_adv_data_update":"0x0",
"lld_adv_rand_addr_update":"0x0",
"lld_adv_restart":"0x0",
"lld_adv_scan_rsp_data_update":"0x0",
"lld_adv_start":"0x0",
"lld_adv_stop":"0x0",
"lld_white_list_rem":"0x0",
"lld_init_rand_addr_update":"0x0",
"lld_res_list_add":"0x0",
"lld_res_list_clear":"0x0",
"lld_res_list_local_rpa_get":"0x0",
"lld_res_list_peer_rpa_get":"0x0",
"lld_res_list_priv_mode_update":"0x0",
"lld_res_list_rem":"0x0",
"lld_scan_rand_addr_update":"0x0",
"lld_init_start":"0x0",
"lld_init_stop":"0x0",
"sch_plan_req":"0x0",
"sch_plan_set":"0x0",
"co_rate_to_phy":"0x0",
"lld_scan_params_update":"0x0",
"lld_scan_start":"0x0",
"lld_scan_stop":"0x0",
"lld_rpa_renew":"0x0",
"ke_mem_init":"0x0",
"co_buf_init":"0x0",
"rwip_sleep":"0x0",
"em_ble_base_address_table_0":"0x0",
"em_ble_base_address_table_1":"0x0",
"em_ble_base_address_table_2":"0x0",
"em_ble_base_address_table_3":"0x0",
"em_ble_base_address_table_4":"0x0",
"em_ble_base_address_table_5":"0x0",
"em_ble_base_address_table_6":"0x0",
"em_ble_base_address_table_7":"0x0",
"em_ble_base_address_table_8":"0x0",
"em_ble_base_address_table_9":"0x0",
"em_ble_base_address_table_10":"0x0",
"ble_util_buf_init_env":"0x0",
"PATCH_FUN":"0x0",
"lld_adv_env":"0x0",
"sch_arb_remove":"0x0",
"sch_slice_fg_remove":"0x0",
"llc_env":"0x0",
"llc_proc_err_ind":"0x0",
"llc_stop":"0x0",
"ll_channel_map_ind_handler":"0x0",
"ll_connection_param_req_handler":"0x0",
"ll_connection_param_rsp_handler":"0x0",
"ll_connection_update_ind_handler":"0x0",
"ll_enc_req_handler":"0x0",
"ll_enc_rsp_handler":"0x0",
"ll_feature_req_handler":"0x0",
"ll_feature_rsp_handler":"0x0",
"ll_length_req_handler":"0x0",
"ll_length_rsp_handler":"0x0",
"ll_min_used_channels_ind_handler":"0x0",
"ll_pause_enc_req_handler":"0x0",
"ll_pause_enc_rsp_handler":"0x0",
"ll_reject_ext_ind_handler":"0x0",
"ll_reject_ind_handler":"0x0",
"ll_slave_feature_req_handler":"0x0",
"ll_start_enc_req_handler":"0x0",
"ll_start_enc_rsp_handler":"0x0",
"ll_unknown_rsp_handler":"0x0",
"ll_version_ind_handler":"0x0",
"ble_util_buf_acl_tx_free":"0x0",
"lld_rxdesc_check":"0x0",
"lld_rxdesc_free":"0x0",
"rwip_priority":"0x0",
"sch_arb_insert":"0x0",
"sch_prog_push":"0x0",
"FMC_SPI_Flash_RDID":"0x0",
"FMC_SPI_Flash_RUID":"0x0",
"FMC_SPI_Flash_WakeUp":"0x0",
"FMC_SPI_Init_Oprt":"0x0",
"FMC_SPI_Flash_PowerDown":"0x0",
"FMC_SPI_FlashRead":"0x0",
"FMC_SPI_FlashWrite":"0x0",
"FMC_SPI_Flash_Erase_Sector":"0x0",
"FMC_SPI_Flash_PowerDown":"0x0",
"FMC_SPI_Flash_WakeUp":"0x0",
"llc_cleanup":"0x0",
"llc_cmd_stat_send":"0x0",
"llc_llcp_send":"0x0",
"llc_llcp_state_set":"0x0",
"llc_proc_get":"0x0",
"llc_proc_id_get":"0x0",
"llc_proc_init":"0x0",
"llc_proc_reg":"0x0",
"llc_proc_state_get":"0x0",
"llc_proc_state_set":"0x0",
"llc_proc_timer_pause_set":"0x0",
"llc_proc_timer_set":"0x0",
"llc_proc_unreg":"0x0",
"lld_con_stop":"0x0",
"lld_adv_evt_start_cbk":"0x0",
"rwip_env":"0x0",
"rwip_prog_delay":"0x0",
"rwip_time_get":"0x0",
"rwip_wakeup_end":"0x0",
"sch_arb_env":"0x0",
"lld_adv_frm_cbk":"0x0",
"rwip_timer_alarm_handler":"0x0",
"rwip_timer_arb_handler":"0x0",
"rwip_timer_co_handler":"0x0",
"lld_env":"0x0",
"aa_gen":"0x0",
"lld_adv_init":"0x0",
"lld_con_init":"0x0",
"lld_core_init":"0x0",
"lld_rpa_renew_env":"0x0",
"lld_channel_assess":"0x0",
"lld_con_env":"0x0",
"lld_con_tx_len_update":"0x0",
"lld_exp_sync_pos_tab":"0x0",
"lld_instant_proc_end":"0x0",
"prf_dst_task_get":"0x0",
"rom_env_init":"0x0",
"gapc_get_bdaddr":"0x0",
"gatt_db_svc16_add":"0x0",
"gatt_db_svc_add":"0x0",
"gatt_db_svc_remove":"0x0",
"gatt_srv_att_read_get_cfm":"0x0",
"gatt_srv_att_val_set_cfm":"0x0",
"gatt_srv_event_send":"0x0",
"gatt_user_srv_register":"0x0",
"llc_msg_handler_tab":"0x0",
"rom_llc_state":"0x0",
"lld_con_evt_start_cbk":"0x0",
"lld_con_evt_canceled_cbk":"0x0",
"co_sca2ppm":"0x0",
"lld_con_evt_time_update":"0x0",
"lld_con_max_lat_calc":"0x0",
"lld_con_sched":"0x0",
"sch_slice_per_add":"0x0",
"rwble_isr":"0x0",
"rwip_isr":"0x0",
"lld_con_frm_isr":"0x0",
"ke_task_schedule":"0x0",
"lld_adv_frm_isr":"0x0",
"sv_lock":"0x0",
"sv_txlen":"0x0",
"rom_lld_con_rx":"0x0",
"rom_lld_con_evt_start_cbk":"0x0",
"rom_lld_con_frm_isr":"0x0",
"gatt_cli_mtu_exch":"0x0",
"rom_lld_disable_latency":"0x0",
"rom_lld_enable_latency":"0x0",
"evt_start":"0x0",
"gatt_cli_discover_svc":"0x0",
"gatt_uuid16_comp":"0x0",
"gatt_cli_att_event_cfm":"0x0",
"gatt_cli_discover_cancel":"0x0",
"gatt_cli_discover_char":"0x0",
"gatt_cli_discover_desc":"0x0",
"gatt_cli_event_register":"0x0",
"gatt_cli_read":"0x0",
"gatt_cli_read_by_uuid":"0x0",
"gatt_cli_write":"0x0",
"gatt_user_cli_register":"0x0",
"gatt_cli_discover_inc_svc":"0x0",
"gatt_cli_event_unregister":"0x0",
"co_rand_word":"0x0",
"co_random_init":"0x0",
"adv_evt_start":"0x0",
}
def traverse(f):
fs = os.listdir(f)
for f1 in fs:
tmp_path = os.path.join(f, f1)
if not os.path.isdir(tmp_path):
if os.path.isfile(tmp_path):
if isinstance(tmp_path, str):
# if tmp_path.endswith('2023_11_22.o'):
if tmp_path.endswith('addr_0x800.o'):
#print("ssss", tmp_path)
logger.info(tmp_path)
find_str(tmp_path)
else:
traverse(tmp_path)
def traverse_host(f):
fs = os.listdir(f)
for f1 in fs:
tmp_path = os.path.join(f, f1)
if not os.path.isdir(tmp_path):
if os.path.isfile(tmp_path):
if isinstance(tmp_path, str):
if tmp_path.endswith('rom_symdefs.o'):
#print("ssss", tmp_path)
logger.info(tmp_path)
find_str(tmp_path)
else:
traverse_host(tmp_path)
def traverse_for_replace(f):
fs = os.listdir(f)
for f1 in fs:
tmp_path = os.path.join(f, f1)
if not os.path.isdir(tmp_path):
if os.path.isfile(tmp_path):
if isinstance(tmp_path, str):
if tmp_path.endswith('rom_symdefs.o'):
logger.info(tmp_path)
replace_str(tmp_path)
def find_str(file):
text_lines = set()
with io.open(file, 'r', encoding='utf-8') as fd:
for line in fd:
for key, value in replace.items():
if re.search(key, line.strip()) != None and len(key)+13== len(line.strip()):
#print(line)
logger.info(line)
replace[key] = line
text_lines.add(line.strip())
text_functions = {line.split()[-1] for line in text_lines}
replace_keys = set(replace.keys())
print("del record key start")
for func in list(replace.keys()):
if func not in text_functions:
print(func)
del replace[func]
print("del record key end")
fd.close()
logger.info(str(replace))
def replace_str(file):
header = "#<SYMDEFS># ARM Linker, 5060750: Last Updated: Tue Sep 05 15:30:26 2023\n"
with io.open(r'tmp.c', 'w', encoding='utf-8') as fw:
fw.write(header)
for key, value in replace.items():
#print(len(key)+13, len(line.strip()), key, line.strip())
replace_flag = False
fw.write(value)
logger.info(value)
#print("line2", value, key)
print("line2", value)
fw.close()
with io.open(file, 'w', encoding='utf-8') as fw:
with io.open(r'tmp.c', 'r', encoding='utf-8') as file:
for line in file:
fw.write(line)
if __name__ == "__main__":
if(os.path.exists("log.txt")):
os.remove("log.txt")
logger = logging.getLogger(__name__)
logger.setLevel(level = logging.INFO)
handler = logging.FileHandler("log.txt")
handler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
#traverse("./Project/example/ble/rom_stack/mdk/")
traverse_host("./Project/example/ble/ble_central_lib/mdk/")
#print(replace)
traverse_for_replace("./Project/example/ble/ble_central/app/src")