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