↓跳过正文
VxWorks 7

完整的 VxWorks 编程指南 (2025 年版)

VxWorks RTOS 编程指南 实时操作系统 Wind River VxBus 网络
目录

VxWorks 是在航空航天、国防、汽车、机器人和工业控制等关键任务领域中应用最广泛的实时操作系统（RTOS）之一。VxWorks 因其确定性、安全认证和安全性而备受信任，并持续发展，为开发者提供了现代工具、容器支持和灵活的编程模型。

本指南提供了2025 年版的全面 VxWorks 编程内容，包含实用的代码示例和开发者最佳实践。

为什么在 2025 年选择 VxWorks？
#

  • 确定性调度：具备微秒级响应的硬实时保证。
  • 跨平台支持：可在 ARM、x86、PowerPC、MIPS、RISC-V 上运行。
  • 安全认证：DO-178C（航空电子）、ISO 26262（汽车）、IEC 61508（工业）。
  • 现代功能：容器化、安全强化、AI/ML 边缘集成。

如果您的应用需要可预测性和安全性，VxWorks 仍然是首选。

1 VxWorks 架构
#

VxWorks 的核心功能包括：

  • 内核：抢占式、基于优先级的调度器。
  • 任务：具有独立堆栈/优先级的轻量级线程。
  • VxBus I/O 系统：统一的设备驱动框架。
  • 网络协议栈：双协议栈 IPv4/IPv6，支持 TSN。
  • 文件系统：NFS、HRFS、dosFS、ROMFS。
  • 安全性：内存保护、堆栈保护、安全启动。

2 开发环境设置
#

工具
#

  • Wind River Workbench IDE 或 CLI 工具链（wr-cc / gcc）。
  • 目标设备：真实硬件（ARM、PPC、x86、RISC-V）或 QEMU 模拟器。
  • 连接方式：通过串口、JTAG 或以太网连接到目标服务器。

工作流程
#

  1. 构建一个包含所需内核组件的 VxWorks 映像项目（VIP）。
  2. 编写应用程序模块或驱动程序。
  3. 部署到目标硬件。
  4. 使用 Workbench、内核 Shell 或 WDB 代理进行调试。

3 VxWorks 中的任务管理
#

任务是按优先级调度的轻量级线程。

创建任务
# 

#include <taskLib.h>
#include <stdio.h>

void helloTask(void) {
    while (1) {
        printf("Hello from VxWorks task!\n");
        taskDelay(sysClkRateGet()); // 1 秒延迟
    }
}

int main(void) {
    taskSpawn("tHello", 100, 0, 8192, (FUNCPTR) helloTask,
              0,0,0,0,0,0,0,0,0,0);
    return 0;
}

管理任务
# 

TASK_ID tid = taskSpawn("tWorker", 90, 0, 8192, (FUNCPTR) workerTask,
                        0,0,0,0,0,0,0,0,0,0);

taskSuspend(tid);   // 暂停任务
taskResume(tid);    // 恢复任务
taskDelete(tid);    // 终止任务

4 任务间通信 (IPC)
#

4.1 信号量
#

用于同步和互斥。

#include <semLib.h>

SEM_ID sem;

void producer(void) {
    while (1) {
        printf("Producing data...\n");
        semGive(sem);
        taskDelay(60);
    }
}

void consumer(void) {
    while (1) {
        semTake(sem, WAIT_FOREVER);
        printf("Consumed data!\n");
    }
}

int main(void) {
    sem = semBCreate(SEM_Q_FIFO, SEM_EMPTY);
    taskSpawn("tProd", 100, 0, 8192, (FUNCPTR) producer,0,0,0,0,0,0,0,0,0,0);
    taskSpawn("tCons", 101, 0, 8192, (FUNCPTR) consumer,0,0,0,0,0,0,0,0,0,0);
    return 0;
}

4.2 消息队列
#

用于任务到任务的通信。

#include <msgQLib.h>

MSG_Q_ID msgQ;
char buf[64];

void sender(void) {
    msgQSend(msgQ, "Hello IPC", 10, WAIT_FOREVER, MSG_PRI_NORMAL);
}

void receiver(void) {
    msgQReceive(msgQ, buf, sizeof(buf), WAIT_FOREVER);
    printf("Received: %s\n", buf);
}

int main(void) {
    msgQ = msgQCreate(10, 64, MSG_Q_PRIORITY);
    taskSpawn("tSender", 90, 0, 8192, (FUNCPTR) sender,0,0,0,0,0,0,0,0,0,0);
    taskSpawn("tReceiver", 91, 0, 8192, (FUNCPTR) receiver,0,0,0,0,0,0,0,0,0,0);
    return 0;
}

5 使用 VxBus 的设备驱动
#

VxBus 是 VxWorks 中的统一驱动框架。

驱动骨架
# 

#include <hwif/vxBus.h>
#include <hwif/vxBusCore.h>

LOCAL STATUS i2cProbe(VXB_DEV_ID dev) {
    return OK; // 找到设备
}

LOCAL STATUS i2cAttach(VXB_DEV_ID dev) {
    printf("I2C device attached!\n");
    return OK;
}

LOCAL VXB_DRV_METHOD i2cMethods[] = {
    { VXB_DEVMETHOD_CALL(vxbDevProbe),  i2cProbe },
    { VXB_DEVMETHOD_CALL(vxbDevAttach), i2cAttach },
    VXB_DEVMETHOD_END
};

VXB_DRV vxI2cDrv = {
    { NULL },
    "vxI2c",
    "Custom I2C Driver",
    VXB_BUSID_PLB,
    0, 0,
    i2cMethods,
    NULL
};

您需要在 BSP 或项目配置中注册此驱动程序，以便它在启动时加载。

6 VxWorks 中的网络编程
#

VxWorks 的网络协议栈功能齐全，支持 IPv4/IPv6、TSN（时间敏感网络）、IPSec、TLS、SNMP 等。

6.1 简单的 TCP 客户端
# 

#include <sockLib.h>
#include <inetLib.h>

int tcpClient(void) {
    int sock;
    struct sockaddr_in server;

    sock = socket(AF_INET, SOCK_STREAM, 0);
    server.sin_family = AF_INET;
    server.sin_port = htons(8080);
    inet_aton("192.168.1.10", &server.sin_addr);

    if (connect(sock, (struct sockaddr *)&server, sizeof(server)) == OK) {
        write(sock, "Hello from VxWorks", 18);
    }
    close(sock);
    return 0;
}

6.2 简单的 TCP 服务器
# 

int tcpServer(void) {
    int sock, newSock;
    struct sockaddr_in server, client;
    char buf[64];

    sock = socket(AF_INET, SOCK_STREAM, 0);
    server.sin_family = AF_INET;
    server.sin_port = htons(8080);
    server.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(sock, (struct sockaddr *)&server, sizeof(server));
    listen(sock, 5);

    while (1) {
        int addrlen = sizeof(client);
        newSock = accept(sock, (struct sockaddr *)&client, &addrlen);
        read(newSock, buf, sizeof(buf));
        printf("Received: %s\n", buf);
        close(newSock);
    }
    return 0;
}

6.3 UDP 客户端
#

UDP 是轻量级的，非常适合实时遥测。

int udpClient(void) {
    int sock;
    struct sockaddr_in server;
    char msg[] = "Telemetry packet";

    sock = socket(AF_INET, SOCK_DGRAM, 0);
    server.sin_family = AF_INET;
    server.sin_port = htons(9000);
    inet_aton("192.168.1.20", &server.sin_addr);

    sendto(sock, msg, sizeof(msg), 0,
           (struct sockaddr *)&server, sizeof(server));
    close(sock);
    return 0;
}

6.4 UDP 服务器
# 

int udpServer(void) {
    int sock;
    struct sockaddr_in server, client;
    char buf[128];

    sock = socket(AF_INET, SOCK_DGRAM, 0);
    server.sin_family = AF_INET;
    server.sin_port = htons(9000);
    server.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(sock, (struct sockaddr *)&server, sizeof(server));

    while (1) {
        int addrlen = sizeof(client);
        int n = recvfrom(sock, buf, sizeof(buf), 0,
                         (struct sockaddr *)&client, &addrlen);
        buf[n] = '\0';
        printf("Received UDP: %s\n", buf);
    }
    return 0;
}

6.5 组播接收器
#

组播在航空电子（ARINC 664）和工业自动化中很常见。

#include <ipcom_sock.h>   // 组播选项所需

int udpMulticastRecv(void) {
    int sock;
    struct sockaddr_in addr;
    struct ip_mreq mreq;
    char buf[256];

    sock = socket(AF_INET, SOCK_DGRAM, 0);

    /* 允许多个接收器 */
    int reuse = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(reuse));

    addr.sin_family = AF_INET;
    addr.sin_port = htons(5000);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(sock, (struct sockaddr *)&addr, sizeof(addr));

    /* 加入组播组 239.255.0.1 */
    mreq.imr_multiaddr.s_addr = inet_addr("239.255.0.1");
    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
    setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq));

    while (1) {
        int n = recvfrom(sock, buf, sizeof(buf), 0, NULL, 0);
        buf[n] = '\0';
        printf("Multicast received: %s\n", buf);
    }
    return 0;
}

6.6 组播发送器
# 

int udpMulticastSend(void) {
    int sock;
    struct sockaddr_in addr;
    char msg[] = "Multicast data packet";

    sock = socket(AF_INET, SOCK_DGRAM, 0);

    addr.sin_family = AF_INET;
    addr.sin_port = htons(5000);
    addr.sin_addr.s_addr = inet_addr("239.255.0.1");

    sendto(sock, msg, sizeof(msg), 0,
           (struct sockaddr *)&addr, sizeof(addr));

    close(sock);
    return 0;
}

网络最佳实践
#

  • 对于低延迟遥测，使用 UDP，但要处理数据包丢失。
  • 对于可靠连接（例如，命令/控制），使用 TCP。
  • 对于一对多的数据分发，使用 组播。
  • 始终检查超时，以避免无限期阻塞。
  • 在安全关键应用中，验证所有收到的数据包。

7 内存管理
#

VxWorks 支持平面内存模型，并可选地支持 MMU 保护。

创建私有堆
# 

#include <memPartLib.h>

PART_ID myHeap;

void memDemo(void) {
    void *pool = malloc(1024 * 1024);
    myHeap = memPartCreate(pool, 1024 * 1024);

    void *ptr = memPartAlloc(myHeap, 256);
    printf("Allocated 256 bytes at %p\n", ptr);

    memPartFree(myHeap, ptr);
}

堆栈检查
# 

#include <taskLib.h>

void monitor(void) {
    taskStackAllotCheck(0); // 检查当前任务堆栈使用情况
}

8 调试和性能分析
#

内核 Shell
# 

-> i
  NAME        ENTRY       TID    PRI  STATUS
  tHello      helloTask   0x3c8  100  READY

系统查看器 (System Viewer)
#

捕获上下文切换、ISR 事件和任务状态，用于实时性能分析。

WDB 代理
#

允许通过 Workbench 进行远程调试。

9 最佳实践
#

  • 使用优先级继承信号量来避免优先级反转。
  • 保持中断服务程序（ISR）简短，将繁重工作推迟到任务中处理。
  • 始终启用堆栈溢出保护。
  • 将应用程序逻辑与 BSP/设备树配置分开。
  • 使用模糊测试和故障注入来验证鲁棒性。

10 VxWorks 开发的未来
#

  • RISC-V 支持在安全关键领域不断扩展。
  • 容器化以支持现代 DevOps 工作流程。
  • 通过更强的加密和运行时检查来强化网络安全。
  • AI/ML 边缘计算，利用 GPU/DSP 集成。

11 VxWorks 7 中的设备树配置
#

从 VxWorks 7 开始，RTOS 使用 Flattened Device Tree (FDT) 以标准化、可移植的方式描述硬件。 BSP 在启动时解析 .dts 文件，并且 VxBus 驱动程序会自动附加到匹配的节点。

示例：添加一个 I2C 控制器
#

device-tree.dts

&i2c0 {
    status = "okay";
    clock-frequency = <100000>;   /* 100 kHz */
    myTempSensor@48 {
        compatible = "myvendor,temp-sensor";
        reg = <0x48>;
    };
};
  • i2c0 → 指向 SoC 中现有的 I2C 控制器。
  • myTempSensor@48 → 地址为 0x48 的设备节点。
  • compatible → 与您的 VxBus 驱动程序匹配。

编写匹配的驱动程序
# 

LOCAL STATUS tempProbe(VXB_DEV_ID dev) {
    VXB_DEV_ID parent = vxbDevParent(dev);
    if (vxbResourceAlloc(dev) != OK)
        return ERROR;
    return OK;
}

LOCAL STATUS tempAttach(VXB_DEV_ID dev) {
    printf("Temp sensor attached: %s\n", vxbDevNameGet(dev));
    return OK;
}

LOCAL VXB_DRV_METHOD tempMethods[] = {
    { VXB_DEVMETHOD_CALL(vxbDevProbe),  tempProbe },
    { VXB_DEVMETHOD_CALL(vxbDevAttach), tempAttach },
    VXB_DEVMETHOD_END
};

VXB_DRV tempDrv = {
    { NULL },
    "tempSensor",
    "Custom Temp Sensor Driver",
    VXB_BUSID_I2C,
    0, 0,
    tempMethods,
    NULL
};

现在，当系统启动时，该传感器节点将被自动探测并附加。

12 MMU 属性和内存映射
#

VxWorks 在 ARM、PPC 和 x86 上支持基于 MMU 的内存保护。 您可以为每个内存区域配置缓存、访问权限和可缓冲性。

示例：设置 MMU 属性
# 

#include <vmLib.h>
#include <private/vmLibP.h>

void mmuSetup(void) {
    VM_CONTEXT_ID ctx = vmCurrentGet();

    /* 为 MMIO 设备定义一个不可缓存的内存区域 */
    void *physAddr = (void *)0x40000000;  // 设备基地址
    size_t size = 0x1000;

    vmRegionAdd(ctx, physAddr, size,
                VM_STATE_MASK_CACHEABLE | VM_STATE_MASK_WRITABLE,
                VM_STATE_CACHEABLE_NOT | VM_STATE_WRITABLE);

    printf("MMU region added at %p, size %x\n", physAddr, (int)size);
}
  • VM_STATE_CACHEABLE_NOT → 禁用 MMIO 的缓存。
  • VM_STATE_WRITABLE → 启用写入访问。

常见属性配置
#

用途 缓存 可缓冲性 访问权限
Flash/ROM 开启 否 只读
RAM 开启 是 读/写
MMIO (设备) 关闭 否 读/写
共享缓冲区 开启 是 读写（原子）

13 VxWorks 7 中的中断处理
#

在嵌入式系统中，中断对于以最小延迟处理硬件事件至关重要。 VxWorks 允许您注册在中断上下文中运行的中断服务程序（ISRs），以及在任务上下文中运行的延迟服务程序（DSRs）。

注册一个 ISR
# 

#include <intLib.h>
#include <stdio.h>

LOCAL int irqCount = 0;

/* 简单的 ISR */
LOCAL void myIsr(void *arg) {
    irqCount++;
    printf("ISR fired, count = %d\n", irqCount);
}

void irqSetup(void) {
    int irqLine = 32; // 示例 IRQ 线
    if (intConnect((VOIDFUNCPTR *)INUM_TO_IVEC(irqLine), myIsr, 0) == OK) {
        intEnable(irqLine);
        printf("ISR registered on IRQ %d\n", irqLine);
    }
}
  • intConnect() → 将 ISR 附加到中断向量。
  • intEnable() → 启用硬件中断线。

最佳实践：保持 ISR 简短
#

ISR 应该尽可能精简，将繁重的工作推迟到任务中处理。 使用信号量或消息队列来移交工作。

#include <semLib.h>

SEM_ID isrSem;

LOCAL void myIsr(void *arg) {
    semGive(isrSem);   // 信号通知任务
}

void irqTask(void) {
    while (1) {
        semTake(isrSem, WAIT_FOREVER);
        printf("Interrupt handled in task context\n");
    }
}

void irqDemo(void) {
    int irqLine = 40;
    isrSem = semBCreate(SEM_Q_FIFO, SEM_EMPTY);

    intConnect((VOIDFUNCPTR *)INUM_TO_IVEC(irqLine), myIsr, 0);
    intEnable(irqLine);

    taskSpawn("tIrqTask", 100, 0, 8192, (FUNCPTR) irqTask,
              0,0,0,0,0,0,0,0,0,0);
}

这里：

  • ISR 通过 semGive() 发出信号。
  • 工作任务进行实际处理。
  • 保持中断延迟低。

处理共享中断
#

如果多个设备共享一个 IRQ，您的 ISR 必须在服务之前检查设备的状态寄存器：

LOCAL void sharedIsr(void *arg) {
    if (deviceStatus() & DEVICE_IRQ) {
        clearDeviceIrq();
        semGive(isrSem);
    }
}

常见陷阱
#

  • ❌ 在 ISR 中使用 printf()（慢，不具确定性）。
  • ❌ 在 ISR 中分配内存。
  • ❌ 在 ISR 中进行长循环。
  • ✅ 始终将工作推迟到任务中处理。

结语
#

本指南现在涵盖了VxWorks 编程的整个核心范围：

  • 任务管理和 IPC
  • 设备树配置
  • 驱动程序开发（VxBus）
  • 网络
  • 内存管理和 MMU 属性
  • 调试和性能分析
  • 中断处理（ISR + 延迟任务）

这些技能将共同赋能开发者，在 VxWorks 7 及更高版本上构建安全、可靠、实时的应用程序。

凭借其经过验证的可靠性和前瞻性的功能，VxWorks 将继续在关键任务嵌入式系统**中占据主导地位。

如果您正在构建下一代自动驾驶汽车、医疗设备或卫星系统，VxWorks 编程专业知识是一项宝贵的技能。

The Complete VxWorks Programming Guide (2025 Edition)

相关文章

深入解析 VxWorks 内存管理：堆、栈、MMU、虚拟内存与嵌入式系统最佳实践
VxWorks RTOS 内存管理 嵌入式系统 实时操作系统 MMU RTP 虚拟内存
VxBus 驱动开发：VxWorks 开发人员的完整指南
VxWorks VxBus 设备驱动 嵌入式系统 RTOS 驱动程序开发
VxWorks 与 Linux 的 BSP 开发对比分析
VxWorks Linux BSP 嵌入式系统 设备驱动 RTOS