mbtk/liblynq_lib/src/lynq_gnss.c

#include <time.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "lynq_gnss.h"




#define QSER_LEN_MAX 128

#define QSER_RESULT_SUCCESS 0
#define QSER_RESULT_FAIL -1
#define QSER_GNSS_TIMEOUT 5

/**********************************VARIABLE***********************************/
typedef struct
{
    char host[QSER_LEN_MAX];
    char id[QSER_LEN_MAX];
    char passwd[QSER_LEN_MAX];
}qser_gnss_info;

static bool inited = FALSE;
static int qser_info_handle_num = 0;
static uint32_t qser_h_sim = 0x5F6F7F8F;
gnss_handler_func_t qser_gnss_callback = NULL;
e_msg_id_t qser_gnss_msg_type = E_MT_LOC_MSG_ID_NMEA_INFO;
static time_t qser_gnss_time = 0;
qser_gnss_info qser_agps_info_save = {0};
gnss_async_func_t qser_gnss_async_callback = NULL;
static mbtk_gnss_nmea_func_t gnss_nmea_cb = NULL;


extern long timezone;
/**********************************VARIABLE***********************************/

/**********************************FUNC***********************************/
static void qser_gnss_async_set_cb(gnss_async_func_t cb)
{
    qser_gnss_async_callback = cb;
}

static gnss_async_func_t qser_gnss_async_get_cb(void)
{
    return qser_gnss_async_callback;
}


static time_t qser_get_timestamp(char *time)
{
    char tmp_char[4] = {0};
    struct tm* tmp_time = (struct tm*)malloc(sizeof(struct tm));

    memset(tmp_time, 0, sizeof(struct tm));
    memset(tmp_char, 0, sizeof(tmp_char));
    memcpy(tmp_char, &time[4], 2);
    tmp_time->tm_sec = atoi(tmp_char);
    memcpy(tmp_char, &time[2], 2);
    tmp_time->tm_min = atoi(tmp_char);
    memcpy(tmp_char, &time[0], 2);
    tmp_time->tm_hour = atoi(tmp_char);
    memcpy(tmp_char, &time[6], 2);
    tmp_time->tm_mday = atoi(tmp_char);
    memcpy(tmp_char, &time[8], 2);
    tmp_time->tm_mon = atoi(tmp_char) - 1;
    memcpy(tmp_char, &time[10], 2);
    tmp_time->tm_year = 100 + atoi(tmp_char);

    time_t _t = mktime(tmp_time);//按当地时区解析tmp_time
    //gnss_log("timestamp: %ld\n",_t);
    tzset();   // 自动设置本地时区
    _t = _t - timezone;
    //gnss_log("timestamp: %ld\n",_t);

    free(tmp_time);
    return _t;
}

static time_t qser_get_gnss_time_sec(void *data, int data_len)
{
    int i = 0, num = 0;
    char *nmea = (char *)data;
    char time[15] = {0};
    char *check_state = NULL;

    //$GNRMC,024142.000,A,3039.364421,N,10403.417935,E,0.051,0.00,030124,,E,A*00
    check_state = strstr(nmea, "RMC");
    if(check_state != NULL)
    {
        for(i = 0; i < data_len; i++)
        {
            if(check_state[i] == ',')
            {
                num++;
                i++;
                if(num == 1)//get time
                {
                    if(check_state[i] >= '0' && check_state[i] <= '9')
                    {
                        memcpy(time, check_state + i, 6);
                        LOGE("[qser_gnss] %s.", time);
                    }
                    else
                    {
                        qser_gnss_time = 0;
                        return qser_gnss_time;
                    }
                }
                else if(num == 9)//get date
                {
                    if(check_state[i] >= '0' && check_state[i] <= '9')
                    {
                        memcpy(time + 6, check_state + i, 6);
                        LOGE("[qser_gnss] %s.", time);
                        break;
                    }
                    else
                    {
                        qser_gnss_time = 0;
                        return qser_gnss_time;
                    }
                }
                else if(num > 9)
                {
                    qser_gnss_time = 0;
                    return qser_gnss_time;
                }
            }
        }

        qser_gnss_time = qser_get_timestamp(time);
    }

    return qser_gnss_time;
}

static void qser_gnss_msg_cb(void *data, int data_len)
{
    if(data == NULL || data_len <= 0)
    {
        LOGE("[qser_gnss] data is NULL.");
        return;
    }

    if(qser_gnss_callback == NULL)
    {
        LOGE("[qser_gnss] qser_gnss_callback is NULL.");
        return;
    }
    
    if(qser_gnss_msg_type == E_MT_LOC_MSG_ID_NMEA_INFO)
    {
        mopen_gnss_nmea_info_t qser_nmea = {0};
        memset(&qser_nmea, 0x0, sizeof(mopen_gnss_nmea_info_t));
        qser_nmea.length = data_len;
        memcpy(qser_nmea.nmea, (char *)data, data_len);
        qser_nmea.timestamp = qser_get_gnss_time_sec(data, data_len);

        if(qser_gnss_callback != NULL)
        {
            qser_gnss_callback(NULL, qser_gnss_msg_type, (void *)(&qser_nmea), NULL);
        }
    }
    else if(qser_gnss_msg_type == E_MT_LOC_MSG_ID_LOCATION_INFO)
    {
        //NOT USE
    }
    else
    {
        //UNKNOWN
    }
}


static void* gnss_async_thread(void* arg)
{
    qser_gnss_error_e state = QSER_GNSS_ERROR_SUCCESS;
    gnss_async_func_t cb = qser_gnss_async_get_cb();
    int ret = qser_Gnss_Start(qser_h_sim);
    if(ret != QSER_RESULT_SUCCESS)
    {
        LOGE("[qser_gnss] gnss_async_thread() fail.");
        state = QSER_GNSS_ERROR_FAIL;
    }

    if(cb != NULL)
    {
        cb(state);
    }
    return NULL;
}

gnss_err_enum gnss_add_nmea_out_func(mbtk_gnss_nmea_func_t cb)
{
    if(cb == NULL)
    {
        LOGE("[mbtk_gnss_api] cb is NULL.");
        return GNSS_ERR_UNKNOWN;
    }
    gnss_nmea_cb = cb;

    return GNSS_ERR_OK;
}


static void gnss_callback(uint32 ind_type, const void* data, uint32 data_len)
{
    if(ind_type == MBTK_GNSS_IND_LOCATION) {
        printf("LOC : %s\n", data);
    } else if(ind_type == MBTK_GNSS_IND_NMEA) {
        printf("NMEA : %s\n", data);
        gnss_nmea_cb(data, data_len);
    } else {
        printf("Unknown IND : %d\n", ind_type);
    }
}


/**********************************FUNC***********************************/

/**********************************API***********************************/
int qser_Gnss_Init (uint32_t *h_gnss)
{
    //UNUSED(h_gnss);
    gnss_err_enum ret = GNSS_ERR_UNKNOWN;

    if(!inited)
    {
        ret = mbtk_gnss_init(gnss_callback);
        if(ret == GNSS_ERR_OK)
        {
            qser_info_handle_num++;
            inited = TRUE;
        }
        else
        {
            LOGE("[qser_gnss] mbtk_gnss_init() fail.");
            return QSER_RESULT_FAIL;
        }
    }
    else
    {
        qser_info_handle_num++;
    }
    *h_gnss = qser_h_sim;

    return QSER_RESULT_SUCCESS;
}

int qser_Gnss_Deinit (uint32_t h_gnss)
{
    //UNUSED(h_gnss);
    if(h_gnss != qser_h_sim)
    {
        LOGE("[qser_gnss] h_sim is error.");
        return QSER_RESULT_FAIL;
    }
    
    gnss_err_enum ret = GNSS_ERR_UNKNOWN;

    if(qser_info_handle_num == 1)
    {
        ret = mbtk_gnss_deinit();
        if(ret == GNSS_ERR_OK)
        {
            qser_info_handle_num = 0;
            inited = FALSE;
        }
        else
        {
            LOGE("[qser_gnss] mbtk_gnss_init() fail.");
            return QSER_RESULT_FAIL;
        }
    }
    else
    {
        qser_info_handle_num--;
    }

    return QSER_RESULT_SUCCESS;
}


int qser_AddRxIndMsgHandler (gnss_handler_func_t handler_ptr,uint32_t h_gnss)
{
    //UNUSED(handler_ptr);
    //UNUSED(h_gnss);
    if(h_gnss != qser_h_sim)
    {
        LOGE("[qser_gnss] h_sim is error.");
        return QSER_RESULT_FAIL;
    }

    if(handler_ptr == NULL)
    {
        LOGE("[qser_gnss] handler_ptr is NULL.");
        return QSER_RESULT_FAIL;
    }
    
    qser_gnss_callback = handler_ptr;
    return QSER_RESULT_SUCCESS;
}


int qser_Set_Indications (uint32_t h_gnss,e_msg_id_t type)
{
    //UNUSED(h_gnss);
    //UNUSED(type);
    if(h_gnss != qser_h_sim)
    {
        LOGE("[qser_gnss] h_sim is error.");
        return QSER_RESULT_FAIL;
    }

    qser_gnss_msg_type = type;
    return QSER_RESULT_SUCCESS;
}

int qser_Gnss_Set_Async_Callback(gnss_async_func_t cb)
{
    qser_gnss_async_set_cb(cb);
    return QSER_RESULT_SUCCESS;
}


int qser_Gnss_Start (uint32_t h_gnss)
{
    //UNUSED(h_gnss);
    if(h_gnss != qser_h_sim)
    {
        LOGE("[qser_gnss] h_sim is error.");
        return QSER_RESULT_FAIL;
    }

    gnss_err_enum ret = GNSS_ERR_UNKNOWN;

    ret = gnss_add_nmea_out_func(qser_gnss_msg_cb);
    if(ret != GNSS_ERR_OK)
    {
        LOGE("[qser_gnss] mbtk_gnss_add_nmea_out_func fail.");
        return QSER_RESULT_FAIL;
    }

    ret = mbtk_gnss_open(1, QSER_GNSS_TIMEOUT);
    if(ret != GNSS_ERR_OK)
    {
        LOGE("[qser_gnss] mbtk_gnss_open is error.");
        return QSER_RESULT_FAIL;
    }
    
    return QSER_RESULT_SUCCESS;
}



int qser_Gnss_Start_Async(uint32_t h_gnss)
{
    //UNUSED(h_gnss);
    if(h_gnss != qser_h_sim)
    {
        LOGE("[qser_gnss] h_sim is error.");
        return QSER_RESULT_FAIL;
    }

    pthread_attr_t thread_attr;
    pthread_t gnss_thread_id;
    pthread_attr_init(&thread_attr);
    if(pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED))
    {
        LOGE("[qser_gnss] pthread_attr_setdetachstate() fail.");
        return QSER_RESULT_FAIL;
    }

    //memcpy(&qser_data_backup, data_call, sizeof(qser_data_call_s));
    if(pthread_create(&gnss_thread_id, &thread_attr, gnss_async_thread, NULL))
    {
        LOGE("[qser_gnss] pthread_create() fail.");
        return QSER_RESULT_FAIL;
    }
    pthread_attr_destroy(&thread_attr);
    
    return QSER_RESULT_SUCCESS;
}


int qser_Gnss_Stop (uint32_t h_gnss)
{
    //UNUSED(h_gnss);
    if(h_gnss != qser_h_sim)
    {
        LOGE("[qser_gnss] h_sim is error.");
        return QSER_RESULT_FAIL;
    }

    gnss_err_enum ret = GNSS_ERR_UNKNOWN;
    ret = mbtk_gnss_close(QSER_GNSS_TIMEOUT);
    if(ret != GNSS_ERR_OK)
    {
        LOGE("[qser_gnss] mbtk_gnss_close is error.");
        return QSER_RESULT_FAIL;
    }
    gnss_nmea_cb = NULL;
    
    return QSER_RESULT_SUCCESS;
}

int qser_Gnss_InjectTime (uint32_t h_gnss,LYNQ_INJECT_TIME_INTO_T *time_info)
{
    UNUSED(h_gnss);
    UNUSED(time_info);

    return 0;
}

/*
int qser_Gnss_Delete_Aiding_Data (uint32_t h_gnss,DELETE_AIDING_DATA_TYPE_T flags)
{
    //UNUSED(h_gnss);
    //UNUSED(flags);
    
    if(h_gnss != qser_h_sim)
    {
        LOGE("[qser_gnss] h_sim is error.");
        return QSER_RESULT_FAIL;
    }

    gnss_err_enum ret = GNSS_ERR_UNKNOWN;
    char param_buf[32] = {0};
    int  length = 0;

    switch(flags)
    {
        case DELETE_NOTHING:
        {
            memcpy(param_buf, "RESET,1", strlen("RESET,1"));
            break;
        }
        case DELETE_EPHEMERIS:
        case DELETE_ALMANAC:
        case DELETE_POSITION_TIME:
        case DELETE_UTC:
        {
            memcpy(param_buf, "RESET,2", strlen("RESET,2"));
            break;
        }
        case DELETE_ALL:
        {
            memcpy(param_buf, "RESET,3", strlen("RESET,3"));
            break;
        }
        default:
        {
            LOGE("[qser_gnss] flags UNKOWN.");
            return QSER_RESULT_FAIL;
        }
    }

    length = strlen(param_buf);
    ret = mbtk_gnss_param_config(param_buf, length);
    if(ret != MBTK_GNSS_RESULT_SUCCESS)
    {
        LOGE("[qser_gnss] mbtk_gnss_param_config is error.");
        return QSER_RESULT_FAIL;
    }
    return QSER_RESULT_SUCCESS;
}
*/

int qser_Gnss_Server_Configuration(char *host, char *id, char *password)
{
    //UNUSED(host);
    //UNUSED(id);
    //UNUSED(password);

    if(host != NULL)
    {
        memcpy(qser_agps_info_save.host, host, QSER_LEN_MAX);
    }

    if(id != NULL)
    {
        memcpy(qser_agps_info_save.id, id, QSER_LEN_MAX);
    }

    if(password != NULL)
    {
        memcpy(qser_agps_info_save.passwd, password, QSER_LEN_MAX);
    }
    return QSER_RESULT_SUCCESS;
}


int qser_Gnss_download(const char *fw_path, int timeout)
{
    gnss_err_enum ret = GNSS_ERR_UNKNOWN;    
    ret = mbtk_gnss_dl(fw_path, timeout);
    if(ret != GNSS_ERR_OK)
    {
        LOGE("[qser_gnss] mbtk_gnss_download  is error.");
        return QSER_RESULT_FAIL;
    }
    return QSER_RESULT_SUCCESS;
}

/*
int qser_Gnss_Set_Frequency(uint32_t h_gnss, int frequency)
{
    //UNUSED(h_gnss);
    //UNUSED(frequency);

    if(h_gnss != qser_h_sim)
    {
        LOGE("[qser_gnss] h_sim is error.");
        return QSER_RESULT_FAIL;
    }

    if(frequency != 1 && frequency != 2 && frequency != 5)
    {
        LOGE("[qser_gnss] frequency out of range.");
        return QSER_RESULT_FAIL;
    }

    gnss_err_enum ret = GNSS_ERR_UNKNOWN;    
    char param_buf[32] = {0};
    int  length = 0;
    length = snprintf(param_buf, 32, "NAVISYSCFG,7,%d", frequency);
    ret = mbtk_gnss_dl(param_buf, length);
    if(ret != MBTK_GNSS_RESULT_SUCCESS)
    {
        LOGE("[qser_gnss] mbtk_gnss_param_config is error.");
        return QSER_RESULT_FAIL;
    }
    return QSER_RESULT_SUCCESS;
}
*/
/**********************************API***********************************/