zephyrproject/
├── zephyr/
│   ├── arch/           # 架构支持（ARM, RISC-V, x86, ARC, Xtensa等）
│   ├── boards/         # 500+板级支持
│   ├── drivers/        # 设备驱动（传感器、外设、通信）
│   ├── subsys/         # 子系统（蓝牙、网络、USB、文件系统、电源管理）
│   ├── kernel/         # 内核（调度、同步、IPC、内存管理）
│   ├── include/        # 公共API头文件（POSIX-like接口）
│   └── cmake/          # CMake构建系统
├── modules/            # 第三方模块（MCUboot, TF-M, LVGL等）
└── west.yml            # 多仓库管理清单

rt-thread/
├── src/               # 内核源码（调度、IPC、时钟、内存）
├── include/           # 内核头文件
├── components/        # 组件层
│   ├── dfs/           # 虚拟文件系统
│   ├── finsh/         # 命令行Shell
│   ├── net/           # 网络协议栈（SAL抽象层）
│   ├── at_device/     # AT指令设备框架
│   └── drivers/       # 驱动框架
├── bsp/               # 200+板级支持包
├── libcpu/            # CPU架构适配
└── packages/          # 500+第三方软件包

FreeRTOS/
├── FreeRTOS/
│   ├── Source/
│   │   ├── tasks.c           # 任务管理
│   │   ├── queue.c           # 队列（信号量/互斥锁基于队列实现）
│   │   ├── list.c            # 链表（调度器内部数据结构）
│   │   ├── timers.c          # 软件定时器
│   │   ├── event_groups.c    # 事件组
│   │   ├── stream_buffer.c   # 流缓冲区
│   │   └── portable/         # 硬件移植层（GCC/IAR/Keil等编译器+架构）
│   ├── include/
│   └── Demo/                 # 各平台示例
├── FreeRTOS-Plus/
│   ├── TCP/                  # FreeRTOS+TCP
│   ├── FAT/                  # FreeRTOS+FAT
│   └── CLI/                  # FreeRTOS+CLI

nuttx/
├── arch/               # 架构支持（ARM, RISC-V, x86, MIPS, Xtensa等）
├── drivers/            # 设备驱动（USB, CAN, Audio, Video, Graphics）
├── fs/                 # 文件系统（VFS, ROMFS, NFS, procfs, tmpfs）
├── net/                # 网络协议栈（TCP/IP, UDP, Socket API）
├── include/            # POSIX标准头文件（pthread.h, socket.h等）
├── sched/              # 调度器（POSIX线程模型）
├── mm/                 # 内存管理（支持MMU-less）
├── audio/              # 音频子系统
└── graphics/           # 图形子系统（NxWidgets, LVGL）

micro_ros/
├── micro_ros_setup/          # 环境搭建脚本
├── rclc/                     # ROS2 C客户端库（轻量版rclcpp）
├── rclc_lifecycle/           # 节点生命周期管理
├── rclc_parameter/           # 参数服务器客户端
├── rmw_microxrcedds/         # DDS-XRCE中间件（eProsima）
├── micro_ros_agent/          # 宿主机代理（连接MCU到ROS2网络）
└── micro_ros_arduino/        # Arduino平台集成

# ===== 安装 west 工具 =====
pip install west

# ===== 初始化Zephyr工作区 =====
west init -m https://github.com/zephyrproject-rtos/zephyr my-zephyr-app
cd my-zephyr-app
west update

# ===== 安装SDK和依赖 =====
west sdk install
pip install -r zephyr/scripts/requirements.txt

# ===== 创建应用目录 =====
mkdir -p app/src

// app/src/main.c —— Zephyr双任务示例
#include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>

#define STACK_SIZE 1024
#define TASK1_PRIO 5
#define TASK2_PRIO 6

K_THREAD_STACK_DEFINE(task1_stack, STACK_SIZE);
K_THREAD_STACK_DEFINE(task2_stack, STACK_SIZE);

struct k_thread task1_data, task2_data;
struct k_mutex my_mutex;

void task1_entry(void *p1, void *p2, void *p3)
{
    while (1) {
        k_mutex_lock(&my_mutex, K_FOREVER);
        printk("[TASK1] Sensor reading at %d ms\n", k_uptime_get_32());
        k_mutex_unlock(&my_mutex);
        k_msleep(100);
    }
}

void task2_entry(void *p1, void *p2, void *p3)
{
    while (1) {
        k_mutex_lock(&my_mutex, K_FOREVER);
        printk("[TASK2] Data processing at %d ms\n", k_uptime_get_32());
        k_mutex_unlock(&my_mutex);
        k_msleep(250);
    }
}

void main(void)
{
    k_mutex_init(&my_mutex);

    k_thread_create(&task1_data, task1_stack,
        K_THREAD_STACK_SIZEOF(task1_stack),
        task1_entry, NULL, NULL, NULL,
        TASK1_PRIO, 0, K_NO_WAIT);

    k_thread_create(&task2_data, task2_stack,
        K_THREAD_STACK_SIZEOF(task2_stack),
        task2_entry, NULL, NULL, NULL,
        TASK2_PRIO, 0, K_NO_WAIT);

    printk("Zephyr RTOS started\n");
}

# app/CMakeLists.txt
cmake_minimum_required(VERSION 3.20)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(my_app)

target_sources(app PRIVATE src/main.c)

# ===== 编译（以STM32F4为例）=====
west build -b stm32f4_disco app/

# ===== 烧录 =====
west flash

# ===== 查看串口输出 =====
west build -t run

# ===== 克隆RT-Thread =====
git clone https://github.com/RT-Thread/rt-thread.git
cd rt-thread/bsp/stm32/stm32f407-atk-explorer

# ===== 使用env工具配置（或RT-Thread Studio图形化）=====
scons --menuconfig
# 勾选：RT-Thread Kernel → Kernel Device Object
# 勾选：RT-Thread Components → Command shell (FinSH)

// applications/main.c —— RT-Thread双线程示例
#include <rtthread.h>

#define THREAD_PRIORITY 25
#define THREAD_STACK_SIZE 512
#define THREAD_TIMESLICE 5

static struct rt_mutex dynamic_mutex;
static rt_thread_t tid1 = RT_NULL;
static rt_thread_t tid2 = RT_NULL;

static void thread1_entry(void *parameter)
{
    while (1) {
        rt_mutex_take(&dynamic_mutex, RT_WAITING_FOREVER);
        rt_kprintf("[TASK1] Sensor reading at %d ms\n",
            rt_tick_get());
        rt_mutex_release(&dynamic_mutex);
        rt_thread_mdelay(100);
    }
}

static void thread2_entry(void *parameter)
{
    while (1) {
        rt_mutex_take(&dynamic_mutex, RT_WAITING_FOREVER);
        rt_kprintf("[TASK2] Data processing at %d ms\n",
            rt_tick_get());
        rt_mutex_release(&dynamic_mutex);
        rt_thread_mdelay(250);
    }
}

int main(void)
{
    rt_mutex_init(&dynamic_mutex, "dmutex", RT_IPC_FLAG_FIFO);

    tid1 = rt_thread_create("sensor",
        thread1_entry, RT_NULL,
        THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
    if (tid1 != RT_NULL) rt_thread_startup(tid1);

    tid2 = rt_thread_create("process",
        thread2_entry, RT_NULL,
        THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
    if (tid2 != RT_NULL) rt_thread_startup(tid2);

    rt_kprintf("RT-Thread started\n");
    return 0;
}

# ===== 编译（生成Keil MDK工程）=====
scons --target=mdk5

# ===== 或用scons直接编译（需要工具链）=====
scons -j4

# ===== 烧录后打开串口，进入FinSH Shell =====
# 常用FinSH命令：
list_thread          # 列出所有线程
list_sem             # 列出所有信号量
list_mutex           # 列出所有互斥锁
free                 # 查看内存使用
ps                   # 查看线程状态

# ===== 克隆FreeRTOS =====
git clone https://github.com/FreeRTOS/FreeRTOS.git --depth 1
cd FreeRTOS/FreeRTOS/Demo/CORTEX_M4F_STM32F407ZG-SK

# FreeRTOS没有构建系统，直接把源文件加入工程
# 核心文件：tasks.c, queue.c, list.c, timers.c
# 移植文件：portable/GCC/ARM_CM4F/port.c
# 内存管理：portable/MemMang/heap_4.c

// main.c —— FreeRTOS双任务示例
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"

SemaphoreHandle_t xMutex;

void vTask1(void *pvParameters)
{
    const char *pcTaskName = "Sensor";
    for (;;) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY) == pdTRUE) {
            printf("[%s] Reading at %lu ms\n",
                pcTaskName, xTaskGetTickCount());
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void vTask2(void *pvParameters)
{
    const char *pcTaskName = "Process";
    for (;;) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY) == pdTRUE) {
            printf("[%s] Processing at %lu ms\n",
                pcTaskName, xTaskGetTickCount());
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(pdMS_TO_TICKS(250));
    }
}

int main(void)
{
    xMutex = xSemaphoreCreateMutex();

    xTaskCreate(vTask1, "Sensor",
        configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate(vTask2, "Process",
        configMINIMAL_STACK_SIZE, NULL, 2, NULL);

    printf("FreeRTOS started\n");
    vTaskStartScheduler();

    for (;;);  /* 不应该到达这里 */
    return 0;
}

// FreeRTOSConfig.h —— 关键配置项
#define configUSE_PREEMPTION            1
#define configUSE_IDLE_HOOK             0
#define configUSE_TICK_HOOK             0
#define configCPU_CLOCK_HZ              ( ( unsigned long ) 168000000 )
#define configTICK_RATE_HZ              ( ( TickType_t ) 1000 )
#define configMAX_PRIORITIES            ( 5 )
#define configMINIMAL_STACK_SIZE        ( ( unsigned short ) 128 )
#define configTOTAL_HEAP_SIZE           ( ( size_t ) ( 17 * 1024 ) )
#define configMAX_TASK_NAME_LEN         ( 16 )
#define configUSE_MUTEXES               1

# ===== 编译（以GCC为例）=====
arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb \
    -I FreeRTOS/Source/include \
    -I FreeRTOS/Source/portable/GCC/ARM_CM4F \
    main.c \
    FreeRTOS/Source/tasks.c \
    FreeRTOS/Source/queue.c \
    FreeRTOS/Source/list.c \
    FreeRTOS/Source/timers.c \
    FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c \
    FreeRTOS/Source/portable/MemMang/heap_4.c \
    -o firmware.elf

# ===== 烧录（以STM32为例）=====
openocd -f board/stm32f4discovery.cfg \
    -c "program firmware.elf verify reset exit"

# ===== 克隆NuttX =====
git clone https://github.com/apache/nuttx.git
git clone https://github.com/apache/nuttx-apps.git apps

cd nuttx

# ===== 配置板级支持（以STM32F4Discovery为例）=====
./tools/configure.sh stm32f4discovery:nsh

# ===== 图形化配置 =====
make menuconfig
# 勾选：Build Setup → Debug Options → Enable Debug Symbols
# 勾选：Application Configuration → Examples → Hello World

// 创建自定义应用 —— apps/examples/myapp/myapp_main.c
#include <nuttx/config.h>
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

static sem_t my_sem;

void *task1_routine(void *arg)
{
    while (1) {
        sem_wait(&my_sem);
        printf("[TASK1] Sensor reading at %lu ms\n",
            (unsigned long)clock());
        sem_post(&my_sem);
        usleep(100000);  /* 100ms */
    }
    return NULL;
}

void *task2_routine(void *arg)
{
    while (1) {
        sem_wait(&my_sem);
        printf("[TASK2] Data processing at %lu ms\n",
            (unsigned long)clock());
        sem_post(&my_sem);
        usleep(250000);  /* 250ms */
    }
    return NULL;
}

int main(int argc, char *argv[])
{
    pthread_t tid1, tid2;
    sem_init(&my_sem, 0, 1);

    pthread_create(&tid1, NULL, task1_routine, NULL);
    pthread_create(&tid2, NULL, task2_routine, NULL);

    printf("NuttX POSIX RTOS started\n");

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

# ===== 编译 =====
make -j$(nproc)

# ===== 产物位置 =====
ls nuttx.bin     # 固件镜像

# ===== 烧录（以STM32为例）=====
openocd -f board/stm32f4discovery.cfg \
    -c "program nuttx.bin 0x08000000 verify reset exit"

# ===== 串口连接后，进入NSH Shell =====
# NuttX Shell (NSH)
nsh> help
nsh> ps         # 查看进程
nsh> free       # 查看内存
nsh> ls /dev    # 查看设备节点（POSIX风格！）

# ===== 安装micro-ROS工具 =====
source /opt/ros/humble/setup.bash
mkdir -p ~/microros_ws/src
cd ~/microros_ws
git clone -b humble https://github.com/micro-ROS/micro_ros_setup.git \
    src/micro_ros_setup
rosdep update && rosdep install --from-paths src --ignore-src -y
colcon build
source install/setup.bash

# ===== 创建固件工作区（以ESP32为例）=====
ros2 run micro_ros_setup create_firmware_ws.sh freertos esp32
ros2 run micro_ros_setup configure_firmware.sh int32_publisher_app

// main.c —— micro-ROS话题发布示例
#include <rcl/rcl.h>
#include <rcl/error_handling.h>
#include <rclc/rclc.h>
#include <rclc/executor.h>
#include <std_msgs/msg/int32.h>

#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

#define RCCHECK(fn) { rcl_ret_t temp_rc = fn; \
    if ((temp_rc != RCL_RET_OK)) { \
        printf("Failed status on line %d: %d\n", \
            __LINE__, (int)temp_rc); \
        vTaskDelete(NULL); }}

rcl_publisher_t publisher;
std_msgs__msg__int32 msg;

void timer_callback(rcl_timer_t *timer, int64_t last_call_time)
{
    (void) last_call_time;
    msg.data++;
    RCSOFTCHECK(rcl_publish(&publisher, &msg, NULL));
    printf("Published: %d\n", msg.data);
}

void appMain(void *arg)
{
    rcl_allocator_t allocator = rcl_get_default_allocator();
    rclc_support_t support;
    rcl_node_t node;

    RCCHECK(rclc_support_init(&support, 0, NULL, &allocator));
    RCCHECK(rclc_node_init_default(&node, "esp32_node",
        "", &support));

    RCCHECK(rclc_publisher_init_default(
        &publisher, &node,
        ROSIDL_GET_MSG_TYPE_SUPPORT(std_msgs, msg, Int32),
        "esp32_sensor_data"));

    rcl_timer_t timer;
    RCCHECK(rclc_timer_init_default(&timer, &support,
        RCL_MS_TO_NS(500), timer_callback));

    rclc_executor_t executor;
    RCCHECK(rclc_executor_init(&executor,
        &support.context, 1, &allocator));
    RCCHECK(rclc_executor_add_timer(&executor, &timer));

    msg.data = 0;
    printf("micro-ROS node started\n");

    rclc_executor_spin(&executor);

    RCCHECK(rcl_publisher_fini(&publisher, &node));
    RCCHECK(rcl_node_fini(&node));
    vTaskDelete(NULL);
}

void app_main(void)
{
    xTaskCreate(appMain, "uros_task",
        20000, NULL, 5, NULL);
}

# ===== 编译固件 =====
ros2 run micro_ros_setup build_firmware.sh

# ===== 烧录到ESP32 =====
ros2 run micro_ros_setup flash_firmware.sh

# ===== 在宿主机启动Agent（串口方式）=====
ros2 run micro_ros_agent micro_ros_agent serial \
    --dev /dev/ttyUSB0 -b 115200

# ===== 验证：在宿主机上查看话题 =====
ros2 topic list
# 输出：/esp32_sensor_data

ros2 topic echo /esp32_sensor_data
# 输出：data: 1
#       data: 2
#       data: 3
#       ...

# ===== Zephyr调试 =====
west build -t menuconfig       # 图形化配置
west build -t guiconfig        # GUI配置
west debug                     # 启动调试器
west build -t ram_report       # 查看RAM占用
west build -t rom_report       # 查看ROM占用

# ===== RT-Thread调试 =====
scons --menuconfig             # 配置
scons --target=mdk5            # 生成MDK工程
scons -c                       # 清理

# ===== FreeRTOS调试 =====
# 无专用构建工具，依赖IDE（Keil/IAR/STM32CubeIDE）
# 运行时API：
# uxTaskGetStackHighWaterMark() # 查看栈余量
# vTaskList()                   # 打印任务列表
# xPortGetFreeHeapSize()        # 查看剩余堆

# ===== NuttX调试 =====
./tools/configure.sh -L        # 列出所有配置
make menuconfig                # 配置
make clean                     # 清理
make distclean                 # 完全清理

# ===== micro-ROS调试 =====
ros2 run micro_ros_setup create_agent_ws.sh   # 创建Agent工作区
ros2 run micro_ros_setup build_agent.sh       # 编译Agent
ros2 topic list                               # 查看话题
ros2 topic echo /topic_name                   # 查看话题内容