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 metres.
   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 metres, above Mean Sea Level, with 3 decimal places (3047 = 3.047 metres).
   50  * - horizontal and vertical accuracies are in metres.
   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 metres 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_configdb Positioning configuration tree
  109  * @copydoc le_pos_configdbPage_Hide
  110  *
  111  * <HR>
  112  *
  113  * Copyright (C) Sierra Wireless Inc. Use of this work is subject to license.
  114  */
  115 /**
  116  * @page c_posSampleCodeFixOnDemand Sample code for Fix On Demand
  117  *
  118  * @include "apps/test/positioning/positioningTest/positioningTest/positioningTest.c"
  119  */
  120 /**
  121  * @page c_posSampleCodeNavigation Sample code for Navigation
  122  *
  123  * @include "apps/test/positioning/posDaemonTest/le_posTest.c"
  124  */
  125 /**
  126  * @interface le_pos_configdbPage_Hide
  127  *
  128  * The configuration database path for Positioning is:
  129  * @verbatim
  130    /
  131        positioning/
  132            acquisitionRate<int> == 5
  133    @endverbatim
  134  *
  135  *  - 'acquisitionRate' is the fix acquisition rate in seconds.
  136  *
  137  * @note
  138  *  If there is no configuration for 'acquisitionRate', it will be automatically set to 5 seconds.
  139  */
  140 /**
  141  * @file le_pos_interface.h
  142  *
  143  * Legato @ref c_pos include file.
  144  *
  145  * Copyright (C) Sierra Wireless Inc. Use of this work is subject to license.
  146  */
  147 
  148 #ifndef LE_POS_INTERFACE_H_INCLUDE_GUARD
  149 #define LE_POS_INTERFACE_H_INCLUDE_GUARD
  150 
  151 
  152 #include "legato.h"
  153 
  154 //--------------------------------------------------------------------------------------------------
  155 /**
  156  *
  157  * Connect the current client thread to the service providing this API. Block until the service is
  158  * available.
  159  *
  160  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  161  * called before any other functions in this API.  Normally, ConnectService is automatically called
  162  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  163  *
  164  * This function is created automatically.
  165  */
  166 //--------------------------------------------------------------------------------------------------
  167 void le_pos_ConnectService
  168 (
  169     void
  170 );
  171 
  172 //--------------------------------------------------------------------------------------------------
  173 /**
  174  *
  175  * Try to connect the current client thread to the service providing this API. Return with an error
  176  * if the service is not available.
  177  *
  178  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  179  * called before any other functions in this API.  Normally, ConnectService is automatically called
  180  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  181  *
  182  * This function is created automatically.
  183  *
  184  * @return
  185  *  - LE_OK if the client connected successfully to the service.
  186  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is bound.
  187  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  188  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  189  */
  190 //--------------------------------------------------------------------------------------------------
  191 le_result_t le_pos_TryConnectService
  192 (
  193     void
  194 );
  195 
  196 //--------------------------------------------------------------------------------------------------
  197 /**
  198  *
  199  * Disconnect the current client thread from the service providing this API.
  200  *
  201  * Normally, this function doesn't need to be called. After this function is called, there's no
  202  * longer a connection to the service, and the functions in this API can't be used. For details, see
  203  * @ref apiFilesC_client.
  204  *
  205  * This function is created automatically.
  206  */
  207 //--------------------------------------------------------------------------------------------------
  208 void le_pos_DisconnectService
  209 (
  210     void
  211 );
  212 
  213 
  214 //--------------------------------------------------------------------------------------------------
  215 /**
  216  *  Reference type for dealing with Position samples.
  217  */
  218 //--------------------------------------------------------------------------------------------------
  219 typedef struct le_pos_Sample* le_pos_SampleRef_t;
  220 
  221 
  222 //--------------------------------------------------------------------------------------------------
  223 /**
  224  * Reference type used by Add/Remove functions for EVENT 'le_pos_Movement'
  225  */
  226 //--------------------------------------------------------------------------------------------------
  227 typedef struct le_pos_MovementHandler* le_pos_MovementHandlerRef_t;
  228 
  229 
  230 //--------------------------------------------------------------------------------------------------
  231 /**
  232  * Handler for Movement changes.
  233  *
  234  *
  235  * @param positionSampleRef
  236  *        Position's sample reference
  237  * @param contextPtr
  238  */
  239 //--------------------------------------------------------------------------------------------------
  240 typedef void (*le_pos_MovementHandlerFunc_t)
  241 (
  242     le_pos_SampleRef_t positionSampleRef,
  243     void* contextPtr
  244 );
  245 
  246 //--------------------------------------------------------------------------------------------------
  247 /**
  248  * Add handler function for EVENT 'le_pos_Movement'
  249  *
  250  * This event provides information on movement changes.
  251  */
  252 //--------------------------------------------------------------------------------------------------
  253 le_pos_MovementHandlerRef_t le_pos_AddMovementHandler
  254 (
  255     uint32_t horizontalMagnitude,
  256         ///< [IN] Horizontal magnitude in metres.
  257         ///<            0 means that I don't care about
  258         ///<           changes in the latitude and longitude.
  259 
  260     uint32_t verticalMagnitude,
  261         ///< [IN] Vertical magnitude in metres.
  262         ///<            0 means that I don't care about
  263         ///<            changes in the altitude.
  264 
  265     le_pos_MovementHandlerFunc_t handlerPtr,
  266         ///< [IN]
  267 
  268     void* contextPtr
  269         ///< [IN]
  270 );
  271 
  272 //--------------------------------------------------------------------------------------------------
  273 /**
  274  * Remove handler function for EVENT 'le_pos_Movement'
  275  */
  276 //--------------------------------------------------------------------------------------------------
  277 void le_pos_RemoveMovementHandler
  278 (
  279     le_pos_MovementHandlerRef_t addHandlerRef
  280         ///< [IN]
  281 );
  282 
  283 //--------------------------------------------------------------------------------------------------
  284 /**
  285  * Get the 2D location's data (Latitude, Longitude, Horizontal
  286  * accuracy).
  287  *
  288  * @return LE_FAULT         Function failed to get the 2D location's data
  289  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  290  * @return LE_OK            Function succeeded.
  291  *
  292  * @note latitudePtr, longitudePtr, hAccuracyPtr can be set to NULL if not needed.
  293  */
  294 //--------------------------------------------------------------------------------------------------
  295 le_result_t le_pos_Get2DLocation
  296 (
  297     int32_t* latitudePtr,
  298         ///< [OUT] Latitude in degrees, positive North.
  299 
  300     int32_t* longitudePtr,
  301         ///< [OUT] Longitude in degrees, positive East.
  302 
  303     int32_t* hAccuracyPtr
  304         ///< [OUT] Horizontal position's accuracy in metres.
  305 );
  306 
  307 //--------------------------------------------------------------------------------------------------
  308 /**
  309  * Get the 3D location's data (Latitude, Longitude, Altitude,
  310  * Horizontal accuracy, Vertical accuracy).
  311  *
  312  * @return LE_FAULT         Function failed to get the 3D location's data
  313  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  314  * @return LE_OK            Function succeeded.
  315  *
  316  * @note latitudePtr, longitudePtr,hAccuracyPtr, altitudePtr, vAccuracyPtr can be set to NULL
  317  *       if not needed.
  318  */
  319 //--------------------------------------------------------------------------------------------------
  320 le_result_t le_pos_Get3DLocation
  321 (
  322     int32_t* latitudePtr,
  323         ///< [OUT] Latitude in degrees, positive North.
  324 
  325     int32_t* longitudePtr,
  326         ///< [OUT] Longitude in degrees, positive East.
  327 
  328     int32_t* hAccuracyPtr,
  329         ///< [OUT] Horizontal position's accuracy in metres.
  330 
  331     int32_t* altitudePtr,
  332         ///< [OUT] Altitude in meters, above Mean Sea Level.
  333 
  334     int32_t* vAccuracyPtr
  335         ///< [OUT] Vertical position's accuracy in metres.
  336 );
  337 
  338 //--------------------------------------------------------------------------------------------------
  339 /**
  340  * Get the time of the last updated location
  341  *
  342  * @return LE_FAULT         Function failed to get the time.
  343  * @return LE_OUT_OF_RANGE  The retrieved time is invalid (all fields are set to 0).
  344  * @return LE_OK            Function succeeded.
  345  *
  346  */
  347 //--------------------------------------------------------------------------------------------------
  348 le_result_t le_pos_GetTime
  349 (
  350     uint16_t* hoursPtr,
  351         ///< [OUT] UTC Hours into the day [range 0..23].
  352 
  353     uint16_t* minutesPtr,
  354         ///< [OUT] UTC Minutes into the hour [range 0..59].
  355 
  356     uint16_t* secondsPtr,
  357         ///< [OUT] UTC Seconds into the minute [range 0..59].
  358 
  359     uint16_t* millisecondsPtr
  360         ///< [OUT] UTC Milliseconds into the second [range 0..999].
  361 );
  362 
  363 //--------------------------------------------------------------------------------------------------
  364 /**
  365  * Get the date of the last updated location
  366  *
  367  * @return LE_FAULT         Function failed to get the date.
  368  * @return LE_OUT_OF_RANGE  The retrieved date is invalid (all fields are set to 0).
  369  * @return LE_OK            Function succeeded.
  370  *
  371  */
  372 //--------------------------------------------------------------------------------------------------
  373 le_result_t le_pos_GetDate
  374 (
  375     uint16_t* yearPtr,
  376         ///< [OUT] UTC Year A.D. [e.g. 2014].
  377 
  378     uint16_t* monthPtr,
  379         ///< [OUT] UTC Month into the year [range 1...12].
  380 
  381     uint16_t* dayPtr
  382         ///< [OUT] UTC Days into the month [range 1...31].
  383 );
  384 
  385 //--------------------------------------------------------------------------------------------------
  386 /**
  387  * Get the motion's data (Horizontal Speed, Horizontal Speed's
  388  * accuracy, Vertical Speed, Vertical Speed's accuracy).
  389  *
  390  * @return LE_FAULT         Function failed to get the motion's data.
  391  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX, UINT32_MAX).
  392  * @return LE_OK            Function succeeded.
  393  *
  394  * @note hSpeedPtr, hSpeedAccuracyPtr, vSpeedPtr, vSpeedAccuracyPtr can be set to NULL if not needed.
  395  */
  396 //--------------------------------------------------------------------------------------------------
  397 le_result_t le_pos_GetMotion
  398 (
  399     uint32_t* hSpeedPtrPtr,
  400         ///< [OUT] Horizontal Speed in m/sec.
  401 
  402     int32_t* hSpeedAccuracyPtrPtr,
  403         ///< [OUT] Horizontal Speed's accuracy in m/sec.
  404 
  405     int32_t* vSpeedPtrPtr,
  406         ///< [OUT] Vertical Speed in m/sec, positive up.
  407 
  408     int32_t* vSpeedAccuracyPtrPtr
  409         ///< [OUT] Vertical Speed's accuracy in m/sec.
  410 );
  411 
  412 //--------------------------------------------------------------------------------------------------
  413 /**
  414  * Get the heading indication.
  415  *
  416  * @return LE_FAULT         Function failed to get the heading indication.
  417  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  418  * @return LE_OK            Function succeeded.
  419  *
  420  * @note headingPtr, headingAccuracyPtr can be set to NULL if not needed.
  421  */
  422 //--------------------------------------------------------------------------------------------------
  423 le_result_t le_pos_GetHeading
  424 (
  425     int32_t* headingPtr,
  426         ///< [OUT] Heading in degrees (where 0 is True North).
  427 
  428     int32_t* headingAccuracyPtr
  429         ///< [OUT] Heading's accuracy in degrees.
  430 );
  431 
  432 //--------------------------------------------------------------------------------------------------
  433 /**
  434  * Get the direction indication. Direction of movement is the
  435  * direction that the vehicle/person is actually moving.
  436  *
  437  * @return LE_FAULT         Function failed to get the direction indication.
  438  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  439  * @return LE_OK            Function succeeded.
  440  *
  441  * @note directionPtr, directionAccuracyPtr can be set to NULL if not needed.
  442  */
  443 //--------------------------------------------------------------------------------------------------
  444 le_result_t le_pos_GetDirection
  445 (
  446     int32_t* directionPtr,
  447         ///< [OUT] Direction indication in degrees (where 0 is True North).
  448 
  449     int32_t* directionAccuracyPtr
  450         ///< [OUT] Direction's accuracy in degrees.
  451 );
  452 
  453 //--------------------------------------------------------------------------------------------------
  454 /**
  455  * Get the position sample's 2D location (latitude, longitude,
  456  * horizontal accuracy).
  457  *
  458  * @return LE_FAULT         Function failed to find the positionSample.
  459  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  460  * @return LE_OK            Function succeeded.
  461  *
  462  * @note If the caller is passing an invalid Position reference into this function,
  463  *       it is a fatal error, the function will not return.
  464  *
  465  * @note latitudePtr, longitudePtr, horizontalAccuracyPtr can be set to NULL if not needed.
  466  */
  467 //--------------------------------------------------------------------------------------------------
  468 le_result_t le_pos_sample_Get2DLocation
  469 (
  470     le_pos_SampleRef_t positionSampleRef,
  471         ///< [IN] Position sample's reference.
  472 
  473     int32_t* latitudePtr,
  474         ///< [OUT] Latitude in degrees.
  475 
  476     int32_t* longitudePtr,
  477         ///< [OUT] Longitude in degrees.
  478 
  479     int32_t* horizontalAccuracyPtr
  480         ///< [OUT] Horizontal's accuracy estimate in metres.
  481 );
  482 
  483 //--------------------------------------------------------------------------------------------------
  484 /**
  485  * Get the position sample's time.
  486  *
  487  * @return LE_FAULT         Function failed to get the time.
  488  * @return LE_OUT_OF_RANGE  The retrieved time is invalid (all fields are set to 0).
  489  * @return LE_OK            Function succeeded.
  490  *
  491  */
  492 //--------------------------------------------------------------------------------------------------
  493 le_result_t le_pos_sample_GetTime
  494 (
  495     le_pos_SampleRef_t positionSampleRef,
  496         ///< [IN] Position sample's reference.
  497 
  498     uint16_t* hoursPtr,
  499         ///< [OUT] UTC Hours into the day [range 0..23].
  500 
  501     uint16_t* minutesPtr,
  502         ///< [OUT] UTC Minutes into the hour [range 0..59].
  503 
  504     uint16_t* secondsPtr,
  505         ///< [OUT] UTC Seconds into the minute [range 0..59].
  506 
  507     uint16_t* millisecondsPtr
  508         ///< [OUT] UTC Milliseconds into the second [range 0..999].
  509 );
  510 
  511 //--------------------------------------------------------------------------------------------------
  512 /**
  513  * Get the position sample's date.
  514  *
  515  * @return LE_FAULT         Function failed to get the date.
  516  * @return LE_OUT_OF_RANGE  The retrieved date is invalid (all fields are set to 0).
  517  * @return LE_OK            Function succeeded.
  518  *
  519  */
  520 //--------------------------------------------------------------------------------------------------
  521 le_result_t le_pos_sample_GetDate
  522 (
  523     le_pos_SampleRef_t positionSampleRef,
  524         ///< [IN] Position sample's reference.
  525 
  526     uint16_t* yearPtr,
  527         ///< [OUT] UTC Year A.D. [e.g. 2014].
  528 
  529     uint16_t* monthPtr,
  530         ///< [OUT] UTC Month into the year [range 1...12].
  531 
  532     uint16_t* dayPtr
  533         ///< [OUT] UTC Days into the month [range 1...31].
  534 );
  535 
  536 //--------------------------------------------------------------------------------------------------
  537 /**
  538  * Get the position sample's altitude.
  539  *
  540  * @return LE_FAULT         Function failed to find the positionSample.
  541  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  542  * @return LE_OK            Function succeeded.
  543  *
  544  * @note If the caller is passing an invalid Position reference into this function,
  545  *       it is a fatal error, the function will not return.
  546  *
  547  * @note altitudePtr, altitudeAccuracyPtr can be set to NULL if not needed.
  548  */
  549 //--------------------------------------------------------------------------------------------------
  550 le_result_t le_pos_sample_GetAltitude
  551 (
  552     le_pos_SampleRef_t positionSampleRef,
  553         ///< [IN] Position sample's reference.
  554 
  555     int32_t* altitudePtr,
  556         ///< [OUT] Altitude in meters.
  557 
  558     int32_t* altitudeAccuracyPtr
  559         ///< [OUT] Altitude's accuracy estimate in metres.
  560 );
  561 
  562 //--------------------------------------------------------------------------------------------------
  563 /**
  564  * Get the position sample's horizontal speed.
  565  *
  566  * @return LE_FAULT         Function failed to find the positionSample.
  567  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX, UINT32_MAX).
  568  * @return LE_OK            Function succeeded.
  569  *
  570  * @note If the caller is passing an invalid Position reference into this function,
  571  *       it is a fatal error, the function will not return.
  572  *
  573  * @note hSpeedPtr, hSpeedAccuracyPtr can be set to NULL if not needed.
  574  */
  575 //--------------------------------------------------------------------------------------------------
  576 le_result_t le_pos_sample_GetHorizontalSpeed
  577 (
  578     le_pos_SampleRef_t positionSampleRef,
  579         ///< [IN] Position sample's reference.
  580 
  581     uint32_t* hspeedPtr,
  582         ///< [OUT] Horizontal speed.
  583 
  584     int32_t* hspeedAccuracyPtr
  585         ///< [OUT] Horizontal speed's accuracy estimate.
  586 );
  587 
  588 //--------------------------------------------------------------------------------------------------
  589 /**
  590  * Get the position sample's vertical speed.
  591  *
  592  * @return LE_FAULT         The function failed to find the positionSample.
  593  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is not valid (set to INT32_MAX).
  594  * @return LE_OK            The function succeeded.
  595  *
  596  * @note If the caller is passing an invalid Position reference into this function,
  597  *       it is a fatal error, the function will not return.
  598  *
  599  * @note vSpeedPtr, vSpeedAccuracyPtr can be set to NULL if not needed.
  600  */
  601 //--------------------------------------------------------------------------------------------------
  602 le_result_t le_pos_sample_GetVerticalSpeed
  603 (
  604     le_pos_SampleRef_t positionSampleRef,
  605         ///< [IN] Position sample's reference.
  606 
  607     int32_t* vspeedPtr,
  608         ///< [OUT] Vertical speed.
  609 
  610     int32_t* vspeedAccuracyPtr
  611         ///< [OUT] Vertical speed's accuracy estimate.
  612 );
  613 
  614 //--------------------------------------------------------------------------------------------------
  615 /**
  616  * Get the position sample's heading. Heading is the direction that
  617  * the vehicle/person is facing.
  618  *
  619  * @return LE_FAULT         Function failed to find the positionSample.
  620  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  621  * @return LE_OK            TFunction succeeded.
  622  *
  623  * @note If the caller is passing an invalid Position reference into this function,
  624  *       it is a fatal error, the function will not return.
  625  *
  626  * @note headingPtr, headingAccuracyPtr can be set to NULL if not needed.
  627  */
  628 //--------------------------------------------------------------------------------------------------
  629 le_result_t le_pos_sample_GetHeading
  630 (
  631     le_pos_SampleRef_t positionSampleRef,
  632         ///< [IN] Position sample's reference.
  633 
  634     int32_t* headingPtr,
  635         ///< [OUT] Heading in degrees (where 0 is True North).
  636 
  637     int32_t* headingAccuracyPtr
  638         ///< [OUT] Heading's accuracy estimate in degrees.
  639 );
  640 
  641 //--------------------------------------------------------------------------------------------------
  642 /**
  643  * Get the position sample's direction. Direction of movement is the
  644  * direction that the vehicle/person is actually moving.
  645  *
  646  * @return LE_FAULT         Function failed to find the positionSample.
  647  * @return LE_OUT_OF_RANGE  One of the retrieved parameter is invalid (set to INT32_MAX).
  648  * @return LE_OK            Function succeeded.
  649  *
  650  * @note If the caller is passing an invalid Position reference into this function,
  651  *       it is a fatal error, the function will not return.
  652  *
  653  * @note directionPtr, directionAccuracyPtr can be set to NULL if not needed.
  654  */
  655 //--------------------------------------------------------------------------------------------------
  656 le_result_t le_pos_sample_GetDirection
  657 (
  658     le_pos_SampleRef_t positionSampleRef,
  659         ///< [IN] Position sample's reference.
  660 
  661     int32_t* directionPtr,
  662         ///< [OUT] Direction in degrees (where 0 is True North).
  663 
  664     int32_t* directionAccuracyPtr
  665         ///< [OUT] Direction's accuracy estimate in degrees.
  666 );
  667 
  668 //--------------------------------------------------------------------------------------------------
  669 /**
  670  * Release the position sample.
  671  *
  672  * @note If the caller is passing an invalid Position reference into this function,
  673  *       it is a fatal error, the function will not return.
  674  */
  675 //--------------------------------------------------------------------------------------------------
  676 void le_pos_sample_Release
  677 (
  678     le_pos_SampleRef_t positionSampleRef
  679         ///< [IN] Position sample's reference.
  680 );
  681 
  682 
  683 #endif // LE_POS_INTERFACE_H_INCLUDE_GUARD
  684 
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_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:219
le_pos_GetDirection
le_result_t le_pos_GetDirection(int32_t *directionPtr, int32_t *directionAccuracyPtr)
le_pos_GetMotion
le_result_t le_pos_GetMotion(uint32_t *hSpeedPtrPtr, int32_t *hSpeedAccuracyPtrPtr, int32_t *vSpeedPtrPtr, int32_t *vSpeedAccuracyPtrPtr)
le_pos_MovementHandlerFunc_t
void(* le_pos_MovementHandlerFunc_t)(le_pos_SampleRef_t positionSampleRef, void *contextPtr)
Definition: le_pos_interface.h:241
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_sample_GetHorizontalSpeed
le_result_t le_pos_sample_GetHorizontalSpeed(le_pos_SampleRef_t positionSampleRef, uint32_t *hspeedPtr, int32_t *hspeedAccuracyPtr)
le_pos_MovementHandlerRef_t
struct le_pos_MovementHandler * le_pos_MovementHandlerRef_t
Definition: le_pos_interface.h:227
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)