le_ecall_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_ecall eCall
   14  *
   15  * @ref le_ecall_interface.h "API Reference" <br>
   16  * @ref howToEcall <br>
   17  * @ref sampleApps_eCall sample app <br>
   18  * @ref le_ecall_samples <br>
   19  *
   20  * <HR>
   21  *
   22  * eCall is a technology initiative intended to bring rapid assistance to auto
   23  * accidents anywhere in the European Union. When a serious vehicle accident occurs,
   24  * sensors automatically trigger an eCall. When activated, the in-vehicle system (IVS)
   25  * establishes a 112-voice connection.
   26  *
   27  * The Mobile Network Operator handles the eCall like any other 112 call and routes the call to the
   28  * most appropriate emergency response centre - Public Safety Answering Point (PSAP).
   29  *
   30  * At the same time, a digital "minimum set of data" (MSD) message is sent over the voice call using
   31  * in-band modem signals. The MSD includes accident information like time, location, driving
   32  * direction, and vehicle description.
   33  *
   34  * The eCall can also be activated manually. The mobile network operator identifies that the 112
   35  * call is an eCall from the “eCall flag” inserted by the vehicle’s communication module.
   36  *
   37  * This API applies for both PAN-EUROPEAN and ERA-GLONASS standards.
   38  *
   39  * @note eCall service is only available on automotive products.
   40  *
   41  * @section le_ecall_binding IPC interfaces binding
   42  *
   43  * All the functions of this API are provided by the @b modemService service.
   44  *
   45  * Here's a code sample binding to modem services:
   46  * @verbatim
   47    bindings:
   48    {
   49       clientExe.clientComponent.le_ecall -> modemService.le_ecall
   50    }
   51    @endverbatim
   52  *
   53  * @section le_ecall_operation Operation modes
   54  *
   55  * The modem can be configured to operate in three different operation modes:
   56  * - le_ecall_ForceOnlyMode(): this function configures the eCall operation mode to eCall only, only
   57  *   emergency number can be used to start an eCall session. The modem doesn't try to register on
   58  *   the Cellular network. This function forces the modem to behave as eCall only mode whatever
   59  *   U/SIM operation mode. The change doesn't persist over power cycles.
   60  *   This function can be called before making an eCall.
   61  *
   62  * - le_ecall_ForcePersistentOnlyMode(): Same as le_ecall_ForceOnlyMode(), but the change persists
   63  *   over power cycles.
   64  *
   65  * - le_ecall_ExitOnlyMode(): this function exits from eCall Only mode. It configures the eCall
   66  *   operation mode to Normal mode, the modem uses the default operation mode at power up (or after
   67  *   U/SIM hotswap). The modem behaves following the U/SIM eCall operation mode; for example the
   68  *   U/SIM can be configured only for eCall, or a combination of eCall and commercial service
   69  *   provision.
   70  *
   71  * - le_ecall_GetConfiguredOperationMode(): this function allows the user to retrieve the configured
   72  *   Operation mode.
   73  *   The configured operation mode can be:
   74  *   - @c LE_ECALL_NORMAL_MODE : normal mode. The modem behaves following the U/SIM eCall operation
   75  *                               mode.
   76  *   - @c LE_ECALL_ONLY_MODE : eCall only mode according to U/SIM operation mode or forced by
   77  *                             application through the le_ecall_ForceOnlyMode() function.
   78  *   - @c LE_ECALL_FORCED_PERSISTENT_ONLY_MODE : persistent eCall only mode.
   79  *
   80  * @section le_ecall_session eCall Session
   81  *
   82  * An eCall session is started by creating an eCall object with the le_ecall_Create() function.
   83  * The eCall session can then be stopped with le_ecall_End().
   84  *
   85  * The eCall type and the kind of activation are specified using different functions to start the
   86  * eCall session:
   87  * - le_ecall_StartManual(): initiate a manual eCall session (triggered by a passenger)
   88  * - le_ecall_StartAutomatic(): initiate an automatic eCall session (automatically triggered by
   89  * the IVS in case of accident)
   90  * - le_ecall_StartTest(): initiate a test eCall session (to test the communication between the
   91  * IVS and the PSAP)
   92  *
   93  * @warning An application must wait for the end of the ongoing eCall before triggering another
   94  * one with the @c le_ecall_StartXxx() functions. An eCall is ended when:
   95  * - the application successfully ended it with le_ecall_End() returning @c LE_OK
   96  * - or the event @ref LE_ECALL_STATE_STOPPED is received
   97  * - or the event @ref LE_ECALL_STATE_ALACK_RECEIVED_CLEAR_DOWN is received
   98  * - or the event @ref LE_ECALL_STATE_DISCONNECTED is received and no redial is launched (see
   99  * @ref le_ecall_redial section for more information about the redial process).
  100  *
  101  * When the eCall object is no longer needed, call le_ecall_Delete() to free all allocated
  102  * resources associated with the object.
  103  *
  104  * The current state of an eCall session can be queried using le_ecall_GetState().
  105  * Alternatively, an application can register a handler be notified when the session state
  106  * changes. The handler can be managed using le_ecall_AddStateChangeHandler() and
  107  * le_ecall_RemoveStateChangeHandler().
  108  *
  109  * An application can also call le_ecall_GetTerminationReason() to retrieve the reason of the call
  110  * termination when call state is @ref LE_ECALL_STATE_DISCONNECTED, and also
  111  * le_ecall_GetPlatformSpecificTerminationCode() to get platform specific termination code (refer
  112  * to your platform documentation for further details).
  113  *
  114  * @section le_ecall_concurrency Concurrency
  115  *
  116  * If another application tries to use the eCall service while a session is already in progress, the
  117  * le_ecall_StartManual(), le_ecall_StartAutomatic(), le_ecall_StartTest() functions will return a
  118  * @c LE_BUSY error. The eCall session in progress won't be interrupted or disturbed. The
  119  * application can follow the session progress with 'state' functions like le_ecall_GetState() and
  120  * le_ecall_AddStateChangeHandler().
  121  * A manual eCall can't interrupt an automatic eCall, and an automatic eCall can't interrupt a
  122  * manual eCall.
  123  *
  124  * @section le_ecall_msd Minimum Set of Data (MSD)
  125  *
  126  * The dynamic values of the MSD can be set with:
  127  * - le_ecall_SetMsdPosition() sets the position of the vehicle.
  128  * - le_ecall_SetMsdPositionN1() sets the first delta position of the vehicle.
  129  * - le_ecall_SetMsdPositionN2() sets the second delta position of the vehicle.
  130  * - le_ecall_SetMsdPassengersCount() sets the number of passengers.
  131  *
  132  * The MSD is automatically encoded with the values previously set.
  133  *
  134  * @warning Those functions return a LE_DUPLICATE error when the MSD has been already imported with
  135  * le_ecall_ImportMsd() function.
  136  *
  137  * The MSD transmission mode can be set or get with:
  138  *  - le_ecall_SetMsdTxMode()
  139  *  - le_ecall_GetMsdTxMode()
  140  *
  141  * The transmission mode can be:
  142  * - @c LE_ECALL_TX_MODE_PUSH : the MSD is pushed by the IVS
  143  * - @c LE_ECALL_TX_MODE_PULL : the MSD is sent when requested by the PSAP
  144  *
  145  * It's possible to import a prepared MSD using the le_ecall_ImportMsd() function.
  146  * The prepared MSD must answer the requirements described in the "EN 15722:2013" publication (this
  147  * publication has been prepared by Technical Committee CEN/TC 278 “Intelligent Transport Systems").
  148  *
  149  * @warning The imported MSD doesn't take into account the values provided by the
  150  * le_ecall_SetMsdXxx() functions. It overwrites any previous imported MSD or encoded MSD.
  151  *
  152  * @warning The imported MSD overwrites the control flags (automaticActivation and testCall) set by
  153  * le_ecall_StartXxx() functions (Manual, Automatic, Test). The User App is in charge of their
  154  * correct settings.
  155  *
  156  * The encoded MSD can be retrieved with le_ecall_ExportMsd() function.
  157  *
  158  * @note The User app must perform the MSD transmission by calling le_ecall_SendMsd() when the
  159  * LE_ECALL_STATE_PSAP_START_IND_RECEIVED event is received.
  160  * The MSD can be updated before calling le_ecall_SendMsd(), using the e_ecall_ImportMsd() function
  161  * or the le_ecall_SetMsdXxx() functions.
  162  *
  163  * @section le_ecall_eraglonass ERA-GLONASS compliancy
  164  *
  165  * To perform an emergency call following the ERA-GLONASS requirements, the 'systemStandard' entry
  166  * of the configuration database must be set to 'ERA-GLONASS'.
  167  *
  168  * Moreover, the User can set some specific configuration settings in accordance with the PSAP
  169  * configuration:
  170  *
  171  * - le_ecall_SetEraGlonassManualDialAttempts(): set the MANUAL_DIAL_ATTEMPTS value. If a dial
  172  *   attempt under manual emergency call initiation failed, it should be repeated maximally
  173  *   ECALL_MANUAL_DIAL_ATTEMPTS-1 times within the maximal time limit of ECALL_DIAL_DURATION.
  174  *   The default value is 10.
  175  *   Redial attempts stop once the call has been cleared down correctly, or if counter / timer
  176  *   reached their limits.
  177  *   Available for both manual and test modes.
  178  * - le_ecall_SetEraGlonassAutoDialAttempts(): set the AUTO_DIAL_ATTEMPTS value. If a dial attempt
  179  *   under automatic emergency call initiation failed, it should be repeated maximally
  180  *   ECALL_AUTO_DIAL_ATTEMPTS-1 times within the maximal time limit of ECALL_DIAL_DURATION.
  181  *   The default value is 10.
  182  *   Redial attempts stop once the call has been cleared down correctly, or if counter / timer
  183  *   reached their limits.
  184  * - le_ecall_SetEraGlonassDialDuration(): set the ECALL_DIAL_DURATION time. It is the maximum time
  185  *   the IVS have to connect the emergency call to the PSAP, including all redial attempts.
  186  *   If the call is not connected within this time (or ManualDialAttempts/AutoDialAttempts dial
  187  *   attempts), it will stop.
  188  *
  189  * The corresponding getter functions let you retrieve the configuration settings values:
  190  *
  191  * - le_ecall_GetEraGlonassManualDialAttempts(): get the MANUAL_DIAL_ATTEMPTS value.
  192  * - le_ecall_GetEraGlonassAutoDialAttempts(): get the AUTO_DIAL_ATTEMPTS value.
  193  * - le_ecall_GetEraGlonassDialDuration(): get the ECALL_DIAL_DURATION time.
  194  *
  195  * @section le_ecall_eraGlonassData ERA-GLONASS MSD additional data
  196  *
  197  * ERA-GLONASS additional data are optional and provided in the MSD message if any.
  198  * They are located in MSD data block number 12 as optional additional data.
  199  *
  200  * ERA-GLONASS MSD additional data describes:
  201  * - The crash severity (Accident Severity Index - ASI15)
  202  * - The diagnostic result
  203  * - The crash information
  204  *
  205  * ERA-GLONASS MSD additional data can be specified through the following functions:
  206  * - le_ecall_SetMsdEraGlonassCrashSeverity().
  207  * - le_ecall_ResetMsdEraGlonassCrashSeverity().
  208  * - le_ecall_SetMsdEraGlonassDiagnosticResult().
  209  * - le_ecall_ResetMsdEraGlonassDiagnosticResult().
  210  * - le_ecall_SetMsdEraGlonassCrashInfo().
  211  * - le_ecall_ResetMsdEraGlonassCrashInfo().
  212  *
  213  * ERA-GLONASS additional data is encoded using the OID version "1.4.1".
  214  * This was assigned to ERA-GLONASS optional additional data by CEN. Content of data
  215  * block in the AdditionalData should be:
  216  *
  217  * @code
  218  *
  219  * ERAOADASN1Module
  220  * DEFINITIONS
  221  * AUTOMATIC TAGS ::=
  222  * BEGIN
  223  * ERADataFormatId::= INTEGER (1)
  224  *
  225  * ERAAdditionalData ::= SEQUENCE {
  226  *    crashSeverity INTEGER(0..2047) OPTIONAL,
  227  *    diagnosticResult DiagnosticResult OPTIONAL,
  228  *    crashInfo CrashInfo OPTIONAL,
  229  *    ...
  230  * }
  231  *
  232  * DiagnosticResult ::= SEQUENCE {
  233  *    micConnectionFailure BOOLEAN OPTIONAL,
  234  *    micFailure BOOLEAN OPTIONAL,
  235  *    rightSpeakerFailure BOOLEAN OPTIONAL,
  236  *    leftSpeakerFailure BOOLEAN OPTIONAL,
  237  *    speakersFailure BOOLEAN OPTIONAL,
  238  *    ignitionLineFailure BOOLEAN OPTIONAL,
  239  *    uimFailure BOOLEAN OPTIONAL,
  240  *    statusIndicatorFailure BOOLEAN OPTIONAL,
  241  *    batteryFailure BOOLEAN OPTIONAL,
  242  *    batteryVoltageLow BOOLEAN OPTIONAL,
  243  *    crashSensorFailure BOOLEAN OPTIONAL,
  244  *    firmwareImageCorruption BOOLEAN OPTIONAL,
  245  *    commModuleInterfaceFailure BOOLEAN OPTIONAL,
  246  *    gnssReceiverFailure BOOLEAN OPTIONAL,
  247  *    raimProblem BOOLEAN OPTIONAL,
  248  *    gnssAntennaFailure BOOLEAN OPTIONAL,
  249  *    commModuleFailure BOOLEAN OPTIONAL,
  250  *    eventsMemoryOverflow BOOLEAN OPTIONAL,
  251  *    crashProfileMemoryOverflow BOOLEAN OPTIONAL,
  252  *    otherCriticalFailires BOOLEAN OPTIONAL,
  253  *    otherNotCriticalFailures BOOLEAN OPTIONAL
  254  * }
  255  *
  256  * CrashInfo ::= SEQUENCE {
  257  *    crashFront BOOLEAN OPTIONAL,
  258  *    crashLeft BOOLEAN OPTIONAL,
  259  *    crashRight BOOLEAN OPTIONAL,
  260  *    crashRear BOOLEAN OPTIONAL,
  261  *    crashRollover BOOLEAN OPTIONAL,
  262  *    crashSide BOOLEAN OPTIONAL,
  263  *    crashFrontOrSide BOOLEAN OPTIONAL,
  264  *    crashAnotherType BOOLEAN OPTIONAL
  265  * }
  266  * END
  267  * @endcode
  268  *
  269  * @section le_ecall_redial Redial management
  270  *
  271  * In the case of PAN-EUROPEAN, the redial can be performed as many times as desired but should be
  272  * performed within 2 minutes. (EN 16062:2014 -7.14.3).
  273  *
  274  * In the case of ERA-GLONASS, the redial can be performed ECALL_MANUAL_DIAL_ATTEMPTS times within
  275  * the maximal time limit of ECALL_DIAL_DURATION (GOST 54620 2013 -- Appendix A).
  276  *
  277  * The \b LE_ECALL_STATE_END_OF_REDIAL_PERIOD state event notifies the User of the redial period
  278  * end.
  279  *
  280  * @section le_ecall_configuration eCall configuration
  281  *
  282  * Some parameters used by the eCall service can be configured through APIs. This includes the
  283  * number to dial, the deregistration time, the redial interval, and some MSD information.
  284  *
  285  * @subsection le_ecall_configuration_callNumber eCall number
  286  *
  287  * By default, the number to dial is read from the FDN/SDN (Fixed Dialling Numbers/Service
  288  * Dialling Numbers) of the U/SIM, depending upon the eCall operating mode.
  289  *
  290  * However, the PSAP phone number can be queried and set with:
  291  *  - le_ecall_GetPsapNumber()
  292  *  - le_ecall_SetPsapNumber()
  293  *
  294  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" PsapNumber
  295  *
  296  * @note That PSAP number is not applied to a manual or an automatically initiated eCall. For these
  297  *       modes, an emergency call is launched.
  298  *
  299  * @warning These two functions don't modify or read the U/SIM content.
  300  *
  301  * le_ecall_UseUSimNumbers() API can be called to request the modem to read the number to
  302  * dial from the FDN/SDN of the U/SIM, depending upon the eCall operating mode.
  303  *
  304  * @subsection le_ecall_configuration_nad NAD deregistration time
  305  *
  306  * The NAD (Network Access Device, i.e. the Modem) deregistration time value can be set with the
  307  * le_ecall_SetNadDeregistrationTime() API and retrieved with the
  308  * le_ecall_GetNadDeregistrationTime() API.
  309  *
  310  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" NadTime
  311  *
  312  * 1. PAN-EUROPEAN standard (<em>EN 16062</em>) defines the T9 and T10 timers. After an eCall
  313  *    clear-down, an <b>eCall only</b> IVS shall:
  314  *    - Remain registered on the network for at least the duration of T9, which is set to
  315  *      one hour by default.
  316  *    - Deregister from the network after the expiration of T10, which duration is set to
  317  *      twelve hours by default.
  318  * 2. ERA-GLONASS standard (<em>ENG_GOST_R_54620</em>) defines the NAD_DEREGISTRATION_TIME
  319  *    with a minimal value of two hours and a maximum value of twelve hours. After an eCall
  320  *    clear-down, the IVS shall remain registered on the network and deregister from the network
  321  *    after the expiration of the NAD_DEREGISTRATION_TIME.
  322  *
  323  * The le_ecall_SetNadDeregistrationTime() API is used to set the duration of a
  324  * <em>deregistration timer</em>: after an eCall clear-down, the IVS remains registered on the
  325  * network for the duration of this timer and then automatically deregisters from the network upon
  326  * its expiration.
  327  *
  328  * @subsubsection le_ecall_configuration_nad_panEU PAN-EUROPEAN standard
  329  * As the T9 timer duration is fixed to one hour, the notified events depend on the
  330  * <em>deregistration timer</em> duration:
  331  *  - If its duration is set to one hour, the @ref LE_ECALL_STATE_TIMEOUT_T9 event will be reported.
  332  *    In this case deregistration is automatically performed when the T9 timeout indication is
  333  *    received.
  334  *  - If its duration is set to more than one hour and less than twelve hours then the
  335  *    @ref LE_ECALL_STATE_TIMEOUT_T10 event will be reported when the <em>deregistration timer</em>
  336  *    expires. The T9 timeout (@ref LE_ECALL_STATE_TIMEOUT_T9 event) will not be notified.
  337  *    In this case deregistration is automatically performed when the <em>deregistration timer</em>
  338  *    expires, provided that the application didn't already deregister from the network before.
  339  *
  340  * @subsubsection le_ecall_configuration_nad_eraGlonass ERA-GLONASS standard
  341  *  - The @ref LE_ECALL_STATE_TIMEOUT_T9 event is not reported as it is not defined in the
  342  *    ERA-GLONASS standard.
  343  *  - The NAD_DEREGISTRATION_TIME default value is eight hours, as defined by
  344  *    <em>GOST_R 54620 Table A.1</em>. It can be changed with le_ecall_SetNadDeregistrationTime()
  345  *    and the value must be set between two and twelve hours.
  346  *  - The @ref LE_ECALL_STATE_TIMEOUT_T10 event will be reported when the NAD_DEREGISTRATION_TIME
  347  *    expires. In this case deregistration is automatically performed when the timer expires.
  348  *
  349  * @subsubsection le_ecall_configuration_nad_timerValue Timer value
  350  *
  351  * Although the time is set in minutes the value is taken in hours, for example:
  352  * - from 1 to 60 minutes -> 1 hour
  353  * - from 61 to 120 minutes -> 2 hours, etc.
  354  *
  355  * Example: if @c deregTime parameter unit is minutes, the effective time is:
  356  * @code ECallConfiguration.nad_deregistration_time = (deregTime+59)/60; @endcode
  357  *
  358  * After termination of an emergency call the in-vehicle system remains registered on the network
  359  * for the period of time, defined by the installation parameter NAD_DEREGISTRATION_TIME.
  360  *
  361  * @warning Be sure to check the possible values of NAD_DEREGISTRATION_TIME for your specific
  362  * platform.
  363  *
  364  * @subsection le_ecall_configuration_redialInterval Redial interval
  365  *
  366  * The minimum interval value between dial attempts can be set or get with:
  367  *  - le_ecall_SetIntervalBetweenDialAttempts()
  368  *  - le_ecall_GetIntervalBetweenDialAttempts()
  369  *
  370  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" DialTimer
  371  *
  372  * The default value is set to 30 seconds.
  373  *
  374  * The time is counted from the start of the first dial attempt.
  375  *
  376  * If more time has expired during the dial attempt, it will wait for 1 second to allow hangup
  377  * before redialing.
  378  *
  379  * If less time has expired during the dial attempt, it will wait for
  380  * (interval - 'dial attempt duration') seconds to allow hangup before redialing.
  381  *
  382  * In the case the call was connected, the redial will be immediate.
  383  *
  384  * le_ecall_SetIntervalBetweenDialAttempts() is available for both manual and test modes.
  385  *
  386  * @subsection le_ecall_configuration_misc Miscellaneous
  387  *
  388  * The preferred system standard defaults to PAN-EUROPEAN
  389  * It can be set an gotten with the following functions:
  390  * - le_ecall_SetSystemStandard()
  391  * - le_ecall_GetSystemStandard()
  392  *
  393  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" Standard
  394  *
  395  * The MSD version can be set and and gotten with the following functions:
  396  * - le_ecall_SetMsdVersion()
  397  * - le_ecall_GetMsdVersion()
  398  *
  399  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" MsdVersion
  400  *
  401  * The vehicle type can be set and gotten with the following functions:
  402  * - le_ecall_SetVehicleType()
  403  * - le_ecall_GetVehicleType()
  404  *
  405  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" Vehicle
  406  *
  407  * The vehicle identifier can be set and gotten with the following functions:
  408  * - le_ecall_SetVIN()
  409  * - le_ecall_GetVIN()
  410  *
  411  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" VIN
  412  *
  413  * The propulsion type can be set and gotten with the following functions:
  414  * - le_ecall_SetPropulsionType()
  415  * - le_ecall_GetPropulsionType()
  416  *
  417  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" Propulsion
  418  *
  419  * @section le_ecall_samples Code samples
  420  *
  421  * A sample code that implements an eCall test session with a local voice prompt can be found in
  422  * \b eCallWPrompt.c file (please refer to @ref c_ecallWPromptSample page).
  423  *
  424  * A sample code that implements an eCall test session with a voice call connection can be found in
  425  * \b eCallWVoice.c file (please refer to @ref c_ecallWVoiceSample page).
  426  *
  427  * If you want to have a look at a more in-depth usage of these APIs, please refer to the
  428  * @ref le_ecall_interface.h.
  429  *
  430  * <HR>
  431  *
  432  * Copyright (C) Sierra Wireless Inc.
  433  */
  434 /**
  435  * @file le_ecall_interface.h
  436  *
  437  * Legato @ref c_ecall include file.
  438  *
  439  * Copyright (C) Sierra Wireless Inc.
  440  */
  441 /**
  442  * @page c_ecallWPromptSample Sample code of an eCall test session with a local voice prompt
  443  *
  444  * @include "apps/test/modemServices/ecall/ecallWPrompt/eCallWPrompt/eCallWPrompt.c"
  445  */
  446 /**
  447  * @page c_ecallWVoiceSample Sample code an eCall test session with a voice call connection
  448  *
  449  * @include "apps/test/modemServices/ecall/ecallWVoice/eCallWVoice/eCallWVoice.c"
  450  */
  451 
  452 #ifndef LE_ECALL_INTERFACE_H_INCLUDE_GUARD
  453 #define LE_ECALL_INTERFACE_H_INCLUDE_GUARD
  454 
  455 
  456 #include "legato.h"
  457 
  458 // Interface specific includes
  459 #include "le_mdmDefs_interface.h"
  460 #include "le_mcc_interface.h"
  461 
  462 
  463 //--------------------------------------------------------------------------------------------------
  464 /**
  465  * Type for handler called when a server disconnects.
  466  */
  467 //--------------------------------------------------------------------------------------------------
  468 typedef void (*le_ecall_DisconnectHandler_t)(void *);
  469 
  470 //--------------------------------------------------------------------------------------------------
  471 /**
  472  *
  473  * Connect the current client thread to the service providing this API. Block until the service is
  474  * available.
  475  *
  476  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  477  * called before any other functions in this API.  Normally, ConnectService is automatically called
  478  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  479  *
  480  * This function is created automatically.
  481  */
  482 //--------------------------------------------------------------------------------------------------
  483 void le_ecall_ConnectService
  484 (
  485     void
  486 );
  487 
  488 //--------------------------------------------------------------------------------------------------
  489 /**
  490  *
  491  * Try to connect the current client thread to the service providing this API. Return with an error
  492  * if the service is not available.
  493  *
  494  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  495  * called before any other functions in this API.  Normally, ConnectService is automatically called
  496  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  497  *
  498  * This function is created automatically.
  499  *
  500  * @return
  501  *  - LE_OK if the client connected successfully to the service.
  502  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  503  *    bound.
  504  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  505  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  506  */
  507 //--------------------------------------------------------------------------------------------------
  508 le_result_t le_ecall_TryConnectService
  509 (
  510     void
  511 );
  512 
  513 //--------------------------------------------------------------------------------------------------
  514 /**
  515  * Set handler called when server disconnection is detected.
  516  *
  517  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  518  * to continue without exiting, it should call longjmp() from inside the handler.
  519  */
  520 //--------------------------------------------------------------------------------------------------
  521 void le_ecall_SetServerDisconnectHandler
  522 (
  523     le_ecall_DisconnectHandler_t disconnectHandler,
  524     void *contextPtr
  525 );
  526 
  527 //--------------------------------------------------------------------------------------------------
  528 /**
  529  *
  530  * Disconnect the current client thread from the service providing this API.
  531  *
  532  * Normally, this function doesn't need to be called. After this function is called, there's no
  533  * longer a connection to the service, and the functions in this API can't be used. For details, see
  534  * @ref apiFilesC_client.
  535  *
  536  * This function is created automatically.
  537  */
  538 //--------------------------------------------------------------------------------------------------
  539 void le_ecall_DisconnectService
  540 (
  541     void
  542 );
  543 
  544 
  545 //--------------------------------------------------------------------------------------------------
  546 /**
  547  * MSD message length in bytes.
  548  */
  549 //--------------------------------------------------------------------------------------------------
  550 #define LE_ECALL_MSD_MAX_LEN 140
  551 
  552 //--------------------------------------------------------------------------------------------------
  553 /**
  554  * Vehicle Identification Number (VIN) string LENGTH. (without nulltermination)
  555  */
  556 //--------------------------------------------------------------------------------------------------
  557 #define LE_ECALL_VIN_MAX_LEN 17
  558 
  559 //--------------------------------------------------------------------------------------------------
  560 /**
  561  * Vehicle Identification Number (VIN) string BYTES. One extra byte is added for the null
  562  * character.
  563  */
  564 //--------------------------------------------------------------------------------------------------
  565 #define LE_ECALL_VIN_MAX_BYTES 18
  566 
  567 //--------------------------------------------------------------------------------------------------
  568 /**
  569  * Reference returned by Create function and used by other functions
  570  */
  571 //--------------------------------------------------------------------------------------------------
  572 typedef struct le_ecall_Call* le_ecall_CallRef_t;
  573 
  574 
  575 //--------------------------------------------------------------------------------------------------
  576 /**
  577  *  Configured operation modes.
  578  */
  579 //--------------------------------------------------------------------------------------------------
  580 typedef enum
  581 {
  582     LE_ECALL_NORMAL_MODE = 0,
  583         ///< Normal mode.
  584     LE_ECALL_ONLY_MODE = 1,
  585         ///< eCall only mode according to U/SIM operation mode or forced
  586         ///< by application through the le_ecall_ForceOnlyMode() function.
  587     LE_ECALL_FORCED_PERSISTENT_ONLY_MODE = 2
  588         ///< Persistent eCall only mode.
  589 }
  590 le_ecall_OpMode_t;
  591 
  592 
  593 //--------------------------------------------------------------------------------------------------
  594 /**
  595  *  Configure which standard to follow for the eCall, either PAN European eCall or ERA GLONASS.
  596  */
  597 //--------------------------------------------------------------------------------------------------
  598 typedef enum
  599 {
  600     LE_ECALL_PAN_EUROPEAN = 0,
  601         ///< PAN-EUROPEAN standard
  602     LE_ECALL_ERA_GLONASS = 1
  603         ///< ERA GLONASS standard
  604 }
  605 le_ecall_SystemStandard_t;
  606 
  607 
  608 //--------------------------------------------------------------------------------------------------
  609 /**
  610  *  eCall session states.
  611  */
  612 //--------------------------------------------------------------------------------------------------
  613 typedef enum
  614 {
  615     LE_ECALL_STATE_UNKNOWN = 0,
  616         ///< Unknown state.
  617     LE_ECALL_STATE_STARTED = 1,
  618         ///< eCall session started.
  619     LE_ECALL_STATE_CONNECTED = 2,
  620         ///< Emergency call is established.
  621     LE_ECALL_STATE_DISCONNECTED = 3,
  622         ///< Emergency call is disconnected.
  623     LE_ECALL_STATE_WAITING_PSAP_START_IND = 4,
  624         ///< Waiting for PSAP start indication.
  625     LE_ECALL_STATE_PSAP_START_IND_RECEIVED = 5,
  626         ///< PSAP start indication received.
  627     LE_ECALL_STATE_MSD_TX_STARTED = 6,
  628         ///< MSD transmission is started.
  629     LE_ECALL_STATE_LLNACK_RECEIVED = 7,
  630         ///< LL-NACK received.
  631     LE_ECALL_STATE_LLACK_RECEIVED = 8,
  632         ///< LL-ACK received.
  633     LE_ECALL_STATE_MSD_TX_COMPLETED = 9,
  634         ///< MSD transmission is complete.
  635     LE_ECALL_STATE_MSD_TX_FAILED = 10,
  636         ///< MSD transmission has failed.
  637     LE_ECALL_STATE_ALACK_RECEIVED_POSITIVE = 11,
  638         ///< AL-ACK received.
  639     LE_ECALL_STATE_ALACK_RECEIVED_CLEAR_DOWN = 12,
  640         ///< AL-ACK clear-down received.
  641     LE_ECALL_STATE_STOPPED = 13,
  642         ///< eCall session has been stopped by PSAP
  643         ///< or IVS le_ecall_End().
  644     LE_ECALL_STATE_RESET = 14,
  645         ///< eCall session has lost synchronization and starts over.
  646     LE_ECALL_STATE_COMPLETED = 15,
  647         ///< eCall session completed. The modem successfully completed
  648         ///< the MSD transmission and received two AL-ACKs (positive).
  649         ///< Can now switch to voice path.
  650     LE_ECALL_STATE_FAILED = 16,
  651         ///< Unsuccessful eCall session.
  652     LE_ECALL_STATE_END_OF_REDIAL_PERIOD = 17,
  653         ///< End of the redial period.
  654     LE_ECALL_STATE_TIMEOUT_T2 = 18,
  655         ///< Timeout for Timer T2 (see CEN-EN 16062, annex A)
  656     LE_ECALL_STATE_TIMEOUT_T3 = 19,
  657         ///< Timeout for Timer T3 (see CEN-EN 16062, annex A)
  658     LE_ECALL_STATE_TIMEOUT_T5 = 20,
  659         ///< Timeout for Timer T5 (see CEN-EN 16062, annex A)
  660     LE_ECALL_STATE_TIMEOUT_T6 = 21,
  661         ///< Timeout for Timer T6 (see CEN-EN 16062, annex A)
  662     LE_ECALL_STATE_TIMEOUT_T7 = 22,
  663         ///< Timeout for Timer T7 (see CEN-EN 16062, annex A)
  664     LE_ECALL_STATE_TIMEOUT_T9 = 23,
  665         ///< Timeout for Timer T9 (see CEN-EN 16062, annex A)
  666     LE_ECALL_STATE_TIMEOUT_T10 = 24
  667         ///< Timeout for Timer T10 (see CEN-EN 16062, annex A)
  668 }
  669 le_ecall_State_t;
  670 
  671 
  672 //--------------------------------------------------------------------------------------------------
  673 /**
  674  *  eCall MSD transmission mode.
  675  */
  676 //--------------------------------------------------------------------------------------------------
  677 typedef enum
  678 {
  679     LE_ECALL_TX_MODE_PULL = 0,
  680         ///< Pull mode (modem/host waits for MSD request from PSAP to send MSD).
  681     LE_ECALL_TX_MODE_PUSH = 1
  682         ///< Push mode (modem/host sends MSD to PSAP right after eCall is connected).
  683 }
  684 le_ecall_MsdTxMode_t;
  685 
  686 
  687 //--------------------------------------------------------------------------------------------------
  688 /**
  689  *  eCall MSD vehicle type
  690  */
  691 //--------------------------------------------------------------------------------------------------
  692 typedef enum
  693 {
  694     LE_ECALL_MSD_VEHICLE_PASSENGER_M1 = 0,
  695         ///< Passenger vehicle (Class M1)
  696     LE_ECALL_MSD_VEHICLE_BUS_M2 = 1,
  697         ///< Buses and coaches (Class M2)
  698     LE_ECALL_MSD_VEHICLE_BUS_M3 = 2,
  699         ///< Buses and coaches (Class M3)
  700     LE_ECALL_MSD_VEHICLE_COMMERCIAL_N1 = 3,
  701         ///< Light commercial vehicles (Class N1)
  702     LE_ECALL_MSD_VEHICLE_HEAVY_N2 = 4,
  703         ///< Heavy duty vehicles (Class N2)
  704     LE_ECALL_MSD_VEHICLE_HEAVY_N3 = 5,
  705         ///< Heavy duty vehicles (Class N3)
  706     LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L1E = 6,
  707         ///< Motorcycles (Class L1e)
  708     LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L2E = 7,
  709         ///< Motorcycles (Class L2e)
  710     LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L3E = 8,
  711         ///< Motorcycles (Class L3e)
  712     LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L4E = 9,
  713         ///< Motorcycles (Class L4e)
  714     LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L5E = 10,
  715         ///< Motorcycles (Class L5e)
  716     LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L6E = 11,
  717         ///< Motorcycles (Class L6e)
  718     LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L7E = 12
  719         ///< Motorcycles (Class L7e)
  720 }
  721 le_ecall_MsdVehicleType_t;
  722 
  723 
  724 //--------------------------------------------------------------------------------------------------
  725 /**
  726  * Propulsion type Bit Mask
  727  */
  728 //--------------------------------------------------------------------------------------------------
  729 typedef enum
  730 {
  731     LE_ECALL_PROPULSION_TYPE_GASOLINE = 0x1,        ///< Gasoline propulsion)
  732     LE_ECALL_PROPULSION_TYPE_DIESEL = 0x2,        ///< Diesel propulsion
  733     LE_ECALL_PROPULSION_TYPE_NATURALGAS = 0x4,        ///< Compressed natural gas propulsion
  734     LE_ECALL_PROPULSION_TYPE_PROPANE = 0x8,        ///< Liquid propane gas propulsion
  735     LE_ECALL_PROPULSION_TYPE_ELECTRIC = 0x10,        ///< Electric propulsion
  736     LE_ECALL_PROPULSION_TYPE_HYDROGEN = 0x20,        ///< Hydrogen propulsion
  737     LE_ECALL_PROPULSION_TYPE_OTHER = 0x40        ///< Other type of propulsions
  738 }
  739 le_ecall_PropulsionTypeBitMask_t;
  740 
  741 
  742 //--------------------------------------------------------------------------------------------------
  743 /**
  744  * Diagnostic result Bit Mask (64 bits)
  745  *
  746  */
  747 //--------------------------------------------------------------------------------------------------
  748 typedef enum
  749 {
  750     LE_ECALL_DIAG_RESULT_PRESENT_MIC_CONNECTION_FAILURE = 0x1,        ///< Present Mic connection failure.
  751     LE_ECALL_DIAG_RESULT_MIC_CONNECTION_FAILURE = 0x2,        ///< Mic connection failure status.
  752     LE_ECALL_DIAG_RESULT_PRESENT_MIC_FAILURE = 0x4,        ///< Present Mic  failure.
  753     LE_ECALL_DIAG_RESULT_MIC_FAILURE = 0x8,        ///< Mic failure status.
  754     LE_ECALL_DIAG_RESULT_PRESENT_RIGHT_SPEAKER_FAILURE = 0x10,        ///< Present Right speaker failure.
  755     LE_ECALL_DIAG_RESULT_RIGHT_SPEAKER_FAILURE = 0x20,        ///< Right speaker failure status.
  756     LE_ECALL_DIAG_RESULT_PRESENT_LEFT_SPEAKER_FAILURE = 0x40,        ///< Present Left speaker failure.
  757     LE_ECALL_DIAG_RESULT_LEFT_SPEAKER_FAILURE = 0x80,        ///< Left speaker failure status.
  758     LE_ECALL_DIAG_RESULT_PRESENT_SPEAKERS_FAILURE = 0x100,        ///< Present Speaker failure.
  759     LE_ECALL_DIAG_RESULT_SPEAKERS_FAILURE = 0x200,        ///< Speaker failure status.
  760     LE_ECALL_DIAG_RESULT_PRESENT_IGNITION_LINE_FAILURE = 0x400,        ///< Present Ignition line failure.
  761     LE_ECALL_DIAG_RESULT_IGNITION_LINE_FAILURE = 0x800,        ///< Ignition line failure status.
  762     LE_ECALL_DIAG_RESULT_PRESENT_UIM_FAILURE = 0x1000,        ///< Present UIM failure.
  763     LE_ECALL_DIAG_RESULT_UIM_FAILURE = 0x2000,        ///< UIM failure status.
  764     LE_ECALL_DIAG_RESULT_PRESENT_STATUS_INDICATOR_FAILURE = 0x4000,        ///< Present Status indicator failure.
  765     LE_ECALL_DIAG_RESULT_STATUS_INDICATOR_FAILURE = 0x8000,        ///< Status indicator failure status.
  766     LE_ECALL_DIAG_RESULT_PRESENT_BATTERY_FAILURE = 0x10000,        ///< Present Battery failure.
  767     LE_ECALL_DIAG_RESULT_BATTERY_FAILURE = 0x20000,        ///< Battery failure status.
  768     LE_ECALL_DIAG_RESULT_PRESENT_BATTERY_VOLTAGE_LOW = 0x40000,        ///< Present Battery voltage low failure.
  769     LE_ECALL_DIAG_RESULT_BATTERY_VOLTAGE_LOW = 0x80000,        ///< Battery voltage low failure status.
  770     LE_ECALL_DIAG_RESULT_PRESENT_CRASH_SENSOR_FAILURE = 0x100000,        ///< Present Crash sensor failure.
  771     LE_ECALL_DIAG_RESULT_CRASH_SENSOR_FAILURE = 0x200000,        ///< Crash sensor failure status.
  772     LE_ECALL_DIAG_RESULT_PRESENT_FIRMWARE_IMAGE_CORRUPTION = 0x400000,        ///< Present Firmware image corruption failure.
  773     LE_ECALL_DIAG_RESULT_FIRMWARE_IMAGE_CORRUPTION = 0x800000,        ///< Firmware image corruption failure status.
  774     LE_ECALL_DIAG_RESULT_PRESENT_COMM_MODULE_INTERFACE_FAILURE = 0x1000000,        ///< Present Comm module interface failure.
  775     LE_ECALL_DIAG_RESULT_COMM_MODULE_INTERFACE_FAILURE = 0x2000000,        ///< Comm module interface failure status.
  776     LE_ECALL_DIAG_RESULT_PRESENT_GNSS_RECEIVER_FAILURE = 0x4000000,        ///< Present GNSS receiver failure.
  777     LE_ECALL_DIAG_RESULT_GNSS_RECEIVER_FAILURE = 0x8000000,        ///< GNSS receiver failure status.
  778     LE_ECALL_DIAG_RESULT_PRESENT_RAIM_PROBLEM = 0x10000000,        ///< Present RAIM problem.
  779     LE_ECALL_DIAG_RESULT_RAIM_PROBLEM = 0x20000000,        ///< RAIM problem status.
  780     LE_ECALL_DIAG_RESULT_PRESENT_GNSS_ANTENNA_FAILURE = 0x40000000,        ///< Present GNSS antenna failure.
  781     LE_ECALL_DIAG_RESULT_GNSS_ANTENNA_FAILURE = 0x80000000,        ///< GNSS antenna failure status.
  782     LE_ECALL_DIAG_RESULT_PRESENT_COMM_MODULE_FAILURE = 0x100000000,        ///< Present Comm module failure.
  783     LE_ECALL_DIAG_RESULT_COMM_MODULE_FAILURE = 0x200000000,        ///< Comm module failure status.
  784     LE_ECALL_DIAG_RESULT_PRESENT_EVENTS_MEMORY_OVERFLOW = 0x400000000,        ///< Present Events memory overflow.
  785     LE_ECALL_DIAG_RESULT_EVENTS_MEMORY_OVERFLOW = 0x800000000,        ///< Events memory overflow status.
  786     LE_ECALL_DIAG_RESULT_PRESENT_CRASH_PROFILE_MEMORY_OVERFLOW = 0x1000000000,        ///< Present Crash profile memory overflow.
  787     LE_ECALL_DIAG_RESULT_CRASH_PROFILE_MEMORY_OVERFLOW = 0x2000000000,        ///< Crash profile memory overflow status.
  788     LE_ECALL_DIAG_RESULT_PRESENT_OTHER_CRITICAL_FAILURES = 0x4000000000,        ///< Present Other critical failures.
  789     LE_ECALL_DIAG_RESULT_OTHER_CRITICAL_FAILURES = 0x8000000000,        ///< Other critical failures status.
  790     LE_ECALL_DIAG_RESULT_PRESENT_OTHER_NOT_CRITICAL_FAILURES = 0x10000000000,        ///< Present Other not critical failures.
  791     LE_ECALL_DIAG_RESULT_OTHER_NOT_CRITICAL_FAILURES = 0x20000000000        ///< Other not critical failures status.
  792 }
  793 le_ecall_DiagnosticResultBitMask_t;
  794 
  795 
  796 //--------------------------------------------------------------------------------------------------
  797 /**
  798  * Crash information Bit Mask (16 bits) indicating the type of road accident.
  799  *
  800  */
  801 //--------------------------------------------------------------------------------------------------
  802 typedef enum
  803 {
  804     LE_ECALL_CRASH_INFO_PRESENT_CRASH_FRONT = 0x1,        ///< Present Front collision indicator.
  805     LE_ECALL_CRASH_INFO_CRASH_FRONT = 0x2,        ///< Front collision indicator.
  806     LE_ECALL_CRASH_INFO_PRESENT_CRASH_LEFT = 0x4,        ///< Present Left collision indicator.
  807     LE_ECALL_CRASH_INFO_CRASH_LEFT = 0x8,        ///< Left collision indicator.
  808     LE_ECALL_CRASH_INFO_PRESENT_CRASH_RIGHT = 0x10,        ///< Present Right collision indicator
  809     LE_ECALL_CRASH_INFO_CRASH_RIGHT = 0x20,        ///< Right collision indicator
  810     LE_ECALL_CRASH_INFO_PRESENT_CRASH_REAR = 0x40,        ///< Present indicator
  811     LE_ECALL_CRASH_INFO_CRASH_REAR = 0x80,        ///< Rear impact indicator.
  812     LE_ECALL_CRASH_INFO_PRESENT_CRASH_ROLLOVER = 0x100,        ///< Present Rollover indicator.
  813     LE_ECALL_CRASH_INFO_CRASH_ROLLOVER = 0x200,        ///< Rollover indicator.
  814     LE_ECALL_CRASH_INFO_PRESENT_CRASH_SIDE = 0x400,        ///< Present Side collision indicator.
  815     LE_ECALL_CRASH_INFO_CRASH_SIDE = 0x800,        ///< Side collision indicator.
  816     LE_ECALL_CRASH_INFO_PRESENT_CRASH_FRONT_OR_SIDE = 0x1000,        ///< Present Front or side collision indicator.
  817     LE_ECALL_CRASH_INFO_CRASH_FRONT_OR_SIDE = 0x2000,        ///< Front or side collision indicator.
  818     LE_ECALL_CRASH_INFO_PRESENT_CRASH_ANOTHER_TYPE = 0x4000,        ///< Present Other types of damage indicator.
  819     LE_ECALL_CRASH_INFO_CRASH_ANOTHER_TYPE = 0x8000        ///< Other types of damage indicator.
  820 }
  821 le_ecall_CrashInfoBitMask_t;
  822 
  823 
  824 //--------------------------------------------------------------------------------------------------
  825 /**
  826  * Reference type used by Add/Remove functions for EVENT 'le_ecall_StateChange'
  827  */
  828 //--------------------------------------------------------------------------------------------------
  829 typedef struct le_ecall_StateChangeHandler* le_ecall_StateChangeHandlerRef_t;
  830 
  831 
  832 //--------------------------------------------------------------------------------------------------
  833 /**
  834  * Handler for eCall state changes.
  835  *
  836  */
  837 //--------------------------------------------------------------------------------------------------
  838 typedef void (*le_ecall_StateChangeHandlerFunc_t)
  839 (
  840     le_ecall_CallRef_t ecallRef,
  841         ///< eCall reference
  842     le_ecall_State_t state,
  843         ///< eCall state
  844     void* contextPtr
  845         ///<
  846 );
  847 
  848 //--------------------------------------------------------------------------------------------------
  849 /**
  850  * This function configures the eCall operation mode to eCall only, only emergency number can be
  851  * used to start an eCall session. The modem doesn't try to register on the Cellular network.
  852  * This function forces the modem to behave as eCall only mode whatever U/SIM operation mode.
  853  * The change doesn't persist over power cycles.
  854  * This function can be called before making an eCall.
  855  *
  856  * @return
  857  *      - LE_OK on success
  858  *      - LE_FAULT for other failures
  859  */
  860 //--------------------------------------------------------------------------------------------------
  861 le_result_t le_ecall_ForceOnlyMode
  862 (
  863     void
  864 );
  865 
  866 //--------------------------------------------------------------------------------------------------
  867 /**
  868  * Same as le_ecall_ForceOnlyMode(), but the change persists over power cycles.
  869  *
  870  * @return
  871  *      - LE_OK on success
  872  *      - LE_FAULT for other failures
  873  */
  874 //--------------------------------------------------------------------------------------------------
  875 le_result_t le_ecall_ForcePersistentOnlyMode
  876 (
  877     void
  878 );
  879 
  880 //--------------------------------------------------------------------------------------------------
  881 /**
  882  * This function exits from eCall Only mode. It configures the eCall operation mode to Normal mode,
  883  * the modem uses the default operation mode at power up (or after U/SIM hotswap). The modem behaves
  884  * following the U/SIM eCall operation mode; for example the U/SIM can be configured only for eCall,
  885  * or a combination of eCall and commercial service provision.
  886  *
  887  * @return
  888  *      - LE_OK on success
  889  *      - LE_FAULT for other failures
  890  */
  891 //--------------------------------------------------------------------------------------------------
  892 le_result_t le_ecall_ExitOnlyMode
  893 (
  894     void
  895 );
  896 
  897 //--------------------------------------------------------------------------------------------------
  898 /**
  899  * Get the configured Operation mode.
  900  *
  901  * @return
  902  *      - LE_OK     on success
  903  *      - LE_FAULT  for other failures
  904  *
  905  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  906  *       function will not return.
  907  */
  908 //--------------------------------------------------------------------------------------------------
  909 le_result_t le_ecall_GetConfiguredOperationMode
  910 (
  911     le_ecall_OpMode_t* opModePtr
  912         ///< [OUT] Operation mode
  913 );
  914 
  915 //--------------------------------------------------------------------------------------------------
  916 /**
  917  * Add handler function for EVENT 'le_ecall_StateChange'
  918  *
  919  * This event provides information on eCall state changes.
  920  *
  921  */
  922 //--------------------------------------------------------------------------------------------------
  923 le_ecall_StateChangeHandlerRef_t le_ecall_AddStateChangeHandler
  924 (
  925     le_ecall_StateChangeHandlerFunc_t handlerPtr,
  926         ///< [IN]
  927     void* contextPtr
  928         ///< [IN]
  929 );
  930 
  931 //--------------------------------------------------------------------------------------------------
  932 /**
  933  * Remove handler function for EVENT 'le_ecall_StateChange'
  934  */
  935 //--------------------------------------------------------------------------------------------------
  936 void le_ecall_RemoveStateChangeHandler
  937 (
  938     le_ecall_StateChangeHandlerRef_t handlerRef
  939         ///< [IN]
  940 );
  941 
  942 //--------------------------------------------------------------------------------------------------
  943 /**
  944  * Create a new eCall object
  945  *
  946  * The eCall is not actually established at this point. It's still up to the caller to call
  947  * le_ecall_Start() when ready.
  948  *
  949  * @return
  950  *      - A reference to the new Call object.
  951  *
  952  * @note On failure, the process exits; you don't have to worry about checking the returned
  953  *       reference for validity.
  954  */
  955 //--------------------------------------------------------------------------------------------------
  956 le_ecall_CallRef_t le_ecall_Create
  957 (
  958     void
  959 );
  960 
  961 //--------------------------------------------------------------------------------------------------
  962 /**
  963  * Call to free up a call reference.
  964  *
  965  * @note This will free the reference, but not necessarily stop an active eCall. If there are
  966  *       other holders of this reference the eCall will remain active.
  967  */
  968 //--------------------------------------------------------------------------------------------------
  969 void le_ecall_Delete
  970 (
  971     le_ecall_CallRef_t ecallRef
  972         ///< [IN] eCall reference
  973 );
  974 
  975 //--------------------------------------------------------------------------------------------------
  976 /**
  977  * Set the system standard.
  978  * Default is PAN EUROPEAN
  979  *
  980  * @return
  981  *  - LE_OK on success
  982  *  - LE_FAULT for other failures
  983  */
  984 //--------------------------------------------------------------------------------------------------
  985 le_result_t le_ecall_SetSystemStandard
  986 (
  987     le_ecall_SystemStandard_t systemStandard
  988         ///< [IN] System standard
  989 );
  990 
  991 //--------------------------------------------------------------------------------------------------
  992 /**
  993  * Get the system standard.
  994  *
  995  * @return
  996  *  - LE_OK on success
  997  *  - LE_FAULT for other failures
  998  *  - LE_BAD_PARAMETER parameter is NULL
  999  */
 1000 //--------------------------------------------------------------------------------------------------
 1001 le_result_t le_ecall_GetSystemStandard
 1002 (
 1003     le_ecall_SystemStandard_t* systemStandardPtr
 1004         ///< [OUT] System Standard
 1005 );
 1006 
 1007 //--------------------------------------------------------------------------------------------------
 1008 /**
 1009  * Set the MSDs version.
 1010  * Default value is 1
 1011  *
 1012  * @return
 1013  *  - LE_OK on success
 1014  *  - LE_FAULT for other failures
 1015  */
 1016 //--------------------------------------------------------------------------------------------------
 1017 le_result_t le_ecall_SetMsdVersion
 1018 (
 1019     uint32_t msdVersion
 1020         ///< [IN] Msd version
 1021 );
 1022 
 1023 //--------------------------------------------------------------------------------------------------
 1024 /**
 1025  * Get the MSD version.
 1026  *
 1027  * @return
 1028  *  - LE_OK on success
 1029  *  - LE_FAULT for other failures
 1030  *  - LE_BAD_PARAMETER parameter is NULL
 1031  */
 1032 //--------------------------------------------------------------------------------------------------
 1033 le_result_t le_ecall_GetMsdVersion
 1034 (
 1035     uint32_t* msdVersionPtr
 1036         ///< [OUT] Msd version
 1037 );
 1038 
 1039 //--------------------------------------------------------------------------------------------------
 1040 /**
 1041  * Set the Vehicled Type
 1042  * Default value is 0
 1043  *
 1044  * @return
 1045  *  - LE_OK on success
 1046  *  - LE_FAULT for other failures
 1047  */
 1048 //--------------------------------------------------------------------------------------------------
 1049 le_result_t le_ecall_SetVehicleType
 1050 (
 1051     le_ecall_MsdVehicleType_t vehicleType
 1052         ///< [IN] Vehicle type
 1053 );
 1054 
 1055 //--------------------------------------------------------------------------------------------------
 1056 /**
 1057  * Get the Vehicled Type.
 1058  *
 1059  * @return
 1060  *  - LE_OK on success
 1061  *  - LE_BAD_PARAMETER parameter is NULL
 1062  *  - LE_FAULT for other failures
 1063  */
 1064 //--------------------------------------------------------------------------------------------------
 1065 le_result_t le_ecall_GetVehicleType
 1066 (
 1067     le_ecall_MsdVehicleType_t* vehicleTypePtr
 1068         ///< [OUT] Vehicle type
 1069 );
 1070 
 1071 //--------------------------------------------------------------------------------------------------
 1072 /**
 1073  * Set the VIN (Vehicle Identification Number).
 1074  *
 1075  * @return
 1076  *  - LE_OK on success
 1077  *  - LE_BAD_PARAMETER parameter is NULL.
 1078  *  - LE_FAULT for other failures
 1079  */
 1080 //--------------------------------------------------------------------------------------------------
 1081 le_result_t le_ecall_SetVIN
 1082 (
 1083     const char* LE_NONNULL vin
 1084         ///< [IN] VIN (Vehicle Identification Number)
 1085 );
 1086 
 1087 //--------------------------------------------------------------------------------------------------
 1088 /**
 1089  * Get the VIN (Vehicle Identification Number).
 1090  *
 1091  * @return
 1092  *  - LE_OK on success
 1093  *  - LE_NOT_FOUND if the value is not set.
 1094  *  - LE_BAD_PARAMETER parameter is NULL or to small
 1095  *  - LE_FAULT for other failures
 1096  */
 1097 //--------------------------------------------------------------------------------------------------
 1098 le_result_t le_ecall_GetVIN
 1099 (
 1100     char* vin,
 1101         ///< [OUT] VIN is gotten with a null termination.
 1102     size_t vinSize
 1103         ///< [IN]
 1104 );
 1105 
 1106 //--------------------------------------------------------------------------------------------------
 1107 /**
 1108  * Set the propulsion type.
 1109  * Note that a vehicle may have more than one propulsion type.
 1110  *
 1111  * @return
 1112  *  - LE_OK on success
 1113  *  - LE_FAULT for other failures
 1114  */
 1115 //--------------------------------------------------------------------------------------------------
 1116 le_result_t le_ecall_SetPropulsionType
 1117 (
 1118     le_ecall_PropulsionTypeBitMask_t propulsionType
 1119         ///< [IN] bitmask
 1120 );
 1121 
 1122 //--------------------------------------------------------------------------------------------------
 1123 /**
 1124  * Get the propulsion stored.
 1125  * Note that a vehicle may have more than one propulsion type.
 1126  *
 1127  * @return
 1128  *  - LE_OK on success
 1129  *  - LE_NOT_FOUND if the value is not set.
 1130  *  - LE_FAULT for other failures
 1131  *  - LE_BAD_PARAMETER parameter is NULL
 1132  */
 1133 //--------------------------------------------------------------------------------------------------
 1134 le_result_t le_ecall_GetPropulsionType
 1135 (
 1136     le_ecall_PropulsionTypeBitMask_t* propulsionTypePtr
 1137         ///< [OUT] bitmask
 1138 );
 1139 
 1140 //--------------------------------------------------------------------------------------------------
 1141 /**
 1142  * Set the push/pull transmission mode.
 1143  *
 1144  * @return
 1145  *  - LE_OK on success
 1146  *  - LE_FAULT for other failures
 1147  */
 1148 //--------------------------------------------------------------------------------------------------
 1149 le_result_t le_ecall_SetMsdTxMode
 1150 (
 1151     le_ecall_MsdTxMode_t mode
 1152         ///< [IN] Transmission mode
 1153 );
 1154 
 1155 //--------------------------------------------------------------------------------------------------
 1156 /**
 1157  * Get the push/pull transmission mode.
 1158  *
 1159  * @return
 1160  *      - LE_OK     on success
 1161  *      - LE_FAULT  for other failures
 1162  *
 1163  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1164  *       function will not return.
 1165  */
 1166 //--------------------------------------------------------------------------------------------------
 1167 le_result_t le_ecall_GetMsdTxMode
 1168 (
 1169     le_ecall_MsdTxMode_t* modePtr
 1170         ///< [OUT] Transmission mode
 1171 );
 1172 
 1173 //--------------------------------------------------------------------------------------------------
 1174 /**
 1175  * Set the position transmitted by the MSD.
 1176  *
 1177  * @return
 1178  *      - LE_OK on success
 1179  *      - LE_DUPLICATE an MSD has been already imported
 1180  *      - LE_BAD_PARAMETER bad input parameter
 1181  *      - LE_FAULT on other failures
 1182  *
 1183  * @note The process exits, if an invalid eCall reference is given
 1184  */
 1185 //--------------------------------------------------------------------------------------------------
 1186 le_result_t le_ecall_SetMsdPosition
 1187 (
 1188     le_ecall_CallRef_t ecallRef,
 1189         ///< [IN] eCall reference
 1190     bool isTrusted,
 1191         ///< [IN] true if the position is accurate, false otherwise
 1192     int32_t latitude,
 1193         ///< [IN] latitude in degrees with 6 decimal places, positive North.
 1194         ///< Maximum value is +90 degrees (+90000000), minimum value is -90
 1195         ///< degrees (-90000000).
 1196     int32_t longitude,
 1197         ///< [IN] longitude in degrees with 6 decimal places, positive East.
 1198         ///< Maximum value is +180 degrees (+180000000), minimum value is
 1199         ///< -180 degrees (-180000000).
 1200     int32_t direction
 1201         ///< [IN] direction of the vehicle from magnetic north (0 to 358, clockwise)
 1202         ///< in 2-degrees unit. Valid range is 0 to 179. If direction of
 1203         ///< travel is invalid or unknown, the value 0xFF shall be used.
 1204 );
 1205 
 1206 //--------------------------------------------------------------------------------------------------
 1207 /**
 1208  * Set the position Delta N-1 from position set in le_ecall_SetMsdPosition() transmitted by the MSD.
 1209  *
 1210  * @return
 1211  *      - LE_OK on success
 1212  *      - LE_DUPLICATE an MSD has been already imported
 1213  *      - LE_BAD_PARAMETER bad input parameter
 1214  *      - LE_FAULT on other failures
 1215  *
 1216  * @note The process exits, if an invalid eCall reference is given
 1217  */
 1218 //--------------------------------------------------------------------------------------------------
 1219 le_result_t le_ecall_SetMsdPositionN1
 1220 (
 1221     le_ecall_CallRef_t ecallRef,
 1222         ///< [IN] eCall reference
 1223     int32_t latitudeDeltaN1,
 1224         ///< [IN] longitude delta from position set in SetMsdPosition
 1225         ///< 1 Unit = 100 miliarcseconds, which is approximately 3m
 1226         ///< maximum value: 511 = 0 0'51.100'' (+- 1580m)
 1227         ///< minimum value: -512 = -0 0'51.200'' (+- -1583m)
 1228     int32_t longitudeDeltaN1
 1229         ///< [IN] longitude delta from position set in SetMsdPosition
 1230         ///< 1 Unit = 100 miliarcseconds, which is approximately 3m
 1231         ///< maximum value: 511 = 0 0'51.100'' (+-1580m)
 1232         ///< minimum value: -512 = -0 0'51.200'' (+- -1583m) )
 1233 );
 1234 
 1235 //--------------------------------------------------------------------------------------------------
 1236 /**
 1237  * Set the position Delta N-2 from position set in le_ecall_SetMsdPositionN1() transmitted by the MSD.
 1238  *
 1239  * @return
 1240  *      - LE_OK on success
 1241  *      - LE_DUPLICATE an MSD has been already imported
 1242  *      - LE_BAD_PARAMETER bad input parameter
 1243  *      - LE_FAULT on other failures
 1244  *
 1245  * @note The process exits, if an invalid eCall reference is given
 1246  */
 1247 //--------------------------------------------------------------------------------------------------
 1248 le_result_t le_ecall_SetMsdPositionN2
 1249 (
 1250     le_ecall_CallRef_t ecallRef,
 1251         ///< [IN] eCall reference
 1252     int32_t latitudeDeltaN2,
 1253         ///< [IN] longitude delta from position set in SetMsdPositionN1
 1254         ///< 1 Unit = 100 miliarcseconds, which is approximately 3m
 1255         ///< maximum value: 511 = 0 0'51.100'' (+-1580m)
 1256         ///< minimum value: -512 = -0 0'51.200'' (+- -1583m)
 1257     int32_t longitudeDeltaN2
 1258         ///< [IN] longitude delta from position set in SetMsdPositionN1
 1259         ///< 1 Unit = 100 miliarcseconds, which is approximately 3m
 1260         ///< maximum value: 511 = 0 0'51.100'' (+-1580m)
 1261         ///< minimum value: -512 = -0 0'51.200'' (+- -1583m) )
 1262 );
 1263 
 1264 //--------------------------------------------------------------------------------------------------
 1265 /**
 1266  * Set the number of passengers transmitted by the MSD.
 1267  *
 1268  * @return
 1269  *      - LE_OK on success
 1270  *      - LE_DUPLICATE an MSD has been already imported
 1271  *      - LE_BAD_PARAMETER bad eCall reference
 1272  *
 1273  * @note The process exits, if an invalid eCall reference is given
 1274  */
 1275 //--------------------------------------------------------------------------------------------------
 1276 le_result_t le_ecall_SetMsdPassengersCount
 1277 (
 1278     le_ecall_CallRef_t ecallRef,
 1279         ///< [IN] eCall reference
 1280     uint32_t paxCount
 1281         ///< [IN] number of passengers
 1282 );
 1283 
 1284 //--------------------------------------------------------------------------------------------------
 1285 /**
 1286  * Import an already prepared MSD.
 1287  *
 1288  * MSD is transmitted only after an emergency call has been established.
 1289  *
 1290  * @return
 1291  *      - LE_OK on success
 1292  *      - LE_OVERFLOW The imported MSD length exceeds the MSD_MAX_LEN maximum length.
 1293  *      - LE_BAD_PARAMETER bad eCall reference
 1294  *      - LE_FAULT for other failures
 1295  *
 1296  * @note On failure, the process exits; you don't have to worry about checking the returned
 1297  *       reference for validity.
 1298  */
 1299 //--------------------------------------------------------------------------------------------------
 1300 le_result_t le_ecall_ImportMsd
 1301 (
 1302     le_ecall_CallRef_t ecallRef,
 1303         ///< [IN] eCall reference
 1304     const uint8_t* msdPtr,
 1305         ///< [IN] the prepared MSD
 1306     size_t msdSize
 1307         ///< [IN]
 1308 );
 1309 
 1310 //--------------------------------------------------------------------------------------------------
 1311 /**
 1312  * Export the encoded MSD.
 1313  *
 1314  * @return
 1315  *  - LE_OK on success
 1316  *  - LE_OVERFLOW  The encoded MSD length exceeds the user's buffer length.
 1317  *  - LE_NOT_FOUND  No encoded MSD is available.
 1318  *  - LE_BAD_PARAMETER bad eCall reference.
 1319  *  - LE_FAULT for other failures.
 1320  *
 1321  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1322  *       function will not return.
 1323  */
 1324 //--------------------------------------------------------------------------------------------------
 1325 le_result_t le_ecall_ExportMsd
 1326 (
 1327     le_ecall_CallRef_t ecallRef,
 1328         ///< [IN] eCall reference
 1329     uint8_t* msdPtr,
 1330         ///< [OUT] the encoded MSD
 1331     size_t* msdSizePtr
 1332         ///< [INOUT]
 1333 );
 1334 
 1335 //--------------------------------------------------------------------------------------------------
 1336 /**
 1337  * Send the MSD.
 1338  *
 1339  * @return
 1340  *      - LE_OK on success
 1341  *      - LE_BAD_PARAMETER bad eCall reference
 1342  *      - LE_FAULT for other failures
 1343  *
 1344  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1345  *       reference for validity.
 1346  */
 1347 //--------------------------------------------------------------------------------------------------
 1348 le_result_t le_ecall_SendMsd
 1349 (
 1350     le_ecall_CallRef_t ecallRef
 1351         ///< [IN] eCall reference
 1352 );
 1353 
 1354 //--------------------------------------------------------------------------------------------------
 1355 /**
 1356  * Start an automatic eCall session
 1357  *
 1358  * @return
 1359  *      - LE_OK on success
 1360  *      - LE_BUSY an eCall session is already in progress
 1361  *      - LE_BAD_PARAMETER bad eCall reference
 1362  *      - LE_FAULT for other failures
 1363  *
 1364  * @note The process exits, if an invalid eCall reference is given
 1365  */
 1366 //--------------------------------------------------------------------------------------------------
 1367 le_result_t le_ecall_StartAutomatic
 1368 (
 1369     le_ecall_CallRef_t ecallRef
 1370         ///< [IN] eCall reference
 1371 );
 1372 
 1373 //--------------------------------------------------------------------------------------------------
 1374 /**
 1375  * Start a manual eCall session
 1376  *
 1377  * @return
 1378  *      - LE_OK on success
 1379  *      - LE_BUSY an eCall session is already in progress
 1380  *      - LE_BAD_PARAMETER bad eCall reference
 1381  *      - LE_FAULT for other failures
 1382  *
 1383  * @note The process exits, if an invalid eCall reference is given
 1384  */
 1385 //--------------------------------------------------------------------------------------------------
 1386 le_result_t le_ecall_StartManual
 1387 (
 1388     le_ecall_CallRef_t ecallRef
 1389         ///< [IN] eCall reference
 1390 );
 1391 
 1392 //--------------------------------------------------------------------------------------------------
 1393 /**
 1394  * Start a test eCall  session
 1395  *
 1396  * @return
 1397  *      - LE_OK on success
 1398  *      - LE_BUSY an eCall session is already in progress
 1399  *      - LE_BAD_PARAMETER bad eCall reference
 1400  *      - LE_FAULT for other failures
 1401  *
 1402  * @note The process exits, if an invalid eCall reference is given
 1403  */
 1404 //--------------------------------------------------------------------------------------------------
 1405 le_result_t le_ecall_StartTest
 1406 (
 1407     le_ecall_CallRef_t ecallRef
 1408         ///< [IN] eCall reference
 1409 );
 1410 
 1411 //--------------------------------------------------------------------------------------------------
 1412 /**
 1413  * End the current eCall session
 1414  *
 1415  * @return
 1416  *      - LE_OK on success
 1417  *      - LE_BAD_PARAMETER bad eCall reference
 1418  *      - LE_FAULT for other failures
 1419  */
 1420 //--------------------------------------------------------------------------------------------------
 1421 le_result_t le_ecall_End
 1422 (
 1423     le_ecall_CallRef_t ecallRef
 1424         ///< [IN] eCall reference
 1425 );
 1426 
 1427 //--------------------------------------------------------------------------------------------------
 1428 /**
 1429  * Get the current state for the given eCall
 1430  *
 1431  * @return
 1432  *      - The current state for the given eCall
 1433  *
 1434  * @note The process exits, if an invalid eCall reference is given
 1435  */
 1436 //--------------------------------------------------------------------------------------------------
 1437 le_ecall_State_t le_ecall_GetState
 1438 (
 1439     le_ecall_CallRef_t ecallRef
 1440         ///< [IN] eCall reference
 1441 );
 1442 
 1443 //--------------------------------------------------------------------------------------------------
 1444 /**
 1445  * Set the Public Safely Answering Point telephone number.
 1446  *
 1447  * @note That PSAP number is not applied to Manually or Automatically initiated eCall. For those
 1448  *       modes, an emergency call is launched.
 1449  *
 1450  * @warning This function doesn't modified the U/SIM content.
 1451  *
 1452  * @return
 1453  *  - LE_OK on success
 1454  *  - LE_FAULT for other failures
 1455  *
 1456  * @note If PSAP number is too long (max LE_MDMDEFS_PHONE_NUM_MAX_LEN digits), it is a fatal error,
 1457  *       the function will not return.
 1458  */
 1459 //--------------------------------------------------------------------------------------------------
 1460 le_result_t le_ecall_SetPsapNumber
 1461 (
 1462     const char* LE_NONNULL psap
 1463         ///< [IN] Public Safely Answering Point number
 1464 );
 1465 
 1466 //--------------------------------------------------------------------------------------------------
 1467 /**
 1468  * Get the Public Safely Answering Point telephone number set with le_ecall_SetPsapNumber()
 1469  * function.
 1470  *
 1471  * @note That PSAP number is not applied to Manually or Automatically initiated eCall. For those
 1472  *       modes, an emergency call is launched.
 1473  *
 1474  * @warning This function doesn't read the U/SIM content.
 1475  *
 1476  * @return
 1477  *  - LE_OK on success
 1478  *  - LE_FAULT on failures or if le_ecall_SetPsapNumber() has never been called before.
 1479  */
 1480 //--------------------------------------------------------------------------------------------------
 1481 le_result_t le_ecall_GetPsapNumber
 1482 (
 1483     char* psap,
 1484         ///< [OUT] Public Safely Answering Point telephone number
 1485     size_t psapSize
 1486         ///< [IN]
 1487 );
 1488 
 1489 //--------------------------------------------------------------------------------------------------
 1490 /**
 1491  * This function can be recalled to indicate the modem to read the number to dial from the FDN/SDN
 1492  * of the U/SIM, depending upon the eCall operating mode.
 1493  *
 1494  * @return
 1495  *  - LE_OK on success
 1496  *  - LE_FAULT for other failures
 1497  */
 1498 //--------------------------------------------------------------------------------------------------
 1499 le_result_t le_ecall_UseUSimNumbers
 1500 (
 1501     void
 1502 );
 1503 
 1504 //--------------------------------------------------------------------------------------------------
 1505 /**
 1506  * Set the NAD_DEREGISTRATION_TIME value. After termination of an emergency call the in-vehicle
 1507  * system remains registered on the network for the period of time, defined by the installation
 1508  * parameter NAD_DEREGISTRATION_TIME.
 1509  *
 1510  * @return
 1511  *  - LE_OK on success
 1512  *  - LE_FAULT on failure
 1513  */
 1514 //--------------------------------------------------------------------------------------------------
 1515 le_result_t le_ecall_SetNadDeregistrationTime
 1516 (
 1517     uint16_t deregTime
 1518         ///< [IN] the NAD_DEREGISTRATION_TIME value (in minutes).
 1519 );
 1520 
 1521 //--------------------------------------------------------------------------------------------------
 1522 /**
 1523  * Get the NAD_DEREGISTRATION_TIME value.
 1524  *
 1525  * @return
 1526  *  - LE_OK on success
 1527  *  - LE_FAULT on failure
 1528  */
 1529 //--------------------------------------------------------------------------------------------------
 1530 le_result_t le_ecall_GetNadDeregistrationTime
 1531 (
 1532     uint16_t* deregTimePtr
 1533         ///< [OUT] the NAD_DEREGISTRATION_TIME value (in minutes).
 1534 );
 1535 
 1536 //--------------------------------------------------------------------------------------------------
 1537 /**
 1538  * Set the minimum interval value between dial attempts.
 1539  *
 1540  * @return
 1541  *  - LE_OK on success
 1542  *  - LE_FAULT for other failures
 1543  */
 1544 //--------------------------------------------------------------------------------------------------
 1545 le_result_t le_ecall_SetIntervalBetweenDialAttempts
 1546 (
 1547     uint16_t pause
 1548         ///< [IN] the minimum interval value in seconds
 1549 );
 1550 
 1551 //--------------------------------------------------------------------------------------------------
 1552 /**
 1553  * Get the minimum interval value between dial attempts.
 1554  *
 1555  * @return
 1556  *  - LE_OK on success
 1557  *  - LE_FAULT for other failures
 1558  */
 1559 //--------------------------------------------------------------------------------------------------
 1560 le_result_t le_ecall_GetIntervalBetweenDialAttempts
 1561 (
 1562     uint16_t* pausePtr
 1563         ///< [OUT] the minimum interval value in seconds
 1564 );
 1565 
 1566 //--------------------------------------------------------------------------------------------------
 1567 /**
 1568  * Set the MANUAL_DIAL_ATTEMPTS value. If a dial attempt under manual emergency call initiation
 1569  * failed, it should be repeated maximally ECALL_MANUAL_DIAL_ATTEMPTS-1 times within the maximal
 1570  * time limit of ECALL_DIAL_DURATION. The default value is 10.
 1571  * Redial attempts stop once the call has been cleared down correctly, or if counter/timer reached
 1572  * their limits.
 1573  *
 1574  * @return
 1575  *  - LE_OK on success
 1576  *  - LE_FAULT on failure
 1577  */
 1578 //--------------------------------------------------------------------------------------------------
 1579 le_result_t le_ecall_SetEraGlonassManualDialAttempts
 1580 (
 1581     uint16_t attempts
 1582         ///< [IN] the MANUAL_DIAL_ATTEMPTS value
 1583 );
 1584 
 1585 //--------------------------------------------------------------------------------------------------
 1586 /**
 1587  * Set tthe AUTO_DIAL_ATTEMPTS value. If a dial attempt under automatic emergency call initiation
 1588  * failed, it should be repeated maximally ECALL_AUTO_DIAL_ATTEMPTS-1 times within the maximal time
 1589  * limit of ECALL_DIAL_DURATION. The default value is 10.
 1590  * Redial attempts stop once the call has been cleared down correctly, or if counter/timer reached
 1591  * their limits.
 1592  *
 1593  * @return
 1594  *  - LE_OK on success
 1595  *  - LE_FAULT on failure
 1596  */
 1597 //--------------------------------------------------------------------------------------------------
 1598 le_result_t le_ecall_SetEraGlonassAutoDialAttempts
 1599 (
 1600     uint16_t attempts
 1601         ///< [IN] the AUTO_DIAL_ATTEMPTS value
 1602 );
 1603 
 1604 //--------------------------------------------------------------------------------------------------
 1605 /**
 1606  * Set the ECALL_DIAL_DURATION time. It's the maximum time the IVS have to connect the emergency
 1607  * call to the PSAP, including all redial attempts.
 1608  * If the call is not connected within this time (or ManualDialAttempts/AutoDialAttempts dial
 1609  * attempts), it will stop.
 1610  *
 1611  * @return
 1612  *  - LE_OK on success
 1613  *  - LE_FAULT on failure
 1614  */
 1615 //--------------------------------------------------------------------------------------------------
 1616 le_result_t le_ecall_SetEraGlonassDialDuration
 1617 (
 1618     uint16_t duration
 1619         ///< [IN] the ECALL_DIAL_DURATION time value (in seconds)
 1620 );
 1621 
 1622 //--------------------------------------------------------------------------------------------------
 1623 /**
 1624  * Get the MANUAL_DIAL_ATTEMPTS value.
 1625  *
 1626  * @return
 1627  *  - LE_OK on success
 1628  *  - LE_FAULT on failure
 1629  */
 1630 //--------------------------------------------------------------------------------------------------
 1631 le_result_t le_ecall_GetEraGlonassManualDialAttempts
 1632 (
 1633     uint16_t* attemptsPtr
 1634         ///< [OUT] the MANUAL_DIAL_ATTEMPTS value
 1635 );
 1636 
 1637 //--------------------------------------------------------------------------------------------------
 1638 /**
 1639  * Get the AUTO_DIAL_ATTEMPTS value.
 1640  *
 1641  * @return
 1642  *  - LE_OK on success
 1643  *  - LE_FAULT on failure
 1644  */
 1645 //--------------------------------------------------------------------------------------------------
 1646 le_result_t le_ecall_GetEraGlonassAutoDialAttempts
 1647 (
 1648     uint16_t* attemptsPtr
 1649         ///< [OUT] the AUTO_DIAL_ATTEMPTS value
 1650 );
 1651 
 1652 //--------------------------------------------------------------------------------------------------
 1653 /**
 1654  * Get the ECALL_DIAL_DURATION time.
 1655  *
 1656  * @return
 1657  *  - LE_OK on success
 1658  *  - LE_FAULT on failure
 1659  */
 1660 //--------------------------------------------------------------------------------------------------
 1661 le_result_t le_ecall_GetEraGlonassDialDuration
 1662 (
 1663     uint16_t* durationPtr
 1664         ///< [OUT] the ECALL_DIAL_DURATION time value (in seconds)
 1665 );
 1666 
 1667 //--------------------------------------------------------------------------------------------------
 1668 /**
 1669  * Set the ERA-GLONASS crash severity parameter.
 1670  *
 1671  * @return
 1672  *  - LE_OK on success
 1673  *  - LE_DUPLICATE an MSD has been already imported
 1674  *  - LE_BAD_PARAMETER bad eCall reference
 1675  */
 1676 //--------------------------------------------------------------------------------------------------
 1677 le_result_t le_ecall_SetMsdEraGlonassCrashSeverity
 1678 (
 1679     le_ecall_CallRef_t ecallRef,
 1680         ///< [IN] eCall reference
 1681     uint32_t crashSeverity
 1682         ///< [IN] the ERA-GLONASS crash severity parameter
 1683 );
 1684 
 1685 //--------------------------------------------------------------------------------------------------
 1686 /**
 1687  * Reset the ERA-GLONASS crash severity parameter. Therefore that optional parameter is not included
 1688  * in the MSD message.
 1689  *
 1690  * @return
 1691  *  - LE_OK on success
 1692  *  - LE_DUPLICATE an MSD has been already imported
 1693  *  - LE_BAD_PARAMETER bad eCall reference
 1694  */
 1695 //--------------------------------------------------------------------------------------------------
 1696 le_result_t le_ecall_ResetMsdEraGlonassCrashSeverity
 1697 (
 1698     le_ecall_CallRef_t ecallRef
 1699         ///< [IN] eCall reference
 1700 );
 1701 
 1702 //--------------------------------------------------------------------------------------------------
 1703 /**
 1704  * Set the ERA-GLONASS diagnostic result using a bit mask.
 1705  *
 1706  * @return
 1707  *  - LE_OK on success
 1708  *  - LE_DUPLICATE an MSD has been already imported
 1709  *  - LE_BAD_PARAMETER bad eCall reference
 1710  */
 1711 //--------------------------------------------------------------------------------------------------
 1712 le_result_t le_ecall_SetMsdEraGlonassDiagnosticResult
 1713 (
 1714     le_ecall_CallRef_t ecallRef,
 1715         ///< [IN] eCall reference
 1716     le_ecall_DiagnosticResultBitMask_t diagnosticResultMask
 1717         ///< [IN] ERA-GLONASS diagnostic result bit mask.
 1718 );
 1719 
 1720 //--------------------------------------------------------------------------------------------------
 1721 /**
 1722  * Reset the ERA-GLONASS diagnostic result bit mask. Optional parameter is not
 1723  * included in the MSD message.
 1724  *
 1725  * @return
 1726  *  - LE_OK on success
 1727  *  - LE_DUPLICATE an MSD has been already imported
 1728  *  - LE_BAD_PARAMETER bad eCall reference
 1729  */
 1730 //--------------------------------------------------------------------------------------------------
 1731 le_result_t le_ecall_ResetMsdEraGlonassDiagnosticResult
 1732 (
 1733     le_ecall_CallRef_t ecallRef
 1734         ///< [IN] eCall reference
 1735 );
 1736 
 1737 //--------------------------------------------------------------------------------------------------
 1738 /**
 1739  * Set the ERA-GLONASS crash type bit mask
 1740  *
 1741  * @return
 1742  *  - LE_OK on success
 1743  *  - LE_DUPLICATE an MSD has been already imported
 1744  *  - LE_BAD_PARAMETER bad eCall reference
 1745  */
 1746 //--------------------------------------------------------------------------------------------------
 1747 le_result_t le_ecall_SetMsdEraGlonassCrashInfo
 1748 (
 1749     le_ecall_CallRef_t ecallRef,
 1750         ///< [IN] eCall reference
 1751     le_ecall_CrashInfoBitMask_t crashInfoMask
 1752         ///< [IN] ERA-GLONASS crash type bit mask.
 1753 );
 1754 
 1755 //--------------------------------------------------------------------------------------------------
 1756 /**
 1757  * Reset the ERA-GLONASS crash type bit mask. Optional parameter is not included
 1758  * in the MSD message.
 1759  *
 1760  * @return
 1761  *  - LE_OK on success
 1762  *  - LE_DUPLICATE an MSD has been already imported
 1763  *  - LE_BAD_PARAMETER bad eCall reference
 1764  */
 1765 //--------------------------------------------------------------------------------------------------
 1766 le_result_t le_ecall_ResetMsdEraGlonassCrashInfo
 1767 (
 1768     le_ecall_CallRef_t ecallRef
 1769         ///< [IN] eCall reference
 1770 );
 1771 
 1772 //--------------------------------------------------------------------------------------------------
 1773 /**
 1774  * Called to get the termination reason.
 1775  *
 1776  * @return The termination reason.
 1777  *
 1778  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1779  *       function will not return.
 1780  */
 1781 //--------------------------------------------------------------------------------------------------
 1782 le_mcc_TerminationReason_t le_ecall_GetTerminationReason
 1783 (
 1784     le_ecall_CallRef_t ecallRef
 1785         ///< [IN] eCall reference.
 1786 );
 1787 
 1788 //--------------------------------------------------------------------------------------------------
 1789 /**
 1790  * Called to get the platform specific termination code.
 1791  *
 1792  * @return The platform specific termination code.
 1793  *
 1794  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1795  *       function will not return.
 1796  */
 1797 //--------------------------------------------------------------------------------------------------
 1798 int32_t le_ecall_GetPlatformSpecificTerminationCode
 1799 (
 1800     le_ecall_CallRef_t ecallRef
 1801         ///< [IN] eCall reference.
 1802 );
 1803 
 1804 #endif // LE_ECALL_INTERFACE_H_INCLUDE_GUARD
LE_ECALL_STATE_END_OF_REDIAL_PERIOD
End of the redial period. 
Definition: le_ecall_interface.h:652
le_ecall_OpMode_t
le_ecall_OpMode_t
Definition: le_ecall_interface.h:580
LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L3E
Motorcycles (Class L3e) 
Definition: le_ecall_interface.h:710
LE_ECALL_STATE_ALACK_RECEIVED_CLEAR_DOWN
AL-ACK clear-down received. 
Definition: le_ecall_interface.h:639
LE_ECALL_CRASH_INFO_PRESENT_CRASH_LEFT
Present Left collision indicator. 
Definition: le_ecall_interface.h:806
le_ecall_GetPlatformSpecificTerminationCode
int32_t le_ecall_GetPlatformSpecificTerminationCode(le_ecall_CallRef_t ecallRef)
le_ecall_SetMsdVersion
le_result_t le_ecall_SetMsdVersion(uint32_t msdVersion)
le_ecall_StartTest
le_result_t le_ecall_StartTest(le_ecall_CallRef_t ecallRef)
le_ecall_SetMsdPositionN2
le_result_t le_ecall_SetMsdPositionN2(le_ecall_CallRef_t ecallRef, int32_t latitudeDeltaN2, int32_t longitudeDeltaN2)
LE_ECALL_FORCED_PERSISTENT_ONLY_MODE
Persistent eCall only mode. 
Definition: le_ecall_interface.h:587
LE_ECALL_STATE_TIMEOUT_T5
Timeout for Timer T5 (see CEN-EN 16062, annex A) 
Definition: le_ecall_interface.h:658
le_ecall_SetPsapNumber
le_result_t le_ecall_SetPsapNumber(const char *LE_NONNULL psap)
LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L1E
Motorcycles (Class L1e) 
Definition: le_ecall_interface.h:706
LE_ECALL_DIAG_RESULT_PRESENT_BATTERY_FAILURE
Present Battery failure. 
Definition: le_ecall_interface.h:766
LE_ECALL_STATE_COMPLETED
Definition: le_ecall_interface.h:646
le_ecall_ForceOnlyMode
le_result_t le_ecall_ForceOnlyMode(void)
LE_ECALL_DIAG_RESULT_PRESENT_RIGHT_SPEAKER_FAILURE
Present Right speaker failure. 
Definition: le_ecall_interface.h:754
LE_ECALL_CRASH_INFO_CRASH_FRONT
Front collision indicator. 
Definition: le_ecall_interface.h:805
le_ecall_SendMsd
le_result_t le_ecall_SendMsd(le_ecall_CallRef_t ecallRef)
le_ecall_ResetMsdEraGlonassCrashSeverity
le_result_t le_ecall_ResetMsdEraGlonassCrashSeverity(le_ecall_CallRef_t ecallRef)
le_ecall_SetEraGlonassDialDuration
le_result_t le_ecall_SetEraGlonassDialDuration(uint16_t duration)
le_ecall_GetMsdVersion
le_result_t le_ecall_GetMsdVersion(uint32_t *msdVersionPtr)
LE_ECALL_DIAG_RESULT_PRESENT_COMM_MODULE_INTERFACE_FAILURE
Present Comm module interface failure. 
Definition: le_ecall_interface.h:774
LE_ECALL_DIAG_RESULT_PRESENT_OTHER_CRITICAL_FAILURES
Present Other critical failures. 
Definition: le_ecall_interface.h:788
LE_ECALL_PROPULSION_TYPE_DIESEL
Diesel propulsion. 
Definition: le_ecall_interface.h:732
le_ecall_SetMsdEraGlonassDiagnosticResult
le_result_t le_ecall_SetMsdEraGlonassDiagnosticResult(le_ecall_CallRef_t ecallRef, le_ecall_DiagnosticResultBitMask_t diagnosticResultMask)
LE_ECALL_STATE_MSD_TX_FAILED
MSD transmission has failed. 
Definition: le_ecall_interface.h:635
LE_ECALL_ONLY_MODE
Definition: le_ecall_interface.h:584
LE_ECALL_ERA_GLONASS
ERA GLONASS standard. 
Definition: le_ecall_interface.h:602
LE_ECALL_STATE_UNKNOWN
Unknown state. 
Definition: le_ecall_interface.h:615
LE_ECALL_DIAG_RESULT_PRESENT_BATTERY_VOLTAGE_LOW
Present Battery voltage low failure. 
Definition: le_ecall_interface.h:768
le_result_t
le_result_t
Definition: le_basics.h:35
LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L5E
Motorcycles (Class L5e) 
Definition: le_ecall_interface.h:714
le_ecall_SetMsdEraGlonassCrashSeverity
le_result_t le_ecall_SetMsdEraGlonassCrashSeverity(le_ecall_CallRef_t ecallRef, uint32_t crashSeverity)
le_ecall_MsdVehicleType_t
le_ecall_MsdVehicleType_t
Definition: le_ecall_interface.h:692
le_ecall_ForcePersistentOnlyMode
le_result_t le_ecall_ForcePersistentOnlyMode(void)
LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L6E
Motorcycles (Class L6e) 
Definition: le_ecall_interface.h:716
LE_ECALL_CRASH_INFO_CRASH_FRONT_OR_SIDE
Front or side collision indicator. 
Definition: le_ecall_interface.h:817
le_ecall_SetMsdTxMode
le_result_t le_ecall_SetMsdTxMode(le_ecall_MsdTxMode_t mode)
le_ecall_ConnectService
void le_ecall_ConnectService(void)
le_mdmDefs_interface.h
LE_ECALL_STATE_TIMEOUT_T10
Timeout for Timer T10 (see CEN-EN 16062, annex A) 
Definition: le_ecall_interface.h:666
LE_ECALL_DIAG_RESULT_FIRMWARE_IMAGE_CORRUPTION
Firmware image corruption failure status. 
Definition: le_ecall_interface.h:773
le_mcc_TerminationReason_t
le_mcc_TerminationReason_t
Definition: le_mcc_interface.h:255
LE_ECALL_CRASH_INFO_PRESENT_CRASH_SIDE
Present Side collision indicator. 
Definition: le_ecall_interface.h:814
LE_ECALL_DIAG_RESULT_PRESENT_MIC_CONNECTION_FAILURE
Present Mic connection failure. 
Definition: le_ecall_interface.h:750
LE_ECALL_DIAG_RESULT_RIGHT_SPEAKER_FAILURE
Right speaker failure status. 
Definition: le_ecall_interface.h:755
LE_ECALL_CRASH_INFO_PRESENT_CRASH_RIGHT
Present Right collision indicator. 
Definition: le_ecall_interface.h:808
LE_ECALL_DIAG_RESULT_OTHER_CRITICAL_FAILURES
Other critical failures status. 
Definition: le_ecall_interface.h:789
LE_ECALL_DIAG_RESULT_CRASH_PROFILE_MEMORY_OVERFLOW
Crash profile memory overflow status. 
Definition: le_ecall_interface.h:787
le_ecall_GetMsdTxMode
le_result_t le_ecall_GetMsdTxMode(le_ecall_MsdTxMode_t *modePtr)
LE_ECALL_STATE_LLNACK_RECEIVED
LL-NACK received. 
Definition: le_ecall_interface.h:629
le_ecall_GetVehicleType
le_result_t le_ecall_GetVehicleType(le_ecall_MsdVehicleType_t *vehicleTypePtr)
LE_ECALL_DIAG_RESULT_PRESENT_CRASH_PROFILE_MEMORY_OVERFLOW
Present Crash profile memory overflow. 
Definition: le_ecall_interface.h:786
LE_ECALL_CRASH_INFO_PRESENT_CRASH_FRONT_OR_SIDE
Present Front or side collision indicator. 
Definition: le_ecall_interface.h:816
le_ecall_ResetMsdEraGlonassCrashInfo
le_result_t le_ecall_ResetMsdEraGlonassCrashInfo(le_ecall_CallRef_t ecallRef)
LE_ECALL_DIAG_RESULT_LEFT_SPEAKER_FAILURE
Left speaker failure status. 
Definition: le_ecall_interface.h:757
LE_ECALL_CRASH_INFO_CRASH_ROLLOVER
Rollover indicator. 
Definition: le_ecall_interface.h:813
LE_ECALL_DIAG_RESULT_PRESENT_OTHER_NOT_CRITICAL_FAILURES
Present Other not critical failures. 
Definition: le_ecall_interface.h:790
LE_ECALL_DIAG_RESULT_IGNITION_LINE_FAILURE
Ignition line failure status. 
Definition: le_ecall_interface.h:761
LE_ECALL_TX_MODE_PULL
Pull mode (modem/host waits for MSD request from PSAP to send MSD). 
Definition: le_ecall_interface.h:679
LE_ECALL_CRASH_INFO_CRASH_SIDE
Side collision indicator. 
Definition: le_ecall_interface.h:815
le_ecall_StateChangeHandlerRef_t
struct le_ecall_StateChangeHandler * le_ecall_StateChangeHandlerRef_t
Definition: le_ecall_interface.h:829
le_ecall_CrashInfoBitMask_t
le_ecall_CrashInfoBitMask_t
Definition: le_ecall_interface.h:802
le_ecall_GetConfiguredOperationMode
le_result_t le_ecall_GetConfiguredOperationMode(le_ecall_OpMode_t *opModePtr)
LE_ECALL_DIAG_RESULT_GNSS_ANTENNA_FAILURE
GNSS antenna failure status. 
Definition: le_ecall_interface.h:781
le_ecall_SetNadDeregistrationTime
le_result_t le_ecall_SetNadDeregistrationTime(uint16_t deregTime)
LE_ECALL_DIAG_RESULT_PRESENT_GNSS_RECEIVER_FAILURE
Present GNSS receiver failure. 
Definition: le_ecall_interface.h:776
le_ecall_SetServerDisconnectHandler
void le_ecall_SetServerDisconnectHandler(le_ecall_DisconnectHandler_t disconnectHandler, void *contextPtr)
LE_ECALL_NORMAL_MODE
Normal mode. 
Definition: le_ecall_interface.h:582
LE_ECALL_DIAG_RESULT_RAIM_PROBLEM
RAIM problem status. 
Definition: le_ecall_interface.h:779
le_mcc_interface.h
le_ecall_DisconnectService
void le_ecall_DisconnectService(void)
LE_ECALL_PAN_EUROPEAN
PAN-EUROPEAN standard. 
Definition: le_ecall_interface.h:600
LE_ECALL_TX_MODE_PUSH
Push mode (modem/host sends MSD to PSAP right after eCall is connected). 
Definition: le_ecall_interface.h:681
le_ecall_SetEraGlonassAutoDialAttempts
le_result_t le_ecall_SetEraGlonassAutoDialAttempts(uint16_t attempts)
LE_ECALL_CRASH_INFO_CRASH_ANOTHER_TYPE
Other types of damage indicator. 
Definition: le_ecall_interface.h:819
LE_ECALL_DIAG_RESULT_UIM_FAILURE
UIM failure status. 
Definition: le_ecall_interface.h:763
LE_ECALL_DIAG_RESULT_BATTERY_FAILURE
Battery failure status. 
Definition: le_ecall_interface.h:767
le_ecall_SetEraGlonassManualDialAttempts
le_result_t le_ecall_SetEraGlonassManualDialAttempts(uint16_t attempts)
LE_ECALL_STATE_TIMEOUT_T6
Timeout for Timer T6 (see CEN-EN 16062, annex A) 
Definition: le_ecall_interface.h:660
LE_ECALL_DIAG_RESULT_SPEAKERS_FAILURE
Speaker failure status. 
Definition: le_ecall_interface.h:759
LE_ECALL_PROPULSION_TYPE_PROPANE
Liquid propane gas propulsion. 
Definition: le_ecall_interface.h:734
LE_ECALL_STATE_PSAP_START_IND_RECEIVED
PSAP start indication received. 
Definition: le_ecall_interface.h:625
LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L4E
Motorcycles (Class L4e) 
Definition: le_ecall_interface.h:712
LE_ECALL_MSD_VEHICLE_COMMERCIAL_N1
Light commercial vehicles (Class N1) 
Definition: le_ecall_interface.h:700
LE_ECALL_PROPULSION_TYPE_GASOLINE
Gasoline propulsion) 
Definition: le_ecall_interface.h:731
le_ecall_GetTerminationReason
le_mcc_TerminationReason_t le_ecall_GetTerminationReason(le_ecall_CallRef_t ecallRef)
le_ecall_RemoveStateChangeHandler
void le_ecall_RemoveStateChangeHandler(le_ecall_StateChangeHandlerRef_t handlerRef)
le_ecall_DiagnosticResultBitMask_t
le_ecall_DiagnosticResultBitMask_t
Definition: le_ecall_interface.h:748
LE_ECALL_DIAG_RESULT_PRESENT_RAIM_PROBLEM
Present RAIM problem. 
Definition: le_ecall_interface.h:778
LE_ECALL_PROPULSION_TYPE_HYDROGEN
Hydrogen propulsion. 
Definition: le_ecall_interface.h:736
LE_ECALL_CRASH_INFO_PRESENT_CRASH_FRONT
Present Front collision indicator. 
Definition: le_ecall_interface.h:804
LE_ECALL_DIAG_RESULT_OTHER_NOT_CRITICAL_FAILURES
Other not critical failures status. 
Definition: le_ecall_interface.h:791
le_ecall_SetMsdPassengersCount
le_result_t le_ecall_SetMsdPassengersCount(le_ecall_CallRef_t ecallRef, uint32_t paxCount)
LE_ECALL_STATE_TIMEOUT_T3
Timeout for Timer T3 (see CEN-EN 16062, annex A) 
Definition: le_ecall_interface.h:656
LE_ECALL_CRASH_INFO_PRESENT_CRASH_ANOTHER_TYPE
Present Other types of damage indicator. 
Definition: le_ecall_interface.h:818
le_ecall_GetState
le_ecall_State_t le_ecall_GetState(le_ecall_CallRef_t ecallRef)
LE_ECALL_STATE_LLACK_RECEIVED
LL-ACK received. 
Definition: le_ecall_interface.h:631
LE_ECALL_STATE_WAITING_PSAP_START_IND
Waiting for PSAP start indication. 
Definition: le_ecall_interface.h:623
le_ecall_End
le_result_t le_ecall_End(le_ecall_CallRef_t ecallRef)
le_ecall_CallRef_t
struct le_ecall_Call * le_ecall_CallRef_t
Definition: le_ecall_interface.h:572
le_ecall_StartManual
le_result_t le_ecall_StartManual(le_ecall_CallRef_t ecallRef)
le_ecall_ResetMsdEraGlonassDiagnosticResult
le_result_t le_ecall_ResetMsdEraGlonassDiagnosticResult(le_ecall_CallRef_t ecallRef)
LE_ECALL_STATE_MSD_TX_COMPLETED
MSD transmission is complete. 
Definition: le_ecall_interface.h:633
le_ecall_GetSystemStandard
le_result_t le_ecall_GetSystemStandard(le_ecall_SystemStandard_t *systemStandardPtr)
LE_ECALL_STATE_TIMEOUT_T7
Timeout for Timer T7 (see CEN-EN 16062, annex A) 
Definition: le_ecall_interface.h:662
LE_ECALL_DIAG_RESULT_COMM_MODULE_FAILURE
Comm module failure status. 
Definition: le_ecall_interface.h:783
le_ecall_SystemStandard_t
le_ecall_SystemStandard_t
Definition: le_ecall_interface.h:598
le_ecall_SetMsdEraGlonassCrashInfo
le_result_t le_ecall_SetMsdEraGlonassCrashInfo(le_ecall_CallRef_t ecallRef, le_ecall_CrashInfoBitMask_t crashInfoMask)
LE_ECALL_DIAG_RESULT_EVENTS_MEMORY_OVERFLOW
Events memory overflow status. 
Definition: le_ecall_interface.h:785
LE_ECALL_STATE_TIMEOUT_T2
Timeout for Timer T2 (see CEN-EN 16062, annex A) 
Definition: le_ecall_interface.h:654
LE_ECALL_DIAG_RESULT_PRESENT_GNSS_ANTENNA_FAILURE
Present GNSS antenna failure. 
Definition: le_ecall_interface.h:780
le_ecall_DisconnectHandler_t
void(* le_ecall_DisconnectHandler_t)(void *)
Definition: le_ecall_interface.h:468
LE_ECALL_MSD_VEHICLE_HEAVY_N2
Heavy duty vehicles (Class N2) 
Definition: le_ecall_interface.h:702
le_ecall_SetMsdPosition
le_result_t le_ecall_SetMsdPosition(le_ecall_CallRef_t ecallRef, bool isTrusted, int32_t latitude, int32_t longitude, int32_t direction)
le_ecall_SetVehicleType
le_result_t le_ecall_SetVehicleType(le_ecall_MsdVehicleType_t vehicleType)
LE_ECALL_CRASH_INFO_PRESENT_CRASH_ROLLOVER
Present Rollover indicator. 
Definition: le_ecall_interface.h:812
le_ecall_Create
le_ecall_CallRef_t le_ecall_Create(void)
LE_ECALL_DIAG_RESULT_STATUS_INDICATOR_FAILURE
Status indicator failure status. 
Definition: le_ecall_interface.h:765
LE_ECALL_DIAG_RESULT_PRESENT_UIM_FAILURE
Present UIM failure. 
Definition: le_ecall_interface.h:762
LE_ECALL_CRASH_INFO_PRESENT_CRASH_REAR
Present indicator. 
Definition: le_ecall_interface.h:810
LE_ECALL_STATE_MSD_TX_STARTED
MSD transmission is started. 
Definition: le_ecall_interface.h:627
legato.h
le_ecall_ImportMsd
le_result_t le_ecall_ImportMsd(le_ecall_CallRef_t ecallRef, const uint8_t *msdPtr, size_t msdSize)
LE_ECALL_STATE_STARTED
eCall session started. 
Definition: le_ecall_interface.h:617
LE_ECALL_MSD_VEHICLE_HEAVY_N3
Heavy duty vehicles (Class N3) 
Definition: le_ecall_interface.h:704
LE_ECALL_DIAG_RESULT_PRESENT_LEFT_SPEAKER_FAILURE
Present Left speaker failure. 
Definition: le_ecall_interface.h:756
LE_ECALL_CRASH_INFO_CRASH_REAR
Rear impact indicator. 
Definition: le_ecall_interface.h:811
LE_ECALL_DIAG_RESULT_PRESENT_MIC_FAILURE
Present Mic failure. 
Definition: le_ecall_interface.h:752
le_ecall_UseUSimNumbers
le_result_t le_ecall_UseUSimNumbers(void)
LE_ECALL_MSD_VEHICLE_BUS_M3
Buses and coaches (Class M3) 
Definition: le_ecall_interface.h:698
le_ecall_GetEraGlonassManualDialAttempts
le_result_t le_ecall_GetEraGlonassManualDialAttempts(uint16_t *attemptsPtr)
LE_ECALL_DIAG_RESULT_PRESENT_STATUS_INDICATOR_FAILURE
Present Status indicator failure. 
Definition: le_ecall_interface.h:764
LE_ECALL_DIAG_RESULT_MIC_FAILURE
Mic failure status. 
Definition: le_ecall_interface.h:753
le_ecall_GetNadDeregistrationTime
le_result_t le_ecall_GetNadDeregistrationTime(uint16_t *deregTimePtr)
LE_ECALL_CRASH_INFO_CRASH_RIGHT
Right collision indicator. 
Definition: le_ecall_interface.h:809
le_ecall_GetEraGlonassAutoDialAttempts
le_result_t le_ecall_GetEraGlonassAutoDialAttempts(uint16_t *attemptsPtr)
LE_ECALL_STATE_CONNECTED
Emergency call is established. 
Definition: le_ecall_interface.h:619
LE_ECALL_STATE_FAILED
Unsuccessful eCall session. 
Definition: le_ecall_interface.h:650
le_ecall_ExitOnlyMode
le_result_t le_ecall_ExitOnlyMode(void)
le_ecall_SetMsdPositionN1
le_result_t le_ecall_SetMsdPositionN1(le_ecall_CallRef_t ecallRef, int32_t latitudeDeltaN1, int32_t longitudeDeltaN1)
LE_ECALL_MSD_VEHICLE_BUS_M2
Buses and coaches (Class M2) 
Definition: le_ecall_interface.h:696
le_ecall_GetPropulsionType
le_result_t le_ecall_GetPropulsionType(le_ecall_PropulsionTypeBitMask_t *propulsionTypePtr)
le_ecall_StateChangeHandlerFunc_t
void(* le_ecall_StateChangeHandlerFunc_t)(le_ecall_CallRef_t ecallRef, le_ecall_State_t state, void *contextPtr)
Definition: le_ecall_interface.h:839
LE_ECALL_DIAG_RESULT_PRESENT_CRASH_SENSOR_FAILURE
Present Crash sensor failure. 
Definition: le_ecall_interface.h:770
LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L7E
Motorcycles (Class L7e) 
Definition: le_ecall_interface.h:718
le_ecall_GetEraGlonassDialDuration
le_result_t le_ecall_GetEraGlonassDialDuration(uint16_t *durationPtr)
LE_ECALL_DIAG_RESULT_PRESENT_SPEAKERS_FAILURE
Present Speaker failure. 
Definition: le_ecall_interface.h:758
LE_ECALL_STATE_ALACK_RECEIVED_POSITIVE
AL-ACK received. 
Definition: le_ecall_interface.h:637
LE_ECALL_DIAG_RESULT_BATTERY_VOLTAGE_LOW
Battery voltage low failure status. 
Definition: le_ecall_interface.h:769
le_ecall_State_t
le_ecall_State_t
Definition: le_ecall_interface.h:613
le_ecall_MsdTxMode_t
le_ecall_MsdTxMode_t
Definition: le_ecall_interface.h:677
le_ecall_SetIntervalBetweenDialAttempts
le_result_t le_ecall_SetIntervalBetweenDialAttempts(uint16_t pause)
LE_ECALL_STATE_DISCONNECTED
Emergency call is disconnected. 
Definition: le_ecall_interface.h:621
LE_ECALL_STATE_STOPPED
Definition: le_ecall_interface.h:641
LE_ECALL_DIAG_RESULT_PRESENT_EVENTS_MEMORY_OVERFLOW
Present Events memory overflow. 
Definition: le_ecall_interface.h:784
LE_ECALL_PROPULSION_TYPE_NATURALGAS
Compressed natural gas propulsion. 
Definition: le_ecall_interface.h:733
le_ecall_StartAutomatic
le_result_t le_ecall_StartAutomatic(le_ecall_CallRef_t ecallRef)
LE_ECALL_DIAG_RESULT_COMM_MODULE_INTERFACE_FAILURE
Comm module interface failure status. 
Definition: le_ecall_interface.h:775
LE_ECALL_PROPULSION_TYPE_ELECTRIC
Electric propulsion. 
Definition: le_ecall_interface.h:735
LE_ECALL_DIAG_RESULT_GNSS_RECEIVER_FAILURE
GNSS receiver failure status. 
Definition: le_ecall_interface.h:777
LE_ECALL_STATE_RESET
eCall session has lost synchronization and starts over. 
Definition: le_ecall_interface.h:644
LE_ECALL_DIAG_RESULT_PRESENT_COMM_MODULE_FAILURE
Present Comm module failure. 
Definition: le_ecall_interface.h:782
LE_ECALL_PROPULSION_TYPE_OTHER
Other type of propulsions. 
Definition: le_ecall_interface.h:737
LE_ECALL_MSD_VEHICLE_PASSENGER_M1
Passenger vehicle (Class M1) 
Definition: le_ecall_interface.h:694
LE_ECALL_STATE_TIMEOUT_T9
Timeout for Timer T9 (see CEN-EN 16062, annex A) 
Definition: le_ecall_interface.h:664
LE_ECALL_DIAG_RESULT_MIC_CONNECTION_FAILURE
Mic connection failure status. 
Definition: le_ecall_interface.h:751
le_ecall_TryConnectService
le_result_t le_ecall_TryConnectService(void)
le_ecall_SetVIN
le_result_t le_ecall_SetVIN(const char *LE_NONNULL vin)
le_ecall_AddStateChangeHandler
le_ecall_StateChangeHandlerRef_t le_ecall_AddStateChangeHandler(le_ecall_StateChangeHandlerFunc_t handlerPtr, void *contextPtr)
le_ecall_ExportMsd
le_result_t le_ecall_ExportMsd(le_ecall_CallRef_t ecallRef, uint8_t *msdPtr, size_t *msdSizePtr)
LE_ECALL_CRASH_INFO_CRASH_LEFT
Left collision indicator. 
Definition: le_ecall_interface.h:807
le_ecall_GetPsapNumber
le_result_t le_ecall_GetPsapNumber(char *psap, size_t psapSize)
LE_ECALL_MSD_VEHICLE_MOTORCYCLE_L2E
Motorcycles (Class L2e) 
Definition: le_ecall_interface.h:708
le_ecall_GetVIN
le_result_t le_ecall_GetVIN(char *vin, size_t vinSize)
LE_ECALL_DIAG_RESULT_PRESENT_FIRMWARE_IMAGE_CORRUPTION
Present Firmware image corruption failure. 
Definition: le_ecall_interface.h:772
le_ecall_Delete
void le_ecall_Delete(le_ecall_CallRef_t ecallRef)
le_ecall_SetSystemStandard
le_result_t le_ecall_SetSystemStandard(le_ecall_SystemStandard_t systemStandard)
LE_ECALL_DIAG_RESULT_PRESENT_IGNITION_LINE_FAILURE
Present Ignition line failure. 
Definition: le_ecall_interface.h:760
le_ecall_SetPropulsionType
le_result_t le_ecall_SetPropulsionType(le_ecall_PropulsionTypeBitMask_t propulsionType)
le_ecall_PropulsionTypeBitMask_t
le_ecall_PropulsionTypeBitMask_t
Definition: le_ecall_interface.h:729
le_ecall_GetIntervalBetweenDialAttempts
le_result_t le_ecall_GetIntervalBetweenDialAttempts(uint16_t *pausePtr)
LE_ECALL_DIAG_RESULT_CRASH_SENSOR_FAILURE
Crash sensor failure status. 
Definition: le_ecall_interface.h:771