Software Development Guide 2.X

Using the NAI Software Support Kit 2.x

You have the SSK 2.x package downloaded and want to build an application with it. This guide covers setting up your development environment and writing and building an application against the NAI SSK 2.x naibrd API.

NAI SSK 2.x is intended for use with boards such as: 68G6, 68ARM2, 68ARM4, 68INT6, NIU3A.

This guide does not cover:

• Cabling, network reachability, terminal access, and transferring your built app onto the board — see Connecting to Boards.
• Launching an NAI sample application and answering its configuration menu — see Running Applications from the Target.
• The naibrd_* API calls that open a handle to your board in code — see Opening a Software Handle to Your Board.

Not sure if SSK 2.x is right for your hardware?

See Choosing the Right SSK — an interactive guide that recommends the correct SSK family and package based on your board, OS, and deployment style. For a breakdown of what’s inside the SSK 2.x package itself, see the SSK 2.x Package Guide.

If you have not already NAI recommends using the NAI Embedded Soft Panel to kickstart development. Via a GUI it allows users to quickly configure and operate NAI products. The API Logger tool within the NAI Embedded Soft Panel will allow you to kickstart writing your program as it will record the API calls made as you use the GUI to configure and operate your hardware.

If you do not yet have your hardware you can still use the NAI Embedded Soft Panel to kickstart your development via the Demo Panel.

If you do not yet know details about your hardware and have already started using the NAI Embedded Soft Panel you can skip to Starting Development. If you want help setting up the environment you can simply pick your preferred OS and follow the corresponding instructions before continuing to Starting Development. The code you write will be fully portable.

To download the NAI Software Support Kit click here.

Environment Setup

These sections will explain how to setup your environment to begin development for your chosen OS. If you do not know what OS you will use yet simply pick your preferred OS, all written .c files will are fully portable.

PetaLinux 2018.2 Target

Environment Setup

Required Tools (PetaLinux 2018.2)

• Xilinx SDK 2018.2
• NAI Library Package
• Terminal Program (Teraterm)

Downloading Xilinx (PetaLinux 2018.2)

1. Head to the Xilinx website archive section.

2. Click the 2018.2 tab to expand it.

3. Select the All OS installer to begin download, then run the installer. The tool that will be used for development is Xilinx SDK 2018.2, which is included in the Vivado Design Suite installation.

Link to original

PetaLinux 2023.2 Target

Environment Setup

Required Tools (PetaLinux 2023.2)

• Vitis Classic 2023.2
• NAI Library Package
• Terminal Program (Teraterm)

Downloading Xilinx (PetaLinux 2023.2)

1. Head to the Xilinx website archive section.

2. Click the 2023.2 tab to expand it.

3. Select the Windows Self Extracting Web Installer to begin download, then run the installer. The tool that will be used for development is Vitis Classic 2023.2, which is included in the Xilinx unified installation.

Link to original

Windows Target

Environment Setup

CMake (Windows)

CMake 3.22.1 or later must be installed to build the Windows SSK. Building CMake for Windows will generate all necessary Visual Studio project files and an nai_ssk.sln file.

Using a command window:

1. cd into the ssk2/build directory
2. run the following command to configure all projects:

cmake -G "Visual Studio 17 2022" -S ../ -B . -D passedArg="D"

Note

To generate project files for a different version of Visual Studio, enter a different generator name (e.g. Visual Studio 15 2017). Use cmake —help to explore configuration options.

The nai_ssk.sln file now exists in the build directory of the SSK and can be opened in the Visual Studio version targeted in the prior step.

Link to original

Linux Target

Environment Setup

CMake (Linux)

CMake 3.22.1 or later must be installed to build the Linux SSK. Using any web browser, navigate to https://cmake.org/files/v3.22 and download the “cmake-3.22.1-linux-x86_64.tar.gz” package.

NAI Linux Drivers

Any Linux system using the SSK 2.x to talk to NAI hardware needs one or both of the following Linux kernel modules loaded. This covers two common scenarios: running directly on an NAI Intel SBC (e.g. 68INT6, 68INT6H), and running on a Linux host PC with an NAI PCIe board (e.g. 79G5, 79C3) installed in one of its slots.

• naipci — PCIe communication between the host and any NAI PCIe / VPX backplane I/O card, plus XMC mezzanine cards. Required in all cases.
• naigspi — internal SPI communication between an NAI Intel SBC and its onboard peripherals (GPIO, watchdog, EEPROM and SATA write protect, backplane reset, etc.). Required only when running on an NAI Intel SBC. If you’re on a Linux host PC with an NAI PCIe card, skip the naigspi steps below.

Source for both drivers ships in the package under linux_drivers/nai_pci_driver/ and linux_drivers/nai_gspi_driver/. Each has its own Makefile that builds against the running kernel’s headers (/lib/modules/$(uname -r)/build).

Build the drivers:

cd linux_drivers/nai_pci_driver
make clean
make all
cd ../nai_gspi_driver
make clean
make all

Note

On RedHat Enterprise Linux 9.3 or newer, replace make all with USE_NEW_CLASS_CREATE=1 make all. RHEL 9.3 backports a kernel change to class_create() that the driver source accommodates through this flag. Ubuntu, RHEL 10, and other distributions do not need it.

Install and load the drivers (recommended for production):

sudo make -C linux_drivers/nai_pci_driver install
sudo make -C linux_drivers/nai_gspi_driver install
sudo modprobe naipci
sudo modprobe naigspi

The install target places each .ko under /lib/modules/$(uname -r)/extra/ and runs depmod, so subsequent boots pick the drivers up automatically through the normal kernel module discovery path.

Or, to load the drivers temporarily for testing only:

sudo insmod linux_drivers/nai_pci_driver/naipci.ko
sudo insmod linux_drivers/nai_gspi_driver/naigspi.ko

Temporary insmod loads do not survive a reboot.

Verify the drivers loaded:

lsmod | grep nai

You should see naipci in the output, plus naigspi if you’re running on an NAI Intel SBC. If a driver you need is missing, the SSK will not be able to reach the hardware it normally accesses through that interface.

Note

To unload the drivers, use sudo modprobe -r naipci (or sudo rmmod naipci) and the same for naigspi.

Link to original

VxWorks 7 Target

Environment Setup

The NAI Software Support Kit currently supports the following versions of VxWorks 7:

• SR660
• 22.09
• 23.03
• 23.09
• 24.03

The SSK is intended for use with the Wind River Workbench development environment. Please contact Wind River with any questions about obtaining a VxWorks license or installing Wind River Workbench.

Link to original

Deos Target

Environment Setup

Please contact DDC-I to obtain a copy of the DDS(DDC-I Developer Suite). Once installed, launch the OpenArbor IDE to start working with the NAI Software Support Kit.

Link to original

Starting Development

NAI recommends starting with the NAI Embedded Soft Panel (ESP) to kickstart development. Its GUI lets you quickly configure and operate NAI products, and its API Logger tool generates the corresponding API calls as you exercise the hardware — a useful jumping-off point for your own code.

When you are ready to write code, the SSK ships a selection of sample applications you can build, run, and use as templates. The full collection is available in the Sample Applications tab. For board-level functionality across module families, NAI also provides standalone guides on interrupts, watchdog timers, NAI ethernet protocols, BIT, multicore applications, and backplane reset.

For the SSK library API references, see:

• Software Support Kit 1.x Library API Documentation
• Software Support Kit 2.x Library API Documentation

Running NAI sample applications

When you launch an NAI sample application on the target, it presents a configuration menu that asks where the application is running and how it should reach the modules. See Running Applications from the Target for the full walkthrough — organized by application location and connection type, with collapsible callouts per hardware variation (Nano, single SBC, SIU master + backplane).

Connecting to the System

This guide assumes the board is powered, on the network, and reachable from your development host. For the cabling, network reachability, terminal access, file transfer, and NAI Ethernet Listener prerequisites needed to get to that point, see Connecting to Boards — it covers the cross-compile flow (ARM/PetaLinux, VxWorks, Deos, Windows host) plus the onboard Linux x86 flow used by NAI Intel SBCs (68INT5/6/6H, 75INT2). The naiMBEEPROMUtil walkthrough, standard serial terminal settings, HDMI/MIL adapter board details, and detailed minicom setup all live there.

Building and Running a Project

Linux

Building and Running a Project

PACKAGE LAYOUT (Linux)

The NAI SSK contains NAI libraries and code to access all onboard and offboard modules. Inside, you’ll find a “base” folder, a “docs” folder, and the root CMakeLists.txt file that’s used as the entry point for CMake to configure a build folder.

“base” Folder (Linux)

The base folder contains the all the “C” source code for the SSK.

Project Name	Description (Listed in order of recommended build order)
nai_bsp	Handles OS and processor specific routines, implements interface driver code.
nai_libs	Library routines used by user applications.
nai_sample_apps	Sample applications to demonstrate module functionality.
naistdlib	Additional C libraries.

“docs” Folder (Linux)

The “docs” folder contains local copies of the SSK’s API documentation and quick-start guides that are available on the Docs website.

“cmake/configs” Folder (Linux)

The “cmake/configs” folder exists in the “nai_libs” directory and contains the toolchain files for all supported configurations to be chosen from when generating the build folder with CMake. A generic native Linux host will use the linux_x86-64.cmake toolchain.

CONFIGURING AND BUILDING THE SSK (Linux)

Instructions (Linux)

1. Open the root folder of the SSK in the terminal.
2. Run the following command with the necessary flags to generate the build folder in the specified location:
   cmake [flags] -B [build_folder] —toolchain ./cmake/configs/linux_x86-64.cmake
   a. To generate a Release or Debug build, add the flag:
   ** -DCMAKE_BUILD_TYPE=[Release|Debug]**
   b. To generate shared object (.so) or archive (.a) libraries, add the flag:
   ** -DBUILD_SHARED_LIBS=[ON|OFF]**

Note

To build for an NAI SBC, replace linux-x86_64.cmake with the toolchain for your board (e.g. 68int6.cmake).

3. Run the following command to compile the build:
   cmake —build [build_folder] -j
4. All compiled binaries and libraries will be found in [build_folder]/bin and [build_folder]/lib, respectively.

Note

In order to change any of the configured flags (switching between .so and .a or Release and Debug), you cannot reuse the same build folder. You must either delete the previously generated build folder or direct CMake to generate a new build folder in a different location. Only then should you rerun the CMake commands with the updated flags.

Example (Linux)

In this example, the SSK is extracted to “~/nai/ssk/” and the goal is to generate a static, debug build in the folder “build_debug_a”.

1. Run cd ~/nai/ssk/ to navigate to the root folder of the SSK.
2. To generate the build folder “build_debug_a” for a static, debug build, use the command:
   cmake -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE=Debug -B build_debug_a —toolchain ./cmake/configs/linux-x86-64.cmake
3. To compile this configuration, run the command:
   cmake —build build_debug_a -j
4. All compiled binaries and libraries will be found in build_debug_a/bin and build_debug_a/lib, respectively.
   a. Truncated outputs of ls -l build_debug_a/bin and ls -l build_debug_a/lib

Link to original

Windows

Building and Running a Project

Building and Running Sample Applications (Windows)

After opening the nai_ssk.sln file in Visual Studio, you should see the following contents in the solution explorer:

1. To build all libraries and sample applications, expand the CmakePredefinedTargets folder. Right-click on ALL_BUILD and select Build. All sample applications are now ready for execution.

Creating Projects from Scratch (Windows)

The CMake build process allows for users to create and add new projects to the SSK with minimal configuration. A new project can be created, integrated into the solution file, and linked to all required NAI libraries through two main steps:

• Adding a CMakeLists.txt file to the project
• Rebuilding the nai_ssk.sln file

2. To start, navigate to the base/nai_sample_apps/naiapp_src/board_modules directory in File Explorer. This path contains the source code for all sample applications.

3. For this example, we are going to create a new DSW sample application. Enter the dsw folder and create a new folder named dsw_interrupt_basic.

4. Enter dsw_interrupt_basic and create another new folder in here named src. This is where you will place your new source file, mimicking the structure of other sample projects.

5. If you compare your new project to other sample projects such as dsw_basic_ops, you will see that they all have a CMakeLists.txt file in the same directory as their source folder. Copy this file from dsw_basic_ops into the same location of your project and open it in a text editor.

6. Inside this file, you’ll find that it specifies the project name, some include directories inside the SSK, some link libraries, and an executable name. Other directories or new libraries can be linked here, but for now, replace every instance of the name dsw_basic_ops in the new file with dsw_interrupt_basic. The contents of the file should now look similar to the following:

CMAKE_MINIMUM_REQUIRED(VERSION 3.8.2)

#CMAKE_POLICY(SET CMP0037 OLD)
PROJECT(dsw_interrupt_basic)

INCLUDE_DIRECTORIES (../../../../../ ../../../../../nai_bsp ../../../../../nai_libs/naibrd/include/ ../../../../../nai_libs/naibrd/src/include_local/ ../../../../naiapp_common/include/)

FILE (GLOB_RECURSE APP_SRC "*.h" "*.c")

SORTPROJECTFILES()

ADD_EXECUTABLE(dsw_interrupt_basic ${APP_SRC} ${COMMON_SRC})
TARGET_LINK_LIBRARIES(dsw_interrupt_basic naiapp_common naibrd)
SET_TARGET_PROPERTIES(dsw_interrupt_basic PROPERTIES FOLDER board_modules/dsw)

Once you’ve placed your C/C++ code in the src folder, your project is now ready to build. However, if you reload the solution file, you will see that the new project is still missing from the dsw directory in the Solution Explorer. This is because the contents of your new CMakeLists.txt file has not yet been read and integrated into the ALL_BUILD.vcxproj file. To update this file, you will rebuild the nai_ssk.sln file like you did in Environment Setup.

7. In a command window, navigate once more to the SSK’s build folder.

8. Run the following command, entering the Visual Studio version of your choice:

cmake -G "Visual Studio 17 2022" -S ../ -B . -D passedArg="D"

9. Open the newly-built solution file in Visual Studio. You should now see that your new project can be found in the Solution Explorer, and building the SSK with ALL_BUILD will now include your project.

Running a Sample App in Visual Studio (Windows)

10. Once all sample applications have been built successfully, they can now be ran from within Visual Studio. From the board_modules folder, select a module family that is included in your hardware. Right-click on a sample application and select Set as Startup Project.

11. The sample application that you’ve chosen is now configured to run. Select the Local Windows Debugger or Start without Debugging button and a new window will open with the running application. The Windows Library Software Support Kit can be used to run applications that target NAI hardware over ethernet from a Windows host.

Link to original

PetaLinux 2018.2

Building and Running a Project

Importing and Building Sample Applications (PetaLinux 2018.2)

1. Run Xilinx SDK 2018.2 and select the following folder from the NAI library package as your workspace:

• PACKAGE_LOCATION\petalinux-2018-2\petalinux-appsrc

2. If there are already projects when you load the workspace, select them all, right-click, and Delete them. Do NOT select “Delete project contents on disk”.

3. Import NAI projects by selecting File→Import→Existing Projects into Workspace from the Xilinx SDK toolbar:

4. Select Next and then select the workspace directory as the root directory:

• PACKAGE_LOCATION\petalinux-2018-2\petalinux-appsrc

5. Select finish to add NAI libraries and sample code projects to the workspace.

• If you get this error, simply X it out and X out the Import window.

• Your Project Explorer should now look similar to this:

6. Navigate to Project at the top of Xilinx and make sure Build automatically is unchecked.

7. Select Window→Preferences from the Xilinx toolbar and set the Indexer to “Use active build configuration” and select OK.

8. Select all of the projects, right-click, click Build Configurations, Set Active, Debug-UltraScale/Zynq-********** (pick the configuration (Zynq/UltraScale) and the board you have, ex. NIU3A).

9. Select all of the library projects (nai_bsp projects, nai_libs projects, naiapp_common) and right-click Clean Project then right-click Build Project.

10. Select a module sample project to Clean then Build which will generate an elf executable that can be run on the processor board.

Creating a New Hello World Application (PetaLinux 2018.2)

11. Navigate to File→New→Application Project to get to the New Project wizard and select Xilinx→Application Project.

12. Provide a name for the project, select linux as the OS Platform and select psu_cortexa53 as the processor type. Language should default to C and Compiler should default to 64-bit. Press next when complete.

13. Select the type of application template you’d like to start with and click Finish when complete.

14. A project with the name entered will appear in the project explorer, right-click the project and build to generate the executable ELF file.

• If your projects appear to successfully build but the Project Explorer still shows a red X on them, trying clicking Project→C/C++ Index→Rebuild to rebuild your projects.

Creating Projects from Scratch (PetaLinux 2018.2)

• Projects can be created with their source code and library includes manually created/linked. This can be helpful if a sample app is having issues and you want to go step by step to make sure nothing is wrong.

15. If you wish to create projects from scratch (starting from a blank slate, creating projects, and linking the source code manually) then navigate to File→Switch Workpsace and set the path to ‘SSK_Template_FromScratch/Template-petalinux-2018-2/petalinux-appsrc’.

• This directory is included with the package and has the same folder structure as the normal petalinux-2018-2 folder but the folders contain nothing so that projects can be made from a blank slate with nothing being detected by Xilinx.

Note

For Zynq, the workspace path would instead be “SSK_Template_FromScratch/Template-petalinux” and all subsequent path locations would follow this path rather than the aforementioned UltraScale one.

Creating an NAI Library Project from Scratch (PetaLinux 2018.2)

16. Navigate to File→New…→Project. Select Library Project under the Xilinx dropdown.

17. Create a project named nai_bsp-naibsp. Uncheck ‘Use default location’ and change the location to ‘SSK_Template_FromScratch/Template-petalinux-2018-2\petalinux-appsrc\nai_bsp\naibsp’. Select the settings as shown in the screenshot and click Finish when done.

Note

If you use the Brose button to Brose to the location of ‘SSK_Template_FromScratch’ but can’t get to it because the C: drive doesn’t show up as an option to browse to, type ‘C:’ into the Location text box and then press Brose again, and you should be able to Brose into the C: drive.

• Your workspace in the IDE should now have an ‘nai_bsp-naibsp’ project.

18. Click the arrow to expand the project, then right-click on the src folder and click Delete. Press OK after it asks to confirm the deletion.

19. Right-click the project and click Build Configurations→Manage…

20. Click New…

21. Add Debug-UltraScale-68ARM2 as the Name with the Existing configuration based on Debug then press OK.

Note

Replace UltraScale with Zynq if your board is Zynq, and replace 68ARM2 with the board you have, ex. NIU3A, 64ARM1.

22. Click on this new configuration and click Set Active.

23. Right-click on the project and select ‘Properties’. Now, select ‘Path and Symbols’ and select the ‘Includes’ page. Click Add… and add the following directories. Press OK when done. If the program asks to rebuild then say no.

• ${workspace_loc}/../../base/

• ${workspace_loc}/../../base/nai_bsp

• ${workspace_loc}/../../base/nai_bsp/naibsp_config_68arm2_petalinux

Note

Replace the 68arm2 in the config folder with your board, ex. NIU3A, 64ARM1.

24. Right-click on the project and select New→Folder.

25. Click Advanced to show more options then click ‘Link to alternate location (Linked Folder)‘. Write WORKSPACE_LOC…\base\nai_bsp\naibsp as the folder location. Click Finish.

26. Add another folder with New→Folder. For the path write WORKSPACE_LOC…\base\nai_bsp\naibsp_config_68arm2_petalinux as the folder location. Click Finish.

Note

Replace the 68arm2 in the config file with your board.

27. Right-click the project to Clean Project and then Build Project. The project should build and the progress will be displayed in the ‘Console’ tab. When finished, there will be a newly created ‘Debug-Zynq/UltraScale-XXXXXX’ folder with an archive file (static library) named ‘libnai_bsp-naibsp.a’.

Adding Additional Library Projects (PetaLinux 2018.2)

• If other libraries are needed, then the steps are the same except for differences in names and paths. The following is a list of the different library paths, debug configurations, and folder paths.

Note

Replace UltraScale with Zynq if your configuration requires Zynq instead, and replace the 68ARM2 in the Debug Configuration with your board, ex. NIU3A, 64ARM1.

• nai_bsp

  • nai_bsp-naibsp (explained in the above tutorial)

  • nai_bsp-naibsp_sys

    • New→Project step
      • Name:nai_bsp-naibsp_sys
      • Path: ‘PACKAGE_LOC\Template-petalinux-2018-2\petalinux-appsrc\nai_bsp\naibsp_sys’
    • Debug Configuration Name
      • Debug-UltraScale-68ARM2
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_bsp\naibsp_sys

  • nai_bsp-naibsp_sbit

    • New→Project
      • Name:nai_bsp-naibsp_sbit
      • Path: ‘PACKAGE_LOC\Template-petalinux-2018-2\petalinux-appsrc\nai_bsp\naibsp_sbit’
    • Debug Configuration Name
      • Debug-UltraScale-68ARM2
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_bsp\naibsp_sbit

  • nai_bsp-naibsp_dev

    • New→Project
      • Name:nai_bsp-naibsp_dev
      • Path: ‘PACKAGE_LOC\Template-petalinux-2018-2\petalinux-appsrc\nai_bsp\naibsp_dev’
    • Debug Configuration Name
      • Debug-UltraScale-68ARM2
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_bsp\naibsp_dev

• nai_libs

  • nai_libs-naibrd

    • New→Project
      • Name:nai_libs-naibrd
      • Path: ‘PACKAGE_LOC\Template-petalinux-2018-2\petalinux-appsrc\nai_libs\nai_libs-naibrd’
    • Debug Configuration Name
      • Debug-UltraScale-68ARM2
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_libs\naibrd\src
      • WORKSPACE_LOC…\base\nai_libs\naibrd\include

  • nai_libs-naiether

    • New→Project
      • Name:nai_libs-naiether
      • Path: ‘PACKAGE_LOC\Template-petalinux-2018-2\petalinux-appsrc\nai_libs\nai_libs-naiether’
    • Debug Configuration Name
      • Debug-UltraScale-68ARM2
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_libs\naiether\src
      • WORKSPACE_LOC…\base\nai_libs\naiether\include

  • nai_libs-naiif

    • New→Project
      • Name:nai_libs-naiif
      • Path: ‘PACKAGE_LOC\Template-petalinux-2018-2\petalinux-appsrc\nai_libs\nai_libs-naiif’
    • Debug Configuration Name
      • Debug-UltraScale-68ARM2
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_libs\naiif\src
      • WORKSPACE_LOC…\base\nai_libs\naiif\include

  • nai_libs-nailib

    • New→Project
      • Name:nai_libs-nailib
      • Path: ‘PACKAGE_LOC\Template-petalinux-2018-2\petalinux-appsrc\nai_libs\nai_libs-nailib’
    • Debug Configuration Name
      • Debug-UltraScale-68ARM2
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_libs\nailib\src
      • WORKSPACE_LOC…\base\nai_libs\nailib\include

  • naiapp_common

    • New→Project
      • Name:naiapp_common
      • Path: ‘PACKAGE_LOC\Template-petalinux-2018-2\petalinux-appsrc\nai_sample_apps\naiapp_common’
    • Debug Configuration Name
      • Debug-UltraScale-68ARM2
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_sample_apps\naiapp_common\src
      • WORKSPACE_LOC…\base\nai_sample_apps\naiapp_common\include

Creating an NAI Sample Project from Scratch (PetaLinux 2018.2)

• All library projects must be created or imported as described previously in order for the sample apps to build.

28. Navigate to File→New→Application Project to get to the New Project wizard and select Xilinx→Application Project, then click Next.

29. Set the project name; in this example, we use naiapp_mod_ad_basic_ops.

30. Uncheck the use default location check box, and set the location to C:\SSK_Template_FromScratch\Template-petalinux-2018-2\petalinux-appsrc\nai_sample_apps\naiapp_src\board_modules\ad\ad_basic_ops

Note

For Zynq, the workspace path would instead be “SSK_Template_FromScratch/Template-petalinux”, and all subsequent path locations would follow this path rather than the aforementioned UltraScale one.

31. Change the OS Platform to linux and select psu_cortexa53 as the processor type for UltraScale or ps7_cortexa9 for Zynq. Language should default to C and Compiler should default to 64-bit or 32-bit for Zynq. Press Next when complete.

32. Under “Available Templates”, select the Linux Empty Application and click the Finish button.

33. The project “naiapp_mod_ad_basic_ops” should now be added to the Workspace and listed under the Project Explorer. Expand the “naiapp_mod_ad_basic_ops” project and “src” folder and right-click the readme.txt file. Select Delete to remove the readme.txt file from the project. Press OK on the confirmation prompt.

34. Right-click on the “naiapp_mod_ad_basic_ops” folder and select properties. Select C/C++ General Paths and Symbols and click the Manage Configurations button.

35. Click the New button to create a new Configuration.

36. Enter the name as “Debug-UltraScale-68ARM2” or “Debug-Zynq-68ARM2” with the Existing configuration set to Debug and click the OK button. Replace 68ARM2 with the board you want to use.

37. Select Debug-Zynq/UltraScale-XXXXX and click on the Set Active button to make it the active configuration and click OK to close the window.

38. In the Configuration drop down box, select the Debug-Zynq/UltraScale-XXXXX configuration if it’s not already selected.

39. If not already in the Properties window, right-click the project and click Properties→C/C++ General→Paths and Symbols. Under the includes tab, add the following paths:

• ${workspace_loc}/../../base
• ${workspace_loc}/../../base/nai_bsp
• ${workspace_loc}/../../base/nai_bsp/naibsp_config_68arm2_petalinux

Note

Replace the 68arm2 in the config file with the board that you have.

40. Under the Libraries tab click Add… and add the following (ORDER MATTERS):

• m
• pthread
• naiapp_common
• nai_libs-naibrd
• nai_bsp-naibsp_sys
• nai_libs-naiif
• nai_libs-naiether
• nai_libs-nailib
• nai_bsp-naibsp

41. Under the Library Paths tab click Add…, add the following and check “Is a workspace path” (ORDER MATTERS):

Note

Replace UltraScale with Zynq if your configuration requires Zynq and 68ARM2 with your board, ex. NIU3A, 64ARM1

• /nai_bsp-naibsp/Debug-UltraScale-68ARM2
• /nai_bsp-naibsp_sys/Debug-UltraScale-68ARM2
• /naiapp_common/Debug-UltraScale-68ARM2
• /nai_libs-naibrd/Debug-UltraScale-68ARM2
• /nai_libs-naiether/Debug-UltraScale-68ARM2
• /nai_libs-naiif/Debug-UltraScale-68ARM2
• /nai_libs-nailib/Debug-UltraScale-68ARM2

42. Click OK on the Properties window to save the settings.

43. In the Project Explorer, right-click on the “naiapp_mod_ad_basic_ops” project and select Build Configurations→Set Active→Debug-Zynq/UltraScale-XXXXX.

44. To add the source file to the project, right-click on the “src” folder inside the “naiapp_mod_ad_basic_ops” project folder, and select New File. Click the Advanced button followed by the Link to file in the file system check box.

45. Click the browse button and add the file path SSK_Template_FromScratch\base\nai_sample_apps\naiapp_src\board_modules\ad\ad_basic_ops\src\ad_basic_ops.c. Change the path to WORKSPACE_LOC…\base\nai_sample_apps\naiapp_src\board_modules\ad\ad_basic_ops\src\ad_basic_ops.c if you want the path to be relative to the workspace location. Click the finish button to add the file to the project.

46. The project is now ready to build by right-clicking the project and clicking Clean Project then right-clicking and clicking Build Project. Once the build completes, an naiapp_mod_ad_basic_ops.elf file will be created in the Debug-UltraScale folder.

Adding Additional NAI Sample App Projects (PetaLinux 2018.2)

• The steps for adding new sample app projects from scratch are the same steps as stated above but the folder paths depend on the sample app.

• The project will be created in a path that starts as SSK_Template_FromScratch\Template-petalinux-2018-2\petalinux-appsrc\nai_sample_apps-naiapp_src\board_modules. The next folder is the module family, followed by the name of the sample app (ex. ad for ad_basic_ops, dt for dt_basic_ops).

• Some sample apps include a utils folder which will be seen within the module’s folder. To add these, you right-click the project, click New→Folder→Advanced→Link to alternate location (Linked folder) and Browse… for it.

• The source code will be in a path that starts as SSK_Template_FromScratch\base\nai_sample_apps\naiapp_src\board_modules, again followed by the module family, then a folder with the name of the sample app which contains the necessary .c file.

Link to original

PetaLinux 2023.2

Building and Running a Project

Importing and Building Sample Applications (PetaLinux 2023.2)

1. Run Vitis Classic 2023.2 and select the following folder from the NAI library package as your workspace:

• PACKAGE_LOCATION\petalinux-2023-2\petalinux-appsrc

2. If there are already projects when you load the workspace, select them all, right-click, and select “Delete”. Do NOT select “Delete project contents on disk”.

3. Navigate to “Window”→”Preferences”. In the Preferences window, navigate to the “Additional”→”C/C++”→“Build”→“Environment” tab.

4. Create an environment variable named “BOARD” and set the value to the name of the board configuration you wish to build for (e.g. “CIU3”, “NIU3C”, etc.). Then select “Apply and Close”.

5. Import NAI projects by selecting “File” → “Import” → “Eclipse workspace or zip file” from the toolbar:

6. Select “Next” and then select the workspace directory as the root directory:

• PACKAGE_LOCATION\petalinux-2023-2\petalinux-appsrc

7. Select “Finish” to add NAI libraries and sample code projects to the workspace.

• Your Project Explorer should now look similar to this:

8. Select “Window"→"Preferences” from the Vitis toolbar and set the Indexer to “Use active build configuration” and select “OK”.

9. Select “Window"→"Open Perspective” in the Vitis toolbar, and select “C/C++“.

10. Select the projects that you wish to build, right-click, click “Build Configurations"→"Set Active"→"Debug/Release” depending on the desired build type.

11. Select all the library projects (nai_bsp projects, nai_libs projects, naiapp_common), right-click, and select “Clean Project”. Then right-click and select “Build Project”.

12. Select a module sample project to Clean then Build which will generate an elf executable that can be run on the processor board.

Creating a New Hello World Application (PetaLinux 2023.2)

13. Navigate to “File"→"New"→"Other” to get to the New Project wizard and select “C/C++"→"C Project”.

14. Provide a name for the project, select “Vitis ARM v8 Linux Executable” under “Project type:” and “Vitis ARM v8 GNU/Linux/Toolchain” under “Toolchains”. Then click “Finish” when complete.

15. A project with the name entered will appear in the project explorer, right-click the project and select New→New Folder. Create a folder named “src” in the resulting window.

16. Right-click the newly created folder, which should appear under the “helloworld” project. Select New→Source File. In the resulting window, select “Default C source template” and name the file “main.c”.

17. Open the newly created source file from the project explorer. Inside the source file, add the following lines of code:

18. Right-click the project and select build to generate the executable ELF file.

Creating Projects from Scratch (PetaLinux 2023.2)

• Projects can be created with their source code and library includes manually create/linked. This can be helpful if a sample app is having issues and you want to go step by step to make sure nothing is wrong.

• If you wish to create projects from scratch (starting from a blank slate, creating projects, and linking the source code manually) then navigate to File→Switch Workspace and set the path to ‘SSK_Template_FromScratch/Template-petalinux-2023-2/petalinux-appsrc’. This directory is included with the package and has the same folder structure as the normal petalinux-202302 folder, but the folders contain nothing so that projects can be made from a blank slate with nothing being detected by Vitis.

Creating an NAI Library Project from Scratch (PetaLinux 2023.2)

19. If not done already, set an environment variable named BOARD to the name of the desired board configuration. Navigate to “Window”→”Preferences”. In the Preferences window, navigate to the “Additional”→”C/C++”→“Build”→“Environment” tab.

20. Create an environment variable named “BOARD” and set the value to the name of the board configuration you wish to build for (e.g. “CIU3”, “NIU3C”, etc.). Then select “Apply and Close”.

21. Navigate to File→New…→Other. Select C Project under the C/C++ dropdown.

22. Select Vitis ARM v8 Linux Executable under Project type. Name the project “nai_bsp-naibsp”. Uncheck ‘Use default location’ and change the location to ‘SSK_Template_FromScratch/Template-petalinux-2023-2\petalinux-appsrc\nai_bsp\naibsp’. Select the settings as shown in the screenshot and click Finish.

Note

If you use the Browse button to Browse to the location of ‘SSK_Template_FromScratch’ but can’t get to it because the C: drive doesn’t show up as an option to browse to, type ‘C:’ into the Location text box and then press Browse again, and you should be able to Browse into the C: drive.

23. Your workspace in the IDE should now have a project named “nai_bsp-naibsp”.

24. Right-click on the project and select ‘Properties’. Now, select ‘Paths and Symbols’ and select the ‘Includes’ page. Click Add… and add the following directories. Press OK when done. If the program asks to rebuild then say no.

• ${workspace_loc}/../../base
• ${workspace_loc}/../../base/nai_bsp
• ${workspace_loc}/../../base/nai_bsp/naibsp_config_${BOARD}_petalinux

25. Right-click on the project and select New→Folder.

26. Click Advanced to show more options then click “Link to alternate location (Linked Folder)“. Write “WORKSPACE_LOC…\base\nai_bsp\naibsp” as the folder location. Click Finish.

27. Right-click the project to Clean Project and then Build Project. The project should build, and the progress will be displayed in the ‘Console’ tab. When finished, there will be a newly created ‘Debug’ folder with an archive (static library) named ‘libnai_bsp-naibsp.a’.

Adding Additional Library Projects (PetaLinux 2023.2)

• If other libraries are needed, then the steps are the same except for differences in names and paths. The following is a list of the different library paths, debug configurations, and folder paths.

• nai_bsp

  • nai_bsp-naibsp (explained in the above tutorial)

  • nai_bsp-naibsp_sys

    • New→Project step
      • Name:nai_bsp-naibsp_sys
      • Path: ‘PACKAGE_LOC\Template-petalinux-2023-2\petalinux-appsrc\nai_bsp\naibsp_sys’
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_bsp\naibsp_sys

  • nai_bsp-naibsp_sbit

    • New→Project
      • Name:nai_bsp-naibsp_sbit
      • Path: ‘PACKAGE_LOC\Template-petalinux-2023-2\petalinux-appsrc\nai_bsp\naibsp_sbit’
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_bsp\naibsp_sbit

  • nai_bsp-naibsp_dev

    • New→Project
      • Name:nai_bsp-naibsp_dev
      • Path: ‘PACKAGE_LOC\Template-petalinux-2023-2\petalinux-appsrc\nai_bsp\naibsp_dev’
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_bsp\naibsp_dev

• nai_libs

  • nai_libs-naibrd

    • New→Project
      • Name:nai_libs-naibrd
      • Path: ‘PACKAGE_LOC\Template-petalinux-2023-2\petalinux-appsrc\nai_libs\nai_libs-naibrd’
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_libs\naibrd

  • nai_libs-naiether

    • New→Project
      • Name:nai_libs-naiether
      • Path: ‘PACKAGE_LOC\Template-petalinux-2023-2\petalinux-appsrc\nai_libs\nai_libs-naiether’
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_libs\naiether

  • nai_libs-naiif

    • New→Project
      • Name:nai_libs-naiif
      • Path: ‘PACKAGE_LOC\Template-petalinux-2023-2\petalinux-appsrc\nai_libs\nai_libs-naiif’
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_libs\naiif

  • nai_libs-nailib

    • New→Project
      • Name:nai_libs-nailib
      • Path: ‘PACKAGE_LOC\Template-petalinux-2023-2\petalinux-appsrc\nai_libs\nai_libs-nailib’
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_libs\nailib

  • naiapp_common

    • New→Project
      • Name:naiapp_common
      • Path: ‘PACKAGE_LOC\Template-petalinux-2023-2\petalinux-appsrc\nai_sample_apps\naiapp_common’
    • New→Folder step
      • WORKSPACE_LOC…\base\nai_sample_apps\naiapp_common

Creating an NAI Sample Project from Scratch (PetaLinux 2023.2)

• All library projects must be created or imported as described previously for the sample apps to build.

28. Navigate to File→New→Other to get to the New Project wizard and select C/C++→C Project, then click Next.

29. Set the project name. In this example we use “naiapp_mod_ad_basic_ops”.

30. Uncheck the “use default location” check box, and set the location to C:\SSK_Template_FromScratch\Template-petalinux-2023-2\petalinux-appsrc\nai_sample_apps\naiapp_src\board_modules\ad\ad_basic_ops.

31. Under “Project type”, select “Vitis ARM v8 Linux Executable” and under “Toolchains”, select “Vitis ARM v8 GNU/Linux Toolchain”. Press “Finish” when complete.

32. Right-click the project and click “Properties"→"C/C++ General"→"Paths and Symbols”. Under the “Includes” tab, add the following paths:

• ${workspace_loc}/../../base
• ${workspace_loc}/../../base/nai_bsp
• ${workspace_loc}/../../base/nai_bsp/nai_bsp_config_${BOARD}_petalinux

33. Under the “Libraries” tab click “Add…” and add the following (ORDER MATTERS):

• pthread
• m
• naiapp_common
• nai_libs-naibrd
• nai_bsp-naibsp_sys
• nai_libs-naiif
• nai_libs-naiether
• nai_libs-nailib
• nai_bsp-naibsp

34. Under the “Library Paths” tab click “Add…”, then check “Is a workspace path”, and add the following (ORDER MATTERS):

• /nai_bsp-naibsp/${config_name:${ProjName}}
• /nai_bsp-naibsp_sys/${config_name:${ProjName}}
• /naiapp_common/${config_name:${ProjName}}
• /nai_libs-naibrd/${config_name:${ProjName}}
• /nai_libs-naiether/${config_name:${ProjName}}
• /nai_libs-naiif/${config_name:${ProjName}}
• /nai_libs-nailib/${config_name:${ProjName}}

35. Click “Apply” on the “Properties” window to save the settings.

36. In the Project Explorer, right-click on the “naiapp_mod_ad_basic_ops” project and select “Build Configurations"→"Set Active"→"Debug”.

37. To add the source files to the project, right-click on the “naiapp_mod_ad_basic_ops” project folder and select “New"→"Folder”. Click the “Advanced” button followed by the “Link to alternate location (Linked Folder)” check box.

38. Click the browse button and add the following folder path:

• SSK_Template_FromScratch\base\nai_sample_apps\naiapp_src\board_modules\ad\ad_basic_ops

Note

Alternatively, enter “WORKSPACE_LOC…\base\nai_sample_apps\naiapp_src\board_modules\ad\ad_basic_ops” if you want the path to be relative to the workspace location.

39. Click the “Finish” button to add the file to the project.

40. Select “New Folder” again, and once again select “Advanced”, followed by “Link to alternate location (Linked Folder)”, and add the following foler path:

• SSK_Template_FromScratch\base\nai_sample_apps\naiapp_src\board_modules\ad\ad_common_utils

Note

“WORKSPACE_LOC…\base\nai_sample_apps\naiapp_src\board_modules\ad_ad_common_utils” if you want the path to be relative to the workspace location.

41. Click the “Finish” button to add the file to the project.

42. The project is now ready to build. Right-click the project and click Clean Project. Then right-click the project again and select Build Project. Once the build is complete, a file named “naiapp_mod_ad_basic_ops.elf” will be created under the Debug folder.

Adding Additional NAI Sample Projects (PetaLinux 2023.2)

• The steps for adding new sample app projects from scratch are the same steps as stated above but the folder paths depend on the sample app.

• The project will be created in a path that starts with ‘SSK_Template_FromScratch\Template-petalinux-2023-2\petalinux-appsrc\nai_sample_apps\naiapp_src\board_modules’. The next folder is the module family followed by the name of the sample app (ex. ad\ad_basic_ops, dt\dt_basic_ops).

• Some sample apps include a utils folder which will be seen within the module’s folder. To add these, you right-click the project, click New→Folder→Advance>>→Link to alternate location (Linked folder) and Browse… for it.

• The source code will be in a path that starts as ‘SSK_Template_FromScratch\base\nai_sample_apps\naiapp_src\board_modules’ with the next folder being the module family followed again by the name of the sample app, which contains the necessary .c file.

Debugging a Sample App on Vitis (PetaLinux 2023.2)

• We will be copying one of the built .elf sample apps to the target board’s home/root folder. You can do this in any preferred way, but the following steps shouw how to do it using Vitis.

43. Go to the “Remote System Explorer” perspective in the top right. If you don’t have this then in the top tab click “Window"→"Perspective"→"Open Perspective"→"Other” and double click “Remote System Explorer”.

44. Right-click the blank area and click “New"→"Connection…“. There are several modes of connection. In this case, “SSH Only” with the IP address of the board is being used.

45. Navigate to Root/home/root. Enter the username “root” and the password “root”. Right-click the root and click “Export from Project”.

46. In the “Remote file system” page, navigate to the sample app you want. On the left side click the dropdown arrow to expand it, then click the “Debug” folder. Then on the right, check the .elf file. When you are done, click Finish.

47. Run the sample app on Teraterm to make sure the app is working and to give execute permissions to it. You can also just use Teraterm as a simple way to use the program.

48. Navigate to /home/root/ on the terminal:

# cd /home/root/

49. Give Execute permission to the application:

# chmod 777 <Sample Application>

50. Execute program from Linux shell terminal:

# ./<Sample Application>

51. In Vitis with the sample app selected in the “Project Explorer”, navigate to “Debug As"→"Debug Configurations…“.

Note

The same steps work for “Run As"→"Run Configurations…” if you prefer to use Vitis to run the program.

52. In the “Debug Configurations” window, double click “Target Communication Framework”, select the new configuration, uncheck “Use local host as the target”, click on the TCF Agent and click Apply.

53. Navigate to the “Application” tab. The local file path should be entered as “Debug/<sample_app>.elf”. The remote file path should be filled in as “home/root/<sample_app.elf>“. Click Debug when finished.

• Vitis should ask to open the Debugger perspective.

Link to original

VxWorks 7

Building and Running a Project

Note

The following guide uses the NIU3A as an example. Replace NIU3A in the instructions with the name of your board where applicable, eg. 68ARM2. If you are using an Intel-based board, eg. 68INT6, please check your software package or contact NAI for alternative instructions.

NIU3A BSP (VxWorks 7)

This section will cover the installation of the NIU3A BSP and the creation of a VxWorks Source Build project.

Install NIU3A BSP (VxWorks 7)

The first step in configuring the NAI VxWorks 7 BSP is to copy the BSP files to the appropriate directory. The supplied BSP folder is named naiNIU3A:

The base folder contains the NAI Library and its BSP files, along with the source of the samples for the NIU3A and its functions modules. The documentation folder contains the NAI Library documentation for each function call in the SSK.

Once the naiNIU3A BSP has been located, copy the folder in the following directory:

For VxWorks 7 SR660:
$(WIND_BASE)/pkgs_v2/os/board/xilinx/

For VxWorks 7 (22.09 - 24.03):
$(WIND_BASE)/source/os/arch/arm/board/Xilinx/

Create Source Code Build (VxWorks 7)

Now with the NIU3A BSP source copied into the appropriate directory a VSB project can be created. Open Workbench and select File → New → Wind River Workbench Project. Under Built Type select VxWorks Source Build and click the Next> button.

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

Give the VxWorks Source Build project a name and click the Next> button.

In the next window, base the VSB on a VxWorks 7 board support package, and the BSP as naiNIU3A_1_0_0_0 as the fill in options. Click Link in sources to project check box if you want all VxWorks kernel source copied to your project. Click the Finish button to complete the project creation.

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

Once the Project Setup Window finishes creating the project (window closes), right-click on VSB project and select Build Project.

Once the VSB has been built, projects for NAI BSP / NAI BRD, and VIP can be created.

PROJECT CREATION (VxWorks 7)

In this section we will cover the creation of the VxWorks image project, and a downloadable kernel module project for the NAIBRD, NAI BSP and the sample applications. NAI BSP is a collection of drivers to interface to NAI hardware and VxWorks 7. In the BSP that was installed earlier is an archive of NAI BSP object code.

Create a VxWorks Image Project (VxWorks 7)

Create new VxWorks image project by selecting File → New → Wind River Workbench Project. Under Build Type select VxWorks image project and click Next>.

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

Give VxWorks Image Project at name and click Next>.

Base the VxWorks Image Project on source build project you built earlier. Make sure BSP and source project name is correct, then click Next>.

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

It is recommended to use PROFILE_DEVELOPMENT when creating a project in a development phase. Click Finish to complete the project creation process.

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

VIP Kernel Configuration (VxWorks 7)

After Workbench creates the VIP, double click Kernel Configuration in the project. For convenience under the Bundles tab there is NAI BSP default components.

Add the NAI BSP default components bundle to include the NAI BSP in entirety. Standalone kernel shell adds useful components for development as well.

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

At this point we need to create a DKM of NAIBRD and the NAI_BSP before continuing onto building the niu3aVip.

DKM For NAIBSP and NAIBRD (VxWorks 7)

Create a Downloadable Kernel Module project by clicking on File → New → Wind River Workbench Project then click Next>.

Give project at name, then click Next>.

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

Base project on VxWorks image project (niu3aVip), click Finish.

Delete dkm.c that was automatically created and add the nai_bsp, nai_libs and nai_sample_apps folders (located in the base folder) into DKM project.

Right-click on DKM project and select Rebuild Project. If this is the first time this project is built you will be prompted to Generate the include paths. Generate the includes by clicking the Generate Includes… button, followed by the Next> button.

To resolve include paths, add the following paths to the DKM project:
$(PRJ_ROOT_DIR)
$(PRJ_ROOT_DIR)/nai_bsp
$(PRJ_ROOT_DIR)/nai_bsp/naibsp_config_niu3a_vxworks7

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

Click Finish and build NAI BSP, NAI Library and samples (NAIBRD) DKM project.

Add NAI BSP Project to VIP (VxWorks 7)

Now that the niu3a_bsp_brd project has been completed we will need to switch back to the niu3aVip project. Add the niu3a_bsp_brd project as a project reference to the niu3aVip by right-clicking on niu3aVip project and selecting Properties. Next, select Project Reference and click on the check box for the niu3a_naibsp project. Click on Apply and Close.

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

Configure VIP Paths (VxWorks 7)

In niu3aVip VxWorks Image Project right-click on project, click Properties followed by Build Properties then select the Paths tab. Add the three paths below referencing the niu3a_bsp_brd project:

<PATH_TO_NIU3A_BSP_BRD_PROJECT >/nai_bsp/naibsp_config_niu3a_vxworks7
<PATH_TO_NIU3A_BSP_BRD_PROJECT>/nai_bsp
<PATH_TO_NIU3A_BSP_BRD_PROJECT>

Note

*replace <PATH_TO_NIU3A_BSP_BRD_PROJECT> with actual path to project.

Click the Apply and Close button.

Right-click on niu3aVip project and select Rebuild Project to build the kernel image. At this point the kernel image should be built successfully and is ready to be loaded onto the NIU3A.

BOOTING VXWORKS 7 KERNEL WITH UBOOT (VxWorks 7)

This section will cover booting the newly created VxWorks image file over uboot. There are sections for loading the image via tftp, and from SATA on the NIU3A.

TFTP Booting VxWorks (VxWorks 7)

Start a tftp server on host PC. For windows $(WIND_BASE)/host/x86-win32/bin/ tftpd32.exe and browse to directory that contains uVxWorks and naiNIU3A.dtb files.

Note

Screenshots may differ based on version of VxWorks/Workbench being used.

Stop Uboot on the NIU3A by pressing the esc key. Once at the uboot prompt, modify the uboot environment variables to reflect your environment. The VxWorks kernel during boot up will read bootargs variable to get host, target, network mask, as well as username and password for FTP server running on host.

Uboot Environment variables:
ZynqMP> setenv ipaddr 192.168.1.16 ZynqMP> setenv netmask 255.255.255.0
ZynqMP> setenv serverip 192.168.1.5
ZynqMP> setenv vxargs setenv bootargs gem(0,0)host:vxWorks h=192.168.1.5 e=192.168.1.16:ffffff00 u=winner pw=winner f=0x00
ZynqMP> saveenv

To boot VxWorks kernel over network:
ZynqMP> tftpboot 0x05000000 uVxWorks
ZynqMP> tftpboot 0x04000000 naiNIU3A.dtb
ZynqMP> run R5fw && run load_cal && run bmargs && run vxargs
ZynqMP> bootm 0x05000000 - 0x04000000

To automate booting over the network:
ZynqMP> setenv vxBootTftp tftpboot 0x05000000 uVxWorks;tftpboot 0x04000000 naiNIU3A.dtb;bootm 0x05000000 - 0x04000000
ZynqMP> setenv load_fw_vx_tftp echo Loading VxWorks from TFTP… && run R5fw && run load_cal && run vxargs && run vxBootTftp
ZynqMP> setenv bootcmd run load_fw_vx_tftp
ZynqMP> saveenv

On next power cycle of target VxWorks should boot over network automatically.

Booting VxWorks from SATA (VxWorks 7)

The NIU3A supports booting the VxWorks image directly from SATA. Uboot requires a tftp connection to the NIU3A in order to configure the NIU3A to boot a VxWorks image from SATA. Once a tftp connection has been established load the uVxWorks and nai68arm2.dtb file and boot VxWorks on the NIU3A. For more information on booting over tftp, see section “Error! Reference source not found.”.

Write a VxWorks image to SATA and boot image in UBoot

UBoot will need a FAT32 filesystem to boot a VxWorks kernel. After booting VxWorks over a network, retrieve the name of SATA device on the NIU3A, by entering the command ‘devs’. In the example below, the SATA name is “/ata0a”.

→ devs
drv refs name
3 [ 3] /ata0a
9 [ 3] /host.host
0 [ 5] /null
1 [ 5] /ttyS0
2 [ 3] /vxbus

To write to the SATA on NIU3A, the SATA write protection must be disabled. Enter the following at the VxWorks command line: → naiSetSataWriteProtect 0

Then to format for FAT32:
→ dosFsVolFormat “/ata0a”,0x20
Formatting /ata0a for DOSFS
Instantiating /ata0a as rawFs, device = 0x20001
Formatting…Retrieved old volume params with %100 confidence:
Volume Parameters: FAT type: FAT32, sectors per cluster 64
2 FAT copies, 0 clusters, 10069 sectors per FAT
Sectors reserved 32, hidden 63, FAT sectors 20138
Root dir entries 0, sysId (null), serial number c500000
Label:” ” …
Disk with 82477647 sectors of 512 bytes will be formatted with:
Volume Parameters: FAT type: FAT32, sectors per cluster 64
2 FAT copies, 1288398 clusters, 10069 sectors per FAT
Sectors reserved 32, hidden 63, FAT sectors 20138
Root dir entries 0, sysId VX5DOS32, serial number c500000
Label:” ” …
OK.

Once the SATA has been formatted copy your naiNIU3A.dtb and uVxWorks to the SATA drive → cp “naiNIU3A.dtb”,“/ata0a”
copying file naiNIU3A.dtb → /ata0a/ naiNIU#A.dtb
value = 0 = 0x0
→ cp “uVxWorks”,“/ata0a”
copying file uVxWorks → /ata0a/uVxWorks

Once the naiNIU3A.dtb and uVxWorks have been copied to SATA, the NIU3A can be power cycled to configure Uboot.

Stop Uboot on the NIU3A by pressing the Esc key. Once at the uboot prompt, modify the uboot environment variables to reflect your environment.

Uboot Environment variables:
U-Boot-PetaLinux> setenv ipaddr 192.168.1.16
U-Boot-PetaLinux> setenv netmask 255.255.255.0
U-Boot-PetaLinux> setenv serverip 192.168.1.5
U-Boot-PetaLinux> setenv vxargs “setenv bootargs gem(0,0)host:vxWorks h=192.168.1.5 e=192.168.1.16:ffffff00 u=winner pw=winner f=0x00”
U-Boot-PetaLinux> setenv bootcmd run vxBootCmdSata
U-Boot-PetaLinux> setenv dtbvipbootstart 4000000
U-Boot-PetaLinux> setenv vipbootstart 5000000
ZynqMP> setenv load_fw_vx_qspi “echo Loading VxWorks from SATA… && run R5fw && run load_cal && run vxargs && run vxBootSata”
U-Boot-PetaLinux> setenv vxBootSata “scsi scan && load scsi 0 $vipbootstart} uVxWorks && load scsi 0 ${dtbvipbootstart} naiNIU3A.dtb;bootm $vipbootstart} - ${dtbvipbootstart}”
U-Boot-PetaLinux> saveenv

On next power cycle of target VxWorks should boot from SATA automatically.

Link to original

Deos

Building and Running a Project

NAI Software Support Kit Description (Deos)

The NAI SSK contains NAI libraries and code to access all onboard and offboard modules. The SSK contains two folders, one labeled base which contains the NAI libraries and another labeled deos_kismet. This folder contains fully configured workspace containing project files that link to the source code in the base folder for Deos RMA. Below is an overview of the projects available in the deos_kismet folder.

Project Name	Description (Listed in recommended build order)
naibsp	Handles OS and processor-specific routines, implements interface driver code
nailib	Defines common utility routines used by other NAI libraries
naiether	Defines NAI ethernet protocol to handle NAI commands over ethernet
naiif	Defines higher level routines for handling read/write access, invokes naibsp calls
naibrd	Defines NAI routines used by NAI sample applications
naiapp_common	Defines utility routines used by NAI sample applications
naiapp_mod_*	NAI sample application programs for all available modules
nai-ultrascale	Deos platform project used to build hyperstart/composite image for NAI 68ARM2, NIU3A, and NIU3E

Building Deos BSP Package in OpenArbor (Deos)

1. Launch OpenArbor

2. Select the deos/deos_kismet/nai-ultrascale directory in the location of the SSK

• Once the workspace has been selected, the following projects should be made available to build in the DDCI-Project Window. (Projects may vary depending on system configuration)

• Building the nai-ultrascale platform project will generate a composite.darc file which contains the kernel, configuration files and application code that will be loaded onto the target system

• Refer to the file uboot_env_vars.md for U-Boot environment variables that need to be set to net-boot Deos on a given platform

Running Other Sample Applications in OpenArbor (Deos)

• By default, the only dependency that the nai-ultrascale platform project has is the Deos standard-apps which enable network connection to run tools like the Video Stream and Status Monitor. To run any of the included NAI sample applications, you can add the application as a dependency on the platform project. The Deos image needs to be rebuilt and reloaded.

3. Go to the platform project nai-ultrascale and navigate to Deos Component → Dependencies. Right-click and select Add Dependency

4. Select the application you would like to integrate with the nai-ultrascale BSP

5. Build all projects

6. In the Target Manager add a connection for the nai-ultrascale platform project

7. Launch the Status Monitor or the Video Stream

8. Right-click the Status Monitor or Video Stream and click Update Target Load. Make sure End up in registry is set to platreg if that is where application dependency is. Make sure Force Cold Start is checked

• Deos should now cold start and the new application should be running

Changing Board IP Address (Deos)

9. Change the IP address in u-boot via the ipaddr environment variable. Make sure to save the environment via the saveenv command:

setenv ipaddr 192.168.1.16
setenv serverip 192.168.1.100
saveenv

• OpenArbor stores information about the platform’s IP address in the lwip.config file.

10. Navigate to the platform project nai-ultrascale → config → lwip.config

11. Change the IP address on the following line:

interface=xilinx-gem:0 192.168.1.16 255.255.255.0

• More information can be found in the Deos NAI-UltraScale BSP User Guide.

Speeding Up the Platform Build (Deos)

• To speed up builds and avoid building libraries that should not need to be modified during application development, we can follow a couple steps to point Open Arbor to the location of our built binaries.

12. Open OpenArbor and build all NAI libraries

13. Open a Windows PowerShell instance and run the script named release-me.ps1 with the following arguments

./release-me.ps1 -copyBinaries:$true

• This will copy the parts of the “desk tree” in the output directory to a common location that OpenArbor can be pointed to look at

14. In OpenArbor navigate to Window → Preferences → DDC-I → Deos Search Path

15. Click ‘Add’. Change Preference Scope to This Workspace Only and browse to the path that the Power Shell script created: /SSK/deos/deos_kismet/$NAI_Board_Name/built-binaries/desk

16. Hit OK

• Now, if you would like to skip building the NAI libraries you can “Close Project” on any applicable libraries that have been copied. OpenArbor will check the search path to see if it has binaries for those libraries and use them instead
• If you need to debug any NAI libraries or want to navigate source, open up the projects

Deos 653 (Deos)

• By default, the naibsp library is configured to be used by a Deos RMA process. If the user would like to call the library from a Deos 653 process, the following changes must be made so that naibsp can use the correst Deos Semaphore implementation:

  • In the naibsp project, navigate to Deos Component→Dependencies and add deos-653-p1 as a dependency.
  • In the naibsp project properties, navigate to DDC-I Options→C Compile→Preprocessor and add a Defined Macro named DEOS653P1. If the application is a C\++ application, the same change will need to be made in the C++ Compile tab.

Creating Projects from Scratch (Deos)

• These steps also demonstrate the process for how to link NAI libraries to your own application the same way that they are referenced in the sample applications. Several of these libraries are required for communication with NAI hardware.

17. Navigate to File→New→DDC-I Executable Project.

18. In the New DDC-I Executable Project window, enter a project name. Select Deos Executable Project as the Project Type and the architecture of your board in the Target dropdown.

Note

This guide is targeting the nai-ultrascale platform, so ARM Target is selected. Your board may require you to select Power PC or x86_64.

19. Expand the new project in the DDC-I Project Window, and open the Deos Component→Dependencies tabs.

20. Modify the platform project’s .options file to add the following dependencies:

<depend>ansi</depend>
<depend>kernel</depend>
<depend>naiapp_common</depend>
<depend>naibrd</depend>
<depend>naibsp</depend>
<depend>naibsp_dev</depend>
<depend>naibsp_sys</depend>
<depend>naiif</depend>
<depend>nailib</depend>

• The Dependencies tab of your project should now look like the following:

21. Right-click on your project and select Preferences→DDC-I Options→C Compile→Directories. Add the following directories to the project:

$(PROJECT_DIR)/../../../../base
$(PROJECT_DIR)/../../../../base/nai_bsp
$(PROJECT_DIR)/../../../../base/nai_bsp/naibsp_config_{BOARD_NAME}_deos

22. Switch over to the Preprocessor tab under C Compile. Add a new Defined Macro named \DEOS with a value of 1.

Note

If the application is a C\++ application, the same change will need to be made in the C++ Compile tab.

23. To add a source folder to the project, right-click the project and select New→Folder→Advanced.

24. Select Link to alternate location (Linked Folder) and Browse to the directory of your src folder. Source files for sample applications are located at base/nai_sample_apps/naiapp_src/board_modules/{MOD_NAME}/{PROJECT_NAME}.

25. Deos Executable Projects use a process developer XML file to define which process, threads, mutexes, and other resources are allocated to them. You have two options for how to create one for your project:

.. If you are already familiar with process developer xml files and/or aware of which resources you are going to allocate, navigate to File→New→Other→DDC-I→DDC-I Deos Process Developer XML File and use the XML wizard to define your resources.

.. If you are not familiar with process developer xml files or are not sure of which resources are required by naibsp, copy the “xml” folder and included pd.xml file from a project in the same module family and paste it in your project directory. Change the names in the xml file referencing the other project to the name of your project.

• The naibsp project contains a naibsp-resources.pia.xml file which adds memory mapped resources to the integration. Below is a description of what these resources are:

Resource	Description
DMABuffer1	Used by NAI’s DMA engine, write data to DMA here, or read DMA data from here
ModuleInfo	NAI internal use. Needed by naibsp
ModuleConfigStatus	NAI internal use. Needed by naibsp
MotherboardCommon	NAI internal use. Needed by naibsp
ModuleControl	NAI internal use. Needed by naibsp
TTLSync	Provides access to 68ARM2 TTL Sync Engine
ModuleSpace	NAI internal use. Needed by naibsp
PCI[1-5]Mem	PCIe BAR for endpoint cards and their modules
ZynqMPCore	UltraScale+ memory regions. Refer to Xilinx UG1087
uart_zus[0,1]	UART UltraScale+ memory regions. Refer to Xilinx UG1087
i2c_zus[0,1]	I2C UltraScale+ memory regions. Refer to Xilinx UG1087
rtc	Real-time-clock UltraScale+ memory regions. Refer to Xilinx UG1087
SWDT_LPD	System Watchdog Timer UltraScale+ memory region. Refer to Xilinx UG1087
SystemTimestampGeneratorSecure	System Timestamp Generator UltraScale+ memory regions. Refer to Xilinx UG1087
SysMon	PL System Monitor UltraScale+ memory regions. Refer to Xilinx UG1087
PSUCSU	PMU Configuration Security Unit UltraScale+ memory regions. Refer to Xilinx UG1087

• Some of these memory mapped resources are required for a project to communicate with NAI hardware, while others are only necessary for utilizing certain functionality (e.g. DMABuffer1). These are included in the process developer xml files for the sample applications. If you are creating your own pd.xml file, be sure to add these resources by using the sample applications as a template.

Configuring Interrupts (Deos)

Kismet Deos SSK only

The interrupt configuration step below applies only to the Kismet Deos SSK (the deos_kismet workspace this guide covers). On the Jupiter Deos SSK (the deos_jupiter workspace), the included interrupt samples build and run as-is — do not add the naibsp_sys-attach-interrupt feature, as it will cause build errors.

• For systems using NAI interrupts, the naibsp_sys-attach-interrupt feature must be enabled. This creates an ISR thread when naibrd_ConnectISR() is called. It increases the thread quota, creates a thread template, and assigns ownership to the responsible interrupt.

26. To enable it, add the following to your process developer XML file:

<usedFeatureSet
     name = "naibsp_sys"
     versionRequirement = "none"
     versionNumber = "none"
     featureSetUndefinedAction = "error"
   >
   <usedFeature
        name = "naibsp_sys-attach-interrupt"
      >
      <usedFeatureParameter
           name = "nameOfScheduler"
           value = "default-core-0"
      ></usedFeatureParameter>
      <usedFeatureParameter
           name = "nameOfUsingProcessInstance"
           value = "dt_basic_interrupt_process"
      ></usedFeatureParameter>
   </usedFeature>
</usedFeatureSet>

27. Add your project as a dependency in the nai-ultrascale project as outlined in Step 3. Right-click the project and select Rebuild Project.

Link to original

Configuring Interrupts (Deos)

If your application uses NAI hardware interrupts, Deos needs one extra project setting — and it differs between the two Deos SSKs:

• Kismet Deos SSK (deos_kismet): the project’s process-developer XML must enable the naibsp_sys-attach-interrupt feature, which creates the ISR thread when naibrd_ConnectISR() is called. See the Configuring Interrupts (Deos) section of the NAI UltraScale Deos Quick-Start Guide for the exact XML block and steps.
• Jupiter Deos SSK (deos_jupiter): the included interrupt samples build and run as-is — do not add the naibsp_sys-attach-interrupt feature, as it will cause build errors.

Other platforms (PetaLinux, VxWorks, Windows) need no equivalent step.