chore(light): 调整氛围灯最暗阈值。

dependencies.lock

@@ -0,0 +1,9 @@
+dependencies:
+  idf:
+    component_hash: null
+    source:
+      type: idf
+    version: 4.4.4
+manifest_hash: dcf4d39b94252de130019eadceb989d72b0dbc26b552cfdcbb50f6da531d2b92
+target: esp32c3
+version: 1.0.0

main/CMakeLists.txt

@@ -1,2 +1,2 @@
-idf_component_register(SRCS "hw-ms03.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"
+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/app_nvs.c

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <stdio.h>
+
+#include "esp_system.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "nvs.h"
+#include "nvs_flash.h"
+
+void app_nvs_init() {
+  esp_err_t err = nvs_flash_init();
+  if (err == ESP_ERR_NVS_NO_FREE_PAGES ||
+      err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+    ESP_ERROR_CHECK(nvs_flash_erase());
+    err = nvs_flash_init();
+  }
+  ESP_ERROR_CHECK(err);
+}

main/light.c

@@ -9,9 +9,12 @@
 #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.h"
+#include "nvs.h"
+#include "nvs_flash.h"
 #include "sdkconfig.h"
 
 static const char *LIGHT_TAG = "DisplayAmbientLight_Light";
@@ -36,6 +39,10 @@ light_mode_t light_mode;
 float display_ambient_light_brightness = 1;
 uint8_t display_ambient_lighting_level = 255;
 
+float led_strip_red_calibration = 1.0;
+float led_strip_green_calibration = 1.0;
+float led_strip_blue_calibration = 1.0;
+
 void led_strip_fade_in_light_level(void *pvParameter) {
   float target = (float)display_ambient_lighting_level / 255.0;
   float step_length = (target - display_ambient_light_brightness) / 40.0;
@@ -55,6 +62,68 @@ void led_strip_set_brightness(uint8_t level) {
 
   xTaskCreate(led_strip_fade_in_light_level, "LED_STRIP_FADE_IN_LIGHT_LEVEL",
               4096, NULL, 1, NULL);
+
+  nvs_handle_t nvs_handle;
+  esp_err_t err = nvs_open("storage", NVS_READWRITE, &nvs_handle);
+  err = nvs_set_u8(nvs_handle, "brightness", level);
+  if (err != ESP_OK) {
+    ESP_LOGW(LIGHT_TAG, "Error (%s) saving light level!\n",
+             esp_err_to_name(err));
+    nvs_close(nvs_handle);
+    return;
+  }
+  err = nvs_commit(nvs_handle);
+  if (err != ESP_OK) {
+    ESP_LOGW(LIGHT_TAG, "Error (%s) saving light level!\n",
+             esp_err_to_name(err));
+  }
+  nvs_close(nvs_handle);
+}
+
+void led_strip_set_color_calibration(float red, float green, float blue) {
+  led_strip_red_calibration = red;
+  led_strip_green_calibration = green;
+  led_strip_blue_calibration = blue;
+
+  nvs_handle_t local_nvs_handle;
+
+  esp_err_t err = nvs_open("storage", NVS_READWRITE, &local_nvs_handle);
+
+  if (err != ESP_OK) {
+    ESP_LOGW(LIGHT_TAG, "Error (%s) opening NVS handle!\n",
+             esp_err_to_name(err));
+    return;
+  }
+
+  err = nvs_set_u8(local_nvs_handle, "calibration_r", (uint32_t)(red * 255));
+  if (err != ESP_OK) {
+    nvs_close(local_nvs_handle);
+    ESP_LOGW(LIGHT_TAG, "Error (%s) write calibration_r failed!",
+             esp_err_to_name(err));
+    return;
+  }
+  err = nvs_set_u8(local_nvs_handle, "calibration_g", (uint8_t)(green * 255));
+  if (err != ESP_OK) {
+    nvs_close(local_nvs_handle);
+    ESP_LOGW(LIGHT_TAG, "Error (%s) calibration_g failed!",
+             esp_err_to_name(err));
+    return;
+  }
+  err = nvs_set_u8(local_nvs_handle, "calibration_b", (uint8_t)(blue * 255));
+  if (err != ESP_OK) {
+    nvs_close(local_nvs_handle);
+    ESP_LOGW(LIGHT_TAG, "Error (%s) calibration_b failed!",
+             esp_err_to_name(err));
+    return;
+  }
+
+  err = nvs_commit(local_nvs_handle);
+  if (err != ESP_OK) {
+    ESP_LOGW(LIGHT_TAG, "Error (%s) save led_strip_red_calibration failed!",
+             esp_err_to_name(err));
+  }
+
+  nvs_close(local_nvs_handle);
 }
 
 /**
@@ -157,21 +226,64 @@ void light_for_init() {
   ESP_LOGI(LIGHT_TAG, "light_for_init");
   ESP_ERROR_CHECK(light_led_strip->clear(light_led_strip, 100));
 
-  uint32_t red = 0, green = 0, blue = 0;
+  nvs_handle local_nvs_handle;
-  int8_t i = 0;
+  esp_err_t err = nvs_open("storage", NVS_READWRITE, &local_nvs_handle);
+  if (err != ESP_OK) {
+    ESP_LOGW(LIGHT_TAG, "Error (%s) opening NVS handle!", esp_err_to_name(err));
+  }
+
+  uint8_t r = 255, g = 255, b = 255;
+  uint8_t brightness = 200;
+  err = nvs_get_u8(local_nvs_handle, "calibration_r", &r);
+  if (err != ESP_OK) {
+    ESP_LOGW(LIGHT_TAG, "Error (%s) reading calibration_r!",
+             esp_err_to_name(err));
+  }
+  err = nvs_get_u8(local_nvs_handle, "calibration_g", &g);
+  if (err != ESP_OK) {
+    ESP_LOGW(LIGHT_TAG, "Error (%s) reading calibration_g!",
+             esp_err_to_name(err));
+  }
+  err = nvs_get_u8(local_nvs_handle, "calibration_b", &b);
+  if (err != ESP_OK) {
+    ESP_LOGW(LIGHT_TAG, "Error (%s) reading calibration_b!",
+             esp_err_to_name(err));
+  }
+  err = nvs_get_u8(local_nvs_handle, "brightness", &brightness);
+  if (err != ESP_OK) {
+    ESP_LOGW(LIGHT_TAG, "Error (%s) reading brightness!", esp_err_to_name(err));
+  }
+
+  nvs_close(local_nvs_handle);
+
+  // set brightness
+  led_strip_set_brightness(brightness);
+
+  // play init light
+  float r_f = (float)r / 255.0;
+  float g_f = (float)g / 255.0;
+  float b_f = (float)b / 255.0;
+
+  uint8_t init_r, init_g, init_b;
 
   do {
-    for (; i < 100; i++) {
+    for (uint8_t i = 0; i < 50; i++) {
+      init_r = (uint8_t)(r_f * (float)i);
+      init_g = (uint8_t)(g_f * (float)i);
+      init_b = (uint8_t)(b_f * (float)i);
+
       for (int j = 0; j < STRIP_LED_NUMBER; j++) {
-        led_strip_hsv2rgb(0, 0, i, &red, &green, &blue);
+        ESP_ERROR_CHECK(light_led_strip->set_pixel(light_led_strip, j, init_r,
-        ESP_ERROR_CHECK(
+                                                   init_g, init_b));
-            light_led_strip->set_pixel(light_led_strip, j, red, green, blue));
       }
       ESP_ERROR_CHECK(light_led_strip->refresh(light_led_strip, 100));
-      vTaskDelay(pdMS_TO_TICKS(10));
+      vTaskDelay(pdMS_TO_TICKS(20));
     }
     vTaskDelay(pdMS_TO_TICKS(100));
   } while (light_mode == light_mode_init);
+
+  led_strip_set_color_calibration((float)r / 255.0, (float)g / 255.0,
+                                  (float)b / 255.0);
 }
 
 void light_for_connecting_wifi() {
@@ -206,9 +318,11 @@ void light_for_idle() {
       // Build RGB values
       led_strip_hsv2rgb(hue, 50, 30, &red, &green, &blue);
 
-      red = red * display_ambient_light_brightness;
+      red = red * display_ambient_light_brightness * led_strip_red_calibration;
-      green = green * display_ambient_light_brightness;
+      green = green * display_ambient_light_brightness *
-      blue = blue * display_ambient_light_brightness;
+              led_strip_green_calibration;
+      blue =
+          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));
@@ -273,18 +387,40 @@ void light_init_strip() {
 void light_play_colors(uint16_t len, uint8_t *buffer) {
   light_mode = light_mode_desktop_sending_colors;
 
+  uint16_t black_count = 0;  // count of black pixels. r/g/b <= 10
+
   for (uint16_t led_index = 0, buffer_cursor = 0;
        led_index < STRIP_LED_NUMBER && buffer_cursor < len;
        led_index++, buffer_cursor += 3) {
     uint8_t r = (uint8_t)((float)buffer[buffer_cursor] *
-                          display_ambient_light_brightness),
+                          display_ambient_light_brightness *
+                          led_strip_red_calibration),
             g = (uint8_t)((float)buffer[buffer_cursor + 1] *
-                          display_ambient_light_brightness),
+                          display_ambient_light_brightness *
+                          led_strip_green_calibration),
             b = (uint8_t)((float)buffer[buffer_cursor + 2] *
-                          display_ambient_light_brightness);
+                          display_ambient_light_brightness *
+                          led_strip_blue_calibration);
+    if (r <= 7 && g <= 7 && b <= 7) {
+      black_count++;
+    }
     ESP_ERROR_CHECK(
         light_led_strip->set_pixel(light_led_strip, led_index, r, g, b));
   }
+
+  if (black_count > STRIP_LED_NUMBER / 5 * 4) {
+    uint8_t r = (uint8_t)((float)50 * display_ambient_light_brightness *
+                          led_strip_red_calibration),
+            g = (uint8_t)((float)40 * display_ambient_light_brightness *
+                          led_strip_green_calibration),
+            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++) {
+      ESP_ERROR_CHECK(
+          light_led_strip->set_pixel(light_led_strip, led_index, r, g, b));
+    }
+  } else {
+  }
   ESP_ERROR_CHECK(light_led_strip->refresh(light_led_strip, 100));
   vTaskDelay(pdMS_TO_TICKS(10));
 }

main/main.c

@@ -1,4 +1,5 @@
 #include "apds_9960.c"
+#include "app_nvs.c"
 #include "ci_03t.c"
 #include "embedded_display.c"
 #include "esp_log.h"
@@ -17,6 +18,7 @@
 static const char *TAG = "DisplayAmbientLight";
 
 void app_main(void) {
+  app_nvs_init();
   light_init_strip();
 
   gpio_install_isr_service(0);
@@ -26,7 +28,7 @@ void app_main(void) {
   init_display();
   display_print8_str(0, 0, "Ambient Light");
   // hw_ms03_init();
-  // ci_03t_init();
+  ci_03t_init();
   apds_9960_init();
   apds_9960_auto_fetch();
   auto_fetch_temperature();

main/mqtt.c

@@ -40,6 +40,8 @@
 #define MQTT_KEY_DESKTOP_ONLINE MQTT_DESKTOP_KEY_PREFIX MQTT_ONLINE_SUFFIX
 #define MQTT_KEY_DESKTOP_COLORS MQTT_DESKTOP_KEY_PREFIX MQTT_COLORS_SUFFIX
 #define MQTT_KEY_DESKTOP_ALL MQTT_DESKTOP_KEY_PREFIX MQTT_ALL_SUFFIX
+#define MQTT_KEY_DESKTOP_COLOR_CALIBRATION \
+  MQTT_DESKTOP_KEY_PREFIX "color-calibration"
 
 #define MQTT_KEY_BOARD_CMD MQTT_BOARD_KEY_PREFIX MQTT_CMD_SUFFIX
 #define MQTT_KEY_DESKTOP_DISPLAY_0_BRIGHTNESS \
@@ -124,6 +126,11 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base,
               .value = (uint16_t)(event->data[0] << 8 | event->data[1]),
           };
           xQueueSend(mqtt_cmd_event, &mqtt_event, NULL);
+        } else if (strncmp(event->topic, MQTT_KEY_DESKTOP_COLOR_CALIBRATION,
+                           event->topic_len) == 0) {
+          led_strip_set_color_calibration((float)event->data[0] / 255.0,
+                                          (float)event->data[1] / 255.0,
+                                          (float)event->data[2] / 255.0);
         } else {
           printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
           printf("DATA=%.*s\r\n", event->data_len, event->data);