494 lines
16 KiB
C++
494 lines
16 KiB
C++
/*----------------------------------------------------------------------------
|
||
* Copyright (c) TJD Technologies Co., Ltd. 2025. All rights reserved.
|
||
*
|
||
* Description: service_pgnss.c
|
||
*
|
||
* Author: luziquan@ss-tjd.com
|
||
*
|
||
* Create: 2025-05-09
|
||
*--------------------------------------------------------------------------*/
|
||
|
||
#include "service_pgnss.h"
|
||
#include "gnss_datatypes.h"
|
||
#include "gnss_nmea_parse.h"
|
||
#include "osal_atomic.h"
|
||
#include "osal_task.h"
|
||
#include "pgnss_encode.h"
|
||
#include "pm_definition.h"
|
||
#include "pm_veto.h"
|
||
#include "rtc_api.h"
|
||
#include "securec.h"
|
||
#include "sys_config.h"
|
||
#include "tiot_service_interface.h"
|
||
#include "tiot_service_interface_ext.h"
|
||
#include <stdio.h>
|
||
#include <string>
|
||
|
||
#define ENABLE_PRINT_INFO 1
|
||
#define ENABLE_DEBUG 0
|
||
|
||
#if ENABLE_PRINT_INFO
|
||
#define static_print_info(...) sys_gps_log_i(__VA_ARGS__) //一般信息打印宏控制
|
||
#define static_print_warn(...) sys_gps_log_w(__VA_ARGS__) //警告信息打印一般常开
|
||
#define static_print_error(...) sys_gps_log_e(__VA_ARGS__) //错误信息打印一般常开
|
||
#if ENABLE_DEBUG
|
||
#define static_print_debug(...) sys_gps_log_d(__VA_ARGS__)
|
||
#else
|
||
#define static_print_debug(...)
|
||
#endif
|
||
#else
|
||
#define static_print_info(...)
|
||
#define static_print_warn(...)
|
||
#define static_print_error(...)
|
||
#endif
|
||
|
||
namespace TJD {
|
||
|
||
int GnssNmeaDecodeFrame(const char *nmea, unsigned int nmeaLen, GnssInfo *gnssInfo,
|
||
GnssNmeaFrameProcess *nmeaFrameProcess);
|
||
|
||
GnssNmeaFrameType GnssNmeaGetFrameType(const char *nmeaBuf, unsigned int length);
|
||
|
||
} // namespace TJD
|
||
|
||
#define MSG_TYPE_ASCII 1
|
||
|
||
static GnssServiceContext g_gnssServiceCtx = {
|
||
.gnssEnabled = false,
|
||
.gnssStarted = false,
|
||
.gnssCallback = {},
|
||
.gnssInfo = {},
|
||
// .location = {},
|
||
.satStatus = {},
|
||
.listenGnssDataThreadId = nullptr,
|
||
};
|
||
|
||
static osThreadId_t g_gnssThreadId = NULL;
|
||
static FILE *g_gnssLogFp = NULL;
|
||
static uint8_t *g_gnssServiceBuff = NULL;
|
||
static osMutexId_t g_gnssMutex = NULL;
|
||
|
||
static int32_t QryVersion(tiot_handle handle)
|
||
{
|
||
const uint8_t qryVersion[] = {0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00};
|
||
// 查询版本号
|
||
int32_t ret = tiot_service_write(handle, qryVersion, sizeof(qryVersion));
|
||
if (ret < 0) {
|
||
static_print_error("error: QryVersion error: %d", ret);
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
// 注入PGNSS，使用默认配置启动
|
||
static int32_t InjectPgnssLessFilesCfgAutoStartFixModeAndNmeaDefault(tiot_handle handle)
|
||
{
|
||
// clang-format off
|
||
const uint8_t cfgColdStartCmd[] = {0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01};
|
||
const uint8_t cfgAutoStartCmd[] = {0x03, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00};
|
||
const uint8_t cfgLogLevelInfo[] = {0x03, 0x00, 0x15, 0x00, 0x00, 0x00, 0x05, 0x00, 0x01, 0x10, 0x01, 0x00, 0x03};
|
||
const uint8_t cfgFixModeAllCmd[] = {0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x1f, 0x00, 0x00, 0x00};
|
||
const uint8_t cfgAllNmeaCmd[] = {0x03, 0x00, 0x04, 0x01, 0x00, 0x00, 0x06, 0x00, 0x03, 0x00,0x02, 0x00, 0xff, 0x00};
|
||
// // const uint8_t cfgNmeaDefaultCmd[] = {0x03,0x00,0x16,0x00,0x00,0x00,0x06,0x00,0x03,0x00,0x02,0x00,0x11,0x00};
|
||
// // const uint8_t cfgDisablePmCmd[] = {0x03,0x00,0x07,0x00,0x00,0x00,0x06,0x00,0x05,0x00,0x02,0x00,0x00,0x00};
|
||
// // const uint8_t cfgEnablePmCmd[] = {0x03,0x00,0x0A,0x00,0x00,0x00,0x06,0x00,0x05,0x00,0x02,0x00,0x01,0x02};
|
||
// clang-format on
|
||
|
||
int32_t ret = 0;
|
||
|
||
// 配置启动模式：自动模式。
|
||
ret = tiot_service_write(handle, cfgAutoStartCmd, sizeof(cfgAutoStartCmd));
|
||
if (ret < 0) {
|
||
static_print_error("cfgAutoStartCmd error: %d", ret);
|
||
return 0;
|
||
}
|
||
|
||
// 配置启动模式：冷启动模式。
|
||
// ret = tiot_service_write(handle, cfgColdStartCmd, sizeof(cfgColdStartCmd));
|
||
// if (ret < 0) {
|
||
// static_print_error("cfgColdStartCmd error: %d", ret);
|
||
// return 0;
|
||
// }
|
||
|
||
// 配置log级别：info级别。
|
||
ret = tiot_service_write(handle, cfgLogLevelInfo, sizeof(cfgLogLevelInfo));
|
||
if (ret < 0) {
|
||
static_print_error("cfgLogLevelInfo error: %d", ret);
|
||
return 0;
|
||
}
|
||
|
||
// 配置使能的GNSS星座：QZSS/GAL/BDS/GLO/GPS。
|
||
ret = tiot_service_write(handle, cfgFixModeAllCmd, sizeof(cfgFixModeAllCmd));
|
||
if (ret < 0) {
|
||
static_print_error("cfgFixModeAllCmd error: %d", ret);
|
||
return 0;
|
||
}
|
||
|
||
// 配置上报NMEA类型：PNT/ZDA/VTG/RMC/GSV/GSA/GLL/GGA。
|
||
ret = tiot_service_write(handle, cfgAllNmeaCmd, sizeof(cfgAllNmeaCmd));
|
||
if (ret < 0) {
|
||
static_print_error("cfgAllNmeaCmd error: %d", ret);
|
||
return 0;
|
||
}
|
||
|
||
// ret = tiot_service_write(handle, cfgDisablePmCmd, sizeof(cfgDisablePmCmd));
|
||
// if (ret < 0) {
|
||
// static_print_error("error: cfgDisablePmCmd error: %d", ret);
|
||
// return 0;
|
||
// }
|
||
|
||
// 注入UTC时间, 注入Pgnss辅助数据前必须先注入参考时间
|
||
struct rtc_time time;
|
||
tjd_driver_rtc_get_ops()->get_rtc_utc_time(&time);
|
||
// 需要用当前的UTC时间替换
|
||
GnssUtcTime utcTime = {static_cast<uint16_t>(time.tm_year),
|
||
static_cast<uint8_t>(time.tm_mon),
|
||
static_cast<uint8_t>(time.tm_mday),
|
||
static_cast<uint8_t>(time.tm_hour),
|
||
static_cast<uint8_t>(time.tm_min),
|
||
static_cast<uint8_t>(time.tm_sec),
|
||
0,
|
||
1};
|
||
uint32_t ts = 0;
|
||
ret = PgnssInjectUtcTime(handle, &utcTime, &ts);
|
||
if (ret == 0) {
|
||
static_print_error("error: PgnssInjectUtcTime failed!");
|
||
return 0;
|
||
}
|
||
static_print_debug("PgnssInjectUtcTime success!");
|
||
|
||
// PGNSS注入
|
||
PgnssInjectLessFiles(handle, ts);
|
||
|
||
return 1;
|
||
}
|
||
|
||
static int32_t StartGnss(tiot_handle handle)
|
||
{
|
||
const uint8_t startCmd[] = {0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00,
|
||
0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00};
|
||
// 启动GNSS
|
||
int32_t ret = tiot_service_write(handle, startCmd, sizeof(startCmd));
|
||
if (ret < 0) {
|
||
static_print_error("error: start gnss error: %d", ret);
|
||
return 0;
|
||
}
|
||
static_print_debug("start gnss");
|
||
return 1;
|
||
}
|
||
|
||
static int32_t StopGnss(tiot_handle handle)
|
||
{
|
||
const uint8_t stopCmd[] = {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
||
// 停止GNSS
|
||
int32_t ret = tiot_service_write(handle, stopCmd, sizeof(stopCmd));
|
||
if (ret < 0) {
|
||
static_print_error("error: stop gnss error: %d", ret);
|
||
return 0;
|
||
}
|
||
static_print_debug("stop gnss");
|
||
return 1;
|
||
}
|
||
|
||
static void ResetGnssInfo(GnssServiceContext *gnssServiceCtx)
|
||
{
|
||
int32_t ret = memset_s(&gnssServiceCtx->gnssInfo, sizeof(GnssInfo), 0, sizeof(GnssInfo));
|
||
if (ret != EOK) {
|
||
static_print_error("memset_s GnssInfo failed:%d", ret);
|
||
}
|
||
}
|
||
|
||
static void ResetLocationSatelliteStatus(GnssServiceContext *gnssServiceCtx)
|
||
{
|
||
int32_t ret = memset_s(&gnssServiceCtx->location, sizeof(GnssLocation), 0, sizeof(GnssLocation));
|
||
if (ret != EOK) {
|
||
static_print_warn("memset_s GnssLocation failed:%d", ret);
|
||
}
|
||
ret = memset_s(&gnssServiceCtx->satStatus, sizeof(GnssSatelliteStatus), 0, sizeof(GnssSatelliteStatus));
|
||
if (ret != EOK) {
|
||
static_print_warn("memset_s GnssSatelliteStatus failed:%d", ret);
|
||
}
|
||
}
|
||
|
||
static int32_t LocationGnssUtilsFillGnssLocation(const GnssInfo *gnssInfo, GnssLocation *location)
|
||
{
|
||
if (gnssInfo->signal == 0) {
|
||
static_print_warn("Location invalid");
|
||
return GNSS_FAILURE;
|
||
}
|
||
location->fieldValidity = GNSS_NMEA_FIELD_TYPE_SMASK;
|
||
if (gnssInfo->field & GNSS_NMEA_FIELD_TYPE_LAT) {
|
||
location->latitude = gnssInfo->lat;
|
||
location->fieldValidity |= GNSS_LOCATION_LAT_VALID;
|
||
}
|
||
if (gnssInfo->field & GNSS_NMEA_FIELD_TYPE_LON) {
|
||
location->longitude = gnssInfo->lon;
|
||
location->fieldValidity |= GNSS_LOCATION_LONG_VALID;
|
||
}
|
||
if (gnssInfo->field & GNSS_NMEA_FIELD_TYPE_ANTALT) {
|
||
location->altitude = gnssInfo->altitude;
|
||
location->fieldValidity |= GNSS_LOCATION_ALTITUDE_VALID;
|
||
}
|
||
if (gnssInfo->field & GNSS_NMEA_FIELD_TYPE_SPEED) {
|
||
location->speed = gnssInfo->speed;
|
||
location->fieldValidity |= GNSS_LOCATION_SPEED_VALID;
|
||
}
|
||
if (gnssInfo->field & GNSS_NMEA_FIELD_TYPE_TRACK) {
|
||
location->bearing = gnssInfo->trackAng;
|
||
location->fieldValidity |= GNSS_LOCATION_BEARING_VALID;
|
||
}
|
||
return GNSS_SUCCESS;
|
||
}
|
||
|
||
GnssQualityLevel GetGnssSignalQualityLevel(const GnssInfo &gnssInfo)
|
||
{
|
||
const GnssSatelliteList *satList = &gnssInfo.satelist;
|
||
GnssQualityLevel quality = GnssQualityLevel::GNSS_QUAL_POOR;
|
||
|
||
int visableSatNum = 0;
|
||
int CnrMax = 0;
|
||
|
||
GnssSatelliteStatusInfo satInfos = satList->gps;
|
||
for (uint32_t i = 0; i < satInfos.satViewedCnt; ++i) {
|
||
if (satInfos.satelliteStatus[i].cnr > CnrMax) {
|
||
CnrMax = satInfos.satelliteStatus[i].cnr;
|
||
}
|
||
}
|
||
visableSatNum += satInfos.satViewedCnt;
|
||
|
||
satInfos = satList->bds;
|
||
for (uint32_t i = 0; i < satInfos.satViewedCnt; ++i) {
|
||
if (satInfos.satelliteStatus[i].cnr > CnrMax) {
|
||
CnrMax = satInfos.satelliteStatus[i].cnr;
|
||
}
|
||
}
|
||
visableSatNum += satInfos.satViewedCnt;
|
||
|
||
satInfos = satList->glonass;
|
||
for (uint32_t i = 0; i < satInfos.satViewedCnt; ++i) {
|
||
if (satInfos.satelliteStatus[i].cnr > CnrMax) {
|
||
CnrMax = satInfos.satelliteStatus[i].cnr;
|
||
}
|
||
}
|
||
visableSatNum += satInfos.satViewedCnt;
|
||
|
||
satInfos = satList->galileo;
|
||
for (uint32_t i = 0; i < satInfos.satViewedCnt; ++i) {
|
||
if (satInfos.satelliteStatus[i].cnr > CnrMax) {
|
||
CnrMax = satInfos.satelliteStatus[i].cnr;
|
||
}
|
||
}
|
||
visableSatNum += satInfos.satViewedCnt;
|
||
|
||
satInfos = satList->qzss;
|
||
for (uint32_t i = 0; i < satInfos.satViewedCnt; ++i) {
|
||
if (satInfos.satelliteStatus[i].cnr > CnrMax) {
|
||
CnrMax = satInfos.satelliteStatus[i].cnr;
|
||
}
|
||
}
|
||
visableSatNum += satInfos.satViewedCnt;
|
||
|
||
if (gnssInfo.hdop <= 1.5 && visableSatNum >= 8 && CnrMax >= 40) {
|
||
quality = GnssQualityLevel::GNSS_QUAL_HIGH; // 开阔环境高精度定位
|
||
} else if (gnssInfo.pdop <= 6 && visableSatNum >= 4 && CnrMax >= 35) {
|
||
quality = GnssQualityLevel::GNSS_QUAL_MEDIUM; // 城市街道常规导航
|
||
} else {
|
||
quality = GnssQualityLevel::GNSS_QUAL_POOR; // 隧道/室内定位失效
|
||
}
|
||
static_print_debug("quality:%d, visableSatNum:%d, CnrMax:%d", quality, visableSatNum, CnrMax);
|
||
return quality;
|
||
}
|
||
|
||
static void GnssContextDispatchEvent(const GnssInfo &gnssInfo, GnssNmeaFrameType nmeaType,
|
||
const GnssNmeaFrameProcess &nmeaFrameProcess)
|
||
{
|
||
int32_t ret = 0;
|
||
switch (nmeaType) {
|
||
case GnssNmeaFrameType::GNSS_NMEA_FRAME_GGA: {
|
||
const GnssNmeaGGA *gga = &nmeaFrameProcess.nmeaFrame.nmeaGGA;
|
||
break;
|
||
}
|
||
case GnssNmeaFrameType::GNSS_NMEA_FRAME_GSV: {
|
||
if (g_gnssServiceCtx.gnssCallback.onGsvUpdate != NULL) {
|
||
g_gnssServiceCtx.gnssCallback.onGsvUpdate(&gnssInfo.satelist);
|
||
}
|
||
if (g_gnssServiceCtx.gnssCallback.onSignalQualityUpdate != NULL) {
|
||
g_gnssServiceCtx.gnssCallback.onSignalQualityUpdate(GetGnssSignalQualityLevel(gnssInfo));
|
||
}
|
||
break;
|
||
}
|
||
case GnssNmeaFrameType::GNSS_NMEA_FRAME_RMC: {
|
||
break;
|
||
}
|
||
case GnssNmeaFrameType::GNSS_NMEA_FRAME_TH002: {
|
||
ResetLocationSatelliteStatus(&g_gnssServiceCtx);
|
||
ret = LocationGnssUtilsFillGnssLocation(&g_gnssServiceCtx.gnssInfo, &g_gnssServiceCtx.location);
|
||
if (ret == GNSS_SUCCESS) {
|
||
g_gnssServiceCtx.gnssCallback.onLocationUpdate(&g_gnssServiceCtx.location);
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void GnssListenDataTask(void *argument)
|
||
{
|
||
int32_t ret = 0;
|
||
|
||
UNUSED(argument);
|
||
|
||
g_gnssServiceCtx.gnssStarted = true;
|
||
|
||
uapi_pm_add_sleep_veto(PM_ID_SYS);
|
||
|
||
tiot_handle handle = tiot_service_open("gn71", NULL);
|
||
if (handle == 0) {
|
||
static_print_error("open tiot service fail");
|
||
goto GNSS_STOP;
|
||
}
|
||
static_print_debug("open tiot service success");
|
||
|
||
if (InjectPgnssLessFilesCfgAutoStartFixModeAndNmeaDefault(handle) == 0) {
|
||
static_print_error("InjectPgnssLessFilesCfgAutoStartFixModeAndNmeaDefault failed");
|
||
goto GNSS_STOP;
|
||
}
|
||
if (QryVersion(handle) == 0) {
|
||
static_print_error("QryVersion failed");
|
||
goto GNSS_STOP;
|
||
}
|
||
if (StartGnss(handle) == 0) {
|
||
static_print_error("start gnss failed");
|
||
goto GNSS_STOP;
|
||
}
|
||
|
||
if (g_gnssServiceBuff == NULL) {
|
||
g_gnssServiceBuff = (uint8_t *)malloc(REPORT_MAX_BYTES * sizeof(uint8_t));
|
||
if (g_gnssServiceBuff == NULL) {
|
||
static_print_error("malloc failed in gps_service_task");
|
||
goto GNSS_STOP;
|
||
}
|
||
}
|
||
|
||
// listening gnss data
|
||
while (true) {
|
||
osMutexAcquire(g_gnssMutex, osWaitForever);
|
||
bool shouldExit = !g_gnssServiceCtx.gnssStarted || g_gnssServiceCtx.gnssEnabled;
|
||
osMutexRelease(g_gnssMutex);
|
||
|
||
if (shouldExit) {
|
||
break;
|
||
}
|
||
|
||
GnssNmeaFrameProcess nmeaFrameProcess = {};
|
||
|
||
ret = tiot_service_read(handle, g_gnssServiceBuff, REPORT_MAX_BYTES, LISTEN_TIME_THR);
|
||
if (ret <= 0) {
|
||
static_print_error("error: tiot_service_read error: %d", ret);
|
||
continue;
|
||
}
|
||
uint16_t *type = (uint16_t *)g_gnssServiceBuff;
|
||
if (type[0] != MSG_TYPE_ASCII) {
|
||
continue;
|
||
}
|
||
g_gnssServiceBuff[ret] = '\0';
|
||
const char *nmeaLine = ((const char *)&g_gnssServiceBuff[MSG_CONTENT_IDX]);
|
||
int32_t nmeaLen = ret - MSG_CONTENT_IDX;
|
||
|
||
GnssNmeaFrameType nmeaType = TJD::GnssNmeaGetFrameType(nmeaLine, nmeaLen);
|
||
static_print_debug("nmeaType:%d nmeaStr:%s nmeaLen:%d", nmeaType, nmeaLine, nmeaLen);
|
||
if (nmeaType >= GNSS_NMEA_FRAME_MAX) {
|
||
static_print_warn("invalid nmeaStr:%s", nmeaLine);
|
||
continue;
|
||
}
|
||
if (nmeaType == GNSS_NMEA_FRAME_GGA) {
|
||
ResetGnssInfo(&g_gnssServiceCtx);
|
||
}
|
||
ret = TJD::GnssNmeaDecodeFrame(nmeaLine, nmeaLen, &g_gnssServiceCtx.gnssInfo, &nmeaFrameProcess);
|
||
if (ret != GNSS_SUCCESS) {
|
||
static_print_warn("invalid nmeaStr:%s", nmeaLine);
|
||
}
|
||
|
||
if (ret == GNSS_SUCCESS) {
|
||
GnssContextDispatchEvent(g_gnssServiceCtx.gnssInfo, nmeaType, nmeaFrameProcess);
|
||
}
|
||
|
||
printf("%s", nmeaLine);
|
||
fprintf(g_gnssLogFp, "%s\n", nmeaLine);
|
||
}
|
||
|
||
GNSS_STOP:
|
||
|
||
StopGnss(handle);
|
||
|
||
tiot_service_close(handle);
|
||
|
||
fclose(g_gnssLogFp);
|
||
g_gnssLogFp = NULL;
|
||
|
||
if (g_gnssServiceBuff) {
|
||
free(g_gnssServiceBuff);
|
||
g_gnssServiceBuff = NULL;
|
||
}
|
||
|
||
uapi_pm_remove_sleep_veto(PM_ID_SYS);
|
||
|
||
static_print_debug("finish gnss");
|
||
|
||
osMutexAcquire(g_gnssMutex, osWaitForever);
|
||
g_gnssServiceCtx.gnssEnabled = false;
|
||
osMutexRelease(g_gnssMutex);
|
||
}
|
||
|
||
void GnssServiceRegisterCallback(GnssCallbackIfaces *callback)
|
||
{
|
||
memcpy_s(&g_gnssServiceCtx.gnssCallback, sizeof(GnssCallbackIfaces), callback, sizeof(GnssCallbackIfaces));
|
||
}
|
||
|
||
uint32_t GnssServiceOpen(void)
|
||
{
|
||
osMutexAcquire(g_gnssMutex, osWaitForever);
|
||
if (g_gnssServiceCtx.gnssStarted || g_gnssServiceCtx.gnssEnabled) {
|
||
osMutexRelease(g_gnssMutex);
|
||
return GNSS_THREAD_RUNNING;
|
||
}
|
||
|
||
// 创建线程前标记状态
|
||
g_gnssServiceCtx.gnssStarted = true;
|
||
osMutexRelease(g_gnssMutex);
|
||
|
||
// 打开日志文件
|
||
g_gnssLogFp = fopen("/user/gnss.log", "w");
|
||
if (g_gnssLogFp == NULL) {
|
||
static_print_error("open log file error");
|
||
return GNSS_FILE_OPEN_FAILURE;
|
||
}
|
||
|
||
osThreadAttr_t task_attr = {"TjdGnssListenDataTask", 0, NULL, 0, NULL, 0x2000, osPriorityHigh, 0, 0};
|
||
task_attr.stack_mem = memalign(16, task_attr.stack_size); // add
|
||
g_gnssThreadId = osThreadNew(GnssListenDataTask, NULL, &task_attr);
|
||
if (g_gnssThreadId == NULL) {
|
||
static_print_error("create gps service task failed");
|
||
return GNSS_THREAD_CREATE_FAILURE;
|
||
}
|
||
return GNSS_SUCCESS;
|
||
}
|
||
|
||
void GnssServiceClose(void)
|
||
{
|
||
osMutexAcquire(g_gnssMutex, osWaitForever);
|
||
if (!g_gnssServiceCtx.gnssStarted) {
|
||
osMutexRelease(g_gnssMutex);
|
||
return;
|
||
}
|
||
|
||
g_gnssServiceCtx.gnssStarted = false;
|
||
g_gnssServiceCtx.gnssEnabled = true; // 设置强制退出标志
|
||
osMutexRelease(g_gnssMutex);
|
||
|
||
// 等待线程实际退出
|
||
if (osThreadGetState(g_gnssThreadId) != osThreadTerminated) {
|
||
osThreadJoin(g_gnssThreadId);
|
||
}
|
||
} |