Interrupts and the timer

ORGANIZAÇÃO DE COMPUTADORES

Interrupts and The Timer


Este capítulo irá apresentar

o uso de interrupções no

ARM ® Cortex-M4 ® e o

módulo timer. O laboratório

irá utilizar o timer para

gerar interrupções.

Introdução


A API Timer fornece um conjunto de

funções de utilização do módulo timer.

As funções são fornecidas para:

• Configurar e controlar o timer;

• Modificar os valores do

temporizador / contador;

• Gerenciar a manipulação de

interrupções.

Introdução


• Lida com exceções e interrupções;

• Tem 8 níveis de prioridade programáveis (agrupamento

prioridade)

• 7 exceções e 65 tipos de Interrupções;

• Salva e restaura o estado automático;

• Faz a leitura automática da entrada da tabela de vetor;

• Interrupções Pre-emptive/Nested

• Tail-Chaining;

• Determinista: sempre 12 ciclos ou 6 com tail-chaining.

Cortex M4 - NVIC


Interrupt Latency – Tail Chaining


Interrupt Latency – Pre - Emption


Interrupt Latency - Late Arrival


Cortex-M4 Manipulação de Interrupção e

Vetores

Manipulação de interrupção é automático. Não há sobrecarga de instruções.

• Entrada

• Insere automaticamente na pilha os registros R0-R3, R12, LR,

PSR, e PC;

• Em paralelo, ISR são pré-buscadas no “instruction bus”. ISR

pronto para começar a execução tão logo a pilha esteja completa;

• Saída

• Estado do processador é automaticamente restaurado a partir da

pilha;

• Em paralelo, instruções de interrupções são pré-buscadas para

serem executadas após a conclusão do POP na pilha;


Tipos de Exceções do Cortex-M4 ®

Tabela 1: Tabela com os tipos de exceção do cortex-M4.


Cortex-M4 ® Vector Table

• Depois de reset, a tabela de vetores

está localizada na endereço 0;

• Cada entrada contém o endereço do

função a ser executada;

• O valor no endereço 0x00 é usado

como endereço inicial da Main Stack

Pointer (MSP);

• A tabela de vetores pode ser

realocada para escrita com a instrução

VTABLE register;

• Abra o startup_ccs.c para ver a tabela

de codificação dos vetores.


Módulo Timer Geral

• Seis timers de uso geral de 16/32-bit e seis de 32/64-bit;

• Doze pinos para capturar, comparar e PWN de 16/32-bit e doze de

32/64-bit;

• Possui os módulos de Timer:

• One-shot

• Contínuo

• Contagem de borda de entrada ou de captura de tempo com 16

bits

• Geração de PWM

• Relógio de tempo real

• Contagem Up ou Down

• PWM simples

• Suporte para sincronização de timer, daisy-chains, e parando durante

a depuração

• Pode desencadear amostras ADC ou transferências DMA


O módulo timer fornece dois

temporizadores/contadores:

• De Meia Largura: • Podem ser configurados para operar

independentemente como timers ou

contadores de eventos;

• De Largura Total: • Pode funcionar como um cronômetro

ou no modo Tempo real Clock (RTC).

Módulo Timer Geral


Configuração para esta API

Meia Largura Largura Total

16 bits 32 bits

32 bits 64 bits

TimerA TimerB TimerA


Um timer pode ser configurado para funcionar como um

Timer One-shot:

• Se configurado no modo one-shot, o cronômetro para

de contar quando ele chega a zero quando a contagem

regressiva ou o valor da carga quando a contagem para

cima.

Timer One-shot


Ou pode ser configurado para funcionar como um Timer

Contínuo:

• Se configurado em contínuo modo, o temporizador

conta a zero (contagem regressiva), ou o valor da

carga, então recarrega e continua a contagem.

Timer Contínuo


Objetivo

Neste laboratório vamos configurar o timer para gerar

interrupções e, em seguida, escrever o código que responde

a interrupção, piscando o LED. Também vamos experimentar

gerar uma exceção, por tentar configurar um periférico antes

de ter sido ativado.


Análise do Código


Procedimento

1 - Importe o Projeto Lab4.


Arquivos de Cabeçalho

2. Incluir os arquivos de cabeçalho necessários para acessar as APIs

StellarisWare:

# include "inc / hw_ints.h"

# include "inc / hw_memmap.h"

# include "inc / hw_types.h"

# include "driverlib / sysctl.h"

# include "driverlib / interrupt.h"

# include "driverlib / gpio.h"

# include "driverlib / timer.h“


Arquivos de Cabeçalho

• hw_ints.h: Macros que definem a atribuição de interrupção em

dispositivos Stellaris (NVIC);

• hw_memmap.h: Macros que definem o mapa de memória do dispositivo

Stellaris. Isto inclui definir as regiões periféricas da base de endereços,

por exemplo, GPIO_PORTF_BASE;

• hw_types.h: Define os tipos comuns e as macros, como tBoolean e

HWREG;

• sysctl.h: Definição e macros para o Sistema de Controle de API do

driverLib. Isto inclui as funções da API, como SysCtlClockSet e

SysCtlClockGet;

• interrupt.h: Definição e macros para NVIC Controller (Interrupção) API do

DriverLib. Isso inclui as funções da API, como IntEnable e IntPrioritySet.

• gpio.h: Definição e macros para GPIO API do driverLib. Isso inclui as

funções da API tais como GPIOPinTypePWM e GPIOPinWrite;

• timer.h: Definição e macros para API do timer de driverLib. Isso inclui as

funções da API tais como TimerConfigure e TimerLoadSet.


Função main ()

3. Calcular o “timer delays” utilizando a variável Period.

int main (void)

{

unsigned long ulPeriod;

}


Configuração do Relógio

4. Configure o relógio do sistema para ser executado em 40MHz com a seguinte

chamada:

SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16M

HZ | SYSCTL_OSC_MAIN);

GPIO Configuração

5. Ative o periférico GPIO e defina os pinos conectados para os LEDs como

saídas.

SysCtlPeripheralEnable (SYSCTL_PERIPH_GPIOF);

GPIOPinTypeGPIOOutput (GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2

|GPIO_PIN_3);


Configuração do Timer

6. Antes de chamar qualquer função específica do periférico driverLib é

necessário ativar o clock. Se isso não for feito irá resultar em uma ISR

Fault (falha de endereço). Adicione as seguintes linhas ao código:

• A segunda declaração configura o timer 0 como um timer de 32 bits.

SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);

TimerConfigure (TIMER0_BASE, TIMER_CFG_32_BIT_PER);


Cálculo do Delay

7. Para alternar um GPIO em 10Hz e um ciclo de trabalho de 50%, é

preciso gerar uma interrupção em ½ do período desejado. Em primeiro

lugar, calcular o número de ciclos de relógio necessários para um período

de 10Hz, chamando SysCtlClockGet () e dividindo-o por sua frequência

desejada, em seguida divida por dois, já que queremos uma contagem

que é ½ para a interrupção. Adicione as seguintes linhas ao código:

ulPeriod = (SysCtlClockGet () / 10) / 2;

TimerLoadSet (TIMER0_BASE, TIMER_A, ulPeriod -1);


Ativar a Interrupção

8. Ative a interrupção não só no módulo Timer, mas também

no NVIC (The Nested Vector Interrupt Controller, controlador

de interrupção do Cortex M4).

IntEnable (INT_TIMER0A);

TimerIntEnable (TIMER0_BASE, TIMER_TIMA_TIMEOUT);

IntMasterEnable ();


Ativar Timer

9. Ative o timer. Isto irá iniciar o timer e as interrupções começará acionando os

tempos de espera. Digite a seguinte linha de código após as anteriores:

TimerEnable (TIMER0_BASE, TIMER_A);

Loop Principal

10. O loop principal do código é simplesmente um tempo vazio (1) uma vez que a

alternância do GPIO vai acontecer na rotina de interrupção. Adicione as seguintes

linhas de código após as anteriores:

while (1)

{

}


Timer de Interrupção Handler

11. Adicione um manipulador de interrupção no timer. Antes é necessário limpar a fonte de

manipulação. Adicione as seguintes linhas de código após o encerramento definitivo da

função main():

main (...)

Timer0IntHandler vazio (void)

{

/ / Limpar a interrupção do timer

TimerIntClear (TIMER0_BASE, TIMER_TIMA_TIMEOUT);

/ / Ler o estado atual do pino GPIO e

/ / Escrever de volta o estado oposto

if (GPIOPinRead (GPIO_PORTF_BASE, GPIO_PIN_2))

{

GPIOPinWrite (GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3, 0);

}

outro

{

GPIOPinWrite (GPIO_PORTF_BASE, GPIO_PIN_2, 4);

}

}


12. Salve o código.


Código Startup

13. Abra o arquivo startup_ccs.c. Este arquivo contém a tabela de vetores

discutidos durante a apresentação. Observe a linha comentada com “Timer 0

subtimer A”.

• Quando a interrupção ocorre o NVIC irá procurar o endereço da ISR neste local.

É neste local que o próximo código será executado.

• Você precisa encontrar cuidadosamente a posição apropriada do vetor e

substituir IntDefaultHandler com o nome de seu manipulador de interrupção


Você também vai precisar para declarar esta função no topo deste

arquivo como externo. Isto é necessário para o compilador resolver o

símbolo. Encontre a linha que contém:

extern _c_int00 vazio (void);

e adicione:

extern Timer0IntHandler vazio (void);

logo abaixo dela, como mostrado abaixo:

Clique no botão salvar e execute o código.


Exceções

15. Encontre a linha de código que ativa o periférico do GPIO

e comente, como mostrado na figura abaixo::

Agora o código vai acessar o periférico sem ativar o relógio.

Interrupts and the timer

Education

Transcript of Interrupts and the timer