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