CMakeLists.txt

@@ -4,5 +4,7 @@
 # CMakeLists in this exact order for cmake to work correctly
 cmake_minimum_required(VERSION 3.5)
 
+set(EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/led_strip)
+
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(display-ambient-light-board)

main/CMakeLists.txt

@@ -1,2 +1,2 @@
-idf_component_register(SRCS "hw-ms03.c" "app_nvs.c" "apds_9960.c" "pca9555.c" "i2c.c" "asr_pro.c" "ci_03t.c" "ui_input.c" "ambient_light.c" "temperature.c" "embedded_display.c" "mqtt.c" "main.c" "wifi.c" "light.c" "mqtt.c" "led_strip_encoder/led_strip_encoder.c"
+idf_component_register(SRCS "hw-ms03.c" "app_nvs.c" "apds_9960.c" "pca9555.c" "i2c.c" "asr_pro.c" "ci_03t.c" "ui_input.c" "ambient_light.c" "temperature.c" "embedded_display.c" "mqtt.c" "main.c" "wifi.c" "light.c" "mqtt.c"
                     INCLUDE_DIRS ".")

main/ambient_light.c

@@ -120,9 +120,9 @@ void ambient_light_fetch(void* arg) {
   uint16_t als_ch0_raw;
   uint16_t als_ch1_raw;
   uint16_t proximity_raw;
-  char als_ch0_str[20];
+  char als_ch0_str[10];
-  char als_ch1_str[20];
+  char als_ch1_str[10];
-  char proximity_str[20];
+  char proximity_str[10];
   uint8_t als_ch0_buffer[] = {0, 0};
   uint8_t als_ch1_buffer[] = {0, 0};
   uint8_t proximity_buffer[] = {0, 0};

main/apds_9960.c

@@ -6,7 +6,6 @@
 #include "driver/i2c.h"
 #include "embedded_display.c"
 #include "esp_log.h"
-#include "esp_timer.h"
 #include "freertos/FreeRTOS.h"
 #include "i2c.c"
 
@@ -129,7 +128,7 @@
 
 #define APDS_9960_TAG "APDS-9960"
 
-static QueueHandle_t apds_9960_int_evt_queue = NULL;
+static xQueueHandle apds_9960_int_evt_queue = NULL;
 
 static int64_t last_apds_9960_int_time = 0;
 

main/i2c.c

@@ -54,7 +54,7 @@ uint8_t i2c_check_slave_exists(uint8_t address) {
   i2c_master_start(cmd);
   i2c_master_write_byte(cmd, (address << 1) | I2C_MASTER_WRITE, ACK_CHECK_EN);
   i2c_master_stop(cmd);
-  esp_err_t ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 50 / portTICK_PERIOD_MS);
+  esp_err_t ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 50 / portTICK_RATE_MS);
   i2c_cmd_link_delete(cmd);
 
   if (ret == ESP_OK) {

main/led_strip_encoder/led_strip_encoder.c

@@ -1,141 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#include "led_strip_encoder.h"
-
-#include "esp_check.h"
-
-static const char *TAG = "led_encoder";
-
-typedef struct {
-  rmt_encoder_t base;
-  rmt_encoder_t *bytes_encoder;
-  rmt_encoder_t *copy_encoder;
-  int state;
-  rmt_symbol_word_t reset_code;
-} rmt_led_strip_encoder_t;
-
-static size_t rmt_encode_led_strip(rmt_encoder_t *encoder,
-                                   rmt_channel_handle_t channel,
-                                   const void *primary_data, size_t data_size,
-                                   rmt_encode_state_t *ret_state) {
-  rmt_led_strip_encoder_t *led_encoder =
-      __containerof(encoder, rmt_led_strip_encoder_t, base);
-  rmt_encoder_handle_t bytes_encoder = led_encoder->bytes_encoder;
-  rmt_encoder_handle_t copy_encoder = led_encoder->copy_encoder;
-  rmt_encode_state_t session_state = 0;
-  rmt_encode_state_t state = 0;
-  size_t encoded_symbols = 0;
-  switch (led_encoder->state) {
-    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
-      }
-      if (session_state & RMT_ENCODING_MEM_FULL) {
-        state |= RMT_ENCODING_MEM_FULL;
-        goto out;  // yield if there's no free space for encoding artifacts
-      }
-    // 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 = 0;  // 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
-      }
-  }
-out:
-  *ret_state = state;
-  return encoded_symbols;
-}
-
-static esp_err_t 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;
-}
-
-static esp_err_t 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 = 0;
-  return ESP_OK;
-}
-
-esp_err_t rmt_new_led_strip_encoder(const led_strip_encoder_config_t *config,
-                                    rmt_encoder_handle_t *ret_encoder) {
-  esp_err_t ret = ESP_OK;
-  rmt_led_strip_encoder_t *led_encoder = NULL;
-  ESP_GOTO_ON_FALSE(config && ret_encoder, ESP_ERR_INVALID_ARG, err, TAG,
-                    "invalid argument");
-  led_encoder = calloc(1, sizeof(rmt_led_strip_encoder_t));
-  ESP_GOTO_ON_FALSE(led_encoder, ESP_ERR_NO_MEM, err, TAG,
-                    "no mem for led strip encoder");
-  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
-  rmt_bytes_encoder_config_t bytes_encoder_config = {
-      .bit0 =
-          {
-              .level0 = 1,
-              .duration0 = 0.3 * config->resolution / 1000000,  // T0H=0.3us
-              .level1 = 0,
-              .duration1 = 0.9 * config->resolution / 1000000,  // T0L=0.9us
-          },
-      .bit1 =
-          {
-              .level0 = 1,
-              .duration0 = 0.9 * config->resolution / 1000000,  // T1H=0.9us
-              .level1 = 0,
-              .duration1 = 0.3 * config->resolution / 1000000,  // T1L=0.3us
-          },
-      .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");
-  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
-  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;
-err:
-  if (led_encoder) {
-    if (led_encoder->bytes_encoder) {
-      rmt_del_encoder(led_encoder->bytes_encoder);
-    }
-    if (led_encoder->copy_encoder) {
-      rmt_del_encoder(led_encoder->copy_encoder);
-    }
-    free(led_encoder);
-  }
-  return ret;
-}

main/led_strip_encoder/led_strip_encoder.h

@@ -1,38 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#pragma once
-
-#include <stdint.h>
-
-#include "driver/rmt_encoder.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @brief Type of led strip encoder configuration
- */
-typedef struct {
-  uint32_t resolution; /*!< Encoder resolution, in Hz */
-} led_strip_encoder_config_t;
-
-/**
- * @brief Create RMT encoder for encoding LED strip pixels into RMT symbols
- *
- * @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
- */
-esp_err_t rmt_new_led_strip_encoder(const led_strip_encoder_config_t *config,
-                                    rmt_encoder_handle_t *ret_encoder);
-
-#ifdef __cplusplus
-}
-#endif

main/light.c

@@ -1,22 +1,28 @@
-#pragma once
+/* RMT example -- RGB LED Strip
-#include <string.h>
 
-#include "driver/rmt_tx.h"
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+#pragma once
+#include "driver/rmt.h"
 #include "esp_log.h"
 #include "esp_system.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "led_strip_encoder/led_strip_encoder.h"
+#include "led_strip.h"
 #include "nvs.h"
 #include "nvs_flash.h"
 #include "sdkconfig.h"
 
 static const char *LIGHT_TAG = "DisplayAmbientLight_Light";
 
+#define RMT_TX_CHANNEL RMT_CHANNEL_0
 #define RMT_TX_GPIO 1
 #define STRIP_LED_NUMBER CONFIG_NUMBER_OF_LEDS
 #define EXAMPLE_CHASE_SPEED_MS (10)
-#define RMT_LED_STRIP_RESOLUTION_HZ 10000000
 
 typedef enum light_mode_e {
   light_mode_init = 0,
@@ -28,13 +34,7 @@ typedef enum light_mode_e {
   light_mode_off = 6,
 } light_mode_t;
 
-rmt_channel_handle_t led_chan = NULL;
+led_strip_t *light_led_strip;
-static uint8_t led_strip_pixels[STRIP_LED_NUMBER * 3];
-rmt_encoder_handle_t led_encoder = NULL;
-rmt_transmit_config_t tx_config = {
-    .loop_count = 0,  // no transfer loop
-};
-
 light_mode_t light_mode;
 float display_ambient_light_brightness = 1;
 uint8_t display_ambient_lighting_level = 255;
@@ -179,53 +179,52 @@ void led_strip_hsv2rgb(uint32_t h, uint32_t s, uint32_t v, uint32_t *r,
   }
 }
 
-// void update_desktop_connection_state() {
+void update_desktop_connection_state() {
-//   static uint8_t tick = 0;
+  static uint8_t tick = 0;
 
-//   bool beat = tick / 10 % 2 ? 1 : 0;
+  bool beat = tick / 10 % 2 ? 1 : 0;
 
-//   switch (light_mode) {
+  switch (light_mode) {
-//     case light_mode_desktop_online:
+    case light_mode_desktop_online:
-//       if (beat) {
+      if (beat) {
-//         led_strip_pixels[0] = 0;
+        ESP_ERROR_CHECK(
-//         led_strip_pixels[1] = 0;
+            light_led_strip->set_pixel(light_led_strip, 0, 10, 10, 10));
-//         led_strip_pixels[2] = 0;
+      }
-//       }
+      ESP_ERROR_CHECK(
-//       led_strip_pixels[3] = 10
+          light_led_strip->set_pixel(light_led_strip, 1, 10, 10, 10));
-//       break;
+      ESP_ERROR_CHECK(
-//     case light_mode_mqtt_connected:
+          light_led_strip->set_pixel(light_led_strip, 2, 10, 10, 10));
-//       if (beat) {
+      break;
-//         ESP_ERROR_CHECK(
+    case light_mode_mqtt_connected:
-//             light_led_strip->set_pixel(light_led_strip, 0, 10, 10, 10));
+      if (beat) {
-//         ESP_ERROR_CHECK(
+        ESP_ERROR_CHECK(
-//             light_led_strip->set_pixel(light_led_strip, 1, 10, 10, 10));
+            light_led_strip->set_pixel(light_led_strip, 0, 10, 10, 10));
-//       }
+        ESP_ERROR_CHECK(
-//       ESP_ERROR_CHECK(
+            light_led_strip->set_pixel(light_led_strip, 1, 10, 10, 10));
-//           light_led_strip->set_pixel(light_led_strip, 2, 22, 22, 22));
+      }
-//       break;
+      ESP_ERROR_CHECK(
-//     case light_mode_idle:
+          light_led_strip->set_pixel(light_led_strip, 2, 22, 22, 22));
-//       if (beat) {
+      break;
-//         ESP_ERROR_CHECK(
+    case light_mode_idle:
-//             light_led_strip->set_pixel(light_led_strip, 0, 77, 77, 77));
+      if (beat) {
-//         ESP_ERROR_CHECK(
+        ESP_ERROR_CHECK(
-//             light_led_strip->set_pixel(light_led_strip, 1, 77, 77, 77));
+            light_led_strip->set_pixel(light_led_strip, 0, 77, 77, 77));
-//         ESP_ERROR_CHECK(
+        ESP_ERROR_CHECK(
-//             light_led_strip->set_pixel(light_led_strip, 2, 77, 77, 77));
+            light_led_strip->set_pixel(light_led_strip, 1, 77, 77, 77));
-//       }
+        ESP_ERROR_CHECK(
-//       break;
+            light_led_strip->set_pixel(light_led_strip, 2, 77, 77, 77));
-//     default:
+      }
-//       break;
+      break;
-//   }
+    default:
+      break;
+  }
 
-//   tick++;
+  tick++;
-// }
+}
 
 void light_for_init() {
   ESP_LOGI(LIGHT_TAG, "light_for_init");
-
+  ESP_ERROR_CHECK(light_led_strip->clear(light_led_strip, 100));
-  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));
 
   nvs_handle local_nvs_handle;
   esp_err_t err = nvs_open("storage", NVS_READWRITE, &local_nvs_handle);
@@ -274,13 +273,10 @@ void light_for_init() {
       init_b = (uint8_t)(b_f * (float)i);
 
       for (int j = 0; j < STRIP_LED_NUMBER; j++) {
-        led_strip_pixels[j * 3 + 0] = init_g;
+        ESP_ERROR_CHECK(light_led_strip->set_pixel(light_led_strip, j, init_r,
-        led_strip_pixels[j * 3 + 1] = init_r;
+                                                   init_g, init_b));
-        led_strip_pixels[j * 3 + 2] = init_b;
       }
-
+      ESP_ERROR_CHECK(light_led_strip->refresh(light_led_strip, 100));
-      ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
-                                   sizeof(led_strip_pixels), &tx_config));
       vTaskDelay(pdMS_TO_TICKS(20));
     }
     vTaskDelay(pdMS_TO_TICKS(100));
@@ -296,34 +292,19 @@ void light_for_connecting_wifi() {
   int8_t tick_tock = 0;
 
   do {
-    if (tick_tock) {
+    ESP_ERROR_CHECK(
-      led_strip_pixels[0] = 150;
+        light_led_strip->set_pixel(light_led_strip, tick_tock, 150, 150, 0));
-      led_strip_pixels[1] = 150;
+    ESP_ERROR_CHECK(light_led_strip->set_pixel(light_led_strip,
-      led_strip_pixels[2] = 0;
+                                               (tick_tock + 1) % 2, 0, 200, 0));
-      led_strip_pixels[3] = 200;
+    ESP_ERROR_CHECK(light_led_strip->refresh(light_led_strip, 100));
-      led_strip_pixels[4] = 0;
-      led_strip_pixels[5] = 0;
-    } else {
-      led_strip_pixels[0] = 200;
-      led_strip_pixels[1] = 0;
-      led_strip_pixels[2] = 0;
-      led_strip_pixels[3] = 150;
-      led_strip_pixels[4] = 150;
-      led_strip_pixels[5] = 0;
-    }
     tick_tock = !tick_tock;
-    ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
-                                 sizeof(led_strip_pixels), &tx_config));
     vTaskDelay(pdMS_TO_TICKS(200));
   } while (light_mode == light_mode_connection_wifi);
 }
 
 void light_for_idle() {
   ESP_LOGI(LIGHT_TAG, "light_for_idle");
-
+  ESP_ERROR_CHECK(light_led_strip->clear(light_led_strip, 100));
-  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));
 
   uint32_t red = 0, green = 0, blue = 0;
   uint16_t step_length = 360 / STRIP_LED_NUMBER;
@@ -337,23 +318,24 @@ void light_for_idle() {
       // Build RGB values
       led_strip_hsv2rgb(hue, 50, 30, &red, &green, &blue);
 
-      led_strip_pixels[j * 3 + 0] = green * display_ambient_light_brightness *
+      red = red * display_ambient_light_brightness * led_strip_red_calibration;
+      green = green * display_ambient_light_brightness *
               led_strip_green_calibration;
-      led_strip_pixels[j * 3 + 1] =
+      blue =
-          red * display_ambient_light_brightness * led_strip_red_calibration;
-      led_strip_pixels[j * 3 + 2] =
           blue * display_ambient_light_brightness * led_strip_blue_calibration;
+      // Write RGB values to strip driver
+      ESP_ERROR_CHECK(
+          light_led_strip->set_pixel(light_led_strip, j, red, green, blue));
     }
-    // update_desktop_connection_state();
+    update_desktop_connection_state();
-    ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
+    ESP_ERROR_CHECK(light_led_strip->refresh(light_led_strip, 100));
-                                 sizeof(led_strip_pixels), &tx_config));
     vTaskDelay(pdMS_TO_TICKS(10));
   }
 }
 
 void light_strip_running_task(void *pv_parameters) {
   while (true) {
-    if (!led_chan) {
+    if (!light_led_strip) {
       ESP_LOGE(LIGHT_TAG, "install WS2812 driver failed 2");
     }
     switch (light_mode) {
@@ -377,28 +359,24 @@ void light_strip_running_task(void *pv_parameters) {
 }
 
 void light_init_strip() {
-  rmt_tx_channel_config_t tx_chan_config = {
+  rmt_config_t config = RMT_DEFAULT_CONFIG_TX(RMT_TX_GPIO, RMT_TX_CHANNEL);
-      .clk_src = RMT_CLK_SRC_DEFAULT,  // select source clock
+  // set counter clock to 40MHz
-      .gpio_num = RMT_TX_GPIO,
+  config.clk_div = 2;
-      .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
-  };
-  ESP_ERROR_CHECK(rmt_new_tx_channel(&tx_chan_config, &led_chan));
 
-  ESP_LOGI(LIGHT_TAG, "Install led strip encoder");
+  ESP_ERROR_CHECK(rmt_config(&config));
+  ESP_ERROR_CHECK(rmt_driver_install(config.channel, 0, 0));
 
-  led_strip_encoder_config_t encoder_config = {
+  // install ws2812 driver
-      .resolution = RMT_LED_STRIP_RESOLUTION_HZ,
+  led_strip_config_t strip_config = LED_STRIP_DEFAULT_CONFIG(
-  };
+      STRIP_LED_NUMBER, (led_strip_dev_t)config.channel);
-  ESP_ERROR_CHECK(rmt_new_led_strip_encoder(&encoder_config, &led_encoder));
+  light_led_strip = led_strip_new_rmt_ws2812(&strip_config);
-
+  if (!light_led_strip) {
-  ESP_LOGI(LIGHT_TAG, "Enable RMT TX channel");
+    ESP_LOGE(LIGHT_TAG, "install WS2812 driver failed");
-  ESP_ERROR_CHECK(rmt_enable(led_chan));
+  }
-
+  // Clear LED strip (turn off all LEDs)
-  ESP_LOGI(LIGHT_TAG, "Start LED rainbow chase");
+  ESP_ERROR_CHECK(light_led_strip->clear(light_led_strip, 100));
+  // Show simple rainbow chasing pattern
+  ESP_LOGI(LIGHT_TAG, "LED Rainbow Chase Start");
 
   light_mode = light_mode_init;
 
@@ -426,9 +404,8 @@ void light_play_colors(uint16_t len, uint8_t *buffer) {
     if (r <= 7 && g <= 7 && b <= 7) {
       black_count++;
     }
-    led_strip_pixels[led_index * 3 + 0] = g;
+    ESP_ERROR_CHECK(
-    led_strip_pixels[led_index * 3 + 1] = r;
+        light_led_strip->set_pixel(light_led_strip, led_index, r, g, b));
-    led_strip_pixels[led_index * 3 + 2] = b;
   }
 
   if (black_count > STRIP_LED_NUMBER / 5 * 4) {
@@ -439,14 +416,12 @@ void light_play_colors(uint16_t len, uint8_t *buffer) {
             b = (uint8_t)((float)20 * display_ambient_light_brightness *
                           led_strip_blue_calibration);
     for (uint16_t led_index = 0; led_index < STRIP_LED_NUMBER; led_index++) {
-      led_strip_pixels[led_index * 3 + 0] = g;
+      ESP_ERROR_CHECK(
-      led_strip_pixels[led_index * 3 + 1] = r;
+          light_led_strip->set_pixel(light_led_strip, led_index, r, g, b));
-      led_strip_pixels[led_index * 3 + 2] = b;
     }
+  } else {
   }
-
+  ESP_ERROR_CHECK(light_led_strip->refresh(light_led_strip, 100));
-  ESP_ERROR_CHECK(rmt_transmit(led_chan, led_encoder, led_strip_pixels,
-                               sizeof(led_strip_pixels), &tx_config));
   vTaskDelay(pdMS_TO_TICKS(10));
 }
 

main/mqtt.c

@@ -52,7 +52,7 @@
 static const char *MQTT_TAG = "DisplayAmbientLight_MQTT";
 
 static EventGroupHandle_t s_mqtt_event_group;
-static QueueHandle_t mqtt_cmd_event = NULL;
+static xQueueHandle mqtt_cmd_event = NULL;
 static esp_mqtt_client_handle_t client = NULL;
 
 typedef struct colors {
@@ -69,8 +69,8 @@ static void log_error_if_nonzero(const char *message, int error_code) {
 }
 
 static void mqtt_event_handler(void *handler_args, esp_event_base_t base,
-                               long event_id, void *event_data) {
+                               int32_t event_id, void *event_data) {
-  ESP_LOGD(MQTT_TAG, "Event dispatched from event loop base=%s, event_id=%ld",
+  ESP_LOGD(MQTT_TAG, "Event dispatched from event loop base=%s, event_id=%d",
            base, event_id);
   esp_mqtt_event_handle_t event = event_data;
   client = event->client;
@@ -195,7 +195,7 @@ static void mqtt_app_start() {
   xTaskCreate(mqtt_cmd_event_handler, "mqtt_cmd_event", 2048, NULL, 10, NULL);
 
   const esp_mqtt_client_config_t mqtt_cfg = {
-      .broker.address.uri = MQTT_BROKER_URL,
+      .uri = MQTT_BROKER_URL,
   };
   esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);
   esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler,

main/temperature.c

@@ -22,7 +22,7 @@
 void fetch_temperature(void* arg) {
   esp_err_t error;
   float temperature = DEFAULT_TEMPERATURE;
-  char temperature_str[20];
+  char temperature_str[10];
   uint8_t temperature_buffer[] = {0, 0};
   display_fill_rect(0, 0, 128, 2, 0x00);
   for (;;) {

main/ui_input.c

@@ -34,8 +34,8 @@
 
 static const char *UI_INPUT_TAG = "UiInput";
 
-static QueueHandle_t ui_input_event = NULL;
+static xQueueHandle ui_input_event = NULL;
-static QueueHandle_t ui_input_raw_event = NULL;
+static xQueueHandle ui_input_raw_event = NULL;
 
 typedef struct encoder_state {
   e_ui_input_raw_key_t key;
@@ -51,6 +51,7 @@ static encoder_state_t encoder_1_state = {.key = ui_input_raw_key_encoder_1,
 
 uint8_t level_byte;
 int8_t delta = 0;
+char changing_str[12] = "NC";
 
 static void IRAM_ATTR gpio_isr_handler(void *arg) {
   xQueueSendFromISR(ui_input_raw_event, NULL, NULL);
@@ -58,7 +59,7 @@ static void IRAM_ATTR gpio_isr_handler(void *arg) {
 
 static void ui_input_update_embedded_display(void *arg) {
   s_ui_input_t input;
-  char changing_str[20] = "NC";
+  char changing_str[12] = "NC";
   for (;;) {
     if (xQueueReceive(ui_input_event, &input, portMAX_DELAY)) {
       switch (input.key) {