le_ecall_interface.h

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