Using the EMAC OE SDK Projects with Eclipse
The EMAC OE SDK is distributed with a set of example projects intended to demonstrate how to use the EMAC OE toolchain and libraries. This guide demonstrates the process of compiling one of the example projects and running it on the target machine using the Eclipse IDE. A basic familiarity with Eclipse is assumed for this guide. For a quick intro, see the First Time Starting EMAC Eclipse.This guide uses the hello EMAC OE SDK example project. It consists of a C file and Makefile.
Contents
Tools Required
- GNU make
- EMAC OE SDK
- wput
NOTE The required tools are preinstalled on the LDC. |
EMAC SDK Example: Compile and Run the hello Project
Setup
- Modify global.properties according to the SDK Remote Upload Setup to provide make with the correct user, password, and IP address for the upload target.
- Create a remote terminal connection. This is necessary to use the Remote System Explorer's SSH Terminal feature in the following procedure.
Building the Project
This procedure provides an overview of how to compile and run C applications for EMAC products in Eclipse. It assumes familiarity with the C programming language and is not intended as a general guide on learning to program.
- Click Window → Open Perspective → Other... To bring up a dialog window with a list of Perspectives to choose from.
- Choose C/C++ and click Ok.[1]
Building With the Eclipse Managed Build System
To build using Eclipse's managed build system, a project needs to be created from the Makefile-based project. To do this, perform the following steps:
- Select File->New->Makefile Project with Existing Code
- In the window that appears (as shown below), click the Browse... button.
Choosing the Project
- Navigate to the location of the project. By default, this is under your home directory in
EMAC-OE-arm-linux-gnueabi-SDK_4.0/projects/hello
- The files listed in the directory will be greyed out, but this is to be expected: Eclipse is just looking for the root directory of the project you are importing. Click the OK button.
- Your Import window should now look similar to this:
Import "Hello" Project
Click the Finish button.You should now see the following in your Project Explorer:
Project Explorer after importing "Hello" project.
The arrowhead to the left of hello indicates that the hello project is open. Click on the arrowhead to see the files in the project. Double click on the hello.c
file to open it. Note: This step is not necessary for building the project. Notice the arrowhead which appeared next to hello.c
. This indicates that the file is now open.
To build the project, ensure the project is highlighted in the Project Explorer treeview in the left pane, then select Project->Build Project. The project will now build, and your window should appear similar to the screenshot below:
If there are any build errors, they will be shown in the Console and/or Problems tabs on the bottom.
EMAC SDK with Qt Example: Compile and Run the textedit
Project
Importing the Project
This procedure provides an overview of how to compile and run Qt C++ applications for EMAC products in Eclipse. It assumes familiarity with the C++ programming language and is not intended as a general guide on learning to program, learning C++, or learning Qt.
- Click Window → Open Perspective → Other... To bring up a dialog window with a list of Perspectives to choose from.
- Choose Qt C++ and click Ok.
Building With the Eclipse Managed Build System
To build using Eclipse's managed build system, the project needs to be imported using its .pro project file. To do this, perform the following steps:
**NOTE**: The first project which must be imported and built is the shared project. The rest of the examples in the projects/qt_demos directory depend on the shared project. Once it has been built, it is safe to close the project and/or remove the project from Eclipse (just be sure to not remove it from disk). |
- In the Project Explorer treeview control on the left side of the screen, make sure nothing is selected (click in a blank area, if necessary), put the mouse cursor in a blank area and right click. From the context menu which appears, select, Import...
Importing a project into Eclipse - In the window that appears (as shown below), make sure Qt Project is selected from the Qt entry in the treeview.
- Click Next >, then click the Browse... button and navigate to the
projects/qt_demos/textedit
directory underneath the install location of your EMAC OE Qt SDK.
- Highlight the .pro file, as shown above, and click OK.
- Click Finish.
Building the Project
You should now see the following in your Project Explorer:
The arrowhead to the left of textedit indicates that the textedit project is open. Click on the arrowhead to see the files in the project. Double click on the textedit.cpp
file to open it. Note: This step is not necessary for building the project. Notice the arrowhead which appears next to textedit.cpp
. This can be used to see a list of classes and functions available within this source file.
To build the project, ensure the project is highlighted in the Project Explorer treeview in the left pane, then select Project→Run qmake. Now, select Project→Build Project. The project will now build, and your window should appear similar to the screenshot below:
If there are any build errors, they will be shown in the Console and/or Problems tabs on the bottom.
Building With Make Targets
- Select the Make Targets View.
- Expand EMAC-OE-arm-linux-gnueabi-SDK_4.0 → projects → hello.[2]
- Cross-compile the program:
Click on the project you're building in the left pane to ensure it is highlighted in blue. The result is shown in Figure 1 below. Now click on Project→Build Project.
Figure 1
Figure 1: Build Project
The project to be built must be hilighted in the left pane, as shown in Figure 1, before you click Project→Build Project to compile the hello example project (this is true any time you build a project). Build Project will perform an incremental build of the currently selected project. Choosing Project→Clean... before choosing Project→Build Project will perform a full rebuild of the project. The method used to determine what to build during an incremental build can be found here: GNU 'make' Manual.
Note 1: If you have the Qt SDK, you will need to choose Qt C++ instead to work with Qt projects. For this first example, though, the C/C++ perspective is the correct one to use with the example program demonstrated here. |
Note 2: If you are unable to expand EMAC-OE-arm-linux-gnueabi-SDK_4.0, right-click on it and choose, Open Project. This should then cause an arrowhead to appear to the left of EMAC-OE-arm-linux-gnueabi-SDK_4.0. Click the arrowhead to expand it. This feature allows you to only keep the project you're currently working on open so that metadata for all your projects is not allocated in RAM. To close a project you're not actively working on, right click on the project and click, Close Project. More conveniently, to close all projects other than the one you are currently working on, right-click on your current project, and click, Close Unrelated Projects. |
Uploading the Project to the Target Machine
In order to use the make target for uploading the code to the target machine (your board from EMAC), you could run the following command in a shell:[3]
make upload
In fact, this is what Eclipse will execute for you in order to perform this step.In order to tell Eclipse how to do this, we first need to create a make target for the upload
make target. To do so, perform the following steps:
- Right click on the project name in the left pane (hello in this example), and choose Make Targets→Build... (or just press <Shift>-<F9> while the project is highlighted in blue). This will bring up the window shown in Figure 2:
Make targets
Figure 2: Make Targets - Check to see if there is an upload target in the list shown. If so, skip the next step.
- If there is no
upload
target, click the Add... button located in the upper right corner of the window shown in Figure 2. The window shown in Figure 3 will appear.
Create make target
Figure 3: Create Make Target
Fill in the wordupload
for Target name, and Eclipse will automatically setupload
to the name of the make target. Ensure the information in your Create Make Target corresponds to that shown in Figure 3, and click Ok. - To upload the executable to the target machine, click on the upload target in the Make Targets window as shown in Figure 4.
Make target upload
Figure 4:upload
selected in Make Targets
Once you have selected theupload
target, click build. The binary executable should be uploaded to the target machine. If there is an error, check to ensure you have thewput
command installed, and that it can be called from within the Eclipse IDE (to ensure thePATH
used by Eclipse contains the directory wherewput
is located). See local to see how to get a shell within the Eclipse environment which can be used to check for thewput
command by typingwput -h
. Ifwput
can be found within thePATH
being used by Eclipse, you will see help information on how to use the command. Otherwise,wput
is either not installed or not in thePATH
.[4] Assumingwput
is installed and can be found in thePATH
, the Makefile will use variables stored in theglobal.properties
file to callwput
to upload the binary executable to the target machine. Theglobal.properties
file is included in the Makefile using theinclude
keyword. This include statement is automatically placed into the Makefile by the Eclipse build system. Theglobal.properties
file also contains variables whichmake
passes to the compiler to ensure that the executable produced is compatible with the target CPU architecture. - Now Connect to the target machine.
- Run the program as shown in Figure 5 using the remote terminal created in the Remote Terminal Setup Guide.
Figure 5: Running the Remote Application
The following is a brief description of each command seen in the SSH Terminal window above:cd /tmp
: Change the current working directory to/tmp/
.ls -l
: List the current working directory's contents with file permissions shown. Notice that root does not have execute permissions for the filehello
.chmod u+x hello
: Give executable permissions to the owner of thehello
file. Note that this assumes that the same user is used to log in through the SSH Terminal as was specified in global.properties according to Step 1 of the Setup for this guide--in this example, the user isroot
.ls -l
: List the current working directory's contents with file permissions shown to be sure that root now has execute permission. The newx
indicates thatroot
does now have execute permissions../hello
: Execute the binary. The output shown is a simple message printed to the screen, "Hello EMAC OE!".
To learn more about what each of the above commands can do, while in a shell, type man followed by the name of the command of interest. For example, you can type: man ls
ls is in fact a far more sophisticated tool than the dir command you may already know. Use q to quit the manual page viewer and return to the shell.While viewing a manpage (manpage is a typical abbreviation for manual page), try pressing the h key. This will show you a great deal of information about how to use the manual page viewer to its fullest potential. To return to the manual page, press the q key to quit viewing the manpage viewer's help page.When in doubt while using Linux shell tools, keep one thing in mind: methods for accomplishing things in various shell programs tend to be very consistent. Not many tools break away from convention, so when you learn one command, you're usually learning things you can do with many other Linux shell commands as well. |
If you want to make modifications to the Example C File and recompile it, follow the same procedure as above to test it again. With a few iterations of this the process will become familiar and easy.
Example C File
This C file can be used by programmers as an example to ensure their build system for EMAC products is functioning correctly. It is included in the EMAC OE SDK Example Project Guide.
Example Makefile
The EMAC OE SDK Example Project Guide shows the default Makefile
file used for the hello
example project. This is a necessary component of the EMAC OE SDK which directs GNU 'Make' in resolving source code dependencies before calling the cross-compiler to create a binary for the target platform. It also provides a convenient upload
target which utilizes the development system's wput
command to send the compiled binary to the target system.If you intend to write your own Makefile
from scratch, EMAC recommends paying close attention to the include paths to learn more about the SDK cross compilation tools.
Next Steps
The next step is to create a new Makefile-based Eclipse project from scratch. This process is similar to the example above, but requires a few extra steps. See the New Project Guide for help on this.
See Also
- Introduction
- Installation
- Configuration
- First Time Starting EMAC Eclipse
- Using the Eclipse Terminal View
- Importing EMAC OE SDK Projects
- Using the EMAC OE SDK Projects
- Creating New Projects
- Remote System Explorer Configuration
- Executing Remote Applications
- Debugging Remote Applications
- ↑ See Note 1
- ↑ See Note 2
- ↑ In Linux, a shell is similar to a Command Prompt on other operating systems
- ↑ See your Linux distribution's documentation to learn how to install the
wput
command (this is Debian Linux if you're using the LDC).
Information about thePATH
environment variable can be found by typingman bash
at a shell prompt, then typing/COMMAND EXECUTION
(in all caps) to search for the relevant section of the Bash manpage.