The full version of IAR Embedded Workbench also supports the following:

IAR Embedded Workbench is a commercial tool. Various editions are available, including a free version called Kickstart which is limited to 16 KB¹ code size (for Cortex^®-M0 and Cortex-M0+ processors) and has some of the advance features disabled. You can also download a fully featured version for a 30 days evaluation.

IAR Embedded Workbench is easy to use and supports many debug features available in the Cortex-M processors. In this chapter we will demonstrate the use of IAR Embedded Workbench for ARM with the Freescale Freedom board FRDM-KL25Z. Before you start, please read section 14.3.1 regarding updating the firmware and device driver installation.

In the example code package from the companion Web site for this book, there are additional examples for other hardware listed in section 14.3.

Most of the device configurations such as configuration files for memory layout, flash programming details are preinstalled so that you only need to select the right microcontroller devices in the project settings to enable the correct compilation flow.

In order to simplify the application development and allow quicker software development, in most cases you will be using a number of files prepared by the microcontroller vendors so that you do not have to waste time in creating definition files for peripheral registers. These files are normally part of the CMSIS compliant device driver library from the microcontroller vendors. In many cases these are referred as software packages which might also include additional components such as examples, tutorials, additional software libraries.

A minimalistic example project using CMSIS device library is illustrated in Figure 15.2.

While your application might only contain one file (left hand side of Figure 15.2), the project also includes a number of files from the microcontroller vendor. While you can create your applications almost entirely in C language, the start-up code which contains the vector table is often provided in form of an assembly code. The start-up code is tool chain specific. However, the rest of the files in the project are tool chain independent. In fact, in the blinky project example that we will cover in Section 15.3, apart from the assembly start-up code, all the other program code files are identical to the example project for Keil^® MDK-ARM as in Chapter 14. This is an important advantage of the CMSIS-CORE because it makes most of the software components independent of the tool chain; hence the software codes are much more portable and reusable.

Additional CMSIS-CORE files are referenced by some of these CMSIS-CORE files. These are generic header files from ARM (bottom right-hand corner of Figure 15.3) and are integrated in the IAR Embedded Workbench installation. One of the project options enables these files to be automatically included during the compilation stage.

If necessary, you can disable this project option and add the generic CMSIS-CORE files into the project manually. This might be needed if you need to use a specific version of CMSIS-CORE files.

If you are using older versions of CMSIS-CORE (version 2.0 or older), you might also find that you need to include a file called core_cm3.c or core_cm0.c in the CMSIS-CORE package for some of the core functions like access to special registers and couple of intrinsic functions. These files are no longer required in newer versions of CMSIS-CORE, and the CMSIS-CORE functions are still fully compatible to older version.

We can create a new project using the pull down menu: Project → Create New Project…

A new window will appear to allow you to select which type of project to create, as shown in Figure 15.5.

There are a number of choices here, for example, we can select:

For this demonstration we select an empty project. The project wizard will then proceed to ask us to define the location of the project file. Here in this stage we create a project called blinky (Figure 15.6).

Once this is done, we have an empty project created, and we can start adding files to it.

In order to make the project more organized, we can add a number of file groups in the project and put different types of files into these groups. You can access to the add group/file function by right clicking on the project target (Debug) and select “Add,” as shown in Figure 15.7, or from the pull down menu, “Project → Add Group/Add File.”

For this project we create three file groups.

In the following steps, the project setup step for Freescale FRDM-KL25Z is illustrated. For other hardware platform the steps are almost identical, just the filenames and the actual blinky code are different. For the Freescale FRDM-KL25Z hardware, the following files are added to the project, as shown in Table 15.1.

After adding the blinky program and the additional files to the project, a project navigation window as shown in Figure 15.8 is obtained. We have not explicitly included other CMSIS Header files as these can be automatically included using a project option (General option, see Table 15.2).

In the next steps, we need to set up various project options. For minimum, a number of project options are essentials, for example:

Note: For user of the STM32L0 Discovery development board, an additional preprocessing macro “STM32L051xx” needs to be defined in the project.

The project options can be accessed by right clicking on the project target (“blinky—Debug” as shown in Figure 15.8), by the pull down menu (Projects → Options), or by shortcut key ALT-F7. There are wide ranges of project options available, for many categories on the left, you can find multiple tabs. For example, in the “General options” category, you can find: Target, Output, Library Configuration, Library Options, MISRA C-2004, MISRA C-1998 (Figure 15.9).

In this blinky project, we need to set up a number of options as shown in Table 15.2.

After setting up the project options, we can now try to compile the project and test it. To start with, we right click on the project target (blinky—Debug) and select Build, and then the IDE will ask us to save the current workspace, which we will save it in the same project directory as “blinky.eww,” as shown in Figure 15.10.

If everything is setup correctly, you should see the compilation report at the IDE as shown in Figure 15.11. Congratulations! You have built you first ARM^® project with IAR Embedded Workbench successfully.

Now you need to download the program to the microcontroller board and test it. This can be done in three ways: Using the pull down menu to select “Project → Download and Debug,” click on the (Download and Debug icon) on the tool bar or use short cut key Ctrl-D.

After the program image is downloaded to the board, the debugger screen should appear as shown in Figure 15.12. The program is currently halted just before the first line of C code in main(), as indicated with the green arrow.

You can start running the program by clicking on the “go” icon on the tool bar. The LEDs on the board should start flashing. You can halt, resume, reset, or single step the program using various icons on the debugger screen, as shown in left hand side of Figure 15.13.

By default the register window is not enabled. To enable the register window, use the pull down menu to select “View → Register.”

You can insert or remove breakpoints by right clicking a line on the source window, and select toggle breakpoint. When the processor is halted, you can see the processor's registers using the register window which can be accessed by pull down menu “View → Register.”

For example, the IAR C Compiler allows various levels of optimization efforts, and when the optimization level is set to high, you can select between size optimization, speed optimization, and balance optimization. You can also enable or disable some of the individual optimization techniques (Figure 15.15).

There are also a number of additional settings for each supported debug adaptor. In some cases you need to set up the debug adaptor settings to specific debug protocol (i.e., JTAG/Serial Wire debug) and reset behaviors. Additional debug and trace options might also be needed if you are using Cortex^®-M3/M4/M7 processor which has trace features.

A new window will then be displayed, and you might need to click in the On/Off icon to enable the trace, as shown in Figure 15.17.

When trace is enabled, the ETM icon on the tool bar is displayed with green background color.

After program execution started and then halted (e.g., by a breakpoint), the instruction trace will then be displayed in the trace window, as shown in Figure 15.18.

You can determine the amount of stack space you need for your application by enabling the stack analysis feature. In order to do this, you need to enable two options in the linker settings:

Once the options are enabled and the project is recompiled, you should see a linker map file in the DebugList directory, and you can see the stack report like the following:

∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗

∗∗∗ STACK USAGE

∗∗∗

  Call Graph Root Category  Max Use  Total Use

  ------------------------  -------  ---------

  Program entry                  20         20

  Uncalled function               4          4

Program entry
  "__iar_program_start": 0x000008dd
  Maximum call chain                              20 bytes
    "__iar_program_start"                          0
    "__cmain"                                      0
    "main"                                         8
    "LED_Set"                                      8
    "LED_On" in blinky.o [1]                       4
Uncalled function
  "SystemInit": 0x00000411
  Maximum call chain                               4 bytes
    "SystemInit"                                   4

Another useful feature of the IAR EWARM is C-RUN, a range of runtime check features that allows detection of potential software failures with just a small amount of software overhead. The C-RUN is an add-on product for IAR EWARM 7.20 and later versions. The C-RUN feature can be enabled from the project option, as shown in Figure 15.22.

Much of the useful information about IAR Embedded Workbench is included in the documentation which is part of the installation. Typically you can find these files from the Help menu.

On the IAR Web site, under the support->resources section, there are also a number of useful and informative technical articles. An example is “Mastering stack and heap for system reliability,” reference 10.