Getting Started with the i.MX RT1160 Evaluation Kit

The most recent versions of MCUXpresso IDE count with a terminal emulation application. This tool can be used to display information sent from your NXP development platform's virtual serial port.

1. Open the MCUXpresso IDE.

2. Launch the MCUXpresso IDE terminal by clicking on the “Open a Terminal” button on the top of the IDE or press “Ctrl + Alt + Shift + T.”

3. Select Serial Terminal

4. Configure the serial port settings (using the LPC-Link2 COM port number) to 115200 baud rate, 8 data bits, no parity and 1 stop bit, then press “OK” button.


5. Verify that the connection is open. If connected, MCUXpresso IDE will look like the figure below at the Terminal view.



6. You're ready to go

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.

1. Download Tera Term from SourceForge. After the download, run the installer and then return to this webpage to continue.
2. 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.

3. 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.
4. Verify that the connection is open. If connected, Tera Term will show something like below in its title bar.

5. You're ready to go.

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.

1. Download PuTTY using the button below. After the download, run the installer and then return to this webpage to continue.
2. 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.
3. 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.

4. 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.

5. You're ready to go

LPCScrypt is a command-line based, fast flash, EEPROM, OTP and security programming tool for LPC microcontrollers. It is the recommended tool to program the latest CMSIS-DAP and J-Link firmware.

1. Download the LPCScrypt tool using the button below, choose your platform (Windows, MAC OC X, Linux). After the download, run the installer. During the installation the DFU and VCOM drivers will be automatically installed for all platforms, also for windows users these drivers can be managed if required by running lpc_driver_installer.exe located within the Drivers subdirectory of the LPCScrypt installation.
   Download
2. Launch LPCScrypt by double-clicking on the “Boot LPCScrypt” file in the LPCScrypt install C:\ProgramData\Microsoft\Windows\Start Menu\Programs\LPCScrypt.
   
3. Configure To program an LPCXpresso v2/v3 board, first ensure that the DFULink jumper is connected.
   • In the MIMXRT1160-EVK, JP22 is the LPCXpresso DFU. Connect jumper on JP22 header.
   
4. Plug the power adapter into the MIMXRT1160-EVK board 5V DC IN header (J43) and switch on 5V DC IN (SW5).
5. Connect the board to your host computer over the debug link USB connector J11.
6. Open a Command shell, and run the program_JLINK script to install the JLink debug firmware:


Note:

• File paths in this document use Windows directory separators, on Linux or Mac OSX these must be replaced with ‘/.’
• For Windows users, shortcuts to these scripts are available from the LPCScrypt entry on the Start menu.

7. Verify once you select on firmware, in this case SEGGER J-Link, LPCScrypt command window will show something like below in its title bar.
   
8. Ready Once programming is complete, disconnect the board from the host. Remove the DFULink jumper, then reconnect the board to the host computer. You should see the probe enumerate on the host’s USB system.

Note: If CMSIS-DAP or SEGGER J-Link are used for LPC-Link2 firmware, power from external adapter is required.

Multicore application projects consist of two (or more) linked projects – one project containing the Master code and the other project(s) containing the Slave code. The ‘Master’ project contains a link to the ‘Slave’ project, which will cause the output image from the ‘Slave’ to be included into the ‘Master’ image when the Master project is built. Building the Master project will trigger the Slave project to be built first.

The RT1160 SDK provides a collection of Multicore example applications. Each Multicore example has two source directories, one for the Arm CM7 and one for the Arm CM4.

1. Build and Flash Multicore Application.

The following steps will guide you through the Multicore Hello World application using MCUXpresso IDE.

Note: The MCUXpresso IDE installation can be found at the section “2. Get Software” of the Getting Started website.

1. Open the MCUXpresso IDE.
2. Switch to the Installed SDKs view within the MCUXpresso IDE window.

3. Drag and drop the MIMXRT1160-EVK SDK (zipped) file into the Installed SDKs view.
4. You will get the following pop-up. Click on OK to continue the import:

5. The installed SDK will appear in the Installed SDKs view as shown below:

6. Find the Quickstart Panel in the lower left-hand corner.

7. Then click on Import SDK example(s)…

8. Click on the evkmimxrt1160 board to select that you want to import an example that can run on that board, and then click on Next.

9. Use the arrow button to expand the multicore_examples category, and then click the checkbox next to hello_world_cm7 to select that project; you will notice that after selecting the cm7 project, the cm4 project will be selected too. To use the UART for printing (instead of the default semihosting), Select UART as the SDK Debug Console checkbox under the project options. Then, click on Finish.

10. Verify that hello_world_cm7 and hello_world_cm4 are now included in the Project Explorer.

11. Select the hello_world_cm7 project and build it. Notice that MCUXpresso will build the hello_world_cm4 project first, and then it will build hello_world_cm7.

12. The project will build without problems.

2. Run an Example Application.

To download and run the application, perform these steps:

1. This board supports the CMSIS-DAP/mbed/DAPLink debug probe by default. Visit https://os.mbed.com/handbook/Windows-serial-configuration and follow the instructions to install the Windows^® operating system serial driver. If running on Linux OS, this step is not required.
2. Connect the board to your computer. Consider the following:
   • Make sure SW1 is set to 0010 to boot from QSPI
   • Connect Power supply to J43 (if J38 is set to [1-2])
   • Connect PC with board using micro USB to J11 port

3. Open the terminal application on the PC, such as PuTTY or TeraTerm, and connect to the debug serial port number. Configure the terminal with these settings:
   • Baudrate: 115200 (BOARD_DEBUG_UART_BAUDRATE)
   • No parity
   • 8 data bits
   • 1 stop bit.

4. Select the hello_world_cm7 application and the application to your MIMXRT1160-EVK.

5. Select the DAPLink debug probe and click “OK”.

6. A second “Probes discovered” window will appear automatically; this is for the hello_world_cm4 project. Again, select the DAPLink debug probe and click “OK”.
7. Click on ‘Resume’ button to start the hello_world_cm7 project.

8. Click on ‘Resume’ button to start the hello_world_cm4 project.

9. Now both cores are running. The console should display this output:

10. Exit debug session by click multi core stop.

Refer to the Getting Started with MCUXpresso SDK for MIMXRT1160-EVK.pdf in the <SDK install folder>/docs folder from the SDK for additional information and instructions to build and run example applications.

1. Build an Example Application.

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.

1. First unzip the previously downloaded SDK.
2. If not already done, open the desired example application workspace. Most example application workspace files can be located using the following path:

<sdk_dir>/boards/<sdk_board_name>/<example_type>/<application_name>/<core_type>/iar

Using the hello_world demo as an example, the path is:

<sdkl_dir>/boards/evkmimxrt1170/demo_apps/hello_world/cm7/iar/hello_world.eww

3. Select the desired build target from the drop-down. For this example, select hello_world – debug

4. To build the application, click the “Make” button, highlighted in red below.

5. The build will complete without errors.


Note: In case of building errors, make sure that the correct Board is selected, right click in the project >> Options >> General Options >> Target >> Device, Select the NXP MIMXRT1176xxxA_M7, this board is supported in IAR Embedded Workbench for Arm version 8.50.6 or Higher.

2. Run an Example Application.

To download and run the application, perform these steps:

1. This board supports the CMSIS-DAP/mbed/DAPLink debug probe by default. Visit https://os.mbed.com/handbook/Windows-serial-configuration and follow the instructions to install the Windows^® operating system serial driver. If running on Linux OS, this step is not required.
2. Connect the board to your computer. Consider the following:
   • Make sure SW1 is set to 0010 to boot from QSPI
   • Connect Power supply to J43 (if J38 is set to [1-2])
   • Connect PC with board using micro USB to J11 port

3. Open the terminal application on the PC, such as PuTTY or TeraTerm, and connect to the debug serial port number. Configure the terminal with these settings:
   • Baudrate: 115200 (BOARD_DEBUG_UART_BAUDRATE)
   • No parity
   • 8 data bits
   • 1 stop bit.

4. Click the "Download and Debug" button to download the application to the target.

5. The application is then downloaded to the target and automatically runs to the main() function.
6. Run the code by clicking the "Go" button to start the application.

7. The hello_world application is now running, and a banner is displayed on the terminal. If this is not true, check your terminal settings and connections.

Refer to the Getting Started with MCUXpresso SDK for MIMXRT1160-EVK.pdf in the <SDK install folder>/docs folder from the SDK for additional information and instructions to build and run multicore example applications.

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.

1. Download the MIMXRT1171, MIMXRT1172, MIMXRT1173, MIMXRT1175 and MIMXRT1176 packs.
2. After downloading the DFP, double click to install it.
3. After the installation finishes, close the Pack Installer window and return to the µVision IDE.

2. Build the Example Application.

The following steps will guide you through opening the hello_world_demo_cm7 application.

1. Open the desired example application workspace in:

<install_dir>/boards/<board_name>/<example_type>/<application_name>/mdk

The workspace file is named as <demo_name>.uvmpw. For this specific example, the actual path is:

<install_dir>/boards/evkmimxrt1170/demo_apps/hello_world/cm7/mdk/hello_world_demo_cm7.uvmpw

2. To build the demo project, select Rebuild, highlighted in red.

3. The build completes without errors.

3. Run an Example Application.

This section describes steps to run a demo application using J-Link GDB Server application. To perform this exercise, make sure that either:

To download and run the application, perform these steps:

1. This board supports the CMSIS-DAP/mbed/DAPLink debug probe by default. Visit https://os.mbed.com/handbook/Windows-serial-configuration and follow the instructions to install the Windows^® operating system serial driver. If running on Linux OS, this step is not required.
2. Connect the board to your computer. Consider the following:
   • Make sure SW1 is set to 0010 to boot from QSPI
   • Connect Power supply to J43 (if J38 is set to [1-2])
   • Connect PC with board using micro USB to J11 port

3. Open the terminal application on the PC, such as PuTTY or TeraTerm, and connect to the debug serial port number. Configure the terminal with these settings:
   • Baudrate: 115200 (BOARD_DEBUG_UART_BAUDRATE)
   • No parity
   • 8 data bits
   • 1 stop bit
   
4. After the application is properly built, click the "Download" button to download the application to the target.

5. Click on “Start/Stop Debug Session” to open the debug view.

6. Run the code by clicking the "Run" button to start the application.

7. The hello_world_demo_cm7 application is now running

Refer to the Getting Started with MCUXpresso SDK for MIMXRT1160-EVK.pdf in the <SDK install folder>/docs folder from the SDK for additional information and instructions to build and run multicore example applications.

1. Set Up Toolchain

This section contains the steps to install the necessary components required to build and run an MCUXpresso SDK demo application with the Arm GCC toolchain, as supported by the MCUXpresso 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 toolset (in other words, compiler, linker, etc.). The GCC toolchain should correspond to the latest supported version, as described in MCUXpresso SDK Release Notes Supporting MIMXRT1160-EVK from <SDK>/docs folder.

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 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.

1. Download the latest MinGW mingw-get-setup installer
   from sourceforge.net/projects/mingw/files/Installer/.
2. 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.

3. Ensure that the mingw32-base and msys-base are selected under Basic Setup.

4. In the Installation menu, click Apply Changes and follow the remaining instructions to complete the installation.

5. 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:

<mingw_install_dir>\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.

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\<version>

Reference the installation folder of the GNU Arm GCC Embedded tools for the exact pathname of your installation.

Install CMake

1. Download CMake 3.0.x from
   www.cmake.org/cmake/resources/software.html.
2. 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.

3. Follow the remaining instructions of the installer.
4. You may need to reboot your system for the PATH changes to take effect.
5. Make sure sh.exe is not in the Environment Variable PATH. This is a limitation of mingw32-make.

2. Build an Example Application.

To build an example application, follow these steps.

1. 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 <version>” and select “GCC Command Prompt”.

2. Change the directory to the example application project directory, which has a path like this:

<install_dir>/boards/<board_name>/<example_type>/<application_name>/armgcc

For this guide, the exact path is:

<install_dir>/boards/evkmimxrt1170/demo_apps/hello_world/cm7/armgcc

3. 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:

3. Run an Example Application.

This section describes steps to run a demo application using J-Link GDB Server application. To perform this exercise, make sure that either:

• The Freelink/LPC-Link2 interface on your board is programmed with the J-Link firmware. If your board does not support Freelink/LPC-Link2 interface, then a standalone J-Link pod is required.
• You have a standalone J-Link pod that is connected to the debug interface of your board.

Note: Some hardware platforms require hardware modification in order to function correctly with an external debug interface.

Procedure to configure Freelink/LPC-Link2 interface with J-Link firmware:

1. Power off the MIMXRT1160-EVK
2. Place a jumper in J22 header to enter DFU boot mode
3. Power on the MIMXRT1160-EVK
4. Connect to PC through J11 port
5. Download and install LPCScrypt from LPCScrypt v2.1.2
6. Go to the scripts folder from LPCScrypt location.
   ie. C:/NXP/LPCScrypt_2.1.1_15/scripts
7. Run the “program_JLINK.cmd” script
8. After script finishes, close the LPCScrypt window
9. Power off the MIMXRT1160-EVK
10. Remove jumper from J22 header
11. Power on the MIMXRT1160-EVK
12. Verify that Device Manager now lists the J-Link interface

After the J-Link interface is configured and connected, follow these steps to download and run the demo applications:

1. Connect the development platform to your PC via USB cable between the LPC-Link2(J11) USB connector and the PC USB connector. If using a standalone J-Link debug pod, also connect it to the SWD/JTAG connector of the board.

2. 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 <version> J-Link GDB Server".
3. Select Device “MIMXRT1176xxxA_M7” and Target interface to SWD.

4. Verify GDB Server is waiting for GDB connection.

5. Open the terminal application on the PC, such as PuTTY or TeraTerm, and connect to the debug serial port number. Configure the terminal with these settings:
• 115200 (reference BOARD_DEBUG_UART_BAUDRATE in board.h)
• No parity
• 8 data bits
• 1 stop bit

6. 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 <version>" and select "GCC Command Prompt".

7. 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:

<install_dir>/boards/<board_name>/<example_type>/<application_name>/cm7/armgcc/debug

<install_dir>/boards/<board_name>/<example_type>/<application_name>/cm7/armgcc/release

For this guide, the path is:

<install_dir>/boards/evkmimxrt1170/demo_apps/hello_world/cm7/armgcc/debug

8. Run the arm-none-eabi-gdb.exe <application_name>.elf. For this example, it is arm-none-eabi-gdb.exe hello_world.elf.

9. Run these commands on the GCC Command Prompt:
   • target remote localhost: 2331
   • monitor reset
   • monitor halt
   • load
10. 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 on the terminal. If this is not true, check your terminal settings and connections.

Refer to the Getting Started with MCUXpresso SDK for MIMXRT1160-EVK.pdf in the <SDK install folder>/docs folder from the SDK for additional information and instructions to build and run multicore example applications.