【CHIBIOS新手必读】：一步步入门CHIBIOS-3.0.4


# 摘要
本文旨在详细介绍CHIBIOS实时操作系统的基础知识、环境搭建、基础编程和高级特性。首先概述CHIBIOS的基本概念、架构和内核特点，随后引导读者通过实际操作搭建开发环境，并解析系统启动流程。基础编程部分涵盖了任务管理、信号量、互斥锁以及中断处理机制，而高级特性实践则包括实时事件管理、动态内存优化和定时器使用。最后，本文通过具体项目案例，如硬件驱动开发、串口通信和网络通信，展示了CHIBIOS在实际应用中的灵活运用。本文适合对实时操作系统感兴趣的读者，提供全面的CHIBIOS使用指南，并展示其在多个领域的应用。

# 关键字
CHIBIOS；实时操作系统；环境搭建；任务调度；中断处理；内存管理

参考资源链接：[ChibiOS/RT 3.0.4 RT Reference Manual: APM操作系统的系统概念与测试](https://wenku.csdn.net/doc/355chypzpb?spm=1055.2635.3001.10343)
# 1. CHIBIOS概述

CHIBIOS是一个开源的实时操作系统（RTOS），专为嵌入式系统设计，提供了一套完整的任务调度、中断管理、时间管理、内存管理以及I/O管理等服务。由于其轻量级和模块化的特点，CHIBIOS非常适合资源受限的嵌入式环境，如微控制器等设备。

## 1.1 CHIBIOS的适用场景

CHIBIOS广泛应用于需要高实时性能、低资源消耗的应用领域，例如工业控制系统、家庭自动化、消费电子以及车载系统等。它的模块化设计允许开发者根据实际需求选择所需功能，从而达到最优的系统资源分配和性能表现。

## 1.2 CHIBIOS的核心优势

核心优势之一是其轻量级内核，对RAM和ROM的需求非常低，易于集成到各种微控制器上。另外，CHIBIOS的可伸缩架构支持从简单的裸机系统到复杂的多核系统。其源代码完全开源，社区活跃，便于开发者学习和定制。

在开始深入了解CHIBIOS之前，理解它的这些基础概念对于后续的环境搭建和编程实践非常重要。接下来的章节将详细介绍如何搭建CHIBIOS开发环境，以及如何进行基础的编程和高级特性的实践应用。

# 2. CHIBIOS环境搭建

### 2.1 CHIBIOS的基本概念和架构

#### 2.1.1 CHIBIOS内核特点

CHIBIOS是一个小型、高效且实时性高的操作系统内核。其特点主要体现在以下几个方面：

- **微内核架构**：CHIBIOS采用微内核设计，只包含最基本的系统服务和调度器。其他的功能如文件系统、网络协议栈都是可选的模块，可以根据需要添加，这使得CHIBIOS在内存和资源受限的嵌入式环境中应用广泛。
- **优先级抢占调度**：CHIBIOS使用优先级抢占式的任务调度器，支持多任务并发运行，并能在更高优先级任务就绪时及时切换，保证了关键任务的即时响应。

- **灵活的任务状态管理**：任务可以处于就绪、运行、挂起、等待等状态，系统能够根据任务状态和优先级动态调整任务执行顺序。

- **实时性**：CHIBIOS内核支持周期性实时任务和单次实时任务的创建和执行，适用于需要严格时间控制的应用场景。

- **低功耗设计**：CHIBIOS考虑到嵌入式设备的电源管理，提供了多种省电模式和任务休眠机制，有助于延长设备的工作时间。

#### 2.1.2 系统层次结构详解

CHIBIOS的系统层次结构从低到高可以划分为以下几个层次：

- **HAL（硬件抽象层）**：HAL是直接与硬件交互的最底层，负责提供硬件访问接口和配置，抽象出统一的硬件访问方式供上层使用。

- **OS（操作系统层）**：OS层包含了CHIBIOS的核心功能，如任务管理、中断处理、信号量等同步机制。

- **middleware（中间件层）**：这一层是可选的，它包括了如文件系统、网络协议栈、串口驱动等高级功能。

- **application（应用层）**：最上层，开发者编写的应用程序代码就是运行在这个层次。应用层可以调用中间件层提供的服务，也可以直接使用操作系统层的功能。

### 2.2 安装CHIBIOS开发环境

#### 2.2.1 准备开发工具和依赖库

在安装CHIBIOS开发环境之前，需要准备好以下开发工具和依赖库：

- **GCC交叉编译器**：根据目标硬件平台选择合适的GCC交叉编译器版本。例如针对ARM架构，可以安装arm-none-eabi-gcc。

- **GDB调试器**：用于程序调试。

- **Make**：构建工具，用于自动化编译过程。

- **Git**：版本控制系统，用于下载和管理CHIBIOS源码。

- **依赖库**：可能需要安装如libusb、libopencm3等库，这些库根据项目需要进行安装。

安装上述工具和库通常可以通过包管理器完成，如Ubuntu系统可以通过apt-get命令安装：

sudo apt-get update
sudo apt-get install gcc-arm-none-eabi gdb-multiarch libopencm3-dev git

#### 2.2.2 配置和编译CHIBIOS源码

获取CHIBIOS源码后，接下来进行配置和编译：

1. 克隆CHIBIOS的仓库：

git clone https://github.com/ChibiOS/ChibiOS.git

2. 进入CHIBIOS源码目录：

cd ChibiOS

3. 创建构建目录并进入，通常使用`os`和`hal`目录作为示例：

make git-submodules
cd os/hal

4. 运行配置命令，选择你的目标平台和配置文件：

make CONF=../os/common/ports/ARMCMx/compilers/GCC/rules.make

5. 编译构建：

make

编译完成后，会在当前目录下生成`.elf`和`.hex`文件，这些文件用于下载到目标硬件。

#### 2.2.3 验证开发环境的搭建

验证开发环境是否搭建成功，可以通过烧录程序到目标硬件并运行来检查。通常使用JTAG/SWD调试器进行：

1. 连接硬件开发板和调试器。

2. 使用GDB或特定的调试工具加载`.elf`文件并进行烧录。

3. 运行程序并观察目标硬件的指示灯或者串口输出信息。

如果以上步骤顺利完成，则说明CHIBIOS开发环境已经成功搭建。

### 2.3 CHIBIOS启动流程分析

#### 2.3.1 启动过程的初始化步骤

CHIBIOS启动时会按照以下初始化步骤进行：

1. **硬件初始化**：包括时钟系统、GPIO、中断向量表等。

2. **HAL初始化**：调用`halInit()`函数初始化HAL层，包括内存管理、定时器、串口等。

3. **OS初始化**：调用`osInit()`函数初始化OS层，设置任务调度器等。

4. **硬件抽象层的启动**：通过`halStart()`函数开始HAL层的正常工作。

5. **操作系统层的启动**：调用`osStart()`函数启动操作系统，创建第一个线程并开始任务调度。

#### 2.3.2 系统启动时的配置选项解析

CHIBIOS支持多种配置选项，这些选项可以在编译时通过Makefile来配置：

- **内核配置选项**：包括是否支持抢占式调度、线程状态、系统时钟频率等。

- **硬件配置选项**：针对不同的硬件平台，例如STM32的不同系列，会有所不同的硬件初始化代码。

- **中间件配置选项**：如果需要使用到特定的中间件功能，例如CAN总线、SPI驱动等，可以通过Makefile的配置选项来包含。

- **调试和日志选项**：如是否启用调试打印信息、调试级别等。

开发者可以通过修改Makefile或者使用配置工具`chconf.h`文件来设置这些选项，以适应不同的应用场景。

// 示例：配置选项在Makefile中的设置
CONF = \
  -DCH_FREQUENCY=72000000 \
  -DCH_USE_SEMAPHORES \
  -DCH_USE_CONDVARS \
  -DCH_USE_EVENT_FLAGS \
  -DCH_USE_MEMPOOLS \
  -DCH_USE.heap=TRUE \
  -DCH_USE_LOCKS \
  -DCH_USE_RAILWAY \
  -DCH_USE_CLASSD \
  -DCH_USE_WTCLASS1 \
  -DCH_USE_WTCLASS2 \
  -DCH_USE_WTCLASS3 \
  -DCH_USE邮编=FALSE

以上内容的深入解读需要具备嵌入式系统的基本知识和一些对CHIBIOS架构的理解。随着文章的逐步展开，本章内容应为读者理解CHIBIOS搭建过程的起点，为后续章节更高级的编程和应用实践打下基础。

# 3. CHIBIOS基础编程

## 3.1 任务管理与调度

### 3.1.1 创建和管理线程任务

在CHIBIOS中创建和管理线程任务是多任务编程的基础。每个线程任务都是独立执行的函数，可以在任务的上下文中执行各种操作。

#include "ch.h"
#include "hal.h"

static WORKING_AREA(waThread1, 128);
static msg_t Thread1(void *arg) {
    (void)arg;
    chRegSetThreadName("thread1");
    while (true) {
        // Do some work here
    }
    return 0;
}

int main(void) {
    halInit();
    chSysInit();
    chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO + 1, Thread1, NULL);
    while (true) {
        // The main thread can perform other tasks or just sleep
    }
}

在上面的代码示例中，`Thread1` 函数代表了一个简单的线程任务。它首先设置了线程名称，然后进入一个无限循环，执行一些工作。`chThdCreateStatic` 函数用于在静态工作区创建线程，其中 `NORMALPRIO + 1` 定义了任务的优先级。

### 3.1.2 任务优先级和调度策略

任务优先级是多任务操作系统中用来决定任务执行顺序的关键参数。CHIBIOS使用优先级来调度任务，确保高优先级的任务可以抢占低优先级的任务执行。

// 定义优先级
#define MAIN_THREAD_PRIO NORMALPRIO
#define THREAD1_PRIO (MAIN_THREAD_PRIO + 1)
#define THREAD2_PRIO (THREAD1_PRIO + 1)

// 在 main 中创建线程时，使用不同的优先级
chThdCreateStatic(waThread1, sizeof(waThread1), THREAD1_PRIO, Thread1, NULL);
chThdCreateStatic(waThread2, sizeof(waThread2), THREAD2_PRIO, Thread2, NULL);

// Thread2 代码类似 Thread1，但优先级更高

在任务创建时指定了优先级参数。在实时操作系统中，通常使用抢占式调度策略，CHIBIOS也不例外。当系统中存在高优先级的就绪任务时，当前正在执行的低优先级任务将被挂起，控制权交给高优先级的任务。

## 3.2 信号量与互斥锁

### 3.2.1 信号量的基本使用

信号量是用于控制任务之间同步和互斥的一种机制。在CHIBIOS中，信号量可以用于实现简单的任务同步。

#include "chsem.h"

static SEMaphore_DECL(mySemaphore, 0); // 初始计数为0的信号量

static msg_t SemaphoreThread(void *arg) {
    (void)arg;
    while (true) {
        chSemWait(&mySemaphore); // 等待信号量
        // Do something after getting the semaphore
    }
}

// 在另一个线程中释放信号量
void releaseSemaphore(void) {
    chSysLock(); // 必须在中断关闭的情况下操作信号量
    chSemSignalI(&mySemaphore); // 释放信号量
    chSysUnlock();
}

使用 `chSemWait` 函数可以实现等待信号量的动作，`chSemSignal` 函数用于释放信号量。信号量操作通常用于任务同步，例如一个任务等待另一个任务完成某个操作。

### 3.2.2 互斥锁的使用场景和注意事项

互斥锁（mutex）用于保护共享资源，确保在任何时刻只有一个任务可以访问该资源。

#include "chm.h"

static MUTEX_DECL(myMutex); // 创建互斥锁

static msg_t MutexThread(void *arg) {
    (void)arg;
    while (true) {
        chMtxLock(&myMutex); // 获取互斥锁
        // 访问共享资源
        chMtxUnlock(&myMutex); // 释放互斥锁
    }
}

在访问共享资源时，任务必须先获取互斥锁，访问结束后立即释放。互斥锁的使用需要注意防止死锁和优先级反转问题。

## 3.3 中断处理机制

### 3.3.1 配置和使用中断服务例程

中断服务例程（ISR）是响应外部或内部事件而触发执行的函数。在CHIBIOS中，每个硬件设备或内部事件都可能有一个与之关联的ISR。

#include "hal.h"

// 定义中断处理函数
static void extiCallback(void *arg) {
    (void)arg;
    // 处理外部中断事件
}

// 配置外部中断
void setupExti(void) {
    extDriverObject *edo = &EXTD1;
    edo->config(WHOEVER, WHAT EVER, extiCallback, NULL);
    edo->enable_int(EXT_INT1);
}

// 在主函数中初始化外部中断
int main(void) {
    halInit();
    chSysInit();
    setupExti();
    while (true) {
        // 主循环
    }
}

在这个示例中，`setupExti` 函数配置了外部中断，并将 `extiCallback` 函数作为中断回调。中断处理函数中应当执行的操作应尽可能简短，以避免影响系统的响应时间。

### 3.3.2 中断优先级管理与线程安全

中断优先级的管理对于确保系统稳定性至关重要。在CHIBIOS中，可以配置不同中断的优先级，以确保关键事件能够得到及时处理。

// 设置中断优先级
const IRQn_Type extIrqLines[] = {EXTI0_IRQn, EXTI1_IRQn, ...};
const uint8_t extIrqPrios[] = {EXTI0_IRQ_PRIO, EXTI1_IRQ_PRIO, ...};
for (size_t i = 0; i < N; ++i) {
    NVIC_SetPriority(extIrqLines[i], extIrqPrios[i]);
}

在执行中断处理过程中，可能会访问共享资源。为确保线程安全，应当在访问共享资源时使用互斥锁或信号量。

static msg_t mySharedAccessTask(void *arg) {
    while (true) {
        chMtxLock(&myMutex); // 获取互斥锁以保证访问线程安全
        // 访问共享资源
        chMtxUnlock(&myMutex); // 完成后释放互斥锁
    }
}

通过以上步骤，我们能够实现对CHIBIOS基础编程的理解和应用，为后续的高级特性和项目实战打下坚实的基础。

# 4. CHIBIOS高级特性实践

## 4.1 实时事件与回调函数
### 4.1.1 设计实时事件处理机制

在实时操作系统中，事件驱动编程是一种常见的编程范式。CHIBIOS通过实时事件系统提供了一种轻量级的事件通知机制，使得线程能够在不需要忙等（busy waiting）的情况下响应外部事件或系统内部事件。

#### 实时事件的创建与注册

实时事件在CHIBIOS中是由`eventmask_t`类型表示，这个类型实际上是一个按位标志集合。事件的创建通常在系统初始化阶段或线程创建阶段进行。注册事件需要调用`eventmask_t chEvtAddMasked()`函数，这个函数的调用将会把当前线程加入到一个事件的监听列表中，并且返回一个事件掩码，表示事件的注册结果。

eventmask_t mask;

// 假设已经定义并初始化了事件
mask = chEvtAddMasked(&my_events, MY_EVENT1 | MY_EVENT2);

// 等待事件发生
chEvtWaitOne(mask);

在上述代码中，`my_events`是一个已经定义的事件集合，`MY_EVENT1`和`MY_EVENT2`是具体的事件。`chEvtAddMasked()`函数将当前线程注册到`my_events`的`MY_EVENT1`和`MY_EVENT2`事件上，并返回一个掩码。之后，`chEvtWaitOne()`函数使得线程等待至少有一个注册的事件发生。

#### 实时事件的触发

事件的触发可以通过`chEvtSignal()`函数进行，这个函数能够向所有注册了该事件的线程发送事件通知。

// 在某处触发事件
chEvtSignalMask(&my_events, MY_EVENT1);

在此处的代码片段中，`my_events`的`MY_EVENT1`事件被触发，所有在`MY_EVENT1`事件上注册等待的线程将会被唤醒继续执行。

### 4.1.2 回调函数的注册与执行流程

回调函数在CHIBIOS中通常通过事件和信号量机制实现。回调函数注册到某个事件后，在事件发生时会被执行。这一机制对于创建解耦合的、事件驱动的系统非常有用。

#### 回调函数的注册

注册回调函数，可以使用`chEvtAddCallback()`函数，将一个回调函数注册到指定的事件上。

// 定义回调函数
static void my_callback(eventmask_t events) {
    // 事件发生时执行的代码
    (void)events; // 避免未使用的参数编译警告
}

// 注册回调函数到事件
chEvtAddCallback(&my_callback_list, my_callback, NULL);

在上述代码中，`my_callback_list`是事件回调列表，`my_callback`是我们想要注册的回调函数。`chEvtAddCallback()`函数将`my_callback`函数注册到`my_callback_list`上，一旦事件发生，`my_callback`函数就会被执行。

#### 回调函数的执行流程

回调函数被注册后，它们会在相应的事件触发时得到执行。CHIBIOS中的回调函数执行时机通常是在事件通知线程时或者中断上下文中，因此，回调函数的实现需要保证尽可能快的执行，并且不应该包含阻塞调用。

// 假设有一个事件发生，触发了回调函数
void event_handler(void) {
    // 调用回调函数
    for (callback_t *cb = my_callback_list->first; cb != NULL; cb = cb->next) {
        cb->func(cb->p);
    }
}

在上面的示例中，`my_callback_list`中的每个回调函数`cb->func`将被依次执行。如果回调函数需要线程上下文，则可能需要在回调函数中发送一个信号量或者启动一个线程。

回调函数是CHIBIOS中实现模块间低耦合交互的一种有效方式。通过事件和回调函数的使用，可以实现灵活的系统响应机制，适应复杂的实时系统需求。

# 5. CHIBIOS项目实战案例

## 5.1 基于CHIBIOS的硬件驱动开发

### 5.1.1 驱动接口定义与实现

开发硬件驱动接口是嵌入式系统开发中的重要环节，它为上层应用提供了一个与硬件交互的抽象层。在CHIBIOS中，硬件驱动的开发通常遵循以下步骤：

1. 定义驱动接口：首先要定义驱动所支持的操作，例如初始化、启动、停止、读取、写入等。

2. 实现驱动接口：接着，为定义的操作提供具体的实现代码。这通常包括设置硬件寄存器、配置硬件接口、处理中断和事件等。

3. 集成到系统中：最后，将驱动整合到CHIBIOS的设备抽象层中，确保系统可以发现和使用这个驱动。

下面是一个简单的CHIBIOS驱动接口定义和实现示例：

#include "ch.h"
#include "hal.h"

#define DRIVER_NAME "MyHardwareDriver"

// 驱动状态枚举
typedef enum {
    MY_DRIVER_UNINITIALIZED,
    MY_DRIVER_INITIALIZED
} MyDriverState;

// 驱动结构体
static struct {
    MyDriverState state;
    // 其他驱动特有的成员变量
} myDriver;

// 驱动初始化函数
msg_t MyDriverInit(void) {
    if (myDriver.state == MY_DRIVER_UNINITIALIZED) {
        // 配置硬件资源，初始化设置等
        myDriver.state = MY_DRIVER_INITIALIZED;
    }
    return myDriver.state == MY_DRIVER_INITIALIZED ? CH_SUCCESS : CH_ERROR;
}

// 驱动启动函数
msg_t MyDriverStart(void) {
    // 启动硬件操作等
    return CH_SUCCESS;
}

// 驱动停止函数
msg_t MyDriverStop(void) {
    // 停止硬件操作等
    return CH_SUCCESS;
}

// 驱动读取函数
size_t MyDriverRead(void *buffer, size_t size) {
    // 从硬件读取数据到buffer
    return size;
}

// 驱动写入函数
size_t MyDriverWrite(const void *buffer, size_t size) {
    // 将buffer中的数据写入硬件
    return size;
}

// 驱动API表
static const struct莞惠半导体DriverAPI莞惠半导体 {
   莞惠半导体.init = MyDriverInit,
   莞惠半导体.start = MyDriverStart,
   莞惠半导体.stop = MyDriverStop,
   莞惠半导体.read = MyDriverRead,
   莞惠半导体.write = MyDriverWrite
}莞惠半导体;

在CHIBIOS中，驱动通常需要注册到设备管理器中，这可以通过 `palSetDriver()` 或 `stm32SetPadDriver()` 等函数实现。

### 5.1.2 驱动与硬件通信协议的建立

在实现了驱动的基本接口之后，建立驱动与硬件通信协议是必不可少的。这通常包括硬件的初始化序列、数据包的格式定义、错误检测和恢复机制等。通信协议的建立需要根据具体的硬件手册和应用需求来设计。

在CHIBIOS中，通信协议的实现可能涉及到中断服务例程（ISR）、轮询机制或直接内存访问（DMA）等技术。例如，在串口通信中，你可能需要配置串口的工作模式、波特率、数据位、停止位和校验方式等参数，并编写中断服务例程来处理接收到的数据。

## 5.2 串口通信应用开发

### 5.2.1 串口配置与数据传输

串口通信是嵌入式系统中应用最为广泛的通信方式之一。在CHIBIOS中配置串口相对简单，主要步骤包括初始化串口、配置串口参数、注册回调函数以及启动串口。

在CHIBIOS中，串口的配置和使用大致遵循以下流程：

1. 初始化串口：通过 `chSequentialStreamInit()` 函数初始化串口流。

2. 配置串口：通过 `sdStart()` 函数和 `serialSetBaudrate()` 函数配置串口波特率等参数。

3. 注册回调函数：通过 `sdRegisterRead()` 函数注册串口读取回调函数。

4. 启动串口：通过 `sdStart()` 函数启动串口。

static const SerialConfig mySerialConfig = {
    115200, // 波特率
    USART_WORDLENGTH_8D, // 数据位数
    USART_STOPBITS_1, // 停止位
    USART_PARITY_NONE // 校验方式
};

void MySerialCallback(SerialDriver *sd) {
    uint8_t c;
    while (sdGetTimeout(sd, TIME_IMMEDIATE) == Qnil) {
        c = sdGetChar(sd);
        // 处理接收到的字符
    }
}

void MySerialInit(void) {
    sdStart(&SD2, &mySerialConfig); // SD2是串口2的驱动
    sdRegisterRead(&SD2, MySerialCallback); // 注册回调函数
}

### 5.2.2 串口通信的调试与优化

串口通信的调试和优化对于确保数据传输的准确性和效率至关重要。调试串口通信一般涉及检查物理连接、确认串口参数设置、观察通信数据的正确性、分析通信过程中的错误和异常情况。

优化串口通信可以考虑以下几点：

1. 使用硬件流控制减少数据溢出的风险。

2. 对重要数据包使用校验和或CRC校验，确保数据的完整性和准确性。

3. 采用 DMA 传输数据，减少CPU在数据传输上的负载。

4. 使用缓存来提高数据读写的效率。

5. 优化数据包的大小和结构，减少数据包之间的间隔时间，以提高吞吐量。

## 5.3 网络通信与协议栈集成

### 5.3.1 网络协议栈的基本概念

在嵌入式系统中集成网络协议栈，可以实现与外部网络的连接，这对于物联网设备尤为重要。CHIBIOS支持TCP/IP协议栈，常见的协议栈包括LwIP和uIP。

网络协议栈提供了不同层级的服务：

- 链路层：如以太网、Wi-Fi等。
- 网络层：负责IP地址分配、数据包路由等。
- 传输层：支持TCP和UDP协议，用于建立可靠的或无连接的通信。
- 应用层：如HTTP、MQTT、CoAP等应用层协议。

### 5.3.2 实现基于TCP/IP协议的数据交互

在CHIBIOS中，实现基于TCP/IP协议的数据交互一般需要以下步骤：

1. 初始化网络设备：配置网络接口，设置IP地址、子网掩码和网关。

2. 初始化协议栈：初始化LwIP或uIP协议栈。

3. 创建套接字：创建TCP或UDP套接字，并进行必要的配置。

4. 连接服务器：如果是TCP连接，还需要进行三次握手建立连接。

5. 数据交互：进行数据的发送和接收操作。

6. 关闭连接：完成数据交互后关闭套接字，释放资源。

下面是一个基于LwIP协议栈的TCP客户端示例代码：

#include "lwip/tcp.h"

struct tcp_pcb *myTcpClient;
err_t myTcpConnect(void *arg, struct tcp_pcb *newpcb, err_t err) {
    myTcpClient = newpcb;
    // 连接到服务器
    err = tcp_connect(myTcpClient, ip_addr_t *ipaddr, u16_t port, myTcpConnectedCallback);
    if (err == ERR_OK) {
        // 连接成功处理
    } else {
        // 连接失败处理
    }
    return ERR_OK;
}

void myTcpConnectedCallback(void *arg, struct tcp_pcb *tpcb, err_t err) {
    if (err == ERR_OK) {
        // 连接成功回调处理
    } else {
        // 连接失败回调处理
    }
}

void myTcpReceiveCallback(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
    if (p != NULL) {
        // 接收到数据处理
        tcp_recved(tpcb, p->tot_len);
        pbuf_free(p); // 释放接收到的数据包
    }
}

通过以上步骤，我们可以实现基于CHIBIOS的网络通信，并通过TCP/IP协议栈与其他设备或服务进行数据交互。