Interrupts

Interrupts are a very important concept in programming a robot. The 6811 has the ability to be working on a task, get interrupted by a higher priority task, dispatch it, and resume execution of the first task. So the interrupt temporarily suspends the main task, handles an interrupt service routine in response to some interrupt signal, and then return to the main task. On a Miniboard, things that can cause interrupt signals are

• Serial Communications
• A digital pulse, received on any pin of Port A
• An overflow of the 6811's main timer
• An input capture in Port A, bits 0, 1, 2, or 3
• An output compare based on timer compare registers TOC1 - 4
• A real time interrupt every X milliseconds
• The IRQ button
• The programmer, by using the SWI opcode
• An illegal op code
• The 6811 monitors itself and may decide that it is failing
• The Reset button

When an interrupt occurs, the 6811 takes several automatic steps to save what it was just doing and find what it needs to do. First, the 6811 will save registers onto the stack (CCR, A, B, X, Y, PC). Then the PC will be set to a specific area of memory depending upon what interrupt occurred. For example, if the Main Timer had overflowed, the PC would now be set to $FFDE. Every different interrupt (there are 22 possible) would have the PC set to a unique place in memory. These memory locations are all in the range $FFD6 to $FFFE. Notice that this is the very top of the memory map. As a programmer, you must put a "vector" at the unique memory location for every interrupt you expect to encounter. Continuing with the timer overflow example, the programmer must put a "vector" at memory location $FFDE. The "vector" is to be used as the new PC value when the interrupt occurs. Since it is an address, a vector is necessarily two bytes long. So the Timer Overflow vector would take up the bytes $FFDE and $FFDF. The address placed here at the vector location will be the next address visited by the PC, so the programmer should put the address of the Interrupt Service Routine there. The programmer does not have to calculate where the ISR will start though, because the assembler can do this automatically. Below is a template of a main program, with an ISR for Main Timer Overflow and two vectors:

	
	ORG	$F800	  	*Start of main at start of EEPROM
Main:	EQU *		
	Code	Here 
End:		     		*Main is done here
Timer_ISR: 	EQU *	   	*Start of ISR
	Interrupt Service RoutineHere 		
	RTI			*return from interrupt
	ORG	$FFDE	
	FDB	Timer_ISR	*Vector 1
	ORG	$FFFE	
	FDB	Main		*Vector 2

So the Interrupt signal occurred (a Main Timer Overflow) and the registers were saved to the stack, and the PC went to the location specified at memory location $FFDE (namely to Timer_ISR) Now the I bit in the CCR is set (to prevent further interrupts) and the 6811 begins executing instructions in the Timer_ISR routine. The programmer may want to keep a count of how many times the main timer overflowed, or to take samples of data on the ports, or do some other imaginative thing during the Timer_ISR. But at the end of the Timer_ISR, the RTI (return from interrupt) instruction must appear. This RTI will have the effect of causing the 6811 to restore all the registers (remember they were saved on the stack) This means that what ever the 6811 was doing before the ISR, it will start right where it left off, because the PC is one of the restored registers. The accumulators, index registers, CCR, PC and even the SP (think about it) are all just as they were before the Interrupt signal. So the 6811 will load the next instruction from Main (where the PC now points) and move happily along.

Back to Table of Contents