Getting Started with i.MX 6 SoloX SABRE
Contents of this document
-
Out of the Box
-
Linux/Android
-
FreeRTOS
-
Exploration
Sign in to save your progress. Don't have an account? Create one.
Purchase your i.MX 6SX SABRE Board
Out of the Box
This page will help guide you through learning about the NXP Linux® OS BSP and SABRE development tool for i.MX 6SoloX.
Development Kit Contains:
- i.MX 6SoloX SABRE board for smart devices
- USB cable (micro-B to standard-A)
- 5V/5A universal power supply
- Quick Start Guide
- 8 GB SD Card with bootable operating system demonstration image
1.1 Get Familiar with the Board
1.2 Insert the SD Card (SD4)
The kit comes with an SD card with a prebuilt NXP Linux® BSP image. Without modifying the system, booting from the image will provide a default system with certain features for building other applications on top of Linux®.
To understand more about NXP Linux®/Android™/FreeRTOS BSP image, please continue reading next sections.
1.3 Connect USB Debug Cable
Connect the micro-B end of the supplied USB cable into Debug UART port J16. Connect the other end of the cable to a host computer.
Terminal window configuration: 115200 baud, 8 data bits, 1 stop bit, no parity
Serial Communication Console setup- Linux Serial Communication Console setup -Windows
On Linux® host machine, run the following command to determine the port number:
$ ls /dev/ttyUSB*
Use the following command to install serial communication program (minicom as an example):
$ sudo apt-get install minicom
Tera Term Tutorial
Tera Term is a very popular open source terminal emulation application. This program can be used to display information sent from your NXP development platform's virtual serial port.
- Download Tera Term from SourceForge. After the download, run the installer and then return to this webpage to continue.
- Launch Tera Term. The first time it launches, it will show you the following dialog. Select the serial option. Assuming your board is plugged in, there should be a COM port automatically populated in the list.
- Configure the serial port settings (using the COM port number identified earlier) to 115200 baud rate, 8 data bits, no parity, and 1 stop bit. To do this, go to Setup -> Serial Port and change the settings.
- Verify that the connection is open. If connected, Tera Term will show something like below in its title bar.
- You're ready to go
PuTTY Tutorial
PuTTY is a popular terminal emulation application. This program can be used to display information sent from your NXP development platform's virtual serial port.
- Download PuTTY using the button below. After the download, run the installer and then return to this webpage to continue.
- Launch PuTTY by either double-clicking on the *.exe file you downloaded or from the Start menu, depending on the type of download you selected.
- Configure In the window that launches, select the Serial radio button and enter the COM port number that you determined earlier. Also enter the baud rate, in this case 115200.
- Click Open to open the serial connection. Assuming the board is connected and you entered the correct COM port, the terminal window will open. If the configuration is not correct, PuTTY will alert you.
- You're ready to go
1.4 Connect LVDS Panel
Connect the LVDS panel with capacitive touch (MCIMX-LVDS1) to the LVDS connector J12.
1.5 Connect Ethernet Cable (Optional)
Connect an Ethernet cable to the lower port of the Ethernet jack P3.
1.6 Connect Power Supply
Connect the 5V power supply cable to the 5V DC power jack J1.
When powered on by flipping SW1 Power switch to ON, the processor starts executing code from on-chip ROM. With default Boot Switch setup, this code reads the fuses to find out which media to search for a bootable image. Then it will find the SD card and begin U-Boot execution automatically.
Information will be printed in the serial console. If you don’t stop the U-Boot process, it will boot the Linux® kernel.
The Linux® penguin images will initially appear in the upper left corner of the display. When the boot process is complete, the Yocto Project® operating system will be displayed on the LVDS panel.
1.7 Congratulations Your Linux® is booted
Once Linux® is booted, you can log in with user name root and no password.
To jump in U-Boot, press any key before the value of the U-Boot environment variable, "bootdelay", decreases and before it times out (default 3 seconds). If you stop the U-Boot process, you can run the following command to boot Linux® again:
U-Boot >boot Linux/Android
2.1 Choose a Development Path
The i.MX Linux® Board Support Package (BSP) is a collection of binary files, source code, and support files that can be used to create a U-Boot boot loader, a Linux® kernel image, and a root file system for i.MX development systems. Current releases of BSP and source code can be found on www.nxp.com/imx6tools
2.1 Overview
Before the Linux® OS kernel can boot on an i.MX board, the Linux® image needs to be copied to a boot device and the boot switches need to be set to boot that device.
To bring up the board and run Linux®, four elements are needed:
- Boot loader (U-Boot)
- Linux® kernel image (zImage)
- A device tree file (.dtb) for the board being used
- A root file system (rootfs) for the particular Linux® image
2.2 Prepare a Linux® BSP Image
The release contains a prebuilt SD card image that is built specifically for the i.MX
6SoloX Sabre-SD
board. The SD card image is a file that is typically named
The prebuilt NXP Linux® Binary Demo Image provides a typical system and basic set of features for using and evaluating the processor. Without modifying the system, the users can evaluate hardware interfaces, test SoC features, and run user space applications.
With the source code and documentation, the users also can customize the Linux® image built for your own device, i.e. add or remove system components.
The Yocto Project is the framework of choice with NXP professional support to build the images that are used for booting a Linux® kernel, although other methods can be used.
For more details, see NXP Yocto Project User’s Guide
2.3 Download Linux® BSP Image
There are various ways to download the Linux® BSP image for different boards, boot devices, and results desired.
For Getting-Started, we only list the few methods to transfer the BSP image to SD card. Experienced Linux® developer can explore other options.
The.Sdcard image (either from a prebuilt or self-built BSP image) is an SD card image that can be flashed directly. This is the simplest way to load everything needed onto the card with one command.
When more flexibility is desired, an SD card can be loaded with the individual components (boot loader, kernel, dtb file, and rootfs file) one-by-one or the.Sdcard image can be loaded and the individual parts can be overwritten with the specific components.
An SD/MMC card reader is required to transfer the boot loader and kernel images to initialize the partition table and copy the root file system.
Linux® host:
The Linux® kernel running on the Linux® host assigns a device node to the SD/MMC card reader.
To identify the device node assigned to the SD/MMC card, carry out the following command in the host computer:
WARNING: The instructions below will permanently delete existing content on the SD card and are dangerous to your PC if run incorrectly. If you have question or would like further details, please consult the i.MX Linux® User's Guide.
$ cat /proc/partitions
Carry out the following command to copy the SD card image to the SD/MMC card. Change sdx below to match the one used by the SD card.
$ sudo dd if= of=/dev/sd bs=1M && sync
Where
Warning: Make sure that the device node is correct for the SD/MMC card. Otherwise, it may damage your operating system or data on the hard disk of your computer.
To set up the partition manually, please read 4.3.3 in i.MX Linux® User's Guide.
To load individual component separately when the full SD card image is not used, please read 4.3.4-3.4.6 in i.MX Linux® User's Guide
The U-Boot boot loader is able to download images over Ethernet to RAM and then writes to an SD card. For this operation. Network communications need to be configured.
For instructions about how to download U-Boot to an MMC/SD card that is not the one used to boot from, please refer to section 4.4.1
Images can be downloaded to other boot media (memory storage device) using U-Boot.To use other memory device, please refer to sections under 4.4.1
The Manufacturing Tool, named MfgTool, is a tool that runs on a Windows OS host and is used to download images to different devices on an i.MX board. The tar.gz file can be found with the prebuilt Linux® BSP image.
2.4 Boot Switch Setup
The boot modes of the i.MX boards are controlled by the boot configuration DIP switches on the board.
The following table describes the dip switch settings for booting from an SD card in slot SD4.
The SD4 slot is on the center of the edge of the SoloX board.
Booting from an SD card in slot SD4 on i.MX 6SoloX SABRE-SD
| Switch | D1 | D2 | D3 | D4 | D5 | D6 | D7 | D8 |
|---|---|---|---|---|---|---|---|---|
| SW10 | OFF | OFF | OFF | OFF | OFF | OFF | OFF | OFF |
| SW11 | OFF | OFF | ON | ON | ON | OFF | OFF | OFF |
| SW12 | OFF | ON | OFF | OFF | OFF | OFF | OFF | OFF |
For boot switch setup to boot from other device (NAND and QuadSPI NOR), please refer to section 4.5 in i.MX Linux® User Guide.
This section walks through the booting process of the i.MX 6SoloX SABRE board with the Android™ system image and briefly introduce how to build the software components that create your own system image. For more information about building the Android™ platform, see source.android.com/source/building.html
Current releases of Demo Images and source code can be found on www.nxp.com/imx6tools
2.1 Overview
The storage devices on the development system (MMC/SD or NAND) must be programmed with the U-Boot boot loader. The i.MX 6 series boot process determines what storage device to access based on the switch settings. When the boot loader is loaded and begins execution, the U-Boot environment space is then read to determine how to proceed with the boot process.
The images from the prebuilt release package or created from source code contain:
- U-Boot image: u-boot.imx
- boot image: boot.img
- Android™ system root image: system.img
- Recovery root image: recovery.img
2.2 Prepare an Android™ BSP Image
The images needed to create an Android™ system can either be obtained from the release package or be built from source.
The prebuilt NXP Android™ demo image will provide a default system with certain features for purpose of evaluation. Without modifying the system, the users can perform some basic operations, and interact wit the system to test hardware interfaces and develop software application in the user space.
The latest prebuilt demo files can be found in Android™ section at www.nxp.com/imx6tools
Preparation
To build the Android™ source files, use a computer running Linux® OS. Ubuntu 14.04 (64-bit) version is the most tested OS for the Android™ Marshmallow 6.0 build.
After installing the computer running Linux® OS, check whether you have all the necessary packages installed for an Android™ build. See "Setting up your machine" on the Android™ website source.android.com/source/initializing.html.
In addition to the packages requested on the Android™ website, please refer to Android™ User Guide to install the additional packages.
Get the source code
Get the Android™ source code from Google repo.
Get the kernel source code and U-Boot from NXP open source Git.
Patch
Apply all the i.MX Android™ patches. For details, please refer to Android™ User Guide.
Build
The build configuration command lunch can be issued with an argument
Here is an example to build the Android™ image with user type for the i.MX 6SoloX SABRE Board:
$ cd ~/myandroid$ source build/envsetup.sh$ lunch sabresd_6dq-user$ make 2>&1 | tee build-log.txt
When the make command is complete, the build-log.txt file contains the execution output. Check for any errors.
To create Android™ platform over-the-air, OTA, and package, the following make target is specified:
$ make otapackage
Note: U-Boot mage, kernel uImage, boot.img can be built separately.
2.3 Download Android™ BSP Image
The Linux® utility "dd" on the computer running Linux® OS can be used to download the images into the SD card.
Before downloading, ensure that your partitions are created as described in Storage partitions.
The Manufacturing Tool, named MfgTool, is a tool that runs on a Windows OS host and is used to download images to target devices on an i.MX board. The tar.gz file can be downloaded in Manufacturing Tools section at www.nxp.com/imx6tools
Use Manufacturing Tool2.4 Boot Switch Setup
The boot modes of the i.MX boards are controlled by the boot configuration switches on the board.
| Download mode (MFGToold mode) | SW10: 00000000 (from 1-8 bit) SW11: 00111000 (from 1-8 bit) SW12: 01000000 (from 1-8 bit) Boot_Mode: 10 (from 1-2 bit) |
| SD boot | SW3: 00000000 (from 1-8 bit) SW4: 00111000 (from 1-8 bit) SW5: 01000000 (from 1-8 bit) Boot_Mode: 01 (from 1-2 bit) |
For boot switch setup to boot from NAND/TFTP/NFS, please refer to 6.2-6.3 in i.MX Android™ User's Guide.
To boot with HDMI displays, please refer to section 3.4 for more instructions.
FreeRTOS
The FreeRTOS BSP for i.MX 6SoloX is a suite of robust peripheral drivers, FreeRTOS support, and multicore communication mechanism designed to simplify and accelerate application development on i.MX 6SoloX Processor.
Current releases of BSP and source code can be found under FreeRTOS section on www.nxp.com/imx6tools
3.1 Overview
The FreeRTOS BSP for i.MX 6SoloX consists of the following runtime software components written in C:
- Arm® Cortex Microcontroller Software Interface Standard (CMSIS) Core, DSP libraries, and CMSIS-compliant device header files.
- Peripheral drivers.
- Multicore communication mechanism - RPMsg.
- An event triggered preemptive scheduling Real-time Operating System - FreeRTOS OS.
The demos/examples in FreeRTOS BSP are built for on-chip Tightly Coupled Memory (TCM) in the Arm Cortex-M4 core.
The FreeRTOS BSP release provides two packages: The .exe package is a self-extract I nstaller that can be used on Windows OS, and the tarball is for installation on Linux® OS.
3.2 Root folder structure of FreeRTOS BSP for i.MX 6SoloX
There are four main areas under install directory of the FreeRTOS BSP tree used to provide the full source code for each demo application:
3.3 Building a Demo
The FreeRTOS BSP comes with rich demo applications and driver examples. To see what's available, browse
to the
BSP 'examples' folder and select your board, the i.MX 6SoloX SABRE board (
To learn more about demo applications or driver examples, open the FreeRTOS
i.MX 6SoloX Demo Application User's Guide, located in
If one or more of the demo applications or driver examples sounds interesting, you're probably wanting to know how you can build and debug yourself. The Getting Started Guide with FreeRTOS BSP provides easy, step-by-step instructions on how to configure, build, and debug demos for all toolchains supported by the BSP.
All examples are provided with projects for the following toolchains:
- IAR Embedded Workbench
- DS-5
- GNU toolchain for Arm® Cortex®-M with CMAKE builds system
3.4 Run application using U-Boot
This section describes the steps to run application using an SD card with prebuilt U-Boot image for i.MX processor. For more information about how to write the U-Boot image to SD card and create FAT file system partition, refer to Linux BSP package.
Using U-Boot3.5 Example Demo
Demo and example applications are provided to demonstrate peripheral drivers, FreeRTOS kernel, RPMsg usage and to highlight the main features of the i.MX 6SoloX processor.
The FreeRTOS BSP provides two types of software applications:
- Demos: Applications intended to highlight key functions of the Arm® Cortex®-M4 Core in i.MX 6SoloX SoC, focusing on a particular use case on FreeRTOS OS.
- Examples: Simple applications intended to concisely illustrate how to use the peripheral drivers of the FreeRTOS BSP in the bare metal environment.
Cortex-M4 standalone sensor demo Cortex-A7/Cortex-M4 Rpmsg Ping Pong demo
The Sensor Demo i.MX 6SoloX is a simple demonstration program that uses the FreeRTOS and a set of drivers provided by NXP. It can get the current gravitational acceleration and magnetic field strength of the board. The purpose of this demo is to show how to use the I2C driver as a Controller to communication with other I2C Targets.
In the second terminal emulator for M4 core, you should see text indicating the sensor example is running (e.g., below). Choose one of the sensor demos and affect the given sensor by moving the board or moving something magnetic near it.
-------------- i.MX 6SoloX SABRE on board sensor example
--------------
Select the sensor demo you want to run:
The user is prompted to enter which sensor they want to communicate
with:
[1].MMA8451Q 3-Axis Digital Accelerometer Polling Demo
[2].MMA8451Q 3-Axis Digital Accelerometer Interrupt Demo
[3].MAG3110 3-Axis Digital Magnetometer Polling Demo
[4].MAG3110 3-Axis Digital Magnetometer Interrupt Demo
As is shown on the log, the RPMsg Controller (Cortex-A9 Linux OS) and Remote (Cortex-M4 FreeRTOS OS) perform a name service handshake to create the communication channel. The M4 channel address is 1, and the A9 channel address is 1024. A9 begins to send the first data to M4. After receiving the data, M4 adds 1 to it and sends it back to A9. A9 responds with the same behavior. The loop continues to demonstrate the stability of RPMsg communication.
After the boot process succeeds, the Arm Cortex-M4 terminal displays the following information:
RPMSG PingPong FreeRTOS RTOS API Demo...
RPMSG Init as Remote
After the Linux pingpong controller side module is installed, the Arm Cortex-M4 terminal displays the following information:
Name service handshake is done, M4 has setup a rpmsg channel [1
---> 1024]
Get Data From Controller Side : 0
Get Data From Controller Side : 2
Get Data From Controller Side : 4
Get Data From Controller Side : 6
Get Data From Controller Side : 8
......
As is shown on the log,
The pingpong demo runs in an infinite loop. Reboot the board to stop it.
Running a demo using IAR Download PDF
1. Build the platform library
These steps show how to open a demo workspace in IAR Embedded Workbench, how to build the platform library required by the demo, and how to build the demo application. The example used below is for the hello_world demo, but similar steps can be applied to any demo in the KSDK.
-
Open demo workspace (*.eww file) in:
/examples/frdmkl46z/demo_apps/ /iar After the workspace is open, two projects are shown: one for the KSDK platform library and one for the demo. Also, the platform library project is bold, indicating that it is the active project. The active project can be changed at any time by right-clicking on the desired project and selecting "Set as Active" or via the build target drop-down at the top of the workspace browser.
-
There are two project configurations (build targets) supported for each KSDK project:
- Debug - Compiler optimization is set to low, and debug information is generated for the executable. This target should be selected for development and debug.
- Release - Compiler optimization is set to high, and debug information is not generated. This target should be selected for final application deployment. The tool allows you to select either the Debug or Release configuration on a per-project basis, but since the demo has a dependency on the platform library, which configuration is selected for the demo must also be selected for the platform library. Selecting a configuration in the drop-down also makes which project and configuration that is selected the active project. For this example, select the "ksdk_platform_lib — Debug" target.
-
Click the "Make" button, highlighted in red below.
-
When the build is complete, the library (libksdk_platform.a) is generated in one of the following directories, according to the chosen build target:
/lib/ksdk_platform_lib/iar/KL46Z4/debug /lib/ksdk_platform_lib/iar/KL46Z4/release
2. Build a Demo Application
The KSDK demo applications are built upon the software building blocks provided in the Kinetis SDK platform library, built in the previous section. If the platform library is not present, the linker displays an error indicating that it cannot find the library. An easy way to check whether the library is present is to expand the Output folder in the ksdk_platform_lib project. If the platform library binary is not built and present, follow the steps on page 1 to build it. Otherwise, continue with the following steps to build the desired demo application.
-
If not already done, open the desired demo application workspace (*.eww file). This example's workspace file is located in:
/examples/frdmkl46z/demo_apps/hello_world/iar -
Select the desired build target from the drop-down. For this example, select the "hello_world — Debug" target.
-
To build the demo application, click the "Make" button, highlighted in red below.
-
The build will complete without errors.
3. Run a Demo Application
The FRDM-KL46Z board comes loaded with the mbed/CMSIS-DAP debug interface from the factory. If you have changed the debug OpenSDA application on your board, visit http://www.nxp.com/opensda for information on updating or restoring your board to the factory state.
-
Connect the development platform to your PC via USB cable between the "SDAUSB" USB port on the board and the PC USB connector.
-
Open the terminal application on the PC (such as PuTTY or TeraTerm) and connect to the debug COM port you determined earlier. Configure the terminal with these settings:
- 115200 baud rate
- No parity
- 8 data bits
- 1 stop bit
-
Click the "Download and Debug" button to download the application to the target.
-
The application is then downloaded to the target and automatically runs to the main() function.
-
Run the code by clicking the "Go" button to start the application.
-
The hello_world application is now running and a banner is displayed on the terminal. If this is not the case, check your terminal settings and connections.
Building a Demo Using DS-5 IDE Download PDF
This section describes the steps required to build demo applications provided in the FreeRTOS BSP. The hello_world demo for i.MX 6SoloX SABRE board is used as an example, though these steps can be applied to any board, demo or example application in the FreeRTOS BSP.
-
Open Arm DS-5 IDE installed on your PC:
-
Select “File->Import” from the DS-5 IDE menu. In the window that appears, expand the “General” folder and select “Existing Projects into Workspace”. Then, click the “Next” button.
-
Click the “Browse” button next to the “Select root directory:” option.
-
Point to the hello_world demo for the appropriate device, which can be found using this path:
/examples/ /demo_apps/hello_world/ds5 For this example, the specific location is:
/ examples/imx6sx_sdb_m4/demo_apps/hello_world/ds5 -
After pointing to the correct directory, your “Import Projects” window should look like the figure below. Click the “Finish” button.
-
There are two project configurations (build targets) supported for each this project:
- Int Ram Debug – Compiler optimization is set to low, and debug information is generated for the executable. This target should be selected for development and debug.
- Int Ram Release – Compiler optimization is set to high, and debug information is not generated. This target should be selected for final application deployment.
-
Choose the appropriate build target, “Int Ram Debug” or “Int Ram Release”, by clicking the downward facing arrow next to the hammer icon, as shown below. For this example, select the “Int Ram Debug” target.
-
The demo starts building after the build target is selected. To rebuild the demo in the future, click the hammer icon (assuming the same build target is chosen).
-
The build result can be found at
/examples/ /demo_apps/ /ds5/ . - The *.axf file contains the debug information of the demo application. It can be used for software debugging;
-
*.bin file can be generated from *.axf file using fromelf.exe tool in
\sw\ARMCompiler5.05u1\bin with the DS-5 Command Prompt. fromelf --bin --output=.bin .axf
Running a demo using Arm ® GCCDownload PDF
1. Set Up Toolchain
This section contains the steps to install the necessary components required to build and run a KSDK demo application with the Arm GCC toolchain, as supported by the Kinetis SDK. There are many ways to use Arm GCC tools, but this example focuses on a Windows environment. Though not discussed here, GCC tools can also be used with both Linux OS and Mac OSX.
Install GCC Arm Embedded Toolchain
Download and run the installer from launchpad.net/gcc-arm-embedded. This is the actual toolchain (i.e., compiler, linker, etc.). The GCC toolchain should correspond to the latest supported version, as described in the Kinetis SDK Release Notes.
Install MinGW
The Minimalist GNU for Windows (MinGW) development tools provide a set of tools that are not dependent on third-party C-Runtime DLLs (such as Cygwin). The build environment used by the KSDK does not use the MinGW build tools, but does leverage the base install of both MinGW and MSYS. MSYS provides a basic shell with a Unix-like interface and tools.
-
Download the latest MinGW mingw-get-setup installer from sourceforge.net/projects/mingw/files/Installer/.
-
Run the installer. The recommended installation path is C:\MinGW, however, you may install to any location.
-
Ensure that the "mingw32-base" and "msys-base" are selected under Basic Setup.
-
Click "Apply Changes" in the "Installation" menu and follow the remaining instructions to complete the installation.
-
Add the appropriate item to the Windows operating system Path environment variable. It can be found under Control Panel -> System and Security -> System -> Advanced System Settings in the "Environment Variables..." section. The path is:
\bin Assuming the default installation path, C:\MinGW, an example is shown below. If the path is not set correctly, the toolchain does not work.
NOTE
If you have "C:\MinGW\msys\x.x\bin" in your PATH variable (as required by KSDK 1.0.0), remove it to ensure that the new GCC build system works correctly.
-
Download CMake 3.0.x from www.cmake.org/cmake/resources/software.html.
-
Install CMake, ensuring that the option "Add CMake to system PATH" is selected when installing. It's up to the user to select whether it's installed into the PATH for all users or just the current user. In this example, the assumption is that it's installed for all users.
-
Follow the remaining instructions of the installer.
-
You may need to reboot your system for the PATH changes to take effect.
NOTE
The installation path cannot contain any spaces.
Add a New Environment Variable for ARMGCC_DIR
Create a new system environment variable and name it ARMGCC_DIR. The value of this variable should point to the Arm GCC Embedded tool chain installation path, which, for this example, is:
C:\Program Files (x86)\GNU Tools Arm Embedded\4.8 2014q3
Reference the installation folder of the GNU Arm GCC Embedded tools for the exact pathname of your installation.
Install CMake
2. Build the Platform Library
-
Open a GCC Arm Embedded tool chain command window. To launch the window, from the Windows operating system Start menu, go to "Programs -> GNU Tools Arm Embedded
" and select "GCC Command Prompt". 
-
Change the directory of the command window to the platform library directory in the KSDK:
/lib/ksdk_platform_lib/armgcc/KL46Z4 -
There are two project configurations (build targets) supported for each KSDK project:
- Debug — Compiler optimization is set to low, and debug information is generated for the executable. This target should be selected for development and debug.
- Release — Compiler optimization is set to high, and debug information is not generated. This target should be selected for final application deployment.
There are batch files provided to build both configurations. For this example, the "Debug" target is built and "build_debug.bat" is typed on the command line. If the "Release" target is desired, type the "build_release.bat" instead. Alternatively, if using the command line is not desired, you can double click on the batch files from Windows Explorer.
-
When the build finishes, the output looks like the image below(with KL46Z4 in place of K64F12).
-
The library (libksdk_platform.a) is generated in one of these directories, according to the build target:
/lib/ksdk_platform_lib/armgcc/KL46Z4/debug /lib/ksdk_platform_lib/armgcc/KL46Z4/release
3. Build a Demo Application
KSDK demo applications require that the platform library for the same build target (Debug or Release) is present. Please ensure that you follow the steps in section 7.2 prior to attempting to build a demo application.
To build a demo application, follow these steps.
-
If not already running, open a GCC Arm Embedded tool chain command window. To launch the window, from the Windows operating system Start menu, go to "Programs -> GNU Tools Arm Embedded
" and select "GCC Command Prompt". 
-
Change the directory to the demo application project directory, which has a path like this:
/examples/frdmkl46z/demo_apps/ /armgcc For this example, the exact path is:
/examples/frdmkl46z/demo_apps/hello_world/armgcc -
Type "build_debug.bat" on the command line or double click on the "build_debug.bat" file in Windows operating system Explorer to perform the build. The output is shown in this figure:
4. Run a Demo Application
The GCC tools require a J-Link debug interface. To update the OpenSDA firmware on your board to the latest J-Link app, visit www.nxp.com/opensda. After installing the J-Link OpenSDA application, download the J-Link driver and software package from www.segger.com/downloads.html.
-
Connect the development platform to your PC via USB cable between the "SDAUSB" USB port on the board and the PC USB connector.
-
Open the terminal application on the PC (such as PuTTY or TeraTerm) and connect to the debug COM port you determined earlier. Configure the terminal with these settings:
- 115200 baud rate
- No parity
- 8 data bits
- 1 stop bit
-
Open the J-Link GDB Server application. Assuming the J-Link software is installed, the application can be launched by going to the Windows operating system Start menu and selecting "Programs -> SEGGER -> J-Link
J-Link GDB Server". -
Modify the settings as shown below. The target device selection chosen for this example is the "MKL46Z128xxx4".
-
After it is connected, the screen should resemble this figure:
-
If not already running, open a GCC Arm Embedded tool chain command window. To launch the window, from the Windows operating system Start menu, go to "Programs -> GNU Tools Arm Embedded
" and select "GCC Command Prompt". 
-
Change to the directory that contains the demo application output. The output can be found in using one of these paths, depending on the build target selected:
/examples/ /demo_apps/ /armgcc/debug /examples/ /demo_apps/ /armgcc/release For this example, the path is:
/examples/frdmkl46z/demo_apps/hello_world/armgcc/debug -
Run the command "arm-none-eabi-gdb.exe
.elf". For this example, it is "arm-none-eabi-gdb.exe hello_world.elf". The example image below displays the building of the frdmkl46z hello_world application as an example. 
-
Run these commands:
- "target remote localhost: 2331"
- "monitor reset"
- "monitor halt"
- "load"
- "monitor reset"
-
The application is now downloaded and halted at the reset vector. Execute the "monitor go" command to start the demo application.
The hello_world application is now running and a banner is displayed in the terminal window.
Exploration
4.1 Key Features Demo in Linux
With Linux® running on the i.MX platform, you can evaluate special features that i.MX SoCs provide:
Power Management Multimedia Graphics Security Connectivity
There are three main power management techniques on i.MX boards:
- Suspend and resume commands
- CPU frequency scaling
- Bus frequency scaling
After Linux® setup, for more details about developing applications in user space. Please see i.MX6 Linux® Reference Manual.
4.2 Application development
After Linux® setup, for more details about developing applications in user space. Please see i.MX6 Linux® Reference Manual.
There are a lot of program environment.
4.3 Yocto Project
NXP Yocto Project User's Guide covers how to set up the Linux® host machine, how to run and configure a Yocto Project, generate an image, and generate a rootfs
For more details, see NXP Yocto Project User’s Guide
4.4 Further resources
Demo not working?
Did your board come in a box that looks like this?
No problem! Your board simply came in the old packaging and has a different out-of-box demo loaded into the flash memory.
You should be seeing the red and green LEDs toggling back and forth. It's OK to move onto the next step when you're ready
Still not working?
Try proceeding to the next steps to get other example applications running on your board. If you still have problems, try contacting us through the NXP Community.
Running a demo using Keil® MDK/µVision® Download PDF
1. Install CMSIS device pack
After the MDK tools are installed, Cortex® Microcontroller Software Interface Standard (CMSIS) device packs must be installed to fully support the device from a debug perspective. These packs include things such as memory map information, register definitions, and flash programming algorithms. Follow these steps to install the appropriate CMSIS pack.
-
Open the MDK IDE, which is called µVision. In the IDE, select the "Pack Installer" icon.
-
In the Devices tab on the left-hand side of the dialog box that appears, expand the NXP category. Then expand the KLxx Series category and highlight KL4x by clicking it once.
-
After the installation finishes, close the Pack Installer window and return to the µVision IDE.
NOTE:
This process requires an internet connection to successfully
complete.
2. Build the Platform Library
These steps show how to open the demo workspace in µVision, how to build the platform library required by the demo, and how to build the demo application.
-
Demo workspace files can be found using this path:
/examples/frdmkl46z/demo_apps/ /mdk The workspace file is named
.uvmpw. For this specific example, the actual path is: /examples/frdmkl46z/demo_apps/hello_world/mdk/hello_world.uvmpw After the workspace is open, two projects show up: one for the KSDK platform library, and one for the demo. By default, the demo project is selected as the active project.
-
Make the platform library project the active project since the library is required by the demo application to build. To make the platform library project active, right click on it and select "Set as Active Project". The active project has a black box around the project name. After it is active, the platform library project is highlighted.
-
There are two project configurations (build targets) supported for each KSDK project:
- Debug — Compiler optimization is set to low, and debug information is generated for the executable. This target should be selected for development and debug.
- Release — Compiler optimization is set to high, and debug information is not generated. This target should be selected for final application deployment.
The tool allows selection of the build target based on the active project, so in order to change the configuration for the platform library it must be the active project. Choose the appropriate build target: "Debug" or "Release" from the drop-down menu.
For this example, select the "ksdk_platform_lib Debug" configuration.
-
Rebuild the project files by left-clicking the "Rebuild" button, highlighted in red.
3. Build a Demo Application
The KSDK demo applications are built upon the software building blocks provided in the Kinetis SDK platform library, built in the previous section. If the platform library is not present, the linker displays an error indicating that it cannot find the library. If the platform library binary is not built and present, follow the steps on page 2 to build it. Otherwise, continue with the following steps to build the desired demo application.
-
If not already done, open the desired demo application workspace in:
/examples/frdmkl46z/demo_apps/ /mdk The workspace file is named
.uvmpw, so for this specific example, the actual path is: /examples/frdmkl46z/demo_apps/hello_world/iar/hello_world.uvmpw -
Make the demo the active project.
-
To build the demo project, select the "Rebuild" button, highlighted in red.
-
The build will complete without errors.
4. Run a Demo Application
The FRDM-KL46Z board comes loaded with the mbed/CMSIS-DAP debug interface from the factory. If you have changed the debug OpenSDA application on your board, visit http://www.nxp.com/opensda for information on updating or restoring your board to the factory state.
-
Connect the development platform to your PC via USB cable between the "SDAUSB" USB port on the board and the PC USB connector.
-
Open the terminal application on the PC (such as PuTTY or TeraTerm) and connect to the debug COM port you determined earlier. Configure the terminal with these settings:
- 115200 baud rate
- No parity
- 8 data bits
- 1 stop bit
-
After the application is properly built, click the "Download" button to download the application to the target.
-
After clicking the "Download" button, the application downloads to the target and should be running. To debug the application, click the "Start/Stop Debug Session" button, highlighted in red.
-
Run the code by clicking the "Run" button to start the application.
-
The hello_world application is now running and a banner is displayed on the terminal. If this is not the case, check your terminal settings and connections.
Running a demo using Kinetis Design Studio IDE Download PDF
1. Install Eclipse Update
Before using KDS IDE with KSDK, the KSDK Eclipse Update must be applied. Without this update, Eclipse cannot generate KSDK-compatible projects.
Windows and Mac® OS Users
The steps required for Mac OS are identical to Windows; the only difference is that the IDE looks slightly different.
-
After installing KDS, check for available updates. Install the Processor Expert 3.0.1 updates from NXP only - do not install any other updates. To check for updates, select “Help” -> “Check for Updates”.
-
Select "Help" -> "Install New Software".
-
In the Install New Software dialog box, click the "Add" button in the upper right corner. Then, in the Add Repository dialog, select the "Archive" button.
-
In the Repository archive dialog box, browse the KSDK install directory
-
Enter the /tools/eclipse_update folder and select the KSDK_
_Eclipse_Update.zip file. -
Click "Open", and the "OK" button in the Add Repository dialog box.
-
The KSDK update shows up in the list of the original Install dialogs
-
Check the box to the left of the KSDK Eclipse update and click the "Next" button in the lower right corner.
-
Follow the remaining instructions to finish the installation of the update.
-
After the update is applied, restart KDS for the changes to take effect.
Linux® OS Users
The following instructions were performed using Ubuntu 14.04. These steps may be slightly different for other Linux distributions.
-
Launch KDS IDE from the command line as the root user. On the command line, use this command, assuming the default KDS IDE install path:
user@ubuntu:~$ sudo /opt/NXP/KDS_x.x.x/eclipse/kinetis-design-studioThe KDS IDE version (shown above as x.x.x) should reflect the version installed on your machine, for example, 3.0.0.
-
You are prompted to enter the root password.
-
After installing KDS, check for available updates. Install the Processor Expert 3.0.1 updates from NXP only - do not install any other updates. To check for updates, select “Help” -> “Check for Updates”.
-
Select "Help" -> "Install New Software"
-
In the "Install New Software" dialog box, click the "Add" button in the upper right corner. Then, in the "Add Repository" dialog, select "Archive".
-
In the Repository archive dialog box, browse the KSDK install directory.
-
Enter the /tools/eclipse_update folder and select the KSDK_
_Eclipse_Update.zip file. -
Click "Open", and "OK" in the "Add Repository" dialog box.
-
The KSDK update shows up in the list of the original Install dialogs.
-
Check the box to the left of the KSDK Eclipse update and click the "Next" button in the lower right corner.
-
Follow the remaining instructions to finish the installation of the update.
-
After the update is applied, restart the KDS IDE for the changes to take effect.
-
After KDS IDE restarts, shut down the IDE and restart by launching KDS IDE as the nonroot user. To do this, follow the command in step 1, only without the "sudo" command.
2. Build the Platform Library
These steps show how to open and build the platform library project in KDS IDE. The platform library is required by the demo and does not build without it.
NOTE
The steps required for Linux and Mac OS are identical to those for Windows.
-
Select "File->Import" from the KDS IDE menu. In the window that appears, expand the "General" folder and select "Existing Projects into Workspace". Then, click the "Next" button.
-
Click the "Browse" button next to the "Select root directory:" option.
-
Point to the platform library project for the appropriate device, which can be found using this path:
/lib/ksdk_platform_lib/kds/KL46Z4 -
After pointing to the correct directory, your "Import Projects" window should look like the figure below. Click the "Finish" button.
-
There are two project configurations (build targets) supported for each KSDK project:
- Debug — Compiler optimization is set to low, and debug information is generated for the executable. This target should be selected for development and debug.
- Release — Compiler optimization is set to high, and debug information is not generated. This target should be selected for final application deployment.
-
Choose the appropriate build target, "Debug" or "Release", by clicking the downward facing arrow next to the hammer icon, as shown below. For this example, select the "Debug" target.
-
The library starts building after the build target is selected. To rebuild the library in the future, click the hammer icon (assuming the same build target is chosen).
4. Run a Demo Application
NOTE
The steps required for Linux and Mac OS are identical to those for Windows.
The FRDM-KL46Z board comes loaded with the mbed/CMSIS-DAP debug interface from the factory. If you have changed the debug OpenSDA application on your board, visit http://www.nxp.com/opensda for information on updating or restoring your board to the factory state.
Mac users must install the J-Link OpenSDA application in order to use the KDS IDE to download and debug their board.
-
Connect the development platform to your PC via USB cable between the "SDAUSB" USB port on the board and the PC USB connector.
-
Open the terminal application on the PC (such as PuTTY or TeraTerm) and connect to the debug COM port you determined earlier. Configure the terminal with these settings:
- 115200 baud rate
- No parity
- 8 data bits
- 1 stop bit
-
For Linux OS users only, run the following commands in your terminal. These install libudev onto your system, which is required by KDS IDE to launch the debugger.
user@ubuntu:~$ sudo apt-get install libudev-dev libudev1user@ubuntu:~$ sudo ln —s /usr/lib/x86_64-linux-gnu/libudev.so /usr/lib/x86_64-linux-gnu/libudev.so.0 -
Ensure that the debugger configuration is correct for the target you're attempting to connect to. Consult Appendix B for more information about the default debugger application on the various hardware platforms supported by the KSDK.
-
To check the available debugger configurations, click the small downward arrow next to the green "Debug" button and select "Debug Configurations".
-
In the Debug Configurations dialog box, select debug configuration that corresponds to the hardware platform you're using. For Windows or Linux users, select is the CMSIS-DAP/DAPLink option under OpenOCD. For Mac users, select J-Link.
After selecting the debugger interface, click the "Debug" button to launch the debugger.
-
-
The application is downloaded to the target and automatically run to main():
-
Start the application by clicking the "Resume" button:
-
The hello_world application is now running and a banner is displayed on the terminal. If this is not the case, check your terminal settings and connections.
Manufacturing Tool Tutorial - Android™
- Connect a USB cable from a computer running Windows OS to the USB OTG port on the board.
- Unzip the mfgtools.tar.gz file to a selected loation. The directory is named MFGTool-Dir in this example.
- Copy the BSP image to to the path: MFGTool-Dir/Profiles/Linux/OS Firmware/files/android/sabresd
- No dedicated boot DIP switches are reserved for serial download mode on i.MX 6 Quad/QuadPlus SABRE-SD board.One way is to change the SABRE-SD SW6 (boot) to 00001100 (from 1-8 bit) to enter download mode.
- Power on the board.
- Double-click the file *.vbs according to the target device.
- Click "Start" to start downloading. the status bar shows the download status. The download may take one to two minutes depending on the host machine.
- After the image downloading is done, set the boot switch to boot up the board according to the table in the next step.
For details, please refer to "3.3 Downloading Board Images" in i.MX Android™ Quick Start Guide
You can connect a USB cable from the debug UART port to the computer and open a serial communication program for for console output.
Manufacturing Tool Tutorial - Linux®
- Connect a USB cable from a computer to the USB OTG port on the board.
- No dedicated boot DIP switches are reserved for serial download mode on i.MX 6 Quad/QuadPlus
SABRE-SD
board.
One way is to set the boot mode to boot from SD slot SD3 but do not insert the SD card, and power on the board. After the message "HID Compliant device" is displayed, the board enters serial download mode. Then insert the SD card into SD slot SD3.See "4.5.11 Serial download mode for the Manufacturing Tool" in i.MX Linux® User Guide. - Power on the board.
- Choose the correct *.vbs file according to the target device. The manufacturing tool automatically pulls the required files based on the device. The default profile of the Manufacturing Tool assumes that your file system is packed and compressed using the bzip2 algorithm. You can also modify the profile to support other formats.
- After the image downloading is done, set the boot switch to boot up the board. See next step in Section 2 in this Getting Started Tutorial or Section "How to boot the i.MX boards" in the document.
For details, please refer to 4.2 Manufacutring Tool in i.MX Linux® User's Guide.
You can connect a USB cable from the debug UART port to the computer and open a serial communication program for for console output.
On this page
- 1.1
Get Familiar with the Board
- 1.2
Insert the SD Card (SD4)
- 1.3
Connect USB Debug Cable
- 1.4
Connect LVDS Panel
- 1.5
Connect Ethernet Cable (Optional)
- 1.6
Connect Power Supply
- 1.7
Congratulations Your Linux® is booted