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

Mais conteúdo relacionado

Mais procurados

Semelhante a Interrupts and the timer

Mais de Mayara Mônica

Último

Interrupts and the timer