Microprocessadores Tópicos Esp. em Eletrônica Industrial

1UTFPR – Campus Curitiba

Prof. Amauri Assef

UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ - UTFPR

DEPARTAMENTO ACADÊMICO DE ELETROTÉCNICA - DAELT

CURSO DE ENGENHARIA INDUSTRIAL ELÉTRICA

MESTRADO EM SISTEMAS DE ENERGIA - PPGSE

Microprocessadores

Tópicos Esp. em Eletrônica Industrial

Prof. Amauri Assef - [email protected]

paginapessoal.utfpr.edu.br/amauriassef

mailto:[email protected]


Prof. Amauri Assef

▪ Interrupção do Tiva C – Módulo NVIC

(Texas Instruments – www.ti.com)

– Interrupções são eventos importantes que devem ser reconhecidos e atendidos por um programa principal de forma prioritária


Prof. Amauri Assef

▪ Configuração do GPIOF para o Tiva C TM4C123G LauchPad

// Habilita clock geral do sistema para rodar em 50 MHz a partir do PLL com cristalSysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);

// Habilita e espera o acesso ao PORTFSysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOF)) {}

// Desbloqueia o pino PF0HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01;HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0;

// Configura o GPIOF para operação com LEDsGPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED);// Configura os dois pinos para leitura do estado das chaves SW1 e SW2GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, SW1|SW2);// Configura a força para 2 mA e resistor fraco de pull-upGPIOPadConfigSet(GPIO_PORTF_BASE, SW1|SW2, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);

#include <inc/tm4c123gh6pm.h>

//Desbloqueio do pino PF0 GPIO_PORTF_LOCK_R = 0x4C4F434B; GPIO_PORTF_CR_R = 0x1F;

#define RED_LED GPIO_PIN_1 //PF1#define BLUE_LED GPIO_PIN_2 //PF2#define GREEN_LED GPIO_PIN_3 //PF3#define SW1 GPIO_PIN_4 //PF4#define SW2 GPIO_PIN_0 //PF0


Prof. Amauri Assef

▪ Exemplo de teste de chaves

while(1){

chave_temp = GPIOPinRead(GPIO_PORTF_BASE,SW1|SW2);

// testa se SW1 e SW2 estao abertasif ( (chave_temp & SW1) && (chave_temp & SW2)){

GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, RED_LED);SysCtlDelay(atraso_100ms); }

// testa se SW1 fechada e SW2 abertaelse if (!(chave_temp & SW1) && (chave_temp & SW2)){

GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, GREEN_LED);SysCtlDelay(atraso_100ms); }

// testa se SW1 aberta e SW2 fechada else if ((chave_temp & SW1) && !(chave_temp & SW2)){

GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, BLUE_LED);SysCtlDelay(atraso_100ms); }

// SW1 e SW2 fechadas else {

GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, RED_LED, GREEN_LED, BLUE_LED);

SysCtlDelay(atraso_100ms); }}


Prof. Amauri Assef

▪ Visão global do módulo de Interrupções▪ As Interrupções possibilitam uma maneira para que os periféricos

interrompam o programa corrente e sejam atendidos rapidamente

▪ Podem ser desencadeados por dispositivos de E/S, temporizadores, ou periféricos que requerem maior atenção para a criação de aplicativos de alto desempenho

▪ Por exemplo, ao invés de verificar e esperar ativamente o fim de algum processamento (polling), o periférico poderia gerar uma interrupção quando o MCU está executado outro código

▪ Muitos sistemas embarcados exigem temporização precisa para gerar eventos em tempos específicos, embora seja possível utilizar um temporizador por software (maneira imprecisa de controlar o tempo)

▪ Os microcontroladores incluem timers implementados em hardware que operam com base no clock do dispositivo

▪ Ao utilizar contadores de hardware o MCU pode controlar o tempo com precisão e ser capaz de executar outras funções simultaneamente


Prof. Amauri Assef

▪ Termos relacionados com módulo de Interrupção▪ Asynchronous Event: Um evento que ocorre e não está sincronizado com o relógio interno

do microcontrolador. Pode acontecer em qualquer momento do ciclo de execução da instrução;

▪ Interrupt Enable: Um bit de um subsistema que habilita a geração um pedido de interrupção;

▪ Interrupt Flag Clearing: Em muitos microcontroladores, sub-sistemas internos, tais como o temporizador pode gerar pedidos de interrupção. Por exemplo, um pedido de interrupção pode ser gerado quando o bit sinalizador de overflow do temporizador (transbordamento) está setado. Quando isso ocorre, a rotina de serviço de interrupção deve resetar o flag que causou o pedido de interrupção a ser gerado;

▪ Interrupt Latency: É o tempo entre quando um pedido de interrupção é afirmado e a CPU começa a executar a rotina de serviço de interrupção;

▪ Interrupt Mask: Bit de controle para mascarar (impedir) que a CPU aceite pedidos de interrupção. A CPU tem instruções que podem mascarar ou desmascarar interrupções;

▪ Interrupt Prioritization: Quando várias interrupções ocorrem simultaneamente o sistema deve ter uma maneira de estabelecer qual deles é o mais importante e deve ser atendido primeiro;

▪ Interrupt Request (IRQ): Sinal com o qual algum dispositivo, tal como um bit de overflow do timer ou um sinal externo, solicita que seja atendido um pedido de interrupção;


Prof. Amauri Assef

▪ Interrupt Return: A rotina do serviço de interrupção necessita desta instrução especial para retornar ao programa interrompido;

▪ Interrupt Service Routine (ISR): Rotina de software escrita para executar as tarefas relativas ao pedido de interrupção para um dispositivo específico;

▪ Interrupt Vector: Quando ocorre uma interrupção a CPU busca o endereço de início da rotina do serviço de interrupção a partir de um local específico e dedicado na memória. O endereço inicial é chamado de vetor e o local da memória onde este é armazenado é chamado o vetor de localização ou endereço de vector;

▪ Pending Interrupt: Quando ocorre um pedido de interrupção e a respectiva rotina do serviço de interrupção não foi atendida, a interrupção é dita pendente;

▪ Real-Time System: Um sistema em tempo real é aquele que usa interrupções para executar tarefas de processamento quando estas são necessárias;

▪ Real-Time Operating System (RTOS): Muitos sistemas de tempo real usam um sistema operacional que permite que o desenvolvedor de software crie tarefas e agende sua execução sob o controle de interrupção.


Prof. Amauri Assef

▪ Fluxo da interrupção

...

Programa

Interrupção

Salva contexto (registradores)

Identifica a origem da interrupção

Obtém o endereço da rotina de tratamento

Restaura contexto (registradores)

Rotina de interrupção

Quando a CPU recebe uma interrupção, primeiro salva o estado atual do programa (registros). Então, verifica qual ISR irá executar usando uma tabela de vetores de interrupção. Em seguida, executa o ISR e antes de concluído, flags de interrupção serão apagados. Depois de concluído, o estado do programa é restaurado e continua a ser executado


Prof. Amauri Assef

▪ GPIO - Pinos Digitais do Tiva▪ Registros de Controle de

Interrupção


Prof. Amauri Assef

– GPIOIS (GPIO Interrupt Sense)

– GPIOIBE (GPIO Interrupt Both Edges)

Valor Descrição

0 Configura o pino correspondente para detectar mudança de borda

1 Configura o pino correspondente para detectar mudança de nível

Valor Descrição

0 A geração de interrupção é controlada pelo GPIOIEV (GPIO Interrupt Event)

1 Ambas as bordas no pino correspondente disparam uma interrupção


Prof. Amauri Assef

– GPIOIEV (GPIO Interrupt Event)

– GPIOIM (GPIO Interrupt Mask)

– GPIORIS (GPIO Raw Interrupt Status) (Read only - RO)

Valor Descrição

0 Uma borda de descida ou nível 0 no pino correspondente disparou uma interrupção

1 Uma borda de subida ou nível 1 no pino correspondente disparou uma interrupção

Valor Descrição

0 A interrupção do pino correspondente é mascarada (desabilitada)

1 A interrupção do pino correspondente é enviada ao controlador de interrupção

Valor Descrição

0 Não ocorreu uma condição de interrupção no pino correspondente

1 Ocorreu uma condição de interrupção no pino correspondente


Prof. Amauri Assef

– GPIOMIS (GPIO Masked Interrupt Status)

– GPIOICR (GPIO Interrupt Clear) (W1C)

Valor Descrição

0 Uma condição de int. no pino correspondente não ocorreu ou está mascarada

1 Uma condição de int. no pino correspondente disparou uma int. para o controlador de interrupções

Valor Descrição

0 A interrupção correspondente não é afetada

1 A interrupção correspondente é limpa


Prof. Amauri Assef

▪ ARM Nested Vector Interrupt Controller (NVIC)▪ É o controlador de interrupções das séries ARM Cortex-M

▪ Responsável por tratar a maior parte das interrupções no MCU

▪ O NVIC no Cortex-M4 apresenta:

1) Suporte de até 240 interrupções com 256 níveis de prioridade para cada interrupção

▪ Baixa latência nas exceções e encaminhamento de interrupções▪ Sempre 12 cycles, ou apenas 6 cycles com tail-chaining

▪ Detecção de nível e borda de sinais de interrupção

▪ Repriorização dinâmica de interrupções

▪ Uma interrupção externa não mascarável NMI (Non-maskable interrupt)

A implementação do NVIC no Tiva TM4C123G suporta 78 interrupções com 8 (0 - 7) níveis de prioridade, sendo 0 o nível mais alto de prioridade


Prof. Amauri Assef

▪ Exceções do Core ARM (System Handler Vectors)▪ Reset: invocada no power on

▪ NMI: interrupção não mascarável usando o sinal NMI ou por software usando o registro Interrupt Control and State (INTCTRL)

▪ Hard Fault: exceção que ocorre devido a um erro durante o processo de exceção, ou porque um exceção não pode ser gerenciada por outro mecanismo de exceção

▪ Memory Management Fault: ocorre devido a uma violação de acesso à memória

▪ Bus Fault: ocorre devido a uma falha relacionada à memória durante uma transação de instrução ou memória de dado

▪ Usage Fault: ocorre devido a uma falta relacionada à execução de instrução, tais como: instrução indefinida, acesso ilegal, estado inválido de instrução, erro de retorno de exceção (divisão por zero)


Prof. Amauri Assef

▪ SVCall: uma chamada de supervisor (SVC - Supervisor Call) é uma exceção sincronizada pela instrução SVC em um ambiente de sistema operacional (SO) para acessar funções do Kernel e device drivers

▪ Debug Monitor: esta exceção é causada pelo monitor de depuração e só é ativa quando habilitada

▪ PendSV: indica uma requisição de interrupção pendível usada em um ambiente de SO para troca de contexto e sincronizada pelo registro Interrupt Control and State (INTCTRL)

▪ SysTick: exceção que o sistema de temporização decrescente gera quando chega no valor 0 e é habilitado como interrupção.

▪ Interrupt (IRQ): é uma IRQ sinalizada por um periférico ou gerada por requisição de software a alimentado através do NVIC


Prof. Amauri Assef

CoreARM

Tiva


Prof. Amauri Assef

▪ ISR e Interrupt Vector Table▪ Para utilizar as interrupções é necessário encontrar o número

do vetor correspondente

▪ O número de vetor é utilizado para encontrar a localização na tabela do vetor para incluir o nome da ISR (página 104 do manual do TM4C123GH6PM)

IRQ

Core ARM

Tiva


Prof. Amauri Assef


Prof. Amauri Assef

▪ Configuração do NVIC com o TivaWare

//*******************************************************************// // Arquivo “driverlib/interrupt.h”// Prototypes for the APIs.//*******************************************************************bool IntMasterEnable(void);bool IntMasterDisable(void);void IntRegister(uint32_t ui32Interrupt, void (*pfnHandler)(void));void IntUnregister(uint32_t ui32Interrupt);void IntPriorityGroupingSet(uint32_t ui32Bits);uint32_t IntPriorityGroupingGet(void);void IntPrioritySet(uint32_t ui32Interrupt, uint8_t ui8Priority);int32_t IntPriorityGet(uint32_t ui32Interrupt);void IntEnable(uint32_t ui32Interrupt);void IntDisable(uint32_t ui32Interrupt);uint32_t IntIsEnabled(uint32_t ui32Interrupt);void IntPendSet(uint32_t ui32Interrupt);void IntPendClear(uint32_t ui32Interrupt);void IntPriorityMaskSet(uint32_t ui32PriorityMask);uint32_t IntPriorityMaskGet(void);void IntTrigger(uint32_t ui32Interrupt);


Prof. Amauri Assef

▪ Configuração da interrupção do GPIO com o TivaWare

//*******************************************************************// // Arquivo "driverlib/gpio.h“// Prototypes for the APIs.//*******************************************************************

void GPIOIntEnable(uint32_t ui32Port, uint32_t ui32IntFlags);void GPIOIntDisable(uint32_t ui32Port, uint32_t ui32IntFlags);uint32_t GPIOIntStatus(uint32_t ui32Port, bool bMasked);void GPIOIntClear(uint32_t ui32Port, uint32_t ui32IntFlags);


Prof. Amauri Assef

▪ Configuração do NVIC com o TivaWare

1) IntMasterEnable(void)Função que permite ao CPU responder a todas as chamadas de interrupção utilizadas

2) IntEnable(uint32_t ui32Interrupt) Função para habilitar a interrupção do periférico indicado

3) GPIOIntEnable(uint32_t ui32Port, uint32_t ui32IntFlags)Função onde um pino da GPIO do microcontrolador é configurado como interrupção e o parâmetro ui32IntFlags representa o pino a ser configurado:

GPIO_INT_PIN_0, GPIO_INT_PIN_1, ... ou GPIO_INT_PIN_7


Prof. Amauri Assef

4) GPIOIntTypeSet(uint32_t ui32Port, uint8_t ui8Pins, uint32_t ui32IntType)

Função onde um pino da GPIO do CPU, que é configurado como interrupção, tem o seu modo de habilitação configurado, e o parâmetro ui32IntType, que representa o modo de habilitação da interrupção, pode ser configurado como:

GPIO_FALLING_EDGE (borda de descida), GPIO_RISING_EDGE (borda de subida), GPIO_BOTH_EDGE (qualquer borda), GPIO_LOW_LEVEL (nível lógico baixo) e GPIO_HIGH_LEVEL (nível lógico alto).

5) GPIOIntEnable(uint32_t ui32Port, uint32_t ui32IntFlags)Função onde um pino da GPIO do microcontrolador é configurado como interrupção e o parâmetro ui32IntFlags representa o pino a ser configurado:

GPIO_INT_PIN_0, GPIO_INT_PIN_1, ... ou GPIO_INT_PIN_7.


Prof. Amauri Assef

▪ Exemplo– Exemplo de configuração de uma Interrupção no Port F e Pino 4

(SW1) por borda de descida:

1) Incluir as funções a seguir para configurar a interrupção do PF4

// Configura o PF4 com interrupção na borda de descida GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_FALLING_EDGE);

// Habilita a interrupção do pino PF4GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4);

// Habilita a interrupção do GPIOFIntEnable(INT_GPIOF);


Prof. Amauri Assef

2) Para que uma função de interrupção ISR seja executada, é necessário declará-la no arquivo startup_ccs.c do projetoque possui a tabela de vetor de gerenciamento das funções. Na linha da IRQ para o GPIOF, alterar o nome da função a ser chamada GPIOD_Int_Handler (nome arbitrário)


Prof. Amauri Assef

Alterar o nome padrão

IntDefaultHandlerpara o novo nome da

função ISRGPIOD_Int_Handler


Prof. Amauri Assef

3) Declare a função a ser chamada através da interrupção desejada como função externa ao código arbitrário

4) No arquivo principal, escrever a função de interrupção associada ao pino e limpar o flag de interrupção que o gerou.

//***********************************************************// Declarações externas para encaminhamento de interrupções //***********************************************************extern void GPIOD_Int_Handler(void);

//***********************************************************************// Interrupção por borda de descida no GPIOF Pino 4 (SW1)//***********************************************************************void GPIOD_Int_Handler(void){

GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, RED_LED);SysCtlDelay(atraso_100ms);GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, 0x00);GPIOIntClear(GPIO_PORTF_BASE, SW1);

}


Prof. Amauri Assef

▪ Configuração dos registros do NVIC sem oTivaWare

– Pesquisar a função dos registradores:

• Interrupt 0-31 Set Enable (ENn)

• Interrupt 0-31 Clear Enable (DISn)

• Interrupt 0-31 Set Pending (PENDn)

• Interrupt 0-31 Clear Pending (UNPENDn)

• Interrupt 0-31 Active Bit (ACTIVEn)

• Interrupt 0-3 Priority (PRIm)

onde n=0...4 e m = 0...34

– Exemplo: Qual é o registro EN e qual o bit deve ser setado para habilitar a interrupção do GPIOF (IRQ 30)?

Resp: IRQ/32 => 30/32 = 0 (EN0) e resto 30 (bit 30)

EN0 |= 1<<30;


Prof. Amauri Assef


Prof. Amauri Assef

▪ Referências

▪ Main page: www.ti.com/launchpad

▪ Tiva C Series TM4C123G LaunchPad:

http://www.ti.com/tool/ek-tm4c123gxl

▪ TM4C123GH6PM folder:

http://www.ti.com/product/tm4c123gh6pm

▪ LaunchPad Wiki:

www.ti.com/launchpadwiki

▪ Valvano, Jonathan. Embedded Systems (Introduction to Arm\xae Cortex\u2122-M Microcontrollers) (p. 260). Jonathan Valvano. E

▪ Microcontroladores ARM7 (Philips - Família LPC213x) : O poder dos 32 Bits - teoria e prática / Daniel Rodrigues de Sousa

▪ Microcontroladores ARMTM CortexTM-M3 (família LPC175x/6x da NXP) : Programação em linguagem C / Alberto Noboru Miyadaira

▪ Introdução aos microcontroladores ARM Cortex-M4 Tiva C Series da Texas Instruments, Stéfano Andrade de Souza, Março de 2015

http://www.ti.com/launchpad

http://www.ti.com/tool/ek-tm4c123gxl

http://www.ti.com/product/tm4c123gh6pm

http://www.ti.com/launchpadwiki

Documents

Microprocessadores Tópicos Esp. em Eletrônica Industrial