AT interface

AT commands
Initialization
The API and the C library
Sending AT commands
Reading data from an AT response
Sending an AT command and reading the response
- Differences with nrf_modem_at_printf
- Differences with nrf_modem_at_scanf
Receiving AT notifications
Thread safety

The Modem library supports sending AT commands to the modem, reading responses, and receiving AT notifications using the AT API found in nrfxlib/nrf_modem/include/nrf_modem_at.h.

AT commands 

AT commands are essentially a set of modem instructions that are used to configure the modem, establish a network connection (or in general, execute operations), and retrieve modem and connection status information. For the full set of supported AT commands, see the AT Commands Reference Guide.

Initialization 

The AT interface can be used once the application initializes the Modem library in NORMAL_MODE by calling nrf_modem_init().

The API and the C library 

The AT interface is modelled after the printf() and scanf() C library functions, which are two powerful functions to print output and scan input according to a specified format. Internally, the AT interface implementation uses the vsnprintf() and vsscanf() functions from the standard C library, and therefore, these functions affect the behavior of this API.

Note

The Modem library requires a C library implementation that provides both vsnprintf() and vsscanf().

Depending on the implementation of the C library that is built with the application, some format specifiers and length modifiers might not be supported or might not behave as expected when using the AT interface functions. This might be the case for format specifiers or length modifiers introduced in newer version of the C standard, as is the case for the hh, ll, j, z and t length modifiers introduced in C99.

Newlibc is a common C library for embedded systems that can be used in nRF Connect SDK. It is available in two versions, nano and vanilla, the former having a smaller feature set and reduced ROM footprint. Generally, the vanilla version will support more format and length modifiers than the nano version. Keep in mind that the Newlibc C library implementation is provided by the compiler toolchain, and the choice of a toolchain can indirectly affect the functionality of the C library. Between the nano and the vanilla Newlibc C library versions, only the latter is known to support C99 length specifiers when using Zephyr’s sdk-ng toolchain or the third-party GNU Arm Embedded Toolchain gnuarmemb.

Sending AT commands 

The application can use nrf_modem_at_printf() to send a formatted AT command to the modem when it is interested only in the result of the operation, for example, OK, ERROR, +CME ERROR or +CMS ERROR. This function works similarly to printf() from the standard C library, and it supports all the format specifiers supported by the printf() implementation of the selected C library.

The following snippet shows how to use nrf_modem_at_printf() to send a formatted AT command to the modem and check the result of the operation:

int cfun_control(int mode)
{
        int err;

        err = nrf_modem_at_printf("AT+CFUN=%d", mode);
        if (err = 0) {
                /* OK, success */
        } else if (err < 0) {
                /* Failed to send command, err is an nrf_errno */
        } else if (err > 0) {
                /* Command was sent, but response is not "OK" */
                switch(nrf_modem_at_err_type(err)) {
                case NRF_MODEM_AT_ERROR:
                        /* Modem returned "ERROR" */
                        printf("error");
                        break;
                case NRF_MODEM_AT_CME_ERROR:
                        /* Modem returned "+CME ERROR" */
                        printf("cme error: %d", nrf_modem_at_err(err));
                        break;
                case NRF_MODEM_AT_CMS_ERROR:
                        /* Modem returned "+CMS ERROR" */
                        printf("cms error: %d", nrf_modem_at_err(err));
                        break;
                }
        }
        return err;
}

int foo(void)
{
        /* Send AT+CFUN=1 */
        cfun_control(1);
        /* Send AT+CFUN=4 */
        cfun_control(4);
}

Any return value other than zero indicates an error. Negative values indicate that the Modem library has failed to send the AT command, and they represent a nrf_errno code that indicates the reason for the failure. Positive values indicate that the modem has received the AT command and has responded with an error. When a positive value is returned, the error type can be retrieved using the nrf_modem_at_err_type() helper function, and the error value (in case of CME or CMS errors) can be retrieved with the nrf_modem_at_err() helper function.

When possible, send unformatted AT commands instead of formatting the whole command as a string. Avoiding formatting reduces the stack requirements for the call.

nrf_modem_at_printf("AT");                      /* sends "AT", low stack usage */
nrf_modem_at_printf("%s", "AT");        /* sends "AT", high stack usage */

char buf[] = "AT";
nrf_modem_at_printf(buf);                       /* sends "AT", low stack usage */
nrf_modem_at_printf("%s", buf);         /* sends "AT", high stack usage */

Note

The application must use escape characters in AT commands as it would when formatting it using printf(). For example, the % character must be used with the escape character as %%.

Reading data from an AT response 

Use nrf_modem_at_scanf() to send an AT command to the modem and parse the response according to a specified format. This function works similarly to scanf() from the standard C library, and it supports all the format specifiers supported by the scanf() implementation of the selected C library.

The following snippet shows how to use nrf_modem_at_scanf() to read the modem network registration status using AT+CEREG?

void cereg_read(void)
{
        int rc;
        int status;

        /* The `*` sub-specifier discards the result of the match.
         * The data is read but it is not stored in any argument.
         */
        rc = nrf_modem_at_scanf("AT+CEREG?", "+CEREG: %*d,%d", &status);

        /* Upon returning, `rc` contains the number of matches */
        if (rc == 1) {
                /* We have matched one argument */
                printf("Network registration status: %d\n", status);
        } else {
                /* No arguments where matched */
        }
}

Note

The nrf_modem_at_scanf() function has a stack usage of at least 512 bytes, which increases, like for all functions, with the number of arguments passed to the function. The actual stack usage depends on the vsscanf() implementation found in the C library that is compiled with the application. If the stack requirements for this function cannot be met by the calling thread, the application can instead call nrf_modem_at_cmd() and parse the response manually.

Sending an AT command and reading the response 

The application can use nrf_modem_at_cmd() to send a formatted AT command to the modem and copy the AT response into the buffer that is supplied to the function. The application can then parse the buffer as necessary, for example, by using the C library function sscanf(), thus achieving the combined functionality of nrf_modem_at_printf() and nrf_modem_at_scanf(). Alternatively, the application can parse the response in any other way, as necessary.

This function works similarly to printf() from the standard C library, and it supports all the format specifiers supported by the printf() implementation of the selected C library. The following snippet shows how to use the nrf_modem_at_cmd() function to change the function mode by using the AT+CFUN command and read the modem response:

void foo(void)
{
        int err;
        char response[64];

        err = nrf_modem_at_cmd(response, sizeof(response), "AT+CFUN=%d", 1);
        if (err) {
                /* error */
        }

        /* buffer contains the whole response */
        printf("Modem response:\n%s", response);
}

The application can use nrf_modem_at_cmd_async() to send a formatted AT command and receive the whole response asynchronously through the provided callback function. Only one asynchronous command can be pending at any time.

The following snippet shows how to use the nrf_modem_at_cmd_async() function to change the function mode by using the AT+CFUN command and read the modem response:

void resp_callback(const char *at_response)
{
        printf("AT response received:\n%s", at_response);
}

void foo(void)
{
        int err;

        err = nrf_modem_at_cmd_async(resp_callback, "AT+CFUN=%d", 1);
        if (err) {
                /* error */
        }
}

Note

The callback function is executed in an interrupt service routine. The user is responsible for rescheduling any processing of the response as appropriate.

When there is a pending response, all other functions belonging to the AT API will block until the response is received in the callback function.

Note

The application must use escape characters in AT commands as it would when formatting it using printf(). For example, the % character must be used with the escape character as %%.

Differences with nrf_modem_at_printf 

Both functions can be used to send a formatted AT command to the modem, the main difference is how the AT response is handled. The nrf_modem_at_cmd() function parses the modem AT response and returns an error accordingly. In addition, it copies the whole modem AT response to the supplied buffer. The nrf_modem_at_printf() function parses the modem AT response and returns an error accordingly. However, the function does not make a copy of the AT response.

The application can use nrf_modem_at_printf() if it requires the result of the AT command (for example, OK or ERROR) and nrf_modem_at_cmd() (or nrf_modem_at_scanf()) if it requires the contents of the AT response.

Differences with nrf_modem_at_scanf 

The application can use nrf_modem_at_scanf() when it is convenient to parse the modem response based on a scanf() format. In this case, the application need not provide any intermediate buffers and can instead parse the response directly into the provided arguments, thus avoiding any extra copy operations.

Conversely, nrf_modem_at_cmd() is the only function in the AT interface that copies the whole response of the modem from the shared memory into the provided input buffer, which is owned by the application. Therefore, this function can be used when the application needs the whole AT command response, as received from the modem, or in those cases when the stack requirements of nrf_modem_at_scanf() are too high for the calling thread, or when parsing the response using a scanf() format is hard.

Receiving AT notifications 

The Modem library can dispatch incoming AT notifications from the modem to a user-provided callback function set by nrf_modem_at_notif_handler_set(). Only one callback function must be registered with the Modem library. Registering a new callback function will override any callback previously set. Multiple parts of an application might require receiving of AT notifications, thus AT notifications need to be dispatched as necessary. In nRF Connect SDK, AT monitor library takes care of the dispatching of notifications.

The following snippet shows how to setup an AT notification handler:

void notif_callback(const char *at_notification)
{
        printf("AT notification received: %s\n", at_notification);
}

int foo(void)
{
        int err;

        err = nrf_modem_at_notif_handler_set(notif_callback);
        if (err) {
                /* error */
        }

        return 0;
}

Note

The callback is invoked in an interrupt context. The user is responsible for rescheduling the processing of AT notifications as appropriate. In nRF Connect SDK, the AT monitor library and the Modem library integration layer takes care of the rescheduling.

Thread safety 

The AT API is thread safe and can be used by multiple threads.