601 lines
22 KiB
C
601 lines
22 KiB
C
/**
|
||
* Copyright (c) CompanyNameMagicTag 2021-2022. All rights reserved.
|
||
* Description: Power display service.
|
||
* Author:
|
||
* Create:
|
||
*/
|
||
|
||
#include <soc_osal.h>
|
||
#include <osal_list.h>
|
||
#include <securec.h>
|
||
#include "cmsis_os2.h"
|
||
#include "systick.h"
|
||
#include "soc_errno.h"
|
||
#include "common_def.h"
|
||
#include "bts_def.h"
|
||
#include "bts_br_gap.h"
|
||
#include "oal_interface.h"
|
||
#include "wearable_log.h"
|
||
#include "local_device_manager.h"
|
||
#include "remote_device_manager.h"
|
||
#include "spp_service.h"
|
||
#include "bts_spp.h"
|
||
#include "btsrv_log.h"
|
||
#include "bts_feature.h"
|
||
#include "auto_ota_service.h"
|
||
#include "msg_center_ota.h"
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
#define AUTO_OTA_RETRY_TIMES 5
|
||
#define AUTO_OTA_SEM_TIMEOUT (60*60*1000) /* 等待信号量超时时间，考虑资源大包传输时间长场景 */
|
||
#define AUTO_OTA_DELAY_MS 100
|
||
#define AUTO_OTA_SPP_TASK_STACK_SIZE 2048
|
||
#define AUTO_OTA_SPP_TASK_PRI 20
|
||
#define ADDR_MAC_LEN 6
|
||
#define AUTO_OTA_RECORD_DEV_MAX_NUM 200 /* 设计成客户可定制 */
|
||
#define AUTO_OTA_SCAN_WAIT_TIME (25*1000) /* 客户可定制 */
|
||
#define AUTO_OTA_UPDATE_RSSI_WAIT_TIME (20*1000) /* 客户可定制 */
|
||
#define AUTO_OTA_INQUERY_DEV_NUM 20 /* 客户可定制 */
|
||
#define AUTO_OTA_OPRATE_DELAY_MS (2*1000) /* 客户可定制 */
|
||
#define AUTO_OTA_ACL_CONN_DELAY (6*1000) /* 客户可定制 */
|
||
#define AUTO_OTA_SPP_RECONN_TIMEOUT 10000 /* 客户可定制 */
|
||
#define AUTO_OTA_WAIT_PREPARE_TIMEOUT (2 * 1000) /* 客户可定制, 用于更换升级包场景 */
|
||
#define AUTO_OTA_DEV_NAME_PREFIX "Watch" /* 客户基于自己产品定义修改bt name前缀，用于黑名单管理 */
|
||
#define AUTO_OTA_DEV_NAME_PREFIX_LEN 5
|
||
#define AUTO_OTA_DST_UPG_VER_PATH "/user/dst_ver.txt"
|
||
|
||
bool g_auto_ota_found_list_init = false;
|
||
struct osal_list_head g_auto_ota_found_dev_list_head;
|
||
osSemaphoreId_t g_auto_ota_transmit_done_sem = NULL;
|
||
uint8_t g_auto_ota_upload_mode = 0; /* 默认是0，不阻塞auto_ota */
|
||
uint8_t g_auto_ota_mac_tmp[ADDR_MAC_LEN] = {0};
|
||
static bool g_anti_back_link_flag = false;
|
||
|
||
typedef struct auto_ota_record_dev {
|
||
uint8_t addr[ADDR_MAC_LEN]; /* mac地址 */
|
||
uint8_t has_been_updated; /* 标记是否已经升级 */
|
||
uint8_t reserved; /* 对齐 */
|
||
} auto_ota_record_dev_t;
|
||
|
||
static auto_ota_record_dev_t g_auto_ota_record_dev[AUTO_OTA_RECORD_DEV_MAX_NUM];
|
||
|
||
typedef struct {
|
||
struct osal_list_head node;
|
||
bd_addr_t bd_addr;
|
||
uint8_t name[BD_NAME_LEN];
|
||
int32_t cod;
|
||
int32_t rssi;
|
||
} auto_ota_found_dev_list_node;
|
||
|
||
typedef struct {
|
||
uint32_t sample_mode;
|
||
spp_create_socket_para_t socket_params;
|
||
bd_addr_t addr;
|
||
} auto_ota_spp_connect_task_params;
|
||
|
||
/* 数据管理 */
|
||
void auto_ota_dev_init(void)
|
||
{
|
||
for (uint8_t i = 0; i < AUTO_OTA_RECORD_DEV_MAX_NUM; i++) {
|
||
(void)memset_s(&g_auto_ota_record_dev[i], sizeof(auto_ota_record_dev_t), 0, sizeof(auto_ota_record_dev_t));
|
||
}
|
||
return;
|
||
}
|
||
|
||
void auto_ota_dev_add(uint8_t *addr)
|
||
{
|
||
for (uint16_t i = 0; i < AUTO_OTA_RECORD_DEV_MAX_NUM; i++) {
|
||
if (g_auto_ota_record_dev[i].has_been_updated == 0) {
|
||
(void)memcpy_s(g_auto_ota_record_dev[i].addr, ADDR_MAC_LEN, addr, ADDR_MAC_LEN);
|
||
g_auto_ota_record_dev[i].has_been_updated = 1;
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "to add record dev_mac : ****%02x%02x%02x%02x\r\n",
|
||
g_auto_ota_record_dev[i].addr[3], g_auto_ota_record_dev[i].addr[2], g_auto_ota_record_dev[i].addr[1],
|
||
g_auto_ota_record_dev[i].addr[0]);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "alloc index = %d\r\n", i);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
bool auto_ota_dev_del(uint8_t *addr)
|
||
{
|
||
for (uint16_t i = 0; i < AUTO_OTA_RECORD_DEV_MAX_NUM; i++) {
|
||
if (g_auto_ota_record_dev[i].has_been_updated == 1 &&
|
||
memcmp(g_auto_ota_record_dev[i].addr, addr, ADDR_MAC_LEN) == 0) {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "found! to del record dev_mac : ****%02x%02x%02x%02x\r\n",
|
||
g_auto_ota_record_dev[i].addr[3], g_auto_ota_record_dev[i].addr[2], g_auto_ota_record_dev[i].addr[1],
|
||
g_auto_ota_record_dev[i].addr[0]);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "free index = %d\r\n", i);
|
||
(void)memset_s(g_auto_ota_record_dev[i].addr, ADDR_MAC_LEN, 0, ADDR_MAC_LEN);
|
||
g_auto_ota_record_dev[i].has_been_updated = 0;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "dev_del: no found dev_mac.\r\n");
|
||
return false;
|
||
}
|
||
|
||
bool auto_ota_dev_found(uint8_t *addr)
|
||
{
|
||
for (uint16_t i = 0; i < AUTO_OTA_RECORD_DEV_MAX_NUM; i++) {
|
||
if (g_auto_ota_record_dev[i].has_been_updated == 1 &&
|
||
memcmp(g_auto_ota_record_dev[i].addr, addr, ADDR_MAC_LEN) == 0) {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "no need to record dev_mac: ****%02x%02x%02x%02x\r\n",
|
||
g_auto_ota_record_dev[i].addr[3], g_auto_ota_record_dev[i].addr[2], g_auto_ota_record_dev[i].addr[1],
|
||
g_auto_ota_record_dev[i].addr[0]);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "taken index = %d\r\n", i);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void auto_ota_dev_show(void)
|
||
{
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "auto_ota total dev info :");
|
||
for (uint16_t i = 0; i < AUTO_OTA_RECORD_DEV_MAX_NUM; i++) {
|
||
if (g_auto_ota_record_dev[i].has_been_updated == 1) {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "already record dev_mac : ****%02x%02x%02x%02x\r\n",
|
||
g_auto_ota_record_dev[i].addr[3], g_auto_ota_record_dev[i].addr[2], g_auto_ota_record_dev[i].addr[1],
|
||
g_auto_ota_record_dev[i].addr[0]);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "taken index = %d\r\n", i);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 黑名单处理 */
|
||
static bool auto_ota_dev_check_dev_name(unsigned char *dev_name)
|
||
{
|
||
if (strncmp((const char *)dev_name, AUTO_OTA_DEV_NAME_PREFIX, AUTO_OTA_DEV_NAME_PREFIX_LEN) == 0) {
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/* 重置发现设备链表 */
|
||
void auto_ota_reset_found_dev_list(void)
|
||
{
|
||
if (!g_auto_ota_found_list_init) {
|
||
g_auto_ota_found_list_init = true;
|
||
OSAL_INIT_LIST_HEAD(&g_auto_ota_found_dev_list_head);
|
||
return;
|
||
}
|
||
|
||
while (osal_list_empty(&g_auto_ota_found_dev_list_head) == false) {
|
||
struct osal_list_head *node = g_auto_ota_found_dev_list_head.next;
|
||
osal_list_del(node);
|
||
oal_mem_free(node);
|
||
}
|
||
}
|
||
|
||
bool auto_ota_bt_start_discovery(void)
|
||
{
|
||
auto_ota_reset_found_dev_list();
|
||
(void)gap_br_set_inquiry_paramters(0, AUTO_OTA_INQUERY_DEV_NUM);
|
||
for (uint8_t i = 0; i < AUTO_OTA_RETRY_TIMES; i++) {
|
||
bool res = gap_br_start_discovery();
|
||
if (res != true) {
|
||
osDelay(AUTO_OTA_DELAY_MS);
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "gap_br_start_discovery fail.\r\n");
|
||
continue;
|
||
} else {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "gap_br_start_discovery succ.\r\n");
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/* 新增节点 */
|
||
static void auto_ota_add_node_to_found_dev_list(const bd_addr_t *bd_addr, const uint8_t *name, int32_t cod, int32_t rssi)
|
||
{
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "auto_ota_add_node, addr: ****%02x%02x%02x%02x, name: %s",
|
||
bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1], bd_addr->addr[0], name); /* addr下标 0 1 2 3 */
|
||
|
||
auto_ota_found_dev_list_node *node =
|
||
(auto_ota_found_dev_list_node *)(void *)oal_mem_alloc(sizeof(auto_ota_found_dev_list_node));
|
||
if (node == NULL) {
|
||
return;
|
||
}
|
||
(void)memset_s(node, sizeof(auto_ota_found_dev_list_node), 0, sizeof(auto_ota_found_dev_list_node));
|
||
|
||
if (memcpy_s(&node->bd_addr, sizeof(node->bd_addr), bd_addr, sizeof(bd_addr_t)) != EOK) {
|
||
oal_mem_free(node);
|
||
return;
|
||
}
|
||
|
||
if (memcpy_s(node->name, sizeof(node->name), name, BD_NAME_LEN) != EOK) {
|
||
oal_mem_free(node);
|
||
return;
|
||
}
|
||
|
||
node->cod = cod;
|
||
node->rssi = rssi;
|
||
osal_list_add_tail((struct osal_list_head *)node, &g_auto_ota_found_dev_list_head);
|
||
}
|
||
|
||
static void auto_ota_sort_found_dev_list(void)
|
||
{
|
||
struct osal_list_head *list_head = &g_auto_ota_found_dev_list_head;
|
||
|
||
for (struct osal_list_head *node1 = list_head->next; node1 != NULL && node1 != list_head; node1 = node1->next) {
|
||
auto_ota_found_dev_list_node *dev_info1 = (auto_ota_found_dev_list_node *)node1;
|
||
for (struct osal_list_head *node2 = node1->next; node2 != NULL && node2 != list_head; node2 = node2->next) {
|
||
auto_ota_found_dev_list_node *dev_info2 = (auto_ota_found_dev_list_node *)node2;
|
||
|
||
/* rssi大的在前 */
|
||
if (dev_info1->rssi >= dev_info2->rssi) {
|
||
continue;
|
||
}
|
||
|
||
/* 交换两个节点的信息 */
|
||
auto_ota_found_dev_list_node tmp_node;
|
||
uint32_t ret =
|
||
(uint32_t)memcpy_s(&tmp_node, sizeof(tmp_node), dev_info1, sizeof(auto_ota_found_dev_list_node));
|
||
ret |= (uint32_t)memcpy_s(&dev_info1->bd_addr,
|
||
sizeof(auto_ota_found_dev_list_node) - sizeof(struct osal_list_head),
|
||
&dev_info2->bd_addr,
|
||
sizeof(auto_ota_found_dev_list_node) - sizeof(struct osal_list_head));
|
||
ret |= (uint32_t)memcpy_s(&dev_info2->bd_addr,
|
||
sizeof(auto_ota_found_dev_list_node) - sizeof(struct osal_list_head),
|
||
&tmp_node.bd_addr,
|
||
sizeof(auto_ota_found_dev_list_node) - sizeof(struct osal_list_head));
|
||
if (ret != EOK) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "swap fail %x\n", ret);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 异步返回，更新RSSI */
|
||
static void auto_ota_update_found_dev_node_rssi(const bd_addr_t *bd_addr, int32_t rssi)
|
||
{
|
||
struct osal_list_head *list_head = &g_auto_ota_found_dev_list_head;
|
||
struct osal_list_head *node = list_head->next;
|
||
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER,"will update rssi, addr: ****%02x%02x%02x%02x, rssi = %d\n",
|
||
bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1], bd_addr->addr[0], rssi); /* addr下标 0 1 2 3 */
|
||
|
||
while (node != NULL && node != list_head) {
|
||
auto_ota_found_dev_list_node *dev_info = (auto_ota_found_dev_list_node *)node;
|
||
if (memcmp(dev_info->bd_addr.addr, bd_addr->addr, BD_ADDR_LEN) == 0) {
|
||
dev_info->rssi = rssi;
|
||
return;
|
||
}
|
||
|
||
node = node->next;
|
||
}
|
||
}
|
||
|
||
static void auto_ota_gap_read_remote_rssi_event_callback(const bd_addr_t *bd_addr, int rssi, int status)
|
||
{
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER,
|
||
" addr: ****%02x%02x%02x%02x rssi: %d status: %d\n",
|
||
bd_addr->addr[3], bd_addr->addr[2], /* addr下标 2 3 */
|
||
bd_addr->addr[1], bd_addr->addr[0], rssi, status); /* addr下标 0 1 */
|
||
|
||
if (status == ERRCODE_BT_SUCCESS) {
|
||
auto_ota_update_found_dev_node_rssi(bd_addr, rssi);
|
||
}
|
||
}
|
||
|
||
static bool auto_ota_get_top_dev_to_connect(void)
|
||
{
|
||
struct osal_list_head *list_head = &g_auto_ota_found_dev_list_head;
|
||
uint8_t blank_addr[ADDR_MAC_LEN] = {0};
|
||
|
||
for (struct osal_list_head *node = list_head->next; node != NULL && node != list_head; node = node->next) {
|
||
auto_ota_found_dev_list_node *dev_info = (auto_ota_found_dev_list_node *)node;
|
||
if (memcmp(dev_info->bd_addr.addr, blank_addr, ADDR_MAC_LEN) == 0) {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "ignore zero addr, name: %s\n", dev_info->name);
|
||
continue;
|
||
}
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER,
|
||
"plan to connect addr: ****%02x%02x%02x%02x name: \"%s\" cod: %x rssi: %d\n",
|
||
dev_info->bd_addr.addr[3], dev_info->bd_addr.addr[2], /* addr下标 3 2 */
|
||
dev_info->bd_addr.addr[1], dev_info->bd_addr.addr[0], /* addr下标 1 0 */
|
||
dev_info->name,
|
||
dev_info->cod,
|
||
dev_info->rssi);
|
||
|
||
for (uint8_t i = 0; i < AUTO_OTA_RETRY_TIMES; i++) {
|
||
if (gap_connect_remote_device(&(dev_info->bd_addr)) != true) {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "to connect acl fail\r\n");
|
||
osDelay(100);
|
||
} else {
|
||
osDelay(AUTO_OTA_ACL_CONN_DELAY);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "to connect acl succ\r\n");
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "no found_device\n");
|
||
return false;
|
||
}
|
||
|
||
static void auto_ota_discovery_result_callback(const bd_addr_t *bd_addr)
|
||
{
|
||
unsigned char length = BD_NAME_LEN;
|
||
unsigned char *device_name = (unsigned char *)(void *)oal_mem_alloc(length);
|
||
if (device_name == NULL) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "gap_discovery_result_callback malloc error!\n");
|
||
return;
|
||
}
|
||
(void)memset_s(device_name, length, 0, length);
|
||
|
||
bool ret1 = gap_get_device_name(bd_addr, device_name, &length);
|
||
int cod = gap_get_device_class(bd_addr);
|
||
bool ret2 = gap_read_remote_rssi_value(bd_addr);
|
||
|
||
if (auto_ota_dev_found(bd_addr->addr) != true && auto_ota_dev_check_dev_name(device_name) == true) {
|
||
auto_ota_add_node_to_found_dev_list(bd_addr, device_name, cod, 0);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
static bool auto_ota_upg_check(void)
|
||
{
|
||
errcode_t ret = ERRCODE_SUCC;
|
||
|
||
/* 目标版本从文件读取，方便客户每次推送不同版本 */
|
||
FILE *fp = NULL;
|
||
|
||
fp = fopen(AUTO_OTA_DST_UPG_VER_PATH, "rb");
|
||
if (fp == NULL) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "open %s fail.\r\n", AUTO_OTA_DST_UPG_VER_PATH);
|
||
return false;
|
||
}
|
||
|
||
fseek(fp, 0L, SEEK_END);
|
||
long file_len = ftell(fp);
|
||
char *dst_ver = (char *)malloc(sizeof(char) * (file_len + 1));
|
||
if (dst_ver == NULL) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "malloc fail, file_len = %d.\r\n", file_len);
|
||
return false;
|
||
}
|
||
|
||
fseek(fp, 0L, SEEK_SET);
|
||
if (fread(dst_ver, file_len, 1, fp) != 1) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "fread fail, file_len = %d.\r\n", file_len);
|
||
free(dst_ver);
|
||
dst_ver = NULL;
|
||
return false;
|
||
}
|
||
fclose(fp);
|
||
dst_ver[file_len] = '\0';
|
||
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "dst_ver = %s, file_len = %d.\r\n", dst_ver, file_len);
|
||
|
||
ret = msg_center_send_data(MSGCENTER_CMD_OTA, MSGCENTER_TYPE_ID_OTA_UPG_CHECK, dst_ver, strlen(dst_ver));
|
||
if (ret != ERRCODE_SUCC) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "send upgrade version check fail, ret = %d\r\n", ret);
|
||
free(dst_ver);
|
||
dst_ver = NULL;
|
||
return false;
|
||
}
|
||
|
||
free(dst_ver);
|
||
dst_ver = NULL;
|
||
return true;
|
||
}
|
||
|
||
static int auto_ota_spp_client_connect_task_body(void *data)
|
||
{
|
||
auto_ota_spp_connect_task_params *task_params = (auto_ota_spp_connect_task_params *)data;
|
||
spp_create_socket_para_t *socket_param = &task_params->socket_params;
|
||
|
||
int ret = spp_connect(socket_param, &task_params->addr);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "spp_connect ret: %x\n", ret);
|
||
|
||
oal_mem_free(data);
|
||
return OSAL_SUCCESS;
|
||
}
|
||
|
||
/* client连接server */
|
||
bool auto_ota_spp_connect(const char *spp_uuid, const bd_addr_t *addr)
|
||
{
|
||
uint8_t uuid_len = (uint8_t)strlen(spp_uuid);
|
||
auto_ota_spp_connect_task_params *task_params =
|
||
(auto_ota_spp_connect_task_params *)oal_mem_alloc(sizeof(auto_ota_spp_connect_task_params));
|
||
|
||
if (generate_uuid_from_string(spp_uuid, uuid_len + 1, &task_params->socket_params.uuid) != EXT_ERR_SUCCESS) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "generate uuid fail\n");
|
||
return false;
|
||
}
|
||
|
||
task_params->sample_mode = 0;
|
||
task_params->socket_params.socket_type = SPP_SOCKET_RFCOMM;
|
||
task_params->socket_params.is_encrypt = true;
|
||
(void)memcpy_s(&(task_params->addr.addr), BD_ADDR_LEN, addr->addr, BD_ADDR_LEN);
|
||
|
||
osal_task *task = osal_kthread_create(auto_ota_spp_client_connect_task_body, task_params,
|
||
"auto_ota_spp_client_connect_task", AUTO_OTA_SPP_TASK_STACK_SIZE);
|
||
if (task == NULL) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "create task fail\n");
|
||
return false;
|
||
}
|
||
int ret = osal_kthread_set_priority(task, AUTO_OTA_SPP_TASK_PRI);
|
||
if (ret != OSAL_SUCCESS) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "set pri error: %08x\n", ret);
|
||
}
|
||
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "create task success.\n");
|
||
|
||
bool is_connected = false;
|
||
uint64_t start_time = uapi_tcxo_get_ms();
|
||
uint64_t current_time;
|
||
while (is_connected == false) {
|
||
is_connected = is_spp_connected(0);
|
||
osDelay(AUTO_OTA_OPRATE_DELAY_MS);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "spp reconnecting.\r\n");
|
||
current_time = uapi_tcxo_get_ms();
|
||
if (current_time - start_time > AUTO_OTA_SPP_RECONN_TIMEOUT || is_connected == true) {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "spp connect %s.\r\n", is_connected == true ? "Succ" : "Fail");
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* 升级版本号校验 */
|
||
bool res = auto_ota_upg_check();
|
||
if (res != true) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "auto_ota_upg_check fail.\n");
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
static void auto_ota_acl_state_changed_callback(const bd_addr_t *bd_addr, gap_acl_state_t state, unsigned int reason)
|
||
{
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "acl cb, state %d, reason %x", state, reason);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "addr: ****%02x%02x%02x%02x",
|
||
bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1], bd_addr->addr[0]); /* mac下标 0 1 2 3 */
|
||
char uuid[] = {"1101"};
|
||
if (state == GAP_ACL_STATE_CONNECTED) {
|
||
if (g_anti_back_link_flag == true) {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "anti back link addr: ****%02x%02x%02x%02x",
|
||
bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1], bd_addr->addr[0]); /* mac下标 0 1 2 3 */
|
||
return;
|
||
}
|
||
bool res = auto_ota_spp_connect(uuid, bd_addr);
|
||
if (res != true) {
|
||
(void)osSemaphoreRelease(g_auto_ota_transmit_done_sem);
|
||
return;
|
||
}
|
||
/* spp trans回调中释放信号量最准确，故此处临时记录mac地址 */
|
||
(void)memcpy_s(g_auto_ota_mac_tmp, ADDR_MAC_LEN, (const char *)bd_addr->addr, ADDR_MAC_LEN);
|
||
g_anti_back_link_flag = true;
|
||
}
|
||
}
|
||
|
||
void auto_ota_gap_register_callbacks(void)
|
||
{
|
||
gap_call_backs_t cb = {
|
||
NULL,
|
||
auto_ota_acl_state_changed_callback,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
auto_ota_discovery_result_callback,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
auto_ota_gap_read_remote_rssi_event_callback,
|
||
NULL
|
||
};
|
||
(void)gap_register_callbacks(&cb);
|
||
}
|
||
|
||
errcode_t auto_ota_enable_bt(void)
|
||
{
|
||
#if defined(SW_UART_DEBUG) || defined(SW_RTT_DEBUG)
|
||
g_bth_log_type_level = 0xFF2; /* BTSRV_LOG_UART_INFO */
|
||
#endif
|
||
bts_feature_t feature = {0};
|
||
feature.bt_auto_reconnect_closed = 1;
|
||
|
||
auto_ota_gap_register_callbacks();
|
||
bts_set_features(&feature); /* 关闭client回链 */
|
||
errcode_t res = enable_bt_stack();
|
||
if (res != 0) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "bt enable fail, ret = %d\r\n", res);
|
||
return ERRCODE_FAIL;
|
||
} else {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "bt enable ok\r\n");
|
||
return ERRCODE_SUCC;
|
||
}
|
||
}
|
||
|
||
void auto_ota_task_init(void)
|
||
{
|
||
g_auto_ota_transmit_done_sem = osSemaphoreNew(1, 0, NULL);
|
||
if (!g_auto_ota_transmit_done_sem) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "sem creat fail!\r\n");
|
||
return;
|
||
}
|
||
}
|
||
|
||
void auto_ota_task_main(void)
|
||
{
|
||
errcode_t ret;
|
||
|
||
auto_ota_dev_init();
|
||
auto_ota_task_init();
|
||
|
||
if (auto_ota_enable_bt() != ERRCODE_SUCC) {
|
||
return;
|
||
}
|
||
|
||
while (1) {
|
||
if (g_auto_ota_upload_mode == 1) {
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "enter upload fwpkg mode, auto_ota not run!\r\n");
|
||
osDelay(AUTO_OTA_WAIT_PREPARE_TIMEOUT);
|
||
continue;
|
||
}
|
||
|
||
/* 保证最开始不会有配对信息回连，可能导致B核wait等回连 */
|
||
if (gap_remove_all_pairs() != true) {
|
||
osDelay(AUTO_OTA_DELAY_MS);
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "remove all pairs fail, auto retry...\r\n");
|
||
continue;
|
||
}
|
||
osDelay(AUTO_OTA_OPRATE_DELAY_MS);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "gap_remove_all_pairs ok\r\n");
|
||
|
||
/* scan */
|
||
if (auto_ota_bt_start_discovery() != true) {
|
||
osDelay(AUTO_OTA_DELAY_MS);
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "start discovery fail, auto retry...\r\n");
|
||
continue;
|
||
}
|
||
|
||
osDelay(AUTO_OTA_SCAN_WAIT_TIME); /* 保证能扫到设备 */
|
||
|
||
(void)gap_br_cancel_discovery();
|
||
osDelay(AUTO_OTA_UPDATE_RSSI_WAIT_TIME);
|
||
auto_ota_sort_found_dev_list(); /* 根据rssi降序排序 */
|
||
/* connect */
|
||
if (auto_ota_get_top_dev_to_connect() != true) {
|
||
osDelay(AUTO_OTA_DELAY_MS);
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "connect fail, auto retry...\r\n");
|
||
continue;
|
||
}
|
||
|
||
osSemaphoreAcquire(g_auto_ota_transmit_done_sem, AUTO_OTA_SEM_TIMEOUT);
|
||
|
||
/* clean, spp资源内部释放 */
|
||
spp_disconnect(0);
|
||
/* 删除配对时会disconnect ACL */
|
||
if (gap_remove_all_pairs() != true) {
|
||
osDelay(AUTO_OTA_DELAY_MS);
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_MSG_CENTER, "remove all pairs fail, auto retry...\r\n");
|
||
continue;
|
||
}
|
||
osDelay(AUTO_OTA_OPRATE_DELAY_MS);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_MSG_CENTER, "gap_remove_all_pairs ok\r\n");
|
||
|
||
osDelay(AUTO_OTA_DELAY_MS);
|
||
auto_ota_dev_show();
|
||
memset_s(g_auto_ota_mac_tmp, sizeof(g_auto_ota_mac_tmp), 0, sizeof(g_auto_ota_mac_tmp));
|
||
g_anti_back_link_flag = false;
|
||
osDelay(AUTO_OTA_DELAY_MS);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif |