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

@@ -65,43 +65,43 @@ menu "MQTT Configuration"
 endmenu
 
 menu "Encoder Configuration"
-    config ENCODER_0_CLK_PIN
-        int "encoder 0 clock GPIO"
-        range 0 32
+    config ENCODER_0_CLK_PORT_IO
+        int "encoder 0 clock IO"
+        range 0 7
+        default 1
+        help
+            Encoder 0 clock io on PCA9555 port 1
+    config ENCODER_0_DT_PORT_IO
+        int "encoder 0 data IO"
+        range 0 7
         default 2
-        help
-            Encoder 0 clock pin
-    config ENCODER_0_DT_PIN
-        int "encoder 0 data GPIO"
-        range 0 32
-        default 3
         help
             Encoder 0 clock data
-    config ENCODER_0_SW_PIN
-        int "encoder 0 switch GPIO"
-        range 0 32
+    config ENCODER_0_SW_PORT_IO
+        int "encoder 0 switch IO"
+        range 0 7
+        default 0
+        help
+            Encoder 0 switch io on PCA9555 port 1
+
+    config ENCODER_1_CLK_PORT_IO
+        int "encoder 1 clock IO"
+        range 0 7
         default 4
         help
-            Encoder 0 switch pin
-
-    config ENCODER_1_CLK_PIN
-        int "encoder 1 clock GPIO"
-        range 0 32
+            Encoder 1 clock io on PCA9555 port 1
+    config ENCODER_1_DT_PORT_IO
+        int "encoder 1 data IO"
+        range 0 7
         default 5
-        help
-            Encoder 1 clock pin
-    config ENCODER_1_DT_PIN
-        int "encoder 1 data GPIO"
-        range 0 32
-        default 6
         help
             Encoder 1 clock data
-    config ENCODER_1_SW_PIN
-        int "encoder 1 switch GPIO"
-        range 0 32
-        default 7
+    config ENCODER_1_SW_PORT_IO
+        int "encoder 1 switch IO"
+        range 0 7
+        default 3
         help
-            Encoder 1 switch pin
+            Encoder 1 switch io on PCA9555 port 1
 
 endmenu
 
@@ -109,13 +109,13 @@ menu "I2C Configuration"
     config I2C_SCL
         int "I2C SCL GPIO"
         range 0 32
-        default 8
+        default 5
         help
             I2C SCL GPIO
     config I2C_SDA
         int "I2C SDA GPIO"
         range 0 32
-        default 10
+        default 4
         help
             I2C SDA GPIO
     config I2C_NUM
@@ -146,3 +146,12 @@ 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/ambient_light.c

@@ -183,7 +183,7 @@ void ambient_light_auto_fetch() {
 
 void ambient_light_init() {
   if (is_apds_9930_online == 0) {
-    ESP_LOGI(AMBIENT_LIGHT_TAG, "AMG8833 is offline");
+    ESP_LOGI(AMBIENT_LIGHT_TAG, "APDS 9930 is offline");
     return;
   }
   ESP_LOGI(AMBIENT_LIGHT_TAG, "Initializing APDS-9930");

main/apds_9960.c

@@ -0,0 +1,524 @@
+#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
+
+// ===============================================
+// 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
+// 0x84 AILTL R/W ALS interrupt low threshold low byte --
+// 0x85 AILTH R/W ALS interrupt low threshold high byte --
+// 0x86 AIHTL R/W ALS interrupt high threshold low byte 0x00
+// 0x87 AIHTH R/W ALS interrupt high threshold high byte 0x00
+// 0x89 PILT R/W Proximity interrupt low threshold 0x00
+// 0x8B PIHT R/W Proximity interrupt high threshold 0x00
+// 0x8C PERS R/W Interrupt persistence filters (non-gesture) 0x00
+// 0x8D CONFIG1 R/W Configuration register one 0x60
+// 0x8E PPULSE R/W Proximity pulse count and length 0x40
+// 0x8F CONTROL R/W Gain control 0x00
+// 0x90 CONFIG2 R/W Configuration register two 0x01
+// 0x92 ID R Device ID ID
+// 0x93 STATUS R Device status 0x00
+// 0x94 CDATAL R Low byte of clear channel data 0x00
+// 0x95 CDATAH R High byte of clear channel data 0x00
+// 0x96 RDATAL R Low byte of red channel data 0x00
+// 0x97 RDATAH R High byte of red channel data 0x00
+// 0x98 GDATAL R Low byte of green channel data 0x00
+// 0x99 GDATAH R High byte of green channel data 0x00
+// 0x9A BDATAL R Low byte of blue channel data 0x00
+// 0x9B BDATAH R High byte of blue channel data 0x00
+// 0x9C PDATA R Proximity data 0x00
+// 0x9D POFFSET_UR R/W Proximity offset for UP and RIGHT photodiodes 0x00
+// 0x9E POFFSET_DL R/W Proximity offset for DOWN and LEFT photodiodes 0x00
+// 0x9F CONFIG3 R/W Configuration register three 0x00
+// 0xA0 GPENTH R/W Gesture proximity enter threshold 0x00
+// 0xA1 GEXTH R/W Gesture exit threshold 0x00
+// 0xA2 GCONF1 R/W Gesture configuration one 0x00
+// 0xA3 GCONF2 R/W Gesture configuration two 0x00
+// 0xA4 GOFFSET_U R/W Gesture UP offset register 0x00
+// 0xA5 GOFFSET_D R/W Gesture DOWN offset register 0x00
+// 0xA7 GOFFSET_L R/W Gesture LEFT offset register 0x00
+// 0xA9 GOFFSET_R R/W Gesture RIGHT offset register 0x00
+// 0xA6 GPULSE R/W Gesture pulse count and length 0x40
+// 0xAA GCONF3 R/W Gesture configuration three 0x00
+// 0xAB GCONF4 R/W Gesture configuration four 0x00
+// 0xAE GFLVL R Gesture FIFO level 0x00
+// 0xAF GSTATUS R Gesture status 0x00
+// 0xE4 (1) IFORCE W Force interrupt 0x00
+// 0xE5 (1) PICLEAR W Proximity interrupt clear 0x00
+// 0xE6 (1) CICLEAR W ALS clear channel interrupt clear 0x00
+// 0xE7 (1) AICLEAR W All non-gesture interrupts clear 0x00
+// 0xFC GFIFO_U R Gesture FIFO UP value 0x00
+// 0xFD GFIFO_D R Gesture FIFO DOWN value 0x00
+// 0xFE GFIFO_L R Gesture FIFO LEFT value 0x00
+// 0xFF GFIFO_R R Gesture FIFO RIGHT value 0x00
+// -----------------------------------     描述                    默认值
+#define APDS_9960_REG_ENABLE 0x80  // 状态和中断的启用              0x00
+#define APDS_9960_REG_ATIME 0x81   // ADC 积分时间                 0xff
+#define APDS_9960_REG_WTIME 0x83   // 等待时间（非手势）           0xff
+#define APDS_9960_REG_AILTL 0x84   // ALS 中断低阈值低字节         --
+#define APDS_9960_REG_AILTH 0x85   // ALS 中断低阈值高字节         --
+#define APDS_9960_REG_AIHTL 0x86   // ALS 中断高阈值低字节         0x00
+#define APDS_9960_REG_AIHTH 0x87   // ALS 中断高阈值高字节         0x00
+#define APDS_9960_REG_PILT 0x89    // 接近中断低阈值               0x00
+#define APDS_9960_REG_PIHT 0x8B    // 接近中断高阈值               0x00
+#define APDS_9960_REG_PERS 0x8C  // 中断持续性过滤器（非手势）   0x00
+#define APDS_9960_REG_CONFIG1 0x8D  // 配置寄存器一                 0x60
+#define APDS_9960_REG_PPULSE 0x8E  // 接近脉冲计数和长度           0x40
+#define APDS_9960_REG_CONTROL 0x8F  // 增益控制                     0x00
+#define APDS_9960_REG_CONFIG2 0x90  // 配置寄存器二                 0x01
+#define APDS_9960_REG_ID 0x92       // 设备 ID                      ID
+#define APDS_9960_REG_STATUS 0x93   // 设备状态                     0x00
+#define APDS_9960_REG_CDATAL 0x94  // 清除通道数据低字节           0x00
+#define APDS_9960_REG_CDATAH 0x95  // 清除通道数据高字节           0x00
+#define APDS_9960_REG_RDATAL 0x96  // 红色通道数据低字节           0x00
+#define APDS_9960_REG_RDATAH 0x97  // 红色通道数据高字节           0x00
+#define APDS_9960_REG_GDATAL 0x98  // 绿色通道数据低字节           0x00
+#define APDS_9960_REG_GDATAH 0x99  // 绿色通道数据高字节           0x00
+#define APDS_9960_REG_BDATAL 0x9A  // 蓝色通道数据低字节           0x00
+#define APDS_9960_REG_BDATAH 0x9B  // 蓝色通道数据高字节           0x00
+#define APDS_9960_REG_PDATA 0x9C   // 接近数据                     0x00
+#define APDS_9960_REG_POFFSET_UR 0x9D  // 接近偏移量上和右             0x00
+#define APDS_9960_REG_POFFSET_DL 0x9E  // 接近偏移量下和左             0x00
+#define APDS_9960_REG_CONFIG3 0x9F  // 配置寄存器三                 0x00
+#define APDS_9960_REG_GPENTH 0xA0   // 手势进入阈值                 0x28
+#define APDS_9960_REG_GEXTH 0xA1    // 手势退出阈值                 0x1E
+#define APDS_9960_REG_GCONF1 0xA2   // 手势配置寄存器一             0x40
+#define APDS_9960_REG_GCONF2 0xA3   // 手势配置寄存器二             0x66
+#define APDS_9960_REG_GOFFSET_U 0xA4  // 手势偏移量上                 0x00
+#define APDS_9960_REG_GOFFSET_D 0xA5  // 手势偏移量下                 0x00
+#define APDS_9960_REG_GOFFSET_L 0xA7  // 手势偏移量左                 0x00
+#define APDS_9960_REG_GOFFSET_R 0xA9  // 手势偏移量右                 0x00
+#define APDS_9960_REG_GPULSE 0xA6  // 手势脉冲计数和长度           0xC5
+#define APDS_9960_REG_GCONF3 0xAA  // 手势配置寄存器三             0x00
+#define APDS_9960_REG_GCONF4 0xAB  // 手势配置寄存器四             0x00
+#define APDS_9960_REG_GFLVL 0xAE   // 手势 FIFO 级别               0x00
+#define APDS_9960_REG_GSTATUS 0xAF  // 手势状态                     0x00
+#define APDS_9960_REG_IFORCE 0xE4   // 强制中断                     0x00
+#define APDS_9960_REG_PICLEAR 0xE5  // 清除接近中断                 0x00
+#define APDS_9960_REG_CICLEAR 0xE6  // 清除 ALS 中断                0x00
+#define APDS_9960_REG_AICLEAR 0xE7  // 清除手势中断                 0x00
+#define APDS_9960_REG_GFIFO_U 0xFC  // 手势 FIFO 数据上             0x00
+#define APDS_9960_REG_GFIFO_D 0xFD  // 手势 FIFO 数据下             0x00
+#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_GFOV 0b00000010    // GFOV
+#define APDS_9960_PINT 0x20          // PINT
+#define APDS_9960_AINT 0x10          // AINT
+#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);
+  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_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_cmd_link_delete(cmd);
+  if (error != ESP_OK) {
+    ESP_LOGW(APDS_9960_TAG, "write failed. %d", error);
+  }
+  return error;
+}
+
+esp_err_t apds_9960_read_byte(uint8_t command, uint8_t* data) {
+  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);
+  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_cmd_link_delete(cmd);
+  if (error != ESP_OK) {
+    ESP_LOGW(APDS_9960_TAG, "read failed. %d", error);
+  }
+  return error;
+}
+
+// read word
+esp_err_t apds_9960_read_word(uint8_t command, uint16_t* data) {
+  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);
+  i2c_master_read_byte(cmd, (uint8_t*)data, ACK_VAL);
+  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_cmd_link_delete(cmd);
+  if (error != ESP_OK) {
+    ESP_LOGW(APDS_9960_TAG, "read failed. %d", error);
+  }
+  return error;
+}
+
+// read bytes by length
+esp_err_t apds_9960_read_bytes_len(uint8_t command, uint8_t* data,
+                                   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 gesture_status_raw;
+  uint8_t status_raw;
+  char red_str[20];
+  char green_str[20];
+  char blue_str[20];
+  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()) {
+      interrupt = gpio_get_level(APDS_9960_INT_GPIO);
+      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);
+    } else {
+      sprintf(clear_str, "C:% 5d", clear_raw);
+      display_print8_str(64, 6, clear_str);
+      ESP_LOGD(APDS_9960_TAG, "Clear: %d", clear_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);
+    } else {
+      sprintf(red_str, "R:% 5d", red_raw);
+      display_print8_str(0, 4, red_str);
+      ESP_LOGD(APDS_9960_TAG, "Red: %d", red_raw);
+    }
+    // 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);
+    } else {
+      sprintf(green_str, "G:% 5d", green_raw);
+      display_print8_str(64, 4, green_str);
+      ESP_LOGD(APDS_9960_TAG, "Green: %d", green_raw);
+    }
+    // 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);
+    } else {
+      sprintf(blue_str, "B:% 5d", blue_raw);
+      display_print8_str(0, 6, blue_str);
+      ESP_LOGD(APDS_9960_TAG, "Blue: %d", blue_raw);
+    }
+
+    vTaskDelay(pdMS_TO_TICKS(1000));
+  }
+  display_fill_rect(0, 2, 128, 8, 0x00);
+}
+
+void apds_9960_auto_fetch() {
+  if (is_apds_9960_online == 0) {
+    return;
+  }
+  xTaskCreate(apds_9960_fetch, "APDS-9960-fetch", 2048, NULL, 10, NULL);
+}
+
+void apds_9960_read_gesture() {
+  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

@@ -0,0 +1,20 @@
+#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/embedded_display.c

@@ -16,7 +16,7 @@
 void i2cWriteByte(uint8_t reg, uint8_t data) {
   i2c_cmd_handle_t cmd = i2c_cmd_link_create();
   i2c_master_start(cmd);
-  i2c_master_write_byte(cmd, I2C_ADDRESS << 1 | I2C_MASTER_WRITE, true);
+  i2c_master_write_byte(cmd, SSD1306_ADDRESS << 1 | I2C_MASTER_WRITE, true);
   i2c_master_write_byte(cmd, reg, true);
   i2c_master_write_byte(cmd, data, true);
   i2c_master_stop(cmd);
@@ -57,7 +57,9 @@ void display_set_pos(uint8_t x, uint8_t y) {
 }
 
 void display_print8_str(uint8_t x, uint8_t y, char str[]) {
-  if (!is_embedded_display_online) return;
+  if (!is_embedded_display_online) {
+    return;
+  }
   uint8_t c;
   for (uint8_t ch, ci = 0; ch = str[ci], ch != '\0'; ci++, x += 8) {
     c = ch - 0x20;

main/hw-ms03.c

@@ -0,0 +1,27 @@
+#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/i2c.c

@@ -20,13 +20,15 @@
 #define PCA9555_ADDRESS 0x20
 #define GX21M15_ADDRESS 0x48
 #define APDS_9930_ADDRESS 0x39
-#define I2C_ADDRESS 0x3c
+#define APDS_9960_ADDRESS 0x39
+#define SSD1306_ADDRESS 0x3c
 
 static const char *I2C_TAG = "APP_I2C";
 
 static uint8_t is_temperature_online = 0;
 static uint8_t is_pca9555_online = 0;
 static uint8_t is_apds_9930_online = 0;
+static uint8_t is_apds_9960_online = 0;
 static uint8_t is_embedded_display_online = 0;
 
 void init_i2c() {
@@ -71,5 +73,6 @@ void i2c_check_slaves() {
   is_temperature_online = i2c_check_slave_exists(GX21M15_ADDRESS);
   is_pca9555_online = i2c_check_slave_exists(PCA9555_ADDRESS);
   is_apds_9930_online = i2c_check_slave_exists(APDS_9930_ADDRESS);
-  is_embedded_display_online = i2c_check_slave_exists(I2C_ADDRESS);
+  is_apds_9960_online = i2c_check_slave_exists(APDS_9960_ADDRESS);
+  is_embedded_display_online = i2c_check_slave_exists(SSD1306_ADDRESS);
 }

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;
-  int8_t i = 0;
+  nvs_handle 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!", 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, red, green, blue));
+        ESP_ERROR_CHECK(light_led_strip->set_pixel(light_led_strip, j, init_r,
+                                                   init_g, init_b));
       }
       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;
-      green = green * display_ambient_light_brightness;
-      blue = blue * display_ambient_light_brightness;
+      red = red * display_ambient_light_brightness * led_strip_red_calibration;
+      green = green * 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,9 +1,11 @@
-#include "ambient_light.c"
+#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"
@@ -16,14 +18,19 @@
 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();
-  ambient_light_init();
-  ambient_light_auto_fetch();
+  apds_9960_init();
+  apds_9960_auto_fetch();
   auto_fetch_temperature();
   pca9555_init();
   ui_input_init();

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/pca9555.c

@@ -1,3 +1,4 @@
+#pragma once
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -19,8 +20,86 @@
 #define PCA95555_CMD_CONFIGURATION_PORT_0 0x06
 #define PCA95555_CMD_CONFIGURATION_PORT_1 0x07
 
+esp_err_t pca9555_write_config(uint8_t cmd_byte, uint8_t data) {
+  i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+  i2c_master_start(cmd);
+  i2c_master_write_byte(cmd, PCA9555_ADDRESS << 1 | I2C_MASTER_WRITE,
+                        ACK_CHECK_EN);
+  i2c_master_write_byte(cmd, cmd_byte, ACK_CHECK_EN);
+  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, 1000 / portTICK_PERIOD_MS);
+  i2c_cmd_link_delete(cmd);
+  if (error != ESP_OK) {
+    ESP_LOGW(PCA_9555_TAG, "write config failed. %d", error);
+  }
+  return error;
+}
 
+esp_err_t pca9555_write_output(uint8_t cmd_byte, uint8_t data) {
+  i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+  i2c_master_start(cmd);
+  i2c_master_write_byte(cmd, PCA9555_ADDRESS << 1 | I2C_MASTER_WRITE,
+                        ACK_CHECK_EN);
+  i2c_master_write_byte(cmd, cmd_byte, ACK_CHECK_EN);
+  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, 1000 / portTICK_PERIOD_MS);
+  i2c_cmd_link_delete(cmd);
+  if (error != ESP_OK) {
+    ESP_LOGW(PCA_9555_TAG, "write output failed. %d", error);
+  }
+  return error;
+}
 
+esp_err_t pca9555_read_one_input(uint8_t cmd_byte, uint8_t* data) {
+  i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+  i2c_master_start(cmd);
+  i2c_master_write_byte(cmd, PCA9555_ADDRESS << 1 | I2C_MASTER_WRITE,
+                        ACK_CHECK_EN);
+  i2c_master_write_byte(cmd, cmd_byte, ACK_CHECK_EN);
+  i2c_master_start(cmd);
+  i2c_master_write_byte(cmd, PCA9555_ADDRESS << 1 | I2C_MASTER_READ,
+                        ACK_CHECK_EN);
+  i2c_master_read_byte(cmd, data, NACK_VAL);
+  i2c_master_stop(cmd);
+  esp_err_t error =
+      i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 1000 / portTICK_PERIOD_MS);
+  i2c_cmd_link_delete(cmd);
+  if (error != ESP_OK) {
+    ESP_LOGW(PCA_9555_TAG, "read input failed. %d", error);
+  }
+  return error;
+}
+
+void pca9555_fetch(void* arg) {
+  ESP_LOGI(PCA_9555_TAG, "fetching");
+  esp_err_t error;
+  uint8_t buff;
+  char disp_str[17];
+  display_fill_rect(0, 6, 128, 8, 0x00);
+  for (;;) {
+    error = pca9555_read_one_input(PCA95555_CMD_INPUT_PORT_1, &buff);
+    if (error != ESP_OK) {
+      ESP_LOGW(PCA_9555_TAG, "read failed. %x", error);
+    } else {
+      sprintf(disp_str, "IO0: 0x%2x  ", buff);
+      display_print8_str(8, 6, disp_str);
+      ESP_LOGD(PCA_9555_TAG, "IO0: 0x%2x", buff);
+    }
+    vTaskDelay(pdMS_TO_TICKS(10));
+  }
+  display_fill_rect(0, 6, 128, 8, 0x00);
+}
+
+void pca9555_auto_fetch() {
+  if (is_apds_9930_online == 0) {
+    return;
+  }
+  xTaskCreate(pca9555_fetch, "pac05555-fetching", 2048, NULL, 10, NULL);
+}
 
 void pca9555_init() {
   if (is_pca9555_online == 0) {
@@ -28,5 +107,6 @@ void pca9555_init() {
     return;
   }
   ESP_LOGI(PCA_9555_TAG, "Initializing PCA9555");
-  // esp_log_level_set(PCA_9555_TAG, ESP_LOG_ERROR);
+  esp_log_level_set(PCA_9555_TAG, ESP_LOG_DEBUG);
+  pca9555_write_config(PCA95555_CMD_CONFIGURATION_PORT_1, 0x12);
 }

main/ui_input.c

@@ -11,66 +11,50 @@
 #include "freertos/queue.h"
 #include "freertos/task.h"
 #include "light.c"
+#include "pca9555.c"
 
-#define GPIO_OUTPUT_IO_0 5
-#define GPIO_OUTPUT_IO_1 6
-#define GPIO_OUTPUT_PIN_SEL \
-  ((1ULL << GPIO_OUTPUT_IO_0) | (1ULL << GPIO_OUTPUT_IO_1))
-#define ENCODER_0_CLK_PIN CONFIG_ENCODER_0_CLK_PIN
-#define ENCODER_0_DT_PIN CONFIG_ENCODER_0_DT_PIN
-#define ENCODER_0_SW_PIN CONFIG_ENCODER_0_SW_PIN
-#define ENCODER_0_CLK_PIN_MASK 1ULL << ENCODER_0_CLK_PIN
-#define ENCODER_0_DT_PIN_MASK 1ULL << ENCODER_0_DT_PIN
-#define ENCODER_0_SW_PIN_MASK 1ULL << ENCODER_0_SW_PIN
-#define ENCODER_1_CLK_PIN CONFIG_ENCODER_1_CLK_PIN
-#define ENCODER_1_DT_PIN CONFIG_ENCODER_1_DT_PIN
-#define ENCODER_1_SW_PIN CONFIG_ENCODER_1_SW_PIN
-#define ENCODER_1_CLK_PIN_MASK 1ULL << ENCODER_1_CLK_PIN
-#define ENCODER_1_DT_PIN_MASK 1ULL << ENCODER_1_DT_PIN
-#define ENCODER_1_SW_PIN_MASK 1ULL << ENCODER_1_SW_PIN
+#define ENCODER_0_CLK_PORT_IO CONFIG_ENCODER_0_CLK_PORT_IO
+#define ENCODER_0_DT_PORT_IO CONFIG_ENCODER_0_DT_PORT_IO
+#define ENCODER_0_SW_PORT_IO CONFIG_ENCODER_0_SW_PORT_IO
+#define ENCODER_1_CLK_PORT_IO CONFIG_ENCODER_1_CLK_PORT_IO
+#define ENCODER_1_DT_PORT_IO CONFIG_ENCODER_1_DT_PORT_IO
+#define ENCODER_1_SW_PORT_IO CONFIG_ENCODER_1_SW_PORT_IO
+#define ENCODER_INT_GPIO GPIO_NUM_3
 #define ESP_INTR_FLAG_DEFAULT 0
 
-#define NOT_ROTATING -1
-#define CLOCKWISE 1
-#define COUNTER_CLOCKWISE 0
+#define RISING_EDGE_NOT_ROTATING 0b00000000
+#define RISING_EDGE_CLOCKWISE 0b10000000
+#define RISING_EDGE_COUNTER_CLOCKWISE 0b11000000
+#define RISING_EDGE_ROTATING_MASK 0b11000000
+
+#define FALLING_EDGE_NOT_ROTATING 0b00000000
+#define FALLING_EDGE_CLOCKWISE 0b00100000
+#define FALLING_EDGE_COUNTER_CLOCKWISE 0b00110000
+#define FALLING_EDGE_ROTATING_MASK 0b00110000
 
 static const char *UI_INPUT_TAG = "UiInput";
 
 static xQueueHandle ui_input_event = NULL;
 static xQueueHandle ui_input_raw_event = NULL;
 
-static int8_t rising_edge_rotation_direction = NOT_ROTATING;
-static int8_t falling_edge_rotation_direction = NOT_ROTATING;
+typedef struct encoder_state {
+  e_ui_input_raw_key_t key;
+  uint8_t bits;   // rising_edge_rotation_direction,
+                  // falling_edge_rotation_direction, dt, clk, sw
+  uint8_t value;  // dt, clk, sw
+} encoder_state_t;
 
-uint8_t input_key;
+static encoder_state_t encoder_0_state = {.key = ui_input_raw_key_encoder_0,
+                                          .bits = 0};
+static encoder_state_t encoder_1_state = {.key = ui_input_raw_key_encoder_1,
+                                          .bits = 0};
+
+uint8_t level_byte;
+int8_t delta = 0;
+char changing_str[12] = "NC";
 
 static void IRAM_ATTR gpio_isr_handler(void *arg) {
-  input_key = (e_ui_input_raw_key_t)arg;
-
-  switch (input_key) {
-    case ui_input_raw_key_encoder_0: {
-      s_ui_input_raw_t event = {
-          .key = input_key,
-          .value = (gpio_get_level(ENCODER_0_SW_PIN) << 2) |
-                   (gpio_get_level(ENCODER_0_CLK_PIN) << 1) |
-                   (gpio_get_level(ENCODER_0_DT_PIN)),
-      };
-      xQueueSendFromISR(ui_input_raw_event, &event, NULL);
-      break;
-    }
-    case ui_input_raw_key_encoder_1: {
-      s_ui_input_raw_t event = {
-          .key = input_key,
-          .value = (gpio_get_level(ENCODER_1_SW_PIN) << 2) |
-                   (gpio_get_level(ENCODER_1_CLK_PIN) << 1) |
-                   (gpio_get_level(ENCODER_1_DT_PIN)),
-      };
-      xQueueSendFromISR(ui_input_raw_event, &event, NULL);
-      break;
-    }
-    default:
-      return;
-  }
+  xQueueSendFromISR(ui_input_raw_event, NULL, NULL);
 }
 
 static void ui_input_update_embedded_display(void *arg) {
@@ -111,91 +95,87 @@ static void ui_input_update_embedded_display(void *arg) {
   }
 }
 
-static void ui_input_raw_handler(void *arg) {
-  s_ui_input_raw_t input;
-  uint8_t clk_level;
-  uint8_t dt_level;
-  uint8_t sw_level;
-  int8_t delta = 0;
-  char changing_str[12] = "NC";
-  for (;;) {
-    if (xQueueReceive(ui_input_raw_event, &input, portMAX_DELAY)) {
-      sw_level = input.value >> 2 & 1;
-      clk_level = input.value >> 1 & 1;
-      dt_level = input.value & 1;
-      if (clk_level) {
-        rising_edge_rotation_direction = dt_level == 0;
-        if (falling_edge_rotation_direction == rising_edge_rotation_direction) {
-          if (rising_edge_rotation_direction) {
-            delta = 1;
-          } else {
-            delta = -1;
-          }
-          falling_edge_rotation_direction = NOT_ROTATING;
-        } else {
-          delta = 0;
-          if (falling_edge_rotation_direction != NOT_ROTATING) {
-            rising_edge_rotation_direction = NOT_ROTATING;
-          }
-        }
+static void encoder_value_change(encoder_state_t *state) {
+  if ((state->value >> 1 & 1) == (state->bits >> 1 & 1)) {
+    return;
+  }
+
+  state->bits = (state->bits & 0b11111000) | (state->value & 0b111);
+  if (state->value >> 1 & 1) {
+    state->bits = (state->bits & (~RISING_EDGE_ROTATING_MASK)) | 0x80 |
+                  ~(state->value >> 2 & 1) << 6;
+    if (((state->bits & FALLING_EDGE_ROTATING_MASK) >> 4) ==
+        ((state->bits & RISING_EDGE_ROTATING_MASK) >> 6)) {
+      if ((state->bits & RISING_EDGE_ROTATING_MASK) == RISING_EDGE_CLOCKWISE) {
+        delta = -1;
       } else {
-        falling_edge_rotation_direction = dt_level;
-        if (rising_edge_rotation_direction == falling_edge_rotation_direction) {
-          if (falling_edge_rotation_direction) {
-            delta = 1;
-          } else {
-            delta = -1;
-          }
-          rising_edge_rotation_direction = NOT_ROTATING;
-
-        } else {
-          delta = 0;
-          if (rising_edge_rotation_direction != NOT_ROTATING) {
-            falling_edge_rotation_direction = NOT_ROTATING;
-          }
-        }
+        delta = 1;
       }
-
-      if (delta == 0) {
-        continue;
+      state->bits = (state->bits & (~FALLING_EDGE_ROTATING_MASK)) |
+                    FALLING_EDGE_NOT_ROTATING;
+    } else {
+      delta = 0;
+      if ((state->bits & FALLING_EDGE_ROTATING_MASK) !=
+          FALLING_EDGE_NOT_ROTATING) {
+        state->bits = (state->bits & (~FALLING_EDGE_ROTATING_MASK)) |
+                      FALLING_EDGE_NOT_ROTATING;
       }
-
-      // display_fill_rect(0, 6, 128, 8, 0);
-
-      // switch (input.key) {
-      //   case ui_input_raw_key_encoder_0:
-      //     sprintf(changing_str, "E0 %d: %u%u%u%u%u", delta,
-      //             (input.value >> 4) & 1, (input.value >> 3) & 1,
-      //             (input.value >> 2) & 1, (input.value >> 1) & 1,
-      //             (input.value) & 1);
-      //     break;
-      //   case ui_input_raw_key_encoder_1:
-      //     sprintf(changing_str, "E1 %d: %u%u%u%u%u", delta,
-      //             (input.value >> 4) & 1, (input.value >> 3) & 1,
-      //             (input.value >> 2) & 1, (input.value >> 1) & 1,
-      //             (input.value) & 1);
-      //     break;
-      //   default:
-      //     strcpy(changing_str, "NC");
-      //     break;
-      // }
-      // display_print8_str(8, 6, changing_str);
-      s_ui_input_t event = {.value = delta};
-      if (input.key == ui_input_raw_key_encoder_0) {
-        if (sw_level) {
-          event.key = ui_input_key_computer_volume;
-        } else {
-          event.key = ui_input_key_display_0_brightness;
-        }
-      } else if (input.key == ui_input_raw_key_encoder_1) {
-        if (sw_level) {
-          event.key = ui_input_key_display_ambient_lighting_level;
-          led_strip_set_brightness(display_ambient_lighting_level + delta);
-        } else {
-          event.key = ui_input_key_display_1_brightness;
-        }
+    }
+  } else {
+    state->bits = (state->bits & (~FALLING_EDGE_ROTATING_MASK)) | 0x20 |
+                  (state->value >> 2 & 1) << 4;
+    if (((state->bits & FALLING_EDGE_ROTATING_MASK) >> 4) ==
+        ((state->bits & RISING_EDGE_ROTATING_MASK) >> 6)) {
+      if ((state->bits & FALLING_EDGE_ROTATING_MASK) ==
+          FALLING_EDGE_CLOCKWISE) {
+        delta = -1;
+      } else {
+        delta = 1;
       }
-      xQueueSendFromISR(ui_input_event, &event, NULL);
+      state->bits = (state->bits & (~RISING_EDGE_ROTATING_MASK)) |
+                    RISING_EDGE_NOT_ROTATING;
+
+    } else {
+      delta = 0;
+      if ((state->bits & RISING_EDGE_ROTATING_MASK) !=
+          RISING_EDGE_NOT_ROTATING) {
+        state->bits = (state->bits & (~RISING_EDGE_ROTATING_MASK)) |
+                      RISING_EDGE_NOT_ROTATING;
+      }
+    }
+  }
+
+  if (delta == 0) {
+    return;
+  }
+
+  s_ui_input_t event = {.value = delta};
+  if (state->key == ui_input_raw_key_encoder_0) {
+    if (state->value & 1) {
+      event.key = ui_input_key_computer_volume;
+    } else {
+      event.key = ui_input_key_display_0_brightness;
+    }
+  } else if (state->key == ui_input_raw_key_encoder_1) {
+    if (state->value & 1) {
+      event.key = ui_input_key_display_ambient_lighting_level;
+      led_strip_set_brightness(display_ambient_lighting_level + delta);
+    } else {
+      event.key = ui_input_key_display_1_brightness;
+    }
+  }
+  xQueueSend(ui_input_event, &event, NULL);
+}
+
+static void ui_input_raw_handler(void *arg) {
+  for (;;) {
+    if (xQueueReceive(ui_input_raw_event, NULL, portMAX_DELAY)) {
+      pca9555_read_one_input(PCA95555_CMD_INPUT_PORT_1, &level_byte);
+
+      encoder_0_state.value = level_byte & 0x7;
+      encoder_value_change(&encoder_0_state);
+      encoder_1_state.value = level_byte >> 3 & 0x7;
+      encoder_value_change(&encoder_1_state);
     }
   }
 }
@@ -208,29 +188,16 @@ void ui_input_init(void) {
   io_conf.pull_up_en = 1;
   io_conf.pull_down_en = 0;
   // interrupt of rising edge
-  io_conf.intr_type = GPIO_INTR_ANYEDGE;
-  io_conf.pin_bit_mask = ENCODER_0_CLK_PIN_MASK | ENCODER_1_CLK_PIN_MASK;
-  gpio_config(&io_conf);
-  io_conf.intr_type = GPIO_INTR_DISABLE;
-  io_conf.pin_bit_mask = ENCODER_0_DT_PIN_MASK | ENCODER_1_DT_PIN_MASK;
-  gpio_config(&io_conf);
-  io_conf.pull_up_en = 1;
-  io_conf.pull_down_en = 0;
-  io_conf.pin_bit_mask = ENCODER_0_SW_PIN_MASK | ENCODER_1_SW_PIN_MASK;
+  io_conf.intr_type = GPIO_INTR_NEGEDGE;
+  io_conf.pin_bit_mask = 1ULL << ENCODER_INT_GPIO;
   gpio_config(&io_conf);
 
   // start encoder task
   ui_input_event = xQueueCreate(10, sizeof(s_ui_input_t));
-  ui_input_raw_event = xQueueCreate(10, sizeof(s_ui_input_raw_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_0_CLK_PIN, gpio_isr_handler,
-                       (void *)ui_input_raw_key_encoder_0);
-  // hook isr handler for specific gpio pin
-  gpio_isr_handler_add(ENCODER_1_CLK_PIN, gpio_isr_handler,
-                       (void *)ui_input_raw_key_encoder_1);
+  gpio_isr_handler_add(ENCODER_INT_GPIO, gpio_isr_handler, NULL);
 
   xTaskCreate(ui_input_update_embedded_display, "ui_input_event", 2048, NULL,
               10, NULL);