le_pos_interface.h

    1 /*
    2  * ====================== WARNING ======================
    3  *
    4  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
    5  * DO NOT MODIFY IN ANY WAY.
    6  *
    7  * ====================== WARNING ======================
    8  */
    9 
   10 /**
   11  * @page c_pos Positioning
   12  *
   13  * @ref le_pos_interface.h "API Reference" <br>
   14  * @subpage c_posCtrl "Positioning Control Reference"
   15  *
   16  * <HR>
   17  *
   18  * This API provides access to the device's physical position and movement information.
   19  *
   20  * @note    Enabling and disabling the positioning system is a privileged operation available
   21  *          only through the @ref c_posCtrl.
   22  *
   23  * @section le_pos_binding IPC interfaces binding
   24  *
   25  * All the functions of this API are provided by the @b positioningService application service.
   26  *
   27  * Here's a code sample binding to Positioning services:
   28  * @verbatim
   29    bindings:
   30    {
   31       clientExe.clientComponent.le_pos -> positioningService.le_pos
   32    }
   33    @endverbatim
   34  *
   35  * @section le_pos_fix Fix On Demand
   36  * The @c le_pos_Get2DLocation() function gets the last updated latitude, longitude
   37  * and the horizontal accuracy values:
   38  *
   39  * - latitude is in degrees, positive North.
   40  * - longitude is in degrees, positive East.
   41  * - horizontal accuracy is in meters.
   42  *
   43  * The latitude and longitude are given in degrees with 6 decimal places like:
   44  * - Latitude +48858300  = 48.858300 degrees North
   45  * - Longitude +2294400 =  2.294400 degrees East
   46  *
   47  * The @c le_pos_Get3DLocation() function gets the last updated latitude, longitude,
   48  * altitude and their associated accuracy values.
   49  * - altitude is in meters, above Mean Sea Level, with 3 decimal places (3047 = 3.047 meters).
   50  * - horizontal and vertical accuracies are in meters.
   51  *
   52  * The @c le_pos_GetTime() function gets the time of last updated position:
   53  * - Hours into the day [range 0..23].
   54  * - Minutes into the hour [range 0..59].
   55  * - Seconds into the minute [range 0..59].
   56  * - Milliseconds into the second [range 0..999].
   57  *
   58  * The @c le_pos_GetDate() function gets the date of last updated position:
   59  * - Year A.D. [e.g. 2014].
   60  * - Month into the year [range 1...12].
   61  * - Days into the month [range 1...31].
   62  *
   63  * The @c le_pos_GetMotion() function gets the last updated horizontal and vertical
   64  * speed values and the associated accuracy values:
   65  * - horizontal speed is in m/sec.
   66  * - vertical speed is in m/sec, positive up.
   67  *
   68  * The @c le_pos_GetHeading() function gets the last updated heading value in
   69  * degrees (where 0 is True North) and its associated accuracy value. Heading is the direction that
   70  * the vehicle/person is facing.
   71  *
   72  * The @c le_pos_GetDirection() function gets the last updated direction value in
   73  * degrees (where 0 is True North) and its associated accuracy value. Direction of movement is the
   74  * direction that the vehicle/person is actually moving.
   75  *
   76  * A sample code can be seen in the following page:
   77  * - @subpage c_posSampleCodeFixOnDemand
   78  *
   79  * @section le_pos_navigation Navigation
   80  * To be notified when the device is in motion, you must register an handler function
   81  * to get the new position's data. The @c le_pos_AddMovementHandler() API registers
   82  * that handler. The horizontal and vertical change is measured in meters so only movement over
   83  * the threshhold will trigger notification (0 means we don't care about changes).
   84  *
   85  * The handler will give a reference to the position sample object that has triggered the
   86  * notification. You can then access parameters using accessor functions, and release
   87  * the object when done with it.
   88  *
   89  * The accessor functions are:
   90  * - le_pos_sample_Get2DLocation()
   91  * - le_pos_sample_GetDate()
   92  * - le_pos_sample_GetTime()
   93  * - le_pos_sample_GetAltitude()
   94  * - le_pos_sample_GetHorizontalSpeed()
   95  * - le_pos_sample_GetVerticalSpeed()
   96  * - le_pos_sample_GetHeading()
   97  * - le_pos_sample_GetDirection()
   98  *
   99  * @c le_pos_sample_Release() releases the object.
  100  *
  101  * You can uninstall the handler function by calling the le_pos_RemoveMovementHandler() API.
  102  * @note The le_pos_RemoveMovementHandler() API does not delete the Position Object. The caller has
  103  *       to delete it by calling the le_pos_sample_Release() function.
  104  *
  105  * A sample code can be seen in the following page:
  106  * - @subpage c_posSampleCodeNavigation
  107  *
  108  * @section le_pos_acquisitionRate Positioning acquisition rate
  109  *
  110  * The acquisition rate value can be set or get with le_pos_SetAcquisitionRate() and
  111  * le_pos_GetAcquisitionRate().
  112  * @note
  113  * If the acquisition rate was not previously configured, it will be set to a default value
  114  * of 5 seconds.
  115  * @note
  116  * The acquisition rate set with le_pos_SetAcquisitionRate() will take effect once a request of
  117  * activation of the positioning service by le_posCtrl_Request() is done.
  118  *
  119  * Copyright (C) Sierra Wireless Inc. Use of this work is subject to license.
  120  */
  121 /**
  122  * @page c_posSampleCodeFixOnDemand Sample code for Fix On Demand
  123  *
  124  * @include "apps/test/positioning/positioningTest/positioningTest/positioningTest.c"
  125  */
  126 /**
  127  * @page c_posSampleCodeNavigation Sample code for Navigation
  128  *
  129  * @include "apps/test/positioning/posDaemonTest/le_posTest.c"
  130  */
  131 /**
  132  * @file le_pos_interface.h
  133  *
  134  * Legato @ref c_pos include file.
  135  *
  136  * Copyright (C) Sierra Wireless Inc. Use of this work is subject to license.
  137  */
  138 
  139 #ifndef LE_POS_INTERFACE_H_INCLUDE_GUARD
  140 #define LE_POS_INTERFACE_H_INCLUDE_GUARD
  141 
  142 
  143 #include "legato.h"
  144 
  145 //--------------------------------------------------------------------------------------------------
  146 /**
  147  *
  148  * Connect the current client thread to the service providing this API. Block until the service is
  149  * available.
  150  *
  151  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  152  * called before any other functions in this API.  Normally, ConnectService is automatically called
  153  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  154  *
  155  * This function is created automatically.
  156  */
  157 //--------------------------------------------------------------------------------------------------
  158 void le_pos_ConnectService
  159 (
  160     void
  161 );
  162 
  163 //--------------------------------------------------------------------------------------------------
  164 /**
  165  *
  166  * Try to connect the current client thread to the service providing this API. Return with an error
  167  * if the service is not available.
  168  *
  169  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  170  * called before any other functions in this API.  Normally, ConnectService is automatically called
  171  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  172  *
  173  * This function is created automatically.
  174  *
  175  * @return
  176  *  - LE_OK if the client connected successfully to the service.
  177  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is bound.
  178  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  179  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  180  */
  181 //--------------------------------------------------------------------------------------------------
  182 le_result_t le_pos_TryConnectService
  183 (
  184     void
  185 );
  186 
  187 //--------------------------------------------------------------------------------------------------
  188 /**
  189  *
  190  * Disconnect the current client thread from the service providing this API.
  191  *
  192  * Normally, this function doesn't need to be called. After this function is called, there's no
  193  * longer a connection to the service, and the functions in this API can't be used. For details, see
  194  * @ref apiFilesC_client.
  195  *
  196  * This function is created automatically.
  197  */
  198 //--------------------------------------------------------------------------------------------------
  199 void le_pos_DisconnectService
  200 (
  201     void
  202 );
  203 
  204 
  205 //--------------------------------------------------------------------------------------------------
  206 /**
  207  *  Reference type for dealing with Position samples.
  208  */
  209 //--------------------------------------------------------------------------------------------------
  210 typedef struct le_pos_Sample* le_pos_SampleRef_t;
  211 
  212 
  213 //--------------------------------------------------------------------------------------------------
  214 /**
  215  * Reference type used by Add/Remove functions for EVENT 'le_pos_Movement'
  216  */
  217 //--------------------------------------------------------------------------------------------------
  218 typedef struct le_pos_MovementHandler* le_pos_MovementHandlerRef_t;
  219 
  220 
  221 //--------------------------------------------------------------------------------------------------
  222 /**
  223  * Handler for Movement changes.
  224  *
  225  *
  226  * @param positionSampleRef
  227  *        Position's sample reference
  228  * @param contextPtr
  229  */
  230 //--------------------------------------------------------------------------------------------------
  231 typedef void (*le_pos_MovementHandlerFunc_t)
  232 (
  233     le_pos_SampleRef_t positionSampleRef,
  234     void* contextPtr
  235 );
  236 
  237 //--------------------------------------------------------------------------------------------------
  238 /**
  239  * Add handler function for EVENT 'le_pos_Movement'
  240  *
  241  * This event provides information on movement changes.
  242  */
  243 //--------------------------------------------------------------------------------------------------
  244 le_pos_MovementHandlerRef_t le_pos_AddMovementHandler
  245 (
  246     uint32_t horizontalMagnitude,
  247         ///< [IN] Horizontal magnitude in meters.
  248         ///<            0 means that I don't care about
  249         ///<           changes in the latitude and longitude.
  250 
  251     uint32_t verticalMagnitude,
  252         ///< [IN] Vertical magnitude in meters.
  253         ///<            0 means that I don't care about
  254         ///<            changes in the altitude.
  255 
  256     le_pos_MovementHandlerFunc_t handlerPtr,
  257         ///< [IN]
  258 
  259     void* contextPtr
  260         ///< [IN]
  261 );
  262 
  263 //--------------------------------------------------------------------------------------------------
  264 /**
  265  * Remove handler function for EVENT 'le_pos_Movement'
  266  */
  267 //--------------------------------------------------------------------------------------------------
  268 void le_pos_RemoveMovementHandler
  269 (
  270     le_pos_MovementHandlerRef_t addHandlerRef
  271         ///< [IN]
  272 );
  273 
  274 //--------------------------------------------------------------------------------------------------
  275 /**
  276  * Get the 2D location's data (Latitude, Longitude, Horizontal
  277  * accuracy).
  278  *
  279  * @return LE_FAULT         Function failed to get the 2D location's data
  280  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  281  * @return LE_OK            Function succeeded.
  282  *
  283  * @note latitudePtr, longitudePtr, hAccuracyPtr can be set to NULL if not needed.
  284  */
  285 //--------------------------------------------------------------------------------------------------
  286 le_result_t le_pos_Get2DLocation
  287 (
  288     int32_t* latitudePtr,
  289         ///< [OUT] WGS84 Latitude in degrees, positive North [resolution 1e-6].
  290 
  291     int32_t* longitudePtr,
  292         ///< [OUT] WGS84 Longitude in degrees, positive East [resolution 1e-6].
  293 
  294     int32_t* hAccuracyPtr
  295         ///< [OUT] Horizontal position's accuracy in meters.
  296 );
  297 
  298 //--------------------------------------------------------------------------------------------------
  299 /**
  300  * Get the 3D location's data (Latitude, Longitude, Altitude,
  301  * Horizontal accuracy, Vertical accuracy).
  302  *
  303  * @return LE_FAULT         Function failed to get the 3D location's data
  304  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  305  * @return LE_OK            Function succeeded.
  306  *
  307  * @note latitudePtr, longitudePtr,hAccuracyPtr, altitudePtr, vAccuracyPtr can be set to NULL
  308  *       if not needed.
  309  */
  310 //--------------------------------------------------------------------------------------------------
  311 le_result_t le_pos_Get3DLocation
  312 (
  313     int32_t* latitudePtr,
  314         ///< [OUT] WGS84 Latitude in degrees, positive North [resolution 1e-6].
  315 
  316     int32_t* longitudePtr,
  317         ///< [OUT] WGS84 Longitude in degrees, positive East [resolution 1e-6].
  318 
  319     int32_t* hAccuracyPtr,
  320         ///< [OUT] Horizontal position's accuracy in meters.
  321 
  322     int32_t* altitudePtr,
  323         ///< [OUT] Altitude in meters, above Mean Sea Level.
  324 
  325     int32_t* vAccuracyPtr
  326         ///< [OUT] Vertical position's accuracy in meters.
  327 );
  328 
  329 //--------------------------------------------------------------------------------------------------
  330 /**
  331  * Get the time of the last updated location
  332  *
  333  * @return LE_FAULT         Function failed to get the time.
  334  * @return LE_OUT_OF_RANGE  The retrieved time is invalid (all fields are set to 0).
  335  * @return LE_OK            Function succeeded.
  336  *
  337  */
  338 //--------------------------------------------------------------------------------------------------
  339 le_result_t le_pos_GetTime
  340 (
  341     uint16_t* hoursPtr,
  342         ///< [OUT] UTC Hours into the day [range 0..23].
  343 
  344     uint16_t* minutesPtr,
  345         ///< [OUT] UTC Minutes into the hour [range 0..59].
  346 
  347     uint16_t* secondsPtr,
  348         ///< [OUT] UTC Seconds into the minute [range 0..59].
  349 
  350     uint16_t* millisecondsPtr
  351         ///< [OUT] UTC Milliseconds into the second [range 0..999].
  352 );
  353 
  354 //--------------------------------------------------------------------------------------------------
  355 /**
  356  * Get the date of the last updated location
  357  *
  358  * @return LE_FAULT         Function failed to get the date.
  359  * @return LE_OUT_OF_RANGE  The retrieved date is invalid (all fields are set to 0).
  360  * @return LE_OK            Function succeeded.
  361  *
  362  */
  363 //--------------------------------------------------------------------------------------------------
  364 le_result_t le_pos_GetDate
  365 (
  366     uint16_t* yearPtr,
  367         ///< [OUT] UTC Year A.D. [e.g. 2014].
  368 
  369     uint16_t* monthPtr,
  370         ///< [OUT] UTC Month into the year [range 1...12].
  371 
  372     uint16_t* dayPtr
  373         ///< [OUT] UTC Days into the month [range 1...31].
  374 );
  375 
  376 //--------------------------------------------------------------------------------------------------
  377 /**
  378  * Get the motion's data (Horizontal Speed, Horizontal Speed's
  379  * accuracy, Vertical Speed, Vertical Speed's accuracy).
  380  *
  381  * @return LE_FAULT         Function failed to get the motion's data.
  382  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX, UINT32_MAX).
  383  * @return LE_OK            Function succeeded.
  384  *
  385  * @note hSpeedPtr, hSpeedAccuracyPtr, vSpeedPtr, vSpeedAccuracyPtr can be set to NULL if not needed.
  386  */
  387 //--------------------------------------------------------------------------------------------------
  388 le_result_t le_pos_GetMotion
  389 (
  390     uint32_t* hSpeedPtr,
  391         ///< [OUT] Horizontal Speed in m/sec.
  392 
  393     uint32_t* hSpeedAccuracyPtr,
  394         ///< [OUT] Horizontal Speed's accuracy in m/sec.
  395 
  396     int32_t* vSpeedPtr,
  397         ///< [OUT] Vertical Speed in m/sec, positive up.
  398 
  399     int32_t* vSpeedAccuracyPtr
  400         ///< [OUT] Vertical Speed's accuracy in m/sec.
  401 );
  402 
  403 //--------------------------------------------------------------------------------------------------
  404 /**
  405  * Get the heading indication.
  406  *
  407  * @return LE_FAULT         Function failed to get the heading indication.
  408  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  409  * @return LE_OK            Function succeeded.
  410  *
  411  * @note headingPtr, headingAccuracyPtr can be set to NULL if not needed.
  412  */
  413 //--------------------------------------------------------------------------------------------------
  414 le_result_t le_pos_GetHeading
  415 (
  416     int32_t* headingPtr,
  417         ///< [OUT] Heading in degrees (where 0 is True North).
  418 
  419     int32_t* headingAccuracyPtr
  420         ///< [OUT] Heading's accuracy in degrees.
  421 );
  422 
  423 //--------------------------------------------------------------------------------------------------
  424 /**
  425  * Get the direction indication. Direction of movement is the
  426  * direction that the vehicle/person is actually moving.
  427  *
  428  * @return LE_FAULT         Function failed to get the direction indication.
  429  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  430  * @return LE_OK            Function succeeded.
  431  *
  432  * @note directionPtr, directionAccuracyPtr can be set to NULL if not needed.
  433  */
  434 //--------------------------------------------------------------------------------------------------
  435 le_result_t le_pos_GetDirection
  436 (
  437     int32_t* directionPtr,
  438         ///< [OUT] Direction indication in degrees (where 0 is True North).
  439 
  440     int32_t* directionAccuracyPtr
  441         ///< [OUT] Direction's accuracy estimate in degrees.
  442 );
  443 
  444 //--------------------------------------------------------------------------------------------------
  445 /**
  446  * Get the position sample's 2D location (latitude, longitude,
  447  * horizontal accuracy).
  448  *
  449  * @return LE_FAULT         Function failed to find the positionSample.
  450  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  451  * @return LE_OK            Function succeeded.
  452  *
  453  * @note If the caller is passing an invalid Position reference into this function,
  454  *       it is a fatal error, the function will not return.
  455  *
  456  * @note latitudePtr, longitudePtr, horizontalAccuracyPtr can be set to NULL if not needed.
  457  */
  458 //--------------------------------------------------------------------------------------------------
  459 le_result_t le_pos_sample_Get2DLocation
  460 (
  461     le_pos_SampleRef_t positionSampleRef,
  462         ///< [IN] Position sample's reference.
  463 
  464     int32_t* latitudePtr,
  465         ///< [OUT] WGS84 Latitude in degrees, positive North [resolution 1e-6].
  466 
  467     int32_t* longitudePtr,
  468         ///< [OUT] WGS84 Longitude in degrees, positive East [resolution 1e-6].
  469 
  470     int32_t* horizontalAccuracyPtr
  471         ///< [OUT] Horizontal position's accuracy in meters.
  472 );
  473 
  474 //--------------------------------------------------------------------------------------------------
  475 /**
  476  * Get the position sample's time.
  477  *
  478  * @return LE_FAULT         Function failed to get the time.
  479  * @return LE_OUT_OF_RANGE  The retrieved time is invalid (all fields are set to 0).
  480  * @return LE_OK            Function succeeded.
  481  *
  482  */
  483 //--------------------------------------------------------------------------------------------------
  484 le_result_t le_pos_sample_GetTime
  485 (
  486     le_pos_SampleRef_t positionSampleRef,
  487         ///< [IN] Position sample's reference.
  488 
  489     uint16_t* hoursPtr,
  490         ///< [OUT] UTC Hours into the day [range 0..23].
  491 
  492     uint16_t* minutesPtr,
  493         ///< [OUT] UTC Minutes into the hour [range 0..59].
  494 
  495     uint16_t* secondsPtr,
  496         ///< [OUT] UTC Seconds into the minute [range 0..59].
  497 
  498     uint16_t* millisecondsPtr
  499         ///< [OUT] UTC Milliseconds into the second [range 0..999].
  500 );
  501 
  502 //--------------------------------------------------------------------------------------------------
  503 /**
  504  * Get the position sample's date.
  505  *
  506  * @return LE_FAULT         Function failed to get the date.
  507  * @return LE_OUT_OF_RANGE  The retrieved date is invalid (all fields are set to 0).
  508  * @return LE_OK            Function succeeded.
  509  *
  510  */
  511 //--------------------------------------------------------------------------------------------------
  512 le_result_t le_pos_sample_GetDate
  513 (
  514     le_pos_SampleRef_t positionSampleRef,
  515         ///< [IN] Position sample's reference.
  516 
  517     uint16_t* yearPtr,
  518         ///< [OUT] UTC Year A.D. [e.g. 2014].
  519 
  520     uint16_t* monthPtr,
  521         ///< [OUT] UTC Month into the year [range 1...12].
  522 
  523     uint16_t* dayPtr
  524         ///< [OUT] UTC Days into the month [range 1...31].
  525 );
  526 
  527 //--------------------------------------------------------------------------------------------------
  528 /**
  529  * Get the position sample's altitude.
  530  *
  531  * @return LE_FAULT         Function failed to find the positionSample.
  532  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  533  * @return LE_OK            Function succeeded.
  534  *
  535  * @note If the caller is passing an invalid Position reference into this function,
  536  *       it is a fatal error, the function will not return.
  537  *
  538  * @note altitudePtr, altitudeAccuracyPtr can be set to NULL if not needed.
  539  */
  540 //--------------------------------------------------------------------------------------------------
  541 le_result_t le_pos_sample_GetAltitude
  542 (
  543     le_pos_SampleRef_t positionSampleRef,
  544         ///< [IN] Position sample's reference.
  545 
  546     int32_t* altitudePtr,
  547         ///< [OUT] Altitude in meters, above Mean Sea Level.
  548 
  549     int32_t* altitudeAccuracyPtr
  550         ///< [OUT] Vertical position's accuracy in meters.
  551 );
  552 
  553 //--------------------------------------------------------------------------------------------------
  554 /**
  555  * Get the position sample's horizontal speed.
  556  *
  557  * @return LE_FAULT         Function failed to find the positionSample.
  558  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX, UINT32_MAX).
  559  * @return LE_OK            Function succeeded.
  560  *
  561  * @note If the caller is passing an invalid Position reference into this function,
  562  *       it is a fatal error, the function will not return.
  563  *
  564  * @note hSpeedPtr, hSpeedAccuracyPtr can be set to NULL if not needed.
  565  */
  566 //--------------------------------------------------------------------------------------------------
  567 le_result_t le_pos_sample_GetHorizontalSpeed
  568 (
  569     le_pos_SampleRef_t positionSampleRef,
  570         ///< [IN] Position sample's reference.
  571 
  572     uint32_t* hSpeedPtr,
  573         ///< [OUT] The Horizontal Speed in m/sec.
  574 
  575     uint32_t* hSpeedAccuracyPtr
  576         ///< [OUT] The Horizontal Speed's accuracy in m/sec.
  577 );
  578 
  579 //--------------------------------------------------------------------------------------------------
  580 /**
  581  * Get the position sample's vertical speed.
  582  *
  583  * @return LE_FAULT         The function failed to find the positionSample.
  584  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is not valid (set to INT32_MAX).
  585  * @return LE_OK            The function succeeded.
  586  *
  587  * @note If the caller is passing an invalid Position reference into this function,
  588  *       it is a fatal error, the function will not return.
  589  *
  590  * @note vSpeedPtr, vSpeedAccuracyPtr can be set to NULL if not needed.
  591  */
  592 //--------------------------------------------------------------------------------------------------
  593 le_result_t le_pos_sample_GetVerticalSpeed
  594 (
  595     le_pos_SampleRef_t positionSampleRef,
  596         ///< [IN] Position sample's reference.
  597 
  598     int32_t* vspeedPtr,
  599         ///< [OUT] The Vertical Speed in m/sec, positive up.
  600 
  601     int32_t* vspeedAccuracyPtr
  602         ///< [OUT] The Vertical Speed's accuracy in m/sec.
  603 );
  604 
  605 //--------------------------------------------------------------------------------------------------
  606 /**
  607  * Get the position sample's heading. Heading is the direction that
  608  * the vehicle/person is facing.
  609  *
  610  * @return LE_FAULT         Function failed to find the positionSample.
  611  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  612  * @return LE_OK            TFunction succeeded.
  613  *
  614  * @note If the caller is passing an invalid Position reference into this function,
  615  *       it is a fatal error, the function will not return.
  616  *
  617  * @note headingPtr, headingAccuracyPtr can be set to NULL if not needed.
  618  */
  619 //--------------------------------------------------------------------------------------------------
  620 le_result_t le_pos_sample_GetHeading
  621 (
  622     le_pos_SampleRef_t positionSampleRef,
  623         ///< [IN] Position sample's reference.
  624 
  625     int32_t* headingPtr,
  626         ///< [OUT] Heading in degrees (where 0 is True North).
  627 
  628     int32_t* headingAccuracyPtr
  629         ///< [OUT] Heading's accuracy estimate in degrees.
  630 );
  631 
  632 //--------------------------------------------------------------------------------------------------
  633 /**
  634  * Get the position sample's direction. Direction of movement is the
  635  * direction that the vehicle/person is actually moving.
  636  *
  637  * @return LE_FAULT         Function failed to find the positionSample.
  638  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  639  * @return LE_OK            Function succeeded.
  640  *
  641  * @note If the caller is passing an invalid Position reference into this function,
  642  *       it is a fatal error, the function will not return.
  643  *
  644  * @note directionPtr, directionAccuracyPtr can be set to NULL if not needed.
  645  */
  646 //--------------------------------------------------------------------------------------------------
  647 le_result_t le_pos_sample_GetDirection
  648 (
  649     le_pos_SampleRef_t positionSampleRef,
  650         ///< [IN] Position sample's reference.
  651 
  652     int32_t* directionPtr,
  653         ///< [OUT] Direction in degrees (where 0 is True North).
  654 
  655     int32_t* directionAccuracyPtr
  656         ///< [OUT] Direction's accuracy estimate in degrees.
  657 );
  658 
  659 //--------------------------------------------------------------------------------------------------
  660 /**
  661  * Release the position sample.
  662  *
  663  * @note If the caller is passing an invalid Position reference into this function,
  664  *       it is a fatal error, the function will not return.
  665  */
  666 //--------------------------------------------------------------------------------------------------
  667 void le_pos_sample_Release
  668 (
  669     le_pos_SampleRef_t positionSampleRef
  670         ///< [IN] Position sample's reference.
  671 );
  672 
  673 //--------------------------------------------------------------------------------------------------
  674 /**
  675  * Set the acquisition rate.
  676  *
  677  * @return
  678  *    LE_OUT_OF_RANGE    Invalid acquisition rate.
  679  *    LE_OK              The function succeeded.
  680  */
  681 //--------------------------------------------------------------------------------------------------
  682 le_result_t le_pos_SetAcquisitionRate
  683 (
  684     uint32_t acquisitionRate
  685         ///< [IN] Acquisition rate in milliseconds.
  686 );
  687 
  688 //--------------------------------------------------------------------------------------------------
  689 /**
  690  * Retrieve the acquisition rate.
  691  *
  692  * @return
  693  *    Acquisition rate in milliseconds.
  694  */
  695 //--------------------------------------------------------------------------------------------------
  696 uint32_t le_pos_GetAcquisitionRate
  697 (
  698     void
  699 );
  700 
  701 
  702 #endif // LE_POS_INTERFACE_H_INCLUDE_GUARD
  703 
le_pos_sample_Get2DLocation
le_result_t le_pos_sample_Get2DLocation(le_pos_SampleRef_t positionSampleRef, int32_t *latitudePtr, int32_t *longitudePtr, int32_t *horizontalAccuracyPtr)
le_pos_GetDate
le_result_t le_pos_GetDate(uint16_t *yearPtr, uint16_t *monthPtr, uint16_t *dayPtr)
le_pos_GetHeading
le_result_t le_pos_GetHeading(int32_t *headingPtr, int32_t *headingAccuracyPtr)
le_result_t
le_result_t
Definition: le_basics.h:35
le_pos_AddMovementHandler
le_pos_MovementHandlerRef_t le_pos_AddMovementHandler(uint32_t horizontalMagnitude, uint32_t verticalMagnitude, le_pos_MovementHandlerFunc_t handlerPtr, void *contextPtr)
le_pos_TryConnectService
le_result_t le_pos_TryConnectService(void)
le_pos_sample_GetHeading
le_result_t le_pos_sample_GetHeading(le_pos_SampleRef_t positionSampleRef, int32_t *headingPtr, int32_t *headingAccuracyPtr)
le_pos_sample_GetTime
le_result_t le_pos_sample_GetTime(le_pos_SampleRef_t positionSampleRef, uint16_t *hoursPtr, uint16_t *minutesPtr, uint16_t *secondsPtr, uint16_t *millisecondsPtr)
le_pos_sample_GetDate
le_result_t le_pos_sample_GetDate(le_pos_SampleRef_t positionSampleRef, uint16_t *yearPtr, uint16_t *monthPtr, uint16_t *dayPtr)
le_pos_sample_GetAltitude
le_result_t le_pos_sample_GetAltitude(le_pos_SampleRef_t positionSampleRef, int32_t *altitudePtr, int32_t *altitudeAccuracyPtr)
le_pos_DisconnectService
void le_pos_DisconnectService(void)
le_pos_GetMotion
le_result_t le_pos_GetMotion(uint32_t *hSpeedPtr, uint32_t *hSpeedAccuracyPtr, int32_t *vSpeedPtr, int32_t *vSpeedAccuracyPtr)
le_pos_ConnectService
void le_pos_ConnectService(void)
le_pos_Get3DLocation
le_result_t le_pos_Get3DLocation(int32_t *latitudePtr, int32_t *longitudePtr, int32_t *hAccuracyPtr, int32_t *altitudePtr, int32_t *vAccuracyPtr)
le_pos_SampleRef_t
struct le_pos_Sample * le_pos_SampleRef_t
Definition: le_pos_interface.h:210
le_pos_sample_GetHorizontalSpeed
le_result_t le_pos_sample_GetHorizontalSpeed(le_pos_SampleRef_t positionSampleRef, uint32_t *hSpeedPtr, uint32_t *hSpeedAccuracyPtr)
le_pos_GetDirection
le_result_t le_pos_GetDirection(int32_t *directionPtr, int32_t *directionAccuracyPtr)
le_pos_GetAcquisitionRate
uint32_t le_pos_GetAcquisitionRate(void)
le_pos_MovementHandlerFunc_t
void(* le_pos_MovementHandlerFunc_t)(le_pos_SampleRef_t positionSampleRef, void *contextPtr)
Definition: le_pos_interface.h:232
legato.h
le_pos_Get2DLocation
le_result_t le_pos_Get2DLocation(int32_t *latitudePtr, int32_t *longitudePtr, int32_t *hAccuracyPtr)
le_pos_sample_GetVerticalSpeed
le_result_t le_pos_sample_GetVerticalSpeed(le_pos_SampleRef_t positionSampleRef, int32_t *vspeedPtr, int32_t *vspeedAccuracyPtr)
le_pos_RemoveMovementHandler
void le_pos_RemoveMovementHandler(le_pos_MovementHandlerRef_t addHandlerRef)
le_pos_GetTime
le_result_t le_pos_GetTime(uint16_t *hoursPtr, uint16_t *minutesPtr, uint16_t *secondsPtr, uint16_t *millisecondsPtr)
le_pos_SetAcquisitionRate
le_result_t le_pos_SetAcquisitionRate(uint32_t acquisitionRate)
le_pos_MovementHandlerRef_t
struct le_pos_MovementHandler * le_pos_MovementHandlerRef_t
Definition: le_pos_interface.h:218
le_pos_sample_GetDirection
le_result_t le_pos_sample_GetDirection(le_pos_SampleRef_t positionSampleRef, int32_t *directionPtr, int32_t *directionAccuracyPtr)
le_pos_sample_Release
void le_pos_sample_Release(le_pos_SampleRef_t positionSampleRef)