Using Eclipse for Makefile projects

Recently, on the MCU on Eclipse website, I saw an article written by Erich Styger on the use of makefile to create a project in Eclipse, and the article explains it very well, so no one translates it for your colleagues ' reference. Of course limited to the individual level, there are improper, please correct me. Original URL: https://mcuoneclipse.com/2017/07/22/tutorial-makefile-projects-with-eclipse/

The benefit of Ides like Eclipse is that it makes it easy to work with projects. Because it can not only generate files, but also can get and automatically manage makefile files. But sometimes this may not be what I want because I need greater flexibility and control, or I want to use the same production files for my continuous integration and automated test systems. In this case, you will need to write your own makefile file.

There's one thing that doesn't rule out anything else: This article describes how to use the makefiles in eclipse to be comfortable with the managed build system in eclipse, but with unlimited make files:

Profile

Eclipse comes with a built-in build system (Managed make): I can configure the compiler linker settings, and Eclipse will handle the rest. In this tutorial, I'll show you how to use Eclipse to manually create and use the crafted make files. The recommended make files and templates can be easily used to control the build system. The proposed method requires that each new source file that is added to the project need to extend the make file, instead, to extend the automatic generation of dependent files for all included header files.

The benefits of using make files are:

• Easier to store and track in a version control system than eclipse. cproject Files and Settings
• Complete control of build and production processes
• As part of the build process, this is trivial compared to other steps, such as using a version control system or an automated test system.
• You can use the same build (make) in the IDE and externally (for example, on an automated build system)
• And it's fun to write make files.

The Make file method requires an understanding of the build process, so it is helpful to know what to use with manage make, so I can take it as a base or inspiration.

Pre-conditions

To use the make file in eclipse, I need the following:

• Eclipse IDE. I'm using NXP Mcuxpresso IDE v10.0.2 (based on neon), but any other eclipse release can do the same.
• Use the Make utility to install the GNU tool chain. Usually it comes with a bundled eclipse IDE, or you can use the DIY toolchain.
• The compiler and linker settings for your target device. Use the options in the existing sample project.
• Launch and linker files. Again, you can borrow the existing sample project.
• Apply the source file. I recommend starting with the "empty" main function.

A good way to get the necessary files and options is to look at a sample project that typically uses "manged make".

?? I've put the source of this project on the GitHub on. In the "Links" section at the end of this article, check the links for GitHub projects.

from Eclipse managed by Make

Using a managed production system, Eclipse detects files that exist in the project (for example, *. c) and automatically generates make files:

Generator settings

This generates the make file:

Generate Make File

With the build tool integration, I have a GUI that can set the tool's options:

Manage Build tool settings

All of this information is added to the make file, and if I do a build, it calls the makes utility (or builder) to build it using all the necessary command lines. Check the console view output to see what it does

Console View Output

With this, I should have everything to do a make file project.

Create Make File Project

I created a new make file project in Eclipse, the menu file> new project:

New Project

As with many things in eclipse, there are several ways to do things.

If I have existing code, I can use the ' makefile Project with existing code '. Then I can give a name and the existing Code location (folder). It then creates the project within the code location folder and adds all the source files to the project:

Create a new make file project with existing code

The common approach is to generate a C or C + + project:

The new C + + project

Then give the project a name and select an empty make file project with the supported Toolchain:

Create an empty Makefile project

Then press Next, and then make the remaining dialog boxes based on the selected toolchain. This will create an empty project such as the following:

Empty Makefile Project

Application files

To edit something, add a new source file:

Add a new source file

Name it main.c or whatever you like:

New Main.c File

Then add a main () routine with some code, such as

static int i;

void Main (void) {

for (;;) {

i++;

}

/* Do not leave main () */

}

Makefile file

Next, use the context menu in the project folder "new" > "File":

New file

Create a file named "Makefile" in your project:

Create Make File

This adds an empty make file.

CMSIS , System files and startup

The next step depends heavily on the device you are using. I use the NXP frdm-kl25z board in this example. For the sake of structuring, I created the source directory. The special "Debug" folder will be used to place objects and executable files.

Expanded project structure

Make file Syntax

The next step is to implement the make file content. The general make file is as follows:

All:hello.axf

Clean:

RM MAIN.O HELLO.AXF

hello.axf:main.o

Gcc-g-O Hello main.o

MAIN.O:

Gcc-c-G main.c

Each entry in the make file has the following syntax:

<target>:< Dependencies list >

<tab> the command to execute

?? Please note that each command requires a <TAB> characters!

There are two of all cleaning known as special targets. ' Clean ' is used to delete all temporary files and ' All ' is used to build the application.

Makefile of the content

In makefile, I have defined variables for deleting files, compilers, and linker:

############################

# commands to delete files

rm:= RM-RF

############################

# compiler

cc:= ARM-NONE-EABI-GCC

############################

# linker

ll:= ARM-NONE-EABI-GCC

Then I define a macro for the final executable file:

############################

# Binary/Can be built

exe:= \

./debug/mymakeproject.axf

Next is a list of all the target files. Because the target file will be placed in the ' Debug ' folder, this is part of the name:

############################

# Target File list

objs:= \

./DEBUG/MAIN.O \

./debug/startup_mkl25z4.o \

./debug/system_mkl25z4.o

The next thing is really cool. If main.c contains header files Main.h, I will have to write a rule

MAIN.O:MAIN.C Main.h

$ (CC)-C Main.c-o MAIN.O

But it was very painful: I had to write rules for each file, and I needed to keep track of the header files. Instead, I let the compiler later create a dependent file with a. d extension (for dependency). The dependent file main.d looks like this:

DEBUG/MAIN.O debug/main.d:source/main.c Source/main.h

Source/main.h:

If it is not a "clean" target, I include the file as an additional rule file:

############################

# contains generated dependent files (only dirty targets)

Ifneq ($ (makecmdgoals), clean)

IFNEQ ($ (Strip $ (c_deps)))

-Contains $ (c_deps)

endif

endif

Here is the set of compiler options I can use later:

############################

# Compiler Options

cc_options:=-C-STD = gnu99-o0-g-Functional part-FDATA-SECTIONS-FNO-BUILTIN-MCPU = Cortex-m0plus-mthumb-dcpu_mkl25z128vlk4-d_ _use_cmsis-i "CMSIS"-i "source"

Similarly, the linker's options:

############################

# Linker Options

ll_options:=-nostdlib-xlinker-map = "Debug/mymakeproject.map"-xlinker--gc-sections-xlinker-print-memory-usage- MCPU = Cortex-m0plus-mthumb-t Linksfile.ld-o $ (EXE)

The next goal is to build the application:

############################

#main (All) target

all:$ (EXE)

@echo "***finished building***"

Follow the target to make a "clean":

############################

#clean Target

Clean

-$ (RM) $ (executables) $ (OBJS) $ (EXE)

-$ (RM)./debug/*.map

[Email protected] ‘ ‘

Here are the rules that link the application to all object files:

############################

# Rule to link the executable

$ (EXE): $ (OBJS) $ (USER_OBJS) linkerfile.ld

@echo ' Building target: [email protected] '

@echo ' Invoking:linker '

ARM-NONE-EABI-GCC $ (ll_options) $ (OBJS) $ (LIBS)

@echo ' finished building target: [email protected] '

@echo '

Next, I specify the rules for building the object file. I must specify a rule for each subfolder that you want to use:

############################

# Rule to build the files in the source folder

./DEBUG/%.O:./source/%.c

@echo ' Building file: $< '

$ (CC) $ (cc_options)-MMD-MP-MF "$ (@:%.o=%.d)"-MT "$ (@:%.o=%.o)"-MT "$ (@:%.o=%.d)"-O "[email protected]" $< "

@echo ' finished building: $< '

@echo '

############################

# Rule to build the files in the CMSIS folder

./DEBUG/%.O:./cmsis/%.c

@echo ' Building file: $< '

$ (CC) $ (cc_options)-MMD-MP-MF "$ (@:%.o=%.d)"-MT "$ (@:%.o=%.o)"-MT "$ (@:%.o=%.d)"-O "[email protected]" $< "

@echo ' finished building: $< '

@echo '

?? Options -MMD-MP-MF " $ ( @ :%. o =%. D) "

-MT " $ ( @ :%. o =%. o) " generates a dependency. d file for each compiled source file .

Production target

To build your project, you can use the usual "make/build" and "clean" menus/commands in eclipse. But there's a cool way: build Goals!

To do this, open the Build target view (menu windows> display View > Others):

Make Create target

In the view, select the item, and then click the New Target button:

New target

To create a "clean" target:

Clean target

This adds a build target group to the project. Use the context menu to add a new target for all:

Create a new target

In this way, I can double-click or use the context menu to execute the target in makefile:

Create a target in the Eclipse project browser

Review

Managed authoring and building in Eclipse is a great feature: it's easy to use, and probably the right thing for a 98% use case like the IDE. But if I want to use Eclipse's normal make file, it's not difficult. Using the proposed make file template, if you add a new source to the project, I must extend the file list. Otherwise everything will be taken care of. Writing a document requires a learning phase, but this can be a good input.

The next thing you can do is make it happy.

RELATED LINKS

• Projects and files in this article on GitHub: Https://github.com/ErichStyger/mcuoneclipse/tree/master/Examples/MCUXpresso/FRDM-KL25Z/MyMakeProject
• Making Files Tutorial: https://mcuoneclipse.com/2012/02/13/make-my-make-with-eclipse-and-mcu10/
• GNU Make:https://www.gnu.org/software/make/

Welcome attention:

Use Eclipse for makefile projects