Audio
Interfaces
Peripherals and Logic
Power Management
Sensors
RF
RFID/NFC
Security and Authentication
Wireless Connectivity
Browse all products
Product Information
Application-Specific Products
NXP Community
Design ideas, demo videos, quality answers. Connect with NXP professionals and other knowledgeable designers ready to help.
Design Resources
Software, documentation, evaluation tools. The resources to build comprehensive solutions and accelerate your time to market.
Access our design resource library
Careers at NXP
We're always looking for passionate and talented people to work with us.
Join our teamJump To
i.MX 8M Mini EVK out of the box
Out of the Box
The following instructions will guide you on how to boot the preloaded Android image on the i.MX 8M Evaluation Kit.
Development kit contains:
- i.MX8MQuad EVK board for smart devices
- USB cable (micro-B to standard-A)
- Cable -Assembly, USB 3.0 Type-A Male, USB micro-B Male, Shielded, 1m
- Cable -Assembly, USB 2.0 Type-A Male, USB Type-C Male, Shielded, 1m
- 12 V/5 A universal power supply
- Quick Start Guide
- Android BSP flashed into the eMMC
1.1 Get Familiar with the Board
Figure 1. i.MX8MQuad EVK front
Figure 2. i.MX8MQuad EVK back
1.2 Boot from eMMC
The i.MX8MQuad EVK comes with a pre-built NXP Android binary demo image flashed on the eMMC. Without modifying the binary inside, booting from the eMMC provides a default system with certain features for building other applications on top of Android.
To understand more about NXP’s Embedded Linux®, Embedded Android™, or MCUXpresso SDK, continue reading the next sections.
1.3 Connect USB Debug Cable
Connect the micro-B end of the supplied USB cable into Debug UART port J1701. Connect the other end of the cable to a host
computer.
If you are not sure about how to use a terminal application, try one of the following tutorials depending on the operating system of the host machine:
Linux
Windows
Windows
1.4 Connect the HDMI cable
To see the user interface provided with the image binary connect a monitor via the HDMI connector (J1001).
1.5 Boot Switch Setup
Click here to see the Boot Switch Setup
1.6 Connect Power Supply
Connect the plug of the 12 V power supply to the DC power jack J902. Power on the EVK board by sliding power switch
SW701 to ON.
Power the board by flipping the switch (SW701). The
processor starts executing from the on-chip ROM code. With the default boot switch setup, the code reads
the fuses to define the media where it is expected to have a bootable image. After it finds a bootable
image, the U-Boot execution should begin automatically.
Information is printed in the smaller number serial console for the Cortex-A53 (COM9 on Windows as an example and /dev/ttyUSB* on Linux). If you do not stop the U-Boot
process, it continues to boot the Linux kernel.
1.7. Congratulations! Android has booted!
During the boot process, the Android logo appears on the HDMI display. Note that the HDMI output resolution is 1080P fixed — to change it, check the Android Documentation.
The Android UI can be seen after the boot process is finished. You can start operating with the mouse.
Minicom Tutorial
Serial communication console setup
On the command prompt of the Linux host machine, run the following command to determine the port number:
$ ls /dev/ttyUSB*
The smaller number is for Arm® Cortex®-A53 core and the bigger number is for Arm® Cortex®-M4 core.
Minicom
Use the following commands to install and run the serial communication program (minicom as an example):
-
Install Minicom using Ubuntu package manager.
$ sudo apt-get install minicom -
Launch Minicom using a console window using the port number
determined earlier.
$ sudo minicom /dev/ttyUSB* -s - Configure Minicom as shown in Figure 3
- The next step is to Connect the HDMI cable.
Figure 3. Minicom Configuration
Tera Term Tutorial
Serial communication console setup
The FTDI USB-serial chip on i.MX8MQuad enumerates two serial ports. Assume that the ports
are COM9 and COM10. The smaller numbered port ( COM9) is for the serial console
communication from Arm® Cortex®-A53 and the larger
numbered port (COM10) is for
Arm® Cortex®-M4 core. The serial-to-USB drivers are
available at http://www.ftdichip.com/Drivers/VCP.htm.
Note: To determine the port number of the i.MX board virtual COM port, open the Windows device manager and find USB serial Port in Ports (COM and LPT)
Teraterm
Is an open source terminal emulation application. This program displays the information sent from the NXP development platform’s virtual serial port.
- Download Tera Term. After the download, run the installer and then return to this webpage to continue.
- Launch TeraTerm. The first time it launches, it shows 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
COMport number identified earlier) to115200baud rate,8data bits, no parity and1stop bit. To do this, go to Setup → Serial Port and change the settings. - Verify that the connection is open. If connected, Tera Term shows something like below in its title bar.
- The next step is to Connect the HDMI cable.
PuTTY Tutorial
Serial communication console setup
The FTDI USB-serial chip on i.MX8MQuad enumerates two serial ports. Assume that the ports
are COM9 and COM10. The smaller numbered port ( COM9) is for the serial console
communication from Arm® Cortex®-A53 and the larger
numbered port (COM10) is for Arm®
Cortex®-M4. The serial-to-USB drivers are available at http://www.ftdichip.com/Drivers/VCP.htm.
Note: To determine the port number of the i.MX board virtual COM port, open the Windows device manager and find USB serial Port in Ports (COM and LPT)
PuTTY is a popular terminal-emulation application. This program displays the information sent from the NXP development platform’s virtual serial port.
- Download PuTTY After the download, run the installer and then return to this webpage to continue.
- Launch PuTTY by either double clicking on the executable 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
COMport number that you determined earlier. Also enter the baud rate, in this case115200. - Click Open to open the serial connection. Assuming the board is
connected and you entered the correct
COMport, the terminal window opens. If the configuration is not correct, PuTTY alerts you. - The next step is to Connect the HDMI cable.
Embedded Linux®
This section is applicable ONLY if attempting to load a Linux operating system on the board.
The i.MX Linux Board Support Package (BSP) is a collection of binary files, source code, and support files that are used to boot an Embedded Linux image on a specific i.MX development platform.
Current releases of Linux binary demo files can be found on the i.MX Linux download page. The Linux User Guide and Linux Reference Manual provide additional information. Additional documentation can be found the i.MX Linux documentation bundle, or under the Linux sections on the i.MX Software and Development Tool.
2.1 Overview
Before the Linux OS kernel can boot on an i.MX board, the Linux image is copied to a boot device (SD card, eMMC and so on) and the boot switches are set to boot that device.
There are various ways to download the Linux BSP image for different boards and boot devices.
For this getting started guide, only a few methods to transfer the Linux BSP image to an SD card are listed. Experienced Linux developers can explore other options.
Depending on the OS used in the host machine, the way to transfer the Linux BSP image onto an SD card can vary.
Choose an option below for detailed instructions:
2.2 Linux
2.2.1 Download an NXP Linux BSP pre-built image
A .sdcard file is a disk image that is flashed
directly into any SD card. This is the simplest way to load all necessary components required to
boot the i.MX8MQuad EVK board. The latest pre-built images for the i.MX8MQuad EVK is available
on the Linux
download page.
The pre-built NXP Linux binary demo image provides a typical system and basic set of features for using and evaluating the processor. Without modifying the system, users can evaluate hardware interfaces, test SoC features, and run userspace applications.
To bring up the board and run Linux, four elements are needed on the boot image:
- 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
The .sdcard images contain these four elements
in a single file.
When more flexibility is desired, an SD card can be loaded with individual components (boot
loader, kernel, dtb file, and rootfs file) one-by-one or the .sdcard image is loaded and the individual parts
are overwritten with the specific components.
2.2.2 Burn an SD card disk image from a Linux host computer
Once the BSP package is downloaded from the Linux
download page, ensure that a pre-built SD card image built specifically for the
i.MX8MQuad EVK board is in the compressed file. The SD card image is named
Note: An SD/MMC card reader is required to copy the SD card disk image into an SD card.**
Connect the SD/MMC card reader with a SD card to your host machine running the Linux OS.
The Linux OS kernel running on the host assigns a device node to the SD/MMC card reader.
To identify the device node assigned to the SD/MMC card, perform the following command in the host computer:
$ cat /proc/partitions
The instructions below will permanently delete existing content on the SD card and are dangerous to your PC if run incorrectly. If you have questions or would like further details, consult the i.MX Linux User Guide.
Run the following command to copy the SD card image to the SD/MMC card. Change /dev/sdX below to match the one used by the SD
card.
$ sudo dd if=
To setup the partition manually, read 4.3.3 in i.MX Linux User Guide.
To load individual components separately when the full SD card image is not used, refer to 4.3.4-3.4.6 in i.MX Linux User Guide.
With the source code and documentation, the users can customize the Linux image built for the device. For example, add or remove system components.
2.2.3 Build your own Linux BSP image (optional)
To build an NXP Linux BSP image, you can obtain the source code from the i.MX CodeAurora repository.
Detailed instructions on how to build an image are available in the Linux User Guide.
2.2.4 The Yocto Project
As an option, NXP provides a framework to build custom images. The Yocto Project is the framework of choice with NXP professional support to build custom images that are used for booting a Linux kernel, although other methods can be used.
Details on how to set up the Yocto Project go beyond this getting started guide. For details, refer to the NXP Yocto Users Guide.
2.3 Windows
2.3.1 Burn NXP Linux BSP image using Manufacturing Tool
The Manufacturing Tool, named MFGTool, is NXP tool of choice to load images on i.MX boards from a Windows OS host computer. The MFGTool is used to download images to different devices on i.MX board.
Perform the following steps to flash the board images:
- The compressed file is found in the pre-built Linux BSP image download bundle.
- Unzip the
L4.9.88_2.0.0-ga_mfg-tools.tar.gzfile to a selected location. This file includes two different MFGTool configurations, one with the rootfs images and one without it. For this tutorial, unzip themfgtools-with-rootfs.zipwhich creates a directory which is namedMFGTool- Dirin this example. - Ensure that the files inside the directory
MFGTool-Dir/Profiles/Linux/OS Firmware/filespath. If there are no files, copy the files from the pre-built images. - Change the board’s
SW802(boot mode) to01(from bit 1 to bit 2) to enter flash mode. - Power on the board. Use USB cable on the board OTG port, and connect a computer running Windows OS with the board.
- Double-click the
*.vbsfile according to the target device as shown in the following table. -
Click Start to start flashing images.
Figure 5. MFGTool interface
The figure below shows flashing in progress, and the status bar shows the flash status. The flash may take one to two minutes depending on the host machine.
Figure 6. MFGTool operation
The figure below shows the tool when the flash is complete.
Figure 7. MFGTool successful flash
- Click Stop and disconnect the USB cable.
- Change
SW801(boot mode) to1100andSW802to10to switch the board back toJ1601boot mode.
Note: There are two USB micro ports in i.MX8MQuad EVK board: USB to UART, USB OTG. The USB to UART can be referenced as debug UART, and the USB OTG can be referenced as USB in the hardware image above. The debug UART can be used to watch the log of the hardware boot processing.
The SD card should be plugged in after the board is powered on.
| Target device and boot storage VBS file | *VBS file |
| i.MX8MQuad EVK | mfgtool2-yocto-mx8-evk-sdcard-sd2.vbs |
2.3.2 Boot Switch Setup
Click here to see the Boot Switch Setup
Embedded Android™
This section describes the boot process of loading the i.MX8MQuad EVK board with an Embedded Android system image and introduces how to build the software components that create your own system image. For details on building the Android platform, see https://source.android.com/source/building.html
The current release includes Demo Images, Source code and Documentation. These can also be found under Android section of the i.MX Software and Development Tool.
3.1 Overview
The storage devices on the development system (MMC/SD or NAND) must be programmed with the U-Boot boot loader. The boot process determines which 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 can come from pre-built release packages or be created from source code. Regardless of how you obtain them, all Android images contain the following components:
-
U-Boot image:
u-boot.imx -
boot image:
boot.img -
Android system root image:
system.img -
Recovery root image:
recovery.img
For more information about the Android BSP refer to the Android User Guide.
Depending on the OS used in the host machine, the way to transfer the Android BSP image onto an SD card can vary.
Choose an option below for detailed instructions:
3.2 Linux
3.2.1 Download NXP Android BSP Image
The pre-built NXP Android demo image provides a default system with certain features for the purpose of evaluation. Without modifying the system, users can perform some basic operations, and interact with the system to test hardware interfaces and develop a software application in the user space.
The pre-built images from the package are categorized by boot device and put in the directory with the device name. The latest pre-built image files can be found in Android section on the i.MX Software and Development Tool, or on the demo images downloader link.
3.2.2 Loading images onto an SD card
Partition the SD card
Once you download the pre-built images, the script below can be used to partition an SD card:
$ cd ${MY_ANDROID}/
$ sudo ./device/fsl/common/tools/fsl-sdcard-partition.sh -f imx8mq /dev/sdX
In /dev/sdX the X is the disk index from 'a' to 'z'. That may be
different on each computer running Linux OS.
IMPORTANT The minimum SD card size required is 8 GB.
Different SD card sizes require different partition scripts:
-
If the SD card is 8 GB, use:
$ sudo ./device/fsl/common/tools/fsl-sdcard-partition.sh -f imx8mq /dev/sdX -
If the SD card is 16 GB, use:
$ sudo ./device/fsl/common/tools/fsl-sdcard-partition.sh -f imx8mq -c 14 /dev/sdX -
If the SD card is 32 GB, use:
$ sudo ./device/fsl/common/tools/fsl-sdcard-partition.sh -f imx8mq -c 28 /dev/sdX -
Unmount all the SD card partitions before running the script.
$ umount /dev/sdX
Copy the related boot loader, boot image, system image, recovery image, GPT table image, and vendor image in your current directory.
This script requires to install the simg2img tool on the computer. simg2img is a tool that
converts the sparse system image to raw system image on the Linux OS host computer. The
android-toolsfsutils package includes the simg2img command for Ubuntu Linux OS.
3.2.3 Build your own Android BSP Image (Optional)
To build the Android source files a host computer running Linux OS is required. Ubuntu 14.04 (64-bit) version is the most tested OS for the Android NXP BSP Release.
Check whether you have all the necessary packages installed for an Android build. See "Setting up your machine" on the Android website https://source.android.com/source/initializing.html.
In addition to the packages requested on the Android website, refer to Android User Guide to install the additional packages. Which can be found inside the Documentation bundle.
Source code
Get the Android source code from Google repo using the manifest and script provided inside the source code package.
$ sudo apt-get install repo
$ source ~/imx-o8.1.0_1.3.0_8mq_ga/imx_android_setup.sh
By default, the imx_android_setup.sh script will create the
source code build environment in the folder ~/android_build.
Note: ${MY_ANDROID} will be
referred as the i.MX Android source code root directory in all i.MX Android release
documentation.
$ export MY_ANDROID=~/android_build
Build
The build configuration command lunch can be
issued with an argument
The following is an example on how to build the Android image with user type for the i.MX8MQuad EVK board:
$ cd ~/myandroid
$ source build/envsetup.sh
$ lunch evk_8mq-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.
The default configuration in the source code package takes internal eMMC as the boot storage. To change to SD card, refer to Android User’s Guide which can be found inside the Documentation bundle.
There are several additional information on how to build, customize and change the Android source code in the documents present in Documentation bundle.
3.3 Windows OS
3.3.1 Download UUU on Windows
Download the latest stable files from UUU GitHub page. An extensive tutorial for UUU can be found in https://github.com/NXPmicro/mfgtools/wiki.
- uuu.exe
- libusb-1.0.dll
- Serial USB drivers (depending on your board and Windows installation)
3.3.2. Download the latest Android images
Download the Android demo files from NXP.com.
Extract the downloaded file into a know directory.
3.3.3 Burn the NXP Linux BSP image to the board
Copy the file named uuu from section Download
UUU on Windows into the extracted Android demo directory.
Open Command Prompt and navigate to the extracted Android demo directory
> uuu.exe uuu-android-mx8mm-evk-sd.lst
Insert an SDcard on connector J1701. Turn on the board in serial download mode, uuu starts to copy the images to the board. To put the board in serial download mode follow the instructions on the Boot switch setup section.
When it finishes, turn off the board, and consult Boot switch setup to configure the board to boot from SDcard.
MCUXpresso SDK
The MCUXpresso Software Development Kit (MCUXpresso SDK) provides comprehensive software source code to be executed in the i.MX8MQuad M4 core. If you do not wish to enable the Cortex-M4 on i.MX8MQuad at this moment you can skip this section.
4.1 Overview
The MCUXpresso SDK is designed for the development of embedded applications for Cortex-M4 standalone or collaborative use with the A cores. Along with the peripheral drivers, the MCUXpresso SDK provides an extensive and rich set of example applications covering everything from basic peripheral use case examples to demo applications. The MCUXpresso SDK also contains RTOS kernels, and device stack, and various other middleware to support rapid development.
Depending on the OS used in the host machine, the way to build and deploy the demos can vary.
Choose an option below for detailed instructions:
4.2 Linux
4.2.1 Download MCUXpresso SDK on Linux
Current releases of the MCUXpresso SDK and source code can be found at https://mcuxpresso.nxp.com/en/welcome.
To download the MCUXpresso SDK for i.MX8MQuad, follow these steps:
-
Click on “Select Development Board”.
-
Select
evkmimx8mqunder “Select a Device, Board, or Kit” and click on “Build MCUXpresso SDK” on the right.
-
Select “Host OS” as
Linux. -
Select “Toolchain/IDE” as
GCC Arm Embedded. -
Click on “Select Optional Middleware“, “Select All“ and hit “Save changes“.
-
Click on “Request Build”.
-
Wait for the SDK to build and download the package.
4.2.2 Build MCUXpresso SDK on Linux
4.2.3 Install toolchain
-
Download and run the installer from
launchpad.net/gcc-arm-embedded. This is the actual toolchain. The toolchain includes the compiler, linker, and so on. The GCC toolchain should correspond to the latest supported version, as described in the MCUXpresso SDK Release Notes found in the package already downloaded. -
Export the toolchain location as
ArmGCC_DIR.$ export ArmGCC_DIR=/usrNoteThe
/usris the usual install directory when youapt-get gcc-arm-none-eabi. Change the directory if this changes. -
Ensure that
cmakeis installed:
$ sudo apt-get install cmake
$ sudo apt-get install gcc-arm-none-eabi
Build MCUXpresso SDK
-
Change the directory of the command window to the demo armgcc directory and run the build command:
$/boards/evkmimx8mq/demo_apps/ /armgcc $ ./build_all.sh -
There are two project configurations (build targets) supported for each MCUXpresso SDK project:
Debug
Compiler optimization is set to low, and debug information is generated for the executable. This target is selected for development and debug.
Release
Compiler optimization is set to high, and debug information is not generated. This target is selected for final application deployment.
Note: There are script files provided to build both configurations. For this example, the
Debugtarget is built andbuild_debug.shis typed on the command line. If theReleasetarget is desired, typebuild_release.shinstead. -
The previous command generates the debug and release binaries (
sdk20-app.bin). These files are in the debug and release folders. - Copy the bootable image
sdk20-app.binto the boot partition of the SD card.
4.2.4 Run applications using U-Boot
This section describes how to run applications using an SD card and pre-built U-Boot image for i.MX processor.
-
Following the steps on the Embedded Linux® tab, prepare an SD card with a pre-built U-Boot + Linux image from Linux BSP package for the i.MX8MQuad processor. If you have already loaded the SD card with a Linux image, you can skip this step.
- Insert the SD card in the host computer (Linux or Windows), and copy the application image
(for example
sdk20-app.bin) to the FAT partition of the SD card. - Safely remove the SD card from the PC.
- Insert the SD card to the target board. Make sure to use the default boot SD slot and double
check the Boot Switch Setup. The default
configuration of the validation board boots from
J1601, and on EVK board there is only one SD slot which is used for boot. -
Connect the DEBUG UART slot on the board with to the PC through the USB cable. The Windows OS installs the USB driver automatically, and the Ubuntu OS will find the serial devices as well.
See Serial Communication Console setup section in Out of the box for more instructions on serial communication applications.
- Open a second terminal emulator on the i.MX8MQuad EVK board’s second enumerated serial
port. This is the Cortex-M4’s serial console. Set the speed to
115200bit/s, data bits8, no parity, and power on the board. -
Power up the board and stop the boot process by pressing any key before the U-Boot countdown reaches zero. At the U-Boot prompt on the first terminal emulator, type the following commands to U-Boot.
=> fatload mmc 1:1 0x7e0000 sdk20-app.bin=> bootaux 0x7e0000These commands copy the image file from the first partition of the SD card into the Cortex-M4’s memory and release the Cortex-M4 from reset.
4.3 Windows
4.3.1 Download MCUXpresso SDK on Windows
Current releases of the MCUXpresso SDK and source code can be found at https://mcuxpresso.nxp.com/en/welcome.
To download the MCUXpresso SDK for i.MX8MQuad, follow these steps:
-
Click on “Select Development Board”.
-
Select
evkmimx8mqunder “Select a Device, Board, or Kit” and click on “Build MCUXpresso SDK” on the right.
-
Select “Host OS” as
Linux. -
Select “Toolchain/IDE” as
GCC Arm Embedded. -
Click on “Select Optional Middleware”, “Select All” and hit “Save changes”.
-
Click on “Request Build”.
-
Wait for the SDK to build and download the package.
4.3.2 Build NXP MCUXpressoSDK on Windows
4.3.3 Install toolchain
Download and run the installer from launchpad.net/gcc-arm-embedded. This is the
actual toolchain. The toolchain includes the compiler, linker, and so on. The toolchain includes
the compiler, linker, and so on. The GCC toolchain should correspond to the latest supported
version, as described in the MCUXpresso SDK Release Notes found in the package already
downloaded.
4.3.4 Install MinGW
The Minimalist GNU for Windows (MinGW) development tools provide a set of tools not dependent on third-party C-Runtime DLLs (such as Cygwin). The build environment used by the MCUXpresso SDK does not utilize 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: https://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-baseandmsys-baseare selected under Basic Setup.
Figure 13. MinGW files
-
Click
Apply Changesin theInstallationmenu and follow the remaining instructions to complete the installation.
Figure 14. Apply changes
-
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 Important: Assuming the default installation path,
C:\MinGW, an example is shown below. If the path is not set correctly, the toolchain does not work.
If you haveC:\MinGW\msys\x.x\binin yourPATHvariable (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.8 2014q3Reference the installation folder of the GNU Arm GCC Embedded tools for the exact path name of your installation.
Figure 15. Variable name
4.3.5 Install CMake
-
Download CMake 3.0.x from https://www.cmake.org/cmake/resources/software.html
-
Before installing CMake, ensure that the option Add CMake to system PATH is selected. It is up to the user to select whether it is installed into the PATH for all users or just the current user. In this example, the assumption is that it is installed for all users.
Figure 16. Install CMake
-
Follow the remaining instructions of the installer.
Note: You may need to reboot your system for the PATH changes to take effect.
MCUXpresso SDK
-
Open a GCC Arm Embedded toolchain command window. To launch the window, from the Windows operating system Start menu, go to Programs → GNU Tools Arm Embedded version> and select GCC Command Prompt.
Figure 17. GCC command prompt
-
Change the directory of the command window to the demo
armgccdirectory and run the build command:\boards\evkmimx8mq\demo_apps\ \armgcc Or double-click on the
build_all.batfile in Explorer to perform the build. The expected output is shown in this figure:
Figure 18. Build result
-
There are two project configurations (build targets) supported for each MCUXpresso SDK project:
-
Compiler optimization is set to low, and debug information is generated for the executable. This target should be selected for development and debug.
-
Compiler optimization is set to high, and debug information is not generated. This target should be selected for final application deployment.
Debug
Release
Note: There are script files provided to build both configurations. For this example, the
Debugtarget is built andbuild_debug.batis typed on the command line. If theReleasetarget is desired, typebuild_release.batinstead. -
-
The previous command generates the debug and release binaries (
sdk20-app.bin). These files are in the debug and release folders. - Copy the bootable image
sdk20-app.binto the boot partition of the SD card.
4.3.6 Run applications using U-Boot
This section describes how to run applications using an SD card and pre-built U-Boot image for i.MX processor.
- Following the steps on the Embedded Linux® tab, prepare an SD card with a pre-built U-Boot + Linux image from Linux BSP package for the i.MX8MQuad processor. If you have already loaded your SD card with a Linux image you can skip this step.
- Insert the SD card to the host computer (Linux or Windows), and copy the application image
(for example
sdk20-app.bin) that you want to run to the FAT partition of the SD card. - Safely remove the SD card from the PC.
- Insert the SD card to the target board. Make sure to use the default boot SD slot and double
check the Boot Switch Setup. The default
configuration of the validation board boots from
J1601, and on EVK board there is only one SD slot which is used for boot. -
Connect the DEBUG UART slot on the board with your PC through the USB cable. The Windows OS installs the USB driver automatically, and the Ubuntu OS will find the serial devices as well.
See Serial Communication Console setup section in Out of the Box for more instructions for serial communication applications.
- Open a second terminal emulator on the i.MX8MQuad EVK board’s second enumerated serial
port. This is the Cortex-M4’s serial console. Set the speed to
115200bps, data bits8, no parity, and power on the board. -
Power up the board and stop the boot process by pressing any key before the U-boot countdown reaches zero. At the U-Boot prompt on the first terminal emulator, type the following commands to U-Boot.
=> fatload mmc 1:1 0x7e0000 sdk20-app.bin=> bootaux 0x7e0000
These commands copy the MCUXpressoSDK memory image file from the first partition of the SD card into the Cortex-M4’s memory and release the Cortex-M4 from reset.
5.1 Explore the documentation
When working with embedded systems, it is important to bear in mind that the documentation is wide and diverse. It is common to have different levels of documentation. The i.MX8MQuad EVK board has some documents. However, this board’s processor is i.MX8MQuad which is documented with SoC level documents. The BSPs available are documented with the BSP level documents.
Choose an option below for related documents:
5.1.1 Board documentation
In the case of i.MX8MQuad EVK the following documents are available.
Table 4. List of i.MX8MQuad EVK board-related documents
| Document | Description |
| Board Schematics | The i.MX8MQuad EVK electric schematic files. |
| i.MX8MQuad EVK Hardware User Guide | The purpose of this document is to help hardware engineers design and test their imx8mq series processor-based designs. It provides information on board layout recommendations, design checklists to ensure first-pass success, and ways to avoid board bring-up problems. It also provides information on board-level testing and simulation such as using BSDL for board-level testing, using the IBIS model for electrical integrity simulation and more. |
5.2 Key features in Linux BSP
With Linux running on the i.MX board, you can evaluate special features that i.MX SoCs provide. This tutorial presents the step-by-step for the following demos.
Choose an option below for detailed instructions:
5.2.1 Power management
This example shows how to suspend to low-power modes and resume to normal operation.
-
Enter the command below in order to enable serial TTY as a wake-up source for the board:
# echo enabled > /sys/class/tty/ttymxc0/power/wakeup
-
Enter the command below to enter Suspend-To-RAM mode:
# echo mem > /sys/power/statePM: Syncing filesystems ... done.Freezing user space processes ... (elapsed 0.005 seconds) done.Freezing remaining freezable tasks ... (elapsed 0.001 seconds) done.Suspending console(s) (use no_console_suspend to debug) -
Press any key on the keyboard to wake up the board. The following messages should appear on
terminal:
PM: suspend of devices complete after 637.926 msecsPM: suspend devices took 0.640 secondsPM: late suspend of devices complete after 1.966 msecsPM: noirq suspend of devices complete after 1.864 msecsDisabling non-boot CPUs ...PM: noirq resume of devices complete after 1.104 msecsPM: resume of devices complete after 99.689 msecsPM: resume devices took 0.110 secondsRestarting tasks ... done.
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 non-root 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.
Boot Switch Setup
SW801 switch on EMMc boot mode, the board boots from
the EMMc.
The boot modes of the i.MX boards are controlled by the boot configuration boot switches on the board.
Figure 4. Boot switch setup
The following table lists the boot switch settings (which takes priority in boot process) for booting from the EMMc on the i.MX8MQuad EVK board.
Table 1. Booting from EMMc on i.MX8MQuad EVKs
| Switch | D1 | D2 | D3 | D4 |
|---|---|---|---|---|
SW801 |
OFF | OFF | ON | OFF |
SW802 |
ON | OFF | - | - |