ESP32-S3驱动3.2寸透明屏：集成LVGL与Lua脚本引擎构建智能交互终端

最近在折腾 HoloCubic 这个透明显示项目时，总觉得原版的1.54寸屏幕有点“施展不开拳脚”，无论是显示信息量还是交互体验都差点意思。于是，一个大胆的想法冒了出来：能不能给它换个更大的“眼睛”，并且让它变得更“聪明”，能动态运行脚本呢？经过一番折腾，我成功将 HoloCubic 升级到了 3.2 寸透明显示屏，并为其赋予了动态运行 Lua 脚本的能力，实现了从“静态相框”到“智能交互终端”的蜕变。本文将完整记录这次改造的全过程，从硬件选型、固件编译、Lua 脚本引擎集成到 LVGL 界面开发，手把手带你复现这个项目。无论你是 ESP32 爱好者、LVGL 图形库的初学者，还是对嵌入式脚本引擎感兴趣的朋友，都能从中找到实用的代码和清晰的思路。

1. 项目背景与核心概念解析

1.1 什么是 HoloCubic？

HoloCubic 是一个基于 ESP32 系列芯片的开源透明显示项目。它的核心创意在于利用一块透明的 OLED 或 TFT 屏幕，配合 ESP32 的 Wi-Fi 功能，可以显示时间、天气、股票等信息，营造出一种悬浮在空中的未来科技感。原版项目通常使用较小的屏幕（如 1.54 寸），功能相对固定。

1.2 为什么要升级？3.2寸屏与 Lua 脚本带来的改变

原版 HoloCubic 的局限性主要体现在两方面：

1. 显示面积有限：1.54寸屏幕在显示复杂信息（如多行文本、图表）时显得局促，视觉冲击力不足。
2. 功能固化：固件功能在编译时确定，想要增加新功能（如显示自定义传感器数据、连接新的网络服务）需要重新修改、编译、烧录固件，对非开发者极不友好。

本次升级的目标正是解决这两个痛点：

• 硬件升级：采用 3.2 寸的 IPS TFT 透明显示屏。更大的屏幕带来了更丰富的视觉表现力，可以设计更复杂的 UI 布局，显示更多内容。
• 软件升级：集成 Lua 脚本引擎。Lua 是一种轻量级、高效、可嵌入的脚本语言。将其集成到固件中，意味着我们可以在不重新烧录固件的情况下，通过编写 Lua 脚本动态地：
  • 创建新的用户界面。
  • 实现新的业务逻辑（如定时任务、网络请求）。
  • 与硬件外设（如 GPIO、I2C 传感器）进行交互。
  • 实现真正的“一次开发，动态扩展”。

1.3 技术栈简介：ESP32-S3, LVGL, Lua

• ESP32-S3：本次项目主控芯片。相较于 ESP32，S3 系列拥有更强的计算能力、更多的 GPIO 和 USB OTG 支持，能更好地驱动较大屏幕和处理 Lua 脚本运行时。
• LVGL (Light and Versatile Graphics Library)：一个开源、高度可裁剪的嵌入式图形库。它提供了丰富的控件（按钮、标签、列表、图表等）和强大的图形功能，是构建精美嵌入式 GUI 的首选。我们将使用 LVGL 来绘制所有界面。
• Lua：本项目选择的脚本语言。其特点是嵌入简单、执行高效、语法简洁。通过将 Lua 解释器移植到 ESP32-S3 上，我们就能在设备上解析并执行 Lua 脚本文件。

2. 环境准备与硬件清单

在开始软件部分之前，请确保你已准备好以下硬件和软件环境。

2.1 硬件清单

接线参考 (以 SPI 接口 ST7789 屏幕为例)：请根据你的屏幕驱动芯片型号调整引脚定义。以下是一个常见连接方式：

• VCC->3.3V
• GND->GND
• SCL->GPIO 18(SPI CLK)
• SDA->GPIO 23(SPI MOSI)
• RES->GPIO 4
• DC->GPIO 2
• CS->GPIO 5
• BLK->GPIO 21(背光控制，可选)

2.2 软件环境准备

1. 操作系统：Windows 10/11, macOS 或 Linux。
2. ESP-IDF 开发框架：这是乐鑫官方的开发框架。我们将使用它来编译和烧录固件。
   • 安装方式：强烈推荐使用乐鑫官方的ESP-IDF Tools Installer(Windows) 或通过VSCode的ESP-IDF扩展进行安装，这能自动处理好环境变量和工具链。
   • 版本：建议使用ESP-IDF v5.1或更高版本，其对 ESP32-S3 的支持最完善。
3. 代码编辑器：Visual Studio Code + ESP-IDF 扩展是当前最流畅的开发体验。
4. 串口调试工具：如PuTTY(Windows)、screen(macOS/Linux) 或 VSCode 内置的串口监视器。

验证环境：打开终端 (VSCode 的 ESP-IDF Terminal)，输入idf.py --version和idf.py set-target esp32s3，确保命令可以正常执行，且目标芯片设置为esp32s3。

3. 核心原理：LVGL 与 Lua 的集成架构

理解整个系统的运行架构，有助于后续的开发和调试。

3.1 系统架构图

[上电启动] | v [ESP-IDF 初始化] -> [硬件初始化 (SPI, 屏幕)] | v [LVGL 初始化] -> [创建显示缓冲区、注册驱动] | v [Lua 虚拟机初始化] -> [注册 LVGL API 到 Lua] | v [加载并执行 主 Lua 脚本 (如 main.lua)] | v [Lua 脚本调用 LVGL API 创建 UI、设置定时器] | v [进入 LVGL 主循环] -> [处理用户输入、刷新屏幕] | v [定时器触发] -> [回调 Lua 函数更新 UI 数据]

3.2 Lua 与 LVGL 的绑定原理

我们并非让 Lua 直接操作屏幕内存，而是通过一层“绑定（Binding）”：

1. 在 C 代码 (固件) 中，我们初始化一个 Lua 虚拟机。
2. 我们编写一系列 C 函数，这些函数内部调用了 LVGL 的 C API（如lv_label_set_text,lv_obj_set_pos）。
3. 将这些 C 函数“注册”到 Lua 虚拟机中。这样，在 Lua 脚本里，就可以像调用普通 Lua 函数一样来调用这些 C 函数，从而间接操控 LVGL 对象。
4. 最终，LVGL 负责将所有对象的更改渲染到屏幕上。

这种方式的优点是：

• 性能：核心图形渲染由高效的 C 代码 (LVGL) 完成。
• 灵活性：业务逻辑和 UI 编排由易于修改的 Lua 脚本完成。
• 安全：可以通过沙箱机制限制 Lua 脚本的访问权限。

4. 实战：从零构建项目固件

让我们一步步创建一个集成了 LVGL 和 Lua 的 ESP32-S3 项目。

4.1 创建 ESP-IDF 项目

打开终端，进入你的工作目录，执行以下命令：

# 使用 ESP-IDF 的模板创建项目 idf.py create-project holocubic_3inch_lua cd holocubic_3inch_lua

4.2 添加必要的组件依赖

本项目需要额外依赖lvgl和lua组件。我们可以使用idf.py add-dependency命令，或者手动编辑idf_component.yml文件。

方法一：使用命令 (推荐)

idf.py add-dependency lvgl/lvgl==8.3.* idf.py add-dependency lua==5.4.*

方法二：编辑idf_component.yml在项目根目录创建或编辑idf_component.yml，内容如下：

dependencies: lvgl/lvgl: "^8.3" lua: "^5.4.6" # 如果你的屏幕驱动不在 LVGL 默认支持列表，可能需要添加对应的驱动组件 # 例如，对于 ST7789，可以搜索并添加社区组件

执行idf.py reconfigure让 IDF 下载并配置这些组件。

4.3 配置项目参数

运行idf.py menuconfig进入配置界面，进行关键配置：

1. 芯片选择：Component config->ESP32S3-Specific-> 确保目标芯片正确。
2. LVGL 配置：
   • Component config->LVGL->LVGL configuration
   • 设置Color depth为 16 位 (根据你的屏幕)。
   • 调整Default display buffer size(例如 1/10 屏幕大小) 和Number of buffers。
   • 在LVGL Ticker下，启用Use esp_timer to tick LVGL。
3. Lua 配置：
   • Component config->Lua-> 可以启用Enable Lua standard libraries中的基础库（如math,table,string）。为了安全，初期可以禁用io和os库。
4. SPI 配置：根据你的屏幕接线，配置 SPI 总线引脚。这通常在Hardware Settings->SPI Configuration中设置，但更常见的做法是在代码中直接定义。
5. 分区表：如果计划使用 SD 卡存储脚本，需要调整分区表 (Partition Table) 以包含FATFS或SPIFFS分区。
6. 串口输出：确保串口波特率 (Serial flasher config) 设置正确，如 115200。

4.4 编写核心驱动与初始化代码

1. 屏幕驱动 (screen_driver.c/h)这是一个关键文件，负责初始化 SPI 总线和屏幕控制器。

// screen_driver.h #pragma once #include “esp_lcd_panel_io.h” #include “esp_lcd_panel_vendor.h” #include “esp_lcd_panel_ops.h” #include “lvgl.h” esp_err_t init_screen(void); void screen_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map);

// screen_driver.c #include “screen_driver.h” #include “driver/spi_master.h” #include “driver/gpio.h” // 根据你的接线修改这些宏定义 #define LCD_HOST SPI2_HOST #define PIN_NUM_MISO -1 // 屏幕通常只接收，MISO 未连接 #define PIN_NUM_MOSI 23 #define PIN_NUM_CLK 18 #define PIN_NUM_CS 5 #define PIN_NUM_DC 2 #define PIN_NUM_RST 4 #define PIN_NUM_BCKL 21 static esp_lcd_panel_handle_t panel_handle = NULL; esp_err_t init_screen(void) { esp_err_t ret; spi_bus_config_t bus_cfg = { .miso_io_num = PIN_NUM_MISO, .mosi_io_num = PIN_NUM_MOSI, .sclk_io_num = PIN_NUM_CLK, .quadwp_io_num = -1, .quadhd_io_num = -1, .max_transfer_sz = 320 * 240 * sizeof(uint16_t), }; // 初始化 SPI 总线 ret = spi_bus_initialize(LCD_HOST, &bus_cfg, SPI_DMA_CH_AUTO); if (ret != ESP_OK) return ret; esp_lcd_panel_io_spi_config_t io_cfg = { .dc_gpio_num = PIN_NUM_DC, .cs_gpio_num = PIN_NUM_CS, .pclk_hz = 40 * 1000 * 1000, // 40 MHz .lcd_cmd_bits = 8, .lcd_param_bits = 8, .spi_mode = 0, .trans_queue_depth = 10, }; // 附加 IO 到 SPI 总线 ret = esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_HOST, &io_cfg, &panel_io); if (ret != ESP_OK) return ret; esp_lcd_panel_dev_config_t panel_cfg = { .reset_gpio_num = PIN_NUM_RST, .rgb_endian = LCD_RGB_ENDIAN_RGB, .bits_per_pixel = 16, }; // 创建屏幕面板 (以 ST7789 为例) ret = esp_lcd_new_panel_st7789(panel_io, &panel_cfg, &panel_handle); if (ret != ESP_OK) return ret; // 复位屏幕、初始化、设置方向、打开背光 esp_lcd_panel_reset(panel_handle); esp_lcd_panel_init(panel_handle); esp_lcd_panel_invert_color(panel_handle, true); // 根据屏幕需要 esp_lcd_panel_mirror(panel_handle, false, true); // 调整旋转 esp_lcd_panel_disp_on_off(panel_handle, true); gpio_set_direction(PIN_NUM_BCKL, GPIO_MODE_OUTPUT); gpio_set_level(PIN_NUM_BCKL, 1); // 打开背光 return ESP_OK; } // LVGL 显示驱动回调函数：将颜色缓冲区刷新到屏幕的特定区域 void screen_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map) { int offsetx1 = area->x1; int offsetx2 = area->x2; int offsety1 = area->y1; int offsety2 = area->y2; // 将 LVGL 的颜色缓冲区复制到屏幕的指定区域 esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map); // 通知 LVGL 刷新完成 lv_disp_flush_ready(drv); }

2. LVGL 初始化与驱动注册 (lvgl_init.c)

#include “lvgl.h” #include “screen_driver.h” static lv_disp_drv_t disp_drv; static lv_disp_t *disp; void lvgl_init(void) { // 初始化 LVGL lv_init(); // 初始化屏幕硬件 init_screen(); // 为 LVGL 分配显示缓冲区（使用内部 RAM 或外部 PSRAM） static lv_color_t buf1[320 * 10]; // 示例：10 行高度的缓冲区 static lv_color_t buf2[320 * 10]; static lv_disp_draw_buf_t draw_buf; lv_disp_draw_buf_init(&draw_buf, buf1, buf2, 320 * 10); // 初始化显示驱动 lv_disp_drv_init(&disp_drv); disp_drv.hor_res = 320; disp_drv.ver_res = 240; disp_drv.flush_cb = screen_flush; // 设置刷新回调函数 disp_drv.draw_buf = &draw_buf; disp_drv.full_refresh = 0; // 使用局部刷新 // 注册驱动，创建显示对象 disp = lv_disp_drv_register(&disp_drv); // 创建默认主题和主屏幕 lv_obj_t *scr = lv_scr_act(); lv_obj_set_style_bg_color(scr, lv_color_black(), 0); }

3. Lua 虚拟机初始化与 LVGL API 绑定 (lua_binding.c)这是连接 Lua 和 LVGL 的桥梁，代码较长，这里展示核心思路和关键函数。

#include <stdio.h> #include “lua.h” #include “lauxlib.h” #include “lualib.h” #include “lvgl.h” static lua_State *L = NULL; // 示例：将 lv_label_create 函数暴露给 Lua static int lua_lv_label_create(lua_State *L) { // 从 Lua 栈中获取父对象参数 lv_obj_t *parent = (lv_obj_t *)lua_touserdata(L, 1); if (!parent) { parent = lv_scr_act(); // 默认父对象为主屏幕 } // 调用 LVGL C API 创建标签 lv_obj_t *label = lv_label_create(parent); // 将创建的 LVGL 对象指针（作为轻量用户数据）压入 Lua 栈，返回给 Lua 脚本 lua_pushlightuserdata(L, label); return 1; // 返回值数量为 1 } // 示例：将 lv_label_set_text 函数暴露给 Lua static int lua_lv_label_set_text(lua_State *L) { // 获取参数：第一个是 label 对象，第二个是文本字符串 lv_obj_t *label = (lv_obj_t *)lua_touserdata(L, 1); const char *text = luaL_checkstring(L, 2); if (label) { lv_label_set_text(label, text); } return 0; // 无返回值 } // 注册所有 LVGL 相关函数到 Lua 全局表 `lv` 中 static void register_lvgl_api(lua_State *L) { lua_newtable(L); // 创建一个新表，作为 `lv` 模块 // 将 C 函数注册到表中 lua_pushcfunction(L, lua_lv_label_create); lua_setfield(L, -2, “label_create”); // lv.label_create lua_pushcfunction(L, lua_lv_label_set_text); lua_setfield(L, -2, “label_set_text”); // lv.label_set_text // ... 注册更多函数：obj_set_pos, obj_set_size, btn_create, etc. // 将这个表设置为全局变量 `lv` lua_setglobal(L, “lv”); } void lua_engine_init(void) { // 创建 Lua 状态机 L = luaL_newstate(); if (!L) { ESP_LOGE(“LUA”, “Failed to create Lua state”); return; } // 打开基础库（可根据需要裁剪） luaL_openlibs(L); // 注册我们自定义的 LVGL API register_lvgl_api(L); ESP_LOGI(“LUA”, “Lua engine initialized”); } // 从文件系统加载并执行一个 Lua 脚本 void lua_run_script(const char *path) { if (!L) return; int ret = luaL_dofile(L, path); if (ret != LUA_OK) { const char *err = lua_tostring(L, -1); ESP_LOGE(“LUA”, “Script error: %s”, err); } } void lua_engine_deinit(void) { if (L) { lua_close(L); L = NULL; } }

4. 主程序入口 (main.c)将以上所有模块整合起来。

#include “freertos/FreeRTOS.h” #include “freertos/task.h” #include “esp_log.h” #include “lvgl.h” #include “lvgl_init.h” #include “lua_binding.h” static const char *TAG = “MAIN”; void app_main(void) { ESP_LOGI(TAG, “HoloCubic 3.2‘’ Lua Project Start!”); // 1. 初始化 LVGL 和屏幕 lvgl_init(); // 2. 初始化 Lua 引擎 lua_engine_init(); // 3. 加载并执行主 Lua 脚本 // 假设脚本存储在 SPIFFS 文件系统的 /spiffs/main.lua lua_run_script(“/spiffs/main.lua”); // 4. 创建 LVGL 定时器任务（负责调用 lv_timer_handler） xTaskCreate(lvgl_timer_task, “lvgl_timer”, 4096, NULL, 5, NULL); // 主循环（或进入低功耗模式） while (1) { vTaskDelay(pdMS_TO_TICKS(10)); // 让出 CPU 控制权 } } // LVGL 定时器任务 static void lvgl_timer_task(void *arg) { while (1) { lv_timer_handler(); // 处理 LVGL 定时器和屏幕刷新 vTaskDelay(pdMS_TO_TICKS(5)); // LVGL 推荐 5ms 左右 } }

4.5 编写第一个 Lua 脚本

在项目的main目录下，或通过 SD 卡/SPIFFS 文件系统，创建一个main.lua文件。

-- main.lua -- 这是由 ESP32 固件加载并执行的第一个 Lua 脚本 print(“[LUA] Hello from Lua script!”) -- 使用绑定的 `lv` 模块创建 UI local screen = lv.get_scr_act() -- 假设我们也绑定了这个函数 -- 创建一个标签 local label1 = lv.label_create(screen) lv.obj_set_pos(label1, 50, 50) lv.label_set_text(label1, “Hello, HoloCubic 3.2!”) -- 创建一个按钮 local btn1 = lv.btn_create(screen) lv.obj_set_pos(btn1, 100, 100) lv.obj_set_size(btn1, 120, 50) local btn_label = lv.label_create(btn1) lv.label_set_text(btn_label, “Click Me”) lv.obj_center(btn_label) -- 定义一个按钮事件回调函数（需要在 C 端绑定事件注册函数） local function on_btn_clicked(obj, event) if event == lv.EVENT_CLICKED then -- 假设 `lv.EVENT_CLICKED` 常量也已绑定 lv.label_set_text(label1, “Button Clicked!”) print(“[LUA] Button was clicked.”) end end -- 将回调函数注册给按钮（需要对应的 C 绑定函数 `lv.obj_add_event_cb`） lv.obj_add_event_cb(btn1, on_btn_clicked, lv.EVENT_CLICKED, nil) print(“[LUA] UI setup complete.”)

4.6 编译、烧录与监控

1. 编译：在项目根目录执行idf.py build。确保没有错误。
2. 连接设备：用 USB 线连接 ESP32-S3 开发板到电脑。
3. 烧录：执行idf.py -p PORT flash，将PORT替换为你的串口号（如COM3或/dev/ttyUSB0）。
4. 监控日志：执行idf.py -p PORT monitor打开串口监视器。你应该能看到 ESP32 的启动日志，以及 Lua 脚本打印的“Hello from Lua script!”信息。
5. 观察屏幕：如果一切顺利，3.2寸透明屏幕上将显示 “Hello, HoloCubic 3.2!” 文本和一个 “Click Me” 按钮。按下按钮，文本会改变。

5. 进阶开发：完善 Lua 绑定与功能

上面的示例只绑定了最基础的几个函数。一个可用的系统需要更完善的绑定。

5.1 系统化绑定 LVGL API

手动为每个 LVGL 函数写绑定代码是繁琐的。有两种更高效的方法：

1. 使用自动绑定生成工具：如LVGL官方推荐的LVGL与MicroPython的绑定方式，或者寻找社区为Lua编写的绑定生成器。这需要一定的工具链搭建。
2. 分模块手动绑定：对于初期项目，可以按需绑定。创建一个lvgl_api_bindings.c文件，系统地为你需要的控件和函数编写绑定。例如：
   • 对象基础操作：create,set_pos,set_size,set_style,add_event_cb,clean。
   • 核心控件：label,btn,slider,bar,chart,list,dropdown。
   • 样式管理。
   • 动画系统。

5.2 实现脚本文件热更新

项目的精髓在于动态脚本。实现步骤：

1. 集成文件系统：在menuconfig中启用SPIFFS或FATFS组件，并配置分区表。
2. 挂载文件系统：在app_main中初始化并挂载文件系统到/spiffs等路径。
3. Lua 文件加载：修改lua_run_script函数，使其从文件系统（如/spiffs/main.lua）加载脚本。
4. 实现更新机制：
   • 网络更新：让 ESP32 连接 Wi-Fi，通过 HTTP 从服务器下载新的main.lua到文件系统，然后重启或动态重新加载 Lua 虚拟机。
   • SD 卡更新：将 Lua 脚本放在 SD 卡中，系统启动时从 SD 卡加载。更换 SD 卡内容即可更新功能。
   • 串口更新：通过串口接收新的 Lua 脚本代码并保存到文件系统。

5.3 添加网络与传感器支持

要让 HoloCubic 真正“智能”，需要让 Lua 脚本能访问网络和硬件。

1. 绑定网络函数：在 C 端封装 ESP-IDF 的 HTTP Client、SNTP、MQTT 等 API，然后暴露给 Lua。例如，可以创建net.http_get(url, callback)这样的 Lua 函数。
2. 绑定硬件 GPIO/I2C：封装gpio_set_level,i2c_read等函数。这样 Lua 脚本就能控制 LED、读取温湿度传感器数据了。
3. 创建异步回调机制：网络请求和传感器读取通常是异步的。需要在 C 端管理好回调函数，确保在事件完成后能安全地调用回 Lua 函数。

6. 常见问题与排查 (FAQ)

在开发过程中，你可能会遇到以下问题：

7. 最佳实践与项目优化建议

当基本功能跑通后，可以考虑以下优化，让项目更稳定、易用。

1. 内存管理：
   • LVGL 对象：在 Lua 脚本中，对于不再使用的 UI 对象，调用lv.obj_del或lv.obj_clean来释放内存。避免内存泄漏。
   • Lua 内存：注意 Lua 中的全局变量和闭包引用。对于大型临时表，使用后置为nil。可以考虑在 C 端设置 Lua 内存上限。
2. 错误处理：
   • 在 C 端绑定函数中，务必检查传入的 Lua 参数类型和数量 (luaL_checkstring,lua_isuserdata等)，防止脚本传参错误导致崩溃。
   • 为 Lua 脚本提供pcall（保护调用）机制，捕获运行时错误并记录到日志，而不是让整个系统崩溃。
3. UI/UX 设计：
   • 利用透明屏特性：设计深色主题、发光字体、悬浮动画，强化“全息”视觉效果。
   • 分层管理：使用 LVGL 的lv_layer_top()和lv_layer_sys()来管理弹出层和系统界面。
   • 动画增强：合理使用 LVGL 的动画 API，让界面切换和状态变化更流畅。
4. 脚本安全与沙箱：
   • 在生产环境中，应严格限制 Lua 脚本的权限。可以考虑禁用危险的os、io、debug库。
   • 可以为每个脚本创建独立的 Lua 状态机，或者使用自定义的加载器来限制脚本访问的 API。
5. 项目管理：
   • 将 Lua 绑定代码模块化，例如lvgl_bindings.c,net_bindings.c,gpio_bindings.c。
   • 使用 Git 进行版本控制，特别是管理你的 Lua 脚本库和 UI 主题。
   • 编写清晰的README.md，说明项目结构、编译方法、引脚定义和 Lua API 文档。

通过以上步骤，你已经将一个基础的 HoloCubic 项目升级为了一个拥有 3.2 寸透明大屏、支持动态 Lua 脚本的智能交互终端。这个框架具有很强的扩展性，你可以继续绑定更多 LVGL 控件和 ESP32 硬件功能，用 Lua 脚本快速开发出时钟、天气站、智能家居控制面板、乃至小游戏等各种应用。

项目的核心价值在于“固件一次烧写，功能无限扩展”。你可以将编译好的固件分享给朋友，他们只需要通过 SD 卡或网络更新 Lua 脚本，就能赋予设备全新的功能，这极大地降低了二次开发的门槛和风险。希望这个项目能为你打开嵌入式 GUI 与脚本化开发的新思路。如果在实践过程中遇到任何问题，欢迎在社区分享你的经验和挑战。