School of Electrical, Computer and Telecommunications Engineering University of Wollongong Australia

Size: px

Start display at page:

Download "School of Electrical, Computer and Telecommunications Engineering University of Wollongong Australia"

Reginald White
6 years ago
Views:

1 ECTE333 s schedule ECTE333 Lecture 9 -Timers School of Electrical, Computer and Telecommunications Engineering University of Wollongong Australia Week Lecture (2h) Tutorial (h) Lab (2h) L7: C programming for the ATMEL AVR 2 Tutorial 7 Lab 7 3 L8: Serial communication 4 Tutorial 8 Lab 8 5 L9: Timers 6 Tutorial 9 Lab 9 7 L: Pulse width modulator 8 Tutorial Lab 9 L:Analogue-to-digital converter Tutorial Lab L2: Revision lecture 2 Lab 2 3 L3: Self-study guide (no lecture) Final exam (25%), Practical exam (2%), Labs (5%) 2/57 Lecture 9 s sequence 9. Interrupt programming in C for ATmega6 9. Interrupt programming in C for ATmega6 In Semester, we learnt the interrupt-driven approach and the ATmega855, writing an interrupt-driven program in the assembly language Timers in ATmega6 In this lecture, we will learn the interrupt subsystem in the ATmega6, writing an interrupt-driven program in C. 9.3 Timer applications Compared to polling, interrupt is a more efficient approach for the CPU to handle peripheral devices, e.g. serial port, external switches, timers, PWM, and ADC. 3/57 4/57

2 Polling versus Interrupt Polling while (){ get_device_status; if (service_required){ instruction k service_routine; routine; normal_execution; instruction k+ rmal_ex xecutio on no Interrupt interrupt signal runs interrupt_ service_ routine Interrupt execution sequence. A device issues an interrupt 2. CPU finishes the current instruction 3. CPU acknowledges the interrupt 4. CPU saves its states and PC onto stack 5. CPU loads the address of ISR onto PC Using polling, the CPU must continually check the device s status. Using interrupt: 6. CPU executes the ISR A device will send an interrupt signal when needed. In response, the CPU will perform an interrupt service routine, and then resume its normal execution. 7. CPU retrieves its states and PC from stack 8. Normal execution resumes 5/57 6/57 ATmega6 interrupt subsystem Table 9.: Interrupts in ATmega6 Vector No. Program Address Interrupt t vector name Description The ATmega6 has 2 interrupts: reset interrupt 3 external interrupts 8 timer interrupts 3 serial port interrupts ADC interrupt $ RESET_vect Reset 2 $2 INT_vect External Interrupt Request 3 $4 INT_vect External Interrupt Request 4 $6 TIMER2_COMP_vect Timer/Counter2 Compare Match 5 $8 TIMER2_OVF_vect Timer/Counter2 Overflow 6 $A TIMER_CAPT_vect Timer/Counter Capture Event 7 $C TIMER_COMPA_vect Timer/Counter Compare Match A 8 $E TIMER_COMPB_vect Timer/Counter Compare Match B 9 $ TIMER_OVF_vect Timer/Counter Overflow $2 TIMER_OVF_vect Timer/Counter Overflow $4 SPI_STC_vect Serial Transfer Complete analogue comparator interrupt SPI interrupt TWI interrupt 2 memory interrupts 2 $6 USART_RXC_vect USART, Rx Complete 3 $8 USART_UDRE_vectUDRE USART Data Register Empty 4 $A USART_TXC_vect USART, Tx Complete 5 $C ADC_vect ADC Conversion Complete 6 $E EE_RDY_vect EEPROM Ready 7 $2 ANA_COMP_vect Analog Comparator 8 $22 TWI_vect 2-wire Serial Interface 9 $24 INT2_vect External Interrupt Request 2 2 $26 TIMER_COMP_vect Timer/Counter Compare Match 2 $28 SPM_RDY_vect Store Program Memory Ready 7/57 8/57

3 Table 9.: Interrupts in ATmega6 Steps to program an interrupt in C Vector No An interrupt with a lower Vector No has a higher priority. E.g., INT has a higher priority than INT and INT2. Program Address The fixed memory location for a given interrupt handler. E.g., in response to interrupt INT, CPU runs instruction at $2. To program an interrupt, 5 steps are required.. Include header file <avr\interrupt.h>. 2. Use C macro ISR() to define the interrupt handler and update IVT. 3. Enable the specific interrupt. t 4. Configure details of the interrupt by setting relevant registers. 5. Enable the interrupt subsystem globally using sei(). Interrupt Vector Name This is the interrupt name, to be used with C macro ISR(). Later, we ll study steps for interrupt programming in C, via 2 examples. 9.. USART RXD Complete interrupt 9..2 External interrupts 9/57 /57 Using C macro ISR() Learning ATmega6 interrupts Vector No. Interrupt vector name Description The C macro ISR() is used to define the handler for a given interrupt. RESET_vect Reset 2 INT_vect External Interrupt Request Its syntax is given as 3 INT_ vect External Interrupt Request 4 TIMER2_COMP_vect Timer/Counter2 Compare Match ISR(interrupt_vector_name){ // code for interrupt handler here where interrupt_vector_name is given in Table TIMER2_OVF_vect Timer/Counter2 Overflow 6 TIMER_CAPT_vect Timer/Counter Capture Event 7 TIMER_COMPA_vect Timer/Counter Compare Match A 8 TIMER_COMPB_vect Timer/Counter Compare Match B 9 TIMER_OVF_vect Timer/Counter Overflow TIMER_OVF_vect Timer/Counter Overflow SPI_STC_vect Serial Transfer Complete 2 USART_RXC_vect USART, Rx Complete Example: To process interrupt t RXD Complete and put the received character in Port B, we write 3 USART_UDRE_vectUDRE USART Data Register Empty 4 USART_TXC_vect USART, Tx Complete 5 ADC_vect ADC Conversion Complete ISR(USART_RXC_vect){ RXC PORTB = UDR; // put the received character in Port B 6 EE_RDY_vect EEPROM Ready 7 ANA_COMP_vect Analog Comparator 8 TWI_vect 2-wire Serial Interface 9 INT2_vect External Interrupt Request 2 2 TIMER_COMP_vect Timer/Counter Compare Match 2 SPM_RDY_vect Store Program Memory Ready /57 2/57

4 9.. Serial RXD interrupt Write a C interrupt-driven program to use the serial port of ATmega6 at baud rate 2, no parity, stop bit, 8 data bits, clock speed MHz. Whenever a character is received, it should be sent to Port B. The serial port on ATmega6 can trigger an RXD interrupt whenever a character is received [Lecture 8]. We enable this interrupt by setting a flag in a serial port register. We then write the interrupt handler, to be run whenever the interrupt is triggered. Serial RXD interrupt: Enabling RXCIE TXCIE UDRIE RXEN TXEN UCSZ2 RXB8 TXB8 Register UCSRB = b Tx extra data bit for 9-bit character size Rx extra data bit for 9-bit character size bit 2 to decide character size to enable USART transmitter: Pin D. = TXD pin to enable USART receiver: Pin D. = RXD pin to enable USART Data Register Empty Interrupt to enable TX Complete Interrupt, valid only if Global Interrupt Flag = and TXC = to enable RX Complete Interrupt, valid only if Global Interrupt Flag = and RXC = For any interrupt, the ATmega6 manual explains how to enable the interrupt. E.g., for serial RXD interrupt, we look at USART section. 3/57 4/57 Serial RXD interrupt: serial_int.c #include <avr/io.h> #include <avr/interrupt.h> void USART_init(void){ // Normal speed, disable multi-proc UCSRA = b; // Enable Tx and Rx pins, enable RX interrupt UCSRB = b; // Asynchronous mode, no parity, stop bit, 8 data bits UCSRC = b; // Baud rate 2bps, assuming MHz clock UBRRL = x33; UBRRH = x; ISR(USART_RXC_vect){ RXC // Handler for RXD interrupt PORTB = UDR; // Received character is displayed on port B int main(void) { USART_init(); // initialise USART sei(); // enable interrupt subsystem globally DDRB = xff; // set port B for output while () {; // infinite loop return ; Serial RXD interrupt: Testing Write To test a C the interrupt-driven serial RXD interrupt program example: to toggle port B whenever a switch on the STK5 board is pressed. The program should use an external Connect RXD pin (pin D.) to RXD pin of RS232 Spare. interrupt. Connect TXD pin (pin D.) to TXD pin of RS232 Spare. Connect Port B to LED connector. Compile, download program. Connect RS232 Spare Connector to Serial Port of PC. Configure and run HyperTerminal and use it to send characters. Video demo: [avr]/ecte333/serial_int.mp4 avr = 5/57 6/57

5 Serial RXD: Polling approach For comparison, the program below uses polling for the same effect. #include <avr/io.h> void USART_init(void){ // Normal speed, disable multi-proc UCSRA = b; // Enable Tx and Rx, disable interrupts UCSRB = b; // Asynchronous mode, no parity, stop bit, 8 data bits UCSRC = b; // Baud rate 2bps, assuming MHz clock UBRRL = x33; UBRRH = x; int main(void) { USART_init(); // initialise USART DDRB = xff; // set port B for output while () { // infinite loop // Poll until RXC flag = while ((UCSRA & (<<RXC)) == x){; PORTB = UDR; // received character is displayed on port B return ; 7/ External interrupts Write External a C interrupt-driven interrupts on ATmega6 program and to toggle ATmega855 port B whenever are similar. a switch on the STK5 board is pressed. The program should use an external Key references on ATmega6 external interrupts: t ATmega6 user interrupt. manual, External Interrupts section. Three external interrupts can be triggered. INT on pin D.2, INT on pin D.3, INT2 on pin B.2. Key steps in using external interrupts: enable the interrupt, specify what types of event will trigger the interrupt. rising-edge interrupt falling-edge interrupt 8/57 External Interrupts: Relevant pins External interrupts: Enabling To enable an external interrupt, set a flag in General Interrupt Control Register (GICR). INT INT INT IVSEL IVSEL Read/Write R/W R/W R/W R R R R/W R/W Initial value Example: To enable INT on pin D.3, we can write GICR = ( << INT); Note that INT and GICR names are already defined in <avr/io.h>. #define INT 7 9/57 2/57

6 External interrupts: Specifying events External interrupts: Specifying events Specify the events that trigger an external interrupt by using MCU Control Register (INT and INT), or MCU Control and Status Register (INT2). For INT and INT: MCUCR SM2 SE SM SM ISC ISC ISC ISC For INT2: MCUCSR JTD ISC2 - JTRF WDRF BORF EXTRF PORF : falling edge triggers an interrupt INT2 : rising edge triggers an interrupt INT2 ISC ISC An interrupt is triggered when low level of INT any change of INT falling edge of INT rising edge of INT ISC ISC An interrupt is triggered when low level of INT any change of INT falling edge of INT rising edge of INT 2/57 22/57 External interrupts: Example External interrupts: ext_int.c Write a C program to toggle port B whenever a switch on the STK5 board is pressed. The program should use an external interrupt. #include <avr/io.h> #include <avr/interrupt.h> ISR(INT_vect){ // handler for INT interrupt PORTB = (~PORTB); // toggle port B Let s use interrupt INT. This interrupt is triggered on pin D.3. To enable interrupt INT: GICR = ( << INT); int main(void) { GICR = ( << INT); // enable interrupt INT MCUCR = (<<ISC); // triggered on any change to INT pin (D.3) To specify that INT is triggered on any change in pin D.3: sei(); DDRB = xff; // enable interrupt subsystem globally // set port B for output MCUCR = ( << ISC); Then, we write interrupt handler and enable interrupt subsystem. PORTB = b; // initial value while () {; return ; // infinite main loop 23/57 24/57

7 External interrupts: Testing ext_int.c Lecture 9 s sequence Write To test a C the interrupt-driven external interrupt program example: to toggle port B whenever a switch on the STK5 board is pressed. The program should use an external Connect INT pin (pin D.3) to switch SW7 on STK5 board. interrupt. Connect GRD pin of Port D to GRD pin of SW connector. Connect Port B to LED connector. 9. Interrupt programming in C for ATmega6 Compile, download program. Press switch SW Timers in ATmega6 Video demo: [avr]/ecte333/ext_int.mp4 9.3 Timer applications 25/57 26/ Timers in ATmega6 Timer terminology Many computer applications require accurate timing. Examples include: recording the time when an event occurs, calculating the time difference between events, performing tasks at specific or periodic times, creating accurate time delays, generating waveforms of certain shape, period, or duty cycle. Lectures 9 and focus on using timers to perform time-related tasks. Input Capture: Input signal is connected to a pin, called input capture, of the timer. When a preset event (rising edge, falling edge, change) occurs on this pin, the current timer value is automatically stored in a register. Output Compare: A timer typically has a pin, called output compare. When the timer reaches a preset value, the output compare pin can be automatically changed to logic or logic. 27/57 28/57

8 Overview of Timers in ATmega6 Overview of Timers in ATmega6 ATmega6 has three timers: Timer, Timer and Timer 2. When the internal system clock is used, a prescaler can be applied to make the timer count at a slower rate. Each timer is associated with a counter and a clock signal. Example: The counter is incremented by in every clock cycle of the timer. Consider a system clock of Mhz (i.e. μs per cycle). Suppose that a timer prescaler of 64 is used. The clock signal of a timer can come from the internal system clock or Then, timer will increment every 64μs. an external clock source. 29/57 3/57 Overview of Timers in ATmega6 Study plan Timer Timer Timer 2 In Lecture 9, we focus on - 8-bit counter - 6-bit counter - 8-bit counter Overall - -bit prescaler - -bit prescaler - -bit prescaler operations of Timer, using Timer overflow interrupt, Functions - PWM - PWM - PWM - Frequency generation - Frequency generation - Frequency generation - Event counter - Event counter - Event counter - Output compare - Output compare channels: 2 - Output compare - Input capture using Timer input capture interrupt, measuring time, creating time delay, measuring gperiod/duty cycle of a signal, information required for Lab 9. Operation modes - Normal mode - Normal mode - Normal mode - Clear timer on - Clear timer on - Clear timer on compare match compare match compare match - Fast PWM - Fast PWM - Fast PWM - Phase correct PWM - Phase correct PWM - Phase correct PWM In Lecture, we will learn using Timer output compare interrupt, generating PWM signals, information required for Lab. Timer has the most capability among the three timers. 3/57 32/57

9 Timer : An overview 6-bit counter. -bit prescaler: 8, 64, 256, and 24 can trigger a timer overflow interrupt when counter reaches MAX. can trigger an input capture interrupt when an event occurs on the input capture pin. timer value is stored automatically in a register. input capture pin for Timer is ICP (D.6). can trigger an output compare match interrupt when timer reaches a preset value. There are two independent output compare channels A and B. Timer : Block diagram Current timer/counter value Output Compare Registers Input Capture register Timer/Counter Control Registers External clock pin Output Compare pins Input Capture pin Not shown here: TIMSK and TIFR registers 33/57 34/57 Timer Relevant pins Timer Five groups of registers ) Timer/Counter TCNT 6-bit register that stores the current value of the timer. 2) Timer/Counter Control Registers TCCRA and TCCRB To configure the operations of Timer. 3) Input Capture Register ICR to store timer value when an event occurs on input capture pin. 4) Interrupt registers TIMSK to enable timer interrupts TIFR to monitor status of timer interrupts. used in this lecture 5) Output Compare Registers OCRA, OCRB To store the preset values for output compare. 35/57 36/57

10 Timer Five groups of registers 9.2. Timer/Counter Control Register A (TCCRA) COMACOMA COMBCOMB FOCA FOCB WGM WGM Specify Waveform Generation Mode used with WGM3, WGM2 WGM3..WGM = for normal mode. to force output compare on channel B to force output compare on channel A Output compare mode for channel B Output compare mode for channel A 37/57 38/ Timer/Counter Control Register B (TCCRB) ICNC ICES - WGM3 WGM2 CS2 CS CS 3 2 Clock select CS2 CS CS Description No clock source (timer stopped) CLK I/O / (no prescaling) CLK I/O /8 (from prescaler) clock select (next slide) CLK I/O /64 (from prescaler) CLK I/O /256 (from prescaler) CLK I/O /24 (from prescaler) select Waveform Generation Mode, used with WGM, WGM WGM3..WGM = for normal mode. input capture edge select: will select rising edge, will select falling edge to activate input capture noise canceller External clock source on T pin. Clock on falling edge. External clock source on T pin. Clock on rising edge. For ATmega6, the default internal clock is clk I/O = MHz. Timer can use the internal or external clock. If using the internal clock, we can set Timer to run 8, 64, 256, or 24 times slower than the internal clock. 39/57 4/57

11 9.2.3 Timer/Counter Interrupt Mask Register (TIMSK) Timer/Counter Interrupt Flag Register (TIFR) OCIE2 TOIE2 TICIE OCIEA OCIEB TOIE OCIE TOIE OCF2 TOV2 ICF OCFA OCFB TOV OCF TOV For Timer For Timer Timer Overflow Interrupt Enable Timer Overflow Interrupt Flag: set to when overflow Timer Output Compare B Match Interrupt Enable: to enable Timer Output Compare B Match Flag: set to when match Timer Output Compare A Match Interrupt Enable: to enable Timer Output Compare A Match Flag: set to when match Timer Input Capture Flag: set to when capture event occurs Timer Input Capture Interrupt Enable: to enable For Timer 2 For Timer 2 This register has flags that indicate when a timer interrupt occurs. 4/57 42/57 Lecture 9 s sequence 9.3 Timer applications In this section, we consider three applications of Timer. 9. Interrupt programming in C for ATmega Creating an accurate delay using timer overflow interrupt Timers in ATmega Measuring elapsed time between two events. 9.3 Timer applications Measuring the period of a square signal using input capture interrupt. 43/57 44/57

12 9.3. Creating an accurate delay Write a C program for ATmega6 to toggle PORTB every 2 seconds. It should use Timer overflow interrupt to create delays of 2s each. Analysis (video) Internal system clock: MHz. With no prescaler, Timer increments every μs. Timer is 6-bit counter, so it will overflow every 2 6 μs. For a 2s delay, we need Timer to overflow for 2s/2 6 μs = 3 times. Coding Write code to enable & intercept t Timer overflow interrupt. t Use interrupt handler to count the number of overflows. When the number of overflows is 3, toggle port B. Creating an accurate delay: timer_delay.c #include <avr/io.h> #include <avr/interrupt.h> volatile int overflow_count; ISR(TIMER_OVF_vect){ // handler for Timer overflow interrupt overflow_count++; // increment overflow count if (overflow_count >= 3){ // when 2s has passed overflow_count = ; // start new count PORTB = ~PORTB; // toggle port B int main(void) { DDRB = xff; // set port B for output PORTB = x; // initial value of PORTB overflow_count = ; // initialise overflow count TCCRA = b; // normal mode TCCRB = b; // no prescaler, internal clock TIMSK = b; // enable Timer overflow interrupt sei(); // enable interrupt subsystem globally while (){; return ; // infinite loop 45/57 46/ Measuring elapsed time Measuring elapsed time To measure time using Timer, we must keep track of both Use Timer to measure the execution time of some custom C code. the number of times that Timer has overflowed: n the current counter value: TCNT Approach: If we reset n and TCNT at the beginning of the interval, then the time elapse is (assuming no prescaler, MHz clock) t = n x TCNT (μs) Clear Timer when the code starts. Record Timer when the code finishes. Also, use Timer Overflow Interrupt to keep track of how many n = TCNT = Timer Overflows TCNT times it has overflowed. 2 n time interval t start t at time t stop at time t 2 47/57 48/57

13 Measuring elapsed time: measure_time.c #include <avr/io.h> #include <avr/interrupt.h> #include <inttypes.h> volatile uint32_t t n; ISR(TIMER_OVF_vect){ // handler for Timer overflow interrupt n++; // increment overflow count int main(void) { int i, j; uint32_t elapse_time; // uint32_t is unsigned 32-bit integer data type TCCRA = b; // normal mode TCCRB = b; // no prescaler, internal clock TIMSK = b; // enable Timer overflow interrupt Measuring period of a square signal Use Timer input capture interrupt to measure the period of a square wave. Analysis: The period of a square wave = the time difference between two consecutive rising edges. Connect the square wave to input capture pin of Timer. Configure input capture module to trigger on a rising edge. n = ; // reset n TCNT = ; // reset Timer sei(); // enable interrupt subsystem globally // start code for (i = ; i < ; i++) for (j = ; j < ; j++){; // end code elapse_time = n * (uint32_t) TCNT; cli(); // disable interrupt subsystem globally return ; Input capture interrupt is triggered. Read ICR register. period Input capture interrupt is triggered. Read ICR register again. square waveform 49/57 5/57 Measuring period of a square signal measure_period.c Assumption: the input signal has a high frequency, hence timer overflow can be ignored. #include <avr/io.h> #include <avr/interrupt.h> #include <inttypes.h> uint6_t period; // data type: unsigned 6-bit integer Implementation: Select timer operations: normal, no prescaler, internal clock MHz, noise canceller enabled, input capture for rising edges. TCCRA = b; TCCRB = b; ISR(TIMER_CAPT_vect){ // handler for Timer input capture interrupt period = ICR; // period = value of Timer stored in ICR TCNT = ; // reset Timer PORTB = ~(period >> 8); // display top 8-bit of period on PORT B int main(void) { DDRB = xff; // set port B for output Enable input capture interrupt: TIMSK = b; TCCRA = b; // normal mode TCCRB = b; // no prescaler, rising edge, noise canceller TIMSK = b; // enable Timer input capture interrupt sei(); // enable interrupt subsystem globally while (){; // infinite loop return ; 5/57 52/57

14 Testing measure_period.c Write To test a C the interrupt-driven code for measuring program period: to toggle port B whenever a switch on the STK5 board is pressed. The program should use an external Connect Input Capture pin (D.6) to square wave generator on interrupt. WishMaker. Connect GRD pin of Port D to GRD pin of WishMaker. Connect Port B to LED connector. Compile, download program. Change frequency of square ware and observe output on LEDs. Extending measure_period.c This example assumes no timer overflow between two rising edges of the square signal. In Lab 9, you are required to extend the code to measure the period for low-frequency signals. It is necessary to intercept timer overflow (see Examples 9.3. & 9.3.2). Video demo: [avr]/ecte333/measure_period.mp4 For testing, the measured period should be sent to PC via serial port. 53/57 54/57 Lecture 9 s summary Lecture 9 s references What we learnt in this lecture: How to write an interrupt-driven program in C for ATmega6. Programming serial and external interrupts in C. Overview of timers in ATmega6. Using Timer overflow and input capture interrupts in 3 applications. What are the next activities? Tutorial 9: Timers. Lab 9: Timers Complete the online Pre-lab Quiz for Lab 9. Write programs for Tasks and 2 of Lab 9. See video demos of Lab 9: [avr]/ecte333/lab9_task.mp4 [avr]/ecte333/lab9_task2.mp4 J. Pardue, C Programming for Microcontrollers, 25, SmileyMicros, [Chapter 7: Interrupts ]. Atmel Corp., 8-bit AVR microcontroller with 6K Bytes In-System Programmable Flash ATmega6/ATmega6L, 27, [Interrupts], t [External Interrupts] t and [Timers]. S. F. Barrett and D. J. Pack, Atmel AVR Microcontroller Primer: Programming and Interfacing, 28, Morgan & Claypool Publishers, [Chapter 5: Timing Subsystem]. 55/57 56/57

15 Lecture 9 s references M. Mazidi, J. Mazidi, R. McKinlay, The 85 microcontroller and embedded systems using assembly and C, 2 nd ed., Pearson Prentice Hall, 26, [Chapters 9]. M. Mazidi and J. Mazidi, The 886 IBM PC and compatible computers, 4 th ed., Pearson Prentice Hall, 23, [Chapters 3]. P. Spasov, Microcontroller technology the 68HC, 3 rd ed., Prentice Hall, 999, [Chapters ]. H. Huang, MC68HC2 an introduction: software and hardware interfacing, Thomson Delmar Learning, 23, [Chapter 8]. 57/57

Topic 11: Interrupts ISMAIL ARIFFIN FKE UTM SKUDAI JOHOR

Topic 11: Interrupts ISMAIL ARIFFIN FKE UTM SKUDAI JOHOR Objectives To become familiar with interrupts on the AVR Maskable and non-maskable Initialization Triggers To develop interrupt service routines