Cart New Account Login

HomeAbout usProductsSupportForumsBlogCustomer Service
February 2006

Hassle Free GCC

Create Your ColdFire 52xx Application with Ease Using PKGCFZ_PRO

 

Whether you are porting your existing C code to the GNU compiler or creating an application from scratch, learning to use any new compiler and development environment can be time consuming.  For those who are new to GCC, setting up compiler options, linker scripts, and target startup code takes even more time.  And, if you have never developed a C application for an embedded system, then you might be working late a few nights this week.  PKGCFZ PRO reduces your down time by simplifying all of these tasks.  Follow the steps below to speed through the development process.

 

Contents

1         Creating a ColdFire Application from Scratch

2         Configuring the Compiler and Target Application

3         Customizing the ColdFire Application

4         Adding Your Own Source Files

5         Changing the Memory Map

6         Configuring Chip Select Registers

7         Customizing the Vector Table and ISRs

8         Conclusion

 

1.  Creating a ColdFire Application from Scratch

 

Even if you are not going to use P&E's default source files for your application, begin by making a WinIDE project from a template.  This will automatically configure the compiler for your target processor.

 

After installing PKGCFZ PRO, launch WinIDE from the Programs folder in the Windows Start menu.  In the WinIDE Environment menu, select New Project from Template.  A list of all ColdFire 52xx processors and select commercial development boards will appear.  For this example, we'll select the template EVB_PE_DEV5213CF, which will create a project for the P&E ColdFire 5213 development board. 

 

 

If listed, select the template for your development board.  If you are using a custom board or if your board is not listed, select the general template for your target processor.

 

Next, WinIDE will ask you three questions:

 

Where would you like your new project folder to be located?

 

 

What is the name of your new project?

 

 

Where is the GNU compiler?

 

 

WinIDE will automatically select the location of the compiler.

 

At this point, WinIDE will create your new project and default source files, and it will configure the compiler settings.  If you do not want to use the default P&E files, we'll discuss replacing them below. 

 

You will see a list of project files in the right pane of WinIDE.  Left-click on a file name to open that file for editing, such as the file main.c:

 

 

Hit the F4 key, or use the WinIDE toolbar button, to compile your code.  If there are no compile time errors, then the GNU software will produce an ELF/DWARF2.0 file, such as main.elf, for debugging and a Freescale s-record file, such as main.s19, for flash programming.  After a successful compile, WinIDE will look similar to this:

 

 

Above, notice that the WinIDE status bar indicates that no errors occurred during compilation.

 

When a compilation fails, WinIDE will highlight the problem code, if applicable, and display the first error message in the WinIDE status bar.  Notice that all the compiler output messages appear in the file err.log.

 

Return to top

 

2.  Configuring the Compiler and Target Application

 

You will need to be concerned with two groups of user settings.  Access compilation settings through WinIDE's dialogs.  See the linker script to edit the ColdFire application settings that determine the final memory map.  In many cases, when you create a project from a template, WinIDE automatically configures both the compilation settings and the target application settings.

 

2.1  Compilation Settings

 

Access all of the compilation settings through WinIDE's Environment menu, Environment Settings dialog, Assembler/Compiler tab, shown here:

 

 

From the Assembler/Compiler tab, four additional dialogs are available.  The WinIDE Error Options dialog controls WinIDE's handling of compiler errors.  The Compiler Options (General) dialog contains settings that enable debug information and control compiler output.  The Compiler Options (Paths) dialog sets all of the path information for the compilation, including library paths, output paths, and the location of the linker script.  Use the Build Dialog to specify the names of the source files to be compiled.

 

Leave all of these dialog settings unaltered for now.  We will look more closely at the Build Dialog and the Compiler Options (Paths) dialog, below.

 

2.2  Target Application Settings

 

The linker script controls the final memory layout of the ColdFire application.  Using the default P&E linker script, you will need to check just a few items located at the top of the linker script file.  Locate the name of the P&E linker script in the Compiler Options (Paths) dialog.  Access this dialog through the WinIDE Environment menu, Environment Settings dialog, Assembler/Compiler tab.

 

In this example, the linker script name is pe_MCF521x.ld. 

 

Close all of the dialog windows and click on the linker script name in the right pane of WinIDE.  The linker script contents appear similar to below.  The top of this file is the user section that contains linker script variables.  Use these linker script variables to control the memory map of your application.  You may or may not need to change these values to suit your target system.  See below for more information about changing the application memory map.

 

 

Now, you will want to recompile the new project, this time ensuring that the compilation settings and memory map are suitable for your target system.  You will also need to replace or change the P&E default source files to perform your specific task.  Read the next section to get your application running.

 

Return to top

 

3.  Customizing the ColdFire Application

 

After creating the new project from a template, you need to ensure that the ColdFire application memory map is compatible with your target system.  Likely, you will find yourself in one of these situations:

 

3.1  You created a project with a template for a specific evaluation board, such as EVB_PE_DEV5213CF, and you want to run the default P&E code on your board.

 

You do not need to change the compilation settings or target application settings..  Ensure that the development board is in its default hardware configuration.  The s-record and ELF/DWARF2.0 files, produced during compilation, are ready for programming and debugging. 

 

3.2  You created a project with a general template, such as MCF5212_5213, and you want to run the default P&E code.

 

You do not need to change any compilation settings in the Assembler/Compiler tab.  However, you need to check the top of the linker script to be sure that the default memory map is suitable for your target system.  You may also need to configure chip select registers during application startup.  See the sections below, "Changing the Memory Map" and "Configuring Chip Select Registers".

 

3.3  You created a project with any C template, and you would like to change or replace the default P&E code.  However, you want to use the P&E initialization code (the crt0 startup code), vector table, and linker script.

 

Four source files operate as a group to frame the P&E ColdFire application:  the linker script, crt0 startup code, user initialization hooks, and the vector table and interrupt service routines.  If you modify one of these files outside of what is described in the documentation, you may need to supply your own linker script, startup code, and vector table code.  You may replace any other default source file except the linker script, startup code (such as pe_crt0_MCF521x.S), user hooks (pe_hooks.c), and vector table and ISRs (such as pe_vectors_DEV5213CF.c).

 

How do you make your source code fit in with the default application files?  Add your files to the compilation; add interrupt handlers, check the memory map in the linker script, and add user initialization code. 

 

To add or remove files from the compilation, you will need to change the list of files in the Build Dialog.  See the section below "Adding Your Own Source Files". 

 

To add interrupt service routines and to edit the vector table, see "Customizing the Vector Table and ISRs".

 

You need to check the top of the linker script to be sure that the default memory map is suitable for your target system.  You may need to configure chip select registers during application startup.  See the sections below, "Changing the Memory Map" and "Configuring Chip Select Registers".

 

3.4  You created a project with any C template, and you will not be using any of the P&E default files, including startup code, vector table, and linker script.

 

To add or remove files from the compilation, you will need to change the list of files in the Build Dialog.  See the section below "Adding Your Own Source Files".  You will need to specify explicitly the name of your startup code, if any.

 

You will need to specify your own linker script file.  See the section "Changing the Memory Map". 

 

Return to top

 

4.  Adding Your Own Source Files

 

From the WinIDE Environment menu, Environment Settings dialog, Assembler/Compiler tab, open the Build Dialog.  This dialog lists all of the file names that will be passed to GCC.  You may include either C or assembly source files. 

 

The Build Dialog should list the name of the ColdFire startup file, such as pe_crt0_MCF521x.S.  The startup code calls the user initialization routines in the file pe_hooks.c.  The vector table and interrupt service routines are located in the file pe_vectors_DEV5213CF.c. 

 

 

In addition to the linker script, the startup code, initialization hooks, and vector table/ISR code comprise the P&E ColdFire application framework.  If you are using these files, add your own source files to the build to produce your application.  If you want to use your own linker script, startup code, and vector table/ISR code, simply remove the startup code, initialization hooks, and vector table from the Build Dialog and specify the new linker script in the Compiler Options (Paths) dialog.  We discuss adding a new linker script below. 

 

When adding your own files to the Build Dialog, you will also want to add them to the right pane of WinIDE.  Do this in the WinIDE Environment menu, Add Files to Project.  This will allow you to quickly open your source file.

 

Return to top

 

5.  Changing the Memory Map

 

If you created a project for a specific evaluation board, such as EVB_PE_DEV5213CF, you will not need to change the linker script.  The default memory map will be compatible with your board.  However, you may desire to change the memory map.  If you created a project for a board using a general template, such as MCF5212_5213, then you will need to be sure that the default memory map is compatible with your ColdFire system. 

 

The linker script controls the memory map of the ColdFire application.  Open the linker script and look at the top of the file, which is the user section of the linker script.  Several linker script variables must be set to be compatible with your target system.  All of these linker script variables are located at the top of the linker script.  Do not change the linker script below the user section, which is clearly marked in the file.

 

The user should examine the following linker script variables, ensuring that their values are appropriate for the target system.

 

__application_load_address:  The value of this variable is the base address of the application.  This is the address of the executable code at load time.  If you will be programming your application to flash, this should equal the base address of flash.

 

__application_run_address:  This is an optional variable and is undefined by default. This is the address of the executable code at run time.  If defined, startup code will copy both executable code and global/static variables to this location, for example, from flash to RAM. 

 

__global_data_run_addr:  This is an optional variable and is defined by default.  The value is the location of global/static variables at run time.  If defined, startup code will copy global/static variables to this location, for example, from flash to RAM.

__stack_start:  This value is the initial value of the stack pointer. Valid RAM must exist at this location.

 

__heap_start:  This is an optional variable and is undefined by default.  This value is the location of the beginning of the heap in RAM.  If undefined, the linker script automatically sets the location of the heap.

These linker script variables are common to all of the template projects.  Note, there may be additional, target specific variables as well.

 

You may choose to use your own linker script.  To specify the name of your own linker script, open the Compiler Options (Paths) dialog, as shown in the section above.  Remember that the default linker script, startup code, and vector table/ISR code act as a unit, so the replacement of one of these files will require that you supply all of them. 

 

Return to top

 

6.  Configuring Chip Select Registers

 

The file pe_hooks.c contains user initialization hooks.  The startup code, such as pe_crt0_MCF521x.S, calls the hook routines.  The routines are useful for custom initialization tasks, such as chip select initialization.

 

Look at the P&E startup code, such as pe_crt0_MCF521x.S, and the routine memory_init_hook in the file pe_hooks.c.  Target execution begins in the startup code, which calls memory_init_hook.  This routine memory_init_hook is the proper location for chip select initialization.  

 

Return to top

 

7.  Customizing the Vector Table and ISRs

 

The vector table and interrupt service routines are located in a file such as pe_vectors_DEV5213CF.c.  To add your own ISR, simply call the user ISR from the default ISR, as below:

 

 

By default, the linker script automatically sets the vector table location to equal the base address of the application.  Although the user may change the application base address in the linker script, the user should not change the relative location of the vector table.  If you are using your own linker script, you must create your own vector table and set its location in your linker script.

 

Return to top

 

8.  Conclusion

 

To state concisely, create a ColdFire 52xx application by doing the following:

 

1.  In WinIDE, create a project from a template.

 

2.  In the WinIDE Build Dialog, replace the default files with your own files, except the startup code (such as pe_crt0.S), user initialization hook (such as pe_hooks.c), and the vector table and interrupt service routines (such as pe_vectors.c).  Add your files to the right pane of WinIDE for quick access.

 

3.  Add custom initialization code, such as chip select configuration code, to the user initialization hooks.

 

4.  Call your own interrupt service routines from the default ISRs.

 

5.  Check the top of the linker script to be sure that the memory map is compatible with your target system.

 

6.  Compile your project to produce an s-record file and ELF/DWARF2.0 file. 

 

Further help is available at the P&E website, including FAQs, user forums, links to GNU resources on the web, and documentation downloads.  PKGCFZ Pro includes Quick Start Guides, a User's Manual that details WinIDE's interaction with GCC, and the Application Framework and Solutions Guide that fully explains the default P&E ColdFire application and provides answers to many specific questions.

 

Return to top


© 2017 P&E Microcomputer Systems Inc.
Website Terms of Use and Sales Agreement