《2023 DigiKey 汽车应用创意挑战赛》--智能车载氛围灯

walker2048

一、项目名称：

车载氛围灯

二、项目概述：

项目，旨在为车辆内部营造一个独特的氛围。通过ESP32和触摸屏，RGB LED灯条，可以在车内创造出多彩的灯光效果。这些灯光可以实现各种模式和效果，如渐变、闪烁、呼吸等。通过连接麦克风，采样麦克风数据，灯光可以根据音乐的节奏和音量进行调整，实现与音乐的同步效果。此外，还可以通过触摸屏来控制灯光的开关、颜色和模式等。

三、作品实物图

四、演示视频

视频.zip (29.3 MB, 下载次数: 8)

2024-1-30 11:45 上传

点击文件名下载附件

五、代码
5.1 触屏驱动移植代码

1. #include "cst816.h"
   
2. 
   
3. #include <driver/i2c.h>
   
4. #include <esp_log.h>
   
5. #ifdef LV_LVGL_H_INCLUDE_SIMPLE
   
6. #include <lvgl.h>
   
7. #else
   
8. #include <lvgl/lvgl.h>
   
9. #endif
   
10. 
    
11. #include "../lvgl_i2c_conf.h"
    
12. #include "tp_i2c.h"
    
13. 
    
14. #define TAG "CST816T"
    
15. 
    
16. static cst816t_status_t cst816t_status;
    
17. uint8_t cst816t_read_len(uint16_t reg_addr, uint8_t *data, uint8_t len) {
    
18.   uint8_t res = 0;
    
19.   res = i2c_master_write_read_device(TOUCH_I2C_PORT, CST816T_ADDR, ?_addr, 1,
    
20.                                      data, len, 1000 / portTICK_PERIOD_MS);
    
21. 
    
22.   return res;
    
23. }
    
24. 
    
25. uint8_t cst816t_chipId(void) { return 0; }
    
26. static esp_err_t cst816t_get_touch_points_num(uint8_t *touch_points_num) {
    
27.   uint8_t res = 0;
    
28.   res = cst816t_read_len(0x02, touch_points_num, 1);
    
29.   return res;
    
30. }
    
31. 
    
32. esp_err_t cst816t_read_pos(uint8_t *touch_points_num, uint16_t *x,
    
33.                            uint16_t *y) {
    
34.   uint8_t data[4];
    
35. 
    
36.   cst816t_get_touch_points_num(touch_points_num);
    
37.   if (0 == *touch_points_num) {
    
38.     *x = 0;
    
39.     *y = 0;
    
40.     return 1;
    
41.   } else {
    
42.     cst816t_read_len(0x03, data, 4);
    
43. 
    
44.     *x = ((data[0] & 0x0f) << 8) | data[1];
    
45.     *y = ((data[2] & 0x0f) << 8) | data[3];
    
46.   }
    
47. 
    
48.   return ESP_OK;
    
49. }
    
50. 
    
51. esp_err_t cst816t_i2c_read(uint8_t slave_addr, uint16_t register_addr,
    
52.                            uint8_t *data_buf, uint8_t len) {
    
53.   i2c_cmd_handle_t i2c_cmd = i2c_cmd_link_create();
    
54. 
    
55.   i2c_master_start(i2c_cmd);
    
56.   i2c_master_write_byte(i2c_cmd, (slave_addr << 1) | I2C_MASTER_WRITE, true);
    
57.   i2c_master_write_byte(i2c_cmd, register_addr, I2C_MASTER_ACK);
    
58. 
    
59.   i2c_master_start(i2c_cmd);
    
60.   i2c_master_write_byte(i2c_cmd, (slave_addr << 1) | I2C_MASTER_READ, true);
    
61. 
    
62.   i2c_master_read_byte(i2c_cmd, data_buf, I2C_MASTER_NACK);
    
63.   i2c_master_stop(i2c_cmd);
    
64.   esp_err_t ret =
    
65.       i2c_master_cmd_begin(TOUCH_I2C_PORT, i2c_cmd, 1000 / portTICK_PERIOD_MS);
    
66.   i2c_cmd_link_delete(i2c_cmd);
    
67.   return ret;
    
68. }
    
69. 
    
70. esp_err_t cst816t_i2c_write8(uint8_t slave_addr, uint16_t register_addr,
    
71.                              uint8_t data) {
    
72.   i2c_cmd_handle_t i2c_cmd = i2c_cmd_link_create();
    
73. 
    
74.   i2c_master_start(i2c_cmd);
    
75.   i2c_master_write_byte(i2c_cmd, (slave_addr << 1) | I2C_MASTER_WRITE, true);
    
76.   i2c_master_write_byte(i2c_cmd, register_addr, I2C_MASTER_ACK);
    
77. 
    
78.   i2c_master_start(i2c_cmd);
    
79.   i2c_master_write_byte(i2c_cmd, data, true);
    
80. 
    
81.   i2c_master_stop(i2c_cmd);
    
82.   esp_err_t ret =
    
83.       i2c_master_cmd_begin(TOUCH_I2C_PORT, i2c_cmd, 1000 / portTICK_PERIOD_MS);
    
84.   i2c_cmd_link_delete(i2c_cmd);
    
85.   return ret;
    
86. }
    
87. 
    
88. void cst816t_init(uint16_t dev_addr) {
    
89.   if (!cst816t_status.inited) {
    
90.     cst816t_status.i2c_dev_addr = dev_addr;
    
91.     uint8_t data_buf[10];
    
92.     esp_err_t ret;
    
93. 
    
94.     ESP_LOGI(TAG, "Checking for CST816T Touch Controller ");
    
95. 
    
96.     if ((ret = cst816t_i2c_read(dev_addr, 0x15, &data_buf, 1) != ESP_OK)) {
    
97.       vTaskDelay(pdMS_TO_TICKS(10));
    
98.       ESP_LOGE(TAG, "Error reading from device: %s",
    
99.                esp_err_to_name(ret)); // Only show error the first time
    
100.                                       // return;
     
101.     }
     
102.     if ((ret = cst816t_i2c_read(dev_addr, 0xa7, &data_buf, 1) != ESP_OK)) {
     
103.       ESP_LOGE(TAG, "Error reading from device: %s",
     
104.                esp_err_to_name(ret)); // Only show error the first time
     
105.       ESP_LOGE(TAG, "device ID: %02x", data_buf[0]);
     
106.       // return;
     
107.     }
     
108. 
     
109.     cst816t_status.inited = true;
     
110.   }
     
111. }
     
112. 
     
113. bool cst816t_read(lv_indev_drv_t *drv, lv_indev_data_t *data) {
     
114. 
     
115.   uint8_t touch_points_num = 0;
     
116.   uint16_t x = 0;
     
117.   uint16_t y = 0;
     
118. 
     
119.   cst816t_read_pos(&touch_points_num, &x, &y);
     
120. 
     
121. #if CONFIG_LV_TOUCH_INVERT_X
     
122.   x = LV_HOR_RES_MAX - x;
     
123. #endif
     
124. #if 1
     
125.   y = 280 - y;
     
126. #endif
     
127. #if 1
     
128.   int16_t swap_buf = x;
     
129.   x = y;
     
130.   y = swap_buf;
     
131. #endif
     
132. 
     
133.   data->point.x = x;
     
134.   data->point.y = y;
     
135.   if (touch_points_num > 0) {
     
136.     data->state = LV_INDEV_STATE_PR;
     
137.     ESP_LOGI(TAG, "X=%u Y=%u", data->point.x, data->point.y);
     
138.     ESP_LOGV(TAG, "X=%u Y=%u", data->point.x, data->point.y);
     
139.   } else {
     
140.     data->state = LV_INDEV_STATE_REL;
     
141.   }
     
142. 
     
143.   return false;
     
144. }

复制代码

5.2 测试用的LVGL代码

1. /* LVGL Example project
   
2. *
   
3. * Basic project to test LVGL on ESP32 based projects.
   
4. *
   
5. * This example code is in the Public Domain (or CC0 licensed, at your option.)
   
6. *
   
7. * Unless required by applicable law or agreed to in writing, this
   
8. * software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   
9. * CONDITIONS OF ANY KIND, either express or implied.
   
10. */
    
11. #include <stdbool.h>
    
12. #include <stdio.h>
    
13. #include <stdlib.h>
    
14. #include <string.h>
    
15. 
    
16. #include "freertos/FreeRTOS.h"
    
17. #include "freertos/task.h"
    
18. #include "esp_freertos_hooks.h"
    
19. #include "freertos/semphr.h"
    
20. #include "esp_timer.h"
    
21. #include "esp_system.h"
    
22. #include "driver/gpio.h"
    
23. 
    
24. /* Littlevgl specific */
    
25. #ifdef LV_LVGL_H_INCLUDE_SIMPLE
    
26. #include "lvgl.h"
    
27. #else
    
28. #include "lvgl/lvgl.h"
    
29. #endif
    
30. 
    
31. #include "lvgl_helpers.h"
    
32. 
    
33. #ifndef CONFIG_LV_TFT_DISPLAY_MONOCHROME
    
34.     #if defined CONFIG_LV_USE_DEMO_WIDGETS
    
35.         #include "lv_examples/src/lv_demo_widgets/lv_demo_widgets.h"
    
36.     #elif defined CONFIG_LV_USE_DEMO_KEYPAD_AND_ENCODER
    
37.         #include "lv_examples/src/lv_demo_keypad_encoder/lv_demo_keypad_encoder.h"
    
38.     #elif defined CONFIG_LV_USE_DEMO_BENCHMARK
    
39.         #include "lv_examples/src/lv_demo_benchmark/lv_demo_benchmark.h"
    
40.     #elif defined CONFIG_LV_USE_DEMO_STRESS
    
41.         #include "lv_examples/src/lv_demo_stress/lv_demo_stress.h"
    
42.     #else
    
43.         #error "No demo application selected."
    
44.     #endif
    
45. #endif
    
46. 
    
47. /*********************
    
48. *      DEFINES
    
49. *********************/
    
50. #define TAG "demo"
    
51. #define LV_TICK_PERIOD_MS 1
    
52. 
    
53. /**********************
    
54. *  STATIC PROTOTYPES
    
55. **********************/
    
56. static void lv_tick_task(void *arg);
    
57. static void guiTask(void *pvParameter);
    
58. static void create_demo_application(void);
    
59. 
    
60. /**********************
    
61. *  STATIC VARIABLES
    
62. **********************/
    
63. 
    
64. static void event_handler(lv_obj_t *obj, lv_event_t event) {
    
65.   if (event == LV_EVENT_VALUE_CHANGED) {
    
66.     int n = lv_dropdown_get_selected(obj);
    
67.     printf("num: %d\n", n);
    
68.   }
    
69. }
    
70. 
    
71. void lv_sport(void) {
    
72.   /*Create a normal drop down list*/
    
73.   // lv_obj_t *ddlist = lv_dropdown_create(lv_scr_act(), NULL);
    
74.   //   lv_dropdown_set_options(ddlist, "1\n2\n3\n4");
    
75. 
    
76.   // lv_obj_align(ddlist, NULL, LV_ALIGN_IN_TOP_MID, 0, 20);
    
77.   // lv_obj_set_event_cb(ddlist, event_handler);
    
78. 
    
79.   /*Create a Tab view object*/
    
80. 
    
81.   lv_obj_t *tabview;
    
82.   tabview = lv_tabview_create(lv_scr_act(), NULL);
    
83. 
    
84.   /*Add 3 tabs (the tabs are page (lv_page) and can be scrolled*/
    
85.   lv_obj_t *tab1 = lv_tabview_add_tab(tabview, "计划健身");
    
86. 
    
87.   /*Add content to the tabs*/
    
88.   lv_obj_t *dr_sport = lv_dropdown_create(tab1, NULL);
    
89.   lv_obj_set_width(
    
90.       dr_sport,
    
91.       lv_obj_get_width_grid(tab1, 3, 1));
    
92.   lv_dropdown_set_options(dr_sport, "Rainbow\n"
    
93.                                     "Comet\n"
    
94.                                     "Sparkle");
    
95.   lv_obj_align(dr_sport, NULL, LV_ALIGN_IN_TOP_LEFT, 0, 10);
    
96. }
    
97. 
    
98. /**********************
    
99. *   APPLICATION MAIN
    
100. **********************/
     
101. void app_main() {
     
102. 
     
103.     /* If you want to use a task to create the graphic, you NEED to create a Pinned task
     
104.      * Otherwise there can be problem such as memory corruption and so on.
     
105.      * NOTE: When not using Wi-Fi nor Bluetooth you can pin the guiTask to core 0 */
     
106.     xTaskCreatePinnedToCore(guiTask, "gui", 4096*2, NULL, 0, NULL, 1);
     
107. }
     
108. 
     
109. /* Creates a semaphore to handle concurrent call to lvgl stuff
     
110. * If you wish to call *any* lvgl function from other threads/tasks
     
111. * you should lock on the very same semaphore! */
     
112. SemaphoreHandle_t xGuiSemaphore;
     
113. 
     
114. static void guiTask(void *pvParameter) {
     
115. 
     
116.     (void) pvParameter;
     
117.     xGuiSemaphore = xSemaphoreCreateMutex();
     
118. 
     
119.     lv_init();
     
120. 
     
121.     /* Initialize SPI or I2C bus used by the drivers */
     
122.     lvgl_driver_init();
     
123. 
     
124.     lv_color_t* buf1 = heap_caps_malloc(DISP_BUF_SIZE * sizeof(lv_color_t), MALLOC_CAP_DMA);
     
125.     assert(buf1 != NULL);
     
126. 
     
127.     /* Use double buffered when not working with monochrome displays */
     
128. #ifndef CONFIG_LV_TFT_DISPLAY_MONOCHROME
     
129.     lv_color_t* buf2 = heap_caps_malloc(DISP_BUF_SIZE * sizeof(lv_color_t), MALLOC_CAP_DMA);
     
130.     assert(buf2 != NULL);
     
131. #else
     
132.     static lv_color_t *buf2 = NULL;
     
133. #endif
     
134. 
     
135.     static lv_disp_buf_t disp_buf;
     
136. 
     
137.     uint32_t size_in_px = DISP_BUF_SIZE;
     
138. 
     
139. #if defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820         \
     
140.     || defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A    \
     
141.     || defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_UC8151D     \
     
142.     || defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SSD1306
     
143. 
     
144.     /* Actual size in pixels, not bytes. */
     
145.     size_in_px *= 8;
     
146. #endif
     
147. 
     
148.     /* Initialize the working buffer depending on the selected display.
     
149.      * NOTE: buf2 == NULL when using monochrome displays. */
     
150.     lv_disp_buf_init(&disp_buf, buf1, buf2, size_in_px);
     
151. 
     
152.     lv_disp_drv_t disp_drv;
     
153.     lv_disp_drv_init(&disp_drv);
     
154.     disp_drv.flush_cb = disp_driver_flush;
     
155. 
     
156. #if defined CONFIG_DISPLAY_ORIENTATION_PORTRAIT || defined CONFIG_DISPLAY_ORIENTATION_PORTRAIT_INVERTED
     
157.     disp_drv.rotated = 1;
     
158. #endif
     
159. 
     
160.     /* When using a monochrome display we need to register the callbacks:
     
161.      * - rounder_cb
     
162.      * - set_px_cb */
     
163. #ifdef CONFIG_LV_TFT_DISPLAY_MONOCHROME
     
164.     disp_drv.rounder_cb = disp_driver_rounder;
     
165.     disp_drv.set_px_cb = disp_driver_set_px;
     
166. #endif
     
167. 
     
168.     disp_drv.buffer = &disp_buf;
     
169.     lv_disp_drv_register(&disp_drv);
     
170. 
     
171.     /* Register an input device when enabled on the menuconfig */
     
172. #if CONFIG_LV_TOUCH_CONTROLLER != TOUCH_CONTROLLER_NONE
     
173.     lv_indev_drv_t indev_drv;
     
174.     lv_indev_drv_init(&indev_drv);
     
175.     indev_drv.read_cb = touch_driver_read;
     
176.     indev_drv.type = LV_INDEV_TYPE_POINTER;
     
177.     lv_indev_drv_register(&indev_drv);
     
178. #endif
     
179. 
     
180.     /* Create and start a periodic timer interrupt to call lv_tick_inc */
     
181.     const esp_timer_create_args_t periodic_timer_args = {
     
182.         .callback = &lv_tick_task,
     
183.         .name = "periodic_gui"
     
184.     };
     
185.     esp_timer_handle_t periodic_timer;
     
186.     ESP_ERROR_CHECK(esp_timer_create(&periodic_timer_args, &periodic_timer));
     
187.     ESP_ERROR_CHECK(esp_timer_start_periodic(periodic_timer, LV_TICK_PERIOD_MS * 1000));
     
188. 
     
189.     /* Create the demo application */
     
190.     lv_sport();
     
191. 
     
192.     while (1) {
     
193.         /* Delay 1 tick (assumes FreeRTOS tick is 10ms */
     
194.         vTaskDelay(pdMS_TO_TICKS(10));
     
195. 
     
196.         /* Try to take the semaphore, call lvgl related function on success */
     
197.         if (pdTRUE == xSemaphoreTake(xGuiSemaphore, portMAX_DELAY)) {
     
198.             lv_task_handler();
     
199.             xSemaphoreGive(xGuiSemaphore);
     
200.        }
     
201.     }
     
202. 
     
203.     /* A task should NEVER return */
     
204.     free(buf1);
     
205. #ifndef CONFIG_LV_TFT_DISPLAY_MONOCHROME
     
206.     free(buf2);
     
207. #endif
     
208.     vTaskDelete(NULL);
     
209. }
     
210. 
     
211. static void lv_tick_task(void *arg) {
     
212.     (void) arg;
     
213. 
     
214.     lv_tick_inc(LV_TICK_PERIOD_MS);
     
215. }
     

复制代码

5.3 测试RGB灯的Python代码

1. # SPDX-FileCopyrightText: 2021 Kattni Rembor for Adafruit Industries
   
2. # SPDX-License-Identifier: MIT
   
3. 
   
4. """
   
5. This example repeatedly displays all available animations, at a five second interval.
   
6. 
   
7. For NeoPixel FeatherWing. Update pixel_pin and pixel_num to match your wiring if using
   
8. a different form of NeoPixels.
   
9. 
   
10. This example does not work on SAMD21 (M0) boards.
    
11. """
    
12. import board
    
13. import neopixel
    
14. 
    
15. from adafruit_led_animation.animation.blink import Blink
    
16. from adafruit_led_animation.animation.comet import Comet
    
17. from adafruit_led_animation.animation.sparkle import Sparkle
    
18. from adafruit_led_animation.animation.rainbow import Rainbow
    
19. from adafruit_led_animation.color import PURPLE, WHITE, AMBER, JADE, MAGENTA, ORANGE
    
20. 
    
21. # Update to match the pin connected to your NeoPixels
    
22. pixel_pin = board.D6
    
23. # Update to match the number of NeoPixels you have connected
    
24. pixel_num = 16
    
25. 
    
26. pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.5, auto_write=False)
    
27. 
    
28. blink = Blink(pixels, speed=0.5, color=JADE)
    
29. colorcycle = ColorCycle(pixels, speed=0.4, colors=[MAGENTA, ORANGE])
    
30. comet = Comet(pixels, speed=0.01, color=PURPLE, tail_length=10, bounce=True)
    
31. sparkle = Sparkle(pixels, speed=0.1, color=PURPLE, num_sparkles=10)
    
32. rainbow = Rainbow(pixels, speed=0.1, period=2)
    
33. 
    
34. animations = AnimationSequence(
    
35.     comet,
    
36.     blink,
    
37.     sparkle,
    
38.     rainbow,
    
39.     advance_interval=5,
    
40.     auto_clear=True,
    
41. )
    
42. 
    
43. while True:
    
44.     animations.animate()

复制代码

由于时间的原因，做完板子就没多少时间完成项目工程了，所以只能简单设计了个LVGL界面，移植触屏驱动，并且使用CircuitPython进行测试WS2812，实现一些简单的LED动画。
六、文档

文档.zip (1.35 MB, 下载次数: 5)

2024-1-29 19:57 上传

点击文件名下载附件