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 le_gnss_Data GNSS data
   69  * The following table describes the <b>minimum</b> required data for those starting modes:
   70  *
   71  * | GNSS Data / Starting mode  | HOT  | WARM  | COLD  | FACTORY |
   72  *| -----------------------| -----| ------| ----- | ------- |
   73  *| Broadcasted Ephemeris  | Used |  |  |  |
   74  *| Extended Ephemeris     | Used(1) | Used(2) | Used(2) | Removed (3) |
   75  *| Approximate Time and Position  | Used | Used |  |  |
   76  *| Almanac   | Used | Used | Used | Used (Factory) |
   77  *
   78  * For example, a requested HOT start without valid broadcasted ephemeris will be treated
   79  * as a WARM start.
   80  *
   81  * @note (1) Extended Ephemeris can be used if Broadcasted Ephemeris are not valid.
   82  * The Extended Ephemeris could be loaded using the le_gnss_LoadExtendedEphemerisFile()
   83  * function.
   84  * @note (2) Extended Ephemeris is used if the Extended Ephemeris file is loaded and valid.
   85  * @note (3) Extended Ephemeris are removed when a FACTORY start is requested.
   86  * The Extended Ephemeris could be loaded again using the le_gnss_LoadExtendedEphemerisFile()
   87  * function.
   88  *
   89  * @subsubsection le_gnss_TTFF Time To First Fix (TTFF)
   90  * The le_gnss_GetTtff() function provides the TTFF (first between 2-Dimensional or 3-Dimensional
   91  * position fix) of the last position fix.
   92  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
   93  *
   94  * A sample code can be seen in the following page:
   95  * - @subpage c_gnssSampleCodeReStart
   96  *
   97  * @subsubsection le_gnss_ForceHotRestart Force HOT restart
   98  * The le_gnss_ForceHotRestart() function performs a "HOT" restart of the GNSS device. The current
   99  * GNSS session is stopped, then started using the available @ref le_gnss_Data.
  100  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
  101  *
  102  * @subsubsection le_gnss_ForceWarmRestart Force WARM restart
  103  * The le_gnss_ForceWarmRestart() function performs a "WARM" restart of the GNSS device. The current
  104  * GNSS session is stopped, then started using the available @ref le_gnss_Data.
  105  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
  106  *
  107  * @subsubsection le_gnss_ForceColdRestart Force COLD restart
  108  * The le_gnss_ForceColdRestart() function performs a "COLD" restart of the GNSS device. The current
  109  * GNSS session is stopped, then started using the available @ref le_gnss_Data.
  110  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
  111  *
  112  * @subsubsection le_gnss_ForceFactoryRestart Force FACTORY restart
  113  * The le_gnss_ForceFactoryRestart() function performs a "FACTORY" restart of the GNSS device.
  114  * The current GNSS session is stopped, then started using the available @ref le_gnss_Data.
  115  * Please refer to @ref le_gnss_APIcallsRequirements. Also see @ref howToGNSS.
  116  *
  117  * @subsection le_gnss_AcquisitionRate Acquisition rate
  118  * The GNSS position is computed and delivered each acquisition rate. The acquisition rate defines
  119  * the time interval that must elapse between two final GPS positions calculation and reports.
  120  * Its default value is 1 second.
  121  * The application can configure/retreive the GNSS device acquisition rate with the
  122  * le_gnss_SetAcquisitionRate() / le_gnss_GetAcquisitionRate() functions.
  123  *
  124  * Please refer to @ref le_gnss_APIcallsRequirements.
  125  *
  126  * A sample code can be seen in the following page:
  127  * - @subpage c_gnssSampleCodeAcquisitionRate
  128  *
  129  * @subsection le_gnss_SetGetConstellation GNSS constellation selection
  130  *
  131  * The le_gnss_SetConstellation() function selects the GNSS constellation(s) used in solution.
  132  * If all GNSS constellations are disabled, the GNSS engine is disabled.
  133  *
  134  * @warning Your platform may require a reboot to take into account this change. Please refer to
  135  * your platform documentation for further details.
  136  *
  137  * Combinations of constellation for GPS , GLONASS, BDS and GALILEO satellites are currently
  138  * supported. Are not supported the constellations for SBAS and QZSS satellites.
  139  *
  140  * All supported GNSS constellations are enabled by default.
  141  * The le_gnss_GetConstellation() function gets the GNSS constellation(s) enabled to be used
  142  * in solution.
  143  *
  144  * A sample code can be seen in the following page:
  145  * - @subpage c_gnssSampleCodeConstellation
  146  *
  147  * @subsection le_gnss_SetGetMinElevation GNSS minimum elevation selection
  148  *
  149  * The le_gnss_SetMinElevation() function sets the GNSS minimum elevation.
  150  * Satellites with elevation lower than the minimum elevation will be ignored.
  151  *
  152  * The le_gnss_GetMinElevation() function gets the GNSS minimum elevation.
  153  *
  154  * A sample code can be seen in the following page:
  155  * - @subpage c_gnssSampleCodeMinElevation
  156  *
  157  * @subsection le_gnss_NmeaSentences NMEA sentences selection
  158  *
  159  * The le_gnss_SetNmeaSentences() function selects the enabled NMEA sentences in the
  160  * @ref le_gnss_NMEA with a bit mask. The supported values are listed in @ref le_gnss_NmeaBitMask_t.
  161  *
  162  * @warning Your GNSS device may require a restart to take into account this change.
  163  * Please refer to your platform documentation for further details.
  164  *
  165  * @note All supported NMEA sentences are enabled by default.
  166  *
  167  * The le_gnss_GetNmeaSentences() function gets the bit mask of the enabled NMEA sentences in the
  168  * @ref le_gnss_NMEA.
  169  *
  170  * Please refer to @ref le_gnss_APIcallsRequirements.
  171  *
  172  * A sample code can be seen in the following page:
  173  * - @subpage c_gnssSampleCodeNmeaSentences
  174  *
  175  * @subsection le_gnss_APIcallsRequirements API calls Requirements
  176  * The following table shows the pre-requisites when using the GNSS service API function set.
  177  * ''LE_OK or error code'' means the function is authorized in the corresponding state, the request
  178  * is performed and the result is returned; otherwise the returned error is indicated for each state
  179  *.
  180  * | Function / GNSS state  | UNINITIALIZED  | READY  | ACTIVE  | DISABLED |
  181  *| ----------------------------- | --------------------------- | -----------------------------| --------------------------- | --------------------------- |
  182  *| le_gnss_Start() | LE_NOT_PERMITTED | LE_OK or error code | LE_DUPLICATE | LE_NOT_PERMITTED |
  183  *| le_gnss_Stop() | LE_NOT_PERMITTED | LE_DUPLICATE | LE_OK or error code | LE_NOT_PERMITTED |
  184  *| le_gnss_ForceHotRestart() | LE_NOT_PERMITTED | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED |
  185  *| le_gnss_ForceWarmRestart() | LE_NOT_PERMITTED | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED |
  186  *| le_gnss_ForceColdRestart() | LE_NOT_PERMITTED | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED |
  187  *| le_gnss_ForceFactoryRestart() | LE_NOT_PERMITTED | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED |
  188  *| le_gnss_Disable() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_DUPLICATE |
  189  *| le_gnss_Enable() | LE_NOT_PERMITTED | LE_DUPLICATE | LE_DUPLICATE | LE_OK or error code |
  190  *| le_gnss_SetConstellation() | LE_NOT_PERMITTED |  LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  191  *| le_gnss_GetConstellation() | LE_NOT_PERMITTED |  LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  192  *| le_gnss_GetTtff() | LE_NOT_PERMITTED |  LE_OK or error code | LE_OK or error code | LE_NOT_PERMITTED |
  193  *| le_gnss_SetAcquisitionRate() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  194  *| le_gnss_GetAcquisitionRate() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  195  *| le_gnss_SetNmeaSentences() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  196  *| le_gnss_GetNmeaSentences() | LE_NOT_PERMITTED | LE_OK or error code | LE_NOT_PERMITTED | LE_NOT_PERMITTED |
  197  *
  198  * Also see @ref howToGNSS.
  199  *
  200  * @section le_gnss_Information GNSS position information
  201  * @ref le_gnss_NMEA
  202  *
  203  * @ref le_gnss_GetInfo
  204  *
  205  * @subsection le_gnss_NMEA NMEA Flow
  206  * The National Marine Electronics Association (NMEA) standard defines an electrical interface
  207  * and data protocol for communications between marine instrumentation.
  208  *
  209  * The NMEA-0183, scope of this document, defines a set of frame prefixed by
  210  * $GP (concerning Global Positioning System),
  211  * $GL (concerning GLONASS)
  212  * and $GN (concerning combination of navigation systems).
  213  * For more details about NMEA standards, please refer to http://www.nmea.org/.
  214  *
  215  * That NMEA frames flow can be retrieved from the "/dev/nmea" device folder, using for example
  216  * the shell command $<EM> cat /dev/nmea | grep '$G'</EM>
  217  *
  218  * @subsection le_gnss_GetInfo Get position information
  219  * The position information is referenced to a position sample object.
  220  *
  221  * An application can register a handler to be notified of the
  222  * updated position each @ref le_gnss_AcquisitionRate, returning a position sample object.
  223  *
  224  * The GNSS information commonly used such as
  225  * device state, position, time and date, satellites information and accuracy
  226  * can be queried using the following functions:
  227  * - le_gnss_GetState()
  228  * - le_gnss_GetPositionState()
  229  * - le_gnss_GetLocation()
  230  * - le_gnss_GetAltitude()
  231  * - le_gnss_GetDate()
  232  * - le_gnss_GetTime()
  233  * - le_gnss_GetGpsTime()
  234  * - le_gnss_GetEpochTime()
  235  * - le_gnss_GetTimeAccuracy()
  236  * - le_gnss_GetHorizontalSpeed()
  237  * - le_gnss_GetVerticalSpeed()
  238  * - le_gnss_GetDirection()
  239  * - le_gnss_GetSatellitesInfo()
  240  * - le_gnss_GetSatellitesStatus()
  241  * - le_gnss_GetDop()
  242  * - le_gnss_GetAltitudeOnWgs84()
  243  * - le_gnss_GetMagneticDeviation()
  244  *
  245  * The handler can be managed using le_gnss_AddPositionHandler()
  246  * and le_gnss_RemovePositionHandler().
  247  * When a position is computed, the handler is called.
  248  *
  249  * The application has to release each position sample object received by the handler,
  250  * using the le_gnss_ReleaseSampleRef().
  251  *
  252  * A sample code can be seen in the following page:
  253  * - @subpage c_gnssSampleCodePosition
  254  *
  255  * @section le_gnss_Assisted_GNSS Assisted GNSS
  256  *
  257  * @ref le_gnss_Assisted_GNSS_EE
  258  * @ref le_gnss_Assisted_GNSS_UP
  259  *
  260  * @subsection le_gnss_Assisted_GNSS_EE Server based Extended Ephemeris
  261  *
  262  * @todo Add detailed documentation.
  263  *
  264  * With le_gnss_LoadExtendedEphemerisFile() , you can load an 'Extended Ephemeris' file into
  265  * the GNSS device from the filesystem.
  266  * You have to download the file before loading it.
  267  * @warning Ensure to check that the downloaded file is supported for your specific platform.
  268  *
  269  * With le_gnss_GetExtendedEphemerisValidity(), you will to get the validity of the last injected
  270  * Extended Ephemeris.
  271  *
  272  * You can enable/disable the use of the 'Extended Ephemeris' file into the GNSS device with
  273  * le_gnss_EnableExtendedEphemerisFile() / le_gnss_DisableExtendedEphemerisFile() functions.
  274  * @warning Ensure to check configuration capabilities for your specific platform.
  275  * A reboot must be required if your platform doesn't allow run-time configuration.
  276  *
  277  * A sample code can be seen in the following page:
  278  * - @subpage c_gnssSampleCodeXtra
  279  *
  280  * @subsection le_gnss_Assisted_GNSS_UP 3GPP User Plane (OMA SUPL)
  281  *
  282  * That 3GPP User Plane A-GNSS (Assisted GNSS) protocol is defined by two different standardization
  283  * bodies, 3GPP and Open Mobile Alliance (OMA). For more information, please refer to the standard.
  284  *
  285  * Both MS-Assisted and MS-Based position determination methods are supported in the User Plane.
  286  *
  287  * In MS-Assisted mode, the MS (Mobile Station) measures the signals from the GNSS satellites
  288  *, then returns the retrieved GNSS data to the SUPL (Secure User Plan Location) server, where the
  289  * position calculation is performed.
  290  *
  291  * In MS-Based mode, the MS gets the assistance data from the SUPL (Secure User Plan Location)
  292  * server. The MS measures the signals from the GNSS satellites and makes the position calculation.
  293  *
  294  * The data transport over User Plan is done using the TCP/IP protocol.
  295  *
  296  * The Assisted-GNSS mode can be configured thru the le_gnss_SetSuplAssistedMode() function.
  297  *
  298  * The supported modes are the following:
  299  * - Standalone mode: That 3GPP User Plane A-GNSS feature is deactivated.
  300  * - MS-Based mode
  301  * - MS-Assisted mode
  302  *
  303  * Moreover, the le_gnss_GetSuplAssistedMode() function reads the configured Assisted-GNSS mode.
  304  *
  305  * The SUPL server is configured using the le_gnss_SetSuplServerUrl() function. That function sets
  306  * the SUPL server URL and optionally the port number.
  307  *
  308  * The SUPL certificate to be used in A-GNSS sessions is injected through the
  309  * le_gnss_InjectSuplCertificate() function and deleted through the le_gnss_DeleteSuplCertificate()
  310  * function.
  311  * The SUPL certificate lenght given as parameter to le_gnss_InjectSuplCertificate() must be less
  312  * than LE_GNSS_SUPL_CERTIFICATE_MAX_LEN.
  313  *
  314  * <HR>
  315  *
  316  * Copyright (C) Sierra Wireless Inc.
  317  */
  318 /**
  319  * @page c_gnssSampleCode Sample code for GNSS device
  320  *
  321  * @include "apps/test/positioning/gnssTest/gnssTest/gnssTest.c"
  322  */
  323 /**
  324  * @page c_gnssSampleCodeEnableDisable Sample code for Enable/Disable GNSS device
  325  *
  326  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssEnable
  327  */
  328 /**
  329  * @page c_gnssSampleCodeStartStop Sample code for Start/Stop GNSS device
  330  *
  331  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  332  */
  333 /**
  334  * @page c_gnssSampleCodeReStart Sample code for restart GNSS device and get TTFF
  335  *
  336  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssReStart
  337  */
  338 /**
  339  * @page c_gnssSampleCodeAcquisitionRate Sample code for GNSS acquisition rate configuration
  340  *
  341  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  342  */
  343 /**
  344  * @page c_gnssSampleCodeConstellation Sample code for GNSS constellation selection
  345  *
  346  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  347  */
  348 /**
  349  * @page c_gnssSampleCodeMinElevation Sample code for GNSS minimum elevation
  350  *
  351  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  352  */
  353 /**
  354  * @page c_gnssSampleCodeNmeaSentences Sample code for GNSS NMEA sentences selection
  355  *
  356  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssControl
  357  */
  358 /**
  359  * @page c_gnssSampleCodePosition Sample code for GNSS position information
  360  *
  361  * @snippet "apps/test/positioning/gnssTest/gnssTest/gnssTest.c" GnssPosition
  362  */
  363 /**
  364  * @page c_gnssSampleCodeXtra Sample code for GNSS Server based Extended Ephemeris
  365  *
  366  * @include "apps/test/positioning/gnssXtraTest/gnssXtraTest/xtraTest.c"
  367  */
  368 /**
  369  * @file le_gnss_interface.h
  370  *
  371  * Legato @ref c_gnss include file.
  372  *
  373  * Copyright (C) Sierra Wireless Inc.
  374  */
  375 
  376 #ifndef LE_GNSS_INTERFACE_H_INCLUDE_GUARD
  377 #define LE_GNSS_INTERFACE_H_INCLUDE_GUARD
  378 
  379 
  380 #include "legato.h"
  381 
  382 
  383 //--------------------------------------------------------------------------------------------------
  384 /**
  385  * Type for handler called when a server disconnects.
  386  */
  387 //--------------------------------------------------------------------------------------------------
  388 typedef void (*le_gnss_DisconnectHandler_t)(void *);
  389 
  390 //--------------------------------------------------------------------------------------------------
  391 /**
  392  *
  393  * Connect the current client thread to the service providing this API. Block until the service is
  394  * available.
  395  *
  396  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  397  * called before any other functions in this API.  Normally, ConnectService is automatically called
  398  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  399  *
  400  * This function is created automatically.
  401  */
  402 //--------------------------------------------------------------------------------------------------
  403 void le_gnss_ConnectService
  404 (
  405     void
  406 );
  407 
  408 //--------------------------------------------------------------------------------------------------
  409 /**
  410  *
  411  * Try to connect the current client thread to the service providing this API. Return with an error
  412  * if the service is not available.
  413  *
  414  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  415  * called before any other functions in this API.  Normally, ConnectService is automatically called
  416  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  417  *
  418  * This function is created automatically.
  419  *
  420  * @return
  421  *  - LE_OK if the client connected successfully to the service.
  422  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  423  *    bound.
  424  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  425  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  426  */
  427 //--------------------------------------------------------------------------------------------------
  428 le_result_t le_gnss_TryConnectService
  429 (
  430     void
  431 );
  432 
  433 //--------------------------------------------------------------------------------------------------
  434 /**
  435  * Set handler called when server disconnection is detected.
  436  *
  437  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  438  * to continue without exiting, it should call longjmp() from inside the handler.
  439  */
  440 //--------------------------------------------------------------------------------------------------
  441 void le_gnss_SetServerDisconnectHandler
  442 (
  443     le_gnss_DisconnectHandler_t disconnectHandler,
  444     void *contextPtr
  445 );
  446 
  447 //--------------------------------------------------------------------------------------------------
  448 /**
  449  *
  450  * Disconnect the current client thread from the service providing this API.
  451  *
  452  * Normally, this function doesn't need to be called. After this function is called, there's no
  453  * longer a connection to the service, and the functions in this API can't be used. For details, see
  454  * @ref apiFilesC_client.
  455  *
  456  * This function is created automatically.
  457  */
  458 //--------------------------------------------------------------------------------------------------
  459 void le_gnss_DisconnectService
  460 (
  461     void
  462 );
  463 
  464 
  465 //--------------------------------------------------------------------------------------------------
  466 /**
  467  * Maximum length of the SUP Server URL string.
  468  */
  469 //--------------------------------------------------------------------------------------------------
  470 #define LE_GNSS_SUPL_SERVER_URL_MAX_LEN 256
  471 
  472 //--------------------------------------------------------------------------------------------------
  473 /**
  474  * Maximum length of the SUP Server URL string.
  475  * One extra byte is added for the null character.
  476  */
  477 //--------------------------------------------------------------------------------------------------
  478 #define LE_GNSS_SUPL_SERVER_URL_MAX_BYTES 257
  479 
  480 //--------------------------------------------------------------------------------------------------
  481 /**
  482  * Maximum SUPL certificate size.
  483  */
  484 //--------------------------------------------------------------------------------------------------
  485 #define LE_GNSS_SUPL_CERTIFICATE_MAX_LEN 2000
  486 
  487 //--------------------------------------------------------------------------------------------------
  488 /**
  489  * Maximum SUPL certificate string size.
  490  * One extra byte is added for the null character.
  491  */
  492 //--------------------------------------------------------------------------------------------------
  493 #define LE_GNSS_SUPL_CERTIFICATE_MAX_BYTES 2001
  494 
  495 //--------------------------------------------------------------------------------------------------
  496 /**
  497  * Define the maximum length of the Satellites Vehicle information list
  498  */
  499 //--------------------------------------------------------------------------------------------------
  500 #define LE_GNSS_SV_INFO_MAX_LEN 80
  501 
  502 //--------------------------------------------------------------------------------------------------
  503 /**
  504  * Define the maximal bit mask for enabled NMEA sentences
  505  *
  506  * @note This maximal value should be coherent with @ref le_gnss_NmeaBitMask_t
  507  */
  508 //--------------------------------------------------------------------------------------------------
  509 #define LE_GNSS_NMEA_SENTENCES_MAX 32767
  510 
  511 //--------------------------------------------------------------------------------------------------
  512 /**
  513  * Define the maximal degree for the minimal elevation
  514  */
  515 //--------------------------------------------------------------------------------------------------
  516 #define LE_GNSS_MIN_ELEVATION_MAX_DEGREE 90
  517 
  518 //--------------------------------------------------------------------------------------------------
  519 /**
  520  *  Reference type for dealing with GNSS position samples.
  521  */
  522 //--------------------------------------------------------------------------------------------------
  523 typedef struct le_gnss_Sample* le_gnss_SampleRef_t;
  524 
  525 
  526 //--------------------------------------------------------------------------------------------------
  527 /**
  528  * Enumeration for GNSS device state
  529  */
  530 //--------------------------------------------------------------------------------------------------
  531 typedef enum
  532 {
  533     LE_GNSS_STATE_UNINITIALIZED = 0,
  534         ///< The GNSS device is not initialized
  535     LE_GNSS_STATE_READY = 1,
  536         ///< The GNSS device is ready
  537     LE_GNSS_STATE_ACTIVE = 2,
  538         ///< The GNSS device is active
  539     LE_GNSS_STATE_DISABLED = 3,
  540         ///< The GNSS device is disabled
  541     LE_GNSS_STATE_MAX = 4
  542         ///< Do not use
  543 }
  544 le_gnss_State_t;
  545 
  546 
  547 //--------------------------------------------------------------------------------------------------
  548 /**
  549  *  GNSS fix position states.
  550  */
  551 //--------------------------------------------------------------------------------------------------
  552 typedef enum
  553 {
  554     LE_GNSS_STATE_FIX_NO_POS = 0,
  555         ///< The GNSS fix position is not fixed.
  556     LE_GNSS_STATE_FIX_2D = 1,
  557         ///< 2-Dimensional position fix.
  558     LE_GNSS_STATE_FIX_3D = 2,
  559         ///< 3-Dimensional position fix.
  560     LE_GNSS_STATE_FIX_ESTIMATED = 3
  561         ///< Estimated (i.e. forward predicted) position fix.
  562 }
  563 le_gnss_FixState_t;
  564 
  565 
  566 //--------------------------------------------------------------------------------------------------
  567 /**
  568  *  GNSS constellation type.
  569  */
  570 //--------------------------------------------------------------------------------------------------
  571 typedef enum
  572 {
  573     LE_GNSS_SV_CONSTELLATION_UNDEFINED = 0,
  574         ///< GNSS constellation field not defined.
  575     LE_GNSS_SV_CONSTELLATION_GPS = 1,
  576         ///< Satellite Vehicle of GPS constellation.
  577         ///< North American satellite navigation system
  578     LE_GNSS_SV_CONSTELLATION_SBAS = 2,
  579         ///< Satellite Vehicle of SBAS constellation.
  580         ///< Satellite-based augmentation system
  581     LE_GNSS_SV_CONSTELLATION_GLONASS = 3,
  582         ///< Satellite Vehicle of Glonass constellation.
  583         ///< Russian satellite navigation system
  584     LE_GNSS_SV_CONSTELLATION_GALILEO = 4,
  585         ///< Satellite Vehicle of Galileo constellation.
  586         ///< European Union satellite navigation system
  587     LE_GNSS_SV_CONSTELLATION_BEIDOU = 5,
  588         ///< Satellite Vehicle of Beidou constellation.
  589         ///< Chinese satellite navigation system
  590     LE_GNSS_SV_CONSTELLATION_QZSS = 6,
  591         ///< Satellite Vehicle of QZSS constellation.
  592         ///< Japanese satellite navigation system
  593     LE_GNSS_SV_CONSTELLATION_MAX = 7
  594         ///< Maximum value.
  595 }
  596 le_gnss_Constellation_t;
  597 
  598 
  599 //--------------------------------------------------------------------------------------------------
  600 /**
  601  * Assisted-GNSS mode
  602  */
  603 //--------------------------------------------------------------------------------------------------
  604 typedef enum
  605 {
  606     LE_GNSS_STANDALONE_MODE = 0,
  607         ///< Standalone mode
  608     LE_GNSS_MS_BASED_MODE = 1,
  609         ///< MS-Based mode.
  610     LE_GNSS_MS_ASSISTED_MODE = 2
  611         ///< MS-Assisted mode.
  612 }
  613 le_gnss_AssistedMode_t;
  614 
  615 
  616 //--------------------------------------------------------------------------------------------------
  617 /**
  618  * GNSS constellation Bit Mask (8 bits) indicating the GNSS constellation(s)
  619  * used in solution.
  620  *
  621  */
  622 //--------------------------------------------------------------------------------------------------
  623 typedef enum
  624 {
  625     LE_GNSS_CONSTELLATION_GPS = 0x1,        ///< GPS constellation used in solution.
  626         ///< North American satellite navigation system
  627     LE_GNSS_CONSTELLATION_GLONASS = 0x2,        ///< GLONASS constellation used in solution.
  628         ///< Russian satellite navigation system
  629     LE_GNSS_CONSTELLATION_BEIDOU = 0x4,        ///< BEIDOU constellation used in solution.
  630         ///< Chinese satellite navigation system
  631     LE_GNSS_CONSTELLATION_GALILEO = 0x8,        ///< GALILEO constellation used in solution.
  632         ///< European Union satellite navigation system
  633     LE_GNSS_CONSTELLATION_SBAS = 0x10,        ///< SBAS constellation used in solution.
  634     LE_GNSS_CONSTELLATION_QZSS = 0x20        ///< QZSS constellation used in solution.
  635         ///< Japanese satellite navigation system
  636 }
  637 le_gnss_ConstellationBitMask_t;
  638 
  639 
  640 //--------------------------------------------------------------------------------------------------
  641 /**
  642  * NMEA sentences Bit Mask indicating the NMEA sentences enabled in the NMEA flow.
  643  *
  644  * @warning The supported NMEA sentences depend on the platform. Please refer to your platform
  645  * documentation for further details.
  646  *
  647  * @note The bit mask values should be coherent with @ref LE_GNSS_NMEA_SENTENCES_MAX
  648  */
  649 //--------------------------------------------------------------------------------------------------
  650 typedef enum
  651 {
  652     LE_GNSS_NMEA_MASK_GPGGA = 0x1,        ///< GPGGA type enabled: GPS fix data.
  653     LE_GNSS_NMEA_MASK_GPGSA = 0x2,        ///< GPGSA type enabled: GPS DOP and active satellites.
  654     LE_GNSS_NMEA_MASK_GPGSV = 0x4,        ///< GPGSV type enabled: GPS satellites in view.
  655     LE_GNSS_NMEA_MASK_GPRMC = 0x8,        ///< GPRMC type enabled: GPS recommended minimum data.
  656     LE_GNSS_NMEA_MASK_GPVTG = 0x10,        ///< GPVTG type enabled: GPS vector track and speed over the ground.
  657     LE_GNSS_NMEA_MASK_GLGSV = 0x20,        ///< GLGSV type enabled: GLONASS satellites in view.
  658     LE_GNSS_NMEA_MASK_GNGNS = 0x40,        ///< GNGNS type enabled: GNSS fix data.
  659     LE_GNSS_NMEA_MASK_GNGSA = 0x80,        ///< GNGSA type enabled: GNSS DOP and active satellites.
  660     LE_GNSS_NMEA_MASK_GAGGA = 0x100,        ///< GAGGA type enabled: Galileo fix data.
  661     LE_GNSS_NMEA_MASK_GAGSA = 0x200,        ///< GAGSA type enabled: Galileo DOP and active satellites.
  662     LE_GNSS_NMEA_MASK_GAGSV = 0x400,        ///< GAGSV type enabled: Galileo satellites in view.
  663     LE_GNSS_NMEA_MASK_GARMC = 0x800,        ///< GARMC type enabled: Galileo recommended minimum data.
  664     LE_GNSS_NMEA_MASK_GAVTG = 0x1000,        ///< GAVTG type enabled: Galileo vector track and speed over the ground.
  665     LE_GNSS_NMEA_MASK_PSTIS = 0x2000,        ///< PSTIS type enabled: GPS session start indication.
  666     LE_GNSS_NMEA_MASK_PQXFI = 0x4000        ///< PQXFI type enabled: Proprietary Qualcomm eXtended Fix Information.
  667 }
  668 le_gnss_NmeaBitMask_t;
  669 
  670 
  671 //--------------------------------------------------------------------------------------------------
  672 /**
  673  * Reference type used by Add/Remove functions for EVENT 'le_gnss_Position'
  674  */
  675 //--------------------------------------------------------------------------------------------------
  676 typedef struct le_gnss_PositionHandler* le_gnss_PositionHandlerRef_t;
  677 
  678 
  679 //--------------------------------------------------------------------------------------------------
  680 /**
  681  * Handler for position information.
  682  *
  683  */
  684 //--------------------------------------------------------------------------------------------------
  685 typedef void (*le_gnss_PositionHandlerFunc_t)
  686 (
  687     le_gnss_SampleRef_t positionSampleRef,
  688         ///< Position's sample reference
  689     void* contextPtr
  690         ///<
  691 );
  692 
  693 //--------------------------------------------------------------------------------------------------
  694 /**
  695  * Set the GNSS constellation bit mask
  696  *
  697  * @return
  698  *  - LE_FAULT         The function failed.
  699  *  - LE_UNSUPPORTED   If the request is not supported.
  700  *  - LE_NOT_PERMITTED If the GNSS device is not initialized, disabled or active.
  701  *  - LE_OK            The function succeeded.
  702  */
  703 //--------------------------------------------------------------------------------------------------
  704 le_result_t le_gnss_SetConstellation
  705 (
  706     le_gnss_ConstellationBitMask_t constellationMask
  707         ///< [IN] GNSS constellation used in solution.
  708 );
  709 
  710 //--------------------------------------------------------------------------------------------------
  711 /**
  712  * Get the GNSS constellation bit mask
  713  *
  714  * @return
  715  *  - LE_OK on success
  716  *  - LE_FAULT on failure
  717  */
  718 //--------------------------------------------------------------------------------------------------
  719 le_result_t le_gnss_GetConstellation
  720 (
  721     le_gnss_ConstellationBitMask_t* constellationMaskPtr
  722         ///< [OUT] GNSS constellation used in solution.
  723 );
  724 
  725 //--------------------------------------------------------------------------------------------------
  726 /**
  727  * This function enables the use of the 'Extended Ephemeris' file into the GNSS device.
  728  *
  729  * @return
  730  *  - LE_FAULT         The function failed.
  731  *  - LE_OK            The function succeeded.
  732  *
  733  */
  734 //--------------------------------------------------------------------------------------------------
  735 le_result_t le_gnss_EnableExtendedEphemerisFile
  736 (
  737     void
  738 );
  739 
  740 //--------------------------------------------------------------------------------------------------
  741 /**
  742  * This function disables the use of the 'Extended Ephemeris' file into the GNSS device.
  743  *
  744  * @return
  745  *  - LE_FAULT         The function failed.
  746  *  - LE_OK            The function succeeded.
  747  *
  748  */
  749 //--------------------------------------------------------------------------------------------------
  750 le_result_t le_gnss_DisableExtendedEphemerisFile
  751 (
  752     void
  753 );
  754 
  755 //--------------------------------------------------------------------------------------------------
  756 /**
  757  * This function must be called to load an 'Extended Ephemeris' file into the GNSS device.
  758  *
  759  * @return
  760  *  - LE_FAULT         The function failed to inject the 'Extended Ephemeris' file.
  761  *  - LE_TIMEOUT       A time-out occurred.
  762  *  - LE_FORMAT_ERROR  'Extended Ephemeris' file format error.
  763  *  - LE_OK            The function succeeded.
  764  *
  765  */
  766 //--------------------------------------------------------------------------------------------------
  767 le_result_t le_gnss_LoadExtendedEphemerisFile
  768 (
  769     int fd
  770         ///< [IN] Extended ephemeris file descriptor
  771 );
  772 
  773 //--------------------------------------------------------------------------------------------------
  774 /**
  775  * This function must be called to get the validity of the last injected Extended Ephemeris.
  776  *
  777  * @return
  778  *  - LE_FAULT         The function failed to get the validity
  779  *  - LE_OK            The function succeeded.
  780  *
  781  */
  782 //--------------------------------------------------------------------------------------------------
  783 le_result_t le_gnss_GetExtendedEphemerisValidity
  784 (
  785     uint64_t* startTimePtr,
  786         ///< [OUT] Start time in seconds (since Jan. 1, 1970)
  787     uint64_t* stopTimePtr
  788         ///< [OUT] Stop time in seconds (since Jan. 1, 1970)
  789 );
  790 
  791 //--------------------------------------------------------------------------------------------------
  792 /**
  793  * This function starts the GNSS device.
  794  *
  795  * @return
  796  *  - LE_FAULT         The function failed.
  797  *  - LE_DUPLICATE     If the GNSS device is already started.
  798  *  - LE_NOT_PERMITTED If the GNSS device is not initialized or disabled.
  799  *  - LE_OK            The function succeeded.
  800  *
  801  */
  802 //--------------------------------------------------------------------------------------------------
  803 le_result_t le_gnss_Start
  804 (
  805     void
  806 );
  807 
  808 //--------------------------------------------------------------------------------------------------
  809 /**
  810  * This function stops the GNSS device.
  811  *
  812  * @return
  813  *  - LE_FAULT         The function failed.
  814  *  - LE_DUPLICATE     If the GNSS device is already stopped.
  815  *  - LE_NOT_PERMITTED If the GNSS device is not initialized or disabled.
  816  *  - LE_OK            The function succeeded.
  817  *
  818  */
  819 //--------------------------------------------------------------------------------------------------
  820 le_result_t le_gnss_Stop
  821 (
  822     void
  823 );
  824 
  825 //--------------------------------------------------------------------------------------------------
  826 /**
  827  * This function performs a "HOT" restart of the GNSS device.
  828  *
  829  * @return
  830  *  - LE_FAULT         The function failed.
  831  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
  832  *  - LE_OK            The function succeeded.
  833  *
  834  */
  835 //--------------------------------------------------------------------------------------------------
  836 le_result_t le_gnss_ForceHotRestart
  837 (
  838     void
  839 );
  840 
  841 //--------------------------------------------------------------------------------------------------
  842 /**
  843  * This function performs a "WARM" restart of the GNSS device.
  844  *
  845  * @return
  846  *  - LE_FAULT         The function failed.
  847  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
  848  *  - LE_OK            The function succeeded.
  849  *
  850  */
  851 //--------------------------------------------------------------------------------------------------
  852 le_result_t le_gnss_ForceWarmRestart
  853 (
  854     void
  855 );
  856 
  857 //--------------------------------------------------------------------------------------------------
  858 /**
  859  * This function performs a "COLD" restart of the GNSS device.
  860  *
  861  * @return
  862  *  - LE_FAULT         The function failed.
  863  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
  864  *  - LE_OK            The function succeeded.
  865  *
  866  */
  867 //--------------------------------------------------------------------------------------------------
  868 le_result_t le_gnss_ForceColdRestart
  869 (
  870     void
  871 );
  872 
  873 //--------------------------------------------------------------------------------------------------
  874 /**
  875  * This function performs a "FACTORY" restart of the GNSS device.
  876  *
  877  * @return
  878  *  - LE_FAULT         The function failed.
  879  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
  880  *  - LE_OK            The function succeeded.
  881  *
  882  */
  883 //--------------------------------------------------------------------------------------------------
  884 le_result_t le_gnss_ForceFactoryRestart
  885 (
  886     void
  887 );
  888 
  889 //--------------------------------------------------------------------------------------------------
  890 /**
  891  * Get the TTFF in milliseconds
  892  *
  893  * @return
  894  *  - LE_BUSY          The position is not fixed and TTFF can't be measured.
  895  *  - LE_NOT_PERMITTED If the GNSS device is not enabled or not started.
  896  *  - LE_OK            Function succeeded.
  897  *
  898  */
  899 //--------------------------------------------------------------------------------------------------
  900 le_result_t le_gnss_GetTtff
  901 (
  902     uint32_t* ttffPtr
  903         ///< [OUT] TTFF in milliseconds
  904 );
  905 
  906 //--------------------------------------------------------------------------------------------------
  907 /**
  908  * This function enables the GNSS device.
  909  *
  910  * @return
  911  *  - LE_FAULT         The function failed.
  912  *  - LE_DUPLICATE     If the GNSS device is already enabled.
  913  *  - LE_NOT_PERMITTED If the GNSS device is not initialized.
  914  *  - LE_OK            The function succeeded.
  915  *
  916  */
  917 //--------------------------------------------------------------------------------------------------
  918 le_result_t le_gnss_Enable
  919 (
  920     void
  921 );
  922 
  923 //--------------------------------------------------------------------------------------------------
  924 /**
  925  * This function disables the GNSS device.
  926  *
  927  * @return
  928  *  - LE_FAULT         The function failed.
  929  *  - LE_DUPLICATE     If the GNSS device is already disabled.
  930  *  - LE_NOT_PERMITTED If the GNSS device is not initialized or started.
  931  *  - LE_OK            The function succeeded.
  932  *
  933  */
  934 //--------------------------------------------------------------------------------------------------
  935 le_result_t le_gnss_Disable
  936 (
  937     void
  938 );
  939 
  940 //--------------------------------------------------------------------------------------------------
  941 /**
  942  * This function sets the GNSS device acquisition rate.
  943  *
  944  * @return
  945  *  - LE_OK on success
  946  *  - LE_FAULT on failure
  947  *  - LE_UNSUPPORTED request not supported
  948  *  - LE_TIMEOUT a time-out occurred
  949  *  - LE_NOT_PERMITTED If the GNSS device is not in "ready" state.
  950  *  - LE_OUT_OF_RANGE  if acquisition rate value is equal to zero
  951  *
  952  * @warning This function may be subject to limitations depending on the platform. Please refer to
  953  *          the @ref platformConstraintsGnss page.
  954  */
  955 //--------------------------------------------------------------------------------------------------
  956 le_result_t le_gnss_SetAcquisitionRate
  957 (
  958     uint32_t rate
  959         ///< [IN] Acquisition rate in milliseconds.
  960 );
  961 
  962 //--------------------------------------------------------------------------------------------------
  963 /**
  964  * This function gets the GNSS device acquisition rate.
  965  *
  966  * @return
  967  *  - LE_OK on success
  968  *  - LE_FAULT on failure
  969  *  - LE_NOT_PERMITTED If the GNSS device is not in "ready" state.
  970  */
  971 //--------------------------------------------------------------------------------------------------
  972 le_result_t le_gnss_GetAcquisitionRate
  973 (
  974     uint32_t* ratePtr
  975         ///< [OUT] Acquisition rate in milliseconds.
  976 );
  977 
  978 //--------------------------------------------------------------------------------------------------
  979 /**
  980  * Add handler function for EVENT 'le_gnss_Position'
  981  *
  982  * This event provides information on position.
  983  *
  984  *  - A handler reference, which is only needed for later removal of the handler.
  985  *
  986  * @note Doesn't return on failure, so there's no need to check the return value for errors.
  987  */
  988 //--------------------------------------------------------------------------------------------------
  989 le_gnss_PositionHandlerRef_t le_gnss_AddPositionHandler
  990 (
  991     le_gnss_PositionHandlerFunc_t handlerPtr,
  992         ///< [IN]
  993     void* contextPtr
  994         ///< [IN]
  995 );
  996 
  997 //--------------------------------------------------------------------------------------------------
  998 /**
  999  * Remove handler function for EVENT 'le_gnss_Position'
 1000  */
 1001 //--------------------------------------------------------------------------------------------------
 1002 void le_gnss_RemovePositionHandler
 1003 (
 1004     le_gnss_PositionHandlerRef_t handlerRef
 1005         ///< [IN]
 1006 );
 1007 
 1008 //--------------------------------------------------------------------------------------------------
 1009 /**
 1010  * This function gets the position sample's fix state
 1011  *
 1012  *  - LE_OK on success
 1013  *  - LE_FAULT on failure
 1014  *
 1015  * @note If the caller is passing an invalid Position sample reference into this function,
 1016  *       it is a fatal error, the function will not return.
 1017  */
 1018 //--------------------------------------------------------------------------------------------------
 1019 le_result_t le_gnss_GetPositionState
 1020 (
 1021     le_gnss_SampleRef_t positionSampleRef,
 1022         ///< [IN] Position sample's reference.
 1023     le_gnss_FixState_t* statePtr
 1024         ///< [OUT] Position fix state.
 1025 );
 1026 
 1027 //--------------------------------------------------------------------------------------------------
 1028 /**
 1029  * Get the location's data (Latitude, Longitude, Horizontal accuracy).
 1030  *
 1031  * @return
 1032  *  - LE_FAULT         Function failed to get the location's data
 1033  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
 1034  *  - LE_OK            Function succeeded.
 1035  *
 1036  * @note latitudePtr, longitudePtr, hAccuracyPtr, altitudePtr, vAccuracyPtr can be set to NULL
 1037  *       if not needed.
 1038  *
 1039  * @note: The latitude and longitude values are based on the WGS84 standard coordinate system.
 1040  *
 1041  * @note The latitude and longitude are given in degrees with 6 decimal places like:
 1042  *    Latitude +48858300 = 48.858300 degrees North
 1043  *    Longitude +2294400 = 2.294400 degrees East
 1044  *
 1045  * @note If the caller is passing an invalid Position sample reference into this function,
 1046  *       it is a fatal error, the function will not return.
 1047  */
 1048 //--------------------------------------------------------------------------------------------------
 1049 le_result_t le_gnss_GetLocation
 1050 (
 1051     le_gnss_SampleRef_t positionSampleRef,
 1052         ///< [IN] Position sample's reference.
 1053     int32_t* latitudePtr,
 1054         ///< [OUT] WGS84 Latitude in degrees, positive North [resolution 1e-6].
 1055     int32_t* longitudePtr,
 1056         ///< [OUT] WGS84 Longitude in degrees, positive East [resolution 1e-6].
 1057     int32_t* hAccuracyPtr
 1058         ///< [OUT] Horizontal position's accuracy in meters [resolution 1e-2].
 1059 );
 1060 
 1061 //--------------------------------------------------------------------------------------------------
 1062 /**
 1063  * Get the position sample's altitude.
 1064  *
 1065  * @return
 1066  *  - LE_FAULT         Function failed to get the altitude.
 1067  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
 1068  *  - LE_OK            Function succeeded.
 1069  *
 1070  * @note Altitude is in meters, above Mean Sea Level, with 3 decimal places (3047 = 3.047 meters).
 1071  *
 1072  * @note For a 2D position fix, the altitude will be indicated as invalid and set to INT32_MAX
 1073  *
 1074  * @note If the caller is passing an invalid Position reference into this function,
 1075  *       it is a fatal error, the function will not return.
 1076  *
 1077  * @note altitudePtr, altitudeAccuracyPtr can be set to NULL if not needed.
 1078  */
 1079 //--------------------------------------------------------------------------------------------------
 1080 le_result_t le_gnss_GetAltitude
 1081 (
 1082     le_gnss_SampleRef_t positionSampleRef,
 1083         ///< [IN] Position sample's reference.
 1084     int32_t* altitudePtr,
 1085         ///< [OUT] Altitude in meters, above Mean Sea Level [resolution 1e-3].
 1086     int32_t* vAccuracyPtr
 1087         ///< [OUT] Vertical position's accuracy in meters [resolution 1e-1].
 1088 );
 1089 
 1090 //--------------------------------------------------------------------------------------------------
 1091 /**
 1092  * Get the position sample's time.
 1093  *
 1094  * @return
 1095  *  - LE_FAULT         Function failed to get the time.
 1096  *  - LE_OUT_OF_RANGE  The retrieved time is invalid (all fields are set to 0).
 1097  *  - LE_OK            Function succeeded.
 1098  *
 1099  * @note If the caller is passing an invalid Position sample reference into this function,
 1100  *       it is a fatal error, the function will not return.
 1101  */
 1102 //--------------------------------------------------------------------------------------------------
 1103 le_result_t le_gnss_GetTime
 1104 (
 1105     le_gnss_SampleRef_t positionSampleRef,
 1106         ///< [IN] Position sample's reference.
 1107     uint16_t* hoursPtr,
 1108         ///< [OUT] UTC Hours into the day [range 0..23].
 1109     uint16_t* minutesPtr,
 1110         ///< [OUT] UTC Minutes into the hour [range 0..59].
 1111     uint16_t* secondsPtr,
 1112         ///< [OUT] UTC Seconds into the minute [range 0..59].
 1113     uint16_t* millisecondsPtr
 1114         ///< [OUT] UTC Milliseconds into the second [range 0..999].
 1115 );
 1116 
 1117 //--------------------------------------------------------------------------------------------------
 1118 /**
 1119  * Get the position sample's GPS time.
 1120  *
 1121  * @return
 1122  *  - LE_FAULT         Function failed to get the time.
 1123  *  - LE_OUT_OF_RANGE  The retrieved time is invalid (all fields are set to 0).
 1124  *  - LE_OK            Function succeeded.
 1125  *
 1126  * @note If the caller is passing an invalid Position sample reference into this function,
 1127  *       it is a fatal error, the function will not return.
 1128  */
 1129 //--------------------------------------------------------------------------------------------------
 1130 le_result_t le_gnss_GetGpsTime
 1131 (
 1132     le_gnss_SampleRef_t positionSampleRef,
 1133         ///< [IN] Position sample's reference.
 1134     uint32_t* gpsWeekPtr,
 1135         ///< [OUT] GPS week number from midnight, Jan. 6, 1980.
 1136     uint32_t* gpsTimeOfWeekPtr
 1137         ///< [OUT] Amount of time in milliseconds into the GPS week.
 1138 );
 1139 
 1140 //--------------------------------------------------------------------------------------------------
 1141 /**
 1142  *  Get the position sample's epoch time.
 1143  *
 1144  * @return
 1145  *  - LE_FAULT         Function failed to acquire the epoch time (epoch time set to 0).
 1146  *  - LE_OK            Function succeeded.
 1147  *
 1148  * @note The epoch time is the number of seconds elapsed since January 1, 1970
 1149  *       (midnight UTC/GMT), not counting leaps seconds.
 1150  *
 1151  * @note If the caller is passing an invalid position sample reference into this function,
 1152  *       it is a fatal error, the function will not return.
 1153  */
 1154 //--------------------------------------------------------------------------------------------------
 1155 le_result_t le_gnss_GetEpochTime
 1156 (
 1157     le_gnss_SampleRef_t positionSampleRef,
 1158         ///< [IN] Position sample's reference.
 1159     uint64_t* millisecondsPtr
 1160         ///< [OUT] Milliseconds since Jan. 1, 1970.
 1161 );
 1162 
 1163 //--------------------------------------------------------------------------------------------------
 1164 /**
 1165  * Get the position sample's time accurary.
 1166  *
 1167  * @return
 1168  *  - LE_FAULT         Function failed to get the time.
 1169  *  - LE_OUT_OF_RANGE  The retrieved time accuracy is invalid (set to UINT16_MAX).
 1170  *  - LE_OK            Function succeeded.
 1171  *
 1172  * @note If the caller is passing an invalid Position sample reference into this function,
 1173  *       it is a fatal error, the function will not return.
 1174  */
 1175 //--------------------------------------------------------------------------------------------------
 1176 le_result_t le_gnss_GetTimeAccuracy
 1177 (
 1178     le_gnss_SampleRef_t positionSampleRef,
 1179         ///< [IN] Position sample's reference.
 1180     uint32_t* timeAccuracyPtr
 1181         ///< [OUT] Estimated time accuracy in milliseconds
 1182 );
 1183 
 1184 //--------------------------------------------------------------------------------------------------
 1185 /**
 1186  * Get the position sample's date.
 1187  *
 1188  * @return
 1189  *  - LE_FAULT         Function failed to get the date.
 1190  *  - LE_OUT_OF_RANGE  The retrieved date is invalid (all fields are set to 0).
 1191  *  - LE_OK            Function succeeded.
 1192  *
 1193  * @note If the caller is passing an invalid Position sample reference into this function,
 1194  *       it is a fatal error, the function will not return.
 1195  */
 1196 //--------------------------------------------------------------------------------------------------
 1197 le_result_t le_gnss_GetDate
 1198 (
 1199     le_gnss_SampleRef_t positionSampleRef,
 1200         ///< [IN] Position sample's reference.
 1201     uint16_t* yearPtr,
 1202         ///< [OUT] UTC Year A.D. [e.g. 2014].
 1203     uint16_t* monthPtr,
 1204         ///< [OUT] UTC Month into the year [range 1...12].
 1205     uint16_t* dayPtr
 1206         ///< [OUT] UTC Days into the month [range 1...31].
 1207 );
 1208 
 1209 //--------------------------------------------------------------------------------------------------
 1210 /**
 1211  * Get the position sample's horizontal speed.
 1212  *
 1213  *  - LE_FAULT         Function failed to find the positionSample.
 1214  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to UINT32_MAX).
 1215  *  - LE_OK            Function succeeded.
 1216  *
 1217  * @note hSpeedPtr, hSpeedAccuracyPtr can be set to NULL if not needed.
 1218  *
 1219  * @note If the caller is passing an invalid Position sample reference into this function,
 1220  *       it is a fatal error, the function will not return.
 1221  */
 1222 //--------------------------------------------------------------------------------------------------
 1223 le_result_t le_gnss_GetHorizontalSpeed
 1224 (
 1225     le_gnss_SampleRef_t positionSampleRef,
 1226         ///< [IN] Position sample's reference.
 1227     uint32_t* hspeedPtr,
 1228         ///< [OUT] Horizontal speed in meters/second [resolution 1e-2].
 1229     uint32_t* hspeedAccuracyPtr
 1230         ///< [OUT] Horizontal speed's accuracy estimate
 1231         ///< in meters/second [resolution 1e-1].
 1232 );
 1233 
 1234 //--------------------------------------------------------------------------------------------------
 1235 /**
 1236  * Get the position sample's vertical speed.
 1237  *
 1238  * @return
 1239  *  - LE_FAULT         The function failed to find the positionSample.
 1240  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is not valid (set to INT32_MAX).
 1241  *  - LE_OK            The function succeeded.
 1242  *
 1243  * @note vSpeedPtr, vSpeedAccuracyPtr can be set to NULL if not needed.
 1244  *
 1245  * @note For a 2D position Fix, the vertical speed will be indicated as invalid
 1246  * and set to INT32_MAX.
 1247  *
 1248  * @note If the caller is passing an invalid Position sample reference into this function,
 1249  *       it is a fatal error, the function will not return.
 1250  */
 1251 //--------------------------------------------------------------------------------------------------
 1252 le_result_t le_gnss_GetVerticalSpeed
 1253 (
 1254     le_gnss_SampleRef_t positionSampleRef,
 1255         ///< [IN] Position sample's reference.
 1256     int32_t* vspeedPtr,
 1257         ///< [OUT] Vertical speed in meters/second [resolution 1e-2],
 1258         ///< positive up.
 1259     int32_t* vspeedAccuracyPtr
 1260         ///< [OUT] Vertical speed's accuracy estimate
 1261         ///< in meters/second [resolution 1e-1].
 1262 );
 1263 
 1264 //--------------------------------------------------------------------------------------------------
 1265 /**
 1266  * Get the position sample's direction. Direction of movement is the direction that the vehicle or
 1267  * person is actually moving.
 1268  *
 1269  * @return
 1270  *  - LE_FAULT         Function failed to find the positionSample.
 1271  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to UINT32_MAX).
 1272  *  - LE_OK            Function succeeded.
 1273  *
 1274  * @note Direction is given in degrees with 1 decimal place: 1755 = 175,5 degrees.
 1275  *       Direction ranges from 0 to 359.9 degrees, where 0 is True North.
 1276  *
 1277  * @note directionPtr, directionAccuracyPtr can be set to NULL if not needed.
 1278  *
 1279  * @note If the caller is passing an invalid Position sample reference into this function,
 1280  *       it is a fatal error, the function will not return.
 1281  */
 1282 //--------------------------------------------------------------------------------------------------
 1283 le_result_t le_gnss_GetDirection
 1284 (
 1285     le_gnss_SampleRef_t positionSampleRef,
 1286         ///< [IN] Position sample's reference.
 1287     uint32_t* directionPtr,
 1288         ///< [OUT] Direction in degrees [resolution 1e-1].
 1289         ///< Range: 0 to 359.9, where 0 is True North
 1290     uint32_t* directionAccuracyPtr
 1291         ///< [OUT] Direction's accuracy estimate
 1292         ///< in degrees [resolution 1e-1].
 1293 );
 1294 
 1295 //--------------------------------------------------------------------------------------------------
 1296 /**
 1297  * Get the Satellites Vehicle information.
 1298  *
 1299  * @return
 1300  *  - LE_FAULT         Function failed to find the positionSample.
 1301  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is invalid.
 1302  *  - LE_OK            Function succeeded.
 1303  *
 1304  * @note satId[] can be set to 0 if that information list index is not configured, so
 1305  * all satellite parameters (satConst[], satSnr[],satAzim[], satElev[]) are fixed to 0.
 1306  *
 1307  * @note For LE_OUT_OF_RANGE returned code, invalid value depends on field type:
 1308  * UINT16_MAX for satId, LE_GNSS_SV_CONSTELLATION_UNDEFINED for satConst, false for satUsed,
 1309  * UINT8_MAX for satSnr, UINT16_MAX for satAzim, UINT8_MAX for satElev.
 1310  *
 1311  * @note If the caller is passing an invalid Position sample reference into this function,
 1312  *       it is a fatal error, the function will not return.
 1313  */
 1314 //--------------------------------------------------------------------------------------------------
 1315 le_result_t le_gnss_GetSatellitesInfo
 1316 (
 1317     le_gnss_SampleRef_t positionSampleRef,
 1318         ///< [IN] Position sample's reference.
 1319     uint16_t* satIdPtr,
 1320         ///< [OUT] Satellites in View ID number, referring
 1321         ///< to NMEA standard.
 1322     size_t* satIdSizePtr,
 1323         ///< [INOUT]
 1324     le_gnss_Constellation_t* satConstPtr,
 1325         ///< [OUT] GNSS constellation type.
 1326     size_t* satConstSizePtr,
 1327         ///< [INOUT]
 1328     bool* satUsedPtr,
 1329         ///< [OUT] TRUE if satellite in View Used
 1330         ///< for Navigation.
 1331     size_t* satUsedSizePtr,
 1332         ///< [INOUT]
 1333     uint8_t* satSnrPtr,
 1334         ///< [OUT] Satellites in View Signal To
 1335         ///< Noise Ratio [dBHz].
 1336     size_t* satSnrSizePtr,
 1337         ///< [INOUT]
 1338     uint16_t* satAzimPtr,
 1339         ///< [OUT] Satellites in View Azimuth [degrees].
 1340         ///< Range: 0 to 360
 1341         ///< If Azimuth angle is currently unknown,
 1342         ///< the value is set to UINT16_MAX.
 1343     size_t* satAzimSizePtr,
 1344         ///< [INOUT]
 1345     uint8_t* satElevPtr,
 1346         ///< [OUT] Satellites in View Elevation [degrees].
 1347         ///< Range: 0 to 90
 1348         ///< If Elevation angle is currently unknown,
 1349         ///< the value is set to UINT8_MAX.
 1350     size_t* satElevSizePtr
 1351         ///< [INOUT]
 1352 );
 1353 
 1354 //--------------------------------------------------------------------------------------------------
 1355 /**
 1356  * Get the Satellites Vehicle status.
 1357  *
 1358  * @return
 1359  *  - LE_FAULT         Function failed to find the positionSample.
 1360  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is invalid.
 1361  *  - LE_OK            Function succeeded.
 1362  *
 1363  * @note If the caller is passing an invalid Position sample reference into this function,
 1364  *       it is a fatal error, the function will not return.
 1365  */
 1366 //--------------------------------------------------------------------------------------------------
 1367 le_result_t le_gnss_GetSatellitesStatus
 1368 (
 1369     le_gnss_SampleRef_t positionSampleRef,
 1370         ///< [IN] Position sample's reference.
 1371     uint8_t* satsInViewCountPtr,
 1372         ///< [OUT] Number of satellites expected to be in view.
 1373     uint8_t* satsTrackingCountPtr,
 1374         ///< [OUT] Number of satellites in view, when tracking.
 1375     uint8_t* satsUsedCountPtr
 1376         ///< [OUT] Number of satellites in view used for Navigation.
 1377 );
 1378 
 1379 //--------------------------------------------------------------------------------------------------
 1380 /**
 1381  * Get the DOP parameters (Dilution Of Precision) for the fixed position.
 1382  *
 1383  * @return
 1384  *  - LE_FAULT         Function failed to find the positionSample.
 1385  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT16_MAX).
 1386  *  - LE_OK            Function succeeded.
 1387  *
 1388  * @note The DOP values are given with 3 decimal places like: DOP value 2200 = 2.20
 1389  *
 1390  * @note If the caller is passing an invalid Position sample reference into this function,
 1391  *       it is a fatal error, the function will not return.
 1392  */
 1393 //--------------------------------------------------------------------------------------------------
 1394 le_result_t le_gnss_GetDop
 1395 (
 1396     le_gnss_SampleRef_t positionSampleRef,
 1397         ///< [IN] Position sample's reference.
 1398     uint16_t* hdopPtr,
 1399         ///< [OUT] Horizontal Dilution of Precision [resolution 1e-3].
 1400     uint16_t* vdopPtr,
 1401         ///< [OUT] Vertical Dilution of Precision [resolution 1e-3].
 1402     uint16_t* pdopPtr
 1403         ///< [OUT] Position Dilution of Precision [resolution 1e-3].
 1404 );
 1405 
 1406 //--------------------------------------------------------------------------------------------------
 1407 /**
 1408  * Get the position sample's altitude with respect to the WGS-84 ellipsoid
 1409  *
 1410  * @return
 1411  *  - LE_FAULT         Function failed to get the altitude.
 1412  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
 1413  *  - LE_OK            Function succeeded.
 1414  *
 1415  * @note altitudeOnWgs84 is in meters, between WGS-84 earth ellipsoid and mean sea level
 1416  *       with 3 decimal places (3047 = 3.047 meters).
 1417  *
 1418  * @note For a 2D position fix, the altitude with respect to the WGS-84 ellipsoid will be indicated
 1419  *       as invalid and set to INT32_MAX.
 1420  *
 1421  * @note If the caller is passing an invalid Position reference into this function,
 1422  *       it is a fatal error, the function will not return.
 1423  */
 1424 //--------------------------------------------------------------------------------------------------
 1425 le_result_t le_gnss_GetAltitudeOnWgs84
 1426 (
 1427     le_gnss_SampleRef_t positionSampleRef,
 1428         ///< [IN] Position sample's reference.
 1429     int32_t* altitudeOnWgs84Ptr
 1430         ///< [OUT] Altitude in meters, between WGS-84 earth ellipsoid
 1431         ///< and mean sea level [resolution 1e-3].
 1432 );
 1433 
 1434 //--------------------------------------------------------------------------------------------------
 1435 /**
 1436  * Get the position sample's magnetic deviation. It is the difference between the bearing to
 1437  * true north and the bearing shown on a magnetic compass. The deviation is positive when the
 1438  * magnetic north is east of true north.
 1439  *
 1440  * @return
 1441  *  - LE_FAULT         Function failed to find the positionSample.
 1442  *  - LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
 1443  *  - LE_OK            Function succeeded.
 1444  *
 1445  * @note magneticDeviation is in degrees, with 1 decimal places (47 = 4.7 degree).
 1446  *
 1447  * @note If the caller is passing an invalid Position sample reference into this function,
 1448  *       it is a fatal error, the function will not return.
 1449  */
 1450 //--------------------------------------------------------------------------------------------------
 1451 le_result_t le_gnss_GetMagneticDeviation
 1452 (
 1453     le_gnss_SampleRef_t positionSampleRef,
 1454         ///< [IN] Position sample's reference.
 1455     int32_t* magneticDeviationPtr
 1456         ///< [OUT] MagneticDeviation in degrees [resolution 1e-1].
 1457 );
 1458 
 1459 //--------------------------------------------------------------------------------------------------
 1460 /**
 1461  * This function gets the last updated position sample object reference.
 1462  *
 1463  * @return A reference to last Position's sample.
 1464  *
 1465  * @note
 1466  *      On failure, the process exits, so you don't have to worry about checking the returned
 1467  *      reference for validity.
 1468  */
 1469 //--------------------------------------------------------------------------------------------------
 1470 le_gnss_SampleRef_t le_gnss_GetLastSampleRef
 1471 (
 1472     void
 1473 );
 1474 
 1475 //--------------------------------------------------------------------------------------------------
 1476 /**
 1477  * This function must be called to release the position sample.
 1478  *
 1479  * @note If the caller is passing an invalid Position sample reference into this function,
 1480  *       it is a fatal error, the function will not return.
 1481  */
 1482 //--------------------------------------------------------------------------------------------------
 1483 void le_gnss_ReleaseSampleRef
 1484 (
 1485     le_gnss_SampleRef_t positionSampleRef
 1486         ///< [IN] Position sample's reference.
 1487 );
 1488 
 1489 //--------------------------------------------------------------------------------------------------
 1490 /**
 1491  * This function sets the SUPL Assisted-GNSS mode.
 1492  *
 1493  * @return
 1494  *  - LE_OK on success
 1495  *  - LE_FAULT on failure
 1496  *  - LE_UNSUPPORTED request not supported
 1497  *  - LE_TIMEOUT a time-out occurred
 1498  */
 1499 //--------------------------------------------------------------------------------------------------
 1500 le_result_t le_gnss_SetSuplAssistedMode
 1501 (
 1502     le_gnss_AssistedMode_t assistedMode
 1503         ///< [IN] Assisted-GNSS mode.
 1504 );
 1505 
 1506 //--------------------------------------------------------------------------------------------------
 1507 /**
 1508  * This function gets the SUPL Assisted-GNSS mode.
 1509  *
 1510  * @return
 1511  *  - LE_OK on success
 1512  *  - LE_FAULT on failure
 1513  */
 1514 //--------------------------------------------------------------------------------------------------
 1515 le_result_t le_gnss_GetSuplAssistedMode
 1516 (
 1517     le_gnss_AssistedMode_t* assistedModePtr
 1518         ///< [OUT] Assisted-GNSS mode.
 1519 );
 1520 
 1521 //--------------------------------------------------------------------------------------------------
 1522 /**
 1523  * This function sets the SUPL server URL.
 1524  * That server URL is a NULL-terminated string with a maximum string length (including NULL
 1525  * terminator) equal to 256. Optionally the port number is specified after a colon.
 1526  *
 1527  * @return
 1528  *  - LE_OK on success
 1529  *  - LE_FAULT on failure
 1530  *  - LE_BUSY service is busy
 1531  *  - LE_TIMEOUT a time-out occurred
 1532  *
 1533  * @note If the SUPL server URL size is bigger than the maximum string length (including NULL
 1534  * terminator) size, it is a fatal error, the function will not return.
 1535  */
 1536 //--------------------------------------------------------------------------------------------------
 1537 le_result_t le_gnss_SetSuplServerUrl
 1538 (
 1539     const char* suplServerUrl
 1540         ///< [IN] SUPL server URL.
 1541 )
 1542 __attribute__(( nonnull(1) ));
 1543 
 1544 //--------------------------------------------------------------------------------------------------
 1545 /**
 1546  * This function injects the SUPL certificate to be used in A-GNSS sessions. Certificates must
 1547  * be encoded in DER. Other certificate encryptions (e.g., PEM, CER and CRT)
 1548  * aren't supported.
 1549  *
 1550  * @return
 1551  *  - LE_OK on success
 1552  *  - LE_FAULT on failure
 1553  *  - LE_BUSY service is busy
 1554  *  - LE_TIMEOUT a time-out occurred
 1555  *
 1556  * @note If the SUPL certificate size is bigger than the Maximum SUPL certificate size,
 1557  * it is a fatal error, the function will not return.
 1558  */
 1559 //--------------------------------------------------------------------------------------------------
 1560 le_result_t le_gnss_InjectSuplCertificate
 1561 (
 1562     uint8_t suplCertificateId,
 1563         ///< [IN] ID of the SUPL certificate.
 1564         ///< Certificate ID range is 0 to 9
 1565     uint16_t suplCertificateLen,
 1566         ///< [IN] SUPL certificate size in Bytes.
 1567     const char* suplCertificate
 1568         ///< [IN] SUPL certificate contents.
 1569 )
 1570 __attribute__(( nonnull(3) ));
 1571 
 1572 //--------------------------------------------------------------------------------------------------
 1573 /**
 1574  * This function deletes the SUPL certificate.
 1575  *
 1576  * @return
 1577  *  - LE_OK on success
 1578  *  - LE_FAULT on failure
 1579  *  - LE_BUSY service is busy
 1580  *  - LE_TIMEOUT a time-out occurred
 1581  */
 1582 //--------------------------------------------------------------------------------------------------
 1583 le_result_t le_gnss_DeleteSuplCertificate
 1584 (
 1585     uint8_t suplCertificateId
 1586         ///< [IN] ID of the SUPL certificate.
 1587         ///< Certificate ID range is 0 to 9
 1588 );
 1589 
 1590 //--------------------------------------------------------------------------------------------------
 1591 /**
 1592  * This function sets the enabled NMEA sentences using a bit mask.
 1593  *
 1594  * @return
 1595  *  - LE_OK             Success
 1596  *  - LE_BAD_PARAMETER  Bit mask exceeds the maximal value
 1597  *  - LE_FAULT          Failure
 1598  *  - LE_BUSY           Service is busy
 1599  *  - LE_TIMEOUT        Timeout occurred
 1600  *  - LE_NOT_PERMITTED  GNSS device is not in "ready" state
 1601  *
 1602  * @warning This function may be subject to limitations depending on the platform. Please refer to
 1603  *          the @ref platformConstraintsGnss page.
 1604  */
 1605 //--------------------------------------------------------------------------------------------------
 1606 le_result_t le_gnss_SetNmeaSentences
 1607 (
 1608     le_gnss_NmeaBitMask_t nmeaMask
 1609         ///< [IN] Bit mask for enabled NMEA sentences.
 1610 );
 1611 
 1612 //--------------------------------------------------------------------------------------------------
 1613 /**
 1614  * This function gets the bit mask for the enabled NMEA sentences.
 1615  *
 1616  * @return
 1617  *  - LE_OK             Success
 1618  *  - LE_FAULT          Failure
 1619  *  - LE_BUSY           Service is busy
 1620  *  - LE_TIMEOUT        Timeout occurred
 1621  *  - LE_NOT_PERMITTED  GNSS device is not in "ready" state
 1622  *
 1623  * @note If the caller is passing an null pointer to this function, it is a fatal error
 1624  *       and the function will not return.
 1625  */
 1626 //--------------------------------------------------------------------------------------------------
 1627 le_result_t le_gnss_GetNmeaSentences
 1628 (
 1629     le_gnss_NmeaBitMask_t* nmeaMaskPtrPtr
 1630         ///< [OUT] Bit mask for enabled NMEA sentences.
 1631 );
 1632 
 1633 //--------------------------------------------------------------------------------------------------
 1634 /**
 1635  * This function returns the status of the GNSS device.
 1636  *
 1637  */
 1638 //--------------------------------------------------------------------------------------------------
 1639 le_gnss_State_t le_gnss_GetState
 1640 (
 1641     void
 1642 );
 1643 
 1644 //--------------------------------------------------------------------------------------------------
 1645 /**
 1646  * This function sets the GNSS minimum elevation.
 1647  *
 1648  * @return
 1649  *  - LE_OK on success
 1650  *  - LE_FAULT on failure
 1651  *  - LE_OUT_OF_RANGE if the minimum elevation is above range
 1652  *  - LE_UNSUPPORTED request not supported
 1653  */
 1654 //--------------------------------------------------------------------------------------------------
 1655 le_result_t le_gnss_SetMinElevation
 1656 (
 1657     uint8_t minElevation
 1658         ///< [IN] Minimum elevation in degrees [range 0..90].
 1659 );
 1660 
 1661 //--------------------------------------------------------------------------------------------------
 1662 /**
 1663  * This function gets the GNSS minimum elevation.
 1664  *
 1665  * @return
 1666  *  - LE_OK on success
 1667  *  - LE_FAULT on failure
 1668  *  - LE_UNSUPPORTED request not supported
 1669  *
 1670  * @note If the caller is passing an null pointer to this function, it is a fatal error
 1671  *       and the function will not return.
 1672  */
 1673 //--------------------------------------------------------------------------------------------------
 1674 le_result_t le_gnss_GetMinElevation
 1675 (
 1676     uint8_t* minElevationPtrPtr
 1677         ///< [OUT] Minimum elevation in degrees [range 0..90].
 1678 );
 1679 
 1680 #endif // LE_GNSS_INTERFACE_H_INCLUDE_GUARD
le_gnss_AssistedMode_t
le_gnss_AssistedMode_t
Definition: le_gnss_interface.h:604
le_gnss_InjectSuplCertificate
le_result_t le_gnss_InjectSuplCertificate(uint8_t suplCertificateId, uint16_t suplCertificateLen, const char *suplCertificate)
le_gnss_GetDirection
le_result_t le_gnss_GetDirection(le_gnss_SampleRef_t positionSampleRef, uint32_t *directionPtr, uint32_t *directionAccuracyPtr)
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:533
le_gnss_SetSuplServerUrl
le_result_t le_gnss_SetSuplServerUrl(const char *suplServerUrl)
LE_GNSS_STATE_MAX
Do not use. 
Definition: le_gnss_interface.h:541
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_SV_CONSTELLATION_GALILEO
Definition: le_gnss_interface.h:584
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:659
le_result_t
le_result_t
Definition: le_basics.h:35
le_gnss_Start
le_result_t le_gnss_Start(void)
LE_GNSS_STANDALONE_MODE
Standalone mode. 
Definition: le_gnss_interface.h:606
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:627
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:523
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:665
le_gnss_GetAcquisitionRate
le_result_t le_gnss_GetAcquisitionRate(uint32_t *ratePtr)
le_gnss_DisconnectService
void le_gnss_DisconnectService(void)
LE_GNSS_SV_CONSTELLATION_GPS
Definition: le_gnss_interface.h:575
LE_GNSS_SV_CONSTELLATION_BEIDOU
Definition: le_gnss_interface.h:587
LE_GNSS_CONSTELLATION_BEIDOU
Chinese satellite navigation system. 
Definition: le_gnss_interface.h:629
LE_GNSS_NMEA_MASK_GNGNS
GNGNS type enabled: GNSS fix data. 
Definition: le_gnss_interface.h:658
LE_GNSS_NMEA_MASK_GAGGA
GAGGA type enabled: Galileo fix data. 
Definition: le_gnss_interface.h:660
le_gnss_ForceColdRestart
le_result_t le_gnss_ForceColdRestart(void)
LE_GNSS_NMEA_MASK_GAGSA
GAGSA type enabled: Galileo DOP and active satellites. 
Definition: le_gnss_interface.h:661
LE_GNSS_STATE_FIX_ESTIMATED
Estimated (i.e. forward predicted) position fix. 
Definition: le_gnss_interface.h:560
le_gnss_ForceWarmRestart
le_result_t le_gnss_ForceWarmRestart(void)
le_gnss_State_t
le_gnss_State_t
Definition: le_gnss_interface.h:531
LE_GNSS_NMEA_MASK_GPGSV
GPGSV type enabled: GPS satellites in view. 
Definition: le_gnss_interface.h:654
LE_GNSS_SV_CONSTELLATION_GLONASS
Definition: le_gnss_interface.h:581
LE_GNSS_CONSTELLATION_QZSS
Japanese satellite navigation system. 
Definition: le_gnss_interface.h:634
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_STATE_ACTIVE
The GNSS device is active. 
Definition: le_gnss_interface.h:537
le_gnss_RemovePositionHandler
void le_gnss_RemovePositionHandler(le_gnss_PositionHandlerRef_t handlerRef)
LE_GNSS_SV_CONSTELLATION_MAX
Maximum value. 
Definition: le_gnss_interface.h:593
le_gnss_EnableExtendedEphemerisFile
le_result_t le_gnss_EnableExtendedEphemerisFile(void)
LE_GNSS_STATE_FIX_3D
3-Dimensional position fix. 
Definition: le_gnss_interface.h:558
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_NMEA_MASK_GAVTG
GAVTG type enabled: Galileo vector track and speed over the ground. 
Definition: le_gnss_interface.h:664
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_NmeaBitMask_t
le_gnss_NmeaBitMask_t
Definition: le_gnss_interface.h:650
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:625
le_gnss_FixState_t
le_gnss_FixState_t
Definition: le_gnss_interface.h:552
LE_GNSS_STATE_FIX_2D
2-Dimensional position fix. 
Definition: le_gnss_interface.h:556
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:590
le_gnss_ReleaseSampleRef
void le_gnss_ReleaseSampleRef(le_gnss_SampleRef_t positionSampleRef)
LE_GNSS_SV_CONSTELLATION_SBAS
Definition: le_gnss_interface.h:578
le_gnss_GetNmeaSentences
le_result_t le_gnss_GetNmeaSentences(le_gnss_NmeaBitMask_t *nmeaMaskPtrPtr)
LE_GNSS_STATE_DISABLED
The GNSS device is disabled. 
Definition: le_gnss_interface.h:539
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:610
le_gnss_SetSuplAssistedMode
le_result_t le_gnss_SetSuplAssistedMode(le_gnss_AssistedMode_t assistedMode)
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:623
LE_GNSS_NMEA_MASK_GPVTG
GPVTG type enabled: GPS vector track and speed over the ground. 
Definition: le_gnss_interface.h:656
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:655
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_NMEA_MASK_PQXFI
PQXFI type enabled: Proprietary Qualcomm eXtended Fix Information. 
Definition: le_gnss_interface.h:666
LE_GNSS_CONSTELLATION_GALILEO
European Union satellite navigation system. 
Definition: le_gnss_interface.h:631
le_gnss_Stop
le_result_t le_gnss_Stop(void)
legato.h
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_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:652
le_gnss_SetServerDisconnectHandler
void le_gnss_SetServerDisconnectHandler(le_gnss_DisconnectHandler_t disconnectHandler, void *contextPtr)
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:686
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_SV_CONSTELLATION_UNDEFINED
GNSS constellation field not defined. 
Definition: le_gnss_interface.h:573
le_gnss_ForceHotRestart
le_result_t le_gnss_ForceHotRestart(void)
LE_GNSS_CONSTELLATION_SBAS
SBAS constellation used in solution. 
Definition: le_gnss_interface.h:633
LE_GNSS_MS_BASED_MODE
MS-Based mode. 
Definition: le_gnss_interface.h:608
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:388
le_gnss_GetGpsTime
le_result_t le_gnss_GetGpsTime(le_gnss_SampleRef_t positionSampleRef, uint32_t *gpsWeekPtr, uint32_t *gpsTimeOfWeekPtr)
LE_GNSS_NMEA_MASK_GPGSA
GPGSA type enabled: GPS DOP and active satellites. 
Definition: le_gnss_interface.h:653
LE_GNSS_STATE_READY
The GNSS device is ready. 
Definition: le_gnss_interface.h:535
LE_GNSS_STATE_FIX_NO_POS
The GNSS fix position is not fixed. 
Definition: le_gnss_interface.h:554
LE_GNSS_NMEA_MASK_GLGSV
GLGSV type enabled: GLONASS satellites in view. 
Definition: le_gnss_interface.h:657
LE_GNSS_NMEA_MASK_GAGSV
GAGSV type enabled: Galileo satellites in view. 
Definition: le_gnss_interface.h:662
le_gnss_GetTimeAccuracy
le_result_t le_gnss_GetTimeAccuracy(le_gnss_SampleRef_t positionSampleRef, uint32_t *timeAccuracyPtr)
le_gnss_PositionHandlerRef_t
struct le_gnss_PositionHandler * le_gnss_PositionHandlerRef_t
Definition: le_gnss_interface.h:676
LE_GNSS_NMEA_MASK_GARMC
GARMC type enabled: Galileo recommended minimum data. 
Definition: le_gnss_interface.h:663
le_gnss_Constellation_t
le_gnss_Constellation_t
Definition: le_gnss_interface.h:571
le_gnss_GetDop
le_result_t le_gnss_GetDop(le_gnss_SampleRef_t positionSampleRef, uint16_t *hdopPtr, uint16_t *vdopPtr, uint16_t *pdopPtr)