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