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

drivers/lpuarte/Kconfig

@@ -6,22 +6,15 @@
 config BM_SW_LPUARTE
 	bool "Low Power UARTE using REQ/RDY lines"
 	help
-	  Low power UARTE implements UARTE API and extends standard UARTE
-	  communication with 2 pins protocol for receiver wake up and flow control.
+	  Low Power UARTE implements UARTE API and extends standard UARTE
+	  communication with a 2-pins protocol for receiver wake-up and flow control.
 
 if BM_SW_LPUARTE
 
-# Set number of event handlers used by the lpuart driver
+# Set number of event handlers used by the LPUART driver
 config NRFX_GPIOTE_NUM_OF_EVT_HANDLERS
 	default 2
 
-config BM_SW_LPUARTE_MAX_PACKET_SIZE
-	int "Maximum RX packet size"
-	default 128
-	help
-	  If interrupt driven API is enabled then internal RX buffer of that
-	  size is created.
-
 config BM_SW_LPUARTE_INT_DRV_TX_BUF_SIZE
 	int "Tx buffer size"
 	default 128
@@ -32,7 +25,7 @@ config BM_SW_LPUARTE_INT_DRV_TX_BUF_SIZE
 	  packet.
 
 module = BM_SW_LPUARTE
-module-str = low power uart
+module-str = Low Power UARTE
 source "subsys/logging/Kconfig.template.log_config"
 
 endif

drivers/lpuarte/lpuarte.c

@@ -4,7 +4,6 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
  */
 
-
 #include <zephyr/logging/log.h>
 #include <bm_lpuarte.h>
 #include <nrfx_gpiote.h>
@@ -113,9 +112,8 @@ static nrfx_err_t req_pin_init(struct bm_lpuarte *lpu, nrfx_gpiote_pin_t pin)
 
 	lpu->req_pin = pin;
 
-	/* Make gpiote driver think that pin is input but then reconfigure to
-	 * output. Which will be at some point reconfigured back to input for
-	 * a moment.
+	/* Set the request pin in idle state to indicate to the receiver that there is no pending
+	 * transmission.
 	 */
 	req_pin_idle(lpu);
 

include/bm_lpuarte.h

@@ -27,22 +27,14 @@ extern "C" {
 enum bm_lpuarte_rx_state {
 	/* RX is disabled. */
 	RX_OFF,
-
 	/* RX is in low power, idle state with pin detection armed. */
 	RX_IDLE,
-
 	/* RX request is pending, receiver is in preparation. */
 	RX_PREPARE,
-
 	/* RX is in active state, receiver is running. */
 	RX_ACTIVE,
-
 	/* RX is transitioning to from active idle state. */
 	RX_TO_IDLE,
-
-	/* RX is waiting for a new buffer. */
-	RX_BLOCKED,
-
 	/* RX is transitioning to off state. */
 	RX_TO_OFF,
 };

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

@@ -19,6 +19,10 @@
 #include <zephyr/logging/log_ctrl.h>
 #include <zephyr/sys/util.h>
 
+#if CONFIG_BLE_LPUART
+#include <lpuarte.h>
+#endif
+
 #include <board-config.h>
 
 LOG_MODULE_REGISTER(app, CONFIG_BLE_NUS_SAMPLE_LOG_LEVEL);
@@ -30,16 +34,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 +134,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 +300,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 +327,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,
+	};
+
+	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);
 
-	nrfx_uarte_config_t uarte_config = NRFX_UARTE_DEFAULT_CONFIG(BOARD_APP_UARTE_PIN_TX,
-								     BOARD_APP_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)));
+
+#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 = nrfx_uarte_init(&uarte_inst, &uarte_config, uarte_evt_handler);
+	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 +466,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 = nrfx_uarte_rx_enable(&uarte_inst, 0);
+	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(&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) {