MARVEL/stair56e_uart
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Stair56E UART project

Browse Source
This commit is contained in:
吴琪
2026-08-05 19:07:52 +08:00
parent 7ca1af130d
commit f5654b70cc
2500 changed files with 619007 additions and 282610 deletions
Download Patch File Download Diff File Expand all files Collapse all files
project/example/ble/ble_peripheral/app/src/Xinc_ble_sdk.lib
BIN
View File
Binary file not shown.
project/example/ble/ble_peripheral/app/src/aes.c
+66
View File
@@ -0,0 +1,66 @@
/**
****************************************************************************************
* *
* @file aes.c
*
* @brief Definition file for AES crypto module functions
*
* Copyright (C) RivieraWaves 2017-2018
*
****************************************************************************************
*/
#include "aes.h"
#if (RWIP_AES_ENCRYPT)
#define USE_AES_ENCRYPT 0
#define USE_AES_DECRYPT 1
#if USE_AES_ENCRYPT
uint8_t key[16]={0x10,0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x0d,0x0c,0x0b};
uint8_t src_val[16]={0x0a,0x0a,0x0e,0x0d,0x0c,0x0b,0x0a,0x13,0x12,0x07,0x06,0x05,0x04,0x0d,0x02,0x01};
uint8_t encrypt_val[16]={0xf7,0x3b,0x9a,0xe6,0x88,0xb0,0x06,0x3e,0x10,0xd4,0x0f,0xb6,0x80,0x4a,0x10,0xee};
#elif USE_AES_DECRYPT
uint8_t key[16]={0x10,0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x0d,0x0c,0x0b};
uint8_t src_val[16]={0xf7,0x3b,0x9a,0xe6,0x88,0xb0,0x06,0x3e,0x10,0xd4,0x0f,0xb6,0x80,0x4a,0x10,0xee};
uint8_t encrypt_val[16]={0x0a,0x0a,0x0e,0x0d,0x0c,0x0b,0x0a,0x13,0x12,0x07,0x06,0x05,0x04,0x0d,0x02,0x01};
#endif
aes_func_result_cb aes_res(uint8_t status, const uint8_t* aes_res_data, uint32_t src_info)
{
printf("src_info:0x%x\n",src_info);
printf("aes_res:");
for(int i=0;i<16;i++){
printf("%02x-",aes_res_data[i]);
}printf("\n");
if(!memcmp(aes_res_data,encrypt_val,sizeof(encrypt_val))){
printf("aes right\n");
}else{
printf("aes error\n");
}
}
void aes_test(void)
{
uint8_t copy=0;
static uint8_t cnt;
if(xc_gpio_read_pin(GPIO_1) == GPIO_PIN_SET){
if(cnt++ > 100){
cnt = 0;
#if USE_AES_ENCRYPT
printf("aes_encrypt\n");
aes_encrypt(key, src_val, 1, aes_res, 0xff);
#elif USE_AES_DECRYPT
printf("aes_decrypt\n");
aes_decrypt(key, src_val, copy, aes_res, 0xff);
#endif
}
}else{
cnt = 0;
}
}
#endif
project/example/ble/ble_peripheral/app/src/app_batt.c
+186 -189
View File
@@ -1,189 +1,186 @@
/**
****************************************************************************************
*
* @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
/**
****************************************************************************************
*
* @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 "arch.h" // Platform Definitions
#include "bass_msg.h" // health thermometer functions
#include "co_bt.h"
#include "co_utils.h"
#include "prf.h"
#include "prf_types.h" // Profile common types definition
#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_START_NTF;
req->old_batt_lvl[0] = 50;
// Send the message
ke_msg_send(req);
}
void app_batt_send_lvl(uint8_t batt_lvl)
{
ASSERT_ERR(batt_lvl <= BAS_BATTERY_LVL_MAX);
// Allocate the message
struct bass_batt_level_upd_req *req =
KE_MSG_ALLOC(BASS_BATT_LEVEL_UPD_REQ, prf_dst_task_get(TASK_ID_BASS),
TASK_APP, bass_batt_level_upd_req);
// Fill in the parameter structure
req->bas_instance = 0;
req->batt_level = batt_lvl;
// Send the message
ke_msg_send(req);
}
static int bass_batt_level_ntf_cfg_ind_handler(
ke_msg_id_t const msgid, struct bass_batt_level_ntf_cfg_ind const *param,
ke_task_id_t const dest_id, ke_task_id_t const src_id)
{
return (KE_MSG_CONSUMED);
}
static int batt_level_upd_handler(ke_msg_id_t const msgid,
struct bass_batt_level_upd_rsp const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief
*
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
static int app_batt_msg_dflt_handler(ke_msg_id_t const msgid, void const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
// Drop the message
return (KE_MSG_CONSUMED);
}
/*
* LOCAL VARIABLE DEFINITIONS
****************************************************************************************
*/
/// Default State handlers definition
const struct ke_msg_handler app_batt_msg_handler_list[] = {
// Note: first message is latest message checked by kernel so default is put
// on top.
{KE_MSG_DEFAULT_HANDLER, (ke_msg_func_t)app_batt_msg_dflt_handler},
{BASS_BATT_LEVEL_NTF_CFG_IND,
(ke_msg_func_t)bass_batt_level_ntf_cfg_ind_handler},
{BASS_BATT_LEVEL_UPD_RSP, (ke_msg_func_t)batt_level_upd_handler},
};
const struct app_subtask_handlers app_batt_handlers = APP_HANDLERS(app_batt);
#endif // BLE_APP_BATT
/// @} APP
project/example/ble/ble_peripheral/app/src/app_batt.h
+110 -110
View File
@@ -1,110 +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_
/**
****************************************************************************************
*
* @file app_batt.h
*
* @brief Battery Application Module entry point
*
* Copyright (C) RivieraWaves 2009-2015
*
*
****************************************************************************************
*/
#ifndef APP_BATT_H_
#define APP_BATT_H_
/**
****************************************************************************************
* @addtogroup APP
* @ingroup RICOW
*
* @brief Battery Application Module entry point
*
* @{
****************************************************************************************
*/
/*
* INCLUDE FILES
****************************************************************************************
*/
#include "rwip_config.h" // SW configuration
#if (BLE_APP_BATT)
#include <stdint.h> // Standard Integer Definition
#include "ke_task.h" // Kernel Task Definition
/*
* STRUCTURES DEFINITION
****************************************************************************************
*/
/// Battery Application Module Environment Structure
struct app_batt_env_tag
{
/// Connection handle
uint8_t conidx;
/// Current Battery Level
uint8_t batt_lvl;
};
/*
* GLOBAL VARIABLES DECLARATIONS
****************************************************************************************
*/
/// Battery Application environment
extern struct app_batt_env_tag app_batt_env;
/// Table of message handlers
extern const struct app_subtask_handlers app_batt_handlers;
/*
* FUNCTIONS DECLARATION
****************************************************************************************
*/
/**
****************************************************************************************
*
* Health Thermometer Application Functions
*
****************************************************************************************
*/
/**
****************************************************************************************
* @brief Initialize Battery Application Module
****************************************************************************************
*/
void app_batt_init(void);
/**
****************************************************************************************
* @brief Add a Battery Service instance in the DB
****************************************************************************************
*/
void app_batt_add_bas(void);
/**
****************************************************************************************
* @brief Enable the Battery Service
****************************************************************************************
*/
void app_batt_enable_prf(uint8_t conidx);
/**
****************************************************************************************
* @brief Send a Battery level value
****************************************************************************************
*/
void app_batt_send_lvl(uint8_t batt_lvl);
#endif //(BLE_APP_BATT)
/// @} APP
#endif // APP_BATT_H_
project/example/ble/ble_peripheral/app/src/app_battc.c
+56 -56
View File
@@ -1,56 +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 },
};
#if 0
/*@TRACE*/
enum basc_msg_id
{
/// Start the Battery Service Client Role - at connection
// BASC_ENABLE_REQ = MSG_ID(BASC, 0x00),
///Confirm that cfg connection has finished with discovery results, or that normal cnx started
BASC_ENABLE_RSP = MSG_ID(BASC, 0x01),
/// Read Characteristic Value Request
// BASC_READ_INFO_REQ = MSG_ID(BASC, 0x02),
/// Read Characteristic Value Request
BASC_READ_INFO_RSP = MSG_ID(BASC, 0x03),
/// Write Battery Level Notification Configuration Value request
// BASC_BATT_LEVEL_NTF_CFG_REQ = MSG_ID(BASC, 0x04),
/// Write Battery Level Notification Configuration Value response
BASC_BATT_LEVEL_NTF_CFG_RSP = MSG_ID(BASC, 0x05),
/// Indicate to APP that the Battery Level value has been received
BASC_BATT_LEVEL_IND = MSG_ID(BASC, 0x06),
};
#endif
void xc_basc_enbale_req()
{
//send msg
BASC_ENABLE_REQ
}
void xc_basc_read_info_req()
{
//send msg
BASC_READ_INFO_REQ
}
void xc_basc_batt_leval_ntf_cfg_req()
{
//send msg
BASC_BATT_LEVEL_NTF_CFG_REQ
}
/// Default State handlers definition
KE_MSG_HANDLER_TAB(basc)
{
// Note: all messages must be sorted in ID ascending order
{BASC_ENABLE_RSP, (ke_msg_func_t) xxx_handler },
{BASC_READ_INFO_RSP, (ke_msg_func_t) xxx_handler },
{BASC_BATT_LEVEL_NTF_CFG_RSP, (ke_msg_func_t) xxx_handler },
{BASC_BATT_LEVEL_IND, (ke_msg_func_t) xxx_handler },
};
project/example/ble/ble_peripheral/app/src/app_sec.c
+547 -546
View File
File diff suppressed because it is too large Load Diff
project/example/ble/ble_peripheral/app/src/app_sec.h
+96 -96
View File
@@ -1,96 +1,96 @@
/**
****************************************************************************************
*
* @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 <stdint.h> // Standard Integer Definition
#include <stdbool.h>
/*
* 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
/**
****************************************************************************************
*
* @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 <stdint.h> // Standard Integer Definition
#include <stdbool.h>
/*
* DEFINES
****************************************************************************************
*/
/*
* STRUCTURES DEFINITIONS
****************************************************************************************
*/
struct app_sec_env_tag
{
// Bond status
bool bonded;
};
/*
* GLOBAL VARIABLE DECLARATIONS
****************************************************************************************
*/
/// Application Security Environment
extern struct app_sec_env_tag app_sec_env;
/// Table of message handlers
extern const struct app_subtask_handlers app_sec_handlers;
/*
* GLOBAL FUNCTIONS DECLARATIONS
****************************************************************************************
*/
/**
****************************************************************************************
* @brief Initialize the Application Security Module
****************************************************************************************
*/
void app_sec_init(void);
#if (NVDS_SUPPORT)
/**
****************************************************************************************
* @brief Remove all bond data stored in NVDS
****************************************************************************************
*/
void app_sec_remove_bond(void);
#endif //(NVDS_SUPPORT)
/**
****************************************************************************************
* @brief Send a security request to the peer device. This function is used to require the
* central to start the encryption with a LTK that would have shared during a previous
* bond procedure.
*
* @param[in] - conidx: Connection Index
****************************************************************************************
*/
void app_sec_send_security_req(uint8_t conidx);
#endif // APP_SEC_H_
/// @} APP_SEC
project/example/ble/ble_peripheral/app/src/app_task.c
+646 -570
View File
File diff suppressed because it is too large Load Diff
project/example/ble/ble_peripheral/app/src/arch_main.c
+698 -292
View File
@@ -1,294 +1,700 @@
/**
****************************************************************************************
*
* @file arch_main.c
*
* @brief Main loop of the application.
*
* Copyright (C) RivieraWaves 2009-2015
*
*
****************************************************************************************
*/
/*
* INCLUDES
****************************************************************************************
*/
#include "rwip_config.h" // RW SW configuration
#include "xc_drv_pwr.h"
#if (USE_ROM_FLASH)
#include "xc6xxx_fmc_spi.h"
#endif // (USE_ROM_FLASH)
#include "app_task.h"
#include "rom_port.h"
#if (BLE_TEST_MODE_SUPPORT)
#include "uart.h" // UART initialization
#endif // (BLE_TEST_MODE_SUPPORT)
#if (BLE_EMB_PRESENT || BT_EMB_PRESENT)
#include "rf.h" // RF initialization
#endif // BLE_EMB_PRESENT || BT_EMB_PRESENT
#if (PLF_NVDS)
#include "nvds.h" // NVDS definitions
#endif // PLF_NVDS
#include "xc6xxx.h"
#include "gpio.h"
#include "xc_drv_gpio.h"
/**
****************************************************************************************
* @addtogroup DRIVERS
* @{
*
*
* ****************************************************************************************
*/
/*
* DEFINES
****************************************************************************************
*/
/// NVDS location in FLASH : 0x000E0000 (896KB (1Mo - 128KB))
#define NVDS_FLASH_ADDRESS (0x0003F800)//((256-2)*1024)
/// 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
****************************************************************************************
*/
#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);
extern uint8_t ota_flag;
void rc32k_testpin_cfg(void)
{
printf("rc 32k \n");
GPIO_InitCfg_t gpio_cfg = {0};
gpio_cfg.Mux = GPIO_Mux0;
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
gpio_cfg.FunSel = GPIO_Dx;
gpio_cfg.Int = NOT_INT;
gpio_cfg.Pull = GPIO_PULLDOWN;
gpio_cfg.Pin = 4;
xc_gpio_init(&gpio_cfg);
xc_gpio_write_pin(4, 1);
xc_gpio_write_pin(4, 0);
xc_gpio_write_pin(4, 1);
xc_gpio_write_pin(4, 0);
xc_gpio_fun_sel(4, GPIO_Dx);
xc_gpio_mux_ctl(4, GPIO_Mux3); // en test_pin[0]
*((uint32_t volatile *)0x40000174) = 26;
}
void flash_init()
{
FMC_SPI_Init_Oprt();
FMC_SPI_Flash_WakeUp();
uint32_t mid = 0;
FMC_SPI_Flash_RDID((uint8_t *)&mid);
LOGI("Flash RDID: 0x%08x\n", mid);
uint8_t ruid[16];
FMC_SPI_Flash_RUID(ruid);
LOGI("Flash RUID11: ");
for (int i = 0; i < 16; i++)
{
LOGI("%02x ", ruid[i]);
}
LOGI("\n");
}
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);
}
/* Zero the host global variable. */
void rom_env_host_init()
{
uint8_t *ptr = 0x10001400;
memset(ptr, 0, 0x10004700 - 0x10001400); //ram code 需要手动搬移
ptr = (uint32_t *)(0x10000800);
memset(ptr, 0, 0x10001300 - 0x10000800);
rom_env.stack_printf = printf;
rom_env.stack_printf("%s %d\n", __func__, __LINE__);
}
/* Add a protection field to determine if the stack is overflowing. */
void stack_tag()
{
uint32_t StackPos;
__IO uint32_t *pStack;
StackPos = __get_MSP();
printf("StackPos=0x%x\n", StackPos);
// 0x800 is the size of the stack, which should be changed according to the configuration of the project.
pStack = (uint32_t *)(StackPos - 0x800);
*pStack = 0xa5a5a5a5;
}
void board_init()
{
clock_init();
app_uart_init();
LOGI("sdk version: %s build time: %s %s\n", TOSTRING(SDK_VERSION), __DATE__, __TIME__);
stack_tag();
rom_env_host_init();
#if (SLEEP_ENABLE)
xc_rc32k_calib_by_hw();
//xc_rc32k_calib_by_soft();
#endif // (SLEEP_ENABLE)
rom_env_init();
uint8_t mac_addr[] = {0xac, 0xc3, 0x33, 0x46, 0x55, 0x66};
memcpy(co_default_bdaddr.addr, mac_addr, 6);
AHB_CTL;
/*
************************************************************************************
* Platform initialization
************************************************************************************
*/
// Initialize random process
srand(1);
}
void bluetooth_init()
{
uint32_t error = RESET_NO_ERROR;
#if (PLF_NVDS)
flash_init();
// Initialize NVDS module
nvds_init((uint8_t *)NVDS_FLASH_ADDRESS, 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);
#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();
}
int main(void)
{
/* Set the broadcast address of the device. */
board_init();
bluetooth_init();
app_ir_init();
app_key_init();
// app_pga_init();
// delay_ms(1);//Wait for the pga to stabilize
//app_audio_record_init();
app_pwm_init();
timer0_2_init();
#if (SLEEP_ENABLE)
// sleep_init();
#endif // (SLEEP_ENABLE)
// rc32k_testpin_cfg();
#if (BLE_APP_PRESENT)
// rf_test_pin_init();
while (1)
{
/**
****************************************************************************************
*
* @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 "core_cm0.h"
#include "xc6xxx.h"
#include "xc6xxx_fmc_spi.h"
#include "xc_drv_fmc_spi.h"
#include "sleep.h"
#include "ota_protocol.h"
#include "mcu_bridge.h"
/**
****************************************************************************************
* @addtogroup DRIVERS
* @{
*
*
* ****************************************************************************************
*/
/*
* DEFINES
****************************************************************************************
*/
/// NVDS location in FLASH : 0x000E0000 (896KB (1Mo - 128KB))
#define NVDS_FLASH_ADDRESS (0x0003F800) //((256-2)*1024)
/*
* GLOBAL VARIABLE DEFINITIONS
****************************************************************************************
*/
/*
* MAIN FUNCTION
****************************************************************************************
*/
/**
****************************************************************************************
* @brief RW main function.
*
* This function is called right after the booting process has completed.
*
* @return status exit status
****************************************************************************************
*/
#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);
#if !FAST_OTA
extern uint8_t ota_flag;
#endif
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);
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");
#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)) {
// int iter = 0;
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];
}
}
LOGI("mac addr: %02x %02x %02x %02x %02x %02x\n", co_default_bdaddr.addr[0],
co_default_bdaddr.addr[1], co_default_bdaddr.addr[2],
co_default_bdaddr.addr[3], co_default_bdaddr.addr[4],
co_default_bdaddr.addr[5]);
}
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)
{
#if XTAL_32K
WDT_InitCfg_t wdt_cfg ;
wdt_cfg.WorkMode = WDT_WORK_MODE1;
wdt_cfg.ReloadValue = WDT_CLK_32M_RESET_MODE1_2097152US;
wdt_cfg.PclkSel = WDT_WORK_32M;
xc_ext32k_wdt_init(&wdt_cfg);
xc_ext32k_wdt_start();
NVIC_EnableIRQ(WDT_IRQn);
#else
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();
#endif
}
/* Zero the host global variable. */
void rom_env_host_init()
{
uint32_t *ptr = (uint32_t *)(0x10000800);
memset(ptr, 0, 0x10001300 - 0x10000800);
rom_env.stack_printf = printf;
}
/* Add a protection field to determine if the stack is overflowing. */
void stack_tag()
{
uint32_t StackPos;
__IO uint32_t *pStack;
StackPos = __get_MSP();
printf("StackPos=0x%x\n", StackPos);
// 0x800 is the size of the stack, which should be changed according to the
// configuration of the project.
pStack = (uint32_t *)(StackPos - 0x800);
*pStack = 0xa5a5a5a5;
}
void board_init()
{
clock_init();
app_uart_init();
#if (POWER_ON)
power_on_check();
#endif // (POWER_ON)
LOGI("sdk version: %s build time: %s %s\n", TOSTRING(SDK_VERSION), __DATE__,
__TIME__);
// stack_tag();
rom_env_host_init();
#if (SLEEP_ENABLE)
#if XTAL_32K
#else
// xc_rc32k_calib_by_hw();
xc_rc32k_calib_by_soft();
#endif// (XTAL_32K)
#endif // (SLEEP_ENABLE)
rom_env_init();
AHB_CTL;
/*
************************************************************************************
* Platform initialization
************************************************************************************
*/
// // Initialize random process
// srand(1);
}
void bluetooth_init()
{
uint32_t error = RESET_NO_ERROR;
#if (PLF_NVDS)
flash_init();
// 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();
}
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;
#if defined(USE_64M_CRYSTAL)
#include "reg_ipcore.h"
#define EVT_TX_EN (0x1)
#define EVT_RX_EN (0x2)
uint32_t fra_base = 0x4b1; // 0x4b1
uint32_t fra_rx_base = 0x4b0; // 0x4b1
uint32_t cur_channel;
__RAM_CODE void tx_channel(void)
{
uint32_t new_val = fra_base;
*((uint32_t volatile *)0x53022050) = new_val;
*((uint32_t volatile *)0x53022064) = *((uint32_t volatile *)0x53022064) & (~(1 << 31));
}
__RAM_CODE void rx_channel(uint8_t channel)
{
uint8_t ch_sel_ofst = 0;
// ��������Ҫ��ƫ�ƣ�Ӳ���Զ���
switch (channel)
{
case 37:
ch_sel_ofst = 0;
break;
case 38:
ch_sel_ofst = 12;
break;
case 39:
ch_sel_ofst = 39;
break;
default:
{
if (channel <= 10)
{
ch_sel_ofst = channel + 1;
}
else
{
ch_sel_ofst = channel + 2;
}
break;
}
}
uint32_t new_val = fra_rx_base + ch_sel_ofst;
*((uint32_t volatile *)0x53022064) = ((new_val << 16) | 0x80008000);
}
__RAM_CODE void PendSV_Handler(void)
{
ip_diagcntl_pack(0, 0, 1, 0x38, 1, 0x3, 1, 0x20);
if (adv_evt_start)
{ // adv event
#if (ADV_EVENT_NOT_RUN_XIP == 1)
#if defined(USE_64M_CRYSTAL)
tx_channel();
while (!sv_lock)
{
uint8_t val1 = ip_diagstat_diag1stat_getf();
// tx
if ((val1 & 0x01))
{
*((uint32_t volatile *)0x53022064) = *((uint32_t volatile *)0x53022064) & (~(1 << 31));
while (val1 & 0x01)
{
val1 = ip_diagstat_diag1stat_getf();
}
uint8_t val2 = ip_diagstat_diag2stat_getf() & 0x3f;
rx_channel(val2);
}
// rx
if ((val1 & 0x02))
{
uint8_t val2 = ip_diagstat_diag2stat_getf() & 0x3f;
rx_channel(val2);
}
}
#else
while (!sv_lock)
;
#endif
#endif // (ADV_EVENT_NOT_RUN_XIP ==1)
}
else if (evt_start)
{ // conn event
#if defined(USE_64M_CRYSTAL)
uint8_t val1 = 0;
uint8_t val2 = ip_diagstat_diag2stat_getf() & 0x3f;
rx_channel(val2);
*((uint32_t volatile*)0x40000178) = 11;
GLOBAL_INT_DISABLE();
while (1)
{
cur_channel = (ip_diagstat_diag2stat_getf() & 0x3f);
if (val2 != cur_channel)
{
rx_channel(cur_channel);
break;
}
uint8_t val1 = ip_diagstat_diag1stat_getf();
if ((val1 & 0x02))
{
break;
}
}
GLOBAL_INT_RESTORE();
// ��rx_en �� tx_en ���½������л�
// while (!sv_lock)
// {
// uint8_t tx_rx_en = 0;
// GLOBAL_INT_DISABLE();
// tx_rx_en = ip_diagstat_diag1stat_getf();
// GLOBAL_INT_RESTORE();
// if (tx_rx_en & EVT_RX_EN)
// {
// while (tx_rx_en & EVT_RX_EN)
// {
// GLOBAL_INT_DISABLE();
// tx_rx_en = ip_diagstat_diag1stat_getf();
// GLOBAL_INT_RESTORE();
// }
// GLOBAL_INT_DISABLE();
// // xc_gpio_write_pin(4, 1);
// *((uint32_t volatile *)0x53022064) = *((uint32_t volatile *)0x53022064) & (~(1 << 31));
// // xc_gpio_write_pin(4, 0);
// GLOBAL_INT_RESTORE();
// // tx ��delay��
// // NVIC_SetPriority((IRQn_Type)PendSV_IRQn, 0x1);
// // tx delay�޸�
// }
// if (tx_rx_en & EVT_TX_EN)
// {
// while (tx_rx_en & EVT_TX_EN)
// {
// tx_rx_en = ip_diagstat_diag1stat_getf();
// }
// for (int i = 0; i < 10; i++)
// ; // must delay
// rx_channel(cur_channel);
// }
// }
#else
while (!sv_lock)
;
#endif
}
}
__RAM_CODE void tx_rx_freq()
{
uint8_t tx_rx_en = 0;
tx_rx_en = ip_diagstat_diag1stat_getf();
if (tx_rx_en & EVT_RX_EN){
*((uint32_t volatile*)0x40000178) = 10;
}
if (tx_rx_en & EVT_TX_EN){
*((uint32_t volatile*)0x40000178) = 11;
}
if (evt_start){
#if 1
if (tx_rx_en & EVT_RX_EN)
{
// xc_gpio_write_pin(8,1);
while (tx_rx_en & EVT_RX_EN)
{
GLOBAL_INT_DISABLE();
tx_rx_en = ip_diagstat_diag1stat_getf();
GLOBAL_INT_RESTORE();
}
GLOBAL_INT_DISABLE();
*((uint32_t volatile *)0x53022064) = *((uint32_t volatile *)0x53022064) & (~(1 << 31));
GLOBAL_INT_RESTORE();
}
if (tx_rx_en & EVT_TX_EN)
{
// xc_gpio_write_pin(9,1);
while (tx_rx_en & EVT_TX_EN)
{
tx_rx_en = ip_diagstat_diag1stat_getf();
}
for (volatile i = 0; i < 10; i++)
; // must delay
rx_channel(cur_channel);
}
#endif
#if 0
if (tx_rx_en & EVT_TX_EN)
{
*((uint32_t volatile *)0x53022064) = *((uint32_t volatile *)0x53022064) & (~(1 << 31));
while (tx_rx_en & EVT_TX_EN)
{
tx_rx_en = ip_diagstat_diag1stat_getf();
}
for (int i = 0; i < 10; i++)
; // must delay
rx_channel(cur_channel);
}
#endif
}
}
#define __write_hw_reg32(reg,val) ((*reg) = (val))
#define __read_hw_reg32(reg, val) ((val) = (*reg))
#define CPR_CTLAPBCLKEN_GRCTL ((volatile unsigned *)(0x40000000 + 0x070))
#define CPR_AOCLKEN_GRCTL ((volatile unsigned *)( 0x40002400 + 0x7C))
#define AO_GPIO_MODE ((volatile unsigned *)(0x40002000 + 0x0044))
#define AO_GPIO_CTL ((volatile unsigned *)(0x40002000 + 0x0048))
void Init_rtc_gpio(uint32_t num,uint8_t inter_mode)
{
uint32_t val;
// if(!((inter_mode>=0x08) &&(inter_mode<=0x0c))) return;
__write_hw_reg32(CPR_CTLAPBCLKEN_GRCTL, 0x20002);
__write_hw_reg32(CPR_AOCLKEN_GRCTL, 0x20002);
__read_hw_reg32(AO_GPIO_MODE , val);
val &= ~(0x0f<<(num<<2));
val |= (inter_mode<<(num<<2));
__write_hw_reg32(AO_GPIO_MODE, val);
__read_hw_reg32(AO_GPIO_CTL , val);
val |= (1<<(8+num));
__write_hw_reg32(AO_GPIO_CTL, val);
// rtc_ao_gpio_mode__aogpio_debounce_en3__setf(1);
NVIC_SetPriority(RTC_IRQn, 0x0);
NVIC_EnableIRQ(RTC_IRQn);
}
#else
#if ((ADV_EVENT_NOT_RUN_XIP ==1) || (CONN_EVENT_NOT_RUN_XIP == 0) || (CONN_EVENT_NOT_RUN_XIP == 1))
__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))
#endif // defined(USE_64M_CRYSTAL)
#if (CONFIG_BT_WAKEUP_VIA_GPIO)
void gpio_intr_callback(uint64_t intr_sta)
{
uint32_t value = ((*(volatile uint32_t *)(0x53022044)));
value |= 1 << 14;
((*(volatile uint32_t *)(0x53022044))) = value;
}
#endif
#if (CONN_EVENT_NOT_RUN_XIP == 3)
#define __write_hw_reg32(reg,val) ((*reg) = (val))
#define __read_hw_reg32(reg, val) ((val) = (*reg))
#define CPR_CTLAPBCLKEN_GRCTL ((volatile unsigned *)(0x40000000 + 0x070))
#define CPR_AOCLKEN_GRCTL ((volatile unsigned *)( 0x40002400 + 0x7C))
#define AO_GPIO_MODE ((volatile unsigned *)(0x40002000 + 0x0044))
#define AO_GPIO_CTL ((volatile unsigned *)(0x40002000 + 0x0048))
void Init_rtc_gpio(uint32_t num,uint8_t inter_mode)
{
uint32_t val;
// if(!((inter_mode>=0x08) &&(inter_mode<=0x0c))) return;
__write_hw_reg32(CPR_CTLAPBCLKEN_GRCTL, 0x20002);
__write_hw_reg32(CPR_AOCLKEN_GRCTL, 0x20002);
__read_hw_reg32(AO_GPIO_MODE , val);
val &= ~(0x0f<<(num<<2));
val |= (inter_mode<<(num<<2));
__write_hw_reg32(AO_GPIO_MODE, val);
__read_hw_reg32(AO_GPIO_CTL , val);
val |= (1<<(8+num));
__write_hw_reg32(AO_GPIO_CTL, val);
// rtc_ao_gpio_mode__aogpio_debounce_en3__setf(1);
NVIC_SetPriority(RTC_IRQn, 0x0);
NVIC_EnableIRQ(RTC_IRQn);
}
#include "reg_ipcore.h"
#define EVT_TX_EN (0x1)
#define EVT_RX_EN (0x2)
__RAM_CODE void tx_on_delay()
{
uint8_t tx_rx_en = 0;
tx_rx_en = ip_diagstat_diag0stat_getf();
if (tx_rx_en & EVT_TX_EN){
while(tx_rx_en & EVT_TX_EN){
tx_rx_en = ip_diagstat_diag0stat_getf();
};
}
}
#endif // (CONN_EVENT_NOT_RUN_XIP == 3)
void ble_tx_rx_on_irq_config()
{
#if (defined(USE_64M_CRYSTAL) || defined(NOT_RUN_XIP_TX_ONLY))
writel(0x53022040, 0);
// xc_gpio_fun_sel(3,0);
// xc_gpio_mux_ctl(3,3); // en test_pin[0]
// *((uint32_t volatile*)0x40000170) = 0;
xc_gpio_fun_sel(GPIO_2,0);
xc_gpio_mux_ctl(GPIO_2,1); // en test_pin[1]
*((uint32_t volatile*)0x40000178) = 10;
#if defined(NOT_RUN_XIP_TX_ONLY)
*((uint32_t volatile*)0x40000178) = 0;
#endif // defined(NOT_RUN_XIP_TX_ONLY)
xc_pwr_pwrkey_init();
Init_rtc_gpio(GPIO_2,0x00);
#endif // (defined(USE_64M_CRYSTAL) || defined(NOT_RUN_XIP_TX_ONLY))
}
int main(void)
{
wdt_init();
/* Set the broadcast address of the device. */
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) || defined(USE_64M_CRYSTAL))
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) || defined(USE_64M_CRYSTAL))
#if (CONFIG_BT_WAKEUP_VIA_GPIO)
uint32_t value = ((*(volatile uint32_t *)(0x53022044)));
value |= 1 << 12;
((*(volatile uint32_t *)(0x53022044))) = value;
#endif // (CONFIG_BT_WAKEUP_VIA_GPIO)
#if (SLEEP_ENABLE)
sleep_init();
#endif // (SLEEP_ENABLE)
ble_tx_rx_on_irq_config();
#if (BLE_APP_PRESENT)
while (1) {
// schedule all pending events
rwip_schedule();
xc_ota_schedule();
// LOGI("GAPM_DEV_BDADDR_IND\r\n");
#if (SLEEP_ENABLE)
if (!ota_flag)
{
// sleep_schedule();
// feedback();
}
#endif // (SLEEP_ENABLE)
//用户应用程序
// scan_uart();
ble_message_process();//BLE接收信息处理
ir_message_process();//ir遥控按键处理
key_message_process(app_key_message_get());//按键检测处理
app_record_process();//ADC_MIC检测处理
}
#endif // (BLE_APP_PRESENT)
}
/// @} DRIVERS
mcu_bridge_process();
#if !FAST_OTA
xc_ota_schedule();
#endif
#if OTA_AES_USED
process_aes_decrypt();
#endif
#if (SLEEP_ENABLE)
#if !FAST_OTA
if (!ota_flag)
#endif
{
sleep_schedule();
}
#endif // (SLEEP_ENABLE)
xc_wdt_reload(); //TOOD
}
#endif // (BLE_APP_PRESENT)
}
/// @} DRIVERS
project/example/ble/ble_peripheral/app/src/fast_ota.c
+380
View File
@@ -0,0 +1,380 @@
/**
****************************************************************************************
*
* @file usr_ota.c
*
* @brief Custom ota.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.p
*
****************************************************************************************
*/
#if FAST_OTA
#include "fast_ota.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"
#include "ota_protocol.h"
#include "ota_flash_interface.h"
#include "aes.h"
#if (BLE_APP_PRESENT)
static volatile uint16_t write_index = 0;
static volatile uint32_t aes_index_at = 0;
static volatile uint32_t write_index_all = 0;
static volatile uint32_t should_recived_length = 0;
static volatile uint32_t app_start_addr = 0;
static volatile uint16_t last_erase_block = 0;
static volatile uint32_t header_app_crc32 = 0;
static ota_process_state_t process_sta = OTA_PROCESS_SEARCH_HEADER;
static uint8_t head_data_temp[256] ={0};
__attribute__((aligned(4))) __RAM_EM uint8_t write_buffer[NVDS_FLASH_SIZE+247];
#if OTA_AES_USED
__attribute__((aligned(4))) uint8_t data_save_buffer[ASE_DATA_BUFFER_SIZE];
static volatile uint16_t data_save_index = 0;
static volatile uint16_t aes_decrypt_index = 0;
static volatile uint8_t aes_decrypt_run = 1;
uint8_t AES_KEY[16] = OTA_AES_KEY;
#endif
extern __RAM_CODE void FMC_SPI_Flash_ReadPage(uint32_t ReadAddr, uint8_t *data, uint16_t size);
extern __RAM_CODE void xc_fmc_spi_flash_erase_page(uint32_t addr);
extern __RAM_CODE void xc_fmc_spi_flash_write_page(uint32_t addr, uint8_t *data, uint16_t size);
void ota_state_restore(void){
write_index =0;
aes_index_at = 0;
write_index_all = 0;
should_recived_length = 0;
app_start_addr = 0;
last_erase_block = 0;
header_app_crc32 =0;
process_sta = OTA_PROCESS_SEARCH_HEADER;
memset(head_data_temp,0,256);
//aes
#if OTA_AES_USED
data_save_index = 0;
aes_decrypt_index = 0;
aes_decrypt_run = 0;
#endif
}
uint8_t *get_fota_env_addr(uint16_t len)
{
if (len > sizeof(write_buffer)) {
LOGI(" len error\n ");
return NULL;
}
return (uint8_t *)(&write_buffer);
}
unsigned int get_crc32(unsigned int crc, unsigned char *buf, unsigned int len) {
const unsigned char *buffer = (const unsigned char *)buf;
int i = 0;
while (len--) {
crc ^= (unsigned int)(*buffer++) << 24;
for (i = 0; i < 8; i++) {
if (crc & 0x80000000) {
crc = (crc << 1) ^ 0xEDB88320;
} else {
crc <<= 1;
}
}
}
return crc;
}
uint32_t calc_crc32(uint32_t addr, uint32_t len)
{
uint8_t buff[FLASH_PAGE_SIZE];
uint32_t size;
uint32_t crc = CRC32_INITIAL;
GLOBAL_INT_DISABLE();
while(len > 0)
{
size = (len > FLASH_PAGE_SIZE)? FLASH_PAGE_SIZE : len;
FMC_SPI_Flash_ReadPage(addr, buff, FLASH_PAGE_SIZE);
crc = get_crc32(crc, buff, size);
addr += size;
len -= size;
// for(uint16_t i = 0;i<256;i++)
// {
// LOGI("%02x ",buff[i]);
// }
// LOGI("\r\n");
// LOGI("crc:%x \r\n",crc);
}
GLOBAL_INT_RESTORE();
return crc;
}
uint32_t calc_crc32_head(uint8_t *buff, uint32_t len)
{
uint32_t size;
uint32_t crc = CRC32_INITIAL;
while(len > 0)
{
size = (len > FLASH_PAGE_SIZE)? FLASH_PAGE_SIZE : len;
crc = get_crc32(crc, buff, size);
len -= size;
}
return crc;
}
//erase code flash if header vailed is true
bool app_header_vailed(uint8_t *app_image_header,uint8_t *data) {
uint32_t head_crc=(app_image_header[243+8]<<24)+(app_image_header[242+8]<<16)+(app_image_header[241+8]<<8)+(app_image_header[240+8]);
if(head_crc != calc_crc32_head(data,240)) {
LOGI("header crc32 filed \r\n");
LOGI("crc header=%08x cal_crc :%08x \r\n",head_crc,calc_crc32((uint32_t)(app_image_header+8),240));
return false;
}
uint32_t size = (app_image_header[7]<<24)+(app_image_header[6]<<16)+(app_image_header[5]<<8)+app_image_header[4];// data
uint32_t app_image_start_addr = (app_image_header[27+8]<<24)+(app_image_header[26+8]<<16)+(app_image_header[25+8]<<8)+(app_image_header[24+8]); // data
uint32_t app_image_end_addr = app_image_start_addr + size - 1;
LOGI("app_image_start_addr:%x ,app_image_end_addr:%x\r\n",app_image_start_addr,app_image_end_addr);
return true;
}
void app_header_update(uint8_t *header)
{
GLOBAL_INT_DISABLE();
FMC_SPI_Flash_Erase_Page(PARAM_ADDR);
FMC_SPI_Flash_WritePage(PARAM_ADDR, header, 256);
GLOBAL_INT_RESTORE();
}
void xc_ota_wdt_init(WDT_InitCfg_t *wdt_cfg)
{
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_pclk_sel__setf(DISABLE);
cpr_lp_ctl__wdt_tclk_en__setf(ENABLE);
wdt_cr__wdt_rmod__setf(wdt_cfg->WorkMode);
wdt_torr__wdt_top__setf(wdt_cfg->ReloadValue);
}
void wdt_reset_system(void)
{
WDT_InitCfg_t wdt_cfg;
NVIC_EnableIRQ(WDT_IRQn);
wdt_cfg.WorkMode = WDT_WORK_MODE0;
wdt_cfg.ReloadValue = WDT_CLK_32M_RESET_MODE0_4096US;
xc_ota_wdt_init(&wdt_cfg);
xc_wdt_start();
while(1);
}
void process_ota(uint8_t *data, uint16_t length) {
volatile uint16_t max_write = 0;
memcpy(&write_buffer[write_index], data, length);
write_index += length;
aes_index_at = write_index;
switch (process_sta) {
case OTA_PROCESS_SEARCH_HEADER:
if (aes_index_at >= sizeof(sBOOT_MESSAGE_OTA))
{
LOGI("write_index=%d\r\n",aes_index_at);
//uint16_t k = 0;
// for(uint16_t i = 0;i<write_index;i++)
// {
// LOGI(" %02x ",write_buffer[i]);
// k++;
// if((k%16 == 0))
// {
// LOGI("\r\n");
// }
// }
uint16_t sotf_v = (write_buffer[1] <<8) +write_buffer[0]; // data
uint16_t rom_v = (write_buffer[3] <<8)+ write_buffer[2];
uint32_t size = (write_buffer[7]<<24)+(write_buffer[6]<<16)+(write_buffer[5]<<8)+write_buffer[4];// data
uint32_t erase_addr = (write_buffer[27+8]<<24)+(write_buffer[26+8]<<16)+(write_buffer[25+8]<<8)+(write_buffer[24+8]); // data
//uint32_t write_addr = (write_buffer[27+8]<<24)+(write_buffer[26+8]<<16)+(write_buffer[25+8]<<8)+(write_buffer[24+8]); // start para
uint32_t app_bin_crc=(write_buffer[11+8]<<24)+(write_buffer[10+8]<<16)+(write_buffer[9+8]<<8)+(write_buffer[8+8]);
LOGI("sotf_v :%x rom_v:%x, size:%x addr:%x app_crc:%x \r\n",sotf_v,rom_v,size,erase_addr,app_bin_crc);
memcpy(head_data_temp,write_buffer+8,256);
if (true == app_header_vailed(write_buffer,head_data_temp))
{
header_app_crc32 = (write_buffer[11+8]<<24)+(write_buffer[10+8]<<16)+(write_buffer[9+8]<<8)+(write_buffer[8+8]);
LOGI("header vaild,app crc =%08x\r\n",header_app_crc32);
should_recived_length = (write_buffer[7]<<24)+(write_buffer[6]<<16)+(write_buffer[5]<<8)+write_buffer[4];// data
app_start_addr = (write_buffer[27+8]<<24)+(write_buffer[26+8]<<16)+(write_buffer[25+8]<<8)+(write_buffer[24+8]); // data
last_erase_block = 0;
process_sta = OTA_PROCESS_DATA_STORE;
aes_index_at = aes_index_at - sizeof(sBOOT_MESSAGE_OTA);
write_index = write_index - sizeof(sBOOT_MESSAGE_OTA);
memcpy(write_buffer, write_buffer + sizeof(sBOOT_MESSAGE_OTA),write_index);
LOGI("new_aes_idx = %d,new_w_idx=%d\r\n",aes_index_at,write_index);
}
else
{
ota_state_restore();
xc_ble_disconnect(app_env.slave_conidx, 0x16);
}
}
break;
case OTA_PROCESS_DATA_STORE:
// LOGI("write_index_all:%d ,aes_index_at:%d should_recived_length: %d \r\n",write_index_all,aes_index_at,should_recived_length);
if ((write_index_all + aes_index_at) < should_recived_length) {
if (aes_index_at >= 1024) {
if(0==(last_erase_block&0x03)){
// LOGI("eraes adddr :%x\r\n",app_start_addr+last_erase_block*1024);
GLOBAL_INT_DISABLE();
FMC_SPI_Flash_Erase_Sector(app_start_addr+last_erase_block*1024);
GLOBAL_INT_RESTORE();
}
last_erase_block ++;
for(uint8_t i = 0;i<4;i++)
{
FMC_SPI_Flash_WritePage(app_start_addr + write_index_all+i*256, write_buffer+i*256, 256);
}
// LOGI("w=%08x\r\n",app_start_addr+write_index_all);
aes_index_at -= 1024;
write_index -= 1024;
write_index_all += 1024;
memcpy(write_buffer, write_buffer + 1024, write_index);
}
}
else
{
LOGI("aes_index_at:%d write_index:%d \r\n",aes_index_at,write_index);
if (aes_index_at == write_index) {
if (0 == (last_erase_block & 0x03)) {
GLOBAL_INT_DISABLE();
FMC_SPI_Flash_Erase_Sector(app_start_addr+last_erase_block*1024);
GLOBAL_INT_RESTORE();
// LOGI("e=%08x\r\n",app_start_addr+last_erase_block*1024);
}
for(uint8_t i = 0;i<4;i++)
{
FMC_SPI_Flash_WritePage(app_start_addr + write_index_all+i*256, write_buffer+i*256, 256);
}
LOGI("write_index_all+write_index=%d\r\n",write_index_all+write_index);
LOGI("app_start_addr=%08x,should_recived_length= %d\r\n",app_start_addr,should_recived_length);
uint32_t crc32_firmware = calc_crc32(app_start_addr,should_recived_length);
LOGI("CRC32 firmware=%08x\r\n",crc32_firmware);
if (crc32_firmware == header_app_crc32) {
app_header_update(head_data_temp);
LOGI("app crc ok\r\n");
wdt_reset_system();
}
else{
LOGI("app crc err\r\n");
ota_state_restore();
xc_ble_disconnect(app_env.slave_conidx, 0x13);
}
}
}
break;
default:
break;
}
}
#if OTA_AES_USED
void reverseArray(uint8_t arr[], uint16_t size) {
uint8_t temp;
for (uint16_t i = 0; i < size / 2; i++) {
temp = arr[i];
arr[i] = arr[size - 1 - i];
arr[size - 1 - i] = temp;
}
}
aes_func_result_cb ota_aes_res(uint8_t status, const uint8_t* aes_res_data, uint32_t src_info)
{
//xc_gpio_write_pin(8, GPIO_PIN_RESET);
// LOGI("src_info:0x%x\n",src_info);
// LOGI("aes_res:");
// for(int i=0;i<16;i++){
// LOGI("%02x-",aes_res_data[i]);
// }LOGI("\n");
reverseArray(aes_res_data,16);
// for(int i=0;i<16;i++){
// LOGI("%02x-",aes_res_data[i]);
// }LOGI("\n");
process_ota(aes_res_data, 16);
// LOGI(".");
// if(!memcmp(aes_res_data,encrypt_val,sizeof(encrypt_val))){
// LOGI("aes right\n");
// }else{
// LOGI("aes error\n");
// }
}
void process_aes_decrypt(void)
{
if((data_save_index - aes_decrypt_index>=16) && aes_decrypt_run)
{
//xc_gpio_write_pin(8, GPIO_PIN_SET);
// LOGI("src data:");
// for(int i=0;i<16;i++){
// LOGI("%02x,",data_save_buffer[i+aes_decrypt_index]);
// }LOGI("\n");
reverseArray(&data_save_buffer[aes_decrypt_index],16);
// for(int i=0;i<16;i++){
// LOGI("%02x,",data_save_buffer[i+aes_decrypt_index]);
// }LOGI("\n");
aes_decrypt(AES_KEY, &data_save_buffer[aes_decrypt_index], 0, ota_aes_res, 0xff);
aes_decrypt_index += 16;
}
}
void process_save_data(uint8_t *data, uint16_t length)
{
aes_decrypt_run = 0;
while(aes_decrypt_index>=160)
{
aes_decrypt_index = aes_decrypt_index - 160;
data_save_index = data_save_index -160;
memcpy(data_save_buffer,data_save_buffer+160,data_save_index);
// LOGI("%d %d %d \r\n",data_save_index,aes_decrypt_index,aes_decrypt_run);
}
memcpy(&data_save_buffer[data_save_index], data, length);
data_save_index += length;
if(data_save_index>=ASE_DATA_BUFFER_SIZE-48)
{
LOGI("data_save_index too large ,error!!!! \r\n");
ota_state_restore();
xc_ble_disconnect(app_env.slave_conidx, 0x16);
}
aes_decrypt_run = 1;
}
#endif
#endif
#endif // (BLE_APP_PRESENT)
project/example/ble/ble_peripheral/app/src/fast_ota.h
+25
View File
@@ -0,0 +1,25 @@
/**
****************************************************************************************
*
* @file usr_server.h
*
* @brief Custom Server profile database definitions.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.
*
****************************************************************************************
*/
#ifndef _FAST_OTA_H_
#define _FAST_OTA_H_
#define OTA_AES_KEY {0x10,0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x0d,0x0c,0x0b};
#define ASE_DATA_BUFFER_SIZE 2048
#define PARAM_ADDR ((8*1024)-512)
typedef enum {
OTA_PROCESS_SEARCH_HEADER,
OTA_PROCESS_DATA_STORE,
} ota_process_state_t;
#endif // _USR_SERVER_H_
project/example/ble/ble_peripheral/app/src/fast_ota_server.c
+245
View File
@@ -0,0 +1,245 @@
/**
****************************************************************************************
*
* @file usr_server.c
*
* @brief Custom Server profile database definitions.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.p
*
****************************************************************************************
*/
#if FAST_OTA
#include "fast_ota_server.h"
#include "fast_ota.h"
#if (BLE_APP_PRESENT)
uint8_t fast_ota_srv_user_lid = GATT_INVALID_USER_LID;
uint16_t fast_ota_svc_start_hdl = GATT_INVALID_HDL;
uint8_t fast_ota_svc_tx_char_notify = DISABLE;
static const gatt_att16_desc_t fast_ota_server_atts[] = {
[FAST_OTA_SVC_DECL] =
{
.uuid16 = GATT_DECL_PRIMARY_SERVICE,
.info = GATT_ATT_RD_BIT,
.ext_info = 0,
},
[FAST_OTA_SVC_TX_CHAR_DECL_CHAR] =
{
.uuid16 = GATT_DECL_CHARACTERISTIC,
.info = GATT_ATT_RD_BIT,
.ext_info = 0,
},
[FAST_OTA_SVC_TX_CHAR_VAL] =
{
.uuid16 = FAST_OTA_SVC_TX_CHAR_UUID,
.info = GATT_ATT_N_BIT| GATT_ATT_WC_BIT | GATT_ATT_WR_BIT,
.ext_info =
GATT_ATT_NO_OFFSET_BIT | FAST_OTA_SVC_TX_CHAR_VAL_MAX_LENGTH,
},
[FAST_OTA_SVC_TX_CHAR_CFG] =
{
.uuid16 = GATT_DESC_CLIENT_CHAR_CFG,
.info = GATT_ATT_RD_BIT | GATT_ATT_WR_BIT,
.ext_info = 0,
},
[FAST_OTA_SVC_RX_CHAR_DECL_CHAR] =
{
.uuid16 = GATT_DECL_CHARACTERISTIC,
.info = GATT_ATT_RD_BIT,
.ext_info = 0,
},
[FAST_OTA_SVC_RX_CHAR_VAL] =
{
.uuid16 = FAST_OTA_SVC_RX_CHAR_UUID,
.info = GATT_ATT_WC_BIT | GATT_ATT_WR_BIT,
.ext_info =
GATT_ATT_NO_OFFSET_BIT | FAST_OTA_SVC_RX_CHAR_VAL_MAX_LENGTH,
},
};
extern unsigned int get_crc32(unsigned int crc, unsigned char *buf, unsigned int len);
extern void wdt_reset_system(void);
extern void process_ota(uint8_t *data, uint16_t length);
extern __RAM_CODE void xc_fmc_spi_init_oprt(void);
extern __RAM_CODE void xc_fmc_spi_flash_wake_up(void);
extern __RAM_CODE void xc_fmc_spi_flash_read_page(uint32_t addr, uint8_t *data, uint16_t size);
extern __RAM_CODE void xc_fmc_spi_flash_erase_page(uint32_t addr);
extern __RAM_CODE void xc_fmc_spi_flash_write_page(uint32_t addr, uint8_t *data, uint16_t size);
void enter_ota_mode()
{
printf("%s\n", __func__);
xc_fmc_spi_init_oprt();
xc_fmc_spi_flash_wake_up();
uint8_t para_buf[256];
uint8_t data[256];
xc_fmc_spi_flash_read_page(((8*1024)-512), para_buf, FLASH_PAGE_SIZE);
para_buf[0]=0x00;
para_buf[48]=0x01;
para_buf[96]=0x00;
uint32_t crc =0;
crc=get_crc32(crc,para_buf,240);
para_buf[243]=crc>>24;
para_buf[242]=crc>>16;
para_buf[241]=crc>>8;
para_buf[240]=crc;
GLOBAL_INT_DISABLE();
xc_fmc_spi_flash_erase_page(0x1e00);
xc_fmc_spi_flash_erase_page(0x1f00);
GLOBAL_INT_RESTORE();
GLOBAL_INT_DISABLE();
xc_fmc_spi_flash_write_page(((8*1024)-512), para_buf, 256);
GLOBAL_INT_RESTORE();
for(int i=0; i<256; i+=2){
data[i] = para_buf[i+1];
data[i+1] = para_buf[i];
}
GLOBAL_INT_DISABLE();
xc_fmc_spi_flash_write_page(((8*1024)-256), data, 256);
GLOBAL_INT_RESTORE();
xc_fmc_spi_flash_read_page(((8*1024)-256), para_buf, FLASH_PAGE_SIZE);
xc_fmc_spi_flash_read_page(((8*1024)-512), para_buf, FLASH_PAGE_SIZE);
wdt_reset_system();
}
uint8_t fast_ota_slave_send_data(uint8_t *data, uint8_t len, uint8_t att_idx);
uint16_t fast_ota_srv_get_hdl_from_att_idx(uint8_t idx)
{
return fast_ota_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 fast_ota_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 fast_ota_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[512] = {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);
}
}
uint8_t upd_flag = 1;
// This function is called during a write procedure to modify attribute handle.
__STATIC void fast_ota_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)[0]), length);
if (hdl == fast_ota_srv_get_hdl_from_att_idx(FAST_OTA_SVC_TX_CHAR_CFG)) {
if ((co_buf_data(p_data)[0] == 0) && (co_buf_data(p_data)[1] == 0)) {
fast_ota_svc_tx_char_notify = DISABLE;
} else {
fast_ota_svc_tx_char_notify = ENABLE;
}
}
#if !SINGLE_OTA
if(upd_flag)
{
xc_ble_update_param(conidx, 9, 12,0, 400);
upd_flag = 0;
}
#endif
#if SINGLE_OTA
if ((hdl == fast_ota_srv_get_hdl_from_att_idx(FAST_OTA_SVC_TX_CHAR_VAL)) && (length == 1))
{
if(co_buf_data(p_data)[0] == SINGLE_OTA_ENTER_CMD)
{
LOGI(" enter single ota mode\r\n");
enter_ota_mode();
}
}
#endif
#if !SINGLE_OTA
if (hdl == fast_ota_srv_get_hdl_from_att_idx(FAST_OTA_SVC_RX_CHAR_VAL))
{
#if OTA_AES_USED
process_save_data(&(co_buf_data(p_data)[0]), length);
#else
process_ota(&(co_buf_data(p_data)[0]), length);
#endif
}
#endif
}
static const gatt_srv_cb_t fast_ota_svc_cb = {
.cb_event_sent = fast_ota_svc_cb_event_sent,
.cb_att_read_get = fast_ota_svc_cb_att_read_get,
.cb_att_val_set = fast_ota_svc_cb_att_val_set,
};
uint8_t fast_ota_svc_add(void)
{
int nb_att = sizeof(fast_ota_server_atts) / sizeof(fast_ota_server_atts[0]);
uint16_t status;
uint16_t svc_uuid = FAST_OTA_SVC_UUID;
status = xc_ble_gatt_user_srv_register(133, 0, &fast_ota_svc_cb, &fast_ota_srv_user_lid);
if (status != GATT_NO_ERROR) {
LOGI_ERR("gatt_user_srv_register error 0x%x", status);
}
status = xc_ble_gatt_service16_add(
fast_ota_srv_user_lid, GATT_UUID_16 << GATT_SVC_UUID_TYPE_LSB, svc_uuid,
nb_att, NULL, &(fast_ota_server_atts[0]), nb_att, &fast_ota_svc_start_hdl);
if (status != GATT_NO_ERROR) {
LOGI_ERR("gatt_service16_add error 0x%x", status);
}
return status;
}
uint8_t fast_ota_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 && fast_ota_svc_tx_char_notify) {
status = xc_ble_gatt_srv_notify(app_env->slave_conidx, fast_ota_srv_user_lid, 0,
fast_ota_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;
}
#endif // (BLE_APP_PRESENT)
#endif
project/example/ble/ble_peripheral/app/src/fast_ota_server.h
+42
View File
@@ -0,0 +1,42 @@
/**
****************************************************************************************
*
* @file usr_server.h
*
* @brief Custom Server profile database definitions.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.
*
****************************************************************************************
*/
#ifndef _FAST_OTA_SERVER_H_
#define _FAST_OTA_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 FAST_OTA_SVC_UUID 0xFFF6
#define FAST_OTA_SVC_TX_CHAR_UUID 0xFFF7
#define FAST_OTA_SVC_RX_CHAR_UUID 0xFFF8
#define FAST_OTA_SVC_RX_CHAR_VAL_MAX_LENGTH 512
#define FAST_OTA_SVC_TX_CHAR_VAL_MAX_LENGTH 512
#define SINGLE_OTA_ENTER_CMD 1
enum cust_svc
{
FAST_OTA_SVC_DECL = 0,
FAST_OTA_SVC_TX_CHAR_DECL_CHAR,
FAST_OTA_SVC_TX_CHAR_VAL,
FAST_OTA_SVC_TX_CHAR_CFG,
FAST_OTA_SVC_RX_CHAR_DECL_CHAR,
FAST_OTA_SVC_RX_CHAR_VAL,
};
uint8_t fast_ota_svc_add(void);
#endif // _USR_SERVER_H_
project/example/ble/ble_peripheral/app/src/fft.c
-159
View File
@@ -1,159 +0,0 @@
#ifndef _FFT_C_
#define _FFT_C_
#include <math.h>
#include <stdio.h>
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define FFTN 32 //fft的点数
#define PWE 5 //2^PWE=NFFT
#define LEN FFTN*2
#define FRE 2000 //采样频率
#define RS 62.5 //分辨率=FRE/FFTN
#define M_PI 3.14159265358979323846
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Local Variables
-------------------------------------------------------------------------------------*/
//由于一个点是复数，因此用偶数脚标表示实部，奇数脚标表示虚部
float fft_input[LEN] = {0,0,1,0,2,0,3,0,4,0,5,0,6,0,7,0,
8,0,9,0,10,0,11,0,12,0,13,0,14,0,15,0,
16,0,17,0,18,0,19,0,20,0,21,0,22,0,23,0,
24,0,25,0,26,0,27,0,28,0,29,0,30,0,31,0};
float fft_output[LEN];
float MAX[2]; //保存最后得出的结果
/*------------------------------------------------------------------------------------
Function
-------------------------------------------------------------------------------------*/
//void main(void)
//{
// int i;
// clock_t begin, end;
//
// begin = clock();
// ReverseArrange(); //倒序
// Redix2FFT(); //FFT变换
// end = clock();
// printf("%lfs\n",(double)(end-begin)/CLOCKS_PER_SEC);
//}
/*倒序函数，将fft_input进行逆向排序
* 0 1 2 3 4 5 6 7
倒序前脚标： 0-1 2-3 4-5 6-7 8-9 10-11 12-13 14-15
0 4 2 6 1 5 3 7
倒序后脚标： 0-1 8-9 4-5 12-13 2-3 10-11 6-7 14-15
*/
//其中：2^PWE=NFFT，PWE表示次幂，即脚标由几位二进制组成
int ReverseArrange(void)
{
int8_t i,j;
int8_t tmp = 0x00; //用来表示脚标
//先给第一个复数赋值
fft_output[0] = fft_input[0];
fft_output[1] = fft_input[1];
//对剩下的数进行倒序
for(i=0;i<(FFTN-1)*2;i+=2){
j = PWE-1; //得出需要左移的位数
//逆向二进制加法
while((tmp & (1<<j)) != 0){
tmp &= ~(1<<j); //把第j位置零
j--;
}
tmp |= (1<<j); //这里最后得出的是：0 4 2 6 1 5 3 7
fft_output[i+2] = fft_input[tmp*2]; //按照新的顺序给输出赋值
fft_output[i+3] = fft_input[tmp*2+1];
}
return 1;
}
/*基2fft运算，需先将fft_input倒序输入到fft_out中*/
int Redix2FFT(void)
{
int8_t layer; //表示FFT的层数
int8_t pmul; //= 2^(PWE - layer)，表示当前层中需要进行几次小FFT，FFTN/pmul表示当前小FFT的点数
int8_t i; //表示正在进行第几次小FFT
int8_t j; //= 2^(layer - 1)，表示当前层小FFT中蝶形运算的次数
int8_t k; //每次小FFT中，正在进行第几次蝶形运算
int8_t currentBase; //表示当前层的小FFT中，第一个元素的脚标
int8_t current; //=currentBase + k，表示当前需要进行蝶形运算的元素的脚标
int8_t another; //=current + j，表示当前需要进行蝶形运算的元素的脚标
int8_t m;
float Re,Im; //实部、虚部的暂存区
float TPOA; //=2 * pi / FFTN，FFT旋转因子WNK的w值
float TPOATP;//=TPOA * pmul，表示小FFT中WNK的w值
float reFactor,imFactor; //=cos(TPOATP * k)，=-sin(TPOATP * k)，表示WNK的实部和虚部
//下面的注释假设FFTN=8
TPOA = 2 * M_PI / FFTN; //TPOA = PI/4
for(layer=1;layer<=PWE;layer++){ //layer = 1,2,3
j = 0x01<<(layer-1); //使用math中的pow()会出现bug，使用左移运算减轻计算量
pmul = 0x01<<(PWE - layer);
for(i=0;i<pmul;i++){ //pmul=4时，i = 0,1,2,3
currentBase = i * 4 *j; //j = 1时，currentBase = 0,4,8,12
TPOATP = TPOA * pmul; //pmul=4时，TPOATP = PI
for(k=0;k<j;k++){ //j=1时，k=0
current = currentBase + k*2; //current = 0,4,8,12;
another = current + j*2; //another = 2,6,10,14;
//准备WNK
reFactor = cos(TPOATP * k); //1
imFactor = -sin(TPOATP * k);//0
//乘上WNK
Re = fft_output[another]; //备份实部
fft_output[another] = fft_output[another] * reFactor
- fft_output[another+1] * imFactor; //fft_output[2] = 8
fft_output[another+1] = fft_output[another+1] * reFactor
+ Re * imFactor; //fft_output[3] = 0
//蝶形加法
Re = fft_output[current]; //Re=0
Im = fft_output[current+1]; //Im=0
fft_output[current] += fft_output[another]; //fft_output[0] = 8;
fft_output[current+1] += fft_output[another+1]; //fft_output[1] = 0
fft_output[another] = Re - fft_output[another]; //fft[2] = -8
fft_output[another+1] = Im - fft_output[another+1]; //fft[3] = 0
}
}
}
for(m = 0; m < LEN; m += 2) {
// printf("[%d]: %f+%fi\n", m/2, fft_output[m], fft_output[m+1]);
}
}
/* 输出整合，计算出每个频率的幅值，取出幅值最大的点
*/
void IntegrateData(void)
{
//计算复数的模，注意，所有的模都存到偶数项中
//fft_output[0] = sqrt(fft_output[0]*fft_output[0]+fft_output[1]*fft_output[1])/FFTN;
fft_output[LEN-2] = sqrt(fft_output[LEN-2]*fft_output[LEN-2]+fft_output[LEN-1]*fft_output[LEN-1])/FFTN;
for(uint8_t i=2;i<(LEN-2);i+=2){ //最后一个点和第一个点已单独处理
fft_output[i] = 2*sqrt(fft_output[i]*fft_output[i]+fft_output[i+1]*fft_output[i+1])/FFTN;
}
//找出其中模长最大的值，记录脚标和模长
MAX[0] = 2; //脚标
MAX[1] = fft_output[2]; //模长
for(uint8_t i=4;i<LEN;i+=2){
if(MAX[1]<fft_output[i]){ //替换
MAX[0] = i;
MAX[1] = fft_output[i];
}
}
}
#endif
project/example/ble/ble_peripheral/app/src/fft.h
-21
View File
@@ -1,21 +0,0 @@
#ifndef _FFT_H_
#define _FFT_H_
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
int ReverseArrange(void);
int Redix2FFT(void);
void IntegrateData(void);
#endif
project/example/ble/ble_peripheral/app/src/gpio.c
-261
View File
@@ -1,261 +0,0 @@
/*!
* \file gpio.c
*
* \brief Target gpio implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "gpio.h"
#include "xc_drv_gpio.h"
#include "nec_infrared.h"
#include "dbg.h"
#include "key.h"
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
//uint8_t gpio_intr_flag = false;
//uint64_t intr_val = 0;
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
* @brief gpio_demo
* @details
* @param void
* @retval void
*/
void gpio_demo(void)
{
// DEBUG("__GPIO_DEMO__\r");
// GPIO_InitCfg_t GPIO_InitCfg = { 0 };
// GPIO_InitCfg.Mux = GPIO_Mux0;
// GPIO_InitCfg.FunSel = GPIO_Dx;
// GPIO_InitCfg.Pull = GPIO_PULLUP;
// // Board KEY_MODE Initialization
// GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
// GPIO_InitCfg.Int = NOT_INT;
// GPIO_InitCfg.Pin = KEY_MODE;
// xc_gpio_init(&GPIO_InitCfg);
// // Board KEY_UP Initialization
// GPIO_InitCfg.Pin = KEY_UP;
// xc_gpio_init(&GPIO_InitCfg);
// // Board KEY_DOWN Initialization
// GPIO_InitCfg.Pin = KEY_DOWN;
// xc_gpio_init(&GPIO_InitCfg);
// // Gpio NVIC Enable
// NVIC_EnableIRQ(GPIO_IRQn);
}
void feedback(void)
{
//LOGI("LED3_PIN:%d",xc_gpio_read_pin(LED3_PIN));
}
///**
// * @brief gpio_intr_callback
// * @details Gpio interrupt callback function
// * @param void
// * @retval void
// */
//__RAM_CODE void gpio_intr_callback(uint64_t intr_sta)
//{
// intr_val = intr_sta;
// gpio_intr_flag = true;
// // Determine the interrupt of IRINPUT_PIN
// if((intr_sta & (1 << IR_PIN)) != 0)
// {
// ir_callback();
// }
//}
//void gpio_pulldown_input_test(void)
//{
// //input test
// GPIO_InitCfg_t GPIO_InitCfg = { 0 };
// GPIO_InitCfg.Mux = GPIO_Mux0;
// GPIO_InitCfg.FunSel = GPIO_Dx;
// GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
// GPIO_InitCfg.Int = NOT_INT;
// GPIO_InitCfg.Pull = GPIO_PULLDOWN;
// for(uint8_t i = 0;i < 8; i++)
// {
// GPIO_InitCfg.Pin = i;
// xc_gpio_init(&GPIO_InitCfg);
// }
// while(1)
// {
// for(uint8_t i = 0;i < 8; i++)
// {
// DEBUG("gaio [%d] Val: %d\r\n", i,xc_gpio_read_pin(i));
// for(int i=0;i<0x45500;i++);
// }
//
// }
//}
//void gpio_pullup_input_test(void)
//{
// //input test
// GPIO_InitCfg_t GPIO_InitCfg = { 0 };
// GPIO_InitCfg.Mux = GPIO_Mux0;
// GPIO_InitCfg.FunSel = GPIO_Dx;
// GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
// GPIO_InitCfg.Int = NOT_INT;
// GPIO_InitCfg.Pull = GPIO_PULLUP;
// for(uint8_t i = 0;i < 8; i++)
// {
// GPIO_InitCfg.Pin = i;
// xc_gpio_init(&GPIO_InitCfg);
// }
// while(1)
// {
// for(uint8_t i = 0;i < 8; i++)
// {
// DEBUG("gaio [%d] Val: %d\r\n", i,xc_gpio_read_pin(i));
// for(int i=0;i<0x45500;i++);
// }
//
// }
//}
//void gpio_nopull_input_test(void)
//{
// //input test
// GPIO_InitCfg_t GPIO_InitCfg = { 0 };
// GPIO_InitCfg.Mux = GPIO_Mux0;
// GPIO_InitCfg.FunSel = GPIO_Dx;
// GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
// GPIO_InitCfg.Int = NOT_INT;
// GPIO_InitCfg.Pull = GPIO_NOPULL;
// for(uint8_t i = 0;i < 8; i++)
// {
// GPIO_InitCfg.Pin = i;
// xc_gpio_init(&GPIO_InitCfg);
// }
// while(1)
// {
// for(uint8_t i = 0;i < 8; i++)
// {
// DEBUG("gaio [%d] Val: %d\r\n", i,xc_gpio_read_pin(i));
// for(int i=0;i<0x45500;i++);
// }
//
// }
//}
//void gpio_pulldown_input_inter_test(void)
//{
// //input test
// GPIO_InitCfg_t GPIO_InitCfg = { 0 };
// GPIO_InitCfg.Mux = GPIO_Mux0;
// GPIO_InitCfg.FunSel = GPIO_Dx;
// GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
// GPIO_InitCfg.Int = RIS_EDGE_INT;
// GPIO_InitCfg.Pull = GPIO_PULLDOWN;
// for(uint8_t i = 0;i < 8; i++)
// {
// GPIO_InitCfg.Pin = i;
// xc_gpio_init(&GPIO_InitCfg);
// }
// // Gpio NVIC Enable
// NVIC_EnableIRQ(GPIO_IRQn);
//
// while(1)
// {
// if(gpio_intr_flag == true)
// {
// DEBUG("Intr Status Val: 0x%016llx\n", intr_val);
// gpio_intr_flag = false;
// }
// }
//}
//void gpio_pullup_input_inter_test(void)
//{
// //input test
// GPIO_InitCfg_t GPIO_InitCfg = { 0 };
// GPIO_InitCfg.Mux = GPIO_Mux0;
// GPIO_InitCfg.FunSel = GPIO_Dx;
// GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
// GPIO_InitCfg.Int = FAIL_EDGE_INT;
// GPIO_InitCfg.Pull = GPIO_PULLUP;
// for(uint8_t i = 0;i < 8; i++)
// {
// GPIO_InitCfg.Pin = i;
// xc_gpio_init(&GPIO_InitCfg);
// }
// // Gpio NVIC Enable
// NVIC_EnableIRQ(GPIO_IRQn);
//
// while(1)
// {
// if(gpio_intr_flag == true)
// {
// DEBUG("Intr Status Val: 0x%016llx\n", intr_val);
// gpio_intr_flag = false;
// }
// }
//}
//void gpio_output_test(void)
//{
// GPIO_InitCfg_t GPIO_InitCfg = { 0 };
// GPIO_InitCfg.Mux = GPIO_Mux0;
// GPIO_InitCfg.FunSel = GPIO_Dx;
// GPIO_InitCfg.Pull = GPIO_PULLDOWN;
// GPIO_InitCfg.Dir = GPIO_DIR_OUTPUT;
// GPIO_InitCfg.Int = NOT_INT;
// for(uint8_t i = 0;i < 8; i++)
// {
// GPIO_InitCfg.Pin = i;
// xc_gpio_init(&GPIO_InitCfg);
// xc_gpio_write_pin(i,GPIO_PIN_RESET);
// }
// for(int i=0;i<0x455000;i++);
// for(uint8_t i = 0;i < 8; i++)
// {
// xc_gpio_write_pin(i,GPIO_PIN_SET);
// }
// for(int i=0;i<0x455000;i++);
// for(uint8_t i = 0;i < 8; i++)
// {
// GPIO_InitCfg.Pin = i;
// xc_gpio_init(&GPIO_InitCfg);
// xc_gpio_write_pin(i,GPIO_PIN_RESET);
// }
//}
project/example/ble/ble_peripheral/app/src/gpio.h
-71
View File
@@ -1,71 +0,0 @@
/*!
* \file gpio.h
*
* \brief The head file of gpio.c
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __GPIO_H__
#define __GPIO_H__
#ifdef __cplusplus
extern "C" {
#endif
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
//#define LED1_PIN GPIO_6
//#define LED2_PIN GPIO_24
//#define LED3_PIN GPIO_10
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void gpio_demo(void);
void feedback(void);
#ifdef __cplusplus
}
#endif
#endif /* __GPIO_H__ */
project/example/ble/ble_peripheral/app/src/key.c
-224
View File
@@ -1,224 +0,0 @@
/*!
* \file key.c
*
* \brief Target key implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "xc_drv_gpio.h"
#include "xc60xx.h"
#include "key.h"
#include "message.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define IS_KEY_DOWN(n) (!(xc_gpio_read_pin(n)))
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
static uint16_t last_key_val = NO_KEY;
static uint16_t key_down_count = 0;
static uint16_t key_up_count = 0;
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
* @brief app_key_hold_detection
* @details
* @param curren_key_val
* @retval key_num
*/
__RAM_CODE uint16_t app_key_hold_detection(uint16_t curren_key_val)
{
uint16_t key_num = NO_KEY;
if (key_down_count < 0xff)
key_down_count++;
if (key_down_count == KEY_DOWN_TIMER)
{
key_num = (curren_key_val | KEY_SHORT_DOWN); // shor key
}
else if(key_down_count == KEY_LONG_TIMER)
{
key_num = (curren_key_val | KEY_LONG_DOWN); // loog key
}
key_up_count = 0;
return key_num;
}
/**
* @brief app_new_key_detection
* @details key up or new key detection
* @param curren_key_val
* @retval key_num
*/
__RAM_CODE uint16_t app_new_key_detection(uint16_t curren_key_val)
{
uint16_t key_num = NO_KEY;
key_up_count++;
if (key_up_count >= KEY_UP_TIMER)
{
if (key_down_count >= KEY_LONG_TIMER)
{
key_num = (last_key_val | KEY_LONG_UP); // long key up
last_key_val = 0;
}
else if (key_down_count >= KEY_DOWN_TIMER && key_down_count < KEY_LONG_TIMER)
{
key_num = (last_key_val | KEY_SHORT_UP); // shor key up
last_key_val = 0;
}
key_down_count = 0;
key_up_count = 0;
}
if ((curren_key_val && curren_key_val != last_key_val))
{
if (key_down_count >= KEY_LONG_TIMER)
{
key_num = (last_key_val | KEY_LONG_UP); // long key up
}
else if (key_down_count >= KEY_DOWN_TIMER && key_down_count < KEY_LONG_TIMER)
{
key_num = (last_key_val | KEY_SHORT_UP); // shor key up
}
last_key_val = curren_key_val;
key_down_count = 0;
key_up_count = 0;
}
return key_num;
}
/**
* @brief key_check_process
* @details
* @param curren_key_val
* @retval key_num
*/
__RAM_CODE uint16_t key_check_process(uint16_t curren_key_val)
{
uint16_t key_num = NO_KEY;
if ( curren_key_val == last_key_val && last_key_val != NO_KEY )
{
key_num = app_key_hold_detection(curren_key_val);
}
else
{
key_num = app_new_key_detection(curren_key_val);
}
return key_num;
}
/**
* @brief gpio_key_check
* @details
* @param void
* @retval key_num
*/
uint16_t gpio_key_check(void)
{
uint16_t key_val = NO_KEY;
if ( IS_KEY_DOWN(KEY_MODE) )
{
key_val = REC_KEY;
}
else if( IS_KEY_DOWN(KEY_UP) )
{
key_val = REC_KEY_UP;
}
else if( IS_KEY_DOWN(KEY_DOWN) )
{
key_val = REC_KEY_DOWN;
}
return key_val;
}
/**
* @brief key_check_process
* @details key scan and send
* @param void
* @retval void
*/
void app_key_scan(void)
{
uint16_t key_num = NO_KEY;
uint16_t key_val = NO_KEY;
key_val = gpio_key_check();
key_num = key_check_process(key_val);
if (key_num != NO_KEY)
{
app_key_message_send( key_num );
}
}
/**
* @brief app_key_init
* @details key init
* @param void
* @retval void
*/
void app_key_init(void)
{
GPIO_InitCfg_t GPIO_InitCfg = {0};
GPIO_InitCfg.Mux = GPIO_Mux0;
GPIO_InitCfg.FunSel = GPIO_Dx;
GPIO_InitCfg.Pull = GPIO_PULLUP;
GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
GPIO_InitCfg.Int = NOT_INT;
GPIO_InitCfg.Pin = KEY_MODE;
xc_gpio_init(&GPIO_InitCfg);
GPIO_InitCfg.Pin = KEY_UP;
xc_gpio_init(&GPIO_InitCfg);
GPIO_InitCfg.Pin = KEY_DOWN;
xc_gpio_init(&GPIO_InitCfg);
}
project/example/ble/ble_peripheral/app/src/key.h
-101
View File
@@ -1,101 +0,0 @@
/*!
* \file key.h
*
* \brief The head file of key.c
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __KEY_H__
#define __KEY_H__
#ifdef __cplusplus
extern "C"
{
#endif
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define KEY_MODE GPIO_18
#define KEY_UP GPIO_19
#define KEY_DOWN GPIO_5
#define KEY_DOWN_TIMER 10
#define KEY_LONG_TIMER 20
#define KEY_LOH_TIMER 20
#define KEY_UP_TIMER 10
// KEY NUM 0- 255
#define KEY_NUM1 0X0001
#define KEY_NUM2 0X0002
#define KEY_NUM3 0X0004
#define KEY_SHORT_DOWN 0X0000
#define KEY_SHORT_UP 0X0100
#define KEY_LONG_DOWN 0X0200
#define KEY_LONG_UP 0X0400
#define NO_KEY 0
#define REC_KEY KEY_NUM1
#define REC_KEY_UP KEY_NUM2
#define REC_KEY_DOWN KEY_NUM3
#define REC_KEY_SHORT_DOWN (REC_KEY | KEY_SHORT_DOWN)
#define REC_KEY_SHORT_UP (REC_KEY | KEY_SHORT_UP)
#define REC_KEY_LONG_DOWN (REC_KEY | KEY_LONG_DOWN)
#define REC_KEY_LONG_UP (REC_KEY | KEY_LONG_UP)
#define REC_KEY_UP_SHORT_DOWN (REC_KEY_UP | KEY_SHORT_DOWN)
#define REC_KEY_UP_SHORT_UP (REC_KEY_UP | KEY_SHORT_UP)
#define REC_KEY_UP_LONG_DOWN (REC_KEY_UP | KEY_LONG_DOWN)
#define REC_KEY_UP_LONG_UP (REC_KEY_UP | KEY_LONG_UP)
#define REC_KEY_DOWN_SHORT_DOWN (REC_KEY_DOWN | KEY_SHORT_DOWN)
#define REC_KEY_DOWN_SHORT_UP (REC_KEY_DOWN | KEY_SHORT_UP)
#define REC_KEY_DOWN_LONG_DOWN (REC_KEY_DOWN | KEY_LONG_DOWN)
#define REC_KEY_DOWN_LONG_UP (REC_KEY_DOWN | KEY_LONG_UP)
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void app_key_init(void);
void app_key_scan(void);
#ifdef __cplusplus
}
#endif
#endif /* __KEY_H__ */
project/example/ble/ble_peripheral/app/src/mcu_bridge.c
+56
View File
@@ -0,0 +1,56 @@
#include "mcu_bridge.h"
#include <stdbool.h>
#include "uart.h"
typedef struct {
uint8_t r_value;
uint8_t g_value;
uint8_t b_value_mode_speed_brightness;
uint8_t type;
} mcu_bridge_packet_t;
static volatile bool packet_pending;
static mcu_bridge_packet_t pending_packet;
/* These callbacks replace the weak callbacks supplied by usr_server.c. */
void ble_callback(uint8_t value0, uint8_t value1, uint8_t value2, uint8_t value3)
{
pending_packet.r_value = value0;
pending_packet.g_value = value1;
pending_packet.b_value_mode_speed_brightness = value2;
pending_packet.type = value3;
packet_pending = true;
}
void ble_diy_callback(uint8_t value, uint8_t *color, uint8_t length)
{
pending_packet.type = value;
if (length > 1) {
pending_packet.r_value = color[1];
}
if (length > 2) {
pending_packet.g_value = color[2];
}
if (length > 3) {
pending_packet.b_value_mode_speed_brightness = color[3];
}
packet_pending = true;
}
void mcu_bridge_process(void)
{
uint8_t data[4];
if (!packet_pending) {
return;
}
data[0] = pending_packet.r_value;
data[1] = pending_packet.g_value;
data[2] = pending_packet.b_value_mode_speed_brightness;
data[3] = pending_packet.type;
packet_pending = false;
scan_uart(data);
}
project/example/ble/ble_peripheral/app/src/mcu_bridge.h
+8
View File
@@ -0,0 +1,8 @@
#ifndef MCU_BRIDGE_H_
#define MCU_BRIDGE_H_
#include <stdint.h>
void mcu_bridge_process(void);
#endif
project/example/ble/ble_peripheral/app/src/message.c
-123
View File
@@ -1,123 +0,0 @@
/*!
* \file key.c
*
* \brief Target key implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "message.h"
#include "xc6xxx.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define MESSAGE_MAX 40
#define MSG_ADD_MAX(msg) (msg >= MESSAGE_MAX) ? (MESSAGE_MAX) : (msg+1)
#define MSG_REDUCE_MIN(msg) (msg) ? (msg - 1) : 0
#define MSG_LOOP_MAX_MIN(msg) (msg >= MESSAGE_MAX) ? (0) : (msg)
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
uint16_t message_buff[MESSAGE_MAX] = {0};
volatile uint16_t message_in_count = 0;
volatile uint16_t message_out_index = 0;
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
* @brief app_key_message_send
* @details key msg send
* @param void
* @retval void
*/
void app_key_message_send(uint16_t msg)
{
if (message_in_count >= MESSAGE_MAX )
{
return;
}
for(uint8_t i = 0; i < MESSAGE_MAX ; i++)
{
if (message_buff[i] == 0)
{
message_buff[i] = msg;
message_in_count++;
break;
}
}
}
/**
* @brief app_key_message_get
* @details get key msg
* @param void
* @retval void
*/
uint16_t app_key_message_get(void)
{
uint16_t msg = 0;
if (!message_in_count)
{
message_out_index = 0;
return msg;
}
for(uint8_t i = 0; i < MESSAGE_MAX ; i++)
{
if (message_buff[message_out_index])
{
msg = message_buff[message_out_index];
message_buff[message_out_index] = 0;
message_out_index = MSG_ADD_MAX(message_out_index);
message_out_index = MSG_LOOP_MAX_MIN(message_out_index);
message_in_count = MSG_REDUCE_MIN(message_in_count);
break;
}
message_out_index = MSG_ADD_MAX(message_out_index);
message_out_index = MSG_LOOP_MAX_MIN(message_out_index);
}
return msg;
}
/**
* @brief app_key_message_clr
* @details clear key msg
* @param void
* @retval void
*/
void app_key_message_clr(void)
{
memset(message_buff,0x00,MESSAGE_MAX);
message_in_count = 0;
}
project/example/ble/ble_peripheral/app/src/message.h
-64
View File
@@ -1,64 +0,0 @@
/*!
* \file key_message.h
*
* \brief The head file of key_message.c
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip )
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __KEY_MESSAGE_H__
#define __KEY_MESSAGE_H__
#ifdef __cplusplus
extern "C"
{
#endif
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void app_key_message_send(uint16_t msg);
uint16_t app_key_message_get(void);
void app_key_message_clr(void);
#ifdef __cplusplus
}
#endif
#endif /* __KEY_MESSAGE_H__ */
project/example/ble/ble_peripheral/app/src/nec_infrared.c
-207
View File
@@ -1,207 +0,0 @@
/*!
* \file nec_infrared.c
*
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "xc6xxx.h"
#include "gpio.h"
#include "nec_infrared.h"
#include "xc_drv_gpio.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
IR_struct IR = {0};
//uint8_t gpio_intr_flag = false;
uint64_t intr_val = 0;
extern uint8_t only_read_charactertics_buffer[];
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
* @brief gpio_demo
* @details
* @param void
* @retval void
*/
void app_ir_init(void)
{
// Board IrInput Initialization
GPIO_InitCfg_t GPIO_InitCfg = { 0 };
GPIO_InitCfg.Mux = GPIO_Mux0;
GPIO_InitCfg.FunSel = GPIO_Dx;
GPIO_InitCfg.Pull = GPIO_PULLUP;
GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
GPIO_InitCfg.Int = RIS_FAIL_EDGE_INT;
GPIO_InitCfg.Pin = IR_PIN;
xc_gpio_init(&GPIO_InitCfg);
// Gpio NVIC Enable
NVIC_EnableIRQ(GPIO_IRQn);
}
/**
* @brief gpio_intr_callback
* @details Gpio interrupt callback function
* @param void
* @retval void
*/
__RAM_CODE void gpio_intr_callback(uint64_t intr_sta)
{
intr_val = intr_sta;
if ((intr_sta & (1 << IR_PIN)) != 0)
{
ir_callback();
}
}
/**
* @brief This function handles EXIT Interrupt .
*/
void ir_callback(void)
{
uint32_t us = 20000;
IR.timer_count = 640 - timer_tcv_get(TIMER2_IDX); //每次进外部中断,先保存当前的计数值 CNT加1的时间为31.25us
static uint8_t acunt = 0;
acunt++;
if (acunt == 255)
acunt = 0;
xc_timer_stop(TIMER2_IDX);
if (xc_gpio_read_pin(IR_PIN) == 1) //检查PA5电平 上升沿 IR.timer_count的值为上一个下降沿到这次的上升沿,中间的间隔时间(即低电平时间)
{
if (IR.IR_event == 0 && IR.f_head == 0) //既没有开始接受01数据，也没有开始接受头码，那么进入接收头码判断
{
if (IR.timer_count > 280 && IR.timer_count < 296) //头码为9ms的低电平,允许误差100us
{
IR.f_head = 1; //如果符合,开始判定头码
}
else if (IR.timer_count > 296) //如果头码已经大于9.1ms 认为是错误
{
IR.f_head = 0;
IR.IR_decode_bit = 0; //电平计数超过了码元长度 清除位数计数
IR.IR_code = 0;
IR.IR_event = 0;
IR.IR_code_get = 0;
IR.low_8bit = 0;
IR.hig_8bit = 0;
IR.rece_ok = 0;
}
}
else if (IR.IR_event == 1) //如果头码判定正确,开始接受01数据
{
if (IR.timer_count > 12 && IR.timer_count < 25) //所有的01数据,开头都是0.56ms的低电平
{
IR.get_bit = 1; //如果符合,那么开始根据后面的高电平时间来判定此次为0还是1
}
else //否则清除所有数据
{
IR.f_head = 0;
IR.IR_decode_bit = 0; //电平计数超过了码元长度 清除位数计数
IR.IR_code = 0;
IR.IR_event = 0;
IR.IR_code_get = 0;
IR.low_8bit = 0;
IR.hig_8bit = 0;
IR.rece_ok = 0;
}
}
}
else //上一个上升沿到这次的下降沿，之间的时间间隔(即高电平时间)
{
if (IR.f_head == 1) //如果9ms的低电平成立了,开始判断是否有4.5ms的高电平时间
{
if (IR.timer_count > 135 && IR.timer_count < 153)
{
IR.IR_event = 1; //4.5ms成立,认为此次的头码成立,开始接收01数据
}
else
{
IR.IR_decode_bit = 0; //电平计数超过了码元长度 清除位数计数
IR.IR_code = 0;
IR.IR_event = 0;
IR.IR_code_get = 0;
IR.low_8bit = 0;
IR.hig_8bit = 0;
IR.rece_ok = 0;
}
IR.f_head = 0; //清除接受头码标志
}
if (IR.IR_event == 1) //接收数据内容成立
{
if (IR.get_bit == 1) //如果0.56ms的低电平已经成立,那么开始判断这次的高电平时间
{
if (IR.timer_count > 12 && IR.timer_count < 25) //0.56ms低+0.56ms高,说明传输的数据为 0
{
IR.IR_code <<= 1;
IR.IR_decode_bit ++;
}
else if (IR.timer_count > 43 && IR.timer_count < 63) //0.56ms低+1.68ms高,说明传输的数据为 1
{
IR.IR_code <<= 1;
IR.IR_code ++; //数据位置1
IR.IR_decode_bit ++;
}
else //如果0.56ms的低电平后接着的是不符合要求的高电平时间,那么清零所有数据
{
IR.f_head = 0;
IR.IR_decode_bit = 0; //电平计数超过了码元长度 清除位数计数
IR.IR_event = 0;
IR.IR_code = 0;
IR.IR_code_get = 0;
IR.low_8bit = 0;
IR.hig_8bit = 0;
IR.rece_ok = 0;
}
if (IR.IR_decode_bit == 32) //接收了32位数据之后,开始判断内容
{
IR.IR_code_get = IR.IR_code;
IR.user_code = (uint16_t)(IR.IR_code_get >> 16); //获取遥控用户码
IR.IR_code_get = IR.IR_code;
IR.low_8bit = IR.IR_code_get & 0x000000FF; //对于本项目而言之后低16位数据有用,其中15-8为数据,7-0为数据反码
IR.hig_8bit = (IR.IR_code_get & 0x0000FF00) >> 8;
IR.low_8bit ^= 0xFF; //拿反码异或1 得到取反数据
if (IR.low_8bit == IR.hig_8bit) //判定数据跟数据反码是否相符,如果相符则为有用数据,否则舍弃所有数据
{
IR.rece_ok = 1;
only_read_charactertics_buffer[5] = IR.hig_8bit;
}
else
{
IR.rece_ok = 0;
IR.low_8bit = 0;
IR.hig_8bit = 0;
IR.IR_code_get = 0;
}
IR.IR_decode_bit = 0;
IR.IR_code = 0;
IR.f_head = 0;
IR.IR_event = 0;
}
IR.get_bit = 0; //每次处理完一位数据之后,清楚标志位,待下次0.56ms低电平成立之后再次判断
}
}
}
xc_timer_set_value(TIMER2_IDX, us); //设置定时器初值，自减
xc_timer_start(TIMER2_IDX); //每次进入外部中断都要启动计数器
}
project/example/ble/ble_peripheral/app/src/nec_infrared.h
-84
View File
@@ -1,84 +0,0 @@
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __NEC_INFRARED_H__
#define __NEC_INFRARED_H__
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define IR_PIN GPIO_2
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
typedef struct IR_decode
{
uint32_t timer_count; //定时器数据
uint32_t IR_code; //读取到的红外码
uint32_t IR_code_get;
uint32_t IR_decode_bit;//解码接收位数
uint32_t IR_event; //红外输出事件
uint16_t user_code;//用户码
uint8_t data_recving_flag;//红外接收中的标志
uint8_t f_head;
uint8_t get_bit;
uint8_t low_8bit;
uint8_t hig_8bit;
uint8_t rece_ok;
uint8_t printf_datalen;
}IR_struct;
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
extern IR_struct IR;
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void ir_callback(void);
void app_ir_init(void);
#endif
///* Private defines -----------------------------------------------------------*/
//#define IR_CODE_GET_POWER (uint8_t)(0xE2)
//#define IR_CODE_GET_SPEED (uint8_t)(0xA2)
//#define IR_CODE_GET_TIMER (uint8_t)(0xA8)
//#define IR_CODE_GET_SHAKE (uint8_t)(0x18)
///* Exported variables prototypes ---------------------------------------------*/
//extern UART_HandleTypeDef UartHandle;
//extern __IO ITStatus UartReady;
//extern TIM_HandleTypeDef TimHandle,Tim3Handle,Tim1Handle, Tim17Handle;
//extern EXTI_HandleTypeDef exti_handle;
//extern GPIO_InitTypeDef GPIO_InitStruct;
//extern IR_struct IR;
///* Exported functions prototypes ---------------------------------------------*/
//void APP_ErrorHandler(void);
project/example/ble/ble_peripheral/app/src/ota_flash_interface.c
+139 -143
View File
@@ -1,143 +1,139 @@
#include "ota_flash_interface.h"
#include "arch.h"
#include "dbg.h"
// extern uint8_t ble_flash_operation_can_check(void);
#include "ota_protocol.h"
op_flash_t op_flash =
{
OP_IDEL,
};
// extern op_flash_t op_flash;
int ble_flash_later_sector_erase(uint32_t addr)
{
if (op_flash.op_state != OP_IDEL)
{
return -1;
}
// SPI_TypeDef *spi_handle = XC_SPI0;
// op_flash.spi_handle = spi_handle;
op_flash.op_state = OP_WIAT_ERASE;
op_flash.op_addr = addr;
return 0;
}
int ble_flash_later_write_page(uint8_t *buff, uint32_t PageAddR)
{
if (op_flash.op_state != OP_IDEL)
{
return -1;
}
// SPI_TypeDef *spi_handle = XC_SPI0;
// op_flash.spi_handle = spi_handle;
op_flash.op_state = OP_WIAT_WRITE;
op_flash.op_addr = PageAddR;
for (int i = 0; i < FLASH_PAGE_SIZE; i++)
{
op_flash.op_buff[i] = buff[i];
}
return 0;
}
int ble_flash_later_page_erase(uint32_t addr)
{
if (op_flash.op_state != OP_IDEL)
{
return -1;
}
op_flash.op_state = OP_WIAT_PAGE_ERASE;
op_flash.op_addr = addr;
return 0;
}
__RAM_CODE void ble_flash_handle(void)
{
if (op_flash.op_state == OP_IDEL)
{
return;
}
else if (op_flash.op_state == OP_WIAT_WRITE)
{
{
// LOGI("FMC_SPI_Flash_WritePage: op_flash.op_addr=%x\n", op_flash.op_addr);
GLOBAL_INT_DISABLE();
FMC_SPI_Flash_WritePage(op_flash.op_addr, op_flash.op_buff, 256);
// if(op_flash.op_addr==0x31000 || op_flash.op_addr==OTA_PARAM_ADDR){
// uint8_t data[FLASH_PAGE_SIZE];
// FMC_SPI_Flash_ReadPage(op_flash.op_addr, data, FLASH_PAGE_SIZE);
// LOGI("Flash Read data: \n");
// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
// {
// LOGI("%02x ", data[i]);
// }
// LOGI("\n");
// LOGI("raw data: \n");
// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
// {
// LOGI("%02x ", op_flash.op_buff[i]);
// }
// LOGI("\n");
// }
// if( op_flash.op_addr==OTA_PARAM_ADDR){
// LOGI("Flash write data: \n");
// FMC_SPI_Flash_ReadPage(op_flash.op_addr, data, FLASH_PAGE_SIZE);
// LOGI("Flash Read data: \n");
// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
// {
// LOGI("%02x ", op_flash.op_buff[i]);
// }
// LOGI("\n");
// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
// {
// LOGI("%02x ", data[i]);
// }
// LOGI("\n");
// }
GLOBAL_INT_RESTORE();
op_flash.op_state = OP_IDEL;
}
}
else if (op_flash.op_state == OP_WIAT_ERASE)
{
{
// LOGI("FMC_SPI_Flash_Erase_Sector: op_flash.op_addr=%x\n", op_flash.op_addr);
GLOBAL_INT_DISABLE();
FMC_SPI_Flash_Erase_Sector(op_flash.op_addr);
GLOBAL_INT_RESTORE();
// LOGI("FMC_SPI_Flash_Erase_Sector: op_flash.op_addr1=%x\n", op_flash.op_addr);
// {
// uint8_t data[FLASH_PAGE_SIZE];
// FMC_SPI_Flash_ReadPage(op_flash.op_addr, data, FLASH_PAGE_SIZE);
//// LOGI("Erase Read data: \n");
//// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
//// {
//// LOGI("%02x ", data[i]);
//// }
//// LOGI("\n");
// }
op_flash.op_state = OP_IDEL;
}
} else if (op_flash.op_state == OP_WIAT_PAGE_ERASE)
{
{
LOGI("FMC_SPI_Flash_Erase_Page: op_flash.op_addr=%x\n", op_flash.op_addr);
GLOBAL_INT_DISABLE();
FMC_SPI_Flash_Page_Sector(op_flash.op_addr);
GLOBAL_INT_RESTORE();
op_flash.op_state = OP_IDEL;
}
}
}
#if !FAST_OTA
#include "ota_flash_interface.h"
#include "arch.h"
#include "dbg.h"
// extern uint8_t ble_flash_operation_can_check(void);
#include "ota_protocol.h"
#include "xc_drv_fmc_spi.h"
op_flash_t op_flash = {
OP_IDEL,
};
// extern op_flash_t op_flash;
int ble_flash_later_sector_erase(uint32_t addr)
{
if (op_flash.op_state != OP_IDEL) {
return -1;
}
// SPI_TypeDef *spi_handle = XC_SPI0;
// op_flash.spi_handle = spi_handle;
op_flash.op_state = OP_WIAT_ERASE;
op_flash.op_addr = addr;
return 0;
}
int ble_flash_later_write_page(uint8_t *buff, uint32_t PageAddR)
{
if (op_flash.op_state != OP_IDEL) {
return -1;
}
// SPI_TypeDef *spi_handle = XC_SPI0;
// op_flash.spi_handle = spi_handle;
op_flash.op_state = OP_WIAT_WRITE;
op_flash.op_addr = PageAddR;
for (int i = 0; i < FLASH_PAGE_SIZE; i++) {
op_flash.op_buff[i] = buff[i];
}
return 0;
}
int ble_flash_later_page_erase(uint32_t addr)
{
if (op_flash.op_state != OP_IDEL) {
return -1;
}
op_flash.op_state = OP_WIAT_PAGE_ERASE;
op_flash.op_addr = addr;
return 0;
}
void ble_flash_handle(void)
{
if (op_flash.op_state == OP_IDEL) {
return;
} else if (op_flash.op_state == OP_WIAT_WRITE) {
{
// LOGI("FMC_SPI_Flash_WritePage: op_flash.op_addr=%x\n",
// op_flash.op_addr);
GLOBAL_INT_DISABLE();
FMC_SPI_Flash_WritePage(op_flash.op_addr, op_flash.op_buff, 256);
// if(op_flash.op_addr==0x31000 ||
// op_flash.op_addr==OTA_PARAM_ADDR){
// uint8_t data[FLASH_PAGE_SIZE];
// FMC_SPI_Flash_ReadPage(op_flash.op_addr, data,
// FLASH_PAGE_SIZE); LOGI("Flash Read data: \n");
// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
// {
// LOGI("%02x ", data[i]);
// }
// LOGI("\n");
// LOGI("raw data: \n");
// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
// {
// LOGI("%02x ", op_flash.op_buff[i]);
// }
// LOGI("\n");
// }
// if( op_flash.op_addr==OTA_PARAM_ADDR){
// LOGI("Flash write data: \n");
// FMC_SPI_Flash_ReadPage(op_flash.op_addr, data,
// FLASH_PAGE_SIZE);
// LOGI("Flash Read data: \n");
// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
// {
// LOGI("%02x ", op_flash.op_buff[i]);
// }
// LOGI("\n");
// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
// {
// LOGI("%02x ", data[i]);
// }
// LOGI("\n");
// }
GLOBAL_INT_RESTORE();
op_flash.op_state = OP_IDEL;
}
} else if (op_flash.op_state == OP_WIAT_ERASE) {
{
// LOGI("FMC_SPI_Flash_Erase_Sector: op_flash.op_addr=%x\n",
// op_flash.op_addr);
GLOBAL_INT_DISABLE();
FMC_SPI_Flash_Erase_Sector(op_flash.op_addr);
GLOBAL_INT_RESTORE();
// LOGI("FMC_SPI_Flash_Erase_Sector:
// op_flash.op_addr1=%x\n", op_flash.op_addr);
// {
// uint8_t data[FLASH_PAGE_SIZE];
// FMC_SPI_Flash_ReadPage(op_flash.op_addr, data,
// FLASH_PAGE_SIZE);
//// LOGI("Erase Read data: \n");
//// for(uint16_t i = 0; i<FLASH_PAGE_SIZE; i++)
//// {
//// LOGI("%02x ", data[i]);
//// }
//// LOGI("\n");
// }
op_flash.op_state = OP_IDEL;
}
} else if (op_flash.op_state == OP_WIAT_PAGE_ERASE) {
{
LOGI("FMC_SPI_Flash_Erase_Page: op_flash.op_addr=%x\n",
op_flash.op_addr);
GLOBAL_INT_DISABLE();
FMC_SPI_Flash_Erase_Page(op_flash.op_addr);
GLOBAL_INT_RESTORE();
op_flash.op_state = OP_IDEL;
}
}
}
#endif
project/example/ble/ble_peripheral/app/src/ota_flash_interface.h
+45 -44
View File
@@ -1,44 +1,45 @@
#ifndef __OTA_FLASH_INTERFACE_H_
#define __OTA_FLASH_INTERFACE_H_
#if (USE_XIP)
#if (USE_ROM_FLASH)
#include "xc6xxx_fmc_spi.h"
#endif // (USE_ROM_FLASH)
#endif // !(USE_XIP)
#include <stdint.h>
#define FMC_SPI_Flash_WritePage xc_fmc_spi_flash_write_page
#define FMC_SPI_Flash_ReadPage xc_fmc_spi_flash_read_page
#define FMC_SPI_Flash_Erase_Sector xc_fmc_spi_flash_erase_sector
#define FMC_SPI_Flash_Page_Sector xc_fmc_spi_flash_erase_page
typedef enum
{
OP_IDEL = 0,
OP_WIAT_WRITE ,
OP_DO_WRITE ,
OP_DONE_WRITE ,
OP_WIAT_ERASE ,
OP_DO_ERASE ,
OP_DONE_ERASE ,
OP_WIAT_PAGE_ERASE,
} op_t;
typedef struct
{
uint8_t op_state;
uint32_t op_addr;
uint8_t __attribute__((aligned(4))) op_buff[(256+8)];
// SPI_TypeDef *spi_handle;
} op_flash_t;
extern op_flash_t op_flash;
void ble_flash_handle(void);
int ble_flash_later_write_page(uint8_t *buff, uint32_t PageAddR);
int ble_flash_later_sector_erase(uint32_t addr);
#endif // __OTA_FLASH_INTERFACE_H_
#ifndef __OTA_FLASH_INTERFACE_H_
#define __OTA_FLASH_INTERFACE_H_
#if (USE_XIP)
#if (USE_ROM_FLASH)
#include "xc6xxx_fmc_spi.h"
#endif // (USE_ROM_FLASH)
#endif // !(USE_XIP)
#include <stdint.h>
#define FMC_SPI_Flash_WritePage xc_fmc_spi_flash_write_page
#define FMC_SPI_Flash_ReadPage xc_fmc_spi_flash_read_page
#define FMC_SPI_Flash_Erase_Sector FMC_SPI_Flash_Erase_Sector
#define FMC_SPI_Flash_Erase_Page xc_fmc_spi_flash_erase_page
typedef enum
{
OP_IDEL = 0,
OP_WIAT_WRITE ,
OP_DO_WRITE ,
OP_DONE_WRITE ,
OP_WIAT_ERASE ,
OP_DO_ERASE ,
OP_DONE_ERASE ,
OP_WIAT_PAGE_ERASE,
} op_t;
typedef struct
{
uint8_t op_state;
uint32_t op_addr;
uint8_t __attribute__((aligned(4))) op_buff[(256+8)];
// SPI_TypeDef *spi_handle;
} op_flash_t;
extern op_flash_t op_flash;
void ble_flash_handle(void);
int ble_flash_later_write_page(uint8_t *buff, uint32_t PageAddR);
int ble_flash_later_sector_erase(uint32_t addr);
int ble_flash_later_page_erase(uint32_t addr);
#endif // __OTA_FLASH_INTERFACE_H_
project/example/ble/ble_peripheral/app/src/ota_protocol.c
+546 -456
View File
File diff suppressed because it is too large Load Diff
project/example/ble/ble_peripheral/app/src/ota_protocol.h
+249 -233
View File
@@ -1,233 +1,249 @@
#ifndef __OTA_PROTOCOL_H_
#define __OTA_PROTOCOL_H_
#include <stdio.h>
#include <string.h>
#include "arch.h"
//#include "ble.h"
//#include "ble_flash_operation.h"
// extern void data_sent(uint8_t *buffer, uint16_t length);
// #define DEBUG(...) //DEBUG(__VA_ARGS__)
#define PARAM_CNT 5
#define TRUES 1
#define FALSE 0
#define CRC32_INITIAL 0
#define DELAY_MS
#define FLASH_INIT
#define FLASH_WRITE_PAGE ble_flash_later_write_page
#define FLASH_READ_PAGE
#define FLASH_SECTOR_ERASE ble_flash_later_sector_erase
#define FlASH_WR_ENABLE
#define FLASH_WAIT_READY
#define FLASH_RELEASE_PD
#define FLASH_ENTER_PD
#define FLASH_PAGE_ERASE
#define CEILING(dividend, divisor) ((dividend) / (divisor) + (((dividend) % (divisor)) ? 1 : 0))
#define FOTAS_NOTIFY ota_slave_send_data
#define FOTA_PAGE_NUM 16
#define OTA_PARAM_ADDR ((8*1024)-512)
enum fota_write_cmd
{
FOTAS_STA_CMD = 1,
FOTAS_STA_RSP_CMD,
FOTAS_INFO_CMD,
FOTAS_INFO_RSP_CMD,
FOTAS_DATA_CMD,
FOTAS_COM_CMD,
FOTAS_RES_CMD,
};
enum fota_result_rsp
{
FOTAS_SUCCEES,
FOTAS_FAIL,
};
enum fota_inf_stat
{
FOTAS_INF_OK,
FOTAS_INF_ERR,
};
enum fota_stat_rsp
{
FOTAS_STAT_OK,
FOTAS_SW_DIF,
FOTAS_ROM_DIF,
FOTAS_OVERLOUP,
};
enum fota_sn
{
FOTAS_RSP,
FOTAS_SENT,
};
enum fota_cmd_type
{
FOTAS_CMD,
FOTAS_ACK,
};
enum fota_ack_type
{
FOTAS_TRANS_SUC,
FOTAS_DEV_READY,
FOTAS_DEV_BUSY,
FOTAS_TANS_TIOUT,
FOTAS_TANS_CANCEL,
FOTAS_TANS_LOSE,
FOTAS_TANS_BIN_ACK,
FOTAS_STATE_MAX,
};
enum fota_rsp_stat
{
FOTAS_RSP_READY,
FOTAS_RCV_SECT_START,
FOTAS_RCV_SECT_CANCEL,
};
enum fota_rcv_rsp
{
FOTAS_RSP_START,
FOTAS_RSP_CMD,
FOTAS_RECV_START,
};
struct img_hdr_t
{
// Secure OTA uses the Signature for image validation instead of calculating a CRC, but the use
// of CRC==CRC-Shadow for quick boot-up determination of a validated image is still used.
// User-defined Image Version Number - default logic uses simple a '!=' comparison to start an OTA .
uint16_t sn;
uint8_t cmd;
uint16_t len;
uint16_t sw_ver;
uint16_t rom_ver; // Rom ver.
uint32_t bin_size; // Image fotas_write_env.length in 4-byte blocks ().
uint32_t crc; // CRC must not be 0x00000000 or 0xFFFFFFFF.
uint16_t pack_num;
} __attribute__((packed));
struct fota_data_att
{
uint16_t sn;
uint16_t len;
uint8_t cmd;
uint32_t segment_id;
uint32_t crc;
uint16_t sector_size;
} __attribute__((packed));
struct fota_data
{
uint16_t sn;
uint8_t cmd;
uint8_t data[256];
} __attribute__((packed));
/*
APP->DEV
sn,cmd,data,fnum
DEV->APP
sn,cmd,atype,para
*/
struct opencode_or_ack
{
uint16_t sn;
uint8_t cmd;
uint8_t data_or_atype; // data or ack type
uint16_t fnum_or_para; // frame num or parameter
uint16_t data;
} __attribute__((packed));
struct dev_send_buf
{
uint16_t sn;
uint16_t len;
uint8_t cmd;
uint16_t status;
} __attribute__((packed));
struct fotas_env
{
uint16_t sn;
uint32_t crc;
uint8_t status;
uint32_t bin_size;
uint8_t sector_buf[FOTA_PAGE_NUM][FLASH_PAGE_SIZE];
uint16_t pack_num;
struct opencode_or_ack ack;
struct dev_send_buf send_buf;
struct fota_data_att data_att;
} __attribute__((packed));
struct fotas_write_env
{
int old_length;
int length;
uint32_t write_addr;
uint32_t erase_addr;
uint16_t all_fnum;
uint16_t cur_num;
uint8_t para_buf[256];
};
typedef struct
{
uint32_t Status; /**/
uint32_t SoftVer; /**/
uint32_t ACheck; /*crc32*/
uint32_t AAddr; /*sector align*/
uint32_t ALen; /*page align*/
uint32_t BCheck; /**/
uint32_t BAddr; /**/
uint32_t BLen; /**/
uint32_t ALoadAddr;
uint32_t BLoadAddr;
uint32_t RESERVED0[2];
} PARAM_UNIT;
struct fotas_flag
{
uint8_t fir_ack_idx;
uint8_t fir_rsp_stat;
uint8_t first_pack_write_flag;
uint8_t ota_succ_flag ;
uint8_t rsp_stat;
uint8_t ack_idx ;
uint8_t sector_erase_flag;
uint8_t wtitten_page_num ; //
uint8_t wtite_flag; // Only when the valid data of the bin file is received, it will be set to 1
};
typedef enum
{
InvalidStat = 0,
ActiveAStat = 1,
EraseAStat = 2,
OverwriteAStat = 3,
ActiveBStat = 4,
EraseBStat = 5,
OverwriteBStat = 6,
} STATUS_T;
typedef struct
{
PARAM_UNIT ParamUnit[PARAM_CNT];
uint32_t ParamCrc32;
uint32_t RESERVED1[3];
} sBOOT_MESSAGE;
extern uint32_t GenerateCrc32(uint32_t PartialCrc, char *Buffer, uint32_t Length);
void fota_disconnect_reset(void);
void xc_fota_dev_ack_cmd(uint16_t sn,
uint8_t cmd,
uint8_t data_or_atype,
uint16_t fnum_or_para);
void xc_fota_server_write_ind(uint8_t *buffer, uint16_t buff_size);
void ota_write_flash(void);
void xc_ota_schedule(void);
void wdt_reset_system(void);
#endif // __OTA_PROTOCOL_H_
#ifndef __OTA_PROTOCOL_H_
#define __OTA_PROTOCOL_H_
#include "arch.h"
#include <stdio.h>
#include <string.h>
#define PARAM_CNT 5
#define TRUES 1
#define FALSE 0
#define CRC32_INITIAL 0
#define DELAY_MS
#define FLASH_INIT
#define FLASH_WRITE_PAGE ble_flash_later_write_page
#define FLASH_READ_PAGE
#define FLASH_SECTOR_ERASE ble_flash_later_sector_erase
#define FlASH_WR_ENABLE
#define FLASH_WAIT_READY
#define FLASH_RELEASE_PD
#define FLASH_ENTER_PD
#define FLASH_PAGE_ERASE
#define CEILING(dividend, divisor) \
((dividend) / (divisor) + (((dividend) % (divisor)) ? 1 : 0))
#define FOTAS_NOTIFY ota_slave_send_data
// #define FOTA_PAGE_NUM 16
#define FOTA_PAGE_NUM 8
#define OTA_PARAM_ADDR ((8 * 1024) - 512)
enum fota_write_cmd
{
FOTAS_STA_CMD = 1,
FOTAS_STA_RSP_CMD,
FOTAS_INFO_CMD,
FOTAS_INFO_RSP_CMD,
FOTAS_DATA_CMD,
FOTAS_COM_CMD,
FOTAS_RES_CMD,
};
enum fota_result_rsp
{
FOTAS_SUCCEES,
FOTAS_FAIL,
};
enum fota_inf_stat
{
FOTAS_INF_OK,
FOTAS_INF_ERR,
};
enum fota_stat_rsp
{
FOTAS_STAT_OK,
FOTAS_SW_DIF,
FOTAS_ROM_DIF,
FOTAS_OVERLOUP,
};
enum fota_sn
{
FOTAS_RSP,
FOTAS_SENT,
};
enum fota_cmd_type
{
FOTAS_CMD,
FOTAS_ACK,
};
enum fota_ack_type
{
FOTAS_TRANS_SUC,
FOTAS_DEV_READY,
FOTAS_DEV_BUSY,
FOTAS_TANS_TIOUT,
FOTAS_TANS_CANCEL,
FOTAS_TANS_LOSE,
FOTAS_TANS_BIN_ACK,
FOTAS_STATE_MAX,
};
enum fota_rsp_stat
{
FOTAS_RSP_READY,
FOTAS_RCV_SECT_START,
FOTAS_RCV_SECT_CANCEL,
};
enum fota_rcv_rsp
{
FOTAS_RSP_START,
FOTAS_RSP_CMD,
FOTAS_RECV_START,
};
struct img_hdr_t
{
// Secure OTA uses the Signature for image validation instead of calculating
// a CRC, but the use of CRC==CRC-Shadow for quick boot-up determination of
// a validated image is still used. User-defined Image Version Number -
// default logic uses simple a '!=' comparison to start an OTA .
uint16_t sn;
uint8_t cmd;
uint16_t len;
uint16_t sw_ver;
uint16_t rom_ver; // Rom ver.
uint32_t bin_size; // Image fotas_write_env.length in 4-byte blocks ().
uint32_t crc; // CRC must not be 0x00000000 or 0xFFFFFFFF.
uint16_t pack_num;
} __attribute__((packed));
struct fota_data_att
{
uint16_t sn;
uint16_t len;
uint8_t cmd;
uint32_t segment_id;
uint32_t crc;
uint16_t sector_size;
} __attribute__((packed));
struct fota_data
{
uint16_t sn;
uint8_t cmd;
uint8_t data[256];
} __attribute__((packed));
/*
APP->DEV
sn,cmd,data,fnum
DEV->APP
sn,cmd,atype,para
*/
struct opencode_or_ack
{
uint16_t sn;
uint8_t cmd;
uint8_t data_or_atype; // data or ack type
uint16_t fnum_or_para; // frame num or parameter
uint16_t data;
} __attribute__((packed));
struct dev_send_buf
{
uint16_t sn;
uint16_t len;
uint8_t cmd;
uint16_t status;
} __attribute__((packed));
struct fotas_env
{
uint16_t sn;
uint32_t crc;
uint8_t status;
uint32_t bin_size;
uint8_t sector_buf[FOTA_PAGE_NUM][FLASH_PAGE_SIZE];
uint16_t pack_num;
struct opencode_or_ack ack;
struct dev_send_buf send_buf;
struct fota_data_att data_att;
} __attribute__((packed));
struct fotas_write_env
{
int old_length;
int length;
uint32_t write_addr;
uint32_t erase_addr;
uint16_t all_fnum;
uint16_t cur_num;
uint8_t para_buf[256];
};
typedef struct
{
uint32_t Status; /**/
uint32_t SoftVer; /**/
uint32_t ACheck; /*crc32*/
uint32_t AAddr; /*sector align*/
uint32_t ALen; /*page align*/
uint32_t BCheck; /**/
uint32_t BAddr; /**/
uint32_t BLen; /**/
uint32_t ALoadAddr;
uint32_t BLoadAddr;
uint32_t RESERVED0[2];
} PARAM_UNIT;
struct fotas_flag
{
uint8_t ota_status;
uint8_t fir_ack_idx;
uint8_t fir_rsp_stat;
uint8_t first_pack_write_flag;
uint8_t ota_succ_flag;
uint8_t rsp_stat;
uint8_t ack_idx;
uint8_t sector_erase_flag;
uint8_t wtitten_page_num; //
uint8_t wtite_flag; // Only when the valid data of the bin file is received,
// it will be set to 1
};
typedef enum
{
InvalidStat = 0,
ActiveAStat = 1,
EraseAStat = 2,
OverwriteAStat = 3,
ActiveBStat = 4,
EraseBStat = 5,
OverwriteBStat = 6,
} STATUS_T;
typedef struct
{
PARAM_UNIT ParamUnit[PARAM_CNT];
uint32_t ParamCrc32;
uint32_t RESERVED1[3];
} sBOOT_MESSAGE;
typedef struct
{
uint16_t sw_ver; //sw_ver
uint16_t rom_ver; // Rom ver.
uint32_t bin_size; // Image length in 4-byte blocks ().
} img_hdr_t;
typedef struct
{
img_hdr_t img;
PARAM_UNIT ParamUnit[PARAM_CNT];
uint32_t ParamCrc32;
uint32_t RESERVED1[3];
} sBOOT_MESSAGE_OTA;
extern struct fotas_flag fotas_status;
extern uint32_t GenerateCrc32(uint32_t PartialCrc, char *Buffer,
uint32_t Length);
void fota_disconnect_reset(void);
void xc_fota_dev_ack_cmd(uint16_t sn, uint8_t cmd, uint8_t data_or_atype,
uint16_t fnum_or_para);
void xc_fota_server_write_ind(uint8_t *buffer, uint16_t buff_size);
void ota_write_flash(void);
void xc_ota_schedule(void);
void wdt_reset_system(void);
void xc_ota_schedule(void);
#endif // __OTA_PROTOCOL_H_
project/example/ble/ble_peripheral/app/src/ota_server.c
+180 -170
View File
@@ -1,170 +1,180 @@
/**
****************************************************************************************
*
* @file ota_server.c
*
* @brief Custom Server profile database definitions.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.p
*
****************************************************************************************
*/
#include "rwip_config.h"
#if (BLE_APP_PRESENT)
#include "ota_server.h"
#include "ota_protocol.h"
uint8_t ota_srv_user_lid = GATT_INVALID_USER_LID;
uint16_t ota_svc_start_hdl = GATT_INVALID_HDL;
uint8_t ota_svc_tx_char_notify = DISABLE;
static const gatt_att_desc_t ota_server_atts[] = {
[OTA_SVC_DECL] =
{
.uuid = 0x00,0x28,
.info = GATT_ATT_RD_BIT | ATT_UUID(16),
.ext_info = 0,
},
[OTA_SVC_RX_CHAR_DECL_CHAR] =
{
.uuid = 0x03, 0x28,
.info = GATT_ATT_RD_BIT| ATT_UUID(16),
.ext_info = 0,
},
[OTA_SVC_RX_CHAR_VAL] =
{
.uuid = OTA_SVC_RX_CHAR_UUID,
.info = GATT_ATT_WC_BIT | GATT_ATT_RD_BIT | ATT_UUID(128),
.ext_info =
GATT_ATT_NO_OFFSET_BIT | OTA_SVC_RX_CHAR_VAL_MAX_LENGTH ,
},
[OTA_SVC_TX_CHAR_DECL_CHAR] =
{
.uuid = 0x03, 0x28,
.info = GATT_ATT_RD_BIT| ATT_UUID(16),
.ext_info = 0,
},
[OTA_SVC_TX_CHAR_VAL] =
{
.uuid = OTA_SVC_TX_CHAR_UUID,
.info = GATT_ATT_N_BIT | ATT_UUID(128),
.ext_info =
GATT_ATT_NO_OFFSET_BIT | OTA_SVC_TX_CHAR_VAL_MAX_LENGTH,
},
[OTA_SVC_TX_CHAR_CFG] =
{
.uuid = 0x02, 0x29,
.info = GATT_ATT_RD_BIT | GATT_ATT_WR_BIT | ATT_UUID(16),
.ext_info = 0,
},
};
uint8_t ota_slave_send_data(uint8_t *data, uint8_t len, uint8_t att_idx);
uint16_t ota_srv_get_hdl_from_att_idx(uint8_t idx)
{
return ota_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 ota_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 ota_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 ota_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, ota_srv_get_hdl_from_att_idx(OTA_SVC_TX_CHAR_CFG));
if (hdl == ota_srv_get_hdl_from_att_idx(OTA_SVC_TX_CHAR_CFG)) {
if ((co_buf_data(p_data)[1] == 0) && (co_buf_data(p_data)[0] == 0)) {
ota_svc_tx_char_notify = DISABLE;
} else {
ota_svc_tx_char_notify = ENABLE;
LOGI("ota_svc_tx_char_notify ENABLE\r\n");
// uint8_t data[] = {0x12, 0x13, 0x14};
// ota_slave_send_data(data, sizeof(data), OTA_SVC_TX_CHAR_VAL);
}
}
}
static const gatt_srv_cb_t ota_src_cb = {
.cb_event_sent = ota_svc_cb_event_sent,
.cb_att_read_get = ota_svc_cb_att_read_get,
.cb_att_val_set = ota_svc_cb_att_val_set,
};
uint8_t ota_svc_add(void)
{
int nb_att = sizeof(ota_server_atts) / sizeof(ota_server_atts[0]);
uint16_t status;
uint8_t ota_svc_uuid[GATT_UUID_128_LEN] = OTA_SVC_UUID;
status = xc_ble_gatt_user_srv_register(GAP_LE_MTU_MAX, 0, &ota_src_cb,
&ota_srv_user_lid);
if (status != GATT_NO_ERROR) {
LOGI_ERR("gatt_user_srv_register error 0x%x", status);
}
status = xc_ble_gatt_service_add(
ota_srv_user_lid, GATT_UUID_128 << GATT_SVC_UUID_TYPE_LSB, ota_svc_uuid,
nb_att, NULL, &(ota_server_atts[0]), nb_att, &ota_svc_start_hdl);
if (status != GATT_NO_ERROR) {
LOGI_ERR("xc_ble_gatt_service_add error 0x%x", status);
}
return status;
}
uint8_t ota_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 && ota_svc_tx_char_notify) {
status = xc_ble_gatt_srv_notify(app_env->slave_conidx, ota_srv_user_lid, 0,
ota_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;
}
#endif // (BLE_APP_PRESENT)
/**
****************************************************************************************
*
* @file ota_server.c
*
* @brief Custom Server profile database definitions.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.p
*
****************************************************************************************
*/
#if !FAST_OTA
#include "rwip_config.h"
#if (BLE_APP_PRESENT)
#include "ota_protocol.h"
#include "ota_server.h"
uint8_t ota_srv_user_lid = GATT_INVALID_USER_LID;
uint16_t ota_svc_start_hdl = GATT_INVALID_HDL;
uint8_t ota_svc_tx_char_notify = DISABLE;
uint8_t ota_start_cmd[6] = {0x00, 0x00, 0x00, 0x00, 0x01, 0x00};
static const gatt_att_desc_t ota_server_atts[] = {
[OTA_SVC_DECL] =
{
.uuid = 0x00,
0x28,
.info = GATT_ATT_RD_BIT | ATT_UUID(16),
.ext_info = 0,
},
[OTA_SVC_RX_CHAR_DECL_CHAR] =
{
.uuid = 0x03,
0x28,
.info = GATT_ATT_RD_BIT | ATT_UUID(16),
.ext_info = 0,
},
[OTA_SVC_RX_CHAR_VAL] =
{
.uuid = OTA_SVC_RX_CHAR_UUID,
.info = GATT_ATT_WC_BIT | GATT_ATT_RD_BIT | ATT_UUID(128),
.ext_info = GATT_ATT_NO_OFFSET_BIT | OTA_SVC_RX_CHAR_VAL_MAX_LENGTH,
},
[OTA_SVC_TX_CHAR_DECL_CHAR] =
{
.uuid = 0x03,
0x28,
.info = GATT_ATT_RD_BIT | ATT_UUID(16),
.ext_info = 0,
},
[OTA_SVC_TX_CHAR_VAL] =
{
.uuid = OTA_SVC_TX_CHAR_UUID,
.info = GATT_ATT_N_BIT | ATT_UUID(128),
.ext_info = GATT_ATT_NO_OFFSET_BIT | OTA_SVC_TX_CHAR_VAL_MAX_LENGTH,
},
[OTA_SVC_TX_CHAR_CFG] =
{
.uuid = 0x02,
0x29,
.info = GATT_ATT_RD_BIT | GATT_ATT_WR_BIT | ATT_UUID(16),
.ext_info = 0,
},
};
uint8_t ota_slave_send_data(uint8_t *data, uint8_t len, uint8_t att_idx);
uint16_t ota_srv_get_hdl_from_att_idx(uint8_t idx)
{
return ota_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 ota_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 ota_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 ota_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);
if (!memcmp(co_buf_data(p_data), ota_start_cmd, 6) || fotas_status.ota_status)
{
fotas_status.ota_status = 1;
xc_fota_server_write_ind(co_buf_data(p_data), length);
}
// LOGI("hdl=%x %x\r\n", hdl,
// ota_srv_get_hdl_from_att_idx(OTA_SVC_TX_CHAR_CFG));
if (hdl == ota_srv_get_hdl_from_att_idx(OTA_SVC_TX_CHAR_CFG)) {
if ((co_buf_data(p_data)[1] == 0) && (co_buf_data(p_data)[0] == 0)) {
ota_svc_tx_char_notify = DISABLE;
} else {
ota_svc_tx_char_notify = ENABLE;
LOGI("ota_svc_tx_char_notify ENABLE\r\n");
// uint8_t data[] = {0x12, 0x13, 0x14};
// ota_slave_send_data(data, sizeof(data), OTA_SVC_TX_CHAR_VAL);
}
}
}
static const gatt_srv_cb_t ota_src_cb = {
.cb_event_sent = ota_svc_cb_event_sent,
.cb_att_read_get = ota_svc_cb_att_read_get,
.cb_att_val_set = ota_svc_cb_att_val_set,
};
uint8_t ota_svc_add(void)
{
int nb_att = sizeof(ota_server_atts) / sizeof(ota_server_atts[0]);
uint16_t status;
uint8_t ota_svc_uuid[GATT_UUID_128_LEN] = OTA_SVC_UUID;
status =
xc_ble_gatt_user_srv_register(133, 0, &ota_src_cb, &ota_srv_user_lid);
if (status != GATT_NO_ERROR) {
LOGI_ERR("gatt_user_srv_register error 0x%x", status);
}
status = xc_ble_gatt_service_add(
ota_srv_user_lid, GATT_UUID_128 << GATT_SVC_UUID_TYPE_LSB, ota_svc_uuid,
nb_att, NULL, &(ota_server_atts[0]), nb_att, &ota_svc_start_hdl);
if (status != GATT_NO_ERROR) {
LOGI_ERR("xc_ble_gatt_service_add error 0x%x", status);
}
return status;
}
uint8_t ota_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 && ota_svc_tx_char_notify) {
status = xc_ble_gatt_srv_notify(
app_env->slave_conidx, ota_srv_user_lid, 0,
ota_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;
}
#endif // (BLE_APP_PRESENT)
#endif
project/example/ble/ble_peripheral/app/src/ota_server.h
+50 -45
View File
@@ -1,45 +1,50 @@
/**
****************************************************************************************
*
* @file ota_server.h
*
* @brief Custom Server profile database definitions.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.
*
****************************************************************************************
*/
#ifndef _OTA_SERVER_H_
#define _OTA_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"
#include "xc6xxx.h"
#define OTA_SVC_UUID {0xFA, 0x34,0x9B,0x5F,0x80,0x00,0x00,0x80,0x00,0x10,0x00,0x00,0x10,0xFF,0x00,0x00}
#define OTA_SVC_TX_CHAR_UUID 0xFB,0x34,0x9B,0x5F,0x80,0x00,0x00,0x80,0x00,0x10,0x00,0x00,0x11,0xFF,0x00,0x00
#define OTA_SVC_RX_CHAR_UUID 0xFB,0x34,0x9B,0x5F,0x80,0x00,0x00,0x80,0x00,0x10,0x00,0x00,0x12,0xFF,0x00,0x00
#define OTA_SVC_RX_CHAR_VAL_MAX_LENGTH (512)
#define OTA_SVC_TX_CHAR_VAL_MAX_LENGTH (512)
enum ota_svc
{
OTA_SVC_DECL = 0,
OTA_SVC_RX_CHAR_DECL_CHAR,
OTA_SVC_RX_CHAR_VAL,
OTA_SVC_TX_CHAR_DECL_CHAR,
OTA_SVC_TX_CHAR_VAL,
OTA_SVC_TX_CHAR_CFG,
};
uint8_t ota_svc_add(void);
uint8_t ota_slave_send_data(uint8_t *data, uint8_t len, uint8_t att_idx);
#endif // _OTA_SERVER_H_
/**
****************************************************************************************
*
* @file ota_server.h
*
* @brief Custom Server profile database definitions.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.
*
****************************************************************************************
*/
#ifndef _OTA_SERVER_H_
#define _OTA_SERVER_H_
#include "app_task.h"
#include "dbg.h"
#include "gatt.h"
#include "gatt_msg.h"
#include "rwble_hl_config.h"
#include "xc6xxx.h"
#include "xc_gatt_server_api.h"
#define OTA_SVC_UUID \
{ \
0xFA, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, \
0x00, 0x10, 0xFF, 0x00, 0x00 \
}
#define OTA_SVC_TX_CHAR_UUID \
0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, \
0x11, 0xFF, 0x00, 0x00
#define OTA_SVC_RX_CHAR_UUID \
0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, \
0x12, 0xFF, 0x00, 0x00
#define OTA_SVC_RX_CHAR_VAL_MAX_LENGTH (512)
#define OTA_SVC_TX_CHAR_VAL_MAX_LENGTH (512)
enum ota_svc
{
OTA_SVC_DECL = 0,
OTA_SVC_RX_CHAR_DECL_CHAR,
OTA_SVC_RX_CHAR_VAL,
OTA_SVC_TX_CHAR_DECL_CHAR,
OTA_SVC_TX_CHAR_VAL,
OTA_SVC_TX_CHAR_CFG,
};
uint8_t ota_svc_add(void);
uint8_t ota_slave_send_data(uint8_t *data, uint8_t len, uint8_t att_idx);
#endif // _OTA_SERVER_H_
project/example/ble/ble_peripheral/app/src/pga_adc.c
-1245
View File
File diff suppressed because it is too large Load Diff
project/example/ble/ble_peripheral/app/src/pga_adc.h
-146
View File
@@ -1,146 +0,0 @@
/*!
* \file pga_adc.h
*
* \brief The head file of pga_adc.h
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __BSP_AUDIO_ADC_H_
#define __BSP_AUDIO_ADC_H_
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "stdint.h"
#include "xc60xx.h"
#include "xc_drv_adc.h"
#include "xc_drv_pga.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define DMA_ENABLE 0
#define DMA_MULTIPLE_TRANS_ENABLE 0
#define ADC_PWM_MODE 1
#define MIC_SAMPLING_DEBUG 0 ///
#define USER_KEY_EN 1// KEY
#define MIC_GAIN_1_EN 1 // The first-level gain is enabled ： 20DB
#define MIC_GAIN_2_LEVEN 0X08 // Second-stage gain ： 1.6DB * N( 0 - 0X0E )
#define ADC_CLK_DIV_0 (0x00UL)
#define ADC_CLK_DIV_2 (0x01UL)
#define ADC_CLK_DIV_4 (0x03UL)
#define ADC_CLK_DIV_8 (0x07UL)
#define ADC_CLK_DIV_16 (0x0fUL)
#define ADC_CLOCK_FREQ_8M ADC_CLK_DIV_0 // ADC_FREQ_8M
#define ADC_CLOCK_FREQ_4M ADC_CLK_DIV_2 // ADC_FREQ_4M
#define ADC_CLOCK_FREQ_2M ADC_CLK_DIV_4 // ADC_FREQ_2M
#define ADC_CLOCK_FREQ_1M ADC_CLK_DIV_8 // ADC_FREQ_1M
#define ADC_CLOCK_FREQ_500K ADC_CLK_DIV_16 // ADC_FREQ_500K
#define ADC_FREQ_CLOCK ADC_CLOCK_FREQ_2M // ADC CLOCK select (ADC_CLOCK_FREQ_1M - ADC_CLOCK_FREQ_4M )
#define MIC_SAMPLING_8K 0
#define MIC_SAMPLING_16K 1
#define SAMPLING_TYPE MIC_SAMPLING_16K
#define MIC_SAMPLING_MAX_LEN 480//Recording cache buff length
#define MIC_SAMPLING_BUFF_MAX 2//
#define PCM_DATA_DEBUG_EN 0 // uart DEBUG pcm data
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
typedef struct
{
int16_t data_buff[MIC_SAMPLING_BUFF_MAX][MIC_SAMPLING_MAX_LEN]; //audio data to the buff
uint16_t data_rx_index; //data_buff index
uint16_t data_rx_len; //data_buff len
uint8_t save_buf_index; //double mic buff 1 index，data_buff[save_buf_index] []
uint8_t get_buf_index; //double mic buff 1 index，data_buff[save_buf_index] []
uint8_t save_data_buff_count; // mic buff SAVE index CON
uint8_t buf_full_flag;
uint8_t sampling_wait_count; // Audio sampling data interval ，The sampling frequency is calculated based on the sampling speed of the ADC ，For example, 16K sampling
uint8_t sampling_count; // Calculate the audio sampling points
int16_t pga_offset_val;
} mic_audio_t;
typedef struct
{
#if (MIC_SAMPLING_DEBUG)
uint32_t audio_adc_rx_con;
uint8_t audio_rx_stop_flag;
#endif // MIC_SAMPLING_DEBUG
#if (MIC_SAMPLING_DEBUG)
uint16_t rec_time;
uint16_t rec_time_con;
#endif //( MIC_SAMPLING_DEBUG)
uint8_t state;
} mic_record_t;
enum
{
REC_INIT,
REC_START,
REC_STOP,
};
#if (ADC_PWM_MODE)
enum adc_fs {
adc_fs_8k = 0,
adc_fs_16k,
};
#endif
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
extern mic_audio_t mic_audio;
extern mic_record_t record;
extern uint16_t adc_mic_average_val;
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void audio_adc_rx_dma_event_handler(void);
void audio_adc_rx_event_handler(uint16_t pga_adc_val);
void audio_adc_start_get_value(ADC_ChannelTypeDef_t Channel, uint16_t *adc_val);
void app_pga_init(void);
void app_audio_record_init(void);
void app_audio_record_start(void);
void app_audio_record_stop(void);
uint8_t app_get_record_state(void);
uint8_t app_get_record_buff_full_state(void);
void app_clr_record_buff_full_state(void);
void app_record_process(void);
void mic_pga_adc_demo(void);
#endif //__BSP_AUDIO_ADC_H_
project/example/ble/ble_peripheral/app/src/pwm.c
-100
View File
@@ -1,100 +0,0 @@
/*!
* \file pwm.c
*
* \brief Target pwm implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*------------------------------------------------------------------------------------
INCLUDE HEADE FILES
--------------------------------------------------------------------------------------*/
#include "pwm.h"
#include "xc_drv_pwm.h"
#include "rgblight.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Local Variables
-------------------------------------------------------------------------------------*/
uint16_t ch0_capture_data[CAPTURE_DATA_MAX];
uint16_t ch1_capture_data[CAPTURE_DATA_MAX];
uint16_t ch2_capture_data[CAPTURE_DATA_MAX];
PWM_CAP_STA_TypeDef pwm_cap_state = PWM_CAP_IDLE;
PWM_BRK_STA_TypeDef pwm_brk_state = PWM_BRK_IDLE;
PWM_BRK_CAP_STA_TypeDef pwm_brk_cap_state = PWM_BRK_CAP_VALID;
pwm_ch_cap_dutycycle_t pwm_ch_cap_dutycycle;
pwm_ch_cap_freq_t pwm_ch_cap_freq;
pwm_ch_cap_type_t pwm_ch_cap_type;
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
void UpdateDisplay(void)
{
xc_pwm_dutycycle_set(PWM2_IDX,256,r_DutyCycle*Brightness/10);
xc_pwm_dutycycle_set(PWM3_IDX,256,g_DutyCycle*Brightness/10);
xc_pwm_dutycycle_set(PWM5_IDX,256,b_DutyCycle*Brightness/10);
}
/**
* @brief app_pwm_init
* @details
* @param void
* @retval void
*/
void app_pwm_init()
{
// PWM0 and PWM1 can be mapped to other pins, PWM0 and PWM1 have inverted output.
// PWM(HZ) = PWMCLK(16000000)/(DutyCycleAcc*(period+1))/2
PWM_InitCfg_t pwm_cfg;
pwm_cfg.DutyCycleAcc = 256;
pwm_cfg.Period = 29;
pwm_cfg.SrcClk = PWM_CLK_SRC_32M_DIV;
pwm_cfg.SrcEnable = PWM_EN_SEL_ALL;
pwm_cfg.DutyCycle =240; //r_DutyCycle*Brightness/10;
pwm_cfg.OutputPin = GPIO_12;
xc_pwm_init(PWM2_IDX, &pwm_cfg);//R
pwm_cfg.DutyCycle = g_DutyCycle*Brightness/10;
pwm_cfg.OutputPin = GPIO_13; // The pin cannot be changed
xc_pwm_init(PWM3_IDX, &pwm_cfg);//G
pwm_cfg.DutyCycle = b_DutyCycle*Brightness/10;
pwm_cfg.OutputPin = GPIO_1; // The pin cannot be changed
xc_pwm_init(PWM5_IDX, &pwm_cfg);//B
xc_pwm_start_all();
}
project/example/ble/ble_peripheral/app/src/pwm.h
-109
View File
@@ -1,109 +0,0 @@
/*!
* \file pwm_test.h
*
* \brief The head file of pwm_test.c
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __PWM_TEST_H__
#define __PWM_TEST_H__
#ifdef __cplusplus
extern "C" {
#endif
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define DEVIATION_FREQ 10
#define DEVIATION_DUTYCYCLE 10
#define CAPTURE_DATA_MAX 101
#define CAPTURE_VALID_POS 4
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
typedef enum
{
PWM_CAP_IDLE = 0,
PWM_CAP_FREQ,
PWM_CAP_DUTYCYCLE,
PWM_CAP_RIGHT,
PWM_CAP_ERROR,
} PWM_CAP_STA_TypeDef;
typedef enum
{
PWM_BRK_IDLE = 0,
PWM_BRK_START,
PWM_BRK_STOP,
} PWM_BRK_STA_TypeDef;
typedef enum
{
PWM_BRK_CAP_VALID,
PWM_BRK_CAP_RECOVERY,
PWM_BRK_CAP_ERROR,
} PWM_BRK_CAP_STA_TypeDef;
typedef struct pwm_ch_cap_freq
{
uint16_t ch0_cap_freq;
uint16_t ch1_cap_freq;
uint16_t ch2_cap_freq;
} pwm_ch_cap_freq_t;
typedef struct pwm_ch_cap_dutycycle
{
uint16_t ch0_cap_dutycycle;
uint16_t ch1_cap_dutycycle;
uint16_t ch2_cap_dutycycle;
} pwm_ch_cap_dutycycle_t;
typedef struct pwm_ch_cap_type
{
uint8_t ch0_cap_type;
uint8_t ch1_cap_type;
uint8_t ch2_cap_type;
} pwm_ch_cap_type_t;
typedef enum
{
PWM_CAP_TYPE_FREQ,
PWM_CAP_TYPE_DUTYCYCLE,
} PWM_CAP_TYPE_TypeDef;
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void app_pwm_init(void);
void UpdateDisplay(void);
#ifdef __cplusplus
}
#endif
#endif /* __PWM_TEST_H__ */
project/example/ble/ble_peripheral/app/src/rgblight.c
-804
View File
@@ -1,804 +0,0 @@
#ifndef _RGBLIGHT_C_
#define _RGBLIGHT_C_
#include "pwm.h"
#include "xc_drv_pwm.h"
#include "rgblight.h"
#include "timer.h"
#include "key.h"
#include "nec_infrared.h"
#include "usr_server.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
PWM_DutyCycle_t pwm_duty_cycle;
uint32_t rgb_DutyCycleAcc = 255;
uint32_t r_DutyCycle = 127;
uint32_t g_DutyCycle = 127;
uint32_t b_DutyCycle = 127;
uint8_t direction = 0;
uint8_t mode = 0;
uint8_t Brightness = 10;
uint8_t TimeSpeed = 0;//跳变和频闪速度200ms
uint8_t FadeSpeed = 2;//渐变速度2ms
uint8_t CurrentStatus = STATICEFFECT;
uint8_t CurrentModel = DYNAMICMODE;
uint8_t deviceStatus = POWERON; // 0：POWERON 1：POWEROFF
uint8_t ModeTemp = 0;//mode缓存
uint8_t MatchOverFlag = 0;//上电定时5S结束标志
uint8_t MODE19_i = 0;
uint16_t speedOption[10] = {200, 300, 400, 500, 600, 700, 800, 900, 1000, 1100}; //跳变和频闪速度ms
//uint8_t ble_value = 0;
//uint8_t ble_user_code = 0;
ble_data_msg user_ble_data_msg;
ble_data_msg *p_ble_data_msg = NULL;
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Function
-------------------------------------------------------------------------------------*/
/**
* @brief ble_callback
* @details
* @param value0：对应遥控的的码值
value1：应用程序的掩码，必须掩码相同，才会进出BLE信息处理
* @retval void
*/
void ble_callback(uint8_t value0,uint8_t value1,uint8_t value2,uint8_t value3)
{
// ble_value = value0;
// ble_user_code = value1;
user_ble_data_msg.tpye = value3;
user_ble_data_msg.r_value = value2;
user_ble_data_msg.g_value = value1;
user_ble_data_msg.b_value_mode_speed_brightness = value0;
p_ble_data_msg = &user_ble_data_msg;
// only_read_charactertics_buffer[0] = p_ble_data_msg->r_value;
// only_read_charactertics_buffer[1] = p_ble_data_msg->g_value;
// only_read_charactertics_buffer[2] = p_ble_data_msg->b_value_mode_speed_brightness;
// only_read_charactertics_buffer[3] = p_ble_data_msg->tpye;
}
/**
* @brief ir_message_process
* @details
* @param void
* @retval void
*/
void ble_message_process(void)
{
// if(ble_user_code ==0xEE)//核对BLE用户码
// {
// ble_user_code = 0;
// functionOption(ble_value);
// }
if(p_ble_data_msg != NULL)
{
switch(p_ble_data_msg->tpye)
{
case 00://rgb
r_DutyCycle = p_ble_data_msg->r_value;
g_DutyCycle = p_ble_data_msg->g_value;
b_DutyCycle = p_ble_data_msg->b_value_mode_speed_brightness;
CurrentStatus = STATICEFFECT;
CurrentModel = TEMPERATUREMODE;
break;
case 01://亮度
Brightness = p_ble_data_msg->b_value_mode_speed_brightness;
break;
case 02://速度
TimeSpeed = p_ble_data_msg->b_value_mode_speed_brightness;
FadeSpeed = p_ble_data_msg->b_value_mode_speed_brightness + 2;
break;
case 03://模式
mode = p_ble_data_msg->b_value_mode_speed_brightness;
CurrentStatus = mode > MODE0 ? DYNAMICEEFECT : STATICEFFECT;
CurrentModel = DYNAMICMODE;
updateParameter();//更新动态模式参数
startTimer(&timer1, 1); // 立刻启动定时器1，设定间隔为1ms，执行1次
break;
case 04://开机，关机，音频
functionOption(p_ble_data_msg->b_value_mode_speed_brightness);
break;
default:
break;
}
// only_read_charactertics_buffer[1] = (uint8_t)(r_DutyCycle*Brightness/10);
// only_read_charactertics_buffer[2] = g_DutyCycle;
// only_read_charactertics_buffer[3] = b_DutyCycle;
// only_read_charactertics_buffer[4] = Brightness;
UpdateDisplay();//更新显示
p_ble_data_msg = NULL;
// only_read_charactertics_buffer[0] = (uint8_t)(r_DutyCycle*Brightness/10);
// only_read_charactertics_buffer[1] = Brightness;
// only_read_charactertics_buffer[2] = (uint8_t)r_DutyCycle;
}
}
/**
* @brief ir_message_process
* @details
* @param void
* @retval void
*/
void ir_message_process(void)
{
if(IR.rece_ok && IR.user_code ==0x47DF)//核对用户码
{
IR.rece_ok = 0;
IR.user_code = 0;
functionOption(IR.hig_8bit);
}
}
/**
* @brief key_message_process
* @details
* @param void
* @retval void
*/
void key_message_process(uint16_t msg)
{
switch(msg)
{
case REC_KEY_SHORT_DOWN:
mode = mode >= MODE19 ? MODE0 : mode++;
break;
case REC_KEY_UP_SHORT_DOWN:
break;
case REC_KEY_DOWN_SHORT_DOWN:
break;
default:
break;
}
}
/**
* @brief adc_mic_pwm_process
* @details
* @param void
* @retval void
*/
void adc_mic_pwm_process(void)
{
}
// 将音频信号值映射到RGB颜色空间中
void mapAudioToRGB(uint16_t audioValue)
{
if(audioValue > 1023)
{
audioValue = 1023;
}
// 映射到红色通道
r_DutyCycle= audioValue % 256;
// 映射到绿色通道
g_DutyCycle= (audioValue / 2) % 256;
// 映射到蓝色通道
b_DutyCycle = (audioValue / 4) % 256;
UpdateDisplay();//更新显示
}
///*********************************************************************************************************************
//色温调节
//*********************************************************************************************************************/
//void TemperatureAdjustment(unsigned char value)
//{
// if (value < 201)
// {
// g_DutyCycle = value;
// b_DutyCycle = MAXDUTY - value;
// }
//}
/*********************************************************************************************************************
RGB色彩调节
*********************************************************************************************************************/
void rgbColorModel(uint8_t value, uint32_t *r_DutyCycle, uint32_t *g_DutyCycle, uint32_t *b_DutyCycle)
{
if (value < 67)
{
*b_DutyCycle = 0;
*g_DutyCycle = (unsigned char)((value / 66.0) * 200);
*r_DutyCycle = 200 - *g_DutyCycle;
}
else if (value < 134)
{
value -= 67;
*r_DutyCycle = 0;
*b_DutyCycle = (unsigned char)((value / 66.0) * 200);
*g_DutyCycle = 200 - *b_DutyCycle;
}
else if (value < 201)
{
value -= 134;
*g_DutyCycle = 0;
*r_DutyCycle = (unsigned char)((value / 66.0) * 200);
*b_DutyCycle = 200 - *r_DutyCycle;
}
}
/*********************************************************************************************************************
亮度,速度，开关调节
*********************************************************************************************************************/
void functionOption(uint8_t key_value)
{
if (deviceStatus == POWERON || key_value == ON) //关机状态只有ON可以识别
{
switch (key_value)
{
case BRIGHTNESS_IN:
if (Brightness < 10)
Brightness++;
break;
case BRIGHTNESS_RE:
if (Brightness > 1)
Brightness--;
break;
case SPEED_IN:
if (TimeSpeed > 0 && CurrentStatus == DYNAMICEEFECT && mode != MODE19)
{
TimeSpeed --;
FadeSpeed --;
}
else if (TimeSpeed > 0 && CurrentStatus == DYNAMICEEFECT && mode == MODE19 && MODE19_i != MODE0)
{
TimeSpeed --;
FadeSpeed --;
}
break;
case SPEED_RE:
if (TimeSpeed < 9 && CurrentStatus == DYNAMICEEFECT && mode != MODE19)
{
TimeSpeed ++;
FadeSpeed ++;
}
else if (TimeSpeed < 9 && CurrentStatus == DYNAMICEEFECT && mode == MODE19 && MODE19_i != MODE0)
{
TimeSpeed ++;
FadeSpeed ++;
}
break;
case MODE_IN:
if (mode <= MODE19)
{
if (CurrentModel == TEMPERATUREMODE)
mode = ModeTemp;
else if (mode < MODE19)
mode ++;
CurrentStatus = mode > MODE0 ? DYNAMICEEFECT : STATICEFFECT;
CurrentModel = DYNAMICMODE;
updateParameter();//更新动态模式，初始值
startTimer(&timer1, 1); // 立刻启动定时器1，设定间隔为1ms，执行1次
}
break;
case MODE_RE:
if (mode >= MODE0)
{
if (CurrentModel == TEMPERATUREMODE)
mode = ModeTemp;
else if (mode > MODE0)
mode --;
CurrentStatus = mode > MODE0 ? DYNAMICEEFECT : STATICEFFECT;
CurrentModel = DYNAMICMODE;
updateParameter();//更新动态模式参数
startTimer(&timer1, 1); // 立刻启动定时器1，设定间隔为1ms，执行1次
}
break;
case ON:
if (deviceStatus == POWEROFF) //关机状态按开机才有识别
{
if (CurrentStatus == DYNAMICEEFECT) //动态效果才进入，mode>=MODE3,必须更新参数
{
updateParameter();
UpdateDisplay();//更新显示
}
// xc_pwm_start(PWM2_IDX);
// xc_pwm_start(PWM3_IDX);
// xc_pwm_start(PWM5_IDX);
xc_pwm_start_all();
startTimer(&timer1, 1); // 立刻启动定时器1，设定间隔为1ms，执行1次
deviceStatus = POWERON;//开机
}
break;
case OFF:
// xc_pwm_stop(PWM2_IDX);
// xc_pwm_stop(PWM3_IDX);
// xc_pwm_stop(PWM5_IDX);
xc_pwm_stop_all();
stopTimer(&timer1);
deviceStatus = POWEROFF;//关机
break;
case MUSIC1:
app_audio_record_start();
break;
default:
// if (key_value < 201)
// {
// rgbColorModel(key_value, &r_DutyCycle, &g_DutyCycle, &b_DutyCycle);
// stopTimer(&timer1);
// CurrentStatus = STATICEFFECT;
// CurrentModel = TEMPERATUREMODE;
// ModeTemp = mode;//缓存
// }
break;
}
if(key_value != MUSIC1)
app_audio_record_stop();//关闭adc
UpdateDisplay();//更新显示
}
}
void updateParameter(void)
{
switch (mode)
{
case MODE0:
break;
case MODE2:
direction = 0;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MAXDUTY;
break;
case MODE19:
MODE19_i = 0;
startTimer(&timer5, 20000); // 立刻启动定时器5，设定间隔为20s
default:
direction = 0;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
break;
}
}
void updateParameterMode19(unsigned char mode)//mode19()函数特定使用
{
switch (mode)
{
case MODE0:
break;
case MODE2:
direction = 0;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MAXDUTY;
break;
default:
direction = 0;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
break;
}
}
/*********************************************************************************************************************
模式
*********************************************************************************************************************/
void Mode0(void)//rgb同时显示白色
{
r_DutyCycle = MAXDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MAXDUTY;
UpdateDisplay();//更新显示
}
void Mode1(void)//RGB同时呼吸
{
if (!direction)
{
r_DutyCycle ++;
g_DutyCycle ++;
b_DutyCycle ++;
if (r_DutyCycle == MAXDUTY)
direction = 1;
}
else
{
r_DutyCycle --;
g_DutyCycle --;
b_DutyCycle --;
if (r_DutyCycle == MINDUTY)
direction = 0;
}
UpdateDisplay();//更新显示
}
void Mode2(void) // RGB渐变
{
switch (direction)
{
case 0:
r_DutyCycle++;
g_DutyCycle = 0;
b_DutyCycle --;
if (r_DutyCycle == MAXDUTY)
direction++;
break;
case 1:
r_DutyCycle--;
g_DutyCycle ++;
b_DutyCycle = 0;
if (g_DutyCycle == MAXDUTY)
direction++;
break;
case 2:
r_DutyCycle = 0;
g_DutyCycle--;
b_DutyCycle ++;
if (b_DutyCycle == MAXDUTY)
direction = 0;
break;
}
UpdateDisplay(); // 更新显示
}
void Mode3(void) // RGB呼吸
{
switch (direction)
{
case 0:
r_DutyCycle++;
g_DutyCycle = 0;
b_DutyCycle = 0;
if (r_DutyCycle == MAXDUTY)
direction++;
break;
case 1:
r_DutyCycle--;
g_DutyCycle = 0;
b_DutyCycle = 0;
if (r_DutyCycle == MINDUTY)
direction++;
break;
case 2:
r_DutyCycle = 0;
g_DutyCycle++;
b_DutyCycle = 0;
if (g_DutyCycle == MAXDUTY)
direction++;
break;
case 3:
r_DutyCycle = 0;
g_DutyCycle--;
b_DutyCycle = 0;
if (g_DutyCycle == MINDUTY)
direction++;
break;
case 4:
r_DutyCycle = 0;
g_DutyCycle = 0;
b_DutyCycle++;
if (b_DutyCycle == MAXDUTY)
direction++;
break;
case 5:
r_DutyCycle = 0;
g_DutyCycle = 0;
b_DutyCycle--;
if (b_DutyCycle == MINDUTY)
direction = 0;
break;
}
UpdateDisplay(); // 更新显示
}
void Mode4(void) // RGB七彩跳动
{
switch (direction)
{
case 0:
r_DutyCycle = MAXDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
break;
case 2:
r_DutyCycle = MINDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MINDUTY;
break;
case 4:
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MAXDUTY;
break;
case 6:
r_DutyCycle = MAXDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MINDUTY;
break;
case 8:
r_DutyCycle = MAXDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MAXDUTY;
break;
case 10:
r_DutyCycle = MINDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MAXDUTY;
break;
case 12:
r_DutyCycle = MAXDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MAXDUTY;
break;
default:
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
break;
}
direction++;
if (direction == 14)
direction = 0;
UpdateDisplay(); // 更新显示
}
void Mode5(void) // RGB跳动
{
switch (direction)
{
case 0:
r_DutyCycle = MAXDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
break;
case 2:
r_DutyCycle = MINDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MINDUTY;
break;
case 4:
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MAXDUTY;
break;
default:
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
break;
}
direction++;
if (direction == 6)
direction = 0;
UpdateDisplay(); // 更新显示
}
void Mode6(void)//R闪动
{
if (!direction)
{
r_DutyCycle = MAXDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
direction = 1;
}
else
{
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
direction = 0;
}
UpdateDisplay();//更新显示
}
void Mode7(void)//G闪动
{
if (!direction)
{
r_DutyCycle = MINDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MINDUTY;
direction = 1;
}
else
{
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
direction = 0;
}
UpdateDisplay();//更新显示
}
void Mode8(void)//B闪动
{
if (!direction)
{
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MAXDUTY;
direction = 1;
}
else
{
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
direction = 0;
}
UpdateDisplay();//更新显示
}
void Mode9(void)//W 闪动
{
if (!direction)
{
direction = 1;
r_DutyCycle = MAXDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MAXDUTY;
}
else
{
direction = 0;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
}
UpdateDisplay();//更新显示
}
void Mode10(void)//W 频闪
{
r_DutyCycle = MAXDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MAXDUTY;
UpdateDisplay();//更新显示
startTimer(&timer2, 50); // 重新启动定时器2，设定间隔为100ms
}
void Mode11(void)//R 闪动
{
if (!direction)
{
direction = 1;
r_DutyCycle = MAXDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
}
else
{
direction = 0;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
}
UpdateDisplay();//更新显示
}
void Mode12(void)//R 频闪
{
r_DutyCycle = MAXDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
UpdateDisplay();//更新显示
startTimer(&timer2, 50); // 重新启动定时器2，设定间隔为100ms
}
void Mode13(void)//G 闪动
{
if (!direction)
{
direction = 1;
r_DutyCycle = MINDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MINDUTY;
}
else
{
direction = 0;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
}
UpdateDisplay();//更新显示
}
void Mode14(void)//G 频闪
{
r_DutyCycle = MINDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MINDUTY;
UpdateDisplay();//更新显示
startTimer(&timer2, 50); // 重新启动定时器2，设定间隔为100ms
}
void Mode15(void)//B 闪动
{
if (!direction)
{
direction = 1;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MAXDUTY;
}
else
{
direction = 0;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
}
UpdateDisplay();//更新显示
}
void Mode16(void)//B 频闪
{
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MAXDUTY;
UpdateDisplay();//更新显示
startTimer(&timer2, 50); // 重新启动定时器2，设定间隔为100ms
}
void Mode17(void)//Y 闪动
{
if (direction)
{
direction = 0;
r_DutyCycle = MAXDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MINDUTY;
}
else
{
direction = 1;
r_DutyCycle = MINDUTY;
g_DutyCycle = MINDUTY;
b_DutyCycle = MINDUTY;
}
UpdateDisplay();//更新显示
}
void Mode18(void)//Y 频闪
{
r_DutyCycle = MAXDUTY;
g_DutyCycle = MAXDUTY;
b_DutyCycle = MINDUTY;
UpdateDisplay();//更新显示
startTimer(&timer2, 50); // 重新启动定时器2，设定间隔为100ms
}
void Mode19(void)//0-18 模式循环
{
MODE19_i = 0;
modefunctin[MODE19_i]();
}
pfunc modefunctin[] =//模式切换，一共15个模式
{
Mode0, Mode1, Mode2, Mode3, Mode4, Mode5, Mode6, Mode7, Mode8, Mode9, Mode10, Mode11, Mode12, Mode13, Mode14, Mode15, Mode16, Mode17, Mode18, Mode19
};
#endif
project/example/ble/ble_peripheral/app/src/rgblight.h
-174
View File
@@ -1,174 +0,0 @@
#ifndef _RGBLIGHT_H_
#define _RGBLIGHT_H_
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define MINDUTY 0
#define MAXDUTY 255
//#define ON 0X00
//#define AUTO 0X01
//#define OFF 0X02
//#define MUSIC1 0X03
//#define MUSIC2 0X04
//#define MUSIC3 0X05
//#define TIMER1 0X06
//#define TIMER2 0X07
//#define TIMER3 0X08
//#define SPEED_IN 0X09
//#define SPEED_RE 0X0A
//#define MODE_IN 0X0B
//#define MODE_RE 0X0C
//#define BRIGHTNESS_IN 0X0D
//#define BRIGHTNESS_RE 0X0F
//#define RED 0X10
//#define GREED 0X11
//#define BLUE 0X12
//#define YELLOW 0X13
//#define CYAN 0X14
//#define BLUISH 0X15
//#define PINK 0X16
//#define PURPLE 0X17
//#define WHITE 0X17
#define ON 0x25
#define AUTO 0x2D
#define OFF 0xA4
#define BRIGHTNESS_IN 0x0B
#define BRIGHTNESS_RE 0x5B
#define SPEED_IN 0x0A
#define SPEED_RE 0x5C
#define MODE_IN 0x0F
#define MODE_RE 0x6E
#define RED 0x06
#define GREED 0x08
#define BLUE 0x5A
#define YELLOW 0x09
#define CYAN 0x8A
#define BLUISH 0x10
#define TIMER1H 0x1C
#define WHITE 0x52
#define TIMER2H 0x53
#define MUSIC1 0x0C
#define MUSIC2 0x1A
#define MUSIC3 0x1F
#define FLASH1 0x01
#define FLASH2 0x00
#define FLASH3 0x02
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
// // 定义RGB颜色结构体
//typedef struct {
// uint8_t r; // 红色通道
// uint8_t g; // 绿色通道
// uint8_t b; // 蓝色通道
//} RGBColor;
typedef struct BLE_DATA_MSG
{
uint8_t tpye;
uint8_t r_value;
uint8_t g_value;
uint8_t b_value_mode_speed_brightness;
}ble_data_msg;
typedef struct
{
uint32_t DutyCycleAcc;
uint32_t DutyCycle;
} PWM_DutyCycle_t;
typedef void (*pfunc)(void);
enum
{
MODE0,
MODE1,
MODE2,
MODE3,
MODE4,
MODE5,
MODE6,
MODE7,
MODE8,
MODE9,
MODE10,
MODE11,
MODE12,
MODE13,
MODE14,
MODE15,
MODE16,
MODE17,
MODE18,
MODE19,
};
enum
{
STATICEFFECT,//色环+静态
DYNAMICEEFECT//动态
};
enum
{
TEMPERATUREMODE,//色环模式
DYNAMICMODE //动态+静态模式
};
enum
{
POWERON,
POWEROFF
};
extern pfunc modefunctin[];
extern uint8_t refreshRfFlag;
extern uint8_t MatchOverFlag;//上电定时5S结束标志
extern uint8_t MODE19_i;
extern uint32_t r_DutyCycle;
extern uint32_t g_DutyCycle;
extern uint32_t b_DutyCycle;
extern uint8_t Brightness;
extern uint8_t CurrentStatus;
extern uint8_t CurrentModel;
extern uint8_t mode;
extern uint8_t FadeSpeed;
extern uint16_t speedOption[10];
extern uint8_t TimeSpeed;
extern uint8_t MODE19_i;
extern uint8_t only_read_charactertics_buffer[];
void TemperatureAdjustment(unsigned char value);
void rgbColorModel(uint8_t value, uint32_t *r_DutyCycle, uint32_t *g_DutyCycle, uint32_t *b_DutyCycle);
void functionOption(uint8_t key_value);
void UpdateDisplay(void);
void PWM_On(unsigned char on, unsigned char PWM_CHINAEL);
void PWM_Off(unsigned char off, unsigned char PWM_CHINAEL);
void updateParameter(void);
void updateParameterMode19(unsigned char mode);
void key_message_process(uint16_t msg);
void ir_message_process(void);
void ble_message_process(void);
void mapAudioToRGB(uint16_t audioValue) ;
void ble_callback(uint8_t value0,uint8_t value1,uint8_t value2,uint8_t value3);
#endif
project/example/ble/ble_peripheral/app/src/rom_symdefs.o
+275 -262
View File
@@ -1,262 +1,275 @@
#<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
0x11010c9d T prf_dst_task_get
0x11010dd1 T rom_env_init
0x110035c5 T gapc_get_bdaddr
0x11009261 T gatt_db_svc16_add
0x11009411 T gatt_db_svc_add
0x11009955 T gatt_db_svc_remove
0x1100a445 T gatt_srv_att_read_get_cfm
0x1100a57d T gatt_srv_att_val_set_cfm
0x1100b0d1 T gatt_srv_event_send
0x1100bfe1 T gatt_user_srv_register
0x11011ddc D llc_msg_handler_tab
0x10001698 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
#<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
0x1100e3c9 T prf_dst_task_get
0x1100e501 T rom_env_init
0x11004309 T gapc_get_bdaddr
0x11008c05 T gatt_db_svc16_add
0x11008d89 T gatt_db_svc_add
0x11002ba7 T _gatt_srv_att_read_get_cfm
0x11002c1b T _gatt_srv_att_val_set_cfm
0x1100a2f5 T gatt_srv_event_send
0x1100a6ad T gatt_user_srv_register
0x1100f070 D llc_msg_handler_tab
0x10001c70 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
0x10001c8b D sv_lock
0x10001c92 D sv_txlen
0x1000179d T rom_lld_con_rx
0x10001a2d T rom_lld_con_evt_start_cbk
0x10001a85 T rom_lld_con_frm_isr
0x1100866d T gatt_cli_mtu_exch
0x1100e6ad T rom_lld_disable_latency
0x1100e6d9 T rom_lld_enable_latency
0x10001c8a D evt_start
0x11003c39 T co_rand_word
0x11003c41 T co_random_init
0x10001c88 D adv_evt_start
0x10001c34 D gatt_srv_read_api_tbl
0x10001c48 D gatt_srv_write_api_tbl
project/example/ble/ble_peripheral/app/src/sleep.c
+473 -331
View File
@@ -1,331 +1,473 @@
/**
****************************************************************************************
*
* @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 <stdlib.h> // standard lib functions
#include <stddef.h> // standard definitions
#include <stdint.h> // standard integer definition
#include <stdbool.h> // boolean definition
#include "boot.h" // boot definition
#include "rwip.h" // RW SW initialization
#include "xc_drv_pwr.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 (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 (3300)
#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;
clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_RC;
// clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
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 system_sleep_init()
{
uint32_t wake_it_src;
#if (USE_XIP == 1)
xc_fmc_spi_init_oprt();
#endif
#if 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
#endif
xc_pwr_gpio_sleep_config();
wake_it_src = GPIO_IRQn_WAKE | RTC_IRQn_WAKE|TIMER_AO0_IRQn_WAKE| TIMER0_IRQn_WAKE;
xc_pwr_wake_it_set(wake_it_src);
}
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();
}
void cpu_switch_16M()
{
//M0_FCLK
cpr_m0_fclk_ctl__m0_fclk_div_p__setf(0x1);
cpr_m0_fclk_ctl__m0_fclk_direct_sw__setf(0x1);
//CTL_PCLK
cpr_ctl_pclk_grctl__ctl_pclk_gr__setf(0x8);
cpr_ctl_pclk_grctl__ctl_pclk_gr_upd__setf(0x1);
cprao_aon_bbldo_adj_set(0x3c);
/* The value needs to be configured to 7,
otherwise the current drop will be slower during sleep
and the clock accuracy of the rc32k will be affected.
*/
cprao_aon_lpoldo_adj_set(0x7);
}
void sleep_init(void)
{
system_sleep_init();
system_lightsleep_cfg();
/* Timer for sleep-wake*/
Timer_InitCfg_t timer_cfg;
timer_cfg.timer_src_clk = TIMER_CLK_SRC_32K;
timer_cfg.timer_div_clk = TIMER_DIV_CLK_32000Hz;
timer_cfg.timer_mode = TIMER_MODE_SINGLE;
xc_timer_init(TIMER0_IDX, &timer_cfg);
//cpu 32M->16M
// cpu_switch_16M();
}
__RAM_CODE void xc_ble_sleep(void)
{
xc_adc_powerdown();
xc_pwr_usb_off();
xc_pwr_rc16m_off();
xc_pwr_rc32k_calib_off();
xc_pwr_opa_tempsensor_off();
xc_pwr_opa_volr_off();
xc_pwr_revddldo_off();
xc_pwr_dcdc_close();
xc_pwr_rfdigital_off();
xc_pwr_rc32k_calib_off();
xc_pwr_modem_off();
xc_pwr_pd_lightsleep_set();
#if (USE_XIP == 1)
#if (USE_ROM_FLASH)
FMC_SPI_Flash_PowerDown();
xc_pwr_rom_off();
#else // (USE_ROM_FLASH)
// xc_fmc_spi_flash_power_down();
#endif // (USE_ROM_FLASH)
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
// cpr_fmc_ctl_set(0x3000 | (1 << 9)); // close FMC
for (int i = 0; i < 10; i++) {
__NOP();
__NOP();
__NOP();
}
#endif
// __disable_irq();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__WFI();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
// cpr_fmc_ctl_set(0x3503);
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
#if (USE_ROM_FLASH)
xc_pwr_rom_on();
FMC_SPI_Flash_WakeUp();
#else // (USE_ROM_FLASH)
// xc_fmc_spi_flash_wake_up();
#endif // (USE_ROM_FLASH)
xc_pwr_ao_timer_pclk32m_Set();
// __enable_irq();
#ifdef USED_DCDC
PWR_DCDC_Open();
#endif
xc_pwr_modem_on();
xc_pwr_rfdigital_on();
xc_adc_wakeup();
}
void enter_cpu_sleep()
{
cpr_ctlapbclken_grctl__uart0_pclk_en__setf(0);
cpr_ahbclken_grctl__dmas_hclk_en__setf(0);
cpr_slp_src_mask_set(0x1e000e);
__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
__WFI();
__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
cpr_slp_src_mask_set(0x1e001e);
// open uart clk
cpr_ctlapbclken_grctl__uart0_pclk_en__setf(1);
}
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)){
case RWIP_DEEP_SLEEP:
{
delay_us(200);
duration_timer = (HS_TO_US(duration) - SLEEP_TIME_EARLY);
xc_timer_set_value(TIMER0_IDX, duration_timer);
xc_timer_start(TIMER0_IDX);
xc_ble_sleep();
xc_timer_stop(TIMER0_IDX);
}
// no break
case RWIP_CPU_SLEEP:
{
enter_cpu_sleep();
}
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)
/**
****************************************************************************************
*
* @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 "sleep.h"
#include "xc6xxx.h"
// CPU early wake-up time (unit:us)
#define SLEEP_TIME_EARLY (3300)
#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 XTAL_32K
clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
#else
clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_RC;
#endif
// clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
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 system_sleep_init()
{
uint32_t wake_it_src;
#if (USE_XIP == 1)
#if (USE_ROM_FLASH)
FMC_SPI_Init_Oprt();
#else // (USE_ROM_FLASH)
xc_fmc_spi_init_oprt();
#endif // (USE_ROM_FLASH)
#endif
#if 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
#endif
xc_pwr_gpio_sleep_config();
wake_it_src =
GPIO_IRQn_WAKE | RTC_IRQn_WAKE | TIMER_AO0_IRQn_WAKE | TIMER0_IRQn_WAKE | MPU_IRQn_WAKE;
xc_pwr_wake_it_set(wake_it_src);
}
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();
}
void cpu_switch_16M()
{
// M0_FCLK
cpr_m0_fclk_ctl__m0_fclk_div_p__setf(0x1);
cpr_m0_fclk_ctl__m0_fclk_direct_sw__setf(0x1);
// CTL_PCLK
cpr_ctl_pclk_grctl__ctl_pclk_gr__setf(0x8);
cpr_ctl_pclk_grctl__ctl_pclk_gr_upd__setf(0x1);
cprao_aon_bbldo_adj_set(0x3c);
/* The value needs to be configured to 7,
otherwise the current drop will be slower during sleep
and the clock accuracy of the rc32k will be affected.
*/
cprao_aon_lpoldo_adj_set(0x7);
}
void sleep_init(void)
{
system_sleep_init();
system_lightsleep_cfg();
/* Timer for sleep-wake*/
Timer_InitCfg_t timer_cfg;
timer_cfg.timer_src_clk = TIMER_CLK_SRC_32K;
timer_cfg.timer_div_clk = TIMER_DIV_CLK_32000Hz;
timer_cfg.timer_mode = TIMER_MODE_SINGLE;
xc_timer_init(TIMER0_IDX, &timer_cfg);
// cpu 32M->16M
// cpu_switch_16M();
cprao_aon_bbldo_adj_set(0x2a);
cprao_aon_lpoldo_adj_set(0x7);
}
__RAM_CODE void xc_ble_sleep(void)
{
xc_adc_powerdown();
xc_pwr_usb_off();
xc_pwr_rc16m_off();
xc_pwr_rc32k_calib_off();
xc_pwr_opa_tempsensor_off();
xc_pwr_opa_volr_off();
xc_pwr_revddldo_off();
xc_pwr_dcdc_close();
xc_pwr_rfdigital_off();
xc_pwr_rc32k_calib_off();
cprao_aon_reg4__bb_coreldo_normal_sw_mux__setf(1);
xc_pwr_modem_off();
xc_pwr_pd_lightsleep_set();
#if (USE_XIP == 1)
#if (USE_ROM_FLASH)
FMC_SPI_Flash_PowerDown();
#else // (USE_ROM_FLASH)
// xc_fmc_spi_flash_power_down();
#endif // (USE_ROM_FLASH)
xc_pwr_rom_off();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
// cpr_fmc_ctl_set(0x3000 | (1 << 9)); // close FMC
for (int i = 0; i < 10; i++) {
__NOP();
__NOP();
__NOP();
}
#endif
// __disable_irq();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__WFI();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
// cpr_fmc_ctl_set(0x3503);
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
xc_pwr_rom_on();
#if (USE_ROM_FLASH)
FMC_SPI_Flash_WakeUp();
#else // (USE_ROM_FLASH)
// xc_fmc_spi_flash_wake_up();
#endif // (USE_ROM_FLASH)
xc_pwr_ao_timer_pclk32m_Set();
// __enable_irq();
#ifdef USED_DCDC
xc_pwr_dcdc_open();
#endif
xc_pwr_modem_on();
xc_pwr_rfdigital_on();
xc_adc_wakeup();
}
void enter_cpu_sleep()
{
cpr_ctlapbclken_grctl__uart0_pclk_en__setf(0);
cpr_ahbclken_grctl__dmas_hclk_en__setf(0);
cpr_slp_src_mask_set(0x1e000e);
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__WFI();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
cpr_slp_src_mask_set(0x1e001e);
// open uart clk
cpr_ctlapbclken_grctl__uart0_pclk_en__setf(1);
}
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)) {
case RWIP_DEEP_SLEEP: {
duration_timer = (HS_TO_US(duration) - SLEEP_TIME_EARLY);
xc_timer_set_value(TIMER0_IDX, duration_timer);
xc_timer_start(TIMER0_IDX);
// Before you sleep, turn off the peripheral to make sure it doesn't generate interrupts,
// and then turn it on again after you sleep up.
// For example, timer interrupts
xc_rc32k_soft_calib_disable();
xc_ble_sleep();
xc_timer_stop(TIMER0_IDX);
xc_rc32k_soft_calib_enable();
}
// no break
case RWIP_CPU_SLEEP: {
// enter_cpu_sleep();
} break;
case RWIP_ACTIVE:
default: {
// nothing to do.
} break;
}
// Checks for sleep have to be done with interrupt disabled
GLOBAL_INT_RESTORE();
#if (POWER_ON)
power_off_check();
#endif // (POWER_ON)
}
#endif // (SLEEP_ENABLE)
#if (POWER_ON)
void system_deepsleep_init()
{
uint32_t wake_it_src;
#if (USE_XIP == 1)
xc_fmc_spi_init_oprt();
#endif
xc_pwr_gpio_sleep_config();
wake_it_src = GPIO_IRQn_WAKE | RTC_IRQn_WAKE;
xc_pwr_wake_it_set(wake_it_src);
}
void system_deepsleep_cfg()
{
#if (USE_XIP != 1)
cprao_aon_puctrl1_set(0xf);
#endif
cprao_aon_sys_time_set((RST_READY_TIME << 12) | (OSC32_STABLE_TIME));
xc_pwr_pd_deepsleep_set();
xc_pwr_sleepsrc_mask_set(0x1e001e);
xc_pwr_osc_off();
}
void cpu_enter_deepsleep()
{
system_deepsleep_init();
// PWRKEY Initialization is required after deep sleep wakeup
xc_pwr_pwrkey_init();
xc_pwr_pwrkey_deepsleep_wake_config(TOUCH_KEY,
DEEP_SLEEP_GPIO_WAKE_HIGH_LEVEL);
// xc_pwr_pwrkey_deepsleep_wake_config(TOUCH_KEY,
// DEEP_SLEEP_GPIO_WAKE_LOW_LEVEL);
system_deepsleep_cfg();
xc_deep_sleep();
}
void power_on_check()
{
uint16_t power_key_scan = 0;
uint16_t resleep_count = 0;
uint16_t power_on_count = 0;
while (1) {
if (power_key_scan == POWER_KEY_SCAN_COUNT) {
power_key_scan = 0;
if (xc_gpio_read_pin(TOUCH_KEY) == 0) {
if (resleep_count >= GENERAL_RESLEEP_TIME_COUNT) {
cpu_enter_deepsleep();
}
resleep_count++;
power_on_count = 0;
} else {
if (power_on_count == POWER_ON_TIME) {
break;
}
power_on_count++;
resleep_count = 0;
}
}
power_key_scan++;
}
xc_pwr_pwrkey_init();
}
void power_off_check()
{
if (xc_gpio_read_pin(TOUCH_KEY) == 1) {
uint16_t power_key_scan = 0;
uint16_t resleep_count = 0;
uint16_t power_off_count = 0;
while (1) {
if (power_key_scan == POWER_KEY_SCAN_COUNT) {
power_key_scan = 0;
if (xc_gpio_read_pin(TOUCH_KEY) == 0) {
if (resleep_count >= GENERAL_RESLEEP_TIME_COUNT) {
break;
}
resleep_count++;
power_off_count = 0;
} else {
if (power_off_count == POWER_OFF_TIME) {
cpu_enter_deepsleep();
}
power_off_count++;
resleep_count = 0;
}
}
power_key_scan++;
}
xc_pwr_pwrkey_init();
}
}
#endif // (POWER_ON)
__RAM_CODE void MPU_Handler(void)
{
cprao_aon_slp_pd_mask_set(0x001);
#if XTAL_32K
cprao_aon_ctl_clk32k_set(0x109);
#endif
printf("MPU_Handler\n");
WDT_InitCfg_t wdt_cfg ;
wdt_cfg.WorkMode = WDT_WORK_MODE0;
wdt_cfg.ReloadValue = WDT_CLK_32M_RESET_MODE0_4096US;
wdt_cfg.PclkSel = WDT_WORK_32M;
xc_wdt_init(&wdt_cfg);
xc_wdt_start();
while(1);
}
// Timer 0 is occupied by sleep and cannot register interrupt functions.
__RAM_CODE void timer0_callback(void *context)
{
}
project/example/ble/ble_peripheral/app/src/sleep.h
+17
View File
@@ -0,0 +1,17 @@
#ifndef _SLEEP_H_
#define _SLEEP_H_
#if (POWER_ON)
#define POWER_KEY_SCAN_COUNT 4000
#define GENERAL_RESLEEP_TIME_COUNT 30
#define POWER_ON_TIME 1200
#define POWER_OFF_TIME 1200
#define TOUCH_KEY GPIO_4
#endif //(POWER_ON)
void sleep_init(void);
void sleep_schedule(void);
#endif //_SLEEP_H_
project/example/ble/ble_peripheral/app/src/startup_xinc.s
+245 -244
View File
@@ -1,244 +1,245 @@
;/*****************************************************************************
; * @file: startup_xinc.s
; * @purpose: CMSIS Cortex-M0 Core Device Startup File for the
; * Device xinc.
; *****************************************************************************/
Stack_Size EQU 0x00000800
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 0 ; 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
;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
;/*****************************************************************************
; * @file: startup_xinc.s
; * @purpose: CMSIS Cortex-M0 Core Device Startup File for the
; * Device xinc.
; *****************************************************************************/
Stack_Size EQU 0x000006f0
AREA STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem SPACE Stack_Size
__initial_sp
Heap_Size EQU 0x00000000
AREA HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem SPACE Heap_Size
__heap_limit
PRESERVE8
THUMB
; Vector Table Mapped to Address 0 at Reset
AREA RESET, DATA, READONLY
EXPORT __Vectors
EXPORT __Vectors_End
EXPORT __Vectors_Size
__Vectors DCD __initial_sp ; Top of Stack
DCD Reset_Handler ; Reset Handler
DCD NMI_Handler ; NMI Handler
DCD HardFault_Handler ; Hard Fault Handler
DCD MemManage_Handler ; MPU Fault Handler
DCD BusFault_Handler ; Bus Fault Handler
DCD UsageFault_Handler ; Usage Fault Handler
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD SVC_Handler ; SVCall Handler
DCD DebugMon_Handler ; Debug Monitor Handler
DCD 0 ; Reserved
DCD PendSV_Handler ; PendSV Handler
DCD SysTick_Handler ; SysTick Handler
; External Interrupts
; ToDo: Add here the vectors for the device specific external interrupts handler
DCD BLE_Handler ; 0
DCD DMA_Handler ; 1
DCD CPR_Handler ; 2
DCD GPIO_Handler ; 3
DCD RTC_Handler ; 4
DCD TIMER0_Handler ; 5
DCD TIMER1_Handler ; 6
DCD TIMER2_Handler ; 7
DCD TIMER3_Handler ; 8
DCD WDT_Handler ; 9
DCD I2C_Handler ; 10
DCD UART0_Handler ; 11
DCD UART1_Handler ; 12
DCD SPI0_Handler ; 13
DCD SPI1_Handler ; 14
DCD 0 ; 15
DCD 0 ; 16
DCD GADC_Handler ; 17
DCD PWM_Handler ; 18
DCD AES_Handler ; 19
DCD USB_Handler ; 20
DCD AUDIO_Handler ; 21
DCD RF24G_Handler ; 22
DCD SPI2_Handler ; 23
DCD MPU_Handler ; 24
DCD UART2_Handler ; 25
DCD I2S_Handler ; 26
DCD AOTIMER0_Handler ; 27
DCD AOTIMER1_Handler ; 28
DCD CMP_Handler ; 29
DCD FMC_Handler ; 30
DCD CAN_Handler ; 31
__Vectors_End
__Vectors_Size EQU __Vectors_End - __Vectors
AREA |.text|, CODE, READONLY
; Reset Handler
Reset_Handler PROC
EXPORT Reset_Handler [WEAK]
IMPORT SystemInit
IMPORT __main
LDR r0, =0x4000013C ; remap
LDR r1, =0x10000001
STR r1, [r0]
LDR R0, =SystemInit
BLX R0
LDR R0, =__main
BX R0
ENDP
; Dummy Exception Handlers (infinite loops which can be modified)
NMI_Handler PROC
EXPORT NMI_Handler [WEAK]
B .
ENDP
HardFault_Handler\
PROC
EXPORT HardFault_Handler [WEAK]
B .
ENDP
MemManage_Handler\
PROC
EXPORT MemManage_Handler [WEAK]
B .
ENDP
BusFault_Handler\
PROC
EXPORT BusFault_Handler [WEAK]
B .
ENDP
UsageFault_Handler\
PROC
EXPORT UsageFault_Handler [WEAK]
B .
ENDP
SVC_Handler PROC
EXPORT SVC_Handler [WEAK]
B .
ENDP
DebugMon_Handler\
PROC
EXPORT DebugMon_Handler [WEAK]
B .
ENDP
Default_Handler PROC
EXPORT BLE_Handler [WEAK]
EXPORT DMA_Handler [WEAK]
EXPORT CPR_Handler [WEAK]
EXPORT GPIO_Handler [WEAK]
EXPORT RTC_Handler [WEAK]
EXPORT TIMER0_Handler [WEAK]
EXPORT TIMER1_Handler [WEAK]
EXPORT TIMER2_Handler [WEAK]
EXPORT TIMER3_Handler [WEAK]
EXPORT WDT_Handler [WEAK]
EXPORT I2C_Handler [WEAK]
EXPORT UART0_Handler [WEAK]
EXPORT UART1_Handler [WEAK]
EXPORT SPI0_Handler [WEAK]
EXPORT SPI1_Handler [WEAK]
;EXPORT KBS_Handler [WEAK]
;EXPORT QDEC_Handler [WEAK]
EXPORT GADC_Handler [WEAK]
EXPORT PWM_Handler [WEAK]
EXPORT AES_Handler [WEAK]
EXPORT PendSV_Handler [WEAK]
EXPORT SysTick_Handler [WEAK]
EXPORT USB_Handler [WEAK];20
EXPORT AUDIO_Handler [WEAK];21
EXPORT RF24G_Handler [WEAK];22
EXPORT SPI2_Handler [WEAK];23
EXPORT MPU_Handler [WEAK];24
EXPORT UART2_Handler [WEAK];25
EXPORT I2S_Handler [WEAK];26
EXPORT AOTIMER0_Handler [WEAK];27
EXPORT AOTIMER1_Handler [WEAK];28
EXPORT CMP_Handler [WEAK];29
EXPORT FMC_Handler [WEAK];30
EXPORT CAN_Handler [WEAK];31
PendSV_Handler
SysTick_Handler
BLE_Handler
RF24G_Handler
DMA_Handler
CPR_Handler
GPIO_Handler
RTC_Handler
TIMER0_Handler
TIMER1_Handler
TIMER2_Handler
TIMER3_Handler
WDT_Handler
I2C_Handler
I2S_Handler
UART0_Handler
UART1_Handler
UART2_Handler
SPI0_Handler
SPI1_Handler
SPI2_Handler
MPU_Handler
;KBS_Handler
;QDEC_Handler
GADC_Handler
PWM_Handler
AUDIO_Handler
;SIM_Handler
AES_Handler
AOTIMER0_Handler
AOTIMER1_Handler
CMP_Handler
FMC_Handler
CAN_Handler
USB_Handler
B .
ENDP
ALIGN
; User Initial Stack & Heap
IMPORT __use_two_region_memory
EXPORT __user_initial_stackheap
__user_initial_stackheap
LDR R0, = Heap_Mem
LDR R1, = (Stack_Mem + Stack_Size)
LDR R2, = (Heap_Mem + Heap_Size)
LDR R3, = Stack_Mem
BX LR
ALIGN
END
project/example/ble/ble_peripheral/app/src/system_xinc.c
+128 -123
View File
@@ -1,123 +1,128 @@
/**
* Initialize the system
*
* @param none
* @return none
*
* @brief Setup the microcontroller system
*
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdio.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 *)(0x11013000 + 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);
}
#if (SCATTER_LOAD_RAM_EM)
#define readl(addr) (*(volatile unsigned int *) (addr))
#define writel(addr, value) (*(volatile unsigned int *) (addr) = (value))
#endif
void SystemInit(void)
{
WDT_ResetInit();
#if (USE_XIP == 1)
set_vector();
#endif
#if (SCATTER_LOAD_RAM_EM)
//enable BT CLK
writel(0x40000040, readl(0x40000040) | (0x01 << 4) | 0xFFFF0000);
#endif
}
__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 */
}
/**
* Initialize the system
*
* @param none
* @return none
*
* @brief Setup the microcontroller system
*
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdio.h>
#include "xc6xxx.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define __DEBUG_OUT_PORT 0
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
#define VECTOR_NUM 48
#if SINGLE_OTA
#define LOADING_ADDR 0x11015000
#else
#define LOADING_ADDR 0x11013000
#endif
void set_vector(void)
{
#if (USE_XIP == 1)
__disable_irq();
for (uint32_t i = 0, *Pvector = (uint32_t *)(LOADING_ADDR + 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);
}
#if (SCATTER_LOAD_RAM_EM)
#define readl(addr) (*(volatile unsigned int *)(addr))
#define writel(addr, value) (*(volatile unsigned int *)(addr) = (value))
#endif
void SystemInit(void)
{
WDT_ResetInit();
#if (USE_XIP == 1)
set_vector();
#endif
#if (SCATTER_LOAD_RAM_EM)
// enable BT CLK
writel(0x40000040, readl(0x40000040) | (0x01 << 4) | 0xFFFF0000);
#endif
}
__RAM_CODE int sendchar(int c)
{
unsigned int status;
#if (__DEBUG_OUT_PORT == 1)
for (;;) {
status = (*((volatile unsigned *)(0x40011000 + 0x14)));
status &= 0x20;
if (status == 0x20)
break;
}
(*((volatile unsigned *)(0x40011000 + 0x00))) = c;
return (1);
#else
for (;;) {
status = (*((volatile unsigned *)(0x40010000 + 0x14)));
status &= 0x20;
if (status == 0x20)
break;
}
(*((volatile unsigned *)(0x40010000 + 0x00))) = c;
return (1);
#endif
}
struct __FILE
{
int handle; /* Add whatever you need here */
};
FILE __stdout;
__RAM_CODE int fputc(int ch, FILE *f) { return (sendchar(ch)); }
int ferror(FILE *f)
{
/* Your implementation of ferror */
return EOF;
}
void _ttywrch(int ch) { sendchar(ch); }
void _sys_exit(int return_code)
{
label:
goto label; /* endless loop */
}
project/example/ble/ble_peripheral/app/src/timer.c
-233
View File
@@ -1,233 +0,0 @@
/*!
* \file timer.c
*
* \brief Target timer implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "timer.h"
#include "xc_drv_timer.h"
#include "rgblight.h"
#include "nec_infrared.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
TimerStatus_t timer_status =
{
.t0_flag = false,
// .t1_flag = false,
// .t2_flag = false,
// .t3_flag = false,
};
// 定义多个软定时器
Timer timer1, timer2, timer4, timer5;
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
// 初始化定时器
void initTimer(Timer *timer)
{
timer->count = 0;
timer->active = 1;
}
// 更新定时器
void updateTimer(Timer *timer)
{
if (timer->active && timer->count > 0)
{
timer->count--;
if (timer->count == 0)
{
timer->active = 0; // 定时器到达设定时间，将活跃状态置为0
}
}
}
// 启动定时器
void startTimer(Timer *timer, unsigned int duration)
{
timer->count = duration;
timer->active = 1;
}
// 中止定时器
void stopTimer(Timer *timer)
{
timer->active = 1;
timer->count = 0;
}
// 软定时器1到达设定时间时执行的函数
void timer1Callback(uint8_t mode)//模式切换回调
{
modefunctin[mode]();
}
// 软定时器2到达设定时间时执行的函数
void timer2Callback(void)//占空比刷新回调
{
UpdateDisplay();//更新显示
}
// 软定时器4到达设定时间时执行的函数
void timer4Callback(void)//对码计时
{
MatchOverFlag = 1;
}
// 软定时器5到达设定时间时执行的函数
void timer5Callback(uint8_t mode)//模式循环
{
if (++MODE19_i > 18) //先自增，如果大于20，就赋值0；
MODE19_i = 0;
if (mode == MODE19)
{
updateParameterMode19(MODE19_i);
startTimer(&timer1, 1); // 立刻启动定时器1，设定间隔为1ms，执行1次,每次进来就是切换到下一个程序，需要立刻切换，
startTimer(&timer5, 20000);//程序切换周期20s
}
}
/**
* @brief timer0_init
* @details
* @param void
* @retval void
*/
void timer0_2_init(void)
{
uint32_t us = 1000;//定时1ms
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;
// Timer0 Config & Start
xc_timer_init(TIMER0_IDX, &timer_cfg);
xc_timer_set_value(TIMER0_IDX, us);//for(int m=0;m<0x455000;m++);
xc_timer_start(TIMER0_IDX);
// Timer1 Config & Start
us = 20000;//定时20ms
timer_cfg.timer_mode = TIMER_MODE_SINGLE;//单次计时
xc_timer_init(TIMER2_IDX, &timer_cfg);
xc_timer_set_value(TIMER2_IDX, us);
// xc_timer_start(TIMER2_IDX);
startTimer(&timer1, 1); // 立刻启动定时器1，设定间隔为1ms，执行1次
startTimer(&timer4, 5000); // 立刻启动定时器1，设定间隔为5s，执行1次
}
/**
* @brief Timer0_Callback
* @details Timer0 handler callback function
* @param void *context
* @retval void
*/
__RAM_CODE void timer0_callback(void *context)
{
// 在中断服务函数中更新定时器0的状态
updateTimer(&timer1);
updateTimer(&timer2);
// updateTimer(&timer3);
updateTimer(&timer4);
updateTimer(&timer5);
if (!timer1.active && timer1.count == 0)
{
stopTimer(&timer1);
if (CurrentModel == DYNAMICMODE)
{
timer1Callback(mode); // 执行定时器1到达设定时间时的函数
}
if (CurrentStatus == DYNAMICEEFECT) //处于动态效果才重复启动定时器
{
if (mode == MODE19)
{
if (MODE19_i == MODE0)
return;
else if (MODE19_i == MODE1 || MODE19_i == MODE2 || MODE19_i == MODE3)
startTimer(&timer1, FadeSpeed); // 重新启动定时器1，设定间隔为10ms
else
startTimer(&timer1, speedOption[TimeSpeed]); // 重新启动定时器1，设定间隔为500ms
}
else
{
if (mode == MODE1 || mode == MODE2 || mode == MODE3)
startTimer(&timer1, FadeSpeed); // 重新启动定时器1，设定间隔为10ms
else
startTimer(&timer1, speedOption[TimeSpeed]); // 重新启动定时器1，设定间隔为500ms
}
}
}
// 检查定时器2是否到达设定时间
if (!timer2.active && timer2.count == 0)
{
stopTimer(&timer2);
timer2Callback(); // 执行定时器2到达设定时间时的函数
}
if (!timer4.active && timer4.count == 0)
{
stopTimer(&timer4);
timer4Callback(); // 执行定时器4到达设定时间时的函数
}
if (!timer5.active && timer5.count == 0)
{
stopTimer(&timer5);
timer5Callback(mode); // 执行定时器5到达设定时间时的函数
}
}
/**
* @brief Timer1_Callback
* @details Timer1 handler callback function
* @param void *context
* @retval void
*/
__RAM_CODE void timer2_callback(void *context)
{
xc_timer_stop(TIMER2_IDX);
uint32_t us = 20000;
xc_timer_set_value(TIMER2_IDX, us);
IR.IR_decode_bit = 0; //电平计数超过了码元长度 清除位数计数
IR.IR_code = 0;
IR.IR_event = 0;
IR.IR_code_get = 0;
IR.low_8bit = 0;
IR.hig_8bit = 0;
IR.rece_ok = 0;
}
project/example/ble/ble_peripheral/app/src/timer.h
-85
View File
@@ -1,85 +0,0 @@
/*!
* \file timer.h
*
* \brief The head file of timer.c
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __TIMER_H__
#define __TIMER_H__
#ifdef __cplusplus
extern "C" {
#endif
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
typedef struct TimerStatus_s
{
uint8_t t0_flag;
uint8_t t1_flag;
uint8_t t2_flag;
uint8_t t3_flag;
} TimerStatus_t;
// 定义定时器结构体
typedef struct {
unsigned int count; // 计数器
unsigned char active; // 活跃状态
} Timer;
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
extern Timer timer1, timer2, timer4, timer5;
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void timer0_2_init(void);
void initTimer(Timer *timer);
void updateTimer(Timer *timer);
void startTimer(Timer *timer, unsigned int duration);
void stopTimer(Timer *timer);
void timer1Callback(uint8_t mode);
void timer2Callback(void);
//void timer3Callback(void);
void timer4Callback(void);
void timer5Callback(uint8_t mode);
#ifdef __cplusplus
}
#endif
#endif /* __TIMER_H__ */
project/example/ble/ble_peripheral/app/src/uart.c
+209 -181
View File
@@ -1,181 +1,209 @@
/*!
* \file uart.c
*
* \brief Target uart implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "uart.h"
#include "xc_drv_uart.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
uint8_t only_read_charactertics_buffer[5] = {5, 4, 3, 2, 1};
uint8_t only_read_charactertics_buffer_length = 5;
uint8_t buffer[5] = {0xAA, 0xAA, 0xAA, 0xAA, 0xAA};
extern bool buffer_complet_flag;
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
* @brief uart_demo
* @details
* @param void
* @retval void
*/
void uart_demo(void)
{
DEBUG("__UART_DEMO__\n");
uint8_t uart_handle = UART0_IDX;
if (uart_handle == UART1_IDX)
{
GPIO_InitCfg_t gpio_cfg = {0};
gpio_cfg.Mux = GPIO_Mux0;
gpio_cfg.Pull = GPIO_PULLUP;
gpio_cfg.Int = NOT_INT;
gpio_cfg.Pin = GPIO_3;
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
gpio_cfg.FunSel = UART1_TX;
xc_gpio_init(&gpio_cfg);
gpio_cfg.Pin = GPIO_2;
gpio_cfg.Dir = GPIO_DIR_INPUT;
gpio_cfg.FunSel = UART1_RX;
xc_gpio_init(&gpio_cfg);
UART_InitCfg_t uart_cfg = {0};
uart_cfg.Parity = UART_PARITY_DISABLE;
uart_cfg.StopBits = UART_TCR_STOP_1BITS;
uart_cfg.WordLength = UART_DATA_8_BITS;
uart_cfg.BaudRate = UART_BAUDRATE_2400;
uart_cfg.HardwareFlowControl = UART_HWFC_DISABLE;
xc_uart_init(uart_handle, &uart_cfg);
}
else if (uart_handle == UART2_IDX)
{
GPIO_InitCfg_t gpio_cfg = {0};
gpio_cfg.Mux = GPIO_Mux1;
gpio_cfg.Pull = GPIO_PULLUP;
gpio_cfg.Int = NOT_INT;
gpio_cfg.FunSel = GPIO_Dx;
gpio_cfg.Pin = GPIO_32; // uart2 tx
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
xc_gpio_init(&gpio_cfg);
gpio_cfg.Pin = GPIO_31; // uart2 rx
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(uart_handle, &uart_cfg);
}
xc_uart_enable_rx_it(uart_handle);
if (uart_handle == UART0_IDX)
{
NVIC_EnableIRQ(UART0_IRQn);
}
else if (uart_handle == UART1_IDX)
{
NVIC_EnableIRQ(UART1_IRQn);
}
else if (uart_handle == UART2_IDX)
{
NVIC_EnableIRQ(UART2_IRQn);
}
// for(int i=0; i<26; i++)
// {
// rxbuff[i] = i+'A';
// }
// xc_uart_send_data(uart_handle,rxbuff,26);
printf("test\n");
// while(1)
// {
// data_len = xc_uart_receive_data(uart_handle, rxbuff);
// if(data_len)
// {
// xc_uart_send_data(uart_handle,rxbuff,data_len);
// data_len = 0;
// }
// }
}
void scan_uart(void)
{
// data_len = xc_uart_receive_data(uart_handle, rxbuff);
if (buffer_complet_flag)
{
static uint8_t n = 1;
// uint16_t data_len = 0;
uint8_t *rxbuff;
uint8_t uart_handle = UART0_IDX;
buffer_complet_flag = 0;
xc_uart_receive_data(uart_handle, rxbuff);
for (uint8_t i = 0; i < 5; i++)
{
only_read_charactertics_buffer[i] = rxbuff[i];
}
if (n == 1)
{
n--;
xc_uart_send_data(uart_handle, only_read_charactertics_buffer, 5);
}
// data_len = 0;
}
}
/*!
* \file uart.c
*
* \brief Target uart implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "uart.h"
#include "xc_drv_uart.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
uint8_t only_read_charactertics_buffer[5] = {5, 4, 3, 2, 1};
uint8_t only_read_charactertics_buffer_length = 5;
uint8_t buffer[5] = {0xAA, 0xAA, 0xAA, 0xAA, 0xAA};
extern bool buffer_complet_flag;
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
* @brief uart_demo
* @details
* @param void
* @retval void
*/
void uart_demo(void)
{
DEBUG("__UART_DEMO__\n");
uint8_t uart_handle = UART0_IDX;
if (uart_handle == UART1_IDX)
{
GPIO_InitCfg_t gpio_cfg = {0};
gpio_cfg.Mux = GPIO_Mux0;
gpio_cfg.Pull = GPIO_PULLUP;
gpio_cfg.Int = NOT_INT;
gpio_cfg.Pin = GPIO_3;
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
gpio_cfg.FunSel = UART1_TX;
xc_gpio_init(&gpio_cfg);
gpio_cfg.Pin = GPIO_2;
gpio_cfg.Dir = GPIO_DIR_INPUT;
gpio_cfg.FunSel = UART1_RX;
xc_gpio_init(&gpio_cfg);
UART_InitCfg_t uart_cfg = {0};
uart_cfg.Parity = UART_PARITY_DISABLE;
uart_cfg.StopBits = UART_TCR_STOP_1BITS;
uart_cfg.WordLength = UART_DATA_8_BITS;
uart_cfg.BaudRate = UART_BAUDRATE_2400;
uart_cfg.HardwareFlowControl = UART_HWFC_DISABLE;
xc_uart_init(uart_handle, &uart_cfg);
}
else if (uart_handle == UART2_IDX)
{
GPIO_InitCfg_t gpio_cfg = {0};
gpio_cfg.Mux = GPIO_Mux1;
gpio_cfg.Pull = GPIO_PULLUP;
gpio_cfg.Int = NOT_INT;
gpio_cfg.FunSel = GPIO_Dx;
gpio_cfg.Pin = GPIO_32; // uart2 tx
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
xc_gpio_init(&gpio_cfg);
gpio_cfg.Pin = GPIO_31; // uart2 rx
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(uart_handle, &uart_cfg);
}
xc_uart_enable_rx_it(uart_handle);
if (uart_handle == UART0_IDX)
{
NVIC_EnableIRQ(UART0_IRQn);
}
else if (uart_handle == UART1_IDX)
{
NVIC_EnableIRQ(UART1_IRQn);
}
else if (uart_handle == UART2_IDX)
{
NVIC_EnableIRQ(UART2_IRQn);
}
// for(int i=0; i<26; i++)
// {
// rxbuff[i] = i+'A';
// }
// xc_uart_send_data(uart_handle,rxbuff,26);
// printf("test\n");
// while(1)
// {
// data_len = xc_uart_receive_data(uart_handle, rxbuff);
// if(data_len)
// {
// xc_uart_send_data(uart_handle,rxbuff,data_len);
// data_len = 0;
// }
// }
}
//void scan_uart(uint8_t *arr)
//{
//// data_len = xc_uart_receive_data(uart_handle, rxbuff);
// if (buffer_complet_flag)
// {
// static uint8_t n = 1;
// // uint16_t data_len = 0;
// uint8_t *rxbuff;
// uint8_t uart_handle = UART0_IDX;
// buffer_complet_flag = 0;
//// xc_uart_receive_data(uart_handle, rxbuff);
//// for (uint8_t i = 0; i < 5; i++)
//// {
//// only_read_charactertics_buffer[i] = rxbuff[i];
//// }
// if (n == 1)
// {
// n--;
// xc_uart_send_data(uart_handle, arr, 4);
// }
// // data_len = 0;
// }
//}
void scan_uart(uint8_t *arr)
{
uint8_t uart_handle = UART0_IDX;
buffer_complet_flag = false; // 清除标志
// 组帧：帧头 + 数据 + 校验
uint8_t frame[6]; // 1字节帧头 + 4字节数据 + 1字节校验位
frame[0] = 0xAA; // 帧头标志
for (uint8_t i = 0; i < 4; i++)
{
frame[1 + i] = arr[i]; // 填充数据
}
// 校验位：简单累加校验
uint8_t checksum = 0;
for (uint8_t i = 0; i < 5; i++) // 帧头和数据
{
checksum += frame[i];
}
frame[5] = checksum; // 校验位
// 发送帧
xc_uart_send_data(uart_handle, frame, 6); // 发送完整帧
// DEBUG("temp[0]:%d,temp[1]:%d,temp[2]:%d,temp[3]:%d,temp[4]:%d,temp[5]:%d\n",frame[0],frame[1],frame[2],frame[3],frame[4],frame[5]);
}
project/example/ble/ble_peripheral/app/src/uart.h
+64 -64
View File
@@ -1,64 +1,64 @@
/*!
* \file uart.h
*
* \brief The head file of uart.c
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __UART_H__
#define __UART_H__
#ifdef __cplusplus
extern "C" {
#endif
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void uart_demo(void);
void scan_uart(void);
#ifdef __cplusplus
}
#endif
#endif /* __UART_H__ */
/*!
* \file uart.h
*
* \brief The head file of uart.c
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __UART_H__
#define __UART_H__
#ifdef __cplusplus
extern "C" {
#endif
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void uart_demo(void);
void scan_uart(uint8_t *arr);
#ifdef __cplusplus
}
#endif
#endif /* __UART_H__ */
project/example/ble/ble_peripheral/app/src/uart_state.c
+5
View File
@@ -0,0 +1,5 @@
#include <stdbool.h>
// The product UART implementation references this application-level flag.
// Keep it independent from the old RGB application during SDK migration.
bool buffer_complet_flag = false;
project/example/ble/ble_peripheral/app/src/usr_server.c
+219 -219
View File
@@ -1,219 +1,219 @@
/**
****************************************************************************************
*
* @file usr_server.c
*
* @brief Custom Server profile database definitions.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.p
*
****************************************************************************************
*/
#include "usr_server.h"
#include "gpio.h"
#include "xc_drv_gpio.h"
#include "rgblight.h"
#if (BLE_APP_PRESENT)
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;
extern uint8_t only_read_charactertics_buffer[5];
extern uint8_t only_read_charactertics_buffer_length;
__WEAK void ble_callback(uint8_t value0,uint8_t value1,uint8_t value2,uint8_t value3)
{
}
static const gatt_att16_desc_t custom_server_atts[] =
{
[CUSTOM_SVC_DECL] =
{
.uuid16 = GATT_DECL_PRIMARY_SERVICE,
.info = GATT_ATT_RD_BIT,
.ext_info = 0,
},
[CUSTOM_SVC_RX_CHAR_DECL_CHAR] =
{
.uuid16 = GATT_DECL_CHARACTERISTIC,
.info = GATT_ATT_RD_BIT,
.ext_info = 0,
},
[CUSTOM_SVC_RX_CHAR_VAL] =
{
.uuid16 = CUSTOM_SVC_RX_CHAR_UUID,
.info = GATT_ATT_RD_BIT | GATT_ATT_WC_BIT | GATT_ATT_WR_BIT,
.ext_info =
GATT_ATT_NO_OFFSET_BIT | CUSTOM_SVC_RX_CHAR_VAL_MAX_LENGTH,
},
[CUSTOM_SVC_TX_CHAR_DECL_CHAR] =
{
.uuid16 = GATT_DECL_CHARACTERISTIC,
.info = GATT_ATT_RD_BIT,
.ext_info = 0,
},
[CUSTOM_SVC_TX_CHAR_VAL] =
{
.uuid16 = CUSTOM_SVC_TX_CHAR_UUID,
.info = GATT_ATT_RD_BIT | GATT_ATT_N_BIT,
.ext_info =
GATT_ATT_NO_OFFSET_BIT | CUSTOM_SVC_TX_CHAR_VAL_MAX_LENGTH,
},
[CUSTOM_SVC_TX_CHAR_CFG] =
{
.uuid16 = GATT_DESC_CLIENT_CHAR_CFG,
.info = GATT_ATT_RD_BIT | GATT_ATT_WR_BIT,
.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,0x22};
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);
status = xc_ble_gatt_srv_read_cfm(conidx, user_lid, token, GAP_ERR_NO_ERROR,
sizeof(only_read_charactertics_buffer), sizeof(only_read_charactertics_buffer), only_read_charactertics_buffer);
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)[0]), length);
// 检查写入的数据是否是 0x12
// if (length == 1 && co_buf_data(p_data)[0] == 0x12)
if (length == 4)
{
ble_callback(co_buf_data(p_data)[0],co_buf_data(p_data)[1],co_buf_data(p_data)[2],co_buf_data(p_data)[3]);
// 设置指定的 GPIO 引脚为高电平
// xc_gpio_write_pin(LED3_PIN, GPIO_PIN_SET);
// only_read_charactertics_buffer[0] = co_buf_data(p_data)[0];r_DutyCycle*Brightness/10
// only_read_charactertics_buffer[0] = (uint8_t)(r_DutyCycle*Brightness/10);
// only_read_charactertics_buffer[1] = co_buf_data(p_data)[1];
// only_read_charactertics_buffer[2] = co_buf_data(p_data)[2];
// only_read_charactertics_buffer[3] = co_buf_data(p_data)[3];
}
else
{
// xc_gpio_write_pin(LED3_PIN, GPIO_PIN_RESET);
// LOGI("LED3_PIN:%d", xc_gpio_read_pin(LED3_PIN));
}
if (hdl == srv_get_hdl_from_att_idx(CUSTOM_SVC_TX_CHAR_CFG))
{
if ((co_buf_data(p_data)[0] == 0) && (co_buf_data(p_data)[1] == 0))
{
custom_svc_tx_char_notify = DISABLE;
}
else
{
custom_svc_tx_char_notify = ENABLE;
uint8_t data[] = {0x12, 0x13, 0x14};
slave_send_data(data, sizeof(data), CUSTOM_SVC_TX_CHAR_VAL);
}
}
}
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;
uint16_t custom_svc_uuid = 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_service16_add(
srv_user_lid, GATT_UUID_16 << 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("gatt_service16_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;
}
#endif // (BLE_APP_PRESENT)
/**
****************************************************************************************
*
* @file usr_server.c
*
* @brief Custom Server profile database definitions.
*
* Copyright (c) 2022 - 2025, XinChip
* All rights reserved.p
*
****************************************************************************************
*/
#include "usr_server.h"
#if (BLE_APP_PRESENT)
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;
extern uint8_t only_read_charactertics_buffer[5];
extern uint8_t only_read_charactertics_buffer_length;
__WEAK void ble_callback(uint8_t value0,uint8_t value1,uint8_t value2,uint8_t value3)
{
}
__WEAK void ble_diy_callback(uint8_t value,uint8_t* color,uint8_t length)
{
}
static const gatt_att16_desc_t custom_server_atts[] =
{
[CUSTOM_SVC_DECL] =
{
.uuid16 = GATT_DECL_PRIMARY_SERVICE,
.info = GATT_ATT_RD_BIT,
.ext_info = 0,
},
[CUSTOM_SVC_RX_CHAR_DECL_CHAR] =
{
.uuid16 = GATT_DECL_CHARACTERISTIC,
.info = GATT_ATT_RD_BIT,
.ext_info = 0,
},
[CUSTOM_SVC_RX_CHAR_VAL] =
{
.uuid16 = CUSTOM_SVC_RX_CHAR_UUID,
.info = GATT_ATT_RD_BIT | GATT_ATT_WC_BIT | GATT_ATT_WR_BIT,
.ext_info =
GATT_ATT_NO_OFFSET_BIT | CUSTOM_SVC_RX_CHAR_VAL_MAX_LENGTH,
},
[CUSTOM_SVC_TX_CHAR_DECL_CHAR] =
{
.uuid16 = GATT_DECL_CHARACTERISTIC,
.info = GATT_ATT_RD_BIT,
.ext_info = 0,
},
[CUSTOM_SVC_TX_CHAR_VAL] =
{
.uuid16 = CUSTOM_SVC_TX_CHAR_UUID,
.info = GATT_ATT_RD_BIT | GATT_ATT_N_BIT,
.ext_info =
GATT_ATT_NO_OFFSET_BIT | CUSTOM_SVC_TX_CHAR_VAL_MAX_LENGTH,
},
[CUSTOM_SVC_TX_CHAR_CFG] =
{
.uuid16 = GATT_DESC_CLIENT_CHAR_CFG,
.info = GATT_ATT_RD_BIT | GATT_ATT_WR_BIT,
.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,0x22};
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);
status = xc_ble_gatt_srv_read_cfm(conidx, user_lid, token, GAP_ERR_NO_ERROR,
sizeof(only_read_charactertics_buffer), sizeof(only_read_charactertics_buffer), only_read_charactertics_buffer);
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)[0]), length);
// 检查写入的数据是否是 0x12
// if (length == 1 && co_buf_data(p_data)[0] == 0x12)
if (length == 4)
{
ble_callback(co_buf_data(p_data)[0],co_buf_data(p_data)[1],co_buf_data(p_data)[2],co_buf_data(p_data)[3]);
// 设置指定的 GPIO 引脚为高电平
// xc_gpio_write_pin(LED3_PIN, GPIO_PIN_SET);
// only_read_charactertics_buffer[0] = co_buf_data(p_data)[0];r_DutyCycle*Brightness/10
// only_read_charactertics_buffer[0] = (uint8_t)(r_DutyCycle*Brightness/10);
// only_read_charactertics_buffer[1] = co_buf_data(p_data)[1];
// only_read_charactertics_buffer[2] = co_buf_data(p_data)[2];
// only_read_charactertics_buffer[3] = co_buf_data(p_data)[3];
}
else
{
ble_diy_callback(co_buf_data(p_data)[0],co_buf_data(p_data),length);
}
if (hdl == srv_get_hdl_from_att_idx(CUSTOM_SVC_TX_CHAR_CFG))
{
if ((co_buf_data(p_data)[0] == 0) && (co_buf_data(p_data)[1] == 0))
{
custom_svc_tx_char_notify = DISABLE;
}
else
{
custom_svc_tx_char_notify = ENABLE;
uint8_t data[] = {0x12, 0x13, 0x14};
slave_send_data(data, sizeof(data), CUSTOM_SVC_TX_CHAR_VAL);
}
}
}
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;
uint16_t custom_svc_uuid = 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_service16_add(
srv_user_lid, GATT_UUID_16 << 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("gatt_service16_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;
}
#endif // (BLE_APP_PRESENT)
project/example/ble/ble_peripheral/app/src/usr_server.h
+44 -44
View File
@@ -1,44 +1,44 @@
/**
****************************************************************************************
*
* @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 0xFFF0
#define CUSTOM_SVC_RX_CHAR_UUID 0xFFF3
#define CUSTOM_SVC_TX_CHAR_UUID 0xFFF4
#define CUSTOM_SVC_RX_CHAR_VAL_MAX_LENGTH 20
#define CUSTOM_SVC_TX_CHAR_VAL_MAX_LENGTH 20
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_
/**
****************************************************************************************
*
* @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 0xFFF0
#define CUSTOM_SVC_RX_CHAR_UUID 0xFFE6
#define CUSTOM_SVC_TX_CHAR_UUID 0xFFF4
#define CUSTOM_SVC_RX_CHAR_VAL_MAX_LENGTH 20
#define CUSTOM_SVC_TX_CHAR_VAL_MAX_LENGTH 20
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_