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