samples: bluettoth: ble_nus: add LPUARTE support

Add support for LPUARTE to NUS sample.

Signed-off-by: Eivind Jølsgard <[email protected]>

Author: eivindj-nordic

samples/bluetooth/ble_nus/Kconfig

@@ -10,15 +10,22 @@ config BLE_UART_IRQ_PRIO
 	int "BLE UART IRQ priority"
 	default 3
 
-config CONFIG_BLE_UART_PARITY
+config BLE_UART_PARITY
 	bool "BLE UART use parity"
 
-config BLE_UART_HWFC
-	bool "BLE UART use HWFC"
+config BLE_LPUART
+	bool "BLE UART Low Power"
 
-if BLE_UART_HWFC
+if BLE_LPUART
+
+config GPIOTE_IRQ_PRIO
+	int "GPIOTE IRQ priority"
+	default 3
 
-endif #BLE_UART_HWFC
+endif #BLE_LPUART
+
+config BLE_UART_HWFC
+	bool "BLE UART use HWFC"
 
 endmenu # "BLE NUS sample"
 

samples/bluetooth/ble_nus/lpuarte.conf

@@ -0,0 +1,5 @@
+# This file enables Low Power UARTE (LPUARTE) driver for the NUS UART instance.
+CONFIG_BLE_LPUART=y
+CONFIG_CLOCK_CONTROL=y
+CONFIG_BM_SW_LPUARTE=y
+CONFIG_BM_TIMER=y

samples/bluetooth/ble_nus/src/main.c

@@ -15,6 +15,9 @@
 #include <bluetooth/services/ble_nus.h>
 #include <nrf_soc.h>
 #include <nrfx_uarte.h>
+#if CONFIG_BLE_LPUART
+#include <lpuarte.h>
+#endif
 #include <zephyr/logging/log.h>
 #include <zephyr/logging/log_ctrl.h>
 #include <zephyr/sys/util.h>
@@ -30,16 +33,34 @@ BLE_QWR_DEF(ble_qwr); /* BLE QWR instance */
 /** Handle of the current connection. */
 static uint16_t conn_handle = BLE_CONN_HANDLE_INVALID;
 
-/** NUS UARTE instance */
-static const nrfx_uarte_t uarte_inst = NRF_UARTE_INST_GET(BOARD_APP_UARTE_INST);
+/** NUS UARTE instance and board config */
+#if CONFIG_BLE_LPUART
+#define NUS_UARTE_INST BOARD_APP_LPUARTE_INST
+#define NUS_UARTE_PIN_TX BOARD_APP_LPUARTE_PIN_TX
+#define NUS_UARTE_PIN_RX BOARD_APP_LPUARTE_PIN_RX
+#define NUS_UARTE_PIN_CTS BOARD_APP_LPUARTE_PIN_CTS
+#define NUS_UARTE_PIN_RTS BOARD_APP_LPUARTE_PIN_RTS
+#define NUS_UARTE_PIN_RDY BOARD_APP_LPUARTE_PIN_RDY
+#define NUS_UARTE_PIN_REQ BOARD_APP_LPUARTE_PIN_REQ
+
+struct bm_lpuarte lpu;
+#else
+#define NUS_UARTE_INST BOARD_APP_UARTE_INST
+#define NUS_UARTE_PIN_TX BOARD_APP_UARTE_PIN_TX
+#define NUS_UARTE_PIN_RX BOARD_APP_UARTE_PIN_RX
+#define NUS_UARTE_PIN_CTS BOARD_APP_UARTE_PIN_CTS
+#define NUS_UARTE_PIN_RTS BOARD_APP_UARTE_PIN_RTS
+
+static const nrfx_uarte_t nus_uarte_inst = NRFX_UARTE_INSTANCE(NUS_UARTE_INST);
+#endif /* CONFIG_BLE_LPUART */
 
 /* Maximum length of data (in bytes) that can be transmitted to the peer by the
  * Nordic UART service module.
  */
 static volatile uint16_t ble_nus_max_data_len = BLE_NUS_MAX_DATA_LEN_CALC(BLE_GATT_ATT_MTU_DEFAULT);
 
 /* Receive buffer used in UART ISR callback */
-static uint8_t uarte_rx_buf[4];
+static uint8_t uarte_rx_buf[IS_ENABLED(CONFIG_BLE_LPUART) ? 128 : 2];
 static int buf_idx;
 
 /**
@@ -112,13 +133,18 @@ static void uarte_evt_handler(nrfx_uarte_event_t const *event, void *ctx)
 			uarte_rx_handler(event->data.rx.p_buffer, event->data.rx.length);
 		}
 
-		nrfx_uarte_rx_enable(&uarte_inst, 0);
+#if !defined(CONFIG_BLE_LPUART)
+		nrfx_uarte_rx_enable(&nus_uarte_inst, 0);
+#endif
 		break;
 	case NRFX_UARTE_EVT_RX_BUF_REQUEST:
-		nrfx_uarte_rx_buffer_set(&uarte_inst, &uarte_rx_buf[buf_idx], 1);
+#if defined(CONFIG_BLE_LPUART)
+		bm_lpuarte_rx_buffer_set(&lpu, &uarte_rx_buf[buf_idx * 64], 64);
+#else
+		nrfx_uarte_rx_buffer_set(&nus_uarte_inst, &uarte_rx_buf[buf_idx], 1);
+#endif
 
-		buf_idx++;
-		buf_idx = (buf_idx < sizeof(uarte_rx_buf)) ? buf_idx : 0;
+		buf_idx = buf_idx ? 0 : 1;
 		break;
 	case NRFX_UARTE_EVT_ERROR:
 		LOG_ERR("uarte error %#x", event->data.error.error_mask);
@@ -273,11 +299,24 @@ static void ble_nus_evt_handler(const struct ble_nus_evt *evt)
 	LOG_DBG("Received data from BLE NUS: %s", evt->params.rx_data.data);
 
 	for (uint32_t i = 0; i < evt->params.rx_data.length; i++) {
-		nrfx_uarte_tx(&uarte_inst, &evt->params.rx_data.data[i], 1, NRFX_UARTE_TX_BLOCKING);
+#if CONFIG_BLE_LPUART
+		bm_lpuarte_tx(&lpu, evt->params.rx_data.data, evt->params.rx_data.length, 0,
+			      BM_TIMER_MS_TO_TICKS(3000));
+		while (bm_lpuarte_tx_in_progress(&lpu)) {
+			k_busy_wait(1);
+		}
+#else
+		nrfx_uarte_tx(&nus_uarte_inst, evt->params.rx_data.data, evt->params.rx_data.length,
+			      NRFX_UARTE_TX_BLOCKING);
+#endif
 	}
 
 	if (evt->params.rx_data.data[evt->params.rx_data.length - 1] == '\r') {
-		nrfx_uarte_tx(&uarte_inst, &newline, 1, NRFX_UARTE_TX_BLOCKING);
+#if CONFIG_BLE_LPUART
+		bm_lpuarte_tx(&lpu, &newline, 1, 0, BM_TIMER_MS_TO_TICKS(3000));
+#else
+		nrfx_uarte_tx(&nus_uarte_inst, &newline, 1, NRFX_UARTE_TX_BLOCKING);
+#endif
 	}
 }
 
@@ -287,33 +326,62 @@ static void ble_nus_evt_handler(const struct ble_nus_evt *evt)
 static int uarte_init(void)
 {
 	int err;
+	nrfx_uarte_config_t *uarte_cfg;
+#if CONFIG_BLE_LPUART
+	struct bm_lpuarte_config lpu_cfg = {
+		.uarte_inst = NRFX_UARTE_INSTANCE(NUS_UARTE_INST),
+		.uarte_cfg = NRFX_UARTE_DEFAULT_CONFIG(NUS_UARTE_PIN_TX,
+						       NUS_UARTE_PIN_RX),
+		.req_pin = BOARD_APP_LPUARTE_PIN_REQ,
+		.rdy_pin = BOARD_APP_LPUARTE_PIN_RDY,
+	};
 
-	nrfx_uarte_config_t uarte_config = NRFX_UARTE_DEFAULT_CONFIG(BOARD_APP_UARTE_PIN_TX,
-								     BOARD_APP_UARTE_PIN_RX);
+	uarte_cfg = &lpu_cfg.uarte_cfg;
+#else
+	nrfx_uarte_config_t uarte_config = NRFX_UARTE_DEFAULT_CONFIG(NUS_UARTE_PIN_TX,
+								     NUS_UARTE_PIN_RX);
+
+	uarte_cfg = &uarte_config;
+#endif
 
 #if defined(CONFIG_BLE_UART_HWFC)
-	uarte_config.config.hwfc = NRF_UARTE_HWFC_ENABLED;
-	uarte_config.cts_pin = BOARD_APP_UARTE_PIN_CTS;
-	uarte_config.rts_pin = BOARD_APP_UARTE_PIN_RTS;
+	uarte_cfg->config.hwfc = NRF_UARTE_HWFC_ENABLED;
+	uarte_cfg->cts_pin = NUS_UARTE_PIN_CTS;
+	uarte_cfg->rts_pin = NUS_UARTE_PIN_RTS;
 #endif
 
 #if defined(CONFIG_BLE_UART_PARITY)
-	uarte_config.parity = NRF_UARTE_PARITY_INCLUDED;
+	uarte_cfg->parity = NRF_UARTE_PARITY_INCLUDED;
 #endif
 
-	uarte_config.interrupt_priority = CONFIG_BLE_UART_IRQ_PRIO;
+	uarte_cfg->interrupt_priority = CONFIG_BLE_UART_IRQ_PRIO;
 
 	/** We need to connect the IRQ ourselves. */
-	IRQ_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_UARTE_INST_GET(BOARD_APP_UARTE_INST)), CONFIG_BLE_UART_IRQ_PRIO,
-		    NRFX_UARTE_INST_HANDLER_GET(BOARD_APP_UARTE_INST), 0, 0);
 
-	irq_enable(NRFX_IRQ_NUMBER_GET(NRF_UARTE_INST_GET(BOARD_APP_UARTE_INST)));
+	IRQ_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_UARTE_INST_GET(NUS_UARTE_INST)),
+		    CONFIG_BLE_UART_IRQ_PRIO, NRFX_UARTE_INST_HANDLER_GET(NUS_UARTE_INST), 0, 0);
+
+	irq_enable(NRFX_IRQ_NUMBER_GET(NRF_UARTE_INST_GET(NUS_UARTE_INST)));
 
-	err = nrfx_uarte_init(&uarte_inst, &uarte_config, uarte_evt_handler);
+#if CONFIG_BLE_LPUART
+	IRQ_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_GPIOTE_INST_GET(20)) + NRF_GPIOTE_IRQ_GROUP,
+		    CONFIG_GPIOTE_IRQ_PRIO, NRFX_GPIOTE_INST_HANDLER_GET(20), 0, 0);
+
+	IRQ_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_GPIOTE_INST_GET(30)) + NRF_GPIOTE_IRQ_GROUP,
+		    CONFIG_GPIOTE_IRQ_PRIO, NRFX_GPIOTE_INST_HANDLER_GET(30), 0, 0);
+
+	err = bm_lpuarte_init(&lpu, &lpu_cfg, uarte_evt_handler);
 	if (err != NRFX_SUCCESS) {
 		LOG_ERR("Failed to initialize UART, nrfx err %d", err);
 		return err;
 	}
+#else
+	err = nrfx_uarte_init(&nus_uarte_inst, &uarte_config, uarte_evt_handler);
+	if (err != NRFX_SUCCESS) {
+		LOG_ERR("Failed to initialize UART, nrfx err %d", err);
+		return err;
+	}
+#endif /* CONFIG_BLE_LPUART */
 
 	return 0;
 }
@@ -397,16 +465,30 @@ int main(void)
 
 	const uint8_t out[] = "UART started.\r\n";
 
-	err = nrfx_uarte_tx(&uarte_inst, out, sizeof(out), NRFX_UARTE_TX_BLOCKING);
+#if CONFIG_BLE_LPUART
+	err = bm_lpuarte_tx(&lpu, out, sizeof(out), NRFX_UARTE_TX_BLOCKING,
+			    BM_TIMER_MS_TO_TICKS(3000));
+	if (err != NRFX_SUCCESS) {
+		LOG_ERR("UARTE TX failed, nrfx err %d", err);
+		return -1;
+	}
+
+	err = bm_lpuarte_rx_enable(&lpu, 0);
+	if (err != NRFX_SUCCESS) {
+		LOG_ERR("UART RX failed, nrfx err %d", err);
+	}
+#else
+	err = nrfx_uarte_tx(&nus_uarte_inst, out, sizeof(out), NRFX_UARTE_TX_BLOCKING);
 	if (err != NRFX_SUCCESS) {
 		LOG_ERR("UARTE TX failed, nrfx err %d", err);
 		return -1;
 	}
 
-	err = nrfx_uarte_rx_enable(&uarte_inst, 0);
+	err = nrfx_uarte_rx_enable(&nus_uarte_inst, 0);
 	if (err != NRFX_SUCCESS) {
 		LOG_ERR("UART RX failed, nrfx err %d", err);
 	}
+#endif
 
 	err = ble_adv_start(&ble_adv, BLE_ADV_MODE_FAST);
 	if (err) {