Embedded Signal Processing

Apple/Mac OsX ElCapitan system - FRDM-K64F KDS 3.2 (Kinetis Design Studio) Setup

Overview

This page describes setup of setting up an FRDM-K64F KDS (Kinetis Design Studio) setup on Apple/Mac systems.

The following instructions are particularly targeted to Apple/mac systems, and may need to be adjusted for other machines/platforms.

Note: Freescale was acquired by NXP

Apple/Mac system - FRDM-K64F KDS 3.2 (Kinetis Design Studio) Setup and Software Installation

The following instructions are for KDS 3.2 and KSDK 2.0 to install the software on a laptop or home computer
The following instructions are particularly targeted to Apple/mac systems, and may need to be adjusted for other machines/platforms.
Because the debug is not fully functional in KDS for Apple/Mac systems, many extra steps below are added (pyocd, etc).
On a PC/linux, you might be able to skip the pyocd/gdb installation steps, if KDS works right out of the box (I am not sure)

0) Before you do anything, make sure that the firmware on your mbed board is updated to the latest version,

for FRDM-K64F boards check here: https://developer.mbed.org/handbook/Firmware-FRDM-K64F
and here: https://developer.mbed.org/platforms/FRDM-K64F/

1) download KDS (Kinetis Design Studio)

Kinetis Design Studio Integrated Development Environment (IDE)
from http://www.nxp.com/products/software-and-tools/run-time-software/kinetis-software-and-tools/ides-for-kinetis-mcus/kinetis-design-studio-integrated-development-environment-ide:KDS_IDE
formerly at http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=KDS_IDE

See also: https://community.nxp.com/community/kinetis/kinetis-design-studio
And see Kinetis Design Studio V3.0.0- User's Guide at http://cache.freescale.com/files/microcontrollers/doc/user_guide/KDSUG.pdf

2) Install KSDK (Kinetis Software Development Kit)

KINETIS-SDK Software Development Kit
at http://www.nxp.com/products/software-and-tools/run-time-software/kinetis-software-and-tools/development-platforms-with-mbed/software-development-kit-for-kinetis-mcus:KINETIS-SDK
formerly at http://www.freescale.com/webapp/sps/site/prod_summary.jsp&code=KINETIS-SDK
Install it somewhere (on Mac /Applications/KDS_SDK20 perhaps)
see also: https://community.freescale.com/docs/DOC-104887
see also KSDK user guide at http://cache.nxp.com/files/soft_dev_tools/doc/support_info/KSDK20GSUG.pdf?fpsp=1&WT_TYPE=Users%20Guides&WT_VENDOR=FREESCALE&WT_FILE_FORMAT=pdf&WT_ASSET=Documentation&fileExt=.pdf
formerly at https://community.freescale.com/docs/DOC-104887

Typically click on the downloaded installer and follow the instructions. For example, on a mac you would double-click 02KinetisSDK2.0Mainline-MacOS.dmg , and copy it to some appropriate location (but not in/below your KDS workspace directory)

4) Before using Kinetis Design Studio with the Kinetis KSDK,

Run KDS and MenuBar::Help::CheckForUpdates ...but do not install any updates unless something critical appears
However, do Install all updates from Freescale/NXP, which are denoted by "com.freescale.xxx" or "com.nxp.xxx
Typically install the New Kinetis SDK 2.x Project Wizard 2.0.0.201606291042
(In older versions before KDS3.2 and before KSDK2.0 the KSDK Eclipse Update must be installed. )
Then, build a simple "hello world" demo/example ,

First, import a demo/example in KDS with "MenuBar::File::Import" from the KDS IDE menu.
In the window that appears, expand the "ProjectOfProjects" folder and select "Existing Project Sets" and click the "Next" button
Click the "Browse" button next to the "Import from file:" option
Point to the platform library project for the appropriate device, which can be found in this subdirectory below your KSDK installation directory:

<install_dir>/boards/frdmk64f/demo_apps/hello_world/kds/hello_world_frdmk64f.wsd

Click the "Finish" button, and the project "hello_world_frdmk64f" should appear in the ProjectExplorer pane
Two build targets are supported for each KSDK project:

Debug – Compiler optimization is set low, and debug info is generated
Release – Compiler optimization is set high, and no debug info is generated.

Build "hello_world_frdmk64f" by selecting the "hello_world_frdmk64f" folder in the ProjectExplorer pane, then clicking the drop-down arrow to the right of the hammer-button in the menuBar, and selecting "release"

Make sure there are no problems reported in the problemPane at the bottom of KDS
You should see "hello_world_frdmk64f.elf" in the binaries folder in the ProjectExplorer pane after building
ELF files are Executable Linkable Format that include a symbol tables and relocatable (in memory) code
To create a binary version in the build (a .bin you can load to the mbed board):

Rightclick the project in the ProjectExplorer pane and click "properties"
Click C++Build::Settings in the popup
Select the toolchain tab in the popup, select the createFlashImageButton and click apply
Click the toolSettingsTab in the popup and on the bottom of the list you should now see the ARMFlashImage items
Click under the general folder under ARMFlashImage and select outputFileFormat=rawBinary and recompile
At the top of the popup, note what configuration (debug/release) was edited
Click OK to close the properties popup
Recompile, and under the debug folder or under the release folder, there should be a ".bin" binary

Also, build the "hello_world_frdmk64f" by selecting the "hello_world_frdmk64f" folder in the ProjectExplorer pane, then by clicking the drop-down arrow to the right of the hammer-button in the menuBar, and selecting "debug"

Make sure there are no problems reported in the problemPane at the bottom of KDS

or build it by right-clicking in the ProjectExplorerPane (leftmost pane)

Note: copy/pasting in KDS create a copy of a project does not usually work, and you will get warnings and errors on the copy when you build it. usually header files cannot be found or include path problems.
If you want to clone hello_world or other demos in the SDK, it is best to use a special tool Kinetis SDK Project Generator 2.2

This tool will allow cloning of the KSDK demo projects
See also https://community.nxp.com/docs/DOC-104144
See also http://www.nxp.com/products/software-and-tools/run-time-software/kinetis-software-and-tools/development-platforms-with-mbed/software-development-kit-for-kinetis-mcus:KINETIS-SDK?fpsp=1&tab=Design_Tools_Tab

A better option for many projects may be to build the software on mbed.org, export it as a KDS export file/archive, and then load the archive into KDS

Following the same procedures as above, build the "bubble" demo/example

Import the "bubble" demo/example
build a "debug" version as described above
make sure there are no compile errors
build the binary version as described above
plug in your FRDM-K64F board, and your USB port should appear as a disk drive "MBED"
copy the binary ".bin" file to your board by dragging it from the debug folder in KDS to your "MBED" board
the green LED on the FRDM-K64F board should flicker as it loads
After loading, press the reset button near where the USB cable enters the FRDM-K64F board
The board LED should change color as you tilt the board when the bubble demo is running properly

5)In KDS 3.2 and KSDK 2.0, it no longer appears that you need to build a platform driver library. older versions may require this, though.

On a PC/linux, you might be abe to skip the next pyocd/gdb installation steps,
if KDS works right out of the box (...not sure, since this install was done for Apple/Mac systems)

6) once you have the basic software running, install the debugger as follows

a) use MenuBar::Help::InstallNewSoftware, select “work with all available sites,”
type gdb into the search query,
select the “mobile and device development" and "C/C++ GDB Hardware Debug” checkbox,
and click next twice to install gdb and restart eclipse

7) install pyocd

For instructions to install pyOCD see: https://github.com/mbedmicro/pyOCD
Note: you may need to run this from a terminal first, because a pip bug may cause failure of install:

sudo -H pip install Cython
sudo -H pip install --pre -U pyocd

8) plug in your FRDM-K64F board, press reset,

and in a command terminal test your pyocd by running the commands:

pyocd-gdbserver --help
pyocd-gdbserver -l

and you should see something like:

tpwmac12:local tpw$ pyocd-gdbserver -l
INFO:root:new board id detected: 02400221AA524E54578CB3EC
0 => MBED MBED CMSIS-DAP (0xd28, 0x204) [k64f] boardId => 02400221AA

12) verify pyOCD

copy the binary "bubble_frdmk64f.elf" file to your download folder (or other folder) by dragging it from the debug folder in KDS to your download folder
verify that the very basics are properly running for debug, by opening 2 different terminals and running the following sessions (commands in red):

In terminal window 1
————————————
    run pyocd-gdbserver to obtain this session
    tpwmac12:~ tpw$ pyocd-gdbserver
    INFO:root:new board id detected: 02400221AA524E54578CB3EC
    INFO:root:board allows 5 concurrent packets
    INFO:root:DAP SWD MODE initialised
    INFO:root:IDCODE: 0x2BA01477
    INFO:root:K64F not in secure state
    INFO:root:6 hardware breakpoints, 4 literal comparators
    INFO:root:CPU core is Cortex-M4
    INFO:root:FPU present
    INFO:root:4 hardware watchpoints
    INFO:root:GDB server started at port:3333
    INFO:root:One client connected!
    [====================] 100%

In terminal window 2
run arm-none-eabi-gdb on your compiled elf file for your project as follows
————————————

    tpwmac12:~ tpw$ /Applications/KDS.app/Contents/toolchain/bin/arm-none-eabi-gdb /Users/tpw/Downloads/bubble_frdmk64f.elf          GNU gdb (GNU Tools for ARM Embedded Processors) 7.6.0.20140731-cvs
    Copyright (C) 2013 Free Software Foundation, Inc.
    License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
    This is free software: you are free to change and redistribute it.
    There is NO WARRANTY, to the extent permitted by law. Type "show copying"
    and "show warranty" for details.
    This GDB was configured as "--host=x86_64-apple-darwin10 --target=arm-none-eabi".
    For bug reporting instructions, please see:
    <http://www.gnu.org/software/gdb/bugs/>...
    Reading symbols from /Users/tpw/tp_frdm_blink_3.elf...done.

(gdb) target remote localhost:3333
Remote debugging using localhost:3333
0x00005104 in UART_WriteBlocking (base=0x4006a000, data=0x2002fee4 "1", length=0)
    at /Users/tpw/Documents/03embedded/motoKDS32frdmK64Fprojects/KSDK20FRDMK64F/devices/MK64F12/drivers/fsl_uart.c:451
    451            while (!(base->S1 & UART_S1_TDRE_MASK))
(gdb) load
Loading section .interrupts, size 0x400 lma 0x0
Loading section .flash_config, size 0x10 lma 0x400
Loading section .text, size 0x7258 lma 0x410
Loading section .ARM, size 0x8 lma 0x7668
Loading section .init_array, size 0x4 lma 0x7670
Loading section .fini_array, size 0x4 lma 0x7674
Loading section .data, size 0x78 lma 0x7678
Start address 0x4d8, load size 30448
Transfer rate: 29 KB/sec, 1449 bytes/write.
(gdb) quit
A debugging session is active.
    Inferior 1 [Remote target] will be detached.
Quit anyway? (y or n) y
Detaching from program: /Users/tpw/Downloads/bubble_frdmk64f.elf, Remote target
Ending remote debugging

6) build a simple demo "hello_world"

First, make sure your FRDM-K64F mbed board is plugged in, and press the reset button to reset the board
Select "MenuBar::File::Import::General::ExistProjectIntoWorkspace" from the KDS IDE menu.
Use selectRootDirectory tool
Navigate to (on Mac /Applications/KDS_SDK120/Freescale/SDK_2.0.0/examples/frdmk64f/demo_apps/hello_world/kds )
Pick hello_world
Do not select the "Copy projects..." option.
Click the "Finish" button.
"Debug" and "Release" are the two project configurations (build targets) supported for each KSDK project

Debug configuratuion compiler optimization is set low, and debug information is generated for the executable
Release configuratuion compiler optimization is set higher, and debug information is not generated for the executable

Build the hello_world by clicking the drop-down arrow to the right of the hammer-button in the menuBar, and selecting "release"

Make sure there are no problems reported in the problemPane at the bottom of KDS

Also, build the hello_world by clicking the drop-down arrow to the right of the hammer-button in the menuBar, and selecting "debug"

Make sure there are no problems reported in the problemPane at the bottom of KDS

It is a bit cumbersome to set up a termial to use hello_world in your very first project, so instead make the following changes at the top of hello_world main.c
Open the hello_world/sources folder,and double-click main.c to add the following code at the top of main:

#include "fsl_port.h" //you must add this to hello_world

int main(void)
{

    /* Init board hardware. */
    BOARD_InitPins();
    BOARD_BootClockRUN();
    BOARD_InitDebugConsole();

    // Enable the clock to the PORT module that the LED is on.
   CLOCK_EnableClock(kCLOCK_PortB);
   CLOCK_EnableClock(kCLOCK_PortE);

   // Setup the red and green LED pin as GPIO
   PORT_SetPinMux(BOARD_LED_RED_GPIO_PORT, BOARD_LED_RED_GPIO_PIN, kPORT_MuxAsGpio);
   PORT_SetPinMux(BOARD_LED_GREEN_GPIO_PORT, BOARD_LED_GREEN_GPIO_PIN, kPORT_MuxAsGpio);
   PORT_SetPinMux(BOARD_LED_BLUE_GPIO_PORT, BOARD_LED_BLUE_GPIO_PIN, kPORT_MuxAsGpio);

   //initialise the RGB to on/off condition
   LED_RED_INIT(LOGIC_LED_OFF);
   LED_GREEN_INIT(LOGIC_LED_OFF);
   LED_BLUE_INIT(LOGIC_LED_OFF);
    LED_RED_OFF();     //Turn off RED Led
    LED_GREEN_OFF(); // Turn on Green Led
    LED_GREEN_OFF(); // Turn on Green Led

    LED_RED_ON();
    while(1)
       {
        for(int xx=0; xx<80000; xx++)
            LED_RED_OFF();
            LED_RED_OFF();
        for(int xx=0; xx<80000; xx++)
            LED_RED_ON();
            LED_RED_ON();
       }

   // ..... and the rest of the code follows below, and is unreachable, and will not execute

7) create your debug configuration: MenuBar::Run::debugConfiguration and double-clcik GDBhardwareDebugging

a) in MainTab:

C/C++Application browse to your firmware.elf location, such as Debug/hello_world_frdmk64f.elf
BuildConfig selectAutomatic UseWorkspaceSettings
click applyButton

b) in debuggerTab,

check "use remote target"
Set Jtag GenericTcpIp localhost:3333 (same port as printed from pyocd-gdbserver)
set full ARM GDBCommand

instead of just "gdb:" use arm-none-eabi-gdb

click applyButton

c) in startupTab

uncheck initilizationCommandResetDelaty
uncheck initilizationCommandHalt
check LoadImage and loadSymbols
check useProjectBinary, and and make sure useProjectBinary points to your hello_world_frdmk64f.elf
click applyButton

d) in commonTab

check saveAsSharedFile
check displayFavoritesDebug
check allocateConsole
click applyButton
click applyButton

8) in KDS, add 2 breakpoints to main.c

open main.cpp and add 2 breakpoints at the “LED1_ON;” and "LED1_OFF;" lines
by double-clicking in the bar to the left of the 2 lines in main.c (little buttons wil appear)

9) To debug, first make sure your FRDM-K64F mbed board is plugged in, and press the reset button to reset the board

a) in the terminal running pyocd-gdbserver use “control-c” to kill it
b) make sure main.c is open and visible in eclipse, so that it apppears whenever the debugger takes over
c) MenuBar::Project::clean
d) Run MenuBar::Project::BuildConfigurations::SetActive::Debug

MenuBar::Project::clean
Run MenuBar::Project::buildProject

Or, build the by clicking the drop-down arrow to the right of the hammer-button in the menuBar, and selecting "Debug"
Make sure there are no problems reported in the problemPane at the bottom of KDS

e) run pyocd-gdbserver in a terminal and make sure it reports port 3333 when it runs
f) make sure main.c is open and visible in KDS, so that it appears whenever the debugger takes over
g) run debug in the main eclipse window,

by clicking the dropdown arrow of the debug icon (yellow circle below) and run helloWorld debug,
or MenuBar::Run::DebugConfigurations

the green LED should flicker as it uploads to the FRDM-K64F

Note: if you get “problem occurred” details: localhost3333 timeout, go back to the terminal and make sure pyocd-gdbserver ran on port 3333
If all goes well you should see the debug window as shown below

Main.c view (red circle below)
Dissassembly view showing machine code and location in memory (blue circle below)
DebugButton (yellow circle below)
ResumeButton (blue arrow below)
TerminateButton (yellow arrow)
Magenta pair of arrows points to green highlighting of the line of code where the program is suspended, both in main.c and dissassembly views
Note also the register pane in the upper right

h) the debugPerspective should appear, otherwise use MenuBar::Window::Perspective::Open::Other::debug

select main.c view and note the disassemblyView at programcounter 2000000
click the resumeButton ( yellow Green Arrow icon )
and the breakpoints should highlight in main.coo and dissassembly as the program executes.
click the skipAllBreakpointsButton and click the resumeButton
the LED should also flash on the board as it runs
note the register view also contains the program counter register ”pc"
click suspendButton to suspend execurion
Click TerminateButton to terminate

If you received this message: “Error: Program “platformio” not found in PATH”, then you need to update Eclipse $PATH variable. In Eclipse IDE make right click on the created project (“Project Explorer“) : “Properties → C/C++ Build → Environment → PATH → Edit” and set to /usr/local/bin:/bin:/usr/bin:/usr/sbin:/sbin .

Freescale, Kinetis are registered trademarks of Freescale Semiconductor, Inc. Texas Instruments, TI, C2000, and Code Composer Studio are a registered trademarks of Texas Instruments Incorporated. Adafruit is a registered TradeMark of Limor Fried. ARM, Cortex and Keil are registered trademarks of ARM Limited (or its subsidiaries). Apple, Yosemite, Mac OS, iPhone, iPad, MacBook, Mac, iTunes, and Xcode are trademarks of Apple inc. All other product or service names are the property of their respective owners. Arduino is a registered trademark of Arduino.