1
Out of the Box2
BSP Introduction3
ExplorationSign in to save your progress. Don't have an account? Create one.
This page will guide you through learning about how to boot Linux® OS on the SABRE board for i.MX6 QuadPlus (can be configured as i.MX6 DualPlus) and briefly introduce the NXP Linux® OS BSP (Board Support Package).
Something went wrong! Please try again.
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® BSP image, please continue reading the next section: BSP Introduction.
Something went wrong! Please try again.
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
On Windows,
To determine the port number of the i.MX board virtual COM port, open the device manager and look under the "Ports" group.
If needed, the serial-to-USB drivers can be found at ftdichip.com/FTDrivers.htm.
Not sure how to use a terminal application? Try one of these tutorials:
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.
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.
Something went wrong! Please try again.
Connect an HDMI cable to the HDMI connector J8. Connect the other end to the HDMI cable to an HDMI capable monitor.
Something went wrong! Please try again.
Attach a keyboard and mouse to interact with the OS GUI displayed on the monitor. Attach a USB hub to USB jack J505 and connect the keyboard and mouse to the hub if more than one device are used. A micro B male to A female adapter cable may be needed.
Something went wrong! Please try again.
Connect an Ethernet cable to the Ethernet jack J7.
Something went wrong! Please try again.
Connect the 5V power supply cable to the 5V DC power jack P1.
When powered 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.
Something went wrong! Please try again.
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
Something went wrong! Please try again.
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
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:
The release contains a prebuilt SD card image that is built specifically for the i.MX 6Quad 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
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.
The boot modes of the i.MX boards are controlled by the boot configuration DIP switches on the board.
The following table shows the DIP switch settings for booting from the SD card slot labeled SD2 and J500 on the i.MX 6 SABRE-SD boards. The SD2 card slot is located beside the LVDS1 connection on the back of the board.
Booting from SD2 (J500) on i.MX 6 SABRE-SD
Switch | D1 | D2 | D3 | D4 | D5 | D6 | D7 | D8 |
---|---|---|---|---|---|---|---|---|
SW6 | On | OFF | OFF | OFF | OFF | OFF | ON | OFF |
For boot switch setup to boot from other device (SD3 and SATA), please refer to 4.5 in i.MX Linux® User Guide.
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.
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.
or
Something went wrong! Please try again.
This section walks through the booting process of the i.MX 6QuadPlus 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
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:
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
To build the Android™ source files, use a computer running Linux® OS. Ubuntu 14.04 (64-bit) versions are the ones we have tested the most for 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 Android™ source code from Google repo.
Get the kernel source code and U-Boot from Freescale open source Git.
Apply all the i.MX Android™ patches. For details, please refer to Android™ User Guide.
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 6Quadplus 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.
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
The boot modes of the i.MX boards are controlled by the boot configuration switches on the board.
The following table lists the boot switch settings for different boot methods:
eMMC 4-bit (MMC2) boot | (SW6) 11100110 (from 1-8 bit) |
eMMC 8-bit (MMC2) boot | (SW6) 11010110 (from 1-8 bit) |
SD boot | (SW6) 01000010 (from 1-8 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.
Something went wrong! Please try again.
With Linux® running on the i.MX platform, you can evaluate special features that i.MX SoCs provide:
There are three main power management techniques on i.MX boards:
After Linux® setup, for more details about developing applications in user space. Please see i.MX6 Linux® Reference Manual.
After Linux® setup, for more details about developing applications in user space. Please see i.MX6 Linux® Reference Manual.
Something went wrong! Please try again.
After Linux® setup, for more details about developing applications in user space. Please see i.MX6 Linux® Reference Manual.
Something went wrong! Please try again.
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
Something went wrong! Please try again.
The Sensor Demo i.MX 7Dual is a simple demonstration program that uses the FreeRTOS and a set of drivers Provided by NXP. It can get the current gravitational acceleration, temperature, altitude, and magnetic field strength of the board. The purpose of this demo is to show how to use the I2C driver as a Master to communication with other I2C Slaves.
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.
-------------- iMX7D SDB on board sensor example --------------
Please select the sensor demo you want to run:
[1].FXAS21002 3-axes Gyro sensor
[2].FXOS8700 6-axes Acc+Mag sensor
[3].MPL3115 Pressure sensor
The features described in the release notes are supported by NXP implemented media framework OMXPlayer. They are only available after applied android_L5.1.1_2.0.0-ga_omxplayer_source.tar.gz software package.
Only codecs that have no license restriction are included in OMXPlayer package.
For the i.MX 6Dual/Quad, the enhanced features nclude the following:
For the i.MX 6SoloX, the enhanced features include the following:
Check Video/Audio decoder/encoder in i.MX Android™ Extended codec Releae Notes.
To install the OMXPlayer package, perform the following steps:
This step generates the device/fsl-codec, external/fsl_imx_omx, lean_obj_before_building.sh, and switch_build_to.sh.
$ source build/envsetup.sh
$ lunch # e.g., sabresd_6dq-user
$./switch_build_to.sh full
$./clean_obj_before_building.sh
$make
Something went wrong! Please try again.
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 RGB LED toggling between each of the three colors; red, blue, and green. It's OK to move onto the next step when you're ready.
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.
The following steps will guide you through opening the hello_world application. These steps may change slightly for other example applications as some of these applications may have additional layers of folders in their path.
If not already done, open the desired example application workspace. Most example application workspace files can be located using the following path:
Using the hello_world demo as an example, the path is:
Select the desired build target from the drop-down. For this example, select the “hello_world – Debug” target.
To build the application, click the “Make” button, highlighted in red below.
The build will complete without errors.:
The FRDM-KE15Z 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:
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.
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 Pack Installer window, navigate to the section with the Kinetis packs (they are in alphabetical order). The Kinetis packs start with "Keil::Kinetis" and are followed by the MCU family name, for example "Keil::Kinetis_K60_DFP". Because this example uses the FRDM-KE15Z platform, the K60 family pack is selected. Click on the "Install" button next to the pack. This process requires an internet connection to successfully complete.
After the installation finishes, close the Pack Installer window and return to the µVision IDE.
The following steps will guide you through opening the hello_world application. These steps may change slightly for other example applications as some of these applications may have additional layers of folders in their path.
If not already done, open the desired demo application workspace in:
The workspace file is named
To build the demo project, select the "Rebuild" button, highlighted in red.
The build will complete without errors.
The FRDM-KE15Z 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:
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.
Before using KDS IDE with KSDK, it is recommended that you make sure that your tools are up-to-date. The steps discussed below are shown using the Windows version of KDS, but are identical for Mac and Linux users.
Select "Help" -> "Check for Updates".
Install all updates from Freescale/NXP – these are denoted by “com.NXP.xxx” or “com.nxp.xxx”. There may also be updates for things such as toolchain or debug interfaces. While these additional updates are typically OK to install, sometimes they may cause issues since they aren’t released as part of the KDS toolchain.
The following steps will guide you through opening the hello_world application. These steps may change slightly for other example applications as some of these applications may have additional layers of folders in their path.
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 "Project of Projects" folder and select "Existing Project Sets". Then, click the "Next" button.
Click the "Browse" button next to the "Import from file:" option.
Point to the example application project, which can be found using this path:
For this guide, choose the specific location:
After pointing to the correct directory, your "Import Working Sets and Projects" window should look like the figure below. Click the "Finish" button.
There are two project configurations (build targets) supported for each KSDK project:
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).
The FRDM-KE15Z 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.
NOTE
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:
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 libudev1
user@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. This refers to the OpenSDA interface of your board. If you’re unsure what your board has, please consult Appendix B of the PDF linked in the top right-hand corner of this dialog.
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 mbed/CMSIS-DAP 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.
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.
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.
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.
NOTE
The installation path cannot contain any spaces.
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:
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.
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.9 2015q3
Reference the installation folder of the GNU Arm GCC Embedded tools for the exact pathname of your installation.
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.
To build an example application, follow these steps.
1. 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 example application project directory, which has a path like this:
For this guide, the exact path is:
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:
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:
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
Modify the settings as shown below. The target device selection chosen for this example is the “MK64FN1M0xxx12” and use the SWD interface.
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
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:
For this guide, the path is:
Run the command "arm-none-eabi-gdb.exe
Run these commands:
The application is now downloaded and halted at the reset vector. Execute the "monitor go" command to start the example application.
The hello_world application is now running and a banner is displayed in the terminal window.
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.
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.
Something went wrong! Please try again.