Deploying VxWorks 7 on Raspberry Pi 4: A Practical Guide

Deploying VxWorks on Raspberry Pi 4: A Practical Guide

VxWorks is a widely used real-time operating system (RTOS) developed by Wind River and deployed in mission-critical systems across aerospace, automotive, industrial automation, and networking infrastructure.

With modern versions of VxWorks 7, developers can experiment with the RTOS on affordable development platforms such as the Raspberry Pi 4. Powered by a quad-core ARM Cortex-A72 processor and up to 8 GB of RAM, the Raspberry Pi 4 provides a capable environment for evaluating VxWorks features including real-time scheduling, networking, device drivers, and Real-Time Processes (RTPs).

This guide walks through the process of deploying VxWorks on a Raspberry Pi 4, from preparing the development environment to booting the system and running applications.

🧰 Prerequisites

#

Before starting, prepare the following hardware and software components.

Hardware

#

• Raspberry Pi 4 Model B (4 GB or 8 GB recommended)
• MicroSD card (8 GB or larger, formatted as FAT32)
• USB-to-TTL serial adapter for UART console access
• Ethernet connection or Wi-Fi network
• Optional USB flash drive for testing storage features

Software

#

• Linux development host (Ubuntu or another Debian-based distribution recommended)
• VxWorks SDK for Raspberry Pi 4 from Wind River Labs
• Raspberry Pi firmware package
• U-Boot bootloader source
• ARM64 cross-compiler (gcc-aarch64-linux-gnu)
• Serial terminal software such as Minicom or PuTTY

Install required development tools on the Linux host:

sudo apt update
sudo apt install build-essential libc6:i386 gcc-aarch64-linux-gnu python3-pip
sudo pip install pyftpdlib

These packages provide the compiler, build tools, and utilities required to build boot components and deploy applications.

⚙️ Setting Up the Development Environment

#

After installing the required tools, the next step is to configure the VxWorks SDK and prepare the boot media.

Download and Initialize the SDK

#

Download the VxWorks SDK package for Raspberry Pi 4 and extract it.

tar -xvf vxworks-sdk.tar.gz
cd vxworks-sdk
source sdkenv.sh

The sdkenv.sh script configures environment variables required for cross-compilation and development tools.

Prepare the SD Card

#

Format the MicroSD card using the FAT32 filesystem.

Download the Raspberry Pi firmware and extract it:

wget https://github.com/raspberrypi/firmware/archive/1.20200212.tar.gz
tar -xzf 1.20200212.tar.gz

Copy the firmware boot files to the SD card:

cp -r firmware-1.20200212/boot/* /path/to/sdcard/

Next, copy the VxWorks boot files included in the SDK:

cp -r /path/to/vxsdk/sdcard/* /path/to/sdcard/

At this stage the SD card contains firmware, boot configuration files, and the VxWorks kernel image.

🔧 Building the U-Boot Bootloader

#

VxWorks on the Raspberry Pi 4 uses U-Boot as the bootloader.

Clone the U-Boot repository:

git clone https://gitlab.denx.de/u-boot/u-boot.git
cd u-boot

Configure the build for Raspberry Pi 4:

CROSS_COMPILE=aarch64-linux-gnu- make rpi_4_defconfig

Compile the bootloader:

CROSS_COMPILE=aarch64-linux-gnu- make

After compilation completes, copy the bootloader to the SD card:

cp u-boot.bin /path/to/sdcard/u-boot-64.bin

Once the SD card contains firmware, U-Boot, and the VxWorks kernel image, it is ready for booting.

🔌 Connecting the UART Console

#

Serial console access is important for monitoring the boot process and interacting with the VxWorks shell.

Connect the USB-to-TTL adapter to the Raspberry Pi GPIO pins:

Launch a serial terminal:

minicom -b 115200 -o -D /dev/ttyUSB0

Use the following settings:

• Baud rate: 115200
• Data bits: 8
• Parity: none
• Stop bits: 1
• Flow control: disabled

This console will display boot messages and provide access to the VxWorks shell.

🚀 Booting VxWorks on Raspberry Pi 4

#

Insert the prepared MicroSD card into the Raspberry Pi and power on the board.

During startup, U-Boot initializes the hardware and loads the VxWorks kernel.

Typical boot output looks similar to the following:

U-Boot 2020.07

## Booting kernel from Legacy Image at 00100000 ...
Image Name:   vxworks
...
VxWorks 7 SMP 64-bit
Board: Raspberry Pi 4 Model B

Once the kernel initializes, the VxWorks shell becomes available.

Verify the system using standard commands.

Display version information:

-> version

List running tasks:

-> i

Typical tasks include system services such as:

• tShell0
• tNet0
• tLogTask

At this point the system is fully operational.

📦 Deploying Applications

#

Applications can be deployed to the VxWorks target using FTP or network file systems.

Start a simple FTP server on the development host:

sudo python -m pyftpdlib -p 21 -u target -P vxTarget -d $HOME &

On the VxWorks target, create a network device:

-> netDevCreate("/wrs", "192.168.10.191", 1)

Access the remote filesystem:

-> cmd
[vxWorks *]# cd /wrs

You can then run executables stored on the host.

Example:

[vxWorks *]# hello

This approach allows quick testing and deployment during development.

📦 Running RTP Containers

#

Modern versions of VxWorks support containerized deployment for Real-Time Processes (RTPs).

Containerization allows applications to run in isolated environments, simplifying deployment and updates.

Build VxWorks Projects

#

Using Wind River Workbench, create:

• a VSB (VxWorks Source Build)
• a VIP (VxWorks Image Project)

Enable container components such as:

INCLUDE_CONTAINER_RUNTIME

Build both projects to generate the runtime image.

Build the Container Image

#

Create a container build directory with a Dockerfile referencing the RTP executable.

Build the image using Buildah:

buildah bud --arch arm64 --os vxworks -f Dockerfile -t philosophers

Push the OCI image to a container registry if needed.

Run the Container on VxWorks

#

On the target system:

Set the system date:

date 2026-03-01

Pull the container image:

vxc pull <account>/philosophers.oci -k

Create a container instance:

vxc create --bundle /ram0/philosophers phil

Start the container:

vxc start phil

Stop it when finished:

vxc kill phil

This workflow allows RTP applications to be deployed and managed in a modern container-based environment.

🛠 Troubleshooting

#

If the system does not boot or behave as expected, check the following common issues.

No console output

• Verify UART wiring
• Confirm baud rate settings
• Ensure the SD card contains the correct firmware and boot files

Networking issues

• Verify bootline parameters
• Confirm DHCP availability or correct IP configuration

Unsupported BSP warning

Some evaluation BSP builds may display warnings indicating unsupported status. These typically do not prevent normal development use.

Container runtime errors

Ensure the target system has internet access and valid DNS configuration.

You can test connectivity with:

ping "www.google.com"

📊 Conclusion

#

Running VxWorks on the Raspberry Pi 4 provides an accessible platform for experimenting with real-time operating systems and modern embedded development techniques.

From bootloader setup and kernel deployment to RTP containerization, the platform allows developers to explore key VxWorks capabilities on affordable hardware. This environment is particularly useful for prototyping, testing device drivers, and experimenting with networking or real-time control workloads.

As VxWorks continues to evolve with support for edge computing, AI workloads, and cloud-connected systems, platforms like the Raspberry Pi 4 offer a practical development sandbox for embedded engineers exploring these technologies.