I’m using Eclipse based IDE’s to develop and debug my embedded applications. This works great, as Eclipse has all the necessary tools to edit, build and debug it. But when it comes just to download/flash a binary to the board, then things are pretty much specific to the tools used. With the advent of the new MCUXpresso IDE, here is how that Eclipse IDE can be used for this.

Outline

The normal way in Eclipse to download a binary to the target is to use the debugger with a so called launch (or debug) configuration. That launch configuration needs a ‘project’, so programming a board without a project is not the usual thing. But there are ways how to download and program an application without a project. I show this here with using the NXP MCUXpresso IDE (V10.0.0), but some ways are applicable say using the Kinetis Design Studio (V3.2.0) or if using the GNU ARM Eclipse plugins.

Binaries

There are different file formats which can be used to program a microcontroller:

• ELF/Dwarf: This is the normal output format of the linker. Typical extensions are .elf, .abs or .axf (ARM eXecutable File). This file format has the code and data, plus the debug information (which is *not* downloaded to the target and only used for debugging).

That ELF/Dwarf file usually gets converted into different binary formats more suitable for programmers or boot loaders, and they do not include the debug information:

• S19/S-Record: textual file format (type, address, size, code, checksum). Typical extensions are .s19, .srec or .sx
• Intel Hex: textual file format (similar representation as S19). Typical extension is .hex
• Binary: In this format, the data is written in binary form, without address information. It is basically a ‘memory dump’.

Each format has its own pros and cons, see “S-Record, Intel Hex and Binary Files” for a more detailed overview.

To generate the different formats:

• MCUXpresso IDE: see “MCUXpresso IDE: S-Record, Intel Hex and Binary Files“
• Kinetis Design Studio or using GNU ARM Eclipse: see “Binary (and S19) Files for the mbed Bootloader with Eclipse and GNU ARM Eclipse Plugins“
• Converting, merging and manipulating binary files: I use the SRecord tool (for all kind of other formats too!), see “CRC Checksum Generation with ‘SRecord’ Tools for GNU and Eclipse” and “Merging S19 Files“

MCUXpresso IDE and GUI Flash Programmer

With MCUXpresso IDE V11, the GUI Flash Programmer supports LinkServer, P&E and Segger connections. The file formats supported depend on the connection type:

• P&E: .axf (ELF/Dwarf)
• LinkServer: .axf (ELF/Dwarf), .bin (Binary)
• SEGGER: .axf (ELF/Dwarf), .bin (Binary)

Using LinkServer GUI Flash Programmer

With using the MCUXpresso IDE, there is a LinkServer GUI Flash Programmer (see “Using the LPCXpresso V2/V3 Boards to Debug an external Board“):

In that dialog I simply can specify the binary I want to download. But there are the following restrictions:

• Only ELF/Dwarf and binary files supported (e.g. no S19 or Intel Hex files)
• Only works with the NXP LinkServer debug connection (LPC-Link, LPC-Link2, CMSIS-DAP) (e.g. no support for Segger J-Link or P&E Multilink)

Using Launch Configuration

The other approach is to use a launch configuration. This actually would be the same as using a normal debug session.

💡 In Kinetis Design Studio V3.2.0 there is a ‘Flash from file’ toolbar button. It is basically the same as using a special launch configuration. As it might interfere with the normal Eclipse launch configuration, I’m not using that way any more.

To create a new launch/debug configuration, I can duplicate an existing one (matching my device):

P&E

The P&E connection is not able to load a raw binary file directly, it only recognizes a file with a header file.

I can make a elf file out of a bin (raw binary) file with the GNU ‘objcopy command (see “Converting a Raw Binary File into an ELF/Dwarf File for Loading and Debugging“):

arm-none-eabi-objcopy.exe --input-target=binary --output-target=elf32-little myApp.bin myApp.bin.elf

This adds a ELF header to the file which I can inspect/verify with the ‘readelf’ GNU programm:

arm-none-eabi-readelf.exe -a myApp.bin.elf

which gives for examle:

ELF Header:
 Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
 Class: ELF32
 Data: 2's complement, little endian
 Version: 1 (current)
 OS/ABI: UNIX - System V
 ABI Version: 0
 Type: REL (Relocatable file)
 Machine: None
 Version: 0x1
 Entry point address: 0x0
 Start of program headers: 0 (bytes into file)
 Start of section headers: 26956 (bytes into file)
 Flags: 0x0
 Size of this header: 52 (bytes)
 Size of program headers: 0 (bytes)
 Number of program headers: 0
 Size of section headers: 40 (bytes)
 Number of section headers: 5
 Section header string table index: 2

Section Headers:
 [Nr] Name Type Addr Off Size ES Flg Lk Inf Al
 [ 0] NULL 00000000 000000 000000 00 0 0 0
 [ 1] .data PROGBITS 00000000 000034 0068f4 00 WA 0 0 1
 [ 2] .shstrtab STRTAB 00000000 006928 000021 00 0 0 1
 [ 3] .symtab SYMTAB 00000000 006a14 000050 10 4 2 4
 [ 4] .strtab STRTAB 00000000 006a64 000058 00 0 0 1
Key to Flags:
 W (write), A (alloc), X (execute), M (merge), S (strings)
 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
 O (extra OS processing required) o (OS specific), p (processor specific)

For the P&E debug connection (MCUXpresso IDE or e.g. Kinetis Design Studio), use a dummy project use that file for the debug session:

 

Then I can use the normal ‘debug’ which will use that binary file specified to be programmed. If I want only to download and skip the ‘debug’ step, then I can use the approach described in “Emulating Eclipse ‘Run’ with ‘Debug’ Configuration“.

Segger (GNU ARM Eclipse)

The same approach is used for the Segger J-Link debug connection (Kinetis Design Studio, or with the GNU ARM Eclipse plugins installed in MCUXpresso IDE, see “MCUXpresso IDE: Importing Kinetis Design Studio Projects“).

Specify the binary file in the Main tab:

The following files are supported: ELF/Dwarf, S19 and Intel Hex.

In the ‘Startup’ settings disable loading the symbols:

Using the same approach for Binary files will produce an error. Alex from Segger (thanks!) provided me a way how to load binary files:

Specify a dummy (valid) ELF/Dwarf file:

In the Startup tab, disable ‘Load Symbols’ and ‘Load Executable’. Use the

monitor loadbin <file name>

to load the file.

💡 I tried using Eclipse variables as ${project_loc} instead of using an absolute path to the binary, but this somehow can lock the debug session (not sure why). Using an absolute path worked for me.

Have ‘Set Program counter’, ‘Set Breakpoint’ and ‘Continue’ disabled:

Summary

Currently users of the GNU ARM Eclipse plugins (e.g. Kinetis Design Studio, or if you install them into MCUXpresso IDE) have the most flexible options to download binaries to the target. For the GNU ARM Eclipse plugins and the P&E plugin all what I need is to specify the binary file.

If using the standard MCUXpresso IDE V10.0.0, then there is the LinkServer dialog which supports the LPC-Link2/Link connections. For P&E the support is the same as with the GNU ARM Eclipse Plugins. For Segger I can install the GNU ARM Eclipse plugins or to use the Segger external tools to download binaries.

Because ‘programming binary files’ is not a standard feature of Eclipse, every vendor comes up with its own ways. If such an option or extension is not present, you still can try using a normal launch configuration, but the debug plugin has to accept a binary without debug information. Or use an external tool outside Eclipse.

Happy Binaring 🙂

Links

• MCUXpresso IDE: http://www.nxp.com/mcuxpresso/ide
• Kinetis Design Studio IDE: http://www.nxp.com/kds
• GNU ARM Eclipse plugins: http://gnuarmeclipse.github.io/