The Ultimate VxWorks Programming Guide

🧭 Introduction

#

VxWorks is a highly reliable, real-time operating system (RTOS) designed for embedded systems. It’s used extensively in aerospace, automotive, industrial, and networking systems where deterministic performance and robustness are crucial.

This blog post is a complete VxWorks programming guide. Whether you’re new to the platform or transitioning from bare-metal or Linux-based embedded development, this guide walks you through:

• VxWorks architecture
• Development environment and tools
• Programming paradigms (tasking, inter-process communication, memory, etc.)
• Sample code using POSIX APIs and native VxWorks APIs
• Best practices

🏗️ VxWorks Architecture Overview

#

VxWorks 7 introduced a modular architecture and Real-Time Processes (RTPs), allowing user-space application development with memory protection.

Key Architectural Components

#

⚙️ Development Workflow

#

1. Setup Toolchain: Install Workbench or use diab/gcc cross-toolchains.
2. Create VxWorks Image: Select OS components in VSB (VxWorks Source Build).
3. Develop RTP or Kernel Module: Choose whether your application runs in user space (RTP) or as part of the kernel.
4. Build and Deploy: Load the image to your target via JTAG, network, or serial.
5. Debug: Use Workbench or target server for live symbol debugging.

🧪 Sample Application – Hello World (RTP)

#

// hello.c
#include <stdio.h>
#include <unistd.h>

int main(void) {
    printf("Hello from VxWorks RTP!\n");
    sleep(1);
    return 0;
}

Compile:

#

ccpentium -o hello.vxe hello.c

Run on target:

#

-> rtpSpawn("/ram0/hello.vxe", 0, 100, 0, 0)

🧵 Multitasking in VxWorks

#

VxWorks provides both POSIX threads and native tasks (taskSpawn).

Using POSIX Threads

#

#include <pthread.h>
#include <stdio.h>

void* task_func(void* arg) {
    printf("Task running\n");
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, task_func, NULL);
    pthread_join(tid, NULL);
    return 0;
}

Using VxWorks Native Tasks

#

#include <vxWorks.h>
#include <taskLib.h>

void task_func(int arg) {
    printf("VxWorks task running\n");
}

int main() {
    taskSpawn("tMyTask", 100, 0, 4096, (FUNCPTR)task_func, 0,0,0,0,0,0,0,0,0,0);
    return 0;
}

📬 Inter-Task Communication

#

VxWorks supports:

• Message Queues (msgQCreate, msgQSend, msgQReceive)
• Semaphores (semBCreate, semGive, semTake)
• Shared Memory
• Pipes and POSIX message queues

Example: Message Queue

#

MSG_Q_ID msgQId;

void senderTask() {
    msgQSend(msgQId, "Hello", 6, WAIT_FOREVER, MSG_PRI_NORMAL);
}

void receiverTask() {
    char buf[32];
    msgQReceive(msgQId, buf, sizeof(buf), WAIT_FOREVER);
    printf("Received: %s\n", buf);
}

void initTasks() {
    msgQId = msgQCreate(10, 32, MSG_Q_PRIORITY);
    taskSpawn("sender", 100, 0, 4096, (FUNCPTR)senderTask, 0,0,0,0,0,0,0,0,0);
    taskSpawn("receiver", 100, 0, 4096, (FUNCPTR)receiverTask, 0,0,0,0,0,0,0,0,0);
}

💾 File System and I/O

#

VxWorks supports DOSFS, HRFS, and raw block I/O.

Mount a USB stick

#

usrUsbInit();
usrFsLibInit();
dosFsDevCreate("/usb0", "usbMassStorageDevice", 0);

Basic File I/O

#

#include <fcntl.h>
#include <unistd.h>

int fd = open("/usb0/log.txt", O_CREAT | O_WRONLY, 0666);
write(fd, "Log Entry\n", 10);
close(fd);

🌐 Networking

#

VxWorks provides IPv4/IPv6 stacks, DHCP, SNTP, FTP, Telnet, and SSH.

Example: Send HTTP GET using BSD Sockets

#

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netdb.h>

void httpGet() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in addr;
    struct hostent* server = gethostbyname("example.com");

    addr.sin_family = AF_INET;
    addr.sin_port = htons(80);
    memcpy(&addr.sin_addr, server->h_addr, server->h_length);

    connect(sock, (struct sockaddr*)&addr, sizeof(addr));
    write(sock, "GET / HTTP/1.0\r\n\r\n", 18);
    char buf[512];
    read(sock, buf, sizeof(buf));
    printf("Response: %s\n", buf);
    close(sock);
}

🔒 Memory Management

#

• malloc, calloc, free (RTP)
• memPartAlloc, memPartFree (Kernel)
• vmLib, vmCreate, vmMap (MMU control)

Stack Overflow Protection

#

taskStackGuardPageEnable(TRUE);

✅ Best Practices

#

• Use RTPs for modularity and isolation
• Enable MMU for memory safety
• Avoid busy-wait loops; use semaphores or message queues
• Use POSIX APIs for portability
• Instrument with windview or logs for performance tuning
• Use static analysis tools to verify safety-critical code

🔚 Conclusion

#

VxWorks is a robust and modular RTOS that allows deep control over real-time embedded applications. With RTP support, POSIX compliance, and a modern development environment, it bridges traditional RTOS features with modern embedded system demands.

📚 Further Reading

#

• VxWorks Application Programmer’s Guide (PDF)
• Wind River Docs
• VxWorks Programmer’s Guide