samples: drivers: moving to zephyr code style

joelguittet · joelguittet · commit de36e05db728 · 2025-12-24T00:37:49.000+01:00
This commit is to be merged with the previous one before merging the PR.

Signed-off-by: Joel Guittet &lt;joelguittet@gmail.com&gt;
diff --git a/samples/drivers/misc/espressif_rmt/CMakeLists.txt b/samples/drivers/misc/espressif_rmt/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2025 Joel Guittet (joelguittet@gmail.com)
+# SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors
 # SPDX-License-Identifier: Apache-2.0
 
 cmake_minimum_required(VERSION 3.20.0)
diff --git a/samples/drivers/misc/espressif_rmt/Kconfig b/samples/drivers/misc/espressif_rmt/Kconfig
@@ -1,6 +1,6 @@
 # Private config options for espressif_rmt sample
 
-# Copyright (c) 2025 Joel Guittet (joelguittet@gmail.com)
+# SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors
 # SPDX-License-Identifier: Apache-2.0
 
 mainmenu "Espressif RMT sample application"
diff --git a/samples/drivers/misc/espressif_rmt/README.rst b/samples/drivers/misc/espressif_rmt/README.rst
@@ -7,7 +7,7 @@
 Overview
 ********
 
-This sample demonstrates how to use the :ref:`Espressif RMT driver API <rmt_api>`.
+This sample demonstrates how to use the :Espressif RMT driver API.
 
 You  should connect a WS2812 strip to the RMT output of the board.
 
@@ -34,7 +34,7 @@ Sample output
 
    *** Booting Zephyr OS build v4.3.0-2805-g63ff14e3d8d0 ***
    Create RMT TX channel
-   I (141) gpio: GPIO[12]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0 
+   I (141) gpio: GPIO[12]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
    Install led strip encoder
    Enable RMT TX channel
    Start LED rainbow chase
diff --git a/samples/drivers/misc/espressif_rmt/prj.conf b/samples/drivers/misc/espressif_rmt/prj.conf
@@ -1 +1,2 @@
-CONFIG_ESPRESSIF_RMT=y
+# SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors
+# SPDX-License-Identifier: Apache-2.0
diff --git a/samples/drivers/misc/espressif_rmt/socs/esp32_procpu.overlay b/samples/drivers/misc/espressif_rmt/socs/esp32_procpu.overlay
@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 Joel Guittet (joelguittet@gmail.com)
+ * SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors
  *
  * SPDX-License-Identifier: Apache-2.0
  */
diff --git a/samples/drivers/misc/espressif_rmt/src/led_strip_encoder.c b/samples/drivers/misc/espressif_rmt/src/led_strip_encoder.c
@@ -1,14 +1,13 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "esp_check.h"
+#include <stdlib.h>
+#include <zephyr/sys/printk.h>
 #include "led_strip_encoder.h"
 
-static const char *TAG = "led_encoder";
-
 typedef struct {
     rmt_encoder_t base;
     rmt_encoder_t *bytes_encoder;
@@ -26,90 +25,104 @@ static size_t rmt_encode_led_strip(rmt_encoder_t *encoder, rmt_channel_handle_t
     rmt_encode_state_t state = RMT_ENCODING_RESET;
     size_t encoded_symbols = 0;
     switch (led_encoder->state) {
-    case 0: // send RGB data
+    case 0: /* send RGB data */
         encoded_symbols += bytes_encoder->encode(bytes_encoder, channel, primary_data, data_size, &session_state);
         if (session_state & RMT_ENCODING_COMPLETE) {
-            led_encoder->state = 1; // switch to next state when current encoding session finished
+            led_encoder->state = 1; /* switch to next state when current encoding session finished */
         }
         if (session_state & RMT_ENCODING_MEM_FULL) {
             state |= RMT_ENCODING_MEM_FULL;
-            goto out; // yield if there's no free space for encoding artifacts
+            goto out; /* yield if there's no free space for encoding artifacts */
         }
-    // fall-through
-    case 1: // send reset code
+    /* fall-through */
+    case 1: /* send reset code */
         encoded_symbols += copy_encoder->encode(copy_encoder, channel, &led_encoder->reset_code,
                                                 sizeof(led_encoder->reset_code), &session_state);
         if (session_state & RMT_ENCODING_COMPLETE) {
-            led_encoder->state = RMT_ENCODING_RESET; // back to the initial encoding session
+            led_encoder->state = RMT_ENCODING_RESET; /* back to the initial encoding session */
             state |= RMT_ENCODING_COMPLETE;
         }
         if (session_state & RMT_ENCODING_MEM_FULL) {
             state |= RMT_ENCODING_MEM_FULL;
-            goto out; // yield if there's no free space for encoding artifacts
+            goto out; /* yield if there's no free space for encoding artifacts */
         }
     }
 out:
     *ret_state = state;
     return encoded_symbols;
 }
 
-static esp_err_t rmt_del_led_strip_encoder(rmt_encoder_t *encoder)
+static int rmt_del_led_strip_encoder(rmt_encoder_t *encoder)
 {
     rmt_led_strip_encoder_t *led_encoder = __containerof(encoder, rmt_led_strip_encoder_t, base);
     rmt_del_encoder(led_encoder->bytes_encoder);
     rmt_del_encoder(led_encoder->copy_encoder);
     free(led_encoder);
-    return ESP_OK;
+    return 0;
 }
 
-static esp_err_t rmt_led_strip_encoder_reset(rmt_encoder_t *encoder)
+static int rmt_led_strip_encoder_reset(rmt_encoder_t *encoder)
 {
     rmt_led_strip_encoder_t *led_encoder = __containerof(encoder, rmt_led_strip_encoder_t, base);
     rmt_encoder_reset(led_encoder->bytes_encoder);
     rmt_encoder_reset(led_encoder->copy_encoder);
     led_encoder->state = RMT_ENCODING_RESET;
-    return ESP_OK;
+    return 0;
 }
 
-esp_err_t rmt_new_led_strip_encoder(const led_strip_encoder_config_t *config, rmt_encoder_handle_t *ret_encoder)
+int rmt_new_led_strip_encoder(const led_strip_encoder_config_t *config, rmt_encoder_handle_t *ret_encoder)
 {
-    esp_err_t ret = ESP_OK;
+    int rc;
     rmt_led_strip_encoder_t *led_encoder = NULL;
-    ESP_GOTO_ON_FALSE(config && ret_encoder, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    if (!(config && ret_encoder)) {
+        printk("Invalid argument\n");
+        return -EINVAL;
+    }
     led_encoder = rmt_alloc_encoder_mem(sizeof(rmt_led_strip_encoder_t));
-    ESP_GOTO_ON_FALSE(led_encoder, ESP_ERR_NO_MEM, err, TAG, "no mem for led strip encoder");
+    if (!led_encoder) {
+        printk("Unable to allocate memory for LED strip encoder\n");
+        return -ENOMEM;
+    }
     led_encoder->base.encode = rmt_encode_led_strip;
     led_encoder->base.del = rmt_del_led_strip_encoder;
     led_encoder->base.reset = rmt_led_strip_encoder_reset;
-    // different led strip might have its own timing requirements, following parameter is for WS2812
+    /* different led strip might have its own timing requirements, following parameter is for WS2812 */
     rmt_bytes_encoder_config_t bytes_encoder_config = {
         .bit0 = {
             .level0 = 1,
-            .duration0 = 0.3 * config->resolution / 1000000, // T0H=0.3us
+            .duration0 = 0.3 * config->resolution / 1000000, /* T0H=0.3us */
             .level1 = 0,
-            .duration1 = 0.9 * config->resolution / 1000000, // T0L=0.9us
+            .duration1 = 0.9 * config->resolution / 1000000, /* T0L=0.9us */
         },
         .bit1 = {
             .level0 = 1,
-            .duration0 = 0.9 * config->resolution / 1000000, // T1H=0.9us
+            .duration0 = 0.9 * config->resolution / 1000000, /* T1H=0.9us */
             .level1 = 0,
-            .duration1 = 0.3 * config->resolution / 1000000, // T1L=0.3us
+            .duration1 = 0.3 * config->resolution / 1000000, /* T1L=0.3us */
         },
-        .flags.msb_first = 1 // WS2812 transfer bit order: G7...G0R7...R0B7...B0
+        .flags.msb_first = 1 /* WS2812 transfer bit order: G7...G0R7...R0B7...B0 */
     };
-    ESP_GOTO_ON_ERROR(rmt_new_bytes_encoder(&bytes_encoder_config, &led_encoder->bytes_encoder), err, TAG, "create bytes encoder failed");
+    rc = rmt_new_bytes_encoder(&bytes_encoder_config, &led_encoder->bytes_encoder);
+    if (rc) {
+        printk("Create bytes encoder failed\n");
+        goto err;
+    }
     rmt_copy_encoder_config_t copy_encoder_config = {};
-    ESP_GOTO_ON_ERROR(rmt_new_copy_encoder(&copy_encoder_config, &led_encoder->copy_encoder), err, TAG, "create copy encoder failed");
-
-    uint32_t reset_ticks = config->resolution / 1000000 * 50 / 2; // reset code duration defaults to 50us
+    rc = rmt_new_copy_encoder(&copy_encoder_config, &led_encoder->copy_encoder);
+    if (rc) {
+        printk("create copy encoder failed\n");
+        goto err;
+    }
+    uint32_t reset_ticks = config->resolution / 1000000 * 50 / 2; /* reset code duration defaults to 50us */
     led_encoder->reset_code = (rmt_symbol_word_t) {
         .level0 = 0,
         .duration0 = reset_ticks,
         .level1 = 0,
         .duration1 = reset_ticks,
     };
     *ret_encoder = &led_encoder->base;
-    return ESP_OK;
+    return 0;
+
 err:
     if (led_encoder) {
         if (led_encoder->bytes_encoder) {
@@ -120,5 +133,5 @@ esp_err_t rmt_new_led_strip_encoder(const led_strip_encoder_config_t *config, rm
         }
         free(led_encoder);
     }
-    return ret;
+    return rc;
 }
diff --git a/samples/drivers/misc/espressif_rmt/src/led_strip_encoder.h b/samples/drivers/misc/espressif_rmt/src/led_strip_encoder.h
@@ -1,9 +1,11 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-#pragma once
+
+#ifndef LED_STRIP_ENCODER_H_
+#define LED_STRIP_ENCODER_H_
 
 #include <stdint.h>
 #include <zephyr/drivers/misc/espressif_rmt/rmt_encoder.h>
@@ -16,22 +18,23 @@ extern "C" {
  * @brief Type of led strip encoder configuration
  */
 typedef struct {
-    uint32_t resolution; /*!< Encoder resolution, in Hz */
+    uint32_t resolution; /**< Encoder resolution, in Hz */
 } led_strip_encoder_config_t;
 
 /**
- * @brief Create RMT encoder for encoding LED strip pixels into RMT symbols
+ * @brief Create RMT encoder for encoding LED strip pixels into RMT symbols.
  *
- * @param[in] dev Pointer to the device structure for the driver instance
- * @param[in] config Encoder configuration
- * @param[out] ret_encoder Returned encoder handle
- * @return
- *      - ESP_ERR_INVALID_ARG for any invalid arguments
- *      - ESP_ERR_NO_MEM out of memory when creating led strip encoder
- *      - ESP_OK if creating encoder successfully
+ * @param config Encoder configuration.
+ * @param ret_encoder Returned encoder handle.
+ * @retval 0 If successful.
+ * @retval -EINVAL for any invalid arguments.
+ * @retval -ENOMEM out of memory when creating led strip encoder.
+ * @retval -ENODEV because of other error.
  */
-esp_err_t rmt_new_led_strip_encoder(const led_strip_encoder_config_t *config, rmt_encoder_handle_t *ret_encoder);
+int rmt_new_led_strip_encoder(const led_strip_encoder_config_t *config, rmt_encoder_handle_t *ret_encoder);
 
 #ifdef __cplusplus
 }
 #endif
+
+#endif /* LED_STRIP_ENCODER_H_ */
diff --git a/samples/drivers/misc/espressif_rmt/src/main.c b/samples/drivers/misc/espressif_rmt/src/main.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Joel Guittet (joelguittet@gmail.com)
+ * SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -20,29 +20,27 @@ const struct gpio_dt_spec rmt_gpio = GPIO_DT_SPEC_GET(DT_PATH(zephyr_user), rmt_
 
 static const struct device *const rmt_dev = DEVICE_DT_GET_ONE(espressif_esp32_rmt);
 
-#define RMT_LED_STRIP_RESOLUTION_HZ 10000000 // 10MHz resolution, 1 tick = 0.1us (led strip needs a high resolution)
-
+#define RMT_LED_STRIP_RESOLUTION_HZ 10000000 /* 10MHz resolution, 1 tick = 0.1us (led strip needs a high resolution) */
 #define EXAMPLE_LED_NUMBERS         24
 #define EXAMPLE_CHASE_SPEED_MS      10
 
 static uint8_t led_strip_pixels[EXAMPLE_LED_NUMBERS * 3];
 
 /**
- * @brief Simple helper function, converting HSV color space to RGB color space
+ * @brief Simple helper function, converting HSV color space to RGB color space.
  *
  * Wiki: https://en.wikipedia.org/wiki/HSL_and_HSV
- *
  */
 void led_strip_hsv2rgb(uint32_t h, uint32_t s, uint32_t v, uint32_t *r, uint32_t *g, uint32_t *b)
 {
-    h %= 360; // h -> [0,360]
+    h %= 360; /* h -> [0,360] */
     uint32_t rgb_max = v * 2.55f;
     uint32_t rgb_min = rgb_max * (100 - s) / 100.0f;
 
     uint32_t i = h / 60;
     uint32_t diff = h % 60;
 
-    // RGB adjustment amount by hue
+    /* RGB adjustment amount by hue */
     uint32_t rgb_adj = (rgb_max - rgb_min) * diff / 60;
 
     switch (i) {
@@ -86,54 +84,83 @@ int main(void)
 	uint32_t blue = 0;
 	uint16_t hue = 0;
 	uint16_t start_rgb = 0;
+	int rc;
 
 	if (!device_is_ready(rmt_dev)) {
 		printk("RMT device %s is not ready\n", rmt_dev->name);
-		return 0;
+		return -EINVAL;
 	}
 	
 	printk("Create RMT TX channel\n");
 	rmt_channel_handle_t led_chan = NULL;
 	rmt_tx_channel_config_t tx_chan_config = {
-		.clk_src = RMT_CLK_SRC_DEFAULT, // select source clock
+		.clk_src = RMT_CLK_SRC_DEFAULT, /* select source clock */
 		.gpio_num = rmt_gpio.pin,
-		.mem_block_symbols = 64, // increase the block size can make the LED less flickering
+		.mem_block_symbols = 64, /* increase the block size can make the LED less flickering */
 		.resolution_hz = RMT_LED_STRIP_RESOLUTION_HZ,
-		.trans_queue_depth = 4, // set the number of transactions that can be pending in the background
+		.trans_queue_depth = 4, /* set the number of transactions that can be pending in the background */
 	};
-	ESP_ERROR_CHECK(rmt_new_tx_channel(&tx_chan_config, &led_chan));
+	rc = rmt_new_tx_channel(&tx_chan_config, &led_chan);
+	if (rc) {
+		printk("RMT TX channel creation failed\n");
+		return rc;
+	}
 
 	printk("Install led strip encoder\n");
 	rmt_encoder_handle_t led_encoder = NULL;
 	led_strip_encoder_config_t encoder_config = {
 		.resolution = RMT_LED_STRIP_RESOLUTION_HZ,
 	};
-	ESP_ERROR_CHECK(rmt_new_led_strip_encoder(&encoder_config, &led_encoder));
+	rc = rmt_new_led_strip_encoder(&encoder_config, &led_encoder);
+	if (rc) {
+		printk("Unable to create encoder\n");
+		return rc;
+	}
 
 	printk("Enable RMT TX channel\n");
-	ESP_ERROR_CHECK(rmt_enable(led_chan));
+	rc = rmt_enable(led_chan);
+	if (rc) {
+		printk("Unable to enable RMT TX channel\n");
+		return rc;
+	}
 
 	printk("Start LED rainbow chase\n");
 	rmt_transmit_config_t tx_config = {
-		.loop_count = 0, // no transfer loop
+		.loop_count = 0, /* no transfer loop */
 	};
 	while (1) {
 		for (int i = 0; i < 3; i++) {
 			for (int j = i; j < EXAMPLE_LED_NUMBERS; j += 3) {
-				// Build RGB pixels
+				/* Build RGB pixels */
 				hue = j * 360 / EXAMPLE_LED_NUMBERS + start_rgb;
 				led_strip_hsv2rgb(hue, 100, 100, &red, &green, &blue);
 				led_strip_pixels[j * 3 + 0] = green;
 				led_strip_pixels[j * 3 + 1] = blue;
 				led_strip_pixels[j * 3 + 2] = red;
 			}
-			// Flush RGB values to LEDs
-			ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels, sizeof(led_strip_pixels), &tx_config));
-			ESP_ERROR_CHECK(rmt_tx_wait_all_done(led_chan, K_FOREVER));
+			/* Flush RGB values to LEDs */
+			rc = rmt_transmit(led_chan, led_encoder, led_strip_pixels, sizeof(led_strip_pixels), &tx_config);
+			if (rc) {
+				printk("Unable to transmit data over TX channel\n");
+				return rc;
+			}
+			rc = rmt_tx_wait_all_done(led_chan, K_FOREVER);
+			if (rc) {
+				printk("Waiting until all done failed\n");
+				return rc;
+			}
 			k_sleep(K_MSEC(EXAMPLE_CHASE_SPEED_MS));
 			memset(led_strip_pixels, 0, sizeof(led_strip_pixels));
-			ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels, sizeof(led_strip_pixels), &tx_config));
-			ESP_ERROR_CHECK(rmt_tx_wait_all_done(led_chan, K_FOREVER));
+			rc = rmt_transmit(led_chan, led_encoder, led_strip_pixels, sizeof(led_strip_pixels), &tx_config);
+			if (rc) {
+				printk("Unable to transmit data over TX channel\n");
+				return rc;
+			}
+			rc = rmt_tx_wait_all_done(led_chan, K_FOREVER);
+			if (rc) {
+				printk("Waiting until all done failed\n");
+				return rc;
+			}
 			k_sleep(K_MSEC(EXAMPLE_CHASE_SPEED_MS));
 		}
 		start_rgb += 60;

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-# Copyright (c) 2025 Joel Guittet (joelguittet@gmail.com)`
	`1`	`+# SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors`
`2`	`2`	`# SPDX-License-Identifier: Apache-2.0`
`3`	`3`
`4`	`4`	`cmake_minimum_required(VERSION 3.20.0)`
Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`		`-CONFIG_ESPRESSIF_RMT=y`
	`1`	`+# SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors`
	`2`	`+# SPDX-License-Identifier: Apache-2.0`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2025 Joel Guittet (joelguittet@gmail.com)`
	`2`	`+ * SPDX-FileCopyrightText: Copyright The Zephyr Project Contributors`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: Apache-2.0`
`5`	`5`	`*/`