le_gnss_interface.h

    1 
    2 
    3 /*
    4  * ====================== WARNING ======================
    5  *
    6  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
    7  * DO NOT MODIFY IN ANY WAY.
    8  *
    9  * ====================== WARNING ======================
   10  */
   11 
   12 /**
   13  * @page c_gnss GNSS
   14  *
   15  * @ref le_gnss_interface.h "API Reference" <br>
   16  * @ref platformConstraintsGnss <br>
   17  * @ref howToGNSS "How To Use GNSS" <br>
   18  * @ref toolsTarget_gnss "GNSS target tool" <br>
   19  *
   20  * <HR>
   21  *
   22  * This API provides access to the GNSS device.
   23  *
   24  * GNSS or Global Navigation Satellite System is a satellite navigation system with global coverage.
   25  *
   26  * This API provides function to configure the GNSS device and retrieve position information.
   27  *
   28  * @section le_gnss_binding IPC interfaces binding
   29  *
   30  * All the functions of this API are provided by the @b positioningService application service.
   31  *
   32  * Here's a code sample binding to Positioning services:
   33  * @verbatim
   34    bindings:
   35    {
   36       clientExe.clientComponent.le_gnss -> positioningService.le_gnss
   37    }
   38    @endverbatim
   39  *
   40  * @section le_gnss_ControlApi GNSS Control API
   41  *
   42  * @subsection le_gnss_EnableDisable Enable/Disable GNSS device
   43  *
   44  * The application can enable/disable the GNSS device with the le_gnss_Enable()
   45  * / le_gnss_Disable() functions.
   46  * By default the GNSS device is enabled for the positioningService application service.
   47  * Also see @ref howToGNSS.
   48  *
   49  * A sample code can be seen in the following page:
   50  * - @subpage c_gnssSampleCodeEnableDisable
   51  *
   52  * @subsection le_gnss_StartStop Start/Stop GNSS device
   53  *
   54  * The application can start/stop the GNSS device with the le_gnss_Start() / le_gnss_Stop()
   55  * functions.
   56  * The default "HOT" start condition is applied and all assistance data are used.
   57  * Also see @ref howToGNSS.
   58  *
   59  * A sample code can be seen in the following page:
   60  * - @subpage c_gnssSampleCodeStartStop
   61  *
   62  * @subsubsection le_gnss_StartingMode Starting mode
   63  *
   64  * Starting modes are used only for test purposes and allow start performance measurement.
   65  * @note For more information about start performances, please refer to your specific
   66  * platform documentation.
   67  *
   68  * @subsubsection SettingConfiguration Setting configuration
   69  *
   70  * @warning The GNSS setting configuration depends on the platform. Please refer to
   71  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
   72  *
   73  * @subsubsection le_gnss_Data GNSS data
   74  * The following table describes the <b>minimum</b> required data for those starting modes:
   75  *
   76  * | GNSS Data / Starting mode  | HOT  | WARM  | COLD  | FACTORY |
   77  *| -----------------------| -----| ------| ----- | ------- |
   78  *| Broadcasted Ephemeris  | Used |  |  |  |
   79  *| Extended Ephemeris     | Used(1) | Used(2) | Used(2) | Removed (3) |
   80  *| Approximate Time and Position  | Used | Used |  |  |
   81  *| Almanac   | Used | Used | Used | Used (Factory) |
   82  *
   83  * For example, a requested HOT start without valid broadcasted ephemeris will be treated
   84  * as a WARM start.
   85  *
   86  * @note (1) Extended Ephemeris can be used if Broadcasted Ephemeris are not valid.
   87  * The Extended Ephemeris could be loaded using the le_gnss_LoadExtendedEphemerisFile()
   88  * function.
   89  * @note (2) Extended Ephemeris is used if the Extended Ephemeris file is loaded and valid.
   90  * @note (3) Extended Ephemeris are removed when a FACTORY start is requested.
   91  * The Extended Ephemeris could be loaded again using the le_gnss_LoadExtendedEphemerisFile()
   92  * function.
   93  *
   94  * @subsubsection le_gnss_TTFF Time To First Fix (TTFF)
   95  * The le_gnss_GetTtff() function provides the TTFF (first between 2-Dimensional or 3-Dimensional
   96  * position fix) of the last position fix.
   97  * The GNSS fix position is calculated by the GNSS engine. Its state can be retrieved by
   98  * le_gnss_GetPositionState() function. The GNSS fix position states are given by le_gnss_FixState_t
   99  * enum.
  100  * @note The "estimated" fix is obtained when less than 3 Satellites Vehicle (SV) are used to
  101  * establish the fix. It includes the case when no SVs are used.
  102  *
  103  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
  104  *
  105  * A sample code can be seen in the following page:
  106  * - @subpage c_gnssSampleCodeReStart
  107  *
  108  * @subsubsection le_gnss_InjectUtcTime Inject UTC time
  109  * The le_gnss_InjectUtcTime() function injects the UTC time into the location engine. Providing an
  110  * accurate UTC time reduces the time to find the first fix.
  111  * @note It is mandatory to enable the 'Extended Ephemeris' file injection into the GNSS device with
  112  * le_gnss_EnableExtendedEphemerisFile() before injecting time with le_gnss_InjectUtcTime API.
  113  * @warning Your GNSS device may require a restart to take into account the enabling of the
  114  * 'Extended Ephemeris' file injection.
  115  * Please refer to your platform documentation @ref platformConstraintsGnss_SettingConfiguration for
  116  * further details.
  117  *
  118  * @subsubsection le_gnss_ForceHotRestart Force HOT restart
  119  * The le_gnss_ForceHotRestart() function performs a "HOT" restart of the GNSS device. The current
  120  * GNSS session is stopped, then started using the available @ref le_gnss_Data.
  121  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
  122  *
  123  * @subsubsection le_gnss_ForceWarmRestart Force WARM restart
  124  * The le_gnss_ForceWarmRestart() function performs a "WARM" restart of the GNSS device. The current
  125  * GNSS session is stopped, then started using the available @ref le_gnss_Data.
  126  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
  127  * @Note This API has a platform dependent feature. Please refer to
  128  * @ref platformConstraintsGnss_WarmRestart for further details.
  129  *
  130  * @subsubsection le_gnss_ForceColdRestart Force COLD restart
  131  * The le_gnss_ForceColdRestart() function performs a "COLD" restart of the GNSS device. The current
  132  * GNSS session is stopped, then started using the available @ref le_gnss_Data.
  133  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
  134  *
  135  * @subsubsection le_gnss_ForceFactoryRestart Force FACTORY restart
  136  * The le_gnss_ForceFactoryRestart() function performs a "FACTORY" restart of the GNSS device.
  137  * The current GNSS session is stopped, then started using the available @ref le_gnss_Data.
  138  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
  139  *
  140  * @subsection le_gnss_AcquisitionRate Acquisition rate
  141  * The GNSS position is computed and delivered each acquisition rate. The acquisition rate defines
  142  * the time interval that must elapse between two final GPS positions calculation and reports.
  143  * Its default value is 1 second.
  144  * The application can configure/retreive the GNSS device acquisition rate with the
  145  * le_gnss_SetAcquisitionRate() / le_gnss_GetAcquisitionRate() functions.
  146  *
  147  * Please refer to @ref le_gnss_APIcallsRequirements.
  148  *
  149  * A sample code can be seen in the following page:
  150  * - @subpage c_gnssSampleCodeAcquisitionRate
  151  *
  152  * @subsection le_gnss_SetGetConstellation GNSS constellation selection
  153  *
  154  * The le_gnss_SetConstellation() function selects the GNSS constellation(s) used in solution.
  155  * If all GNSS constellations are disabled, the GNSS engine is disabled.
  156  *
  157  * @warning Your GNSS device may require a restart to take into account this change.
  158  * Please refer to your platform documentation @ref platformConstraintsGnss_SettingConfiguration for
  159  * further details.
  160  *
  161  * Combinations of constellation for GPS, GLONASS, BDS, GALILEO and QZSS satellites are currently
  162  * supported. Constellation for SBAS satellites is not supported.
  163  *
  164  * @warning Some constellation types are unsupported depending on the plateform. Please refer to
  165  * @ref platformConstraintsGnss_ConstellationType section for full details.
  166  *
  167  * All supported GNSS constellations are enabled by default.
  168  * The le_gnss_GetConstellation() function gets the GNSS constellation(s) enabled to be used
  169  * in solution.
  170  *
  171  * le_gnss_SetConstellationArea sets the area for a GNSS constellation. le_gnss_GetConstellationArea
  172  * gets the area for a GNSS constellation.
  173  *
  174  * A sample code can be seen in the following page:
  175  * - @subpage c_gnssSampleCodeConstellation
  176  *
  177  * @subsection le_gnss_SetGetMinElevation GNSS minimum elevation selection
  178  *
  179  * The le_gnss_SetMinElevation() function sets the GNSS minimum elevation.
  180  * Satellites with elevation lower than the minimum elevation will be ignored.
  181  *
  182  * The le_gnss_GetMinElevation() function gets the GNSS minimum elevation.
  183  *
  184  * A sample code can be seen in the following page:
  185  * - @subpage c_gnssSampleCodeMinElevation
  186  *
  187  * @subsection le_gnss_NmeaSentences NMEA sentences selection
  188  *
  189  * The le_gnss_SetNmeaSentences() function selects the enabled NMEA sentences in the
  190  * @ref le_gnss_NMEA with a bit mask. The supported values are listed in @ref le_gnss_NmeaBitMask_t.
  191  *
  192  * @note This function may be subject to limitations depending on the platform. Please refer to the
  193  * @ref platformConstraintsGnss page.
  194  *
  195  * @warning Your GNSS device may require a restart to take into account this change.
  196  * Please refer to your platform documentation @ref platformConstraintsGnss_SettingConfiguration for
  197  * further details.
  198  *
  199  * @warning Some NMEA sentences are unsupported depending on the plateform. Please refer to
  200  * @ref platformConstraintsGnss_nmeaMask section for full details.
  201  *
  202  * @note All supported NMEA sentences are enabled by default.
  203  *
  204  * The le_gnss_GetNmeaSentences() function gets the bit mask of the enabled NMEA sentences in the
  205  * @ref le_gnss_NMEA.
  206  *
  207  * Please refer to @ref le_gnss_APIcallsRequirements.
  208  *
  209  * A sample code can be seen in the following page:
  210  * - @subpage c_gnssSampleCodeNmeaSentences
  211  *
  212  * @subsection le_gnss_APIcallsRequirements API calls Requirements
  213  * The following table shows the pre-requisites when using the GNSS service API function set.
  214  * ''LE_OK or error code'' means the function is authorized in the corresponding state, the request
  215  * is performed and the result is returned; otherwise the returned error is indicated for each state
  216  *.
  217  * | Function / GNSS state  | UNINITIALIZED  | READY  | ACTIVE  | DISABLED |
  218  *| ----------------------------- | --------------------------- | -----------------------------| --------------------------- | --------------------------- |
  219  *| le_gnss_Start() | LE_NOT_PERMITTED | LE_OK or error code | LE_DUPLICATE | LE_NOT_PERMITTED |
  220  *| le_gnss_Stop() | LE_NOT_PERMITTED | LE_DUPLICATE | LE_OK or error code | LE_NOT_PERMITTED |
  221  *| le_gnss_ForceHotRestart() | LE_NOT_PERMITTED | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED |
  222  *| le_gnss_ForceWarmRestart() | LE_NOT_PERMITTED | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED |
  223  *| le_gnss_ForceColdRestart() | LE_NOT_PERMITTED | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED |
  224  *| le_gnss_ForceFactoryRestart() | LE_NOT_PERMITTED | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED |
  225  *| le_gnss_Disable() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_DUPLICATE |
  226  *| le_gnss_Enable() | LE_NOT_PERMITTED | LE_DUPLICATE | LE_DUPLICATE | LE_OK or error code |
  227  *| le_gnss_SetConstellation() | LE_NOT_PERMITTED |  LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  228  *| le_gnss_GetConstellation() | LE_NOT_PERMITTED |  LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  229  *| le_gnss_SetConstellationArea() | LE_NOT_PERMITTED |  LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  230  *| le_gnss_GetConstellationArea() | LE_NOT_PERMITTED |  LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  231  *| le_gnss_GetTtff() | LE_NOT_PERMITTED |  LE_OK or error code | LE_OK or error code | LE_NOT_PERMITTED |
  232  *| le_gnss_SetAcquisitionRate() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  233  *| le_gnss_GetAcquisitionRate() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  234  *| le_gnss_SetNmeaSentences() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  235  *| le_gnss_GetNmeaSentences() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  236  *
  237  * Also see @ref howToGNSS.
  238  *
  239  * @section le_gnss_Information GNSS position information
  240  * @ref le_gnss_NMEA
  241  *
  242  * @ref le_gnss_GetInfo
  243  *
  244  * @subsection le_gnss_NMEA NMEA Flow
  245  * The National Marine Electronics Association (NMEA) standard defines an electrical interface
  246  * and data protocol for communications between marine instrumentation.
  247  *
  248  * The NMEA-0183, scope of this document, defines a set of frame prefixed by
  249  * $GP (concerning Global Positioning System),
  250  * $GL (concerning GLONASS)
  251  * and $GN (concerning combination of navigation systems).
  252  * For more details about NMEA standards, please refer to http://www.nmea.org/.
  253  *
  254  * That NMEA frames flow can be retrieved from the "/dev/nmea" device folder, using for example
  255  * the shell command $<EM> cat /dev/nmea | grep '$G'</EM>
  256  *
  257  * @subsection le_gnss_GetInfo Get position information
  258  * The position information is referenced to a position sample object.
  259  *
  260  * An application can register a handler to be notified of the
  261  * updated position each @ref le_gnss_AcquisitionRate, returning a position sample object.
  262  *
  263  * The GNSS information commonly used such as
  264  * device state, position, time and date, satellites information and accuracy
  265  * can be queried using the following functions:
  266  * - le_gnss_GetState()
  267  * - le_gnss_GetPositionState()
  268  * - le_gnss_GetLocation()
  269  * - le_gnss_GetAltitude()
  270  * - le_gnss_GetDate()
  271  * - le_gnss_GetTime()
  272  * - le_gnss_GetGpsTime()
  273  * - le_gnss_GetGpsLeapSeconds()
  274  * - le_gnss_GetEpochTime()
  275  * - le_gnss_GetTimeAccuracy()
  276  * - le_gnss_GetHorizontalSpeed()
  277  * - le_gnss_GetVerticalSpeed()
  278  * - le_gnss_GetDirection()
  279  * - le_gnss_GetSatellitesInfo()
  280  * - le_gnss_GetSbasConstellationCategory()
  281  * - le_gnss_GetSatellitesStatus()
  282  * - le_gnss_GetDop()
  283  * - le_gnss_GetDilutionOfPrecision()
  284  * - le_gnss_GetAltitudeOnWgs84()
  285  * - le_gnss_GetMagneticDeviation()
  286  *
  287  * le_gnss_SetDataResolution() function can be called to configure the resolution of position data
  288  * type per client session. Currently, three data types are supported:
  289  * - Vertical position accuracy provided by le_gnss_GetAltitude().
  290  * - Vertical speed accuracy provided by le_gnss_GetVerticalSpeed().
  291  * - Horizontal speed accuracy provided by le_gnss_GetHorizontalSpeed().
  292  * Each data type can be set with a resolution from 0 to 3 decimal place.
  293  *
  294  * For example, to get the vertical position accuracy with a resolution of 2 decimal places,
  295  * le_gnss_SetDataResolution() function is called with vertical position accuracy set as data type
  296  * and 2 decimal place is set as resolution, then le_gnss_GetAltitude() function is called.
  297  *
  298  * @note If le_gnss_SetDataResolution() function is not called, the position data types are received
  299  * in their default accuracies.
  300  *
  301  * le_gnss_ConvertDataCoordinateSystem() function can be called to convert a location data value
  302  * from a coordinate system to another. Currently it is possible to convert the following data
  303  * types:
  304  * - Latitude
  305  * - Longitude
  306  * - Altitude
  307  *
  308  * System coordinates source and destination are currently:
  309  * - Coordinate system WGS84
  310  * - Coordinate system PZ90
  311  *
  312  * @note Only conversion from WGS84 coordinate system to PZ90 coordinate system is currently
  313  * supported.
  314  * @note The altitude in coordinate system WGS84 is obtained by le_gnss_GetAltitudeOnWgs84()
  315  * function.
  316  *
  317  * A sample code using le_gnss_ConvertDataCoordinate() function can be seen in the following page:
  318  * - @subpage c_gnssSampleCodePosition
  319  *
  320  * le_gnss_GetDilutionOfPrecision() gets the DOP parameters (Dilution Of Precision) with a
  321  * resolution of 3 decimal places by default. This resolution can be modified by calling the
  322  * @c le_gnss_SetDopResolution() function first.
  323  *
  324  * As @c le_gnss_SetDopResolution() sets the resolution per client session,
  325  * @c le_gnss_SetDopResolution() and @c le_gnss_GetDilutionOfPrecision() functions should be called
  326  * in the same thread or client session.
  327  *
  328  * A sample code can be seen in the following page:
  329  * - @subpage c_gnssSampleCodePosition
  330  *
  331  * The handler can be managed using le_gnss_AddPositionHandler()
  332  * and le_gnss_RemovePositionHandler().
  333  * When a position is computed, the handler is called.
  334  *
  335  * The application has to release each position sample object received by the handler,
  336  * using the le_gnss_ReleaseSampleRef().
  337  *
  338  * A sample code can be seen in the following page:
  339  * - @subpage c_gnssSampleCodePosition
  340  *
  341  * @section le_gnss_Assisted_GNSS Assisted GNSS
  342  *
  343  * @ref le_gnss_Assisted_GNSS_EE
  344  * @ref le_gnss_Assisted_GNSS_UP
  345  *
  346  * @subsection le_gnss_Assisted_GNSS_EE Server based Extended Ephemeris
  347  *
  348  * @todo Add detailed documentation.
  349  *
  350  * With le_gnss_LoadExtendedEphemerisFile() , you can load an 'Extended Ephemeris' file into
  351  * the GNSS device from the filesystem.
  352  * You have to download the file before loading it.
  353  * @warning Ensure to check that the downloaded file is supported for your specific platform.
  354  *
  355  * With le_gnss_GetExtendedEphemerisValidity(), you will to get the validity of the last injected
  356  * Extended Ephemeris.
  357  *
  358  * You can enable/disable the use of the 'Extended Ephemeris' file into the GNSS device with
  359  * le_gnss_EnableExtendedEphemerisFile() / le_gnss_DisableExtendedEphemerisFile() functions.
  360  * @warning Ensure to check configuration capabilities for your specific platform.
  361  * A reboot must be required if your platform doesn't allow run-time configuration.
  362  *
  363  * A sample code can be seen in the following page:
  364  * - @subpage c_gnssSampleCodeXtra
  365  *
  366  * @subsection le_gnss_Assisted_GNSS_UP 3GPP User Plane (OMA SUPL)
  367  *
  368  * That 3GPP User Plane A-GNSS (Assisted GNSS) protocol is defined by two different standardization
  369  * bodies, 3GPP and Open Mobile Alliance (OMA). For more information, please refer to the standard.
  370  *
  371  * Both MS-Assisted and MS-Based position determination methods are supported in the User Plane.
  372  *
  373  * In MS-Assisted mode, the MS (Mobile Station) measures the signals from the GNSS satellites
  374  *, then returns the retrieved GNSS data to the SUPL (Secure User Plan Location) server, where the
  375  * position calculation is performed.
  376  *
  377  * In MS-Based mode, the MS gets the assistance data from the SUPL (Secure User Plan Location)
  378  * server. The MS measures the signals from the GNSS satellites and makes the position calculation.
  379  *
  380  * The data transport over User Plan is done using the TCP/IP protocol.
  381  *
  382  * The Assisted-GNSS mode can be configured thru the le_gnss_SetSuplAssistedMode() function.
  383  *
  384  * The supported modes are the following:
  385  * - Standalone mode: That 3GPP User Plane A-GNSS feature is deactivated.
  386  * - MS-Based mode
  387  * - MS-Assisted mode
  388  *
  389  * Moreover, the le_gnss_GetSuplAssistedMode() function reads the configured Assisted-GNSS mode.
  390  *
  391  * The SUPL server is configured using the le_gnss_SetSuplServerUrl() function. That function sets
  392  * the SUPL server URL and optionally the port number.
  393  *
  394  * The SUPL certificate to be used in A-GNSS sessions is injected through the
  395  * le_gnss_InjectSuplCertificate() function and deleted through the le_gnss_DeleteSuplCertificate()
  396  * function.
  397  * The SUPL certificate lenght given as parameter to le_gnss_InjectSuplCertificate() must be less
  398  * than LE_GNSS_SUPL_CERTIFICATE_MAX_LEN.
  399  *
  400  * <HR>
  401  *
  402  * Copyright (C) Sierra Wireless Inc.
  403  */
  404 /**
  405  * @page c_gnssSampleCode Sample code for GNSS device
  406  *
  407  * @include "apps/test/positioning/gnssTest/gnssTest/gnssTest.c"
  408  */
  409 /**
  410  * @page c_gnssSampleCodeEnableDisable Sample code for Enable/Disable GNSS device
  411  *
  412  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssEnable
  413  */
  414 /**
  415  * @page c_gnssSampleCodeStartStop Sample code for Start/Stop GNSS device
  416  *
  417  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  418  */
  419 /**
  420  * @page c_gnssSampleCodeReStart Sample code for restart GNSS device and get TTFF
  421  *
  422  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssReStart
  423  */
  424 /**
  425  * @page c_gnssSampleCodeAcquisitionRate Sample code for GNSS acquisition rate configuration
  426  *
  427  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  428  */
  429 /**
  430  * @page c_gnssSampleCodeConstellation Sample code for GNSS constellation selection
  431  *
  432  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  433  */
  434 /**
  435  * @page c_gnssSampleCodeMinElevation Sample code for GNSS minimum elevation
  436  *
  437  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  438  */
  439 /**
  440  * @page c_gnssSampleCodeNmeaSentences Sample code for GNSS NMEA sentences selection
  441  *
  442  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  443  */
  444 /**
  445  * @page c_gnssSampleCodePosition Sample code for GNSS position information
  446  *
  447  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssPosition
  448  */
  449 /**
  450  * @page c_gnssSampleCodeXtra Sample code for GNSS Server based Extended Ephemeris
  451  *
  452  * @include "apps/test/positioning/gnssXtraTest/gnssXtraTest/xtraTest.c"
  453  */
  454 /**
  455  * @file le_gnss_interface.h
  456  *
  457  * Legato @ref c_gnss include file.
  458  *
  459  * Copyright (C) Sierra Wireless Inc.
  460  */
  461 
  462 #ifndef LE_GNSS_INTERFACE_H_INCLUDE_GUARD
  463 #define LE_GNSS_INTERFACE_H_INCLUDE_GUARD
  464 
  465 
  466 #include "legato.h"
  467 
  468 
  469 //--------------------------------------------------------------------------------------------------
  470 /**
  471  * Type for handler called when a server disconnects.
  472  */
  473 //--------------------------------------------------------------------------------------------------
  474 typedef void (*le_gnss_DisconnectHandler_t)(void *);
  475 
  476 //--------------------------------------------------------------------------------------------------
  477 /**
  478  *
  479  * Connect the current client thread to the service providing this API. Block until the service is
  480  * available.
  481  *
  482  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  483  * called before any other functions in this API.  Normally, ConnectService is automatically called
  484  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  485  *
  486  * This function is created automatically.
  487  */
  488 //--------------------------------------------------------------------------------------------------
  489 void le_gnss_ConnectService
  490 (
  491     void
  492 );
  493 
  494 //--------------------------------------------------------------------------------------------------
  495 /**
  496  *
  497  * Try to connect the current client thread to the service providing this API. Return with an error
  498  * if the service is not available.
  499  *
  500  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  501  * called before any other functions in this API.  Normally, ConnectService is automatically called
  502  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  503  *
  504  * This function is created automatically.
  505  *
  506  * @return
  507  *  - LE_OK if the client connected successfully to the service.
  508  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  509  *    bound.
  510  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  511  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  512  */
  513 //--------------------------------------------------------------------------------------------------
  514 le_result_t le_gnss_TryConnectService
  515 (
  516     void
  517 );
  518 
  519 //--------------------------------------------------------------------------------------------------
  520 /**
  521  * Set handler called when server disconnection is detected.
  522  *
  523  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  524  * to continue without exiting, it should call longjmp() from inside the handler.
  525  */
  526 //--------------------------------------------------------------------------------------------------
  527 void le_gnss_SetServerDisconnectHandler
  528 (
  529     le_gnss_DisconnectHandler_t disconnectHandler,
  530     void *contextPtr
  531 );
  532 
  533 //--------------------------------------------------------------------------------------------------
  534 /**
  535  *
  536  * Disconnect the current client thread from the service providing this API.
  537  *
  538  * Normally, this function doesn't need to be called. After this function is called, there's no
  539  * longer a connection to the service, and the functions in this API can't be used. For details, see
  540  * @ref apiFilesC_client.
  541  *
  542  * This function is created automatically.
  543  */
  544 //--------------------------------------------------------------------------------------------------
  545 void le_gnss_DisconnectService
  546 (
  547     void
  548 );
  549 
  550 
  551 //--------------------------------------------------------------------------------------------------
  552 /**
  553  * Maximum length of the SUP Server URL string.
  554  */
  555 //--------------------------------------------------------------------------------------------------
  556 #define LE_GNSS_SUPL_SERVER_URL_MAX_LEN 256
  557 
  558 //--------------------------------------------------------------------------------------------------
  559 /**
  560  * Maximum length of the SUP Server URL string.
  561  * One extra byte is added for the null character.
  562  */
  563 //--------------------------------------------------------------------------------------------------
  564 #define LE_GNSS_SUPL_SERVER_URL_MAX_BYTES 257
  565 
  566 //--------------------------------------------------------------------------------------------------
  567 /**
  568  * Maximum SUPL certificate size.
  569  */
  570 //--------------------------------------------------------------------------------------------------
  571 #define LE_GNSS_SUPL_CERTIFICATE_MAX_LEN 2000
  572 
  573 //--------------------------------------------------------------------------------------------------
  574 /**
  575  * Maximum SUPL certificate string size.
  576  * One extra byte is added for the null character.
  577  */
  578 //--------------------------------------------------------------------------------------------------
  579 #define LE_GNSS_SUPL_CERTIFICATE_MAX_BYTES 2001
  580 
  581 //--------------------------------------------------------------------------------------------------
  582 /**
  583  * Define the maximum length of the Satellites Vehicle information list
  584  */
  585 //--------------------------------------------------------------------------------------------------
  586 #define LE_GNSS_SV_INFO_MAX_LEN 80
  587 
  588 //--------------------------------------------------------------------------------------------------
  589 /**
  590  * Define the maximal bit mask for enabled NMEA sentences
  591  *
  592  * @note This maximal value should be coherent with @ref le_gnss_NmeaBitMask_t
  593  */
  594 //--------------------------------------------------------------------------------------------------
  595 #define LE_GNSS_NMEA_SENTENCES_MAX 4194303
  596 
  597 //--------------------------------------------------------------------------------------------------
  598 /**
  599  * @deprecated LE_GNSS_NMEA_MASK_PQXFI is deprecated. LE_GNSS_NMEA_MASK_PTYPE is to be used instead.
  600  * Setting LE_GNSS_NMEA_MASK_PTYPE will also set LE_GNSS_NMEA_MASK_PQXFI.
  601  * LE_GNSS_NMEA_MASK_PTYPE supports all Proprietary type masks: PQXFI, PQGSA and PQGSV.
  602  */
  603 //--------------------------------------------------------------------------------------------------
  604 #define LE_GNSS_NMEA_MASK_PQXFI 16384
  605 
  606 //--------------------------------------------------------------------------------------------------
  607 /**
  608  * Define the maximal degree for the minimal elevation
  609  */
  610 //--------------------------------------------------------------------------------------------------
  611 #define LE_GNSS_MIN_ELEVATION_MAX_DEGREE 90
  612 
  613 //--------------------------------------------------------------------------------------------------
  614 /**
  615  * Satellite Vehicle (SV) ID to PRN offset definitions
  616  *
  617  * @note SV ID is given both in le_gnss_GetSatellitesInfo() API and NMEA flow. Its corresponding
  618  *       PRN code can be computed adding the following offset according to its constellation.
  619  */
  620 //--------------------------------------------------------------------------------------------------
  621 #define LE_GNSS_PRN_OFFSET_GPS 0
  622 
  623 //--------------------------------------------------------------------------------------------------
  624 /**
  625  */
  626 //--------------------------------------------------------------------------------------------------
  627 #define LE_GNSS_PRN_OFFSET_SBAS 87
  628 
  629 //--------------------------------------------------------------------------------------------------
  630 /**
  631  */
  632 //--------------------------------------------------------------------------------------------------
  633 #define LE_GNSS_PRN_OFFSET_GLONASS -64
  634 
  635 //--------------------------------------------------------------------------------------------------
  636 /**
  637  */
  638 //--------------------------------------------------------------------------------------------------
  639 #define LE_GNSS_PRN_OFFSET_GALILEO -300
  640 
  641 //--------------------------------------------------------------------------------------------------
  642 /**
  643  */
  644 //--------------------------------------------------------------------------------------------------
  645 #define LE_GNSS_PRN_OFFSET_BEIDOU -200
  646 
  647 //--------------------------------------------------------------------------------------------------
  648 /**
  649  */
  650 //--------------------------------------------------------------------------------------------------
  651 #define LE_GNSS_PRN_OFFSET_QZSS 0
  652 
  653 //--------------------------------------------------------------------------------------------------
  654 /**
  655  *  Reference type for dealing with GNSS position samples.
  656  */
  657 //--------------------------------------------------------------------------------------------------
  658 typedef struct le_gnss_Sample* le_gnss_SampleRef_t;
  659 
  660 
  661 //--------------------------------------------------------------------------------------------------
  662 /**
  663  * Enumeration for GNSS device state
  664  */
  665 //--------------------------------------------------------------------------------------------------
  666 typedef enum
  667 {
  668     LE_GNSS_STATE_UNINITIALIZED = 0,
  669         ///< The GNSS device is not initialized
  670     LE_GNSS_STATE_READY = 1,
  671         ///< The GNSS device is ready
  672     LE_GNSS_STATE_ACTIVE = 2,
  673         ///< The GNSS device is active
  674     LE_GNSS_STATE_DISABLED = 3,
  675         ///< The GNSS device is disabled
  676     LE_GNSS_STATE_MAX = 4
  677         ///< Do not use
  678 }
  679 le_gnss_State_t;
  680 
  681 
  682 //--------------------------------------------------------------------------------------------------
  683 /**
  684  *  GNSS fix position states.
  685  */
  686 //--------------------------------------------------------------------------------------------------
  687 typedef enum
  688 {
  689     LE_GNSS_STATE_FIX_NO_POS = 0,
  690         ///< The GNSS fix position is not fixed.
  691     LE_GNSS_STATE_FIX_2D = 1,
  692         ///< 2-Dimensional position fix.
  693     LE_GNSS_STATE_FIX_3D = 2,
  694         ///< 3-Dimensional position fix.
  695     LE_GNSS_STATE_FIX_ESTIMATED = 3
  696         ///< Estimated (i.e. forward predicted) position fix.
  697 }
  698 le_gnss_FixState_t;
  699 
  700 
  701 //--------------------------------------------------------------------------------------------------
  702 /**
  703  *  Resolutions values.
  704  */
  705 //--------------------------------------------------------------------------------------------------
  706 typedef enum
  707 {
  708     LE_GNSS_RES_ZERO_DECIMAL = 0,
  709         ///< Resolution of 0 decimal place.
  710     LE_GNSS_RES_ONE_DECIMAL = 1,
  711         ///< Resolution of 1 decimal place.
  712     LE_GNSS_RES_TWO_DECIMAL = 2,
  713         ///< Resolution of 2 decimal places.
  714     LE_GNSS_RES_THREE_DECIMAL = 3,
  715         ///< Resolution of 3 decimal places.
  716     LE_GNSS_RES_UNKNOWN = 4
  717         ///< Unknown resolution.
  718 }
  719 le_gnss_Resolution_t;
  720 
  721 
  722 //--------------------------------------------------------------------------------------------------
  723 /**
  724  **  Data types.
  725  */
  726 //--------------------------------------------------------------------------------------------------
  727 typedef enum
  728 {
  729     LE_GNSS_DATA_VACCURACY = 0,
  730         ///< Vertical accuracy data.
  731     LE_GNSS_DATA_VSPEEDACCURACY = 1,
  732         ///< Vertical speed accuracy data.
  733     LE_GNSS_DATA_HSPEEDACCURACY = 2,
  734         ///< Horizontal speed accuracy data.
  735     LE_GNSS_DATA_UNKNOWN = 3
  736         ///< Unknown data type.
  737 }
  738 le_gnss_DataType_t;
  739 
  740 
  741 //--------------------------------------------------------------------------------------------------
  742 /**
  743  *  SBAS constellation category
  744  */
  745 //--------------------------------------------------------------------------------------------------
  746 typedef enum
  747 {
  748     LE_GNSS_SBAS_EGNOS = 0,
  749         ///< Satellite Vehicle of Satellite-based augmentation system
  750         ///< (SBAS) EGNOS constellation.
  751     LE_GNSS_SBAS_WAAS = 1,
  752         ///< Satellite Vehicle of Satellite-based augmentation system
  753         ///< (SBAS) WAAS constellation.
  754     LE_GNSS_SBAS_GAGAN = 2,
  755         ///< Satellite Vehicle of Satellite-based augmentation system
  756         ///< (SBAS) GAGAN constellation.
  757     LE_GNSS_SBAS_MSAS = 3,
  758         ///< Satellite Vehicle of Satellite-based augmentation system
  759         ///< (SBAS) MSAS constellation.
  760     LE_GNSS_SBAS_SDCM = 4,
  761         ///< Satellite Vehicle of Satellite-based augmentation system
  762         ///< (SBAS) SDCM constellation.
  763     LE_GNSS_SBAS_UNKNOWN = 5
  764         ///< Satellite Vehicle of Satellite-based augmentation system
  765         ///< (SBAS) unknown constellation.
  766 }
  767 le_gnss_SbasConstellationCategory_t;
  768 
  769 
  770 //--------------------------------------------------------------------------------------------------
  771 /**
  772  *  GNSS constellation type.
  773  */
  774 //--------------------------------------------------------------------------------------------------
  775 typedef enum
  776 {
  777     LE_GNSS_SV_CONSTELLATION_UNDEFINED = 0,
  778         ///< GNSS constellation field not defined.
  779     LE_GNSS_SV_CONSTELLATION_GPS = 1,
  780         ///< Satellite Vehicle of GPS constellation.
  781         ///< North American satellite navigation system
  782     LE_GNSS_SV_CONSTELLATION_SBAS = 2,
  783         ///< Satellite Vehicle of SBAS constellation.
  784         ///< Satellite-based augmentation system
  785     LE_GNSS_SV_CONSTELLATION_GLONASS = 3,
  786         ///< Satellite Vehicle of Glonass constellation.
  787         ///< Russian satellite navigation system
  788     LE_GNSS_SV_CONSTELLATION_GALILEO = 4,
  789         ///< Satellite Vehicle of Galileo constellation.
  790         ///< European Union satellite navigation system
  791     LE_GNSS_SV_CONSTELLATION_BEIDOU = 5,
  792         ///< Satellite Vehicle of Beidou constellation.
  793         ///< Chinese satellite navigation system
  794     LE_GNSS_SV_CONSTELLATION_QZSS = 6,
  795         ///< Satellite Vehicle of QZSS constellation.
  796         ///< Japanese satellite navigation system
  797     LE_GNSS_SV_CONSTELLATION_MAX = 7
  798         ///< Maximum value.
  799 }
  800 le_gnss_Constellation_t;
  801 
  802 
  803 //--------------------------------------------------------------------------------------------------
  804 /**
  805  * Assisted-GNSS mode
  806  */
  807 //--------------------------------------------------------------------------------------------------
  808 typedef enum
  809 {
  810     LE_GNSS_STANDALONE_MODE = 0,
  811         ///< Standalone mode.
  812     LE_GNSS_MS_BASED_MODE = 1,
  813         ///< MS-Based mode.
  814     LE_GNSS_MS_ASSISTED_MODE = 2
  815         ///< MS-Assisted mode.
  816 }
  817 le_gnss_AssistedMode_t;
  818 
  819 
  820 //--------------------------------------------------------------------------------------------------
  821 /**
  822  * Dilution of precision type
  823  */
  824 //--------------------------------------------------------------------------------------------------
  825 typedef enum
  826 {
  827     LE_GNSS_PDOP = 0,
  828         ///< Position dilution of precision.
  829     LE_GNSS_HDOP = 1,
  830         ///< Horizontal dilution of precision.
  831     LE_GNSS_VDOP = 2,
  832         ///< Vertical dilution of precision.
  833     LE_GNSS_GDOP = 3,
  834         ///< Geometric dilution of precision.
  835     LE_GNSS_TDOP = 4,
  836         ///< Time dilution of precision.
  837     LE_GNSS_DOP_LAST = 5
  838         ///<
  839 }
  840 le_gnss_DopType_t;
  841 
  842 
  843 //--------------------------------------------------------------------------------------------------
  844 /**
  845  * GNSS constellation area type
  846  */
  847 //--------------------------------------------------------------------------------------------------
  848 typedef enum
  849 {
  850     LE_GNSS_UNSET_AREA = 0,
  851         ///< Unset area.
  852     LE_GNSS_WORLDWIDE_AREA = 1,
  853         ///< Worldwide area.
  854     LE_GNSS_OUTSIDE_US_AREA = 2
  855         ///< Outside US area.
  856 }
  857 le_gnss_ConstellationArea_t;
  858 
  859 
  860 //--------------------------------------------------------------------------------------------------
  861 /**
  862  * GNSS constellation Bit Mask (8 bits) indicating the GNSS constellation(s)
  863  * used in solution.
  864  *
  865  */
  866 //--------------------------------------------------------------------------------------------------
  867 typedef enum
  868 {
  869     LE_GNSS_CONSTELLATION_GPS = 0x1,        ///< GPS constellation used in solution.
  870         ///< North American satellite navigation system
  871     LE_GNSS_CONSTELLATION_GLONASS = 0x2,        ///< GLONASS constellation used in solution.
  872         ///< Russian satellite navigation system
  873     LE_GNSS_CONSTELLATION_BEIDOU = 0x4,        ///< BEIDOU constellation used in solution.
  874         ///< Chinese satellite navigation system
  875     LE_GNSS_CONSTELLATION_GALILEO = 0x8,        ///< GALILEO constellation used in solution.
  876         ///< European Union satellite navigation system
  877     LE_GNSS_CONSTELLATION_SBAS = 0x10,        ///< SBAS constellation used in solution.
  878     LE_GNSS_CONSTELLATION_QZSS = 0x20        ///< QZSS constellation used in solution.
  879         ///< Japanese satellite navigation system
  880 }
  881 le_gnss_ConstellationBitMask_t;
  882 
  883 
  884 //--------------------------------------------------------------------------------------------------
  885 /**
  886  * NMEA sentences Bit Mask indicating the NMEA sentences enabled in the NMEA flow.
  887  *
  888  * @warning The supported NMEA sentences depend on the platform. Please refer to your platform
  889  * documentation for further details.
  890  *
  891  * @note The bit mask values should be coherent with @ref LE_GNSS_NMEA_SENTENCES_MAX
  892  */
  893 //--------------------------------------------------------------------------------------------------
  894 typedef enum
  895 {
  896     LE_GNSS_NMEA_MASK_GPGGA = 0x1,        ///< GPGGA type enabled: GPS fix data.
  897     LE_GNSS_NMEA_MASK_GPGSA = 0x2,        ///< GPGSA type enabled: GPS DOP and active satellites.
  898     LE_GNSS_NMEA_MASK_GPGSV = 0x4,        ///< GPGSV type enabled: GPS satellites in view.
  899     LE_GNSS_NMEA_MASK_GPRMC = 0x8,        ///< GPRMC type enabled: GPS recommended minimum data.
  900     LE_GNSS_NMEA_MASK_GPVTG = 0x10,        ///< GPVTG type enabled: GPS vector track and speed over the ground.
  901     LE_GNSS_NMEA_MASK_GLGSV = 0x20,        ///< GLGSV type enabled: GLONASS satellites in view.
  902     LE_GNSS_NMEA_MASK_GNGNS = 0x40,        ///< GNGNS type enabled: GNSS fix data.
  903     LE_GNSS_NMEA_MASK_GNGSA = 0x80,        ///< GNGSA type enabled: GNSS DOP and active satellites.
  904     LE_GNSS_NMEA_MASK_GAGGA = 0x100,        ///< GAGGA type enabled: Galileo fix data.
  905     LE_GNSS_NMEA_MASK_GAGSA = 0x200,        ///< GAGSA type enabled: Galileo DOP and active satellites.
  906     LE_GNSS_NMEA_MASK_GAGSV = 0x400,        ///< GAGSV type enabled: Galileo satellites in view.
  907     LE_GNSS_NMEA_MASK_GARMC = 0x800,        ///< GARMC type enabled: Galileo recommended minimum data.
  908     LE_GNSS_NMEA_MASK_GAVTG = 0x1000,        ///< GAVTG type enabled: Galileo vector track and speed over the ground.
  909     LE_GNSS_NMEA_MASK_PSTIS = 0x2000,        ///< PSTIS type enabled: GPS session start indication.
  910     LE_GNSS_NMEA_MASK_REMOVED = 0x4000,        ///<
  911     LE_GNSS_NMEA_MASK_PTYPE = 0x8000,        ///< PTYPE type enabled: Proprietary Type mask.
  912     LE_GNSS_NMEA_MASK_GPGRS = 0x10000,        ///< GPGRS type enabled: GPS Range residuals.
  913     LE_GNSS_NMEA_MASK_GPGLL = 0x20000,        ///< GPGLL type enabled: GPS Geographic position, latitude / longitude.
  914     LE_GNSS_NMEA_MASK_DEBUG = 0x40000,        ///< DEBUG type enabled: Debug NMEA indication.
  915     LE_GNSS_NMEA_MASK_GPDTM = 0x80000,        ///< GPDTM type enabled: Local geodetic datum and datum offset from a
  916     LE_GNSS_NMEA_MASK_GAGNS = 0x100000        ///< GAGNS type enabled: Fix data for Galileo.
  917 }
  918 le_gnss_NmeaBitMask_t;
  919 
  920 
  921 //--------------------------------------------------------------------------------------------------
  922 /**
  923  *  Coordinate system
  924  */
  925 //--------------------------------------------------------------------------------------------------
  926 typedef enum
  927 {
  928     LE_GNSS_COORDINATE_SYSTEM_WGS84 = 0,
  929         ///< Coordinate system WGS84.
  930     LE_GNSS_COORDINATE_SYSTEM_PZ90 = 1,
  931         ///< Coordinate system PZ90.
  932     LE_GNSS_COORDINATE_SYSTEM_MAX = 2
  933         ///< Maximum value.
  934 }
  935 le_gnss_CoordinateSystem_t;
  936 
  937 
  938 //--------------------------------------------------------------------------------------------------
  939 /**
  940  **  Location data types
  941  */
  942 //--------------------------------------------------------------------------------------------------
  943 typedef enum
  944 {
  945     LE_GNSS_POS_LATITUDE = 0,
  946         ///< Latitude data position.
  947     LE_GNSS_POS_LONGITUDE = 1,
  948         ///< Longitude data position.
  949     LE_GNSS_POS_ALTITUDE = 2,
  950         ///< Altitude data position.
  951     LE_GNSS_POS_MAX = 3
  952         ///< Maximum value.
  953 }
  954 le_gnss_LocationDataType_t;
  955 
  956 
  957 //--------------------------------------------------------------------------------------------------
  958 /**
  959  * Reference type used by Add/Remove functions for EVENT 'le_gnss_Position'
  960  */
  961 //--------------------------------------------------------------------------------------------------
  962 typedef struct le_gnss_PositionHandler* le_gnss_PositionHandlerRef_t;
  963 
  964 
  965 //--------------------------------------------------------------------------------------------------
  966 /**
  967  * Handler for position information.
  968  *
  969  */
  970 //--------------------------------------------------------------------------------------------------
  971 typedef void (*le_gnss_PositionHandlerFunc_t)
  972 (
  973     le_gnss_SampleRef_t positionSampleRef,
  974         ///< Position's sample reference
  975     void* contextPtr
  976         ///<
  977 );
  978 
  979 //--------------------------------------------------------------------------------------------------
  980 /**
  981  * Set the GNSS constellation bit mask
  982  *
  983  * @return
  984  *  - LE_FAULT         The function failed.
  985  *  - LE_UNSUPPORTED   If the request is not supported.
  986  *  - LE_NOT_PERMITTED If the GNSS device is not initialized, disabled or active.
  987  *  - LE_OK            The function succeeded.
  988  *
  989  * @warning Some constellation types are unsupported depending on the plateform. Please refer to
  990  *          @ref platformConstraintsGnss_ConstellationType section for full details.
  991  *
  992  * @warning The settings are platform dependent. Please refer to
  993  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
  994  */
  995 //--------------------------------------------------------------------------------------------------
  996 le_result_t le_gnss_SetConstellation
  997 (
  998     le_gnss_ConstellationBitMask_t constellationMask
  999         ///< [IN] GNSS constellation used in solution.
 1000 );
 1001 
 1002 //--------------------------------------------------------------------------------------------------
 1003 /**
 1004  * Get the GNSS constellation bit mask
 1005  *
 1006  * @return
 1007  *  - LE_OK on success
 1008  *  - LE_FAULT on failure
 1009  *
 1010  * @note If the caller is passing a null pointer into this function, it is a fatal error, the
 1011  *       function will not return.
 1012  */
 1013 //--------------------------------------------------------------------------------------------------
 1014 le_result_t le_gnss_GetConstellation
 1015 (
 1016     le_gnss_ConstellationBitMask_t* constellationMaskPtr
 1017         ///< [OUT] GNSS constellation used in solution.
 1018 );
 1019 
 1020 //--------------------------------------------------------------------------------------------------
 1021 /**
 1022  * Set the area for the GNSS constellation
 1023  *
 1024  * @return
 1025  *  - LE_OK            The function succeeded.
 1026  *  - LE_FAULT         The function failed.
 1027  *  - LE_UNSUPPORTED   If the request is not supported.
 1028  *  - LE_NOT_PERMITTED If the GNSS device is not initialized, disabled or active.
 1029  *  - LE_BAD_PARAMETER Invalid constellation area.
 1030  *
 1031  * @warning The settings are platform dependent. Please refer to
 1032  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 1033  */
 1034 //--------------------------------------------------------------------------------------------------
 1035 le_result_t le_gnss_SetConstellationArea
 1036 (
 1037     le_gnss_Constellation_t satConstellation,
 1038         ///< [IN] GNSS constellation type.
 1039     le_gnss_ConstellationArea_t constellationArea
 1040         ///< [IN] GNSS constellation area.
 1041 );
 1042 
 1043 //--------------------------------------------------------------------------------------------------
 1044 /**
 1045  * Get the area for the GNSS constellation
 1046  *
 1047  * @return
 1048  *  - LE_OK            On success
 1049  *  - LE_FAULT         On failure
 1050  *  - LE_UNSUPPORTED   Request not supported
 1051  *  - LE_NOT_PERMITTED If the GNSS device is not initialized, disabled or active.
 1052  *
 1053  * @note If the caller is passing a null pointer into this function, it is a fatal error, the
 1054  *       function will not return.
 1055  */
 1056 //--------------------------------------------------------------------------------------------------
 1057 le_result_t le_gnss_GetConstellationArea
 1058 (
 1059     le_gnss_Constellation_t satConstellation,
 1060         ///< [IN] GNSS constellation type.
 1061     le_gnss_ConstellationArea_t* constellationAreaPtr
 1062         ///< [OUT] GNSS constellation area.
 1063 );
 1064 
 1065 //--------------------------------------------------------------------------------------------------
 1066 /**
 1067  * This function enables the use of the 'Extended Ephemeris' file into the GNSS device.
 1068  *
 1069  * @return
 1070  *  - LE_FAULT         The function failed.
 1071  *  - LE_OK            The function succeeded.
 1072  *
 1073  * @warning The settings are platform dependent. Please refer to
 1074  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 1075  */
 1076 //--------------------------------------------------------------------------------------------------
 1077 le_result_t le_gnss_EnableExtendedEphemerisFile
 1078 (
 1079     void
 1080 );
 1081 
 1082 //--------------------------------------------------------------------------------------------------
 1083 /**
 1084  * This function disables the use of the 'Extended Ephemeris' file into the GNSS device.
 1085  *
 1086  * @return
 1087  *  - LE_FAULT         The function failed.
 1088  *  - LE_OK            The function succeeded.
 1089  *
 1090  * @warning The settings are platform dependent. Please refer to
 1091  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 1092  */
 1093 //--------------------------------------------------------------------------------------------------
 1094 le_result_t le_gnss_DisableExtendedEphemerisFile
 1095 (
 1096     void
 1097 );
 1098 
 1099 //--------------------------------------------------------------------------------------------------
 1100 /**
 1101  * This function must be called to load an 'Extended Ephemeris' file into the GNSS device.
 1102  *
 1103  * @return
 1104  *  - LE_FAULT         The function failed to inject the 'Extended Ephemeris' file.
 1105  *  - LE_TIMEOUT       A time-out occurred.
 1106  *  - LE_FORMAT_ERROR  'Extended Ephemeris' file format error.
 1107  *  - LE_OK            The function succeeded.
 1108  *
 1109  */
 1110 //--------------------------------------------------------------------------------------------------
 1111 le_result_t le_gnss_LoadExtendedEphemerisFile
 1112 (
 1113     int fd
 1114         ///< [IN] Extended ephemeris file descriptor
 1115 );
 1116 
 1117 //--------------------------------------------------------------------------------------------------
 1118 /**
 1119  * This function must be called to get the validity of the last injected Extended Ephemeris.
 1120  *
 1121  * @return
 1122  *  - LE_FAULT         The function failed to get the validity
 1123  *  - LE_OK            The function succeeded.
 1124  *
 1125  * @note If the caller is passing an invalid Position sample reference or null pointers into this
 1126  *       function, it is a fatal error, the function will not return.
 1127  */
 1128 //--------------------------------------------------------------------------------------------------
 1129 le_result_t le_gnss_GetExtendedEphemerisValidity
 1130 (
 1131     uint64_t* startTimePtr,
 1132         ///< [OUT] Start time in seconds (since Jan. 1, 1970)
 1133     uint64_t* stopTimePtr
 1134         ///< [OUT] Stop time in seconds (since Jan. 1, 1970)
 1135 );
 1136 
 1137 //--------------------------------------------------------------------------------------------------
 1138 /**
 1139  * This function must be called to inject the UTC time into the GNSS device.
 1140  *
 1141  * @return
 1142  *  - LE_OK            The function succeeded.
 1143  *  - LE_FAULT         The function failed to inject the UTC time.
 1144  *  - LE_TIMEOUT       A time-out occurred.
 1145  *
 1146  * @note It is mandatory to enable the 'Extended Ephemeris' file injection into the GNSS device with
 1147  * le_gnss_EnableExtendedEphemerisFile() before injecting time with this API.
 1148  */
 1149 //--------------------------------------------------------------------------------------------------
 1150 le_result_t le_gnss_InjectUtcTime
 1151 (
 1152     uint64_t timeUtc,
 1153         ///< [IN] [IN] UTC time since Jan. 1, 1970 in milliseconds
 1154     uint32_t timeUnc
 1155         ///< [IN] [IN] Time uncertainty in milliseconds
 1156 );
 1157 
 1158 //--------------------------------------------------------------------------------------------------
 1159 /**
 1160  * This function starts the GNSS device.
 1161  *
 1162  * @return
 1163  *  - LE_FAULT         The function failed.
 1164  *  - LE_DUPLICATE     If the GNSS device is already started.
 1165  *  - LE_NOT_PERMITTED If the GNSS device is not initialized or disabled.
 1166  *  - LE_OK            The function succeeded.
 1167  *
 1168  */
 1169 //--------------------------------------------------------------------------------------------------
 1170 le_result_t le_gnss_Start
 1171 (
 1172     void
 1173 );
 1174 
 1175 //--------------------------------------------------------------------------------------------------
 1176 /**
 1177  * This function stops the GNSS device.
 1178  *
 1179  * @return
 1180  *  - LE_FAULT         The function failed.
 1181  *  - LE_DUPLICATE     If the GNSS device is already stopped.
 1182  *  - LE_NOT_PERMITTED If the GNSS device is not initialized or disabled.
 1183  *  - LE_OK            The function succeeded.
 1184  *
 1185  */
 1186 //--------------------------------------------------------------------------------------------------
 1187 le_result_t le_gnss_Stop
 1188 (
 1189     void
 1190 );
 1191 
 1192 //--------------------------------------------------------------------------------------------------
 1193 /**
 1194  * This function performs a "HOT" restart of the GNSS device.
 1195  *
 1196  * @return
 1197  *  - LE_FAULT         The function failed.
 1198  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
 1199  *  - LE_OK            The function succeeded.
 1200  *
 1201  */
 1202 //--------------------------------------------------------------------------------------------------
 1203 le_result_t le_gnss_ForceHotRestart
 1204 (
 1205     void
 1206 );
 1207 
 1208 //--------------------------------------------------------------------------------------------------
 1209 /**
 1210  * This function performs a "WARM" restart of the GNSS device.
 1211  *
 1212  * @return
 1213  *  - LE_FAULT         The function failed.
 1214  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
 1215  *  - LE_OK            The function succeeded.
 1216  *
 1217  * @Note This API has a platform dependent feature. Please refer to
 1218  * @ref platformConstraintsGnss_WarmRestart for further details.
 1219  */
 1220 //--------------------------------------------------------------------------------------------------
 1221 le_result_t le_gnss_ForceWarmRestart
 1222 (
 1223     void
 1224 );
 1225 
 1226 //--------------------------------------------------------------------------------------------------
 1227 /**
 1228  * This function performs a "COLD" restart of the GNSS device.
 1229  *
 1230  * @return
 1231  *  - LE_FAULT         The function failed.
 1232  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
 1233  *  - LE_OK            The function succeeded.
 1234  *
 1235  */
 1236 //--------------------------------------------------------------------------------------------------
 1237 le_result_t le_gnss_ForceColdRestart
 1238 (
 1239     void
 1240 );
 1241 
 1242 //--------------------------------------------------------------------------------------------------
 1243 /**
 1244  * This function performs a "FACTORY" restart of the GNSS device.
 1245  *
 1246  * @return
 1247  *  - LE_FAULT         The function failed.
 1248  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
 1249  *  - LE_OK            The function succeeded.
 1250  *
 1251  */
 1252 //--------------------------------------------------------------------------------------------------
 1253 le_result_t le_gnss_ForceFactoryRestart
 1254 (
 1255     void
 1256 );
 1257 
 1258 //--------------------------------------------------------------------------------------------------
 1259 /**
 1260  * Get the TTFF in milliseconds
 1261  *
 1262  * @return
 1263  *  - LE_BUSY          The position is not fixed and TTFF can't be measured.
 1264  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
 1265  *  - LE_OK            Function succeeded.
 1266  *  - LE_FAULT         If there are some other errors.
 1267  *
 1268  * @note If the caller is passing a null pointer into this function, it is a fatal error, the
 1269  *       function will not return.
 1270  */
 1271 //--------------------------------------------------------------------------------------------------
 1272 le_result_t le_gnss_GetTtff
 1273 (
 1274     uint32_t* ttffPtr
 1275         ///< [OUT] TTFF in milliseconds
 1276 );
 1277 
 1278 //--------------------------------------------------------------------------------------------------
 1279 /**
 1280  * This function enables the GNSS device.
 1281  *
 1282  * @return
 1283  *  - LE_FAULT         The function failed.
 1284  *  - LE_DUPLICATE     If the GNSS device is already enabled.
 1285  *  - LE_NOT_PERMITTED If the GNSS device is not initialized.
 1286  *  - LE_OK            The function succeeded.
 1287  *
 1288  * @warning The settings are platform dependent. Please refer to
 1289  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 1290  */
 1291 //--------------------------------------------------------------------------------------------------
 1292 le_result_t le_gnss_Enable
 1293 (
 1294     void
 1295 );
 1296 
 1297 //--------------------------------------------------------------------------------------------------
 1298 /**
 1299  * This function disables the GNSS device.
 1300  *
 1301  * @return
 1302  *  - LE_FAULT         The function failed.
 1303  *  - LE_DUPLICATE     If the GNSS device is already disabled.
 1304  *  - LE_NOT_PERMITTED If the GNSS device is not initialized or started.
 1305  *  - LE_OK            The function succeeded.
 1306  *
 1307  * @warning The settings are platform dependent. Please refer to
 1308  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 1309  */
 1310 //--------------------------------------------------------------------------------------------------
 1311 le_result_t le_gnss_Disable
 1312 (
 1313     void
 1314 );
 1315 
 1316 //--------------------------------------------------------------------------------------------------
 1317 /**
 1318  * This function sets the GNSS device acquisition rate.
 1319  *
 1320  * @return
 1321  *  - LE_OK on success
 1322  *  - LE_FAULT on failure
 1323  *  - LE_UNSUPPORTED request not supported
 1324  *  - LE_TIMEOUT a time-out occurred
 1325  *  - LE_NOT_PERMITTED If the GNSS device is not in "ready" state.
 1326  *  - LE_OUT_OF_RANGE  if acquisition rate value is equal to zero
 1327  *
 1328  * @warning This function may be subject to limitations depending on the platform. Please refer to
 1329  *          the @ref platformConstraintsGnss page.
 1330  *
 1331  * @warning The settings are platform dependent. Please refer to
 1332  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 1333  */
 1334 //--------------------------------------------------------------------------------------------------
 1335 le_result_t le_gnss_SetAcquisitionRate
 1336 (
 1337     uint32_t rate
 1338         ///< [IN] Acquisition rate in milliseconds.
 1339 );
 1340 
 1341 //--------------------------------------------------------------------------------------------------
 1342 /**
 1343  * This function gets the GNSS device acquisition rate.
 1344  *
 1345  * @return
 1346  *  - LE_OK on success
 1347  *  - LE_FAULT on failure
 1348  *  - LE_NOT_PERMITTED If the GNSS device is not in "ready" state.
 1349  *
 1350  * @note If the caller is passing a null pointer into this function, it is a fatal error, the
 1351  *       function will not return.
 1352  */
 1353 //--------------------------------------------------------------------------------------------------
 1354 le_result_t le_gnss_GetAcquisitionRate
 1355 (
 1356     uint32_t* ratePtr
 1357         ///< [OUT] Acquisition rate in milliseconds.
 1358 );
 1359 
 1360 //--------------------------------------------------------------------------------------------------
 1361 /**
 1362  * Add handler function for EVENT 'le_gnss_Position'
 1363  *
 1364  * This event provides information on position.
 1365  *
 1366  *  - A handler reference, which is only needed for later removal of the handler.
 1367  *
 1368  * @note Doesn't return on failure, so there's no need to check the return value for errors.
 1369  */
 1370 //--------------------------------------------------------------------------------------------------
 1371 le_gnss_PositionHandlerRef_t le_gnss_AddPositionHandler
 1372 (
 1373     le_gnss_PositionHandlerFunc_t handlerPtr,
 1374         ///< [IN]
 1375     void* contextPtr
 1376         ///< [IN]
 1377 );
 1378 
 1379 //--------------------------------------------------------------------------------------------------
 1380 /**
 1381  * Remove handler function for EVENT 'le_gnss_Position'
 1382  */
 1383 //--------------------------------------------------------------------------------------------------
 1384 void le_gnss_RemovePositionHandler
 1385 (
 1386     le_gnss_PositionHandlerRef_t handlerRef
 1387         ///< [IN]
 1388 );
 1389 
 1390 //--------------------------------------------------------------------------------------------------
 1391 /**
 1392  * This function gets the position sample's fix state
 1393  *
 1394  *  - LE_OK on success
 1395  *  - LE_FAULT on failure
 1396  *
 1397  * @note If the caller is passing an invalid Position sample reference or a null pointer into this
 1398  *       function, it is a fatal error, the function will not return.
 1399  */
 1400 //--------------------------------------------------------------------------------------------------
 1401 le_result_t le_gnss_GetPositionState
 1402 (
 1403     le_gnss_SampleRef_t positionSampleRef,
 1404         ///< [IN] Position sample's reference.
 1405     le_gnss_FixState_t* statePtr
 1406         ///< [OUT] Position fix state.
 1407 );
 1408 
 1409 //--------------------------------------------------------------------------------------------------
 1410 /**
 1411  * Get the location's data (Latitude, Longitude, Horizontal accuracy).
 1412  *
 1413  * @return
 1414  *  - LE_FAULT         Function failed to get the location's data
 1415  *  - LE_OUT_OF_RANGE  At least one of the retrieved parameters is invalid (set to INT32_MAX).
 1416  *  - LE_OK            Function succeeded.
 1417  *
 1418  * @note latitudePtr, longitudePtr and hAccuracyPtr can be set to NULL if not needed.
 1419  *
 1420  * @note The latitude and longitude values are based on the WGS84 standard coordinate system.
 1421  *
 1422  * @note The latitude and longitude values are given in degrees with 6 decimal places like:
 1423  *       Latitude +48858300 = 48.858300 degrees North
 1424  *       Longitude +2294400 = 2.294400 degrees East
 1425  *       (The latitude and longitude values are given in degrees, minutes, seconds in NMEA frame)
 1426  *
 1427  * @note In case the function returns LE_OUT_OF_RANGE, some of the retrieved parameters may be
 1428  *       valid. Please compare them with INT32_MAX.
 1429  *
 1430  * @note If the caller is passing an invalid Position sample reference into this function,
 1431  *       it is a fatal error, the function will not return.
 1432  */
 1433 //--------------------------------------------------------------------------------------------------
 1434 le_result_t le_gnss_GetLocation
 1435 (
 1436     le_gnss_SampleRef_t positionSampleRef,
 1437         ///< [IN] Position sample's reference.
 1438     int32_t* latitudePtr,
 1439         ///< [OUT] WGS84 Latitude in degrees, positive North [resolution 1e-6].
 1440     int32_t* longitudePtr,
 1441         ///< [OUT] WGS84 Longitude in degrees, positive East [resolution 1e-6].
 1442     int32_t* hAccuracyPtr
 1443         ///< [OUT] Horizontal position's accuracy in meters [resolution 1e-2].
 1444 );
 1445 
 1446 //--------------------------------------------------------------------------------------------------
 1447 /**
 1448  * Get the position sample's altitude.
 1449  *
 1450  * @return
 1451  *  - LE_FAULT         Function failed to get the altitude. Invalid Position reference provided.
 1452  *  - LE_OUT_OF_RANGE  At least one of the retrieved parameters is invalid (set to INT32_MAX).
 1453  *  - LE_OK            Function succeeded.
 1454  *
 1455  * @note Altitude is in meters, above Mean Sea Level, with 3 decimal places (3047 = 3.047 meters).
 1456  *
 1457  * @note For a 2D position fix, the altitude will be indicated as invalid and set to INT32_MAX
 1458  *
 1459  * @note Vertical position accuracy is default set to meters with 1 decimal place (3047 = 3.0
 1460  *       meters). To change its accuracy, call the @c le_gnss_SetDataResolution() function. Vertical
 1461  *       position accuracy is set as data type and accuracy from 0 to 3 decimal place is set as
 1462  *       resolution.
 1463  *
 1464  * @note In case the function returns LE_OUT_OF_RANGE, some of the retrieved parameters may be
 1465  *       valid. Please compare them with INT32_MAX.
 1466  *
 1467  * @note If the caller is passing an invalid Position reference into this function,
 1468  *       it is a fatal error, the function will not return.
 1469  *
 1470  * @note altitudePtr, altitudeAccuracyPtr can be set to NULL if not needed.
 1471  */
 1472 //--------------------------------------------------------------------------------------------------
 1473 le_result_t le_gnss_GetAltitude
 1474 (
 1475     le_gnss_SampleRef_t positionSampleRef,
 1476         ///< [IN] Position sample's reference.
 1477     int32_t* altitudePtr,
 1478         ///< [OUT] Altitude in meters, above Mean Sea Level [resolution 1e-3].
 1479     int32_t* vAccuracyPtr
 1480         ///< [OUT] Vertical position's accuracy in meters.
 1481 );
 1482 
 1483 //--------------------------------------------------------------------------------------------------
 1484 /**
 1485  * Get the position sample's time.
 1486  *
 1487  * @return
 1488  *  - LE_FAULT         Function failed to get the time.
 1489  *  - LE_OUT_OF_RANGE  The retrieved time is invalid (all fields are set to 0).
 1490  *  - LE_OK            Function succeeded.
 1491  *
 1492  * @note If the caller is passing an invalid Position sample reference or null pointers into this
 1493  *       function, it is a fatal error, the function will not return.
 1494  *
 1495  */
 1496 //--------------------------------------------------------------------------------------------------
 1497 le_result_t le_gnss_GetTime
 1498 (
 1499     le_gnss_SampleRef_t positionSampleRef,
 1500         ///< [IN] Position sample's reference.
 1501     uint16_t* hoursPtr,
 1502         ///< [OUT] UTC Hours into the day [range 0..23].
 1503     uint16_t* minutesPtr,
 1504         ///< [OUT] UTC Minutes into the hour [range 0..59].
 1505     uint16_t* secondsPtr,
 1506         ///< [OUT] UTC Seconds into the minute [range 0..59].
 1507     uint16_t* millisecondsPtr
 1508         ///< [OUT] UTC Milliseconds into the second [range 0..999].
 1509 );
 1510 
 1511 //--------------------------------------------------------------------------------------------------
 1512 /**
 1513  * Get the position sample's GPS time.
 1514  *
 1515  * @return
 1516  *  - LE_FAULT         Function failed to get the time.
 1517  *  - LE_OUT_OF_RANGE  The retrieved time is invalid (all fields are set to 0).
 1518  *  - LE_OK            Function succeeded.
 1519  *
 1520  * @note If the caller is passing an invalid Position sample reference or null pointers into this
 1521  *       function, it is a fatal error, the function will not return.
 1522  */
 1523 //--------------------------------------------------------------------------------------------------
 1524 le_result_t le_gnss_GetGpsTime
 1525 (
 1526     le_gnss_SampleRef_t positionSampleRef,
 1527         ///< [IN] Position sample's reference.
 1528     uint32_t* gpsWeekPtr,
 1529         ///< [OUT] GPS week number from midnight, Jan. 6, 1980.
 1530     uint32_t* gpsTimeOfWeekPtr
 1531         ///< [OUT] Amount of time in milliseconds into the GPS week.
 1532 );
 1533 
 1534 //--------------------------------------------------------------------------------------------------
 1535 /**
 1536  *  Get the position sample's epoch time.
 1537  *
 1538  * @return
 1539  *  - LE_FAULT         Function failed to acquire the epoch time.
 1540  *  - LE_OK            Function succeeded.
 1541  *  - LE_OUT_OF_RANGE  The retrieved time is invalid (all fields are set to 0).
 1542  *
 1543  * @note The epoch time is the number of seconds elapsed since January 1, 1970
 1544  *       (midnight UTC/GMT), not counting leaps seconds.
 1545  *
 1546  * @note If the caller is passing an invalid position sample reference or a null pointer into this
 1547  *       function, it is a fatal error, the function will not return.
 1548  */
 1549 //--------------------------------------------------------------------------------------------------
 1550 le_result_t le_gnss_GetEpochTime
 1551 (
 1552     le_gnss_SampleRef_t positionSampleRef,
 1553         ///< [IN] Position sample's reference.
 1554     uint64_t* millisecondsPtr
 1555         ///< [OUT] Milliseconds since Jan. 1, 1970.
 1556 );
 1557 
 1558 //--------------------------------------------------------------------------------------------------
 1559 /**
 1560  * Get the position sample's time accurary.
 1561  *
 1562  * @return
 1563  *  - LE_FAULT         Function failed to get the time.
 1564  *  - LE_OUT_OF_RANGE  The retrieved time accuracy is invalid (set to UINT16_MAX).
 1565  *  - LE_OK            Function succeeded.
 1566  *
 1567  * @note If the caller is passing an invalid position sample reference or a null pointer into this
 1568  *       function, it is a fatal error, the function will not return.
 1569  */
 1570 //--------------------------------------------------------------------------------------------------
 1571 le_result_t le_gnss_GetTimeAccuracy
 1572 (
 1573     le_gnss_SampleRef_t positionSampleRef,
 1574         ///< [IN] Position sample's reference.
 1575     uint32_t* timeAccuracyPtr
 1576         ///< [OUT] Estimated time accuracy in nanoseconds
 1577 );
 1578 
 1579 //--------------------------------------------------------------------------------------------------
 1580 /**
 1581  * Get the position sample's UTC leap seconds in advance
 1582  *
 1583  * @return
 1584  *  - LE_FAULT         Function failed to get the leap seconds.
 1585  *  - LE_OUT_OF_RANGE  The retrieved time accuracy is invalid (set to UINT8_MAX).
 1586  *  - LE_OK            Function succeeded.
 1587  *
 1588  * @note The leap seconds in advance is the accumulated time in seconds since the start of GPS Epoch
 1589  * time (Jan 6, 1980). This value has to be added to the UTC time (since Jan. 1, 1970)
 1590  *
 1591  * @note Insertion of each UTC leap second is usually decided about six months in advance by the
 1592  * International Earth Rotation and Reference Systems Service (IERS).
 1593  *
 1594  * @note If the caller is passing an invalid position sample reference or a null pointer into this
 1595  *       function, it is a fatal error, the function will not return.
 1596  */
 1597 //--------------------------------------------------------------------------------------------------
 1598 le_result_t le_gnss_GetGpsLeapSeconds
 1599 (
 1600     le_gnss_SampleRef_t positionSampleRef,
 1601         ///< [IN] Position sample's reference.
 1602     uint8_t* leapSecondsPtr
 1603         ///< [OUT] UTC leap seconds in advance in seconds
 1604 );
 1605 
 1606 //--------------------------------------------------------------------------------------------------
 1607 /**
 1608  * Get the position sample's date.
 1609  *
 1610  * @return
 1611  *  - LE_FAULT         Function failed to get the date.
 1612  *  - LE_OUT_OF_RANGE  The retrieved date is invalid (all fields are set to 0).
 1613  *  - LE_OK            Function succeeded.
 1614  *
 1615  * @note If the caller is passing an invalid Position sample reference or null pointers into this
 1616  *       function, it is a fatal error, the function will not return.
 1617  */
 1618 //--------------------------------------------------------------------------------------------------
 1619 le_result_t le_gnss_GetDate
 1620 (
 1621     le_gnss_SampleRef_t positionSampleRef,
 1622         ///< [IN] Position sample's reference.
 1623     uint16_t* yearPtr,
 1624         ///< [OUT] UTC Year A.D. [e.g. 2014].
 1625     uint16_t* monthPtr,
 1626         ///< [OUT] UTC Month into the year [range 1...12].
 1627     uint16_t* dayPtr
 1628         ///< [OUT] UTC Days into the month [range 1...31].
 1629 );
 1630 
 1631 //--------------------------------------------------------------------------------------------------
 1632 /**
 1633  * Get the position sample's horizontal speed.
 1634  *
 1635  *  - LE_FAULT         Function failed to find the positionSample.
 1636  *  - LE_OUT_OF_RANGE  At least one of the retrieved parameters is invalid (set to UINT32_MAX).
 1637  *  - LE_OK            Function succeeded.
 1638  *
 1639  * @note hSpeedPtr, hSpeedAccuracyPtr can be set to NULL if not needed.
 1640  *
 1641  * @note Horizontal speed is in meters/second with 2 decimal places (3047 = 30.47 meters/second).
 1642  *
 1643  * @note Horizontal speed accuracy estimate is default set to meters/second with 1 decimal place
 1644  *       (304 = 30.4 meters/second). To change its accuracy, call the @c le_gnss_SetDataResolution()
 1645  *       function. Horizontal speed accuracy estimate is set as data type and accuracy from 0 to 3
 1646  *       decimal place is set as resolution.
 1647  *
 1648  * @note In case the function returns LE_OUT_OF_RANGE, some of the retrieved parameters may be
 1649  *       valid. Please compare them with UINT32_MAX.
 1650  *
 1651  * @note If the caller is passing an invalid Position sample reference into this function,
 1652  *       it is a fatal error, the function will not return.
 1653  *
 1654  * @warning The Horizontal speed accuracy is platform dependent. Please refer to
 1655  *          @ref platformConstraintsGnss_speedAccuracies section for full details.
 1656  */
 1657 //--------------------------------------------------------------------------------------------------
 1658 le_result_t le_gnss_GetHorizontalSpeed
 1659 (
 1660     le_gnss_SampleRef_t positionSampleRef,
 1661         ///< [IN] Position sample's reference.
 1662     uint32_t* hspeedPtr,
 1663         ///< [OUT] Horizontal speed in meters/second [resolution 1e-2].
 1664     uint32_t* hspeedAccuracyPtr
 1665         ///< [OUT] Horizontal speed's accuracy estimate in meters/second.
 1666 );
 1667 
 1668 //--------------------------------------------------------------------------------------------------
 1669 /**
 1670  * Get the position sample's vertical speed.
 1671  *
 1672  * @return
 1673  *  - LE_FAULT         The function failed to find the positionSample.
 1674  *  - LE_OUT_OF_RANGE  At least one of the retrieved parameters is not valid (set to INT32_MAX).
 1675  *  - LE_OK            The function succeeded.
 1676  *
 1677  * @note vSpeedPtr, vSpeedAccuracyPtr can be set to NULL if not needed.
 1678  *
 1679  * @note For a 2D position Fix, the vertical speed will be indicated as invalid
 1680  * and set to INT32_MAX.
 1681  *
 1682  * @note Vertical speed accuracy estimate is default set to meters/second with 1 decimal place
 1683  *       (304 = 30.4 meters/second). To change its accuracy, call the @c le_gnss_SetDataResolution()
 1684  *       function. Vertical speed accuracy estimate is set as data type and accuracy from 0 to 3
 1685  *       decimal place is set as resolution.
 1686  *
 1687  * @note In case the function returns LE_OUT_OF_RANGE, some of the retrieved parameters may be
 1688  *       valid. Please compare them with INT32_MAX.
 1689  *
 1690  * @note If the caller is passing an invalid Position sample reference into this function,
 1691  *       it is a fatal error, the function will not return.
 1692  *
 1693  * @warning The Vertical speed accuracy is platform dependent. Please refer to
 1694  *          @ref platformConstraintsGnss_speedAccuracies section for full details.
 1695  */
 1696 //--------------------------------------------------------------------------------------------------
 1697 le_result_t le_gnss_GetVerticalSpeed
 1698 (
 1699     le_gnss_SampleRef_t positionSampleRef,
 1700         ///< [IN] Position sample's reference.
 1701     int32_t* vspeedPtr,
 1702         ///< [OUT] Vertical speed in meters/second [resolution 1e-2],
 1703         ///< positive up.
 1704     int32_t* vspeedAccuracyPtr
 1705         ///< [OUT] Vertical speed's accuracy estimate in meters/second.
 1706 );
 1707 
 1708 //--------------------------------------------------------------------------------------------------
 1709 /**
 1710  * Get the position sample's direction. Direction of movement is the direction that the vehicle or
 1711  * person is actually moving.
 1712  *
 1713  * @return
 1714  *  - LE_FAULT         Function failed to find the positionSample.
 1715  *  - LE_OUT_OF_RANGE  At least one of the retrieved parameters is invalid (set to UINT32_MAX).
 1716  *  - LE_OK            Function succeeded.
 1717  *
 1718  * @note Direction and direction accuracy are given in degrees with 1 decimal place: 1755 = 175.5
 1719  *       degrees.
 1720  *       Direction ranges from 0 to 359.9 degrees, where 0 is True North.
 1721  *
 1722  * @note In case the function returns LE_OUT_OF_RANGE, some of the retrieved parameters may be
 1723  *       valid. Please compare them with UINT32_MAX.
 1724  *
 1725  * @note directionPtr, directionAccuracyPtr can be set to NULL if not needed.
 1726  *
 1727  * @note If the caller is passing an invalid Position sample reference into this function,
 1728  *       it is a fatal error, the function will not return.
 1729  */
 1730 //--------------------------------------------------------------------------------------------------
 1731 le_result_t le_gnss_GetDirection
 1732 (
 1733     le_gnss_SampleRef_t positionSampleRef,
 1734         ///< [IN] Position sample's reference.
 1735     uint32_t* directionPtr,
 1736         ///< [OUT] Direction in degrees [resolution 1e-1].
 1737         ///< Range: 0 to 359.9, where 0 is True North
 1738     uint32_t* directionAccuracyPtr
 1739         ///< [OUT] Direction's accuracy estimate
 1740         ///< in degrees [resolution 1e-1].
 1741 );
 1742 
 1743 //--------------------------------------------------------------------------------------------------
 1744 /**
 1745  * Get the Satellites Vehicle information.
 1746  *
 1747  * @return
 1748  *  - LE_FAULT         Function failed to find the positionSample.
 1749  *  - LE_OUT_OF_RANGE  At least one of the retrieved parameters is invalid.
 1750  *  - LE_OK            Function succeeded.
 1751  *
 1752  * @note satId[] can be set to 0 if that information list index is not configured, so
 1753  * all satellite parameters (satConst[], satSnr[],satAzim[], satElev[]) are fixed to 0.
 1754  *
 1755  * @note For LE_OUT_OF_RANGE returned code, invalid value depends on field type:
 1756  * UINT16_MAX for satId, LE_GNSS_SV_CONSTELLATION_UNDEFINED for satConst, false for satUsed,
 1757  * UINT8_MAX for satSnr, UINT16_MAX for satAzim, UINT8_MAX for satElev.
 1758  *
 1759  * @note In case the function returns LE_OUT_OF_RANGE, some of the retrieved parameters may be
 1760  *       valid.
 1761  *
 1762  * @note If the caller is passing an invalid Position sample reference into this function,
 1763  *       it is a fatal error, the function will not return.
 1764  */
 1765 //--------------------------------------------------------------------------------------------------
 1766 le_result_t le_gnss_GetSatellitesInfo
 1767 (
 1768     le_gnss_SampleRef_t positionSampleRef,
 1769         ///< [IN] Position sample's reference.
 1770     uint16_t* satIdPtr,
 1771         ///< [OUT] Satellites in View ID number, referring
 1772         ///< to NMEA standard.
 1773     size_t* satIdSizePtr,
 1774         ///< [INOUT]
 1775     le_gnss_Constellation_t* satConstPtr,
 1776         ///< [OUT] GNSS constellation type.
 1777     size_t* satConstSizePtr,
 1778         ///< [INOUT]
 1779     bool* satUsedPtr,
 1780         ///< [OUT] TRUE if satellite in View Used
 1781         ///< for Navigation.
 1782     size_t* satUsedSizePtr,
 1783         ///< [INOUT]
 1784     uint8_t* satSnrPtr,
 1785         ///< [OUT] Satellites in View Signal To
 1786         ///< Noise Ratio (C/No) [dBHz].
 1787     size_t* satSnrSizePtr,
 1788         ///< [INOUT]
 1789     uint16_t* satAzimPtr,
 1790         ///< [OUT] Satellites in View Azimuth [degrees].
 1791         ///< Range: 0 to 360
 1792         ///< If Azimuth angle is currently unknown,
 1793         ///< the value is set to UINT16_MAX.
 1794     size_t* satAzimSizePtr,
 1795         ///< [INOUT]
 1796     uint8_t* satElevPtr,
 1797         ///< [OUT] Satellites in View Elevation [degrees].
 1798         ///< Range: 0 to 90
 1799         ///< If Elevation angle is currently unknown,
 1800         ///< the value is set to UINT8_MAX.
 1801     size_t* satElevSizePtr
 1802         ///< [INOUT]
 1803 );
 1804 
 1805 //--------------------------------------------------------------------------------------------------
 1806 /**
 1807  * Get the SBAS constellation category given the SBAS satellite number ID.
 1808  *
 1809  */
 1810 //--------------------------------------------------------------------------------------------------
 1811 le_gnss_SbasConstellationCategory_t le_gnss_GetSbasConstellationCategory
 1812 (
 1813     uint16_t satId
 1814         ///< [IN] SBAS satellite number ID, referring to NMEA standard.
 1815 );
 1816 
 1817 //--------------------------------------------------------------------------------------------------
 1818 /**
 1819  * Get the Satellites Vehicle status.
 1820  *
 1821  * @return
 1822  *  - LE_FAULT         Function failed to find the positionSample.
 1823  *  - LE_OUT_OF_RANGE  At least one of the retrieved parameters is invalid (set to UINT8_MAX).
 1824  *  - LE_OK            Function succeeded.
 1825  *
 1826  * @note In case the function returns LE_OUT_OF_RANGE, some of the retrieved parameters may be
 1827  *       valid. Please compare them with UINT8_MAX.
 1828  *
 1829  * @note If the caller is passing an invalid Position sample reference into this function,
 1830  *       it is a fatal error, the function will not return.
 1831  */
 1832 //--------------------------------------------------------------------------------------------------
 1833 le_result_t le_gnss_GetSatellitesStatus
 1834 (
 1835     le_gnss_SampleRef_t positionSampleRef,
 1836         ///< [IN] Position sample's reference.
 1837     uint8_t* satsInViewCountPtr,
 1838         ///< [OUT] Number of satellites expected to be in view.
 1839     uint8_t* satsTrackingCountPtr,
 1840         ///< [OUT] Number of satellites in view, when tracking.
 1841     uint8_t* satsUsedCountPtr
 1842         ///< [OUT] Number of satellites in view used for Navigation.
 1843 );
 1844 
 1845 //--------------------------------------------------------------------------------------------------
 1846 /**
 1847  * Get the DOP parameters (Dilution Of Precision) for the fixed position
 1848  *
 1849  * @return
 1850  *  - LE_FAULT         Function failed to find the positionSample.
 1851  *  - LE_OUT_OF_RANGE  At least one of the retrieved parameters is invalid (set to UINT16_MAX).
 1852  *  - LE_OK            Function succeeded.
 1853  *
 1854  * @deprecated This function is deprecated, le_gnss_GetDilutionOfPrecision() should be used for
 1855  *             new code.
 1856  *
 1857  * @note The DOP values are given with 3 decimal places like: DOP value 2200 = 2.200
 1858  *
 1859  * @note In case the function returns LE_OUT_OF_RANGE, some of the retrieved parameters may be
 1860  *       valid. Please compare them with UINT16_MAX.
 1861  *
 1862  * @note If the caller is passing an invalid Position sample reference into this function,
 1863  *       it is a fatal error, the function will not return.
 1864  */
 1865 //--------------------------------------------------------------------------------------------------
 1866 le_result_t le_gnss_GetDop
 1867 (
 1868     le_gnss_SampleRef_t positionSampleRef,
 1869         ///< [IN] Position sample's reference.
 1870     uint16_t* hdopPtr,
 1871         ///< [OUT] Horizontal Dilution of Precision [resolution 1e-3].
 1872     uint16_t* vdopPtr,
 1873         ///< [OUT] Vertical Dilution of Precision [resolution 1e-3].
 1874     uint16_t* pdopPtr
 1875         ///< [OUT] Position Dilution of Precision [resolution 1e-3].
 1876 );
 1877 
 1878 //--------------------------------------------------------------------------------------------------
 1879 /**
 1880  * Get the DOP parameter (Dilution Of Precision) for the fixed position.
 1881  *
 1882  * @return
 1883  *  - LE_FAULT         Function failed to find the DOP value.
 1884  *  - LE_OUT_OF_RANGE  The retrieved parameter is invalid (set to UINT16_MAX).
 1885  *  - LE_OK            Function succeeded.
 1886  *
 1887  * @note This function replaces the deprecated function le_gnss_GetDop().
 1888  *
 1889  * @note The DOP value is given with 3 decimal places by default like: DOP value 2200 = 2.200
 1890  *       The resolution can be modified by calling the @c le_gnss_SetDopResolution() function.
 1891  *
 1892  * @note If the caller is passing an invalid Position sample reference into this function,
 1893  *       it is a fatal error, the function will not return.
 1894  */
 1895 //--------------------------------------------------------------------------------------------------
 1896 le_result_t le_gnss_GetDilutionOfPrecision
 1897 (
 1898     le_gnss_SampleRef_t positionSampleRef,
 1899         ///< [IN] Position sample's reference.
 1900     le_gnss_DopType_t dopType,
 1901         ///< [IN] Dilution of Precision type.
 1902     uint16_t* dopPtr
 1903         ///< [OUT] Dilution of Precision corresponding to the dopType
 1904 );
 1905 
 1906 //--------------------------------------------------------------------------------------------------
 1907 /**
 1908  * Get the position sample's altitude with respect to the WGS-84 ellipsoid
 1909  *
 1910  * @return
 1911  *  - LE_FAULT         Function failed to get the altitude.
 1912  *  - LE_OUT_OF_RANGE  The altitudeOnWgs84 is invalid (set to INT32_MAX).
 1913  *  - LE_OK            Function succeeded.
 1914  *
 1915  * @note altitudeOnWgs84 is in meters, with respect to the WGS-84 ellipsoid with 3 decimal
 1916  *       places (3047 = 3.047 meters).
 1917  *
 1918  * @note For a 2D position fix, the altitude with respect to the WGS-84 ellipsoid will be indicated
 1919  *       as invalid and set to INT32_MAX.
 1920  *
 1921  * @note If the caller is passing an invalid Position reference or a null pointer into this
 1922  *       function, it is a fatal error, the function will not return.
 1923  */
 1924 //--------------------------------------------------------------------------------------------------
 1925 le_result_t le_gnss_GetAltitudeOnWgs84
 1926 (
 1927     le_gnss_SampleRef_t positionSampleRef,
 1928         ///< [IN] Position sample's reference.
 1929     int32_t* altitudeOnWgs84Ptr
 1930         ///< [OUT] Altitude in meters, between WGS-84 earth ellipsoid
 1931         ///< and mean sea level [resolution 1e-3].
 1932 );
 1933 
 1934 //--------------------------------------------------------------------------------------------------
 1935 /**
 1936  * Get the position sample's magnetic deviation. It is the difference between the bearing to
 1937  * true north and the bearing shown on a magnetic compass. The deviation is positive when the
 1938  * magnetic north is east of true north.
 1939  *
 1940  * @return
 1941  *  - LE_FAULT         Function failed to find the positionSample.
 1942  *  - LE_OUT_OF_RANGE  The magneticDeviation is invalid (set to INT32_MAX).
 1943  *  - LE_OK            Function succeeded.
 1944  *
 1945  * @note magneticDeviation is in degrees, with 1 decimal places (47 = 4.7 degree).
 1946  *
 1947  * @note If the caller is passing an invalid Position sample reference into this function,
 1948  *       it is a fatal error, the function will not return.
 1949  */
 1950 //--------------------------------------------------------------------------------------------------
 1951 le_result_t le_gnss_GetMagneticDeviation
 1952 (
 1953     le_gnss_SampleRef_t positionSampleRef,
 1954         ///< [IN] Position sample's reference.
 1955     int32_t* magneticDeviationPtr
 1956         ///< [OUT] MagneticDeviation in degrees [resolution 1e-1].
 1957 );
 1958 
 1959 //--------------------------------------------------------------------------------------------------
 1960 /**
 1961  * This function gets the last updated position sample object reference.
 1962  *
 1963  * @return A reference to last Position's sample.
 1964  *
 1965  * @note
 1966  *      On failure, the process exits, so you don't have to worry about checking the returned
 1967  *      reference for validity.
 1968  */
 1969 //--------------------------------------------------------------------------------------------------
 1970 le_gnss_SampleRef_t le_gnss_GetLastSampleRef
 1971 (
 1972     void
 1973 );
 1974 
 1975 //--------------------------------------------------------------------------------------------------
 1976 /**
 1977  * This function must be called to release the position sample.
 1978  *
 1979  * @note If the caller is passing an invalid Position sample reference into this function,
 1980  *       it is a fatal error, the function will not return.
 1981  */
 1982 //--------------------------------------------------------------------------------------------------
 1983 void le_gnss_ReleaseSampleRef
 1984 (
 1985     le_gnss_SampleRef_t positionSampleRef
 1986         ///< [IN] Position sample's reference.
 1987 );
 1988 
 1989 //--------------------------------------------------------------------------------------------------
 1990 /**
 1991  * This function sets the SUPL Assisted-GNSS mode.
 1992  *
 1993  * @return
 1994  *  - LE_OK on success
 1995  *  - LE_FAULT on failure
 1996  *  - LE_UNSUPPORTED request not supported
 1997  *  - LE_TIMEOUT a time-out occurred
 1998  *
 1999  * @warning The settings are platform dependent. Please refer to
 2000  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 2001  */
 2002 //--------------------------------------------------------------------------------------------------
 2003 le_result_t le_gnss_SetSuplAssistedMode
 2004 (
 2005     le_gnss_AssistedMode_t assistedMode
 2006         ///< [IN] Assisted-GNSS mode.
 2007 );
 2008 
 2009 //--------------------------------------------------------------------------------------------------
 2010 /**
 2011  * This function gets the SUPL Assisted-GNSS mode.
 2012  *
 2013  * @return
 2014  *  - LE_OK on success
 2015  *  - LE_FAULT on failure
 2016  *
 2017  * @note If the caller is passing a null pointer into this function, it is a fatal error, the
 2018  *       function will not return.
 2019  */
 2020 //--------------------------------------------------------------------------------------------------
 2021 le_result_t le_gnss_GetSuplAssistedMode
 2022 (
 2023     le_gnss_AssistedMode_t* assistedModePtr
 2024         ///< [OUT] Assisted-GNSS mode.
 2025 );
 2026 
 2027 //--------------------------------------------------------------------------------------------------
 2028 /**
 2029  * This function sets the SUPL server URL.
 2030  * That server URL is a NULL-terminated string with a maximum string length (including NULL
 2031  * terminator) equal to 256. Optionally the port number is specified after a colon.
 2032  *
 2033  * @return
 2034  *  - LE_OK on success
 2035  *  - LE_FAULT on failure
 2036  *  - LE_BUSY service is busy
 2037  *  - LE_TIMEOUT a time-out occurred
 2038  *
 2039  * @note If the SUPL server URL size is bigger than the maximum string length (including NULL
 2040  * terminator) size, it is a fatal error, the function will not return.
 2041  *
 2042  * @warning The settings are platform dependent. Please refer to
 2043  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 2044  */
 2045 //--------------------------------------------------------------------------------------------------
 2046 le_result_t le_gnss_SetSuplServerUrl
 2047 (
 2048     const char* LE_NONNULL suplServerUrl
 2049         ///< [IN] SUPL server URL.
 2050 );
 2051 
 2052 //--------------------------------------------------------------------------------------------------
 2053 /**
 2054  * This function injects the SUPL certificate to be used in A-GNSS sessions. Certificates must
 2055  * be encoded in DER. Other certificate encryptions (e.g., PEM, CER and CRT)
 2056  * aren't supported.
 2057  *
 2058  * @return
 2059  *  - LE_OK on success
 2060  *  - LE_BAD_PARAMETER on invalid parameter
 2061  *  - LE_FAULT on failure
 2062  *  - LE_BUSY service is busy
 2063  *  - LE_TIMEOUT a time-out occurred
 2064  *
 2065  * @note If the SUPL certificate size is bigger than the Maximum SUPL certificate size,
 2066  * it is a fatal error, the function will not return.
 2067  */
 2068 //--------------------------------------------------------------------------------------------------
 2069 le_result_t le_gnss_InjectSuplCertificate
 2070 (
 2071     uint8_t suplCertificateId,
 2072         ///< [IN] ID of the SUPL certificate.
 2073         ///< Certificate ID range is 0 to 9
 2074     uint16_t suplCertificateLen,
 2075         ///< [IN] SUPL certificate size in Bytes.
 2076     const char* LE_NONNULL suplCertificate
 2077         ///< [IN] SUPL certificate contents.
 2078 );
 2079 
 2080 //--------------------------------------------------------------------------------------------------
 2081 /**
 2082  * This function deletes the SUPL certificate.
 2083  *
 2084  * @return
 2085  *  - LE_OK on success
 2086  *  - LE_BAD_PARAMETER on invalid parameter
 2087  *  - LE_FAULT on failure
 2088  *  - LE_BUSY service is busy
 2089  *  - LE_TIMEOUT a time-out occurred
 2090  */
 2091 //--------------------------------------------------------------------------------------------------
 2092 le_result_t le_gnss_DeleteSuplCertificate
 2093 (
 2094     uint8_t suplCertificateId
 2095         ///< [IN] ID of the SUPL certificate.
 2096         ///< Certificate ID range is 0 to 9
 2097 );
 2098 
 2099 //--------------------------------------------------------------------------------------------------
 2100 /**
 2101  * This function sets the enabled NMEA sentences using a bit mask.
 2102  *
 2103  * @return
 2104  *  - LE_OK             Success
 2105  *  - LE_BAD_PARAMETER  Bit mask exceeds the maximal value
 2106  *  - LE_FAULT          Failure
 2107  *  - LE_BUSY           Service is busy
 2108  *  - LE_TIMEOUT        Timeout occurred
 2109  *  - LE_NOT_PERMITTED  GNSS device is not in "ready" state
 2110  *
 2111  * @warning This function may be subject to limitations depending on the platform. Please refer to
 2112  *          the @ref platformConstraintsGnss page.
 2113  *
 2114  * @note Some NMEA sentences are unsupported depending on the plateform. Please refer to
 2115  *       @ref platformConstraintsGnss_nmeaMask section for full details. Setting an unsuported NMEA
 2116  *       sentence won't report an error.
 2117  *
 2118  * @warning The settings are platform dependent. Please refer to
 2119  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 2120  *
 2121  * @deprecated LE_GNSS_NMEA_MASK_PQXFI is deprecated. LE_GNSS_NMEA_MASK_PTYPE should be used
 2122  *             instead. Setting LE_GNSS_NMEA_MASK_PTYPE will also set LE_GNSS_NMEA_MASK_PQXFI.
 2123  */
 2124 //--------------------------------------------------------------------------------------------------
 2125 le_result_t le_gnss_SetNmeaSentences
 2126 (
 2127     le_gnss_NmeaBitMask_t nmeaMask
 2128         ///< [IN] Bit mask for enabled NMEA sentences.
 2129 );
 2130 
 2131 //--------------------------------------------------------------------------------------------------
 2132 /**
 2133  * This function gets the bit mask for the enabled NMEA sentences.
 2134  *
 2135  * @return
 2136  *  - LE_OK             Success
 2137  *  - LE_FAULT          Failure
 2138  *  - LE_BUSY           Service is busy
 2139  *  - LE_TIMEOUT        Timeout occurred
 2140  *  - LE_NOT_PERMITTED  GNSS device is not in "ready" state
 2141  *
 2142  * @note If the caller is passing a null pointer to this function, it is a fatal error, the
 2143  *       function will not return.
 2144  *
 2145  * @note Some NMEA sentences are unsupported depending on the plateform. Please refer to
 2146  *       @ref platformConstraintsGnss_nmeaMask section for full details. The bit mask for an unset
 2147  *       or unsupported NMEA sentence is zero.
 2148  */
 2149 //--------------------------------------------------------------------------------------------------
 2150 le_result_t le_gnss_GetNmeaSentences
 2151 (
 2152     le_gnss_NmeaBitMask_t* nmeaMaskPtrPtr
 2153         ///< [OUT] Bit mask for enabled NMEA sentences.
 2154 );
 2155 
 2156 //--------------------------------------------------------------------------------------------------
 2157 /**
 2158  * This function returns the status of the GNSS device.
 2159  *
 2160  */
 2161 //--------------------------------------------------------------------------------------------------
 2162 le_gnss_State_t le_gnss_GetState
 2163 (
 2164     void
 2165 );
 2166 
 2167 //--------------------------------------------------------------------------------------------------
 2168 /**
 2169  * This function sets the GNSS minimum elevation.
 2170  *
 2171  * @return
 2172  *  - LE_OK on success
 2173  *  - LE_FAULT on failure
 2174  *  - LE_OUT_OF_RANGE if the minimum elevation is above range
 2175  *  - LE_UNSUPPORTED request not supported
 2176  *
 2177  * @warning The settings are platform dependent. Please refer to
 2178  *          @ref platformConstraintsGnss_SettingConfiguration section for full details.
 2179  */
 2180 //--------------------------------------------------------------------------------------------------
 2181 le_result_t le_gnss_SetMinElevation
 2182 (
 2183     uint8_t minElevation
 2184         ///< [IN] Minimum elevation in degrees [range 0..90].
 2185 );
 2186 
 2187 //--------------------------------------------------------------------------------------------------
 2188 /**
 2189  * This function gets the GNSS minimum elevation.
 2190  *
 2191  * @return
 2192  *  - LE_OK on success
 2193  *  - LE_FAULT on failure
 2194  *  - LE_UNSUPPORTED request not supported
 2195  *
 2196  * @note If the caller is passing n null pointer to this function, it is a fatal error, the
 2197  *       function will not return.
 2198  */
 2199 //--------------------------------------------------------------------------------------------------
 2200 le_result_t le_gnss_GetMinElevation
 2201 (
 2202     uint8_t* minElevationPtrPtr
 2203         ///< [OUT] Minimum elevation in degrees [range 0..90].
 2204 );
 2205 
 2206 //--------------------------------------------------------------------------------------------------
 2207 /**
 2208  * Set the resolution for the DOP parameters
 2209  *
 2210  * @return LE_OK               Function succeeded.
 2211  * @return LE_BAD_PARAMETER    Invalid parameter provided.
 2212  * @return LE_FAULT            Function failed.
 2213  *
 2214  * @note The function sets the same resolution to all DOP values returned by
 2215  *       le_gnss_GetDilutionOfPrecision() API. The resolution setting takes effect immediately.
 2216  *
 2217  * @note The resolution setting is done per client session.
 2218  */
 2219 //--------------------------------------------------------------------------------------------------
 2220 le_result_t le_gnss_SetDopResolution
 2221 (
 2222     le_gnss_Resolution_t resolution
 2223         ///< [IN] Resolution.
 2224 );
 2225 
 2226 //--------------------------------------------------------------------------------------------------
 2227 /**
 2228  * Set the resolution for the specific type of data
 2229  *
 2230  * @return LE_OK               Function succeeded.
 2231  * @return LE_BAD_PARAMETER    Invalid parameter provided.
 2232  * @return LE_FAULT            Function failed.
 2233  *
 2234  * @note The resolution setting takes effect immediately and is not persistent to reset.
 2235  *
 2236  * @note The resolution setting is done per client session.
 2237  */
 2238 //--------------------------------------------------------------------------------------------------
 2239 le_result_t le_gnss_SetDataResolution
 2240 (
 2241     le_gnss_DataType_t dataType,
 2242         ///< [IN] Data type.
 2243     le_gnss_Resolution_t resolution
 2244         ///< [IN] Resolution.
 2245 );
 2246 
 2247 //--------------------------------------------------------------------------------------------------
 2248 /**
 2249  * This function converts a location data parameter from/to multi-coordinate system
 2250  *
 2251  * @return
 2252  *  - LE_OK on success
 2253  *  - LE_FAULT on failure
 2254  *  - LE_BAD_PARAMETER Invalid parameter provided.
 2255  *  - LE_UNSUPPORTED request not supported
 2256  *
 2257  * @note The resolution of location data parameter remains unchanged after the conversion.
 2258  */
 2259 //--------------------------------------------------------------------------------------------------
 2260 le_result_t le_gnss_ConvertDataCoordinateSystem
 2261 (
 2262     le_gnss_CoordinateSystem_t coordinateSrc,
 2263         ///< [IN] Coordinate system to convert from.
 2264     le_gnss_CoordinateSystem_t coordinateDst,
 2265         ///< [IN] Coordinate system to convert to.
 2266     le_gnss_LocationDataType_t locationDataType,
 2267         ///< [IN] Type of location data to convert.
 2268     int64_t locationDataSrc,
 2269         ///< [IN] Data to convert.
 2270     int64_t* locationDataDstPtr
 2271         ///< [OUT] Converted Data.
 2272 );
 2273 
 2274 #endif // LE_GNSS_INTERFACE_H_INCLUDE_GUARD
LE_GNSS_POS_LONGITUDE
Longitude data position. 
Definition: le_gnss_interface.h:947
LE_GNSS_SBAS_EGNOS
Definition: le_gnss_interface.h:748
le_gnss_AssistedMode_t
le_gnss_AssistedMode_t
Definition: le_gnss_interface.h:808
le_gnss_GetDirection
le_result_t le_gnss_GetDirection(le_gnss_SampleRef_t positionSampleRef, uint32_t *directionPtr, uint32_t *directionAccuracyPtr)
le_gnss_DopType_t
le_gnss_DopType_t
Definition: le_gnss_interface.h:825
LE_GNSS_COORDINATE_SYSTEM_WGS84
Coordinate system WGS84. 
Definition: le_gnss_interface.h:928
le_gnss_GetAltitude
le_result_t le_gnss_GetAltitude(le_gnss_SampleRef_t positionSampleRef, int32_t *altitudePtr, int32_t *vAccuracyPtr)
LE_GNSS_STATE_UNINITIALIZED
The GNSS device is not initialized. 
Definition: le_gnss_interface.h:668
le_gnss_GetSbasConstellationCategory
le_gnss_SbasConstellationCategory_t le_gnss_GetSbasConstellationCategory(uint16_t satId)
le_gnss_InjectSuplCertificate
le_result_t le_gnss_InjectSuplCertificate(uint8_t suplCertificateId, uint16_t suplCertificateLen, const char *LE_NONNULL suplCertificate)
LE_GNSS_STATE_MAX
Do not use. 
Definition: le_gnss_interface.h:676
le_gnss_GetSatellitesInfo
le_result_t le_gnss_GetSatellitesInfo(le_gnss_SampleRef_t positionSampleRef, uint16_t *satIdPtr, size_t *satIdSizePtr, le_gnss_Constellation_t *satConstPtr, size_t *satConstSizePtr, bool *satUsedPtr, size_t *satUsedSizePtr, uint8_t *satSnrPtr, size_t *satSnrSizePtr, uint16_t *satAzimPtr, size_t *satAzimSizePtr, uint8_t *satElevPtr, size_t *satElevSizePtr)
LE_GNSS_RES_THREE_DECIMAL
Resolution of 3 decimal places. 
Definition: le_gnss_interface.h:714
le_gnss_LocationDataType_t
le_gnss_LocationDataType_t
Definition: le_gnss_interface.h:943
LE_GNSS_SV_CONSTELLATION_GALILEO
Definition: le_gnss_interface.h:788
le_gnss_GetExtendedEphemerisValidity
le_result_t le_gnss_GetExtendedEphemerisValidity(uint64_t *startTimePtr, uint64_t *stopTimePtr)
LE_GNSS_NMEA_MASK_GNGSA
GNGSA type enabled: GNSS DOP and active satellites. 
Definition: le_gnss_interface.h:903
le_result_t
le_result_t
Definition: le_basics.h:35
LE_GNSS_VDOP
Vertical dilution of precision. 
Definition: le_gnss_interface.h:831
le_gnss_Start
le_result_t le_gnss_Start(void)
LE_GNSS_STANDALONE_MODE
Standalone mode. 
Definition: le_gnss_interface.h:810
le_gnss_AddPositionHandler
le_gnss_PositionHandlerRef_t le_gnss_AddPositionHandler(le_gnss_PositionHandlerFunc_t handlerPtr, void *contextPtr)
LE_GNSS_CONSTELLATION_GLONASS
Russian satellite navigation system. 
Definition: le_gnss_interface.h:871
le_gnss_GetEpochTime
le_result_t le_gnss_GetEpochTime(le_gnss_SampleRef_t positionSampleRef, uint64_t *millisecondsPtr)
le_gnss_ForceFactoryRestart
le_result_t le_gnss_ForceFactoryRestart(void)
le_gnss_SampleRef_t
struct le_gnss_Sample * le_gnss_SampleRef_t
Definition: le_gnss_interface.h:658
le_gnss_LoadExtendedEphemerisFile
le_result_t le_gnss_LoadExtendedEphemerisFile(int fd)
LE_GNSS_NMEA_MASK_PSTIS
PSTIS type enabled: GPS session start indication. 
Definition: le_gnss_interface.h:909
le_gnss_GetAcquisitionRate
le_result_t le_gnss_GetAcquisitionRate(uint32_t *ratePtr)
le_gnss_DisconnectService
void le_gnss_DisconnectService(void)
LE_GNSS_SBAS_MSAS
Definition: le_gnss_interface.h:757
LE_GNSS_DATA_HSPEEDACCURACY
Horizontal speed accuracy data. 
Definition: le_gnss_interface.h:733
LE_GNSS_NMEA_MASK_GAGNS
GAGNS type enabled: Fix data for Galileo. 
Definition: le_gnss_interface.h:916
LE_GNSS_SV_CONSTELLATION_GPS
Definition: le_gnss_interface.h:779
LE_GNSS_NMEA_MASK_PTYPE
PTYPE type enabled: Proprietary Type mask. 
Definition: le_gnss_interface.h:911
LE_GNSS_SV_CONSTELLATION_BEIDOU
Definition: le_gnss_interface.h:791
LE_GNSS_CONSTELLATION_BEIDOU
Chinese satellite navigation system. 
Definition: le_gnss_interface.h:873
LE_GNSS_RES_TWO_DECIMAL
Resolution of 2 decimal places. 
Definition: le_gnss_interface.h:712
LE_GNSS_NMEA_MASK_GNGNS
GNGNS type enabled: GNSS fix data. 
Definition: le_gnss_interface.h:902
LE_GNSS_PDOP
Position dilution of precision. 
Definition: le_gnss_interface.h:827
LE_GNSS_NMEA_MASK_GAGGA
GAGGA type enabled: Galileo fix data. 
Definition: le_gnss_interface.h:904
le_gnss_ForceColdRestart
le_result_t le_gnss_ForceColdRestart(void)
LE_GNSS_RES_UNKNOWN
Unknown resolution. 
Definition: le_gnss_interface.h:716
LE_GNSS_NMEA_MASK_GAGSA
GAGSA type enabled: Galileo DOP and active satellites. 
Definition: le_gnss_interface.h:905
LE_GNSS_STATE_FIX_ESTIMATED
Estimated (i.e. forward predicted) position fix. 
Definition: le_gnss_interface.h:695
le_gnss_ForceWarmRestart
le_result_t le_gnss_ForceWarmRestart(void)
le_gnss_State_t
le_gnss_State_t
Definition: le_gnss_interface.h:666
le_gnss_InjectUtcTime
le_result_t le_gnss_InjectUtcTime(uint64_t timeUtc, uint32_t timeUnc)
LE_GNSS_NMEA_MASK_GPGSV
GPGSV type enabled: GPS satellites in view. 
Definition: le_gnss_interface.h:898
le_gnss_SetDataResolution
le_result_t le_gnss_SetDataResolution(le_gnss_DataType_t dataType, le_gnss_Resolution_t resolution)
LE_GNSS_NMEA_MASK_GPGRS
GPGRS type enabled: GPS Range residuals. 
Definition: le_gnss_interface.h:912
LE_GNSS_OUTSIDE_US_AREA
Outside US area. 
Definition: le_gnss_interface.h:854
LE_GNSS_POS_LATITUDE
Latitude data position. 
Definition: le_gnss_interface.h:945
LE_GNSS_SBAS_SDCM
Definition: le_gnss_interface.h:760
LE_GNSS_SV_CONSTELLATION_GLONASS
Definition: le_gnss_interface.h:785
LE_GNSS_CONSTELLATION_QZSS
Japanese satellite navigation system. 
Definition: le_gnss_interface.h:878
le_gnss_SetConstellationArea
le_result_t le_gnss_SetConstellationArea(le_gnss_Constellation_t satConstellation, le_gnss_ConstellationArea_t constellationArea)
le_gnss_GetTtff
le_result_t le_gnss_GetTtff(uint32_t *ttffPtr)
le_gnss_GetConstellation
le_result_t le_gnss_GetConstellation(le_gnss_ConstellationBitMask_t *constellationMaskPtr)
LE_GNSS_RES_ZERO_DECIMAL
Resolution of 0 decimal place. 
Definition: le_gnss_interface.h:708
LE_GNSS_POS_ALTITUDE
Altitude data position. 
Definition: le_gnss_interface.h:949
LE_GNSS_STATE_ACTIVE
The GNSS device is active. 
Definition: le_gnss_interface.h:672
le_gnss_RemovePositionHandler
void le_gnss_RemovePositionHandler(le_gnss_PositionHandlerRef_t handlerRef)
le_gnss_SetSuplServerUrl
le_result_t le_gnss_SetSuplServerUrl(const char *LE_NONNULL suplServerUrl)
LE_GNSS_SV_CONSTELLATION_MAX
Maximum value. 
Definition: le_gnss_interface.h:797
LE_GNSS_COORDINATE_SYSTEM_PZ90
Coordinate system PZ90. 
Definition: le_gnss_interface.h:930
le_gnss_EnableExtendedEphemerisFile
le_result_t le_gnss_EnableExtendedEphemerisFile(void)
LE_GNSS_UNSET_AREA
Unset area. 
Definition: le_gnss_interface.h:850
LE_GNSS_STATE_FIX_3D
3-Dimensional position fix. 
Definition: le_gnss_interface.h:693
le_gnss_GetAltitudeOnWgs84
le_result_t le_gnss_GetAltitudeOnWgs84(le_gnss_SampleRef_t positionSampleRef, int32_t *altitudeOnWgs84Ptr)
le_gnss_GetTime
le_result_t le_gnss_GetTime(le_gnss_SampleRef_t positionSampleRef, uint16_t *hoursPtr, uint16_t *minutesPtr, uint16_t *secondsPtr, uint16_t *millisecondsPtr)
le_gnss_GetSuplAssistedMode
le_result_t le_gnss_GetSuplAssistedMode(le_gnss_AssistedMode_t *assistedModePtr)
le_gnss_GetLocation
le_result_t le_gnss_GetLocation(le_gnss_SampleRef_t positionSampleRef, int32_t *latitudePtr, int32_t *longitudePtr, int32_t *hAccuracyPtr)
le_gnss_DisableExtendedEphemerisFile
le_result_t le_gnss_DisableExtendedEphemerisFile(void)
LE_GNSS_TDOP
Time dilution of precision. 
Definition: le_gnss_interface.h:835
LE_GNSS_NMEA_MASK_GAVTG
GAVTG type enabled: Galileo vector track and speed over the ground. 
Definition: le_gnss_interface.h:908
le_gnss_TryConnectService
le_result_t le_gnss_TryConnectService(void)
le_gnss_SetAcquisitionRate
le_result_t le_gnss_SetAcquisitionRate(uint32_t rate)
le_gnss_SetMinElevation
le_result_t le_gnss_SetMinElevation(uint8_t minElevation)
LE_GNSS_SBAS_WAAS
Definition: le_gnss_interface.h:751
le_gnss_NmeaBitMask_t
le_gnss_NmeaBitMask_t
Definition: le_gnss_interface.h:894
le_gnss_GetDilutionOfPrecision
le_result_t le_gnss_GetDilutionOfPrecision(le_gnss_SampleRef_t positionSampleRef, le_gnss_DopType_t dopType, uint16_t *dopPtr)
le_gnss_DeleteSuplCertificate
le_result_t le_gnss_DeleteSuplCertificate(uint8_t suplCertificateId)
LE_GNSS_CONSTELLATION_GPS
North American satellite navigation system. 
Definition: le_gnss_interface.h:869
le_gnss_ConvertDataCoordinateSystem
le_result_t le_gnss_ConvertDataCoordinateSystem(le_gnss_CoordinateSystem_t coordinateSrc, le_gnss_CoordinateSystem_t coordinateDst, le_gnss_LocationDataType_t locationDataType, int64_t locationDataSrc, int64_t *locationDataDstPtr)
le_gnss_FixState_t
le_gnss_FixState_t
Definition: le_gnss_interface.h:687
LE_GNSS_STATE_FIX_2D
2-Dimensional position fix. 
Definition: le_gnss_interface.h:691
le_gnss_GetMagneticDeviation
le_result_t le_gnss_GetMagneticDeviation(le_gnss_SampleRef_t positionSampleRef, int32_t *magneticDeviationPtr)
LE_GNSS_SV_CONSTELLATION_QZSS
Definition: le_gnss_interface.h:794
LE_GNSS_POS_MAX
Maximum value. 
Definition: le_gnss_interface.h:951
le_gnss_ReleaseSampleRef
void le_gnss_ReleaseSampleRef(le_gnss_SampleRef_t positionSampleRef)
LE_GNSS_SV_CONSTELLATION_SBAS
Definition: le_gnss_interface.h:782
le_gnss_GetNmeaSentences
le_result_t le_gnss_GetNmeaSentences(le_gnss_NmeaBitMask_t *nmeaMaskPtrPtr)
LE_GNSS_NMEA_MASK_DEBUG
DEBUG type enabled: Debug NMEA indication. 
Definition: le_gnss_interface.h:914
LE_GNSS_NMEA_MASK_GPGLL
GPGLL type enabled: GPS Geographic position, latitude / longitude. 
Definition: le_gnss_interface.h:913
LE_GNSS_STATE_DISABLED
The GNSS device is disabled. 
Definition: le_gnss_interface.h:674
le_gnss_GetVerticalSpeed
le_result_t le_gnss_GetVerticalSpeed(le_gnss_SampleRef_t positionSampleRef, int32_t *vspeedPtr, int32_t *vspeedAccuracyPtr)
LE_GNSS_MS_ASSISTED_MODE
MS-Assisted mode. 
Definition: le_gnss_interface.h:814
le_gnss_SetSuplAssistedMode
le_result_t le_gnss_SetSuplAssistedMode(le_gnss_AssistedMode_t assistedMode)
LE_GNSS_DATA_UNKNOWN
Unknown data type. 
Definition: le_gnss_interface.h:735
le_gnss_GetDate
le_result_t le_gnss_GetDate(le_gnss_SampleRef_t positionSampleRef, uint16_t *yearPtr, uint16_t *monthPtr, uint16_t *dayPtr)
le_gnss_ConstellationBitMask_t
le_gnss_ConstellationBitMask_t
Definition: le_gnss_interface.h:867
le_gnss_SetDopResolution
le_result_t le_gnss_SetDopResolution(le_gnss_Resolution_t resolution)
LE_GNSS_NMEA_MASK_GPVTG
GPVTG type enabled: GPS vector track and speed over the ground. 
Definition: le_gnss_interface.h:900
LE_GNSS_COORDINATE_SYSTEM_MAX
Maximum value. 
Definition: le_gnss_interface.h:932
LE_GNSS_DATA_VACCURACY
Vertical accuracy data. 
Definition: le_gnss_interface.h:729
le_gnss_ConnectService
void le_gnss_ConnectService(void)
LE_GNSS_NMEA_MASK_GPRMC
GPRMC type enabled: GPS recommended minimum data. 
Definition: le_gnss_interface.h:899
le_gnss_GetSatellitesStatus
le_result_t le_gnss_GetSatellitesStatus(le_gnss_SampleRef_t positionSampleRef, uint8_t *satsInViewCountPtr, uint8_t *satsTrackingCountPtr, uint8_t *satsUsedCountPtr)
LE_GNSS_CONSTELLATION_GALILEO
European Union satellite navigation system. 
Definition: le_gnss_interface.h:875
le_gnss_Stop
le_result_t le_gnss_Stop(void)
legato.h
LE_GNSS_SBAS_UNKNOWN
Definition: le_gnss_interface.h:763
LE_GNSS_WORLDWIDE_AREA
Worldwide area. 
Definition: le_gnss_interface.h:852
le_gnss_CoordinateSystem_t
le_gnss_CoordinateSystem_t
Definition: le_gnss_interface.h:926
le_gnss_GetState
le_gnss_State_t le_gnss_GetState(void)
le_gnss_SetNmeaSentences
le_result_t le_gnss_SetNmeaSentences(le_gnss_NmeaBitMask_t nmeaMask)
LE_GNSS_HDOP
Horizontal dilution of precision. 
Definition: le_gnss_interface.h:829
le_gnss_ConstellationArea_t
le_gnss_ConstellationArea_t
Definition: le_gnss_interface.h:848
le_gnss_GetPositionState
le_result_t le_gnss_GetPositionState(le_gnss_SampleRef_t positionSampleRef, le_gnss_FixState_t *statePtr)
le_gnss_GetMinElevation
le_result_t le_gnss_GetMinElevation(uint8_t *minElevationPtrPtr)
le_gnss_Disable
le_result_t le_gnss_Disable(void)
LE_GNSS_NMEA_MASK_GPGGA
GPGGA type enabled: GPS fix data. 
Definition: le_gnss_interface.h:896
le_gnss_SetServerDisconnectHandler
void le_gnss_SetServerDisconnectHandler(le_gnss_DisconnectHandler_t disconnectHandler, void *contextPtr)
LE_GNSS_SBAS_GAGAN
Definition: le_gnss_interface.h:754
le_gnss_GetHorizontalSpeed
le_result_t le_gnss_GetHorizontalSpeed(le_gnss_SampleRef_t positionSampleRef, uint32_t *hspeedPtr, uint32_t *hspeedAccuracyPtr)
le_gnss_PositionHandlerFunc_t
void(* le_gnss_PositionHandlerFunc_t)(le_gnss_SampleRef_t positionSampleRef, void *contextPtr)
Definition: le_gnss_interface.h:972
le_gnss_GetLastSampleRef
le_gnss_SampleRef_t le_gnss_GetLastSampleRef(void)
le_gnss_SetConstellation
le_result_t le_gnss_SetConstellation(le_gnss_ConstellationBitMask_t constellationMask)
le_gnss_Resolution_t
le_gnss_Resolution_t
Definition: le_gnss_interface.h:706
LE_GNSS_SV_CONSTELLATION_UNDEFINED
GNSS constellation field not defined. 
Definition: le_gnss_interface.h:777
LE_GNSS_DATA_VSPEEDACCURACY
Vertical speed accuracy data. 
Definition: le_gnss_interface.h:731
le_gnss_ForceHotRestart
le_result_t le_gnss_ForceHotRestart(void)
LE_GNSS_CONSTELLATION_SBAS
SBAS constellation used in solution. 
Definition: le_gnss_interface.h:877
LE_GNSS_MS_BASED_MODE
MS-Based mode. 
Definition: le_gnss_interface.h:812
le_gnss_Enable
le_result_t le_gnss_Enable(void)
le_gnss_DisconnectHandler_t
void(* le_gnss_DisconnectHandler_t)(void *)
Definition: le_gnss_interface.h:474
le_gnss_GetGpsTime
le_result_t le_gnss_GetGpsTime(le_gnss_SampleRef_t positionSampleRef, uint32_t *gpsWeekPtr, uint32_t *gpsTimeOfWeekPtr)
LE_GNSS_NMEA_MASK_GPDTM
GPDTM type enabled: Local geodetic datum and datum offset from a. 
Definition: le_gnss_interface.h:915
LE_GNSS_NMEA_MASK_GPGSA
GPGSA type enabled: GPS DOP and active satellites. 
Definition: le_gnss_interface.h:897
le_gnss_SbasConstellationCategory_t
le_gnss_SbasConstellationCategory_t
Definition: le_gnss_interface.h:746
le_gnss_GetConstellationArea
le_result_t le_gnss_GetConstellationArea(le_gnss_Constellation_t satConstellation, le_gnss_ConstellationArea_t *constellationAreaPtr)
le_gnss_GetGpsLeapSeconds
le_result_t le_gnss_GetGpsLeapSeconds(le_gnss_SampleRef_t positionSampleRef, uint8_t *leapSecondsPtr)
LE_GNSS_STATE_READY
The GNSS device is ready. 
Definition: le_gnss_interface.h:670
LE_GNSS_RES_ONE_DECIMAL
Resolution of 1 decimal place. 
Definition: le_gnss_interface.h:710
LE_GNSS_STATE_FIX_NO_POS
The GNSS fix position is not fixed. 
Definition: le_gnss_interface.h:689
LE_GNSS_GDOP
Geometric dilution of precision. 
Definition: le_gnss_interface.h:833
LE_GNSS_NMEA_MASK_GLGSV
GLGSV type enabled: GLONASS satellites in view. 
Definition: le_gnss_interface.h:901
LE_GNSS_NMEA_MASK_GAGSV
GAGSV type enabled: Galileo satellites in view. 
Definition: le_gnss_interface.h:906
le_gnss_GetTimeAccuracy
le_result_t le_gnss_GetTimeAccuracy(le_gnss_SampleRef_t positionSampleRef, uint32_t *timeAccuracyPtr)
le_gnss_DataType_t
le_gnss_DataType_t
Definition: le_gnss_interface.h:727
le_gnss_PositionHandlerRef_t
struct le_gnss_PositionHandler * le_gnss_PositionHandlerRef_t
Definition: le_gnss_interface.h:962
LE_GNSS_NMEA_MASK_GARMC
GARMC type enabled: Galileo recommended minimum data. 
Definition: le_gnss_interface.h:907
le_gnss_Constellation_t
le_gnss_Constellation_t
Definition: le_gnss_interface.h:775
le_gnss_GetDop
le_result_t le_gnss_GetDop(le_gnss_SampleRef_t positionSampleRef, uint16_t *hdopPtr, uint16_t *vdopPtr, uint16_t *pdopPtr)