This section will demonstrate how to write an interrupt in an easy way. It starts with a brief description of the application used in this project, followed by a description of how to set up the project.

The interrupt handler will read values from the serial communication port receive register (UART), UARTRECEIVE. It will then print the value. The main program enables interrupts and starts printing periods (.) in the foreground process while waiting for interrupts.

The following lines define the interrupt handler used in this tutorial (the complete source code can be found in the file Interrupt.c in project4 supplied in the arm\tutor directory):

The __irq keyword is used for directing the compiler to use the calling convention needed for an interrupt function. The __arm keyword is used for making sure that the IRQ handler is compiled in ARM mode. In this example only UART receive interrupts are used, so there is no need to check the interrupt source. In the general case however, when several interrupt sources are used, an interrupt service routine must check the source of an interrupt before action is taken.

For detailed information about the extended keywords used in this tutorial, see the IAR C/C++ Development Guide for ARM®.

On Cortex-M3, an interrupt service routine enters and returns in the same way as a normal function, which means no special keywords are required.

In the Interrupt.c file in the Project4CM3 project, the interrupt function UART_Handler is provided. Note that when you add an interrupt function for Cortex-M devices, you must also add the name of that function in the interrupt vector table. You do this in the system startup code cstartup.s. For this tutorial, a reference to the UART_Handler function is already provided in __vector_table, which you can find in the file CstartupCM3.s.

For more information about how to write device-specific interrupt functions for Cortex-M, see the IAR C/C++ Development Guide for ARM®.

The C-SPY interrupt system is based on the cycle counter. You can specify the amount of cycles to pass before C-SPY generates an interrupt.

To simulate the input to UART, values are read from the file InputData.txt, which contains the Fibonacci series. You will set an immediate read breakpoint on the UART receive register, UARTRECEIVE, and connect a user-defined macro function to it (in this example the Access macro function). The macro reads the Fibonacci values from the text file.

Whenever an interrupt is generated, the interrupt routine reads UARTRECEIVE and the breakpoint is triggered, the Access macro function is executed and the Fibonacci values are fed into the UART receive register.

The immediate read breakpoint will trigger the break before the processor reads the UARTRECEIVE register, allowing the macro to store a new value in the register that is immediately read by the instruction.

This section will demonstrate the steps involved in setting up the simulator for simulating a serial port interrupt. The steps involved are:

In C-SPY, you can define setup macros that will be registered during the C-SPY startup sequence. In this tutorial you will use the C-SPY macro file SetupSimple.mac, available in the arm\tutor directory. It is structured as follows:

First the setup macro function execUserSetup is defined, which is automatically executed during C-SPY setup. Thus, it can be used to set up the simulation environment automatically. A message is printed in the Log window to confirm that this macro has been executed:

Then the file InputData.txt, which contains the Fibonacci series to be fed into UART, is opened:

After that, the macro function Access is defined. It will read the Fibonacci values from the file InputData.txt, and assign them to the receive register address:

You must connect the Access macro to an immediate read breakpoint. However, this will be done at a later stage in this tutorial.

Finally, the file contains two macro functions for managing correct file handling at reset and exit.

For detailed information about macros, see the C-SPY® Debugging Guide for ARM®.

For reference information about argument variables, see the IDE Project Management and Building Guide for ARM®.

For ARM7TDMI, set the Device description file option to $TOOLKIT_DIR$\tutor\config\ioarm7.ddf.

For Cortex-M3, set the Device description file option to $TOOLKIT_DIR$\tutor\config\iocm3.ddf.

Alternatively, click the Make button on the toolbar. The Make command compiles and links those files that have been modified.

The Interrupt.c window is displayed (among other windows). Click in it to make it the active window.

Make these settings for your interrupt:

During execution, C-SPY will wait until the cycle counter has passed the activation time. When the current assembler instruction is executed, C-SPY will generate an interrupt which is repeated approximately every 2000 cycles.

By defining a macro and connecting it to an immediate breakpoint, you can make the macro simulate the behavior of a hardware device, for instance an I/O port, as in this tutorial. The immediate breakpoint will not halt the execution, only temporarily suspend it to check the conditions and execute any connected macro.

In this example, the input to the UART is simulated by setting an immediate read breakpoint on the UARTRECEIVE address and connecting the defined Access macro to it. The macro will simulate the input to the UART. These are the steps involved:

During execution, when C-SPY detects a read access from the UARTRECEIVE address, C-SPY will temporarily suspend the simulation and execute the Access macro. The macro will read a value from the file InputData.txt and write it to UARTRECEIVE. C-SPY will then resume the simulation by reading the receive buffer value in UARTRECEIVE.

If you want to inspect the details of the breakpoint, choose View>Breakpoints.

To inspect the contents of the serial communication port receive register UARTRECEIVE, choose View>Register to open the Register window. Choose UART from the drop-down list.

Note how the contents of UARTRECEIVE has been updated.

Because the main program has an upper limit on the Fibonacci value counter, the tutorial application will soon reach the exit label and stop.

To automate the setting of breakpoints and the procedure of defining interrupts, the system macros __setSimBreak and __orderInterrupt, respectively, can be executed by the setup macro execUserSetup.

The files SetupAdvanced.mac for ARM7TDMI and SetupAdvancedCM3.mac for Cortex-M3 are extended with system macro calls for setting the breakpoint and specifying the interrupt:

For ARM7TDMI (the arm7 dummy device):

For Cortex-M3 (the cm3 dummy device):

If you replace the file SetupSimple.mac, used in the previous tutorial, with the file SetupAdvanced.mac or SetupAdvancedCM3.mac, C-SPY will automatically set the breakpoint and define the interrupt at startup. Thus, you do not need to start the simulation by manually filling in the values in the Interrupts and Breakpoints dialog boxes.