Programming All External Interrupt Sources of Atmega16

In previous post, I show a simple programming example of INT0. As it's already stated, the Atmega16 has up to 3 external interrupt sources. In this example, I use all its external interrupt sources, the INT0, the INT1, and the INT2.

I select the low logic level of these interrupt source to trigger the ISR. Whenever any interrupt occurs, its corresponding output LEDs will toggle its logic state. The output LEDs are PB5, PB6, and PB7.

Program simulation

Source Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

/* * atmega16AllExtIntEx.c * * Created: 6/10/2022 7:06:23 PM * Author : Admin */ #include <avr/io.h> #include <avr/interrupt.h> int main(void) { //PD2 and PD3 Input DDRD&=~(1<<2); DDRD&=~(1<<3); //Turn on PD2 and PD3 high PORTD|=(1<<2)|(1<<3); //PortB output DDRB=0xFF; //PB2 input DDRB&=~(1<<2); //Turn PB2 high PORTB|=(1<<2); //Enable INT0...2 request GICR|=(1<<INT0)|(1<<INT1)|(1<<INT2); //Enable interrupt sei(); //Clear Flag GIFR|=(1<<INTF0); while (1) { } return 0; } //Interrupt Service Routine - ISR ISR(INT0_vect){ //Toggle RB5 PORTB^=0x20; } ISR(INT1_vect){ //Toggle RB6 PORTB^=0x40; } ISR(INT2_vect){ //Toggle RB7 PORTB^=0x80; }

Click here to download its zip file.

ATMega16 two-digit multiplexing display and counting example

Display multiplexing is very common for most microcontroller programming and interfacing. In usual, a controller could drive up to 8 digits before we can see its display flickering. In this programming example, I use only two digits of 7-Segment display. Because it's easy to build the circuit with a  little of source codes.

Program simulation in Proteus

Controller keeps track of counting an external pulse generated by SW1 switch pressing. The maximum press counting is 60 before it rolls down to 0. The display will become flicker whenever the input switch has a longer press duration, but it's not longer than 250ms.

/*
 * mux2Ssd.c
 *
 * Created: 5/25/2022 7:20:40 PM
 * Author : Admin
 */ 
 
#include <avr/io.h>
 
#define F_CPU 4000000UL
#include <util/delay.h>
 
int main(void)
{
    //common cathode
    unsigned char SSD[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
	unsigned char cnt=0;
	//PortC output
	DDRC=0xFF;
	//PD7 input
	DDRD&=~(1<<7);	
	//Turn on PD7
	PORTD|=(1<<7);
    while (1) 
    {
		//Display processing
		PORTD&=~(1<<0);
		PORTD&=~(1<<1);
		PORTC=SSD[cnt/10];
		PORTD|=(1<<0);
		_delay_ms(3);
 
		PORTD&=~(1<<0);
		PORTD&=~(1<<1);
		PORTC=SSD[cnt%10];
		PORTD|=(1<<1);
		_delay_ms(3);
 
		//Input Testing
		if ((PIND&0x80)==0)
		{
			//while((PIND&0x80)==0);
			cnt++;
			_delay_ms(250);
		}
		if(cnt>=60) cnt=0;
    }
}
 
 

Click here to download source file.

Schematic diagram

Atmega16 external interrupt programming example

Atmega16 has up to 21 interrupt sources. Here I will discuss only the external interrupt of this controller. External interrupt consist of three source sources:

1. INT0 - External interrupt request 0
2. INT1 - External interrupt request 1, and
3. INT2 - External interrupt request 2.

First I will show how to use INT0 source. It has four sense that determine whether the interrupt is triggering. It is the Interrupt Sense Control register bits of the MCU Control Register (MCUCR).

MCU Control Register (MCUCR)

 Interrupt Sense Control register bits

The General Interrupt Control Register (GICR) turn on and off these external interrupt source, including the INT0 source.

General Interrupt Control Register – GICR

They also have their corresponding interrupt flag in the General Interrupt Flag Control (GIFR).

General Interrupt Flag Control (GIFR)

There are three bit corresponding to INTF1, INTF0, and INTF2. These bits will be cleared after the Interrupt Service Routine (ISR) executed. Optionally the programmer can clear any flag by setting it. However it is uncommon from most of microcontrollers.

In C programming the interrupt is very easy to program that I will show it in this programming example.

In this example I use only the INT0 source. The interrupt sense is the falling edge of INT0, as I will select it in program. Each time the INT0 occurs, and output LED connects to PD7 will toggle.

Schematic Diagram

The source code is very simple. It contains a little lines of code.

/*
 * int0Example1.c
 *
 * Created: 5/27/2022 6:45:11 PM
 * Author : Admin
 */ 
 
#include <avr/io.h>
 
#include <avr/interrupt.h>
 
int main(void)
{
    //PortD output
	DDRD=0xFF;
	//RD2 input
	DDRD&=~(1<<2);
	//Turn on RD2
	PORTD|=(1<<2);
	//Select falling edge of INT0
	MCUCR|=(1<<ISC01);
	//Enable INT0 request
	GICR|=(1<<INT0);
	//Enable interrupt
	sei();
	//Clear Flag
	GIFR|=(1<<INTF0);
    while (1) 
    {
    }
}
 
//Interrupt Service Routine - ISR
ISR(INT0_vect){
	//Toggle PD7
	PORTD^=0x80;
}
 

Click here to download it source file.

Displaying an External Pulse Counting Using ATMega16 Timer/Counter0

 

Introduction

As mentioned in previous post, configuring Timer/Counter0 module of ATMega16 to drive in counter mode the programmer doesn’t need to write a program routine to count external input pulse. The counter is automatically increase its content with the present of input pulse change.

Since counter mode is fast, the system can show its content on a multiplexing display without flickering. In this example of using Timer/Counter0 module, the system accept a number of input pulse from external device using its peripheral hardware inside. Its result will be displayed on a three-digit multiplexing display.

Hardware and Software Preparation

This programming example is solely experimented on a personal computer. Embedded controller’s program is written using embedded C in Atmel Studio 7 while its hardware experiment will be tested in Proteus simulator.

Hardware Preparation

Proteus is a good choice for electronics circuit design and simulation. Software simulation produces a nearby result to physical hardware test.

Schematic diagram preparation for system simulation

The user can choose another lower frequency of its crystal oscillator, but the delay function parameter must be properly set in software.

An optional square wave generator GEN1 supplies a variable high frequency. It’s enabled/disabled by a latched switch SW2.

Software Preparation

Software setting of counter mode of Timer/Counter0 peripheral is done within a few lines of code. Another routine is written to handle multiplexing display. This three-digits display made of some little more lines of code.

C

/*

 * counter0MuxDisplay.c

 *

 * Created: 12/15/2020 9:49:40 PM

 * Author : admin

 */ 

​

#include <avr/io.h>

​

#define F_CPU 16000000UL

#include <util/delay.h>

​

/*Each digit active for 5ms*/

#define digitOn 5

​

void driveDisplay(void){

    /*7-Segments data for common cathode type display*/

    char cCathode[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};

    // digit 3

    PORTD=0x00;

    PORTC=cCathode[TCNT0/100];

    PORTD=0x04;

    _delay_ms(digitOn);

    //digit 2

    PORTD=0x00;

    PORTC=cCathode[(TCNT0%100)/10];

    PORTD=0x02;

    _delay_ms(digitOn);

    //digit 1

    PORTD=0x00;

    PORTC=cCathode[TCNT0%10];

    PORTD=0x01;

    _delay_ms(digitOn);

}

​

int main(void)

{

    /*Counter Mode, Rising Edge Detection*/

    TCCR0=(1<<CS02)|(1<<CS01)|(1<<CS00);

    /*Port C Drives Segments*/

    DDRC=0xFF;

    /*PD0.2 Drives Digits*/

    DDRD=0x07;

    while (1) 

    {

        /*Display The Result*/

        driveDisplay();

    }

}

I created a label for delay function parameter. It’s “digitOn”, and it’s set to 5 (ms). it’s useful for code modification in later hardware test.

Proteus Simulation

Without spending time in physical hardware prototyping, the programmer can draw this example circuit in simulator. It also save a lot of time and budget of components purchasing.

Proteus simulation of this working example

The result shown on this picture is 195 in decimal. the maximum counting of the 8-bit TCNT0 register is 0xFF or 255 in decimal. After it reached 255 it will roll back to 0 at next counting.

Creating A 16-bit Counter

We can get a 16-bit counting register from this 8-bit TCNT0 register by adding one more 8-bit register. An additional C unsigned 16-bit integer stores the total counting result up to 65536 counts.

Circuit Diagram Preparation

This optional programming example has some variation on its output display. It’s a five-digit multiplexing display that show a counting variable up to 65536 counts before it rolls back to 0.

Proteus VSM circuit diagram for hardware prototyping and simulation

I added a counter timer virtual instrument to verify the counting result whenever the counter is supplied from a high speed square wave generator GEN1.

AVR GCC Code Preparation

I added an unsigned 8-bit character and another unsigned 16-bit integer to get a 16-bit counting variable in AVR GCC.

Since interrupt flag created by Timer/Counter0 Overflow (TOV0) is set whenever TCNT0 overflows and rolls back to 0, we test and clear this flag to update the 16-bit counting variable.

Unlike previous example of an 8-bit counter, this 16-bit counter needs a five-digit display. The need to add more lines of code to the program that drive this multi-digit multiplexing display. We will more embedded C codes in this example.

C

/*

 * counter0MuxDisplay_2.c

 *

 * Created: 12/16/2020 12:44:43 PM

 * Author : admin

 */ 

​

#include <avr/io.h>

​

#define F_CPU 16000000UL

#include <util/delay.h>

​

/*Each digit active for 5ms*/

#define digitOn 5

​

/*Auxiliary Counting Variables */

unsigned char tcnt0_1=0;

unsigned int  totalCounter=0;

​

void driveDisplay(void){

    /*7-Segments data for common cathode type display*/

    char cCathode[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};

    /*Test TOV0 Flag To Update The Result*/

    if (TIFR&(1<<TOV0))

    {

        TIFR=0x01;

        tcnt0_1+=1;

    }

    /*Make a 16-bit Counting Variable*/

    totalCounter=(tcnt0_1*256)+TCNT0;

    //digit 5

    PORTD=0x00;

    PORTC=cCathode[totalCounter/10000];

    PORTD=(1<<3);

    _delay_ms(digitOn);

    //digit 4

    PORTD=0x00;

    PORTC=cCathode[(totalCounter%10000)/1000];

    PORTD=(1<<4);

    _delay_ms(digitOn);

    // digit 3

    PORTD=0x00;

    PORTC=cCathode[(totalCounter%1000)/100];

    PORTD=(1<<5);

    _delay_ms(digitOn);

    //digit 2

    PORTD=0x00;

    PORTC=cCathode[(totalCounter%100)/10];

    PORTD=(1<<6);

    _delay_ms(digitOn);

    //digit 1

    PORTD=0x00;

    PORTC=cCathode[totalCounter%10];

    PORTD=(1<<7);

    _delay_ms(digitOn);

}

​

int main(void)

{

    /*Counter Mode, Rising Edge Detection*/

    TCCR0=(1<<CS02)|(1<<CS01)|(1<<CS00);

    /*Port C Drives Segments*/

    DDRC=0xFF;

    /*Port D Drives Digits*/

    DDRD=0xFF;

    /*Clear TOV0*/

    TIFR=0x01;

    /*Clear Counter*/

    TCNT0=0;

    while (1) 

    {

        /*Display The Result*/

        driveDisplay();

    }

}

We will see its simulation result at the next section.

Simulation Result

This circuit diagram composes of a lot of components placement and breadboard wiring. Using a simulator could produce a comparable result to the one’s in physical hardware.

Simulation result in Proteus VSM of this working example

Square wave generator GEN1 creates a frequency of 5kHz for this counter. Timer counter counts a nearby result with respect to the microcontroller counter. This microcontroller counting system reset its content whenever it reaches the maximum value of 65536 counts.