LAB - PIO - IRQ - Parte 1

Iremos entender melhor e começar a implementar mudanças no código de exemplo.

Bordas

Agora vamos modificar o código um pouco, o exemplo está funcionando com interrupção em borda de descida no pino, ou seja, a função de callback é chamada quando você aperta o botão (High -> Low). Iremos modificar o comportamento para operar com borda de subida, fazendo com que a função de callback seja chamada quando soltarmos o botão (Low -> High).

-pio_configure(BUT_PIO, PIO_INPUT, BUT_IDX_MASK, PIO_PULLUP);
+pio_configure(BUT_PIO, PIO_INPUT, BUT_IDX_MASK, PIO_PULLUP | PIO_DEBOUNCE);
+pio_set_debounce_filter(BUT_PIO, BUT_IDX_MASK, 60);

IRQ - Keep it short and simple

O tempo que um firmware deve ficar na interrupção deve ser o menor possível, pelos principais motivos:

1. Outras interrupções de mesma prioridade irão aguardar o retorno da interrupção. O firmware irá deixar de servir de maneira rápida a diferentes interrupções se gastar tempo nelas.
2. Nem todas as funções são reentrantes. Funções como printf podem não operar corretamente dentro de interrupções por poderem ser chamadas mais de uma vez, sem terem terminado de executar.
3. RTOS: As tarefas devem ser executadas em tasks e não nas interrupções, possibilitando assim um maior controle do fluxo de execução do firmware (vamos ver isso mais para frente).

Para maiores informações acesse: https://betterembsw.blogspot.com/2013/03/rules-for-using-interrupts.html

Existem algumas soluções para essa questão, a mais simples delas é a de realizar o processamento de uma interrupção no loop principal (while(1)), essa abordagem é muito utilizada em sistemas embarcados. E deve ser feita da forma a seguir:

• Define-se uma variável global que servirá como flag (true ou false) [^1] e importante, essa variável precisa ser do tipo volatile)
• Interrupção altera o status da flag para True
• while(1) verifica status da flag para realizar ação.
• while(1) volta a flag para o estado original False.

Analise o exemplo a seguir que ilustra o uso de flags para tratar o evento no botão:

/* flag */
volatile char but_flag; // (1)

/* funcao de callback/ Handler */
void but_callBack(void){
  but_flag = 1;
}

void main(void){
  /* inicializacao */
  // ....
  // ...

  while(1){

   if (but_flag) {  // (2)
       pisca_led(5, 200);    
       but_flag = 0; // (3)
   }
  }
}

1. :man_raising_hand: Note que a variável que será utilizada como flag foi declarada como volatile
2. O bloco de código dentro do if só será processado quando o but_flag for True
3. Essa linha é muito importante pois sem ela o bloco do if seria executuado novamente sem o evento externo do botão.

Low power modes

Trabalhar por interrupção possui várias vantagens, e uma delas é a possibilidade de fazer o uC entrar em modos de operação de baixo consumo energético (sleep modes).

No caso do uC utilizado no curso, são 4 modos distintos de lowpower, cada um com sua vantagem / desvantagem:

• Active Mode: Active mode is the normal running mode with the core clock running from the fast RC oscillator, the main crystaloscillator or the PLLA. The Power Management Controller can be used to adapt the core, bus and peripheral frequencies and to enable and/or disable the peripheral clocks.

• Backup mode: The purpose of Backup mode is to achieve the lowest power consumption possible in a system which is performing periodic wake-ups to perform tasks but not requiring fast startup time.

• Wait mode: The purpose of Wait mode is to achieve very low power consumption while maintaining the whole device in a powered state for a startup time of less than 10 us.

• Sleep Mode: The purpose of sleep mode is to optimize power consumption of the device versus response time. In this mode, only the core clock is stopped. The peripheral clocks can be enabled. The current consumption in this mode is application-dependent

Adicionando a lib de lowpower mode (ASF Wizard)

Para termos acessos as funções da Microchip que lidam com o sleep mode devemos adicionar a biblioteca Sleep manager (service) no Microchip Studio:

• ASF ASF Wizard

Agora basta adicionar a biblioteca Sleep manager (service) ao projeto.

Entrando em lowpower

Agora podemos usar as funções de low power, primeiramente iremos utilizar somente o modo sleep mode via a chamada da função pmc_sleep() conforme exemplo a seguir:

void main(void){ 
  while(1){
     if (but_flag) { ... }

     // Entra em sleep mode    
     pmc_sleep(SAM_PM_SMODE_SLEEP_WFI); // (1)
  }
}

1. Código 'trava' aqui até ser 'acordado'

Uma vez chamada essa função o uC entrará em modo sleep WFI (WaitForInterrupt), ou seja, o CORE para a execução do código e retoma as atividades normais somente quando uma interrupção "acordar" o CORE.

Pensando um pouco

pio_handler_set(BUT_PIO,
                BUT_PIO_ID,
                BUT_IDX_MASK,
+               PIO_IT_EDGE,
                but_callback);

  ----   
      \____ Fall-Edge
                      ==> but_callback()    
      _____ High-Edge
  ___/

void but_callback (void) {
    if (pio_get(BUT_PIO, PIO_INPUT, BUT_IDX_MASK)) {
        // PINO == 1 --> Borda de subida
    } else {
        // PINO == 0 --> Borda de descida
    }       
}