le_ecall_interface.h

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