ublox-gps-hal

1:ubx_moduleif.cpp

hw_module_tHAL_MODULE_INFO_SYM====>s_hwModuleMethods====>hwModuleOPen====>CGpsIf::getIf(CGpsIf::s_interface)

=======================================================================

const GpsInterface CGpsIf::s_interface= {

   IF_ANDROID23( size:         sizeof(GpsInterface),)

   init:                          CGpsIf::init,

   start:                         CGpsIf::start,

   stop:                          CGpsIf::stop,

#if (PLATFORM_SDK_VERSION <= 8)

    set_fix_frequency:       CGpsIf::setFixFrequency,

#endif

   cleanup:                       CGpsIf::cleanup,

   inject_time:                   CGpsIf::injectTime,

   IF_ANDROID23( inject_location: CGpsIf::injectLocation,)

   delete_aiding_data:         CGpsIf::deleteAidingData,

   set_position_mode:          CGpsIf::setPositionMode,

   get_extension:          CGpsIf::getExtension,

};

 

 

int CGpsIf::init(GpsCallbacks*callbacks)====>

s_mainControlThread =s_myIf.m_callbacks.create_thread_cb("gps thread", ubx_thread,&s_controlThreadInfo);====>

gps_thread.cpp====>void ubx_thread(void*pThreadData)

 

=========================================================================

1:ubx_moduleif.cpp

 

由bug信息

//CGpsIf::setPositionMode(1732655112): mode=0(GPS_POSITION_MODE_STANDALONE)recurrence=0(GPS_POSITION_RECURRENCE_PERIODIC) min_interval=1000preferred_accuracy=0 preferred_time=0

 

 

intCGpsIf::setPositionMode(GpsPositionMode mode, int fix_frequency)

{

    LOGD("CGpsIf::%s(%u): mode=%i(%s) fix_frequency=%i",

           __FUNCTION__,

           (unsignedint) pthread_self(),

           mode, _LOOKUPSTR(mode, GpsPositionMode),

            fix_frequency);

    intmin_interval = fix_frequency;

#else // (PLATFORM_SDK_VERSION > 8/* >2.2 */)

intCGpsIf::setPositionMode(GpsPositionMode mode, GpsPositionRecurrence recurrence,

           uint32_tmin_interval, uint32_t preferred_accuracy, uint32_t preferred_time)

{

    LOGD("CGpsIf::%s(%u): mode=%i(%s) recurrence=%i(%s) min_interval=%u preferred_accuracy=%upreferred_time=%u",

           __FUNCTION__,

           (unsignedint) pthread_self(),

            mode, _LOOKUPSTR(mode, GpsPositionMode),

            recurrence, _LOOKUPSTR(recurrence,GpsPositionRecurrence),

            min_interval,

            preferred_accuracy,

            preferred_time);

 

#endif

    if(s_myIf.m_ready)

    {

       s_myIf.m_mode= mode;

      

       min_interval= min_interval ? min_interval : 1000;

       LOGD("++++samdebug CGpsIf::min_interval:%d",min_interval);

 

 

 

 

       gps_state_set_interval(min_interval);

    }

    else

    {

       LOGE("CGpsIf::%s: Not initialised", __FUNCTION__);

    }

   

    return0;

}

 

 

2：gps_thread.cpp

 

void gps_state_set_interval(uint32_tmin_interval)

{

   int64_t nextReportEpochMs = 0;    // default - no driver intervention

    inttimeInterval = 0;

   

   if (min_interval < MIN_INTERVAL)

   {

       // Below minimun, set to receiver minimum, with no driver intervention

       min_interval = MIN_INTERVAL;

   }

   else if ((min_interval >= MIN_INTERVAL) && (min_interval<= 2000))

   {

       // Receiver can cope with these values.

   }

   else

    {

       // Too fast for receiver, so driver will intervene to extend

       LOGW("%s : Interval (%i) too big - Driver will intervene",__FUNCTION__, min_interval);

       timeInterval = (int) min_interval;

       nextReportEpochMs = getMonotonicMsCounter();

       min_interval = 1000;

   }

   

    CMyDatabase*pDatabase = CMyDatabase::getInstance();

    pDatabase->setEpochInterval(timeInterval,nextReportEpochMs);

   

    CUbxGpsState*pUbxGps = CUbxGpsState::getInstance();

   pUbxGps->lock();

    pUbxGps->putRate((int) min_interval);

    pUbxGps->writeUbxCfgRate();

    pUbxGps->unlock();

}