No último tutorial, vimos como funcionam os tempos de espera no nosso Arduino, foi falado na função delay e na micros, funções que nos permitem fazer “tempos de espera” no tempo na nossa placa. No tutorial de hoje iremos falar de Interrupts, uma maneira mais pertinente de trabalharmos com a gestão de eventos no nosso Arduino.
Os Interrupts, como o próprio nome indica, são interrupções que existem no nosso programa. Numa maneira muito resumida, uma interrupção ou Interrrupt é um sinal emitido, para o nosso programa, indicando que um determinado evento está a precisar da sua total atenção. Para tal, precisa imediatamente de parar o que está a fazer e dar atenção a esse evento. Após ter efetuado essa ação prioritária, o programa continua o seu funcionamento a partir de onde foi interrompido.
No Arduino podemos trabalhar com os Interrupts externos e Timer Interrupts.
Interrupts Externos
Os Interrupts, num modo geral, são efetuados ao nível do Hardware, onde um evento externo é acionado e enviado um sinal para o processador. Por exemplo, quando um botão é premido ou quando recebemos informação de um encoder de um motor. Basicamente quando há uma ação ao nível do hardware e queremos que seja efetuada de imediato, que seja prioritária. Contudo os Interrupts externos são fantásticos mas tornam-se um pouco limitados, não a sua capacidade mas em relação à sua quantidade, nem todas os pinos no Arduino suportam Interrupts externos. No caso do Arduino Uno somente suporta dois interrupts (0 e 1) que estão atribuídos nos pinos digitais 2 e 3 da nossa placa. Mas, para grande satisfação, o Arduino Due tem todos os pinos digitais Interrupts. O código para os Interrupts externos é bastante simples e fácil de entender, basicamente basta indicar o interrupt, o que irá fazer e quando o irá executar.
int botao = 2;
unsigned long tempoanterior = 0;
const long intervalo = 1000;
void setup() {
pinMode(botao, INPUT_PULLUP);
attachInterrupt(0, teste, RISING); // Definição do Interrupt:(O Interrupt a usar, função para ser executada, Executar quando for de LOW para HIGH
Serial.begin(9600);
}
// Função para o Interrupt
void teste() {
Serial.println(“Interrupt Externo”);
}
void loop() {
if (millis() – tempoanterior >= intervalo) {
tempoanterior = millis();
Serial.println(“Programa a executar”);
}
}
Como podemos ver no código acima apresentado, somente temos que adicionar duas coisas para podermos usar um Interrupt externo, a declaração do Interrupt e uma função que contenha o código que queiramos que seja executado. Nos parâmetros de entrada do attachInterrupt() é necessário colocar o número do Interrupt que vai ser usado, (no caso do Arduino Uno o Interrupt 0 está atrubuido ao pino digital 2 e o Interrupt 1 ao pino digital 3), a função que irá ser executada assim que o Hardware chama ou der sinal ao Arduino. No nosso código temos como último parâmetro RISING, isto significa que o Interrupt irá ser ativado quando o pino do Interrupt for de LOW para HIGH, ou seja, quando for de 0 para 1. Além do RISING existem outros parâmetros, tais como:
- FALLING – Quando vai de LOW para HIGH
- CHANGE – Quando o estado do pino é alterado
- LOW – Quando o nosso pino estiver em LOW
- HIGH – Quando o nosso pino estiver em HIGH ( esta opção só está disponível no Arduino DUE, Zero e MKR1000)
No código apresentado irá sempre apresentar a mensagem “Programa a executar” a cada 1 segundo, sempre que o utilizador prima o botão que está ligado ao pino 2, uma interrupção ocorre no nosso programa e durante esse tempo é mostrada a mensagem “Interrupt Externo”.
Timer Interrupts
Os Timer Interrupts têm um objetivo de funcionamento semelhante aos Interrupts Externos, só que somente é usado Software. Este tipo de Interrupts são muito pertinentes pois não contêm limitação de pinos, uma vez que tudo é tratado a nível do Software. Como não podemos ativar a interrupção segundo um tipo de estado de um determinado pino, para fazer a interrupção iremos usar o tempo. Ou seja de x em x de tempo uma interrupção vai acontecer no nosso programa e será executada uma determinada ação. Funciona exatamente da mesma maneira que os Interrupts externos, mas invés de estar à espera de uma determinada ação do Hardware, é através de tempo. Uma das utilizações para os Timer Interrupts é nas leituras dos Sonares, onde queremos que, num determinado tempo, o eco do nosso sonar seja lido, mas num tutorial mais à frente iremos falar do funcionamento dos Sonares e aí entramos em mais pormenor.
Para usarmos os Timer Interrupts no nosso Arduino é necessário usar a a biblioteca TimerOne. Podemos fazer o download da mesma nos repositórios oficiais do Arduino. Esta biblioteca pode ser usada em todos os Arduinos exceto no Arduino Due onde, neste caso, a biblioteca semelhante é a DuoTimer.
#include <TimerOne.h>
unsigned long tempoanterior = 0;
const long intervalo = 1000;
void setup() {
Timer1.initialize(2500) // Inicializa o Timer da interrupção(microsegundos)
Timer1.setPeriod(25000); // Define o Tempo em que irá ocorrer a proxima interrupção(microsegundos)
Timer1.attachInterrupt(teste); // Atribui a função teste ao Interrupt
Serial.begin(9600);
}
// Função para o Interrupt
void teste() {
Serial.println(“Timer Interrupt”);
}
void loop() {
if (millis() – tempoanterior >= intervalo) {
tempoanterior = millis();
Serial.println(“Programa a executar”);
}
}
O código acima apresentado tem o mesmo objetivo que o exemplo dos External Interrupts, mas fazendo uma pequena alteração: invés de a interrupção existir com a indicação do Hardware (neste caso do botão) é com uma indicação temporal, em cada 2,5 segundos irá haver uma interrupção no programa e irá ser executada a função teste().
Como podemos observar neste artigo, o uso de Interrupts é muito simples e, ao mesmo tempo, muito útil. Após termos este conhecimento, podemos deixar de parte a função delay() que tantos problemas nos dá quando estamos a trabalhar em multitasking no nosso Arduino. Neste tutorial foi apenas exemplificado o básico da utilização dos Interrupts, iremos trabalhar mais neles em futuros projetos.