diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt index d8d194f2..1e239567 100644 --- a/app/CMakeLists.txt +++ b/app/CMakeLists.txt @@ -21,6 +21,7 @@ target_sources(app PRIVATE src/sm_at_icmp.c) target_sources(app PRIVATE src/sm_at_fota.c) target_sources(app PRIVATE src/sm_at_dfu.c) target_sources(app PRIVATE src/sm_uart_handler.c) +target_sources(app PRIVATE src/sm_log.c) # NORDIC SDK APP END target_sources_ifdef(CONFIG_SM_SMS app PRIVATE src/sm_at_sms.c) target_sources_ifdef(CONFIG_SM_PPP app PRIVATE src/sm_ppp.c) diff --git a/app/boards/nrf9151dk_nrf9151_ns.overlay b/app/boards/nrf9151dk_nrf9151_ns.overlay index ca3be6d0..e9b9fb1a 100644 --- a/app/boards/nrf9151dk_nrf9151_ns.overlay +++ b/app/boards/nrf9151dk_nrf9151_ns.overlay @@ -8,6 +8,7 @@ chosen { ncs,sm-uart = &dtr_uart0; nordic,pm-ext-flash = &gd25wb256; + zephyr,console = &uart1; }; }; @@ -69,3 +70,11 @@ &i2c2 { status = "disabled"; }; + +/* Enable UART1 as the shared backend for Zephyr logs and modem traces (VCOM1 on the DK). + * Modem traces require 1 000 000 baud. Hardware flow control is not used. + */ +&uart1 { + status = "okay"; + current-speed = <1000000>; +}; diff --git a/app/boards/thingy91x_nrf9151_ns.overlay b/app/boards/thingy91x_nrf9151_ns.overlay index 114041af..9f63f502 100644 --- a/app/boards/thingy91x_nrf9151_ns.overlay +++ b/app/boards/thingy91x_nrf9151_ns.overlay @@ -7,6 +7,7 @@ / { chosen { ncs,sm-uart = &dtr_uart0; + zephyr,console = &uart1; }; }; @@ -27,3 +28,11 @@ /* Use PORT event for DTR (26) pin to save power */ sense-edge-mask = ; }; + +/* Enable UART1 as the shared backend for Zephyr logs and modem traces. + * Modem traces require 1 000 000 baud. Hardware flow control is not used. + */ +&uart1 { + status = "okay"; + current-speed = <1000000>; +}; diff --git a/app/overlay-trace-backend-uart.conf b/app/overlay-trace-backend-uart.conf index 81219079..8f74f23d 100644 --- a/app/overlay-trace-backend-uart.conf +++ b/app/overlay-trace-backend-uart.conf @@ -4,14 +4,6 @@ # SPDX-License-Identifier: LicenseRef-Nordic-5-Clause # -# Enable UART logging backend - shared with nRF modem traces. -CONFIG_UART_CONSOLE=y -CONFIG_RTT_CONSOLE=n -CONFIG_LOG_BACKEND_RTT=n -# Log backend starts disabled; the UART is off until activated via AT#XLOG=1. -CONFIG_LOG_BACKEND_UART=y -CONFIG_LOG_BACKEND_UART_AUTOSTART=n - # Enable UART modem trace backend - shared with the UART log backend. CONFIG_SM_MODEM_TRACE_BACKEND_UART=y CONFIG_NRF_MODEM_LIB_TRACE=y diff --git a/app/overlay-trace-backend-uart.overlay b/app/overlay-trace-backend-uart.overlay deleted file mode 100644 index f8be3317..00000000 --- a/app/overlay-trace-backend-uart.overlay +++ /dev/null @@ -1,14 +0,0 @@ -/ { - chosen { - /* Route the shared log/trace UART backend to UART1 (VCOM1 on DK). */ - zephyr,console = &uart1; - }; -}; - -/* Enable UART1 as the shared backend for Zephyr logs and modem traces (VCOM1 on the DK). - * Modem traces require 1 000 000 baud. Hardware flow control is not used. - */ -&uart1 { - status = "okay"; - current-speed = <1000000>; -}; diff --git a/app/prj.conf b/app/prj.conf index 625bc6f7..405557a1 100644 --- a/app/prj.conf +++ b/app/prj.conf @@ -14,20 +14,19 @@ CONFIG_RING_BUFFER=y CONFIG_REBOOT=y CONFIG_EVENTFD=y -# Segger RTT -CONFIG_USE_SEGGER_RTT=y -# Where console messages (printk) are output. -# By itself, SM does not output any. -CONFIG_RTT_CONSOLE=y -CONFIG_UART_CONSOLE=n -# Where logs are output. -CONFIG_LOG_BACKEND_RTT=y -CONFIG_LOG_BACKEND_UART=n -# Increase the buffer so that all Serial Modem boot logs fit into the buffer. -# Because J-Link RTT Viewer has to be connected after the bootup, -# only logs that fit into the buffer are shown. This is especially useful in showing -# errors if Serial Modem does not start properly. -CONFIG_SEGGER_RTT_BUFFER_SIZE_UP=2048 +# Enable UART logging by default. +CONFIG_UART_CONSOLE=y +CONFIG_LOG_BACKEND_UART=y +# Logging does not start until activated via AT#XLOG=1 and is deactivated with AT#XLOG=0. +CONFIG_LOG_BACKEND_UART_AUTOSTART=n + +# Disable Segger RTT logging by default. +CONFIG_USE_SEGGER_RTT=n +CONFIG_RTT_CONSOLE=n +CONFIG_LOG_BACKEND_RTT=n +# Optional: when RTT logging is enabled, increase the RTT buffer so that +# all Serial Modem boot logs fit into the buffer. +#CONFIG_SEGGER_RTT_BUFFER_SIZE_UP=2048 # Network CONFIG_NETWORKING=y diff --git a/app/sample.yaml b/app/sample.yaml index 897c1cc4..b8e5a745 100644 --- a/app/sample.yaml +++ b/app/sample.yaml @@ -6,7 +6,7 @@ tests: build_only: true extra_args: - EXTRA_CONF_FILE="overlay-cmux.conf;overlay-ppp.conf;overlay-trace-backend-uart.conf;overlay-nrf-device-provisioning.conf" - - EXTRA_DTC_OVERLAY_FILE="overlay-nrf91m1.overlay;overlay-trace-backend-uart.overlay" + - EXTRA_DTC_OVERLAY_FILE="overlay-nrf91m1.overlay" extra_configs: - CONFIG_SM_LOG_LEVEL_DBG=y platform_allow: diff --git a/app/src/sm_log.c b/app/src/sm_log.c new file mode 100644 index 00000000..72403355 --- /dev/null +++ b/app/src/sm_log.c @@ -0,0 +1,146 @@ +/* + * Copyright (c) 2026 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +/* + * AT#XLOG command — enable/disable the Zephyr UART log backend at runtime. + * + * The UART (zephyr,console) is shared with the modem-trace backend + * (sm_trace_backend_uart.c). AT#XLOG and AT#XTRACE are mutually exclusive: + * each refuses to activate while the other is in use. + * + */ + +#include + +/* Only compiled if zephyr,console is present and active in the devicetree. */ +#if DT_HAS_CHOSEN(zephyr_console) && DT_NODE_HAS_STATUS(DT_CHOSEN(zephyr_console), okay) + +#include +#include +#include +#include +#include + +#include "sm_at_host.h" + +LOG_MODULE_REGISTER(sm_log, CONFIG_SM_LOG_LEVEL); + +/* Zephyr console UART is used both for application logs and modem traces. */ +#define UART_DEVICE_NODE DT_CHOSEN(zephyr_console) +static const struct device *const uart_dev = DEVICE_DT_GET(UART_DEVICE_NODE); + +static bool log_active; + +static int uart_suspend(void) +{ + int ret = pm_device_action_run(uart_dev, PM_DEVICE_ACTION_SUSPEND); + + if (ret && ret != -EALREADY) { + LOG_ERR("Failed to %s UART device: %d", "suspend", ret); + return ret; + } + + return 0; +} + +static int uart_resume(void) +{ + int ret = pm_device_action_run(uart_dev, PM_DEVICE_ACTION_RESUME); + + if (ret && ret != -EALREADY) { + LOG_ERR("Failed to %s UART device: %d", "resume", ret); + return ret; + } + return 0; +} + +static bool uart_is_active(void) +{ + enum pm_device_state state = PM_DEVICE_STATE_OFF; + int err = pm_device_state_get(uart_dev, &state); + + if (err) { + LOG_ERR("Failed to get UART device state (%d).", err); + return false; + } + return state == PM_DEVICE_STATE_ACTIVE; +} + +SM_AT_CMD_CUSTOM(xlog, "AT#XLOG", handle_at_log); +STATIC int handle_at_log(enum at_parser_cmd_type cmd_type, struct at_parser *parser, uint32_t) +{ + const struct log_backend *log_be = log_backend_get_by_name("log_backend_uart"); + + if (!log_be) { + return -ENODEV; + } + + if (cmd_type == AT_PARSER_CMD_TYPE_SET) { + int mode; + int ret = at_parser_num_get(parser, 1, &mode); + + if (ret || (mode < 0) || (mode > 1)) { + return -EINVAL; + } + + if (mode == (int)log_active) { + return 0; + } + + if (mode == 1 && uart_is_active()) { + return -EBUSY; + } + + if (mode == 1) { + ret = uart_resume(); + if (ret) { + return ret; + } + if (!log_be->cb->initialized) { + log_backend_init(log_be); + } + log_backend_enable(log_be, log_be->cb->ctx, CONFIG_LOG_DEFAULT_LEVEL); + log_active = true; + } else { + log_backend_disable(log_be); + ret = uart_suspend(); + if (ret) { + return ret; + } + log_active = false; + } + return 0; + } else if (cmd_type == AT_PARSER_CMD_TYPE_READ) { + rsp_send("\r\n#XLOG: %d\r\n", (int)log_active); + return 0; + } else if (cmd_type == AT_PARSER_CMD_TYPE_TEST) { + rsp_send("\r\n#XLOG: (0,1)\r\n"); + return 0; + } + + return -EINVAL; +} + +static int sm_log_init(void) +{ + if (!IS_ENABLED(CONFIG_LOG_BACKEND_UART) || + !IS_ENABLED(CONFIG_LOG_BACKEND_UART_AUTOSTART)) { + /* Start with UART log backend disabled. */ + if (uart_suspend()) { + LOG_ERR("Failed to suspend UART log backend"); + sm_init_failed = true; + return -EFAULT; + } + } else { + log_active = true; + } + + return 0; +} + +SYS_INIT(sm_log_init, POST_KERNEL, CONFIG_APPLICATION_INIT_PRIORITY); + +#endif /* DT_HAS_CHOSEN(zephyr_console) */ diff --git a/app/src/sm_trace_backend_uart.c b/app/src/sm_trace_backend_uart.c index 3f1a5746..39494b97 100644 --- a/app/src/sm_trace_backend_uart.c +++ b/app/src/sm_trace_backend_uart.c @@ -11,11 +11,6 @@ * This backend uses uart_tx (async DMA). The two are mutually exclusive in * time: AT#XLOG and AT#XTRACE each refuse to enable if the other is active. * - * AT#XLOG=1 enable Zephyr application log backend - * AT#XLOG=0 disable Zephyr application log backend - * AT#XTRACE=1 enable modem trace backend - * AT#XTRACE=0 disable modem trace backend - * * The UART is suspended when backends are off and resumed when either * is enabled. No baud-rate switching is performed; both sides run at the * baud rate configured in the devicetree (1 000 000 baud on the nRF9151 DK). @@ -24,7 +19,6 @@ #include #include #include -#include #include #include @@ -41,9 +35,9 @@ LOG_MODULE_REGISTER(sm_trace_backend_uart, CONFIG_MODEM_TRACE_BACKEND_LOG_LEVEL) /* Timeout per individual UART TX attempt. */ #define UART_TX_WAIT_TIME_MS 1000 -/* UART device for the log backend is used both for Zephyr logs and modem traces. */ -#define TRACE_UART_DEVICE_NODE DT_CHOSEN(zephyr_console) -static const struct device *const trace_uart_dev = DEVICE_DT_GET(TRACE_UART_DEVICE_NODE); +/* Zephyr console UART is used both for application logs and modem traces. */ +#define UART_DEVICE_NODE DT_CHOSEN(zephyr_console) +static const struct device *const uart_dev = DEVICE_DT_GET(UART_DEVICE_NODE); /* Synchronizes trace_backend_write() with activate/deactivate. */ static K_SEM_DEFINE(tx_sem, 0, 1); @@ -56,11 +50,8 @@ static volatile size_t tx_bytes; static trace_backend_processed_cb trace_processed_callback; -/* Track which backend is currently using the UART. */ -static bool log_active; static bool trace_active; -/* UART async callback — only called when trace backend is active. */ static void uart_callback(const struct device *dev, struct uart_event *evt, void *user_data) { ARG_UNUSED(dev); @@ -85,21 +76,13 @@ static int trace_backend_init(trace_backend_processed_cb trace_processed_cb) return -EFAULT; } - if (!device_is_ready(trace_uart_dev)) { + if (!device_is_ready(uart_dev)) { LOG_ERR("UART device not ready"); return -ENODEV; } trace_processed_callback = trace_processed_cb; - /* Suspend UART at startup it can be resumed in runtime. */ - int ret = pm_device_action_run(trace_uart_dev, PM_DEVICE_ACTION_SUSPEND); - - if (ret && ret != -EALREADY) { - LOG_ERR("Failed to %s UART device: %d", "suspend", ret); - return ret; - } - return 0; } @@ -121,7 +104,7 @@ static int trace_backend_write(const void *data, size_t len) k_sem_take(&tx_sem, K_FOREVER); - ret = uart_tx(trace_uart_dev, (const uint8_t *)data, chunk, + ret = uart_tx(uart_dev, (const uint8_t *)data, chunk, UART_TX_WAIT_TIME_MS * USEC_PER_MSEC); if (ret) { LOG_ERR("uart_tx failed: %d", ret); @@ -161,7 +144,7 @@ static int trace_backend_activate(void) /* Register the async callback. The log backend never calls * uart_callback_set (it uses polling), so this is the sole owner. */ - ret = uart_callback_set(trace_uart_dev, uart_callback, NULL); + ret = uart_callback_set(uart_dev, uart_callback, NULL); if (ret) { LOG_ERR("Failed to set UART callback: %d", ret); return ret; @@ -191,7 +174,7 @@ static int trace_backend_deactivate(void) /* Wait for any in-flight write to release tx_sem. */ if (k_sem_take(&tx_sem, K_MSEC(UART_TX_WAIT_TIME_MS)) != 0) { - uart_tx_abort(trace_uart_dev); + uart_tx_abort(uart_dev); k_sem_take(&tx_sem, K_FOREVER); } @@ -204,17 +187,19 @@ static int trace_backend_deactivate(void) static int uart_suspend(void) { - int ret = pm_device_action_run(trace_uart_dev, PM_DEVICE_ACTION_SUSPEND); + int ret = pm_device_action_run(uart_dev, PM_DEVICE_ACTION_SUSPEND); if (ret && ret != -EALREADY) { LOG_ERR("Failed to %s UART device: %d", "suspend", ret); + return ret; } - return ret; + + return 0; } static int uart_resume(void) { - int ret = pm_device_action_run(trace_uart_dev, PM_DEVICE_ACTION_RESUME); + int ret = pm_device_action_run(uart_dev, PM_DEVICE_ACTION_RESUME); if (ret && ret != -EALREADY) { LOG_ERR("Failed to %s UART device: %d", "resume", ret); @@ -223,57 +208,16 @@ static int uart_resume(void) return 0; } -SM_AT_CMD_CUSTOM(xlog, "AT#XLOG", handle_at_log); -STATIC int handle_at_log(enum at_parser_cmd_type cmd_type, struct at_parser *parser, uint32_t) +static bool uart_is_active(void) { - const struct log_backend *log_be = log_backend_get_by_name("log_backend_uart"); + enum pm_device_state state = PM_DEVICE_STATE_OFF; + int err = pm_device_state_get(uart_dev, &state); - if (!log_be) { - return -ENODEV; + if (err) { + LOG_ERR("Failed to get UART device state (%d).", err); + return false; } - - if (cmd_type == AT_PARSER_CMD_TYPE_SET) { - int mode; - int ret = at_parser_num_get(parser, 1, &mode); - - if (ret || (mode < 0) || (mode > 1)) { - return -EINVAL; - } - if (trace_active) { - return -EBUSY; - } - if (mode == (int)log_active) { - return 0; - } - - if (mode == 1) { - ret = uart_resume(); - if (ret) { - return ret; - } - if (!log_be->cb->initialized) { - log_backend_init(log_be); - } - log_backend_enable(log_be, log_be->cb->ctx, CONFIG_LOG_DEFAULT_LEVEL); - log_active = true; - } else { - log_backend_disable(log_be); - ret = uart_suspend(); - if (ret) { - return ret; - } - log_active = false; - } - return 0; - } else if (cmd_type == AT_PARSER_CMD_TYPE_READ) { - rsp_send("\r\n#XLOG: %d\r\n", (int)log_active); - return 0; - } else if (cmd_type == AT_PARSER_CMD_TYPE_TEST) { - rsp_send("\r\n#XLOG: (0,1)\r\n"); - return 0; - } - - return -EINVAL; + return state == PM_DEVICE_STATE_ACTIVE; } SM_AT_CMD_CUSTOM(xtrace, "AT#XTRACE", handle_at_trace); @@ -286,13 +230,15 @@ STATIC int handle_at_trace(enum at_parser_cmd_type cmd_type, struct at_parser *p if (ret || (mode < 0) || (mode > 1)) { return -EINVAL; } - if (log_active) { - return -EBUSY; - } + if (mode == (int)trace_active) { return 0; } + if (mode == 1 && uart_is_active()) { + return -EBUSY; + } + if (mode == 1) { ret = uart_resume(); if (ret) { @@ -325,3 +271,20 @@ STATIC int handle_at_trace(enum at_parser_cmd_type cmd_type, struct at_parser *p return -EINVAL; } + +static int sm_trace_backend_uart_init(void) +{ + /* Allow UART to be active if CONFIG_LOG_BACKEND_UART_AUTOSTART=y */ + if (!IS_ENABLED(CONFIG_LOG_BACKEND_UART_AUTOSTART)) { + /* Start the trace backend disabled. */ + if (uart_suspend()) { + LOG_ERR("Failed to suspend UART trace backend"); + sm_init_failed = true; + return -EFAULT; + } + } + + return 0; +} + +SYS_INIT(sm_trace_backend_uart_init, POST_KERNEL, CONFIG_APPLICATION_INIT_PRIORITY); diff --git a/doc/app/at_trace.rst b/doc/app/at_trace.rst index 8e4b5647..d4c92cf8 100644 --- a/doc/app/at_trace.rst +++ b/doc/app/at_trace.rst @@ -13,7 +13,8 @@ Trace AT commands This page describes the AT commands for controlling the shared UART trace backend. -These commands are only available when the application is built with the :file:`overlay-trace-backend-uart.conf` and :file:`overlay-trace-backend-uart.overlay` configuration overlays. +The ``AT#XLOG`` command is always available in the default build. +The ``AT#XTRACE`` command requires building with the :file:`overlay-trace-backend-uart.conf` configuration overlay. See :ref:`sm_logging_uart_backend` for a full description of the feature. The Zephyr application log backend (``AT#XLOG``) and the modem trace backend (``AT#XTRACE``) share a single UART. diff --git a/doc/app/sm_logging.rst b/doc/app/sm_logging.rst index 9d72045a..40fc1f74 100644 --- a/doc/app/sm_logging.rst +++ b/doc/app/sm_logging.rst @@ -13,46 +13,47 @@ Logs often refer to the |SM| application logging while the modem logs are referr Application logging ******************* -|SM| uses the SEGGER Real-Time Transfer (RTT) for application logging by default. -You can view the RTT logs with an RTT client such as ``J-Link RTT Viewer``. -See `Testing and optimization`_ for instructions on how to view the logs. +|SM| outputs application logs over ``UART1`` (VCOM1 on the nRF9151 DK) by default. +The UART is kept suspended at startup and activated at runtime using the ``AT#XLOG=1`` command. +This avoids any UART power overhead when logs are not needed. +See :ref:`SM_AT_trace` for the full command reference. .. note:: The negative error codes that are visible in logs are *errno* codes defined in `nrf_errno.h`_. -By default, the |SM| uses the ``UART0`` for sending and receiving AT commands. -If a different UART is used, the application log can be output through ``UART0`` while AT commands are sent and received through the other UART. -To switch to ``UART0`` output for application logs, change the following options in the :file:`prj.conf` file:: - - # Segger RTT - CONFIG_USE_SEGGER_RTT=n - CONFIG_RTT_CONSOLE=n - CONFIG_UART_CONSOLE=y - CONFIG_LOG_BACKEND_RTT=n - CONFIG_LOG_BACKEND_UART=y - The default logging level for the |SM| is ``CONFIG_SM_LOG_LEVEL_INF``. You can get more verbose logs by setting the ``CONFIG_SM_LOG_LEVEL_DBG`` Kconfig option. TF-M logging must use the same UART as the application. For more details, see `shared TF-M logging`_. -Modem traces -************ +.. _sm_logging_rtt: -To send modem traces over UART on an nRF91 Series DK, configuration must be added for the UART device in the devicetree and Kconfig. -This is done by adding the `modem trace UART snippet`_ (``-Dapp_SNIPPET=nrf91-modem-trace-uart``) when building and programming. +Enabling RTT logs +================= -Use the `Cellular Monitor app`_ for capturing and analyzing modem traces. +RTT logging is disabled by default. +To switch from UART1 back to SEGGER RTT, add the following to your :file:`prj.conf`:: -.. note:: + # Disable UART logging + CONFIG_UART_CONSOLE=n + CONFIG_LOG_BACKEND_UART=n - When measuring power consumption while the modem is active, the modem traces must not be active. - If the build includes modem traces, the traces must be deactivated with ``AT%XMODEMTRACE=0``, before taking measurements. - Active traces show approximately 700 uA overhead on the power consumption. + # Enable Segger RTT + CONFIG_USE_SEGGER_RTT=y + CONFIG_RTT_CONSOLE=y + CONFIG_LOG_BACKEND_RTT=y + # Optional: increase the buffer so that boot logs are not lost before RTT Viewer connects. + CONFIG_SEGGER_RTT_BUFFER_SIZE_UP=2048 - If ``hw-flow-control`` is enabled for the trace UART in the devicetree (it is disabled by default), the same approximately 700 uA overhead is present even when the traces are deactivated using ``AT%XMODEMTRACE=0``. - ``hw-flow-control`` prevents the trace UART from sending, when there is no reader for the data. - This prevents the trace UART from suspending, as it cannot empty its buffers. +You can view the RTT logs with an RTT client such as ``J-Link RTT Viewer``. +See `Testing and optimization`_ for instructions. + + +.. note:: + + `nRF9151 anomaly 36`_ locks the debug port when the application reaches a low power state (<3 uA current consumption). + This takes place when DTR is deasserted and the RTT client, such as J-Link RTT Viewer, is not connected. + Since the RTT backend relies on the debug port, the RTT client must be connected before the application enters a low power state to avoid this issue. .. note:: @@ -68,20 +69,22 @@ Use the `Cellular Monitor app`_ for capturing and analyzing modem traces. Shared UART log and trace backend ********************************** -The |SM| application supports a shared UART backend that routes both Zephyr application logs and modem traces to the same physical UART (``UART1``, VCOM1 on the nRF9151 DK). +The |SM| application routes Zephyr application logs to ``UART1`` (VCOM1 on the nRF9151 DK) by default. The baud rate of the shared UART is set to 1000000 to support the high data rate required for modem traces. Configuration ============= -To use the shared UART backend, build the |SM| application with the Kconfig and devicetree overlays: +Application log output over ``UART1`` is included in the default build. + +To also enable the modem trace backend (``AT#XTRACE``), build with the Kconfig overlay: .. code-block:: console - west build -p -b nrf9151dk/nrf9151/ns -- -DEXTRA_CONF_FILE="overlay-trace-backend-uart.conf" -DEXTRA_DTC_OVERLAY_FILE="overlay-trace-backend-uart.overlay" + west build -p -b nrf9151dk/nrf9151/ns -- -DEXTRA_CONF_FILE="overlay-trace-backend-uart.conf" -After flashing, both backends are disabled by default, and the UART is suspended. -Use the ``AT#XLOG`` and ``AT#XTRACE`` AT commands to activate them at runtime. +After flashing, the UART is suspended at startup. +Use ``AT#XLOG=1`` to activate application logs and ``AT#XTRACE=1`` to activate modem traces. See :ref:`SM_AT_trace` for the full command reference. .. note:: diff --git a/doc/links.txt b/doc/links.txt index e63a7dbd..92f04477 100644 --- a/doc/links.txt +++ b/doc/links.txt @@ -21,7 +21,7 @@ .. _`nRF9151 Hardware Design Guidelines — ENABLE`: https://docs.nordicsemi.com/bundle/nwp_056/page/WP/nwp_054/enable.html .. _`Thingy91x_firmware_update`: https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/app_dev/device_guides/thingy91x/thingy91x_updating_fw_programmer.html#updating_the_firmware_on_the_nrf5340_soc .. _`shared TF-M logging`: https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/app_dev/device_guides/nrf91/nrf91_snippet.html#tfm-enable-share-uart - +.. _`nRF9151 anomaly 36`: https://docs.nordicsemi.com/bundle/errata_nRF9151_Rev2/page/ERR/nRF9151/Rev2/latest/anomaly_151_36.html .. _`app_boards_names`: https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/app_dev/board_names.html#app-boards-names .. _`Configuring and building`: https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/security/tfm/index.html#ug-tfm .. _`Testing and optimization`: https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/test_and_optimize.html diff --git a/doc/releases/migration_notes_ncs_slm_v3.1.x.rst b/doc/releases/migration_notes_ncs_slm_v3.1.x.rst index 7636cbb7..151138c5 100644 --- a/doc/releases/migration_notes_ncs_slm_v3.1.x.rst +++ b/doc/releases/migration_notes_ncs_slm_v3.1.x.rst @@ -44,6 +44,12 @@ This section gives instructions on how to migrate from the |NCS| v3.1.x `SLM `. You can now use this option to enable the `nRF Cloud Location Services `_ for cloud-assisted geolocation, which supports cellular and Wi-Fi positioning. diff --git a/doc/releases/migration_notes_v2.0.0.rst b/doc/releases/migration_notes_v2.0.0.rst index 67528bc9..91e4aa95 100644 --- a/doc/releases/migration_notes_v2.0.0.rst +++ b/doc/releases/migration_notes_v2.0.0.rst @@ -15,6 +15,11 @@ Required changes The following changes are mandatory to make your application work in the same way as in previous releases. +* Application logging backend changed from RTT to UART — The default application log backend has changed from SEGGER RTT to UART1 (VCOM1 on the nRF9151 DK). + The UART is suspended at startup and activated at runtime with ``AT#XLOG=1``. + See :ref:`SM_AT_trace` for the full command reference. + If you cannot move to UART logs, see :ref:`sm_logging_rtt` for how to re-enable RTT logs. + * Full FOTA - When compiling, rename ``overlay-full_fota.conf`` to ``overlay-full-fota.conf`` and add ``PM_STATIC_YML_FILE=pm_static_nrf9151dk_nrf9151_ns_full_fota.yml`` to the build configuration. See :ref:`SM_AT_FOTA` for more information.