How to build mbed src and Hello world (AMRCC, ARM GCC) (tutorial)

This tutorial is dedicated to building mbed sources and exporting hello world. K20D5M is going to be used as an example, because it is still not available in the mbed online compiler. Thus this give us to compile any application based on mbed libraries. My machine is running Windows so paths presented in the 2nd step are for windows.

1. Download the mbed github repository

If you are familiar with git, just clone repository using git clone command. For those who don't use git, download the repository as archive (zip).
Link mbed src ZIP archive (~5MB) [github.com/mbedmicro/mbed]

After downloading is completed, unzip the archive.

2. Set your toolchain paths

There few toolchains which can be used, I'll present ARM GCC and ARMCC (uVision). Create a new file named private_settings.py in the workspace_tools directory. This private settings file defines settings which overrides default settings.

from os.path import join
#KEIL
ARM_PATH = "C:/Keil/ARM"
ARM_BIN = join(ARM_PATH,"ARMCC","bin")
ARM_INC = join(ARM_PATH,"RV31","INC")
ARM_LIB    = join(ARM_PATH,"ARMCC","lib")
ARM_CPPLIB = join(ARM_PATH, "ARMCC","lib","cpplib")

#GCC ARM
GCC_ARM_PATH = "C:/Program Files/GNU Tools ARM Embedded/4.7 2013q3/bin"

BUILD_OPTIONS = ["debug-info"]

ARM_ paths are used for ARMCC (uVision IDE, paths for each folders might vary, as I had problems with previous versions, because they changed the folder structure), GCC_ARM_ path for ARM GCC toolchain path. Set those according your installation folder.
I use debug-info build-option, to include debug symbols.

3. Build sources for your target

To build mbed sources for TARGET and TOOLCHAIN, use command:

python build.py -m TARGET -t TOOLCHAIN

The list of supported targets is quite long, to check if your TARGET is supported TARGETS array [github.com/mbedmicro/mbed].
Each TARGET defines supported TOOLCHAIN. For example, K20D5M has ARM and GCC_ARM.

To build for ARM (that's ARMCC used in uVision for example)

python build.py -m K20D5M -t ARM

To build for GCC ARM

python build.py -m K20D5M -t GCC_ARM

If you just invoke command without -t, the target will be built for all supported toolchains.

4. Using exporters

As soon as you have built mbed sources for your target, go to my previous tutorial about using exporters. There is just shown to export Hello world example.

How to use mbed exporters

5. Build an application

Using ARM GCC, use makefile to build an application. If uVision is used, build the application in the uVision IDE. No matter what toolchain you use, they should generate a binary file, which can be copied to mbed msd drive. Same procedure as it's used by the mbed online compiler.

FRDM KL05, FRDM K20D50M testing for mbed enablement

Is anybody out there who wants to participate in enabling those 2 platforms? I posted instructions how to debug KL05Z target offline with mbed sources few weeks ago. However, I did not receive any feedback if that is working for you or any problems with its implementation.

The fresh new target K20D50M is still not complete, thus needed some more tweaks to complete its implementation.

Here's a post from mbed, good place to start:  Let's enable KL05Z and K20D5M targets online on mbed [mbed.org/forum/mbed]
Leave a comment, preferably there on mbed community.

How to use mbed exporters (tutorial)

I always created my own projects while I was developing offline with mbed. Fortunately, there are exporters which I assume are used in the online compiler. They are available in the mbed sources, in the folder /workspace_tools/export, Github mbed - export folder [github.com/mbedmicro/mbed]

These exporters support more platforms than online compiler, thus if you see a platform in the mbed sources but is not yet available online, this is your chance to start using your target. It requires IDE or at least a toolchain to compile it.

What targets are currently supported by exporters?

• NUCLEO_F103RB
• KL25Z,
• LPC1347
• LPC11U24_301
• LPC4330_M4
• nRF51822,
• LPC11U35_401
• LPC810
• KL46Z
• LPC812
• KL05Z
• LPC1768
• K20D5M
• LPC4088
• LPC11C24
• MBED_MCU
• LPC1114
• LPC11U24,
• STM32F407
• LPC2368

To see what options are available, invoke project.py, an output:

d:\Code\git_repo\github\mbed\workspace_tools>python project.py


[ERROR] You have to specify one of the following tests:
[ 0] MBED_A1: Basic
[ 1] MBED_A2: semihost file system
[ 2] MBED_A3: C++ STL
[ 3] MBED_A4: I2C TMP102
[ 4] MBED_A5: DigitalIn DigitalOut
[ 5] MBED_A6: DigitalInOut
[ 6] MBED_A7: InterruptIn
[ 7] MBED_A8: Analog
[ 8] MBED_A9: Serial Echo at 115200
[ 9] MBED_A10: PortOut PortIn
[ 10] MBED_A11: PortInOut
[ 11] MBED_A12: SD File System
[ 12] MBED_A13: I2C MMA7660
[ 13] MBED_A14: I2C Master
[ 14] MBED_A15: I2C Slave
[ 15] MBED_A16: SPI Master
[ 16] MBED_A17: SPI Slave
[ 17] MBED_A18: Interrupt vector relocation
[ 18] MBED_A19: I2C EEPROM read/write test
[ 19] MBED_A20: I2C master/slave test
[ 20] MBED_A21: Call function before main (mbed_main)
[ 21] MBED_A22: SPIFI for LPC4088 (test 1)
[ 22] MBED_A23: SPIFI for LPC4088 (test 2)
[ 23] MBED_A24: Serial echo with RTS/CTS flow control
[ 24] BENCHMARK_1: Size (c environment)
[ 25] BENCHMARK_2: Size (float math)
[ 26] BENCHMARK_3: Size (printf)
[ 27] BENCHMARK_4: Size (mbed libs)
[ 28] BENCHMARK_5: Size (all)
[ 29] MBED_1: I2C SRF08
[ 30] MBED_2: stdio
[ 31] MBED_3: PortOut
[ 32] MBED_4: Sleep
[ 33] MBED_5: PWM
[ 34] MBED_6: SW Reset
[ 35] MBED_7: stdio benchmark
[ 36] MBED_8: SPI
[ 37] MBED_9: Sleep Timeout
[ 38] MBED_10: Hello World
[ 39] MBED_11: Ticker
[ 40] MBED_12: C++
[ 41] MBED_13: Heap & Stack
[ 42] MBED_14: Serial Interrupt
[ 43] MBED_15: RPC
[ 44] MBED_16: RTC
[ 45] MBED_17: Serial Interrupt 2
[ 46] MBED_18: Local FS Directory
[ 47] MBED_19: SD FS Directory
[ 48] MBED_20: InterruptIn 2
[ 49] MBED_21: freopen Stream
[ 50] MBED_22: Semihost
[ 51] MBED_23: Ticker 2
[ 52] MBED_24: Timeout
[ 53] MBED_25: Time us
[ 54] MBED_26: Integer constant division
[ 55] MBED_27: SPI ADXL345
[ 56] MBED_28: Interrupt chaining (InterruptManager)
[ 57] MBED_29: CAN network test
[ 58] MBED_30: CAN network test using interrupts
[ 59] MBED_31: PWM LED test
[ 60] CMSIS_RTOS_1: Basic
[ 61] CMSIS_RTOS_2: Mutex
[ 62] CMSIS_RTOS_3: Semaphore
[ 63] CMSIS_RTOS_4: Signals
[ 64] CMSIS_RTOS_5: Queue
[ 65] CMSIS_RTOS_6: Mail
[ 66] CMSIS_RTOS_7: Timer
[ 67] CMSIS_RTOS_8: ISR
[ 68] RTOS_1: Basic
[ 69] RTOS_2: Mutex
[ 70] RTOS_3: Semaphore
[ 71] RTOS_4: Signals
[ 72] RTOS_5: Queue
[ 73] RTOS_6: Mail
[ 74] RTOS_7: Timer
[ 75] RTOS_8: ISR
[ 76] RTOS_9: File
[ 77] NET_1: TCP client hello world
[ 78] NET_2: UDP client hello world
[ 79] NET_3: TCP echo server
[ 80] NET_4: TCP echo client
[ 81] NET_5: UDP echo server
[ 82] NET_6: UDP echo client
[ 83] NET_7: HTTP client
[ 84] NET_8: NTP client
[ 85] NET_9: Multicast Send
[ 86] NET_10: Multicast Receive
[ 87] NET_11: Broadcast Send
[ 88] NET_12: Broadcast Receive
[ 89] NET_13: TCP client echo loop
[ 90] UB_1: u-blox USB modem: HTTP client
[ 91] UB_2: u-blox USB modem: SMS test
[ 92] USB_1: Mouse
[ 93] USB_2: Keyboard
[ 94] USB_3: Mouse_Keyboard
[ 95] USB_4: Serial Port
[ 96] USB_5: Generic HID
[ 97] USB_6: MIDI
[ 98] USB_7: AUDIO
[ 99] CMSIS_DSP_1: FIR
[100] DSP_1: FIR
[101] KL25Z_1: LPTMR
[102] KL25Z_2: PIT
[103] KL25Z_3: TSI Touch Sensor
[104] KL25Z_4: RTC
[105] KL25Z_5: MMA8451Q accelerometer
[106] EXAMPLE_1: /dev/null
[107] EXAMPLE_2: FS + RTOS


Usage: project.py [options]

Options:
-h, --help show this help message and exit
-m MCU, --mcu=MCU generate project for the given MCU (NUCLEO_F103RB, KL25Z,
LPC1347, LPC11U24_301, LPC4330_M4, nRF51822,
LPC11U35_401, LPC810, KL46Z, LPC812, KL05Z, LPC1768,
K20D5M, LPC4088, LPC11C24, MBED_MCU, LPC1114, LPC11U24,
STM32F407, LPC2368)
-p PROGRAM The index of the desired test program: [0-107]
-i IDE The target IDE: ['ds5_5', 'gcc_arm', 'codered',
'codesourcery', 'uvision', 'iar']
-b Use the mbed library build, instead of the sources

The output provides all information which we need to build a project. As I pushed today K20D5M target to mbed repository, I'll take that as an example how to start with mbed target which is not yet supported in the mbed compiler.
If you don't have prebuilt mbed sources for your target, don't use -b option (you can use it if you have built your target previously, then it creates the mbed library, same output as from the online compiler exporter). If you have not built target sources, use -b option, error is shown.

The very first application we can build is Hello world ([ 38] MBED_10: Hello World) To build it for GCC ARM, invoke:

python project.py -m K20D5M -p 38 -i gcc_arm

If you receive an error which contains jinja2, that means the projects generators require jinja2 package, please add it to your python installation. Easy install can help you, for more help, a procedure Jinja2 windows - how to install [forums.udacity.com/questions]

The output should be many compiled files, at the end [OK]. In the mbed root directory, there's should be a new folder build. Inside in the path build/export/workspace are sources which were copied there by an exporter. In the build/export folder, should be located an archive MBED_10_GCC_ARM_K20D5M.zip
This archive contains the exported application, unzip it , invoke make command to build Hello world application.

Freescale K20D50M (Target K20D5M) was added to mbed sources (news)

I have added another Freescale target to mbed github repository, this time it's the first Freescale Cortex M4 target.

I had pushed a branch which contains K20D5M target files, it was merged a minute ago to mbed master. It contains exporters for GCC ARM and uVision (ARMCC). I will add a new blog post how to use those exporters, it completely facilitates testing.

The K20D5M is supported, not fully functional. Demo like Hello world works, but for example I2C is not yet complete, neither PWM. Any help with this target is welcomed !

Update your K20D50M to CMSIS-DAP interface, which I shared on my mbed notepad, currently in beta version, link CMSIS-DAP K20D50M [mbed.org/users/Kojto/notebook]

If any questions, leave a comment or contact me on mbed. I will be working on this to complete entire HAL for K20D5M target.

debugging pyOCD gdb (tutorial)

I finally found a root cause of pyOCD locking kinetis chip. It took me quite a while to get into gdb server implementation, still many functions are unveiled for me. I am going to give you few tips what I would do once something is not working, or even to be sure that the right binary is going to be flashed. That's was my case, when I knew that pyOCD is flashing wrong data to the wrong address.

To start with, please if you use gdb server, change logging to DEBUG. This information is in gdb_test.py file.

logging.basicConfig(level=logging.DEBUG)

What helped me a lot to just see how data are interpreted, disable erasing the chip and then flashing as well. The code below is from gdbserver.py file. Don't forget, if you change anything inside pyOCD, please rerun setup.py file with a command

python setup.py install

Comment out two lines that init() and eraseALL().

if ops == 'FlashErase':
    self.flash.init()
    self.flash.eraseAll()
    return self.createRSPPacket("OK")

Flashing is carried out by calling programPage. Once you comment that line out, your target won't be flashed, so you can add a breakpoint anywhere there, write data to a file and see how they are interpreted.

while len(self.flashData) > 0:
    size_to_write = min(self.flash.page_size, len(self.flashData))
    #if 0 is returned from programPage, security check failed
    if (self.flash.programPage(flashPtr, self.flashData[:size_to_write]) == 0):
        logging.error("Protection bits error, flashing has stopped")
        return None
    flashPtr += size_to_write

    self.flashData = self.flashData[size_to_write:]

    # print progress bar
    sys.stdout.write('\r')
    i = int((float(flashPtr)/float(bytes_to_be_written))*20.0)
    # the exact output you're looking for:
    sys.stdout.write("[%-20s] %d%%" % ('='*i, 5*i))
    sys.stdout.flush()

There are many debug files commented in the implementation, which are intended for debugging purposes. The one below is from FlashDone command case, once you enable it, the bad_bin contains entire data which are going to be written to the flash. You can compare it to your bin generated, reveal if it matches the data.

elif 'FlashDone' in ops :
    flashPtr = 0
    bytes_to_be_written = len(self.flashData)

    """
    bin = open(os.path.join(parentdir, 'res', 'bad_bin.txt'), "w+")
    
    i = 0
    while (i < bytes_to_be_written):
        bin.write(str(self.flashData[i:i+16]) + "\n")
        i += 16
    """

How did I solve that problem with locking the chip? The most important addition is the security bits check, which is crucial. If data at the address 0x400 are not set to 0xFF, flashing should be stopped. If it would not be stopped, the chip can get secured, depending on the 16 byte value at that address.
I added the following lines, this is why debug logging is good to have enabled, you can see how those bits are set and are going to be flashed. This would have unveiled that chip is going to get locked.

def checkSecurityBits(self, address, data):
    #error if security bits have unexpected values
    if (address == 0x400):
        for i in range(12):
            logging.debug("data[%d] at add 0x%X: 0x%X", i, i, data[i])
            if (data[i] != 0xff):
                return 0

        logging.debug("data[%d] at add 0x%X: 0x%X", i+3, i+3, data[i+3])
        logging.debug("data[%d] at add 0x%X: 0x%X", i+4, i+4, data[i+4])
        if ((data[i+3] != 0xff) or (data[i+4] != 0xff)):
            return 0

    return 1

I even locked sometimes the chip (only security bit or some other bits, not mass erase bit). If chip is locked, mbed msd drive does not need to appear! Don't get frustrated. Follow the lines below, and you might get mbed drive again.
To solve this problem, get into bootloader mode (to disable CMSIS-DAP which enables another interface to access the mcu chip), use external jlink or just openSDA jlink. Execute the commands I shared in the previos post:
unlocking kinetis chip with jlink console [http://embeddedworldweb.blogspot.com]
Don't be afraid if it returns error, sometimes it does but chip is functional again. Just reconnect your board, mbed drive should appear again if the chip is not bricked (like mass erase bit is set).

To get familiar with gdb serial protocol, this link helps
GDB Remote serial protocol [www.embecosm.com/appnotes/]

I will add more chips to pyOCD. Finding the root cause of locking the kinetis chip provided a really appreciated lesson. Happy to contribute to pyOCD.

Side note: the security check is on my branch at the moment - waiting for merge to the master branch. Don't use KL25Z with pyOCD from the origin master at the moment! You can lock your chip. Thanks for understanding.
To test the above features, here's link to my branch  dev issue#1 - security bits check [github.com/0xc0170]

KL46Z CMSIS-DAP update - beta version 2 (news)

Some of you might have noticed that KL46Z was stripped from platforms. Wonder why?

The CMSIS-DAP interface was functional. However, it sets randomly the security bit or even disabled mass erase bit. With help from the mbed team, we corrected it.

I updated my notepad page on mbed, the CMSIS-DAP v2 for KL46Z is shared there.
CMSIS-DAP for the freedom platform [mbed.org/users/Kojto/notebook]

The freedom KL46Z online on mbed (news)

Today is a day full of updates since the morning. Another great news for us, mbed geeks. The freedom board KL46Z is among enabled mbed platforms, the second freedom platform.

Link: FRDM-KL46Z [http://mbed.org/handbook]


Here's a picture, directly from mbed handbook for KL46Z, with all needed pins description.

The second picture shows how are sensors connected,

Looks as good, doesn't it? Thanks to mbed for this descriptive pictures!

I have added exporters for uVision and GCC yesterday, got merged today to master.

Thanks to Michael Conners, who created the initial version of HAL for KL46Z. His pull request started my contribution to KL46Z HAL.

mbed KL25Z export to ARM GCC (news)

The export for target KL25Z to GCC ARM is available !!

Please share !

kinetis lxx gpio demo for the freedom platform (update)

Quick update.
I introduced yesterday KLxx project with only one freedom board supported - KL25Z.

I have added 3 more boards - KL02Z, KL05Z and KL46Z. Current version is v0.3. As version states, still needs more testing.

On github: Kinetis KLxx gpio demo - GCC [github.com/0xc0170]

The freedom platform ARM GCC basic project (news)

I created gcc projects for K20/K60 back in the March this year. I finally realized I could update my makefile and startups for CMSIS files and of course, for the freedom platform. Time's up!

The initial version contains the gpio demo for the FRDM-KL25Z. Here's the link Kinetis L ARM GCC demo using CMSIS files [github.com/0xc0170]

If you have any problems, questions, leave a comment as usual. I will add more freedom platform by time.

CMSIS-DAP for the freedom platform (news)

As many of you know, I recently added new freedom platforms to CMSIS-DAP, with help from the mbed team and also bigarmer2013.

I built today the CMSIS-DAP for the following boards:

• KL05Z
• KL25Z
• KL46Z
• K20D50M

You can download them here CMSIS-DAP for the freedom platform [mbed.org/users/Kojto/notebook]

Be aware, they are for testing purposes at the moment

If you have any problems, report them on mbed site, preferably in the notebook comments. EnjoY!

unlocking kinetis (KL25Z) with the jlink console

I locked my KL25Z board using pyOCD gdb yesterday, was not able to connect to the chip with ULINK, neither with CMSIS-DAP interface on KL25Z (K20). Because I am using older bootloader on openSDA interface, the board does not recognize jlink openSDA binary file. The only option left for me was to test it with an external jlink. So you need an external jlink to follow. I am not aware that ulink can do this. If you are, leave a comment!

To start with this, enter to the bootloader mode, if you are using openSDA hardware interface. So no any other interface is active which would block an access to the target.

I connected my jlink to it, shown error while connecting to the chip. Usually when I locked kinetis chip, at least jlink was able to connect to MCU. This time I assumed the mass erase protection bit was set. Thus I followed just simple steps find out what is the state of my core. I got lucky, the mass erase bit was not set, jlink was able to unlock the kinetis. If mass erase bit is set, it would fail. I accidentally selected KL26Z chip.

SEGGER J-Link Commander V4.76f ('?' for help)
Compiled Sep 27 2013 16:54:08
DLL version V4.76f, compiled Sep 27 2013 16:53:51
Firmware: J-Link Lite-FSL V1 compiled Jun 25 2012 16:40:07
Hardware: V1.00
S/N: 361000149
VTarget = 2.874V
Info: Could not measure total IR len. TDO is constant high.
Info: Could not measure total IR len. TDO is constant high.
No devices found on JTAG chain. Trying to find device on SWD.
Info: Found SWD-DP with ID 0x0BC11477

****** Error: Error while identifying Cortex-M core.
Info: Found SWD-DP with ID 0x0BC11477
No device found on SWD.
Failed to identify target. Trying again with slow (4 kHz) speed.
Info: Could not measure total IR len. TDO is constant high.
Info: Could not measure total IR len. TDO is constant high.
No devices found on JTAG chain. Trying to find device on SWD.
Info: Found SWD-DP with ID 0x0BC11477

****** Error: Error while identifying Cortex-M core.
Info: Found SWD-DP with ID 0x0BC11477
No device found on SWD.

J-Link>device ?
Info: Device "MKL26Z128XXX4" selected (128 KB flash, 16 KB RAM).
Reconnecting to target...
Info: Could not measure total IR len. TDO is constant high.
Info: Could not measure total IR len. TDO is constant high.
J-Link>unlock kinetis
Unlocking device...O.K.

J-Link>SWDReadAP 0x1000000
Read AP register 16777216 = 0x00000000
J-Link>SWDReadAP 0x1000000
Read AP register 16777216 = 0x00000031

J-Link>erase
Info: Found SWD-DP with ID 0x0BC11477
Info: Found SWD-DP with ID 0x0BC11477
Info: Found Cortex-M0 r0p0, Little endian.
Info: FPUnit: 2 code (BP) slots and 0 literal slots
Info: Kinetis L-series (setup): Disabling watchdog.
Erasing device (MKL26Z128xxx4)...
Info: J-Link: Flash download: Flash programming performed for 1 range (1024 byte
s)
Info: J-Link: Flash download: Total time needed: 1.086s (Prepare: 0.465s, Compar
e: 0.143s, Erase: 0.017s, Program: 0.047s, Verify: 0.012s, Restore: 0.399s)
Erasing done.
J-Link>

To read further about MDM-AP Control register (check the output SWDReadAP), see chapter 9.3.1 MDM-AP Control Register where all bits are described.

Update1:
I am testing the KL46Z interface, got locked today, but was not able to revive it with the same procedure as above, unlocking failed firstly. I invoked erase, passed with a error, and the unlock. My chip is again alive!

SEGGER J-Link Commander V4.76f ('?' for help)
Compiled Sep 27 2013 16:54:08
DLL version V4.76f, compiled Sep 27 2013 16:53:51
Firmware: J-Link Lite-FSL V1 compiled Jun 25 2012 16:40:07
Hardware: V1.00
S/N: 361000149
VTarget = 3.280V
Info: Could not measure total IR len. TDO is constant high.
Info: Could not measure total IR len. TDO is constant high.
No devices found on JTAG chain. Trying to find device on SWD.
Info: Found SWD-DP with ID 0x0BC11477

****** Error: Error while identifying Cortex-M core.
Info: Found SWD-DP with ID 0x0BC11477
No device found on SWD.
Failed to identify target. Trying again with slow (4 kHz) speed.
Info: Could not measure total IR len. TDO is constant high.
Info: Could not measure total IR len. TDO is constant high.
No devices found on JTAG chain. Trying to find device on SWD.
Info: Found SWD-DP with ID 0x0BC11477

****** Error: Error while identifying Cortex-M core.
Info: Found SWD-DP with ID 0x0BC11477
No device found on SWD.
J-Link>device ?
Info: Device "MKL46Z256XXX4 (ALLOW SECURITY)" selected (256 KB flash, 32 KB RAM)
.
Reconnecting to target...
Info: Could not measure total IR len. TDO is constant high.
Info: Could not measure total IR len. TDO is constant high.
J-Link>unlock kinetis
Unlocking device...Timeout while unlocking device.
J-Link>unlock kinetis
Unlocking device...Timeout while unlocking device.
J-Link>unlock kinetis
Unlocking device...Timeout while unlocking device.
J-Link>erase
Info: Found SWD-DP with ID 0x0BC11477

****** Error: Kinetis (connect): Timeout while halting CPU. CPU does not stop.
Erasing device (MKL46Z256xxx4 (allow security))...
Info: Found SWD-DP with ID 0x0BC11477
Info: Found SWD-DP with ID 0x0BC11477
Info: Found Cortex-M0 r0p0, Little endian.
Info: FPUnit: 2 code (BP) slots and 0 literal slots
Info: Kinetis L-series (setup): Disabling watchdog.
Info: J-Link: Flash download: Flash programming performed for 1 range (1024 byte
s)
Info: J-Link: Flash download: Total time needed: 1.173s (Prepare: 0.481s, Compar
e: 0.245s, Erase: 0.016s, Program: 0.001s, Verify: 0.010s, Restore: 0.417s)
Erasing done.
J-Link>unlock kinetis
Unlocking device...O.K.
J-Link>

pyOCD (gdb) and KL25Z

As I wrote yesterday, that everything was working, I run today directly gdb, using elf file. The result? KL25Z got locked, can't flash it anyhow. Need to replace the chip and look into the gdb server implementation, why it caused locking the chip. This confirmed what users reported on mbed site, that it locks the chip.

Here's an output:

Readelf returns from application elf file (simple gpio demo which I used yesterday, but bin file created from this elf file):

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:                              EXEC (Executable file)
  Machine:                           ARM
  Version:                           0x1
  Entry point address:               0xc1
  Start of program headers:          52 (bytes into file)
  Start of section headers:          111732 (bytes into file)
  Flags:                             0x5000002, has entry point, Version5 EABI
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         5
  Size of section headers:           40 (bytes)
  Number of section headers:         23
  Section header string table index: 20

Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .isr_vector       PROGBITS        00000000 008000 0000f4 00  AX  0   0  4
  [ 2] .flash_protect    PROGBITS        00000400 008400 000010 00   A  0   0  1
  [ 3] .text             PROGBITS        00000410 008410 006818 00  AX  0   0  8
  [ 4] .ARM.exidx        ARM_EXIDX       00006c28 00ec28 000008 00  AL  3   0  4
  [ 5] .data             PROGBITS        1ffff0c0 00f0c0 0000dc 00  WA  0   0  4
  [ 6] .bss              NOBITS          1ffff19c 00f19c 000154 00  WA  0   0  4
  [ 7] .heap             PROGBITS        1ffff2f0 00f1a0 000080 00      0   0  8
  [ 8] .stack_dummy      PROGBITS        1ffff2f0 00f220 000080 00      0   0  8
  [ 9] .ARM.attributes   ARM_ATTRIBUTES  00000000 00f2a0 000028 00      0   0  1
  [10] .comment          PROGBITS        00000000 00f2c8 0000e0 01  MS  0   0  1
  [11] .debug_info       PROGBITS        00000000 00f3a8 00579f 00      0   0  1
  [12] .debug_abbrev     PROGBITS        00000000 014b47 0011c7 00      0   0  1
  [13] .debug_loc        PROGBITS        00000000 015d0e 000e8a 00      0   0  1
  [14] .debug_aranges    PROGBITS        00000000 016b98 000298 00      0   0  8
  [15] .debug_ranges     PROGBITS        00000000 016e30 0002d0 00      0   0  8
  [16] .debug_line       PROGBITS        00000000 017100 0016d4 00      0   0  1
  [17] .debug_str        PROGBITS        00000000 0187d4 00184b 01  MS  0   0  1
  [18] .debug_frame      PROGBITS        00000000 01a020 0012f0 00      0   0  4
  [19] .stabstr          STRTAB          00000000 01b310 000076 00      0   0  1
  [20] .shstrtab         STRTAB          00000000 01b386 0000ed 00      0   0  1
  [21] .symtab           SYMTAB          00000000 01b80c 002730 10     22 439  4
  [22] .strtab           STRTAB          00000000 01df3c 000e64 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)

Be warned !