NXP S32K: Cortex-M4 Tutorial
Using the S32K144 EVB evaluation board
Arm Keil MDK 5 Toolkit Fall 2017
V 1.2 bob.boys@arm.com
The latest version of this document is here: www.keil.com/appnotes/docs/apnt_299.asp
Introduction:
NXP Cookbook Example Ports for MDK:
www.keil.com/appnotes/docs/apnt_304.asp
The purpose of this lab is to
introduce you to the NXP
A lab for the S32K-148 EVB using ETM:
www.keil.com/appnotes/docs/apnt_305.asp
S32K Cortex®-M4 processor
using the ARM® Keil® MDK toolkit featuring the IDE μVision®. We will demonstrate all debugging features available on this
processer. At the end of this tutorial, you will be able to confidently work with these processors and Keil MDK.
See www.keil.com/NXP and www.keil.com/S32 New Getting Started MDK 5: www.keil.com/gsg.
Keil MDK supports and has examples for most NXP Arm processors. Check the Keil Device Database® on
www.keil.com/dd2. This list is also provided by the μVision Pack Installer utility.
NXP i.MX processors are supported by Arm DS-MDK™. www.keil.com/ds-mdk.
Keil MDK-Lite™ is a free evaluation version that limits code size to 32 Kbytes. Nearly all Keil examples will compile within
this 32K limit. The addition of a valid license number will turn it into one of the commercial versions.
RTX RTOS: All variants of MDK contain the full version of RTX with Source Code. RTX has a BSD or Apache 2.0 license
with source code. www.keil.com/RTX and https://github.com/ARM-software/CMSIS_5 FreeRTOS is now supported.
Why Use Keil MDK ?
MDK provides these features particularly suited for NXP Cortex-M users:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
µVision IDE with Integrated Debugger, Flash programmer and the ARM ® Compiler
toolchain. MDK is turn-key "out-of-the-box". Examples and board support included.
Arm Compiler 5 and Arm Compiler 6 (LLVM) are included. For GCC:.
https://developer.arm.com/open-source/gnu-toolchain/gnu-rm/downloads
Compiler Safety Certification Kit: www.keil.com/safety/
TÜV certified. SIL3 (IEC 61508) and ASILD (ISO 26262). AC5 and AC6.
Dynamic Syntax checking on C/C++ source lines.
MISRA C/C++ support using PC-Lint. www.gimpel.com
Keil Middleware: Network, USB, Flash File and Graphics for some NXP processors.
NEW! Event Recorder for Keil Middleware, RTX and User programs. Page 17.
CoreSight™ Serial Wire Viewer (SWV). ETM instruction trace capability on
appropriately equipped NXP processors. Provides Instruction Debugging, Code
Coverage and Performance Analysis. For the S32K148 ETM lab see: www.keil.com/appnotes/docs/apnt_305.asp
Adapters: OpenSDA (CMSIS-DAP or P&E mode), ULINK™2, ULINK-ME, ULINKplus, ULINKpro and J-Link.
Affordable perpetual and term licensing with support. Contact Keil sales for pricing options. Inside-Sales@arm.com
Keil Technical Support is included for one year and is renewable. This helps you get your project completed faster.
Micrium µC/Probe compatible. www.micrium.com/ucprobe FreeRTOS is supported. NXP SDK included.
This document includes details on these features plus more:
1.
2.
3.
4.
5.
6.
7.
8.
Serial Wire Viewer (SWV) data trace. Includes Exceptions (interrupts), Data writes, graphical Logic Analyzer.
Real-time Read and Write to memory locations for the Watch, Memory and Peripheral windows. These are nonintrusive to your program. No CPU cycles are stolen. No instrumentation code is added to your source files.
Six Hardware Breakpoints (can be set/unset on-the-fly) and two Watchpoints (also known as Access Breaks).
RTX and RTX Tasks window: a kernel awareness program for RTX that updates while your program is running.
NEW! µVision Event Recorder. You can use this in your own programs too.
printf using SWV ITM or Event Recorder (EVR). No UART is required.
A DSP example program using Arm CMSIS-DSP libraries.
An extensive list of available document resources.
1
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
General Information:
1.
2.
3.
4.
NXP Evaluation Boards & Keil Evaluation Software:
MDK 5 Keil Software Information:
Debug Adapters Supported:
CoreSight Definitions:
3
3
3
4
Keil Software and Software Packs:
5.
6.
7.
Keil MDK Software Download and Installation:
µVision Software Pack and RTX5_Blinky example Download and Install Process:
Other features of Software Packs:
5
5
6
Using Debug Adapters:
8.
9.
10.
11.
Configuring the P&E OpenSDA Debug Adapter:
Configuring the CMSIS-DAP OpenSDA Adapter:
Testing the OpenSDA CMSIS-DAP Connection:
Configuring External Debug Adapters: Keil ULINK2/ME, ULINKpro, J-Link:
7
8
8
9
Blinky Example and Debugging Features:
12.
13.
14.
15.
16.
17.
18.
19.
20.
Blinky example using the S32K144 EVB:
Hardware Breakpoints and Single Stepping:
Call Stack & Locals window:
Watch and Memory windows and how to use them:
Peripheral System Viewer (SV):
Watchpoints: Conditional Breakpoints:
RTX System and Threads Viewer:
RTX Event Viewer:
NEW! Event Recorder:
10
11
12
13
14
15
16
17
18
Serial Wire Viewer (SWV):
21.
22.
23.
24.
25.
Serial Wire Viewer (SWV) Configuration with ULINK2, ULINK-ME and J-Link:
SWV ULINKpro Configuration:
Displaying Exceptions (including Interrupts) with SWV Event Viewer:
Using µVision Logic Analyzer (LA) Graphical variable display:
printf using ITM:
19
20
21
22
23
DSP:
26. DSP Sine Example:
24
Other Useful Information:
27. Document Resources:
28. Keil Products and contact information:
27
28
2
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
1) NXP Evaluation Boards & Keil Evaluation Software:
Keil MDK provides board support for many NXP Cortex-M processors. For the i.MX series see www.keil.com/ds5-mdk
On the second last page of this document is an extensive list of resources that will help you successfully create your projects.
This list includes application notes, books and labs and tutorials for other NXP boards.
We recommend you obtain the latest Getting Started Guide for MDK5: It is available free on www.keil.com/gsg/.
Arm forums: https://developer.arm.com
Keil Forums:
www.keil.com/forum/
2) MDK 5 Keil Software Information: This document uses MDK 5.24 or later.
MDK 5 Core is the heart of the MDK toolchain. This will be in the form of MDK Lite which is the evaluation version. The
addition of a Keil license will turn it into one of the commercial versions available. Contact Keil Sales for more information.
Device and board support are distributed via Software Packs. These Packs are downloaded from the web with the "Pack
Installer", the version(s) selected with "Select Software Packs" and your project configured with "Run Time Environment"
(RTE). These utilities are components of µVision.
A Software Pack is an ordinary .zip file with the extension changed to .pack. It contains various header, Flash programming
and example files and more. Contents of a Pack is described by a .pdsc file in XML format.
See www.keil.com/dd2/pack for the current list of available Software Packs. More packs are being added.
Example Project Files: This document uses the RTX5_Blinky example project contained in the S32K Software Pack.
3) Debug Adapters Supported:
These are listed below with a brief description. Configuration instructions start on page 7.
1.
OpenSDA: OpenSDA is an on-board debug adapter. NXP OpenSDA has a P&E and a CMSIS-DAP mode
depending on the firmware loaded into the OpenSDA processor U8. You do not need an external debugger such as a
ULINK2 to do this lab. If you want to use Serial Wire Viewer (SWV), you need any ULINK or a J-Link. You can
add CMSIS-DAP to a custom board. See https://github.com/ARM-software/CMSIS_5.
2.
CMSIS-DAP: An extra processor on your board becomes a debug adapter compliant to CMSIS-DAP. The S32K
and many other NXP boards incorporate CMSIS-DAP.
3.
ULINK2 and ULINK-ME: ULINK-ME is only offered as part of certain evaluation
board packages. ULINK2 can be purchased separately. These are electrically the
same and both support Serial Wire Viewer (SWV), Run-time memory reads and writes
for the Watch and Memory windows and hardware breakpoint set/unset on-the-fly.
4.
ULINKpro: ULINKpro supports all SWV features and adds ETM Instruction Trace.
ETM records all executed instructions. ETM provides Code Coverage, Execution
Profiling and Performance Analysis features. ULINKpro also provides the fastest
Flash programming times. Not all S32K devices have ETM. Consult your datasheet.
5.
ULINK2
NEW ! ULINKplus: High SWV performance plus Power Measurement.
See www.keil.com/ulink/ulinkplus/ for complete details.
6.
Segger J-Link: J-Link Version 6 (black) or later supports Serial Wire Viewer.
SWV data reads and writes are not currently supported with a J-Link.
ULINKpro
Debug Connections: An external debug adapter must be connected
to the J14 SWD connector and shown in these pictures. This is a
10 pin CoreSight standard connector. A special cable is
provided with a ULINK2, ULINK-ME and ULINKpro.
Contact Segger for a special adapter board for the J-Link series.
www.segger.com
J14 SWD
3
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
ULINKplus
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
4) CoreSight Definitions:
It is useful to have a basic understanding of these terms:
Cortex-M0 and Cortex-M0+ may have only features 2) and 4) plus 11), 12) and 13) implemented. Cortex-M3, Cortex-M4
and Cortex-M7 can have all features listed implemented. MTB is normally found on Cortex-M0+. It is possible some
processors have all features except ETM Instruction trace and the trace port. Consult your specific datasheet.
1.
JTAG: Provides access to the CoreSight debugging module located on the Cortex processor. It uses 4 to 5 pins.
2.
SWD: Serial Wire Debug is a two pin alternative to JTAG and has about the same capabilities except Boundary Scan
is not possible. SWD is referenced as SW in the µVision Cortex-M Target Driver Setup.
The SWJ box must be selected in ULINK2/ME or ULINKpro. Serial Wire Viewer (SWV) must use SWD because
the JTAG signal TDO shares the same pin as SWO. The SWV data normally comes out the SWO pin or Trace Port.
3.
JTAG and SWD are functionally equivalent. The signals and protocols are not directly compatible.
4.
DAP: Debug Access Port. This is a component of the Arm CoreSight debugging module that is accessed via the
JTAG or SWD port. One of the features of the DAP are the memory read and write accesses which provide on-thefly memory accesses without the need for processor core intervention. µVision uses the DAP to update Memory,
Watch, Peripheral and RTOS kernel awareness windows while the processor is running. You can also modify
variable values on the fly. No CPU cycles are used, the program can be running and no code stubs are needed.
You do not need to configure or activate DAP. µVision configures DAP when you select a function that uses it.
Do not confuse this with CMSIS_DAP which is an Arm on-board debug adapter standard.
5.
SWV: Serial Wire Viewer: A trace capability providing display of reads, writes, exceptions, PC Samples and printf.
6.
SWO: Serial Wire Output: SWV frames usually come out this one pin output. It shares the JTAG signal TDO.
7.
Trace Port: A 4 bit port that ULINKpro uses to collect ETM frames and optionally SWV (rather than SWO pin).
8.
ITM: Instrumentation Trace Macrocell: As used by µVision, ITM is thirty-two 32 bit memory addresses (Port 0
through 31) that when written to, will be output on either the SWO or Trace Port. This is useful for printf type
operations. µVision uses Port 0 for printf and Port 31 for the RTOS Event Viewer. The data can be saved to a file.
9.
ETM: Embedded Trace Macrocell: Displays all the executed instructions. The ULINKpro provides ETM. ETM
requires a special 20 pin CoreSight connector. ETM also provides Code Coverage and Performance Analysis. ETM
is output on the Trace Port or accessible in the ETB (ETB has no Code Coverage or Performance Analysis).
10. ETB: Embedded Trace Buffer: A small amount of internal RAM used as an ETM trace buffer. This trace does not
need a specialized debug adapter such as a ULINKpro. ETB runs as fast as the processor and is especially useful for
very fast Cortex-A processors. Not all processors have ETB. See your specific datasheet.
11. MTB: Micro Trace Buffer. A portion of the device internal user RAM is used for an instruction trace buffer. Only
on Cortex-M0+ processors. Cortex-M3/M4 and Cortex-M7 processors provide ETM trace instead.
12. Hardware Breakpoints: The Cortex-M0+ has 2 breakpoints. The Cortex-M3, M4 and M7 usually have 6. These
can be set/unset on-the-fly without stopping the processor. They are no skid: they do not execute the instruction they
are set on when a match occurs. The CPU is halted before the instruction is executed.
13. Watchpoints: Both the Cortex-M0, M0+, Cortex-M3, Cortex-M4 and Cortex-M7 can have 2 Watchpoints. These
are conditional breakpoints. They stop the program when a specified value is read and/or written to a specified
address or variable. There also referred to as Access Breaks in Keil documentation.
Read-Only Source Files:
Some source files in the Project window will have a yellow key on them:
This means they are read-only. This is
to help unintentional changes to these files. This can cause difficult to solve problems. These files normally need no
modification. µVision icon meanings are found here: www.keil.com/support/man/docs/uv4/uv4_ca_filegrp_att.htm
If you need to modify one, you can use Windows Explorer to modify its permission.
1.
In the Projects window, double click on the file to open it in the Sources window.
2.
Right click on its source tab and select Open Containing folder.
3.
Explorer will open with the file selected.
4.
Right click on the file and select Properties.
5.
Unselect Read-only and click OK. You are now able to change the file in the µVision editor.
6.
It is a good idea to make the file read-only when you are finished modifications.
4
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
5) Keil MDK Software Download and Installation:
1.
Download MDK 5.24 Lite or later from the Keil website. www.keil.com/mdk5/install
2.
Install MDK into the default folder. You can install into any folder, but this lab uses the default C:\Keil_v5
3. We recommend you use the default folders for this tutorial. We will use C:\00MDK\ for the examples.
4.
If you install MDK into a different folder, you will have to adjust for the folder location differences.
5. You do not need a debug adapter: just the S32K board, a USB cable and MDK installed on your PC.
6. For the exercises using SWV, you need a Keil ULINK2, ULINK-ME, ULINKplus, ULINKpro or a J-Link.
7. You do not need a Keil MDK license for this tutorial. All examples will compile within the 32 K limit.
6) µVision Software Pack Download and Install Process:
A Software Pack contain components such as header, Flash programming, documents and other files used in a project.
1) Start µVision and open Pack Installer:
1.
Connect your computer to the internet. This is needed to download the Software Packs. Start µVision:
2.
Open the Pack Installer by clicking on its icon:
3.
This window opens up: Select the Devices tab:
4.
Note “ONLINE” is displayed at the bottom right.
If “OFFLINE” is displayed, connect to the
Internet before continuing.
5.
If there are no entries shown because you were
not connected to the Internet when Pack
Installer opened, select Packs/Check for
A Pack Installer Welcome screen will open. Read and close it.
Updates or
to refresh once you have
connected to the Internet.
2) Install The S32K Software Pack:
1.
In the Devices tab, select NXP and then S32K Series as shown above: The devices supported are displayed.
2.
Select Keil::S32_SDK_DFP and click Install. This Pack will download and install into MDK. This download can
take several minutes. Both S32K-144 and S32K-148 processors are contained in this pack.
3.
Its status is indicated by the “Up to date” icon:
4.
Update means there is an updated Software Pack available for download.
TIP: The left hand pane filters the selections displayed on the right pane. You can start with either Devices or Boards.
3) Install the RTX5_Blinky Example:
1.
Select the Boards tab. Select S32K.
2.
Select the Examples tab:
3.
Opposite CMSIS-RTOS2 Blinky (S32K144-EVB):
select Copy:
4.
The Copy Example window opens up: Select Use
Pack Folder Structure. Unselect Launch µVision.
5.
Type in C:\00MDK\. Click OK to copy the RTX5_Blinky project.
6.
The RTX5_Blinky example will now copy to
C:\00MDK\addon_mdk\Boards\NXP\S32K144-EVB\
TIP: The default folder for copied examples the first time you install MDK is
C:\Users\<user>\Documents. For simplicity, we will use the default folder of
C:\00MDK\ in this tutorial. You can use any folder you prefer.
7.
Close the Pack Installer. You can open it any time by clicking on its icon.
5
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
7) Other features of Software Packs:
Select Software Pack version:
This µVision utility provides the ability to choose among the various software pack versions installed in your computer.
1.
Open the Select Software Pack by clicking on its icon:
2.
This window opens up. Note Use latest versions … is selected. The latest version of the Pack will be used.
3.
Unselect this setting and the window changes to allow various versions of Packs to be selected.
4.
Note various options are visible as shown here:
5.
Select excluded and see the options as shown:
6.
Select Use latest versions… Do not make any changes.
7.
Click Cancel to close this window to make sure no changes are made.
Manage Run-Time Environment (MRTE):
1.
Select Project/Open Project.
2.
Open the project: C:\00MDK\addon_mdk\Boards\NXP\S32K144-EVB\RTX5_Blinky\Blinky.uvprojx.
3.
Click on the Manage Run-Time Environment (MRTE) icon:
4.
Expand various headers and note the selections you can make. A selection made here will automatically insert the
appropriate source files into your project. You can select NXP SDK files from under the Device header.
5.
Do not make any changes. Click Cancel to close this window.
The window below opens:
TIP: µVision icon meanings are found here: www.keil.com/support/man/docs/uv4/uv4_ca_filegrp_att.htm
6
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
8) Configuring OpenSDA in P&E Mode:
If you are using any Keil ULINK, CMSIS-DAP or J-Link as your debug adapter: you can skip this page:
µVision supports OpenSDA on this board in either P&E or CMSIS-DAP mode. This allows debugging the S32K board with a
USB cable. No external adapter is required. The P&E firmware is installed on the S32K144 board at delivery. OpenSDA in
CMSIS-DAP mode is described on the next page.
If you decide to use a ULINK2, ULINK-ME or ULINKplus, you will get Serial Wire Viewer (SWV). With a ULINKpro,
ETM Trace is added which records all executed instructions and provides Code Coverage and Performance Analysis.
Install the P&E USB drivers:
1.
Plug a USB cable from your PC to J7 on the S32K board.
2.
Windows will automatically install the necessary P&E USB drivers.
Green LEDs D2 and D3 will light. If Blinky is installed, LED D11 will blink.
Start µVision and select the Blinky Project:
1.
Start µVision by clicking on its desktop icon.
2.
Select Project/Open Project.
3.
Open the project: C:\00MDK\addon_mdk\Boards\NXP\S32K144-EVB\RTX5_Blinky\Blinky.uvprojx.
Create a new Target Selection for P&E OpenSDA:
1.
Select Project/Manage/Project Items… or select:
2.
In the Project Targets area, select NEW
3.
Enter PE Flash and press Enter. Click OK to close this window.
4.
In the Target Selector menu, select the PE Flash selection you just made:
5.
Select Options for Target
6.
Select PEMicro Debugger… as shown here: <an important step>
or press your keyboard INSERT key.
or ALT-F7. Click on the Debug tab to select a debug adapter.
Configure the P&E Connection Manager: (the board must be connected)
1.
Click on Settings: The P&E Connection Manager window opens.
2.
In the Interface box, select OpenSDA Embedded Tower Debug: USB Port: as
shown here:
3.
Click the Select New Device box, and select your exact processor. In this case it is S32K144F512M15 as shown
here: This step is very important.
4.
Click on the Refresh List and you
will get a valid Port: box:
5.
This means µVision is connected to the target S32K processor using P&E OpenSDA.
6.
At the bottom of this window, unselect Show this dialog before attempting… as shown below:
7.
Click on OK to close this window.
8.
If you see Undetected in Port:, this means µVision is not connected to the target. Problems can be the S32K board is
not connected to USB, or the wrong device is selected. Fix the problem and click Refresh List to try again.
9.
Select File/Save All or click
. P&E OpenSDA is now completely configured including Flash programming.
10. You can go to page 10 to compile and run Blinky !
TIP: You can program the on-board OpenSDA debug adapter U8 to run in CMSIS-DAP mode. This procedure is described
on the next page. CMSIS-DAP currently has more features than P&E.
7
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
9) Configuring OpenSDA in CMSIS-DAP mode:
If you are using any Keil ULINK, or a J-Link as your debug adapter: you can skip this page:
This document will use NXP OpenSDA as an CMSIS-DAP debug adapter. This will replace the P&E debugger that comes
pre-installed on a new S32K board. Target connection by µVision will be via a standard USB cable connected to USB
connector J7. The on-board Kinetis K20 processor U8 acts as the CMSIS-DAP on-board debug adapter.
Program the K20 with the CMSIS-DAP application file CMSIS-DAP.S19:
1) Locate the file CMSIS-DAP.S19:
1.
CMSIS-DAP.S19 is located where this document is located. www.keil.com/appnotes/docs/apnt_299.asp. You will
now copy this file into the S32K board USB device.
2) Put the S32K Board into Bootloader: Mode:
2.
Set jumper J104 to position 1-2.
3.
Hold RESET button SW5 on the board down and connect a USB cable to J7 as shown below:
4.
When you hear the USB dual-tone, release the RESET button to enter bootloader mode.
5.
The S32K board will act as a USB mass storage device called BOOTLOADER connected to your PC. Open this
USB device with Windows Explorer.
3) Copy CMSIS-DAP.S19 into the S32K Board:
6.
Copy and paste or drag and drop CMSIS-DAP.S19 into this Bootloader USB device.
4) Exit Bootloader Mode:
7.
Set jumper J104 to back to position 2-3.
8.
Cycle the power to the S32K board while not holding RESET button down.
9.
The S32K board is now ready to connect to µVision as a CMSIS-DAP debug adapter.
TIP: This application will remain in the U8 K20 Flash each time the board power is cycled
with RESET not pressed. The next time board is powered with RESET held on, it will be
erased. CMSIS-DAP.S19 is the CMSIS application in the Motorola S record format that loads
and runs on the K20 OpenSDA processor.
TIP: If you must later re-program CMSIS-DAP.s19 and it still does not work with µVision: check that Port: is set to SW and
not JTAG. See the TIP: below.
10) Testing The OpenSDA CMSIS-DAP Connection: (Optional Exercise)
1.
Start µVision
if it is not already running. Select Project/Open Project.
2.
Select the Blinky project C:\00MDK\addon_mdk\Boards\NXP\S32K144-EVB\RTX5_Blinky\Blinky.uvprojx.
3.
Select Target Options
4.
Select CMSIS-DAP Debugger as shown here:
5.
Click on Settings: and the window below opens up: Select SW in the Port box as shown below. An IDCODE and
Device name will then be displayed indicating connection to the CoreSight DAP. This means CMSIS-DAP
OpenSDA is working. You can continue with the tutorial. Click on OK twice to return to the µVision main menu.
6.
If nothing or an error is displayed in this SW Device box, this must be corrected before you can continue.
7.
Select File/Save All or
or ALT-F7 and select the Debug tab:
.
TIP: To refresh the SW Device box, in the Port: box select
JTAG and then select SW again. You can also exit then re-enter
this window. CMSIS-DAP will not work with JTAG selected,
only SW. But this is a useful way to refresh the SW setting.
8
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
11) Configuring External Debug Adapters in µVision:
ULINK2/ME, ULINKpro and J-Link:
It is easy to configure for a variety of Debug Adapters. The RTX5_Blinky example is preconfigured for a Keil ULINK2. You
can select S32K144 as in Step 1 and then jump to step to Testing the Debug Connection below. You can add a configuration
for a ULINKpro, a J-Link or OpenSDA in either P&E or CMSIS-DAP modes easily.
Prerequisites:
µVision must be running and in Edit mode (not Debug mode). Your project must be loaded. We will use Blinky.
Create a new Target Selection:
1.
Select S32K144 Flash to use as the template adapter:
2.
Select Project/Manage/Project Items… or select:
3.
In the Project Targets area, select NEW
4.
Enter your debug adapter name and press Enter. Click OK to close this window.
5.
In the Target Selector menu, select the menu item you just made:
6.
Select Options for Target
7.
Select your debug adapter. Valid options are ULINK2/ME, ULINK Pro Cortex
Debugger, CMSIS-DAP, J-Link / JTRACE or PEMicro as shown:
or press your keyboard INSERT key.
or ALT-F7. Click on the Debug tab to select a debug adapter.
TIP: For the selections CMSIS-DAP or PEMicro Debugger, the onboard OpenSDA K20
processor must have the proper firmware installed as described on the previous two pages.
Testing the Debug Connection:
1.
Connect the appropriate Debug Adapter connected to the 10 pin CoreSight
connector J14.
2.
Click on Settings: and the window below opens up: Select SW in the Port box
and SWJ as shown below. An IDCODE and Device name will be displayed
indicating connection to the processor.
3.
If nothing or an error is displayed in this SW Device box, this must be corrected before you can continue.
4.
Select File/Save All or
.
TIP: To refresh the SW Device box, in the Port: box
select JTAG and then select SW again. You can also exit
then re-enter this window. CMSIS-DAP will not work
with JTAG selected, only SW. But this is a useful way to
refresh the SW setting.
Verify the Flash Program Algorithm: This is preset by the Software Pack when you select the processor.
1.
Select the Flash Download tab.
2.
The window that opens will display the correct algorithm. This is selected automatically according to the processor
selected in the Device tab.
3.
Below is the correct algorithm for the S32K144 processor:
4.
Click OK twice to return to the main µVision window.
The new Debug Adapter is now ready
to use.
TIP: You have now created a new Target Option. You can make any changes in the Options Target windows and save it.
These are easily recalled by selecting the appropriate Options Target in the drop down menu as described above.
9
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
12) Blinky example program using the NXP S32K144 board:
Now we will connect a Keil MDK development system using the S32K board. This page will use the OpenSDA P&E
debug adapter but you can select any that you have programmed and connected according to one of the three preceding
pages.
1.
Connect a USB cable between your PC and the S32K board J7 USB connector.
2.
If you are using an external debug adapter, connect it to J14 SWD. Power the board to USB J7.
3.
Start µVision by clicking on its desktop icon.
4.
Select Project/Open Project.
5.
Open the file: C:\00MDK\addon_mdk\Boards\NXP\S32K144-EVB\RTX5_Blinky\Blinky.uvprojx.
6.
Choose your debug adapter that you configured previously:
7.
Compile the source files by clicking on the Rebuild icon.
8.
Enter Debug mode by clicking on the Debug icon.
The Flash memory will be programmed. Progress will be
indicated in the Output Window or in the P&E window. Select OK if the Evaluation Mode box appears.
.
TIP: If the Flash programs with P&E but does not enter debug mode, select Debug mode again:
9.
Click on the RUN icon.
10. Stop the program with the STOP icon.
The tri-colour LED will now blink in sequence on the S32K board.
Now you know how to compile a program, program it into the S32K processor Flash, run it and stop it !
Note: The board will start Blinky stand-alone. Blinky is now permanently programmed in the Flash until reprogrammed.
Single-Stepping:
1.
With Blinky.c in focus (Blinky.c tab is underlined), click on the Step In icon
or F11 a few times: You will see
the program counter jumps a C line at a time. The yellow arrow indicates the next C line to be executed.
2.
Click on the top margin of the Disassembly window to bring it into focus. Clicking Step Into now jumps the program
counter one assembly instruction at a time.
Debug Adapters:
You can use a variety of debug adapters with your S32K
and µVision. Their feature list increases as follows:
The one with the higher number has the most performance.
1.
P&E OpenSDA
2.
CMSIS-DAP OpenSDA
3.
Keil ULINK2 or ULINK-ME
4.
J-Link
5.
Keil ULINKplus
6.
Keil ULINKpro
Keil ULINK2 with NXP S32K144 EVB
10
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
13) Hardware Breakpoints:
The S32 has six hardware breakpoints that can be set or unset on the fly while the program is running and using a CMSISDAP, any Keil ULINK or a J-Link debug adapter. You must stop the program to set/unset breakpoints with P&E.
1.
With Blinky running, in the Blinky.c window, click on a darker grey block on the left on a suitable part of the source
code. This means assembly instructions are present at these points. Inside the thread thrADC between near lines 47
through 50 is a good place: You can also click in the Disassembly window to set a breakpoint.
2.
A red circle will appear and the program will presently stop. Remember to restart the program if using P&E.
3.
Note the breakpoint is displayed in both the Disassembly and source windows as shown here:
4.
Set a second breakpoint in the for (;;) loop as before.
5.
Every time you click on the RUN icon
the program
will run until the breakpoint is again encountered.
6.
The yellow arrow is the current program counter value.
7.
Clicking in the source window will indicate the
appropriate code line in the Disassembly window and
vice versa. This is relationship indicated by the cyan
arrow and the yellow highlight:
8.
Open Debug/Breakpoints or Ctrl-B and you can see any
breakpoints set. You can temporarily unselect them or
delete them.
9.
Delete all breakpoints and close the Breakpoint window.
10. You can also delete the breakpoints by clicking on the
red circle.
TIP: If you set too many breakpoints, µVision will warn you.
TIP: Arm hardware breakpoints do not execute the instruction they are set to and land on. Arm CoreSight hardware
breakpoints are no-skid. This is a rather important feature for effective debugging.
Keil ULINKpro with NXP S32K144 EVB
11
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
14) Call Stack + Locals Window:
Local Variables:
The Call Stack and Locals windows are incorporated into one integrated window. Whenever the program is stopped, the Call
Stack + Locals window will display call stack contents as well as any local variables located in the active function or thread.
If possible, the values of the local variables will be displayed and if not the message <not in scope> will be displayed. The
Call + Stack window presence or visibility can be toggled by selecting View/Call Stack Window in the main µVision window
when in Debug mode.
1.
Set a breakpoint on one of the lines inside the thread thrADC in Blinky.c near lines 47 through 50.
2.
Click on RUN
3.
Click on the Step In icon
4.
Click on the Call Stack + Locals tab if necessary to open it. Expand some of the entries.
5.
As you click on Step In, you can see the program
entering and perhaps leaving various functions.
Note the local variables are displayed
6.
Shown is an example Call Stack + Locals window:
7.
The functions as they were called are displayed. If
these functions had local variables, they would be
displayed.
8.
If you get stuck in a delay or the os_idle_Daemon,
click on RUN to start over.
9.
If using P&E and the program does not stop, click
. The program will stop on the breakpoint.
to enter a few functions.
Stop.
10. Click Step Out
to immediately exit a function.
11. Right click on a function and select either Callee or Caller code and this will be highlighted in the source and
disassembly windows.
12. When you ready to continue, remove the hardware breakpoint by clicking on its red circle ! You can also type CtrlB, select Kill All and then Close.
TIP: You can modify a variable value in the Call Stack & Locals window when the program is stopped.
TIP: This window is only valid when the processor is halted. It does not update while the program is running because locals
are normally kept in a CPU register. These cannot be read by the debugger while the program is running. Any local variable
values are visible only when they are in scope.
Do not forget to remove any hardware breakpoints before continuing.
12
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
15) Watch and Memory Windows and how to use them:
The Watch and Memory windows will display updated variable values in real-time. It does this using the Arm CoreSight
debugging technology that is part of Cortex-M processors. It is also possible to “put” or insert variable values into a
Watch or Memory window in real-time. This is possible with a Watch if the variable is changing slowly or the program is
stopped. It is possible to enter variable names into windows manually. You can also right click on a variable and select
Add varname to.. and select the appropriate window. The System Viewer windows work using the same CoreSight
technology. Call Stack, Watch and Memory windows can’t see local variables unless stopped in their function.
Watch window:
A global variable: The global variable delay_val is declared in Blinky.c near line 34.
1.
Leave Blinky running.
2.
You can configure a Watch or Memory window while the program is running.
3.
Note: With P&E, you must stop the program to configure Watch window and to view the variable.
4.
In Blinky.c, right click on delay_val and select Add delay_val to … and select Watch 1. Watch 1 will automatically
open. delay_val will be displayed as shown here:
5.
Vary the pot R13 and delay_val will update in real time.
6.
With P&E, you must stop the program to update the window.
TIP: To Drag ‘n Drop into a tab that is not active, pick up the variable
and hold it over the tab you want to open; when it opens, move your
mouse into the window and release the variable.
TIP: A Watch or Memory window can display and update global and static variables, structures and
peripheral addresses while the program is running. These are unable to display local variables because
these are typically stored in a CPU register. These cannot be read by µVision in real-time. To view a
local variable in these windows, convert it to a static or global variable.
Memory window:
1.
Right click on delay_val and select Add delay_val to … and select Memory 1.
2.
Vary the pot R13. Note: With P&E you must stop the program to see the updated variable.
3.
Note the value of delay_val is displaying its address in Memory 1 as if it is a pointer. This is useful to see what
address a pointer is pointing to but this not what we want to see at this time.
4.
Add an ampersand “&” in front of the variable name and press Enter. The physical address here is 0x2000_0000.
5.
Right click in the Memory window and select Unsigned/Int.
6.
The data contents of delay_val is displayed as shown here:
7.
Both the Watch and Memory windows are updated in real-time.
8.
Right-click with the mouse cursor over the desired data field and
select Modify Memory. You can change a memory or variable onthe-fly while the program is still running. You will not see any
change as this variable is constantly updated.
TIP: No CPU cycles are used to perform these operations.
TIP: To view variables and their location use the Symbol window. Select View/Symbol Window while in Debug mode.
SystemCoreClock:
1.
In the Watch1 window, double click on <Enter Expression> and type in SystemCoreClock.
2.
Right click on SystemCoreClock and unselect Hexadecimal Display.
3.
96 MHz will be displayed. SystemCoreClock is provided by CMSIS to help determine the CPU clock frequency.
13
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
16) Peripherals System Viewer (SV):
The System Viewer provides the ability to view certain registers in the CPU core and in peripherals. In most cases, these
Views are updated in real-time while your program is running. These Views are available only while in Debug mode. There
are two ways to access these Views: a) View/System Viewer and b) Peripherals/System Viewer.
1.
Click on RUN. You can open SV windows when your program is running.
Select ADC0:
2.
Select Peripherals/System Viewer and then ADC0 as shown here.
3.
This window opens up. Expand RA:
4.
You can now see RA update as the pot is changed.
5.
You can change the values in the System Viewer on-the-fly. In
this case, the values are updated quickly so it is hard to see the
change.
TIP: If you click on a register in the properties column, a description
about this register will appear at the bottom of the window.
TIP: You can also open GPIO PTD to monitor the LEDs blinking.
SysTick Timer: This program uses the SysTick timer as a tick timer for
RTX. RTX has configured the SysTick timer in RTX_Config.h.
1.
Select Peripherals/Core Peripherals and then select SysTick
2.
The SysTick window shown below opens:
3.
Note it also updates in real-time while your program runs. These windows use the same CoreSight DAP technology
as the Watch, Memory and Peripheral windows.
4.
Note the ST_RELOAD and RELOAD registers. This is the reload register value. This is set during the SysTick
configuration by RTX using values set in RTX_Config.h Kernel Tick Frequency and the CPU clock.
5.
Note that it is set to 0x176FF. This is the same value hex value of 96,000,000/1000-1 (0x17700-1) that is
programmed into RTX_Config.h. This is where this value comes from. Changing the variable passed to this function
is how you change how often the SysTick timer creates its interrupt 15.
6.
In the RELOAD register in the SysTick window, while the program is running, type in 0x5000 and click inside
ST_RELOAD ! (or the other way around)
7.
The blinking LEDs will speed up. This will convince you of the power of Arm CoreSight debugging.
8.
Replace RELOAD with 0x176FF. A CPU RESET
9.
You can look at other Peripherals contained in the System View windows.
10. When you are done, stop the program
Timer.
will also do this.
and close all the System Viewer windows that are open.
TIP: It is true: you can modify values in the SV while the program is
running. This is very useful for making slight timing value changes
instead of the usual modify, compile, program, run cycle.
You must make sure a given peripheral register allows and will properly
react to such a change. Changing such values indiscriminately is a good
way to cause serious and difficult to find problems.
14
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
17) Watchpoints: Conditional Breakpoints
The S32K Cortex-M4 processor has two Watchpoints. Watchpoints can be thought of as conditional breakpoints.
Watchpoints are also referred to as Access Breaks in Keil documents. Cortex-M3/M4/M7 Watchpoints are not intrusive for
equality test. Currently, you can set one Watchpoint with µVision.
1.
Use the same Blinky configuration as the previous page. You can configure a Watchpoint while the program is
running or halted.
2. We will use the same global variable delay_val found in Blinky.c you used to explore the Watch windows.
3.
Select Debug in the main µVision window and then select Breakpoints or press Ctrl-B.
4.
Select Access to Read and Write.
5.
Enter: “delay_val == 0x80” without the quotes in
the Expression box. This window will display:
6.
Click on Define or press Enter and the expression
will be accepted into the Current Breakpoints:
box as shown below in the bottom Breakpoints
window:
7.
Click on Close.
8.
Enter the variable delay_val in Watch 1 if it is not
already there.
9.
Click on RUN.
.
10. Vary Pot R13 until delay_val equals 0x80 as
displayed in the Watch window.
11. When delay_val equals 0x80, the Watchpoint will stop the program. See Watch 1 shown below:
12. Watchpoint expressions you can enter are detailed in the Help button in the Breakpoints window. Triggering on a
data read or write is most common. You can leave out the value and trigger on just a Read and/or Write as you
select.
13. This is useful to detect levels of stack pointers.
14. To repeat this exercise, change delay_val to something other than 0x80 in the Watch window and click on RUN.
15. Stop the CPU if it is running.
16. Select Debug/Breakpoints (or Ctrl-B) and delete the Watchpoint
with Kill All and select Close.
17. Exit Debug mode.
TIP: To edit a Watchpoint, double-click on it in the
Breakpoints window and its information will be dropped
down into the configuration area. Clicking on Define will
create another Watchpoint. You should delete the old one
by highlighting it and click on Kill Selected or try the next
TIP:
TIP: The checkbox beside the expression allows you to
temporarily unselect or disable a Watchpoint without
deleting it.
TIP: Raw addresses can be used with a Watchpoint. An
example is: *((unsigned long *)0x20000004)
15
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
18) RTX System and Threads Viewer: Need OpenSDA P&E or CMSIS-DAP, any ULINK and J-Link.
This example uses the new Arm RTX 5 RTOS. It has an Apache 2.0 license and sources and documents are included. See
http://www2.keil.com/mdk5/cmsis/rtx. It is also located on https://github.com/ARM-software/CMSIS_5
With previous versions of RTX, the System and Thread Viewer was opened in Open Debug/OS Support.
With RTX5, select View/Watch/RTX RTOS.
Keil uses the term "threads" instead of "tasks" for consistency. You do not need to run RTX or any RTOS in your project.
Using an RTOS is becoming increasingly common as projects complexity increases.
NOTE: With OpenSDA in P&E mode, the program must be stopped to open the RTX RTOS window and to see updates.
OpenSDA in CMSIS-MODE displays this window updating in real-time while the program runs.
Running System and Threads Viewer:
1.
µVision must be in Debug mode and the program running. If using P&E, stop the program.
2.
Select View/Watch/RTX RTOS. A window similar to below opens up. You may have to click on its header and drag
it into the middle of the screen and resize the columns to comfortably view it.
3.
This window updates as the various threads switch state. (except with P&E).
4.
There are three Threads listed under the Threads heading. thrADC to operate the ADC to measure the pot R13
position, thrLED to change the LEDS and thrBUT is for the buttons. These are all located in Blinky.c near lines 43,
59 and 80 respectively. It is easy to add more threads to RTX.
5.
Stop the program.
It will probably stop in app_main thread in the for (;;) as shown by osThreadRunning. This
program spends most of its time in app_main. This can be adjusted to meet your needs.
Stopping in a Thread:
1.
Set a breakpoint in one of the three tasks in Blinky.c by clicking in the left margin on a grey area. Do not select the
for (;;) statement as this will not stop the program. This line (NOP) is executed only once at the start of the program.
2.
Click on Run
3.
You will be able to determine which thread is running
when the breakpoint was activated. This is shown by
osThreadRunning displayed beside the thread name.
4.
If you set a breakpoint in another thread, each time
you click on RUN, the next task will display as
Running.
5.
Remove all the breakpoints by clicking on each one.
You can use Ctrl-B and select Kill All.
6.
Stay in Debug mode for the next page.
and the program will stop at this thread and the System and Threads Viewer will be updated.
TIP: You can set/unset hardware breakpoints while the
program is running.
TIP: Recall this window uses CoreSight DAP read and write
technology to update this window. Serial Wire Viewer is not
used and is not required to be activated for this window to
display and be updated.
16
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
19) Event Viewer: Uses SWV: ULINK2, ULINKplus, ULINKpro or J-Link:
Event Viewer displays the RTX threads executing in a graphical format. It is easy to make measurements of various timings
of RTX. FreeRTOS has a similar window in µVision. A ULINKpro has the advantage of also displaying interrupt routines.
Viewing Event Viewer:
1.
Run RTX5_Blinky with a suitable debug adapter connected and configured for Serial Wire Viewer operation.
2.
Select Debug/OS Support and then select Event Viewer.
3.
The Event Viewer window below will open:
4.
Note: In This version of Event Viewer, only the main() thread is implemented for RTX5. This window is still under
development. The other threads will be added in a future version of µVision. will be added.
5.
Event Viewer for other versions of RTX are fully implemented.
6.
The interrupt handlers for SVCall, SysTick and ADC0 are displayed as a ULINKpro was used. This will also work
with a ULINKplus which adds power sensing capability.
7.
Select Cursor and you can make various measurements of the waveforms.
8.
If you hover your mouse over a blue block, statistics will be displayed and the block turned yellow as shown below:
9.
In this case, the mouse was over the ADC0 interrupt #55.
10. There were 10,512 ADC0 events. They lasted from 6.5 through 32.1 µs with 27.85 µs as the average time.
TIP: You can stop the update of this Event Viewer without
stopping the program.
17
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
20) Event Recorder:
Event Recorder is a new µVision feature. Code annotations can be inserted into your code to send out messages to µVision
and be displayed as shown below. Keil Middleware and RTX5 have these annotations already inserted. You can add Event
Recorder annotations to your own source code.
Documentation for Event Recorder is found here: www.keil.com/pack/doc/compiler/EventRecorder/html/
Demonstrating Event Recorder with RTX5_Blinky:
1.
µVision must be running Blinky from the previous page.
2.
Open Event Recorder by selecting View/Analysis/Event Recorder or
3.
Since Event Recorder is activated in Blinky.c, the window above will display.
4.
Various RTX events will display as they happen. You can do this for your own code.
Event Recorder Features:
1.
Stop and start Event Recorder while the program is running:
2.
Clear the window when the program is not running:
3.
Stop the program.
4.
In the Mark: box, enter ThreadDelay and these frames will be highlighted as shown here: This is useful to find
events that do not occur frequently.
5.
If you click on a frame in the
Event Property column, you will
be taken to Help for this event.
6.
Hover your mouse over an event in
the Value column and a hint will
display such as this one:
1.
Stop the program.
2.
Exit Debug mode.
Close any Event Recorder and Threads and Event (RTX RTOS) windows.
18
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
21) Serial Wire Viewer (SWV) Configuration: For Keil ULINK2/ME, ULINKplus or J-Link.
Serial Wire Viewer is a data trace including interrupts in real-time without any code stubs in your sources. SWV is output on
the SWO pin found on the JTAG/SWD connectors, either 10 or 20 pin. SWO is shared with JTAG TDO pin. This means you
must use SWD (Keil SW) and not JTAG for debugging to avoid this conflict. SWD has essentially the same abilities as JTAG
except for Boundary Scan.
These instructions are not for ULINKpro: they are on the next page.
Configure SWV:
1.
Connect a ULINK2/ME, ULINKplus or J-Link to the 10 pin connector SWD J14.
2.
µVision must be stopped and in Edit mode (not Debug mode).
3.
Your debugger should be selected from other exercises in this tutorial.
4.
For ULINK2/ME: select Flash:
5.
Select Options for Target
6.
Select Settings:
7.
Confirm Port: is set to SW and SWJ box is enabled for SWD operation. SWV will not work with JTAG.
8.
Click on the Trace tab. The window below is displayed.
9.
In Core Clock: enter 96 MHz. Select Trace Enable. This value must be set correctly to your CPU speed.
. ULINK2/ME is pre-selected.
or ALT-F7 and select the Debug tab. Your debugger must be displayed beside Use:.
on the right side of this window.
TIP: To find Core Clock frequency: Enter the global variable SystemCoreClock in a Watch window and run the program.
10. Click on OK twice to return to the main µVision menu. SWV is now configured and ready to use.
Display Trace Records:
1.
Select File/Save All or click
.
2.
Enter Debug mode.
3.
Click on the RUN icon. .
4.
Open Trace Records window by clicking on the
small arrow beside the Trace
icon
and select Records:
5.
The Trace Records window will open:
6.
If you see Exceptions as shown, SWV is
working correctly. If not, the most probably cause is a wrong Core Clock:.
7.
Double-click inside Trace Records to clear it.
8.
Exception 15 is the SYSTICK timer. It is the
timer provided for RTOS use.
9.
All frames have a timestamp displayed.
You can see two exceptions happening:
1.
Num 11 is SVCall from the RTX calls.
2.
Num 15 is the Systick timer.
▪
Entry: when the exception enters.
▪
Exit: When it exits or returns.
▪
Return: When all the exceptions have returned to the main program. This is useful to detect tail-chaining.
TIP: The only valid ITM frames are ITM 0 and ITM 31. If you see any other values, this nearly always means the Core
Clock: value is incorrect. Since we are using a UART for SWO in this case, the frequency must be correct.
19
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
22) Serial Wire Viewer (SWV) Configuration with ULINKpro:
(using the 1 bit SWO Port)
1) Configure SWV: (You can also use the 4 bit ETM Trace Port in suitably equipped NXP processors with a ULINKpro.)
1.
µVision must be stopped and in Edit mode (not Debug mode). Blinky must be loaded.
2.
Connect a ULINKpro to the 10 pin connector SWD J14. You will have already configured ULINKpro on page 9.
2.
Select Options for Target
3.
Select Settings:
4.
Click on the Trace tab. The window below is displayed. Confirm these settings are correct.
5.
Set Core Clock: to 96 MHz. ULINKpro uses this only
to calculate timings displayed in some windows.
6.
Select the Trace Enable box.
7.
Unselect ETM Trace Enable.
8.
In Trace Port, select Serial Wire Output - Manchester.
9.
Select EXTRC to display exceptions and interrupts.
or ALT-F7 and select the Debug tab. ULINKpro must be visible in the dialog box.
on the right side of this window.
10. Click on OK twice to return to the main µVision menu.
SWV is now configured and ready to use.
11. In this configuration, SWV data will be output on the 1
bit SWO pin.
TIP: If Sync Trace Port with 4-bit Data is chosen in Trace Port: box, SWV data is sent out the 4 bit Trace Port pins if
available on your processor. The S32K144 does not have a Trace Port. This has much higher data throughput than the 1 bit
SWO pin. It is easy to overflow trace data. A ULINKpro works the best at high SWO data rates. A ULINKplus provides
high performance SWV capabilities for when there is no 4 bit Trace Port.
2) Display the Trace Data window:
1.
Select File/Save All or click
. It is not necessary to rebuild the project.
2.
Enter Debug mode.
3.
Open the Trace Data window by clicking on the small arrow beside the Trace icon:
4.
The Trace Data window shown below will open.
5.
STOP
Click on the RUN icon.
.
the program to display the Exceptions as shown below:
TIPS:
1.
The Trace Data window is different than the
Trace Records window provided with ULINK2.
2.
Clear the Trace Data window by clicking
3.
The contents of the Trace Data window can be
saved to a file.
4.
ULINKpro does not update the Trace Data
window while the program is running.
5.
The Trace Port outputs SWV data faster than the 1 bit SWO with UART (ULINK2) or Manchester with ULINKpro.
The 1 bit SWO port can still be useful for very high CPU speeds that ETM is unable to handle. ( > ~ 100 MHz )
20
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
23) Displaying Exceptions (includes interrupts) with SWV:
This exercise needs a ULINK2, ULINK-ME, ULINKplus, ULINKpro or a J-Link. Does not work with OpenSDA.
The Trace Exceptions window displays exceptions firing with suitable timing information.
Display Trace Exceptions:
1.
Select the Trace Exception tab (located beside the Watch and Memory windows).
2.
Click in the Count column header to bring the active exceptions to the top as shown below:
3.
Note the various timings displayed. If you are using a ULINKpro and RTX, you can see these in graphical form.
TIP: To quickly disable Trace Exceptions unselect EXCTRC:
This is a quick way to disable Trace
Exceptions if you have SWO overload. Exception frames are not captured and the bus load is less on the single bit SWO pin.
Display Trace Exceptions Graphically with a ULINKpro and Event Viewer: This needs a ULINKpro.
Event Viewer normally displays RTX threads and with a ULINKpro, exception timings are added. You can clearly see when
the interrupt handlers were active in relation to each other and how long they were active in their respective handler routines.
1.
With a ULINKpro connected and RTX5_Blinky running, select Debug/OS Support/Event Viewer.
2.
This window opens up. Select a time of about 1 ms in Grid using the In and Out buttons.
3.
You can see the three exceptions activated.
The width of the blue bars indicate the
exception handler execution times.
Measuring a Time:
1.
Select Cursor and Timing Info.
2.
Select Stop Update Screen. The Blinky
program continues to run.
3.
Find an ADC0 exception and click on it.
This anchors it in the window.
4.
Select In in the Zoom dialog until ADC0 is
about as wide as in the screen below right:
5.
Set the cursor by clicking on the left edge of
the ADC0 blue block.
6.
Hover the cursor on the block and it turns
yellow/orange.
7.
A box opens displaying various times as shown bottom left:
Current Slice: measures the yellow box time. Cursors: measures the cursor positions.
21
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
24) Using the Logic Analyzer (LA) with ULINK2, ULINK-ME, ULINKpro or J-Link:
This example will use a ULINK2, ULINKplus, ULINKpro or a J-Link with the Blinky example. Please connect a your debug
adapter to your S32K board and configure it for Serial Wire Viewer (SWV) trace as described previously on pages 18 or 19.
µVision has a graphical Logic Analyzer (LA) window. Up to four variables can be displayed in real-time using the Serial
Wire Viewer as implemented in the S32K. LA uses the same comparators as Watchpoints so all can't be used at same time.
Configure and Use the Logic Analyzer:
1.
SWV must be configured as found on pages 18 or 19 for the debug adapter you are using.
2.
µVision must be in Debug mode.
3.
Run the program.
4.
Open View/Analysis Windows and select Logic Analyzer or select the LA window on the toolbar.
5.
Locate the global variable delay_val in Blinky.c near line 34.
6.
Right click on delay_val and select Add delay_val to… and select Logic Analyzer.
If Event Viewer is open from the previous page, close it.
. TIP: You can configure the LA while the program is running or stopped.
TIP: If an error results when adding counter to the LA, the most probable cause is SWV is not configured correctly.
7.
In the LA, click on Setup and set Max: in Display Range to 0x150 and Min to 0x0. Click on Close.
8.
The LA is now configured to display delay_val in a graphical format.
9.
delay_val should still be in the Watch and Memory windows. It will be changing as you vary the Pot R13.
10. Adjust the Zoom OUT icon in the LA window to about 0.5 sec or so to display data in the LA as shown below:
TIP: If the LA is blank, exit and reenter Debug mode
to refresh the CoreSight comparators.
TIP: The Logic Analyzer can display up to four static and global variables, structures and arrays. It can’t see locals: just make
them static or global. To see Peripheral registers, enter them into the Logic Analyzer and write data to them.
View Data Write of delay_val:
When a variable is added to the Logic Analyzer, the data
write frames are sent to the Trace Data or Records window.
1.
Select Debug/Debug Settings. Select the Trace tab.
2.
Select On Data R/W Sample.
3.
Click OK twice. This adds execution addresses to
the Src Code/Trigger Addr column.
4.
Clear the Trace Data or Trace Records window.
5.
RUN the program.
6.
Open the Trace Data or Trace Records window.
7.
The window similar to this opens up: This one is for
ULINKpro. ULINK2 is different and updates while the
program is running.
8.
In the Display box, select ITM Data Write:
For ULINK2, right click in the Trace Records window
and unselect Exceptions.
9.
The first line in this Trace Data window means:
. STOP
Double click for ULINK2 or for ULINKpro click:
the program.
The instruction at 0x0000 3428 caused a write of data 0xD7 to address 0x2000 0000 at the listed time in seconds.
10. If using a ULINKpro, in the Trace Data window, double click on a data write frame and the instruction causing this
write will be highlighted in the Disassembly and the appropriate source window.
TIP: The Src Code/Trigger Addr column is activated when you selected On Data R/W Sample in Step 2. You can leave this
unselected to save bandwidth on the SWO pin if you are not interested in it. With a ULINK2, this column is called PC.
TIP: The ULINK2 gives a different Trace window. It is the same Trace Records as shown elsewhere in this document.
TIP: Raw addresses can also be entered into the Logic Analyzer. An example is: *((unsigned long *)0x20000000)
22
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
25) printf using ITM 0 (Instrumentation Trace Macrocell) SWV is required:
ITM Port 0 is available for a printf type of instrumentation that requires minimal user code. After the write to the ITM port,
zero CPU cycles are required to get the data out of the processor and into µVision for display in the Debug (printf) Viewer
window. It is possible to send ITM data to a file: www.keil.com/appnotes/docs/apnt_240.asp.
1.
Stop the program
and exit Debug mode
.
Add STDOUT File (retarget_io.c):
1.
Open the Manage Run-Time Environment window (MRTE)
.
2.
Expand Compiler and I/O as shown here:
3.
Select STDOUT and ITM. This adds the file retarget_io.c to the project.
4.
Ensure all blocks are green and click OK to close the MRTE.
TIP: If you select EVR instead of ITM, printf will not require SWV.
Add printf to Blinky.c:
1.
Inside the thread thrADC found starting near line 43, add this line at line 51: printf("delay_val = %d\n", delay_val);
Increase the thread stack size in RTX:
1.
Open the file RTX_Config.h.
2.
Select Configuration Wizard tab at its bottom.
3.
Change Default Thread Stack size: to 320 bytes as
shown below right:
Compile and Run the Project:
1.
Select File/Save All or click
2.
Rebuild the source files
.
and enter Debug mode
.
3.
Click on View/Serial Windows and select Debug
(printf) Viewer and click on RUN.
4.
In the Debug (printf) Viewer you will see the printf
statements appear as shown below right:
5.
Right click on the Debug window and select Mixed Hex ASCII mode. Note other useful
settings that are available.
Obtaining a character typed into the Debug printf Viewer window from your keyboard:
It is possible for your program to input characters from a keyboard with the function ITM_ReceiveChar in core.CM4.h.
This is documented here: www.keil.com/pack/doc/CMSIS/Core/html/group__ITM__Debug__gr.html
A working example can be found in the File System Demo in Keil Middleware. Download this using the Pack Installer.
TIP: ITM_SendChar is a useful function you can also use to send characters out ITM. It is found in core.CM4.h.
TIP: It is important to select as few options in the Trace configuration as possible to avoid overloading the SWO pin. Enable
only those SWV features that you need. If you need higher performance SWV, a ULINKpro using 4 bit Trace Port or a
ULINKpro or a ULINKplus using the SWO pin provides the fastest speed.
23
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
26) DSP SINE Example:
Arm CMSIS-DSP libraries are offered for Arm Cortex-M0, Cortex-M3, Cortex-M4 and Cortex-M7 processors. DSP libraries
plus all sources are provided in MDK in C:\Keil_v5\ARM\Pack\ARM\CMSIS\.
See www.keil.com/cmsis and https://github.com/ARM-software/CMSIS_5.
This example creates a sine wave, then creates a second to act as noise, which are then added together (disturbed), and then
the noise is filtered out (filtered). The waveform in each step is displayed in the Logic Analyzer using Serial Wire Viewer.
This example incorporates the Keil RTOS RTX. RTX has a BSD or Apache 2.0 license. All source code is provided.
This program will run with OpenSDA but to see the interesting and useful SWV features you need any ULINK or a J-Link.
1.
Get the example from www.keil.com/appnotes/docs/apnt_299.asp. Copy it to C:\00MDK\Boards\NXP\S32K\DSP.
2.
Open the project file C:\00MDK\Boards\NXP\S32K\DSP\sine.uvprojx.
3.
To use OpenSDA P&E: connect a USB cable to USB connector. See page 7 to install P&E on the S32K board. No
SWV including the LA will function with OpenSDA. The program must be stopped to update the Watch window.
4.
To use OpenSDA CMSIS-DAP: connect a USB cable to USB connector. See page 8 to install CMSIS-DAP.
5.
For any ULINK or J-Link: Connect it to the USB 8 pin connector J14 SWD connector on the S32K board.
6.
Power the board by connecting a USB cable to your PC.
7.
Select your debug adapter from the pull-down menu as shown here:
8.
Compile the source files by clicking on the Rebuild icon.
9.
Enter Debug mode by clicking on the Debug icon.
.
The Flash will be programmed.
TIP: The default Core Clock: is 80 MHz for use by the Trace configuration window under the Trace tab.
10. Click on the RUN icon.
Open the Logic Analyzer window
and the Watch 1 window: View/Watch/
11. This project has Serial Wire Viewer configured and the Logic Analyzer and Watch 1 loaded with the four variables.
12. If the variables in Watch 1 are changing, the program is running correctly. Stop the program if using P&E.
13. Four waveforms will be displayed in the Logic Analyzer using the Serial Wire Viewer as shown below. Adjust
Zoom for an appropriate display. Displayed are 4 global variables: sine, noise, disturbed and filtered.
Trouble: If one or two variables display no waveform, disable ITM Stimulus Port 31 in the Trace Config window and/or
Exceptions in the Trace Exceptions window. The SWO pin is probably overloaded if you are using a ULINK2. A
ULINKplus or a ULINKpro handles SWV data faster than a ULINK2 or J-Link can. Make sure the Core Clock is set to 80.
14. Select View/Watch Windows
and select Watch 1. The four
variables are displayed
updating as shown below:
15. Open the Trace Records
window and the Data Writes
to the four variables are
displayed using Serial Wire
Viewer. When you enter a
variable in the LA, its data
write is also displayed in the
Trace window. With
ULINKpro you must stop the
program to display the data Trace Data window. J-Link does not display any data read or write frames. OpenSDA
P&E has no SWV support.
16. Select View/Serial Windows/Debug (printf)
Viewer. ASCII data is displayed from the printf
statements in DirtyFilter.c. Not with P&E.
17. Leave the program running.
18. Close the Trace Records window if open.
24
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
Signal Timings in Logic Analyzer (LA):
1.
In the LA window, select Signal Info, Show Cycles, Amplitude and Cursor.
2.
Click on STOP in the Update Screen box. You could also stop the program but leave it running in this case.
3.
Click somewhere interesting in the LA to set a reference cursor line.
4.
Note as you hover the cursor various timing information is displayed as shown below:
RTX System and Threads Viewer: This works with OpenSDA CMSIS-DAP, Keil ULINK and J-Link.
6.
Click on Start in the Update Screen box to resume the collection of data. The program must be running.
7.
Open Debug/OS Support and select RTX System and Thread Viewer. A window similar to below opens up. You
may have to click on its header and drag it into the middle of the screen to comfortably view it.
8.
As the various threads switch state this is displayed. Note most of the CPU time is spent in the idle daemon: it shows
as Running. The processor spends relatively little time in other tasks. You will see this illustrated clearly on the next
page. It is possible to adjust these timings to give more CPU time to various threads as needed.
NOTE: With OpenSDA in P&E mode, the program must be stopped to update this window.
9.
Set a breakpoint in each of the four tasks in DirtyFilter.c by clicking in the left margin on a grey area. Do not select
while(1) as this will not stop the program.
10. Click on Run and the program will stop at a thread and the System and Threads Viewer will be updated accordingly.
In the screen below, the program stopped in the noise_gen task:
11. Clearly you can see that noise_gen was Running when the breakpoint was activated.
12. Each time you click on RUN, the next task
will display as Running.
13. Remove all the breakpoints by clicking on
each one. You can use Ctrl-B and select
Kill All.
14. Stay in Debug mode for the next page.
TIP: You can set/unset hardware breakpoints
while the program is running.
TIP: Recall this window uses CoreSight DAP read
and write technology to update this window. Serial
Wire Viewer is not used and is not required to be
activated for this window to display and be updated.
The DSP example uses RTX4 and not RTX5 as used in the RTX5_Blinky example. This means the System and Thread
Viewer has a different format.
The Event Viewer does use SWV and this is demonstrated on the next page.
25
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
RTX Event Viewer (EV): ULINK2, ULINKplus, ULINKpro and J-Link: Not with OpenSDA.
1.
If you are using a ULINKpro, skip this step unless you want to see SWV overload.: Stop the program. Click on
Setup... in the Logic Analyzer. Select Kill All to remove all variables and select Close. This is necessary because the
SWO pin will likely be overloaded when the Event Viewer is opened up. Inaccuracies might/will occur.
2.
Select Debug/Debug Settings.
3.
Click on the Trace tab.
4.
Enable ITM Stimulus Port 31.
Event Viewer uses this port to
collect its information.
5.
Click OK.
6.
Click on RUN
7.
Open Debug/OS Support and
select Event Viewer. The window
here opens up:
.
TIP: If Event Viewer is still blank, exit
and re-enter Debug mode.
Main Thread:
1.
Select Stop in the Update Screen. Scroll to the beginning of the Event Viewer.
2.
The first thread in this program was main() as depicted in the Event Viewer. The main thread is the main() function
in DirtyFilter.c It runs some RTX initialization code at the beginning and is stopped with osDelay(osWaitForever);.
TIP: If Event Viewer is blank or erratic, or the LA variables are not displaying or
blank: this is likely because the Serial Wire Output pin is overloaded and dropping trace
frames. Solutions are to delete some or all of the variables in the Logic Analyzer to free
up some SWO or Trace Port bandwidth. Try turning off the exceptions with EXTRC.
3.
The 5 running threads plus the idle daemon are displayed on the Y axis. Event
Viewer shows which thread is running, when and for how long.
4.
Click Stop in the Update Screen box.
5.
Click on Zoom In so three or four threads are displayed as shown here:
6.
Select Cursor. Position the cursor over one set of bars and click once. A red
line is set here:
7.
Move your cursor to the next set and total time and difference are displayed.
8.
Since you enabled Show Cycles, the total cycles and difference is also shown.
The 1 msec shown is the SysTick timer value which is set in RTX_Conf_CM.c in the
OS_CLOCK and OS_TICK variables.
Using a Keil ULINKpro to view Interrupt Handler execution times:
SWV Throughput: ULINKpro is much better with SWO bandwidth issues. It has been able to display both the EV and LA
windows. The ULINKpro ETM and ULINKpro Manchester modes are preconfigured in Options for Target.
ULINKpro can also use the 4 bit Trace Port for even faster operation for SWV. Trace Port use is mandatory for ETM trace.
A ULINKpro in ETM mode provides program flow debugging, Code Coverage and Performance Analysis. ULINKpro also
supports ETB (Embedded Trace Buffer) as found in many Kinetis processors.
Exceptions: A ULINKpro displays
exceptions at the bottom of the Event
Viewer. Shown here are the SysTick and
SVCall exceptions. You can measure the
duration of the time spent in the handlers.
Any other exception events such as DMA
will also be displayed here.
This is the end of the lab exercises !
26
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
27) Document Resources:
See www.keil.com/NXP
Books:
1.
NEW! Getting Started with MDK 5:
Obtain this free book here: www.keil.com/mdk5/
2.
There is a good selection of books available on ARM: www.arm.com/support/resources/arm-books/index.php
3.
µVision contains a window titled Books. Many documents including data sheets are located there.
4.
The Definitive Guide to the Arm Cortex-M0/M0+ by Joseph Yiu.
Search the web for retailers.
5.
The Definitive Guide to the Arm Cortex-M3/M4 by Joseph Yiu.
Search the web for retailers.
6.
Embedded Systems: Introduction to Arm Cortex-M Microcontrollers (3 volumes) by Jonathan Valvano
7.
MOOC: Massive Open Online Class: University of Texas:
http://users.ece.utexas.edu/~valvano/
Application Notes:
1.
NEW! Arm Compiler Qualification Kit: Compiler Safety Certification: www.keil.com/safety
2.
Using Cortex-M3 and Cortex-M4 Fault Exceptions
www.keil.com/appnotes/files/apnt209.pdf
3.
CAN Primer using Keil MCB170:
www.keil.com/appnotes/files/apnt_247.pdf
4.
Segger emWin GUIBuilder with µVision™
www.keil.com/appnotes/files/apnt_234.pdf
5.
Porting mbed Project to Keil MDK™
www.keil.com/appnotes/docs/apnt_207.asp
6.
MDK-ARM™ Compiler Optimizations
www.keil.com/appnotes/docs/apnt_202.asp
7.
GNU tools (GCC) for use with µVision
https://launchpad.net/gcc-arm-embedded
8.
Barrier Instructions
9.
Cortex-M Processors for Beginners:
http://infocenter.arm.com/help/topic/com.arm.doc.dai0321a/index.html
http://community.arm.com/docs/DOC-8587
10. Lazy Stacking on the Cortex-M4:
www.arm.com and search for DAI0298A
11. Cortex Debug Connectors:
www.keil.com/coresight/coresight-connectors
12. FlexMemory configuration using MDK
13. Sending ITM printf to external Windows applications:
www.keil.com/appnotes/files/apnt220.pdf
www.keil.com/appnotes/docs/apnt_240.asp
14. NEW! Migrating Cortex-M3/M4 to Cortex-M7 processors:
www.keil.com/appnotes/docs/apnt_270.asp
15. NEW! ARMv8-M Architecture Technical Overview
www.keil.com/appnotes/files/apnt_291.pdf
16. NEW! Determining Cortex-M CPU Frequency using SWV
www.keil.com/appnotes/docs/apnt_297.asp
Keil Tutorials for NXP Boards:
www.keil.com/NXP
1.
2.
3.
4.
5.
6.
7.
KL25Z Freedom
K20D50M Freedom Board
Kinetis K60N512 Tower
Kinetis K60D100M Tower
Kinetis FRDM-K64F Freedom
Kinetis K64F120M Tower
A lab for the S32K-148 EVB using ETM:
www.keil.com/appnotes/docs/apnt_232.asp
www.keil.com/appnotes/docs/apnt_243.asp
www.keil.com/appnotes/docs/apnt_239.asp
www.keil.com/appnotes/docs/apnt_249.asp
www.keil.com/appnotes/docs/apnt_287.asp
www.keil.com/appnotes/docs/apnt_288.asp
www.keil.com/appnotes/docs/apnt_305.asp
8.
NXP Cookbook Example Ports for MDK:
www.keil.com/appnotes/docs/apnt_304.asp
Useful Arm Websites:
1.
NEW! CMSIS 5 Standards:
https://github.com/ARM-software/CMSIS_5 and www.keil.com/cmsis/
2.
Forums: www.keil.com/forum
3.
Arm University Program: www.arm.com/university. Email: university@arm.com
4.
mbed™: http://mbed.org
http://community.arm.com/groups/tools/content
27
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
https://developer.arm.com/
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com
28) Keil Products and contact information:
See www.keil.com/NXP
Keil Microcontroller Development Kit (MDK-ARM™) for NXP processors:
▪
MDK-Lite™ (Evaluation version) up to 32K Code and Data Limit - $0
▪
New MDK-ARM-Essential™ For all Cortex-M series processors – unlimited code limit
▪
New MDK-Plus™ MiddleWare Level 1. ARM7™, ARM9™, Cortex-M, SecureCore®.
▪
New MDK-Professional™ MiddleWare Level 2. For details: www.keil.com/mdk5/version520.
For the latest MDK details see: www.keil.com/mdk5/selector/
Keil Middleware includes Network, USB, Graphics and File System. www.keil.com/mdk5/middleware/
USB-JTAG/SWD Debug Adapter (for Flash programming too)
▪
ULINK2 - (ULINK2 and ME - SWV only – no ETM)
ULINK-ME is equivalent to a ULINK2.
▪
New ULINKplus- Cortex-Mx High performance SWV & power measurement.
▪
ULINKpro - Cortex-Mx SWV & ETM instruction trace. Code Coverage and Performance Analysis.
▪
ULINKpro D - Cortex-Mx SWV no ETM trace ULINKpro also works with Arm DS-5.
You can use OpenSDA on the S32K board. For Serial Wire Viewer (SWV), a ULINK2, ULINK-ME or a J-Link
is needed. For ETM support, a ULINKpro is needed. OS-JTAG or OpenSDA do not support either SWV or ETM.
Call Keil Sales for more details on current pricing. All products are available.
For the Arm University program: go to www.arm.com/university Email: university@arm.com
All software products include Technical Support and Updates for 1 year. This can easily be renewed.
Keil RTX™ Real Time Operating System
▪
RTX is provided free as part of Keil MDK. It is the full version of RTX – it is not restricted or crippled.
▪
No royalties are required. It has a BSD or Apache 2.0 license.
▪
RTX source code is included with all versions of MDK.
▪
▪
Kernel Awareness visibility windows are integral to µVision.
https://github.com/ARM-software/CMSIS_5
For the entire Keil catalog see www.keil.com or contact Keil or your
local distributor. For NXP support: www.keil.com/NXP
For Linux, Android, bare metal (no OS) and other OS support on NXP
i.MX and Vybrid series processors please see DS-5 and DS-MDK at
www.arm.com/ds5/ and www.keil.com/ds-mdk.
Getting Started with DS-MDK: www.keil.com/mdk5/ds-mdk/install/
For more information:
Sales In Americas: sales.us@keil.com or 800-348-8051. Europe/Asia: sales.intl@keil.com +49 89/456040-20
Keil Technical Support in USA: support.us@keil.com or 800-348-8051. Outside the US: support.intl@keil.com.
Global Inside Sales Contact Point: Inside-Sales@arm.com Arm Keil World Distributors: www.keil.com/distis
Forums: www.keil.com/forum
http://community.arm.com/groups/tools/content
28
NXP S32K-144 Cortex-M4 Lab using Arm® Keil™ MDK 5 toolkit
https://developer.arm.com/
Copyright © 2017 Arm Ltd. All rights reserved
www.keil.com