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