modbus: support UART ASYNC API in modbus serial

Reason for this extension are CRC mismatches happening due to RX data
loss when using the interrupt driven API at higher speeds and/or high
CPU load. It is recommended to use the ASYNC API along with hardware
byte counting requiring a timer instance and one PPI channel to achieve
a robust communication at high baudrates on nRF platforms.

Signed-off-by: Anouar Raddaoui <[email protected]>

Author: Anouar Raddaoui

subsys/modbus/Kconfig

@@ -48,6 +48,12 @@ config MODBUS_SERIAL
 	help
 	  Enable Modbus over serial line support.
 
+config MODBUS_SERIAL_ASYNC_API
+	depends on MODBUS_SERIAL && UART_ASYNC_API
+	bool "Modbus over serial line UART ASYNC API support"
+	help
+	  Use UART ASYNC API for Modbus over serial line.
+
 config MODBUS_ASCII_MODE
 	depends on MODBUS_SERIAL
 	bool "Modbus transmission mode ASCII"

subsys/modbus/modbus_serial.c

@@ -37,14 +37,26 @@ static void modbus_serial_tx_on(struct modbus_context *ctx)
 		gpio_pin_set(cfg->de->port, cfg->de->pin, 1);
 	}
 
-	uart_irq_tx_enable(cfg->dev);
+	if (IS_ENABLED(CONFIG_MODBUS_SERIAL_ASYNC_API)) {
+		int err;
+
+		err = uart_tx(cfg->dev, cfg->uart_buf, cfg->uart_buf_ctr, SYS_FOREVER_US);
+		if (err) {
+			LOG_ERR("uart_tx failed with %d", err);
+		}
+	} else {
+		uart_irq_tx_enable(cfg->dev);
+	}
 }
 
 static void modbus_serial_tx_off(struct modbus_context *ctx)
 {
 	struct modbus_serial_config *cfg = ctx->cfg;
 
-	uart_irq_tx_disable(cfg->dev);
+	if (!IS_ENABLED(CONFIG_MODBUS_SERIAL_ASYNC_API)) {
+		uart_irq_tx_disable(cfg->dev);
+	}
+
 	if (cfg->de != NULL) {
 		gpio_pin_set(cfg->de->port, cfg->de->pin, 0);
 	}
@@ -70,14 +82,29 @@ static void modbus_serial_rx_on(struct modbus_context *ctx)
 	}
 
 	atomic_set_bit(&ctx->state, MODBUS_STATE_RX_ENABLED);
-	uart_irq_rx_enable(cfg->dev);
+	if (IS_ENABLED(CONFIG_MODBUS_SERIAL_ASYNC_API)) {
+		int err;
+
+		err = uart_rx_enable(cfg->dev, cfg->uart_buf,
+				     sizeof(cfg->uart_buf), cfg->rtu_timeout);
+		if (err) {
+			LOG_ERR("uart_rx_enable failed with %d", err);
+		}
+	} else {
+		uart_irq_rx_enable(cfg->dev);
+	}
 }
 
 static void modbus_serial_rx_off(struct modbus_context *ctx)
 {
 	struct modbus_serial_config *cfg = ctx->cfg;
 
-	uart_irq_rx_disable(cfg->dev);
+	if (IS_ENABLED(CONFIG_MODBUS_SERIAL_ASYNC_API)) {
+		uart_rx_disable(cfg->dev);
+	} else {
+		uart_irq_rx_disable(cfg->dev);
+	}
+
 	atomic_clear_bit(&ctx->state, MODBUS_STATE_RX_ENABLED);
 
 	if (cfg->re != NULL) {
@@ -424,6 +451,44 @@ static void uart_cb_handler(const struct device *dev, void *app_data)
 	}
 }
 
+static void uart_cb_async_handler(const struct device *dev, struct uart_event *evt, void *app_data)
+{
+	struct modbus_context *ctx = (struct modbus_context *)app_data;
+	struct modbus_serial_config *cfg;
+
+	if (ctx == NULL) {
+		LOG_ERR("Modbus hardware is not properly initialized");
+		return;
+	}
+
+	cfg = ctx->cfg;
+
+	switch (evt->type) {
+	case UART_TX_DONE:
+		cfg->uart_buf_ctr = 0;
+		modbus_serial_tx_off(ctx);
+		modbus_serial_rx_on(ctx);
+		break;
+	case UART_RX_RDY:
+		cfg->uart_buf_ctr = evt->data.rx.len;
+		k_work_submit(&ctx->server_work);
+		break;
+	case UART_TX_ABORTED:
+		__fallthrough;
+	case UART_RX_STOPPED:
+		__fallthrough;
+	case UART_RX_BUF_REQUEST:
+		__fallthrough;
+	case UART_RX_BUF_RELEASED:
+		__fallthrough;
+	case UART_RX_DISABLED:
+		break;
+	default:
+		LOG_WRN("Unhandled UART event type: %d", evt->type);
+		break;
+	}
+}
+
 /* This function is called when the RTU framing timer expires. */
 static void rtu_tmr_handler(struct k_timer *t_id)
 {
@@ -621,18 +686,20 @@ int modbus_serial_init(struct modbus_context *ctx,
 	cfg->uart_buf_ctr = 0;
 	cfg->uart_buf_ptr = &cfg->uart_buf[0];
 
-	err = uart_irq_callback_user_data_set(cfg->dev, uart_cb_handler, ctx);
-	if (err != 0) {
-		return err;
-	};
-
-	k_timer_init(&cfg->rtu_timer, rtu_tmr_handler, NULL);
-	k_timer_user_data_set(&cfg->rtu_timer, ctx);
+	if (IS_ENABLED(CONFIG_MODBUS_SERIAL_ASYNC_API)) {
+		err = uart_callback_set(cfg->dev, uart_cb_async_handler, ctx);
+	} else {
+		err = uart_irq_callback_user_data_set(cfg->dev, uart_cb_handler, ctx);
+		if (!err) {
+			k_timer_init(&cfg->rtu_timer, rtu_tmr_handler, NULL);
+			k_timer_user_data_set(&cfg->rtu_timer, ctx);
+			modbus_serial_rx_on(ctx);
+		}
+	}
 
-	modbus_serial_rx_on(ctx);
 	LOG_INF("RTU timeout %u us", cfg->rtu_timeout);
 
-	return 0;
+	return err;
 }
 
 void modbus_serial_disable(struct modbus_context *ctx)