This is Part 2 of a Mini Series. In Part 1, I described how to set up the hardware (see “Tutorial: Adafruit WS2812B NeoPixels with the Freescale FRDM-K64F Board – Part 1: Hardware“). Now it is time to have the software tools ready. In this post I describe to have the IDE (Freescale Kinetis Design Studio) with the Freescale SDK installed, along with the correct firmware on the FRDM-K64F Board. The goal is to drive Adafruit’s NeoPixel (WS2812B) with the Freescale FRDM-K64F board:
Category Archives: gcc
Using Kinetis Design Studio V3.0.0 with the Launchpad 4.9-2015-q2 Release
The Kinetis Design Studio v3.0.0 comes with the GNU/GCC ARM Embedded (launchpad) version 4.8-2014-q3. End of June 2015, ARM released a new version, the 4.9-2015-q1.So why not using that newer release?
- It comes with GDB version 7.8 and has the ‘return of function display’ feature.
- GDB has Phyton scripting support.
- It fixes that nasty GDB bug ‘breakpoint on removed code’ issue.
Is that already enough to make that switch?
Eclipse Project ‘Refresh Policy’: Broken Incremental Build with External Make?
So here is a problem I have observed for a while, and several users have reported that to me: the problem is that for some reasons and only for some projects, when I do a ‘build’ in Eclipse CDT, it does a ‘full’ build. It does not only build the changed files, it builds all or many files in the project.
I expect that only the changed files will be rebuild. Instead, it compiles many files it should not compile/build, with the result that a build takes a very long time. That’s clearly wrong, and not what I expect. So what is causing this problem?
Code Coverage with gcov, launchpad tools and Eclipse Kinetis Design Studio V3.0.0
What makes Eclipse great: using open source tools there are a lot of tools and techniques available which usually are only provided for desktop development.
A while back I described how to do code coverage with Eclipse Kepler and the GNU ARM Embedded (launchpad) tools (see “Code Coverage for Embedded Target with Eclipse, gcc and gcov“). With Kinetis Design Studio out, time to do the same with that Eclipse distribution, especially as Freescale is now using the stock GNU ARM Embedded tools too.
Problem: undefined reference to ‘__end__’ if using Semihosting
In case you are running into the following GNU linker error about a missing __end__:
'Building target: MyProject.elf' 'Invoking: Cross ARM C++ Linker' ... toolchain/bin/../lib/gcc/arm-none-eabi/4.8.4/../../../../arm-none-eabi/lib/armv6-m/rdimon-crt0.o: In function `_start': (.text+0xdc): undefined reference to `__end__' collect2.exe: error: ld returned 1 exit status make: *** [MyProject.elf] Error 1
The GNU linker complains that rdimon-crt0.o needs the symbol __end__. This symbol marks the end of the user data/RAM section, and is needed by the rdimon library specs which is used with semihosting.
Editing Compiler Include (or other) Settings in Eclipse
So now I have carefully set up my compiler include paths in Eclipse to tell the GNU compiler where to find my header files:
The question is: how can I apply these settings to another project?
CRC Checksum Generation with ‘SRecord’ Tools for GNU and Eclipse
One of the things missing for Embedded in the GNU linker is that it cannot generate a CRC checksum. Luckily, there is the solution of using SRecord:

Semihosting with GNU ARM Embedded (Launchpad) and Kinetis Design Studio
A while back I wrote two articles about Semihosting: “Semihosting with GNU ARM Embedded (LaunchPad) and GNU ARM Eclipse Debug Plugins” and Semihosting with Kinetis Design Studio. With using the GNU ARM Embedded (lauchpad) in my Kinetis Design Studio, time for a ‘summary’ post :-).
Poor Man’s Trace: Free-of-Charge Function Entry/Exit Trace with GNU Tools
There are cases where my application runs find for days, weeks or even months, but then from time to time there is an application crash. Yes, the watchdog will recover it, but still it would be good to know what happened? One solution would be to hook up a trace probe (like the one I have described in this post: “First Steps with the P&E Tracelink“). But having such a trace probe attached all the time is first not cheap and second not always possible. So what if the application would leave ‘breadcrumbs’ behind which would tell me the flow of the program leading to the problem? I have found a functionality in the GNU tools which seems not be widely known or use, but is incredibly helpful in such cases.
So what if I could get a log like this telling me which functions get called by whom?
{ 00000E88->00000DA0 ???->DEMO_Init
} 00000E88<-00000DA0 ???<-DEMO_Init
{ 00000E8C->00000D40 ???->DEMO_Run
{ 00000D62->00000CE8 DEMO_Run:0x0022->decide
{ 00000D0E->00000C60 decide:0x0026->calcValue
} 00000D0E<-00000C60 decide:0x0026<-calcValue
{ 00000D16->00000CA0 decide:0x002E->getValue
{ 00000CC6->00000C60 getValue:0x0026->calcValue
} 00000CC6<-00000C60 getValue:0x0026<-calcValue
} 00000D16<-00000CA0 decide:0x002E<-getValue
} 00000D62<-00000CE8 DEMO_Run:0x0022<-decide
{ 00000D62->00000CE8 DEMO_Run:0x0022->decide
Solving the 8192 Character Command Line Limit on Windows
There is a really annoying issue with using command line tools on Windows: the maximum length of the command line passed to cmd.exe is 8192 characters (see http://blogs.msdn.com/b/oldnewthing/archive/2003/12/10/56028.aspx). So you think this is not a problem for you, as you would not pass such a long command line to cmd.exe (the DOS shell under Windows)? Well, if you are using Eclipse (as I do) which generates make files (which is the normal way), then the cmd.exe very likely is involved to call the compiler/linker/etc, indirectly with the usage of make.exe. Compiling files is usually not a problem as it does not hit that 8192 limit. However, it is likely that link phase will end up with an error:
If you have such a problem, there is a solution ….






