Ethernut Home Hardware Firmware Tools Download Community
 
Ethernuts  /  Elektor Internet Radio  /  Source Code Debugging
Search | Legals | Deutsch

Elektor Internet Radio Source Code Debugging

This document explains how to setup Eclipse and OpenOCD to allow source code debugging of Nut/OS applications running on Elektor Internet Radio. It is assumed, that you are already familiar with creating Nut/OS applications. The Nut/OS Software Manual describes the required steps.

This document has been originally written for Nut/OS 4.9 beta. Additional comments had been included later to cover Nut/OS 4.10.

Note, that you don't need to use Eclipse to create your own Nut/OS applications. You favorite text editor is just fine to create the source code and building your application can be done on the command line.

The same is true for debugging. There are a number of alternative tools available, like GDB for the command line purists or Insight, which provides a GUI for GDB. Actually, Eclipse uses GDB too, but provides a nicely integrated user interface for editing, compiling, uploading and debugging Nut/OS applications. While based on Java, it is available on all major platforms.

One last word before you move on: If you got here, because you assume that either your application or any of the Nut/OS libraries contains a bug, you should carefully think about, whether source code debugging will really help. Multithreaded network applications often fail because of timing problems or racing conditions. Setting breakpoints and inspecting variables will seldom help to find such bugs. What you need is some sort of tracing. In its most simple form, you can use the devDebug device to let your program output additional information on the serial port while running. In almost the same way you can use syslog. A similar situation may occur, when parts of memory are overwritten by bad pointers or buffer overflows. You should consider other debugging methods provided by Nut/OS, which are explained in the chapter Error Handling of the Nut/OS Software Manual.

Requirements

This is a short listing only. For Details please refer to the related manuals.

Required Hardware

The first 2 items you can build yourself, using the Eagle 4.11 CAD files for Elektor Internet Radio and Tutelizer 2.0. Readily built and tested devices are available at www.egnite.de/en/egnite-shop.html and from several distributors.

Required Software (Windows)

The following software needs to be installed on the Windows PC:

You can download the Java Runtime at www.oracle.com/technetwork/java/javase/downloads.

Eclipse is available at download.eclipse.org/eclipse/downloads and the CDT can be found at www.eclipse.org/cdt. Remember to install the Platform Runtime Binary. You may try Eclipse IDE for C/C++ Developers, which includes the CDT, but this version is not covered here.

TeraTerm can be downloaded at ttssh2.sourceforge.jp.

The last 3 items are available at our download page.

Installation details can be found in the documents that come with the specific product.

Required Software (Ubuntu)

The following software needs to be installed on the Linux PC (tested with Ubuntu 10.10):

You can install the Java Runtime Environment, minicom and openocd with the following command: 

apt-get install default-jre minicom openocd

Eclipse is available at download.eclipse.org/eclipse/downloads and the CDT can be found at www.eclipse.org/cdt Remember to install the Platform Runtime Binary. You may try Eclipse IDE for C/C++ Developers, which includes the CDT, but this version is not covered here. Also the eclipse package of Ubuntu doesn't work.

Installation details can be found in the documents that come with the specific product.

Configuring Nut/OS

When using the latest YAGARTO distribution, you must be aware of a significant change. While earlier releases used arm-elf-gcc, YAGARTO is now using arm-none-eabi-gcc. While Nut/OS 4.10 should work with this environment out of the box, Nut/OS 4.9 has been prepared to make this switch easy. Open the file nut/Makevars.arm-gcc with your text editor. Locate the line 

#TRGT = arm-none-eabi-

and remove the leading numero sign: 

TRGT = arm-none-eabi-

Save your changes.

In order to include debugging information in the compiled binaries you need to switch from arm-gcc to arm-gccdbg. When done, rebuild Nut/OS and recreate the application directory. The following steps will give detailed instructions.

The screenshots were taken while running the wxWidgets version of the Nut/OS Configurator. In Nut/OS 4.10, this tool had been replaced by Qt based version. Thus, the images will slightly differ from your screen output.

When started for the first time, the Nut/OS Configurator will display a file selection dialog. If this is hidden by the splash window, simply click on that window to close it.


Select the file eir10c.cfg and click on Open.


The Configurators main window will show the Nut/OS Components in a tree structure on the right side.


From the Edit menu select Settings....


Nothing needs to be changed on the Repository page of the settings dialog. You may check Enable multiple configurations if you are concurrently working with different target boards.


Select arm-gccdbg as the platform on the Build page.


On the Tools page you need to enter the path to all required tools, separated by semicolons. For the EIR board this should point to the Nut/OS win32 tools directory and the YAGARTO bin directory. While all other settings use normal slashes in paths, here we must use backslashes. If you are using Linux and the compiler is in a standard path, you don't need to insert a path here.


On the last page titled Samples you may select arm-oocd as the programmer of choice, but this is only required for programming the flash memory, not for debugging in RAM.


Before building the system, change the Linker Script in the components tree under Tools/GCC Settings to at91sam7se512_ram.


We are using YAGARTO with Newlib 1.19. Make sure that Posix compatible unsetenv is checked under C runtime (target specific)/Environment.


Under Linux you may need to disable Non-DSDL Code/RealNetworks RPSL/RCSL.


Nut/OS 4.9.10 contains 2 bugs, which let debugging in RAM fail for AT91SAM7SE targets. The first one is with the linker script at91sam7se512_ram.ld in directory nut\arch\arm\ldscripts. You can use a simple text editor like Notepad to fix this.

Near the beginning of the file remove the line . 

rom(rx)  : org = 0x00000000, len = 496k

and change the value 0x00200000 in line 

iram(rw) : org = 0x00200000, len = 32k

to 0x00000000, resulting in 

iram(rw) : org = 0x00000000, len = 32k

Somewhere in the middle you will find the line 

.data : AT (__etext)

which needs to be replaced by 

.data :

The second bug is in the file crtat91sam7se512_ram.S in directory nut\arch\arm\init. Again use your favorite text editor to remove the following part: 

/*
 * Remapping memory, SRAM to 0x00000000
 */
ldr     r1, =MC_BASE
mov     r0, #01
str     r0, [r1, #MC_RCR_OFF]

/*
 * Use 2 cycles for flash access.
 */
ldr     r1, =MC_BASE
mov     r0, #MC_FWS_2R3W
str     r0, [r1, #MC_FMR_OFF]

Then remove all lines starting from 

/*
 * The watchdog is enabled after processor reset. Disable it.
 */
ldr     r1, =WDT_BASE
ldr     r0, =WDT_WDDIS
str     r0, [r1, #WDT_MR_OFF] :

up to and including 

        /*
         * Switch to PLL clock.
         */
        ldr     r0, [r1, #PMC_MCKR_OFF]
        orr     r0, r0, #PMC_CSS_PLL_CLK
        str     r0, [r1, #PMC_MCKR_OFF]
wait_pllsel:
        ldr     r0, [r1, #PMC_SR_OFF]
        tst     r0, #PMC_MCKRDY
        beq     wait_pllsel

Finally remove this part: 

        /*
         * Relocate .data section (Copy from ROM to RAM).
         */
        ldr     r1, =__etext
        ldr     r2, =__data_start
        ldr     r3, =__data_end

_41:
        cmp     r2, r3
        ldrlo   r0, [r1], #4
        strlo   r0, [r2], #4
        blo     _41

Save your changes.


Now we are ready to build Nut/OS for debugging. Select Build Nut/OS in the Build menu.


A message box shows the settings for creating the build directory. Verify them and click OK to build this directory.


A second message box shows the settings for building the system. Again verify them and click OK.


The build may take a few minutes.


When done, make sure that it has been terminated successfully.


Nut/OS uses a separate directory for the application code. A template can be created by selecting Create Sample Directory, containing all Nut/OS samples that are included in the distribution. Remember, that we will use the events sample.


When runnign the wxWidget based Configurator, a message box will show the current settings. Click OK, if everything looks as expected.


When done, you may exit the Configurator by selecting Exit in the File menu.


Because we changed at least the linker script, the Configurator asks, whether to save these changes. In order to preserve the original settings, you may simply click No. Alternatively you can select Yes and choose a different filename like eir10c-debug.cfg in the following file selection dialog.


Configuring Eclipse

It is assumed that you successfully installed Eclipse and the CDT plug-in. For a first demonstration we will use the events sample that is included in the Nut/OS distribution.

When started, Eclipse will ask for the Workspace Path. Choose the Nut/OS sample directory, e.g. C:\Ethernut-4.10\nutapp or ~/ethernut-4.9.10/nutapp under Linux.


The welcome page appears. Click on Workbench in the upper right corner.


The so called Java Perspective appears. We will later change to the C Perspective.


In the File menu select New and Project....


In the New Project dialog choose C Project and click on Next.


In the C Project dialog enter events for the project name. Then choose Empty Project and -- Other Toolchain --. Again click on Next.


On the next page click on Advanced settings....


In the Project Properties page select Settings and check GNU Elf Parser. Then click on OK.


Back in the C Project dialog click Finish.


Click Yes to open the C/C++ perspective.


We do not need the Java Perspective, therefore you should close it.


Uncheck Build Automatically in the Project menu.


In the same menu select Properties.


In the Properties dialog select Environment in the tree on the right. Then click Add.


The variable Name must be PATH. You need to enter the path to all required tools as the Value, separated by semicolons. The first path should point to the Nut/OS win32 tools directory and the second one to the YAGARTO bin directory.


Click OK to store the updated Environment.


Then, in the same menu, select Build Project.


Building this simple application requires a few seconds only.


When done, the newly created files appear in the Project Explorer. The file events.elf contains the executable binary including all debug information.


Debugging the Application

Click on the Open Perspective button and select Debug. This will open the Debug Perspective.


Click on the tiny arrow near the bug in the toolbar to open the related menu. Then select Debug Configuration....


In the Debug Configurations dialog select GDB Hardware Debugging and click on the New button.


Enter EIR Debugging as the configuration name and events as the project name. Next click on Search Project....


Select events.elf and click OK.


Back in the Debug Configurations dialog click on Select other.


Choose Standard GDB Hardware Debugging Launcher as the preferred launcher and click OK.


Back in the Debug Configurations dialog click on the Debugger tab and enter arm-none-eabi-gdb in GDB Command. Although we will use remote target debugging, Use remote target must be unchecked here.


Now click on the Startup tab. Set breakpoint at and Resume must be checked. Enter NutInit as the breakpoint target.

Then copy and paste the following commands into the field Initialization Commands. 

target remote localhost:3333
monitor jtag_khz 30
monitor reset
monitor sleep 500
monitor poll
monitor soft_reset_halt
monitor gdb_breakpoint_override soft
monitor mww 0xfffff130 0xffffffff
monitor mww 0xfffff124 0xffffffff
monitor mww 0xfffffd44 0x00008000
monitor mww 0xffffff00 0x00000001
monitor mww 0xFFFFFC20 0x00000601
monitor sleep 10
monitor mww 0xFFFFFC2C 0x00481c0e
monitor sleep 10
monitor mww 0xFFFFFC30 0x00000004
monitor sleep 10
monitor mww 0xFFFFFC30 0x00000007
monitor sleep 10
monitor mww 0xfffff474 0x3f800000
monitor mww 0xfffff404 0x3f800000
monitor mww 0xfffff674 0x0003effd
monitor mww 0xfffff604 0x0003effd
monitor mww 0xfffff870 0x0000ffff
monitor mww 0xfffff804 0x0000ffff
monitor mww 0xffffff80 0x00000002
monitor mww 0xffffffb8 0x2192215a
monitor sleep 10
monitor mww 0xffffffb0 0x00000011
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000012
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000014
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000014
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000014
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000014
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000014
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000014
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000014
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000014
monitor mww 0x20000000 0x00000000
monitor mww 0xffffffb0 0x00000013
monitor mww 0x20000014 0xcafedede
monitor mww 0xffffffb4 0x00000013
monitor mww 0xffffffb0 0x00000010
monitor mww 0x20000000 0x00000180
monitor jtag_khz 12000
set mem inaccessible-by-default off

Finally click Apply to store the settings and Close to close the dialog.


Once again click on the tiny arrow near the bug to open the menu and select Organize Favorites....


Click Add.


Check EIR Debugging and click OK.


In the previous dialog click OK again.


We will now setup the hardware, using the following steps:

If the Turtelizer is used for the first time, it will be required to install the FTDI driver. For more details please refer to the Turtelizer's documentation.


Next we will start OpenOCD. We could do this within Eclipse, but for the first time it makes sense to start it manually to check the output in case of problems.

Now open a command line and change to directory C:\Ethernut-4.10\nut\tools\turtelizer2. Add the Nut/OS tools directory for Windows to your path, using the following command 

set PATH=C:\ethernut-4.10\nut\tools\win32;%PATH%

Yout don't need to set the path under Linux. Then start OpenOCD using 

openocd -f board/eir.cfg -f interface/turtelizer2.cfg

The events sample will create some output on the RS-232. To make it visible, we start a terminal emulator. On Windows PCs we could use HyperTerminal, but TeraTerm is the preferred one. After TeraTerm started, select Serial port... from the Setup menu.


Select the COM port to which the Ethernut board is connected. Configure the port to 8 data bits, no parity, 1 stop bit and no flow control and click on OK.


Under Linux you can use the following command on a terminal to start minicom: 

minicom -D /dev/ttyUSB0 -b 115200

You need to replace /dev/ttyUSB0 with the correct device.


Let's get back to Eclipse. Remember that we specified a breakpoint at NutInit in the debugger configuration. For some unknown reason the debugger fails, if this is not defined. However, the function NutInit is located in the initialization of Nut/OS, while you will be mostly interested in debugging your application code.

Lets specify a second breakpoint at the beginning of the application code, which is the function main. Click on the tab C/C++ in the upper right corner to change to the C Perspective.

In the Project Explorer double click on the events folder to expand it. Then click on the tiny arrow in front of events.c to expand this part of the tree. Note, that this arrow will appear only when moving the mouse over the Project Explorer window.

Now double click on main(void) to open the source file at this location.


At the first line click with the right mouse button on blue border to open the context menu. Select Toggle Breakpoint.


Switch back to the debug perspective by clicking on the tab Debug in the upper right corner. Click on the bug button in the toolbar to start debugging.


The code will be downloaded to the target and started. Then it stops at the first breakpoint at the beginning of NutInit. Press F8 or click the Resume button .


The target code will run up to the next breakpoint in main. You can now press F5 or click the button to step execute a single line, F6 or click the button to step over a function call.


Now continue pressing F6 until we stepped over the first puts() function call.


When this statement has been executed, the text Nut/OS Event Queue Demo should appear in the terminal emulator window.


As you continue stepping through the main loop...


...additional output appears on the serial port.


You may set additional breakpoints, evaluate variables or memory areas and do many other useful things during debugging. Please refer to the Eclipse documentation for further details.

Under Linux an Error occures in the output of openocd, when debugging: 

Error: address + size wrapped(0xfffffffe, 0x00000004)