VxWorks 7 SDK for UP² (Apollo Lake)

Introduction

UP² is a pro maker board based on the Intel's Apollo Lake platform.

The VxWorks 7 SDK is a development environment dedicated to VxWorks application developers which includes 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

Starting a local FTP server on port 21 with user "target" and password "vxtarget" and FTP root in the current user's home can be done as follows

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

# Booting VxWorks on UP²

1. Format a USB mass storage device as a FAT32 file system and copy the EFI directory from "/vxsdk/sdcard/" to the USB drive.

2. Make sure the target is powered down and insert the USB flash drive into the target’s USB port. Connect a display and a USB keyboard to the target.

3. Power up the target, and observe the VxWorks UEFI boot loader on the target console while it loads the VxWorks kernel.

Once the target has booted, the VxWorks banner becomes visible on the target console.

    Target Name: vxTarget


                              VxWorks 7 SMP
            
                Copyright 1984-2018 Wind River Systems,  Inc.
            
                     Core Kernel version: 1.2.7.0
                              Build date: Aug 10 2018 13:53:49
                                   Board: x86 Processor (ACPI_BOOT_OP) SMP/SMT PAE
                               CPU Count: 4
                          OS Memory Size: ~8020MB
                        ED&R Policy Mode: Permanantly Deployed
                    
                    
                    
    Adding 9870 symbols for standalone.

    ->

For host file system access from the VxWorks guest, start an FTP server and enable user "target" with password "vxTarget".

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

If your target 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).

Application development

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

Source the SDK development environment before using the SDK.

$ source sdkenv.sh

Developing applications from the command line

The VxWorks compiler driver (wr-cc/wr-c++) utility lets you invoke VxWorks toolchains to compile your real time process (RTP) application from command line. The SDK development environment includes a set of environment variables (CC, CXX, CPP, etc) which match the various compiler driver utilities.

Procedure:

1. Create a C source file foo.c:

#include <stdio.h>

int main(void)
    {
    printf("hello, world!\n");
    return 0;
    }

1. Compile the source file foo.c to create a Real Time Process application.

$ wr-cc -rtp foo.c -static -o foo.vxe

or

$ $CC -rtp foo.c -static -o foo.vxe

Alternatively, you can also create a Makefile and then call make to compile the source file.

all:
    $CC -rtp foo.c -static -o foo.vxe

$ make

Developing applications using CMake

By default, a generated VxWorks SDK includes CMake. When the application developer sources the SDK environment, they will automatically have access to CMake. There is no need to download, install and configure CMake separately. With VxWorks CMake, you can build existing CMake examples that are included in the generated SDK, or you can create your own projects.

CMake examples can be found in the directories /examples/rtp/hello_cmake_rtp and /examples/dkm/hello_cmake_dkm

Procedure: 1. Create a project directory, called my_project.

$ mkdir my_project

1. Create the CMakeLists.txt file in the project folder.

2. To build your project, run the following command:

$ cmake -D CMAKE_TOOLCHAIN_FILE=${WIND_SDK_HOME}/vxsdk/sysroot/mk/rtp.toolchain.cmake .

Note: RTP is used in the example. If you would like to build a DKM project instead, change the toolchain name to dkm.toolchain.cmake.

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 &

After booting VxWorks on your target, switching to the "cmd" shell will allow you to navigate to the location of your application with greater ease.

E.g.

-> cmd
[vxWorks *]# 

Placing the application in a location accessible over FTP will make it visible with minimal configuration to the VxWorks instance.

Assuming the application is located in $HOME/opt and the FTP server uses a minimal configuration which provides FTP access to $HOME:

[vxWorks *]# cd opt
[vxWorks *]# ls foo.c
foo.c
[vxWorks *]# more foo.c
#include <stdio.h>

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

Creating and deploying Python applications

Prerequisites

The VxWorks image included with the SDK contains all the prerequisites for running python applications on VxWorks.

Launch Python from the cmd shell to print the Hello World! string:

[vxWorks *] cd /usr
[vxWorks *]# python3
Launching process 'python3' ...
Process 'python3' (process Id = 0xffff800000641380) launched.
Python 3.8.0 (default, Feb  2 2021, 19:28:52) 
[Clang 10.0.1.1 (http://gitlab.devstar.cloud/compilers/llvm/clang.git 5449acbae on vxworks
Type "help", "copyright", "credits" or "license" for more information.

>>> import sys
>>> print("Hello World!")
Hello World!
>>> print (sys.platform)
vxworks

Python scripts can be executed as

[vxWorks *] python3 helloworld.py

Hello World!

Note: If you launch Python from the shell, you may need to set the value of rtpSpStackSize before starting Python (for example, set the rtpSpStackSize to 0x1000000). For more information, see rtpSp( ) in the API reference.