0.10
Eclipse Development Environment Setup

Integration with Eclipse simplifies the compilation, remote execution and remote debugging of EGT applications using Buildroot

The typical usage model of our EGT integration with Eclipse would be:

  1. Creating the buildroot system for a particular target board to execute or debug EGT applications or libraries. This involves configure your buildroot system, enable EGT package with their dependencies and Build the buildroot system. Refer section Cross Compiling With Buildroot
  2. Once Buildroot compilation is done. The output/image folder contains all the files to boot Linux on to the target board. To create a sdcard image to boot Linux on to sam9x60EK board refer create sdcard image.
  3. Start Eclipse to develop, execute or debug your own custom EGT applications/libraries, that will rely on EGT library built and installed by Buildroot.

This tutorial will guide you through the installation, usage of Eclipse for developing EGT application using Buildroot.

Eclipse Installation

At the current time, the latest stable version of Eclipse is called 2019-06. Most Linux distributions come either with an Eclipse package or allow it to be easily installed by the package manager in the distribution. However, note that this is frequently an out of date version. You can get hold of the latest version from the central download site at http://www.eclipse.org As an IDE, Eclipse supports many different programming languages including Java, C, C++, Python, and many others. At installation time you need to select the version to support the package(s) that you want. To make this easier there is an installation tool which will guide you through the steps.

eclipse_install.png
Eclipse installer
Download Eclipse IDE for C/C++ Developers and follow below steps for installation.

See also
https://www.eclipse.org/downloads/packages/

Extract the eclipse-cpp-2019-06-R-linux-gtk-x86_64.tar.gz to folder /opt

sudo tar -zxvf eclipse-cpp-2019-06-R-linux-gtk-x86_64.tar.gz -C /opt
sudo chown -R root:root /opt/eclipse

Create a desktop file and install it:

gedit eclipse.desktop

copy below lines to the eclipse.desktop file

[Desktop Entry]
Name=Eclipse
Type=Application
Exec=/opt/eclipse/eclipse
Terminal=false
Icon=eclipse
Comment=Integrated Development Environment
NoDisplay=false
Categories=Development;IDE;
Name[en]=Eclipse

Set a executable permission and execute following command to install it:

sudo desktop-file-install eclipse.desktop

Create a symlink in /usr/local/bin

sudo ln -s /opt/eclipse/eclipse /usr/local/bin/eclipse

For eclipse icon to be displayed in dash, eclipse icon can be added as

sudo cp /opt/eclipse/icon.xpm /usr/share/pixmaps/eclipse.xpm

Eclipse needs to have either OpenJDK or Sun Java installed to be able to run eclipse and here is a simple example of installing Open JDK 1.8:

sudo apt install openjdk-8-jdk

With Eclipse installed in /opt folder and it can now be accessed by any users.

Start Eclipse and Create EGT project

Start Eclipse from the Ubuntu Applications tray and you will be asked where to place your workspace directory. By default, the location will be under users home directory. i.e. /home/<user>/eclipse-workspace.

eclipse_workspace.png
Eclipse workspace
With the workspace set and clicking launch, Eclipse will start with a startup screen.

eclipse_startup_screen.png
Eclipse startup screen
Now we create a new EGT project that will use a toolchain generated by Buildroot. In the below example we create an EGT project using autotool and it is up to the developer to write the configure.ac file and Makefile.am. This allows the project to be built outside of Eclipse and to use standard Unix tools as your project build system. For more info on autotools, refer GNU Autotools

Click on Create a new C/C++ Project and Select "C++ Managed Build" in New C/C++ Project window then click Next

eclipse_new_c_cpp_project.png
Select C++ Managed Build
In Create C/C++ Project window:

  1. Set the project name,
  2. In Project type, Expand GNU Autotools and Select Empty project.
  3. In Toolchains, Select GNU Autotools Toolchain
  4. Click on Next.

eclipse_cpp_project.png
Create C++ Project
To cross-compile this Project using Buildroot toolchain. we need to set few environments variables and this can be done clicking Advance Setting in Select Configurations window.

eclipse_cpp_project_select_configurations.png
C++ Project Select Configurations
In the Properties window, Expand Autotools and select configure settings. Under Configure Settings, select platform specifiers and set "Host platform (--host)" to "arm-buildroot-linux-gnueabi"

eclipse_cpp_project_properties_autotools_configue.png
C++ Project Properties Autotools
Now select Environment Variables and click New. Under New Environment Variable window set buildroot toolchain path and Click OK.

  1. Name: PATH
  2. Value: buildroot/output/host/bin:$PATH

eclipse_cpp_project_properties_autotools_env.png
C++ Project Properties Autotools Environment
To enable debug options, Select Advance and check Debug(-g) option and then click Apply.

eclipse_cpp_project_properties_autotools_advance.png
C++ Project Properties Autotools Advance
Now expand the C/C++ Build. Select Environment and click Add. In New Variable window set buildroot toolchain path with below details. click OK & "Apply and Close" an then Finish.

  1. Name: PATH
  2. Value: buildroot/output/host/bin:$PATH
  3. Check Add to all configurations

eclipse_cpp_project_properties_build_env.png
C++ Project Properties Build Environment
Create source files in the Project by right Clicking on Project name and Select New -> Source File.

eclipse_new_source_file.png
New C++ Source file
In New Source File window, set File name basic.cpp & Click Finish

eclipse_set_filename.png
Enter filename
copy below lines to basic.cpp file

#include <egt/ui>
int main()
{
egt::Application app;
egt::TopWindow window;
egt::Button button(window, "Press Me");
egt::center(button);
window.show();
return app.run();
}

eclipse_new_cpp.png
Create cpp file
Similarly create a new configure.ac file and copy below lines.

AC_PREREQ(2.59)
AC_INIT(basic, 1.0)
AC_PROG_CXX
AM_INIT_AUTOMAKE([1.10 foreign])
PKG_CHECK_MODULES(EGT, [libegt])
AC_SUBST(EGT_LIBS)
AC_SUBST(EGT_CFLAGS)
AC_CONFIG_FILES([Makefile])
AC_OUTPUT

eclipse_new_configure.png
Create configure.ac file
Now create a new Makefile.am file and copy below lines.

bin_PROGRAMS=basic
basic_SOURCES=basic.cpp
basic_CPPFLAGS = $(EGT_CFLAGS)
basic_LDFLAGS = $(EGT_LIBS) -lpthread

eclipse_new_Makefile_am.png
Create Makefile.am file
save all using file->saveall or press (shift + Ctrl + S)

To Build this Project, first Invoke Autoreconf tool by right-click on the project and select Invoke Autotools->Invoke Autoreconf. This operation will call the autotools to generate configure script & Makefile.in files. This operation has to be done again if you make changes to configure.ac or Makefile.am.

eclipse_invoke_autoreconf.png
Invoke autoreconf
Set the "-i -v -f" option to autoreconf window and click OK. This tells autoreconf to automatically install some additional scripts and files that are needed for correct operation of configure script.

eclipse_autoreconf_args.png
Set autoreconf arguments
Now we can see in the console that autoreconf command finished successfully and configure and Makefile.in files have generated in the project folder.

eclipse_autoreconf_success.png
Autoreconf success
Now Reconfigure project by right-click on the project and select Reconfigure Project. This will call configure script with argument –host option & set Environment variable values to ensures that your project will be cross-compiled with the Buildroot toolchain. You may define additional options in project properties.

eclipse_reconfigure_project.png
Reconfigure project
In the console, we can see operation finished successfully and Makefile generated in the Project folder.

eclipse_reconfigure_success.png
Reconfigure project finished
Finally to build this project. Select Project-> "Build All" or Press (Ctrl-b).

eclipse_build_success.png
Build project

Executing EGT application on Target Remotely

Eclipse will execute a EGT application on to target board by transfer the application binary using SSH and SSH server must have installed on target board.

Buildroot offers you two choices:

  1. The Dropbear package can be enabled in Networking applications -> dropbear.
  2. The full-blown SSH implementation, OpenSSH, which can be enabled in Networking applications -> openssh.

Most SSH servers do not allow log in as root with an empty password. To set the root password login on the target board, type below commands:

# passwd
Changing password for root
New password:
Bad password: too short
Retype password:
Password for root changed by root

Type below commands to configure Ethernet interface and make sure host machine and target board are connected.

# ifconfig eth0 192.168.1.12 up

First step is to create a new run configuration. Right click your EGT project and click on Run As->Run Configurations...

eclipse_run_as.png
Run as
Double click on "C/C++ Remote Application" to create a Run configurations for a target board.

eclipse_run_create_new.png
New launch configuration
To setup a ssh connection with the target, click “New” under connection. select SSH and click on Okay.

eclipse_run_ssh_conn.png
SSH connection setup
In New Connection window, Set the below details and click Finish.

  1. Connection Name: Remote Host
  2. Host: IP Address of a target board.
  3. User: root
  4. Check public key based authentication.
  5. passphrase: root password of target board.

eclipse_run_conn_finish.png
Finish launch configuration
Set the Remote Absolute File Path to /root/basic and click Run.

Wait while application is copied to the target using SSH protocols.

eclipse_run_wait.png
Coping application to target
Finally in the Console, see the traces and EGT application running on target board.

Debug EGT Application Remotely

As a preliminary step, you also need to ensure that gdbserver is present on your target. if gdbserver not preset, then enable following options in buildroot menuconfig:

  1. Toolchain -> GDB debugger Version
  2. Toolchain -> Build cross gdb for the host
  3. Target packages -> Debugging, profiling and benchmark -> gdb
  4. Target packages -> Debugging, profiling and benchmark -> gdbserver
  5. Target packages -> Debugging, profiling and benchmark -> full debugger

To get a nice debugging experience, you may want Buildroot to build the libraries with debugging symbols. To do so, enable the Build options -> build packages with debugging symbols option.

Create remote debug configuration

The create remote debug configuration will connect to the target board and it will automatically download the compiled binary, start a gdb-server session and connect to it from within the Eclipse IDE.

Create remote debug configuration by right click on Project and select "Debug As" -> "Debug Configurations…"

eclipse_debug_configuration.png
Select Debug Configurations
In the Debug Configurations window, Double Click "C/C++ Remote Application"

eclipse_debug_remote_app.png
Select C/C++ Remote Application
To set up the remote debugging connection. Select New under Connection and Choose a connection type of SSH and configure the New Connection as follows:

eclipse_run_conn_finish.png
setup SSH Connection
Set Remote Absolute File Path to /root/basic.

To configure the gdb connection over ssh. Go to Debugger tab and in the Debugger tab, the GDB debugger: gdb setting currently points to the default debugger on the host system. This is a x86_64 debugger and it does not understand the symbols and messages from the gdb-server on the target. You must change this to point to the ARM specific gdb that is created by Buildroot, change it to:

<buildroot>/output/host/bin/arm-buildroot-linux-gnueabi-gdb

To prevent some spurious SIGNALS and to help the GDB debugger we have provided an initialization script. Create a gdbinit file in your project folder and copy below line and Set gdbinit file path to GDB command file:

handle SIGILL nostop
set sysroot buildroot/output/target

eclipse_debug_debugger_tab.png
setup GDB Debugger
click on Apply and Debug button.

Now Eclipse you should be able to select the new Debug Configuration and if a pop up appears, then clicking on Yes in confirm perspective switch window. If you get a authentication Message dialog box. Select Yes to accept it or else Eclipse will change to the debug perspective and the application will halt at main(). Press Resume (F8) to continue execution and the application should to running the target. You can view variables & disassembly code.

Enjoying the enhanced debug experience.

eclipse_debug_window.png
Eclipse debug window

Build libegt on Host Machine

This sections describes how to build a standalone EGT library and its examples on host machine in Eclipse using Autotools. To fetch the Source from Git repository refer section Fetching Source

Create a new CPP Project using File-> New -> Project. In New Project window, Expand C/C++ and Select C/C++ Project then Click Next

eclipse_new_cpp_project.png
Create new cpp project
In the New C/C++ Project window, Select C++ Managed Builds and Click Next.

eclipse_new_cpp_project_template.png
Select C++ Managed Builds
In C++ Project window,

  1. Set the project name.
  2. Uncheck default location
  3. Browse to git clone location of a EGT directory
  4. Select "GNU Autotools Empty project" type
  5. Select "GNU Autotools Toolchain" and Click on Finish button.

eclipse_host_create_cpp_project.png
Eclipse create new cpp project
Now we can see in the console Tab:

  1. The autoreconf command finished successfully and generated configure and Makefile.in files in Project folder.
  2. Executed a configure scripts and generated Makefile's in the project folder

eclipse_host_reconfigure_done.png
Eclipse reconfigure done
To build the libegt project (Ctrl-b) or select Project->"build all" option and observe build messages in Console.

eclipse_host_buildall.png
Eclipse build libegt project

Execute EGT application on Host Machine.

Before we start execute/debug a application, we need to set environment variable LD_LIBRARY_PATH pointing to libegt.so folder (i.e. src/.libs/)

Go to Project properties by right clicking project and select Properties or Press (Alt + Enter). In Project properties window, Expand "C/C++ Build" and Select "Environment" and then Click ADD.

eclipse_host_env.png
Add Project Environment Variables
In a New Environment variable window set below details and click OK and again OK to close the Project properties window.

  1. Name: LD_LIBRARY_PATH
  2. PATH: project/src/.libs/:$LD_LIBRARY_PATH.
  3. check Add to all Configurations.

eclipse_host_set_env.png
Eclipse set environment variable
We can start executing EGT examples application by right Clicking on libegt Project and Select Run As -> "2.Local C/C++ Application".

eclipse_host_Run_as.png
Select Local C/C++ Application
In "C Local Application" window, Select basic under Binaries and click OK.

eclipse_host_select_application.png
Select basic Application under Binaries
A new EGT window will pop up running EGT Basic example application.

eclipse_host_basic_example.png
Eclipse basic example demo

Debug EGT application on Host Machine

To debug EGT example applications, right Click on libegt Project and Select "Debug As" -> "2.Local C/C++ Application"

eclipse_host_debug_as.png
Select Local C/C++ Application
In "C Local Application" window, Select basic under Binaries and click OK.

eclipse_host_select_application.png
Select basic Application under Binaries

Eclipse will switch automatically to Debug perspective window and debugger stops on the main function of the application and you can see disassembly code. Press Resume (F8) to continue execution and the application should to running the Host Machine.

eclipse_host_debug_window.png
Eclipse debug window