feat: 使用校准的颜色来显示空闲灯光。

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 "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/Kconfig.projbuild

@@ -146,12 +146,3 @@ menu "UART Configuration"
         help
             UART NUM
 endmenu
-
-menu "ADPS 9960"
-    config APDS_9960_INT_GPIO
-        int "APDS 996O INT GPIO"
-        range 0 32
-        default 2
-        help
-            APDS 996O INT GPIO
-endmenu

main/apds_9960.c

@@ -1,19 +1,14 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "common.h"
-#include "driver/gpio.h"
 #include "driver/i2c.h"
 #include "embedded_display.c"
 #include "esp_log.h"
-#include "freertos/FreeRTOS.h"
 #include "i2c.c"
 
-#define APDS_9960_INT_GPIO CONFIG_APDS_9960_INT_GPIO
+// #define APDS_9930_CMD_REPEATED 0x80        // 命令重复地址
+// #define APDS_9930_CMD_AUTO_INCREMENT 0x90  // 命令自动递增地址
 
-// ===============================================
-// Register addresses
-// ===============================================
 // 0x80 ENABLE R/W Enable states and interrupts 0x00
 // 0x81 ATIME R/W ADC integration time 0xFF
 // 0x83 WTIME R/W Wait time (non-gesture) 0xFF
@@ -114,40 +109,13 @@
 #define APDS_9960_REG_GFIFO_L 0xFE  // 手势 FIFO 数据左             0x00
 #define APDS_9960_REG_GFIFO_R 0xFF  // 手势 FIFO 数据右             0x00
 
-#define APDS_9960_GVALID 0b00000001  // GVALID
+#define APDS_9960_CONTROL_VALUE \
-#define APDS_9960_GFOV 0b00000010    // GFOV
+  0b00001010  // 50 mA LED, Reserved, 2x PGAIN, 4x ALS/Cain GAIN
-#define APDS_9960_PINT 0x20          // PINT
+#define APDS_9960_ENABLE_VALUE 0b00000111
-#define APDS_9960_AINT 0x10          // AINT
+#define APDS_9930_OFFSET_VALUE 0x8f
-#define APDS_9960_GINT 0x04          // GINT
-
-// 50 mA LED, Reserved, 2x PGAIN, 4x ALS/Cain GAIN
-#define APDS_9960_CONTROL_VALUE 0b00001010
-// Enable Gesture, Proximity, ALS, Power
-// X, GEN, PIEN, AIEN, WEN, PEN, AEN, PON
-#define APDS_9960_ENABLE_VALUE 0b01100111
 
 #define APDS_9960_TAG "APDS-9960"
 
-static xQueueHandle apds_9960_int_evt_queue = NULL;
-
-static int64_t last_apds_9960_int_time = 0;
-
-esp_err_t apds_9960_write_empty(uint8_t command) {
-  i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-  i2c_master_start(cmd);
-  i2c_master_write_byte(cmd, APDS_9960_ADDRESS << 1 | I2C_MASTER_WRITE,
-                        ACK_CHECK_EN);
-  i2c_master_write_byte(cmd, command, ACK_CHECK_DIS);
-  i2c_master_stop(cmd);
-  esp_err_t error =
-      i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 10 / portTICK_PERIOD_MS);
-  i2c_cmd_link_delete(cmd);
-  if (error != ESP_OK) {
-    ESP_LOGW(APDS_9960_TAG, "write failed. %d", error);
-  }
-  return error;
-}
-
 esp_err_t apds_9960_write(uint8_t command, uint8_t data) {
   i2c_cmd_handle_t cmd = i2c_cmd_link_create();
   i2c_master_start(cmd);
@@ -157,7 +125,7 @@ esp_err_t apds_9960_write(uint8_t command, uint8_t data) {
   i2c_master_write_byte(cmd, data, ACK_CHECK_EN);
   i2c_master_stop(cmd);
   esp_err_t error =
-      i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 10 / portTICK_PERIOD_MS);
+      i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 1000 / portTICK_PERIOD_MS);
   i2c_cmd_link_delete(cmd);
   if (error != ESP_OK) {
     ESP_LOGW(APDS_9960_TAG, "write failed. %d", error);
@@ -177,10 +145,10 @@ esp_err_t apds_9960_read_byte(uint8_t command, uint8_t* data) {
   i2c_master_read_byte(cmd, data, NACK_VAL);
   i2c_master_stop(cmd);
   esp_err_t error =
-      i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 10 / portTICK_PERIOD_MS);
+      i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 1000 / portTICK_PERIOD_MS);
   i2c_cmd_link_delete(cmd);
   if (error != ESP_OK) {
-    ESP_LOGW(APDS_9960_TAG, "read failed. %d", error);
+    ESP_LOGW(APDS_9960_TAG, "write failed. %d", error);
   }
   return error;
 }
@@ -199,87 +167,42 @@ esp_err_t apds_9960_read_word(uint8_t command, uint16_t* data) {
   i2c_master_read_byte(cmd, (uint8_t*)data + 1, NACK_VAL);
   i2c_master_stop(cmd);
   esp_err_t error =
-      i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 10 / portTICK_PERIOD_MS);
+      i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 1000 / portTICK_PERIOD_MS);
   i2c_cmd_link_delete(cmd);
   if (error != ESP_OK) {
-    ESP_LOGW(APDS_9960_TAG, "read failed. %d", error);
+    ESP_LOGW(APDS_9960_TAG, "write failed. %d", error);
   }
   return error;
 }
 
-// read bytes by length
+void apes_9960_fetch(void* arg) {
-esp_err_t apds_9960_read_bytes_len(uint8_t command, uint8_t* data,
+  ESP_LOGI(APDS_9960_TAG, "apes_9960_fetch");
-                                   uint8_t len) {
-  i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-  i2c_master_start(cmd);
-  i2c_master_write_byte(cmd, APDS_9960_ADDRESS << 1 | I2C_MASTER_WRITE,
-                        ACK_CHECK_EN);
-  i2c_master_write_byte(cmd, command, ACK_CHECK_EN);
-  i2c_master_start(cmd);
-  i2c_master_write_byte(cmd, APDS_9960_ADDRESS << 1 | I2C_MASTER_READ,
-                        ACK_CHECK_EN);
-  for (int i = 0; i < len; i++) {
-    if (i == len - 1) {
-      i2c_master_read_byte(cmd, (uint8_t*)data + i, NACK_VAL);
-    } else {
-      i2c_master_read_byte(cmd, (uint8_t*)data + i, ACK_VAL);
-    }
-  }
-  i2c_master_stop(cmd);
-  esp_err_t error =
-      i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 100 / portTICK_PERIOD_MS);
-  i2c_cmd_link_delete(cmd);
-  if (error != ESP_OK) {
-    ESP_LOGW(APDS_9960_TAG, "read failed. %d", error);
-  }
-  return error;
-}
-
-void apds_9960_clear_all_int(void) {
-  ESP_LOGI(APDS_9960_TAG, "apds_9960_clear_all_int");
-  ESP_ERROR_CHECK_WITHOUT_ABORT(apds_9960_write_empty(APDS_9960_REG_AICLEAR));
-  ESP_ERROR_CHECK_WITHOUT_ABORT(apds_9960_write(APDS_9960_REG_GCONF4, 0x06));
-}
-
-void apds_9960_fetch(void* arg) {
-  ESP_LOGI(APDS_9960_TAG, "apds_9960_fetch");
   esp_err_t error;
   uint16_t red_raw;
   uint16_t green_raw;
   uint16_t blue_raw;
   uint16_t clear_raw;
-  uint8_t byte_buffer;
+  uint8_t proximity_raw;
-  uint8_t gesture_status_raw;
+  char red_str[10];
-  uint8_t status_raw;
+  char green_str[10];
-  char red_str[20];
+  char blue_str[10];
-  char green_str[20];
+  char clear_str[10];
-  char blue_str[20];
+  char proximity_str[10];
-  char clear_str[20];
-  char status_str[20];
-  uint8_t interrupt = 0;
   display_fill_rect(0, 2, 128, 8, 0x00);
   for (;;) {
-    if (last_apds_9960_int_time + 1000000 < esp_timer_get_time()) {
+    // Proximity
-      interrupt = gpio_get_level(APDS_9960_INT_GPIO);
+    error = apds_9960_read_byte(APDS_9960_REG_PDATA, &proximity_raw);
-      if (interrupt == 1 ||
-          last_apds_9960_int_time + 10000000 < esp_timer_get_time()) {
-        apds_9960_clear_all_int();
-      }
-    }
-
-    // clear
-    error = apds_9960_read_word(APDS_9960_REG_CDATAL, &clear_raw);
     if (error != ESP_OK) {
-      ESP_LOGW(APDS_9960_TAG, "read failed. %d", error);
+      ESP_LOGW(APDS_9960_TAG, "read proximity failed. %x", error);
     } else {
-      sprintf(clear_str, "C:% 5d", clear_raw);
+      sprintf(proximity_str, "Prox: % 5d  ", proximity_raw);
-      display_print8_str(64, 6, clear_str);
+      display_print8_str(8, 2, proximity_str);
-      ESP_LOGD(APDS_9960_TAG, "Clear: %d", clear_raw);
+      ESP_LOGD(APDS_9960_TAG, "Prox: %d %x", proximity_raw);
     }
     // red
     error = apds_9960_read_word(APDS_9960_REG_RDATAL, &red_raw);
     if (error != ESP_OK) {
-      ESP_LOGW(APDS_9960_TAG, "read failed. %d", error);
+      ESP_LOGW(APDS_9960_TAG, "read failed. %x", error);
     } else {
       sprintf(red_str, "R:% 5d", red_raw);
       display_print8_str(0, 4, red_str);
@@ -288,7 +211,7 @@ void apds_9960_fetch(void* arg) {
     // green
     error = apds_9960_read_word(APDS_9960_REG_GDATAL, &green_raw);
     if (error != ESP_OK) {
-      ESP_LOGW(APDS_9960_TAG, "read failed. %d", error);
+      ESP_LOGW(APDS_9960_TAG, "read failed. %x", error);
     } else {
       sprintf(green_str, "G:% 5d", green_raw);
       display_print8_str(64, 4, green_str);
@@ -297,228 +220,43 @@ void apds_9960_fetch(void* arg) {
     // blue
     error = apds_9960_read_word(APDS_9960_REG_BDATAL, &blue_raw);
     if (error != ESP_OK) {
-      ESP_LOGW(APDS_9960_TAG, "read failed. %d", error);
+      ESP_LOGW(APDS_9960_TAG, "read failed. %x", error);
     } else {
       sprintf(blue_str, "B:% 5d", blue_raw);
       display_print8_str(0, 6, blue_str);
       ESP_LOGD(APDS_9960_TAG, "Blue: %d", blue_raw);
     }
+    // clear
+    error = apds_9960_read_word(APDS_9960_REG_CDATAL, &clear_raw);
+    if (error != ESP_OK) {
+      ESP_LOGW(APDS_9960_TAG, "read failed. %x", error);
+    } else {
+      sprintf(clear_str, "C:% 4d", clear_raw);
+      display_print8_str(64, 6, clear_str);
+      ESP_LOGD(APDS_9960_TAG, "Clear: %d", clear_raw);
+    }
 
     vTaskDelay(pdMS_TO_TICKS(1000));
   }
   display_fill_rect(0, 2, 128, 8, 0x00);
 }
 
-void apds_9960_auto_fetch() {
+void apes_9960_auto_fetch() {
   if (is_apds_9960_online == 0) {
     return;
   }
-  xTaskCreate(apds_9960_fetch, "APDS-9960-fetch", 2048, NULL, 10, NULL);
+  xTaskCreate(apes_9960_fetch, "APDS-9960-fetch", 2048, NULL, 10, NULL);
 }
 
-void apds_9960_read_gesture() {
+void apes_9960_init() {
-  ESP_LOGI(APDS_9960_TAG, "apes_9960_gesture_fetch");
-  uint8_t byte_buffer;
-  esp_err_t error;
-  uint32_t gesture_values_raw_arr[32];
-  char gesture_values_str_arr[20];
-
-  error = apds_9960_read_byte(APDS_9960_REG_GSTATUS, &byte_buffer);
-  if (error != ESP_OK) {
-    ESP_LOGW(APDS_9960_TAG, "read APDS_9960_REG_GSTATUS failed. %d", error);
-    return;
-  }
-  ESP_LOGD(APDS_9960_TAG, "APDS-9960 interrupt. status: %x", byte_buffer);
-  if (!(byte_buffer & APDS_9960_GVALID)) {
-    ESP_LOGI(APDS_9960_TAG, "Gesture no valid");
-    return;
-  }
-
-  ESP_LOGD(APDS_9960_TAG, "Gesture interrupt");
-  error = apds_9960_read_byte(APDS_9960_REG_GFLVL, &byte_buffer);
-  if (error != ESP_OK) {
-    ESP_LOGW(APDS_9960_TAG, "read APDS_9960_REG_GFLVL failed. %d", error);
-    apds_9960_write(APDS_9960_REG_GCONF4, 0x06);
-    return;
-  }
-  if (byte_buffer < 4) {
-    ESP_LOGD(APDS_9960_TAG, "Gesture FIFO level too low: %d", byte_buffer);
-    apds_9960_write(APDS_9960_REG_GCONF4, 0x06);
-    return;
-  }
-  ESP_LOGD(APDS_9960_TAG, "Gesture FIFO Level: %d", byte_buffer);
-
-  error = apds_9960_read_bytes_len(
-      APDS_9960_REG_GFIFO_U, (uint8_t*)gesture_values_raw_arr, byte_buffer * 4);
-  apds_9960_write(APDS_9960_REG_GCONF4, 0x06);
-
-  if (error != ESP_OK) {
-    ESP_LOGW(APDS_9960_TAG, "read APDS_9960_REG_GFIFO(len: %d) failed. % d",
-             byte_buffer * 4, error);
-  } else {
-    int16_t before_ud = 0, before_lr = 0, after_ud = 0, after_lr = 0;
-    int16_t u = 0, d = 0, l = 0, r = 0;
-
-    uint8_t last_2_index = byte_buffer - 2;
-
-    // head 2
-    for (int i = 0; i < 2; i++) {
-      u = gesture_values_raw_arr[i] & 0xff;
-      d = gesture_values_raw_arr[i] >> 8 & 0xff;
-      l = gesture_values_raw_arr[i] >> 16 & 0xff;
-      r = gesture_values_raw_arr[i] >> 24 & 0xff;
-      before_ud += (u - d) * 100 / u + d;
-      before_lr += (l - r) * 100 / l + r;
-    }
-
-    // last 2
-    for (int i = last_2_index; i < byte_buffer; i++) {
-      u = gesture_values_raw_arr[i] & 0xff;
-      d = gesture_values_raw_arr[i] >> 8 & 0xff;
-      l = gesture_values_raw_arr[i] >> 16 & 0xff;
-      r = gesture_values_raw_arr[i] >> 24 & 0xff;
-      after_ud += (u - d) * 100 / u + d;
-      after_lr += (l - r) * 100 / l + r;
-    }
-
-    for (int i = 0; i < byte_buffer; i++) {
-      if (i < 2) {
-        u = gesture_values_raw_arr[i] & 0xff;
-        d = gesture_values_raw_arr[i] >> 8 & 0xff;
-        l = gesture_values_raw_arr[i] >> 16 & 0xff;
-        r = gesture_values_raw_arr[i] >> 24 & 0xff;
-        before_ud += (u - d) * 100 / u + d;
-        before_lr += (l - r) * 100 / l + r;
-      } else if (i >= last_2_index) {
-        u = gesture_values_raw_arr[i] & 0xff;
-        d = gesture_values_raw_arr[i] >> 8 & 0xff;
-        l = gesture_values_raw_arr[i] >> 16 & 0xff;
-        r = gesture_values_raw_arr[i] >> 24 & 0xff;
-        after_ud += (u - d) * 100 / u + d;
-        after_lr += (l - r) * 100 / l + r;
-      }
-    }
-    printf("Δud: %d, Δlr: %d \n", after_ud - before_ud, after_lr - before_lr);
-    display_fill_rect(0, 0, 128, 2, 0x00);
-
-    if (abs(after_ud - before_ud) * 2 > abs(after_lr - before_lr)) {
-      if (after_ud - before_ud < -80) {
-        display_print8_str(0, 0, "Gesture: up");
-      } else if (after_ud - before_ud > 80) {
-        display_print8_str(0, 0, "Gesture: down");
-      }
-    } else {
-      if (after_lr - before_lr < -120) {
-        display_print8_str(0, 0, "Gesture: left");
-      } else if (after_lr - before_lr > 120) {
-        display_print8_str(0, 0, "Gesture: right");
-      }
-    }
-    // display_print8_str(0, 0, gesture_str);
-  }
-}
-
-void apds_9960_read_proximity() {
-  uint8_t proximity_raw;
-  char proximity_str[20];
-  esp_err_t error;
-
-  // Proximity
-  error = apds_9960_read_byte(APDS_9960_REG_PDATA, &proximity_raw);
-  if (error != ESP_OK) {
-    ESP_LOGW(APDS_9960_TAG, "read proximity failed. %x", error);
-  } else {
-    ESP_LOGD(APDS_9960_TAG, "Prox: % 5d  ", proximity_raw);
-    sprintf(proximity_str, "Prox: % 5d  ", proximity_raw);
-    display_print8_str(8, 2, proximity_str);
-  }
-}
-
-void apds_9960_int_handler(void* arg) {
-  xQueueSendFromISR(apds_9960_int_evt_queue, &arg, NULL);
-}
-
-void apds_9960_int_evt_handler() {
-  if (is_apds_9960_online == 0) {
-    return;
-  }
-
-  apds_9960_clear_all_int();
-  esp_err_t error;
-  uint8_t status_raw;
-  while (xQueueReceive(apds_9960_int_evt_queue, NULL, portMAX_DELAY)) {
-    last_apds_9960_int_time = esp_timer_get_time();
-    ESP_ERROR_RETRY(apds_9960_read_byte(APDS_9960_REG_STATUS, &status_raw), 10);
-    ESP_ERROR_RETRY(apds_9960_write_empty(APDS_9960_REG_AICLEAR), 10);
-
-    ESP_LOGD(
-        APDS_9960_TAG, "[apds_9960_int_evt_handler]  status %d%d%d%d %d%d%d%d",
-        (status_raw >> 7) & 1, (status_raw >> 6) & 1, (status_raw >> 5) & 1,
-        (status_raw >> 4) & 1, (status_raw >> 3) & 1, (status_raw >> 2) & 1,
-        (status_raw >> 1) & 1, status_raw & 1);
-    if (status_raw & APDS_9960_PINT) {
-      apds_9960_read_proximity();
-    }
-    if (status_raw & APDS_9960_GINT) {
-      apds_9960_read_gesture();
-    }
-
-    vTaskDelay(10 / portTICK_PERIOD_MS);
-  }
-}
-
-void apds_9960_init() {
   if (is_apds_9960_online == 0) {
     ESP_LOGI(APDS_9960_TAG, "APDS-9960 is offline");
     return;
   }
   ESP_LOGI(APDS_9960_TAG, "Initializing APDS-9960");
-  // esp_log_level_set(APDS_9960_TAG, ESP_LOG_DEBUG);
-
-  gpio_config_t io_conf = {};
-
-  io_conf.mode = GPIO_MODE_INPUT;
-  io_conf.pull_up_en = 0;
-  io_conf.pull_down_en = 0;
-  io_conf.intr_type = GPIO_INTR_NEGEDGE;
-  io_conf.pin_bit_mask = 1ULL << APDS_9960_INT_GPIO;
-  gpio_config(&io_conf);
-
-  gpio_isr_handler_add(APDS_9960_INT_GPIO, apds_9960_int_handler, NULL);
-
-  // 环境光 ADC 积分时间
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_ATIME, 246));  // 27.8ms
-  // 增益
   ESP_ERROR_CHECK(
       apds_9960_write(APDS_9960_REG_CONTROL, APDS_9960_CONTROL_VALUE));
 
-  // enable gesture interrupt
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_GCONF4, 0x06));
-  // 累积的手势数据达到 4 组时触发中断
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_GCONF1, 0x40));
-  // Gesture Enter Threshold
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_GPENTH, 3));
-  // Gesture Exit Threshold
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_GEXTH, 3));
-  // Gesture Drive Strength
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_GCONF2, 0b0110000));
-
-  // // set wait time
-  // ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_WTIME, 171));
-
-  // set interrupt persistence
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_PERS, 0x44));
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_PILT, 0x80));
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_PIHT, 0x40));
-  ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_CONFIG2, 0x80));
-
-  // // enable sleep after interrupt
-  // ESP_ERROR_CHECK(apds_9960_write(APDS_9960_REG_CONFIG3, 0x10));
-
   ESP_ERROR_CHECK(
       apds_9960_write(APDS_9960_REG_ENABLE, APDS_9960_ENABLE_VALUE));
-
-  apds_9960_int_evt_queue = xQueueCreate(10, NULL);
-  xTaskCreate(apds_9960_int_evt_handler, "apds_9960_gesture_fetch", 2048, NULL,
-              10, NULL);
 }

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/common.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include "esp_log.h"
-
-#define ESP_ERROR_RETRY(action, max_retries)                      \
-  {                                                               \
-    uint8_t retry_count = 0;                                      \
-    esp_err_t error;                                              \
-    while (retry_count < max_retries) {                           \
-      error = action;                                             \
-      if (error == ESP_OK) break;                                 \
-      retry_count++;                                              \
-      ESP_LOGI("RETRY", "Retrying... (%d/%d)\n", retry_count + 1, \
-               max_retries);                                      \
-    }                                                             \
-    if (error != ESP_OK) {                                        \
-      ESP_LOGE("RETRY", "retry failed. %d", error);               \
-      ESP_ERROR_CHECK(error);                                     \
-    }                                                             \
-  }

main/hw-ms03.c

@@ -1,27 +0,0 @@
-#pragma once
-#include "driver/gpio.h"
-#include "freeRTOS/FreeRTOS.h"
-
-#define HW_MS03_INT_GPIO 6
-#define BEEP_GPIO 7
-
-void hw_ms03_int_handler(void *arg) {
-  gpio_set_level(BEEP_GPIO, gpio_get_level(HW_MS03_INT_GPIO));
-}
-
-void hw_ms03_init() {
-  gpio_config_t io_conf = {};
-
-  io_conf.mode = GPIO_MODE_INPUT;
-  io_conf.pull_up_en = 0;
-  io_conf.pull_down_en = 1;
-  io_conf.intr_type = GPIO_INTR_ANYEDGE;
-  io_conf.pin_bit_mask = 1ULL << HW_MS03_INT_GPIO;
-  gpio_config(&io_conf);
-  io_conf.mode = GPIO_MODE_OUTPUT;
-  io_conf.pin_bit_mask = 1ULL << BEEP_GPIO;
-  io_conf.pull_down_en = 0;
-  gpio_config(&io_conf);
-
-  gpio_isr_handler_add(HW_MS03_INT_GPIO, hw_ms03_int_handler, NULL);
-}

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 <= 10 && g <= 10 && b <= 10) {
+      black_count++;
+    }
     ESP_ERROR_CHECK(
         light_led_strip->set_pixel(light_led_strip, led_index, r, g, b));
   }
+
+  if (black_count > STRIP_LED_NUMBER / 4 * 3) {
+    ESP_ERROR_CHECK(light_led_strip->clear(light_led_strip, 100));
+    uint8_t r = (uint8_t)((float)100 * display_ambient_light_brightness *
+                          led_strip_red_calibration),
+            g = (uint8_t)((float)100 * display_ambient_light_brightness *
+                          led_strip_green_calibration),
+            b = (uint8_t)((float)100 * 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));
+    }
+  }
   ESP_ERROR_CHECK(light_led_strip->refresh(light_led_strip, 100));
   vTaskDelay(pdMS_TO_TICKS(10));
 }

main/main.c

@@ -1,10 +1,10 @@
 #include "apds_9960.c"
+#include "app_nvs.c"
 #include "ci_03t.c"
 #include "embedded_display.c"
 #include "esp_log.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "hw-ms03.c"
 #include "i2c.c"
 #include "light.c"
 #include "mqtt.c"
@@ -17,19 +17,16 @@
 static const char *TAG = "DisplayAmbientLight";
 
 void app_main(void) {
+  app_nvs_init();
   light_init_strip();
-
-  gpio_install_isr_service(0);
   init_i2c();
   i2c_check_slaves();
-
   init_display();
   display_print8_str(0, 0, "Ambient Light");
-  // hw_ms03_init();
+  ci_03t_init();
-  // ci_03t_init();
+  apes_9960_init();
-  apds_9960_init();
+  // apes_9960_auto_fetch();
-  apds_9960_auto_fetch();
+  // auto_fetch_temperature();
-  auto_fetch_temperature();
   pca9555_init();
   ui_input_init();
   xTaskCreate(mqtt_publish_ui_input, "mqtt_publish_ui_input", 2048, NULL, 10,

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);

main/ui_input.c

@@ -196,6 +196,8 @@ void ui_input_init(void) {
   ui_input_event = xQueueCreate(10, sizeof(s_ui_input_t));
   ui_input_raw_event = xQueueCreate(10, 0);
 
+  // install gpio isr service
+  gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT);
   // hook isr handler for specific gpio pin
   gpio_isr_handler_add(ENCODER_INT_GPIO, gpio_isr_handler, NULL);