le_atClient_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_atClient AT Commands Client
   14  *
   15  * @ref le_atClient_interface.h "API Reference"
   16  *
   17  * @warning Some AT commands may conflict with Legato APIs; using both may cause problems that can
   18  * be difficult to diagnose. AT commands should be avoided whenever possible, and should only be
   19  * used with great care.
   20  *
   21  * The AT Client Service handles the AT commands sent to the modem on a specified
   22  * serial device. It also supports getting AT command responses (intermediate, final or
   23  * unsolicited responses).
   24  * This service can be subscribed to by several apps simultaneously.
   25  *
   26  * @section le_atClient_binding IPC interfaces binding
   27  *
   28  * All the functions of this API are provided by the @b atService.
   29  *
   30  * Here's a code sample binding to the AT commands server:
   31  * @verbatim
   32    bindings:
   33    {
   34       atClientTest.atClientTestComp.le_atClient -> atService.le_atClient
   35    }
   36    @endverbatim
   37  *
   38  * @section atClient_binding Device Binding
   39  *
   40  * le_atClient_Start() must be called to bind a specific device with the ATClient.
   41  * Multiple devices can be bound. The app has to configured the device before using it with
   42  * the ATClient.
   43  * A device can be unbound using le_atClient_Stop().
   44  *
   45  * @section atClient_statement Statement
   46  *
   47  * An AT command statement is requested before sending it. The following steps have to be done for
   48  * its declaration:
   49  *
   50  * - create an AT command reference using le_atClient_Create().
   51  *
   52  * - use le_atClient_SetCommand() to set the AT command to be sent to the modem.
   53  *
   54  * - set the sending port to use le_atClient_SetDevice().
   55  *
   56  * - can set a timeout value using le_atClient_SetTimeout(); default value is @c 30s.
   57  *
   58  * - request expected final responses and set using le_atClient_SetFinalResponse().The final
   59  * response is mandatory to detect
   60  * the end of the AT command execution. If an AT command answers with a final response that
   61  * doesn't belong to the final responses set, the AT command execution will end by timeout.
   62  *
   63  * - can call le_atClient_SetIntermediateResponse() to set the intermediate responses
   64  * filters. This is optional.
   65  *
   66  * Command responses given in le_atClient_SetIntermediateResponse() and
   67  * le_atClient_SetFinalResponse() are the first characters of the response lines. They are used as a
   68  * filter of the received lines (a line are the characters received between receiving a
   69  * <CR> and an <LF>). Other lines are dropped.
   70  *
   71  * - text can be set using le_atClient_SetText(). This is used for commands that answers a
   72  * '>' character to receive additional information. The given text is sent to the modem when '>' is
   73  * detected. The character @c CTRL-Z is automatically sent.
   74  *
   75  *
   76  * @section atClient_send Sending
   77  *
   78  * When the AT command declaration is complete, it can be sent using le_atClient_Send(). This API is
   79  * synchronous (blocking until final response is detected, or timeout reached).
   80  *
   81  * le_atClient_SetCommandAndSend() is equivalent to le_atClient_Create(), le_atClient_SetCommand(),
   82  * le_atClient_SetDevice(), le_atClient_SetTimeout(), le_atClient_SetIntermediateResponse() and
   83  * le_atClient_SetFinalResponse(), in case of an Error le_atClient_Delete(),
   84  * in one API call.
   85  * The AT command reference is created and returned by this API. When an error
   86  * occurs the command reference is deleted and is not a valid reference anymore
   87  *
   88  * @section atClient_responses Responses
   89  *
   90  * When the AT command has been sent correctly (i.e., le_atClient_Send() or
   91  * le_atClient_SetCommandAndSend() execution is successful), the app gets these AT command
   92  * responses:
   93  * - le_atClient_GetFinalResponse() is used to get the final responses
   94  * - le_atClient_GetFirstIntermediateResponse() is used to get the first intermediate result code.
   95  * Other intermediate result codes can be obtained by calling
   96  * le_atClient_GetNextIntermediateResponse().Returns LE_NOT_FOUND when there are no further results.
   97  *
   98  * When a response has been set in the AT command declaration, the AT command response returned by
   99  * these APIs start with the given pattern, and ends when a <CR><LF> is detected.
  100  *
  101  * @section atClient__delete Deleting
  102  *
  103  * When the AT command is over, the reference has to be deleted by calling le_atClient_Delete().
  104  *
  105  * @section atClient_unsolicited Unsolicited Responses
  106  *
  107  * An app can subscribe to a specific, unsolicited response using
  108  * le_atClient_AddUnsolicitedResponseHandler(), and can be removed using
  109  * le_atClient_RemoveUnsolicitedResponseHandler(). The subscribed handler is called when the given
  110  * pattern is detected. The handler receives a parameter with the complete line of the unsolicited
  111  * response.
  112  * The parameter @c lineCount is used to set the unsolicited lines number.
  113  * For example, @c +CMT unsolicited response has the following syntax:
  114  * @code
  115  * +CMT: ...<CR><LF>
  116  * <sms text>
  117  * @endcode
  118  * In this case, @c lineCount has to be set to @c 2 to receive both lines into the handler.
  119  * @c +CREG unsolicited response is sent only one line, so @c lineCount is set to @c 1.
  120  *
  121  * <HR>
  122  *
  123  * Copyright (C) Sierra Wireless Inc.
  124  */
  125 /**
  126  * @file le_atClient_interface.h
  127  *
  128  * Legato @ref c_atClient include file.
  129  *
  130  * Copyright (C) Sierra Wireless Inc.
  131  */
  132 
  133 #ifndef LE_ATCLIENT_INTERFACE_H_INCLUDE_GUARD
  134 #define LE_ATCLIENT_INTERFACE_H_INCLUDE_GUARD
  135 
  136 
  137 #include "legato.h"
  138 
  139 // Interface specific includes
  140 #include "le_atDefs_interface.h"
  141 
  142 
  143 //--------------------------------------------------------------------------------------------------
  144 /**
  145  * Type for handler called when a server disconnects.
  146  */
  147 //--------------------------------------------------------------------------------------------------
  148 typedef void (*le_atClient_DisconnectHandler_t)(void *);
  149 
  150 //--------------------------------------------------------------------------------------------------
  151 /**
  152  *
  153  * Connect the current client thread to the service providing this API. Block until the service is
  154  * available.
  155  *
  156  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  157  * called before any other functions in this API.  Normally, ConnectService is automatically called
  158  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  159  *
  160  * This function is created automatically.
  161  */
  162 //--------------------------------------------------------------------------------------------------
  163 void le_atClient_ConnectService
  164 (
  165     void
  166 );
  167 
  168 //--------------------------------------------------------------------------------------------------
  169 /**
  170  *
  171  * Try to connect the current client thread to the service providing this API. Return with an error
  172  * if the service is not available.
  173  *
  174  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  175  * called before any other functions in this API.  Normally, ConnectService is automatically called
  176  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  177  *
  178  * This function is created automatically.
  179  *
  180  * @return
  181  *  - LE_OK if the client connected successfully to the service.
  182  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  183  *    bound.
  184  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  185  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  186  */
  187 //--------------------------------------------------------------------------------------------------
  188 le_result_t le_atClient_TryConnectService
  189 (
  190     void
  191 );
  192 
  193 //--------------------------------------------------------------------------------------------------
  194 /**
  195  * Set handler called when server disconnection is detected.
  196  *
  197  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  198  * to continue without exiting, it should call longjmp() from inside the handler.
  199  */
  200 //--------------------------------------------------------------------------------------------------
  201 void le_atClient_SetServerDisconnectHandler
  202 (
  203     le_atClient_DisconnectHandler_t disconnectHandler,
  204     void *contextPtr
  205 );
  206 
  207 //--------------------------------------------------------------------------------------------------
  208 /**
  209  *
  210  * Disconnect the current client thread from the service providing this API.
  211  *
  212  * Normally, this function doesn't need to be called. After this function is called, there's no
  213  * longer a connection to the service, and the functions in this API can't be used. For details, see
  214  * @ref apiFilesC_client.
  215  *
  216  * This function is created automatically.
  217  */
  218 //--------------------------------------------------------------------------------------------------
  219 void le_atClient_DisconnectService
  220 (
  221     void
  222 );
  223 
  224 
  225 //--------------------------------------------------------------------------------------------------
  226 /**
  227  */
  228 //--------------------------------------------------------------------------------------------------
  229 typedef struct le_atClient_Cmd* le_atClient_CmdRef_t;
  230 
  231 
  232 //--------------------------------------------------------------------------------------------------
  233 /**
  234  */
  235 //--------------------------------------------------------------------------------------------------
  236 typedef struct le_atClient_Device* le_atClient_DeviceRef_t;
  237 
  238 
  239 //--------------------------------------------------------------------------------------------------
  240 /**
  241  * Reference type used by Add/Remove functions for EVENT 'le_atClient_UnsolicitedResponse'
  242  */
  243 //--------------------------------------------------------------------------------------------------
  244 typedef struct le_atClient_UnsolicitedResponseHandler* le_atClient_UnsolicitedResponseHandlerRef_t;
  245 
  246 
  247 //--------------------------------------------------------------------------------------------------
  248 /**
  249  * Handler for unsolicited response reception.
  250  *
  251  */
  252 //--------------------------------------------------------------------------------------------------
  253 typedef void (*le_atClient_UnsolicitedResponseHandlerFunc_t)
  254 (
  255     const char* LE_NONNULL unsolicitedRsp,
  256         ///< The call reference.
  257     void* contextPtr
  258         ///<
  259 );
  260 
  261 //--------------------------------------------------------------------------------------------------
  262 /**
  263  * This function must be called to start a ATClient session on a specified device.
  264  *
  265  * @return reference on a device context
  266  */
  267 //--------------------------------------------------------------------------------------------------
  268 le_atClient_DeviceRef_t le_atClient_Start
  269 (
  270     int fd
  271         ///< [IN] File descriptor.
  272 );
  273 
  274 //--------------------------------------------------------------------------------------------------
  275 /**
  276  * This function must be called to stop the ATClient session on the specified device.
  277  *
  278  * @return
  279  *      - LE_FAULT when function failed
  280  *      - LE_OK when function succeed
  281  */
  282 //--------------------------------------------------------------------------------------------------
  283 le_result_t le_atClient_Stop
  284 (
  285     le_atClient_DeviceRef_t device
  286         ///< [IN] Device reference
  287 );
  288 
  289 //--------------------------------------------------------------------------------------------------
  290 /**
  291  * This function must be called to create a new AT command.
  292  *
  293  * @return pointer to the new AT Command reference
  294  */
  295 //--------------------------------------------------------------------------------------------------
  296 le_atClient_CmdRef_t le_atClient_Create
  297 (
  298     void
  299 );
  300 
  301 //--------------------------------------------------------------------------------------------------
  302 /**
  303  * This function must be called to delete an AT command reference.
  304  *
  305  * @return
  306  *      - LE_OK when function succeed
  307  *
  308  * @note If the AT Command reference is invalid, a fatal error occurs,
  309  *       the function won't return.
  310  */
  311 //--------------------------------------------------------------------------------------------------
  312 le_result_t le_atClient_Delete
  313 (
  314     le_atClient_CmdRef_t cmdRef
  315         ///< [IN] AT Command
  316 );
  317 
  318 //--------------------------------------------------------------------------------------------------
  319 /**
  320  * This function must be called to set the AT command string to be sent.
  321  *
  322  * @return
  323  *      - LE_OK when function succeed
  324  *
  325  * @note If the AT Command reference is invalid, a fatal error occurs,
  326  *       the function won't return.
  327  */
  328 //--------------------------------------------------------------------------------------------------
  329 le_result_t le_atClient_SetCommand
  330 (
  331     le_atClient_CmdRef_t cmdRef,
  332         ///< [IN] AT Command
  333     const char* LE_NONNULL command
  334         ///< [IN] Set Command
  335 );
  336 
  337 //--------------------------------------------------------------------------------------------------
  338 /**
  339  * This function must be called to set the waiting intermediate responses.
  340  * Several intermediate responses can be specified separated by a '|' character into the string
  341  * given in parameter.
  342  *
  343  * @return
  344  *      - LE_FAULT when function failed
  345  *      - LE_OK when function succeed
  346  *
  347  * @note If the AT Command reference or set intermediate response is invalid, a fatal error occurs,
  348  *       the function won't return.
  349  */
  350 //--------------------------------------------------------------------------------------------------
  351 le_result_t le_atClient_SetIntermediateResponse
  352 (
  353     le_atClient_CmdRef_t cmdRef,
  354         ///< [IN] AT Command
  355     const char* LE_NONNULL intermediate
  356         ///< [IN] Set Intermediate
  357 );
  358 
  359 //--------------------------------------------------------------------------------------------------
  360 /**
  361  * This function must be called to set the final response(s) of the AT command execution.
  362  * Several final responses can be specified separated by a '|' character into the string given in
  363  * parameter.
  364  *
  365  * @return
  366  *      - LE_FAULT when function failed
  367  *      - LE_OK when function succeed
  368  *
  369  * @note If the AT Command reference or set response is invalid, a fatal error occurs,
  370  *       the function won't return.
  371  */
  372 //--------------------------------------------------------------------------------------------------
  373 le_result_t le_atClient_SetFinalResponse
  374 (
  375     le_atClient_CmdRef_t cmdRef,
  376         ///< [IN] AT Command
  377     const char* LE_NONNULL response
  378         ///< [IN] Set Response
  379 );
  380 
  381 //--------------------------------------------------------------------------------------------------
  382 /**
  383  * This function must be called to set the text when the prompt is expected.
  384  *
  385  * @return
  386  *      - LE_FAULT when function failed
  387  *      - LE_OK when function succeed
  388  *
  389  * @note If the AT Command reference is invalid, a fatal error occurs,
  390  *       the function won't return.
  391  */
  392 //--------------------------------------------------------------------------------------------------
  393 le_result_t le_atClient_SetText
  394 (
  395     le_atClient_CmdRef_t cmdRef,
  396         ///< [IN] AT Command
  397     const char* LE_NONNULL text
  398         ///< [IN] The AT Data to send
  399 );
  400 
  401 //--------------------------------------------------------------------------------------------------
  402 /**
  403  * This function must be called to set the timeout of the AT command execution.
  404  *
  405  * @return
  406  *      - LE_OK when function succeed
  407  *
  408  * @note If the AT Command reference is invalid, a fatal error occurs,
  409  *       the function won't return.
  410  */
  411 //--------------------------------------------------------------------------------------------------
  412 le_result_t le_atClient_SetTimeout
  413 (
  414     le_atClient_CmdRef_t cmdRef,
  415         ///< [IN] AT Command
  416     uint32_t timer
  417         ///< [IN] The timeout value in milliseconds.
  418 );
  419 
  420 //--------------------------------------------------------------------------------------------------
  421 /**
  422  * This function must be called to set the device where the AT command will be sent.
  423  *
  424  * @return
  425  *      - LE_FAULT when function failed
  426  *      - LE_OK when function succeed
  427  *
  428  * @note If the AT Command reference is invalid, a fatal error occurs,
  429  *       the function won't return.
  430  */
  431 //--------------------------------------------------------------------------------------------------
  432 le_result_t le_atClient_SetDevice
  433 (
  434     le_atClient_CmdRef_t cmdRef,
  435         ///< [IN] AT Command
  436     le_atClient_DeviceRef_t devRef
  437         ///< [IN] Device where the AT command has to be sent
  438 );
  439 
  440 //--------------------------------------------------------------------------------------------------
  441 /**
  442  * This function must be called to send an AT Command and wait for response.
  443  *
  444  * @return
  445  *      - LE_FAULT when function failed
  446  *      - LE_TIMEOUT when a timeout occur
  447  *      - LE_OK when function succeed
  448  *
  449  * @note If the AT Command reference is invalid, a fatal error occurs,
  450  *       the function won't return.
  451  */
  452 //--------------------------------------------------------------------------------------------------
  453 le_result_t le_atClient_Send
  454 (
  455     le_atClient_CmdRef_t cmdRef
  456         ///< [IN] AT Command
  457 );
  458 
  459 //--------------------------------------------------------------------------------------------------
  460 /**
  461  * This function is used to get the first intermediate response.
  462  *
  463  * @return
  464  *      - LE_FAULT when function failed
  465  *      - LE_OK when function succeed
  466  *
  467  * @note If the AT Command reference is invalid, a fatal error occurs,
  468  *       the function won't return.
  469  */
  470 //--------------------------------------------------------------------------------------------------
  471 le_result_t le_atClient_GetFirstIntermediateResponse
  472 (
  473     le_atClient_CmdRef_t cmdRef,
  474         ///< [IN] AT Command
  475     char* intermediateRsp,
  476         ///< [OUT] First intermediate result code
  477     size_t intermediateRspSize
  478         ///< [IN]
  479 );
  480 
  481 //--------------------------------------------------------------------------------------------------
  482 /**
  483  * This function is used to get the next intermediate response.
  484  *
  485  * @return
  486  *      - LE_NOT_FOUND when there are no further results
  487  *      - LE_OK when function succeed
  488  *
  489  * @note If the AT Command reference is invalid, a fatal error occurs,
  490  *       the function won't return.
  491  */
  492 //--------------------------------------------------------------------------------------------------
  493 le_result_t le_atClient_GetNextIntermediateResponse
  494 (
  495     le_atClient_CmdRef_t cmdRef,
  496         ///< [IN] AT Command
  497     char* intermediateRsp,
  498         ///< [OUT] Get Next intermediate result
  499         ///< code.
  500     size_t intermediateRspSize
  501         ///< [IN]
  502 );
  503 
  504 //--------------------------------------------------------------------------------------------------
  505 /**
  506  * This function is used to get the final response
  507  *
  508  * @return
  509  *      - LE_FAULT when function failed
  510  *      - LE_OK when function succeed
  511  *
  512  * @note If the AT Command reference is invalid, a fatal error occurs,
  513  *       the function won't return.
  514  */
  515 //--------------------------------------------------------------------------------------------------
  516 le_result_t le_atClient_GetFinalResponse
  517 (
  518     le_atClient_CmdRef_t cmdRef,
  519         ///< [IN] AT Command
  520     char* finalRsp,
  521         ///< [OUT] Get Final Line
  522     size_t finalRspSize
  523         ///< [IN]
  524 );
  525 
  526 //--------------------------------------------------------------------------------------------------
  527 /**
  528  * This function must be called to automatically set and send an AT Command.
  529  *
  530  * @return
  531  *      - LE_FAULT when function failed
  532  *      - LE_TIMEOUT when a timeout occur
  533  *      - LE_OK when function succeed
  534  *
  535  * @note This command creates a command reference when called
  536  *
  537  * @note In case of an Error the command reference will be deleted and though
  538  *       not usable. Make sure to test the return code and not use the reference
  539  *       in other functions.
  540  *
  541  * @note If the AT command is invalid, a fatal error occurs,
  542  *        the function won't return.
  543  *
  544  */
  545 //--------------------------------------------------------------------------------------------------
  546 le_result_t le_atClient_SetCommandAndSend
  547 (
  548     le_atClient_CmdRef_t* cmdRefPtr,
  549         ///< [OUT] Cmd reference
  550     le_atClient_DeviceRef_t devRef,
  551         ///< [IN] Dev reference
  552     const char* LE_NONNULL command,
  553         ///< [IN] AT Command
  554     const char* LE_NONNULL interResp,
  555         ///< [IN] Expected intermediate response
  556     const char* LE_NONNULL finalResp,
  557         ///< [IN] Expected final response
  558     uint32_t timeout
  559         ///< [IN] Timeout value in milliseconds.
  560 );
  561 
  562 //--------------------------------------------------------------------------------------------------
  563 /**
  564  * Add handler function for EVENT 'le_atClient_UnsolicitedResponse'
  565  *
  566  * This event provides information on a subscribed unsolicited response when this unsolicited
  567  * response is received.
  568  *
  569  */
  570 //--------------------------------------------------------------------------------------------------
  571 le_atClient_UnsolicitedResponseHandlerRef_t le_atClient_AddUnsolicitedResponseHandler
  572 (
  573     const char* LE_NONNULL unsolRsp,
  574         ///< [IN] Pattern to match
  575     le_atClient_DeviceRef_t devRef,
  576         ///< [IN] Device to listen
  577     le_atClient_UnsolicitedResponseHandlerFunc_t handlerPtr,
  578         ///< [IN] unsolicited handler
  579     void* contextPtr,
  580         ///< [IN]
  581     uint32_t lineCount
  582         ///< [IN] Indicate the number of line of
  583         ///< the unsolicited
  584 );
  585 
  586 //--------------------------------------------------------------------------------------------------
  587 /**
  588  * Remove handler function for EVENT 'le_atClient_UnsolicitedResponse'
  589  */
  590 //--------------------------------------------------------------------------------------------------
  591 void le_atClient_RemoveUnsolicitedResponseHandler
  592 (
  593     le_atClient_UnsolicitedResponseHandlerRef_t handlerRef
  594         ///< [IN]
  595 );
  596 
  597 #endif // LE_ATCLIENT_INTERFACE_H_INCLUDE_GUARD
le_atClient_TryConnectService
le_result_t le_atClient_TryConnectService(void)
le_atClient_AddUnsolicitedResponseHandler
le_atClient_UnsolicitedResponseHandlerRef_t le_atClient_AddUnsolicitedResponseHandler(const char *LE_NONNULL unsolRsp, le_atClient_DeviceRef_t devRef, le_atClient_UnsolicitedResponseHandlerFunc_t handlerPtr, void *contextPtr, uint32_t lineCount)
le_atClient_SetTimeout
le_result_t le_atClient_SetTimeout(le_atClient_CmdRef_t cmdRef, uint32_t timer)
le_result_t
le_result_t
Definition: le_basics.h:35
le_atClient_UnsolicitedResponseHandlerFunc_t
void(* le_atClient_UnsolicitedResponseHandlerFunc_t)(const char *LE_NONNULL unsolicitedRsp, void *contextPtr)
Definition: le_atClient_interface.h:254
le_atClient_SetText
le_result_t le_atClient_SetText(le_atClient_CmdRef_t cmdRef, const char *LE_NONNULL text)
le_atClient_SetServerDisconnectHandler
void le_atClient_SetServerDisconnectHandler(le_atClient_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_atDefs_interface.h
le_atClient_SetIntermediateResponse
le_result_t le_atClient_SetIntermediateResponse(le_atClient_CmdRef_t cmdRef, const char *LE_NONNULL intermediate)
le_atClient_Delete
le_result_t le_atClient_Delete(le_atClient_CmdRef_t cmdRef)
le_atClient_Start
le_atClient_DeviceRef_t le_atClient_Start(int fd)
le_atClient_GetNextIntermediateResponse
le_result_t le_atClient_GetNextIntermediateResponse(le_atClient_CmdRef_t cmdRef, char *intermediateRsp, size_t intermediateRspSize)
le_atClient_DisconnectHandler_t
void(* le_atClient_DisconnectHandler_t)(void *)
Definition: le_atClient_interface.h:148
le_atClient_SetDevice
le_result_t le_atClient_SetDevice(le_atClient_CmdRef_t cmdRef, le_atClient_DeviceRef_t devRef)
le_atClient_UnsolicitedResponseHandlerRef_t
struct le_atClient_UnsolicitedResponseHandler * le_atClient_UnsolicitedResponseHandlerRef_t
Definition: le_atClient_interface.h:244
le_atClient_SetCommandAndSend
le_result_t le_atClient_SetCommandAndSend(le_atClient_CmdRef_t *cmdRefPtr, le_atClient_DeviceRef_t devRef, const char *LE_NONNULL command, const char *LE_NONNULL interResp, const char *LE_NONNULL finalResp, uint32_t timeout)
le_atClient_Create
le_atClient_CmdRef_t le_atClient_Create(void)
le_atClient_GetFinalResponse
le_result_t le_atClient_GetFinalResponse(le_atClient_CmdRef_t cmdRef, char *finalRsp, size_t finalRspSize)
legato.h
le_atClient_Send
le_result_t le_atClient_Send(le_atClient_CmdRef_t cmdRef)
le_atClient_Stop
le_result_t le_atClient_Stop(le_atClient_DeviceRef_t device)
le_atClient_RemoveUnsolicitedResponseHandler
void le_atClient_RemoveUnsolicitedResponseHandler(le_atClient_UnsolicitedResponseHandlerRef_t handlerRef)
le_atClient_SetFinalResponse
le_result_t le_atClient_SetFinalResponse(le_atClient_CmdRef_t cmdRef, const char *LE_NONNULL response)
le_atClient_ConnectService
void le_atClient_ConnectService(void)
le_atClient_GetFirstIntermediateResponse
le_result_t le_atClient_GetFirstIntermediateResponse(le_atClient_CmdRef_t cmdRef, char *intermediateRsp, size_t intermediateRspSize)
le_atClient_DisconnectService
void le_atClient_DisconnectService(void)
le_atClient_SetCommand
le_result_t le_atClient_SetCommand(le_atClient_CmdRef_t cmdRef, const char *LE_NONNULL command)