%poky; ] > If you are familiar with the popular Eclipse IDE, you can use an Eclipse Yocto Plug-in to allow you to develop, deploy, and test your application all from within Eclipse. This chapter describes general workflow using the SDK and Eclipse and how to configure and set up Eclipse. This chapter assumes development of applications on top of an image prepared using the Yocto Project. As such, inclusion of a pre-built image or the building of an image is included in the workflow. The chapter also assumes development on a build host that is set up to use the Yocto Project. Realize that you can easily use Eclipse and the Yocto Project plug-in to develop an application for any number of images developed and tested on different machines.

The following figure and supporting list summarize a general workflow for application development that uses the SDK within the Eclipse IDE. The application developed runs on top of an image created using the Yocto Project. Prepare the Host System for the Yocto Project: Because this example workflow assumes development on a system set up to use the Yocto Project, you need to be sure your build host can use the Yocto Project. See the "Preparing the Build Host" section in the Yocto Project Development Tasks Manual for information on how to set up your build host. Be sure you install the "xterm" package, which is a graphical and Eclipse plug-in extra needed by Eclipse. Secure the Yocto Project Kernel Target Image: This example workflow assumes application development on top of an image built using the Yocto Project. Depending on whether you are using a pre-built image that matches your target architecture or you are using an image you build using the OpenEmbedded Build System and where you are going to run the image while you develop your application (QEMU or real hardware), the area from which you get the image differs. Download the image from machines if your target architecture is supported and you are going to develop and test your application on actual hardware. Download the image from machines/qemu if your target architecture is supported and you are going to develop and test your application using the QEMU Emulator. Build your image if you cannot find a pre-built image that matches your target architecture. If your target architecture is similar to a supported architecture, you can modify the kernel image before you build it. See the "Using devtool to Patch the Kernel" section in the Yocto Project Linux Kernel Development Manual for an example. You can also see the "Making a Suitable Qemux86 Image" wiki for steps needed to build an image suitable for QEMU and for debugging within the Eclipse IDE. Install the SDK: The SDK provides a target-specific cross-development toolchain, the root filesystem, the QEMU emulator, and other tools that can help you develop your application. For information on how to install the SDK, see the "Installing the SDK" section. Secure the Target Root Filesystem and the Cross-Development Toolchain: You need to find and download the appropriate root filesystem and the cross-development toolchain. You can find the tarballs for the root filesystem in the same area used for the kernel image. Depending on the type of image you are running, the root filesystem you need differs. For example, if you are developing an application that runs on an image that supports Sato, you need to get a root filesystem that supports Sato. You can find the cross-development toolchains at toolchains. Be sure to get the correct toolchain for your development host and your target architecture. See the "Locating Pre-Built SDK Installers" section for information and the "Installing the SDK" section for installation information. As an alternative to downloading an SDK, you can build the SDK installer. For information on building the installer, see the "Building an SDK Installer" section. Another helpful resource for building an installer is the "Cookbook guide to Making an Eclipse Debug Capable Image" wiki page. Create and Build Your Application: You need to have source files for your application. Once you have the files, you can use the Eclipse IDE to import them and build the project. Deploy the Image With the Application: Using the Eclipse IDE, you can deploy your image to the hardware or to QEMU through the project's preferences. You can also use Eclipse to load and test your image under QEMU. See the "Using the Quick EMUlator (QEMU)" chapter in the Yocto Project Development Tasks Manual for information on using QEMU. Test and Debug the Application: Once your application is deployed, you need to test it. Within the Eclipse IDE, you can use the debugging environment along with supported performance enhancing Linux Tools.

The Eclipse IDE is a popular development environment and it fully supports development using the Yocto Project. When you install and configure the Eclipse Yocto Project Plug-in into the Eclipse IDE, you maximize your Yocto Project experience. Installing and configuring the Plug-in results in an environment that has extensions specifically designed to let you more easily develop software. These extensions allow for cross-compilation, deployment, and execution of your output into a QEMU emulation session as well as actual target hardware. You can also perform cross-debugging and profiling. The environment also supports performance enhancing tools that allow you to perform remote profiling, tracing, collection of power data, collection of latency data, and collection of performance data. This release of the Yocto Project supports both the Oxygen and Neon versions of the Eclipse IDE. This section provides information on how to use the Oxygen release with the Yocto Project. For information on how to use the Neon version of Eclipse with the Yocto Project, see "Appendix D".

To develop within the Eclipse IDE, you need to do the following: Install the Oxygen version of the Eclipse IDE. Configure the Eclipse IDE. Install the Eclipse Yocto Plug-in. Configure the Eclipse Yocto Plug-in. Do not install Eclipse from your distribution's package repository. Be sure to install Eclipse from the official Eclipse download site as directed in the next section.

Follow these steps to locate, install, and configure Oxygen Eclipse: Locate the Oxygen Download: Open a browser and go to http://www.eclipse.org/oxygen/. Download the Tarball: Click through the "Download" buttons to download the file. Unpack the Tarball: Move to a clean directory and unpack the tarball. Here is an example: $ cd ~ $ tar -xzvf ~/Downloads/eclipse-inst-linux64.tar.gz Everything unpacks into a folder named "eclipse-installer". Launch the Installer: Use the following commands to launch the installer: $ cd ~/eclipse-installer $ ./eclipse-inst Select Your IDE: From the list, select the "Eclipse IDE for C/C++ Developers". Install the Software: Click "Install" to begin the installation. Accept all the certificates and any license agreements. Click "Install" again to finish the installation. Launch Oxygen: Accept the default "workspace" and click the "Launch" button. You should see the Eclipse welcome page from which can click "workbench" to enter your workspace. The executable for Eclipse is located in the eclipse/cpp-oxygen/eclipse folder. To launch Eclipse outside of the installation process, simply execute that binary. Here is an example: $ ~/eclipse/cpp-oxygen/eclipse/eclipse

Follow these steps to configure the Oxygen Eclipse IDE. Depending on how you installed Eclipse and what you have already done, some of the options do not appear. If you cannot find an option as directed by the manual, it has already been installed. If you want to see all options regardless of whether they are installed or not, deselect the "Hide items that are already installed" check box. Be sure Eclipse is running and you are in your workbench. Just click "workbench" if you are not in your default workspace. Select "Install New Software" from the "Help" pull-down menu. Select "Oxygen - http://download.eclipse.org/releases/oxygen" from the "Work with:" pull-down menu. Expand the box next to "Linux Tools" and select the following: C/C++ Remote (Over TCF/TE) Run/Debug Launcher TM Terminal Expand the box next to "Mobile and Device Development" and select the following boxes: C/C++ Remote (Over TCF/TE) Run/Debug Launcher Remote System Explorer User Actions TM Terminal TCF Remote System Explorer add-in TCF Target Explorer Expand the box next to "Programming Languages" and select the following box: C/C++ Development Tools SDK Complete the installation by clicking through appropriate "Next" and "Finish" buttons and then restart the Eclipse IDE.

You can install the Eclipse Yocto Plug-in into the Eclipse IDE one of two ways: use the Yocto Project's Eclipse Update site to install the pre-built plug-in, or build and install the plug-in from the latest source code.

To install the Oxygen Eclipse Yocto Plug-in from the update site, follow these steps: Start up the Eclipse IDE. In Eclipse, select "Install New Software" from the "Help" menu. Click "Add..." in the "Work with:" area. Enter &ECLIPSE_DL_PLUGIN_URL;/oxygen in the URL field and provide a meaningful name in the "Name" field. Click "OK" to have the entry automatically populate the "Work with:" field and to have the items for installation appear in the window below. Check the boxes next to the following: Yocto Project SDK Plug-in Yocto Project Documentation plug-in Complete the remaining software installation steps and then restart the Eclipse IDE to finish the installation of the plug-in. You can click "OK" when prompted about installing software that contains unsigned content.

To install the Oxygen Eclipse Yocto Plug-in from the latest source code, follow these steps: Be sure your build host has JDK version 1.8 or greater. On a Linux build host you can determine the version using the following command: $ java -version Install X11-related packages: $ sudo apt-get install xauth In a new terminal shell, create a Git repository with: $ cd ~ $ git clone git://git.yoctoproject.org/eclipse-yocto Use Git to create the correct tag: $ cd ~/eclipse-yocto $ git checkout -b oxygen/&DISTRO_NAME_NO_CAP; remotes/origin/oxygen/&DISTRO_NAME_NO_CAP; This creates a local tag named oxygen/&DISTRO_NAME_NO_CAP; based on the branch origin/oxygen/&DISTRO_NAME_NO_CAP;. You are put into a detached HEAD state, which is fine since you are only going to be building and not developing. Change to the scripts directory within the Git repository: $ cd scripts Set up the local build environment by running the setup script: $ ./setup.sh When the script finishes execution, it prompts you with instructions on how to run the build.sh script, which is also in the scripts directory of the Git repository created earlier. Run the build.sh script as directed. Be sure to provide the tag name, documentation branch, and a release name. Following is an example: $ ECLIPSE_HOME=/home/scottrif/eclipse-yocto/scripts/eclipse ./build.sh -l oxygen/&DISTRO_NAME_NO_CAP; master yocto-&DISTRO; 2>&1 | tee build.log The previous example command adds the tag you need for oxygen/&DISTRO_NAME_NO_CAP; to HEAD, then tells the build script to use the local (-l) Git checkout for the build. After running the script, the file org.yocto.sdk-release-date-archive.zip is in the current directory. If necessary, start the Eclipse IDE and be sure you are in the Workbench. Select "Install New Software" from the "Help" pull-down menu. Click "Add". Provide anything you want in the "Name" field. Click "Archive" and browse to the ZIP file you built earlier. This ZIP file should not be "unzipped", and must be the *archive.zip file created by running the build.sh script. Click the "OK" button. Check the boxes that appear in the installation window to install the following: Yocto Project SDK Plug-in Yocto Project Documentation plug-in Finish the installation by clicking through the appropriate buttons. You can click "OK" when prompted about installing software that contains unsigned content. Restart the Eclipse IDE if necessary. At this point you should be able to configure the Eclipse Yocto Plug-in as described in the "Configuring the Oxygen Eclipse Yocto Plug-in" section.

Configuring the Oxygen Eclipse Yocto Plug-in involves setting the Cross Compiler options and the Target options. The configurations you choose become the default settings for all projects. You do have opportunities to change them later when you configure the project (see the following section). To start, you need to do the following from within the Eclipse IDE: Choose "Preferences" from the "Window" menu to display the Preferences Dialog. Click "Yocto Project SDK" to display the configuration screen. The following sub-sections describe how to configure the plug-in. Throughout the descriptions, a start-to-finish example for preparing a QEMU image for use with Eclipse is referenced as the "wiki" and is linked to the example on the " Cookbook guide to Making an Eclipse Debug Capable Image" wiki page.

Cross Compiler options enable Eclipse to use your specific cross compiler toolchain. To configure these options, you must select the type of toolchain, point to the toolchain, specify the sysroot location, and select the target architecture. Selecting the Toolchain Type: Choose between "Standalone pre-built toolchain" and "Build system derived toolchain" for Cross Compiler Options. Standalone Pre-built Toolchain: Select this type when you are using a stand-alone cross-toolchain. For example, suppose you are an application developer and do not need to build a target image. Instead, you just want to use an architecture-specific toolchain on an existing kernel and target root filesystem. In other words, you have downloaded and installed a pre-built toolchain for an existing image. Build System Derived Toolchain: Select this type if you built the toolchain as part of the Build Directory. When you select "Build system derived toolchain", you are using the toolchain built and bundled inside the Build Directory. For example, suppose you created a suitable image using the steps in the wiki. In this situation, you would select "Build system derived toolchain". Specify the Toolchain Root Location: If you are using a stand-alone pre-built toolchain, you should be pointing to where it is installed (e.g. /opt/poky/&DISTRO;). See the "Installing the SDK" section for information about how the SDK is installed. If you are using a build system derived toolchain, the path you provide for the "Toolchain Root Location" field is the Build Directory from which you run the bitbake command (e.g /home/scottrif/poky/build). For more information, see the "Building an SDK Installer" section. Specify Sysroot Location: This location is where the root filesystem for the target hardware resides. This location depends on where you separately extracted and installed the target filesystem when you either built it or downloaded it. If you downloaded the root filesystem for the target hardware rather than built it, you must download the sato-sdk image in order to build any c/c++ projects. As an example, suppose you prepared an image using the steps in the wiki. If so, the MY_QEMU_ROOTFS directory is found in the Build Directory and you would browse to and select that directory (e.g. /home/scottrif/poky/build/MY_QEMU_ROOTFS). For more information on how to install the toolchain and on how to extract and install the sysroot filesystem, see the "Building an SDK Installer" section. Select the Target Architecture: The target architecture is the type of hardware you are going to use or emulate. Use the pull-down "Target Architecture" menu to make your selection. The pull-down menu should have the supported architectures. If the architecture you need is not listed in the menu, you will need to build the image. See the "Building a Simple Image" section of the Yocto Project Development Tasks Manual for more information. You can also see the wiki.

You can choose to emulate hardware using the QEMU emulator, or you can choose to run your image on actual hardware. QEMU: Select this option if you will be using the QEMU emulator. If you are using the emulator, you also need to locate the kernel and specify any custom options. If you selected the Build system derived toolchain, the target kernel you built will be located in the Build Directory in tmp/deploy/images/machine directory. As an example, suppose you performed the steps in the wiki. In this case, you specify your Build Directory path followed by the image (e.g. /home/scottrif/poky/build/tmp/deploy/images/qemux86/bzImage-qemux86.bin). If you selected the standalone pre-built toolchain, the pre-built image you downloaded is located in the directory you specified when you downloaded the image. Most custom options are for advanced QEMU users to further customize their QEMU instance. These options are specified between paired angled brackets. Some options must be specified outside the brackets. In particular, the options serial, nographic, and kvm must all be outside the brackets. Use the man qemu command to get help on all the options and their use. The following is an example: serial ‘<-m 256 -full-screen>’ Regardless of the mode, Sysroot is already defined as part of the Cross-Compiler Options configuration in the "Sysroot Location:" field. External HW: Select this option if you will be using actual hardware. Click "Apply and Close" to save your plug-in configurations.

You can create two types of projects: Autotools-based, or Makefile-based. This section describes how to create Autotools-based projects from within the Eclipse IDE. For information on creating Makefile-based projects in a terminal window, see the "Makefile-Based Projects" section. Do not use special characters in project names (e.g. spaces, underscores, etc.). Doing so can cause configuration to fail. To create a project based on a Yocto template and then display the source code, follow these steps: Select "C/C++ Project" from the "File -> New" menu. Select "C Managed Build" from the available options and click "Next". Expand "Yocto Project SDK Autotools Project". Select "Hello World ANSI C Autotools Projects". This is an Autotools-based project based on a Yocto template. Put a name in the "Project name:" field. Do not use hyphens as part of the name (e.g. "hello"). Click "Next". Add appropriate information in the various fields. Click "Finish". If the "open perspective" prompt appears, click "Yes" so that you in the C/C++ perspective. The left-hand navigation pane shows your project. You can display your source by double clicking the project's source file.

The earlier section, "Configuring the Oxygen Eclipse Yocto Plug-in", sets up the default project configurations. You can override these settings for a given project by following these steps: Select "Yocto Project Settings" from the "Project -> Properties" menu. This selection brings up the Yocto Project Settings Dialog and allows you to make changes specific to an individual project. By default, the Cross Compiler Options and Target Options for a project are inherited from settings you provided using the Preferences Dialog as described earlier in the "Configuring the Oxygen Eclipse Yocto Plug-in" section. The Yocto Project Settings Dialog allows you to override those default settings for a given project. Make or verify your configurations for the project and click "Apply and Close". Right-click in the navigation pane and select "Reconfigure Project" from the pop-up menu. This selection reconfigures the project by running Autotools GNU utility programs such as Autoconf, Automake, and so forth in the workspace for your project. Click on the "Console" tab beneath your source code to see the results of reconfiguring your project.

To build the project select "Build All" from the "Project" menu. The console should update and you can note the cross-compiler you are using (i.e. i586-poky-linux-gcc in this example). When building "Yocto Project SDK Autotools" projects, the Eclipse IDE might display error messages for Functions/Symbols/Types that cannot be "resolved", even when the related include file is listed at the project navigator and when the project is able to build. For these cases only, it is recommended to add a new linked folder to the appropriate sysroot. Use these steps to add the linked folder: Select the project. Select "Folder" from the "File -> New" menu. In the "New Folder" Dialog, click the "Advanced" button and then activate "Link to alternate location (linked folder)" button. Click "Browse" to navigate to the include folder inside the same sysroot location selected in the Yocto Project configuration preferences. Click "Finish" to save the linked folder.

To start the QEMU emulator from within Eclipse, follow these steps: See the "Using the Quick EMUlator (QEMU)" chapter in the Yocto Project Development Tasks Manual for more information on using QEMU. Expose and select "External Tools Configurations ..." from the "Run -> External Tools" menu. Locate and select your image in the navigation panel to the left (e.g. qemu_i586-poky-linux). Click "Run" to launch QEMU. The host on which you are running QEMU must have the rpcbind utility running to be able to make RPC calls on a server on that machine. If QEMU does not invoke and you receive error messages involving rpcbind, follow the suggestions to get the service running. As an example, on a new Ubuntu 16.04 LTS installation, you must do the following in a new shell in order to get QEMU to launch: $ sudo apt-get install rpcbind After installing rpcbind, you need to edit the /etc/init.d/rpcbind file to include the following line: OPTIONS="-i -w" After modifying the file, you need to start the service: $ sudo service portmap restart If needed, enter your host root password in the shell window at the prompt. This sets up a Tap 0 connection needed for running in user-space NFS mode. Wait for QEMU to launch. Once QEMU launches, you can begin operating within that environment. One useful task at this point would be to determine the IP Address for the user-space NFS by using the ifconfig command. The IP address of the QEMU machine appears in the xterm window. You can use this address to help you see which particular IP address the instance of QEMU is using.

Once the QEMU emulator is running the image, you can deploy your application using the Eclipse IDE and then use the emulator to perform debugging. Follow these steps to deploy the application. Currently, Eclipse does not support SSH port forwarding. Consequently, if you need to run or debug a remote application using the host display, you must create a tunneling connection from outside Eclipse and keep that connection alive during your work. For example, in a new terminal, run the following: $ ssh -XY user_name@remote_host_ip Using the above form, here is an example: $ ssh -XY root@192.168.7.2 After running the command, add the command to be executed in Eclipse's run configuration before the application as follows: export DISPLAY=:10.0 Be sure to not destroy the connection during your QEMU session (i.e. do not exit out of or close that shell). Select "Debug Configurations..." from the "Run" menu. In the left area, expand "C/C++Remote Application". Locate your project and select it to bring up a new tabbed view in the Debug Configurations Dialog. Click on the "Debugger" tab to see the cross-tool debugger you are using. Be sure to change to the debugger perspective in Eclipse. Click on the "Main" tab. Create a new connection to the QEMU instance by clicking on "new". Select "SSH", which means Secure Socket Shell and then click "OK". Optionally, you can select a TCF connection instead. Clear out the "Connection name" field and enter any name you want for the connection. Put the IP address for the connection in the "Host" field. For QEMU, the default is "192.168.7.2". However, if a previous QEMU session did not exit cleanly, the IP address increments (e.g. "192.168.7.3"). You can find the IP address for the current QEMU session by looking in the xterm that opens when you launch QEMU. Enter "root", which is the default for QEMU, for the "User" field. Be sure to leave the password field empty. Click "Finish" to close the New Connections Dialog. If necessary, use the drop-down menu now in the "Connection" field and pick the IP Address you entered. Assuming you are connecting as the root user, which is the default for QEMU x86-64 SDK images provided by the Yocto Project, in the "Remote Absolute File Path for C/C++ Application" field, browse to /home/root/ProjectName (e.g. /home/root/hello). You could also browse to any other path you have write access to on the target such as /usr/bin. This location is where your application will be located on the QEMU system. If you fail to browse to and specify an appropriate location, QEMU will not understand what to remotely launch. Eclipse is helpful in that it auto fills your application name for you assuming you browsed to a directory. If you are prompted to provide a username and to optionally set a password, be sure you provide "root" as the username and you leave the password field blank. If browsing to a directory fails or times out, but you can ssh into your QEMU or target from the command line and you have proxies set up, it is likely that Eclipse is sending the SSH traffic to a proxy. In this case, either use TCF , or click on "Configure proxy settings" in the connection dialog and add the target IP address to the "bypass proxy" section. You might also need to change "Active Provider" from Native to Manual. Be sure you change to the "Debug" perspective in Eclipse. Click "Debug" Accept the debug perspective.

As mentioned earlier in the manual, performance tools exist (Linuxtools) that enhance your development experience. These tools are aids in developing and debugging applications and images. You can run these tools from within the Eclipse IDE through the "Linuxtools" menu. For information on how to configure and use these tools, see http://www.eclipse.org/linuxtools/.