VxWorks 7 SDK for Raspberry Pi 4

Introduction

The VxWorks 7 SDK is a development environment dedicated to VxWorks application developers which include the following features:

standard cross-compilation tools based on clang/LLVM which can be used to build both downloadable kernel modules (DKM) and RTP (Real Time Process) applications
simplified build management: makefile, cmake, roll-your own
target / architecture specific: includes a generic VxWorks kernel which is bootable on the target platform
header files and libraries for application development
Wind River Debugger (wrdbg)
documentation

This guide helps you get up and running with developing applications for platforms running VxWorks. You can use it for creating new applications, or just exploration of VxWorks capabilities.

Setting up the development environment

You should start by downloading a VxWorks SDK for your platform of choice from https://labs.windriver.com and unpacking it. Refer to the documentation in docs in the unpacked SDK for additional information on creating and debugging applications.

OS requirements

The SDKs are meant to run on Linux hosts. Some of the examples in this document are specific to Debian derivatives.

Prerequisite(s)

Host dependencies

On Debian derivatives, the following packages need to be installed:

sudo apt install build-essential libc6:i386

Having an FTP server installed on your development host will make application deployment easier and allow you to access the host file system from a VxWorks target.

To accommodate for the varying runtime configurations of the VxWorks kernel images included in the SDKs, you may be interested in using an FTP server option based on pyftpdlib.

Install pyftpdlib.

sudo apt install python-pip
sudo pip install pyftpdlib

Booting VxWorks on Raspberry Pi 4

To create the SD card, download the firmware from:

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

E.g.
wget https://github.com/raspberrypi/firmware/archive/1.20200212.tar.gz

Format an SD card as a FAT32 file system and copy the contents of the "boot" directory from the downloaded firmware to the SD card.
Compile a u-boot binary for Raspberry Pi 4 and copy it to the SD card

E.g. on a Ubuntu/Debian host

$ sudo apt install gcc-arm-linux-gnueabihf
$ git clone https://gitlab.denx.de/u-boot/u-boot.git
$ cd u-boot
$ CROSS_COMPILE=aarch64-linux-gnu- make rpi_4_defconfig
$ CROSS_COMPILE=aarch64-linux-gnu- make

Copy u-boot.bin to the SD card as u-boot-64.bin
Copy the files in bsps/rpi_/boot/sdcard/ to the SD card.
Copy the VxWorks kernel image bsps/rpi_4_0_1_1_0/uboot/uVxWorks to the SD card.
Connect a USB to serial cable to the Raspberry Pi

On the Raspberry Pi 4 Model, GPIOs 12 and 13 (UART 5, transmit on pin 32/GPIO12, receive on pin 33/GPIO13) ) are used as UART transmit and receive pins (UART5).

Connect the USB to serial cable adapter between the Raspberry Pi and your PC. Then start a serial communication program (e.g. minicom) and configure the serial connnection parameters as follows:

Bps/Par/Bits       : 115200 8N1
Hardware Flow Control : No
Software Flow Control : No

NOTE: VxWorks console on HDMI display

The Raspberry Pi 4 VxWorks kernel included in this SDK release includes HDMI and USB keyboard support. While the recommended usage scenario is the one with the USB to serial adapter, you can use the Raspberry Pi 4 without one.
A micro-HDMI - HDMI cable is required to connect a display to the Raspberry Pi 4 on port HDMI0 (the one closest to the USB-C power connector). Plug in a USB keyboard in one of the USB host ports on the Raspberry Pi.

After plugging in the SD card in your Raspberry Pi and powering it up, the VxWorks kernel previously copied onto the SD card will boot automatically.

U-MMC:   emmc2@7e340000: 0, mmcnr@7e300000: 1
Loading Environment from FAT... OK
In:    serial
Out:   serial
Err:   serial
Net:   eth0: genet@7d580000
Hit any key to stop autoboot:  0 
6345976 bytes read in 423 ms (14.3 MiB/s)
## Booting kernel from Legacy Image at 00100000 ...
   Image Name:   vxworks
   Image Type:   AArch64 VxWorks Kernel Image (uncompressed)
   Data Size:    6345912 Bytes = 6.1 MiB
   Load Address: 00100000
   Entry Point:  00100000
   Verifying Checksum ... OK
   Loading Kernel Image
   !!! WARNING !!! Using legacy DTB
## Starting vxWorks at 0x00100000, device tree at 0x00000000 ...
Target Name: vxTarget 
 
 _________            _________
 \77777777\          /77777777/
  \77777777\        /77777777/
   \77777777\      /77777777/
    \77777777\    /77777777/
     \77777777\   \7777777/
      \77777777\   \77777/              VxWorks 7 SMP 64-bit
       \77777777\   \777/
        \77777777\   \7/     Core Kernel version: 3.1.2.2
         \77777777\   -      Build date: Mar 25 2020 21:16:50
          \77777777\
           \7777777/         Copyright Wind River Systems, Inc.
            \77777/   -                 1984-2020
             \777/   /7\
              \7/   /777\
               -   -------

                   Board: Raspberry Pi 4 Model B - ARMv8
               CPU Count: 4
          OS Memory Size: ~447MB
        ED&R Policy Mode: Deployed
     Debug Agent: Not started
         Stop Mode Agent: Not started
              BSP Status: *** UNSUPPORTED ***


 Adding 12365 symbols for standalone.

->

Supported features:

SD card
USB mass storage
network - defaulting to DHCP
USB keyboard
VxWorks console on HDMI display

Application development

Start by opening a Linux terminal window and going to the location of your unpacked VxWorks SDK.

Source the SDK environment file to update your PATH and environmental variables, gaining direct access to the tools included within the SDK.

$ source <SDK_DIR>/toolkit/wind_sdk_env.linux

Building applications

A "hello world" C application can be built as:

$ $CC hello.c -static -o hello

Make a note of the location of your application.

Running applications

Start an FTP server on port 21 with user "target" and password "vxtarget" and FTP root in the current user's home.

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

Make a note of the IP address of your development host.

If your Raspberry Pi has successfully completed DHCP negotiation, it will be able to access the host file system via a VxWorks remote file device.

In the vxWorks shell run the following command to create a device named "wrs".

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

Note: Replace 192.168.10.191 with the IP address of your development host (i.e. the one on which you're running the FTP server).

Switch to the cmd shell and navigate to the location of the RTP you have created, now available on the target via the remote file device created previously.

E.g.

-> cmd
[vxWorks *]# cd wrs
[vxWorks *]# pwd
wrs/
[vxWorks *]# cd opt
[vxWorks *]# ls
hello
hello.c
[vxWorks *]# more hello.c
#include <stdio.h>

int main(int argc, char **argv) {
    printf("Hello World\n");
    return 0;
}
[vxWorks *]#
[vxWorks *]# hello
Launching process 'hello' ...
Process 'hello' (process Id = 0xffff8000005e85d0) launched.
Hello world
[vxWorks *]#

Refer to the documentation in docs for additional information on creating and debugging applications.

Creating Rust applications

The Rust development environment is set up in a similar manner to the standard application development environment, i.e. by sourcing the SDK environment file.

E.g.

$ source <SDK_DIR>/toolkit/wind_sdk_env.linux

Building a simple hello world Rust program

$ cargo new hello
$ cd hello
$ cargo build

This will create an RTP called hello.vxe in the directory target/vxworks-target/build-mode where vxworks-target is one of the targets listed below and build-mode is either debug or release.

For example you might see an RTP in the directory: target/armv7-wrs-vxworks-eabihf/debug/hello.vxe

VxWorks Rust targets:

ARM 32-bit: armv7-wrs-vxworks-eabihf
ARM 64-bit: aarch64-wrs-vxworks
Intel 32-bit: i686-wrs-vxworks
Intel 64-bit: x86_64-wrs-vxworks

Run the hello.vxe in the VxWorks shell. You will see the following output:

Hello, world!

Note: For more information on using cargo, including how to customize the build output location or change the build mode from debug to release, see the cargo documentation here https://doc.rust-lang.org/cargo/guide/.