企业官网建设流程全解析

1. 从“组装”到“创造”：为什么驱动开发是硬核工程师的分水岭

如果你在嵌入式或系统开发领域，经常听到“驱动”这个词，但感觉它离自己很远——你可能是那个熟练调用各种库、配置现成模块、让硬件“跑起来”的“模块组装师”。这没什么不好，很多项目确实只需要到这个层面。但当你遇到一个全新的传感器、一块定制的主板，或者需要把性能压榨到极致时，你会发现手头的“积木”不够用了。这时，驱动开发能力就成了那道分水岭：一边是应用层面的整合，另一边是深入硬件与操作系统内核的创造。

驱动，简单说就是让操作系统认识并正确操作硬件的“翻译官”和“管理员”。没有合适的驱动，再强大的CPU、再精密的传感器，在系统眼里都是一块无法沟通的“砖头”。网上搜索“jlink驱动安装”、“ch340驱动安装教程”的人，大多是在解决“识别”问题；而搜索“linux驱动开发”、“字符设备驱动框架”的人，已经开始思考如何“创造”了。

这篇文章不是劝所有人都去写驱动，而是帮你理清：什么情况下你需要关心驱动？从“会用驱动”到“会写驱动”需要跨越哪些认知和实践鸿沟？我会以一个从业者的视角，拆解驱动开发的核心流程、常见陷阱以及它带来的真正价值。你会发现，驱动开发并没有想象中那么神秘，但它确实要求你换一种思维方式。

2. 驱动开发到底在解决什么问题？不只是让灯闪烁

很多人对驱动开发的初印象，是让一个LED灯按照代码闪烁。这没错，但这只是“Hello World”级别。真正的驱动开发，解决的是以下几类更底层、更普遍的问题：

2.1 硬件抽象与统一接口

操作系统（如Linux、Windows）不可能为世界上每一款硬件都单独写一套代码。驱动的作用，就是为千差万别的硬件（不同厂商的网卡、声卡、GPIO控制器）提供一套统一的软件接口。例如，无论你用的是Intel还是Realtek的网卡，上层网络协议栈都通过统一的net_device结构体来操作它。驱动开发者的工作，就是实现这些标准接口背后的硬件具体操作。

2.2 资源管理与并发安全

硬件是稀缺资源。驱动必须管理好对硬件的独占访问。想象一下，两个应用程序同时向同一个串口发送数据会发生什么？数据会混杂在一起，导致通信彻底失败。驱动需要利用锁、队列等机制，确保在任何时候，对硬件的操作都是有序、安全的。这是“模块组装”时很少需要考虑的层面。

2.3 中断处理与异步事件

硬件事件（如数据到达、操作完成）通常以中断的形式通知CPU。驱动必须包含中断处理程序（ISR），它要求快速响应、不能阻塞。在ISR中，你往往只能做最简单的标记，然后把耗时的处理（比如解析一包完整的网络数据）推迟到后台的“下半部”（如tasklet、workqueue）中。这种异步编程模型，与大部分应用层同步编程思维截然不同。

2.4 电源管理与性能优化

在移动和物联网设备上，功耗至关重要。驱动需要配合操作系统，在设备空闲时将其置于低功耗状态，在需要时快速唤醒。同时，驱动中的数据结构、缓冲区管理、DMA（直接内存访问）使用方式，直接决定了硬件性能发挥的上限。一个糟糕的驱动，可以让高端硬件的性能表现不如低端产品。

当你搜索“stlink驱动安装”或“pl2303驱动”时，你是在使用别人写好的驱动来解决“有无”问题。而当你需要为一块定制电路板上的CPLD编写驱动，或优化一款摄像头在Linux下的帧率和稳定性时，你就必须直面上述所有问题。这就是“组装”与“开发”的本质区别。

3. 环境准备：你的“战场”不是IDE，是内核与硬件

写应用层程序，你打开VS Code或Clion，配置好库路径就行。写驱动，尤其是Linux内核驱动，你的工作环境要复杂得多。

3.1 核心工具链：编译器与内核源码

你不能再使用普通的gcc。你需要目标平台对应的交叉编译工具链（比如arm-linux-gnueabihf-gcc）。更重要的是，你必须有一份与目标系统运行版本完全一致的内核源代码。驱动模块是内核的一部分，它必须针对特定内核版本进行编译。版本不匹配是驱动加载失败最常见的原因之一。

# 查看目标系统的内核版本 uname -r # 例如输出：5.10.0-26-generic # 那么你准备的源码树版本必须与之匹配或高度兼容

3.2 开发与调试环境

不要直接在重要的生产机器或唯一的开发板上进行驱动开发。推荐以下两种方式：

1. 虚拟机+内核模块开发：在虚拟机（如VirtualBox/VMware）中安装Linux，并安装内核头文件包（linux-headers-$(uname -r)）。你可以在这里安全地编写、编译、加载、卸载简单的字符设备驱动，即使内核崩溃，也只需重启虚拟机。
2. 真实硬件+调试器：对于涉及具体硬件的驱动（如操作GPIO、I2C设备），你需要真实的开发板（如树莓派、BeagleBone或各种ARM核心板）。配合JTAG/SWD调试器（如J-Link、ST-Link）和GDB，可以进行源码级调试。串口（通过CH340、FT232等USB转串口模块连接）是必不可少的调试信息输出通道。

3.3 必要的知识储备

在写第一行驱动代码前，你需要理解：

• C语言：尤其是结构体、指针、函数指针、内存操作。内核驱动中几乎没有C++和高级抽象。
• 硬件基础：能看懂原理图，理解芯片数据手册（Datasheet）中的寄存器描述。知道什么是GPIO、I2C、SPI、UART、中断引脚。
• 操作系统概念：进程/线程、内存管理、虚拟地址/物理地址、中断、并发与锁。

如果这些概念对你来说还比较陌生，我建议先通过一些简单的内核模块例子来熟悉环境，而不是直接挑战一个复杂的设备驱动。

4. 第一个驱动：从“Helloworld”模块到字符设备

我们从一个最简单的内核模块开始，它不控制任何硬件，只在内核加载和卸载时打印信息。这是理解驱动生命周期和编译加载流程的最佳起点。

4.1 编写最简单的内核模块

创建一个文件hello.c：

#include <linux/init.h> #include <linux/module.h> #include <linux/kernel.h> MODULE_LICENSE("GPL"); MODULE_AUTHOR("Your Name"); MODULE_DESCRIPTION("A simple hello world kernel module"); static int __init hello_init(void) { printk(KERN_INFO "Hello, world! Driver module loaded.\n"); return 0; // 返回0表示初始化成功 } static void __exit hello_exit(void) { printk(KERN_INFO "Goodbye, world! Driver module unloaded.\n"); } module_init(hello_init); // 指定模块加载时调用的函数 module_exit(hello_exit); // 指定模块卸载时调用的函数

注意：这里使用printk而不是printf，因为这是在内核空间。

4.2 编写Makefile

在同一目录下创建Makefile：

obj-m += hello.o # 要生成的目标模块名为 hello.ko KDIR := /lib/modules/$(shell uname -r)/build # 指向当前系统的内核构建目录 PWD := $(shell pwd) all: $(MAKE) -C $(KDIR) M=$(PWD) modules clean: $(MAKE) -C $(KDIR) M=$(PWD) clean

4.3 编译、加载、查看与卸载

# 1. 编译 make # 编译成功后，会生成 hello.ko 文件 # 2. 加载模块（需要root权限） sudo insmod hello.ko # 3. 查看模块是否加载及内核输出 lsmod | grep hello # 查看已加载模块列表 dmesg | tail -5 # 查看内核日志，应该能看到“Hello, world!”信息 # 4. 卸载模块 sudo rmmod hello # 5. 再次查看内核日志，确认卸载信息 dmesg | tail -5 # 应该能看到“Goodbye, world!”

如果这一步能成功，恭喜你，你已经跨过了驱动开发的第一道门槛：正确配置编译环境，并理解了模块的加载/卸载生命周期。

4.4 升级为字符设备驱动

一个只能打印信息的模块没什么用。真正的设备驱动需要提供文件操作接口，让用户空间程序能够通过open、read、write、ioctl、close等系统调用来操作它。

下面是一个简化版的字符设备驱动框架，它实现一个可读写的内存缓冲区：

#include <linux/module.h> #include <linux/fs.h> // 包含 file_operations 结构体 #include <linux/cdev.h> // 字符设备结构 #include <linux/uaccess.h> // copy_to_user, copy_from_user #include <linux/slab.h> // kmalloc, kfree #define DEVICE_NAME "my_char_dev" #define BUFFER_SIZE 1024 static int major_num; // 主设备号 static struct cdev my_cdev; static char *device_buffer; // 驱动内部缓冲区 // 文件操作函数集合 static int dev_open(struct inode *inodep, struct file *filep) { printk(KERN_INFO "my_char_dev: Device opened\n"); return 0; } static ssize_t dev_read(struct file *filep, char __user *buffer, size_t len, loff_t *offset) { int bytes_to_read; int bytes_read; if (*offset >= BUFFER_SIZE) { return 0; // EOF } bytes_to_read = min(len, (size_t)(BUFFER_SIZE - *offset)); if (bytes_to_read == 0) return 0; // 将内核缓冲区数据拷贝到用户空间 if (copy_to_user(buffer, device_buffer + *offset, bytes_to_read)) { return -EFAULT; // 拷贝失败 } *offset += bytes_to_read; bytes_read = bytes_to_read; printk(KERN_INFO "my_char_dev: Read %d bytes\n", bytes_read); return bytes_read; } static ssize_t dev_write(struct file *filep, const char __user *buffer, size_t len, loff_t *offset) { int bytes_to_write; int bytes_written; if (*offset >= BUFFER_SIZE) { return -ENOSPC; // 设备空间不足 } bytes_to_write = min(len, (size_t)(BUFFER_SIZE - *offset)); if (bytes_to_write == 0) return -ENOSPC; // 将用户空间数据拷贝到内核缓冲区 if (copy_from_user(device_buffer + *offset, buffer, bytes_to_write)) { return -EFAULT; } *offset += bytes_to_write; bytes_written = bytes_to_write; printk(KERN_INFO "my_char_dev: Written %d bytes\n", bytes_written); return bytes_written; } static int dev_release(struct inode *inodep, struct file *filep) { printk(KERN_INFO "my_char_dev: Device closed\n"); return 0; } // 定义文件操作结构体 static struct file_operations fops = { .owner = THIS_MODULE, .open = dev_open, .read = dev_read, .write = dev_write, .release = dev_release, }; static int __init char_dev_init(void) { dev_t dev_num; // 1. 动态申请一个主设备号 if (alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME) < 0) { printk(KERN_ALERT "Failed to allocate major number\n"); return -1; } major_num = MAJOR(dev_num); printk(KERN_INFO "my_char_dev: Registered with major number %d\n", major_num); // 2. 初始化cdev结构，并将其与fops关联 cdev_init(&my_cdev, &fops); my_cdev.owner = THIS_MODULE; // 3. 将cdev添加到内核系统 if (cdev_add(&my_cdev, dev_num, 1) < 0) { printk(KERN_ALERT "Failed to add cdev\n"); unregister_chrdev_region(dev_num, 1); return -1; } // 4. 为缓冲区分配内存 device_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL); if (!device_buffer) { printk(KERN_ALERT "Failed to allocate buffer\n"); cdev_del(&my_cdev); unregister_chrdev_region(dev_num, 1); return -ENOMEM; } memset(device_buffer, 0, BUFFER_SIZE); printk(KERN_INFO "my_char_dev: Module loaded successfully\n"); return 0; } static void __exit char_dev_exit(void) { // 清理：释放缓冲区、删除cdev、释放设备号 kfree(device_buffer); cdev_del(&my_cdev); unregister_chrdev_region(MKDEV(major_num, 0), 1); printk(KERN_INFO "my_char_dev: Module unloaded\n"); } module_init(char_dev_init); module_exit(char_dev_exit);

这个驱动做了以下几件关键事：

1. 设备号管理：通过alloc_chrdev_region向系统动态申请一个主设备号。
2. 字符设备抽象：使用struct cdev来代表一个字符设备，并用cdev_init和cdev_add将其注册到内核。
3. 文件操作集：实现struct file_operations中的关键函数（open, read, write, release），这是用户空间与驱动交互的桥梁。
4. 内核/用户空间数据交换：使用copy_to_user和copy_from_user安全地在内核缓冲区和用户缓冲区之间拷贝数据。直接使用指针访问用户空间内存是严重错误，会导致内核崩溃。
5. 内存管理：使用kmalloc和kfree在内核空间分配/释放内存。

编译加载这个模块后，你可以用用户态程序来测试它：

# 加载模块后，查看分配的主设备号，假设是250 cat /proc/devices | grep my_char_dev # 创建设备节点（需要主设备号和次设备号，次设备号这里用0） sudo mknod /dev/my_char_dev c 250 0 sudo chmod 666 /dev/my_char_dev # 设置权限以便普通用户访问 # 测试写入和读取 echo "Hello Driver" > /dev/my_char_dev cat /dev/my_char_dev

如果一切正常，cat命令会输出你写入的字符串。通过dmesg可以看到驱动打印的读写日志。

5. 对接真实硬件：以GPIO和中断为例

让一个LED闪烁是嵌入式驱动的“Hello World”。我们以常见的通过GPIO控制LED，并为其添加中断响应（例如连接一个按键）为例，看看驱动如何与真实硬件交互。

5.1 硬件连接与原理图理解

假设你的开发板上，LED连接在GPIO 17上（输出），按键连接在GPIO 27上（输入，内部上拉，按键按下接地）。你首先需要从板子的原理图或数据手册中确认这些引脚编号，以及它们对应的系统内GPIO编号（可能不是简单的17、27，需要通过芯片数据手册换算）。

5.2 使用GPIO子系统

现代Linux内核推荐使用GPIO子系统（<linux/gpio/consumer.h>或<linux/gpio.h>）来操作GPIO，而不是直接读写寄存器。它提供了设备树（Device Tree）支持，使得驱动与硬件配置解耦。

#include <linux/gpio/consumer.h> // 新接口 // 或 #include <linux/gpio.h> // 旧接口 struct gpio_desc *led_gpio; struct gpio_desc *button_gpio; int button_irq_number; static irqreturn_t button_interrupt_handler(int irq, void *dev_id) { // 中断处理程序，要求快速执行，不能阻塞 int state = gpiod_get_value(button_gpio); printk(KERN_INFO "Button interrupt triggered! State: %d\n", state); // 根据按键状态翻转LED gpiod_set_value(led_gpio, !gpiod_get_value(led_gpio)); return IRQ_HANDLED; // 表明中断已被处理 } static int __init gpio_driver_init(void) { int ret; // 1. 获取GPIO描述符（新方法，推荐） led_gpio = gpiod_get(NULL, "led", GPIOD_OUT_LOW); // 从设备树或平台数据获取名为"led"的GPIO，初始输出低电平 if (IS_ERR(led_gpio)) { // 如果新方法失败，可以尝试旧方法（不推荐） // ret = gpio_request(17, "my_led"); // gpio_direction_output(17, 0); printk(KERN_ERR "Failed to get LED GPIO\n"); return PTR_ERR(led_gpio); } button_gpio = gpiod_get(NULL, "button", GPIOD_IN); if (IS_ERR(button_gpio)) { gpiod_put(led_gpio); printk(KERN_ERR "Failed to get Button GPIO\n"); return PTR_ERR(button_gpio); } // 2. 将GPIO映射为中断号 button_irq_number = gpiod_to_irq(button_gpio); if (button_irq_number < 0) { gpiod_put(button_gpio); gpiod_put(led_gpio); printk(KERN_ERR "Failed to map GPIO to IRQ\n"); return button_irq_number; } // 3. 申请中断 // 参数：中断号， 处理函数， 中断触发标志（下降沿触发，即按键按下）， 设备名， 传递给处理函数的设备ID ret = request_irq(button_irq_number, button_interrupt_handler, IRQF_TRIGGER_FALLING, "my_button", NULL); if (ret) { gpiod_put(button_gpio); gpiod_put(led_gpio); printk(KERN_ERR "Failed to request IRQ: %d\n", ret); return ret; } printk(KERN_INFO "GPIO driver loaded. LED on GPIO %d, Button on GPIO %d (IRQ %d)\n", desc_to_gpio(led_gpio), desc_to_gpio(button_gpio), button_irq_number); return 0; } static void __exit gpio_driver_exit(void) { // 释放资源：顺序与申请相反 free_irq(button_irq_number, NULL); gpiod_put(button_gpio); gpiod_set_value(led_gpio, 0); // 关闭LED gpiod_put(led_gpio); printk(KERN_INFO "GPIO driver unloaded\n"); }

关键点解析：

• GPIO获取：gpiod_get是推荐方式，它依赖于设备树配置，使驱动代码不依赖具体的物理引脚号，提高了可移植性。
• 中断申请：request_irq将硬件中断号与你的处理函数绑定。IRQF_TRIGGER_FALLING表示在引脚电平从高到低变化（下降沿）时触发中断，适合按键按下（接地）场景。
• 中断处理程序：必须快速、非阻塞。这里只是简单读取引脚状态和翻转LED。如果需要处理复杂任务，应使用tasklet或workqueue将任务推后执行。
• 资源释放：在模块退出函数中，必须按正确顺序释放所有申请的资源（IRQ、GPIO），否则会导致资源泄漏，下次加载可能失败。

5.3 设备树（Device Tree）配置

为了让gpiod_get能通过名称（如“led”）找到正确的GPIO，你需要配置设备树。这是将硬件描述与驱动代码分离的关键。在开发板的设备树源文件（.dts或.dtsi）中添加：

my_gpio_device { compatible = "my-company,gpio-example"; status = "okay"; led-gpio = <&gpio 17 GPIO_ACTIVE_HIGH>; // 假设物理GPIO 17，高电平有效 button-gpio = <&gpio 27 GPIO_ACTIVE_LOW>; // 假设物理GPIO 27，低电平有效（按键按下为低） };

驱动中的gpiod_get(NULL, “led”, …)就会去查找名为led-gpio的属性。设备树的编译和加载是另一个复杂话题，但对于嵌入式Linux驱动开发是必学内容。

6. 驱动开发中的“深坑”与调试艺术

驱动运行在内核空间，一个微小的错误（如空指针解引用、内存越界）都可能导致整个系统崩溃（内核Oops或Panic）。调试驱动比调试应用层程序困难得多。

6.1 常见问题与排查顺序

当你的驱动模块加载失败、设备无法操作或系统崩溃时，按以下顺序排查：

1. 编译问题：

   • 错误：Invalid module format或version magic mismatch。
   • 原因：模块与当前运行内核的版本不匹配。
   • 解决：确认你编译所用的内核源码版本与uname -r一致。确保已安装对应版本的linux-headers包。

2. 加载与初始化问题：

   • 错误：insmod失败，dmesg显示具体错误码。
   • 排查：
     • -1：初始化函数返回非零。检查init函数中资源申请（kmalloc,gpiod_get,request_irq等）是否失败。
     • -12：Cannot allocate memory。检查kmalloc/kzalloc大小，或ioremap范围。
     • -16：Device or resource busy。设备号或硬件资源（如IRQ）已被其他驱动占用。
     • -19：No such device。通常与设备树相关，驱动probe函数未成功匹配到硬件。检查设备树节点status是否为“okay”，compatible字符串是否匹配。

3. 运行时崩溃（Oops）：

   • 现象：系统打印一堆寄存器值和调用栈（Backtrace），然后可能挂死或继续运行（取决于错误严重性）。
   • 关键信息：Unable to handle kernel NULL pointer dereference at virtual address xxxxxxxx（空指针解引用）或general protection fault（内存访问越界）。
   • 排查：
     • 仔细看Oops信息的第一行和调用栈。它指出了出错的指令地址和附近的代码行（如果有内核调试符号）。
     • 最常见原因：未验证指针是否有效就使用（如未检查kmalloc返回值）；用户空间指针未使用copy_from_user就直接访问；访问了已经释放的内存（Use-After-Free）。
     • 使用printk在可疑代码路径前后添加日志，缩小范围。

4. 功能异常：

   • 现象：驱动能加载，但read/write/ioctl返回错误数据或错误码。
   • 排查：
     • 检查所有copy_to_user/copy_from_user的返回值，它们可能因用户空间地址非法而失败。
     • 检查并发访问：多个进程同时open你的设备并操作，是否加了必要的锁（如mutex）？
     • 检查硬件状态：用逻辑分析仪或示波器查看GPIO、I2C等总线上的实际波形，确认软件发出的信号与硬件实际接收的是否一致。很多问题不是驱动逻辑错，而是时序或电气特性不满足。

6.2 核心调试工具

• printk：最基础、最强大的工具。使用不同的日志级别（KERN_ERR,KERN_INFO,KERN_DEBUG）。可以通过/proc/sys/kernel/printk调整控制台输出级别。注意：在内核启动早期或中断上下文中，printk可能无法立即输出到控制台。
• dmesg：查看内核环形缓冲区中的日志。始终是你的第一道排查工具。使用dmesg -w可以实时查看。
• /proc和/sys文件系统：内核和驱动可以在这里暴露状态信息。例如，/proc/interrupts查看中断统计，/proc/iomem查看物理内存映射。
• KGDB/KDB：内核级别的源码调试器，需要两台机器或通过串口连接，配置复杂但功能强大，可以设置断点、单步执行。
• SystemTap / Ftrace：动态追踪工具，可以监控函数调用、延迟等，用于分析性能瓶颈和复杂逻辑流。
• 硬件工具：万用表、逻辑分析仪、示波器。当怀疑是硬件或时序问题时，它们无可替代。

6.3 必须养成的安全习惯

1. 永远检查返回值：内核函数（kmalloc,gpiod_get,request_irq,copy_from_user……）几乎都会返回错误码。必须检查并处理。
2. 初始化变量：局部变量，特别是指针，必须初始化。内核栈数据是未清零的。
3. 谨慎使用内存：明确每一块内存的生命周期。谁分配，谁释放。使用kfree释放kmalloc分配的内存，并且释放后不要再访问。
4. 理解执行上下文：你的代码可能运行在进程上下文（可以睡眠），也可能运行在中断上下文（禁止睡眠，不能调用可能引起调度的函数）。在中断处理函数中调用kmalloc(GFP_KERNEL)或mutex_lock是致命的。
5. 使用内核提供的设施：不要自己造轮子。内存分配、锁、延时、工作队列、链表管理等，都使用内核提供的成熟API。

7. 超越基础：驱动开发的进阶方向

当你掌握了字符设备、GPIO、中断的基本框架后，可以朝着更专业的方向深入：

7.1 平台设备与设备树（Platform Device & DT）

这是现代Linux驱动的主流模型。驱动代码定义platform_driver，通过compatible属性与设备树（Device Tree）中描述的硬件节点匹配。这实现了驱动代码与硬件配置的完全分离，同一份驱动源码可以用于不同板卡，只需修改设备树即可。

7.2 总线驱动模型（I2C, SPI, USB）

对于挂载在标准总线（I2C、SPI、USB）上的设备，内核提供了完整的子系统。你需要实现的是该总线下的设备驱动（如i2c_driver）。总线核心层会帮你处理总线通信、设备发现等繁琐工作。例如，为一个I2C温度传感器写驱动，你主要实现probe、remove以及提供温度读取的file_operations或sysfs接口。

7.3 块设备与网络设备驱动

这分别是为磁盘类设备和网卡准备的驱动框架。它们比字符设备复杂得多，需要实现一整套完整的接口（如block_device_operations,net_device_ops），处理复杂的队列、DMA、协议栈交互等。这是驱动开发中的“高级关卡”。

7.4 内核社区与代码风格

如果你想贡献代码到主线内核，必须严格遵守内核的编码风格（Linux Kernel Coding Style）。使用scripts/checkpatch.pl检查你的补丁。提交补丁到邮件列表，参与社区讨论。阅读内核源码中优秀的驱动（如drivers/input/keyboard/下的键盘驱动）是极佳的学习方式。

从“模块组装师”到驱动开发者，最大的转变不是多学几个API，而是思维模式的升级：从“如何调用”变为“如何实现接口”；从“关注功能”变为“关注资源、并发与安全”；从“在用户空间思考”变为“在内核空间思考”。这个过程充满挑战，但一旦打通，你对整个计算机系统的理解将豁然开朗。你不再只是硬件的使用者，而是成为了让硬件“活”起来的创造者。

我建议的学习路径是：Hello World模块 -> 字符设备驱动（内存缓冲区）-> GPIO控制 -> 中断处理 -> 结合设备树 -> 尝试一个简单的I2C传感器驱动。每一步都亲手写代码、编译、加载、测试、故意制造错误并调试。当你为一个自己设计的硬件成功编写出稳定的驱动时，那种成就感远非组装模块可比。