#include "runtime.h"
-#if MICROPY_QPY_MODULE_QUECGNSS
+#if 1
#include "helios_debug.h"
#include "helios_gnss.h"
-#define MOD_GNSS_LOG(msg, ...) custom_log(GNSS, msg, ##__VA_ARGS__)
-
+//#define MOD_GNSS_LOG(msg, ...) custom_log(GNSS, msg, ##__VA_ARGS__)
+#define MOD_GNSS_LOG(msg, ...)
+Helios_Thread_t GNSS_thread_id =0;
static c_callback_t *g_usr_callback = NULL;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_gnss_register_usr_callback_obj, mp_gnss_register_usr_callback);
-#if defined(PLAT_Unisoc_8850)
+#if defined(PLAT_Unisoc_8850) || defined(PLAT_Qualcomm)
STATIC mp_obj_t mp_gnss_set_priority(mp_obj_t priority)
{
- int ret=0;
+ int ret = 0;
int pri = mp_obj_get_int(priority);
- if ((pri < 0) || (pri > 3))
+ if ((pri < HELIOS_GNSS_PRIORITY_GROUP_0) || (pri >= HELIOS_GNSS_PRIORITY_GROUP_MAX))
{
- mp_raise_ValueError("invalid value, priority should be in [0,3].");
+ char errmsg[64] = {0};
+ sprintf(errmsg, "invalid value, priority should be in [%d,%d).", HELIOS_GNSS_PRIORITY_GROUP_0, HELIOS_GNSS_PRIORITY_GROUP_MAX);
+ mp_raise_ValueError(errmsg);
}
ret = Helios_GNSS_SetGnssLtePriority((Helios_GNSS_LTE_Priority)pri);
return mp_obj_new_int(ret);
STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_gnss_get_priority_obj, mp_gnss_get_priority);
#endif
+//查找最近的相同字符，查到返回偏移量，查补到返回-1
+int Find_char(char *data ,char c)
+{
+ int i=0;
+ int len = strlen(data);
+ for(i = 0;i<65536;i++)
+ {
+ if(i > (len-1) || data[i] == c )
+ break;
+ }
+ if(i > (len-1) || i >= 65536)
+ return -1;
+ else
+ return i;
+}
+int gnss_enable = 0;
+#define GNSS_Parser_len 120
+#define GNSS_Parser_gsv_len 64
+typedef struct _GNSS_data
+{
+ char rmc_data[GNSS_Parser_len+1];
+ char vtg_data[GNSS_Parser_len+1];
+ char gga_data[GNSS_Parser_len+1];
+ char unsigned gsv_data[GNSS_Parser_gsv_len*2];
+ int gsv_data_len;
+}GNSS_data;
+GNSS_data GNSS_Parser_data = {0};
+void GNSS_Nmea_Parser(GNSS_data *data, char *recbuff)
+{
+ char* buff_tmp = NULL;
+ int Parser_len = 0;
+
+ memset(data,0,sizeof(GNSS_data));
+ while(*recbuff)
+ {
+ if(*recbuff == '$')
+ {
+ if(memcmp(recbuff+3,"GGA",3) == 0)
+ {
+ buff_tmp = strstr(recbuff,"\r\n");
+ if(buff_tmp)
+ {
+
+ Parser_len = buff_tmp - recbuff;
+ if (Parser_len > GNSS_Parser_len)
+ Parser_len = GNSS_Parser_len;
+ memcpy(data->gga_data,recbuff,Parser_len);
+ data->gga_data[Parser_len] = 0;
+ recbuff = buff_tmp;
+ //MOD_GNSS_LOG("gga_data:%s\n",data->gga_data);
+ }
+ }else if(memcmp(recbuff+3,"RMC",3) == 0)
+ {
+ buff_tmp = strstr(recbuff,"\r\n");
+ if(buff_tmp)
+ {
+
+ Parser_len = buff_tmp - recbuff;
+ if (Parser_len > GNSS_Parser_len)
+ Parser_len = GNSS_Parser_len;
+ memcpy(data->rmc_data,recbuff,Parser_len);
+ data->rmc_data[Parser_len] = 0;
+ recbuff = buff_tmp;
+ //MOD_GNSS_LOG("rmc_data:%s\n",data->rmc_data);
+ }
+ }else if(memcmp(recbuff+3,"VTG",3) == 0)
+ {
+ buff_tmp = strstr(recbuff,"\r\n");
+ if(buff_tmp)
+ {
+ Parser_len = buff_tmp - recbuff;
+ if (Parser_len > GNSS_Parser_len)
+ Parser_len = GNSS_Parser_len;
+ memcpy(data->vtg_data,recbuff,Parser_len);
+ data->vtg_data[Parser_len] = 0;
+ recbuff = buff_tmp;
+ //MOD_GNSS_LOG("vtg_data:%s\n",data->vtg_data);
+ }
+ }
+ else if(memcmp(recbuff+3,"GSV",3) == 0)
+ {
+ buff_tmp = strstr(recbuff,"\r\n");
+ if(buff_tmp)
+ {
+ //char *gsv_data = ;
+ char data_tmp[11] = {0};
+ int gsv_count = 0;
+ Parser_len = buff_tmp - recbuff;
+ // if (Parser_len > GNSS_Parser_len)
+ // Parser_len = GNSS_Parser_len;
+ //memcpy(gsv_data,recbuff,Parser_len);
+ char *gsv_data_tmp = recbuff;
+ //MOD_GNSS_LOG("gsv_data:%s\n",gsv_data);
+ while(*gsv_data_tmp)
+ {
+ Parser_len--;
+ if(Parser_len <= 0)
+ break;
+ if(*gsv_data_tmp == ',')
+ {
+ gsv_data_tmp++;
+ gsv_count++;
+ if(gsv_count>3)
+ {
+ if(gsv_count%4 == 0 || gsv_count%4 == 3)//卫星信噪比 卫星编号
+ {
+ memset(data_tmp,0,11);
+ int len_tmp = Find_char(gsv_data_tmp,',');
+ //MOD_GNSS_LOG("Find_char1:len:%d %s\n",len_tmp,gsv_data_tmp);
+ if( len_tmp == -1)
+ break;
+ if(len_tmp > 10)
+ len_tmp = 10;
+ memcpy(data_tmp,gsv_data_tmp,len_tmp);
+ // if(data->gsv_data_len%2 != 0 && data->gsv_data_len >= 1)
+ // data->gsv_data_len--;
+ if(len_tmp>0)
+ data->gsv_data[data->gsv_data_len] = (unsigned char)atoi(data_tmp);
+ else
+ data->gsv_data[data->gsv_data_len] = 0;
+ //MOD_GNSS_LOG("gsv_data: [%d]:",data->gsv_data[data->gsv_data_len]);
+ data->gsv_data_len++;
+ }
+ // if(gsv_count%4 == 3)//卫星信噪比
+ // {
+ // memset(data_tmp,0,11);
+ // int len_tmp = Find_char(gsv_data_tmp,',');
+ // //MOD_GNSS_LOG("Find_char2:len:%d %s\n",len_tmp,gsv_data_tmp);
+ // if( len_tmp == -1)
+ // break;
+ // if(len_tmp > 10)
+ // len_tmp = 10;
+ // memcpy(data_tmp,gsv_data_tmp,len_tmp);
+ // // if(data->gsv_data_len%2 != 1 && data->gsv_data_len >= 1)
+ // // data->gsv_data_len--;
+ // if(len_tmp>0)
+ // data->gsv_data[data->gsv_data_len] = (char)atoi(data_tmp);
+ // else
+ // data->gsv_data[data->gsv_data_len] = 0;
+ // //MOD_GNSS_LOG("[%d]:%d \n",data->gsv_data[data->gsv_data_len-1],data->gsv_data[data->gsv_data_len]);
+ // data->gsv_data_len++;
+ // }
+ if(data->gsv_data_len >= GNSS_Parser_gsv_len*2)
+ break;
+ }
+ }
+ else if(*gsv_data_tmp == '*')
+ break;
+ else
+ gsv_data_tmp++;
+ }
+
+ recbuff = buff_tmp;
+ }
+ }
+ }
+ recbuff++;
+ }
+}
+void GNSS_thread_entry(void * argv)
+{
+ MOD_GNSS_LOG("GNSS_thread_entry:1!!!\n");
+ //MP_THREAD_GIL_EXIT();
+ int ret = Helios_GNSS_Switch(HELIOS_GNSS_ENABLE);//开启
+ //MP_THREAD_GIL_ENTER();
+ int recbuff_len_max = 4096;
+ char *recbuff=NULL;
+ //MOD_GNSS_LOG("GNSS_thread_entry:2!!!\n");
+ recbuff = calloc(1, recbuff_len_max + 1);
+ if(NULL==recbuff)
+ {
+ MOD_GNSS_LOG("malloc err.\r\n");
+ return ;
+ }
+ //MOD_GNSS_LOG("GNSS_thread_entry:3!!!\n");
+ while(gnss_enable)
+ {
+ memset(recbuff, 0, recbuff_len_max + 1);
+ //MP_THREAD_GIL_EXIT();
+ ret = Helios_GNSS_GetNmea((unsigned char *)recbuff, recbuff_len_max);
+ //recbuff[recbuff_len_max] = 0;
+ MOD_GNSS_LOG("Helios_GNSS_GetNmea:%d\n",ret);
+ //MOD_GNSS_LOG("recbuff:\n%s\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n",recbuff);
+ //MP_THREAD_GIL_ENTER();
+ if (ret != 0)
+ {
+ break;
+ }
+ //GNSS_Parser_data = {0};
+ GNSS_Nmea_Parser(&GNSS_Parser_data,recbuff);
+ MOD_GNSS_LOG("\nGNSS_Nmea_Parser!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+ Helios_msleep(1000);
+ }
+ if(NULL != recbuff)
+ {
+ free(recbuff);
+ recbuff=NULL;
+ }
+ // MP_THREAD_GIL_EXIT();
+ // Helios_GNSS_Switch(HELIOS_GNSS_DISABLE);//关闭
+ // MP_THREAD_GIL_ENTER();
+
+ //Helios_Thread_Delete(GNSS_thread_id);
+ GNSS_thread_id = 0;
+ MOD_GNSS_LOG("GNSS_thread_entry1:end\n");
+ Helios_Thread_Exit();
+ MOD_GNSS_LOG("GNSS_thread_entry2:end\n");
+}
+Helios_ThreadAttr ThreadAttr_GNSS = {
+ .name = "GNSS_thead",
+ .stack_size = 1024*10,
+ .priority = 100,
+ .entry = GNSS_thread_entry,
+ .argv = NULL
+ };
+STATIC mp_obj_t mp_get_gnss_gsv(void)
+{
+ mp_obj_t tuple[GNSS_Parser_gsv_len*2];
+ for(int i = 0;i<GNSS_Parser_data.gsv_data_len;i++)
+ {
+ tuple[i] = mp_obj_new_int(GNSS_Parser_data.gsv_data[i]);
+ // if(i%2 == 0)
+ // {
+ // MOD_GNSS_LOG("mp_get_gnss_gsv:%d:[%d]\n",GNSS_Parser_data.gsv_data[i],GNSS_Parser_data.gsv_data[i+1]);
+ // }
+
+ }
+ return mp_obj_new_tuple(GNSS_Parser_data.gsv_data_len, tuple);
+}
+STATIC mp_obj_t mp_get_gnss_gga(void)
+{
+ return mp_obj_new_str((char *)GNSS_Parser_data.gga_data, strlen((char *)GNSS_Parser_data.gga_data));
+}
+STATIC mp_obj_t mp_get_gnss_rmc(void)
+{
+ return mp_obj_new_str((char *)GNSS_Parser_data.rmc_data, strlen((char *)GNSS_Parser_data.rmc_data));
+}
+STATIC mp_obj_t mp_get_gnss_vtg(void)
+{
+ return mp_obj_new_str((char *)GNSS_Parser_data.vtg_data, strlen((char *)GNSS_Parser_data.vtg_data));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_get_gnss_gsv_obj, mp_get_gnss_gsv);
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_get_gnss_gga_obj, mp_get_gnss_gga);
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_get_gnss_rmc_obj, mp_get_gnss_rmc);
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_get_gnss_vtg_obj, mp_get_gnss_vtg);
STATIC mp_obj_t mp_gnss_switch(mp_obj_t opt)
{
int ret=0;
- int gnss_enable = mp_obj_get_int(opt);
- if ((gnss_enable < 0) || (gnss_enable > 2))
+ int gnss_enable_t = mp_obj_get_int(opt);
+ if ((gnss_enable_t < 0) || (gnss_enable_t > 3))
{
mp_raise_ValueError("invalid value, opt should be in [0,2].");
+ return mp_obj_new_int(-1);
}
- MP_THREAD_GIL_EXIT();
- ret = Helios_GNSS_Switch((Helios_GnssSW)gnss_enable);
- MP_THREAD_GIL_ENTER();
+ MOD_GNSS_LOG("gnss_enable_t:%d\n",gnss_enable_t);
+ if(gnss_enable_t == HELIOS_GNSS_ENABLE_THREAD && gnss_enable != HELIOS_GNSS_ENABLE_THREAD)//需要开启线程解析
+ {
+ GNSS_thread_id = Helios_Thread_Create(&ThreadAttr_GNSS);
+ MOD_GNSS_LOG("open GNSS_thread %d!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n",GNSS_thread_id);
+ }else
+ {
+ MP_THREAD_GIL_EXIT();
+
+
+ ret = Helios_GNSS_Switch((Helios_GnssSW)gnss_enable_t);//
+
+ MP_THREAD_GIL_ENTER();
+ }
+
+ gnss_enable = gnss_enable_t;
+
return mp_obj_new_int(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_gnss_switch_obj, mp_gnss_switch);
recbuff_len_max = mp_obj_get_int(size);
recbuff = calloc(1, recbuff_len_max + 1);
- memset(recbuff, 0, recbuff_len_max + 1);
+
if(NULL==recbuff)
{
MOD_GNSS_LOG("malloc err.\r\n");
return mp_obj_new_int(-1);
}
-
+ memset(recbuff, 0, recbuff_len_max + 1);
MP_THREAD_GIL_EXIT();
- int ret = Helios_GNSS_GetNmea(recbuff, recbuff_len_max);
+ int ret = Helios_GNSS_GetNmea((unsigned char*)recbuff, recbuff_len_max);
MP_THREAD_GIL_ENTER();
if (ret != 0)
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(qpy_module_gnss_deinit_obj, qpy_module_gnss_deinit);
+#if defined(PLAT_ASR_1606)
+STATIC mp_obj_t qpy_module_gnss_config_set(mp_obj_t mp_config_type, mp_obj_t mp_config_value)
+{
+ int config_type = mp_obj_get_int(mp_config_type);
+ int config_value = mp_obj_get_int(mp_config_value);
+ int ret = Helios_GNSS_Configuration_Set((uint8_t)config_type, (uint8_t)config_value);
+ return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(qpy_module_gnss_config_set_obj, qpy_module_gnss_config_set);
+STATIC mp_obj_t qpy_module_gnss_config_get(mp_obj_t mp_config_type)
+{
+ int config_type = mp_obj_get_int(mp_config_type);
+ int ret = Helios_GNSS_Configuration_Get((uint8_t)config_type);
+ return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(qpy_module_gnss_config_get_obj, qpy_module_gnss_config_get);
+#endif
+
STATIC const mp_rom_map_elem_t gnss_module_globals_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_quecgnss) },
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&mp_get_gnss_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_gnss_nmea_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_get_state), MP_ROM_PTR(&mp_get_gnss_state_obj) },
{ MP_ROM_QSTR(MP_QSTR_gnssEnable), MP_ROM_PTR(&mp_gnss_switch_obj) },
+ { MP_ROM_QSTR(MP_QSTR_get_gsv), MP_ROM_PTR(&mp_get_gnss_gsv_obj) },
+ { MP_ROM_QSTR(MP_QSTR_get_gga), MP_ROM_PTR(&mp_get_gnss_gga_obj) },
+ { MP_ROM_QSTR(MP_QSTR_get_rmc), MP_ROM_PTR(&mp_get_gnss_rmc_obj) },
+ { MP_ROM_QSTR(MP_QSTR_get_vtg), MP_ROM_PTR(&mp_get_gnss_vtg_obj) },
{ MP_ROM_QSTR(MP_QSTR_setCallback), MP_ROM_PTR(&mp_gnss_register_usr_callback_obj) },
#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05)
{ MP_ROM_QSTR(MP_QSTR_enableGST), MP_ROM_PTR(&mp_gnss_nmea_set_gst_obj) },
//{ MP_ROM_QSTR(MP_QSTR_setSysType), MP_ROM_PTR(&mp_gnss_nmea_sys_type_cfg_obj) },
//{ MP_ROM_QSTR(MP_QSTR_getSysType), MP_ROM_PTR(&mp_gnss_nmea_sys_type_get_obj) },
#endif
-#if defined(PLAT_Unisoc_8850)
+#if defined(PLAT_Unisoc_8850) || defined(PLAT_Qualcomm)
{ MP_ROM_QSTR(MP_QSTR_setPriority), MP_ROM_PTR(&mp_gnss_set_priority_obj) },
{ MP_ROM_QSTR(MP_QSTR_getPriority), MP_ROM_PTR(&mp_gnss_get_priority_obj) },
#endif
+#if defined(PLAT_ASR_1606)
+ { MP_ROM_QSTR(MP_QSTR_configSet), MP_ROM_PTR(&qpy_module_gnss_config_set_obj) },
+ { MP_ROM_QSTR(MP_QSTR_configGet), MP_ROM_PTR(&qpy_module_gnss_config_get_obj) },
+#endif
};
STATIC MP_DEFINE_CONST_DICT(gnss_module_globals, gnss_module_globals_table);
from machine import I2C
from Gsensor import SC7A20
import pm
+import ure
try :
from Hsensor import GH3018
except Exception as e:
self.location_queue = Queue(100)
self.lpm_fd = None
self.start_agps = 0
- #quecgnss.init()
- #quecgnss.gnssEnable(0)
+ quecgnss.init()
+ quecgnss.gnssEnable(0)
@staticmethod
def get_date():
return "{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])
return "{:02d}:{:02d}:{:02d}".format(*utime.localtime()[3:6])
def post_processor_after_instantiation(self):
- _gps_cfg = {
- "UARTn": UART.UART1,
- "buadrate": 115200,
- "databits": 8,
- "parity": 0,
- "stopbits": 1,
- "flowctl": 0,
- "PowerPin": Pin.GPIO2,
- "StandbyPin": Pin.GPIO3,
- "BackupPin": None,
- "gps_mode": 0x01,
- }
- self.gps = GPS(**_gps_cfg)
- self.gps.power_switch(0)#关闭GPS
+ # _gps_cfg = {
+ # "UARTn": UART.UART1,
+ # "buadrate": 115200,
+ # "databits": 8,
+ # "parity": 0,
+ # "stopbits": 1,
+ # "flowctl": 0,
+ # "PowerPin": Pin.GPIO2,
+ # "StandbyPin": Pin.GPIO3,
+ # "BackupPin": None,
+ # "gps_mode": 0x01,
+ # }
+ # self.gps = GPS(**_gps_cfg)
+ # self.gps.power_switch(0)#关闭GPS
EventMesh.subscribe(constants.EVENT.GPSOPEN, self.gps_open)
EventMesh.subscribe(constants.EVENT.GPSCLOSE, self.gps_close)
EventMesh.subscribe(constants.EVENT.START_LOCATION, self.start_location)
return
self.location_thread_id = _thread.start_new_thread(self.location_thread, ())
self.location_flag = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
#self.gps_open(event, msg)
self.location_flag = 1
#self.gps_open(event, msg)
self.location_type = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
def close_location(self, event, msg):
self.location_flag = 0
self.location_type = 0
+ self.timer_read_GPS_info.stop()
def WIFI_scan_open(self, event, msg):
#print("WIFI_scan_open")
-
-
if wifiScan.getState() == False :
self.wifi_data = []
wifiScan.control(1)
def gps_open(self, event, msg):
#print("publish:gps_open")
#quecgnss.init()
- quecgnss.gnssEnable(1)
- self.gps.__gps_nmea_data_clean()
+ quecgnss.gnssEnable(2)
+ #self.gps.__gps_nmea_data_clean()
def gps_close(self, event, msg):
quecgnss.gnssEnable(0)
def location_timer(self, *args, **kwargs):
else :
break
-
+ def GxGGA_latitude(self, gga_data):
+ """Parse latitude from GGA"""
+ if gga_data:
+ latitude_re = ure.search(r",[0-9]+\.[0-9]+,[NS],", gga_data)
+ if latitude_re:
+ latitude = latitude_re.group(0)[1:-3]
+ return str(float(latitude[:2]) + float(latitude[2:]) / 60)
+ return ""
+ def GxGGA_longitude(self, gga_data):
+ """Parse longitude from GGA"""
+ if gga_data:
+ longitude_re = ure.search(r",[0-9]+\.[0-9]+,[EW],", gga_data)
+ if longitude_re:
+ longitude = longitude_re.group(0)[1:-3]
+ return str(float(longitude[:3]) + float(longitude[3:]) / 60)
+ return ""
+
+ def GxGGA_altitude(self, gga_data):
+ """Parse altitude from GGA"""
+ if gga_data:
+ altitude_re = ure.search(r",-*[0-9]+\.[0-9]+,M,", gga_data)
+ if altitude_re:
+ return altitude_re.group(0)[1:-3]
+ return ""
def location_thread(self):
self.wifi_data = []
print("location_thread:1")
EventMesh.publish(constants.EVENT.GPSOPEN)
print("location_thread:2")
- self.timer_read_GPS_info.start(1000, 1, self.location_timer)
-
+ #self.timer_read_GPS_info.start(1000, 1, self.location_timer)
+ print("location_thread:3")
#utime.sleep_ms(1000)
self.location_timer_count = 0
#quecgnss.read(4096)#去掉第一次错误数据
# if self.location_check_data_timer_count >= 3:
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
- if self.location_check_data_timer_count >= 3 :#3秒查一次基站数据和wifi数据
+ if self.location_check_data_timer_count >= 1 :#3秒查一次基站数据和wifi数据
self.location_check_data_timer_count = 0
#print(self.location_timer_count)
GSV_dict= {}
#检查GNSS数据
if ( self.gps_data == {} or self.location_type == 1) and quecgnss.get_state() == 2:
-
- self.gps.__gps_nmea_data_clean()
- #gnss_r_data = [0,1]
- gnss_r_data = quecgnss.read(4096)
- #EventMesh.txt_log("gps Datalen:{}".format(gnss_r_data[0]))
- print("location gnss_r_data:len{}\n{}".format(gnss_r_data[0],gnss_r_data[1].decode()))
- #print("gnss_r_data len:{}".format(gnss_r_data[0]))
- if gnss_r_data[0] > 0 : #有数据
- tmp_ok_count = 0
- tmp_very_ok_count = 0
- gsv_data = gnss_r_data[1].split("GSV")
-
- if len(gsv_data) >= 2 :
- gsv_data = gsv_data[1:]
- for i in range(len(gsv_data)) :
- gsv_data[i] = gsv_data[i].split("\r\n")[0]
- gsv_tmp = gsv_data[i].split(",")
- if len(gsv_tmp) < 7 :
- break
-
- gsv_tmp = gsv_tmp[4:]
- #print("gsv_tmp:{}".format(gsv_tmp))
- for i in range(len(gsv_tmp)) :
- if i % 4 == 0:
- GSV_dict[gsv_tmp[i]] = gsv_tmp[i+3]
- try:
- #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
- if gsv_tmp[i+3] != "" :
- if int(gsv_tmp[i+3])>=20:
- tmp_ok_count +=1
- if int(gsv_tmp[i+3])>=30:
- tmp_very_ok_count +=1
-
- except Exception as e:
- usys.print_exception(e)
- #print("GSV_dict:{}:[{}]".format(gsv_tmp[i],gsv_tmp[i+3]))
- if len(gsv_tmp)-i < 4:
- break
-
- if(tmp_ok_count > self.GSV_sig_ok_count ):
- self.GSV_sig_ok_count = tmp_ok_count
- if(tmp_very_ok_count > self.GSV_sig_very_ok_count ):
- self.GSV_sig_very_ok_count = tmp_very_ok_count
-
- # if len(match_gga_data) > 8:
- # #print(match_gga_data)
- # if(match_gga_data[7] ):
- # gga_count_tmp = int(match_gga_data[7]) #可用卫星
- # if(gga_count_tmp > self.GGA_count):
- # self.GGA_count = gga_count_tmp
- print("GGA_count:{} GSV_sig_ok_coun:{} ".format(self.GGA_count,self.GSV_sig_ok_count))
+
+ pass
+ tmp_ok_count = 0
+ tmp_very_ok_count = 0
+ gsv_data = quecgnss.get_gsv()
+ rmc_data = quecgnss.get_rmc()
+ gga_data = quecgnss.get_gga()
+ vtg_data = quecgnss.get_vtg()
+ print("gsv:{}".format(quecgnss.get_gsv()))
+ print("gga:{}".format(quecgnss.get_gga()))
+ print("rmc:{}".format(quecgnss.get_rmc()))
+ print("vtg:{}".format(quecgnss.get_vtg()))
+ for i in range(len(gsv_data)) :
- match_rmc_data = self.match.GxRMC(gnss_r_data[1]).split(",")
-
- #print("match_rmc_data:\n{}".format(match_rmc_data))
- if len (match_rmc_data)>3: #有rmc数据
- if match_rmc_data[2] == 'A':
-
- if self.gps.__check_gps_valid(gnss_r_data[1].decode()): #数据齐全 :
-
- #print("hhhhhh:{}\n\n".format(self.gps.__gsv_data))
- match_vtg_data = self.gps.__vtg_data.split(",")#self.match.GxVTG(gnss_r_data[1]).split(",")
- match_gga_data = self.gps.__gga_data.split(",")#self.match.GxGGA(gnss_r_data[1]).split(",")
- #match_gga_data = self.match.GxGGA(gnss_r_data[1]).split(",")
-
- EventMesh.txt_log("GGA:{}".format(match_gga_data))
- # EventMesh.txt_log("VTG:{}".format(match_vtg_data))
- # EventMesh.txt_log("RMC:{}".format(match_rmc_data))
- #EventMesh.txt_log("timer:{} ok:{} very_ok:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GSV_sig_very_ok_count))
- print("LOCATION_ok :time:{}!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n".format(self.location_timer_count))
+ if i % 2 == 0:
+ if i+1 >= len(gsv_data) :
+ print("gsv_data num error!!")
+ break
+ GSV_dict[gsv_data[i]] = gsv_data[i+1]
+ #print("type:gsv_data{}".format(type(gsv_data[i+1])))
+ try:
+ #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
+ if gsv_data[i+1] :
+ if (gsv_data[i+1])>=20:
+ tmp_ok_count +=1
+ if (gsv_data[i+1])>=30:
+ tmp_very_ok_count +=1
+
+ except Exception as e:
+ usys.print_exception(e)
+
+ if(tmp_ok_count > self.GSV_sig_ok_count ):
+ self.GSV_sig_ok_count = tmp_ok_count
+ if(tmp_very_ok_count > self.GSV_sig_very_ok_count ):
+ self.GSV_sig_very_ok_count = tmp_very_ok_count
+ match_rmc_data = rmc_data.split(",")
+ if len (match_rmc_data)>3: #有rmc数据
+ if match_rmc_data[2] == 'A':
+ match_gga_data = gga_data.split(",")
+ if len(match_gga_data) >4: #数据全
+ match_vtg_data = vtg_data.split(",")
gps_date = "%s,%s"%(match_rmc_data[9],match_rmc_data[1][:6])#日期
- gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
+ #gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
latitude = "0,N" #纬度
- latitude_tmp = str(gps_data_tmp[1]).split(".")
+ latitude_tmp = str(self.GxGGA_latitude(gga_data)).split(".")
if len(latitude_tmp) >= 2 and len(latitude_tmp[1])>=5:
latitude = "%s.%s"%(latitude_tmp[0],latitude_tmp[1][:6])
latitude = "%s,%s"%(latitude,match_rmc_data[4] )
longitude = "0,E"#经度
- longitude_tmp = str(gps_data_tmp[0]).split(".")
+ longitude_tmp = str(self.GxGGA_longitude(gga_data)).split(".")
if len(longitude_tmp) >= 2 and len(longitude_tmp[1])>=5:
longitude = "%s.%s"%(longitude_tmp[0],longitude_tmp[1][:6])
longitude = "%s,%s"%(longitude,match_rmc_data[6] ) #match_rmc_data[6] + str(gnss_r_data[1])
high = "0"#高度
- high = str(gps_data_tmp[2])
+ high = str(self.GxGGA_altitude(gga_data))
number = "0"#可用卫星
precision = "5.8"#精度
if len(match_gga_data)>5 :
"date": gps_date,
"precision": precision
}
- else :
- EventMesh.txt_log("gps数据不全")
- else :
- EventMesh.txt_log("gps 无数据")
-
+# ***********************************************************************************
#检查wifi数据
if self.location_type == 1: #测试模式
self.location_timer_count = 0
- if len(gnss_r_data) >= 1:
- if gnss_r_data[0] > 0:
- EventMesh.publish("PUSH_LOCATION_DATA", [[self.gps_data,GSV_dict],self.wifi_data,self.cell_data])
+
+ EventMesh.publish("PUSH_LOCATION_DATA", [[self.gps_data,GSV_dict],self.wifi_data,self.cell_data])
if self.gps_data != {} : #发送数据
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
self.location_queue.put(constants.PROTOCOL.UD_SEND)
#self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
utime.sleep_ms(500)
- self.timer_read_GPS_info.stop()
- self.gps.power_switch(0)
+
+ #self.timer_read_GPS_info.stop()
+ #self.gps.power_switch(0)
wifiScan.control(0)
+ EventMesh.publish(constants.EVENT.GPSCLOSE)
# if EventMesh.publish("get_lcd_state" ) == 0:#休眠的时候，恢复休眠
# pm.autosleep(1)
# pm.sclkEx_set(1, 1, 5)
projects / mirrors / ASR1603_G5.git / commitdiff