Arduino - interrupções

As interrupções param o trabalho atual do Arduino para que algum outro trabalho possa ser feito.

Suponha que você esteja sentado em casa, conversando com alguém. De repente, o telefone toca. Você para de bater papo e pega o telefone para falar com o chamador. Ao terminar a conversa telefônica, você volta a conversar com a pessoa antes que o telefone toque.

Da mesma forma, você pode pensar na rotina principal como conversar com alguém; o toque do telefone faz com que você pare de conversar. A rotina do serviço de interrupção é o processo de falar ao telefone. Quando a conversa telefônica termina, você volta à sua rotina principal de bate-papo. Este exemplo explica exatamente como uma interrupção faz com que um processador aja.

O programa principal está sendo executado e executando alguma função em um circuito. No entanto, quando ocorre uma interrupção, o programa principal é interrompido enquanto outra rotina é executada. Quando essa rotina termina, o processador volta à rotina principal novamente.

Caracteristicas importantes

Aqui estão alguns recursos importantes sobre interrupções -

As interrupções podem vir de várias fontes. Nesse caso, estamos usando uma interrupção de hardware que é acionada por uma mudança de estado em um dos pinos digitais.
A maioria dos projetos do Arduino tem duas interrupções de hardware (conhecidas como "interrupção 0" e "interrupção 1") conectadas aos pinos de E / S digital 2 e 3, respectivamente.
O Arduino Mega possui seis interrupções de hardware, incluindo as interrupções adicionais ("interrupt2" a "interrupt5") nos pinos 21, 20, 19 e 18.
Você pode definir uma rotina usando uma função especial chamada “Rotina de serviço de interrupção” (geralmente conhecida como ISR).
Você pode definir a rotina e especificar as condições na borda ascendente, na borda descendente ou em ambas. Nessas condições específicas, a interrupção seria atendida.
É possível que essa função seja executada automaticamente, cada vez que um evento acontecer em um pino de entrada.

Tipos de interrupções

Existem dois tipos de interrupções -

Hardware Interrupts - Eles ocorrem em resposta a um evento externo, como um pino de interrupção externa ficando alto ou baixo.
Software Interrupts- Eles ocorrem em resposta a uma instrução enviada no software. O único tipo de interrupção que a “linguagem Arduino” suporta é a função attachInterrupt ().

Usando interrupções no Arduino

As interrupções são muito úteis em programas Arduino, pois ajudam a resolver problemas de temporização. Uma boa aplicação de uma interrupção é ler um codificador rotativo ou observar uma entrada do usuário. Geralmente, um ISR deve ser o mais curto e rápido possível. Se o seu esboço usa vários ISRs, apenas um pode ser executado por vez. Outras interrupções serão executadas após o término da atual em uma ordem que depende da prioridade que elas têm.

Normalmente, as variáveis globais são usadas para passar dados entre um ISR e o programa principal. Para garantir que as variáveis compartilhadas entre um ISR e o programa principal sejam atualizadas corretamente, declare-as como voláteis.

sintaxe da instrução attachInterrupt

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs; 
   //this function must take no parameters and return nothing. 
   //This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

As três constantes a seguir são predefinidas como valores válidos -

LOW para acionar a interrupção sempre que o pino estiver baixo.
CHANGE para acionar a interrupção sempre que o valor do pino for alterado.
FALLING sempre que o pino vai de alto para baixo.

Example

int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
   pinMode(13, OUTPUT); //set pin 13 as output
   attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
   //interrupt at pin 2 blink ISR when pin to change the value
} 
void loop() { 
   digitalWrite(13, state); //pin 13 equal the state value
} 

void blink() { 
   //ISR function
   state = !state; //toggle the state when the interrupt occurs
}