IFC - Instituto Federal Catarinense, Campus Luzerna - Programação Aplicada a Microcontroladores

AULA 11 - INTERRUPÇÕES E CONTADORES

Estudo das interrupções, dos contadores e dos temporizadores

11.1 Objetivo:
Nesta aula serão estudadas funções internas do hardware do microcontrolador utilizado no
Arduino. O primeiro assunto abordado são as interrupções, seguido pelos contadores e
temporizadores. O objetivo do estudo destes conteúdos é permitir aos alunos que utilizem estes
recursos de hardware para desenvolver seus programas.

11.2 Interrupções no Arduino

Interrupções são desvios realizados no programa pelo hardware do microcontrolador, ou
seja, uma função do programa é chamada quando algum evento acontece no hardware do Arduino.
As interrupções são instrumentos muito úteis na programação do Arduino, pois é através delas é
possível executar várias tarefas ao mesmo tempo, de forma paralela.
Estas funções, que são chamadas pelas interrupções são chamadas de ISRs e possuem
algumas limitações únicas que as outras funções não possuem. Uma ISR não recebe argumentos, e
não pode retornar nada. Geralmente, uma ISR deve ser o mais curta e rápida possível. Se o seu
programa usa múltiplas ISRs, apenas uma pode ser executada de cada vez, outras interrupções serão
executadas após a atual terminar, em uma ordem que depende de sua prioridade.
A função millis() depende de interrupções para contar, então essa nunca deverá ser utilizada
dentro de uma ISR. O mesmo acontece com a função delay(). A função micros() funciona
inicialmente, mas começará a se comportar erraticamente após 1-2 ms. A função
delayMicroseconds(), por sua vez, não usa nenhum contador, então funciona normalmente.
Outra questão que deve ser levada em conta quando se fala de ISRs são as variáveis.
Tipicamente variáveis globais são usadas para passar dados entre uma ISR e o programa principal,
porém, para que isso funcione estas variáveis devem ser declaradas usando o modificador volatile.
Existem várias fontes de interrupção no Arduino, como por exemplo, os pinos de interrupção
externa, os temporizadores, o conversor A/D, a comunicação serial etc.
O número de entradas que suportam interrupções esternas varia conforme o modelo do
Arduino. No caso do Arduino uno pode-se utilizar os pinos 2 e 3.

Professor Ricardo Kerschbaumer 94

IFC - Instituto Federal Catarinense, Campus Luzerna - Programação Aplicada a Microcontroladores
11.2.1 Configuração das Interrupções externas
O Arduino fornece uma função específica para configurar as interrupções externas. Esta
função é a attachInterrupt(). A sintaxe desta função é a seguinte.

attachInterrupt(digitalPinToInterrupt(pino), ISR, modo);

Onde:
pino: é o pino do Arduino (2 ou 3).
ISR: é o nome da função que deve ser executada pela interrupção.
modo: é o modo de ativação da interrupção, que pode ser,
• LOW acionar a interrupção quando o estado do pino for LOW,
• CHANGE acionar a interrupção quando o sempre estado do pino mudar
• RISING acionar a interrupção quando o estado do pino for de LOW para HIGH apenas,
• FALLING acionar a interrupção quando o estado do pino for de HIGH para LOW apenas.

A seguir temos um exemplo de programa que utiliza a interrupção externa no Arduino.

const int pinoLed = 9;

const int pinoInterrupcao = 2; // só podem ser os pinos 2 ou 3

volatile int estado = LOW;

void pisca() // função de interrupção

{
estado = !estado; // inverte o valor do estado
}

void setup()
{
pinMode(pinoLed, OUTPUT);
// ativa a interrupção
attachInterrupt(digitalPinToInterrupt(pinoInterrupcao), pisca, RISING);
}

void loop()
{
digitalWrite(pinoLed, estado);
}

Neste exemplo, um LED conectado ao pino 9 do Arduino é ligado e desligado através de um

botão conectado ao pino 2 do Arduino, com o auxílio da interrupção externa.
Observe que neste exemplo não é necessário verificar o estado do pino 2 para verificar se o
botão foi pressionado, o hardware o microcontrolador utilizado no Arduino faz isso
automaticamente.
Professor Ricardo Kerschbaumer 95
IFC - Instituto Federal Catarinense, Campus Luzerna - Programação Aplicada a Microcontroladores
Para um exemplo mais complexo utilizaremos o circuito da figura a seguir.

No circuito da figura temos as seguintes conexões.

Pino 2 – Botão de incremento.

Pino 3 – Botão de decremento.

Pino 7 – Segmento A do display.

Pino 8 – Segmento B do display.
Pino 9 – Segmento C do display.
Pino 10 – Segmento D do display.
Pino 11 – Segmento E do display.
Pino 12 – Segmento F do display.
Pino 13 – Segmento G do display.

O programa a seguir utiliza interrupções para incrementar e decrementar os números

apresentados no display.

Professor Ricardo Kerschbaumer 96

IFC - Instituto Federal Catarinense, Campus Luzerna - Programação Aplicada a Microcontroladores
volatile int cont=0; digitalWrite(7,HIGH);
digitalWrite(8,LOW);
void display(int n) digitalWrite(9,HIGH);
{ digitalWrite(10,HIGH);
if(n==0) digitalWrite(11,HIGH);
{ digitalWrite(12,HIGH);
digitalWrite(7,HIGH); digitalWrite(13,HIGH);
digitalWrite(8,HIGH); }
digitalWrite(9,HIGH); if(n==7)
digitalWrite(10,HIGH); {
digitalWrite(11,HIGH); digitalWrite(7,HIGH);
digitalWrite(12,HIGH); digitalWrite(8,HIGH);
digitalWrite(13,LOW); digitalWrite(9,HIGH);
} digitalWrite(10,LOW);
if(n==1) digitalWrite(11,LOW);
{ digitalWrite(12,LOW);
digitalWrite(7,LOW); digitalWrite(13,LOW);
digitalWrite(8,HIGH); }
digitalWrite(9,HIGH); if(n==8)
digitalWrite(10,LOW); {
digitalWrite(11,LOW); digitalWrite(7,HIGH);
digitalWrite(12,LOW); digitalWrite(8,HIGH);
digitalWrite(13,LOW); digitalWrite(9,HIGH);
} digitalWrite(10,HIGH);
if(n==2) digitalWrite(11,HIGH);
{ digitalWrite(12,HIGH);
digitalWrite(7,HIGH); digitalWrite(13,HIGH);
digitalWrite(8,HIGH); }
digitalWrite(9,LOW); if(n==9)
digitalWrite(10,HIGH); {
digitalWrite(11,HIGH); digitalWrite(7,HIGH);
digitalWrite(12,LOW); digitalWrite(8,HIGH);
digitalWrite(13,HIGH); digitalWrite(9,HIGH);
} digitalWrite(10,HIGH);
if(n==3) digitalWrite(11,LOW);
{ digitalWrite(12,HIGH);
digitalWrite(7,HIGH); digitalWrite(13,HIGH);
digitalWrite(8,HIGH); }
digitalWrite(9,HIGH); }
digitalWrite(10,HIGH);
digitalWrite(11,LOW); void aumenta() // função de interrupção
digitalWrite(12,LOW); {
digitalWrite(13,HIGH); cont++;
} }
if(n==4)
{ void diminui() // função de interrupção
digitalWrite(7,LOW); {
digitalWrite(8,HIGH); cont--;
digitalWrite(9,HIGH); }
digitalWrite(10,LOW);
digitalWrite(11,LOW); void setup()
digitalWrite(12,HIGH); {
digitalWrite(13,HIGH); pinMode(7, OUTPUT); //A
} pinMode(8, OUTPUT); //B
if(n==5) pinMode(9, OUTPUT); //C
{ pinMode(10, OUTPUT); //D
digitalWrite(7,HIGH); pinMode(11, OUTPUT); //E
digitalWrite(8,LOW); pinMode(12, OUTPUT); //F
digitalWrite(9,HIGH); pinMode(13, OUTPUT); //G
digitalWrite(10,HIGH); attachInterrupt(digitalPinToInterrupt(2), aumenta, RISING);
digitalWrite(11,LOW); attachInterrupt(digitalPinToInterrupt(3), diminui, RISING);
digitalWrite(12,HIGH); }
digitalWrite(13,HIGH); void loop()
} {
if(n==6) display(cont);
{ }

Professor Ricardo Kerschbaumer 97

IFC - Instituto Federal Catarinense, Campus Luzerna - Programação Aplicada a Microcontroladores
É importante observar que neste exemplo a interrupções incrementam e decrementam a
variável “cont”, assim foi necessário declarar esta variável com o modificador “volatile”.

11.3 Contadores e Temporizadores no Arduino

Os temporizadores e os contadores são elementos de hardware presentes no
microcontrolador utilizado no Arduino. Na realidade trata-se de um único elemento que realiza
ambas as tarefas. Isso se deve ao fato de um contador poder contar eventos e assim trabalhar como
um contador ou então contar tempo e trabalhar como um temporizador. Assim sendo um
temporizador nada mais é do que um contador que conta o tempo. No microcontrolador utilizado no
Arduino existem 3 destes contadores ou temporizadores.
Utilizaremos como exemplo o temporizador ou contador 1, que é composto por um contador
de 16 bits que pode contar eventos ou pulsos de clock, operando assim como temporizador. Ele
possui um divisor de frequência que pode ser utilizado para dividir o clock por um determinado
valor entes que este sinal seja aplicado ao contador. Este circuito é conhecido como prescaler.
A figura a seguir apresenta um diagrama de blocos do temporizador ou contador 1.

O temporizador ou contador 1 pode receber os pulsos para sua contagem tanto do circuito
interno como de um sinal externo. A fonte dos pulsos de contagem é definida nos registradores de
controle. A seguir são apresentados estes registradores.

Professor Ricardo Kerschbaumer 98

IFC - Instituto Federal Catarinense, Campus Luzerna - Programação Aplicada a Microcontroladores
TCCR1A – Registrador de controle do Timer 1 A

TCCR1B – Registrador de controle do Timer 1 B

Cada um destes registradores possui grupos de bits que devem ser configurados para ajustar
o modo de operação do contador ou temporizados. A configuração destes registradores não é trivial,
e requer uma leitura atenciosa do manual do microcontrolador utilizado no Arduino.

Além destes registradores existem ainda outros registradores que são utilizados na contagem
e na comparação dos valores dos temporizadores ou contadores.

A seguir é apresentado um exemplo de programa que utiliza o hardware do microcontrolador

como temporizador.

ISR(TIMER1_OVF_vect)
{
TCNT1 = 49911;
if(digitalRead(13)==LOW) {
digitalWrite(13,HIGH);
}
else {
digitalWrite(13,LOW);
}
}

void setup()
{ // configuração do temporizador
TCNT1 = 49911; // para 1 segundo
PRR &= ~(1 << PRTIM1);
TCCR1A = 0;
TCCR1B=(0<<WGM13)|(0<<WGM12)|0<<ICNC1|0<<ICES1|(1<<CS12)|(0<<CS11)|(1<<CS10);
TIMSK1 = 0 << OCIE1B | 0 << OCIE1A | 0 << ICIE1 | 1 << TOIE1;
sei();
pinMode(13,OUTPUT);
}

void loop()
{

Professor Ricardo Kerschbaumer 99

IFC - Instituto Federal Catarinense, Campus Luzerna - Programação Aplicada a Microcontroladores
Neste exemplo o temporizador 1 é configurado para executar uma interrupção de 1 em 1
segundo, esta interrupção é utilizada para ligar ou desligar o LED conectado ao pino 13 do Arduino.
Os temporizadores e contadores são assunto bastante amplo e complexo, o próprio Arduino
não possui suporte nativo a todas as funções destes componentes de hardware.
Este material apresentou apenas um pequeno exemplo de temporizadores ou contadores, para mais
informações o manual do microcontrolador deve ser consultado.

11.4 Conclusão
Esta aula aforam apresentados temas relacionados a funções mais específicas do
microcontrolador utilizado no Arduino. O assunto e bastante amplo, e esta aula serve apenas para
demostrar superficialmente o funcionamento destes componentes. Maiores informações sobre o
microcontrolador utilizado no Arduino podem ser encontrada em:
http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-
ATmega328P_Datasheet.pdf.
Na próxima aula serão apresentados as entradas analógicas e as saídas PWM do Arduino.

11.5 Exercício
1) Implemente o exemplo de programa que utiliza as interrupções externas para alterar os números
do display no ThinkerCad e verifique seu funcionamento.

2) Implemente o exemplo de programa que utiliza as interrupções externas para alterar os números
do display no Arduino e verifique seu funcionamento.

3) Implemente o exemplo de programa do temporizador de 1 segundo no ThinkerCad e verifique

seu funcionamento.

4) Implemente o exemplo de programa do temporizador de 1 segundo no Arduino e verifique seu

funcionamento.

Professor Ricardo Kerschbaumer 100